Saravanan666/pypi-org huggingface dataset:
Package: live-serial
live-serial: real-time serial port plotter/loggerlive-serialis a simple package that tiespyserial,matplotlibandcsvtogether to create a real-time plotter and
logger of serial port data. This is intended to make life easier for
people who work with sensors who need to see real-time feedback when
they interact with the sensors.Quickstartpip install live-serialThe package includes a scriptlivemon.pythat starts the plotting
and logging. Although the script is documented internally, the most
common use cases are:livemon.py COM3 -logdir C:\sensordata\on a Windows machine, and:livemon.py /dev/ttyACM0 -logdir ~/sensordatafor linux or MacOS. That command will open a live plotting window and
log the port data to file simultaneously. To see a full list of examples
and command-line arguments, typelivemon.py-examples.Configuration FilesAlthough the command-line parameters are useful for many quick tasks,
repetitive debugging of a multi-sensor serial port setup can be tedious.
For these cases, we recommend creating a configuration file (an example
is shown insensors.cfg).
This is also a great way to share configuration information with other
team members working on the same project: they just need to change the
port numbers in the config file for their system.The documentation on configuration options is atAPI
Documentation.Running the Unit TestsTo run all the unit tests to make sure that your local setup is working
correctly, you will need to havesocatinstalled (for UNIX-based
systems), or some virtual COM ports running (for Windows).socatis
available viaapt-getandbrew. For Windows systems, you will
need to find a virtual port generator (we have usedhttps://freevirtualserialports.com/before and it worked fine). On
Windows, the COM ports are assigned by the OS, so we can’t label them
for you. The scripts expectCOM1andCOM3to be the writeable,
virtual ports (attached toCOM2andCOM4respectively). If that
is not the case, the unit tests will not work out of the box for you.
You can edittests/conftest.py(~ line 20) andtests/test_multi.py(~ line 15) to use different port numbers.cd live-serial
toxAPI DocumentationFull API documentation is hosted atgithub
pages.
Package: live-server
Live ServerServe static files and reload them when they get changed. Great for development!Inspired bylive-serverfor Node.InstallInstall it globallypip install live-serverUseStart Live Server in a folder with command line by usinglive-serveror give it a pathlive-server ../staticExplore more options like changing port number usinglive-server --helpFound a bug?Raise an issue at itsrepo.
Package: livesolid
livesolidAdd a short description here!A longer description of your project goes here…Making Changes & ContributingThis project usespre-commit, please make sure to install it before making any
changes:pip install pre-commit
cd livesolid
pre-commit installIt is a good idea to update the hooks to the latest version:pre-commit autoupdateDon’t forget to tell your contributors to also install and use pre-commit.NoteThis project has been set up using PyScaffold 4.4. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: livesplit
PySplitPySplit is a Python library for communicating with Livesplit Server.InstallationUse the package managerpipto install foobar.pipinstalllivesplit-pythonUsageExampleimportlivesplitimporttime# Create our livesplit object# On connection, your timer won't be reset by default# To read more, take a look at options later.l=livesplit.Livesplit()# Start our timerl.startTimer()l.startGameTimer()# Wait one secondtime.sleep(1)# Stop the game timer 1 second inl.stopGameTimer()time.sleep(1)# Stop the timerl.pause()# Wait one second againtime.sleep(1)# Reset the timerl.reset()Livesplit ParametersParameterTypeDescriptionDefaultipStringIP address / hostname the Livesplit Server can be located at."127.0.0.1"portIntegerPort that the Livesplit Server is listening on.16834resetBooleanWhether to reset the timer when creating this objectFalsesetupGameTimerBooleanWhether to setup and pause the game timer when creating this object.Value ofresetContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseThis project is licensed under the MIT license. To read more, open up the license file.
Package: livesplit-parser
Livesplit-ParserA Python Package to Parse Your Data Regarding Your SpeedrunsThis Pyton package parses LiveSplit files and parses data within LiveSplit files.Install this package withpip install livesplit_parserCheck out the documentation for this packagehere.Example Usagefromlivesplit_parserimportLivesplitDatalss_path=''# put the path to your .lss file heremy_run=LivesplitData(lss_path)print('NUMBER OF ATTEMPTS:',my_run.num_attempts)print('NUMBER OF COMPLETED ATTEMPTS:',my_run.num_completed_attempts)print('PERCENTAGE OF RUNS COMPLETED:',my_run.percent_runs_completed)print('YOUR ATTEMPT DATA\n:',my_run.attempt_info_df)print('YOUR SPLIT DATA:\n',my_run.split_info_df)TODO Features to IncludeInclude aStandDevcolumn in thesplit_info_dfthat includes the standard deviation of all your attempts for that splitPlot split time distributions usingviolinplotsPlot runtime distributions with the splits on the x-axis and standard deviation on the y-axisPlot number of runs that reset between completed runsPlot completed runs over time (run ID on x-axis, final time on y-axis)Plot completed runs with a heatmap showing how good that segment was for that runCreate a Runner class that contains a list of Runners with their data and methods that plot runs against each otherexample: plot each runner's PB over time (runners can compare themselves against each other)another example: heatmap from before with splits on the x-axis, runner on the y-axis, and heatmap comparing that segment with the means of the personal bests of every runner includedOther ideas for plots and features can be submitted to theIssues boardon my GitHub repo :)
Package: livestat
livestatPython module to compute running statistics over data, like when measuring timings from a stream.Properties:
- count
- min,max,mean
- std and variance
- kurtosis and skewness # allows to measure the “normality of the dataset”The main class is LiveStat to which data can be appended with append(x). For incremental values the DeltaLiveStat provides an easy to use helper.Usage:from livestat import LiveStat,DeltaLiveStatx = LiveStat(“optionalname”)
x.append(10)
x.append(20)
print x # count is 2x = DeltaLiveStat(“dt”)
x.append(10)
x.append(20)
print x # count is 1 containing the difference#also from array
x.extend([10,20,30,40,50])Extra Features:# the LiveStat objects can be combined for example when performing over different data Windows or in a multiprocessing environment
x.merge(y) # now x contains the merge of the statistics# the LiveStat object can be multipled by scalar or translated, for the objective of performing some unit transformation. All the measures are transformed appropriately
x + 5
x * 5In progress:
- numpy support
- normality testPackage RepositoryThis project is maintained here:https://github.com/sankazim/pylivestatRelatedThe faststat package is similar:https://pypi.python.org/pypi/faststat/https://github.com/doublereedkurt/faststat/
Package: live-static-server
live-static-serverlive static serverUsageDevelopment Tipsinit env:     python3 -m pip install --upgrade pipenvinit shell:   pipenv shellinit project: pipenv installbuild:        python -m buildupload test:  python -m twine upload --repository testpypi dist/*upload prod:  python -m twine upload dist/*use test:     pip install --index-urlhttps://test.pypi.org/simple/--no-deps live-static-server-USER_NAMEuse prod:     pip install live-static-serverChangelogChangelogContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.
Package: livestatus-objects
# Livestatus (Object Oriented)Helps to query MK Livestatus and return results as objects## Installationpip install livestatus-objects## Example>>> from livestatus_objects import LivestatusServer, Host
>>> s = LivestatusServer(localhost, 50000)
>>> host = Host.get(s, 'www01.example.net')
>>> host
infra-www01.hostsvpn.sysnove.net
>>> host.services
[Fork rate, Linux diskstat, Linux procstat, Load, Memory, NTP Clock Offset, Partitions, Postfix mail queue, Postfix stats, Ssh, Swap, Swap paging rate, Total procs, Uptime, Zombie procs]
>>> host.last_state
'UP'
>>> host.services[3]
Load
>>> host.services[3].last_state
'OK'
>>> host.services[3].perf_data
'load1=0.000;5.000;20.000;0; load5=0.010;5.000;15.000;0; load15=0.050;5.000;10.000;0;'## LicenceThis code is under [WTFPL](https://en.wikipedia.org/wiki/WTFPL). Just do what the fuck you want with it.
Package: livestreamer
OverviewLivestreamer is acommand-line utilitythat pipes video streams
from various services into a video player, such asVLC.
The main purpose of Livestreamer is to allow the user to avoid buggy and CPU
heavy flash plugins but still be able to enjoy various streamed content.
There is also anAPIavailable for developers who want access
to the video stream data.Documentation:http://docs.livestreamer.io/Issue tracker:https://github.com/chrippa/livestreamer/issuesPyPI:https://pypi.python.org/pypi/livestreamerDiscussions:https://groups.google.com/forum/#!forum/livestreamerIRC: #livestreamer @ FreenodeFree software: Simplified BSD licenseFeaturesLivestreamer is built upon a plugin system which allows support for new services
to be easily added. Currently most of the big streaming services are supported,
such as:DailymotionLivestreamTwitchUStreamYouTube Live… and many more. A full list of plugins currently included can be found
on thePluginspage.QuickstartThe default behaviour of Livestreamer is to playback a stream in the default
player (VLC).#pipinstalllivestreamer$livestreamertwitch.tv/day9tvbest[cli][info] Found matching plugin twitch for URL twitch.tv/day9tv
[cli][info] Opening stream: source
[cli][info] Starting player: vlcFor more in-depth usage and install instructions see theUser guide.Related softwareFeel free to add any Livestreamer related things to
thewiki.ContributingIf you wish to report a bug or contribute code, please take a look
atCONTRIBUTING.rstfirst.
Package: livestreamer-curses
Livestreamer-curses is a limited front-end to Chrippa’sLivestreamerfor UNIX
systems. With it you can manage a list of your favorite streams and play
them (several at a time if your connection can handle it).screenshotUsageInstall usingpip installlivestreamer-curseswhich will provide thelivestreamer-cursescommandTo change the way to calllivestreamer, use the configuration file
(seelivestreamer-curses-hfor default location). See sample file for configuration options.Changelogv1.5.2 (2015-02-18)Bugfixes: Fix importsv1.5.0 (2015-02-17)Feature: Periodically check if streams are online (foreground and blocking, for now). Corresponding configuration variable:CHECK_ONLINE_INTERVALv1.4.0 (2014-11-13)Feature: Templatable command linev1.3.0 (2014-09-25)Feature: Follow XDG specification,you need to move your old rc and .db files, use -h flag to see whereFeature: Add options to overwrite/dump the database from a/to a fileBugfix: dbm issue on Mac OS Xv1.2.0 (2014-05-29)Feature: Python 3 supportBugfixes: Window resizingv1.1.0 (2014-05-25)Feature: Added a way to check and filter offline streams. UseOto refresh andoto toggle showing offline. See alsoCHECK_ONLINE_ON_STARToption to perform this check when startinglivestreamer-curses.Bugfixes: Better handling of special keys and configuration filev1.0.0 (2014-02-24)Backward incompatible changes: change project structure to
accomodate for distutilsFeature: Added-dand-foptions for custom database and
config file locations, respectively.v0.32 (2014-02-23)Buxgix: Actually use selected command line (how did I miss this?!)v0.31 (2014-01-09)Buxgix: Streams are now properly sorted when filteringv0.3 (2014-01-09)Feature: .livestreamer-cursesrc file which comes with 2
configuration options, see livestreamer-cursesrc.samplev0.2 (2013-12-22)Feature: filter streams withfkey, clear it withFDependenciesLivestreamer
Package: livestt
livesttInstallationpip install livestt # this could take a whileUsageLivestt gives access to 3 main classes/functions.Wait for the wake wordfromlivesttimportwaitdefcallback_func():print("Wakeword said!")wait(callback=callback_func)Thewaitfunction takes in these args:callback(Callable): The function to be called when the wake word is detected.args(tuple[any] | None): The arguments to be passed to the callback function. The default is None.wake_word(str): The wake word that the function is waiting for. The default is "Sheila".prob_threshold(float): The probability threshold for the wake word detection. The default is 0.5.chunk_length_s(float): The length of the audio chunk to be processed at a time, in seconds. The default is 2.0.stream_chunk_s(float): The length of the audio stream chunk to be processed at a time, in seconds. The default is 0.25.debug(bool): If True, debug information will be printed. The default is True.Raises:ValueError: If the wake word is not in the set of valid class labels.Returns:NoneRecord audiofromlivesttimportRecorderimporttimerecorder=Recorder("test.wav")recorder.start()# Starts recorder threadtime.sleep(5)# Waits before ending threadrecorder.end()# Writes recording to "test.wav"TheRecorderclass when started starts a new recorder thread where it will listen to the audio until the thread is ended. Upon the thread ending, the recording will be saved to a file. TheRecorderclass takes these args:chunk(int): The number of audio frames per buffer.format(int): The sample format for the recording.channels(int): The number of channels for the recording.fs(int): The sample rate of the recording.filename(str): The name of the output file where the recording will be saved.The file_ MUST currently be .wavlistening(bool): A flag indicating whether the recorder is currently recording.Transcribe a given audio filefromlivesttimporttranscribetranscription=transcribe("test.wav")fortintranscription:print(t.text)Thetranscribefunction transcribes the given audio file and outputs the transcribed text along with other information. Thetranscribefunction takes these args:input_file(str): The path to the audio file to be transcribed.language(str): The language of the audio file. The default is "en" (English).model_name(str): The name of the model to be used for transcription. The default is "tiny.en".This function yields a tuple with the following fields:text(str): The transcribed text.language_probability(float): The probability of the detected language.language(str): The detected language.segment_end(float): The end time of the transcribed segment.segment_start(float): The start time of the transcribed segment.ExamplesFor a full example, check out the example in the fileexample/main.py.Tech stackPyaudiofor recording audio.faster-whisperfor transcription.openWakeWordfor wakeword detection.AcknowledgmentsThanks toKoljafor the inspiration. I couldn't figure out how to use his library so I made my own. Check this outhere.ContributionContributions are always welcome! Open an issue or make a PR. Or just contact me on discord: @a3l6Author(s)@a3l6
Package: live_stylus
python-live-stylus==============Convert stylus to css real time. Easily used with any web framwork.It depends on the Python Stylus: https://github.com/bkad/python-stylusAnd the Python Stylus depends on [Node](http://nodejs.org) and [Stylus](http://learnboost.github.com/stylus/)So you need install nodejs and stylus node package before .#Install```pip install live-stylus```#UsageFor example , in a flask project :```pythonfrom flask import Flaskfrom live_stylus import ConvStylusapp = Flask(__name__)from views import *if __name__ == "__main__":app.debug = TrueConvStylus()app.run()```In a bottle project :```pythonfrom bottle import route, run, templatefrom live_stylus import ConvStylus@route('/hello/:name')def index(name='World'):return template('<b>Hello {{name}}</b>!', name=name)if __name__ == "__main__":ConvStylus()run(host='localhost', port=8080)```Then when you modify a .styl file , it will be converted to a same name css file immediately.eg. css/global.styl => css/global.cssIf you use other web framwork , just put the ConvStylus() before the .run() or .start() code.If you want monitor a explicitly directoty's stylus file , you can use:```pythonConvStylus('/home/xxx/work/project/static/css')```## Questions?If you have any questions, please feel free to ask through [New Issue](https://github.com/allenm/python-live-stylus/issues/new).## Licensepython-live-stylus is available under the terms of the [MIT License](https://github.com/allenm/python-live-stylus/blob/master/license).
Package: livetest
Inspired by Ian Bicking’s excellentWebTest, this is an extension to allow the same sort of simple pythonic testing to be used against running sites. Many tests written for WebTest will be able to be used directly on LiveTest.This enables the full platform (app servers, load balancers, routing, DNS, etc) to be tested rather than just the internal WSGI application.InstallationSimple as:$ easy_install livetestOr with pip:$ pip install livetestOr grab the development version:$ easy_install livetest==devUsageSetup an app to test against with just a hostname:>>> import livetest
>>> app = livetest.TestApp('www.google.com')Make requests just like WebTest:>>> resp = app.get('/')Grab forms:>>> resp.forms
{0: <webtest.Form object at 0x10118ac50>}
>>> form = resp.forms[0]
>>> form.fields
{'btnI': [<webtest.Submit object at 0x10118ae10>],
 'btnG': [<webtest.Submit object at 0x10118add0>],
 'q': [<webtest.Text object at 0x10118ad90>],
 'source': [<webtest.Hidden object at 0x10118ad10>],
 'hl': [<webtest.Hidden object at 0x10118acd0>],
 'ie': [<webtest.Hidden object at 0x10118ad50>]}Submit forms:>>> form['q'] = 'python testing'
>>> resp = form.submit()Test stuff in the response:>>> resp.mustcontain('Agile', 'unittest', 'PyUnit')
>>> resp
<200 OK text/html body='<!doctype...v>  '/25498>
>>> resp.status
'200 OK'CreditsThanks to Edward Dale (scompt) for various fixes.LinkswebsiteWebTest homedevelopment versionLicenseLivetest is released under the MIT License. See the LICENSE file for more
information.
Package: live_thumb
Live thumbnail usingMJPEGandnginx_push_stream.UsageCompile Nginx withnginx_push_streamsupport. The example config also uses lua-nginx-module and lua-resty-redis to store and serve old snapshots from Redis, but this module is optional. The Nginx configuration should be something like this:$ LUAJIT_LIB=/usr/local/lib/ LUAJIT_INC=/usr/local/include/luajit-2.0 ./configure --add-module=../nginx-push-stream-module --add-module=../lua-nginx-module --with-pcre --with-ipv6 --with-ld-opt=-L/usr/local/libNow run Nginx with sample config:$ nginx -c $PWD/nginx.confMake a directory to store the thumbs$ mkdir -p frames/partsStart ffmpeg to create thumbs for a channel (partsin this example):$ ffmpeg -re -i rtmp://example.com/live/stream -vf "scale=159:-1" -r 3 frames/parts/thumb%9d.jpgRun the broadcaster:$ python broadcaster.pyIf you prefer, install the script usingpipand run it:$ pip install live_thumb
$ broadcasterWatch the movie with the example html:$ open test.htmlOr go tohttp://localhost:9080/sub/partsdirectly.To also store the snapshots on redis, you should run the broadcaster with an extra env variable:$ REDIS_HOST="localhost" REDIS_PORT=7000 python broadcaster.pyThe snapshots will be served fromhttp://localhost:9080/snapshot/parts. You can also specify a timestamp:http://localhost:9080/snapshot/parts?timestamp=1396381230
Package: live-transcribe
Live TranscribeLive Transcribe is a Python package that provides live, real-time transcription based on OpenAI's Whisper. Works
offline.Currently, Live Transcribe supports only PulseAudio as an audio backend.Installationoptional but highly recommended for low latencyRefer to thePytorch documentation guideto install Pytorchwith CUDA support.pip install live-transcribeUsageJust run:python -m live_transcribeorlive_transcribeIf you want to transcribe from another audio device, than the default, use the--deviceoption, e.g.:live_transcribe --list-devices
live_transcribe --device "alsa_input.usb-046d_HD_Pro_Webcam_C920_8C0B5B0F-02.analog-stereoOn the first usage, the OpenAI's Whisper model will be downloaded and cached.Seelive_transcribe --helpfor options.DependenciesLive Transcribe has the following dependencies:Python 3.8 or higher
OpenAI-Whisper
PulseAudio
Package: livetribe-plugins
LiveTribe’s simple Python plugin framework.Seethe LiveTribe sitefor more information.
Seegithubfor the
latest source.AboutThe LiveTribe Plugins distribution contains a simple Python plugin
framework.  It defines no classes that need to be implemented nor imposes
arbitrary lifecycle events or special plugin information files.Inspired by Calvin Spealman’s straight plugin,https://github.com/ironfroggy/straight.plugin.Issues / Questions / FeedbackAny issues with, questions about, or feedback for LiveTribe Plugins
should be sent to the livetribe-user list onLiveTribe’s Mailing Lists. For confirmed issues or feature
requests, open a case onjira.
Please do not e-mail any of the LiveTribe developers directly with issues or
questions - you’re more likely to get an answer on the list.InstallationIf you havedistributeinstalled you
should be able to doeasy_installlivetribe-pluginsto install
LiveTribe Plugins. Otherwise you can download the project source and dopython setup.py installto install.DependenciesThe LiveTribe Plugins distribution is supported and tested on Python 2.x (where
x >= 6) and Python 3.x (where x >= 2).Additional dependencies are:(to generate documentation)sphinx(to auto-discover tests)noseExamplesHere’s a basic example (for more see theexamplessection of the docs):from livetribe.plugins import collect_plugin_classes
from acme.framework import Factory

for plugin in collect_plugin_classes('acme.plugins', subclasses_of=Factory, recurse=True):
    instance = plugin()
    instance.work()DocumentationFull Documentation:http://readthedocs.org/docs/livetribe-plugins.You will needsphinxinstalled to generate the
documentation. Documentation can be generated by runningpython setup.py doc. Generated documentation can be found in thedoc/build/html/directory.TestingThe easiest way to run the tests is to installnose(easy_install nose) and runnosetestsorpython setup.py testin the root
of the distribution. Tests are located in thetests/directory.
Package: liveupstoxoc
liveupstoxocFetch live OptionsChain from Upstox for freeInstallationMake sure you've installed chromedriver as per your systen.
If not use download chromedrivers fromhttps://chromedriver.storage.googleapis.com/index.html?path=95.0.4638.17/pipinstallliveupstoxocHow to use the libraryfromliveupstoxocimportlive_upstox_ocn=live_upstox_oc.upstox_oc(pathtochromedriver)#Now enter login details of your upstox accountn.login(username,password,2fa)#Now you're ready for fetch live options chain.#For fetching optionschain of NIFTY and BANKNIFTYoc=n.get_oc("NIFTY")# or "BANKNIFTY"#For fetching optionschain of Stocksoc=n.get_oc("3426")#For fetching option chain of TataPower. Similarly enter Token of the stocks you want to Fetch options chain for.#To close the chromedrivern.close()
Package: livevox-pypi
livevox-pypilivevox-pypi is a Python library for dealing with not supported livevox API functions.InstallationUse the package managerpipto install livevox-pypi.pipinstalllivevox-pypiUsagefromlivevox_apiimportlivevox_pypiaslv# Set selenium optionsoptions=lv.setting_selenium_options(headless=False)#Initialize webdriver objectdriver=webdriver.Chrome('./chromedriver',options=options)# Login Into Livevoxlv.login_livevox(driver,username='javier',password='ilovepython',client_code='Python_client')ContributingOnly the owner will pull requests in this project.LicenseMIT