Saravanan666/pypi-org huggingface dataset:
Package: ralf-dialogue-jhuapl
ralf-dialogueralf-dialogueis a Python framework for quickly prototyping dialogue agents that leverage large language models (LLMs),
like ChatGPT or GPT-4. It lives in the broader RALF ecosystem, and assumes the use of theralflibrary, which
provides primitives, constructs, and other utilities for building complex systems around large language models
using a desingn paradigm that some parts of the community have begun to callcomposability.A word on the broader RALF ecosystemralfis a Python library intended to assist developers in creating applications
that involve calls to Large Language Models (LLMs). A core concept inralfis the idea ofcomposability,
which allows chaining together LLM calls such that the output of one call can be
used to form the prompt of another.ralfmakes it easy to chain together both
LLM-based and Python-based actions— enabling developers to construct complex
information processing pipelines composed of simpler building blocks. Using LLMs
in this way can lead to more capable, robust, steerable and inspectable applications.A general framework for building applications -- including conversational AIs -- that rely
on a mix of prompted large language models (LLMs) and conventional Python code and services.
This can be considered a powerful form of neuro-symbolic AI. Other frameworks -- such as this
one,ralf-dialogue-- build on the coreralflibrary, adding primatives and components for
building conversational agents (or "chatbots") that can interact with users in natural language,
leveraging context and accessing external knowledge stores or reasoning engines. Many of these
components are still under active construction, and we're always looking for talented contributors.Quickstart GuideThis quickstart guide is intended to get you up and running withralfwithin
a few minutes.InstallationWe recommend creating a Conda environment before installing the package:conda create -n ralf python=3.10
conda activate ralfInstall from PyPIYou may installralf-dialoguefrom PyPI usingpip:pip install ralf-dialogue-jhuaplInstall from SourceAlternatively, you can build the package from source. First, clone the Github repository:git clone https://github.com/jhuapl-fomo/ralf-dialogue.gitNext, install the requirements usingpip:cd ralf-dialogue
pip install -r requirements.txtThen, build the package usingflitand install it usingpip:flit build
pip install .Or if you would like an editable installation, you can instead use:pip install -e .OpenAI Configurationralfcurrently relies on language models provided by OpenAI.
In order to access the models, you must store your OpenAI API key as an
environment variable by executing the following in bash:echo "export OPENAI_API_KEY='yourkey'" >> ~/.bashrc
source ~/.bashrcRunning the DemosTo test if installation was successful, try running the demo scripts:cd demos
python simple_chat.pyThis demo script will allow you to converse with a chatbot created usingralf-dialogue. Next, you can delve deeper and explore other features of the library:python analyze_conversation.pyIf the scripts execute successfully, you are good to go!
Package: ralf-jhuapl
ralfralfis a Python library intended to assist developers in creating applications
that involve calls to Large Language Models (LLMs). A core concept inralfis the idea ofcomposability,
which allows chaining together LLM calls such that the output of one call can be
used to form the prompt of another.ralfmakes it easy to chain together both
LLM-based and Python-based actions— enabling developers to construct complex
information processing pipelines composed of simpler building blocks. Using LLMs
in this way can lead to more capable, robust, steerable and inspectable applications.Currently, theralfbase library offers generic functionality for action chaining
(through theDispatcherandActionclasses) as well as text classificaiton
(through theZeroShotClassifierclass). Check out the other projects within
the RALF ecosystem for more specialized functionality, like dialogue management
and information extraction.Quickstart GuideThis quickstart guide is intended to get you up and running withralfwithin
a few minutes.InstallationWe recommend creating a Conda environment before installing the package:conda create -n ralf python=3.10
conda activate ralfInstall from PyPIYou may installralffrom PyPI usingpip:pip install ralf-jhuaplInstall from SourceAlternatively, you can build the package from source. First, clone the Github repository:git clone https://gitlab.jhuapl.edu/ralf/ralfNext, install the requirements usingpip:cd ralf
pip install -r requirements.txtThen, build the package usingflitand install it usingpip:flit build
pip install .Or if you would like an editable installation, you can instead use:pip install -e .OpenAI Configurationralfcurrently relies on language models provided by OpenAI.
In order to access the models, you must store your OpenAI API key as an
environment variable by executing the following in bash:echo "export OPENAI_API_KEY='yourkey'" >> ~/.bashrc
source ~/.bashrcRunning the DemosTo test if installation was successful, try running the demo scripts:cd demos
python dispatcher_demo.py
python classifier_demo.pyIf the scripts execute successfully, you are good to go! You may want to look
through the demo scripts to learn about some of the thingsralfcan do, or
follow the more detailed tutorials.Documentation & TutorialsThe best way to get started withralfis to follow the tutorials, which can be found in thefull documentation.LicenseThis project is released under theMIT License.Copyright © 2023 The Johns Hopkins University Applied Physics LaboratoryContact:ralf@jhuapl.edu
Package: ralipyard
RalipyardPython thread-safe rate limit semaphore for threading and async/await style built on Rust's libraryraliguardOverviewFor example, crate a semaphore that allows only 5 calls per 1 secondimportasyncioimporttimeimportdatetimeimportralipyardasyncdeftask(sem:ralipyard.Semaphore,no:int):delay=sem.calc_delay()awaitasyncio.sleep(delay)print(f"Task{no=}executes its code at{time.monotonic():.5f}")asyncdefmain():sem=ralipyard.Semaphore(access_times=5,per_period=datetime.timedelta(seconds=1))tasks=[task(sem,i)foriinrange(100)]awaitasyncio.gather(*tasks)asyncio.run(main())Output:Taskno=0executesitscodeat0.21575
Taskno=4executesitscodeat1.22018
Taskno=3executesitscodeat1.22022
Taskno=2executesitscodeat1.22023
Taskno=1executesitscodeat1.22024
Taskno=9executesitscodeat2.21618
Taskno=7executesitscodeat2.21622
Taskno=8executesitscodeat2.21623
Taskno=6executesitscodeat2.21624
Taskno=5executesitscodeat2.21624
Taskno=11executesitscodeat3.22016
Taskno=10executesitscodeat3.22020
Taskno=12executesitscodeat3.22021
Taskno=14executesitscodeat3.22022
Taskno=13executesitscodeat3.22023
...InstalationFrom PyPI:python-mpipinstallralipyardOr from GitHubpython-mpipinstallhttps://github.com/deknowny/archive/ralipyard.zipDocumentationIt's unnecessary because the library has the only 1 class with the only 2 methods, visitstubsfor more information
Package: ralisem
Rate Limit SemaphoreRate limit semaphore for async-style (any core)There are two implementations of rate limit semaphore. Live demo shows howFixedNewPreviousDelaySemaphoreandFixedNewFirstDelaySemaphoreworkOverviewimportdatetimeimportralisem# Or another implementationsem=ralisem.FixedNewPreviousDelaySemaphore(access_times=3,per=datetime.timedelta(seconds=1))asyncwithsem:...Difference:FixedNewPreviousDelaySemaphore: Sures the last and a new access have a fixed required delay (per / access_times)FixedNewFirstDelaySemaphore: Sures first and last in series (serias isaccess_times) have a fixed delay (per)MethodsAll of these implementations are inherited from one baseTimeRateLimitSemaphoreBase. Check out full methodshereInstallationVia PyPI:python-mpipinstallralisemOr via GitHubpython-mpipinstallhttps://github.com/deknowny/rate-limit-semaphore/archive/main.zipContributingCheck outContributing section
Package: rallf
RALF Python SDKRALLF SDK provides the tools to create tasks for rallf robots (rallf.com) using python3.Disclaimer! This package is in development stage (unstable), it may be potentially buggyInstallationUsing Python Package Index (PyPI)pip3installrallfFrom sourcegitclonehttps://github.com/RobotUnion/rallf-python-sdkcdrallf-python-sdk
pip3install-rrequirements.txt
python3setup.pyinstallGetting started (hello bot-task)In order to get started with robot task development, just runrallf-py create-project "hello"and it will create a basic project with the files explained below.hello.py# File: src/hello.pyfromrallf.sdkimportTask'''Hello task opens github and returns the title of the page upon it is loaded.To learn more about python selenium api, see https://selenium-python.readthedocs.io/'''classHello(Task):# implementing self.run is required for tasks, not for skillsdefrun(self,input):# Log stuff via the available loggerself.logger.debug('Hello Bot')# get a firefox instancebrowser=self.robot.devices['firefox']browser.get('https://github.com')returnbrowser.getTitle()Try it (rallf cli)To use thecliyou can use either the binary included in the packagerallf-py <args>or executing directly from pythonpython3 -m rallf.cli <args>Runrunmethod using theCLIrallf-pyrun.-frunRunrunmethod using thejsonrpcapiecho'{"jsonrpc": "2.0", "id": 1, "method": "delegate", "params": {"routine": "run", "args": {}}}'|rallf-pyrun.Get helprallf-py-hExtended usageTask ManifestTask manifest is mandatory for rallf.com tasks, but not necessary for developing, visitmanifest referenceto learn more in-deep about task manifests./* File config/manifest.json */{"title":"Hello Task","description":"This tasks logs hello and returns the <title> of github.com","long-description":"@README.md","fqtn":"com.example.hello","type":"task",/* choices: task, skill */"main":"src.hello.Hello","exports":["run"],/* default: ["run"] */"permissions":{"uris":["https://github.com","https://google.com"],"devices":["firefox","chrome"],"skills":{"com.example.facebook":["likePage","likePost"],"com.example.gmail":["search","likePost"]},}}Injected objectsself.robotthis object is injected in the task creationinputthis parameter is passed to therun(self, input)functionInter Task Communication (ITC)Call other tasks from the market (rallf.com)Use robot skillsTask lifecycle callbackswarmup(self)thisoptionalmethod is executed some time before the task starts to speed-up the rest of calls.run(self, input)thisrequiredmethod handles the work of the task and is triggered at start of the task.cooldown(self)thisoptionalmethod is called when the task is going to be some time without use.Task vs SkillA common question is the difference between Task and Skill inside the RALLF ecosystem, the main difference is that
Tasks only have one method calledrunand the skill can have many, so technically a Task is a subtype of Skill,
and also a Skill can implement therunmethod and can be used as Task too.
Package: rally
Rally is tool & framework that allows one to write simple plugins and combine
them in complex tests scenarios that allows to perform all kinds of testing!Team and repository tagsWhat is RallyRally is intended to provide a testing framework that is
capable to performspecific,complicatedandreproducibletest cases onreal deploymentscenarios.Rallyworkflow can be visualized by the following diagram:Who Is Using RallyDocumentationRally documentation on ReadTheDocsis a perfect place to start learning about Rally. It provides you with aneasyandillustrativeguidance through this benchmarking tool.For example, check out theRally step-by-step tutorialthat
explains, in a series of lessons, how to explore the power of Rally in
benchmarking your OpenStack clouds.ArchitectureIn terms of software architecture, Rally is built of 4 main components:Environment- one of key component in Rally. It manages and stores
information about tested platforms. Env manager is using platform plugins
to: create, delete, cleanup, check health, obtain information about
platforms.Taskcomponent is responsible for executing tests defined in
task specs, persisting and reporting results.Verificationcomponent allows to wrap subunit-based testing tools and
provide complete tool on top of them with allow to do pre configuration,
post cleanup as well process and persist results to Rally DB for future use
like reporting and results comparing.Use CasesThere are 3 major high level Rally Use Cases:Typical cases where Rally aims to help are:Automate measuring & profiling focused on how new code changes affect the
OpenStack performance;Using Rally profiler to detect scaling & performance issues;Investigate how different deployments affect the OS performance:Find the set of suitable OpenStack deployment architectures;Create deployment specifications for different loads (amount of
controllers, swift nodes, etc.);Automate the search for hardware best suited for particular OpenStack cloud;Automate the production cloud specification generation:Determine terminal loads for basic cloud operations: VM start & stop,
Block Device create/destroy & various OpenStack API methods;Check performance of basic cloud operations in case of different loads.LinksFree software: Apache licenseDocumentation:https://rally.readthedocs.org/en/latest/Source:https://opendev.org/openstack/rallyBugs:https://bugs.launchpad.net/rallyStep-by-step tutorial:https://rally.readthedocs.io/en/latest/quick_start/tutorial.htmlLaunchpad page:https://launchpad.net/rallyGitter chat:https://gitter.im/rally-dev/LobbyTrello board:https://trello.com/b/DoD8aeZy/rally
Package: rally-cli
rally-cly:Rally API ClientInstallFrom code repo dir:pipinstall--user--editable.UseRallyTypeGeneric class is used for all models with no specific model ClassfromtypingimportListfromrallycliimportRallyAPIfromrallycli.modelsimportRallyTypeGeneric,type_names,US,Feature,Userrally_api=RallyAPI(key_based_auth=True,external_key="<your_external_key_here>",baseurl="https://eu1.rallydev.com/",workspace="/workspace/<workspace_OID_here>")project_ref:str="/project/<your_project_OID_here>"## getting the projectproject:RallyTypeGeneric=rally_api.project_api.get_project_by_ref(project_ref)## getting project releasesreleases:List[RallyTypeGeneric]=rally_api.timebox_api.get_releases_for_project(project_ref=project._ref)## getting project iterationsiterations:List[RallyTypeGeneric]=rally_api.timebox_api.get_active_iterations_for_project(project_ref=project._ref)## create UserStoryus:US=US()us.Name=f"Autocreated Us{n}"us.Project=project_refus.Description=f"Test US{n}para rallycli python module. By{rally_api.user_api.get_this_user().EmailAddress}"us.Owner=rally_api.user_api.get_this_user()us.Release=releases[0]._refus.Iteration=iterations[0]._refcreated_us:US=rally_api.artifact_api.create_artifact(us,type_names.US)print(created_us)feature:Feature=rally_api.artifact_api.get_artifact_by_formattedid("FE1")print(feature.Name)# Get all disabled users using 4 parallel threadsusers:List[User]=rally_api.query("( Disabled = true)","user",fetch="Username",model_class=User,threads=4,pagesize=80)
Package: rally-openstack
Rally plugins forOpenStack platformUsage# Install this package (will install rally if not installed)pipinstallrally-openstack# List all installed pluginsrallypluginlist--platformopenstack# Create OpenStack Envcat<<EOT >> env.yaml
---
openstack:
  auth_url: "https://keystone.net/identity"
  region_name: RegionOne
  https_insecure: False
  users:
    - username: user_that_runs_commands
      password: his password
      project_name: project_that_users_belong_to
EOTrallyenvcreate--namemy_openstack--specenv.yaml# Check that you provide correct credentialsrallyenvcheck# Collect key Open Stack metricsrallytaskstart./tasks/openstack_metrics/task.yaml--task-args{"image_name":"image_to_use","flavor_name":"flavor_to_use"}# Generate Reportrallytaskreport--outreport.htmlLinksFree software: Apache licenseDocumentation:https://rally.readthedocs.org/en/latest/Source:https://opendev.org/openstack/rally-openstack/Bugs:https://bugs.launchpad.net/rallyStep-by-step tutorial:https://rally.readthedocs.io/en/latest/quick_start/tutorial.htmlLaunchpad page:https://launchpad.net/rallyGitter chat:https://gitter.im/rally-dev/LobbyTrello board:https://trello.com/b/DoD8aeZy/rally
Package: ralogs
# ralogsralogs is a simple python script which connects to Rancher and stream logs
directly to your terminal from multiple containers within a single stack.## Requirementsralogs requires Python 3.5 or higher and pip3 to be installed on your machine.## Changelog1.4
- fixed installation script1.3
- fix stack not found issue by searching API using stack name1.2
- moved required dependencies into setup.py to avoid strict version requirements1.1
- Added third parameter to specify a service
- Added container names and IDs to the logs output1.0
- Initial release## Installation` $ pip3 install ralogs `## ConfigurationCheck if installation was successful:` $ ralogs-v`It should display version info. Now open and edit configs:` $ subl$HOME/.ralogs`rancher_url - where you can access Rancher (eg.https://rancher.example.com)api_key and api_secret - this you can create in Rancher GUI, go to API -> Keys from top menu and add new Account API Key## Usage:` $ ralogs environment stack `If the stack has more than one service, you can select it by name by adding third argument:` $ ralogs environment stack service `
Package: ralph_beast
ralph_beast===========Beast is convenient Ralph API commandline client.It can be used as generic Tastypie commandline client for querying, manipulatingREST resources from the shell.Docs----- `how to install`_.. _how to install: https://github.com/allegro/ralph_beast/blob/master/doc/install.rst- howto_.. _howto: https://github.com/allegro/ralph_beast/blob/master/doc/howto.rstChange Log----------2.1.3~~~~~* Api compatibility fixed with the latest Ralph.2.1.2~~~~~* Fixed bug where data were truncated to 20 characters.* Fixed bug where column output was not always correct.2.1.1~~~~~* Fixed bug when less than 50 records where returned2.1.0~~~~~* Added pagination support.* Added subfields support.* Added create new resource function.* Update function now works correctly.* Better unicode conversion for border case data.2.0.0~~~~~* Rewritten from scratch version with basic update support andmultiple formats(csv, console) support.1.0.0~~~~~* Initial version
Package: ralph_pricing
=====Pricing module for Ralph=====The pricing module aggregates data from Ralph and from Ralph Assets to generatereports showing the prices of the servers in inventory per their owners daily.Change Log----------1.2.8~~~~~Released on December 11, 2013* F5 devices billing added.1.2.7~~~~~Released on November 03, 2013* Added search boxes, filters and additional columns in admin.* Fixed corner-case bug related to calculation of bladesystems costs.1.2.6~~~~~Released on August 08, 2013* Added "show only active" option in the reports* Added short descriptions to reports templates* Fixed assets plugin - IntegrityError protection, added new tests* Show extra costs in the extra costs types admin1.0.0~~~~~* initial release
Package: ralsei
RalseiRalseiis a Python framework for building modular
data pipelines running inside the postgres database.It was built with use cases such as web scraping in mind,
with the philosophy that all artifacts should be stored in the database:
from downloaded html to the parsed resultsFeaturesBased on thejinja-psycopglibrary, combiningtype-safeSQL formatting withjinja's template languageDeclarative with minimal boilerplateResumablepipelines, both at row-level and table-level granularity -
no need to re-compute or re-download what has already been processedInstallationpip install ralseiTip: consider usingPDMorPoetryfor project-based dependency managementQuick StartFirst, create a script from the following template:fromralseiimportRalseiClidefmake_pipeline(args):return{}#  Declare your pipeline in the format "name": Task(...)if__name__=="__main__":cli=RalseiCli()# Here you can add custom argumentscli.run(make_pipeline)To see some example pipelines, take a look at theBuiltin Taskssection of the documentationAlternativesDBT- jinja + SQL basedmore suitable for processing data that you already haveKedro- python based,
more suitable for processing data that you already have
Package: ramachandran
RamachandranRamachandran plot visualizes energetically allowed regions for backbone torsion (dihedral) angles ψ against φ of amino acid residues in protein structure. This Python package provides the implementations from scratch to crawling PDB/PDBx files from RCSB PDB Bank, parsing PDB/PDBx files for extracting geometric information, computing the torsion angles of residues from atom coordinates and the Ramachandran favorable regions from the reference PDB/PDBx files selected, and creating Ramachandran plots for user-provided PDB/PDBx files.DependenciesPython 3.8+Numpy 1.20.1+Scipy 1.6.0+Matplotlib 3.3.4+UsagesIt is recommended to use Docker container to run the program.Build Docker Image$ docker build -f docker/ramachandran.Dockerfile --no-cache --tag=ramachandran:0.0.1 .Run Docker Container$ docker run -it --rm --gpus device=0 -v $(pwd):/mnt ramachandran:0.0.1Install$ pip install ramachandranCreate Ramachandran Plots$ ramachandran-plot --help
usage: ramachandran-plot [-h] --file-path FILE_PATH
                         [--save-dir-path SAVE_DIR_PATH]
                         [--protein-name PROTEIN_NAME]

Ramachandran Plot Tool. Plots for GLY, PRO, pre-PRO, and Other residues will
be created.

optional arguments:
  -h, --help            show this help message and exit
  --file-path FILE_PATH
                        PDB/PDBx file path. (default: None)
  --save-dir-path SAVE_DIR_PATH
                        Directory path for saving the Ramachandran plots for
                        the PDB/PDBx file. (default: .)
  --protein-name PROTEIN_NAME
                        Protein name. (default: None)Demo$ ramachandran_plot --file-path 1AXC.cif --save-dir-path 1AXC --protein-name 1AXCGeneralGLYPROPre-PROTODOFilter homologous proteins for computing the Ramachandran statistics, since too many homologous protein structures will bias the statistics.Add theoriginal hard-coded Ramachandran favorable region.ReferencesRamachandran PlotPyRAMA
Package: ramachandranplot
RamachandranplotPython3 implementation of the Ramachandran plotPackage does work with Python2.7 but it is recommended to use Python3For easy installation use pip:pip install ramachandranplotUsage:import os
import ramachandarnplot as rama
pdb = "example.pdb" #path of pdb file any pdb which is required to be ploted.
rama.plot_ramachandran(pdb)Example output:Dependencies:Running ramachandarnplot requiresmatplotlib,numpyandbiopythonTo install these on a standard Linux system:pip install python3-matplotlib
pip install python3-biopython
pip install python3-numpyFor the standard PSI and PHI preferences see:Lovellet al. Structure validation by Calpha geometry: phi,psi and Cbeta deviation. 2003; DOI: 10.1002/prot.10286