Saravanan666/pypi-org huggingface dataset:
Package: runesdb
RuneS-DBRuneS-DB is a platform whereresults from different projects on runic inscriptionsare combined.This repository is completely independent from RuneS-DB.InstallationWorks for Python 3.6 and above.$ pip install runesdbSourcesThe data is availableherewhere you can export results of a query by clicking on a small
button whose id is "butDownloadExcelModal" (I note it here because I needed time to find it!).When you download data, you get this note:The rights to the data are held by the Göttingen Academy of Sciences and Humanities and are subject to the CC-BY- SA law. The RuneS research units Göttingen, Eichstätt-München and Kiel were involved in the generation of the data. RuneS-DB contains data from the Kiel Runenprojekt, the Danish database runer.ku.dk and the Samnordisk runtextdatabas/Rundata accessible under the Open Database License (ODbL). Please also note the additional information on other origin of the data provided under the label sources .If you confirm by clicking on "Download data", you will get a file named "runes_data.csv".CodeUserreader.pyjust to read your data.visualize.pyprovides a basic example on how to look at data according
to estimated time of creation of runic inscriptions;
Package: run-exe
# Overview #Run executable file, with option to try as admin on error on Windows.# Usage #The following example opens a temporary file in the root ofC:.  This should
prompt the user to permit the process to run with elevated privileges.import sys
import tempfilet = tempfile.mktemp(dir=’C:/’)run_exe(sys.executable, ‘’’ -c “’’’‘’’import os;’’’
‘’’open(‘%s’, ‘wb’)’’’
‘’’os.remove(%s)”’’’ % (t, t),
try_admin=True)
Package: runexp
runexpLibrary to run experiment from argparse or config file with slurmExamplesargparseTo work with the builtinargparselibrary, have a look at the fileexamples/argparse/main.py. The only change required is the line to parse the arguments :import argparse
from runexp import parse

parser = argparse.ArgumentParser(...)

parser.add_argument(...)- args = parser.parse_args()+ args = parse(parser)# rest of the program, using `args`
time.sleep(5.0)
pprint.pprint(vars(args))If you don't specify any special options, it's likerunexpwas never there in the first place.pythonexamples/argparse/main.pytarget--string'a bc'--float0.1--no-option--scTo perform a parameter sweep, you can prefix key-value arguments withsweep-and write all values as a coma separated list. Because dry-run is the default, it will print the command to execute the script and show a description equivalent to what the run would be :$pythonexamples/argparse/main.pytarget--string'a bc'--sweep-float0.1,0.2,0.3--no-option--sc===DRYRUN===runthecommandbelowforanactualexecution
pythonexamples/argparse/main.pytarget--string'a bc'--sweep-float0.1,0.2,0.3--no-option--sc--runexp-no-dry-run===============/home/maxime/repos/runexp/.venv/bin/pythonexamples/argparse/main.pytarget--float0.1--no-option--sc--string'a bc'/home/maxime/repos/runexp/.venv/bin/pythonexamples/argparse/main.pytarget--float0.2--no-option--sc--string'a bc'/home/maxime/repos/runexp/.venv/bin/pythonexamples/argparse/main.pytarget--float0.3--no-option--sc--string'a bc'If you want to run this code on a SLURM cluster, you can do it as follows :$pythonexamples/argparse/main.pytarget--string'a bc'--float0.1--no-option--sc--runexp-slurm===DRYRUN===runthecommandbelowforanactualexecution
pythonexamples/argparse/main.pytarget--string'a bc'--float0.1--no-option--sc--runexp-slurm--runexp-no-dry-run===============Behavior inconsistanceWhat should happen if no runexp option is given ?For the ArgParse case, it makes sense that if no RunExp option is found, nothing happens : RunExp should be minimally intrusive and avoid breaking everything, so args are returned as if RunExp did nothing.For the ConfigFile case, it is not possible to run the program without RunExp as this is the way to parse the config. If it makes sense to re-use the function, it should be defined elsewhere and the decorator should be used as a function.Moreover, because the ArgParse function needs to return the namespace, it should exit the process on a dry run, while the ConfigFile currently doesn't.
Package: runexpy
runexpy - Experiment managerPython library to perform multiple executions of a script with different parameters,
manage the results and collect them.How does it work?Get you scriptWrite a script (it can be a Python program or any command line executable) which can take
command line parameters in GNU standard, i.e. in the format--arg=value.The script can print anything on standard output and standard error. Moreover, it can
produce any file in the current working directory, e.g.output.txtcan contain the
result computed by the script.Example of a Python script, e.g.script.pyimportrandomfromargparseimportArgumentParserdefmain():ap=ArgumentParser("Draw a random number")ap.add_argument("--seed","-s",type=int,required=True)ap.add_argument("--lower","-l",type=float,default=0)ap.add_argument("--upper","-u",type=float,default=1)args=ap.parse_args()random.seed(args.seed)draw=args.lower+random.random()*(args.upper-args.lower)withopen("output.txt","w")asf:f.write(str(draw))if__name__=="__main__":main()Define you experimental settingsWrite a Python script that defines the experiments you want to run.Example, e.g. experiment.pyfromrunexpy.campaignimportCampaignfromrunexpy.runnerimportSimpleRunnerdefmain():# for a python scriptscript=["python3","script.py"]# for any command-line executable# script = "my-program"campaign_dir="campaigns"# define the arguments with their default value if any, else Nonedefault_params={"seed":None,"lower":0,"upper":1,}c=Campaign.new(script,campaign_dir,default_params)runs={"seed":[0,1,2],"lower":[0,0.5],}# equivalent to# runs = [#     {"seed": 0, "lower": 0,   "upper": 1},#     {"seed": 0, "lower": 0.5, "upper": 1},#     {"seed": 1, "lower": 0,   "upper": 1},#     {"seed": 1, "lower": 0.5, "upper": 1},#     {"seed": 2, "lower": 0,   "upper": 1},#     {"seed": 2, "lower": 0.5, "upper": 1},# ]# run the experimentsrunner=SimpleRunner()c.run_missing_experiments(runner,runs)# parse resultsforresult,filesinc.get_results_for(runs):withopen(files["output.txt"])asf:draw=f.read()print(f"Draw in interval [{result.params['lower']},{result.params['upper']}]"f" with seed{result.params['seed']}:{draw}")# print("stdout: ", open(files["stdout"]).read())# print("stderr: ", open(files["stderr"]).read())if__name__=="__main__":main()Run your experimentsBy running yourexperiment.py, runexpy will create a directory containing all your experiments
with the corresponding results and files produced. A database is kept to store all the informations
and allow for an easy retrieval of the outputs.
Package: runfalcon-build-tools
RUNFALCON BUILD TOOLSThis package contains tools to facilitate building and deployment applications for runfalcon teamREQUIEREMENTSBefore installing RUNFALCON BUILD TOOLS, be sure you have installed:Git Client (Installer)Docker (Installer)AWS cli V2 (Installer)USAGEpython3 -m runfalconbuildtools <command> <operation> [args]Whereargsrepresents a list ofoperationarguments in format:key1=value1value2=value2...Commands3-artifactDownloads an artifact from S3 repositoryOperationDescriptionExamplegetDownload an specific artifactTo download apache-jmeter-runfalcon version 1.0.0 run:python3 -m runfalconbuildtools s3-artifact get name=apache-jmeter-runfalcon version=1.0.0 outdir=./jmeterCommandcode-artifactDownloads an artifact from AWS Code artifact repositoryOperationDescriptionExamplegetDownload an specific artifactTo download runfalcon-agent-receiver version 1.0.10 run:python3 -m runfalconbuildtools code-artifact get domain=runfalcon repository=Runfalcon package=runfalcon-agent-receiver namespace=com.runfalcon.agentreceiver package-version=1.0.10 format=maven outdir=./artifactsCommandconfigManage configuration filesOperationDescriptionExamplejsonModify values in a json formatted fileTo changeconfig-1in json filemy-json.jsonrun:python3 -m runfalconbuildtools config json file=my-json.json config-1="new value"propertiesModify values in a properties fileTo changeconfig-1in properties filemy-props.propertiesrun:python3 -m runfalconbuildtools config properties file=my-props.properties config-1="new value"downloadDownloads properties file from runfalcon repoTo download config file ofmy-appforSTAGEenvironment in curren directory run:python3 -m runfalconbuildtools config download application=my-app env=STAGE outdir=.CommandkeysHandle key files for applicationsOperationDescriptionExamplegetDownload keys files for an applicationTo downlaod ssh keys for applicationmy-appinto current directory, forSTAGEenviroment run:python3 -m runfalconbuildtools keys get application=my-app name=ssh env=STAGE outdir=.CommandsslHandle ssl certificate files for applicationsOperationDescriptionExampledownloadDownload ssl certificate files for an applicationTo downlaod ssl certificate files for applicationmy-appinto current directory, forSTAGEenviroment run:python3 -m runfalconbuildtools ssl download application=my-app env=STAGE outdir=.
Package: runflow
What Runflow is?Runflow is a tool to define and run workflows. To find out more about Runflow, check outrunflow.org.Runflow supports Python (3.7, 3.8, 3.9).
The main audiences are devops, data scientists and hackers.Runflow is in alpha release stage.What Runflow is Not?Runflow is not job scheduler. It does not schedule the job runs for you. However, you can combine Runflow with some existing scheduling solutions to run your job periodically, such as APScheduler, crontab, etc.Runflow is not a job worker. It does not watch workloads from somewhere such as job queue. When the job run is complete, the program exits. Nonetheless, it's quite easy to integrate Runflow with some existing worker solutions, such as Celery, Python-RQ, etc.GoalsSimple: We want you feel simple when developing and running workflows. No hazzle.Flexible: We want it integrate to many existing solutions to broaden its use cases.How You Will Use Runflow?Runflow provides building blocks for defining tasks and workflows, failure recovering, command-line interfaces, etc.Typically, you willDefine your workflows in HCL2 syntax.Run your workflows using a simple commandrunflow run.You can choose whatever technology stack you’re familiar with and glue them using Runflow.Alternatives: Airflow, Prefect, Oozie, Azkaban.Getting StartedSetup Python EnvironmentFirst, prepare a Python environment:$python3-mvenvenv
$sourcevenv/bin/activateRunpip install runflowto install the latest version fromPyPI.$pipinstallrunflowTo install the HEAD, runpip install git+https://github.com/soasme/runflow.git.Write a Flow SpecNext, write a flow spec. Let’s create a file "example.hcl":$mkdirmyrunflow
$cdmyrunflow
$viexample.hcl# File: example.hclflow"example"{variable"content"{default="Hello World!"}task"bash_run" "echo"{command="echo ${var.content}"}}Run the FlowAt last, let’s run it.$runflowrunexample.hcl
HelloWorld!

$runflowrunexample.hcl--var="content=Hello Runflow!"HelloRunflow!What’s Next?From this point, you have run a minimal example using Runflow.For more information, please head to the fulldocumentation.TestTo run all of the test cases, please run:make lint test.Get in TouchPlease report an issue at:https://github.com/soasme/runflow/issues.
Package: run-fortran
run-fortranIn what followspythonis an alias forpython3.5orpypy3.5or any later version (python3.6,pypy3.6and so on).InstallationInstall the latestpip&setuptoolspackages versionspython-mpipinstall--upgradepipsetuptoolsUserDownload and install the latest stable version fromPyPIrepositorypython-mpipinstall--upgraderun_fortranDeveloperDownload the latest version fromGitHubrepositorygitclonehttps://github.com/lycantropos/run-fortran.gitcdrun_fortranInstallpythonsetup.pyinstallUsageList available commands & optionsrun-fortran--helpDevelopmentBumping versionPreparationInstallbump2version.Pre-releaseChoose which version number category to bump followingsemver
specification.Test bumping versionbump2version--dry-run--verbose$CATEGORYwhere$CATEGORYis the target version number category name, possible
values arepatch/minor/major.Bump versionbump2version--verbose$CATEGORYThis will set version tomajor.minor.patch-alpha.ReleaseTest bumping versionbump2version--dry-run--verbosereleaseBump versionbump2version--verbosereleaseThis will set version tomajor.minor.patch.Running testsPlainpytestInsideDockercontainer:withCPythondocker-compose--filedocker-compose.cpython.ymlupwithPyPydocker-compose--filedocker-compose.pypy.ymlupBashscript:withCPython./run-tests.shor./run-tests.shcpythonwithPyPy./run-tests.shpypyPowerShellscript:withCPython.\run-tests.ps1or.\run-tests.ps1cpythonwithPyPy.\run-tests.ps1pypy
Package: rungalileo-tidecv
A GeneralToolbox forIdentifying ObjectDetectionErrors████████╗██╗██████╗ ███████╗
╚══██╔══╝██║██╔══██╗██╔════╝
   ██║   ██║██║  ██║█████╗  
   ██║   ██║██║  ██║██╔══╝  
   ██║   ██║██████╔╝███████╗
   ╚═╝   ╚═╝╚═════╝ ╚══════╝An easy-to-use, general toolbox to compute and evaluate the effect of object detection and instance segmentation on overall performance. This is the code for our paper:TIDE: A General Toolbox for Identifying Object Detection Errors(ArXiv) [ECCV2020 Spotlight].Check out our ECCV 2020 short video for an explanation of what TIDE can do:InstallationTIDE is available as a python package for python 3.6+ astidecv. To install, simply install it with pip:pip3installtidecvThe current version is v1.0.1 (changelog).UsageTIDE is meant as a drop-in replacement for theCOCO Evaluation toolkit, and getting started is easy:fromtidecvimportTIDE,datasetstide=TIDE()tide.evaluate(datasets.COCO(),datasets.COCOResult('path/to/your/results/file'),mode=TIDE.BOX)# Use TIDE.MASK for maskstide.summarize()# Summarize the results as tables in the consoletide.plot()# Show a summary figure. Specify a folder and it'll output a png to that folder.This prints evaluation summary tables to the console:-- mask_rcnn_bbox --

bbox AP @ 50: 61.80

                         Main Errors
=============================================================
  Type      Cls      Loc     Both     Dupe      Bkg     Miss
-------------------------------------------------------------
   dAP     3.40     6.65     1.18     0.19     3.96     7.53
=============================================================

        Special Error
=============================
  Type   FalsePos   FalseNeg
-----------------------------
   dAP      16.28      15.57
=============================And a summary plot for your model's errors:Jupyter NotebookCheck out theexample notebookfor more details.DatasetsThe currently supported datasets are COCO, LVIS, Pascal, and Cityscapes. More details and documentation on how to write your own database drivers coming soon!CitationIf you use TIDE in your project, please cite@inproceedings{tide-eccv2020,
  author    = {Daniel Bolya and Sean Foley and James Hays and Judy Hoffman},
  title     = {TIDE: A General Toolbox for Identifying Object Detection Errors},
  booktitle = {ECCV},
  year      = {2020},
}ContactFor questions about our paper or code, make an issue in this github or contactDaniel Bolya. Note that I may not respond to emails, so github issues are your best bet.
Package: rungsted
[![Build Status](https://travis-ci.org/coastalcph/rungsted.svg?branch=master)](https://travis-ci.org/coastalcph/rungsted)## Rungsted structured perceptron sequential tagger### InstallThe software is installable via PyPI, e.g. do` pip install rungsted `### DemoThe repository contains a subset of the part-of-speech tagged Brown corpus. To run the structured perceptron labeler on this dataset, execute:python src/labeler.py--traindata/brown.train--testdata/brown.test.vwRungsted’s input format is closely modeled on the powerful and flexible format of [Vowpal Wabbit](https://github.com/JohnLangford/vowpal_wabbit/wiki/Input-format),
with the exception that Rungsted is perfectly fine with labels that are not integers.### DatasetsProvided you have a working installation of NLTK, you can recreate the Brown dataset with this command.python rungsted/datasets/cr_brown_pos_data.py data/brown.train.vw data/brown.test.vwThere is also a scriptrungsted/datasets/conll_to_vw.pyto convert from CONLL-formatted input to Rungsted### Building and uploading to PyPIFirst, runpython setup.py sdistto generate a source distribution.
Then upload the distribution files to PyPI with twine:twine upload dist/*.To develop locally, usepython setup.py develop.
Package: runhelper
runhelperrunhelperis a small library that helps you logs metrics for your instances and stores them on a easy to parse CSV file.Tool-side UsageCurrently, there are three main types of metric supported.Timer tagsTimer tags are used to time specific parts of your code.runhelper.timer_start('my.tag')
time_sensitive_code1()
time_sensitive_code2()
runhelper.timer_stop('my.tag')Times are accumulated during the execution of your tool.Counter tagsCounter tags are used to count events.runhelper.tag_increment('my.tag')You can optionally increment the tag by a value different than 1 (floats are also supported).runhelper.tag_increment('my.tag', 3)Custom tagsYou can also log any custom values you want.runhelper.log_any('my.tag', my_object)Automatic logging at program terminationBy default,runhelperlogs all timer and counter tags on normal program termination. If you also want to log when the program is force terminated you need to register the SIGTERM handler:runhelper.register_sigterm_handler()If you wish to perform additional operations when a SIGTERM happens you can also pass a callback:runhelper.register_sigterm_handler(callback_function)Evaluation-side UsageThe evaluation side ofrunhelperconsists of a single class that encapsulates all functionality. TheRunnerclass helps you run instances in parallel, supports timeouts and memouts (when used withrulsolver) and extracts all the tags logged from your tool into an easy to parse CSV file. The tool also allows you to transparently resume a previously running experiment, skipping all the instances that were executed already. The following snippet exemplifies its usage:instances = [ INSTANCE_LIST ]

runner = Runner('path_to_runsolver', 'output_file.csv',
                 timeout=TIMELIMIT_IN_SECONDS,
                 memout=MEMLIMIT_IN_KBS,
                 pool_size=NUM_PROCESSES)
                 
for instance in instances:
    runner.schedule(instance, [TOOL_EXECUTABLE, ARG1, ARG2, ...], INSTANCE_OUTPUT_FILE)
    
runner.wait()This code will, for each instance, call the commandTOOL_EXECUTABLEwith the arguments you specify and save its output toINSTANCE_OUTPUT_FILE. The result is a CSV file containing one line for each instance with some basic info, plus all the tags that you logged during the tool execution. Here is an example of an output file:instancerealcpuramtimeoutmemoutmy.tag.1my.tag.2i13.23.15600FalseFalse0.346i2109.86200TrueFalse0.211i32.121200FalseFalse0.013
Package: runHiC
runHiC is an easy-to-use command-line tool for Hi-C data processing.Since version 0.8.6, runHiC has supported data from all kinds of 3C-based experiments,
including Hi-C, Micro-C, HiChIP/PLAC-Seq, and ChIA-PET. For experiments that do not use
restriction enzymes for DNA fragmentation, you can set the enzyme name arbitrarily for your
record. For example, for Micro-C, you can set it toMNase; for ChIA-PET, you can set it tosonication.Since version 0.8.5, runHiC has changed the default aligner tochromap,
which is comparable tobwa-memin alignment accuracy, but runs over 10 times faster.Since version 0.8.1, runHiC can be used directly onArima HiCdata
by setting the enzyme name toArima.Since version 0.8.0, runHiC has changed its default data container/format from HDF5 toPairsandCooler.Design ConceptsrunHiC is designed to process Hi-C data from raw sequencing reads(.sra, .fastq, .fastq.gz) to the ICE-corrected
contact matrices. It currently contains 5 subcommands:mappingMap raw sequencing reads to a supplied genome. Support three read aligners: chromap, bwa and minimap2.filteringPerform read-level and fragment-level noise removingbinning1.Generate contact matirx; 2. Perform ICE/matrix-balancing normalizationpileupPerform the entire processing steps frommappingtobinningqualityEvaluate the quality of your Hi-C dataLinksDetailed DocumentationInstallationQuick StartData QualityParallel ComputationCode Repository(At GitHub, Track the package issue)PyPI(Download and Installation)UsageOpen a terminal, typerunHiC-horrunHiC <subcommand>-hfor help information.CitationXiaotao Wang. (2016). runHiC: A user-friendly Hi-C data processing software based on hiclib. Zenodo.10.5281/zenodo.55324
Package: runif
ContentsRunifWhy?FEATURESHISTORYLaunch exampleUnstable interfaces / Dev notesTestsRELEASE HISTORYRunifIdempotent andminimalpython 3 library for rapid scripting. Provide
support for creating file, adding data to them, patching and so on.Why?(Ba)sh scripting is very easy to setup. So we end up using it all the
time for simple procedural script.Firing up python for a simple task seems too much but… what if a library
will not only simplify scripting but offer some feature out of the box?Sometimes is it useful to have idempotent script, like Ansible and
Saltstack teach us.runif enable an idempotent, functional programming-way.FEATURESNo dependency: it works with python library out of the boxPython logging integration: debug, info level are tuned to provide you the right amount of informationBattle tested on complex scenariosHISTORYI have the need for a idempotent script for a complex set of migration procedures. Bash was a pain.
Java was an overkill so runif popped out.Try the examples running them from the root directoryThe run() function is very handy to fire direct command,
like running git pull or so on (as in a bash script)Note: runif it is NOT a replacement for Gradle, GNU Make, Maven, etc.Launch exampleInstall the package with > python setup.py installHere an example of what happen if you run twice thesamescript:$  python examples/stepByStep.py
[INFO] runif.py.run_if_missed demo ===> step1
[INFO] runif.py.run_if_missed demo/demofile.txt ===> step2
[INFO] runif.py.run_if_missed demo/demofile2.c ===> step2
[INFO] runif.py.run_if_unmarked demo/demofile.txt ===> Step3
[INFO] runif.py.run_if_present demo/demofile.txt ===> <lambda>
demo/demofile.txt present!
[INFO] runif.py.run_each demo\demofile2.c ===> <lambda>
** demo\demofile2.c

$  python examples/stepByStep.py
[INFO] runif.py.run_if_present demo/demofile.txt ===> <lambda>
demo/demofile.txt present!
[INFO] runif.py.run_each demo\demofile2.c ===> <lambda>
** demo\demofile2.cUnstable interfaces / Dev notesrun_each               is still unstable
run_if_modified        is brand new and not tested on a huge set of test cases. it is NOT thread safeSee ./CHANGELOG.md for the last modificationTestsInstall py.test withpip install pytestrun with PYTHONPATH=. pytestThe PYTHONPATH variable is used to ensure you are using the current
version and not another possibly installed one on your envSeehttps://docs.pytest.org/en/latest/example/index.htmlfor usage
examplesRELEASE HISTORYv1.0.4 - June Stable release
v0.0.x - May 2020 First public release
Package: runigma
# periodicRuNigma is a fictional cypher machine inspired by World War 2's Enigma Machines.# Setup```bashpip install runigma```# Example usage```pythonfrom runigma import RuNigmaMachinerotors = 'Ё Ь Д Н Й'reflector = 'Ш'ring_settings = 'a _ y g Б'plugboard_settings = 'xЕ hЬ КМ Тn iЗ АЛ ЮЫ Бt z8 ОШ wЯ y0 a7 4Ъ СЖ p6 Эe g_ 2b dc'machine = RuNigmaMachine.from_key_sheet(rotors=rotors, reflector=reflector, ring_settings=ring_settings,plugboard_settings=plugboard_settings)machine.set_display('ЯХ3ОЪ')crypted = machine.process_text('hello world')print(crypted)# displays: БЮУЦwЛgcЭЕМ```# Command line tools## runigmaThis tool can be used for encipher and decipher text.```bashrunigma --key-file=enigma.keys -s ФСИАР -t HELLOXWORLDX``````bashrunigma -r A Б В Г Д -i a b c d -p AB CD EF GH IJ KL MN -u Ф -s АУГСД```## runigma-sheetThis tool can be used for generate new key sheet file.```bashrunigma-sheet > keysheet.txt```