Saravanan666/pypi-org huggingface dataset:
Package: vallex-tools
A Python interface to various vallency lexicon (Vallex) data.https://verner.gitlab.io/pyvallex/pipinstallvallex-toolsFeaturesMITlicensedparses lexicon data in txt and json formatsprovides a cli for working with the data (searching, printing histogram, converting between txt/json, running data tests)infrastructure to run data testsQt(WebEngine) based ui (searching, simple editing)web based interface (searching)Example UsefromvalleximportLexiconCollection,add_file_to_collectionfromvallex.grepimportparse_pattern,filter_db# Create a collection of lexiconscoll=LexiconCollection()# Load a lexicon and add it to the collectionsadd_file_to_collection(coll,open('v-vallex.txt','r',encoding='utf-8'))# Filter the collection looking for lexical units which have ACT in their framepat=parse_pattern('frame.functor=ACT')coll=filter_db(coll,pat)# Print out the frame attribute of each lexical unit in the filtered# collectionforluincoll.lexical_units:print(lu.frame)It also includes a cli interface:$vallex-cli-iv-vallex.txt--filterframe,lemma,refl--grepframe.functor=ACT...*ŽRÁTSE:id:blu-v-žrát-se-1~impf:žrátse+ACT(1;obl)CAUS(7,pro+4;typ)#
# END ========== ../data-txt/v-vallex.txt ========== END$vallex-cli-iv-vallex.json--histogramframe.functor--grepframe.functor=ACT...NTT(186/17819)DPHR*(286/17819)DIR1*(286/17819)MANN*(325/17819)ORIG*(382/17819)DIR**(484/17819)EFF***(601/17819)LOC***(606/17819)DIR3***(610/17819)BEN***(637/17819)ADDR***(731/17819)MEANS****(809/17819)PAT************************(4836/17819)ACT*******************************(6176/17819)Installing the command-line toolsUnixWe suggest using thepipxorpipsiscript installers:$python3-mpipinstall--userpipx$python3-mpipxensurepath$pipxinstallvallex-toolsAlternatively, just create a Python3 virtualenv and run vallex-tools from there:$python3-mvirtualenv-p`whichpython3`venv$.venv/bin/activate(venv)$pipinstallvallex-toolsAssuming you usedpipxto install vallex-tools, you can get bash command completion forvallex-cli,
by putting the following line into your.bashrcor.bash_profile:eval$(pipxrunvallex-clicompletion)(Forpipsi, replacepipxwithpipsi. For the virtualenv, you need to first activate the virtualenv,
then run the eval with justvallex-cliinstead of pipx, and then deactivate the environment again).WindowsRun theinstall-win.ps1script in aPowerShellprompt. This script will download and install a Python interpretter intoC:\vallex-toolsand the it will use it to install thevallex-toolspackage. Finally, it will put a shortcut to run
thevallex-guion the desktop. Using this method, all configuration & logs will live in theC:\vallex-toolsdirectory. To change this directory, you can edit the script and change the
definition of the$install_pathvariable.ContributingPlease seeDeveloper documentationfor documentation describing how to set-up your environment for working on vallex-tools.
Package: valley
ValleyPython extensible schema validations and declarative syntax helpers.InstallationpipinstallvalleyGetting StartedimportvalleyasvclassAnimal(v.Schema):name=v.StringProperty(required=True)species=v.StringProperty(required=True)color=v.StringProperty(required=True)meal_type=v.StringProperty()age=v.IntegerProperty(required=True)frog=Animal(name='Kermit',species='frog',color='green',meal='carnivore',age=1)frog.validate()
Package: valleybackups
Command-line based AWS Glacier backup toolInstallationRunpip install valleybackupsUsageSee docs onhttp://valleybackups.readthedocs.org/Compile docsFirst make sure you havesphinxandsphinx-bootstrap-themepip
packages installed.Then cd into /docs and run make htmlAuthorMade with brains and love by Valley Works (http://www.valleyworks.us).
Support:valleybackups@valleyworks.usHow to contribute to ValleyBackupsWe welcome rockstars and ninja contributors like you.If you have any bug report, feature request, or any suggestion, please
open a new issue on GitHub.To submit hotfixes or features please create a pull request in GitHub.Repository:https://github.com/valleyworks/valleybackupsThank you!
Package: valleydata
# Valleydata# Getting StartedFirst you need to install a few necessary dependencies.* VirtualBox (https://www.virtualbox.org/).* Vagrant (https://www.vagrantup.com/).* Install Guest Additions plugin for Vagrant (`vagrant plugin install vagrant-vbguest`)If you already use Vagrant, please make sure you update your box before starting it, do it with `vagrant box update`.Then you can clone this project and run `vagrant up` at the root folder. After this finishes, `vagrant ssh` to get inside the vm. Note: if you already use vagrant, it wont hurt running `vagrant box update` so we use the latest version available.Packages included in the vm:* Python 3.5.2 with virtualenv.* Latest Nodejs installed with nvm.# Usage## MySqlYou can connect using cli or your favorite client using the following config:* Host: localhost* Port: 33061* User: root* Password: root## PythonRun `vagrant ssh` to get inside the VM, then you will need to make a new virtualenv and install the dependencies.After that you should be able to run `python test.py`# TestingRun `python test.py`# Usage## valleydata class```valleydata = valleydata(date_list=<list_of_dates>)```Note that `date_list` is a required parameter### Methods- **get_top_hours**: Returns a list of tuples ((str)hour, (int)occurrences) representing most active hours. For example:```[('03 PM', 5), ('09 PM', 5), ('01 PM', 4)]```- **get_top_weekdays**: Returns a list of tuples ((str)weekday, (int)ocurrences) representing most active weekdays. For example:```[('Saturday', 12), ('Sunday', 9), ('Tuesday', 7), ('Friday', 7), ('Monday', 6)]```- **get_ip_info**: Returns a dict with info about a valid ip address (uses `ipinfo.io` external api). For example:```{'loc': '45.5186,-73.5545','city': 'Montr\xe9al','country': 'CA','region': 'Quebec','hostname': '198-48-208-217.cpe.pppoe.ca','ip': u'198.48.208.217','org': u'AS5645 TekSavvy Solutions, Inc.','postal': u'H2L'}```## TextAnalyzer class```text_analyzer = TextAnalyzer(texts=<list_of_dicts>)```Note that `texts` is a required parameter and should have the following structure:```{'text': "string",'status': "string" (texts will be grouped by this string)}```### Methods- **most_used_words (group=string)**: Returns a list of tuples ((str)word, (int)occurrences). For example:```[(u'magni', 3), (u'praesentium', 3), (u'amet', 3), (u'quae', 2), (u'non', 2), (u'molestias', 2)]```- **get_group**: Returns a list of strings that belongs to the given group.- **get_ranking**: Returns a dict AND a int. The dict contains points for each group and the int indicates the total score. Currently the score goes up if the group is called `approved`, otherwise it will go down.
Package: valleydeight
ValleydeightPronounced like: "validate"[val-i-deyt]Effective dictionary and nested object validation for PythonLately, I've found myself writing many YAML-based config files.
Being able to quickly and easily put together a schema for these files has become helpful, and the existing options out there were proving awkward to me.The approach here is to work directly on the resulting python objects.
This allows the code here to be useful in many other situations, and to validate other types of markup easily (eg JSON, XML (?), pickled primitives, etc).Installationpip install --user valleydeightUsageTo be able to validate an object, you must build up a Validator.  Doing this is straight forward for most types.
There are currently many types of Validators implemented:Primitive types:Str,Int,Float,BoolLists of items:List,FixedListDictionaries of items:DictMixed types:ChoiceCustom objects:ObjectA validator that accepts everything:PassTo make a validator, simply instantiate one of the above classes, composing together the more complicated types where needed.
To use the validator call it with the object you wish to validate.For example, say we wish to check that we have a list of dictionaries where each dictionary has a string called "name" and a boolean called "on":importvalleydeightasvd# Build the validatorvalidator=vd.List(vd.Dict(name=vd.Str(),on=vd.Bool()))# Make a test object that should pass finetest_object=[dict(name="hello",on=True),dict(name="World",on=False)]parsed_object=validator(test_object)# Make a test object that will fail, since one of the elements has the wrong type:test_object=[dict(name="hello",on=True),dict(name="World",on=2018)]parsed_object=validator(test_object)# Raises ValidatorExceptionTheChoiceclass allows us to make complicated "custom" types:importvalleydeightasvd# Something like a pythonic Enum with mixed types:enum_t=vd.Choice("one",4,True)# A mixture of validator types:mix_t=vd.Choice(vd.Str(),vd.Dict(name=vd.Str(),value=vd.Pass()).opts(need_all_keys=True))# A mixture of specific values and generic typesmix_t=vd.Choice(10012,False,vd.Str(),vd.List(vd.Float()))The difference between aListand aFixedListis that aListallows an
arbitrary number of items, which must all be the same type (although this can
be aChoicetype), whereas aFixedListhas both a fixed length and specific types for each element.Example programFor an example program see the script in theexamples/directory on GitHub.
In addition the unit tests in thetests/directory might be informative.
Package: valleytext
=========
ValleyTextThis tool can be used to extract keywords from sentences without chunks or word boundaries (for example, Chinese).
It is based on trie tree optimized by AhoCorasick Automation.Installation::$ pip install valleytextUsageExtract keywords
>>> from valleytext import create_trie
>>> words_dict = {'设备': ['GPS', '设备']}
>>> extractor = create_trie(words_dict, False)
>>> extracts = extractor.extract_keywords_from_text('我有一台gps设备')
>>> extracts
>>> # [(4, 7, 'gps', '设备'), (7, 9, '设备', '设备')]LicenseThe project is licensed under the MIT license.
Package: valo-api
valo_apiValorant API Wrapper forhttps://github.com/Henrik-3/unofficial-valorant-apiInstallationpip install valo-apiIf you want to use the async functions, you need to install theaiohttppackage.pip install valo-api[async]DocumentationHostedThe documentation is hosted here:https://raimannma.github.io/ValorantAPI/From SourceAfter installing the package dependenciespip install -r requirements.txt, you can use the following commands to get the documentation:cd docs/ && make htmlOpen the index.html file in the docs/_build/html/ directory.
Package: valo-api-official
valo_api_officialValorant API WrapperInstallationpip install valo-api-officialDocumentationHostedThe documentation is hosted here:https://raimannma.github.io/ValorantAPIOfficial/From SourceAfter installing the package dependenciespip install -r requirements.txt, you can use the following commands to get the documentation:cd docs/ && make htmlOpen the index.html file in the docs/_build/html/ directory.
Package: valohai-cli
Valohai Command Line ClientThis is the command-line client for theValohaimachine learning IaaS platform.Installationvalohai-clisupports Python 3.8 and higher.If you still need to run on Python 3.5, version 0.13.0 was the last one to support it.
If you still need to run on Python 3.6, version 0.23.0 was the last one to support it.
If you still need to run on Python 3.7, version 0.25.0 was the last one to support it.System-wide or user-wide installation with pipxThe recommended way to installvalohai-clisystem-wide is to usepipx, an
utility to install and run Python applications in isolated environments.
(If you're familiar with Node.js'snpxtool, it's the same idea.)This ensures thatvalohai-cli's dependencies don't conflict with other Python packages.Once you have installed and configuredpipx(see the link above), you can$pipxinstallvalohai-cliand to upgrade it later on,$pipxupgradevalohai-cliSystem-wide or user-wide installation with pipYou can also installvalohai-clisystem-wide withpip,
but this may cause conflicts with other Python packages installed
system-wide or user-wide.$pip3install-Uvalohai-cliThe-Uflag ensures that any present version is upgraded, too.Installation in a virtual environmentIf you prefer to installvalohai-cliin a virtual environment, you can do so withpipas well.$python3-mvenvvenv
$sourcevenv/bin/activate
$pipinstall-Uvalohai-cliGetting StartedAfter you've installed the client,vhshould work and you should see a description
of commands.See thetutorial document!DevelopingDevelopment requires Python 3.10+; otherwise you'll get false positive type failures.
CI will run tests on older Python versions.To work on thevalohai-clicode: pull the repository, create and activate a virtualenv, then run:makedevThis installsvalohai-clias an "editable"vhcommand available in the virtualenv, but linked to
the working copy's source. That is, you can now edit the source undervalohai_cliin your working
directory, and try it out withvh.vh--help# Usage: vh [OPTIONS] COMMAND [ARGS]...To run lints, type checks and tests:# run linting and type checksmakelint# run testsmaketest
Package: valohai-wattson
Valohai Wattson 🔌⚡AboutWattson is a Python library for estimating cloud compute carbon emissions.It currently supports estimating emissions for a range of Amazon EC2 instances in a variety of regions.UsageYou can install this package with pip by runningpip install valohai-wattson.If you are currently using AWS instances, you can calculate the carbon emissions for your instances using the following code:from wattson import estiamte_carbon_emissions

training_emissions = estimate_carbon_emissions(
    instance_type='c4.2xlarge',
    region='us-east-1',
    hours=1,
    load_percentage=0.5,
)The returned value will be of the typewattson.EmissionsEstimationand have the following information:data_license: The license of the data used to estimate the emissions.region: The region the original computation was performed in.instance_type: The instance type of the original computation.avg_load: The average CPU load during the original computation (defaults to 50% if not specified).scope_2_co2eq: The estimated CO2 emissions for the electricity used in the original computation.scope_3_co2eq: The estimated CO2 emissions for manufacturing of the device used in the original computation, assuming a 4-year usage.compensated: Were any of the emissions of the original computation compensated using e.g. carbon emissions compensation or renewable energy credits.details: Any additional details about e.g. the compensation methodology.AcknowledgementsThis project uses theEC2 Carbon Emissions Dataset by Teads Engineering.LicensesThe library code isCopyright (c) 2022 Valohai, licensed under the MIT License.The Teads Engineering EC2 Carbon Emissions Dataset islicensed under the Creative Commons Attribution 4.0 International License.
Package: valohai-yaml
valohai-yamlParses and validatesvalohai.yamlfiles.Valohai YAML files are used to define how your machine learning project workloads and pipelines are ran on theValohaiecosystem. Refer toValohai Documentationto learn how to write the actual YAML files and for more in-depth usage examples.Installationpipinstallvalohai-yamlUsageValidationProgrammatic usage:fromvalohai_yamlimportvalidate,ValidationErrorstry:withopen('path/to/valohai.yaml')asf:validate(f)exceptValidationErrorsaserrors:print('oh no!')forerrinerrors:print(err)Command-line usage:valohai-yamlmy_yaml.yamlecho$?# 1 if errors, 0 if okParsingfromvalohai_yamlimportparsewithopen('path/to/valohai.yaml')asf:config=parse(f)print(config.steps['cool step'].command)Development# setup development dependenciesmakedev# run linting and type checksmakelint# run testsmaketest
Package: valorant
valorant.pyvalorant.pyis an unofficial API wrapper for Riot Games' Valorant API endpoints. It's modern, easy to use, feature-rich, and intuitive!FeaturesSimple:High-level abstraction of API interactions; easy to use and easy to customize.Lightweight:Doesn't rely on any external dependencies, minimal package size.Extensive:Covers all Valorant related endpoints from the Riot Games API. Also includes Account coverage.Fast:HTTP requests and object instancing optimized to use minimal resources and complete tasks quickly!Intuitive:Complete auto-completion, docstrings, and type-hinting for all library objects and variables.Installationvalorant.pyrequires Python 3.8 or higher.ManagerCommandPIPpip install valorantPoetrypoetry add valorantUsageTake a look at theexamples/folder for more usage snippets!Quickstart:importvalorantKEY="RGAPI-Key-Here"client=valorant.Client(KEY)agents=client.get_characters()print(agents.get("Viper"))Local Client:importvalorantclient=valorant.LocalClient()print(client.get_session())NOTE:The Local Client interacts with the Client API that Valorant uses while the game is running on your system. This means access to current player, friend requests, shop, etc. The Local Client is currently unstable.valorant.pyis not liable for any punishment you may recieve should you use its tools to break Valorant ToS. (i.e Auto-Agent Selection)DocumentationThe public API documentation forvalorant.pyis hosted onReadTheDocs.io.Usebash bin/docsto start the documentation server locally. This uses Ruby'sWEBrickgem.Help and QuestionsHave a bug or issue? Need help with the API? Open anissueor hop in the#valorant-pychannel of the Frisscraft Community Discord Server.ContributingHead over to theContributing Guidepage.
Package: valorant-api
valorant-apiA Python wrapper for valorant-api.comInstallationpip install valorant-apiUsages# this code is just for referencefromvalorant_apiimportSyncValorantApi,AsyncValorantApi#syncapi=SyncValorantApi(language="ru-RU")agents=api.get_agents()#Asyncapi=AsyncValorantApi(language="ru-Ru")agents=awaitapi.get_agents()# searchingagent=agents.find_where(displayname="Raze",developerName="Gumshoe")agent=agents.find_first(displayname="Raze")# agents image generationfromvalorant_apiimportgeneratorsfont_file=r"valorant_api\fonts\Valorant Font.ttf"# initialize classgenerator=generators.AgentImageGenerator(font_file)# generator actual imageimage=awaitgenerator.generate(agent)# save the imageimage.save("image.png","PNG")Agents Image ExampleRequirementspython-dateutilaiohttprequestsPillow
Package: valorant.py
valorantA modern, easy to use, feature-rich, and async ready API wrapper for Valorant API written in Python.Key FeaturesModern Pythonic API usingasyncandawait.InstallingPython 3.8 or higher is requiredWindows:$ pip install -U valorant.pyLinux/MacOS:$ python3 -m pip install -U valorant.pyQuick Exampleimportasyncioimportvalorantasyncdefmain():client=valorant.Client(valorant.Locale.thai)# set default locale to thaiasyncwithclient:weapon=client.get_weapon('9c82e19d-4575-0200-1a81-3eacf00cf872')# VandalassertweaponisnotNoneforskininweapon.skins:print(skin.display_name)# default localeprint(skin.display_icon)# specify localeprint(skin.display_name.ja_JP)print(skin.display_name.japanese)print(skin.display_name.from_locale(valorant.Locale.japanese))ifskin.themeisnotNone:print(skin.theme.display_name)print(skin.theme.display_icon)ifskin.content_tierisnotNone:print(skin.content_tier.display_name)print(skin.content_tier.display_icon)forlevelinskin.levels:print(level.display_name)forchromainskin.chromas:print(chroma.display_name)asyncio.run(main())LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.Project inspired bydiscord.pythe Discord API wrapper for Python.LinksValorant APIOfficial Discord Server
Package: valorum
This package provides a simplified interface to datasets that we use
frequently.Loading dataTo see a list of available datasets runimportvalorumvalorum.data.available()To load one of the listed datasets rundf=valorum.data.load("dataset_name")wheredataset_nameis replaced by one of the names returned byvalorum.data.available().When you first load a dataset, valorum will fetch the data from
somewhere online. It will then save a local copy of the data to your
hard drive. Subsequent requests to load a dataset (even in different
python sessions) will first attempt to load the data from your hard
drive and only fetch from online if necessary.ConfigurationThe valorum library is configurable. Below is a listing of available
configuration options.To see a list of valid configuration options runimportvalorumvalorum.data.config.describe_options()To set a configuration usevalourm.data.options[section.option] = value.For example, to set the configuration option for the BLS api_key I would
call:importvalorumvalorum.data.options["bls.api_key"]="MY_API_KEY"Developer docsContributing datasetsTo contribute a dataset you need to implement a function_retrieve_{name}inside the filedata/retrieve.py. This function
is responsible for obtaining the data either “by hand” (data hard coded
into the function) or from online. The function must return a pandas
DataFrame with the data.
Package: valory-docker-compose
Docker ComposeDocker Compose is a tool for running multi-container applications on Docker
defined using theCompose file format.
A Compose file is used to define how the one or more containers that make up
your application are configured.
Once you have a Compose file, you can create and start your application with a
single command:docker-compose up.Compose files can be used to deploy applications locally, or to the cloud onAmazon ECSorMicrosoft ACIusing
the Docker CLI. You can read more about how to do this:Compose for Amazon ECSCompose for Microsoft ACIWhere to get Docker ComposeWindows and macOSDocker Compose is included inDocker Desktopfor Windows and macOS.LinuxYou can download Docker Compose binaries from therelease pageon this repository.Using pipIf your platform is not supported, you can download Docker Compose usingpip:pip install docker-composeNote:Docker Compose requires Python 3.6 or later.Quick StartUsing Docker Compose is basically a three-step process:Define your app's environment with aDockerfileso it can be
reproduced anywhere.Define the services that make up your app indocker-compose.ymlso
they can be run together in an isolated environment.Lastly, rundocker-compose upand Compose will start and run your entire
app.A Compose file looks like this:services:web:build:.ports:-"5000:5000"volumes:-.:/coderedis:image:redisYou can find examples of Compose applications in ourAwesome Compose repository.For more information about the Compose format, see theCompose file reference.ContributingWant to help develop Docker Compose? Check out ourcontributing documentation.If you find an issue, please report it on theissue tracker.ReleasingReleases are built by maintainers, following an outline of therelease process.