Saravanan666/pypi-org huggingface dataset:
Package: ruly
RulyRuly is a simple, lightweight rule engine that can be used to define rules and
prove statements using backward chaining. It attempts to be highly configurable,
allowing callers of its functions to define callbacks in cases for conflict
resolutions or derivations of new rules.InstallationRuly can be installed and used as a Python package. It can be installed by
calling:pip install rulyUsageimportrulyknowledge_base=ruly.knowledge_base.create(["IF color = 'red' THEN creature = 'dragon'","IF color = 'grey' THEN creature = 'rat'"])print(ruly.backward_chain(knowledge_base,'creature',color='red'))# prints dragonFor more examples and information on how to create new rules, solve conflicts,
generate new rules on the fly during evaluations, etc., see thedocumentation.Development environmentTo set up the development environment, requirements must be installed either by
callingsetup.pyor by installing them manually usingpipandrequirements.txtfile. Also, ruly's build tool,doitneeds to be installed. Supported tasks can be listed by calling:doitlist
Package: ruly-dmn
Ruly-DMNruly-dmnis a python package that offers a limited implementation of the DMN
standard, with additional features. It relies on therulyrule engine to make decisions
and derive new rules. It can be used as a library or as a command line tool.The command line tool assumes that the DMN diagrams are defined as XML files,
in the format specified by theCamunda
modeler. The recommended workflow is to
use the Camunda modeler to create diagrams and initial decision tables and then
pass them to functions in this package, so it can make decisions or derive new
rules. See theexamplesdirectory for examples of working DMN files that can
both be opened in the Camunda modeler and passed to the functions of this
package.The current limitations, in regard to the complete DMN standard:only available hit policies are unique, first and anythere are no constraints on enumerated variables when user is entering new
rulesonly one output column in decision tables is allowedonly available variable comparision (when making decisions) is for equalityvisual diagrams are not taken into account when creating rule engine rules,
only decision tablesS-Feel and other code evaluations in rules are not supportedInstallationTo install, call:pipinstallruly-dmnUsageWhen the package is installed, it can be used either by importing its modules
(seedocumentationfor more details), or by
callingruly-dmnin command line.  Alternatively,python -m ruly_dmn.mainmay be used instead of the command line tool.After installation, it should be possible to call ruly-dmn with one of the DMN
diagrams in the example directories, i.e.:ruly-dmn-oo.dmnexamples/0001/diagram.dmnBeverageSeason="Spring"Which should output Beverage = Pinot Noir. The tool also may create new rules
and, if it does, these rules should be written ino.dmnfile. For more
information on how the command line tool works, callruly-dmn --helpDevelopment environmentTo install development dependencies, callpipinstall-rrequirements.txtThis will, among other packages, installdoit, which isruly-dmn's build
tool. Use this tool to perform various actions like testing, building
documentation, linting check, etc. For the list of all available tasks, call:doitlistContributingFeel free to post any issues - bugs, feature requests, etc. Do not send pull
requests before an issue for the problem it solves is created. When sending
pull requests, please reference the issue(s) it attempts to solve and, after
the review process, it will be accepted. Make sure that the updated changes
reflect on the documentation and tests, so they're not left in an inconsistent
state.
Package: ruly-zlatsic
RulyRuly is a simple, lightweight rule engine that can be used to define rules and
prove statements using backward chaining. It attempts to be highly configurable,
allowing callers of its functions to define callbacks in cases for conflict
resolutions or derivations of new rules.InstallationRuly can be installed and used as a Python package. It can be installed by
calling:pip install rulyUsageimportrulyknowledge_base=ruly.knowledge_base.create(["IF color = 'red' THEN creature = 'dragon'","IF color = 'grey' THEN creature = 'rat'"])print(ruly.backward_chain(knowledge_base,'creature',color='red'))# prints dragonFor more examples and information on how to create new rules, solve conflicts,
generate new rules on the fly during evaluations, etc., see thedocumentation.Development environmentTo set up the development environment, requirements must be installed either by
callingsetup.pyor by installing them manually usingpipandrequirements.txtfile. Also, ruly's build tool,doitneeds to be installed. Supported tasks can be listed by calling:doitlist
Package: rulz
rulzA decorator based IoC framework for python3.6+. There are no runtime
dependencies outside of what's in the standard library.A demo module is inrulz/plugins/demo.py.#!/usr/bin/env pythonfromrulzimportplugin,run_graph@plugin()defone():return1@plugin()deftwo():return2@plugin(one,two)defadd(a,b):returna+bif__name__=="__main__":print(run_graph())Invoke it directly or create a driver script like this:#!/usr/bin/env pythonfromrulzimportload,run_graphload("rulz.plugins")print(run_graph())
Package: rum-auto-sender
auto_sender适用于可公开的数据，比如摘抄本，个人博客，笔记等。比如，我在个人电脑的某个专用文件夹，放了许多个人博客文章，每篇文章是一个以 .md 结尾的文本文件。auto_sender 的作用是：1、把该文件夹与 rum group 形成映射；2、把文件夹下的每个文本文件，映射一条 trx；3、然后自动或手动提交/更新/同步。为什么？存储在 rum group 的数据，既是可靠的、分布式的数据备份，可一键恢复到新的指定目录或新设备上；也可以作为产品的数据源，比如论坛的主帖，博客主的个人文集，被运用到 port.base.one 等相似的站点。关于：采用 python 实现，偏后端，作为 demo 而存在，目前几乎没有图形交互。换言之，rum group 的数据可以采用任何已有的产品应用来渲染，这个 bot 只处理原始数据与 rum group 的映射与同步。安装pipinstallrum_auto_sender使用example
Package: rumboost
DescriptionRUMBoost is a python package to estimate Random Utility models with Gradient Boosted Decision Trees. More specifically, each parameter in the traditional utility function is replaced by an ensemble of regression trees with appropriate constraints to: i) ensure the guarantee of marginal utilities monotonicity; ii) incorporate alternative-specific attributes; and iii) provide an intrinsically interpretable non-linear form of the utility function, directly learnt from the data.Currently RUMBoost can estimate the following RUMs:MNLNested LogitCross-Nested LogitAn equivalent of the Mixed Effect modelFor more details, you can refer to thepreprintof our paper.InstallationRUMBoost is launched on pypi. You can install it with the following command:pip install rumboostWe recommend to install rumboost in a separate environment with its dependencies.Documentation and exampleThe full documentation can be foundhere. In addition, you can find several examples on how to use RUMBoost under the example folder. Currently, there are seven example notebooks. We recommend using them in this order:simple_rumboost: how to train and plot parameters of a simple RUMBoost modelfeature_interaction: how to include feature interactions for training and plottingnested: how to train a nested logit RUMBoost modelfunctional_effect: how to train and plot a functional effect RUMBoost modelcross-nested: how to train a cross-nested logit RUMBoost modelbootstrap: how to test the model robustnesssmoothing_and_vot: how to smooth a RUMBoost output and plot the smoothed version, as well as computing and plotting VoTBug reports and feature requestsIf you encounter any issues or have ideas for new features, please open anissue. You can also contact us atnicolas.salvade.22@ucl.ac.ukLicenseThis project is licensed under the MIT License - see theLICENSEfile for details.Reference paper (preprint)Salvadé, Nicolas and Hillel, Tim, Rumboost: Gradient Boosted Random Utility Models. Available at SSRN:https://ssrn.com/abstract=4701222orhttp://dx.doi.org/10.2139/ssrn.4701222
Package: rum-docs-theme
This is the theme for the Rum documentation.It is a fork ofpython-docs-theme, with
modifications to suit the Rum programming language.The forked version ofpython-docs-themeis licensed under the Python Software
Foundation License (PSFL). Any modifications made are licensed under the Mozilla Public
License, version 2 (MPL 2.0).Copies of the PSFL and the MPL 2.0 are included with this project atLICENSE_PSFLandLICENSE_MPLrespectively.To use this theme:Create and activate a virtual environment:$ python -m venv env
$ source env/bin/activateInstall python-docs-theme usingpip:(env)$ python -m pip install rum-docs-theme
Package: rumex
Behaviour Driven Development(BDD) testing library.Rumex is trying to be more of a library rather than a framework.
This approach aims to increase flexibility and reduce dependency
on design choices made by designers of alternative frameworks.Installationpip install rumexBasic exampleimportrumexexample_file=rumex.InputFile(text='''
        Name: Basic example

        Scenario: Simple arithmetics

            Given an integer 1
            And an integer 2
            When addition is performed
            Then the result is 3
    ''',uri='in place file, just an example',)steps=rumex.StepMapper()classContext:def__init__(self):self.integers=[]self.sum=None@steps(r'an integer (\d+)')defstore_integer(integer:int,*,context:Context):context.integers.append(integer)@steps(r'addition is performed')defadd(*,context:Context):context.sum=sum(context.integers)@steps(r'the result is (\d+)')defcheck_result(expected_result:int,*,context:Context):assertexpected_result==context.sumrumex.run(files=[example_file],steps=steps,context_maker=Context,)More examplesPerhaps the best way to discover Rumex’s fetures is to look at the examples:docs/examplesAPIFor API documentation seedocs/apiSome alternativesbehavepytest-bdd
Package: ruminaq
Ruminaq python package is part of Ruminaq projecthttps://github.com/systemincloud/ruminaq.
This package is an api for writing custom tasks in python.InstallationInstall with pip.$pipinstallruminaqCode DemoDefine a custom task as follow:@python_task_info(generator=True,external_source=True)@parameter(name="param")classMyPythonTask(PythonTask):def__init_ports__(self):self.in1=InputPort(name="in1",data_type=Bool)self.in2=InputPort(name="in2",data_type=Bool,asynchronous=True)self.out=OutputPort(name="out",data_type=Bool)defexecute_async(self,async_in):""" this will run when asynchronous port
            receive data """defexecute_ext_src(self):""" this will run after internal
            request """defgenerate(self):""" this will run periodicaly """defexecute(self,grp):""" this will run when all synchronous ports
            from group receive data """
Package: ruminate
ruminateA Wagtail app for publishing article pages in an academic/scientifically-oriented setting. Please bear with us while we prepare more detailed documentation.Compatibilityruminate' major.minor version number indicates the Wagtail release it is compatible with. Currently this is Wagtail 4.1.xInstallationInstall usingpip:pipinstallruminateAddruminateto yourINSTALLED_APPSsetting:INSTALLED_APPS=[# ...'ruminate'# ...]
Package: rummage
RummageRummage is a cross platform search and replace tool. Rummage crawls directories and searches for specified patterns
(either regular expression or literal) and can optionally replace those targets with desired text.Rummage is written in Python and is currently available on Python 3. Rummage by default uses Python's Re regular
expression engine, but you can also use the fantastic, feature richRegexsearch
engine and do interesting things like fuzzy searching and more.ScreenshotsDocumentationhttps://facelessuser.github.io/Rummage/LicenseRummage is released under the MIT license.
Package: rummy-circl-otp
Rummy Circle OTPThis package allows users to generate OTPs for the Rummy Circle website by sending a specified number of requests to the website's OTP generation API.InstallationUse the package managerpipto install rummy_circl_otp.pipinstallrummy_circl_otp

importrummy_circl_otp
importjsonnum=input("Enter your mobile number: ")req=int(input("Enter the number of requests to send: "))rummy_circl_otp.run(num,req)
Package: rummy-circ-otp
Rummy Circle OTPThis package allows users to generate OTPs for the Rummy Circle website by sending a specified number of requests to the website's OTP generation API.InstallationUse the package managerpipto install rummy_circle_otp.pipinstallrummy_circ_otp

importrummy_circ_otp
importjsonnum=input("Enter your mobile number: ")req=int(input("Enter the number of requests to send: "))rummy_circ_otp.run(num,req)
Package: rumor-view
rumor_viewPython library to visualize categorical column values relationship.ObjectiveHelp explore data frame to find column values which has strong relationship.
This module estimate P(x1=v1 | x2=v2), and consider significance based on
"lift" := P(x1=v1 | x2=v2) / P(x1=v1).There are two main functionalities;show_columnsThis method provides a map for your exploration. This visualize graph which node represents each column, and edge between nodes when correspondent columns have lift in some value pair of those columns.show_relationThis method provides a detailed view for a pair of columns. With this you can see concrete values which has strong relationshipInstallationpip install rumor_viewUsageRight now this module handles all the column as categorical. If you have numeric columns it is recommended to convert them as categorical values before inputing this module.import rumor_view


view = rumor_view.RumorView(df)

view.show_columns() # this shows all the columns
view.show_columns(target_column="target") # this shows only 2 hops from target column

view.show_relations("target", "column") # this shows value relationships between input columns
Package: rump
R(outing)Ump(ire) is anexperimenalupstream (i.e. server) selector for
HTTP requests. It doesnotproxy the request but instead integrates with a
load-balancer or reverse-proxy that exposes an upstream selection interface:nginxX-Accel-*…dev$gitclonegit@github.com:bninja/rump.git$cdrump$mkvirtualenvrump(rump)$pipinstall-e.[tests](rump)$py.testtest/--cov=rump--cov-reportterm-missingwtf?Typically you can embed complex routing logic directly in a load-balancer or
reverse-proxy (e.g. nginx lua, varnish vcl, etc) and that’s what should be
done 99% of the time.This is anexperimentto see what writing a Python based HTTP upstream
selector would look like and what flexibility that gives you.Use it as aprogramor embed it as alibin your proxy.programInstall it:ansible-rump…Use it:$rumplistmy-router$rumpshow-dmy-router...$rumpedit-dmy-router$servicerumpdstatuslibGet it:$pipinstallrumpUse it:importrumprouter=rump.Router(name='my-router',...)upstream=router.match_upstream(router.request_type(wsgi_environ))ifupstream:server=upstream()
Package: rumpy
rumpyPython SDK forQuoRum.About QuoRumhttps://rumsystem.net/https://github.com/rumsystem/quorum/blob/main/Tutorial.mdhttps://github.com/rumsystem/quorumInstallrumpy@pypipipinstallrumpyEnvinit or update:pipinstallpipenv
pipenvinstallrun:pipenvshell
pipenvrunpythondo_sth.pyExamples>> ExamplesContributing>> Contributing>> Bug TrackerLicenseThis work is released under theGPL3.0license. A copy of the license is provided in theLICENSEfile.
Package: rumydata
Are You My Data?This python package provides a set of tools to solve several of the major challenges
that arise in the transmission of data. These tools attempt to solve four main
problems:defining exactly what your data should becommunicating that definition to others (so they can send you data)validating the data that you receivenot disclosing the data on accidentThese problems are solved with the following feature sets in this package:an expressive, extensible set of classes to define a data settechnical documentation generators, based upon the definitiondata validation methods, based upon the definitionsanitized error messages which state what the datashouldbe, but not what
it actually is (i.e. what was expected, not what was received)InstallationFor most users, the recommended method to install is via pip:pipinstallrumydataThis package requires python version 3.7 or higher. By default there are no
third-party package dependencies. However, some extras are available.Excelpip install rumydata[Excel]Parquetpip install rumydata[Parquet]DocumentationPlease see the full documentation atreadthedocsVersioningThis project follows the specifications ofSemantic Versioning 2.0.
Users of this package should avoid calling any private or semi-private members
(i.e. starting with one or more underscores_in the name). As long as this rule
is followed, upgrading to a higher minor or patch release should always be safe.
Package: run
This module provides convenient ways to guarantee a certain script
state.run.aloneMake sure only one instance of the program is running,
this is done by acquiring an fcntl file lock on the
current script:>>> import run.aloneCaveatsThere are a few things to keep in mind:import run.alone once, it will exit your program if it gets
imported twicesymlinked scripts will be resolved to the inode it has been
linked to, this is a limitiation of using fcltn file locksrun.untilRun until a specified timespec, if the process runs
longer, it will be killed:>>> import run
>>> run.until('23m42s')
>>> ...You can also choose to limit on the amount of CPU-time
being consumed (default is wall clock time):>>> run.until('42s', 'cpu')
>>> ...AcknowledgementsThis module is dirived from theSys::RunAloneandSys::RunUntilperl modules written byElizabeth Mattijsen.
Package: run80by24-client
This command-line application turns your terminal into a screen which you can
control through the80by24 service.InstallingInstall using pipon a system with Python>=3.5:pip install 80by24-clientRunning80by24will run the client.Ctrl-Caborts.ConfigurationOut of the box, the client generates a random passphrase and connects to80by24.net. This can be changed by
putting a configuration file into~/.80by24.confof the following form:host:       http://localhost:8080
passphrase: correct horse battery staple
Package: runa
Librería para Uso de los WS del Estado EcuatorianoLibrería para uso WS del Bus Gubernamental de EcuadorFree software: MIT licenseDocumentation:https://runa.readthedocs.ioInstalling$pipinstallrunaUsingThis library will create a configuration file .runa.json in your HOMEPATH, update this to use it.>>>importruna>>>pr=runa.busqueda_por_nui('0102030405')>>>print(pr)<Runa[0102030405-PUJONJUANMANUEL]>>>>pr.json()...>>>contribuyente=runa.busqueda_ruc('0102030405001')>>>print(contribuyente)<Contribuyente[0102030405001-MICOMPANIACIA.LTDA.]>FeaturesWS Consultar_CiudadanoWS SRIConfig file neededCreditsCreated by Cristian SalameaHistory0.2.1 (2017-12-19)Corrección de dependencias0.2.0 (2017-12-18)Implementación del WS del SRICorregidas dependenciasObjetos suscriptables0.1.0 (2017-11-21)First release on PyPI.Implementación base para el servicio de Consultar_Ciudadano
Package: runabq
runabqrunabq is a command tool that can execute multiple input data files of FEA software Abaqus in succession.
runabq can execute all the input data in the current directory with a simple command.InstallationAnaconda, venv$pipinstallrunabqUsageUse the latest Abaqus version. That is, it executes the'abaqus' command internally.$runabqUse the specify abaqus version.$runabq-v2021student edition$runabq-v2021seUse user subroutines and CPUs.$runabquser=sub.fcpus=5Help$ runabq --helpEnter code = "a" or blank to execute all the input files in the current directory. Default is "a".$runabq
fileslist:1:job1.inp2:job2.inp3:job3.inpa:allx:exitcode?aIf you want to execute only a specific input file, enter numbers separated by ",".$runabq
fileslist:1:job1.inp2:job2.inp3:job3.inp4:test1.inp5:test2.inpa:allx:exitcode?1,4For consecutive numbers, enter the first and last numbers separated by ":".$runabq
fileslist:1:case1.inp2:case2.inp3:case3.inp4:job1.inp5:job2.inpa:allx:exitcode?1:3
Package: run-across-america
Run Across AmericaPython library to fetch and analyze team and user data from Run Across America.Installationpip install run-across-americaUsageAvailable methods:user_id(user_code: str): Exchanges your user code (from the signup email) for your user id.user(user_id: str): Retrieves information about a user from theiruser_id.teams(user_id: str): Retrieves all the teams a particular user is a member of.goals(team_id: str): Retrieves information about the distance goal for a team.members(team_id: str): Retrieves all the members of a team.leaderboard(team_id: str): Retrieves the current leaderboard of a team.feed(team_id: str): Retrieves all the activities of a team.User IDExchanges your user code (from the signup email) for your user id. Options:user_code: str= The alphanumeric code sent to a user after signup.Example>>> from run_across_america import RunAcrossAmerica
>>> client = RunAcrossAmerica()
>>> user_id: str = client.user_id("HELLO")

"f71f47b9-56b0-4bf9-99cd-fcb9b016d819"UserRetrieves information about a user from theiruser_id. Options:user_id: str= The GUID obtaining from exchanging the user code.Example>>> from run_across_america import RunAcrossAmerica, User
>>> client = RunAcrossAmerica()
>>> user: User = client.user("f71f47b9-56b0-4bf9-99cd-fcb9b016d819")

User(id='f71f47b9-56b0-4bf9-99cd-fcb9b016d819', age=None, created=datetime.datetime(2022, 1, 1, 12, 30, 0, 900000), email='test@example.com', first_name='Hello', gender=None, last_name='World', phone=None, icon=None, code='YYSHOEY6', timezone='America/Chicago', username='@hello-world', state='IL')
Package: runai
Run:AI Python libraryPublic functional modules for Keras, TF and PyTorchInfoStatusCircleCI is used for CI system:ModulesThis library consists of a few pretty much independent submodules:ModuleNameInfoElasticelasticMake Keras and PyTorch models elasticGradient AccumulationgaGradient accumulation for Keras and PyTorch optimizersHPOhpoHyperparameter optimization assistanceModel ParallelismmpModel-parallelism support for Keras builtin layersAuto ProfilerprofilerExport timeline of TF/Keras models easilyReporterreporterAn interface to send metrics and parameters to Promethues Push GatewayGetting StartedInstallingInstall therunaiPython library usingpipusing the following command:pip install runaiMake sure to use the correctpipinstaller (you might need to usepip3for Python3)Running The TestsAll tests (unit tests) can be run using the following command:python -m unittest discover -s tests -v
Package: runai-interactive-context
RunAI interactive contextThis CLI improves the interactive mode of therunaiCLI by:Deleting the job on exit to reduce the costs of idle interactive sessions.Allowing for longer delays when asking for a port forward (RunAI CLI only waits 60 seconds)Parsing and translating url of a jupyter notebook (with the forwarded port and token information).Table of ContentsInstallationUsageLicenseInstallationpip install runai-interactive-contextUsageStart an interactive jupyter server:runai-interactive --mode jupyter <job_name> <image_name> -- jupyter serverRun a streamlit applicationrunai-interactive --mode port --container-port 8501 <job_name> <image_name> -- streamlit app.pyLicenserunai-interactive-contextis distributed under the terms of theMITlicense.