Saravanan666/pypi-org huggingface dataset:
Package: runmetricsvisualizer
RunMetrics VisualizerA handy developer tool for storing function runtime data and graphing it via GUI!Table of ContentsAbout The ProjectBuilt WithGetting StartedPrerequisitesInstallationUsageRoadmapContributingLicenseContactAcknowledgmentsAbout The ProjectThis personal project is meant to be a developer tool, aimed at mass running functions, storing their runtimes as CSV data, aggregating it, and using a GUI to create a graph of this data. This tool is pip installable, making it extremely easy for Python developers to use.Built WithPythonMatplotlibPandasTkinterPoetryPyPiGetting StartedPrerequisitespippip--versionInstallationSimply pip install the modulepipinstallrunmetricsvisualizerUsageimportrunmetricsvisualizerasrmvRunMetrics.run()Runs a specified function desired amount of times, outputs runtime data to CSV file as provided by user. Uses *args and **kwargs for function parameters.\RunMetrics.run(function,output_csv_file,*function_args,function_run_count,**function_kwargs)Example# our functiondefdo_something(num,iterations):forxinrange(num):sum([x**4forxinrange(iterations)])# (num = 100, iterations = 1000) Will generate 50 datapointsRunMetrics.run(do_something,'data/test.csv',100,1000,count=50)RunMetrics.plot()Opens a Tkinter-generated GUI window for customizing graph settings: datapoint colors, chart style, background theme, and chart title.RunMetrics.plot(CSVfile_to_plot_from)ExampleRunMetrics.plot('data/test.csv')# opens the following GUI menuRoadmapSee theopen issuesfor a full list of proposed features (and known issues).ContributingContributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make aregreatly appreciated.If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the MIT License. SeeLICENSE.txtfor more information.ContactRahul Vikram -LinkedInAcknowledgmentsGitHub PagesREADME.md Template
Package: runml-checks
Deepchecks is a Python package for comprehensively validating your machine learning models and data with minimal effort.
This includes checks related to various types of issues, such as model performance, data integrity,
distribution mismatches, and more.What Do You Need in Order to Start Validating?Depending on your phase and what you wise to validate, you’ll need a subset of the following:Raw data (before pre-processing such as OHE, string processing, etc.), with optional labelsThe model’s training data with labelsTest data (which the model isn’t exposed to) with labelsA model compatible with scikit-learn API that you wish to validate (e.g. RandomForest, XGBoost)Deepchecks validation accompanies you from the initial phase when you
have only raw data, through the data splits, and to the final stage of
having a trained model that you wish to evaluate. Accordingly, each
phase requires different assets for the validation. See more about
typical usage scenarios and the built-in suites in thedocs.InstallationUsing pippipinstalldeepchecks#--upgrade --userUsing condacondainstall-cdeepchecksdeepchecks
Package: run-models
ï»¿# run_modelsrun_modelslets you run many regression and classification models with their default parameters and rank them by RMSE or AUC.Installationpip install run_modelsDependenciesnumpypandasscikit-learnxgboostlightgbmcatboostmatplotlibHow to use it?run_modelscomes with two functions:run_models.run_regressors(data, target_column)for regression tasks - All models are ranked by RMSE.run_models.run_classifiers(data, target_column)for classification tasks - All models are ranked y AUC.import run_models as rmfig = rm.run_classifiers(titanic_data, 'Survived')
Package: runmonitor-RIFT
RIFT run-monitorA package providing utilities for monitoring and healing runs withRIFT. Built fromhttps://git.ligo.org/richard.udall/runmonitor_rift, with original work done athttps://git.ligo.org/richard.udall/miscelleaneous-scripts/Developed by Adhav Arulanandan, Grihith Manchanda, Joshua Brandt, Richard O'Shaughnessy, and Richard UdallInstallationThis package assumes the user is on an LDAS-like cluster.To install, do the standard: pip install runmonitor-riftConfigure environment variables:RUNMON_BASE = a sub-directory in a public-facing directory (e.g. ~/public_html/RUNMON/)RUNMON_CLUSTER = a designator for a cluster (e.g. CIT)Some functionality, especially for healing scripts, will work best if this is installed in an environment which also has RIFT installed, though overrides will usually be available.
Package: runnel
RunnelDistributed event processing for Python based on Redis Streams.https://runnel.devRunnel allows you to easily create scalable stream processors, which operate on
partitions of event streams in Redis. Runnel takes care of assigning partitions
to workers and acknowledging events automatically, so you can focus on your
application logic.Whereas traditional job queues do not provide ordering guarantees, Runnel is
designed to process partitions of your event stream strictly in the order
events are created.InstallationpipinstallrunnelBasic UsagefromdatetimeimportdatetimefromrunnelimportApp,Recordapp=App(name="myapp",redis_url="redis://127.0.0.1")# Specify event types using the Record class.classOrder(Record):order_id:intcreated_at:datetimeamount:floatorders=app.stream("orders",record=Order,partition_by="order_id")# Every 4 seconds, send an example record to the stream.@app.timer(interval=4)asyncdefsender():awaitorders.send(Order(order_id=1,created_at=datetime.utcnow(),amount=9.99))# Iterate over a continuous stream of events in your processors.@app.processor(orders)asyncdefprinter(events):asyncfororderinevents.records():print(f"processed{order.amount}")Meanwhile, run the worker (assuming code inexample.pyandPYTHONPATHis set):$runnelworkerexample:appFeaturesDesigned to support a similar paradigm to Kafka Streams, but on top of Redis.At least once processing semanticsAutomatic partitioning of events by keyEach partition maintains strict orderingDynamic rebalance algorithm distributes partitions among workers on-the-flySupport for nested Record types with custom serialisation and compressionBackground tasks, including timers and cron-style schedulingUser-defined middleware for exception handling, e.g. dead-letter-queueingA builtin batching mechanism to efficiently process events in bulkArunnel[fast]bundle for C or Rust extension dependencies (uvloop,xxhash,orjson,lz4)DocumentationFull documenation is available athttps://runnel.dev.GuideMotivationArchitectureAPI ReferenceBlog postsEssays about this project or the technology it's using:Redis streams vs. KafkaStructured concurrency in Python with AnyIOLocal developmentTo run the test suite locally, clone the repo and install the optional deps
(e.g. viapoetry install -E fast). Make sure Redis is running on localhost at
port 6379, then runpytest.See alsoFor a traditional task queue that doesn't provide ordering guarantees, see our
sister projectFennel.
Package: runnerase
runneraseAn Interface between the Runner Neural Network Energy Representation (RuNNer) and the Atomic Simulation Environment (ASE).Key Featuresreaders and writersfor all RuNNer file formats.Runner, anASE calculatorclass for managing the RuNNer workflow.SymmetryFunction/SymmetryFunctionSet, classes for generating and manipulatingatom-centered symmetry functions.Aplotting library for generatingnice figuresfrom RuNNer data.storage classesfor atom-centered symmetry function values, weights and scaling data of the atomic neural networks, the split between training and testing set, and the results of a RuNNer fit.RunnerSinglePointCalculator, an extension of the ASESinglePointCalculatorfor storing the total charge of a structure.InstallationThe package can be easily installed via pip. If they are not available,ASEandnumpywill be automatically installed as dependencies.$pipinstallrunneraseCreditsThis software is an extension of theAtomic Simulation Environment.The original code was written by Alexander Knoll - @aknoll -alexknoll@mailbox.org.LicenseThis software is distributed under the GPL v3. For details, seeLICENSE.
Package: runner.py
.. image:: https://badge.fury.io/py/run.py.svg:target: https://pypi.org/project/runner.py/.. image:: https://travis-ci.org/mariocesar/run.py.svg?branch=master:target: https://travis-ci.org/mariocesar/run.pyInstall and Use---------------Install with pip... code-block:: consolepip install runner.pyA simple example on how to use it... code-block:: pythonimport asynciofrom runnerpy.runner import Runnerif __name__ == '__main__':loop = asyncio.get_event_loop()runner = Runner(loop)runner.run('python manage.py runserver')runner.run('celery -A project worker -l INFO')runner.start()Now a Django app will run along the celery worker. Hit ctrl+c to stop both.Some examples: Creating a backup.. code-block:: pythonimport asynciofrom runnerpy.runner import Runnerif __name__ == '__main__':loop = asyncio.get_event_loop()runner = Runner(loop)runner.run('cp -ar dist/static public/static')runner.run('pg_dump --all')runner.start()Some examples: Creating a backup.. code-block:: pythonimport asynciofrom runnerpy.runner import Runnerif __name__ == '__main__':loop = asyncio.get_event_loop()runner = Runner(loop)runner.run('tail -f /var/log/syslog)runner.run('ls -al /home')runner.start()
Package: runnerz
Runnerzsimple runner like robot framework and httprunner相比于httprunner支持多种步骤,及自定义步骤支持dubbo接口用例支持多种步骤支持多种样式的报告,及自定义报告模板 reportz支持用例并发支持异步请求 aiohttp用例支持tag, level支持xpath支持trigger及设置定时任务 pytest-crontab支持更相信的请求连接信息 requestz支持json_schema断言支持直接使用python/js脚本支持参数化运行 cli / html支持自定义keywords支持的场景接口测试Web/App测试Dubbo接口测试定时任务特性HTTP默认配置用户自定义变量环境变量.env支持并发及多轮setup_hook/teardown_hookeq断言jsonschema断言xpath/jsonpath/re提取css selector提取根据条件跳过用例, skip表达式merge config多级steps支持ddt支持if/else/switch/whileargsoptionsadd options initriggerunittest用例har运行postman运行jmeter运行robotdubbo支持[x]自定义keywords由reportz支持重跑步骤组并行运行测试报告timeout限制Todo
Package: running
🏃‍♀️ running 🏃A flexible but user-friendly running pace calculator as a command line tool.Installation$ pip install runningUsageCallrunningwith two of the three argumentspace,distanceortime, and it will calculate the missing one for you.$ running --pace 4:30/km --distance marathon 
Elapsed time: 3:09:53 [H:]MM:SSYou can also just use the first letter of the argument names:$ running -p 4:30 -d marathonNote that distance unit for the pace was omitted, defaulting to kilometer. This can be changed with theunit(-u) parameter as follows:$ running -p 8:00 -d 10km -u miles
Elapsed time: 49:43 [H:]MM:SSYou can also directly specify the units for the pace:$ running -p 6min/mile -t 1hour
Travelled distance: 16.09 km
$ running -d half-marathon -t 1:45:00
Required pace: 04:59 /kmThe tool is quite flexible in terms of the valid expressions for the arguments, seerunning --helpfor more examples.Ever wondered how fast Usain Bolt would run a marathon?$ running -p bolt -d marathon
Elapsed time: 1:07:22 [H:]MM:SS
Package: runninglight
Running Light ControlA light-weight package for controlling a raspberry-pi connected LED running light.Example code:import RPi.GPIO as GPIO
import runninglight
import time


#Pin for the light
MPIN = 3

#set up
GPIO.setmode(GPIO.BCM)
GPIO.setup(MPIN, GPIO.OUT)

#create
rlm = runninglight.runninglightmanager(MPIN)

#run
rlm.set_mode(runninglight.light_mode.doubleblink_1sec)
rlm.start()
print("Started!")
Package: running-mate
Running MateVersion and monitor your models, record inferences, and send alerts without any additional infrastructure. Designed for small data science or machine learning teams lacking a full MLOps solution.Training:Create local SQLite databaseVersion modelGenerate baseline statsInference:Check features against baseline statsCreate and send alertsGetting StartedInstall:$pipinstallrunning-mateRunning Mate stores data in a local SQLite database. Start by creating the database, creating a new Mate (which represent your AI/ML model), and generate the baseline statistics:frommate.dbimportconnect_db,version_or_create_matefrommate.generatorsimportgenerate_baseline_statsconnect_db()mate=version_or_create_mate("mate-name")generate_baseline_stats(your_dataframe,"mate-name")This ideally happens at training time.Then, in your serving environment, define the alert targets, get the current Mate version, load the model, wrap you model prediction in thematecontext manager:frommate.alertsimportTerminalAlertTargetfrommate.dbimportconnect_db,get_current_matefrommate.runimportRunningMatealert_targets=[TerminalAlertTarget(),]connect_db()version=get_current_mate("mate-name").versionmodel=load(f"models/mate-name-{version}.joblib")withRunningMate("mate-name",version,your_dataframe,alert_targets):model.predict(enc.transform(your_dataframe))By default, not all feature values are recorded. To record all values, setshould_save_all_feature_valuestoTrue:withRunningMate("mate-name",version,your_dataframe,alert_targets,should_save_all_feature_values=True):model.predict(enc.transform(df))You can generate a summary stats report like so:frommate.generatorsimportgenerate_baseline_statsprint(generate_feature_stats_summary_report("mate-name"))ExamplesThe basic example project, found in "examples/basic", usesTerminalAlertTarget, for outputting alerts to the terminal, andAlertWebhookTarget, for sending alerts tohttp://localhost:5000/hook.Create/activate a virtual environment and install the dependencies:$cdexample/basic

$python3-mvenvvenv
$sourcevenv/bin/activate

$pipinstall-rrequirements.txtIn one terminal window, run the web server:$cdweb

$FLASK_DEBUG=1python-mflaskrunThen, train the model and run an inference through it in a different window:$pythontrain.py
$pythoninfer.pyNavigate tohttp://localhost:5000to see the alert.There's also a drift example inexamples/drift.DevelopmentAfter cloning down the repo, create/activate a virtual environment and install the dependencies:$python3-mvenvvenv
$sourcevenv/bin/activate(venv)$pipinstall-rrequirements-dev.txtInstall as local package:(venv)$pipinstall-e.Run tests:(venv)$python-mpytest.Lint, format code, and type check:(venv)$python-mflake8--ignore=E501,W503matetestsexamples(venv)$python-mblackmatetestsexamples(venv)$python-misort--profileblackmatetestsexamples(venv)$python-mmypymatetestsexamples
Package: running-ng
running-ngrunning-ngis a collection of scripts that help people run workloads in a methodologically sound settings.Installationpip3 install running-ngDevelopment setupvirtualenv envsource env/bin/activatepip install -U pip setuptools build[virtualenv]To make a distribution archives, runpython -m buildwithin the virtual environment.
To run an editable build in the virtual environment, runpip install -e ..
To install to usersite-packages, runpip install dist/running_ng-<VERSION>-py3-none-any.whloutside the virtual environment.There are twoextrasavailable.zulip: dependencies for theZuliprunbmsplugin.tests: dependencies for running tests.DocumentationPlease refer tothis sitefor up-to-date documentations.LicenseThis project is licensed under the Apache License, Version 2.0.
Package: running-performance
Python Running PerformanceThis is about running as in 🏃‍♀.This package contains functions to calculate running performance indicators as well as time predictions based on known running performances.MIT LicenseCopyright (c) 2019 Christian WygodaPermission 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: running-sign
Running_SignSmall tool to show dynamic indicator when program is running.Functionrunning_sign_rotation(interval= 0, msg_pre="", msg_post="", sign = ["\", "|", "/", "-", "|", "/", "-"])generator to show rotating indicator.
parameter:interval: number, seconds of interval time between every frame of indicator.msg_pre: string, content will show before indicator.msg_post: string, conent will show after indicator.sign: list, symbols which will be showed sequentially.running_sign_progress(interval=0, msg_pre = "", msg_post="", sign=".",  max_num = 120)generator to show progress bar.
parameter：interval: number, seconds of interval time between every frame of indicator.msg_pre: string, content will show before indicator.msg_post: string, conent will show after indicator.sign: string, symbols which will be showed in progress way.max_num: number, max numbers of sign in one bar progress.running_sign(interval=0, msg_pre="", msg_post="", sign=None, max_num=120)funtion, as entrance of two above function.parameter: refer to parameters in above function. If sign != None, will callrunning_sign_progress, otherwise will callrunning_sign_progress.return: generator.running_pct(msg_pre="", msg_post="", sign="■", pct=50, scale=1)function, show progress bar.
parameter:msg_pre: string, content will show before indicator.msg_post: string, conent will show after indicator.sign: string, symbols which will be showed in progress way.pct: number, length of progress bar.scale: number, scale of progress bar, default = 1 while the length of progress bar is 100 which means 100 signs.Examplers=running_sign_rotation(1)foriinrange(10):next(rs)
Package: runningstatistics
running-statsA simple Python module for computing the sample statistics of an array in a running/online fashion (when samples are not kept).This is just a Python port of [John Cook]'s C++ codehere. There is also a Julia implementation by John Myles Whitehere. The only special feature of this code is that we support computing running statistics of arrays living on a GPU via CuPy.You may also be interested in the Python moduleRunStats.My interest in computing statistics this way comes from summarizing the samples generated by a MCMC sampler when storing all of the samples is infeasible.
Package: run-octave
run-octaveA package for running Octave functions and calling Scripts in the Python interpreter!NoteInstallGNU Octave.Requirementspython 3scipyInstallationSimply install run-octave package fromPyPIpip install run-octaveExamplesfrom run_octave import RunOctave
import numpy as np

# Create the RunOctave object and explicitly add the path to octave-gui.exe
#octave = RunOctave(octave_path='C:/Program Files/GNU Octave/Octave-6.2.0/mingw64/bin/octave-gui.exe')
octave = RunOctave(octave_path='C:/Octave/Octave-5.2.0/mingw64/bin/octave-gui.exe')

A = np.array([[ 2, 0, 1],
              [-1, 1, 0],
              [-1, 1, 0],
              [-3, 3, 0]])

# Start Testing
m, n = octave.run(nargout=2, target='size', args=(A,))
print(m, n)

N = octave.run(nargout=1, target='vecnorm', args=(A, 2, 2))
print(N)

# Inserting expressions directly
X = octave.run(nargout=1, target='ones(4, 3) * 255;')
print(X)
Package: run-one
run-oneTool for parsing matrix files, extracting actions and processing them according to user defined logicHow to setup environment and install dependenciespython-mvenv$VENV_PATH$VENV_PATH/bin/pipinstall-Upipsetuptools$VENV_PATH/bin/pipinstallpoetry$VENV_PATH/bin/poetryinstall-Eth2Note:-E th2is optional and can be omitted if you don't need th2-related dependencies.Config example (using th2 processor)matrix_path:"matrix_case.csv"# path to matrix file or directory with matricesfilename_pattern:"*.matrix.csv"# matching pattern for files (can contain shell-style wildcards)processed_actions:# which actions to process (action name to name of handler class)send:"TH2ActHandler"receive:"TH2Check1Handler"store:"TH2EstoreHandler"sleep:"SleepHandler"actSsh:"TH2ActSSHHandler"field_mapping:# mapping for field renaming (old name to new name)TIF:"TimeInForce"nested_fields:["NoPartyIDs","OrderQtyData","Parties","Instrument"]# which fields to convert to collectionsfields_to_drop:# which fields to remove["PreviousID","Protocol","CaseName","Seq"]fields_to_extract:# which fields to extract and keep as additional information["Action","MessageType","Time","User","ID","ExecutionAlias","Direction","Description"]regenerate_id_fields:["ClOrdID","OrigClOrdID"]# ID-like fields to regenerateregenerate_time_fields:["TransactTime"]# Time-like fields to regenerateprocessor_config:# processor config in free formth2_configs:"th2_configs"# path to directory with th2 configsroot_event_name:'run-onerootevent'# name of created root eventbook:"test_book"# book namescope:"test_script"# scope nameuse_place_method:False# use th2 act place methods (True) or plain send (False)key_fields:# mapping of key fields (message type to list of field names with support of nested fields) for th2-check1 requestExecutionReport:-"Side"-"ClOrdID"-"OrigClOrdID"-Instrument:-"Symbol"fail_unexpected:"NO"# rule of failing the validation for th2-check1 request if any unexpected field receivedignore_fields:# mapping of fields (message type to list of field names) to be ignored in the th2-check1 rule validationExecutionReport:-"header"-"trailer"sleep:1# delay between each action processing in secondstimestamp_shift:1# for how many seconds to the past make a shift for event timestamps
Package: runp
runp exports Python functions from files to the command line.
You don’t need to change your existing code.If you have a file named myfile.py with:def foo():
    """beeps a lot"""
    print "beep beep"

def bar(text):
    """Prints things

    Args:
        text (str): The text to print
    """
    print textAnd you want to run it in the command line just do:$ runp myfile.py foo
beep beepYou can also pass arguments to your functions:$ runp myfile.py bar:"this is sweet!"
this is sweet!Functions with names starting with _ are hidden.You can list available functions with:$ runp myfile.py -l
Available functions:
foo    beeps a lot
bar    Prints thingsAnd get info on a specific function:$ runp myfile.py -d bar
Displaying docstring for function bar in module myfile

bar(text)
    Prints things

    Args:
        text (str): The text to printSyntax for calling functions is:$ runp myfile.py function_name:arg1value,arg2=arg2valueThe concept, syntax for commands and initial code are heavily inspired by fabric’s task system.
Package: runp3
runpThis repository is a modified of runp, which is no longer maintained, for modern Python 3.runp exports Python functions from files to the command line.
You don't need to change your existing code.If you have a file named myfile.py with::def foo():
    """beeps a lot"""
    print "beep beep"

def bar(text):
    """Prints things

    Args:
        text (str): The text to print
    """
    print textAnd you want to run it in the command line just do::$ runp myfile.py foo
beep beepYou can also pass arguments to your functions::$ runp myfile.py bar:"this is sweet!"
this is sweet!Functions with names starting with _ are hidden.You can list available functions with::$ runp myfile.py -l
Available functions:
foo    beeps a lot
bar    Prints thingsAnd get info on a specific function::$ runp myfile.py -d bar
Displaying docstring for function bar in module myfile

bar(text)
    Prints things

    Args:
        text (str): The text to printSyntax for calling functions is::$ runp myfile.py function_name:arg1value,arg2=arg2valueThe concept, syntax for commands and initial code are heavily inspired by fabric's task system.