Saravanan666/pypi-org huggingface dataset:
Package: rkt-ai-lib
rkt_ai_lib - Python libraryThis Python library is based only on built-in Python libraries and two (2) non-build-in library :numpypandasPython Version 3.9.9PyYaml Version 5.4.1 (Released Jan 20, 2021)numpy Version 1.21.5 (Released Jan 7, 2022)pandas Version 1.3.5 (Released Dec 12, 2021)What is Python?Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.sourceWhat is numpy?NumPy is the fundamental package for scientific computing in Python.It is a Python library that provides a multidimensional array object, various derived objects (such as masked arrays and matrices),and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation,
sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more.sourceWhat is pandas?pandas is a Python package that provides fast, flexible, and expressive data structures designed to make working with
"relational" or "labeled" data both easy and intuitive.It aims to be the fundamental high-level building block for doing practical, real world data analysis in Python.Additionally, it has the broader goal of becoming the most powerful and flexible open source data analysis / manipulation tool available in any language.It is already well on its way towards this goal.sourceLibrariesAI: overlay of pandas library (Renforcement Learning - Qlearning)Use itInstall(venv)my_project>pipinstallrkt_ai_lib[--index-urlhttps://gitlab.tprc.ovh/api/v4/groups/python/-/packages/pypi]fromos.pathimportexistsfromrkt_ai_libimportQLearningfromyour_local_libimportMyGameObjectmy_action_list=['up','down','left','right']# can override alpha (0.1), gamma (0.5)ifexists("my_mind.pkl"):mind=QLearning(actions=my_action_list,should_load=True,qtable_file_to_load="my_mind.pkl")else:mind=QLearning(actions=my_action_list)# You can use the Qlearning for another thing then gamemy_game=MyGameObject()whileTrue:# get the current statestate=my_game.get_state()# get the actionaction=mind.choose_action(state)# do the action your logic is here (move, attack, ... for game, send, buy, ... for trading, ...)my_game.do_action(action)# get the reward this is here reward logicreward=my_game.get_reward(action,state)# update the Q-tablemind.learn(state,action,reward)# check if you "win"ifmy_game.is_win():breakmind.save("my_mind.pkl")Output (as file or sdtout ot both)Your "game" logContributingIf you find this library useful here's how you can help:Send a merge request with your kickass new features and bug fixesHelp new users withissuesthey may encounterSupport the development of this library and star this repo!
Package: rkt-armutils
:docker:inject-qemu-binsInjects QEMU binaries into a docker image required to run ARM binaries
on x86_64 processors.NOTICE: This operation is flattening the docker layers by doing export
and importExamples:rkd:docker:inject-qemu-bins--image=arm32v7/php:7.2-fpmClass name to import:rkt_armutils.docker.InjectQEMUBinaryIntoContainerTask [see how toimport]:travis:use-experimental-dockerTurns on experimental features in Docker client.NOTICE: Overrides
~/.docker/config.json - but useful on CIClass name to import:rkt_armutils.docker.UseExperimentalDockerTask [see how toimport]:travis:configure-qemuConfigures Travis-CI to use QEMU for building docker containers.Class name to import:rkt_armutils.docker.ConfigureTravisBuildTask [see how toimport]
Package: rkt-config-lib
rkt_config_lib - Python libraryThis Python library is based only on built-in Python libraries and one (1) non-build-in library :PyYamlPython Version 3.7.2PyYaml Version 5.4.1 (Released Jan 20, 2021)What is Python?Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.sourceWhat is PyYaml?YAML is a data serialization format designed for human readability and interaction with scripting languages. PyYAML is a YAML parser and emitter for Python.PyYAML features a complete YAML 1.1 parser, Unicode support, pickle support, capable extension API, and sensible error messages. PyYAML supports standard YAML tags and provides Python-specific tags that allow to represent an arbitrary Python object.PyYAML is applicable for a broad range of tasks from complex configuration files to object serialization and persistence.sourceLibrariesConfig: overlay of PyYaml library (read-only), use Tool and Logger library (rkt_tool_lib, rkt_logger_lib)Use itInstall(venv)my_project>pipinstallrkt_config_lib[--index-urlhttps://gitlab.tprc.ovh/api/v4/groups/python/-/packages/pypi]Examplefromrkt_config_libimportConfigc=Config()# by default search folder named "config" in root project folder# for load all yaml filesc.get_data()print(f"{c.data}")Output (as file, sdtout or both)03/03/2022 16:44:09 :: [Logger] :: INFO :: Create logger for 'Config'
03/03/2022 16:44:09 :: [Logger] :: INFO :: add 'StreamHandler' in 'Config' logger
03/03/2022 16:44:09 :: [Logger] :: INFO :: add 'FileHandler' in 'Config' logger
03/03/2022 16:44:09 :: [Config] :: INFO :: Load 'database' file ...{'database': {'connect_id': {'dbms': 'mariadb'}}}
  ^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                       |
   |                      data: file content
 file name without extensionContributingIf you find this library useful here's how you can help:Send a merge request with your kickass new features and bug fixesHelp new users withissuesthey may encounterSupport the development of this library and star this repo!
Package: rktellolib
RKTelloLibIn light of the many poorly-designed libraries to interact with the DJI (Ryze) Tello drone that either do way more than they should or don't do enough, I have taken the initiative to create this small library. It's a simple interface built upon the officialTello SDKthat allows you to control and interact with the drone with minimal effort.InstallationInstall using PIP$pipinstallrktellolibInstall from Source$gitclonehttps://github.com/ramujin/rktellolib.git
$cdrktellolib
$pipinstall-e.Example Usage to Fly in a Square PatternfromrktellolibimportTellodrone=Tello(debug=True,has_video=False)drone.connect()drone.takeoff()drone.forward(100)drone.cw(90)drone.forward(100)drone.cw(90)drone.forward(100)drone.cw(90)drone.forward(100)drone.cw(90)drone.land()drone.disconnect()Example Usage to Stream VideofromrktellolibimportTelloimportcv2drone=Tello(debug=True,has_video=True)drone.connect()whileTrue:frame=drone.get_frame()ifframeisNone:breakcv2.imshow('rktellolib',frame)ifcv2.waitKey(1)==27:# ESC keybreakdrone.disconnect()Available Commands# Operational Commandsconnect()disconnect()takeoff()land()# Discrete Action Commandsup(distance:int)down(distance:int)left(distance:int)right(distance:int)forward(distance:int)back(distance:int)cw(degree:int)ccw(degree:int)# RC Control Commandrc(v_lr:int,v_fb:int,v_ud:int,v_yaw:int)# Camera Commandget_frame()# Retrieve All Drone State Informationget_states()# Retrieve a Specific Stateget_state(field:str)# Retrieve System & Environment Statesget_battery()get_flight_time()get_temp()get_barometer()# Retrieve Positional Statesget_height()get_distance_tof()get_ax()get_ay()get_az()get_vx()get_vy()get_vz()# Retrieve Rotational Statesget_roll()get_pitch()get_yaw()
Package: rkt-logger-lib
rkt_logger_lib - Python libraryPython Version 3.7.2What is Python?Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.sourceLibrariesLogger: overlay of logging libraryUse itInstall(venv)my_project>pipinstallrkt_logger_lib[--index-urlhttps://gitlab.tprc.ovh/api/v4/groups/python/-/packages/pypi]You can use one-by-one each libfromrkt_logger_libimportLoggerl=Logger(caller_class="My_Super_Project")l.set_logger(level="DEBUG",caller_class="My_Super_Project")l.add(caller="My_Super_Project",message="This is a test DEBUG message",level="DEBUG")l.add(caller="My_Super_Project",message="This is a test INFO message",level="INFO")l.add(caller="My_Super_Project",message="This is a test WARNING message",level="WARNING")l.add(caller="My_Super_Project",message="This is a test ERROR message",level="ERROR")l.add(caller="My_Super_Project",message="This is a test CRITICAL message",level="CRITICAL")Output (as file, sdtout or both)03/03/2022 18:27:19 :: [Logger] :: INFO :: Create logger for 'My_Super_Project'
03/03/2022 18:27:19 :: [Logger] :: INFO :: add 'StreamHandler' in 'My_Super_Project' logger
03/03/2022 18:27:19 :: [Logger] :: INFO :: add 'FileHandler' in 'My_Super_Project' logger
03/03/2022 18:27:19 :: [My_Super_Project] :: DEBUG :: This is a test DEBUG message
03/03/2022 18:27:19 :: [My_Super_Project] :: INFO :: This is a test INFO message
03/03/2022 18:27:19 :: [My_Super_Project] :: WARNING :: This is a test WARNING message
03/03/2022 18:27:19 :: [My_Super_Project] :: ERROR :: This is a test ERROR message
03/03/2022 18:27:19 :: [My_Super_Project] :: CRITICAL :: This is a test CRITICAL messageContributingIf you find this library useful here's how you can help:Send a merge request with your kickass new features and bug fixesHelp new users withissuesthey may encounterSupport the development of this library and star this repo!
Package: rktools
rktoolsA general purpose Python library.[![Build Status][travis-image]][travis-url]
[![Downloads Stats][npm-downloads]][npm-url]rktoolsis a general purpose Python Library. It is originally designed after the needs of several small tools during Python projects development.IntroductionThe library is organized around dedicated modules for monitoring processes, for loggings events, and so forth:loggers:A simple Pythonloggingwrapper that provide additional features such as http server logging handler management...monitors:A set of monitoring tools to provide visibility to the end user. For instance, it provideProgressBarwhich is atqdmwrapper, and so forthInstallrktoolsis currently supported only for Linux systems. However, since it is written with pure Python, it should run without any problem on all platforms.Using pipThe easiest way to installrktoolsis usingpipto fetch it fromPypias follows:$pipinstallrktoolsUsing rktoolsThe modules usage is as follows.LoggersImport theinit_loggerfunction from therktools.loggersmodule:fromrktools.loggersimportinit_loggerDeclare and initialize aloggerglobal (or local variable) :...logger=init_logger(name="test_monitors",config=config)...The returnedloggerobject is an instance of Pythonlogging.Loggerclass.
Also notice that the Pythonloggingpackage can be required if you want to override the logging level:importlogging...logger=init_logger(name="test_monitors",config=config,level=logging.getLevelName("DEBUG"))...Use theloggerobject the same way you use the Pythonlogging.Loggerobject:...logger.debug("A debug message!")logger.info("A info message!")logger.warning("A warn message!")logger.error("A error message!")logger.critical("A critical message!")...Find more details in the reference documentationhere.MonitoringImport theProgressBarclass from themonitorsmodule:fromrktools.monitorsimportProgressBarChanges0.0.1Lib creation. Work in progressFeedbackOpen a ticket / fork the project onGitHub, or send me an email atklaregis@gmail.com.
Package: rkt-tool-lib
rkt_tool_lib - Python libraryPython minimal Version 3.7What is Python?Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.sourceLibrariesTool: toolbox library with, you can automatically format the path in your code without worrying about the platform hosting your scriptUse itInstall(venv)my_project>pipinstallrkt_tool_lib[--index-urlhttps://gitlab.tprc.ovh/api/v4/groups/python/-/packages/pypi]Examplefromrkt_tool_libimportToolt=Tool()print(t.get_cwd())print(t.get_dir('db'))Output (as file, sdtout or both)windowsC:\Users\Me\Documents\path\to\my\project\
C:\Users\Me\Documents\path\to\my\project\db\linux:/home/me/path/to/my/project/
/home/me/path/to/my/project/db/ContributingIf you find this library useful here's how you can help:Send a merge request with your kickass new features and bug fixesHelp new users withissuesthey may encounterSupport the development of this library and star this repo!
Package: rkt-utils
:db:wait-forWait for database to be up and running, and the contents will be present.Supports: PostgreSQL, MySQLExamples:rkd:db:wait-for\--host=postgres\--username=riotkit\--password=some\--port5432\--timeout25\--db-name=humhub\--type=postgresrkd:db:wait-for\--host=mysql\--port=3306\--type=mysqlClass name to import:rkt_utils.db.WaitForDatabaseTask [see how toimport]:utils:env-to-jsonDumps all environment variables into JSONrkd:utils:env-to-json# parse any JSON value one dimension deeprkd:utils:env-to-json--parse-jsonClass name to import:rkt_utils.envtojson.EnvToJsonTask [see how toimport]:docker:tagRe-tag images to propagate version tags in docker-like format eg. 1.0.1 -> 1.0 -> 1 -> latestExamples:1.0.0 -> 1.0 -> 1 -> latest
1.0.0-RC1 -> 1.0.0-latest-rc# simple propagate tags 1.2.23 -> 1.2 -> 1rkd:docker:tag--imagemy-image:1.2.23--propagate# advanced usagerkd:docker:tag--imagemy-image:1.2.23--propagate--allowed-meta=rc,alpha,stable,dev,prod,test,beta,build,b:docker:pushPush all re-tagged imagges by:docker:tagrkd@--imagemy-image:1.2.23--propagate:docker:tag:docker:push
Package: rk-utils
rk_utilsSome useful Python utilities made by RKWS.A longer description of your project goes here…Making Changes & ContributingFor developers, extra requirements are inrequirements_dev.txt:cd rk_utils
pip install -r requirements_dev.txtThis project usespre-commit, and it is a good idea to update the hooks to
the latest version before installing:cd rk_utils
pre-commit autoupdate
pre-commit installThere are some usefultoxcommands that can be used to simplify developing:cd rk_utils
tox  # to run all the tests
tox -e docs  # to build your documentation
tox -e build  # to build your package distribution
tox -e publish  # to test your project uploads correctly in test.pypi.org
tox -e publish -- --repository pypi  # to release your package to PyPI
tox -av  # to list all the tasks availableNoteThis project has been set up using PyScaffold 4.4. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: rkvst-receipt-scitt
RKVST Scitt Receipt Verification in pythonPython support for the offline verification of scitt receipts for rkvst events.Notice: This work is based on thedraftstandarddraft-birkholz-scitt-receipts-02. This work and the upstream standard will evolve. We make no current promise of api stabilityPython SupportThis package currently is tested against Python versions 3.7,3.8,3.9, 3.10 and 3.11.The current default version is 3.7 - this means that this package will not
use any features specific to versions 3.8 and later.After End of Life of a particular Python version, support is offered on a best effort
basis. We may ask you to update your Python version to help solve the problem,
if it cannot be reasonably resolved in your current version.
Package: rl4net
RL4NetRL4Net is a reinforcement learning platform based on Pytorch and OpenAI Gym.The supported interface algorithms currently include:SarsaQlearningDeep Q-Network (DQN)Deep Deterministic Policy Gardient (DDPG)InstallationNotice:The platform uses pytorch and numpy. It is recommended to use conda to create a new environment and install it.RL4Net is currently hosted on PyPI. It requires Python >= 3.6.You can simply install RL4Net from PyPI with the following command:pipinstallrl4netYou can also install with the newest version through GitHub:pipinstallgit+https://github.com/bupt-ipcr/RL4Net.git@masterOr install it after downloading it locally:gitclonehttps://github.com/bupt-ipcr/RL4NetEnter folder and install it with pip:cdRL4Netpipinstall.After installation, run examples :pythonexamples/ddpg.pyIf no error occurs, you have successfully installed RL4Net.DocumentationTodoQuick StartYou can create your own reinforcement learning agent through the base class provided inrl4net.agents.The general method is as follows:# import base classfromrl4net.agentsimportxxxBase# inherit and complete necessary methodsclassmyxxx(xxxBase):def_build_net(self):passlearn more about the usage, by codes examples and  annotated documentations underexamples/.Simple neural networks built on pytorch are also provided inrl4net.models. You can take it as a simple implement of DRL neural network.fromrl4net.modelsimportSimpleDQNNetThird, if you want to call the attached envs, you should run__init__.pyto register togym. After that you can use standardgymmethods to create it.importrl4net.envenv=gym.make('Maze-v0')ContributingVVALB is still under development. More algorithms and features are going to be added and we always welcome contributions to help make VVLAB better. If you would like to contribute, please check out this link.
Package: rl4uc-pwdemars
RL4UC: Reinforcement Learning for Unit CommitmentThis project contains an RL environment for the unit commitment problem.## InstallationYou can install this repository by running:git clone https://github.com/pwdemars/rl4uc.git
cd rl4uc
pip install .Example usage:Below we will try an action on the 5 generator system. An action is a commitment decision for the following time period, defined by a binary numpy array: 1 indicates that we want to turn (or leave) the generator on, 0 indicates turn or leave it off.fromrl4uc.environmentimportmake_envimportnumpyasnp# Create an environment, 5 generators by default.env=make_env()# Reset the environment to a random demand profile.obs_init=env.reset()# Define a commitment decision for the next time period.action=np.array([1,1,0,0,0])# Turn on generators 0 & 1, turns all others off.# Take the action, observe the reward.observation,reward,done=env.step(action)print("Dispatch:{}".format(env.disp))print("Finished?{}".format(done))print("Reward:{:.2f}".format(reward))
Package: rlacalc
rlacalccrunches the numbers for risk-limiting post-election audits.
It can calculate sample sizes, as well as calculate risk levels based on observed ballots.
It can handle many of the commonly used RLA tests, including ballot-level comparison via Kaplan-Markov and
ballot polling via BRAVO.GoalsIt is important to emphasize that the output of an audit should be
a report providing evidence related to election outcome, details about and explanations of any discrepancies found,
and conclusions based on that evidence.  See the paperEvidence-Based Elections Stark and Wagnerand the reportRisk-Limiting Post-Election Audits: Why and How.rlacalc helps observers to explore the best way to do an audit beforehand, and to check the numbers in reports published after an audit, e.g. as described for aPublic RLA Oversight Protocol.rlacalc can be used to perform calculations from the command line or used as a library in Python. In addition, if the hug package
is available, it can be accessed over the web.Installationrlacalc works with Python 2.7 and Python 3.x.
There are no other mandatory dependencies beyond the standard library.If hug is installed, rlacalc can be deployed via a web server.Usage$ rlacalc --help
...

$ rlacalc --test
...

$ rlacalc -m 1 -n
Sample size = 479 for margin 1%, risk 10%, gamma 1.03905, o1 0, o2 0, u1 0, u2 0

$ rlacalc -m 1 -n --o1 1
Sample size = 615 for margin 1%, risk 10%, gamma 1.03905, o1 1, o2 0, u1 0, u2 0

$ rlacalc -m 3 -r 5
KM_exp_rnd  = 226 for margin 3%, risk 5%, gamma 1.03905, or1 0.001, or2 0.0001, ur1 0.001, ur2 0.0001, roundUp1 1, roundUp2 0BackgroundFor tools implemented in javascript, with plots, seeTools for Comparison Risk-Limiting Election AuditsTools for Ballot-Polling Risk-Limiting Election AuditsHistoryrlacalc was included as part ofaudit_cvrsin 2015 to help run some early pilot audits in Colorado as part of theThe Colorado Risk-Limiting Audit Project (CORLA).
Package: rl-agents
Implementation of various reinforcement learning methods.Free software: BSD 3-Clause ‘New’ or ‘Revised’ LicenseDocumentation:https://rl-agents.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand themateuspontesm/cookiecutter-poetryproject template,
a fork ofjohanvergeer/cookiecutter-poetryproject template
Package: r-lambda
RunR#lambda function in python workflowIntroduce theR#lambdaTheR#lambda function is a kind of shell feature function in R# script host. Assuming that there is a function namedhello_worldin aR#package which is nameddemo, so that we could run this hello world function in R# script file:# function inside package namespace: democonsthello_world=function(str){print(`hello: ${str}!`);}# call function in another script filedemo::hello_world("world");Via theR#lambda function feature, that we could run this function without write script file, and we could run this function from commandline directly, example as:# call function via R# lambdaRscript--lambdademo::hello_worldand the parameter value of hello world function will be setup via a runtime json file./.r_env/run.jsonin the working directory:{"str":"world"}If the function invoke containsgetOptionfunction calls, then you could setup the runtime environment via the json file./.r_env/options.jsonin the working directory:{"example-var":"1234"}So, you could get such environment variable value in R# runtime environment bygetOption:print(getOption("example-var"));# [1] "1234"Call R# lambda from a python workflowFor call a R# lambda function from your python workflow, then you could use this python package function. Current package call the R# workflow function running in local machine or running in a docker container already been wrapped into function calls, so that you can call such hello world function inR#package in python, example like:importr_lambdafromr_lambda.dockerimportdocker_imager_lambda.call_lambda("demo::hello_world",argv={"str":"world"},options=None,workdir="./",docker=docker_image(id="example_image",volumn=["/home"],name="test",tty=True),run_debug=False)