Saravanan666/pypi-org huggingface dataset:
Package: venvpool
venvpoolRun your Python scripts using an automated pool of virtual environments to satisfy their requirementsInstallThese are generic installation instructions.To use, permanentlyThe quickest way to get started is to install the current release from PyPI:pip3 install --user venvpoolTo use, temporarilyIf you prefer to keep .local clean, install to a virtualenv:python3 -m venv venvname
venvname/bin/pip install venvpool
. venvname/bin/activateTo developFirst clone the repo using HTTP or SSH:git clone https://github.com/combatopera/venvpool.git
git clone git@github.com:combatopera/venvpool.gitNow use pyven's pipify to create a setup.py, which pip can then use to install the project editably:python3 -m venv pyvenvenv
pyvenvenv/bin/pip install pyven
pyvenvenv/bin/pipify venvpool

python3 -m venv venvname
venvname/bin/pip install -e venvpool
. venvname/bin/activateCommandsmotivateCreate and maintain wrapper scripts in ~/.local/bin for all runnable modules in the given projects, or the current project if none given.motivate -SCreate/maintain wrappers for all console_scripts of the given requirement specifier.motivate -CCompact the pool of venvs.
Package: venvstarter
Program to bootstrap a virtualenv for your program!Full documentation athttp://venvstarter.readthedocs.ioTestsTo run the tests you must first create apythons.jsonin the root of your
checkout of venvstarter that tells the tests where to find each version of
Python:{"python3.7":"~/.pyenv/versions/3.7.12/bin/python","python3.8":"~/.pyenv/versions/3.8.12/bin/python","python3.9":"~/.pyenv/versions/3.9.6/bin/python""python3.10":"~/.pyenv/versions/3.10.0/bin/python""python3.11":"~/.pyenv/versions/3.11.0/bin/python"}In this example I’m using pyenv to get copies of each Python. Using pyenv isn’t
a requirement, but it does make it easy! There is nothing in the tests that rely
on features in any particular version, and so the minor patch of each version is
irrelevant. All that matters is having some version of 3.7, 3.8, 3.9, 3.10 and 3.11.I recommend running the tests in a virtualenv. I use virtualenvwrapper for this
but you can also do apython3-mvenv my_venvsomewhere and use that.Then once you’re in a virtualenv:> python -m pip install -e ".[tests]"
> ./test.sh
Package: venv-test-wzc
venv_test_wzc这是一个用验证PIPY上传及下载的工程Installationpip install venv_test_wzcUsageexample:another example:Get helpUpdate log1.0.1Secondary release1.0.0first releasehow to upload a new version (for me)make sure have twine installed firstchangesetup.pytestingpython3 setup.py developpython3 setup.py sdisttwine upload dist/*
Package: venvtools
venvtoolsA simple setuptools command to help with virtualenvDEPRECATEDUse eitherpoetryorpipxaccording to your use case.MotivationThe objective of this utility is to provide means for easy creation of a virtual
environment for local packages using python's standard venv module and to integrate
with setuptools distribution model for seamless resolution and installation of
dependencies.How to useInside your package root folder execute the following to create the venv and install
your package dependencies inside it:python./setup.pyvenvor (if yoursetup.pyis executable)./setup.pyvenvCurrently updating dependencies inside the venv is not working correctly.
It's recommended to recreate the venv to archive it.(This will be fixed in a posterior version)./setup.pyvenv--rm&&./setup.pyvenvOptions--env-name (-n)         Virtual environment name.
                        (DEFAULT: Project name)
--get-pip               Virtual env get-pip.py URL.
                        (DEFAULT: https://bootstrap.pypa.io/get-pip.py)
--extras (-e)           Comma separated list of extras to be installed.
--system-site-packages  Make the system (global) site-packages dir available to the
                        created environment.
--rm                    Remove virtual environment.
--editable              Install package to venv as editable.
--location (-l)         Retrieve virtual environment location.
--old-resolver          Force pip to use its old resolver.LicenseSeeLICENSECOPYRIGHTCopyright (c) 2018-2023 Vítor Vasconcellos. All rights reserved.
Package: venvx
venvxCreate and use virtual environments with easeInstallationInstall the venvx package with pippython-mpipinstall--uservenvxor your favorite Python package manager. To install thevenvshell extension, entervenvxshellext>~/.venvx.shReview the content of the file and source it into your bash or zsh profile.UsageAssuming the current directory contains two virtual enviroments called .venv3.10 and .venv3.11:%ls-a
./../.venv3.10/.venv3.11/The commandvenv useactivates, and switches between, virtual environments.%venvuse.venv3.10(.venv3.10)%whichpip
/path/to/.venv3.10/bin/pipIf the venv name begins with .venv, it suffices to specify the remainder of the name. For instance, in order to switch to another virtual enviroment:(.venv3.10)%venvuse3.11(.venv3.11)%whichpip
/path/to/.venv3.11/bin/pipTo quickly run a command in a virtual environment, use the run command.(.venv3.11)%venvrun3.10whichpython
/path/to/.venv3.10/bin/python(.venv3.11)%Since venv always activates the virtual environment internally, venv commands may be run within another virtual environment as shown above, or outside:(.venv3.11)%venvoff
%venvrun3.10pytest-vtests
%New virtual environments can be created withvenv create. If the name of the virtual environment is omitted, ".venv" will be used:%venvcreateor use a different name e.g.%venvcreatepyenvThe Python version to use within the new virtual environment may be specified with the -v (a.k.a. --versions) option.%mkdirnewdir&&cdnewdir
%venvcreate-v3.83.9
%venvcreatepyenv-v3.83.9
%ls-a
./../.venv3.8/.venv3.9/pyenv3.8/pyenv3.9/The new virtual environments have already been upgraded to the most recent version of thepippackage. The command%venvupgrade-pipexisting_envupgrades the pip module of an existing virtual environment. Obviously, this works in an activated virtual enviroment as well.%venvuse3.9(.venv3.9)%venvupgrade-pipIn Git Bash on Windows, the Scripts/activate script defines a VIRTUAL_ENV path that contains both "/" and "\" path separators.venv fix [path]corrects that.When a virtual environment is copied to a different location, the activate script's VIRTUAL_ENV setting, as well as the shebangs in the various scripts within the venv's bin/ folder, all still refer to the original virtual environment.venv fix [path]performs the necessary updates. Example (Darwin or Linux):%mv.venv3.9.venv39
%venvfix39Checkingifanyscriptsrequirepatches-yes(6)Fixingtheshebanginpip3-doneFixingtheshebanginpip-doneFixingtheshebanginpip3.9-doneFixingtheVIRTUAL_ENVsettinginactivate.fish-doneFixingtheVIRTUAL_ENVsettinginactivate-doneFixingtheVIRTUAL_ENVsettinginactivate.csh-doneEntervenv helpandvenvx -hfor more information on usage.
Package: ve-power-meter
ve-power-meterPower measurement tool for NEC Vector EngineInstallationpip install ve-power-meterUsage$ ve-power-meter
timestamp,power.draw,temperature.core,temperature.memory
2023/06/13 12:15:10.275,47.04,45,40
2023/06/13 12:15:11.292,47.04,45,40
2023/06/13 12:15:12.309,47.01,45,40
2023/06/13 12:15:13.326,47.01,47,44
2023/06/13 12:15:14.342,145.38,49,50
2023/06/13 12:15:15.358,173.39,50,50
2023/06/13 12:15:16.373,173.39,51,52
2023/06/13 12:15:17.390,170.48,51,53
2023/06/13 12:15:18.405,170.48,51,54
2023/06/13 12:15:19.421,177.39,52,54Notes:vecmdmust be available at/opt/nec/ve/mmm/bin/vecmd(tested with mmm v1.3.78).Metrics are printed out every second.temperature.coreis the average temperature of all cores (Celsius).temperature.memoryis the average temperature of all HBM modules (Celsius).power.drawisAUX 12V V * AUX 12V C + Edge 12V V * Edge 12V C(Watts).
Package: veppy
WARNING:This code is an alpha release and not production-ready. APIs may change at any time.Veppy is a genetic variant effect predictor for Python. Inspired by SnpEff and VEP.Installation$pipinstallveppyInstallation from source$gitclonegit@github.com:solvebio/veppy.git$cdveppy$pythonsetup.pyinstallSetupStep 1 (OPTIONAL):Prepare a directory for veppy dataThe default data path is:./dataYou can override this by setting$VEPPY_DATA_DIR.exportVEPPY_DATA_DIR=/opt/veppyStep 2:Download source data and build indexesNOTE:This step downloads about 1gb of data. After indexing, the data directory will consume about 8gb of disk space../scripts/download_data_GRCh37.shStep 3:Index the source datapython./run_index.pyExample Usage>>>fromveppy.veppyimportcalculate_consequences>>>variant=('1',8025384,'A','T')>>>result=calculate_consequences('GRCh37',*variant)>>>printresult.resultsTestingTests are currently based on chr1 versions of input data.
Full genome tests are coming soon!$nosetestsCoverage:$nosetests--with-coverage--cover-package=veppyAbout SolveBioSolveBio is a genomics company based in New York City.
Package: veq
veqVeq, short forViewEquation, is a pygame based application for graphing equations.Note: If you are viewing this README from PyPI, you may be unable to properly open links. Please check the README on theGitHub page, instead.Getting StartedInstallationThe recommended way to install the most up-to-date version of this project is by cloning the respository and runningsetup.py install. This allows you to control which branch you install as well. This may not always guarantee a stable release, however.You can also use pip to install the recommended release fromPyPIwithpip install veq.RequirementsIt is recommended you use the most recent stable version of Python. This project was built using Python 3.8.10. Dependencies are listed inrequirements.txtand should be installed when runningsetup.py.RunningRunning the application can be done through the console script entry pointveqor throughpython3 -m veq. The application takes the following command-line arguments:usage: veq [-h] [--debug] [-s n] [-a] [-p PRECISION] [-d DOMAIN] [-r RANGE]
           equation

Visualize an equation.

positional arguments:
  equation              Equation to plot.

optional arguments:
  -h, --help            show this help message and exit
  --debug               Enable debug logging.
  -s n, --step n        Enable gridlines with step n
  -a, --noaxis          Disable axis.
  -p PRECISION, --precision PRECISION
                        Number precision for text formatting.
  -d DOMAIN, --domain DOMAIN
                        Initial domain.
  -r RANGE, --range RANGE
                        Initial range.FeaturesExpressions will be evaluated and graphed withy = f(x)over a set domain and range. You can view exactly where a point falls on an equation by hovering over the line. You can also find the corresponding y-value to an x-value by moving the mouse. You can save one point for reference.SyntaxSeeOPERATIONS.mdfor valid operations.ControlsThe following controls are supported:controlactionLeft Mouse ButtonSave point.Mouse Right-Click DragMove view by changing domain and range.Mouse Wheel UpZoom in by decreasing domain and range.Mouse Wheel DownZoom out by increasing domain and range.+Zoom in by decreasing domain and range.-Zoom out by increasing domain and range.RReset domain and range.SHIFT-RReset variable t.Left/Right ArrowShift domain left/right.Up/Down ArrowShift range up/down.DocumentationDocumentation is supplied through Sphinx Auto-Doc and is available onreadthedocs.LicenseThis project is licensed under GNU GENERAL PUBLIC LICENSE V3. ViewLICENSEfor details.AuthorsWillow Ciesialka
Package: verace
IntroductionThis project provides a Python 2.7/3.x library to aid checking strings
in files. Verace’s main use case is checking that version strings are
consistent in project files. The main features of this library are:Custom parse any project files for strings.Easily determine if all strings are consistent.Quickly updated tracked strings.Should work on any platform without additional dependencies;Qpromptis recommended for
default prompts.StatusCurrently, this project is in thedevelopment releasestage. While
this project is suitable for use, please note that there may be
incompatibilities in new releases.RequirementsVerace should run on any Python 2.7/3.x interpreter without additional
dependencies.InstallationVerace can be installed with pip using the following command:pip install veraceAdditional, Verace can be installed from source by running:python setup.py installUsageStart by importing Verace into your Python script:importveraceCreate aVerCheckerobject, name it and set the root location:mychk=verace.VerChecker("My Checker",__file__)Include a file to check. If no check function is provided,check_basic()will be used by default. Let’s look for the version
string insetup.py:mychk.include(r"lib\setup.py",match="version = ",splits=[('"',1)])Get the string found by the checker:print("version found = "+mychk.string())# version found = 0.4.1The string can be updated in all associated files:mychk.update("something different!")That’s the basics. Check outthe
documentationfor more info.Here are some real-world examples of Verace in action:AuxlyQpromptVerace
(meta)DocumentationThe full documentation for this project can be foundhere on Read the
Docs.FAQHow isVeracepronounced?“ver-AH-che” - Italian word for “truthful/accurate”.Is this library only for Python projects?Not at all! Any project can use Verace!
Package: veracode-api-py
Veracode API PythonPython helper library for working with the Veracode APIs. Handles retries, pagination, and other features of the modern Veracode REST APIs.Not an official Veracode product. Heavily based on original work byCTCampbell.SetupInstall from pypi:pypi veracode_api_py(Optional) Save Veracode API credentials in~/.veracode/credentials[default]
veracode_api_key_id = <YOUR_API_KEY_ID>
veracode_api_key_secret = <YOUR_API_KEY_SECRET>Use in your applicationsImport VeracodeAPI or one of the individual API classes into your code and call the methods. Most methods return JSON or XML depending on the underlying API.You can find sample scripts for some APIs in theSamples folder.DocsFor detailed documentation on the available methods, please see theveracode-api-py docs.NotesDifferent API calls require different roles. Consult theVeracode Docs.This library does not include a complete set of Veracode API methods. In particular, it only provides a handful of XML API methods.To use this library (or a script based on it) with a proxy server, you can set environment variables with the addresses of the proxies:export HTTP_PROXY='http://10.10.10.10:8000'export HTTPS_PROXY='http://10.10.10.10:1212'Contributions are welcome. See theContributions guidelines.
Package: veracode-python
Veracode API wrapperA python wrapper for communicating with theVeracodeAPIs.This python module currently supports the following APIs.ResultsUploadAdminMitigationFlaw ReportSandboxThere is also a top level helper classApplication,
this can be instantiated with an application name which exposes properties that will lazy load data from the corresponding API.Install$ pip3 install veracode-pythonConfigurationTo use this module you will need to configure your API credentials. Visit the Veracodehelp centerfor more information.Create a file~/.veracode/credentialscontaining your API id and secret in the following format.[DEFAULT]
VERACODE_API_ID = 5318f66b17e00...
VERACODE_API_SECRET = 4dc495318f66b1037c...You can setup multiple profiles if needed and select the profile via theVERACODE_API_PROFILEenviroment variable.UsageUsing the top level classes you can do fairly complex tasks with a few lines of code. Keep in mind that the structure of these modules may change as I add more classes.NOTE: You can set theVERACODE_LOG_LEVELenviroment varible to any valid python loggerloglevel. The default isNOTSET. Of course you can set the loglevel directly in your code rather than setting an enviroment variable.Application>>>fromveracode.applicationimportApplication>>>app=Application('verademo')>>>app<VeracodeApplication:name='verademo',id=552948>>>>app.build<VeracodeBuild:version='Wed Oct 30 - 8522bfa6',id=5347783>>>>app.policy'Production - Critical + SCA'>>>app.sandbox<VeracodeSandbox:name='None',id=None>>>>app.sandbox=app.sandboxes[2]>>>app.sandbox<VeracodeSandbox:name='CI Nightly Sandbox',id=1556344>>>>app.build<VeracodeBuild:version='Wed Oct 29 Nightly Sandbox Build',id=5346981>>>>app.sandbox=None>>>app.build<VeracodeBuild:version='Wed Oct 30 - 8522bfa6',id=5347783>>>>app.build.report<VeracodeReport:application='verademo',sandbox='None',build='Wed Oct 30 - 8522bfa6',flaws=160>>>>list(app.build.report.flaws)[0]<VeracodeFlaw:CWE='78',severity=5>Direct SDK accessReturns a python object with a one-to-one mapping to the returned XML.fromveracodeimportSDKresult=SDK.results.SummaryReport(build_id=5347783)print('The number of unmitigated flaws is:',result.flaws_not_mitigated)The number of unmitigate flaws is: 160Direct API accessReturns a custom response object with propertiesdata: returned XML andstatus_code: server response code.  The full response is also avialable.If the API requires parameters you can pass them to the constructor as a python dictionary.  The parameter names match the API parameters for the coresponding API that can be found on thehelp center.fromveracodeimportAPIbuilds=API.results.GetAppBuilds.get()print('Server returned:',builds.status_code)print('The first 20 bytes of the response XML is:',builds.data[:20])Server returned: 200
The first 20 bytes of the response XML is: '<?xml version="1.0" '
Package: veracode-to-sqlite
veracode-to-sqliteThis is a command-line tool that creates a SQLite database from the JSON results
file of a Veracode scan.Veracode scans can produce dozens or hundreds of issues that need to be
reviewed. In some settings there's good UI for triaging these issues. In other
cases (such as when running apipeline scan) the results are presented as a
raw JSON file, and must be triaged by hand.This tool converts the results from JSON into a SQLite database, which can then
be consumed by a tool likedatasettefor further analysis.
Package: vera-core
VERACore is a Python application for visualization and engineering analyses of output data from VERA (Virtual Environment for Reactor Applications).
Implemented in Python, it provides instantaneous 2D and 3D images, 1D plots, and alphanumeric data from VERA multi-physics simulations.For an interactive online example, seehere.InstallingVERACore can be installed via pip and can run locally or deployed as a service.
To use it locally within a virtual environment, you can run the following commands:python3 -m venv ./vera-env
source ./vera-env/bin/activate
pip install -U pip
pip install vera-core

vera-core --data <path-to-vera-out-file>DevelopmentSetup a virtual environment with a modern Python 3.python3 -m venv ./vera-env
source ./vera-env/bin/activate
pip install -U pipGet the code base and build its widgetsgit clone git@github.com:Kitware/VERACore.git
cd VERACore#BuildthecustomUIwidgetscd vue-components
npm i
npm run build
cd ..#Installlocalrepositoryintoyourvenvpip install -e .Run the application to test out your changesvera-core --serverLicensingVERACore is provided as an open source solution and follows theApache Software License
Package: veracore-api-client
The VeraCore API Client is a basic VeraCore.com REST API client built for Python.Compatibility & Unit Testing are actively done against Python 3.8 and 3.9.You can find out more regarding the API in theOfficial VeraCore.com REST API DocumentationThe Swagger documentation can be found here:https://{domain}.veracore.com/VeraCore/Public.Api/swagger/ui/indexReplace{domain}with your VeraCore domain nameExamplesRetrieving orders that are in an unprocessed state:fromveracore_api_clientimportVeraCorefromveracore_api_client.constantsimportORDER_STATUS_UNPROCESSEDveracore=VeraCore(username='APIUsername',password='APIPassword',system_id='APISystemID',domain='VCDomain.veracore.com')orders=veracore.get_orders(order_status=ORDER_STATUS_UNPROCESSED)fororderinorders:print('ID:%s| Status:%s| Stream:%s| Ordered By:%s| Ship To:%s'%(order['ID'],order['CurrentOrderStatus'],order['OrderClassification']['OrderProcessingStream'],order['OrderedBy']['Name'],','.join([shipment['ShipTo']['Name']forshipmentinorder['Shipments']])))Authors & LicenseThis package is released under an open source GNU General Public License v3 or later (GPLv3+) license. This package was originally created by Eli Keimig.The latest build status can be found atTravis CI
Package: veracross-api
Veracross API Python LibraryProvides an easy way to pull information from the Veracross API in Python.Rate limiting and pagination will be handled automatically.Usage Example:importveracross_apiasvc={'school_short_name':'abc','vcuser':'username','vcpass':'password'}# Create a new object with libraryvc=v.Veracross(c)# Follow the guidelines specified here: https://api.veracross.com/docs# Specify the endpoint documented in the api or just one record from that target.# Examples of endpoint are: facstaff, students, classes, courses, course_schedules, enrollments, etc.# To return one record from that target, just specify the id number.# Additional parameters are passed using a dictionary.# Return all faculty and staffdata=vc.pull("facstaff")print(data)# Return one faculty and staff member by iddata=vc.pull("facstaff/99999")print(data)# Pass url parameters in a dictionary to the pull method.# Return all faculty staff updated after 2019-01-01param={"updated_after":"2019-01-01"}data=vc.pull("facstaff",parameters=param)print(data)# Return the amount of requests left in rate limitingvc.rate_limit_remaining# Return the amount of time left before the limit is resetvc.rate_limit_resetAll data will be returned as a dictionary.
Package: veracross-client
veracross-clientThis project provides a Python wrapper for the Veracross API. It enables Veracross administrators to access, manipulate, and manage data programmatically with Python.InstallationInstall the latest version of veracross-client by runningpip install --upgrade veracross-clientGetting StartedTo begin, you need to create an OAuth Application in Veracross using the documentation found atVeracross Community: OAuth Applications and Veracross Overview. Be sure to set the scopes to cover the data you would like to access.After creating an OAuth Application and setting its scopes, create a file named config.json similar to sample_config.json provided in this repository. It should look like:{
    "client_id": "OAuth application client id",
    "client_secret": "OAuth application client secret",
    "school_route": "school route that appears in Veracross URL"
}To create a client for connecting to Veracross API, use the following code:import veracross_client as vc
import json

secrets =json.loads(open('config.json').read())

client = vc.VeracrossClient(school_route=secrets['school_route'],
                            client_id=secrets['client_id'],
                            client_secret=secrets['client_secret'],
                            scopes=["_scope 1_","_scope 2_",...])Be sure to replace the list of scopes with the scopes added to the OAuth Application. The veracross-client wrapper will return an error if a function with inappropriate scopes is used.Once the client is initiated, use the client's methods to access individual endpoints of the Veracross API. All GET methods will return a dataframe.ContributingThis wrapper is still in development. Methods for individual endpoints are not guaranteed to work. Please post issues with the name of the method that is not working along with a description of the error being encountered.
Package: verarandom
verarandomTrue random numbers in Python.Full documentation:https://alighahraei.github.io/verarandom/UsageThis module provides random.Random subclasses, so they implement allrandom functions(exceptBookkeeping functions) with true randomness. They
require an internet connection to work and will either raise a ConnectionError or a subclass of
verarandom.errors.VeraRandomError for validation failures and other related error conditions.>>>fromverarandomimportRandomOrg>>>r=RandomOrg()>>>r.quota_estimate1000000>>>r.randint(1,10,n=5)[3,4,10,3,7]>>>r.quota_estimate# bits were deducted from quota999986>>>r.randint(3,5,n=1)[5]>>>r.randint(-10,3)# a single number (like random.randint)-2>>>r.random()0.040120765652295>>>r.choice(['rock','paper','scissors'])'scissors'