Saravanan666/pypi-org huggingface dataset:
Package: viperdb
ViperDBViperDB is a lightweight embedded key-value store written in pure Python.
It has been designed for being extremely simple while efficient.Featurestiny: the main db file consists of just ~300 lines of code.highly coverage: thanks to the small codebase, every single line of code is tested.log-structured: ViperDB takes design concepts by log-structured databases such asBitcask.written in pure Python: no external dependency needed.Database layoutViperDB simply consists of two files: akey log fileand avalue log file.
The first is used to maintain information about values (e.g. offset, size, etc...) which are actually stored in the value log.
This layout allows to speed-up db initialization, which consists in loading the pointers to the entire key-space from the key-file to a dictionary.
For simplicity, the key file is treated as a text file, with each line containing a json-encoded entry.
The value file is viewed as a raw sequence of bytes. Before being written to the value file, each value is encoded according to the following scheme:
builtin types (except for thebytestype) are json-encoded, while user-defined classes are pickled.To keep logic simple, no automatic compaction is performed in the background: unused space must be reclaimed explicitly through thereclaimfunction.API usagefromviperdbimportViperDBdb=ViperDB('./db')# db can be used as a simple dictionarydb['hello']='ViperDB!'assertdb['hello']=='ViperDB'deldb['hello']assert'hello'notindbdb.reclaim()# call this method periodically to free unused space.db.close()# flush any pending write and close the database.ContributeViperDB is a very recent project and, as such, it comes with no warranty.
If you find any bug, or have some suggestion, feel free to contribute by opening a new issue or making a pull request.
Package: viper-df
viperSimple, expressive pipeline syntax to transform and manipulate data with easeOverviewviperis a Python package that provides a simple, expressive way to work with data. It allows you to easily manipulate and transform data using a pipeline syntax similar to that ofdplyr.Pipelining your DataFrame manipulation operations offers several benefits:improved code readability (no need to 'comment the what')no need to save intermediate dataframesability to chain a long sequence of operations in a single commandthinking of coding as a series of transformations between the input and the desired output can improve the design and make it less coupledDocsComplete documentation and reference are available on the package'ssite.Quick StartInstallation:pipinstallviper-dfHere is an example of how to useviperto analyze the famedmtcarsdataset.We want to find:the average consumption, expressed in Miles/(US) gallonthe average powerFurthermore:only consider those cars that weigh more than 2000lbsgroup the results by the number of cylinders and number of gearsarrange in descending orders by the grouping variablesimportviperasvfromviper.dataimportmtcarsv.pipeline(mtcars,v.rename("hp = power","mpg = consumption",),v.mutate(consumption=lambdar:1/r["consumption"]),v.filter(lambdar:r["wt"]>2),v.group_by("cyl","gear"),v.summarize("power = mean()","consumption = mean()"),v.arrange("cyl desc","gear desc"),)#                power  consumption# cyl gear# 8   5     299.500000     0.064979#     3     194.166667     0.068824# 6   5     175.000000     0.050761#     4     116.500000     0.050875#     3     107.500000     0.050989# 4   5      91.000000     0.038462#     4      85.000000     0.041259#     3      97.000000     0.046512Hereyou can find more examples, particularly on joins.RoadmapThe future development of the package will probably focus on:addingpivot_longerandpivot_widerfunctionsadding morejoin_*functionsContributionsYou are welcome to contribute to the project or openissuesif you have any ideas.
Package: viper-ic
ViperA hybrid integrated circuit design environment (ICDE) with extensions for both open-source and proprietary design toolsStill under development and not ready for regular usageExplore the docs »Discuss·Report Bug·Request FeatureOverviewViper is an open integrated circuit design environment.  It supports design
workflows with both free and proprietary software tools.  It also natively
supports software-based circuit design flows in addition to
traditional flows.It supports both open source tools andCadence Virtuosowith theVirtuepackage.Project Manager GUISeeissue #5Environment ManagerIt has a circuit design package and environment manager that makes it easy
to install packages and create additional environments so the environment can
be customized to the needs of every team and every project.viper-forgeis developing a set of
viper packages.Getting StartedSetup a new machine or site using theinstall script.ContributingAll development planning happens inGitHub issuesandGitHub discussions.If you see an issue of interest, first check to see if there is an existing
branch named after its issue number.  Then feel free to comment on the issue
and hopefully submit a pull request with your update.For more general questions or if you're looking for guidance on getting
started, post inGitHub discussions.Cadence Virtuoso SupportCadence Virtuoso is supported with theVirtuepackage.Command Line Interfacessp: "start project" Opens a Viper project.
Run "sp --help" for more details
Package: viper-infra-commander
Viper provides a simple API (Python and CLI) to easily manage large infrastructures.Getting StartedInstallationpipinstall-Uviper-infra-commander# Or install with batteries includedpipinstall-U"viper-infra-commander[batteries]"Initialization# (Optional) enable tab completioneval"$(viperautocomplete$(basename$SHELL))"# See the help menuviper-h# Initialize SQLite DBviperinit-fViper in Action (Basic Mode)Define a set of hosts in csv format (json and yml are also supported) inhosts.csv:cat>hosts.csv<<EOFip,hostname,login_name,identity_file
192.168.0.11,host11,root,/root/.ssh/id_rsa.pub
192.168.0.12,host12,root,/root/.ssh/id_rsa.pub
192.168.0.13,host13,root,/root/.ssh/id_rsa.pub
192.168.0.14,host14,root,/root/.ssh/id_rsa.pub
192.168.0.15,host15,root,/root/.ssh/id_rsa.pubEOFDefine a task intask.py:cat>task.py<<EOFfromviperimportTaskdefping_command(host):return"ping","-c","1",host.ipdefping():returnTask(name="Ping once",command_factory=ping_command)EOFPerform the following actions:Run the task on the set of hosts in parallel with 5 workers,filter only the results where the task failed,re-run the task on them,store the results in DBviperhosts:from-filehosts.csv\|viperhosts:run-tasktask.ping--max-worker5\|viperresults:wherereturncodeIS_NOT0\|viperresults:re-run--indent4See the stdout of the final results from DB:viperresults\|viperresults:final\|viperresults:format"{host.hostname}: {stdout}"Export the results to a csv file:viperresults--final\|viperresults:to-fileresults.csv--indent4Define a job using the Python API (CLI and Python API are almost similar):cat>job.py<<EOFfromviperimportWhereConditionsfromtaskimportpingdefping_and_export(hosts):return(hosts.task(ping()).run(max_workers=5).final().to_file("results.csv"))EOFRun the job using CLI:viperhosts:from-filehosts.csv\|viperrunjob.ping_and_export\|viperresults:format"{host.hostname}: {stdout}"Viperfile in Action (Advanced Mode)Define a project with custom subcommands in viperfile:cat>viperfile.py<<EOFfromviperimportHosts,Taskfromviper.projectimportProject,argfoo=Project(prefix="foo")@foo.hostgroup(args=[arg("-f","--file",default="hosts.csv")])defallhosts(args):returnHosts.from_file(args.file)defremote_exec_command(host,command):return("ssh","-i",host.identity_file,"-l",host.login_name,"-p",str(host.port),"-o","StrictHostKeyChecking=no","-o","PubkeyAuthentication=yes",host.ip,command,)@foo.job(args=[arg("command",help="command to execute"),arg("-w","--workers",type=int,default=1),])defremote_exec(hosts,args):return(hosts.task(Task(name="Remote execute command",command_factory=remote_exec_command,timeout=5,),args.command,).run(max_workers=args.workers).final())EOFSee the auto generated custom subcommands:viper--helpRun the job:viper@foo:allhosts\|viper@foo:remote_exec"uname -a"--workers5\|viperresults:to-fileresults.csv\|viperresults:format"{task.name} [{host.hostname}]: {returncode}: {stdout}"Further ReadingsAPI Docs with Examples ☞https://viper-infra-commander.netlify.comContributing To ViperContribution Guidelines ☞https://github.com/sayanarijit/viper/blob/master/CONTRIBUTING.md
Package: viper-in-python
This Scanpy-compatible package provides the Interactome class to easily allow the user to both load and interact with ARACNe networks. Once these networks have been loaded, the user has the option to filter regulators, filter targets, and prune the network. The user can then give their Interactome (or multiple Interactomes) and a gene expression signature to Pyviper function to either run VIPER or NaRnEA to infer protein activity. This package also provides the option to compute pathway enrichment with Interactomes built from sets of pathways from MSigDB.
Package: viper-lib
ViperA Python library full of useful Python tools.Viper adds many missing tools and improves many existing tools in Python.
For example, this includes frozendicts, a more advanced IO interface, improved ABCs, debugging tools, new decorators, types of classes, even new types of modules, etc.
It is designed to feel very Python-like.To list all of the available packages, simply Python's interactive prompt and explore:>>> from Viper import *
>>> import Viper
>>> dir(Viper)
['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', 'abc', 'debugging', 'exceptions', 'format', 'frozendict', 'interactive', 'io', 'meta', 'pickle_utils', 'warnings']
>>> help(io)
Help on module Viper.io in Viper:

NAME
    Viper.io - This module adds some useful IO tools. This includes IO buffer and pipe/circular buffers for both bytes and strings.

CLASSES
    Viper.abc.io.BytesIO(Viper.abc.io.BytesReader, Viper.abc.io.BytesWriter, Viper.abc.io.IO)
        BytesBuffer
        BytesIO
    Viper.abc.io.StringIO(Viper.abc.io.StringReader, Viper.abc.io.StringWriter, Viper.abc.io.IO)
        StringBuffer
        StringIO

    class BytesBuffer(Viper.abc.io.BytesIO)
...Some practical and classical examples of the content of Viper include:Making iterable classes:>>> class MyClass(metaclass = Viper.meta.iterable.InstanceReferencingClass):
...     pass
... 
>>> c = MyClass()
>>> list(MyClass)[0] is c
True
>>> del c
>>> len(list(MyClass))
0This is useful for classes for which you want to keep track of the instances or for which you need to perform some operations on.Timing function calls and generate performance reports:>>> c = Viper.debugging.chrono.Chrono()
>>> @c
... def fibo(n):
...     if n <= 0:
...         return 0
...     if n == 1:
...         return 1
...     return fibo(n - 1) + fibo(n - 2)
...
>>> fibo(25)
75025
>>> Viper.debugging.chrono.print_report(c)
Execution report featuring 1 functions or methods, over 375ms.
Per function results :
Function __main__.fibo
        Calls : 242785, Total :   375ms   , Average : 1µs, 545ns, Proportion : 100.0% of the timeYou can use one Chrono object on multiple functions. It becomes useful if you need to know what part of your code you should optimize first.Flux operators:>>> buffer = Viper.io.BytesIO()
>>> buffer << Viper.pickle_utils.StreamPickler("This is a test object")
>>> buffer.seek(0)
0
>>> Viper.pickle_utils.StreamUnpickler() << buffer
'This is a test object'Flux operator define a much stronger, safer and handy interface than Python IOs. Furthermore, this syntax is revertible and stackable for constants:>>> buffer = Viper.io.StringIO()
>>> "Good!\n" >> (buffer << "Hello!\n" << "How are you doing?\n")
<Viper.io.StringIO object at 0x000002A2F862E4A0>
>>> buffer.seek(0)
0
>>> buffer.readable
Budget(32)
>>> print(buffer.read(buffer.readable.value))
Hello!
How are you doing?
Good!And many other useful random features!Note that this library is extensively documented. Use Python's help system (for example the help function while in an interactive interpreter) to learn how to use all the modules and classes.
Package: viper-test
viperSimple, expressive pipeline syntax to transform and manipulate data with easeOverviewviperis a Python package that provides a simple, expressive way to work with data. It allows you to easily manipulate and transform data using a pipeline syntax similar to that ofdplyr.Pipelining your DataFrame manipulation operations offers several benefits:improved code readability (no need to 'comment the what')no need to save intermediate dataframesability to chain a long sequence of operations in a single commandthinking of coding as a series of transformations between the input and the desired output can improve the design and make it less coupledDocsComplete documentation and reference are available on the package's site.Quick StartInstallation:pipinstallviperHere is an example of how to useviperto analyze the famedmtcarsdataset.We want to find:the average consumption, expressed in Miles/(US) gallonthe average powerFurthermore:only consider those cars that weigh more than 2000lbsgroup the results by the number of cylinders and number of gearsarrange in descending orders by the grouping variablesfromviper.mainimport*fromviper.dataimportmtcarspipeline(mtcars,rename("hp = power","mpg = consumption",),mutate(consumption=lambdar:1/r["consumption"]),filter(lambdar:r["wt"]>2),group_by("cyl","gear"),summarize("power = mean()","consumption = mean()"),arrange("cyl desc","gear desc"),)#                power  consumption# cyl gear# 8   5     299.500000     0.064979#     3     194.166667     0.068824# 6   5     175.000000     0.050761#     4     116.500000     0.050875#     3     107.500000     0.050989# 4   5      91.000000     0.038462#     4      85.000000     0.041259#     3      97.000000     0.046512Here you can find more examples, particularly on joins.RoadmapThe future development of the package will probably focus on:addingpivot_longerandpivot_widerfunctionsadding morejoin_*functionsContributionsYou are welcome to contribute to the project or openissuesif you have any ideas.
Package: viperthon
viperthonIt will read different datafile and perform basic operation with just one clickInstallationpip install viperthonExamplefrom viperthon import load
load("D:\data science\ineuron\ML\ML\class\Admission_Prediction.csv")LicenseÂ© 2021 Swati PandeyThis repository is licensed under the MIT License.
See LICENSE for details.
Package: viper-thonix
viperthonixIt will read different datafile and perform basic operation with just one clickInstallationpip install viper-thonixExamplefrom viper-thonix import load
load("D:\data science\ML\ML\class\Admission_Prediction.csv")LicenseÂ© 2021 Swati PandeyThis repository is licensed under the MIT License.
See LICENSE for details.
Package: vipes
VipesWhat is Vipes?Vipes is a complete script manager, it helps you to manage your development workflow by providing you with the ability to add, remove and update custom scripts. Viper is crossplatform, that means you can use it on any operating system that supports python as long as you configure it to do so.How to install Vipes?To install Vipes, you need to use the following command:pipinstallvipes
Package: viphoneme
Project Custom from vPhon for convert Raw text to IPAUse for embeding TTS model using Tacotron2/Fastspeech2 ...By using IPA, tacotron2 can deal with cases cross language as a proposal from futre paperFunction include: Convert Grapheme to IPA, List same token output, normalize text with vinorm and wordtokenRequirment: vinorm, underthesea, eng_to_ipapip install vinorm
pip install underthesea
pip install eng_to_ipaInstall viphoneme by pippip install viphonemeUsage:fromviphonemeimportvi2IPAphoneme=vi2IPA("Được viết vào 6/4/2020, có thể xử lí những trường hợp chứa English")>>dɯək6viət5vaw2ʂăw5tʰaŋ5bon5năm1haj1ŋin2xoŋ͡m1ʈăm1haj1_mɯəj1,kɔ5_tʰe4sɯ4_li5ɲɯŋ3ʈɯəŋ2_hɤp6cɯə5ˈɪŋlɪʃFunction to convert to phoneme with option split each elementfromviphonemeimportvi2IPA_splitdelimit="/"vi2IPA_split("Được viết vào 6/4/2020, có thể xử lí những trường hợp chứa English",delimit)>>/d/ɯə/k/6//v/iə/t/5//v/a/w/2//ʂ/ă/w/5//tʰ/a/ŋ/5//b/o/n/5//n/ă/m/1//h/a/j/1//ŋ/i/n/2//x/o/ŋ͡m/1//ʈ/ă/m/1//h/a/j/1/_/m/ɯə/j/1//,//k/ɔ/5/_/tʰ/e/4//s/ɯ/4/_/l/i/5//ɲ/ɯ/ŋ/3//ʈ/ɯə/ŋ/2/_/h/ɤ/p/6//c/ɯə/5//ɪ/ŋ/l/ɪ/ʃ//./Parsing, split phoneme element, with listParse is list of avaible symbol, delimit is symbol to split each elementParsing(listParse,text,delimit)Get list of symbol using for represent phonemefromviphonemeimportsymsprint(syms)Star me if you find it interesting :))Cite me if you use it for paper :)):@inproceedings{tri2020vietnamese,
  title={Vietnamese Speech Synthesis with End-to-End Model and Text Normalization},
  author={Tri, Nguyen Minh and Nam, Cao Xuan and others},
  booktitle={2020 7th NAFOSTED Conference on Information and Computer Science (NICS)},
  pages={179--184},
  year={2020},
  organization={IEEE}
}This is for quick using to test TTS model in Vietnamese, there is too much more task to use it for production, such as OOV (You can handle it by using MFA from Kaldi or Transformer Aligner)Montreal-Forced-Aligner:https://github.com/MontrealCorpusTools/Montreal-Forced-Aligner
Package: vipickle
👑 VIPpickleTiny python package for saving instances with unpickable attributesQuickstartInstallvipicklewith pip :pipinstallvipickleThen inherit fromVIPicklableand define which attribute are not picklable and how they should be dumped and restored.importtorchfromtorchvisionimportmodelsfrompathlibimportPathfromvipickleimportVIPicklableclassMyClass(VIPicklable):PICKLE_BLACKLIST=["vision_model"]def__init__(self):self.vision_model=models.vgg16(weights='IMAGENET1K_V1')def_dump_vision_model_(self,save_dir:Path,overwrite:bool=True):model_weights_path=save_dir/"model_weights.pth"ifoverwriteornotmodel_weights_path.exists():torch.save(model.state_dict(),model_weights_path)def_restore_vision_model_(self,save_dir:Path):self.vision_model=models.vgg16()self.vision_model.load_state_dict(torch.load(save_dir/"model_weights.pth"))# Create an instanceobj=Myclass()# train could modify the model weightsobj.train()# we save the instance to a folder, _dump_vision_model_ will dump the weights in the folderobj.save("a/folder")delobj# we can then reload the object, _restore_vision_model_ will recreate the attribute vision_model and load the weightsobj=MyClass.load("a/folder")obj.vision_model.eval()Additionnal dependenciesDev dependenciespipinstallvipickle[dev]Unit tests dependenciespipinstallvipickle[test]Documentation dependenciespipinstallvipickle[doc]
Package: vippool-storage
vippool-storageThis project provides a library to access the vippool-clerk service, which was run by VIPPOOL Corp.,
and let you use Python to easily write to and read from the MonaCoin blockchain.The vippool-clerk service is not in operation at this time.
You will need to set up your own server.FeaturesConsult the current balance of a coin-address for your private key.Send coins to some other coin-address, from a coin-address for your private key.Write arbitrary data to the blockchain. (requires a separate transaction fee)Read arbitrary data from the blockchain.InstallingYou can use pip to install the python package:$ pip install vippool_storageUsagePlease see the filesample.pyas an example.ContactFor asking for information, request features, or submit bug reports; please use the Github "issues" page.https://github.com/vippool/storage/issuesYou can also send an email to our developers:dev-team@vippool.netLicense(C) 2019-2022 VIPPOOL Inc.This project is published under the MIT license.
Package: vipr-data
ViPR Data Services is the next generation software defined storage solution that layers cloud data types over traditional storage arrays. It transforms existing data into cloud data enabling new access patterns for modern applications. ViPR leverages and extends capabilities of the underlying storage devices to provide enterprise grade private cloud storage.This SDK provides convenient access to the S3 API extensions that ViPR Data Services provides to enhance the object storage experience, such as NFS file access to a bucket.
Package: vips-abi
# Ethereum Contract[![Build Status](https://circleci.com/gh/ethereum/eth-abi.svg?style=shield)](https://circleci.com/gh/ethereum/eth-abi)
[![Documentation Status](https://readthedocs.org/projects/eth-abi/badge/?version=latest)](https://readthedocs.org/projects/eth-abi/?badge=latest)
[![PyPi version](https://img.shields.io/pypi/v/eth-abi.svg)](https://pypi.python.org/pypi/eth-abi)Python utilities for working with the Ethereum ABI## Installation`sh pip installeth-abi`## DocumentationFor documentation, visit [https://eth-abi.readthedocs.io/en/latest/](https://eth-abi.readthedocs.io/en/latest/).## DevelopmentClone the repository and then run:`sh pip install-e.[dev] `You might want to do this inside a virtualenv.### Running the testsYou can run the tests with:`sh py.test tests `Or you can installtoxto run the full test suite.### ReleasingPandoc is required for transforming the markdown README to the proper format to
render correctly on pypi.For Debian-like systems:` apt install pandoc `Or on OSX:`sh brew install pandoc `To release a new version:`sh make releasebump=$$VERSION_PART_TO_BUMP$$`#### How to bumpversionThe version format for this repo is{major}.{minor}.{patch}for stable, and{major}.{minor}.{patch}-{stage}.{devnum}for unstable (stagecan be alpha or beta).To issue the next version in line, specify which part to bump,
likemake release bump=minorormake release bump=devnum.If you are in a beta version,make release bump=stagewill switch to a stable.To issue an unstable version when the current version is stable, specify the
new version explicitly, likemake release bump=”–new-version 4.0.0-alpha.1 devnum”
Package: vipster
VIsual Periodic STructure EditoRMaster branch:Testing branch:Fast and easy to use graphical editor for periodic atomistic simulations.
For more information, please visit theHomepage.Binary releases are availablehere,
installation instructions can be foundhere.Last but not least, a (sadly, feature-reduced) browser version can be triedhere!LibvipsterC++17 based backbone: Powerful container-classes and I/OFast and native GUI with OGL3.3 based renderingPortable browser-based GUI, shared render-codeScripting interface for batch-processingDependencies:JSON for Modern C++CLI11tinyexprCMake{fmt}and a C++17-capable compiler (g++ > 8 or clang > 4)optional:Qt5(desktop application)emscripten(web interface)pybind11(script interface)Catch2(testing)LAMMPS(interactive forcefield calculations)Supported file types:FormatReadingWritingxyz (augmented)✔✔PWScf input✔✔PWScf output✔LAMMPS data✔✔LAMMPS dump✔CPMD input✔✔Gaussian cube✔XCrysden✔ORCA input✔✔VASP Poscar✔✔