Saravanan666/pypi-org huggingface dataset:
Package: vggish-keras
VGGish: A VGG-like audio classification modelThis repository provides a VGGish model, implemented in Keras with tensorflow backend (sincetf.slimisdeprecated, I think we should have an up-to-date interface). This repository is developed
based on the model forAudioSet.
For more details, please visit theslim version.Installpipinstallvggish-kerasWeights will be downloaded the first time they are requested. You can also runpython -m vggish_keras.download_helpers.download_weightswhich will download them.UsageBasic - simple & efficient method:importlibrosaimportnumpyasnpimportvggish_kerasasvgk# loads the model once and provides a simple function that takes in `filename` or `y, sr`compute=vgk.get_embedding_function(hop_duration=0.25)# model, pump, and sampler are available as attributescompute.model.summary()# take a peak at the model# compute from filenameZ,ts=compute(librosa.util.example_audio_file())# compute from pcmy,sr=librosa.load(librosa.util.example_audio_file())Z,ts=compute(y=y,sr=sr)Alternatives - using the under-the-hood helper functions:# get the embeddings - WARNING: it instantiates a new model each timeZ,ts=vgk.get_embeddings(librosa.util.example_audio_file(),hop_duration=0.25)# create model, pump, sampler once and pass to vgk.get_embeddings# - more typing :'(model,pump,sampler=vgk.get_embedding_model(hop_duration=0.25)Z,ts=vgk.get_embeddings(librosa.util.example_audio_file(),model=model,pump=pump,sampler=sampler)Manually, using the keras model and pump directly:importlibrosaimportnumpyasnpimportvggish_kerasasvgk# define the modelpump=vgk.get_pump()model=vgk.VGGish(pump)sampler=vgk.get_sampler(pump)# transform audio into VGGish embeddingsfilename=librosa.util.example_audio_file()X=np.concatenate([x[vgk.params.PUMP_INPUT]forxinsampler(pump(filename))])Z=model.predict(X)# calculate timestampsts=vgk.get_timesteps(Z,pump,sampler)assertZ.shape==(13,512)Reference:Gemmeke, J. et. al.,AudioSet: An ontology and human-labelled dataset for audio events,
ICASSP 2017Hershey, S. et. al.,CNN Architectures for Large-Scale Audio Classification,
ICASSP 2017I include a weight conversion script indownload_helpers/convert_ckpt.pywhich shows how I converted the weights from.ckptto.h5forthosethat are interested.TODOcurrently, parameters (sample rate, hop size, etc) can be changed globally viavgk.params- I'd like to allow for parameter overrides to be passed tovgk.VGGishcurrently it relies onhttps://github.com/bmcfee/pumpp/pull/123. Once merged, remove custom github install location
Package: vgif
Programmatically generate animated GIF from video in PythonWith this video2gif converter you can upload any format of video and rich media files to turn them into high quality animated GIFs.Getting Started1. Installpip Installpip install vgif-Usource InstallClone this repositoryRun setup from the repository root directorypython3 setup.py install2. Start UP🅶 GUIStart interface:vgif-guiSelect video fileSet optionsClick button “Start” to startOnce started converter will save the output under the same folder ad source videoClick button “ReStart” to re-start this processClick button “Exit” to end this program.The options includes:Video Sample Rate : (default sample every 10 frame)Output GIF FPS: Set output GIF fps(default 10 fps)Video Resize Rate: Shrink video n times smaller (default 2 times smaller)🅲 CMDUsagevgif [OPTIONS]::

   Converts video to GIF.

Options:
   -i, --input PATH         input video file
   -o, --output TEXT        output gif file path and name.
   -s, --scale INTEGER      Scale the factor for frame_x and frame_y.
   -r, --resolution TEXT    The resolution factor for factor ( For Compress ),
                     like 1920x1080.

   -fps, --gif-fps INTEGER  The fps of the GIF.
   --help                   Show this message and exit.Just Give the Input:vgif -i /myLocalDir/myVideo.mov

This will generate the GIF with the same name to the same directory as the original file.Give the file path for out.:vgif -i /myLocalDir/myVideo.mov -o /some_dir/out.gif
Package: vgio
vgiovgio is a Python package for video game file I/OMissionPythonic:Clean and well written Python.Domain-specific:The APIs and objects reflect the source code and community knowledge.Complete:Support as many file types as possible.Robust:The APIs and objects are thoroughly unit tested.Supported GamesDevil DaggersDuke Nukem 3DHexen IIHROTQuakeQuake IIInstallation$ pip install vgioUsagefromvgio.quake.bspimportBspwithBsp.open('./maps/start.bsp')asbsp_file:"""Do rad stuff with the BSP data structure!"""DocumentationAPI documentation is available onreadthedocs.Tests$ python -m unittest discoverLicenseMITSee thelicensedocument for the full text.
Package: vgmusic
vgmusic.py(unofficial) Python API forVGMusic.
This project is in no way affiliated with or sponsered by Mike Newman or any of the staff at VGMusic.Cachesvgmusic.py relies heavily on caches to avoid downloading VGMusic pages repeatedly; the CLI auto-caches for you into acache.jsonfile.An example of a cache file is at the root of this repo; it is a pre-parsed full dump of info
(direct links, authors, etc.) on all the songs currently on VGMusic.
It weighs in at 8.5 MB as JSON (6 MB without indentation).UsageThoughout these examples, we will be using theAPIobject as the api:importvgmusicapi=vgmusic.API()It is recommended to close it once you are done:# do something here...api.close()The best way is to use acontext manager, a.k.awithstatement:withvgmusic.API()asapi:# do something hereNote that the API is lazy: It will only retrieve data for a console/system the first time it is queried for it.
To override this behaviour, useforce_cache(seeModule Documentation).Module DocumentationSeeAPI.md.CLIThe command-line interface can be used to download MIDI files concurrently (useful for scripting).Make sure to install the CLI extra first:pip install vgmusic[cli]For more info on how to use the cli, runvgmusic --help.RESTInstall the rest extension:pip install vgmusic[rest]and start the server withpython3 -m vgmusic.rest.For docs, visithereonce you've started the server.LicenseMIT.
Package: vgn
VGNAsynchron Python API for theVerkehrsverbund Grossraum Nuernberg (VGN).Uses the officialREST-APIto query realtime public transport information for Nuremberg.With the python 3.7 featureasyncio tasksfast and non-blocking querries are possible.Read the docsfor more information.Consider installingcchardetandaiodnsvia pip for speedup (see theaiohttp documentation).Exampleimportvgnimportasyncioasyncdefmain():asyncwithVGNClient()asvgn_client:res=awaitasyncio.gather(vgn_client.api_version(),vgn_client.all_stations(),vgn_client.departure_schedule(704),vgn_client.departure_schedule_for_line(704,"U2"),vgn_client.rides(TransportType.BUS,30),)print(f'Api version:{res[0]}')print(f'Stations in nbg:{str(len(res[1]))}')print(f'Departures at plaerrer in nbg:{res[2]}')print(f'Departures of underground line 2 at plaerrer in nbg:{res[3]}')print(f'Bus departures in the next 30 minutes:{res[4]}')if__name__=='__main__':asyncio.run(main())
Package: vgpt
Shell GPT Vertex AISummarya command line interface for google cloud platform's vertex ai chat botgenerated using:will-wright-eng/cookiecutter-typer-cliInstallingvgpt& Supported Versionsvgptis available on PyPI:python-mpipinstallvgptShell GPT Vertex AI Command Line Interface officially supports Python 3.8+.Supported Features & UsageFor help, run:vgpt--helpCommands:➜vgpt--helpUsage:vgpt[OPTIONS]COMMAND[ARGS]...

Options:--versionShowtheversionandexit.--helpShowthismessageandexit.

Commands:configConfigurestheapplicationconfig-testconfigtestendpointhellofirstendpointDevelopmentTo contribute to this tool, first checkout the code:gitclonehttps://github.com/will-wright-eng/shell-gpt-vertex-ai.gitcdshell-gpt-vertex-aiThen create a new virtual environment:python-mvenvvenvsourcevenv/bin/activateNow install the dependencies and test dependencies:pipinstall-e'.[test]'To run the tests:pytestInstall pre-commit before submitting a PR:brewinstallpre-commit
pre-commitinstallReferencesPyPI PackageBased on cookiecutter templatewill-wright-eng/click-app
Package: vgs-api-client
vgs-api-client-pythonThis repository contains a Python API client library for the Very Good Security API.RequirementsBuilding and using the API client library requires Python 3.6+.Installationpip install vgs-api-clientDevelopmentFollowDEVELOPMENTinstruction.ReleaseFollowRELEASEinstruction.Documentationhttps://www.verygoodsecurity.com/docs/vault/api/Tutorialhttps://www.verygoodsecurity.com/docs/tokenization/python-tutorialArtifacthttps://pypi.org/project/vgs-api-client/Artifacthttps://pypi.org/project/vgs-api-client/Supportsupport@verygoodsecurity.com
Package: vgs-cli
VGS CLICommand Line Tool for programmatic configurations on VGS.Official DocumentationTable of ContentsRequirementsInstallationPyPIRunRunning in DockerCommandsAutomation with VGS CLISphinx DocumentationPlugins DevelopmentRequirementsPython 3orDocker.InstallationPyPIInstall the latest version fromPyPI:pip install vgs-cliRunVerify your installation by running:vgs --versionRunning in DockerCheck ourofficial documentation.Commandshelploginlogoutroutes getroutes applylogs accessaccess-credentials getaccess-credentials generateorganizations getvaults getAutomation with VGS CLIIf you want to use the VGS CLI for automation you might be interested in creating aservice account.Plugins DevelopmentSeeClick - Developing Plugins.In order to develop a plugin you need to register your commands to an entrypoint insetup.py.Supported entrypoints:vgs.plugins- for extendingvgswith sub-commandsvgs.get.plugins- for extendingvgs getwith sub-commandsvgs.apply.plugins- for extendingvgs applywith sub-commandsvgs.logs.plugins- for extendingvgs logswith sub-commandsExample:entry_points='''[vgs.plugins]activate=vgscliplugin.myplugin:new_command[vgs.get.plugins]preferences=vgscliplugin.myplugin:new_get_command'''Plugin catalogvgs-cli-admin-pluginvgs-cli-marketplace-pluginvgs-cli-marketplace-dev-pluginvgs-cli-compute-pluginvgs-cli-athena-plugin
Package: vhacdx
vhacdxPython bindings for V-HACDA very simple and raw python binding forV-HACDthat is forked fromthomwolf/pyVHACDwhich generates an approximate convex decomposition of a triangle mesh.Contains a single method:output = compute_vhacd(points, faces)which take as inputs:points: a (N, 3) Numpy array of double containing the coordinates of the N vertex of the meshface: a (M,) Numpy array of uint32 containing the face vertxe indices were M is 3 times the number of facesGives as output a list (number of convex hulls) of pairs of points-faces for each convex hull.To installpip install vhacdx
Package: vharfbuzz
vharfbuzz - A user-friendlier way to use Harfbuzz in Pythonuharfbuzzis anawesometool for shaping text in Python. But it wraps the Harfbuzz C interface quite closely, so still requires you to perform a bunch of boilerplate operations before you can get on with the shaping. This module allows you a slightly more high-level interface to the text shaping process. For example, rather than:withopen(sys.argv[1],'rb')asfontfile:fontdata=fontfile.read()text=sys.argv[2]face=hb.Face(fontdata)font=hb.Font(face)buf=hb.Buffer()buf.add_str(text)buf.guess_segment_properties()features={"kern":True,"liga":True}hb.shape(font,buf,features)withvharfbuzzyou can just say:vhb=Vharfbuzz(sys.argv[1])buf=vhb.shape(sys.argv[2],{"features":{"kern":True,"liga":True}})TheVharfbuzzclass also contains a number of other helpful methods to perform common operations on Harfbuzz buffers. SeeRead The Docsfor more information.Installationvharfbuzz is available frompypi, so can be installed like so:pip3 install vharfbuzzIf building from source, you can install it like so:pip3 install -r requirements.txt
pip3 install .
Package: vhash
If you have documents with class labels, and you want to create numeric
representations of those documents that maximize inter-class differences, then
this package is for you. This package provides vectorizing hash tables that
quickly transform your text, optimizing for the maximum distance between
document-class vectors.This project has a C++ backend with a python interface, allowing for maximum
speed and maximum interopability.InstallationTo install, usepip:pipinstallvhashMinimum Working ExampleThis package follows the conventions ofscikit-learnto provide an
intuitive and familiar interface.fromtypingimportAnyfromnptypingimportNDArrayfromvhashimportVHash# sample documents: each item in the list is its own documentdocs=['hi, my name is Mike','hi, my name is George','hello, my name is Mike',]# class labels for each documentlabels=[1,0,1]# create & train modelvhash=VHash().fit(docs,labels)# create numeric representation (2D float array)numeric:NDArray[(Any,Any),float]=vhash.transform(docs)MetricsTo see how this text transformer compares to BERT, check out thesample notebook,
where we show howvhashoutperformssBERTon a sentiment analysis task.DocumentationTo get started, check out thedocs!If you will be contributing to this repo, checkout thedeveloper guide.
Package: vhcalc
vhcalcIt's a client-side library that implements a custom algorithm for extracting video hashes (fingerprints) from any video source.Getting StartedPrerequisitesPythonUsage$export_imghash_from_media--helpUsage:export_imghash_from_media[OPTIONS]Thisscriptexportingbinaryimageshashes(fingerprints)from(any)media(videofile)Options:--versionShowtheversionandexit.-r,--medias_patternPATH-OR-GLOBPatterntofindmedias[required]-o,--output-filePATHFilewheretowriteimageshashes.--helpShowthismessageandexit.DockerDocker hub:yoyonel/vhcalc$dockerrun-ityoyonel/vhcalc:main--help
Usage:export_imghash_from_media[OPTIONS]Thisscriptexportingbinaryimageshashes(fingerprints)from(any)media(videofile)Options:--versionShowtheversionandexit.-r,--medias_patternPATH-OR-GLOBPatterntofindmedias[required]-o,--output-filePATHFilewheretowriteimageshashes.--helpShowthismessageandexit.ContributingSeeContributingAuthorsLionel Attyyoyonel@hotmail.comCreated fromLee-W/cookiecutter-python-templateversion 1.1.2
Package: vhdmmio
vhdMMIOvhdMMIO will be a fully vendor-agnostic tool to build an AXI4-lite MMIO
infrastructure with. It will generate at least VHDL files, C header files, and
basic documentation from a single source, ensuring that these things stay in
sync and preventing you from writing massive amounts of boilerplate code for
every register file you need. Besides MMIO routing, it will also support
interrupt routing natively.The project is currently very much a work in progress. But you can check out
what we plan to support in the generated docshere.
You can also find example register file descriptionshere, and,
assuming Azure Pipelines passed, you should be able to build them yourself to
see what vhdmmio can already do.
Package: vhh-cmc
Plugin package: Camera Movements ClassificationThis package includes all methods to classify a given shot/or image sequence in one of the categories Pan, Tilt or NA.Package DescriptionPDF format:vhh_cmc_pdfHTML format (only usable if repository is available in local storage):vhh_cmc_htmlQuick SetupRequirements:Ubuntu 18.04 LTSpython version 3.6.x0 Environment Setup (optional)Create a virtual environment:create a folder to a specified path (e.g. /xxx/vhh_cmc/)python3 -m venv /xxx/vhh_cmc/Activate the environment:source /xxx/vhh_cmc/bin/activate1A Install using PipThe VHH Shot Boundary Detection package is available onPyPIand can be installed viapip.Update pip and setuptools (tested using pip==20.2.3 and setuptools==50.3.0)pip install vhh-cmcAlternatively, you can also build the package from source.1B Install by building from SourceCheckout vhh_cmc repository to a specified folder:git clonehttps://github.com/dahe-cvl/vhh_cmcInstall the cmc package and all dependencies:Updatepipandsetuptools(tested using pip==20.2.3 and setuptools==50.3.0)Install thewheelpackage:pip install wheelchange to the root directory of the repository (includes setup.py)python setup.py bdist_wheelThe aforementioned command should create a /dist directory containing a wheel. Install the package usingpython -m pip install dist/xxx.whlNOTE:You can check the success of the installation by using the commendpip list. This command should give you a list
with all installed python packages and it should includevhh-cmc.2 Setup environment variables (optional)source /data/dhelm/python_virtenv/vhh_sbd_env/bin/activateexport CUDA_VISIBLE_DEVICES=0export PYTHONPATH=$PYTHONPATH:/XXX/vhh_cmc/:/XXX/vhh_cmc/Develop/:/XXX/vhh_cmc/Demo/3 Run demo script (optional)change to root directory of the repositorypython Demo/vhh_cmc_run_on_single_video.pyRelease GenerationCreate and checkout release branch: (e.g. v1.1.0):git checkout -b v1.1.0Update version number in setup.pyUpdate Sphinx documentation and release versionMake sure thatpipandsetuptoolsare up to dateInstallwheelandtwineBuild Source Archive and Built Distribution usingpython setup.py sdist bdist_wheelUpload package to PyPI usingtwine upload dist/*Evaluation & ResultsExperiment: "../cmc_eval_20210614/vhhmmsi_eval_db_part4/vhhmmsi_eval_db_2"parametersvaluesmvi_mv_ratio0.2threshold_significance2.0threshold_consistency2.3mvi_window_size10region_window_size5precisionrecallf1-scoreaccuracyexp020.72930.72440.71810.7093
Package: vhh-sbd
Plugin package: Shot Boundary DetectionThis package includes all methods to detect and split a given video into the basic shots. (currently focused on Abrupt Transitions).Package DescriptionPDF format:vhh_sbd_pdfHTML format (only usable if repository is available in local storage):vhh_sbd_htmlQuick SetupRequirements:Ubuntu 18.04 LTS (also tested on Windows 10)python version 3.6.x0 Environment Setup (optional)Create a virtual environment:create a folder to a specified path (e.g. /xxx/vhh_sbd/)python3 -m venv /xxx/vhh_sbd/Activate the environment:source /xxx/vhh_sbd/bin/activate1A Install using PipThe VHH Shot Boundary Detection package is available onPyPIand can be installed viapip.Update pip and setuptools (tested using pip==20.2.3 and setuptools==50.3.0)pip install vhh-sbdAlternatively, you can also build the package from source.1B Install by building from SourceCheckout vhh_sbd repository to a specified folder:git clone https://github.com/dahe-cvl/vhh_sbdInstall the sbd package and all dependencies:Updatepipandsetuptools(tested using pip==20.2.3 and setuptools==50.3.0)Install thewheelpackage:pip install wheelchange to the root directory of the repository (includes setup.py)python setup.py bdist_wheelThe aforementioned command should create a /dist directory containing a wheel. Install the package usingpython -m pip install dist/xxx.whlNOTE:You can check the success of the installation by using the commandpip list. This command should give you a list
with all installed python packages and it should includevhh-sbd.2 Install PyTorchInstall a Version of PyTorch depending on your setup. Consult thePyTorch websitefor detailed instructions.3 Setup environment variables (optional)source /data/dhelm/python_virtenv/vhh_sbd_env/bin/activateexport CUDA_VISIBLE_DEVICES=1export PYTHONPATH=$PYTHONPATH:/XXX/vhh_sbd/:/XXX/vhh_sbd/Develop/:/XXX/vhh_sbd/Demo/4 Run demo script (optional)change to root directory of the repositorypython Demo/vhh_sbd_run_on_single_video.pyNOTE:Do not forget to change paths in demo script!Release GenerationCreate and checkout release branch: (e.g. v1.1.0):git checkout -b v1.1.0Update version number in setup.pyUpdate Sphinx documentation and release versionMake sure thatpipandsetuptoolsare up to dateInstallwheelandtwineBuild Source Archive and Built Distribution usingpython setup.py sdist bdist_wheelUpload package to PyPI usingtwine upload dist/*
Package: vhh-stc
Plugin package: Shot Type ClassificationThis package includes all methods to classify a given shot/or image sequence in one of the categories Extreme Long Shot
(ELS), Long Shot (LS), Medium Shot (MS) or Close-Up Shot (CU).Package DescriptionPDF format:vhh_stc_pdfHTML format (only usable if repository is available in local storage):vhh_stc_htmlQuick SetupThis package includes a setup.py script and a requirements.txt file which are needed to install this package for custom applications.
The following instructions have to be done to used this library in your own application:Requirements:Ubuntu 18.04 LTSCUDA 10.1 + cuDNNpython version 3.6.x0 Environment Setup (optional)Create a virtual environment:create a folder to a specified path (e.g. /xxx/vhh_stc/)python3 -m venv /xxx/vhh_stc/Activate the environment:source /xxx/vhh_stc/bin/activate1A Install using PipThe VHH Shot Boundary Detection package is available onPyPIand can be installed viapip.Update pip and setuptools (tested using pip==20.2.3 and setuptools==50.3.0)pip install vhh-stcAlternatively, you can also build the package from source.1B Install by building from SourceCheckout vhh_stc repository to a specified folder:git clonehttps://github.com/dahe-cvl/vhh_stcInstall the stc package and all dependencies:Updatepipandsetuptools(tested using pip==20.2.3 and setuptools==50.3.0)Install thewheelpackage:pip install wheelchange to the root directory of the repository (includes setup.py)python setup.py bdist_wheelThe aforementioned command should create a /dist directory containing a wheel. Install the package usingpython -m pip install dist/xxx.whlNOTE:You can check the success of the installation by using the commendpip list. This command should give you a list
with all installed python packages and it should includevhh-stc.2 Install PyTorchInstall a Version of PyTorch depending on your setup. Consult thePyTorch websitefor detailed instructions.3 Setup environment variables (optional)source /data/dhelm/python_virtenv/vhh_sbd_env/bin/activateexport CUDA_VISIBLE_DEVICES=1export PYTHONPATH=$PYTHONPATH:/XXX/vhh_stc/:/XXX/vhh_stc/Develop/:/XXX/vhh_stc/Demo/4 Run demo script (optional)change to root directory of the repositorypython Demo/vhh_stc_run_on_single_video.pyRelease GenerationCreate and checkout release branch: (e.g. v1.1.0):git checkout -b v1.1.0Update version number in setup.pyUpdate Sphinx documentation and release versionMake sure thatpipandsetuptoolsare up to dateInstallwheelandtwineBuild Source Archive and Built Distribution usingpython setup.py sdist bdist_wheelUpload package to PyPI usingtwine upload dist/*
Package: vhinny
Vhinny - Financial Data APIPublic API to access Vhinny's Financial Data. For more information, please visit us athttps://www.vhinny.com/aboutInstallationMake sure you have Python 3.6+ on your system, then runpip install vhinnyDocumentationStart by importing the package# Importing Vhinny always is a good place to start
from vhinny import VhinnyInitiate your instancevhi = Vhinny()Looking for a Balance Sheet? Try this:data = vhi.balance_sheet(ticker='AAPL', year=2012)This will return a dictionary similar to the one below. Note, if we don't have data for a combination
of (ticker, year) you've specified, this call will returnNone# Sample response:
{
    'accounts_payable_items': 2012000000.0, 
    'accounts_receivable': 7885000000.0, 
    'assets': 93798000000.0, 
    'cash_and_equivalents': 14778000000.0, 
    'current_assets': 60454000000.0, 
    'filing_date': '2013-01-29', 
    'goodwill': 10537000000.0, 
    'intangible_assets': 7473000000.0, 
    'inventory': 505000000.0, 
    'liabilities': 22083000000.0, 
    'liabilities_current': 14337000000.0, 
    'liabilities_non_current': 7746000000.0, 
    'long_term_debt_current': 0.0, 
    'long_term_debt_non_current': 2988000000.0, 
    'non_current_assets': 33344000000.0, 
    'property_plant_and_equipment': 11854000000.0, 
    'reported_as_of': '2012-12-31', 
    'retained_earnings': 48342000000.0, 
    'stockholders_equity': 71715000000.0, 
    'treasury_stock_value': None
}You can also request Income Statement, and the Statement of Cash Flows like so:vhi.income_statement(ticker='AAPL', year=2012)
vhi.cash_flows(ticker='AAPL', year=2012)Happy coding!