Saravanan666/pypi-org huggingface dataset:
Package: wattrex-driver-flow
DRIVER FOR FLOWMETERIntroductionThe purpose of this package is to communicate with the flowmeter, read the measurements and save them to a csv file.
To do this, you need one or two flowmeters and an Arduino Uno.Flowmeter featuresFlow range: 0.05 l/min - 10 l/min.Supply voltage: 4.5V -24V.Rated current: 8mA.Output: NPN/PNP pulse currentPipe diameter range: 8mm.Connections:- Blue: Output.
 - Red: +4,5 - 24V.
 - Screen 0 V.Arduino connection diagramPower of the arduino through the usb to usb port of the controller.Flow main:- Blue: Pin 2
 - Red: 5V
 - Screen: GNDFlow aux:- Blue: Pin 8
 - Red: 5V
 - Screen: GNDSCPI CommandsMessage: 'IDN*?' Response: ':IDN:FLOWmeter:DEVice: Device_number :VERsion: firmware_version \n'Message: ':MEASure:FLOW?' Response: ':MEASure:FLOW:DATA flow_main flow_aux \n'ReferencesFlowmeter:https://es.rs-online.com/web/p/caudalimetros/5082704Arduino uno:https://store.arduino.cc/products/arduino-uno-rev3
Package: wattrex-mn-manager
Master Node ManagerThis module defines classes and methods to manage the master node.
It communicates the web server and the database with the computational units.REQUIREMENTSAt the same file system level like this README.md file, 2 extra files have to be placed..cred.yamlTemplate:---

database:
  user: ?
  password: ?
  host: ?.?.?.?
  port: ?
  database: wattrex_master_db
  engine: mysql

mqtt:
  user: ?
  password: ?
  host: ?.?.?.?
  port: ?log_config.yamlWith example content:---
#YAML FILE START

__main__: "INFO"

##### DEV ######
mn_broker_client: "INFO"
mn_manager_node: "DEBUG"

##### DRV ######
drv_mqtt: "INFO"

##### SYS #####
system_logger_tool: "ERROR"
system_shared_tool: "ERROR"

file_handlers: {}
Package: wattro-sync
Wattro SyncErmöglicht es, Daten aus einer lokalen Quelle mit Wattro zu synchronisieren.VoraussetzungVerbindung zu wattro (https) und Quellsystempython >= 3.10 und pipInstallationpip install wattro-syncEinrichtenDie zentrale KonfigurationsdateiDie Synchronisation beruht auf einer Konfigurationsdatei, welche mitpython -m wattro_sync.setup ZIEL QUELLEerzeugt
oder aktualisiert werden kann (siehepython -m wattro_sync.setup --helpfür alle gültigen Optionen).Im Prozess werden je nach Ziel- und Quelltyp verschiedene Eingaben abgefragt und die
Datenverfügbarkeit geprüft.
Nur gültige Werte werden in die Konfigurationsdatei geschrieben.ACHTUNGFür Importe aus Mosaik muss aus technischen Gründen ein View angesporchen werden, welcherdie Datensätze auf maximal 2k beschränkt unddie Datensätze nach Änderungsdatum sortiertDie Konfigurationsdatei kann von Hand angepasst werden.
Mitpython -m wattro_sync.sync --drykann geprüft werden, ob die Synchronisation wie erwartet arbeitet.Mail InfosUm Informationen zum Erfolg der Synchornisation zu bekommen, können Mails verschickt
werden.
Das "log_level" entspricht dabei einem numerischen Wert nach
demPython Log Level Schema.Insbesondere:Levelnumerischer WertMail wird versendet bei...ERROR40Fehler beim SynchronisierenINFO20Änderung von DatensätzenDEBUG10Aufruf des ScriptsSynchronisationMitpython -m wattro_sync.syncwerden die Daten synchronisiert.
Siehepython -m wattro_sync.sync --helpfür mehr.DevelopmentPre Commit tooling# requires black, mypy and bandit to be installed (via pip)# none of the following commands should produce output on the second run.# lintblackwattro_sync-q# search for typing issuesmypywattro_sync--no-error-summary--config-filemypy.ini# search for common issuesbandit-rwattro_sync-cbandit.yaml-qBuild# requires build and twine to be installed (via pip)python-mbuild
twineuploaddist/*
Package: watts
WATTSWATTS (Workflow and Template Toolkit for Simulation) consists of a set of Python
classes that can manage simulation workflows for one or multiple codes. It
provides the following capabilities:An isolated execution environment when running a code;The ability to use placeholder values in input files that are filled in
programmatically;Seamless unit conversions when working with multiple codes;A managed database that simulation inputs and outputs are automatically saved
to; andPython classes that provide extra post-processing and analysis capabilities
for each code.InstallationTo installwatts, run:python -m pip install wattsDocumentationDocumentation for WATTS can be foundhere.CitingIf you use WATTS in your research, please consider giving proper attribution by
citing the following publication:Paul K. Romano, Nicolas E. Stauff, Zhiee Jhia Ooi, Yinbin Miao, Amanda Lund,
and Ling Zou, "WATTS: Workflow and template toolkit for simulation,"Journal
of Open Source Software,7(79), 4735 (2022).doi:10.21105/joss.04735SponsorsWATTS is being developed with support from Argonne National Laboratory. For any
questions, please contactwatts@anl.gov.
Package: watttime-api-wrapper
WattTime-API-WrapperPython API wrapper for the WattTime API:https://www.watttime.org/api-documentationKey FeaturesFull support for all endpoints and parameters.API key will be automatically updated once it has expired (every 30 mins).Built in rate limiting to comply with WattTime API ussage guidelines (3000 requests/5 mins)Increased performance by reusingsession objectaccross requests.Additional QoL features to facilitate working with response data.Option to save Historical Emissions response as .zip file and extract contents.Option to combine extracted .csv files into a single file.Installation InstructionsInstall Requirements (If Necessary)Both "pandas" and "requests" libraries are required to use this library.pip install pandaspip install requestsInstall Librarypip install watttime-api-wrapperUsage InstructionsRegister AccountThis step is only required if you do not already have a WattTime account.from WattTime import WattTime


username = "{username}"  # required
password = "{password}"  # required
email = "{user@email.com}"  # required
org = "{organization}"  # optional
wt = WattTime.RegisterNewUser(username, password, email)Create a ClientOnce you have registered an account, saving your username and password as environment variables is recommended.from WattTime import WattTime
import os


username = os.getenv("WATTTIME_API_USERNAME")
password = os.getenv("WATTTIME_API_PASSWORD")
wt = WattTime.GridEmissionsInformation(username, password)Use the ClientDetermine Grid Regionlatitude = 33.844978
longitude = -118.387238
wt.determine_grid_region(latitude, longitude)The output is similar to the following:> {'abbrev': 'CAISO_LONGBEACH', 'name': 'California ISO Long Beach', 'id': 233}For a full list of ussage examples, see theWattTime API Demo.ipynbnotebook that has been included in this repository.
Package: watz
Watz Python SDKThe Python SDK for Watz APIs.InstallationYou can installwatzviapipfromPyPI:$pipinstallwatzUsagePlease see theusage docsfor details.Getting a keySee the API section on theWatz website.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theApache 2.0 license, theWatz Python SDKis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.
Package: waunit
Web Analytics Unit (WAUnit)WAUnit is a testing framework for Google Analytics (other platforms coming soon).When you setup custom tracking for a website you have to validate if the hits are correct, HitInspect automates the verification of tracking specifications.Watch the Youtube video ‘WAUnit Overview’.In a nutshell this is how it works:A python unittest using Selenium Webdriver is executedA local proxy captures the Google Analytics hitsThe unittest compares the specs with the proxy hit log and returns OK/FAIL for each test and detailed information on what doesn’t match.RequirementsPython 2.7SeleniummitmproxyInstallationInstall WAUnit using pip. Notice a core requirement is mitmproxy. Be sure to installSSL certificatesfor mitmproxy so the proxy can capture SSL traffic.python pip install WAUnitQuickstartIf you are not familiar with Selenium read thegetting startedwith Selenium Python Bindings. Watch the Youtube video ‘Getting Started with WAUnit’Create a folder for the projectCreate a configuration file: wunit.cfgStart the proxy:waunitproxy –config wunit.cfgA file named hitdata.db will be created in your home directoryDownload [sample.py](#) to your project directoryExecute the sample with: python sample.pywunit.cfg[WAUnit]
Only googleanalyticsuniversal is available right now
parser = googleanalyticsuniversal

[Proxy] host = 127.0.0.1
port = 8080
hitsdb = hitsdataQuestions? Comments?Drop me a line at@joaocorreia
Package: wav2clip
Wav2CLIPOfficial implementation of the paper WAV2CLIP: LEARNING ROBUST AUDIO REPRESENTATIONS FROM CLIPInstallationpip install wav2clipUsageClip-Level Embeddingsimport wav2clip

model = wav2clip.get_model()
embeddings = wav2clip.embed_audio(audio, model)Frame-Level Embeddingsimport wav2clip

model = wav2clip.get_model(frame_length=16000, hop_length=16000)
embeddings = wav2clip.embed_audio(audio, model)
Package: wav2mel
wav2melConverts WAV audio [1] to Mel spectrograms for use in machine learning systems like Tacotron2.This library contains portions of the copy-pasted code you see everywhere for WAV to Mel conversion.[1] Or any audio format supported bylibrosa(which usessoundfileandaudioread).Installationpipinstallwav2melDependenciesPython 3.6 or higherlibrosa, numpy, scipy, numbaFormatwav2meloutputsnumpy save data: one.npyfile each input file.UsageYou can convert a single WAVE file from.wavto a mel spectrogram (.npy) as follows:wav2mel<WAVE_FILE>NPY_FILEMultiple WAVE files can also be converted and saved to a directory:wav2mel--output-dir/path/to/melsWAVE_FILE[WAVE_FILE...]Each.npyfile will be named after the corresponding.wavfile.Seewav2mel --helpfor more options (filter/hop/window length, sample rate, etc.).With GNU Parallelfind/path/to/wavs-name'*.wav'-typef|parallel-Xwav2mel--output-dir/path/to/melsmel2wav (Griffin-Lim)You can convert a mel spectrogram to WAV audio too usinggriffin-lim:mel2wav<NPY_FILE>WAVE_FILEormel2wav--output-dir/path/to/wavsNPY_FILE[NPY_FILE...]Seemel2wav --helpfor more options.
Package: wav2vec2-stt
Wav2Vec2 STT PythonBeta SoftwareSimple Python library, distributed via binary wheels with few direct dependencies, for easily usingwav2vec 2.0models for speech recognition.Requirements:Python 3.7+Platform: Linux x64 (Windows is a work in progress; MacOS may work; PRs welcome)Python package requirements:cffi,numpyWav2Vec2 2.0 Model (must be converted to compatible format)Several are available ready-to-go on this project'sreleases pageand below.You can convert your own models by following the instructionshere.Models:ModelDownload SizeFacebook Wav2Vec2 2.0 Base (960h)360 MBFacebook Wav2Vec2 2.0 Large (960h)1.18 GBFacebook Wav2Vec2 2.0 Large LV60 (960h)1.18 GBFacebook Wav2Vec2 2.0 Large LV60 Self (960h)1.18 GBUsagefromwav2vec2_sttimportWav2Vec2STTdecoder=Wav2Vec2STT('model_dir')importwavewav_file=wave.open('tests/test.wav','rb')wav_samples=wav_file.readframes(wav_file.getnframes())assertdecoder.decode(wav_samples).strip().lower()=='it depends on the context'Also contains a simple CLI interface for recognizingwavfiles:$python-mwav2vec2_sttdecodemodeltest.wav
ITDEPENDSONTHECONTEXT
$python-mwav2vec2_sttdecodemodeltest.wavtest.wav
ITDEPENDSONTHECONTEXT
ITDEPENDSONTHECONTEXT
$python-mwav2vec2_stt-h
usage:python-mwav2vec2_stt[-h]{decode}...

positionalarguments:{decode}sub-commanddecodedecodeoneormoreWAVfiles

optionalarguments:-h,--helpshowthishelpmessageandexitInstallation/BuildingRecommended installation via wheel from pip (requires a recent version of pip):python-mpipinstallwav2vec2_sttSeesetup.pyfor more details on building it yourself.AuthorDavid Zurow (@daanzu)LicenseThis project is licensed under the GNU Affero General Public License v3 (AGPL-3.0-or-later). See theLICENSE filefor details. If this license is problematic for you, please contact me.AcknowledgmentsContains and uses code fromPyTorchandtorchaudio, licensed under the BSD 2-Clause License.
Package: wav-autoencoder
WavAutoEncoderThis repository is an implementation of  autoencoder based on Transformer architecture for self supervised speech representation .Install$pipinstallwav-autoencoderUsageSimple example for using the modelimporttorchfromwav_autoencoderimportWavAutoEncoderConfig,WavAutoEncoderModel>>config=WavAutoEncoderConfig()>>model=WavAutoEncoderModel(config)>>wav_signal=torch.randn(2,1,16000)>>outputs=model(wav_signal)>>print(outputs.shape)TodoCitations@misc{title={WavAutoencoder:ASelf-SupervisedFrameworkforLearningAudioRepresentations},author = {Abdou Aziz DIOP},year   = {2022}}
Package: wavcheck
wavcheckFree little command-line tool to check audio WAV files in Broadcast Wave Format
(BWF) for issues (timecode, UMID,etc.). Designed especially for film & TV
composers to use before sending out mix tracks or stems that need to remain
precisely synchronized.Also can automatically add the BWF embedded starting timecode into filenames
(likeyourtune_TC01020304.wav) and fix duplicate UMID problems (which can
cause warnings when importing into Pro Tools, for example).How to InstallPREREQUISITE: requires Python 3.6 or later installed on your system. You can
download the latest verionhere. SeeRequirements for Installing
Packagesif you need more help.Open a terminal program (Terminal, PowerShell, Command Prompt,etc.) and
installwavcheckwith these commands (you may need to restart your terminal
afterensurepath):python3-mpipinstall--userpipx
python3-mpipxensurepath
pipxinstallwavcheckFor Windows users, Python 3 might be installed as thepyprogram:py -m pip install --user pipx
py -m pipx ensurepath
pipx install wavcheckUpgrading to a New VersionpipxupgradewavcheckQuick StartPut all the.wavfiles you want to check in the same directory and change to
it. Then just runwavcheck:cdpath/to/your/audio/dir
wavcheckIt will ask you to choose a frame rate, report any warnings, and offer to
automatically fix certain problems if possible.To print more verbose output, including all the Broadcast Wave Format (BWF)
embedded metadata for every WAV file, add-vor--verbose:wavcheck--verboseTo print out help information with a complete list of possible command-line
arguments:wavcheck-hIssues CheckedWarns about these potential problems:Non-standard WAV formats.Low bit depths (< 16) or sample rates (< 44.1k).Some files using different bit depths or sample rates than others.Very short audio files (< 1s).Missing Broadcast Wave Format (BWF) metadata.Audio files that start at time00:00:00:00.Audio files that start at a fractional timecode frame position.Missing or duplicate SMPTE Unique Material Identifiers (UMIDs) within BWF
metadata.Unnaturally loud BWF loudness stats (achievement unlocked—but please
don't), or true peaks above 0 dBTP.Timecode in filename doesn't match BWF start time.Automatically Reading FramerateWhen you first runwavcheckand choose a frame rate, it will ask if you want
to write that choice into a file calledFRAMERATE.txtin the same directory.
Then on any subsequent runs, it will read the frame rate from that file. (I
recommend including this file along with your audio files to avoid any
confusion, since BWF metadata does NOT encode the frame rate standard in any
way).Alternatively, you can put the framerate directly in the file name, likeFRAMERATE 24.000 non-drop.txt.Or if you have another existing file where you already have your frame rate
written, you can use it instead. For example, you could have a file called_IMPORTANT INFO.txt:Picture Version: XYZ_2022-02-22
Frame Rate: 29.970 drop
Anything else you want...Then tellwavcheckto find the framerate within that file:wavcheck--framerate="_IMPORTANT INFO.txt"Run into any problems (with this wavcheck tool)?Look for an existing bug report or file a new issuehere.
Package: wavchunk
wav-chunkRead or write INFO chunks from aRIFF WAVfile.Installation$pipinstallwavchunkDependenciesPython 3.6 or higherUsageBy default,wavchunkadds or gets INFO chunk bytes after the WAVdatachunk.Add INFO chunkimportwavchunkwithopen("infile.wav","rb")asin_file:withopen("outfile.wav","wb")asout_file:wavchunk.add_chunk(in_file,"my data".encode(),out_file=out_file)Get INFO chunkimportwavchunkwithopen("infile.wav","rb")asin_file:my_data=wavchunk.get_chunk(in_file).decode()print(my_data)Command-Line InterfaceThewavchunkmodule can also be used from the command-line.
By default, WAV data is expected on stdin and is written to stdout so that commands can be chained together in a pipe.Add INFO chunk$python3-mwavchunkadd--data'my data'<infile.wav>outfile.wavGet INFO chunk$python3-mwavchunkget--data-<infile.wav
<datafromchunk>Delete INFO chunk$python3-mwavchunkget--delete--datamydata.bin<infile.wav>outfile.wav
Package: wavebox
Wavebox: Clean, Compact, and Easy Flask Backend WrapperWelcome toWavebox– your ultimate solution for creating clean, compact, and blazing-fast Flask backend applications with ease! Whether you're a seasoned developer or just starting with Flask, Wavebox empowers you to build web applications quickly and efficiently.FeaturesSimplicity: Wavebox is designed to make Flask backend development a breeze. Its clean and intuitive API lets you focus on your application's logic rather than boilerplate code.Compact: We believe in minimalism. With Wavebox, you get a lightweight package that doesn't bloat your project. It keeps your codebase neat and tidy.Ease of Use: Whether you're a beginner or a pro, Wavebox is easy to pick up. Our documentation is comprehensive and user-friendly, helping you get started in no time.InstallationInstall Wavebox using pip:pipinstallwaveboxQuick StartGetting started with Wavebox is as easy as 1-2-3! Here's a quick example of setting up a basic Flask app:MainfromflaskimportFlask,Blueprint,Response,jsonifyfromwerkzeug.exceptionsimportNotFound,BadRequestfromwavebox.definitionsimportApplicationsfromwavebox.components.exceptionsimportFundamentalExceptionclassApplicationName(Applications):def__init__(self,flask_app:Flask):super().__init__(flask_app,Blueprint('root',flask_app.name,url_prefix="/"))defglobal_handle_http_exception(self,ex:FundamentalException)->Response:passdefmain():app=Flask(__name__)application_name=ApplicationName(app)application_name.start()if__name__=='__main__':main()Save this asapp.py, and you're ready to go! Run your app withpython app.py, and visithttp://localhost:5000in your browser to see it in action.DocumentationFor detailed information on using Wavebox, check out ourdocumentation.ContributingWe welcome contributions from the community! If you have ideas, bug reports, or want to contribute to Wavebox, please see ourContribution Guidelines.LicenseWavebox is distributed under theGNU General Public License.Get Started NowWavebox is here to simplify your Flask backend development. Start building web applications the clean, compact, fast, and easy way with Wavebox!if you have ideas, bug reports, or want to contribute to Wavebox, please see ourContribution Guidelines.Happy coding with Wavebox! 🚀🌊
Package: wavecar2unk
wavecar2unkConverts the VASP WAVECAR to UNK files for wannier90.
This works for non-collinear WAVECARs, which is needed for spin-orbit coupling in wannier90 >= v2.0.0.
However, to use this code, the full k-point grid needs to be contained in the WAVECAR file (i.e., you should run a nscf calculation with ISYM=-1 or already include the tag as recommended in the case of spin-orbit coupling).
To use non-collinear calculations with wannier90, you need to enable support for v2 in VASP.
The steps are as follows:Installwavecar2unk usingpip.Apply the patchmlwf.patchfromChengcheng-Xiao/VASP2WAN90_v2_fix. E.g.,curl https://raw.githubusercontent.com/Chengcheng-Xiao/VASP2WAN90_v2_fix/master/mlwf.patch | patch -p0Compile VASP with the-DVASP2WANNIER90v2inCPP_OPTIONSand the path to your compiled wannier90 librarylibwannier.a. E.g.,CPP_OPTIONS= -DHOST=\"LinuxIFC\"\
             -DMPI -DMPI_BLOCK=8000 \
             -Duse_collective \
             -DscaLAPACK \
             -DCACHE_SIZE=4000 \
             -Davoidalloc \
             -Duse_bse_te \
             -Dtbdyn \
             -Duse_shmem \
    	     -DVASP2WANNIER90v2

LLIBS      = /home/user/compile/wannier90-2.1/libwannier.a $(SCALAPACK) $(LAPACK) $(BLAS)Use the generated VASP binary to run a SCF calculation.Setup up a calculation for wannier90.Runwavecar2unkin the calculation directory where thewannier90.winandWAVECARfiles are.Run VASP with no need forLWRITE_UNK = Truein theINCARor, more usefully, for the case of non-collinear, whereLWRITE_UNK = Truedoesn't work.Installationwavecar2unk is implemented in python and can be installed throughpip.
Dependencies are kept to a minimum and include standard packages, such asclickandpymatgen.With pipAs always with python, it is highly recommended to use a virtual environment.
To install wavecar2unk, issue the following command,$ pip install wavecar2unkor to install directly from github,$ pip install git+https://github.com/mturiansky/wavecar2unkUsageUsage: wavecar2unk [OPTIONS]

  Converts the VASP WAVECAR to UNK files for wannier90.

  Args:     input_file (Path): path to WAVECAR file (default='./WAVECAR')
  output_directory (Path): directory where UNKs ar ewritten (default = .)
  verbose (bool): verbose output (default = False)

Options:
  -i, --input_file FILE           input wavecar file (default = ./WAVECAR)
  -o, --output-directory DIRECTORY
                                  output directory where UNKs are written
                                  (default = .)

  -v, --verbose BOOLEAN           verbose output (default = False)
  --help                          Show this message and exit.ContributingContributions are welcome and any potential change or improvement should be submitted as a pull request onGithubor topymatgen, directly.
Package: wavechart
WaveCharta chart util to show audio waveUsageInstallpip install wavechartStatic chartDisplay the waveform of a sound fileimportwavechartchart=wavechart.StaticWaveChart(path='audio.wav')chart.show()Dynamic chartDisplay the waveform of a sound queue in the format of numpy arrayfromrecorderimportRecorderimportwavechartr=Recorder()wave_queue=r.get_wave_queue()chart=wavechart.DynamicWaveChart(wave_queue=wave_queue)chart.show()
Package: wave-chunk-parser
Wave Chunk ParserParses wave files chunks in order to extract metadata and audio. Also provides an option to write a bunch of given chunks back into a coherent file.Installationpip install wave-chunk-parserReading a file / IO streamfrom wave_chunk_parser.chunks import RiffChunk

with open("file.wav", "rb") as file:
    riff_chunk = RiffChunk.from_file(file)From there you can access the sub chunks from riff_chunk.sub_chunks. The data chunk uses a numpy array to hold the vectors of audio samples.Format (fmt) and data chunks are critical. Cart chunk is optional but provides those markers we need for handling broadcast audio.Writing a file / IO streamYou will need to build the chunks individually and supply them in a list of:chunks = [FormatChunk, DataChunk, CartChunk]The format chunk must come before the data chunk (we need to know how to en/decode it). Cart chunk can appear anywhere in the list or even not exist at all.To get a blob for writing to disk (or wherever), simply:riff_chunk = RiffChunk(chunks)
blob = riff_chunk.to_bytes()The to_bytes function exists on every chunk type. So, if you particularly desire, you can turn a standalone format chunk into a blob.Numpy on macOSWe need openblas to make Numpy work on macOS:pip uninstall numpy
brew install openblas
OPENBLAS="$(brew --prefix openblas)" pip install numpy --no-cache-dir