Saravanan666/pypi-org huggingface dataset:
Package: vqc-lite
VQC-LiteVQC-Lite is an object-oriented Python library for building variational quantum circuits and related tasks in quantum
machine learning (QML).VQC-Lite may not be the most efficient simulator, but it's definitely an intuitive, reader-friendly and simple-to-use one. With
just a few hundred lines of code and full documentation, one could see how a VQC is built layer by layer, from
elementary unitary gates all the way up to a differentiable and optimizable quantum circuit.VQC-Lite provides two alternative ways to construct VQCs, one involving only standard numpy functions, and one using the
framework Pennylane (https://github.com/PennyLaneAI/pennylane). Both implementations give VQCs of similar
functionalities with the same I/O. While the latter is currently more efficiently integrated with Jax for circuit
optimization by differentiation, the former provides the additional feature of optimization by sweeping.Author and Developer: Kevin Shen ->Github->LinkedInInstallationUse the package managerpipto install VQC-Lite.pipinstallvqc_liteUse the requirements.txt sheet to install dependenciespipinstall-rrequirements.txtUsagePlease read the Jupyter Notebooks under the folder demo/ for more details. There contains 2 notebooks.The notebook "circuit" gives an introduction to the VQC circuit stacks.The notebook "experiment" gives an illustrative example application for VQC: uploading an image onto a quantum computer.importnumpyasnpfromvqc_lite.circuit_stack_pennylane.circuit_mpsimportMPS_GU2_Pfromvqc_lite.experiments.expressibilityimportExpressibility_Evaluationfromvqc_lite.experiments.state_preparationimportCompression_Adam# initialize a VQCcircuit=MPS_GU2_P(nl=1,nq=4)# 1 layer of general 2 qubit gates covering 4 qubits# execute a VQCparams=np.random.uniform(size=45)# 3 gates, each with 15 parametersparams=circuit.params_to_proper_shape(params)# reshape the parameterspsi_out=circuit.run_with_param_input(params)# get output state# state preparation with VQCghz=np.zeros(4*[2])# Let's compress a GHZ state as an exampleghz[0,0,0,0]=1/np.sqrt(2)ghz[1,1,1,1]=1/np.sqrt(2)task=Compression_Adam(ghz,circuit,steps=1000)# use Adam optimizertask.run()# evaluate expressibilitytask=Expressibility_Evaluation(circuit)task.run()ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseApache-2.0
Package: vqf
This is the implementation of the IMU orientation estimation filter described in the following publication:D. Laidig and T. Seel. “VQF: Highly Accurate IMU Orientation Estimation with Bias Estimation and Magnetic
Disturbance Rejection.” Information Fusion 2023, 91, 187–204.doi:10.1016/j.inffus.2022.10.014.
[Accepted manuscript available atarXiv:2203.17024.]The filter can perform simultaneous 6D (magnetometer-free) and 9D (gyr+acc+mag) sensor fusion and can also be used
without magnetometer data. Different sampling rates for gyroscopes, accelerometers, and magnetometers are
supported as well. While in most cases, the defaults will be reasonable, the algorithm can be influenced via two
tuning parameters.DocumentationDetailed documentation can be found athttps://vqf.readthedocs.io/.InstallationThe VQF Python package can easily be installed from PyPI via pip, e.g.:pipinstallvqfFor more information, please refer to thedocumentation.LicenseVQF is licensed under the terms of theMIT license.ContactDaniel Laidig <laidig at control.tu-berlin.de>
Package: vqls-prototype
Variational Quantum Linear Solver PrototypeThis repository contains a prototype implementation of the variational quantum linear solver [1,2] that allows to solve linear systems, $A\times x = b$, using variational circuits.Table of ContentsFor UsersAbout the ProjectBeginner's GuideInstallationQuickstart GuideTutorialsHow-TosPrototype Template File GlossaryReferences and AcknowledgementsLicenseFor Developers/ContributorsContribution GuideTechnical DocsReferences and Acknowledgements[1] Variational Quantum Linear Solver, Carlos Bravo-Prieto, Ryan LaRose, M. Cerezo, Yigit Subasi, Lukasz Cincio, Patrick J. Coles, arXiv.1909.05820, 2020[2] VQLS Tutorial:https://github.com/qiskit-community/qiskit-textbook/blob/main/content/ch-paper-implementations/vqls.ipynbLicenseApache License 2.0
Package: vquest
Automate IMGT V-QUEST usage on imgt.orgIMGT'sV-QUESTis only available via a web interface.  This Python package automates V-QUEST
usage by submitting request data like the web form does.  Currently only the
"Download AIRR formatted results" option is supported.Example command-line usage, with rhesus sequences in seqs.fasta:pip install . # or skip this and use "python -m vquest" below
vquest --species rhesus-monkey --receptorOrLocusType IG --fileSequences seqs.fastaThe output is saved toParameters.txtandvquest_airr.tsv(the files
V-QUEST provides in a zip archive) in the working directory by default.Or with--alignto automatically extract the alignment as FASTA:vquest --align --species rhesus-monkey --receptorOrLocusType IG --fileSequences seqs.fastaHere the aligned FASTA text is printed directly to standard output.Example Python usage:>>> from vquest.vq import *
>>> config = layer_configs(DEFAULTS, {"species": "rhesus-monkey", "receptorOrLocusType": "IG", "fileSequences": "seqs.fasta"})
>>> result = vquest(config)
>>> result.keys()
dict_keys(['Parameters.txt', 'vquest_airr.tsv'])Here the output is a dictionary of filenames to contents.The only required options are species, receptorOrLocusType, and either
fileSequences or sequences (to provide sequences directly as text).  Options
can be given via command-line arguments or one or more YAML configuration
files.  Seedata/defaults.ymland./vquest.py --helpfor
details.The web form will only accept 50 sequences at a time, so the sequences given
here are grouped into chunks of 50, submitted, and (by default) the results
automatically combined.  A delay (default 1 second) is used between submissions
to avoid being impolite to the server.V-QUEST:http://www.imgt.org/IMGT_vquest/analysisV-QUEST docs:http://www.imgt.org/IMGT_vquest/user_guide#introA different approach, usingSeleniumto automate V-QUEST usage with a browser:https://github.com/AndrewZoldy/IMGT_VQUEST_BOT
Package: vqvae
Pytorch VQVAE implementationExamplefromvqvaeimportVQVAE,sequential_encoder,sequential_decoderfromtorch.optimimportAdamfromfunctoolsimportpartialinput_channels=3output_channels=3embedding_length=256hidden_channels=64beta=0.25embedding_size=512opt=partial(Adam,lr=2e-4)encoder=sequential_encoder(input_channels,embedding_size,hidden_channels)# Encoder from the paperdecoder=sequential_decoder(embedding_size,output_channels,hidden_channels)# Decoder from the papervqvae=VQVAE(encoder,decoder,opt,beta,embedding_length,embedding_size)# Pytorch-Lightning module,# hence usable to train the model
Package: vracer
installationpipinstallvracerusagepython-mvracer-fpath_to_file_to_be_debugged.py-jpath_to_output_debugged_json_file.json# orpython-mvracer--filenamesome_python_file.py--jsonfilenameoutput_file_path.jsonthis library is based on snoop debugger library.it creates a trace of the code that is passed (python file) along with tracking the change of variables value. The tracked output is dumped as a json file.
Package: vrc-controller
VRC ControllerThis Python Module is a wrapper for VR Chat's OSC binding and listens to vrchat audio.In this package, when sound is heard the program records sound for the time specified in constants.py or until there's silence, and then does speech -> text through SpeechRecognition.
You can use your own dictation models like vosk if you want.This project was heavily inspired byAI Joken. I wanted some python bindings so here we are.THIS PROJECT IS IN A HEAVILY DEVELOPMENTAL STATE
Package: vrcgal-py
Python utilities for Virtual Reality and Clinical Gait Analysis Laboratory, High Point University.Please include these citations---------------------> Duarte, M. (2015) Notes on Scientific Computing for Biomechanics and Motor Control. GitHub repository, https://github.com/demotu/BMC.> Long, B., Gosselin, D. (2017) Python utilities for Virtual Reality and Clinical Gait Analysis. GitHub repository, https://github.com/vrcgal/vrcgal_py.
Package: vrchatapi
VRChat API Library for PythonA Python client to interact with the unofficial VRChat API. Supports all REST calls specified in theAPI specification.DisclaimerThis is the official response of the VRChat Team (from Tupper more specifically) on the usage of the VRChat API.Use of the API using applications other than the approved methods (website, VRChat application) are not officially supported. You may use the API for your own application, but keep these guidelines in mind:We do not provide documentation or support for the API.Do not make queries to the API more than once per 60 seconds.Abuse of the API may result in account termination.Access to API endpoints may break at any given time, with no warning.As stated, this documentation was not created with the help of the official VRChat team. Therefore this documentation is not an official documentation of the VRChat API and may not be always up to date with the latest versions. If you find that a page or endpoint is not longer valid please create an issue and tell us so we can fix it.Getting StartedFirst add the package to to your project:pipinstallvrchatapiBelow is an example on how to login to the API and fetch your own user information.# Step 1. We begin with creating a Configuration, which contains the username and password for authentication.importvrchatapifromvrchatapi.apiimportauthentication_apifromvrchatapi.exceptionsimportUnauthorizedExceptionfromvrchatapi.models.two_factor_auth_codeimportTwoFactorAuthCodefromvrchatapi.models.two_factor_email_codeimportTwoFactorEmailCodeconfiguration=vrchatapi.Configuration(username='username',password='password',)# Step 2. VRChat consists of several API's (WorldsApi, UsersApi, FilesApi, NotificationsApi, FriendsApi, etc...)# Here we enter a context of the API Client and instantiate the Authentication API which is required for logging in.# Enter a context with an instance of the API clientwithvrchatapi.ApiClient(configuration)asapi_client:# Instantiate instances of API classesauth_api=authentication_api.AuthenticationApi(api_client)try:# Step 3. Calling getCurrentUser on Authentication API logs you in if the user isn't already logged in.current_user=auth_api.get_current_user()exceptUnauthorizedExceptionase:ife.status==200:if"Email 2 Factor Authentication"ine.reason:# Step 3.5. Calling email verify2fa if the account has 2FA disabledauth_api.verify2_fa_email_code(two_factor_email_code=TwoFactorEmailCode(input("Email 2FA Code: ")))elif"2 Factor Authentication"ine.reason:# Step 3.5. Calling verify2fa if the account has 2FA enabledauth_api.verify2_fa(two_factor_auth_code=TwoFactorAuthCode(input("2FA Code: ")))current_user=auth_api.get_current_user()else:print("Exception when calling API:%s", e)exceptvrchatapi.ApiExceptionase:print("Exception when calling API:%s", e)print("Logged in as:",current_user.display_name)Seeexample.pyfor more example usage on getting started.ContributingContributions are welcome, but do not add features that should be handled by the OpenAPI specification.Join theDiscord serverto get in touch with us.
Package: vr.cli
A command-line interface for wrangling Velociraptor swarms and automating
some common operations.ImplementationThe cli provides a command-line interface around the vr.common.models.Featuresvr.clisupports several sub-commands, including:buildswarmuptestsFor a complete list of commands, invoke vr.cli with –help.BuildSimply assemble a build of an app at a given tag. This routine is useful to
prime an build before doing other swarm operations.SwarmThis routine dispatch a swarm at a given tag:vr.cli swarm MyApp-Recipe_.* 3.0 -x Recipe_SkippedIt takes as its parameters a filter of swarm name, a version number, and
optionally some excludes.The name filter is case sensitive, but the excludes are case insensitive.UptestsThis routine will provide a quick printout of all failing uptests.ProcsList, start, or stop procs.Compare ReleasesCompare the configuration of any two releases (indicated by release ID).ConfigurationThevr.clicommand requires a URL to communicate with the
Velociraptor instance via its REST api. By default, the URL is inferred from
the namedeployas resolved by DNS. Ifdeployresolves asdeploy.example.com,vr.cliwill usehttps://deploy.example.comas
the URL. The value can be overridden by passing--urlto the command or by
setting theVELOCIRAPTOR_URLenvironment variable.AuthenticationThe Velociraptor client models (found in vr.common.models) will default to
using the current username (getpass.getuser). If your username on your local
host doesn’t match your username in Velociraptor, you can override the
username by passing--usernameto the command or by setting any of theenvironment variables searched by getuseror by settingVELOCIRAPTOR_USERNAMEenvironment variable.vr.clialso leverages keyring to avoid entering passwords each time.
To do this, it needs a system name and username. For the username, it uses
the username resolved above. For the system name, it defaults to the domain
name of the Velociraptor URL (as resolved above). The domain can be overridden
by setting theVELOCIRAPTOR_AUTH_DOMAINenvironment variable.Environment VariablesFor unattended use, it’s also possible to supply authentication credentials to
Velociraptor by setting theVELOCIRAPTOR_USERNAMEandVELOCIRAPTOR_PASSWORDenvironment variables, which will supersede
the interactive values above. This technique is strongly discouraged for
interactive use.
Package: vr-delaunay-to-voronoi
VR.Delaunay-To-VoronoiConvert from Delaunay tesselation to Voronoi triangulation.
In contrast to qHull, this provides edges of Voronoi triangulations.VisualizationFeaturesLargely typedReasonably quickFully testedProblem StatementqHull provides edges, but not vertices of Voronoi triangulations.
To gather the edges and the vertices, this library derives them from the
Delaunay tesselation.ApproachThe Delaunay tesselation is calculated by qHull.
This provides a stable and known-good base to derive from.Mental ModelTODOStatusLicenseThis package is not licensed. Therefore, it can only be used in the DFKI.UsageThis package originates from and is being used in production
at theVR.Backendproject.
However,
the VR.Backend project is currently internal to the DFKI.DemoTODODevelopmentFor development and maintenance of this project,
see thedevelopment documentation.DocumentationFor more complete documentation,
see ourdedicated documentation pages.SupportPlease refer to the issue tracker for any inquiry.
Package: vrealpython-reader
Real Python Feed ReaderThe Real Python Feed Reader is a basicweb feedreader that can download the latest Real Python tutorials from theReal Python feed.For more information see the tutorialHow to Publish an Open-Source Python Package to PyPIon Real Python.InstallationYou can install the Real Python Feed Reader fromPyPI:pip install realpython-readerThe reader is supported on Python 2.7, as well as Python 3.4 and above.How to useThe Real Python Feed Reader is a command line application, namedrealpython. To see a list of thelatest Real Python tutorialssimply call the program:$ realpython
The latest tutorials from Real Python (https://realpython.com/)
 0 How to Publish an Open-Source Python Package to PyPI
 1 Python "while" Loops (Indefinite Iteration)
 2 Writing Comments in Python (Guide)
 3 Setting Up Python for Machine Learning on Windows
 4 Python Community Interview With Michael Kennedy
 5 Practical Text Classification With Python and Keras
 6 Getting Started With Testing in Python
 7 Python, Boto3, and AWS S3: Demystified
 8 Python's range() Function (Guide)
 9 Python Community Interview With Mike Grouchy
10 How to Round Numbers in Python
11 Building and Documenting Python REST APIs With Flask and Connexion – Part 2
12 Splitting, Concatenating, and Joining Strings in Python
13 Image Segmentation Using Color Spaces in OpenCV + Python
14 Python Community Interview With Mahdi Yusuf
15 Absolute vs Relative Imports in Python
16 Top 10 Must-Watch PyCon Talks
17 Logging in Python
18 The Best Python Books
19 Conditional Statements in PythonTo read one particular tutorial, call the program with the numerical ID of the tutorial as a parameter:$ realpython 0
# How to Publish an Open-Source Python Package to PyPI

Python is famous for coming with batteries included. Sophisticated
capabilities are available in the standard library. You can find modules for
working with sockets, parsing CSV, JSON, and XML files, and working with
files and file paths.

However great the packages included with Python are, there are many
fantastic projects available outside the standard library. These are most
often hosted at the Python Packaging Index (PyPI), historically known as the
Cheese Shop. At PyPI, you can find everything from Hello World to advanced
deep learning libraries.

[... The full text of the article ...]You can also call the Real Python Feed Reader in your own Python code, by importing from thereaderpackage:>>> from reader import feed
>>> feed.get_titles()
['How to Publish an Open-Source Python Package to PyPI', ...]
Package: vredis.py
Distributed script crawler framework.# Simply connecting redis on the worker side of the library provides an-# executable power for distributed scripts# All function executions on the sender end will be piped to redis,# and the worker end will be pulled out of the pipe to execute.# Support multi-task simultaneous execution! Each execution maintains a taskid,# and different tasks maintain their configuration space according to the-# taskid when they are executed simultaneously.worker# if in start_worker.pyimportvrediss=vredis.Worker.from_settings(host='xx.xx.xx.xx',port=6666,password='vredis')s.start()# if in bashC:\Users\Administrator>vredisworker-hoxx.xx.xx.xx-po6666-pavredis-db0# if not set param. use defaults param.# default host localhost# default port 6379# default password None# default db 0senderfromvredisimportpipepipe.connect(host='xx.xx.xx.xx',port=6666,password='vredis')pipe.DEBUG=True# True/False. worker prints on the worker_console.# very low code intrusion, no decorator or even complete barrier-free execution# The decorated function becomes a send function and is sent to the task pipeline@pipedefsome(i):importtime,randomrd=random.randint(1,2)time.sleep(rd)print('use func:{}, rd time:{}'.format(i,rd))return123# return a data and wraps them in JSON data and passes them in redis.@pipe.table('mytable')# if not set table, use "default" as tablenamedefsome2(i):print('use func2:{}'.format(i))return333,444# if return is a generator or list or tuple,# First, he iterates out the parameters and wraps them in JSON data and passes them in.# data collection space use tablename <= default tablename space "default".foriinrange(100):some(i)# first send task it will get a taskid. info will log out.some2(i)get_datafromvredisimportpipepipe.connect(host='xx.xx.xx.xx',port=6666,password='vredis')foriinpipe.from_table(taskid=26):print(i)# the second param is tablename. default tablename is "default"
Package: vre-eoles
Product NameToolbox to:automatize extraction of wind speed and wind turbine FC via the renewable.ninja API  (https://www.renewables.ninja/).build aggregated FC at the France level (B. Shirizadeh et al.https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3592447,https://github.com/BehrangShirizadeh/EOLES_elecRES)compare simulated wind turbine FC with the RTE experimental ones.plot the results with geographical representationInstallationRun the following to install:pipinstallvre_eolesUsage examplerefer toimage_features_extract-examples.Release History0.1.0Meta- François Bertin– francois.bertin7@wanadoo.frDistributed under theMIT licenseAbout the authors- François Bertin retired, formally senior scientist at CEA-LETI
Package: vrelease-bin
vrelease-py-wrapperPython wrapper forvrelease. Install with pipenv:pipenvinstall--devvrelease-binOr pip:pipinstallvrelease-binHow can I use it?For instructions on how to usevrelease,see this.Global installpipinstallvrelease-binSudo privileges might be needed. After that,vreleasewill be available atPATH. Simply:vrelease-hPer project basisWhen installing on a single project, add a script to yourPipfile:[scripts]"vrelease:help"="vrelease -h"And run like any pipenv script:pipenvrunvrelease:helpLicenseTo the extent possible under law,Caian Ertlhas waivedall copyright
and related or neighboring rights to this work. In the spirit offreedom of
information, I encourage you to fork, modify, change, share, or do whatever
you like with this project!^C ^V
Package: vrepper
If you have Python and V-Rep the robot simulator
software installed, why not combine both? This library let’s you
access the V-Rep API in a bit more humane way the native implementation
(V-Rep ships with its own Python API, but it’s a bit harder to use).
This library gives you a lot of convenience and includes an example for
OpenAI Gym integration. This codebase is an extension of ctmakro’shttps://github.com/ctmakro/vrepperwho provided all the basic functions -
so without their effort this wouldn’t have been possible.
Package: vrfy
Verify with VRFY: Ensure the integrity of your file copies, hash by hash!When beginning to explore cloud storage (or other methods of remotely storing files), one may become concerned about file integrity at some point. When dealing with a large number of individual files, how can one be certain that no file becomes corrupted during the storage process, and that downloaded files remain identical to their uploaded versions? This concern is particularly relevant after undergoing multiple segmentation and encryption/decryption processes. It's impractical to manually verify all files, making file corruption a common worry, especially for those using smaller cloud providers.Those concerns are mitigated by using a small console application calledvrfy.vrfyhandles the heavy lifting and verifies the integrity of your backups for you!
With a single, easy command, you can:Verify that copies are identical (i.e., all files are included in both locations, and -by using sha256 hash checksums- that not even a single bit was changed).Create and store a file with sha256 hash checksums beside your data. This file can be backed up with your data and used for verification later.Verify that your data is unchanged using the checksum file.InstallationPIP:Installvrfyusing pip:pipinstallvrfy--userUsage1. Verifing that two directories are identicalVerifing that the contents of '/path/of/clone' are identical to those of '/path/of/master'. For example, '/path/of/master' might be a local backup, whereas '/path/of/clone' might be loaded from cloud storage.vrfy/path/of/master/path/of/cloneorvrfy-m/path/of/master-c/path/of/clone-ror (checksums are printed to console)vrfy-m/path/of/master-c/path/of/clone-r-p2. Storing checksums for future verificationCreating a file that lists checksums for all files within a directory:vrfy-c/path/of/dataUsing-r(recursive) all in sub-directories as well:vrfy-r-c/path/of/data3. Verifing files against stored checksumsVerifying that all files within a directory haven't been changed (i.e., their checksums still match):vrfy-v/path/of/dataUsing option-r(recursive) all sub-directories are verified as well:vrfy-r-v/path/of/dataUsing option-p(print) all checksums are printed to console for further inspection:vrfy-p-r-v/path/of/dataVerifying the current working directory and all its sub-directories:vrfyVerifying file against an expected checksum:vrfy-f/path/of/file/filename-csexpectedChecksumWhere "expectedChecksum" can be one of the following:A string containing the expected sha256 hash digest.A *.sha256sum-file that includes the expected hash digest.A sums.csv-file created byvrfythat includes the expected hash digest.4. Other CLI optionsDisplay version of vrfy:vrfy-versionDisplay checksum for given file:vrfy-p-f/path/of/file/filename