Saravanan666/pypi-org huggingface dataset:
Package: python-rai
RAI is a python library that is designed to help AI developers in
various aspects of responsible AI development. It consists of a core API
and a corresponding web-based dashboard application. RAI can easily be
integrated into AI development projects and measures various metrics for
an AI project during each phase of AI development, from data quality
assessment to model selection based on performance, fairness and
robustness criteria. In addition, it provides interactive tools and
visualizations to understand and explain AI models and provides a
generic framework to perform various types of analysis including
adversarial robustness.Note: - The dashboard GUI is currently designed around 1920x1080
displaysDocumentationDocumentation is available online:https://responsibleai.readthedocs.io/en/latest/To InstallThe project uses sqlite as storage and requires no additional
installation for this.pip installpython-raiIf you need to use the dashboard as well you must  install the additional requirementspip installpython-rai[dashboard]To start using the library you must configure the folder where the results will be stored and be used by the dashboardexport DATABASE_FOLDER=YOUR_LOCATIONTo start the dashboard server use the following command:python3-mRAIDashboardDemos:We have added a few demo projects to showcase some of the capabilities of RAI.
to run any of the demos please use 'python demo_filename'. For instance :
python ./demos/adult_demo_grid_search.py

below is a short description of the provided demos:

File: adult_demo_grid_search.py
Description: This demo uses the Adults dataset (https://archive.ics.uci.edu/ml/datasets/adult) to show how RAI can be used in model selection

File: image_class_analysis.py
Description: this demo uses Cifar10 dataset and shows how RAI can be used to evaluate image classification tasks

File: image_class_training.py
Description: this demo uses Cifar10 dataset and shows how RAI can be used monitor image processing tasks during training


File: tabular_class_console.py
Description: this demo shows how RAI can be used without the dashboard to calculate and report on the metrics for a machine learning task

File: text.py
File: text_output.py
Description: these demos show how RAI and its dashboard can be used for evaluating the natural language modeling tasksCisco Research, Emerging Tech and Incubations,Cisco Systems Inc.
Package: python-raindropio
python-raindropioPython wrapper forRaindrop.io API.This library is in the early stage of development.RequirementsRequires Python 3.7 or later.Installpip3 install python-raindropioUsageYou must register your application athttps://app.raindrop.io/settings/integrations.
In the application page, create test token to run following samples.Create collectionfromraindropioimportAPI,Collectionapi=API(raidrop_access_token)c=Collection.create(api,title="Sample collection")print(c.title)Search bookmarks from Unsorted collection.fromraindropioimportAPI,CollectionRef,Raindropapi=API(raidrop_access_token)page=0while(items:=Raindrop.search(api,collection=CollectionRef.Unsorted,page=page)):print(page)foriteminitems:print(item.title)page+=1LicenseCopyright 2020 Atsuo IshimotoSee LICENSE for detail.
Package: python-rako
Python: Rako Controls API ClientAsynchronous Python client for Rako Controls.AboutThis package allows you to control and monitor Rako Controls devices
programmatically. It is mainly created to allow third-party programs to automate
their behavior.Installationpipinstallpython-rakoUsageimportasyncioasyncdefmain():# TODOpassif__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(main())Changelog & ReleasesThis repository keeps a change log usingGitHub's releasesfunctionality. The format of the log is based onKeep a Changelog.Releases are based onSemantic Versioning, and use the format
ofMAJOR.MINOR.PATCH. In a nutshell, the version will be incremented
based on the following:MAJOR: Incompatible or major changes.MINOR: Backwards-compatible new features and enhancements.PATCH: Backwards-compatible bugfixes and package updates.ContributingThis is an active open-source project. We are always open to people who want to
use the code or contribute to it.We've set up a separate document for ourcontribution guidelines.Thank you for being involved! :heart_eyes:Setting up development environmentIn case you'd like to contribute, aMakefilehas been included to ensure a
quick start.makevenvsource./venv/bin/activate
makedevNow you can start developing, runmakewithout arguments to get an overview
of all make goals that are available (including description):$make
AsynchronousPythonclientforRakoControlsLighting.

Usage:makehelpShowsthismessage.makedevSetupadevelopmentenvironment.makelintRunalllinters.makelint-blackRunlintingusingblack&blacken-docs.makelint-flake8Runlintingusingflake8(pycodestyle/pydocstyle).makelint-pylintRunlintingusingPyLint.makelint-mypyRunlintingusingMyPy.maketestRuntestsquicklywiththedefaultPython.makecoverageCheckcodecoveragequicklywiththedefaultPython.makeinstallInstallthepackagetotheactivePython'ssite-packages.makecleanRemovesbuild,test,coverageandPythonartifacts.makeclean-allRemovesallvenv,build,test,coverageandPythonartifacts.makeclean-buildRemovesbuildartifacts.makeclean-pycRemovesPythonfileartifacts.makeclean-testRemovestestandcoverageartifacts.makeclean-venvRemovesPythonvirtualenvironmentartifacts.makedistBuildssourceandwheelpackage.makereleaseReleasebuildonPyPmakevenvCreatePythonvenvenvironment.Authors & contributorsThe original setup of this repository is byBen Marengo.For a full list of all authors and contributors,
checkthe contributor's page.LicenseLicense
Package: python-random-strings
python random stringsa python library to generate random strings and digits and special characters or a combination of theminstallation 🛠pipinstallpython-random-stringsoptions 🖇Random Lower CaseRandom Upper CaseRandom LettersRandom DigitsRandom Hex DigitsRandom Oct DigitsRandom PunctuationRandom PrintableRandom WhitespaceSample Code ✏️frompython_random_stringsimportrandom_stringsa=random_strings.random_lowercase(6)print(a)output=>hueioja=random_strings.random_uppercase(6)print(a)output=>GAVKDFa=random_strings.random_letters(6)print(a)output=>rENOtba=random_strings.random_digits(6)print(a)output=>653665a=random_strings.random_hexdigits(6)print(a)output=>c25Ba6a=random_strings.random_octdigits(6)print(a)output=>540322a=random_strings.random_punctuation(6)print(a)output=>"=*$^<a=random_strings.random_printable(6)print(a)output=>)|~6yZa=random_strings.random_whitespace(6)print(a)output=>\t\n\r\t\n\x0c
Package: python-raptor
RaptorA Easy Way To Benchmark Your Code.How To Use ItStep 1: First You Will Need To Create A Benchmark File For Your Project"""to_benchmark.py"""#Add All Your Setupimportmath#Write Your Benchmarking Functionsdefbench_square_root():"""Name Your Function Starting With bench. Or Raptor Wont Detect ItAlso the function should not take any arguments"""returnmath.sqrt(25)defbench_multiply():return5**25Step 2: Download raptor.pypip install python-raptorThen, Run This In Your TerminalNOTICE: The -t Argument Takes An Integer Which Tells Raptor How Many Times
Should Each Benchmarking Function Runraptor.py to_benchmark.py -t 10000Step 3: See The  Output. Voilaaaaa!!!!!!!!!Output========== Bench Marking ===========
[bench_square_root] Took 0.0025385 Seconds For 10000 Run(s)
[bench_multiply] Took 0.0010813999999999997 Seconds For 10000 Run(s)Future FeaturesI want to add an history, which can show you how much faster or slower your program has gottenI want to add colored outputI want to add better exception handlingBuilt WithRaptor Uses Timeit Module To Benchmark Your CodeAuthorRoshan Jignesh Mehta -sonicroshan122@gmail.com
Package: python-raven
This is a compatibility wrapper aroundpython-ucam-webauthonly, to avoid conflicting with theravenpackage.This package exposesucam_webauth.ravenasraven. This is how the library
used to be packaged, pre v0.9. You should ideally depend onpython-ucam-webauthand importucam_webauth.ravendirectly.Other linkspython-ucam-webauth packagesource on github
Package: python-rc
python-rcPython remote control library for programmatically control remote machines of mutliple cloud providers. Currently support gcloud, azure and digitalocean.Usagepython-rc consists of python-rc lib and python-rc cli.python-rc clirc <group name> command ...: execute command non interactively in group of machines
rc <group name>/name_pattern1,... command ...: execute command non interactively in group of machines, but only subset that match pattern 
rc <group name> @file: execute content of local file in group of machines
rc tmux <group name>: launch a tmux that ssh to every instance in group of machines, input to one machine will be replicate to the group
rc edit <group name>: create or edit machines in group
rc cat <group name>: show machines in group
rc ls: show defined groups
rc rm <group name>: delete group definition (does not delete machines)
rc rsync: parallel rsync
rc ssh-config: generate ~/.ssh/config that can be used with ssh machine_name, scp, rsync, mosh, etc.In python-rc tmux, you can useC-b ato toggle input to all machines and input into single machine.python-rc libImport one of provider module: gcloud, digitalocean and azure to get or create a machine. Use machine methods to execute shell commands, execute background task, edit file, etc on the machine. Example:from rc import gcloud
m = gcloud.get('instance1')
# run a single line command
p = m.run('ls')
print(p.stdout)

# run a multiline command
m.bash('''
cd workspace/proj
make -j 4
''')

# run a muliline commands as root
m.sudo('''
apt update
apt install -y jq
''')

# edit a file, as user `ubuntu`:
m.edit('~/a.txt', '''
file line1
file line2
''', user='ubuntu')

# run a server process in background
m.run_bg('''
cd workspace/someserver
npm i
npm run
''')

# run a python snippet on a server
p = m.python('''
import json
j = json.load(open('foo.json'))
print(j['key'])
''')

# Useful utility example:
# parallel run tasks on each machine
from rc import pmap
def task(machine, script_path):
    machine.bootup()
    machine.upload(f'~/local/path/{script_path}', f'~/remote/path/script_path}')
    machine.run(f'bash remote/path/{script_path}')

pmap(lambda i: task(machines[i], tasks[i]), range(n))DocumentationTODO. Seerc/test/for example usages for nowTestTo run gcloud part test,gcloudcli needs to be installed and logged in.pipenv sync -d
pipenv run pytest -s
Package: python-rclone
python-rcloneA Python wrapper forrclone.rclonemust be alreadyinstalledand discoverable in$PATH.StatusWork in progress. Experimental.Usageimportrclonecfg="""[local]type = localnounc = true"""result=rclone.with_config(cfg).listremotes()print(result.get('out'))# b'local:\n'print(result.get('code'))# 0print(result.get('error'))Implemented commands:copyCopy files from source to dest, skipping already copiedsyncMake source and dest identical, modifying destination only.listremotesList all the remotes in the config file.lsList the objects in the path with size and path.lsjsonList directories and objects in the path in JSON format.deleteRemove the contents of path.Even if not allrclonecommands have been exposed, it's possible to invoke any command usingrun_cmdmethod directly, as shown in the example bellow:importrclonecfg="""[local]type = localnounc = true"""result=rclone.with_config(cfg).run_cmd(command="lsd",extra_args=["local:/tmp","-v","--dry-run"])Logging and DebuggingTo see more info about which commands are executed, or what other messages they print, you can enable logging as the example bellow shows:importlogginglogging.basicConfig(level=logging.DEBUG,format="%(asctime)s%(name)s[%(levelname)s]:%(message)s")importrclonecfg="""[local]type = localnounc = true"""result=rclone.with_config(cfg).listremotes()Developer guide$pipinstall-rrequirements.txt
$maketest
Package: python-rconfig
rconfighelps bring configuration, stored remotely on aConsulserver, to  your application.InstallationInstall the latest version with:pip3 install -U python-rconfigFor command-line support, use the CLI option during installation:pip3 install -U "python-rconfig[cli]"For command-line and yaml support:pip3 install -U "python-rconfig[cli,yaml]"UsageFirst off allrconfigexpects that you have the following key structure
on the consul server:<root-key>
    |____<common-config-key>
    |          |
    |          |___<some-env-key>
    |          |           |_____<key-value>
    |          |           |_____<key-value>
    |          |
    |          |___<another-env-key>
    |                      |_____<key-value>
    |                      |_____<key-value>
    |____<app-config-key>
               |
               |___<some-env-key>
               |           |_____<key-value>
               |           |_____<key-value>
               |
               |___<another-env-key>
                           |_____<key-value>
                           |_____<key-value>Here root key stands for the name of the project when some have multiple
applications that grouped under some kind of common purpose (often when talk
about microservices).
Under common configuration key, you should store configurations that common
to all your applications in the project, in this case, it’s much easier to
change the config in one place than go to multiple.Command-line InterfaceCLI offers you an ability to load config fromConsul(within a few ways)
without a need of changing application code.Usage: rconfig [OPTIONS] COMMAND [ARGS]...

Options:
  -h, --host TEXT     Host of a consul server  [required]
  -a, --access TEXT   Access key for a consul server  [required]
  -p, --port INTEGER  Port of consul server  [default: 8500]
  -k, --key TEXT      Consul key  [required]
  --help              Show this message and exit.

Commands:
  export  Print out bash command export for all found config
  list    Show all config for given keysLet’s look at few examples.<your-awesome-app>
    |____<prod>
           |___<LOG_LEVEL -> "WARNING">
           |___<LOG_FILE_HANDLER -> 1>To loadprodconfig ofyou-awesome-app, issue:$ rconfig -h localhost -a access-key -k 'your-awesome-app/prod' list

{'LOG_LEVEL': 'WARNING',
 'LOG_FILE_HANDLER': 1}To export config to different formats, use:Bash:$ rconfig -h localhost -a access-key -k 'your-awesome-app/prod' export -f bash

export LOG_LEVEL='WARNING'
export LOG_FILE_HANDLER='1'$ rconfig -h localhost -a access-key -k 'your-awesome-app/prod' export -f bash:inline

export LOG_LEVEL='WARNING' LOG_FILE_HANDLER='1'Yaml:$ rconfig -h localhost -a access-key -k 'your-awesome-app/prod' export -f yaml

LOG_LEVEL: WARNING
LOG_FILE_HANDLER: 1Json:$ rconfig -h localhost -a access-key -k 'your-awesome-app/prod' export -f json

{"LOG_LEVEL": "WARNING", "LOG_FILE_HANDLER": 1}$ rconfig -h localhost -a access-key -k 'your-awesome-app/prod' export -f json:pretty

{
    "LOG_LEVEL": "WARNING",
    "LOG_FILE_HANDLER": 1
}
Package: python-rdio
An unofficial Python library for accessing the Rdio API, using OAuth. Inspired
by Rdio’s own ‘rdio-python’ library as well as python-twitter.To use, do:>>> import rdio
>>> rdio_manager = rdio.Api(CONSUMER_KEY, CONSUMER_SECRET)
>>> user = rdio_manager.find_user('benjaminkreeger@gmail.com')
>>> print '%s %s's key is: %s.' % (user.first_name, user.last_name, user.key)
Package: python-rdio-export
This exporter can be used to backup the collection of an Rdio user. It
includes a command-line utility script and a library for bundling into
your own applications. The command-line utility will output results
to stdout by default.If you like this library and it’s saved you some time, please consider
supporting further development with aGittip donation!Requirementsrequestsrequests_oauthlibInstalling$ pip install python-rdio-exportAuthenticationYou’ll need to acquire API credentials from theRdio developer site.When using the command-line utility you can authenticate with Rdio
one of three ways.First, by providing your credentials to the command-line utility
directly:$ rdio-export --user twaddington --id your_client_id --secret your_client_secretYou can also (optionally) provide your Rdio credentials via two environment
variables:$ export RDIO_CLIENT_ID=your_client_id
$ export RDIO_CLIENT_SECRET=your_client_secretYou can also (optionally) provide your Rdio credentials via a global config
file located in~/.rdioconfigwith the format:[Rdio]
rdioClientId=your_client_key
rdioClientSecret=your_client_secretNote: Credentials are parsed in the order listed above. For example, the
script will first attempt to use credentials provided via the--idand--secretarguments. Next, credentials will be
loaded from the environment variables. Finally, the config file will be
examined for credentials.ExamplesNote: Results will be printed to stdout by default.Export by username:$ rdio-export --user twaddingtonExport by email:$ rdio-export --email tristan.waddington@gmail.comExport to a file:$ rdio-export --user twaddington > rdio-backup.txtBug reportsIf you encounter any issues, please open a new issue on the project’sGitHub page.LicenseCopyright 2014 Tristan Waddington

Licensed 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 at

   http://www.apache.org/licenses/LICENSE-2.0

Unless 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
limitations under the License.
Package: python-rdm
Python Relational Data MiningThis python project was created to enable easier use of several inductive logic programming (ILP) and relational data mining (RDM)
algorithm implementations. One important aim of the project is to offer a common bridge between a RDBMS and the ILP&RDM implementations, since many of approaches accept databases in their own format.This project also includes the UI components (widgets) for theClowdFlowsdata mining platform.Currently, the project offers support for MySQL, PostgreSQL, SQLite and CSV files-based databases and the following algorithms: Aleph, RSD, Wordification, TreeLiker, Caraf, Relaggs, Quantiles, Cardinalization, 1BC, 1BC2, and Tertius.Included approachesAlthough python-rdm itself is MIT licensed, we include approaches that have their own licenses (all of the sources are unmodified). To be sure, please contact the respective authors if you want to use their approach for any commercial purposes.AlephOfficial pageFreely available for academic purposes, contact the authorAshwin Srinivasanfor commercial useThe source code is includedhere(aleph.pl)RSDbyFilip Železnýet alOfficial pageThe source code is includedhere(.pl files)Included with permission by the authorTreeLiker(includes HiFi, RelF and Poly)Official pageThe binaries are includedhereGPL licenseWordificationbyMatic Perovšeket alpython-rdm is currently the main repository for this approach.The source code is includedhereMIT licenseNicolas Lachiche's team at the University of Strasbourg contributions:1BC, 1BC2, TertiusByPeter FlachandNicolas LachicheSources included herehereOfficial sites:Tertius,1BCIncluded with permission by the authors; please contact the authors for commercial useCarafByClement Charnay,Agnès BraudandNicolas Lachicheet alAll implemented in the Caraf java binaries includedhereIncluded with permission by the authors; please contact the authors for commercial useRelaggs(Krogel and Wrobel, 2001),Quantiles,CardinalizationOriginal Properadapted byNicolas Lachicheet alGPLv2 licenseAll implemented in the Proper java binaries includedhereInstallation, documentationPlease find installation instructions, examples and API reference onRead the Docs.NotePlease note that this is a research project and that drastic changes can be (and are) made pretty regularly. Changes are documented in theCHANGELOG.Pull requests and issues are welcome.Contributors to the RDM package codeAnže Vavpetič (@anzev), Nicolas Lachiche, Alain Shakour (@alshak), Matic Perovšek (@mperice), Vid Podpečan (@vpodpecan)Knowldge Technologies Department, Jožef Stefan Institute, LjubljanaEngineering, Computer and Imaging Sciences Laboratory, University of Strasbourg, France
Package: python-rdma-qe
Table of ContentsInstallationDescriptionRedhat Kernel RDMA QE Python libs and tests.Installation$dnfinstall-ypython3-pip.noarch$pip3install--userpython-rdma-qeUpgrade$pip3list|greppython-rdma-qe$pip3install-Upython-rdma-qeUninstallation$pip3uninstallpython-rdma-qeUsage$python3Python 3.9.16 (main, Mar  7 2023, 00:00:00)[GCC 11.3.1 20221121 (Red Hat 11.3.1-4)] on linuxType "help", "copyright", "credits" or "license" for more information.>>> import rdmaqe.rdma.general as g>>> hca = g.HCA("hfi1_0")INFO: [2023-06-13 03:25:58] Running: 'ibv_devinfo -d hfi1_0'...hca_id:	hfi1_0transport:			InfiniBand (0)fw_ver:				1.27.0node_guid:			0011:7501:0167:0fb0sys_image_guid:			0011:7501:0167:0fb0vendor_id:			0x1175vendor_part_id:			9456hw_ver:				0x10board_id:			Cornelis Omni-Path Host Fabric Interface Adapter 100 Seriesphys_port_cnt:			1port:	1state:			PORT_ACTIVE (4)max_mtu:		4096 (5)active_mtu:		4096 (5)sm_lid:			5port_lid:		6port_lmc:		0x00link_layer:		InfiniBand>>> print(hca.get_protocol("1"))InfiniBand
Package: python-rdomanager-oscplugin
OpenStackClient reference plugin moduleThe OSC plugin system is designed so that the plugin need only be
properly installed for OSC to find and use it.  It utilizes thesetuptoolsentry points mechanism to advertise to OSC the
plugin module and supported commands.rdomanager-oscpluginis an OpenStackClient (OSC) plugin implementation that
implements commands useful for RDO manager and the install and management of
both an undercloud and an overcloud.DiscoveryOSC discovers extensions by enumerating the entry points found underopenstack.cli.extensionand initializing the given client module.[entry_points]
openstack.cli.extension =
    oscplugin = oscplugin.pluginThe client module must implement the following interface functions:API_NAME- A string containing the plugin API name; this is
the name of the entry point declaring the plugin client module
(oscplugin = ...in the example above) and the group name for
the plugin commands (openstack.oscplugin.v1 =in the example below)API_VERSION_OPTION(optional) - If set, the name of the API
version attribute; this must be a valid Python identifier and
match the destination set inbuild_option_parser().API_VERSIONS- A dict mapping a version string to the client classbuild_option_parser(parser)- Hook to add global options to the parsermake_client(instance)- Hook to create the client objectOSC enumerates the loaded plugins and loads commands from the entry points
defined for the API version:openstack.oscplugin.v1 =
    plugin_list = oscplugin.v1.plugin:ListPlugin
    plugin_show = oscplugin.v1.plugin:ShowPluginNote that OSC defines the group name asopenstack.<api-name>.v<version>so the version should not contain the leading ‘v’ character.This second step is identical to that performed for all but the Identity
client in OSC itself.  Identity is special due to the authentication
requirements.  This limits the ability to add additional auth modules to OSC.ClientThe current implementation of therdomanager_oscpluginClient class is an
empty placeholder.  This client object is not equired but OSC’s ClientManager
will maintain it as required and is the interface point for other plugins to
access anything implemented by this plugin.
Package: python-rdrsegmenter
python-rdrsegmenterA Python wrapper forRdrSegmenterusing PyjniusTable Of ContentsPrerequisitesInstallationExamplePrerequisitesJava 1.8+ (JREorJDK)InstallationYou can install this package from PyPI usingpip:$ pip install python-rdrsegmenterExample#!/usr/bin/python# -*- coding: utf-8 -*-frompython_rdrsegmenterimportload_segmentersegmenter=load_segmenter()segmenter.tokenize("Tôi là chàng sinh viên Bách Khoa")