Saravanan666/pypi-org huggingface dataset:
Package: pvipy
Pvi.pyPython wrapper forB&R PVI (process visualization interface).In times of more modern protocols like OPC-UA, this may seem a bit old-fashioned.
But PVI has some hidden strengths and is also very versatile.
Have a look into the documentation of the 'Lines' (ANSL, INA2000, NET2000, MTC, ADI, DCAN, SNMP, MODBUS, MININET) and what they are used for.
In most cases it is used just to communicate with B&R PLCs with 'ANSL' and 'SNMP'.
Unfortunately its native C-language interface is very complex and also PVI Services (C#) can be a high barrier to entry.
It's a lot more fun with Python !PVI installation and licensePVI needs a previous installation of 'PVI Development Setup' fromB&R's homepage.
Without a PVI license 1TG0500.02 (+ TG Guard e.g. 0TG1000.02) PVI will run for two hours ("Trial license")).After this period all PVI based programs will stop working (or will not even start).
In that case PVI-Manager must be stopped and restarted again.
This can be very annoying when Automation Studio is being used in the background at the same time, because it then has to be restarted as well.
Contact your local B&R office to buy a valid license if trial license is not sufficient for you.Installationpip install pvipyUsagefind the online help here:https://hilch.github.io/Pvi.py/or just jump to theexamplesTest environmentCurrent test environment is AS4.1.17.113 / PVI 4.1.12 which can bedownloaded from B&R websiteand Python 3.8
Package: pvkoala
Koala Binding for PythonKoala Noise Suppression EngineMade in Vancouver, Canada byPicovoiceKoala is an on-device noise suppression engine. Koala is:Private; All voice processing runs locally.Cross-Platform:Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)Android and iOSChrome, Safari, Firefox, and EdgeRaspberry Pi (5, 4, 3) and NVIDIA Jetson NanoCompatibilityPython 3.7 or higherRuns on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (5, 4, 3), and NVIDIA Jetson Nano.Installationpip3 install pvkoalaAccessKeyKoala requires a valid PicovoiceAccessKeyat initialization.AccessKeyacts as your credentials when using Koala
SDKs. You can get yourAccessKeyfor free. Make sure to keep yourAccessKeysecret.
Signup or Login toPicovoice Consoleto get yourAccessKey.UsageCreate an instance of the engine and enhance audio:importpvkoalakoala=pvkoala.create(access_key='${ACCESS_KEY}')defget_next_audio_frame():passwhileTrue:enhanced_audio=koala.process(get_next_audio_frame())Replace${ACCESS_KEY}with yours obtained fromPicovoice Console.
The input audio must come from a single-channel stream with integer 16-bit encoding. The sample rate must be identical
tokoala.sample_rate. The stream must be split intoframeswith a fixed length in samples that can be obtained
fromkoala.frame_length.The output ofkoala.process()is a frame of enhanced audio with the same 16-bit integer encoding. The delay in
samples between the start time of the input frame and the start time of the output frame can be attained fromkoala.delay_sample.In case the next audio frame does not directly follow the previous one, callkoala.reset().
When done be sure to explicitly release the resources usingkoala.delete().Demospvkoalademoprovides command-line utilities for processing audio using Koala.
Package: pvkoalademo
Koala Noise Suppression DemosMade in Vancouver, Canada byPicovoiceKoalaKoala is an on-device noise suppression engine. Koala is:Private; All voice processing runs locally.Cross-Platform:Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)Android and iOSChrome, Safari, Firefox, and EdgeRaspberry Pi (5, 4, 3) and NVIDIA Jetson NanoCompatibilityPython 3.7+Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (5, 4, 3), and NVIDIA Jetson Nano.Installationpip3 install pvkoalademoAccessKeyKoala requires a valid PicovoiceAccessKeyat initialization.AccessKeyacts as your credentials when using Koala
SDKs. You can get yourAccessKeyfor free. Make sure to keep yourAccessKeysecret.
Signup or Login toPicovoice Consoleto get yourAccessKey.UsageMicrophone DemoThe microphone demo collects audio from a microphone connected to your machine. The audio is passed through the Koala
noise suppression engine and stored in a.wavfile.
Run the following in the terminal:koala_demo_mic --access_key ${ACCESS_KEY} --output-path ${WAV_OUTPUT_PATH}Replace${ACCESS_KEY}with yours obtained from Picovoice Console and${WAV_OUTPUT_PATH}with a path to a.wavfile
where the enhanced audio will be stored. Terminate the demo withCtrl+C.File DemoThe file demo passes audio stored in a.wavfile through the Koala noise suppression engine. The result is shifted to
compensate for the delay introduced by Koala and stored in a separate.wavfile that will have the same length as the
input file without any delay.
Run the following in the terminal:koala_demo_file --access_key ${ACCESS_KEY} --input_path ${WAV_INPUT_PATH} --output_path ${WAV_OUTPUT_PATH}Replace${ACCESS_KEY}with yours obtained from Picovoice Console,${WAV_INPUT_PATH}with a path to a compatible
(single-channel, 16 kHz, 16-bit PCM).wavfile you wish to enhance, and${WAV_OUTPUT_PATH}with a path to a.wavfile where the enhanced audio will be stored.
Package: pvleopard
Leopard Binding for PythonLeopard Speech-to-Text EngineMade in Vancouver, Canada byPicovoiceLeopard is an on-device speech-to-text engine. Leopard is:Private; All voice processing runs locally.AccurateCompact and Computationally-EfficientCross-Platform:Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)Android and iOSChrome, Safari, Firefox, and EdgeRaspberry Pi (5, 4, 3) and NVIDIA Jetson NanoCompatibilityPython 3.7+Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.Installationpip3 install pvleopardAccessKeyLeopard requires a valid PicovoiceAccessKeyat initialization.AccessKeyacts as your credentials when using Leopard SDKs.
You can get yourAccessKeyfor free. Make sure to keep yourAccessKeysecret.
Signup or Login toPicovoice Consoleto get yourAccessKey.UsageCreate an instance of the engine and transcribe an audio file:importpvleopardleopard=pvleopard.create(access_key='${ACCESS_KEY}')transcript,words=leopard.process_file('${AUDIO_FILE_PATH}')print(transcript)forwordinwords:print("{word=\"%s\"start_sec=%.2fend_sec=%.2fconfidence=%.2fspeaker_tag=%d}"%(word.word,word.start_sec,word.end_sec,word.confidence,word.speaker_tag))Replace${ACCESS_KEY}with yours obtained fromPicovoice Consoleand${AUDIO_FILE_PATH}to the path an audio file.Finally, when done be sure to explicitly release the resources:leopard.delete()Language ModelThe Leopard Python SDK comes preloaded with a default English language model (.pvfile).
Default models for other supported languages can be found inlib/common.Create custom language models using thePicovoice Console. Here you can train
language models with custom vocabulary and boost words in the existing vocabulary.Pass in the.pvfile via themodel_pathargument:leopard=pvleopard.create(access_key='${ACCESS_KEY}',model_path='${MODEL_FILE_PATH}')Word MetadataAlong with the transcript, Leopard returns metadata for each transcribed word. Available metadata items are:Start Time:Indicates when the word started in the transcribed audio. Value is in seconds.End Time:Indicates when the word ended in the transcribed audio. Value is in seconds.Confidence:Leopard's confidence that the transcribed word is accurate. It is a number within[0, 1].Speaker Tag:If speaker diarization is enabled on initialization, the speaker tag is a non-negative integer identifying unique speakers, with0reserved for unknown speakers. If speaker diarization is not enabled, the value will always be-1.Demospvleoparddemoprovides command-line utilities for processing audio using
Leopard.
Package: pvleoparddemo
Leopard Speech-to-Text DemosMade in Vancouver, Canada byPicovoiceLeopardLeopard is an on-device speech-to-text engine. Leopard is:Private; All voice processing runs locally.AccurateCompact and Computationally-EfficientCross-Platform:Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)Android and iOSChrome, Safari, Firefox, and EdgeRaspberry Pi (5, 4, 3) and NVIDIA Jetson NanoCompatibilityPython 3.7+Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (4, 3), and NVIDIA Jetson Nano.Installationpip3 install pvleoparddemoAccessKeyLeopard requires a valid PicovoiceAccessKeyat initialization.AccessKeyacts as your credentials when using Leopard SDKs.
You can get yourAccessKeyfor free. Make sure to keep yourAccessKeysecret.
Signup or Login toPicovoice Consoleto get yourAccessKey.UsageFile DemoRun the following in the terminal:leopard_demo_file --access_key ${ACCESS_KEY} --audio_paths ${AUDIO_FILE_PATH}Replace${ACCESS_KEY}with yours obtained from Picovoice Console and${AUDIO_FILE_PATH}with a path to an audio file you
wish to transcribe.Microphone DemoYou need a working microphone connected to your machine for this demo. Run the following in the terminal:leopard_demo_mic --access_key ${ACCESS_KEY}Replace${ACCESS_KEY}with yours obtained from Picovoice Console. Once running, the demo prints:>>> Press `ENTER` to start:PressENTERkey and wait for the following message in the terminal:>>> Recording ... Press `ENTER` to stop:Now start recording and when done pressENTERkey to get the transcription.
Package: pvlib
pvlib python is a community developed toolbox that provides a set of
functions and classes for simulating the performance of photovoltaic
energy systems and accomplishing related tasks.  The core mission of pvlib
python is to provide open, reliable, interoperable, and benchmark
implementations of PV system models.We need your help to make pvlib-python a great tool!Documentation:http://pvlib-python.readthedocs.ioSource code:https://github.com/pvlib/pvlib-python
Package: pvlink
pvlinkParaView-Web RemoteRenderer in JupyterInstallationYou can install pvlink usingpip.$ pip install pvlinkIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:$ jupyter nbextension enable --py [--sys-prefix|--user|--system] pvlinkTo enable pvlink with Jupyter lab, make sure the Jupyter widgets extension is installed, and install the pvlink extension:$ jupyter labextension install @jupyter-widgets/jupyterlab-manager # install the Jupyter widgets extension
$ jupyter labextension install pvlinkUsageFor examples see theexample notebook.The RemoteRenderer additionally requires theparaview.simpleandparaview.web modules.Jupyter Proxy Setup (using nginx)To enable streaming these settings need to be set, in the nginx config file for Jupyter (for example: in /etc/nginx/conf.d/):# top-level http config for websocket headers
# If Upgrade is defined, Connection = upgrade
# If Upgrade is empty, Connection = close
map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

... location ... {
   ...
           # websocket headers
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
  ...
}An unused stream is automatically disconnected by nginx, afterproxy_read_timeout's seconds are exceeded. The default value of 60s is reached quite fast, therefore it is recommended to increase this value.
For example:# HTTPS server to handle JupyterHub
server {
    listen 443 ssl;
    ...
    proxy_read_timeout 3600s;
    ...ChangelogSeeChangelog
Package: pvmismatch
An explicit IV & PV curve trace calculator for PV system circuitsModel chainCell > Cell string > Module > String > SystemKey Model inputsCell technology characteristicsEffective Irradiance (suns)Temperature (cell temperature)Bypass device configurationCell string layoutInstallationPVMismatch is onPyPI. Install it
withpip:$ pip install pvmismatchRequirementsPVMismatch requires NumPy, SciPy and matplotlib. These packages are available
from PyPI,Christoph Gohlkeand Anaconda. You must install them prior to using PVMismatch.UsagePlease see thedocumenationfor
tutorials and API. Bugs and feature requests can be reported onGitHub. The change
history is also onGitHub.Other Projects that use PVMismatchSystem level mismatch loss calculator using PVMismatch tool (STC and Annual energy loss)https://github.com/SunPower/MismatchLossStudyCiting PVMismatchWe appreciate your use of PVMismatch, and ask that you appropriately cite the software in exchange for its open-source publication.Mark Mikofski, Bennet Meyers, Chetan Chaudhari (2018). “PVMismatch Project:https://github.com/SunPower/PVMismatch”. SunPower Corporation, Richmond, CA.
Package: pvml
pvmlA simple Machine Learning libraryThe library include code for many classic machine learning models such as logistic regression, svm, neural networks etc.The code is particularly aimed to students in machine learning and does not require advanced programming skills, just a basic understanding of Python and the numpy package.Do not expectoptimized algorithms or a sophisticated design.If your objective is to obtain good results quickly, please consider using a more professional library such asscikit-learn.InstallationThe library is available onPYPIand can be installed as followspip3 install pvml
Package: pvo
Python: Asynchronous client for the PVOutput APIAsynchronous client for the PVOutput API.AboutThis package allows you to monitor PV systems connected toPVOutputprogrammatically. It is mainly created to allow third-party programs to
integrate with PVOutput.InstallationpipinstallpvoUsageimportasynciofrompvoimportPVOutputasyncdefmain():"""Show example on using the PVOutput API client."""asyncwithPVOutput(api_key="API_KEY_FROM_PVOUTPUT_ORG",system_id=60017,)aspvoutput:status=awaitpvoutput.status()print(status)if__name__=="__main__":asyncio.run(main())Changelog & ReleasesThis repository keeps a change log usingGitHub's releasesfunctionality. The format of the log is based onKeep a Changelog.Releases are based onSemantic Versioning, and use the format
ofMAJOR.MINOR.PATCH. In a nutshell, the version will be incremented
based on the following:MAJOR: Incompatible or major changes.MINOR: Backwards-compatible new features and enhancements.PATCH: Backwards-compatible bugfixes and package updates.ContributingThis is an active open-source project. We are always open to people who want to
use the code or contribute to it.We've set up a separate document for ourcontribution guidelines.Thank you for being involved! :heart_eyes:Setting up development environmentThe easiest way to start, is by opening a CodeSpace here on GitHub, or by using
theDev Containerfeature of Visual Studio Code.This Python project is fully managed using thePoetrydependency
manager. But also relies on the use of NodeJS for certain checks during
development.You need at least:Python 3.11+PoetryNodeJS 18+ (including NPM)To install all packages, including all development requirements:npminstall
poetryinstallAs this repository uses thepre-commitframework, all changes
are linted and tested with each commit. You can run all checks and tests
manually, using the following command:poetryrunpre-commitrun--all-filesTo run just the Python tests:poetryrunpytestAuthors & contributorsThe original setup of this repository is byFranck Nijhof.For a full list of all authors and contributors,
checkthe contributor's page.LicenseMIT LicenseCopyright (c) 2023 Franck NijhofPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: pvoctopus
Octopus Binding for PythonOctopusMade in Vancouver, Canada byPicovoiceOctopus is Picovoice's Speech-to-Index engine. It directly indexes speech without relying on a text representation. This
acoustic-only approach boosts accuracy by removing out-of-vocabulary limitation and eliminating the problem of competing
hypothesis (e.g. homophones)CompatibilityPython 3.5+Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)Installationpip3 install pvoctopusAccessKeyOctopus requires a valid PicovoiceAccessKeyat initialization.AccessKeyacts as your credentials when using Octopus SDKs.
You can get yourAccessKeyfor free. Make sure to keep yourAccessKeysecret.
Signup or Login toPicovoice Consoleto get yourAccessKey.UsageCreate an instance of the engine:importpvoctopusaccess_key="${ACCESS_KEY}"# AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)octopus=pvoctopus.create(access_key=access_key)Octopus consists of two steps: Indexing and Searching. Indexing transforms audio data into aMetadataobject that
searches can be run against.Octopus indexing has two modes of operation: indexing PCM audio data, or indexing an audio file.When indexing PCM audio data, the valid audio sample rate is given byhandle.sample_rate.
The engine accepts 16-bit linearly-encoded PCM and operates on single-channel audio:audio_data=[...]metadata=octopus.index(audio_data)Similarly, files can be indexed by passing in the absolute file path to the audio object.
Supported file formats are mp3, flac, wav and opus:audio_file_path="/path/to/my/audiofile.wav"metadata=octopus.index_file(audio_file_path)Once theMetadataobject has been created, it can be used for searching:search_term='picovoice'matches=octopus.search(metadata,[search_term])Multiple search terms can be given:matches=octopus.search(metadata,['picovoice','Octopus','rhino'])Thematchesobject is a dictionary where thekeyis thephrase, and thevalueis alistofMatchobjects.
TheMatchobject contains thestart_sec,end_secandprobabilityof each match:matches=octopus.search(metadata,['avocado'])avocado_matches=matches['avocado']formatchinavocado_matches:print(f"Match for `avocado`:{match.start_sec}->{match.end_sec}({match.probability})")TheMetadataobject can be cached or stored to skip the indexing step on subsequent searches.
This can be done with theto_bytes()andfrom_bytes()methods:metadata_bytes=metadata.to_bytes()# ... Write & load `metadata_bytes` from cache/filesystem/etc.cached_metadata=pvoctopus.OctopusMetadata.from_bytes(metadata_bytes)matches=octopus.search(cached_metadata,['avocado'])When done the Octopus, resources have to be released explicitly:octopus.delete()Non-English ModelsIn order to search non-English phrases you need to use the corresponding model file. The model files for all supported
languages are availablehere.Demospvoctopusdemoprovides command-line utilities for searching audio files using
Octopus.
Package: pvoctopusdemo
Octopus Speech-to-Index engineMade in Vancouver, Canada byPicovoiceThis package contains commandline program for indexing and searching inside audio files using Octopus Speech-to-Index engine.OctopusOctopus is Picovoice's Speech-to-Index engine. It directly indexes speech without relying on a text representation.CompatibilityPython 3Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64).AccessKeyOctopus requires a valid PicovoiceAccessKeyat initialization.AccessKeyacts as your credentials when using Octopus SDKs.
You can get yourAccessKeyfor free. Make sure to keep yourAccessKeysecret.
Signup or Login toPicovoice Consoleto get yourAccessKey.Installationsudo pip3 install pvoctopusdemoUsageThis demo allows testing Octopus interactively through commandline. It accepts MP3, WAV, FLAC, and OPUS audio files with sample rates higher than 16kHz. The following command processes all files in the space-separated{AUDIO_PATHS}list:octopus_demo  --access_key {AccessKey} --audio_paths ${AUDIO_PATHS}where{AccessKey}is an AccessKey which should be obtained fromPicovoice Console.After processing audio files, you are asked for a search phrase:Enter search phrase (Ctrl+c to exit):The search phrase can have several words separated by space, but each word should only consist of alphabetic characters. As shown in the prompt above, pressCtrlandCkeys at the same time to exit the program.
Package: pvops
pvops is a python package for PV operators & researchers. It is
a collection of functions for working with text-based data
from photovoltaic power systems. The library includes functions for
processing text data as well as fusion of the text information with
time series data for visualization of contextual details for data
analysis.Documentation:https://pvops.readthedocs.io/en/latest/index.htmlSource code:https://github.com/sandialabs/pvOps
Package: pvorca
Orca Binding for PythonOrca Text-to-Speech EngineMade in Vancouver, Canada byPicovoiceOrca is an on-device text-to-speech engine producing high-quality, realistic, spoken audio with zero latency. Orca is:Private; All voice processing runs locally.Cross-Platform:Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64)Android and iOSChrome, Safari, Firefox, and EdgeRaspberry Pi (5, 4, 3) and NVIDIA Jetson NanoCompatibilityPython 3.7+Runs on Linux (x86_64), macOS (x86_64, arm64), Windows (x86_64), Raspberry Pi (5, 4, 3), and NVIDIA Jetson Nano.Installationpip3 install pvorcaAccessKeyOrca requires a valid PicovoiceAccessKeyat initialization.AccessKeyacts as your credentials when using Orca
SDKs. You can get yourAccessKeyfor free. Make sure to keep yourAccessKeysecret.
Signup or Login toPicovoice Consoleto get yourAccessKey.UsageCreate an instance of the Orca engine:importpvorcaorca=pvorca.create(access_key='${ACCESS_KEY}')Replace the${ACCESS_KEY}with your AccessKey obtained fromPicovoice Console.You can synthesize speech by calling one of thesynthesizemethods:# Return raw PCMpcm=orca.synthesize(text='${TEXT}')# Save the generated audio to a WAV file directlyorca.synthesize_to_file(text='${TEXT}',path='${OUTPUT_PATH}')Replace${TEXT}with the text to be synthesized and${OUTPUT_PATH}with the path to save the generated audio as a
single-channel 16-bit PCM WAV file.When done make sure to explicitly release the resources withorca.delete().Text inputOrca accepts the 26 lowercase (a-z) and 26 uppercase (A-Z) letters of the English alphabet, as well as
common punctuation marks. You can get a list of all supported characters by calling thevalid_characters()method provided in the Orca SDK you are using.
Pronunciations of characters or words not supported by this list can be achieved withcustom pronunciations.Custom pronunciationsOrca allows to embed custom pronunciations in the text via the syntax:{word|pronunciation}.The pronunciation is expressed inARPAbetphonemes, for example:"This is a {custom|K AH S T AH M} pronunciation""{read|R IY D} this as {read|R EH D}, please.""I {live|L IH V} in {Sevilla|S EH V IY Y AH}. We have great {live|L AY V} sports!"VoicesOrca can synthesize speech with various voices, each of which is characterized by a model file located
inlib/common.
To create an instance of the engine with a specific voice, use:orca=pvorca.create(access_key='${ACCESS_KEY}',model_path='${MODEL_PATH}')and replace${MODEL_PATH}with the path to the model file with the desired voice.Speech controlOrca allows for keyword arguments to be provided to thesynthesizemethods to control the synthesized speech:speech_rate: Controls the speed of the generated speech. Valid values are within [0.7, 1.3]. A higher (lower) value
produces speech that is faster (slower). The default is1.0.Orca propertiesTo obtain the set of valid characters, callorca.valid_characters.To retrieve the maximum number of characters allowed, callorca.max_character_limit.The sample rate of Orca isorca.sample_rate.Demospvorcademoprovides command-line utilities for synthesizing audio using
Orca.