Saravanan666/pypi-org huggingface dataset:
Package: waverunner
Waverunner is a symmetrical client/server RPC toolsecurely advertises and executes arbitrary remote python modulesserver-side code:create a script (let's call itbatch-script.py) that looks like this:importnumpyimportfancyInstrumentControlfromwaverunnerimportSecureMethod@SecureMethoddefget_measurement(stimulus):returnfancyInstrumentControl.pass(stimulus)then run waverunner:$python-mwaverunner\--srv-path/path/to/batch-script.py\--notify123.345.543.2--passwordmybestfriendsgirlfriendisamediocresong

foundbatch-script.get_measurement
servingat142.555.432.1
sendingnotificationsto123.345.543.2waverunner will now serve 'batch-script.get_measurement()' and advertise to
any waverunner that might be running at 123.345.543.2client-side code:fromwaverunnerimportServerserver=Server(password='mybestfriendsgirlfriendisamediocresong',user_ips='142.555.432.1')request=('batch-script.get_measurement',np.stack([np.random.randn(100)foriinrange(100)]),)result=server.external_request('http://142.555.432.1',*request)print(result)
Package: wavescout
WaveScoutWaveScout is a lightweight Python library for quickly analyzing the tempo and key of audio files and slicing them into smaller segments based on measures.FeaturesAnalyzes tempo (BPM) and key of audio filesGenerates beat maps for audio filesSlices audio files into smaller segments based on measuresExports plaintext beat map files and audio slices as a zip fileSupports processing multiple audio files in a directoryInstallationYou can install WaveScout using pip:pipinstallwavescoutDependenciesnumpyaubiopydubUsageHere's a simple example of using WaveScout:fromwavescoutimportWaveScout# Analyze the audio filescout=WaveScout("path/to/your/audio_file.mp3")# Export the beat map to a plaintext filescout.export("beat_map.txt")# Export the audio slices to a zip filescout.export("slices.zip",export_slices=True)You can also use WaveScout to analyze and process multiple audio files in a directory:fromwavescoutimportWaveScoutFactoryfactory=WaveScoutFactory("path/to/your/audio_files_directory")maps=factory.create_maps()formapinmaps:map.export(f"{map.input_file_basename}_beat_map.txt")map.export(f"{map.input_file_basename}_slices.zip",export_slices=True)LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: waves-galaxy-adaptors
WAVES adaptors classes are aimed to be used inside a WAVES-webapp project, but could be useful elsewhere depending on your
requirementsFeaturesWaves Galaxy adapter is a set of classes intended to wrapped remote calculation devices interface into the WAVES unified ServiceRunner API through Galaxy Server (https://usegalaxy.org)WAVES core package:https://github.com/lirmm/waves-coreGALAXY project:https://galaxyproject.org/BioBlend galaxy API:https://github.com/galaxyproject/bioblendContributeIssue Tracker:https://github.com/lirmm/waves-galaxy/issuesSource Code:https://github.com/lirmm/waves-galaxySupportIf you are having issues, please let us know.
We have a mailing list located at:waves-webapp@googlegroups.comLicenseThe project is licensed under the GNU GPLv3 license.
Package: waves-gateway
Waves-Gateway-FrameworkA framework to connect other cryptocurrencies to the Waves platform.
Requires Python 3.5 or newer.For detailed usage instructions please refer to the source code documentation that may be exported
by using the commands described below.
The framework exports a class Gateway. This class has to instantiated.
Once done, the Gateway can be started by calling the run method on the resulting instance.The constructor of the Gateway class requires instances of certain interfaces.
Those interfaces define the required functionality that a concrete Gateway implementation has to provide.
You may also take a look at an example implementation that
realizes a Waves-Gateway for Litecoin:https://github.com/jansenmarc/WavesGatewayLTCExample.How to installpipinstallwaves-gatewayRequired packages for developmentpython3.5-mpipinstallcoveragemypypylintSphinxLintThePyLintpackage is required for linting.
Install it like this:pip install pylint.python3.5setup.pylintMyPyTheMyPypackage performs static
type analysis to prevent errors.python3.5 setup.py mypyUnittestpython3.5setup.pytestThe convention is to write Unittests for every class in a separate file
starting withtest_This is the default prefix of the python
Unittest module.Coveragepython3.5setup.pycoverageDocumentation GenerationCreates a folder docs with the generated HTML documentation.pipinstall.-Upython3.5setup.pydocsDoctestDoctests are not used in this project. Write Unittests instead.yapfThis project uses yapf (https://github.com/google/yapf) as a formatting
tool So, please format your code before commiting by running this:python3.5-myapf-rwaves_gateway--stylepep8--style{COLUMN_LIMIT:120}-iThe pipeline will fail if the code is not properly formatted.DistributionFirst, runnpm run build:prodto update the assets.
After that, runpython3.5 setup.py sdistto create an installable tar archive.Publish to test.pypi.org:twineupload--repository-urlhttps://test.pypi.org/legacy/dist/*Regular publish:twineuploaddist/*RecommendationsUse Python 3.5 for development.PyCharm users should enable Gevent compatible debugging:https://blog.jetbrains.com/pycharm/2012/08/gevent-debug-support/.
Package: waveshare-epaper
Waveshare e-paper packageWaveshare e-paper package for Python on Raspberry Pi.
Original source ishttps://github.com/waveshare/e-Paper.Installpipinstallwaveshare-epaperUsageYou can get available e-paper modules list byepaper.modules().$pythonPython3.7.3(default,Jan222021,20:04:44)[GCC8.3.0]onlinuxType"help","copyright","credits"or"license"formoreinformation.>>>importepaper>>>epaper.modules()['epd1in02','epd1in54','epd1in54_V2','epd1in54b','epd1in54b_V2','epd1in54c','epd2in13','epd2in13_V2','epd2in13b_V3','epd2in13bc','epd2in13d','epd2in66','epd2in66b','epd2in7','epd2in7b','epd2in7b_V2','epd2in9','epd2in9_V2','epd2in9b_V3','epd2in9bc','epd2in9d','epd3in7','epd4in01f','epd4in2','epd4in2b_V2','epd4in2bc','epd5in65f','epd5in83','epd5in83_V2','epd5in83b_V2','epd5in83bc','epd7in5','epd7in5_HD','epd7in5_V2','epd7in5b_HD','epd7in5b_V2','epd7in5bc']See below for a list of e-paper model names.https://github.com/waveshare/e-Paper/tree/master/RaspberryPi_JetsonNano/python/lib/waveshare_epdFor more information on how to use the e-paper library module, please refer to thee-Paperpart of the wiki below.Waveshare Wikiepaper.epapermethod takes the model name and returns the e-paper library module.importepaper# For example, when using 7.5inch e-Paper HATepd=epaper.epaper('epd7in5').EPD()# init and Clearepd.init()epd.Clear()LicenseThis software is released under the MIT License, see LICENSE.
Package: waveshare-rpi
RPI Waveshare LibThis is a simple library for using the WaveShare L76x GPS hat for the Raspberry Pi.The library turns on sensing and runs a background thread that parses the incoming serial messages and pushes them into a queue, from which the most recent message of a given type can be queried synchronously without blocking.The API exposes the following methods:Importing the LibraryimportwaveshareStart Serial Streamstart(device)This starts the stream of serial data from the waveshare ("device" should be the name of the USB device being used to communicate with the waveshare).  Prior to running this method, all getters will returnNone.Stop Serial Streamstop()This stops the stream of serial data from the device.  Until it is re-started, all getters will return the last value published by the device.Read Data Packetsget_gga()get_gsa()get_gsv()get_rmc()For a description of the contents of each packet type, see:http://aprs.gids.nl/nmea/
Package: waveshare-ws170120-brightness
WaveShare WS170120 BrightnessTable of ContentsIntroInstallationpippipxManuallyUsagePython ModuleStandalone ScriptIntroA simple python pip module and script in order to control the
backlight of a WaveShare WS170120 touchscreen. The tools provided by
Waveshare are binary only and are only able to set the brightness in
steps of 10%, while the hardware supports steps of 1%.The project has been generated from some simple USB capturing. The
protocol is easy enough, seeUSB-ProtocolInstallationpippip install waveshare-ws170120-brightnessorgit clone https://github.com/rotdrop/waveshare-ws170120-brightness.git
pip install ./waveshare-ws170120-brightnessor directly from githubpip install waveshare-ws170120-brightness@git+https://github.com/rotdrop/waveshare-ws170120-brightness.gitpipxThis generates an isolated virtual environment and installes the bundled scriptwaveshare-ws170120-brightness.pipx install waveshare-ws170120-brightnessorgit clone https://github.com/rotdrop/waveshare-ws170120-brightness.git
pipx install ./waveshare-ws170120-brightnessor directly from githubpipx install waveshare-ws170120-brightness@git+https://github.com/rotdrop/waveshare-ws170120-brightness.gitManuallyClone the repository, install the requirements (seerequirements.txt). The python script is located ininit.py.UsagePython Modulefrom waveshare_ws170120_brightness import WaveshareWS170120
...
backlightController = WaveshareWS170120(verbosity=1)
backlichtController.setBrightness(percentage=47)The class constructor as well as thesetBrightness()method will raise exceptions if something goes wrong.the constructor will raise aFileNotFoundErrorif the hidraw device for the touchscreen could not be foundthesetBrightness()method may raise anIOErrorif writing to the hidraw device gave unexpected resultsIn addition, the called system services may raise their own errors. These are not caught in the program code.Standalone ScriptThe corresponding executable just has the same name as the package,waveshare-ws170120-brightness. Please runwaveshare-ws170120-brightness -hfor usage information. Currently, this generates the outputusage: waveshare-ws170120-brightness [-h] -b PERCENTAGE [-v]

Set the brightness of an attached Waveshare WS170120 touch-screen

options:
  -h, --help            show this help message and exit
  -b PERCENTAGE, --brightness PERCENTAGE
                        set the brightness value to the given percentage.
  -v, --verboseHowever, that may change ...
Package: wavespec
wavespecSome spectral analysis tools for analyzing waves in data.InstallationUsingpip3:pip3 install wavespec --userInstalling the wheel usingpip3:pip3 install wavespec-0.0.1-py3-none-any.whl --userFrom git:git clone https://github.com/mattkjames7/wavespec
cd wavespec
python3 setup.py install --userUsageimportwavespecaswsFast Fourier Transform (FFT)power,phase,freq,fr,fi=ws.Fourier.FFT(t,x,WindowFunction=None,Param=None)Lomb-Scargle (LS)P,A,phi,a,b=ws.LombScargle.LombScargle(t,x0,f,Backend='C++',WindowFunction=None,Param=None)SpectrogramsNw,LenW,Freq,out=ws.Spectrogram.Spectrogram(t,v,wind,slip,Freq=None,Method='FFT',WindowFunction=None,Param=None,Detrend=True,FindGaps=True,GoodData=None,Quiet=True,LenW=None)ax,Nw,LenW,Freq,Spec=ws.Spectrogram.PlotSpectrogram(t,v,wind,slip,Freq=None,Method='FFT',WindowFunction=None,Param=None,Detrend=True,FindGaps=True,GoodData=None,Quiet=True,LenW=None,fig=None,maps=[1,1,0,0],PlotType='Pow',scale=None,zlog=False,TimeAxisUnits='s',FreqAxisUnits='Hz')3D SpectrogramsNw,LenW,Freq,Spec=ws.Spectrogram.Spectrogram3D(t,vx,vy,vz,wind,slip,Freq=None,Method='FFT',WindowFunction=None,Param=None,Detrend=True,FindGaps=False,GoodData=None)Testsws.Test.TestLS(A=[1.0,2.0],f=[0.04,0.1],phi=[0.0,90.0],Backend='C++')ws.Test.TestPolarization(xPow=2.0,xPhase=0.0,yPow=1.0,yPhase=40.0)ws.Test,TestSpectrogram()
Package: wavesplit
wavesplitwavesplit is a package for merging multiple wav files together and then
splitting them later based on the perserved lengths. It enables you to
perform any sort of operation on the merged file before splitting back
to the original clips.Requires you to havesoxinstalled fromhttps://sox.sourceforge.net/Installpip install wavesplitHow to useSimply input the wav files usingwavesplitorwavemergewavesplit merged.wav merged.txtOrwavemerge *.wavWhich will outputmerged.txtandmerged.wav
Package: wavespy
WavesPyWavesNode API clientFull documentationhttps://wavespy.readthedocs.io/en/latest/InstallationRequirements:Python 3.6 and higherPackages fromrequirements.txtFrom PyPI:pipinstallwavespyOr from source:pythonsetup.pyinstallWhat's includedNode API clientSyncAsyncGenerators and validatorsAddress dataTransactions dataMatcher APIDocsTests
Package: wavestate.bunch
wavestate.bunchUtility classes providing "Bunch" containers. These are dictionaries with
attribute access of the elements. They wrap any lower level dictionaries they
output, so the interface mimics the "struct" container from Matlab.BunchThe Bunch class is a lightweight wrapper for dictionaries to allow attribute
access as a means to access elements with less syntax. Bunch does not copy
assigned dictionaries, it wraps them. This is unlike some other implementations
such as gwinc.Struct.d=dict(A=1,B=2,d2=dict(C=1))b1=Bunch(d)print(b1.A)print(b1.d2.C)orb2=dict(A=1,B=2,d2=dict(C=1))print(b2.A)print(b2.d2.C)A useful pattern while developing and debugging code, particularly while refactoring large
blocks of code into functions isdefcode_block(arg1,arg2,arg3,...):...a=1b=2...returnBunch(locals())ret=code_block(...)ret.awhich is a lightweight way to access elements from the code_block that is
promoted into a function.DeepBunchThere are a collection of more advanced containers
DeepBunch allows speculative access of elements, such that if it is missing
an attribute, a temporary is created such thatA=DeepBunch()A.B.C.D=1is acceptable.andif A.B.C.E:
  raise Exception('The above test evaluates to False')and in this case, no intermediate dictionaries are actually created until a value is assigned to a leaf.HDFDeepBunchh5py is not a required dependency of wavestate.bunch, but if it is installed
then one can import theHDFDeepBunch, which provides a similar interface to
the DeepBunch, but uses HDF5 files as a back-end, with internal handling of
numpy arrays.
Package: waves-utilities
WAVES UtilitiesThis python package/repository contains useful scripts, dataloaders, and examples for
working with the WAVES dataset of pediatric physiological waveforms.What is WAVES?WAVES is an open-access pediatric physiological waveform dataset containing ECG,
respiratory, plethysmogram, arterial blood pressure, and a variety of other
high-frequency waveforms extracted from bedside monitors for patients at the Lucile
Packard Childrens Hospital. The WAVES dataset itself is hosted by Redivis athttps://redivis.com/WAVES/datasetsWAVES is administrated by theSURF Stanford Medicineresearch group.What is this repository for?Python utilities to load and plot physiological waveform data from the WAVES datasetHow do I get set up?Download/clone the repositorySet up a python environment with the required dependencies:conda env create -f environment.ymlInstall the python package from pypi withpip install waves_utilities(or runpython setup.py developfor local development)Usage ExamplesRefer to the tests and API documentation for more information on API options/arguments.Load data from .csv filefrom waves_utilities import WavesUtilityAPI
util_api = WavesUtilityAPI()

# Load a single row
csv_row = next(util_api.csv_manager.read_csv("waveform_test_extract.csv", limit=1))

# Load all rows (keep memory usage in mind for large data extracts)
csv_rows = list(util_api.csv_manager.read_csv("waveform_test_extract.csv"))Plot waveforms# Plot 5 seconds from a single waveform
util_api.waveform_plotter.plot_waveform(
    csv_row, save_filepath="single_waveform.png", duration_seconds=5
)

# Plot the full duration of multiple waveforms in file
util_api.waveform_plotter.plot_waveforms(
    csv_rows, save_filepath="multi_waveforms.png", title="Test Waveform Data"
)Contribution guidelinesWriting testsCode reviewOther guidelinesWho do I talk to?Daniel Miller: Primary researcher/developer for the WAVES dataset and codebaseDavid Scheinker: Head of the SURF Stanford Medicine research group
Package: wavesynth
wavesynthA simple sound-synthesis library that provides a simplified stateful API
for generating music. The API is intentionally analogous to theturtleAPI to assist in the creation of music-based assignments that duplicate
lessons from graphics-based assignments for more accessible course
design.The library has fairly unsophisticated synthesis resulting in pretty
basic sounds, and is also not super performant, although both of these
things could be improved.A log of notes is printed to assist with debugging and/or for matching
desired output.Designed by Peter Mawhorter.
Contributions from Lyn & Ohana Turbak.DependenciesWriting audio to.wavfiles can be accomplished using just the built-in
Python modules, but if you want to play audio, thesimpleaudiopackage
will be needed.InstallingTo install from PyPI, run the following command on the command-line:python-mpipinstallwavesynthOnce it's installed, you can run a built-in example using:python-mwavesynthDocumentationSeethe
documentationfor more details on how to use it and what each function does.ChangelogVersion 2.2.0 adds support for playing audio directly viaIPythonwhen running in a Jupyter notebook, without needing to usesimpleaudio. This also creates an audio widget in the page via
which the sound can be replayed without re-running the code if
desired.Version 2.1.0 changes volume handling so thatloudercan cause volume
values to go above 1.0, but internally loudness does not increase
beyond 1.0. This means that symmetric calls tolouderand thenquieterwill always cancel each other out, even if theloudercalls would take the volume above 1.0.Version 2.0.0 replacesstepUpandstepDownwithclimbUpandclimbDownand removesleapUpandleapDown. New functions likesetFundamentalandsetScaleTypemanage an internal notion of key
signature which controls howclimbUpandclimbDownchange
pitches. To emulate the oldleapfunctionality, set the scale type
to a pentatonic scale and use theclimbfunctions.
Package: wave-train
WaveTrainbyJerome Riedel, Patrick Gelß, and Burkhard SchmidtFreie Universität Berlin, GermanyShort descriptionWaveTrainis an open-source software for numerical simulations of chain-like
quantum systems with nearest-neighbor (NN) interactions only
(with or without periodic boundary conditions).
This Python package is centered around tensor train (TT, or matrix product) representations of
quantum-mechanical Hamiltonian operators and (stationary or time-evolving) state vectors.WaveTrainbuilds on the Python tensor train toolboxscikit_tt,
which provides efficient construction methods, storage schemes,
as well as solvers for eigenvalue problems and linear differential equations in the TT format.WaveTraincomprises solvers for time-independent and time-dependent Schrödinger equations
employing TT decompositions to construct low-rank representations.
Often, the TT ranks of state vectors are found to depend only marginally on the chain lengthN,
which results in the computational effort growing only slightly more than linearly inN,
thus mitigating thecurse of dimensionality.
Thus,WaveTraincomplements the existingWavePacket project at SourceForgewhich does not offer these advantages but which can be used for general Hamiltonians,
i.e., without restriction to chain-like systems.As a complement to the Python classes for full quantum mechanics,WaveTrainalso contains classes for
fully classical and mixed quantum-classical (Ehrenfest or mean field) dynamics of bipartite
("slow-fast" and/or "heavy-light") systems.
Moreover, the graphical capabilities allow visualization of quantum dynamics ‘on the fly’, with a choice of
several different graphical representations based on reduced density matrices.Full descriptionFor a detailed description of the WaveTrain software, see our article that appeared in April 2023 in J. Chem. Phys.[^1].InstallationAfter downloading and installing the Python tensor train toolboxscikit_tt,
installation of theWaveTrainsoftware package is straightforwardpip install git+https://github.com/PGelss/scikit_tt
pip install wave_trainwhere pip belongs to a Python installation with minimum version requirement 3.7.0.
For a developer installation you can download the latest version ofWaveTrainto your local computer by using the 'git clone' command.git clone https://github.com/PGelss/wave_train.git 
cd wave_train
python setup.py install --userApplicationssee our work on solving the TISE[^2] and TDSE[^3] for coupled excitons and phonons[^1]: J. Riedel, P. Gelß, R. Klein, and B. Schmidt, "WaveTrain: A Python Package for Numerical Quantum Mechanics of Chain-Like Systems Based on Tensor Trains",J. Chem. Phys. 158 (16), 164801 (2023)[^2]: P. Gelß, R. Klein, S. Matera, B. Schmidt, "Solving the Time-Independent Schrödinger Equation for
Chains of Coupled Excitons and Phonons using Tensor Trains",J. Chem. Phys. 156 (2), 024109 (2022)[^3]: P. Gelß, R. Klein, S. Matera, and B. Schmidt, "Quantum Dynamics of Coupled Excitons and Phonons in Chain-Like Systems: Tensor Train Approaches and Higher-Order Propagators",arXiv:2302.03725
Package: wave-viewer
Wave ViewerA simple GUI for viewing waveforms. It plots the waveform with vispy in a
separate process. The GUI is built with PySide6.TheWaveViewerclass is the main interface for the wave_viewer package. It
provides methods for adding and removing lines from the plot, clearing the plot,
and closing the GUI.Installationpipinstallwave-viewerUsageBelow is a simple example of how to use theWaveViewerclass. Avoid callingclearif you only want to update the plot. It is more efficient to update the
plot withadd_line.fromwave_viewerimportWaveViewerimportnumpyasnp# This if statement is required for multiprocessing on Windowsif__name__=="__main__":# Create the viewerviewer=WaveViewer()# Add a line to the plotx=np.arange(100000)/2e9y=np.exp(1j*2*np.pi*1e6*x)ys=[y.real,y.imag]viewer.add_line("line1",x,ys,offset=0)# Add another line to the plotviewer.add_line("line2",x,ys,offset=2)# Auto scale the plotviewer.autoscale()# Remove the first lineviewer.remove_line("line1")# Replace the second liney=np.exp(1j*2*np.pi*2e6*x)ys=[y.real,y.imag]viewer.add_line("line2",x,ys,offset=2)# Clear the plotviewer.clear()# Close the GUIviewer.close()
Package: wavinfo
wavinfoThewavinfopackage allows you to probe WAVE andRF64/WAVE filesand extract extended metadata, with an emphasis on film, video and
professional music production.Metadata Supportwavinforeads:Broadcast-WAVEmetadata, including embedded program
loudness, coding history andSMPTE UMID.Audio Definition Model (ADM)track metadata and schema, including
channel, pack formats,
object, content and programme.Dolby Digital Plusand Dolby Atmosdbmdmetadata.iXMLproduction recorder metadata, including project, scene, and
take tags, recorder notes and file family information.iXMLSTEINBERGsound library attributes.Wave embedded cue markers, cue marker labels, notes and timed ranges as used
by Zoom, iZotope RX, etc.Most of the commonRIFF INFOmetadata fields.Thewav formatis also parsed, so you can access the basic sample rate
and channel count information.How To UseThe entry point for wavinfo is the WavInfoReader class.fromwavinfoimportWavInfoReaderpath='../tests/test_files/A101_1.WAV'info=WavInfoReader(path)adm_metadata=info.admixml_metadata=info.ixmlThe package also installs a shell command:$wavinfotest_files/A101_1.WAVOther ResourcesFor other file formats and ID3 decoding,
look ataudio-metadata.
Package: waving-hands
# WavingHandsP2P Multiplayer Python implementation of Richard Bartle's Waving Hands (very WIP and buggy right now!This code was originally written in 2020 and I've learned a lot since then.### DevelopmentSetup your preferred python environment first:python -m venv venvsource venv/bin/activateThen do a developer install. This will give you the `waving-hands` command you can use to start the client/server:python setup.py developwaving-hands### TestingUse pytest for testing:pip install pytestpytest
Package: wavinsentio
Wavin SentioAPI Wrapper for Wavin Sentio underfloor heating system.Enables you to query status of thermostats and change target temperatureUsage examplews = wavinsentio.WavinSentio("username","password")Release History0.1.0The first proper release0.2.0Added setTemperature, setProfile and refresh token logic0.2.1PyPi push0.2.2Cleaned folder structure0.2.3Fixed error handling0.3.0Added get_location including outdoor temperature0.4.1Changed base URL for Wavin Sentio service