Saravanan666/pypi-org huggingface dataset:
Package: arb-launcher
arb_launcherarb_launcheris a Python package that provides a simple yet powerful way to launch and manage detached programs and methods. It allows you to run external programs or Python methods in a completely detached process, making them independent of the parent process.FeaturesLaunch external programs and Python methods as detached processesRedirect thestdoutandstderrof the detached process to specific files (/dev/nullby default so that the output is never printed to the console)Terminate matching processes based on their names and argumentsFully daemonized processes, making them independent of the parent process and allowing them to run in the backgroundInstallationTo installarb_launcher, simply clone the repository and run the following command:pipinstallarb_launcherUsagearb_launcherprovides a simple command-line interface for launching detached programs. You can also use it as a method or library in your Python projects.Command-Line InterfaceTo use the command-line interface, simply run:arb_launcher<program>[args][--stdout<stdout_file>][--stderr<stderr_file>]Simplified Launch MethodThearb_launcherpackage also provides a simplified method,launch_detached, for quickly launching detached programs or methods:fromarb_launcher.launcherimportlaunch_detachedlaunch_detached(target,args,stdout=None,stderr=None)targetcan be either a string representing the command or a callable Python method.argsshould be a list of arguments, if any.stdoutandstderrare optional parameters to redirect the output to specific files.ExampleHere's an example of how to use the simplifiedlaunch_detachedmethod to launch a detached Python method:fromarb_launcher.launcherimportlaunch_detacheddefmy_method(arg1,arg2):# Your code herelaunch_detached(my_method,args=['arg1','arg2'],stdout='output.log',stderr='error.log')Python APITo use thearb_launcherpackage in your Python project, first import theProgramHandlerclass:fromarb_launcher.program_handlerimportProgramHandlerThen, create aProgramHandlerobject and call thelaunch()method:handler=ProgramHandler(target,args,stdout,stderr)handler.launch()targetcan be either a string representing the command or a callable Python method.argsshould be a list of arguments, if any.stdoutandstderrare optional parameters to redirect the output to specific files.ExampleHere's an example of how to use thearb_launcherpackage to launch a detached Python method:fromarb_launcher.program_handlerimportProgramHandlerdefmy_method(arg1,arg2):# Your code herehandler=ProgramHandler(my_method,args=['arg1','arg2'],stdout='output.log',stderr='error.log')handler.launch()
Package: arblay
arblayThis repository stores a source code for thearblaylibrary.arblayis a small unofficial extension ofmatplotlib, which aims at making matplotlib figures with arbitrary layouts.  You can easily generate a variety of figures specifying each Axes object size in pixel.Note: This repository only deals with rectangle-shaped figures having rectangle-shaped Axes with no rotation.  You cannot make any warped figures (i.e. rounds, trapezia, and triangles) and ones with tilting Axes.InstallRun the following code.pip install arblayHow to UseSee description ininstruction.md.You can try to generate some examples fromdemo.ipynbas well.
Package: arbor
Arbor LibraryArboris a library for implementing performance portable network simulations of multi-compartment neuron models.An installation guide and library documentation are available online atdocs.arbor-sim.org.Submit a ticketorjoin GitterorMatrixif you have any questions or need help.Citing ArborThe Arbor introductory paper and entry on Zenodo can be cited, seeCITATION.bib. Please refer toour documentationfor more information.
Package: arboreto
The most satisfactory definition of man from the scientific point of view is probably Man the Tool-maker.Inferring a gene regulatory network (GRN) from gene expression data is a computationally expensive task, exacerbated by increasing data sizes due to advances
in high-throughput gene profiling technology.Thearboretosoftware library addresses this issue by providing a computational strategy that allows executing the class of GRN inference algorithms
exemplified byGENIE3[1] on hardware ranging from a single computer to a multi-node compute cluster. This class of GRN inference algorithms is defined by
a series of steps, one for each target gene in the dataset, where the most important candidates from a set of regulators are determined from a regression
model to predict a target gene’s expression profile.Members of the above class of GRN inference algorithms are attractive from a computational point of view because they are parallelizable by nature. In arboreto,
we specify the parallelizable computation as adaskgraph [2], a data structure that represents the task schedule of a computation. A dask scheduler assigns the
tasks in a dask graph to the available computational resources. Arboreto uses thedask distributedscheduler to
spread out the computational tasks over multiple processes running on one or multiple machines.Arboreto currently supports 2 GRN inference algorithms:GRNBoost2: a novel and fast GRN inference algorithm usingStochastic Gradient Boosting Machine(SGBM) [3] regression withearly-stoppingregularization.GENIE3: the classic GRN inference algorithm usingRandom Forest(RF) orExtraTrees(ET) regression.Get StartedArboreto was conceived with the working bioinformatician or data scientist in mind. We provide extensive documentation and examples to help you get up to speed with the library.Read thearboreto documentation.Browse examplenotebooks.Report anissue.LicenseBSD 3-Clause LicensepySCENICArboreto is a component inpySCENIC: a lightning-fast python implementation of
theSCENICpipeline [5] (Single-Cell rEgulatory Network Inference and Clustering)
which enables biologists to infer transcription factors, gene regulatory networks
and cell types from single-cell RNA-seq data.ReferencesHuynh-Thu VA, Irrthum A, Wehenkel L, Geurts P (2010) Inferring Regulatory Networks from Expression Data Using Tree-Based Methods. PLoS ONERocklin, M. (2015). Dask: parallel computation with blocked algorithms and task scheduling. In Proceedings of the 14th Python in Science Conference (pp. 130-136).Friedman, J. H. (2002). Stochastic gradient boosting. Computational Statistics & Data Analysis, 38(4), 367-378.Marbach, D., Costello, J. C., Kuffner, R., Vega, N. M., Prill, R. J., Camacho, D. M., … & Dream5 Consortium. (2012). Wisdom of crowds for robust gene network inference. Nature methods, 9(8), 796-804.Aibar S, Bravo Gonzalez-Blas C, Moerman T, Wouters J, Huynh-Thu VA, Imrichova H, Kalender Atak Z, Hulselmans G, Dewaele M, Rambow F, Geurts P, Aerts J, Marine C, van den Oord J, Aerts S. SCENIC: Single-cell regulatory network inference and clustering. Nature Methods 14, 1083–1086 (2017). doi: 10.1038/nmeth.4463
Package: arboris
Arboris is a rigid body dynamics and contacts simulator written in python.Arboris includes a generic and easily extensible set of joints
(singularity-free multi-dof joints, non-honolomic joints, etc.) which are
used to model open rigid mechanisms with a minimal set of state variables.The dynamics of these systems are computed in a form similar to the
Boltzmann-Hamel equations.Using time-stepping and a semi-implicit Euler integration scheme, a first-order
approximation of the model is also computed. This allows for additional
constraints such as contacts and kinematic loops to be solved using a
Gauss-Seidel algorithm.Arboris is mostly useful for robotic applications and human motion studies.
The python language makes it particularly suited for fast-paced development
(prototyping) and education.BackgroundIn 2005, Alain Micaelli, a researcher from CEA LIST, wrote a first version of
the simulator in the matlab language. It was an implementation (and often an
extension) of the algorithms described in[Park2005],[Murray1994]and[Liu2003].
He was later joined by Sébastien Barthélemy, from ISIR/UPMC, who reorganized
the code to take advantage of the early object-oriented features of matlab.
It eventually became clear that the language was ill-designed, and that a full
rewrite was necessary. With the help of Joseph Salini, also from ISIR/UPMC,
Arboris-python was born. The resulting framework is now quite similar to what
is presented in[Duindam2006].The matlab version of the simulator is now deprecated.[Murray1994]Richard M. Murray, Zexiang Li and S. Shankar Sastry,
“A  Mathematical Introduction to Robotic Manipulation”,
CRC Press, 1994.[Park2005]Jonghoon Park,
“Principle of Dynamical Balance for Multibody Systems”,
Multibody System Dynamics, vol. 14, number 3-4, pp. 269-299, 2005.[Liu2003]T. Liu and M. Y. Wang,
“Computation of three dimensional rigid body dynamics of
multiple contacts using time-stepping and Gauss-Seidel
method”,
IEEE Transaction on Automation Science and Engineering,
submitted, November 2003.[Duindam2006]V. Duindam,
“Port-Based Modelling and Control for  Efficent Bipedal Walking Robots”,
University of Twente, 2006.
Package: arborq
[![Build Status](https://travis-ci.org/esnet/arborq.svg?branch=master)](https://travis-ci.org/esnet/arborq) [![Coverage Status](https://coveralls.io/repos/github/esnet/arborq/badge.svg?branch=master)](https://coveralls.io/github/esnet/arborq?branch=master)# arborq – a simple Python library to query Arbor Peakflow devices
Package: arbutus
arbutusSimplification of CLI construction in Python based on argparse: just add branches and arguments. CLI construction from yaml file also available.If you are interested in participating, please feel free to contribute.Explore the docs »Report BugRequest FeatureContentsGetting StartedRequirementsInstallationUsageRoadmapContributingLicenseContactGetting StartedRequirementsPython 3.8 or aboveargparseloggingInstallationpip install arbutusUsageOnce installed, the cli can be defined using a yaml file, using the keywords branches to define new branch names and
arguments to define new arguments and it's characteristics. For example:main:branches:sum:arguments:integers:type:floatnargs:+help:list of integers to sumaction:name:sum_source:samplestore:arguments:something:type:strnargs:+help:string or strings to storeaction:storeThe yaml above would imply that amodulenamed sample includes the actionsum_, and makes use of thestoreaction.
These actions can be defined using the@Arbutus.new_actionwrapper. For example:fromarbutusimportArbutus@Arbutus.new_actiondefsum_(*args,**kwargs):total=0fornumberinkwargs['values']:total+=numberprint(total)Finally, the CLI itself can be constructed by calling thefrom_yamlmethod:importarbutusif__name__=='__main__':cli=arbutus.Arbutus()cli.from_yaml('sample/cli.yaml')cli.parse_args()The CLI can then be called like:# This would display general help about the CLI functionalitypython3sample/sample.py-h# This would display general help about the sum test functionalitypython3sample/sample.pysum-h# This would throw the result of running the sum function with the passed argumentspython3sample/sample.pysum12253RoadmapSee 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!LicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactAlvaro U. Bravo -alvaroubravo@gmail.comProject Links:arbutus - GitHubarbutus - PyPi(back to top)
Package: arb-watchdog
arb_watchdogarb_watchdogis a Python package designed to monitor and manage the status of specified processes. It uses Redis as a backend for storing process data and provides a simple API for interacting with this data. The package is highly configurable and can be used to monitor and manage a wide range of processes.FeaturesMonitor the status of specified processesStore process data in RedisConfigurable process monitoring intervalAutomatically reloads configuration when the config file is updatedSupports multiple processesProvides a simple API for interacting with process dataInstallationTo install thearb_watchdogpackage, you can usepip:pipinstallarb_watchdogConfig FileFirst, create a configuration file in JSON format with the following keys:redis_host: The hostname of your Redis server (e.g., "localhost")redis_port: The port number of your Redis server (e.g., 6379)interval: The interval (in seconds) at which the processes will be monitored (e.g., 60)processes: A list of process names to monitor (e.g., ["fake_process", "another_fake_process"])Example configuration file (config.json):{"redis_host":"localhost","redis_port":6379,"interval":60,"processes":["fake_process","another_fake_process"]}By default,arb_watchdogwill look for a configuration file under the$ARB_CONFIGS_PATHdirectory. ($ARB_CONFIGS_PATH/arb_watchdog_config.json). If this variable is not set, it will use./arb_watchdog_config.json.UsageTo usearb_watchdog, import the package and create aProcessWatcherinstance with the path to your configuration file:fromarb_watchdog.process_watcherimportProcessWatcherconfig_file="config.json"process_watcher=ProcessWatcher(config_file=config_file)You can then use theProcessWatcherinstance to perform various operations, such as getting the process list, updating process data, and getting process data for specified processes:# Get the list of processes to monitorprocess_list=process_watcher.get_process_list()# Update process dataprocess_data=ProcessData(name="fake_process",pid=12345,status="UP")process_watcher.update_process_data(process_data)# Get process data for a specified processprocess_data=process_watcher.get_process_data("fake_process")Console Scriptsarb_watchdogprovides two console scripts for easy interaction with the package:arb_watchdogandarb_watchdog_cli.arb_watchdogarb_watchdogis a console script that runs thearb_watchdogprocess in the background, continuously monitoring the specified processes and updating their data in Redis. To run the script, simply execute the following command in your terminal, replacing <config_file> with the path to your configuration file:arb_watchdog-f<config_file>arb_watchdog_cliarb_watchdog_cliis a console script that shows data stored in the Redis database based on theconfig.jsonfileTo run the script, execute the following command in your terminal, replacing <config_file> with the path to your configuration file:arb_watchdog_cli-f<config_file>Example output:Running TestsTo run the tests for thearb_watchdogpackage, use the following command:python-munittestdiscover-stests
Package: arby
ArbyArby is a fully data-driven Python module to construct surrogate models, reduced bases and empirical interpolants from training data.This package implements a type ofReduced Order Modelingtechnique for reducing the computational complexity of mathematical models in numerical simulations. This is done by building a surrogate model for the underlying model using only a training set of samples.InstallFrom PyPI repopipinstallarbyFor the latest version, clone this repo locally and from inside dopipinstall-e.or insteadpipinstall-egit+https://github.com/aaronuv/arbyQuick UsageSuppose we have a set of real functions parametrized by a real number λ. This set,
thetraining set, represents an underlying parametrized model fλ(x)
with continuous dependency in λ. Without a complete knowledge about fλ(x),
we'd like to produce an accurate approximation to the ground truth only through access to the training set.With Arby we can do this by building asurrogate model. For simplicity,
suppose a discretization of the parameter domain [par_min,par_max] withNtrainsamples
indexing the training setparams=np.linspace(par_min,par_max,Ntrain)and a discretization of the x domain [a,b] inNsamplespointsx_samples=np.linspace(a,b,Nsamples)Next, we build a training settraining_set=[f(par,x_samples)forparinparams]that has shape (Ntrain,Nsamples).Finally, we build the surrogate model by executing:fromarbyimportReducedOrderModelasROMf_model=ROM(training_set=training_set,physical_points=x_samples,parameter_points=params)Withf_modelwe get function samples for any parameterparin the
interval [par_min,par_max] simply by calling it:f_model_at_par=f_model.surrogate(par)plt.plot(x_samples,f_model_at_par)plt.show()DocumentationFor more details and examples check theread the docs.LicenseMITContact Usaaron.villanueva@unc.edu.ar(c) 2020 Aarón Villanueva
Package: arbytmap
ArbytmapWhat is this repository for?Arbytmap is a bitmap conversion and manipulation module. Arbytmap is intended for use in converting bitmaps from one format to another, half-rezzing and generating mipmaps, swizzling bitmaps, and writing converted bitmaps to files. Arbytmap is currently undergoing a large scale cleanup, as much of it was written years ago when I was a much worse programmer.Many of the conversion functions have accelerator modules written in C, so this module(if properly compiled and installed) can reach speeds seen in lower level languages.Raw formats currently supported by this module are as follows:A8, Y8, AY8, A8Y8, R3G3B2, 5G6B5, R8G8B8, Y8U8V8, A1R5G5B5, A4R4G4B4, X8R8G8B8, A8R8G8B8, R16G16B16, A16R16G16B16DXT formats currently supported by this module are as follows:DXT1/2/3/4/5, DXN, DXT5A, DXT5Y, DXT5AY, CTX1, U8V8TodoClean up and standardize the interface for loading bitmaps and conversion settings into the Arbytmap class.Cleanup/redo pretty much everything that looks/functions bad.Who do I talk to?Devin Bobadilla (Author of arbytmap)mosesbobadilla@gmail.com
Package: arc1-pyqt
Python + Qt5 interface to the ArC1 platformThis is the main repository of the ArC1 control panel, a tool to run tests on
theArC1 characterisation
platform.  Versatile and
extensible it provides all you need to start characterising memory devices with
your ArC ONE board. Powered by the Qt framework it is available on all major
operating systems.InstallOn WindowsFor Windows a ready-to-run executable is provided in thereleases
page. Just unzip and
runArC ONE Control.exe. Please note that depending on your Windows version
you might need to install theARM mbed serial port
driver.On anything supported by Python + Qt5You need to havePython ≥3.7andgitinstalled in your system. You can
install the latest snapshot using the command.pip install git+https://github.com/arc-instruments/arc1_pyqtStarting with v2.0.0-rc0 arc1_pyqt is also available from PyPI:pip install arc1_pyqt.UseYou should now have everything you need to characterise devices with your ArC1
board. Followthe user
documentationfor a
complete guide on how to use the software for your experiments.DevelopIf the built-in functionality is not enough for your testing procedure you can
create your own modules to better suit your needs. Custom modules must subclassarc1pyqt.modutils.BaseProgPaneland be placed in one of the standard module
load directories which can be found underSettings→Module directories.
You can either create a single-file module such as those that are shipped witharc1_pyqtand can be found underarc1_pyqt/ProgPanelsor standard Python
packages for more elaborate ones. On the top-level of your package you should
have a python module with the same name as the module forarc1_pyqtto pick
it up at startup.If you want to develop onarc1_pyqtitself clone this repository and install
its dependencies withpython -m pip install -r requirements.txt.I found a bug!If arc1_pyqt does not behave as you would expect pleaseopen an
issuedescribing the
problem and how to reproduce it. Don't forget to mention the operating system
you are running on!
Package: arc2control
ArC TWO™ Control PanelThis is the frontend application for ArC TWO. It exposes functionality mostly
related to crossbar configurations and provides a set of predefined
experiments suitable for general and (P/R/FE)RAM devices characterisation.InstructionsInstallationIf you have a recent Python installer, stable ArC2Control versions are
available from PyPI:pip install arc2controlYou can then run ArC2Control with:python -m arc2controlAdditionally, installers for Windows and AppImages for Linux are
made periodically available from ourreleases
page.If you have git installed, you can also try out the latest development
snapshot:pip install git+https://github.com/arc-instruments/arc2controlDevelopmentTo develop on ArC2Control itself the recommended way to get started is by using
a virtual environment. ArC2Control usespoetryto
manage virtual environments. You might want to use a development version ofpyarc2as well although that's
optional. We try to depend only on stable pre-built versions ofpyarc2but
that's not guaranteed.[Optional] You will need a functionalRust toolchain.You will need a relatively new Python (≥ 3.8) and also have poetry
installed (python -m pip install poetry). Pip must also be updated to at
least version 20.x.Clone this repository and descend into it.Initialise the virtual environment:python -m poetry install. This only needs
to be done once.[Optional] Updatepyarc2to the latest development snapshot which can
easily be done with the included scriptpoetry run python venv-pyarc2-update.py git+https://github.com/arc-instruments/pyarc2.  This will downloadpyarc2via git,
build it and install it into the virtualenv.Run the setup scriptpoetry run python setup.py build.Run ArC2Controlpoetry run python -m arc2control.Custom modulesArC2Control can be extended with custom experiment panels. An ArC2Control experiment
module is a standalone Python module that includes the following in its__init__.py.MOD_NAME='ModuleName'MOD_DESCRIPTION='Description of said module'MOD_TAG='MN'# a shorthand tag for the moduleBUILT_IN=Falsefrom.moduleimportMainModule# MainModule must derive from arc2control.modules.base.BaseModule`ENTRY_POINT=MainModuleThe built-in experiment modules are also built with the same infrastructure so
they can be used as a scaffold to build your own.I have a questionFeel free to make a new topic underDiscussions. This
should be your first stop for support unless you are somewhat certain you run
into a bug (which is very possible at this stage). In that case…I found a bug!If ArC2Control does not behave as you would expect pleaseopen an
issuedescribing the
problem and how to reproduce it. Don't forget to mention the operating system
you are running on!
Package: arc3o
docsThis is the code for the Arctic Observation Operator for 6.9 GHz, presented in:Burgard, C., Notz, D., Pedersen, L. T., and Tonboe, R. T.: The Arctic Ocean Observation Operator for 6.9 GHz (ARC3O) – Part 2: Development and evaluation, The Cryosphere, 14, 2387–2407,https://doi.org/10.5194/tc-14-2387-2020, 2020.! Please be careful when using the code !Especially, there might not be an error message when ran at another polarization or frequency than 6.9 GHz, vertical polarization,
but the results have only be evaluated at that frequency and polarization!If you are interested in 6.9 GHz, vertical polarization, enjoy! :)To read more about ARC3O and know how to run it, check out the documentation here:https://arc3o.readthedocs.io/Contact me atclara.burgard@gmail.comin case of questions.
Package: arc4
A small and insanely fast ARCFOUR (RC4) cipher implementation of Python.Strongly focused on performance; entire source code is written in C.Thread-safety; you can improve further performance with multi-threading.Easily installable; single file with no dependency, pre-built wheels provided.BenchmarkBelow is benchmark metrics against 3 major RC4 implementations.The whole benchmark code is in./benchmark.py.Notearc4 supports multi-threading but it is too fast to ignore the overhead of context-switching, in most cases.InstallInstall from PyPIpipinstallarc4Or clone the repo and do installgitclonehttps://github.com/manicmaniac/arc4.gitcdarc4pythonsetup.pyinstallUsage>>>fromarc4importARC4>>>arc4=ARC4(b'key')>>>cipher=arc4.encrypt(b'some plain text to encrypt')Because RC4 is a stream cipher, you must initialize RC4 object in the beginning of each operations.>>>arc4=ARC4(b'key')>>>arc4.decrypt(cipher)b'some plain text to encrypt'DocumentsHere is the API reference.https://arc4.readthedocs.io/en/latest/Testingpython-munittestdiscoverLicenseThis software is under the MIT License.