Saravanan666/pypi-org huggingface dataset:
Package: radware-sdk-common
IntroductionThis project implements common SDK functions for Radware device SDK packages.
it defines interfaces for interacting with device management & configuration planes.
the package is intended to be independently reusable in any device project in Python.
right now it offers REST interface for communication, but additional can be added as neededeach implementing device SDK inherit a ConfigurationManager module that offer configuration staging engine,
dry run , differential update , write on change and config diff (via the abstraction defined by the model)
set of interfaces enable accurate definition of procedure and normalization customization.each implementing device provide two methods to accomplish object configuration declaration:DEPLOY - when applicable it basically delete (if exist) and create new objectDIFFERENTIAL - modify current object to reach desire configuration state as reflected in structure, it will change/add/remove accordingly.the former suitable for "push-all-at-once" automation, the latter is good for "per-object" modifications as it keep external referencesthe SDK is requires Python >3.6further details & doc will be added laterInstallationpip install radware-sdk-commonDesign PrinciplesDefine the Interfaces for beans, configurators, managementDefine device connections APIProvide the Backend driver for communication: currently supports RESTDefine the abstraction base structure and interfaceExceptionsTranslate enums: developer/user can work with string/values/enumIt is actually taking care of configuring the device and also provide a Configuration Manager with staging capability:Diff before and after: at the abstraction levelDry run: go down to the lowest code point, right before submitting the REST call.Dry run report of duplicate entries (Differential=False), Identify duplicate entries within a structureNormalizes result for diff: handle order mismatch, necessary for abstract compare (server1 == real2)Differential update: Executes changes only - modify/add/remove, ignore attributes equal to existing. Useful to prevent errors due to conflicts with existing configuration entriesWrite on change: Executes Alteon write calls only when an actual change has been evaluated. Prevent false apply due to internal index changeTranslate resultinterface for struct-specific normalizationAuthorscommon SDK was created byLeon MeguiraCopyrightCopyright 2019 Radware LTDLicenseLicensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
Package: radynpy
RadynPyIMPORTANT NOTEThis is an early development release of RadynPy, a nascent suite of tools to
allow analysis of Radyn simulations to be performed in Python. It contains a
minimal set of features to perform analysis of Radyn CDF files, and produce
contribution functions.If you don’t know what Radyn is, then this package is probably not aimed at you!The easiest way to load a CDF file is to useradynpy.cdf.LazyRadynData. An
object can be constructed by passing the path to a Radyn CDF file. Data is
loaded lazily as it is requested. The normal keys of this file can then be
accessed by.notation (e.g. data.tg1). To look at the indexing convention
and the data layout (which is different to IDL due to handling of the record
time axis), the functionsindex_convention, and for information on a
specific variable, or set of variables,var_infocan be used.var_infotakes a string or list of strings for the variables of interest (this string
may be ‘*’ to print information on all variables).The classradynpy.cdf.RadynDataalso exists, it takes the path to a CDF
file, and a list of keys to be loaded (or ‘*’ for everything). It performs
similarly to LazyRadynData, but a key that was not requested at construction
will not be loaded.NOTE:By default bothRadynDataandLazyRadynDataexpect a filename in
the F-CHROMA style (i.e. with the heating parameters), if your filename does
not fit this style then both classes take aparseFilenameParams=Falsekwarg.Contribution functions can be plotted usingradynpy.matsplotlib.contib_fn.
See the extensive docstring of this function for more information. Utilities
used in the calculation of the contribution function can be found inradynpy.matsplotlib.utilsandradynpy.matsplotlib.opacity. For the
most part these are very simple functions and classes that mirror the
counterparts in the Radyn software distribution produced by M. Carlsson.
Package: radyn-xtools
radyn_xtoolsradyn_xtoolsis a package with some bare-bones Python analysis routines for a grid of M dwarf flare models (Kowalski, Allred, & Carlsson, submitted Feb 2024) calculated with the RADYN code.  The.fitsfiles (grid output) can be downloaded through Zenodo.In a terminal window:conda create --name your_env_name python=3.11pip install radyn_xtoolsconda activate your_env_nameSeeradyn_xtools_Demo.ipynbfor a demonstration on how to use the tools.  This should be downloaded intoyour_env_name/site-packages/radyn_xtools/folder.  To find it, start python and type:import radyn_xtools.radyn_xtools as radxradx
Package: raebot
raebotSearch for definitions from the DLE.This package is inspired bypyrae, but is implemented in a way I find more
intuitive. Also, most importantly for me, synonym and antonym support.InstallationpipinstallraebotDevelopInstall poetry.Create a virtual environmentrunpoetry installto install the dependencies.TDD recommended. Add a case, then update the script to make the test pass.PRs welcome.TestingRunpoetry run pytestto run the tests.PublishIf you are Weiwei or one of his robots, runpoetry publish --buildto publish a new version.Usage>>>fromraebotimportsearch_words>>>frompprintimportpprint>>>pprint(search_words('hola'))[Word(word='lindo, da',etymology="Del lat. limpĭdus 'limpio', 'puro'.",definitions=[DefinitionX(types=['adj.'],definition='Hermoso, bello, grato a la vista.',examples=[],synonyms=['bonito','bello','hermoso','precioso','exquisito','agraciado','guapo','majo'],antonyms=['feo']),DefinitionX(types=['adj.'],definition='Perfecto, primoroso y exquisito.',examples=[],synonyms=[],antonyms=[])],phrases=[Phrase(phrase='lindo don Diego',definition=[Definition(types=['m. coloq.','desus.'],definition='lindo (‖ hombre que ''presume de guapo).',examples=[])])])]WarningFor now it is used by me myself and I for generating anki flashcards. It may never be on feature parity with pyrae. But we shall see.
Package: raek-mne
raek_mneTools for processing EEG data with MNE.Free software: MIT licenseDocumentation:https://raek-mne.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History2022.11.01 (2022-11-01)First release on PyPI.
Package: raepy
AboutThis is the official repositiory for the python based software drivers of the robot autonomy effector.
This package enables you to control the fingertip distance of the gripper, the position of the rack and direct Servo access.PrerequisitesPython > 3.6Linux based System OSEthernet or Wifi Connected RPi4SSH Connection to RPi (VSCODE SSH extension is strongly recommended)InstallationEither clone this repository withpip3installgit+https://github.com/romzn/raepy.gitor direct from the pypi repositorypip3installraepyor build the newest version andgitclonegithub.com/romzn/raepy.gitcdraepy## Build repository and Installpython3-mpipinstall--upgradebuild
python-mbuild
pip3install.# Start tests to see basic functionality (!!After the racktest and servoest an recalibration has to be made!!)python3-munittestracktest.py
python3-munittestradialgrippertest.py
python3-munittestracktest.pyBasic functionalityTo move the gripper or the rack the their specific objects has to be loaded in the current script.fromraepyimportRack,RadialGripper,Servorack=Rack()gripper=RadialGripper()servo=Servo()rack.out()# brings the rack to the front position (+8cm) and the grippers backgripper.grasp()# brings the grippers together until they meet resistance, then they are holding with an specific force.gripper.to(0.1)# Set the distance between the two fingertips to 10 cmgripper.to(0.2)# Set the distance between the two fingertips to 20 cmrack.to(0.5)# Drives the rack to an absolute position (5cm)rack.to(1.2)# Drives the rack out !! but before dismantle the grippers or they will collide !!servo.led_to(color)# sets the color to ['black', 'red', 'green', 'blue', 'yellow', 'cyab', 'magenta']servo.limp()# Sets the motor current to zero which results in powerless fingersservo.hold()# holds the position with an specific force (max 28 Nm)# ! There are some servomotor functions more, just take a look at the sources ./src/servo !CalibrationTo calibrate the gripper two steps has to be made.In the first step the grippers have to be dismantled an the rack must drive Rack OutNormally an calibration is not needed because the gripper is calibrated by factory.
In the case you dismantle Gripper without mounting them back into exactly the same position,
or you drive the rack completely out an recalibration is necessary. It is also necesseary if the package was updated
Package: raesl
Ratio support for the  Elephant Specification Language (ESL) in Python.QuickstartInstallationRaESL can be installed usingpip install raesl[all]for any Python version >=3.9. Or,
for Poetry managed projects, usepoetry add raesl-Eallto add it as a dependency.For RaESL’s different subcommands and functionality, the wheel provides extras which you could
provide instead of theallused above:doc: documentation generation using pandoc, Markdown and optionally LaTeX.jupyter: a Jupyter ESL kernel.pygments: an ESL syntax highlighter for pygments.rich: Rich doc output in the form of Plotly images.server: A language server to parse documents.The defaultcompilecommand is always available.Please refer to theusage documentationfor more info
on how to use RaESL.Developer guidePython packaging informationThis project is packaged usingpoetry. Packaging
information as well as dependencies are stored inpyproject.toml.Installing the project and its development dependencies can be done usingpoetry install-Eall.VersioningThis project usessemantic versioning. Version increments are
checked usingRaver.ChangelogChangelog format as described byhttps://keepachangelog.com/has been adopted and can be reviewedon this page <https://raesl.ratio-case.nl/changelog.html>.TestsTests can be run usingpoetry run pytest.LintingLinting config is included inpyproject.tomlfor both Black and Ruff.
Package: rafaelkrc
libpythonproModulo de aprendizangem de construÃ§ao de projeto Python no curso PytoolsNesse curso Ã© ensinado como contribuir com projetos de cÃ³digo aberto.Link para o cursoPythonProSuportada versÃ£o 3 de PythonPara instalar:'''console
python3 -m venv .venv
.venv/scripts/activate
pip install -r requirements-dev.txt
'''Para verificar a qualidade do cÃ³digo:
'''console
flake8
'''TÃ³picos a serem abordados:GitVirtualenvdistPip
Package: rafalkrol-xyz.cdk-fsx-ontap
CDK FSx ONTAPOverviewAn AWS Cloud Development Kit (CDK) constructfor deploying shared file storage usingAmazon FSx for Netapp ONTAP.InstallationTypeScriptyarnaddcdk-fsx-ontapPythonpipinstallrafalkrol-xyz.cdk_fsx_ontapUsagea)basic - going with all of the defaultsNB, check the full example insrc/examples/basic.tsdeclareconstvpc:ec2.Vpc;declareconstsecurityGroupSource:ec2.SecurityGroup;newFsxOntap(this,'FsxOntap',{vpc,ec2SecurityGroup,});AcknowledgementsThis project utilizesprojen(star it on GitHub)
and was created by followingthis guide by hayao-k(like it on Dev.to).
Package: rafcon
Documentation: Hosted onRead the DocsHomepage:DLR-RM.github.io/RAFCON/License:EPLDevelop your robotic tasks using an intuitive graphical user interfaceRAFCON uses hierarchical state machines, featuring concurrent state execution, to represent robot programs.
It ships with a graphical user interface supporting the creation of state machines and
contains IDE like debugging mechanisms. Alternatively, state machines can programmatically be generated
using RAFCON’s API.Universal applicationRAFCON is written in Python, can be extended with plugins and is hard- and middleware independent.Visual programmingThe sophisticated graphical editor can be used for the creation, execution and debugging of state machines.Collaborative workingShare and reuse your state machines in form of libraries, stored as JSON strings in text files.Installation preparationsBefore installing RAFCON, Python >=3.6, pip and setuptools are required on your system. Most of the other dependencies
are automatically resolved by pip/setuptools, but not all of them. Those need be be installed manually, too:Installation requirements for Ubuntu 18.04sudoapt-getinstallpython-devpython-pipbuild-essentialgladepython-gi-cairosudo-Hpipinstall--upgradepipsudo-Hpipinstall--upgradesetuptoolsGeneral requirementsIf you are not using Ubuntu 18.04, please make sure that the following packages are installed:Python >=3.6pip (recent version required: v18 known to be working)python-setuptools (recent version required: v40 known to be working)Installing RAFCONpipinstallrafcon--userThe--userflag is optional. If not set, RAFCON is installed globally (in this case you normaly need to have root privileges).If during the installation the errorImportError: No module named cairooccurs, please install pycairo directly
via:pipinstall--user"pycairo==1.19.1"Of course you can also directly use the RAFCON sources from GitHub.cd/install/directorygitclonehttps://github.com/DLR-RM/RAFCONrafconStart RAFCONNo matter which installation option you choose, RAFCON can be started from any location using (make sure/usr/local/binor~/.local/binis in yourPATHenvironment variable):rafconOn a multi-python setup start rafcon using:python<your-version>-mrafconUninstallationIf you want to uninstall RAFCON, all you need to do is callpipuninstallrafcon
Package: rafcon-task-planner-plugin
RAFCON Task Planner PluginOverviewThe RAFCON Task Planner Plugin is aRAFCONplugin to interface arbitrary pddl planner such as theFast Downward Planning System.It's purpose is to use such planners to plan a predefined scenario, and generate a RAFCON state machine out of the found plan.
To achieve this, the plugin extends RAFCON, so that a state's semantic can be expressed via a pddl action. Subsequently, a set of such pddl annotated states can be used to auto-generate a domain file, find a plan for a handwritten problem and generate a state machine based on the solution.One important aspect is that the Task Planner Plugin is able to interface abritrary planner. So new planners can be quickly integrated using a python script. This mechanism was for example used to successfully integrate theFast Downward, as well as theFast-ForwardPlanning System.InstallationCurrently the plugin is available on GitHub and PyPi. Information about how to obtain and install it from one of these platforms, is available at the homepage'sGetting Started Section.Plugin HomepageDocumentation as well as some tutorials are available at thePlugin's Homepage.
Package: rafe
rafe: Reproducible Artifacts for Environmentsrafe is a tool for inspecting python environments and building packages (irrespective of language) in a reproducible manner.BuildingTo press a fresh rafe wheel from source, simply run:pythonsetup.pybdist_wheelAnd the wheel should be available in thedist/folder.InstallingTo install rafe, simply pip install the wheelpipinstall<wheel>UsageBefore starting to use rafe, it needs to generate a configuration. Do this by running:rafeconfig--initNow, you can use rafe however you'd like. Note that you can call it in two ways:python -m raferafeBoth are valid.Workflow for Griffe API checksAssuming you have already runrafe config --inityou will have the folder.rafe/work/- place your git repo folder there, such that numpy would be at.rafe/work/numpy/With this in place you should next runpythonrafecheck-api-breaks--packagenumpy--oldv1.12.1--newv1.17.5`In older griffe versions, if you are given a git branch error, you'll need to clean up the griffe created branches before rerunning. E.g.git branch -D griffe_v1.12.1from the appropriate folder
It has been verified that this is no longer an issue with griffe v0.30.1 (last to support py3.7)Once you have run the above you should be able to run the verify pass (for objects removed) using the command below:pythonrafeverify-breaks--packagenumpy--path./numpy_objects_removed.json`This will attempt to eval ahasattr()for each of the missing items, and where it fails it may attempt to import the missing attribute and try again. The resultingnumpy_actual_misses.jsonshould be much closer to the truth.
Package: raffiot
Robust And Fast Functional IO ToolkitRaffiotis small (almost) dependency-free python library providing some
usual functional tools. It currently providesan easy-to-useIOmonad which isstack-safe,fast, supportasynchronous,concurrent,parallelprogramming, has many other features.aResourcedata type for easy but reliableresource management.aResultdata structure to represent errorsDemoFor a demo, just type this in a terminal:curlhttps://raw.githubusercontent.com/chrilves/raffiot.py/main/demos/raffiot_demo.sh|/bin/shThis demo runs 4 computations in parallel. It demonstrates how simple concurrent
and parallel programing is inraffiot.Note that this command will install raffiot in your current Python environmentDocumentationGuideTheguideis online athttps://chrilves.github.io/raffiot.py/index.html.APITheAPIis online athttps://chrilves.github.io/raffiot.py/api/index.html.Featurespure python:Raffiotis written entirely in Python 3.7+.small: it is just a few small files.(almost) dependency-free: it only depends ontyping-extensions(for the@finalannotation).crystal clear codeIOstack safe: you just won't run into stack overflows anymore.fast: you won't notice the overhead.dependency injectionmade easy: make some context visible from anywhere.simpleasynchronousandconcurrent programming: full support of synchronous,
asynchronous and concurrent programmingwith the same simple API.railway-oriented programming: clean and simple failure management.distinctionbetweenexpected and unexpected failures: some failures are part
of your program's normal behaviour (errors) while others are show something
terribly wrong happened (panics). Yes, that's heavily inspired byRust.ResourcePython has thewithconstruction, butResourcegoes a step further.easy user-defined resource creation: just provide some open and close
function.composability: the resource you want to create depends on another resource?
Not a problem, you can compose resources the way you want. It scales.failures handling in resources:Resourcehas everythingIOhas, including
its wonderful failure management.ResultDid I mentionRailway-Oriented Programming?Resultis represent the 3 possible
result of a computation:Ok(value): the computation successfully computed the thisvalue.Error(error): the computation failed on some expected failureerror, probably
from the business domain.Panic(exception): the computation failed on some unexpected failureexception.
Package: ra-fixture-generator
RA Fixture GeneratorOS2mo/LoRa Flatfile Fixture Generator.Usagedocker build . -t ra-fixture-generatorWhich yields:...
Successfully built ...
Successfully tagged ra-fixture-generator:latestAfter which you can run:docker run --rm ra-fixture-generator --helpWhich yields:Usage: fixture_generator.py [OPTIONS]

  Flatfile Fixture Generator.

  Used to generate flatfile fixture data (JSON) for OS2mo/LoRa.

Options:
  --name TEXT           Name of the root organization  [required]
  --indent INTEGER      Pass 'indent' to json serializer
  --lora-file FILENAME  Output Lora Flatfile  [required]
  --mo-file FILENAME    Output OS2mo Flatfile  [required]
  --help                Show this message and exit.At this point two flat files can be generated with:docker run --rm -v $PWD:/srv/ ra-fixture-generator \
    --name "Aarhus Kommune" --lora-file /srv/lora.json --mo-file /srv/mo.jsonAt which point two fileslora.jsonandmo.jsonwill be available in the current work-dir.
These files can then be uploaded using thera-flatfile-importer.For instance using:docker run -i --rm ra-flatfile-importer lora upload --mox-url http://MOXURL:8080 < lora.json
docker run -i --rm ra-flatfile-importer mo upload --mo-url http://MOURL:5000 < mo.jsonAlternatively the two can be combined:docker run -i --rm ra-fixture-generator \
    --name "Aarhus Kommune" --lora-file - --mo-file /dev/null | \
docker run -i --rm ra-flatfile-importer lora upload --mox-url http://MOXURL:8080And similarily for MO:docker run -i --rm ra-fixture-generator \
   --name "Aarhus Kommune" --lora-file /dev/null --mo-file - | \
docker run -i --rm ra-flatfile-importer mo upload --mo-url http://MOURL:5000VersioningThis project usesSemantic Versioningwith the following strategy:MAJOR: Incompatible changes to existing data modelsMINOR: Backwards compatible updates to existing data models OR new models addedPATCH: Backwards compatible bug fixesLicenseThis project:MPL-2.0Dependencies:pydantic:MITThis project usesREUSEfor licensing. All licenses can be found in theLICENSES folderof the project.
Package: raflash
Renesas RA flash toolFlash tool for the built in ROM bootloader for Renesas RA microcontrollersRequirementsPython >= 3.6venvLocal and development installStrongly Recommended to use venv (https://docs.python.org/3/library/venv.html)python -m venv .venvsource .venv/bin/activatepip install -r requirements.txtpip install -e .Access rights to USB deviceAdd a file/etc/udev/rules.d/40-renesas.rulesand add the following:SUBSYSTEMS=="usb", ATTRS{idVendor}=="045b", ATTRS{idProduct}=="0261", GROUP="plugdev", MODE="0666"Make sure you retrigger udev again:sudo udevadm triggerMake sure you are also in the groupplugdevUsageusage: raflash [-h] {write,read,erase,info} ...

RA Flasher Tool

options:
  -h, --help            show this help message and exit

Commands:
  {write,read,erase,info}
    write               Write data to flash
    read                Read data from flash
    erase               Erase sectors
    info                Show flasher informationEach command has various options. For example, use RAFlasher write -h to see all write options:usage: raflash write [-h] [--start_address START_ADDRESS] [--size SIZE] [--verify] file_name

positional arguments:
  file_name             File name

options:
  -h, --help            show this help message and exit
  --start_address START_ADDRESS
                        Start address
  --size SIZE           Size in bytes
  --verify              Verify after writingDevPull requestsIssuesSupported functionalityReadWriteErase / sector eraseInfo / area informationID AuthenticationBaud rate (only for SCI)Supported OSLinuxWindowsMac OSSupported interfacesUSBSCISupported MCUsRA4 (tested)RA2 (should potentially work)RA6Note: only tested on RA4 hardwareResourceshttps://www.renesas.com/us/en/document/apn/renesas-ra-family-system-specifications-standard-boot-firmware