Saravanan666/pypi-org huggingface dataset:
Package: velour
velourPython package for topological inference from point clouds with persistent homology.
Based on thegudhilibrary.MethodsThe packagevelourgathers implementations of our methods for topological inference. It allows the use of:DTM-filtrations:a family of filtrations for persistent homology, that can be applied even when the input point cloud contains anomalous points. Notebook demohereand mathematical explanationhere.Lifted sets and lifted filtrations:allows to estimate the homology of an abstract manifold from a finite sample of an immersion of it. Notebook demohereand mathematical explanationhere.Persistent Stiefel-Whitney classes:allows to estimate the first Stiefel-Whitney class of a vector bundle from a finite sample of it. Notebook demohereand mathematical explanationhere.StructureThe package is divided into three modules:persistentgathers tools for handling filtrations of simplicial complexes (simplex trees).geometrycontains the implementation of various geometric quantities used bypersistent.datasetsconsists in various utilities for sampling datasets (from $\mathbb{R}^2$ to $\mathbb{R}^{12}$) and plotting them.SetupIt can be installed from PyPI viapip install velourCurrent release: 2020.11.18DocumentationNot yet! But feel free to contact me anytime.Raphaël Tinarrage -https://raphaeltinarrage.github.io/
Package: velovae
VeloVAE - Variational Mixtures of ODEs for Inferring Cellular Gene Expression DynamicsThe rapid growth of scRNA-seq data has spurred many advances in single-cell analysis. A key problem is to understand how gene expression changes during cell development. Recently, RNA velocity provided a new way to study gene expression from a dynamical system point of view. Because cells are destroyed during measurement, any scRNA-seq data are just one or very few static snapshots of mRNA count matrices. This makes it hard to learn the gene expression kinetics, as the time information is lost.VeloVAE is a deep generative model for learning gene expression dynamics from scRNA-seq data. The purpose of our method is to infer latent cell time and velocity simultaneously. This is achieved by using variational Bayesian inference with neural networks. VeloVAE is based on the biochemical process of converting nascent mRNA molecules to mature ones via splicing. The generative model is constrained by a set of ordinary differential equations. VeloVAE is capable of handling more complex gene expression kinetics compared with previous methods.The package depends on several main-stream packages in computational biology and machine learning, including [scanpy](https://scanpy.readthedocs.io/en/stable/), [PyTorch](https://pytorch.org/), [scikit-learn](https://scikit-learn.org/stable/). We suggest using a GPU to accelerate the training process.A sample jupyter notebook is available [here](notebooks/velovae_example.ipynb). Notice that the dataset in the example is from [scVelo](https://scvelo.readthedocs.io/), so you would need to install scVelo.
Package: velovi
veloviVariational inference for RNA velocity. This is an experimental repo for the veloVI model. Installation instructions and tutorials are in the docs. Over the next few months veloVI will move intoscvelo.Getting startedPlease refer to thedocumentation.InstallationYou need to have Python 3.8 or newer installed on your system. If you don't have
Python installed, we recommend installingMiniconda.There are several alternative options to install velovi:Install the latest release on PyPI:pipinstallveloviInstall the latest development version:pipinstallgit+https://github.com/yoseflab/velovi.git@mainRelease notesSee thechangelog.ContactFor questions and help requests, you can reach out in thescverse discourse.
If you found a bug, please use theissue tracker.Citation@article{gayoso2022deep,
  title={Deep generative modeling of transcriptional dynamics for RNA velocity analysis in single cells},
  author={Gayoso, Adam and Weiler, Philipp and Lotfollahi, Mohammad and Klein, Dominik and Hong, Justin and Streets, Aaron M and Theis, Fabian J and Yosef, Nir},
  journal={bioRxiv},
  pages={2022--08},
  year={2022},
  publisher={Cold Spring Harbor Laboratory}
}
Package: velruse
Velruse is a set of authentication routines that provide a unified way
to have a website user authenticate to a variety of different identity
providers and/or a variety of different authentication schemes.It is similar in some ways to RPXnow with the exception of being
open-source, locally installable, and easily pluggable for custom
identity providers and authentication schemes.You can run Velruse as a stand-alone service for use with your websites
regardless of the language they’re written in. While Velruse itself is
written in Python, since it can interact with your website purely via
HTTP POST’s.Velruse can:Normalize identity information from varying provider sources
(OpenID, Google, Facebook, etc.) to Portable Contacts.Simplify complex authentication protocols by providing a simple
consistent API.Provide extension points for other authentication systems, write your
own auth provider to handle CAS, LDAP, and use it with ease.Integrate with most web applications regardless of the language used
to write the website.Warning: It’s early yet for Velruse, so only those interested in
developing Velruse should be taking a look into this now.OverviewVelruse aims to simplify authenticating a user. It provides auth
providers that handle authenticating to a variety of identity providers
with multiple authentication schemes (LDAP, SAML, etc.).Eventually, Velruse will include widgets similar to RPXNow that allow
one to customize a login/registration widget so that a website user can
select a preferred identity provider to use to sign-in.In the mean-time, effort is focused on increasing the available auth
providers for the commonly used authentication schemes and identity
providers (Facebook, Google, OpenID, etc).Unlike other authentication libraries for use with web applications, a
website using Velruse for authentication does not have to be written in
any particular language.APIVelruse implements an API similar to RPXNow to standardize the way a
web application handles user authentication.Velruse Authentication flowWebsite sends a POST to the auth provider‘s URL with an endpoint that
the user should be redirected back to when authentication is complete
and includes any additional parameters that the auth provider requires.When the auth provider finishes the authentication, the user is
redirected back to the endpoint specified with a POST, which includes
a unique token.Website then makes a query to the UserStore using the token that was
provided. The user’s identity information will be returned, or an
error if the authentication was unsuccessful.If the website is unable to directly access the UserStore then Step 3 can
be replaced by issuing a HTTP POST in the background to the auth provider
requesting the user’s information with the token.
Package: velruse-naver
velruse-navervelruse provider for NAVER OAuth2Quick introductionWIPDevelopment environmentTo setup development environment:virtualenv -p python2.7 .
bin/pip install -U setuptools pip pip-tools
makeChanges0.1.1 (2018-10-27)Return full token response as credentials.0.1.0 (2018-10-27)Initial release.
Package: velvet
Velvet“That’s beautiful, what is that velvet?”NoteThis project is still in the planning phase. The foundation of
the project is still being configured. Once that is complete, actual
signal processing functionality will be added.Velvet provides signal processing and communications algorithms in
Python. Typical usage often looks like this:#!/usr/bin/env python

import velvet as vtInstallRequirements/DependenciesPython 2.7 or aboveNumPy 1.7 or aboveSciPy 0.13 or aboveMatplotlib 1.3.1 or aboveThe package is available onPyPI:$ pip install velvetTo get the latest development work, clone from github and install as follows:$ git clone https://github.com/sgwoodjr/velvet.git
$ cd velvet
$ python setup.py installUnit testing:$ nosetests -vRun unit tests with a coverage report:$ nosetests -v --with-coverage --cover-html --cover-package=velvetContributeWrite a bug report or send a pull request.Here is what others have donecontributorsLicenseCopyright (c) 2015 SGWThe source code is available under theNew BSD License.SeeLICENSEfor further details.
Package: vema
VemaVema is a solution for developing static web pages, from Python + Flask, which has the basic tools and already configured to focus on the design of the pages.FeaturesRender pages made in HTML or MD.Build static pages, so you only have to upload them to your hosting.Seo optimization.Routes generator.Optimization of the resources of your pages.Free and open-source softwareWhat feature do you miss or would you like to have?InstallClone the repository and work with it. Or you can also install it as a package and develop it on your own.https://pypi.org/project/vema/To install it.pipinstallvemaDocumentationHere you can find theproject documentationFirst stepsYou can see the first steps here.First steps
Package: vEMden
# Volume Electron Microscropy DENoising (vEMden)This package performs automatic (unsupervised) denoising of volume electron microscopy images. Two deep learning
architectures are available:
<ul>
<li>Noise Reconstruction & Remove Network (NRRN)</li>
<li>DenoiseNet</li>
</ul>For installation, more information/details and full examples with code and data, visit:https://www.thibault.biz/Research/VolumeEM/vEMden/vEMden.html
Package: vements
Vements Client Library for PythonThe Vements Client Library for Python is a Python library for accessing the Vements API.  It also includes a command line tool that can be used to interact with the API in scripts or in a terminal.DocumentationSee theGetting Started Guidefor more information on how to use this library.InstallationTo install the Vements Client Library for Python, use the following command:$pipinstallvementsBuildThere is no separate build step for the Python CLI tool, but you can simplify access with an alias:$aliasvements='python -m vements'UsageThe following example shows how to use the Vements Client Library for Python to create a new Vements client, and then use that client to create a new Vements scoreboard.importvementsclient=vements.Client()scoreboard=client.scoreboard.create(display="My Scoreboard",rank_dir="desc",public=False)Command Line ToolThe Python CLI tool supports all of the same operations as the CLI tool in other languages:achievement CRUD, list, leaderboard, record progressparticipant CRUD, list, progress, scoresscoreboard CRUD, list, scoreboard, record scoreThe above commands all support the following options:--api-keyto specify the API key--verboseto show verbose outputIn addition to resource commands, these common commands are also supported:api-versionto show the API versionclient-versionto show the client library versionThe library and CLI both support the following environment variables:API_KEYto specify the API keySERVER_TAGSto specify the tags used to select the server URL
Package: veml6075
VEML6075 UVA and UVB light sensorInstallingStable library from PyPi:Just runsudo pip install veml6075Latest/development library from GitHub:git clonehttps://github.com/pimoroni/veml6075-pythoncdveml6075-pythonsudo ./install.sh0.0.2Port to i2cdevice>=0.0.6 set/get API0.0.1Initial Release
Package: vemomoto
Vector Movement Modelling ToolsThis meta-package contains several packages needed to model the traffic of
invasive species and disease vectors in large-scale systems.The package is licensed under theLGPL-v3. For documentation please refer tothe project's documentation page on github. Please report any bugs onthe project's bug tracker. You are welcome to adjust the provided
files to your needs and to improve the code. It is encouraged that you share any
improvements onthe github pageif possible.
Package: vemomoto-core
Vector Movement Modelling Tools - Necessary ToolsThis meta-package contains several packages originally developed to facilitate the
implementation of a model for vector movement in large-scale systems. The
provided functionality may be useful in other instances as well, though.The package is licensed under theLGPL-v3. For documentation please refer tothe project's documentation page on github. Please report any bugs onthe project's bug tracker. You are welcome to adjust the provided
files to your needs and to improve the code. It is encouraged that you share any
improvements onthe github pageif possible.
Package: vemomoto-core-concurrent
Vector Movement Modelling Tools - Necessary Tools for Concurrent ComputingThis package contains modules simplifying multiprocessing and the work with
shared memmory in the classical C-Python. The modules have been originally
developed to facilitate the implementation of a vector movement model but
may have broader use cases.The package is licensed under theLGPL-v3. For documentation please refer tothe project's documentation page on github. Please report any bugs onthe project's bug tracker. You are welcome to adjust the provided
files to your needs and to improve the code. It is encouraged that you share any
improvements onthe github pageif possible.
Package: vemomoto-core-npcollections
Flexible NumPy-Based ContainersThis package contains modules implementing numpy-based containers that are
flexible in size and allow efficient vectorized data manipulation.The package is licensed under theLGPL-v3. For documentation please refer tothe project's documentation page on github. Please report any bugs onthe project's bug tracker. You are welcome to adjust the provided
files to your needs and to improve the code. It is encouraged that you share any
improvements onthe github pageif possible.
Package: vemomoto-core-tools
Vector Movement Modelling Tools - Helpful ToolsThis package contains miscellaneous helpful tools that were originally developed
to facilitate the implementation of a vector movement model but may have broader
use cases. The package contains files toease code documentation by enabling enheritance of docstringsimplementing indented printing for well-formatted status messagesextending iteration toolssaving and lading objectsprofiling codeprinting and saving status messages at the same time.The package is licensed under theLGPL-v3. For documentation please refer tothe project's documentation page on github. Please report any bugs onthe project's bug tracker. You are welcome to adjust the provided
files to your needs and to improve the code. It is encouraged that you share any
improvements onthe github pageif possible.
Package: vEMreg
# Volume Electron Microscropy DENoising (vEMden)This package performs registration (alignment) of volume electron microscopy images.
It’s a stochastic version of TurboReg/StackReg.
For installation, more information/details and full examples with code and data, visit:https://www.thibault.biz/Research/VolumeEM/vEMreg/vEMreg.html
Package: vemseg
Volume Electron Microscopy SEGmentationA package for the segmentation of volume electron microscopy images using XGBoost.InstallationYou can installvemsegviapip:pip install vemsegUsageShown below are some example uses of the VEMClassifier and some other functionality provided
by thevemsegpackage.importvemsegasvemfromskimage.ioimportimreadX=imread("train_image.tiff")y=imread("train_labels.tiff")mask=imread('train_mask.tiff')clf=vem.VEMClassifier(max_depth=4,n_estimators=400,learning_rate=0.01,verbosity=0)features=clf.set_features(["sobel_of_gaussian_blur","laplace_box_of_gaussian_blur","original"],range(1,4))clf.fit(X,y,mask=mask)We then useclf.predictto get the prediction from the trained
classifier. We can use theshowflag to generate an image of the
predictions.prediction=clf.predict(X,show=True,mask=mask)We can then plot the features importance like so, with fig size indicating the size of the plot.clf.feature_importance(fig_size=(20,10))Deciding what hyperparameters to use can often be very difficult, so we can use an adaptation
of sklearns GridSearchCV to determine which hyperparameters work best.parameters={'max_depth':range(2,5,1),'n_estimators':range(200,500,100)}grid_search=clf.GridSearchCV(X,y,param_grid=parameters,n_jobs=10,cv=10,verbose=True,update_params=True,mask=mask,)print(grid_search.best_estimator_)Will outputFitting 10 folds for each of 9 candidates, totalling 90 fits
VEMClassifier(base_score=0.5, booster='gbtree', callbacks=None,
              colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,
              early_stopping_rounds=None, enable_categorical=False,
              eval_metric=None, feature_types=None, gamma=0, gpu_id=-1,
              grow_policy='depthwise', importance_type=None,
              interaction_constraints='', learning_rate=0.300000012,
              max_bin=256, max_cat_threshold=64, max_cat_to_onehot=4,
              max_delta_step=0, max_depth=3, max_leaves=0, min_child_weight=1,
              missing=nan, monotone_constraints='()', n_estimators=200,
              n_jobs=0, num_parallel_tree=1, objective='binary:logistic',
              predictor='auto', ...)After completing training one can save the model to be reused like so.clf.save_model('model.json')And to reload the model from the JSON file one simply has to initialise a new
VEMClassifier and then load the model.importvemsegpre_trained_model=vem.VEMClassifier()pre_trained_model.load_model('model.json')LicenseDistributed under the terms of theBSD-3license,
"napari-vemseg" is free and open source softwareContribute to VEMsegContributions are very welcome.Similar SoftwareFull credit to the following software for inspiration and use within this tool.apocXGBoostscikit-learnReference
Package: ven
Easy way to use virtualenv.FeaturesStore virtualenv in .venv directory, along with your .git and requirements.txtRun command inside virtualenv without activating it.Install$ pip install --user venQuickstartInitialize an empty virtualenv usingven init:$ ven init
New python executable in .venv/bin/python
Installing setuptools, pip...done.

$ ls -A
.venvRun command inside virtualenv usingven run:$ ven run which python
~/project/.venv/bin/pythonActivate virtualenv in a sub-shell:$ ven run
$ which python
~/project/.venv/bin/python
$ (Deactivate with Ctrl-D)UsageUsage: ven [OPTIONS] COMMAND [ARGS]...

  Easy way to use virtualenv

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  help  Show help information
  init  Create a new virtualenv
  run   Run command in virtualenv (default: shell)CaveatsUse ‘–’ to separateven runoptions and command that contains ‘-‘:$ ven run -- python --version
Python 2.7.5oh-my-zshoverwrites $PATH, add the following to your .zshrc:if [ -n "$VIRTUAL_ENV" ]; then
    export PATH="$VIRTUAL_ENV/bin:$PATH"
fiRecommanded aliases:alias vrun='ven run --'
alias vpy='ven run -- python'
alias vpip='ven run -- pip'
Package: vencopy
Welcome to VencoPy!Authors: Niklas Wulff, Fabia MiorelliContact:niklas.wulff@dlr.deContentsDescriptionInstallationCodestyleDocumentationUseful LinksWant to contribute?DescriptionA data processing tool offering hourly demand and flexibility profiles for future electric vehicle fleets in an aggregated manner.InstallationDepending on if you want to use VencoPy or if you want to contribute, there are
two different installation procedures described in VencoPy's documentation:I want to apply the toolI want to contribute to the codebase, the documentation or the tutorialsIn order to start using VencoPy, check out ourtutorials. For this you won't need any additional data.To run VencoPy in full mode, you will need the data set Mobilität in Deutschland (German for mobility in Germany). You
can request it here from the clearingboard transport:https://daten.clearingstelle-verkehr.de/order-form.htmlCurrently,
VencoPy is so far only tested with the B2 data set of MiD 2008 and MiD 2017.Enjoy the tool, we're happy to receive feedback!CodestyleWe use PEP-8, with the exception of lowerCamelCase for method and variable names as well as UpperCamelCase for classes.DocumentationThe documentation can be found here:https://vencopy.readthedocs.io/en/latest/index.htmlTo build the documentation from a conda bash with an activated environment type:sphinx-build-bhtml./docs/./build/Useful LinksDocumentation:https://vencopy.readthedocs.io/en/latest/index.html#Source code:https://gitlab.com/dlr-ve/vencopyPyPI release:https://pypi.org/project/vencopyLicence:https://opensource.org/licenses/BSD-3-ClauseWant to contribute?Great, welcome on the VencoPy team! Please read our contribute section in the documentation and reach out to Niklas
(niklas.wulff@dlr.de). If experience difficulties on set up or have other technical questions, join ourgitter community
Package: vendetta
vendettaAnonymize CSV file(s) by replacing sensitive values with fakes.InstallationpipinstallvendettaExampleSuppose you haveorders.csvdataset with real customer names and order IDs.CustomerName,CustomerLastName,OrderID
Darth,Wader,1254
Darth,Wader,1255
,Yoda,1256
Luke,Skywalker,1257
Leia,Skywalker,1258
,Yoda,1259This list contains 4 unique customers. Let's create a configuration file, say,orders.yaml:columns:CustomerName:first_nameCustomerLastName:last_nameand run:vendettaanonymizeorders.yaml<orders.csv>anon.csvwhich gives something like this inanon.csv:CustomerName,CustomerLastName,OrderID
Elizabeth,Oliver,1254
Elizabeth,Oliver,1255
Karen,Rodriguez,1256
Jonathan,Joseph,1257
Katelyn,Joseph,1258
Karen,Rodriguez,1259OrderID column was not mentioned in the config, and was left as isUsingfaker, program replaced the first and last names with random first and last names, making the data believableIf in the source file two cells for the same column had the same value (Vader), the output file will also have identical values in these cells.Enjoy!LicenseMITCreditsThis project was generated withwemake-python-package. Current template version is:b80221aaae4ac702bea7e66b77b9389d527c1e3c. See what isupdatedsince then.
Package: vendia-utils-brian-mcnamara
vendia-utilsThis package has utilities that are useful when interacting withVendia Universal Application (Uni)data.BlocksAblockis a ledger entry which contains, in addition to its transactions, three additional pieces of metadata:A link to the previous entryA copy of the previous entry's content hashA content hash that includes (1) and (2)These additional items are what make a block more than just a log entry - they ensure that the block and its history are also tamperproof, because any change to any portion of the history will cause one or more of the hashes to be invalid.Vendia supports the following block notification types:Real-time block notifications: Emitted when the node commits a new block. Includes a summary of the transactions included in the block.Dead-letter notifications: Emitted when an asynchronous transaction cannot be committed within the retry policy. Includes the full details of the original transaction.A new block notification is emitted when data in a node has changed.  Data could have been created, updated, or deleted.  Block reports can be sent to an outbound integration:HTTPS webhooksAWS Lambda functionsAWS SQS queuesEmail addressesThe block report includes information about the block, including theBlockId,BlockHash, ****, but it does not include the full list of mutations that were included in the block transaction list.  Users must query the Uni to get this information.
Package: vendoasg
Vendo APISource:fromvendoasgimportVendovend=Vendo("URL_TO_VENDO_API")vend.logInApi("log_api","pass_api")vend.loginUser("user_login","user_pass")PIP:pip install vendoasgfromvendoasg.vendoasgimportVendovend=Vendo("URL_TO_VENDO_API")vend.logInApi("log_api","pass_api")vend.loginUser("user_login","user_pass")