Saravanan666/pypi-org huggingface dataset:
Package: robomaster
RoboMaster SDK is based on the Python language and is suitable for the Python SDK software library
of the RoboMater series.
Currently applicable to RoboMaster EP and Tello Edu and other products, it provides a rich API interface,
including: motion control, flight control, intelligent identification, lighting effect settings, data push,
video streaming and audio streaming APIs. And the design follows the principle of being as simple as possible,
and can be quickly used to facilitate learning and teaching. Based on each API interface,
there are code examples, you can refer to our developer documentation robomaster-dev.readthedocs.io.
Package: robomasterpy
RoboMasterPyEnglish|中文RoboMasterPyis a RoboMaster Python SDK and framework:Python SDK: inspect and control your Robomaster, remotely;framework: development framework providing and regularising control flow and data flow, resolving common needs like pulling and parsing on video stream, events and pushes, decoupling boilerplate codes like controlling loop, logging, graceful shutdown. You may rely on the framework, implement your business logic with ease of mind and less manual labor.The SDK(client) is straightforward to use:>>>importrobomasterpyasrm# IP of RoboMaster is detected under router mode>>>cmd=rm.Commander()# check RoboMaster's API version>>>cmd.version()'version 00.00.00.60'>>>cmd.get_robot_mode()'chassis_lead'# ensure your Robomaster has enough room to move>>>cmd.chassis_move(x=-1,z=30)'ok'# activate video streaming,# which can be handled by the framework.>>>cmd.stream(rm.SWITCH_ON)'ok'# activate gimbal attitude push at 5Hz,# which can be handled by the framework.>>>cmd.gimbal_push_on(attitude_freq=5)'ok'# Watch out!>>>cmd.blaster_fire()'ok'The framework lets you create complicated application easier, e.g.:Drive your robomaster using keyboard;Make your robomaster a goalkeeper;More examplesInstallationRoboMasterPy requires Python 3.6 and above.Install Dependencies FirstIf you are using Python 3.6.x, you need to installdataclasses, which is already included in Python 3.7 and better:pipinstalldataclassesInstall OpenCV of your flavor, suggestion::# if you are using condacondainstall-cconda-forgeopencv# if you are using pip onlypipinstallopencv-contrib-pythonInstall RoboMasterPypipinstallrobomasterpyUser GuideEnglish:https://robomasterpy.nanmu.me/en/latest/中文文档（Chinese）：https://robomasterpy.nanmu.me/zh_CN/latest/Documentation is generously hosted by Read the Docs.Health and Safety NoticeYour Robomaster may hurt people or pet, break stuffs or itself;Make sure your RoboMaster has enough room to move; make sure the ground is clear;Start slowly, avoid using high speed for debugging;Use cushion;Stay safe and have fun!PaperworkRoboMasterPy is a fan work, and it has no concern with DJI.DJI, RoboMaster are trademarks of SZ DJI Technology Co., Ltd.AcknowledgementRoboMasterPy was incubated during a RoboMaster EP developing contest. The author would like to thank DJI for hardware and technical support.LicenseMIT LicenseCopyright (c) 2020LI Zhennan
Package: robomeshcat
RoboMeshCatSet of utilities for visualizing robots in web-based visualizerMeshCat.
The whole library is object and robot centric allowing you to modify properties of instances rather than manipulating
the visualization tree of the MeshCat itself.
The library allows you to easily generate videos like this (source code ishere):or like this (by installing a few moredependencies;source code):InstallationFromcondainstall-cconda-forgerobomeshcatFrom PyPIpipinstallrobomeshcatAboutThis library allows you to visualize and animate objects and robots in web browser.
Compared toMeshCatlibrary, on which we build, our library is
object-oriented allowing you to modify the properties of individual objects, for example:o=Object.create_sphere(radius=0.2)o.pos[2]=2.# modify positiono.opacity=0.3# modify transparencyo.color[0]=1.# modify red channel of the coloro.hide()# hide the object, i.e. set o.visible = FalseIn addition to objects, it allows you to easily create and manipulate robots (loaded fromURDFfile):r=Robot(urdf_path='robot.urdf')r[0]=np.pi# set the value of the first jointr['joint5']=0# set the value of the joint named 'joint5'r.pos=[0,0,0]# set the base pose of the robotr.color,r.opacity,r.visibility,r.rot=...# change the color, opacity, visibility, or rotationAll changes will be displayed immediately in the browser, that we call 'online' rendering.
By default, you can rotate the camera view with your mouse.
However, our library allows you to control the camera from the code as well through theSceneobject, that is the main
point for visualization:scene=Scene()scene.add_object(o)# add object 'o' into the scene, that will display itscene.add_robot(r)# add robot 'r' into the scene, that will display itscene.camera_pos=[1,1,1]# set camera positionscene.camera_pos[2]=2# change height of the camerascene.camera_zoom=2# zoom inscene.reset_camera()# reset camera such that you can control it with your mouse againFor complete examples of object and robot interface see our two examples:01_object.pyand02_robots.py.It is also possible to visualize human model after installing a few more dependencies,
seeinstallationand example06_human.py.AnimationThis library allows you to animate all the properties of the objects and robots (e.g. position, robot configuration,
color,opacity) inside the browser (from which you can replay, slow-down, etc.). Simply use:scene=Scene()scene.add_object(o)withscene.animation(fps=25):o.pos[2]=2.scene.render()# create a first frame of the animation, with object position z-axis set to 2.o.pos[2]=0.scene.render()# create a second frame of the animation with object on the groundYou can also store the animation into the video, using the same principle:withscene.video_recording(filename='video.mp4',fps=25):scene.render()See our examples onAnimationandImage and video.
Package: robomimic
robomimic[Homepage][Documentation][Study Paper][Study Website][ARISE Initiative]Latest Updates[07/03/2023]v0.3.0: BC-Transformer and IQL :brain:, support for DeepMind MuJoCo bindings :robot:, pre-trained image reps :eye:, wandb logging :chart_with_upwards_trend:, and more[05/23/2022]v0.2.1: Updated website and documentation to feature more tutorials :notebook_with_decorative_cover:[12/16/2021]v0.2.0: Modular observation modalities and encoders :wrench:, support forMOMARTdatasets :open_file_folder:[release notes][documentation][08/09/2021]v0.1.0: Initial code and paper releaseColab quickstartGet started with a quick colab notebook demo of robomimic with installing anything locally.robomimicis a framework for robot learning from demonstration.
It offers a broad set of demonstration datasets collected on robot manipulation domains and offline learning algorithms to learn from these datasets.robomimicaims to make robot learning broadlyaccessibleandreproducible, allowing researchers and practitioners to benchmark tasks and algorithms fairly and to develop the next generation of robot learning algorithms.Core FeaturesReproducing benchmarksThe robomimic framework also makes reproducing the results from different benchmarks and datasets easy. See thedatasets pagefor more information on downloading datasets and reproducing experiments.TroubleshootingPlease see thetroubleshootingsection for common fixes, orsubmit an issueon our github page.Contributing to robomimicThis project is part of the broaderAdvancing Robot Intelligence through Simulated Environments (ARISE) Initiative, with the aim of lowering the barriers of entry for cutting-edge research at the intersection of AI and Robotics.
The project originally began development in late 2018 by researchers in theStanford Vision and Learning Lab(SVL).
Now it is actively maintained and used for robotics research projects across multiple labs.
We welcome community contributions to this project.
For details please check ourcontributing guidelines.CitationPlease citethis paperif you use this framework in your work:@inproceedings{robomimic2021,title={What Matters in Learning from Offline Human Demonstrations for Robot Manipulation},author={Ajay Mandlekar and Danfei Xu and Josiah Wong and Soroush Nasiriany and Chen Wang and Rohun Kulkarni and Li Fei-Fei and Silvio Savarese and Yuke Zhu and Roberto Mart\'{i}n-Mart\'{i}n},booktitle={Conference on Robot Learning (CoRL)},year={2021}}
Package: robonomics-interface
robonomics-interfaceThis is a simple wrapper overhttps://github.com/polkascan/py-substrate-interfaceused to facilitate writing code for applications using Robonomics.Robonomics project:https://robonomics.network/Robonomics parachain dapp:https://parachain.robonomics.network/Documentation:https://multi-agent-io.github.io/robonomics-interface/Installationpip3installrobonomics-interfaceContributingWhen contributing to this repository, please first discuss the change you wish to make via issue,
email, or any other method with the owners of this repository before making a change.Pull Request ProcessInstallpoetryGit clone the repositoryInstall requirements withpoetryinstallInstallingsubstrate_interfacemay requireRustandRustup nightly.Add functions/edit code/fix issues.Make a PR....Profit!Some important rulesIf needed, install dependencies withpoetryadd<lib>UseReStructuredTextdocstrings.Respect typing annotation.Add documentation. Please take in consideration that if a new class was created, add it todocs/source/modules.rst.
Other functionality is better to be described indocs/source/usage.rstBlack it:black-l120<modified_file>Check how the docs look viamake htmlfrom thedocsfolder and checking thedocs/build/html/index.htmlpage.Do not bump version.One may test the code by# in project rootpoetrybuild
pip3uninstallrobonomcis_interface-y#if was installed previouslypip3installpip3installdist/robonomics_interface-<version>-py3-none-any.whlpython3<testing_script>
Package: robopal
English |中文文档robopalis an open source robot simulation framework based onMuJoCo, mainly used for deep reinforcement learning training and
Control algorithm verification. A variety of control schemes and example environments are provided within the framework.Compared with other frameworks, ours has the following advantages:Higher motion accuracy, it is more in line with the motion in the real environmentHigh portability, more concise code, easy to learn and useRich task environment, such as compliant control, motion imitation, visual servoing, etc.InstallationRequired environmentsWindows(10+) / LinuxPython 3.9+MuJoCo-2.3.7pinocchio2.6.20Install from source$ git clone https://github.com/NoneJou072/robopal
$ cd robopal
$ pip install -e .ControllerThe development version mainly includes the following controllers:Joint Space ControllerUse Ruckig to plan joint positions, velocities, accelerations for smooth motion, and calculate torques based on pd control and dynamicsCartesian Space ControllerPosition/rotation control in Cartesian space based on pd control and kinematics
Package: roboparse
roboparseSimple utility which helps to organize code of your scraper.ExampleGo to theexampledirectory.InstallationVia pippipinstallroboparseVia gitgitclonehttps://github.com/Toffooo/roboparse.gitcdroboparse
pipinstall-e.RoutersYou have 2 options when you create routers.Make one and big router for all features that you needDivide it to small partsBig routerfromroboparseimportBaseRouterfromroboparse.schemasimportRouterResponseclassBlogSiteRouter(BaseRouter):defget_posts(self)->RouterResponse:response=self.create_router_response(path="<site_url>",# Path is just meta data. It uses for nothinglinter={"type":"LIST","tag":"li","attrs":{"class":"content-list__item"},"children":{"type":"ELEMENT","tag":"h2","attrs":{"class":"post__title"},"children":{"type":"ELEMENT","tag":"a","attrs":{"class":"post__title_link"}}}})returnresponsedefget_main(self)->RouterResponse:response=self.create_router_response_from_json(path="json_file.json")returnresponsedef_fb_exclude_none_blocks(self,data):return[elementforelementindataifelementisnotNone]Small routerfromroboparseimportBaseRouterfromroboparse.schemasimportRouterResponseclassBlogFilters:def_fb_exclude_none_blocks(self,data):return[elementforelementindataifelementisnotNone]classBlogMainRouter(BaseRouter,BlogFilters):defget(self)->RouterResponse:response=self.create_router_response_from_json(path="json_file.json")returnresponseclassBlogPostRouter(BaseRouter,BlogFilters):defget(self)->RouterResponse:response=self.create_router_response(path="<site_url>",# Path is just meta data. It uses for nothinglinter={"type":"LIST","tag":"li","attrs":{"class":"content-list__item"},"children":{"type":"ELEMENT","tag":"h2","attrs":{"class":"post__title"},"children":{"type":"ELEMENT","tag":"a","attrs":{"class":"post__title_link"}}}})returnresponseExplanation:create_router_response- Every method of router should return router response as following, this responses will be provided to parser, and handled by ita)path- Meta about url of pageb)linter- You have to provide there hierarchy of html elementscreate_router_responsefrom_json- Same ascreate_router_response, provide json file's path and load your linter's schema from it. Json structure should be same_fb prefix- You can register filters for your router. In this example, I've declared the filter by adding to method name_fbprefix.
This will register your method in the class as filter. My filter just removes None elements from list and returning handled data.See code example atexample/scraper.py
Package: robophery
Design and implementation of Python library for interfacing low level hardware
sensors and actuators with MQTT and TSDB bindings. The system architecture is
designed to be so simple at hardware level to support sigle-board
microcontrollers like ESP2866, ESP32 modules as well as sigle-board computers
based on ARM or x86 architectures. The communication among devices is handled
by the standard MQTT message bus.InstallationVirtualenvInstall required dependenciesapt-getinstallpython-devlibyaml-devgitpython-virtualenvPrepare clean virtualenvvirtualenv/opt/robopheryClone this repositorygitclonehttps://github.com/cznewt/robophery.gitInstall dependencies and robopherysource/opt/robophery/bin/activatepipinstall-rrequirements.txtpythonsetup.pyinstallServiceIf you are running systemd-enabled distribution, setup systemd unit file to
start robophery automatically:cat<< EOF >>/etc/systemd/system/robophery.service
[Unit]
Description=robophery manager
Wants=mosquitto.service
After=network.target mosquitto.service

[Service]
Type=simple
User=root
Group=root
WorkingDirectory=/opt/robophery
Environment=ROBOPHERY_CONF=/etc/robophery
ExecStart=/opt/robophery/bin/rp_manager
RestartSec=5
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOFCreate/opt/robopherydirectory and config file/opt/robophery/robophery_conf.pyand start the service.systemctldaemon-reloadsystemctlstartrobopherysystemctlenablerobopheryTo check status of a service, usesystemctl status-lrobophery.
To see logs, you can use systemd journal (eg.journalctl-urobophery-f)ConfigurationYou can usesalt-formula-robopheryto automate both installation and
configuration or you can provide config file in any other way.ExampleFollowing example configuration will setup robophery running on Raspberry Pi
and will collect data from DHT22 sensor attached to GPIO pin 3 and publish it
to MQTT every 60 seconds.CONF = {
  'name': 'mylittleraspberry',
  'log_level': 'debug',
  'log_handlers': ['console', 'syslog'],
  'read_interval': 10000,
  'publish_interval': 60000,
  'platform': 'raspberrypi',
  'config': {
    'comm': {
      'default_mqtt': {
        'host': 'mymqttserver',
        'port': 1883,
        'class': 'robophery.comm.linux.mqtt.PahoMqttComm'
      },
    },
    'interface': {
      'local_gpio': {
        'engine': 'gpio',
        'class': 'robophery.platform.rpi.gpio.RaspberryPiGpioInterface'
      }
    },
    'module': {
      'dht22': {
        'data': {
          'pin': 3,
        },
        'class': 'robophery.module.gpio.dht22.Dht22Module'
      }
    }
  }
}More InformationOffical RoboPhery DocumentationSensor Markup Language (SenML)
Package: robophisher
RoboPhisherWhat is it?RoboPhisher is a security tool that mounts automated victim-customized
phishing attacks against WiFi clients in order to obtain credentials or
infect the victims with malware. It is primarily a social engineering
attack that unlike other methods it does not include any brute forcing.
It is an easy way for obtaining credentials from captive portals and third
party login pages (e.g. in social networks) or WPA/WPA2 passphrases.The Latest VersionDetails of the latest version can be found on the projects Github
page underhttps://github.com/blackHatMonkey/RoboPhisher.DocumentationThe documentation available as of the date of this release is
included in RST format in the docs/ directory. The most
up-to-date documentation can be found athttp://robophisher.readthedocs.io/en/latest/.InstallationPlease see the Getting Started section of the documentation.LicensingPlease see the file called LICENSE.ContactsIf you want to be informed about new code releases, bug fixes,
security fixes, general news and information about RoboPhisher
subscribe to the Github project under
<https://github.com/blackHatMonkey/RoboPhisher>If you have a concrete bug report for RoboPhisher please see
the instructions for bug reporting at
<http://robophisher.readthedocs.io/en/latest/users_guide.html#bug-reporting>DisclaimerUsage of RoboPhisher for attacking infrastructures without prior mutual
agreement can be considered as an illegal activity. It is the final
user’s responsibility to obey all applicable local, state and federal laws.
Authors assume no liability and are not responsible for any misuse or damage
caused by this program.
Package: robo-pid
robo-pidA Python PID Controller For Mobile RoboticsRoboPIDis PID controller designed to handle the combined kinematic
and dynamic complexity of mobile robotics. The controller implements timestep
integration and can be used in discretized time regulators.RoboPIDhas proven to be a tested, reliable PID controller that can
regulate the dynamic balance and rapid response required for differential drive
linear and lateral wheeled motion control. It has been used, for example with mobile
robotic systems for LVC (Linear Velocity Control) for regulating wheel velocities,
LVDR (Lateral Velocity Differential Regulator) for keeping the wheel velocities in sync for
differential drive mobile robots when traversing a straight line path and
ADVR (Angular Differential Velocity Regulator) for tracking a heading angle using typical
motion control input signals (v,w) for linear velocities and angular orientation rotational rates.The PID controller supports 2 modes of operation:IntegrativeandIterativeInIntegrative Mode, the timestep integrations are calculated inside the controller
and the output from the PID controller for the current timestep is used directly or with
modifications and sent to the device or process plant as the current input signal without
further iterative integration.InIterative Mode, the PID timestep integrations are manually calculated and updated
outside the controller in the algorithm that calls the PID controller for the output of
the PID at the current timestep.Installation:$pipinstall robo-pidFor documentation seehttps://robo-pid.readthedocs.io/en/latest/
Package: roboplot
roboplotLibrary of plotting functions for everything roboticsAboutroboplotaims to provide a set of easy to use functions for plotting various data and visualizations related to robotics.
The goal is for this to be fully featured and easy to use, in a functional style, to aid in rapid prototyping.As such,roboplotleveragesgtsamheavily for access to robotics primitives that are easy to work with.gtsamsupports conversions to and from other libraries, in case you prefer something else.InstallationSimply runpipinstallroboplotTo install a development version, runpip install -e .in the root directory.DocumentationTODO!Feature RequestsSupport for measurement streamsAddmeshcatsupport so we can view plots on browsers.Support forPolyscopefor 3D geometry plotting.bqplotIPyVolumefor 3D shapes?
Package: robopy
ROBOPY is a python implimentation of The Robotics Toolbox (RTB) (The brainchild of Peter Corke) for Matlab. The toolbox provides a range of functions that are useful in the study and simulation of classical arm-type robotics including kinematics, dynamics and trajectory generation. Via the porting of the toolbox we hope to create greater access to the toolbox without the need for pricy software subscriptions.
Package: robopython
robopythonRobo Wunderkind Python API - BLED112 USB Dongle RequiredOfficial Robo Wunderkind Modular Robotics Kit Python InterfaceFor more information about Robo Wunderkind please visithttps://www.robowunderkind.com/Python 2.x Supported
Python 3.x SupportedFree software: Apache Software License 2.0Documentation:https://robopython.readthedocs.io.Upcoming FeaturesNew Module integration such as Line TrackerMQTT Wi-Fi networkingFuzzy Logic Filter for Sensors/StatesGetting StartedInstall with: pip install robopythonfrom robopython import RoboCreate an instance of Robo object by doing: my_robo = Robo(“BLE Name”)Test Functionality by playing a sound with: my_robo.System.play_sound(0)Chrome OSUpdate to latest Chrome OSSet into Developer Mode$ sudo dev_install pythonInstall ChromeBrew:https://skycocker.github.io/chromebrew/crew install freestylepip install robopythonRun python as sudo for robopython to workTroubleshootingIf you get an error saying No BGAPI compatable device is detected please insert the BLED112 USB dongle or switch USB ports
If problem persists you can identify the COM port explicitley with my_robo = Robo(“BLE Name”, COM PORT)History0.1.0 (2018-11-06)First release on PyPI.0.4.3 (2019-01-16)0.4.4 (2019-10-15)0.4.5 (2019-10-18)0.4.6 (2019-10-27)0.4.7 (2019-11-13)0.4.8 (2020-02-19)0.5.0 (2020-03-04)1.0.1 (2020-09-03)1.0.2 (2020-09-17)1.0.3 (2021-03-15)1.0.4 (2021-03-17)Latest release on PyPI.
Package: roboquant
Roboquant is an open-source algorithmic trading platform. It is flexible, user-friendly and completely free to use. It is designed for anyone serious about algo-trading.So whether you are a beginning retail trader or an established trading firm, roboquant can help you to develop robust and fully automated trading strategies. You can find out more atroboquant.org.UsageThe following code snippet shows the steps required to run a full back-test on a number of stocks.importroboquantasrqfeed=rq.feeds.YahooFeed("JPM","IBM","F",start_date="2000-01-01")strategy=rq.strategies.EMACrossover()account=rq.run(feed,strategy)print(account)InstallRoboquant can be installed like most other Python packages, using pip or conda.
Make sure you have Python version 3.10 or higher installed.python3-mpipinstall--upgraderoboquantThe core of roboquant limits the dependencies.
But you can install roboquant including one or more of the optional dependencies if you need certain functionality:# market data from Yahoo Finance using the YahooFeedpython3-mpipinstall--upgrade"roboquant[yahoo]"# PyTorch based strategies using RNNStrategypython3-mpipinstall--upgrade"roboquant[torch]"# Integration with Interactive Brokers using IBKRBrokerpython3-mpipinstall--upgrade"roboquant[ibkr]"# Install all dependenciespython3-mpipinstall--upgrade"roboquant[all]"Building from sourceAlthough this first step isn't required, it is recommended to create a virtual environment.
Go to the directory where you have downloaded the source code and run the following commands:python3-mvenv.venvsource.venv/bin/activateYou should now be in the virtual environment and ready to install the required packages and build/install roboquant:pipinstall-rrequirements.txt
python-mbuild
pipinstall.Some other useful commands:# run the unit testspython-munittestdiscover-stests/unit# validate the codeflake8roboquanttestsKotlin versionNext to this Python version ofroboquant, there is also a Kotlin version available.
Both (will) share a similar API, just the used computer language is different.Which one to use depends very much on personal preference, skills and the use-case.