Saravanan666/pypi-org huggingface dataset:
Package: robot-kafka-library
robot-kafka-libraryrobot framework extension test kafka message queue systemhttps://pypi.org/project/robot-kafka-library/How to Usepip install robot-kafka-libraryImport into project file : example.robotLibrary    RobotKafkaLibrary.Producer
Library    RobotKafkaLibrary.Consumer

*** Test Cases ***
Test producer topic test publish message1
    ${RESULT} =     Publish  {broker-ip}:{port}   {topic}   {message}
    log    ${RESULT}
    Log to console   ${RESULT}

Test consumer topic test subscribe message1
    ${MSG} =     Subscribe  {broker-ip}:{port}   {topic}   {option-timeout}
    log    ${MSG}
    Log to console   ${MSG}Example Result
Package: robot-kit
robot_kitHaving fun with the Freenove 4WD Smart Car KitInstallSSH to your Raspberry Pi and install the Python module for Python 3.$ sudo pip3 install robot_kitExamplesSee the Examples directory for all the code, here is the code listing forexamples/robot_start.pyfrom robot_kit.leds import NeoPixelStrip
from robot_kit.wheels import Wheels
from robot_kit.ultrasonic import Ultrasonic
import time

if __name__ == '__main__':
    """Run some of the basic commands for robot_kit"""

    """Test for the NeoPixelStrip class"""
    led_strip = NeoPixelStrip()

    # Turn the LEDs Yellow and then Green
    led_strip.on(128, 128, 0)
    time.sleep(1.0)
    led_strip.on(0, 255, 0)
    time.sleep(1.0)
    led_strip.off()

    # Turn the wheels
    wheels = Wheels()
    wheels.all(0.25)
    time.sleep(1.0)
    wheels.stop()

    # Get the distance from the Ultrasonic sensor
    dis_sensor = Ultrasonic()
    for i in range(50):
        print(dis_sensor.get_distance())
        time.sleep(0.5)Note:Yon order to run this code you'll need to be sudo as the LED library requires it.$ sudo python3 robot_start.py
Package: robotlibcore-temp
Tools to ease creating larger test libraries forRobot Frameworkusing
Python.Code is stable and version 1.0 is already used bySeleniumLibrary.
Better documentation and packaging still to do.Example"""Main library."""fromrobotlibcoreimportHybridCorefrommystuffimportLibrary1,Library2classMyLibrary(HybridCore):"""General library documentation."""def__init__(self):libraries=[Library1(),Library2()]HybridCore.__init__(self,libraries)"""Library components."""fromrobotlibcoreimportkeywordclassLibrary1(object):@keyworddefexample(self):"""Keyword documentation."""pass@keyworddefanother_example(self,arg1,arg2='default'):passdefnot_keyword(self):passclassLibrary2(object):@keyword('Custom name')defthis_name_is_not_used(self):pass@keyword(tags=['tag','another'])deftags(self):pass
Package: robot-lockable
Robot Framework Remote Resource AllocatorResource locking library for Robot Framework.UsageLibrary importLibrary     RobotLockable       lock_folder=.   resource_list_file=example/resource.json    (hostname=hostname)Available Keywordskeywordargumentsnotelock<requirements>(<timeout_s>)Allocate resource using giving requirementsunlock<resource>Release resourceSee more details using Remote library CLI to generate documentation:python3 RobotLockable/Remote.py --docRemote serverLibrary provide command line utilrobot_lockablethat provide robot remote
server for lockable functionality.
This is useful when resources located remotely
for test case.robot_lockable --help
Usage: robot_lockable [OPTIONS]

  main function for remote plugin

Options:
  --port INTEGER              RemoteLockable server Port
  --host TEXT                 Interface to listen. Use "0.0.0.0" to get access
                              from external machines

  --hostname TEXT             Hostname
  --resources_list_file TEXT  Resources list file
  --lock_folder TEXT          Lock folder
  --doc TEXT                  generate documentation. E.g. doc.html or list
  --help                      Show this message and exit.Run Remote Server In Docker ContainerDocker container is run using command below. Replace path to resource.json and hostname with project specific values:docker run \
  -p 8270:8270 \
  -v <local path to the resource.json folder>:/<path to resource.json folder> \
  --hostname $(hostname) \
  jussiva/robot-lockable:latest \
  --resources_list_file <path to resource.json folder>Full exampleTo run example resource allocator located in this repository, docker run command is:docker run \
  -p 8270:8270 \
  -v $PWD/example:/example/ \
  --hostname hostname \
  --rm \
  jussiva/robot-lockable:latest \
  --resources_list_file /example/resource.json
Package: robot-log-visualizer
🤖 robot-log-visualizerrobot-log-visualizerimplements a python visualizer to display the data logged withYarpRobotLoggerDeviceapplication.📝 InstallPlease follow one of the following methods to use the softwareInstall withconda(recommended)Assuming that you havecondainstalled, you can create a new environment and install therobot-log-visualizerwith the following commands:conda create -n visualizer-envconda activate visualizer-envand you can install therobot-log-visualizerwith the following commandconda install -c robotology robot-log-visualizer🐍 Install frompipwith apt pythonInstallpython3, if not installed (inUbuntu 20.04):sudo apt install python3.8 python3-virtualenv swigCreate avirtual environmentand activate it. For example:python3 -m venv visualizer-env. visualizer-env/bin/activateInside the virtual environment, install the application frompip:pip install robot-log-visualizer👷 Install the latest version (not recommended)If you want to use the latest feature of therobot-log-visualizeryou can install it with the
following commandpython -m pip install git+https://github.com/ami-iit/robot-log-visualizer.git🏃 UsageOnce you have installed therobot-log-visualizeryou can run it from the terminalrobot-log-visualizer.webmYou can navigate the dataset thanks to the slider or by pressingCtrl-fandCtrl-bto move
forward and backward.💡 Environment variablesrobot-log-visualizerlooks for the model in the folders pointed by one of the following environment variables:GAZEBO_MODEL_PATH,ROS_PACKAGE_PATH,AMENT_PREFIX_PATHPlease remember to add your model folder to one of these
environment variables.
For instance, if you have a model in the folder~/my-modelsyou can add it to theGAZEBO_MODEL_PATHwith the
following commandexport GAZEBO_MODEL_PATH=${GAZEBO_MODEL_PATH}:~/my-modelsWhere~/my-modelsis the path to your models folder that is structured as followstree ~/my-models~/my-models├── model1│   ├── model.config│   └── model.urdf└── model2├── model.config└── model.urdfAnd the name of the robot stored in thematfile ismodel1ormodel2.🐛 Bug reports and supportAll types ofissuesare welcome.📝 LicenseMaterials in this repository are distributed under the following license:All software is licensed under the BSD 3-Clause License. SeeLICENSEfile for details.🧑‍💻 MaintainerGiulio Romualdi (@GiulioRomualdi)
Package: robot-mongodb-library
robot-mongodb-libraryrobot framework extension for test connect mongodbhttps://pypi.org/project/robot-mongodb-library/How to Usepip install robot-mongodb-libraryImport into project file : example.robot*** Settings ***
Library   RobotMongoDBLibrary.Insert
Library   RobotMongoDBLibrary.Update
Library   RobotMongoDBLibrary.Find
Library   RobotMongoDBLibrary.Delete


*** Variables ***
# CONNECT WITH PARAMS
# &{MONGODB_CONNECT_STRING}    host=127.0.0.1   port=27017   username=admin   password=password    database=robotdb     collection=customer

# CONNECT WITH CONNECTION STRING CLUSTER
&{MONGODB_CONNECT_STRING}=   connection=mongodb://admin:password@127.0.0.1:27017,127.0.0.2:27017,127.0.0.3:27017/robotdb?authSource=robotdb    database=robotdb   collection=customer


*** Test Cases ***
Test insert data into mongodb
    &{DATA}     Create Dictionary   _id=X100001      name=Tarathep      address=Thailand     phone=8888888888
    ${MSG}      InsertOne   ${MONGODB_CONNECT_STRING}    ${DATA}
    Should Be Equal    ${MSG}    INSERTED SUCCESS


Test find by fillter data from mongodb
    &{FILLTER}     Create Dictionary   name=Tarathep      address=Thailand
    ${RESULTS}     Find    ${MONGODB_CONNECT_STRING}    ${FILLTER}
    FOR    ${RESULT}    IN    @{RESULTS}
           Log To Console    ${RESULT["phone"]}
    END


Test update data phone into mongodb by ID
    &{NEWDATA}     Create Dictionary        phone=0649359xxx
    ${MSG}      Update   ${MONGODB_CONNECT_STRING}    X100001      ${NEWDATA}
    Should Be Equal    ${MSG}    UPDATED SUCCESS


Test find data by ID from mongodb
    ${RESULTS}     FindOneByID    ${MONGODB_CONNECT_STRING}    X100001
    Log To Console      ${RESULTS}


Test delete data by ID into mongodb
    ${MSG}     DeleteOneByID    ${MONGODB_CONNECT_STRING}    X100001
    Should Be Equal    ${MSG}    DELETED SUCCESSExample Result
Package: robot-mouse-track
随着互联网技术的发展，鼠标轨迹识别算法在很多人机交互产品中的需求日益增加，比如，一些网站为了防止被爬，增加了一些滑块验证码，但是一些软件已经可以模拟人的行为破解滑块验证码。本项目就是通过对鼠标轨迹的特征分析，判定是否是人的行为还是机器行为。常见应用场景：网站反爬虫、在线考试系统脚本刷题。
Package: robotonotebook
Roboto Notebook===============A [Mezzanine](http://mezzanine.jupo.org/) theme intended for publishing a personal blog with aminimalist design typeset with Google’s [Roboto](https://www.google.com/fonts/specimen/Roboto) typeface.In initial development.Installation------------1.  Install the Roboto Notebook theme from the Python Package Index(PyPI): `pip install robotonotebook`.2.  Add `"robotonotebook",` to the top of the list of `INSTALLED_APPS` in yourMezannine project’s `settings.py`.3.  Add the following settings to your project’s `settings.py`:INLINE_EDITING_ENABLED = FalsePAGE_MENU_TEMPLATES = ((1, 'Sidebar', 'pages/menus/tree.html'),(2, 'Footer', 'pages/menus/footer.html'),)PAGE_MENU_TEMPLATES_DEFAULT = '1'Things To Do-------------   Remove hardcoded links to editing in admin and find out why adminlink doesn’t lead to pages’ editing interface, while it works forthe blog.-   Finalize styling of all pages, including Mezzanine accounts, formsand galleries.-   Fix image max-width.-   Custom blog archive.-   Fixtures for initial example blog post, about page and footer page.-   Code syntax highlighting.-   Print stylesheet.Future Features That Would Be Nice-----------------------------------   Drag and drop images into library upload area on sidebar, and thenonto post.-   Option for static generation under tools?-   Deployment.-   Download backup of all pages in zipped HTML archive includingstyles and Markdown text file duplicates, i.e. `About.html`,`About.md`-   Built-in [Pandoc](http://pandoc.org/) converter in admin interface.-   Markdown editor with toggleable preview as default for creatingpages and posts, possibly using HTML [Content Editable](https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Content_Editable).Credits======="robotonotebook" is written and maintained by Simon Griffee.Contributors------------The following kind people contributed directly or indirectly to this project:- Hynek Schlawack <https://hynek.me/articles/sharing-your-labor-of-love-pypi-quick-and-dirty/>- Peter Downs <http://peterdowns.com/posts/first-time-with-pypi.html>- Stephen McDonald <https://groups.google.com/d/msg/mezzanine-users/bdqjepkhtzc/dG0xl9qx4kEJ>Please add yourself here alphabetically when you submit your first pull request.Version 0.0.1 (June 1, 2015)--------------------------* No changes listed.
Package: robotools
robotoolsThis is a package for debugging and planning liquid handling operations, writing worklist files for the Tecan FreedomEVO and Tecan Fluent platform on the fly.You can visit the documentation athttps://robotools.readthedocs.io, where thenotebooksare rendered next to auto-generated API documentation.Installationrobotoolsis available throughPyPI:pip install robotoolsContributingThe easiest way to contribute is to report bugs by openingIssues.We apply automated code style normalization usingblack.
This is done with apre-commit, which you can set up like this:pip install pre-commitpre-commit installpre-commit run --allStep 2.) makes sure that thepre-commitruns automatically before you make a commit.Step 3.) runs it manually.Usage and Citingrobotoolsis licensed under theGNU Affero General Public License v3.0.When usingrobotoolsin your work, please cite thecorresponding software version.@software{robotools,author={Michael Osthege andLaura Helleckes},title={JuBiotech/robotools: v1.3.0},month=nov,year=2021,publisher={Zenodo},version={v1.3.0},doi={10.5281/zenodo.5745938},url={https://doi.org/10.5281/zenodo.5745938}}Head over to Zenodo togenerate a BibTeX citationfor the latest release.
Package: robot-opentmi
robot listener plugin for opentmiThis robot-framework listener listen results and upload them to OpenTMI.UsageInstall using pip:pip install robot-opentmiRunning with robot:robot --listener robot_opentmi.plugin.PythonListener:<host>:<token>:<port>:<store_logs> example/example.robotWhere:<host>is OpenTMI uri (required)<token>is OpenTMI access token (required)<port>is OpenTMI port (default: 80, optional)<store_logs>store logs to OpenTMI (default: False, optional)metadatamodule utilize some special robot metadata.
Usage:robot -M <KEY>:<VALUE> ...Keys:Device Under Test:DUT_SERIAL_NUMBERDUT_TYPEDUT_VERSIONDUT_VENDORDUT_MODELDUT_PROVIDERSoftware Under Test:SUT_COMPONENTSUT_FEATURESUT_COMMIT_IDSUT_BRANCH
Package: roboto-telegram
RobotoA type-hinted async Telegram bot library, supportingtrio,curioandasyncio.Roboto's API is not perfectly stable nor complete yet. It will be kept a 0.x.0
until the Telegram Bot API is completely implemented, and will be bumped to
1.0.0 when it is complete.Basic usageRoboto is still a low-level bot API, meaning it does not provide much
abstraction over the Bot API yet (that is planned, though).Currently, a basic echo bot with roboto looks like:fromrobotoimportToken,BotAPIfromtrioimportrun# This could be asyncio or curio as well!api_token=Token('your-bot-token')asyncdefmain()->None:asyncwithBotAPI.make(api_token)asbot:offset=0whileTrue:updates=awaitbot.get_updates(offset)forupdateinupdates:ifupdate.messageisnotNoneandupdate.message.textisnotNone:awaitbot.send_message(update.message.chat.id,update.message.text,)ifupdates:offset=updates[-1].update_id+1# In asyncio it should be "main()".run(main)Being statically-typed, Roboto supports easy autocompletion andmypystatic
checking.ContributingCheck ourcontributing guideto know how to develop on
Roboto and contribute to our project.GoalsPrinciplesEase of static checking for client code, especially static typing.Forwards compatibility (additions to the bot HTTP API should not break older
versions of Roboto easily).Achieved milestonesSupport for other async runtimes other than asyncio (especiallytrio) (done in 0.2.0).All functions underAvailable methodsin the official
documentation(0.3.0).All functions underUpdating messagesin the official
documentation(0.4.0).Next milestonesAll functions underStickersin the
documentation(0.5.0).Inline mode
functionality(0.6.0).Payments functionality(0.7.0).Telegram Passport
functionality(0.8.0).Games functionality(0.9.0).Tests for all bot API functions inbot_tester.Documentation with examples and tutorials.API documentation (automatically generated, likely withSphinx).API cleanup/streamlining (e.g. use kw-only arguments in bot methods) (1.0.0).High-level API (abstraction for command handlers, necessary internal
state, etc.).AcknowledgementsThis used to be a disclaimer that we were vendoringasks. We are not anymore (the feature we needed is
now on upstream), but I will still keep the acknowledgemente because it (throughanyio) gives us the ability to support the three
major async event loops,asyncio,trioandcurio!
Package: robot-poete
robot_poete - Le Robot PoèteCe module permet de programmer le Robot Poète.'    ____        __          __     ____        __   __      '
'   / __ \____  / /_  ____  / /_   / __ \____  _\_\ / /____  '
'  / /_/ / __ \/ __ \/ __ \/ __/  / /_/ / __ \/ _ \/ __/ _ \ '
' / _, _/ /_/ / /_/ / /_/ / /_   / ____/ /_/ /  __/ /_/  __/ '
'/_/ |_|\____/_.___/\____/\__/  /_/    \____/\___/\__/\___/  '
'                                                            'Vous pouvez l'installer avec pip:pip install robot_poeteExemple d'usage:# importation et initialisation de la biblioteque
from robot_poete import RP
rp = RP()

# chemin du dossier de rimes
pathDossier1 = rp.pathSongFolder(rp.path, 'dossier', 'sous_dossier')

# liste des pistes audio
liste1 = rp.listSong(pathDossier1)

# choix aléatoire d'une piste
song = rp.random(liste1)

# suppression de la piste dans la liste
rp.remove(liste1, song)

# lecture de la piste
rp.playSong(pathDossier1, song)Ce code est sous licence MIT.Copyright (c) 2020 Yoann VARENNEPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: robotpt-common-utils
READMEA collection of common functions.SetupOption 1: Clone the repositoryBest if you want to modify or view the code - note that you can do the following inside of a virtual environmentgit clone https://github.com/robotpt/robotpt-common-utilsAn easy way to setup the repository with its dependencies and with your Python path
is to usepip.pip install -e robotpt-common-utilsTests can be run with the following commands.cd robotpt-common-utils
python3 -m unittestOption 2: Use PipBest if you just want to use itpython3 -m pip install robotpt_common_utils
Package: robotpy
Easy to remember desktop installation for RobotPy! For more information
about RobotPy, see the [documentation](https://robotpy.readthedocs.io).The instructions below work on a normal computer. For RoboRIO instructions,
see [the documentatation](https://robotpy.readthedocs.io/en/stable/install/robot.html#install-robotpy).Install core RobotPy componentsOn Windows:` py-3-mpip install-Urobotpy `On Linux/OSX:` pip3 install-Urobotpy `Install optional RobotPy components> [!NOTE]
> At the beginning of build season not all components are available because
> vendors haven’t made releases set. If you install one of those components,
> it will try to install version0.0.0There are several categories of optional components that you can install. This
uses the standard pip ‘extras’ installation functionality. The available
categories are:apriltagcommands2cscorenavxpathplannerlibphoenix5phoenix6playingwithfusionrevromisimxrpLet’s say that you wanted to install the latest version of the NavX software
along with command based programming. You would do this:On Windows:` py-3-mpip install-Urobotpy[navx,commands2] `On Linux/OSX:` pip3 install-Urobotpy[navx,commands2] `Install all optional componentsThere is a special ‘all’ category which will install the core components
and all of the optional categories.On Windows:` py-3-mpip install-Urobotpy[all] `On Linux/OSX:` pip3 install-Urobotpy[all] `
Package: robotpy-adi
RobotPy wrappers for the following Analog Devices products:ADIS16448ADIS16470NoteThe RobotPy project is not associated with or endorsed by Analog
Devices Inc. or FIRST Robotics CompetitionDocumentationInstallationPython API DocumentationAuthorsADIS16448 support contributed by@picode98ADIS16470 support contributed by@SHU-maticLicenseMIT License
Package: robotpy-build
robotpy-buildThis is a build tool intended to be generally useful for any python project
that has binary dependencies. It is especially designed to meet the needs
of RobotPy's various wrapper libraries, chiefly around:Managing upstream binary dependenciesAutogenerating pybind11 wrappers around those dependenciesBuilding wheels from those generated wrappersRequires Python 3.8+DocumentationDocumentation can be found athttps://robotpy-build.readthedocs.io/AuthorDustin Spicuzza is the primary author of robotpy-build, but it is the
culmination of many years of experimentation with automated wrapper
generation by members of the RobotPy community.robotpy-build is available under the BSD 3-clause license.
Package: robotpy-cli
robotpy-cliNew for 2024, this package is used to execute subcommands on a RobotPy project.
This does not actually implement any subcommands itself, but provides a mechanism
to execute those subcommands.UsageOn Windows:py -m robotpyOn Linux/macOS:python -m robotpySee the RobotPy documentation for more information.How RobotPy subcommands are implementedWhen a user runsrobotpyorpython -m robotpy, they are presented with
several subcommands. Each of these subcommands is implemented as a class
that is registered using python's entry point mechanism in the "robotpy"
group. The registered class must meet the following requirements:The docstring of the class is used when the user does --help. The first
line is treated as the summary, and all other lines are displayed when
the subcommand specific help is queried.If the subcommand is a group of commands:The class must have asubcommandsattribute, which is a list of
(name, subcommand_class) tuples. The subcommand_class must meet the requirements
for a subcommand.If it is a subcommand that is executed:The constructor must take a single argument, an argparse.ArgumentParser.
The object may register any arguments or subparsers that it needs.Therunfunction is called when the subcommand is used by the user.
The arguments to this function are passed in by name, and the names can
be any of the options that the subcommand registered. There are two other
special argument names:options- if specified, this is the Namespace returned by parse_argsrobot_class- if specified, the user's robot.py will be loaded and
it will be inspected for their robot class, which will be passed in
as this optionmain_file- if specified, the name of the user's robot.py file. This
is not guaranteed to exist unless robot_class is also an option.project_path- if specified, the name of the directory that contains
the user's robot.py file. This is not guaranteed to exist unless robot_class
is also an option.