Saravanan666/pypi-org huggingface dataset:
Package: rapidae
Rapidae: Python Library for Rapid Creation and Experimentation of Autoencoders🔗Documentation| 🔗PyPI PackageDescription 💻Rapidae is a Python library specialized in simplifying the creation and experimentation of autoencoder models. With a focus on ease of use, Rapidae allows users to explore and develop autoencoder models in an efficient and straightforward manner.Main features 💪Ease of Use:Rapidae has been designed to make the process of creating and experimenting with autoencoders as simple as possible, users can create and train autoencoder models with just a few lines of code.Backend versatility:Rapidae was develovep using the new version Keras 3.0. This adds the ability to run experiments on three different backends (Tensorflow, Pytorch and Jax) allows users to take advantage of the specific strengths of each without having to learn new syntaxes. Rapidae handles the abstraction, allowing researchers to focus on the design and evaluation of their models.Customization:Easily customize model architecture, loss functions, and training parameters to suit your specific use case.Experimentation:Conduct experiments with different hyperparameters and configurations to optimize the performance of your autoencoder models.Overview 📦Rapidae is structured as follows:data:This module contains everything related to the acquisition and preprocessing of data sets. It also includes a tool utils for various tasks: latent space visualization, evaluation, etc.metrics:Its main functionality is the creation of new custom metrics. From an abstract class on which to inherit and create new metrics.models:This is the core module of the library. It includes the base architectures on which new ones can be created, several predefined architectures and a list of predefined default encoders and decoders,pipelines:Pipelines are designed to perform a specific task such as data preprocessing or model training.Installation ⚙️With Package manager PipThe easiest way is to use the pip command so that it's installed together with all its dependencies.pipinstallrapidaeFrom source codeYou can also download this repository and then create a virtual environment to install the dependencies in.
We recommend this option if you plan to contribute to Conmo.gitclonehttps://github.com/NahuelCostaCortez/rapidaecdrapidaeThen you only have to install the requirements in a new Python virtual environment using:pipinstall-rrequirements.txtDocumentation 📚Check out the full documentation for detailed information on installation, usage, examples and recipes: 🔗Documentation LinkAll documentation source and configuration files are located inside the docs directory.Dealing with issues 🛠️If you are experiencing any issues while running the code or request new features/models to be implemented pleaseopen an issue on github.License ✒️This project is licensed under the Apache 2.0 license. See LICENSE file for further details.
Package: rapida-python
Table Of ContentsAbout the ProjectGetting StartedPrerequisitesInstallationUsageAbout The Projectrapida-python sdk to Experiment, Test and Deploy LLM Applications 10X faster and cheaperGetting StartedThis is an example of how you may give instructions on setting up your project locally.
To get a local copy up and running follow these simple example steps.PrerequisitesThis is an example of how to list things you need to use the software and how to install them.python 3.9InstallationGet a free API Key atrapida.aipip install rapida-pythonpip install rapida-pythonRefer toDocumentationon how to use the API KeyUsageUse this space to show useful examples of how a project can be used. Additional screenshots, code examples and demos work well in this space. You may also link to more resources._For more examples, please refer to theDocumentation
Package: rapid-clay-formations-fab
rapid_clay_formations_fabFabrication code for Rapid Clay Formations.Getting started- for installation and update instructionsExample files- for demonstration purposesContributing- how to start working on the codeKnown issues- for things that we know don't workIssues- for unknown issues, as well as suggestions and questionsDocumentationCOMPASrapid_clay_formations_fabis part is built on top ofcompas,compas_fabandcompas_rrc.Note on compatibilityInstallation of the package requires Python >= 3.6.Big parts are compatible with IronPython 2.7 (to be run inside Rhino plugin
Grasshopper).The modules that require Python >= 3.6 should raise an exception on import.
Package: rapid-desktop-switcher
rapid-switchChange your virtual desktop with the press of a key. Helpful as a panic button.Getting StartedPrerequisitespip install pyautogui
pip install pyxhook
pip install pyqt5
pip install basic-config-loaderInstallingDownload the file and put it in your $PATHConfiguringThe configuration is read from a file called .rapidswitcher in your home directory. It should be in the form of a JSON file. See config-example.json in the source repo for more information.VersioningWe useSemVerfor versioning. For the versions available, see thetags on this repository.LicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for details
Package: rapid-django
Rapid Django============A set of opionated tools for rapid development of enterprise CRUD portals.Rapid Django generates CRUD pages and menus, based on a simple to useregistry of models, forms and views.How to Use==========Add the 'rapid' application to your installed apps, and run a database migration.Create a 'base.html' template that will be used by the CRUD generator. A minimumtemplate looks as following:::<DOCTYPE html><html><head><link href="link to bootstrap" rel="stylesheet"><script src="link to jquery"></script></head><body>{% load rapid_menu %}{% menu request %}{% block body %}{% endblock %}<script src="link to the jquery-form plugin"></body></html>A menu will be generated in a unumbered list (UL) at the "menu" tag, and theregistered data will be placed at the "body" block.After that, one must register actions. For that, the module "rapid.views" has three helper functions:"register_model", "register_instance_form", and "register_simple_select".Use "register_model" for creating default actions for listing, viewing, editing, addin, and optionallyremoving objects of a model.Use "register_instance_form" for creating custom actions where users submit a form, and act uponinstances of a model. The form may not be a ModelForm, but must implement the save() method.Use "register_simple_select" for enabling the rapid select widget for all generated edit formswith fields that select the registered model (that is, foreign key, one to one, and one to manyfields, besides reverse relationships).The module "rapid.permissions" includes helper functions for managing user permissions on theregistered actions. Permmissions may be managed for entire models and for instances (but notcolumns yet).
Package: rapid-env
Rapid ENVLibrary with helpers for rapid development environment ramp up, build and distribution.SUBMODULESosh - operating system helperscopyrun_processrun_process_with_stdoutdownload_archivegit - provides default git ignore template.conan - conan helpers, wrapping someconancommand lines and flows.docker - docker helpers, wrapping somedockercommand lines and flows.installationpip install rapid-envUsagefrom codeimportrapidenvfrom command linerun as module via command line.renvorpython -m rapidenvcmd helpersmng: running manage.py 'def main()' function from project root.project root located searching .git in current and parent folder recursively.
Package: rapidexec
RapidExec (Work in progress)RapidExec is a command line tool that allows you to easier access docker containers. It is written in Python and uses the docker API to interact with the containers.InstallationTo install RapidExec with all dependencies, you can use the following command:pipinstallrapidexecTo install RapidExec with only export dependencies, you can use the following command:pipinstallrapidexec[export]To install RapidExec with only docker dependencies, you can use the following command:pipinstallrapidexec[docker]UsageTo use RapidExec, you can use the following command:rapidexec[OPTIONS]COMMAND[ARGS]...OptionsOptionDescription--helpShows usage information--versionShow the version and exit.CommandsCommandDescriptiondocker-psList all running containers.docker-logsShow the logs of a container.compose-logsShow the logs of a docker-compose service.exportExport pyproject.toml dependencies to a requirements.txt file.Example outputdocker-ps$rapidexecdocker-psexportScenario: toml file pyproject.toml and output file requirements.txt$rapidexecexport-fpyproject.toml-orequirements.txtScenario: exclude optional groups$rapidexecexport--excludedev,exportScenario: include only specific optional groups$rapidexecexport--includedevLicenseThis project is licensed under the MIT License - see theLICENSEfile for details.ContributingIf you want to contribute to this project, you can create a pull request on GitHub.
Package: rapidfire
SETUPInit RapidFire$pipinstallrapidfire$rap--init$vi/Your/home/directory/.rapidfire.d/raprcSet the value in RAPIDFIRE_PYFILE_PATHRAPIDFIRE_PYFILE_PATH = /path/hoge.pyEdit sample code$vi/path/hoge.pyfromrapidfireimporttask@taskdefsample():return['text1','text2','text3']Run RapidFire$rapsampleAPIrapidfire.task(next_action, clipboard, per_page)Parametersnext_action - For next_action, specify the function name to be executed nextclipboard option - Copy the result to the cripboardper_page - Lines per pageExamplefromrapidfireimporttask@task(next_action='sample_method2',per_page=2)defsample_method1():return['text1','text2','text3']@task(clipboard=True)defsample_method2():text=sample_method1# The value selected by sample_method1 is enteredreturn['{}is selected'.format(text)]
Package: rapidflow
rapidFlowThis is a project, that tries to accelerate micro research projects by providing a richer functionality for the
already known hpyerparameter optimization libraryoptuna. The code of optuna is not
modified, it is incorporated into rapidFlow to provide richer evaluation and easy parallel processing.Getting StartedPrerequisitesPython >= 3.7PyTorchInstallrapidFlow is build upon Pytorch, so make sure you have PyTorch installed.From Pip
Install package with:pip install rapidflowWith cloned repository
Install package with:pip install -e /srcTODO:move experiment library to another repoexperiments in docker container with gpu? (or singularity)test on multiple gpustesting and propper dokusignificance testingAcknowledgmentsFeel free to contribute. If you use this repository please cite with:@misc{rapidFlow_geb,
    author = {Gebauer, Michael},
    title = {rapidFlow},
    year = {2022},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/gebauerm/model_storage}},
    }Authorelysias
Package: rapid-framework
Rapid Framework is a tool for integrating Continuous Integration, Automatic Testing, Automatic Building and Continuous Deployment in a quality and
efficient manner.Why Rapid?Rapid was built with ease and scalability in mind. There are various features which allow you to take control of your builds and know what is happening
at all times. Rapid makes your CI Solution infrastructure. It simply works.Rapid was built to be small and efficient. Rapid is a layered system which allows you to be free to scale your infrastructure as needed. Rapid is the
only CI Solution that we know of that can build and release itself with no down time.Have you ever used a system that runs out of memory? Ever have a client blow up and you can’t recover? That doesn’t happen with Rapid. Try it out!RequirementsServer - System that supports python. At least 60MB of RAM! That’s it!
Client - System that supports python. At least 30MB of RAM! That’s it!FeaturesMulti Staged pipelinesParallel WorkflowsSliced ActionsAbility to track time for all parts of your buildRe-run Action possibilityPrioritized buildsInterstitial RunsTargeted clientsDistributed LoggingAutomatic upgrades24/7 Uptime - Install a new version and restart in 200ms!Behavior Point Test MappingUWSGI integrationMassive ScalingGithub Integration for handling webhooksRelease Step Mapping and workflowsExternal process integration and workflowInstallation$pipinstallrapid-frameworkOptions$rapid--helpusage: rapid [-h] [-f CONFIG_FILE] [-p PORT] [-m] [-c] [-l] [-d LOG_DIR][-q QA_DIR] [–downgrade DB_DOWNGRADE] [–create_db]
[–create_migration MIGRATE]Rapid Framework client main controloptional arguments:-h,--helpshow this help message and exit-fCONFIG_FILE,--configCONFIG_FILEconfig file path-pPORT,--portPORTPort for the master to listen on-m,--masterMaster mode is default-c,--clientClient mode-l,--loggingLogging mode-dLOG_DIR,--log_dirLOG_DIRLogging directory-qQA_DIR,--qa_dirQA_DIRQA Dir--downgradeDB_DOWNGRADEDowngrade db for alembic--create_dbCreate initial db--create_migrationMIGRATECreate Migration for alembicLicenseRapid islicensedunder theApache 2.0 License. The terms of the license are as follows:Copyright (c) 2015 Michael Bright and Bamboo HR LLCLicensed 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
limitations under the License.
Package: rapidfuzz-capi
RapidFuzz C-APIAboutThis package provides the C-API of RapidFuzz. It can be used inside thepyproject.tomlto compile and extension module extending RapidFuzz. Providing this C-API in a separate package simplifies the build process. It allows the usage on platforms which are not supported by RapidFuzz, or for which RapidFuzz does not provide wheels (e.g. because they are not officially supported by numpy). Us this as:[build-system]requires=["wheel","setuptools","rapidfuzz_capi==1.0.5"]Similar to numpy the include path can be found in the following way:importrapidfuzz_capirapidfuzz_capi.get_include()
Package: rapidgui
rapidGuiNo fuss rapid gui for quick and easy developmenthow to use:For quick setup, create instance of quickgui class and add member variables:q = rapidgui.quickGui()

q.value = "eyooo?"
q.variable = 42.0

def clickMe():
    print("hello world")

q.hello = clickMeThis will create a tkinter window that contains titles and controls to change these variables.Currently only these types are supported:int, float, Decimal - will create a ttk.spinboxstring - will create a ttk.entryfunction - will create a ttk.buttonchange log2/18/2023 - Fix: values were returned as int2/18/2023 - added decimal support (precision is dependent on tkinter spinbox)
- added safe fail on empty spinbox (doesn't update value)
Package: rapidhrv
RapidHRVRapidHRV is a data processing pipeline for the analysis and visualization of cardiac data.Please provide credit where appropriate:Kirk, P. A., Davidson Bryan, A., Garfinkel, S., & Robinson, O. J. (2021).RapidHRV: An open-source toolbox for extracting heart rate and heart rate variability(PsyArXiv)This library is distributed under anMIT LicenseInstallationpipinstallrapidhrvUsageGiven a numpy array, or something convertable to it (such as a list),rapidhrv.preprocesscan generate input suitable for analysis withrapidhrv.analyze, which will return a pandas dataframe containing HRV data.importnumpyasnpimportrapidhrvasrhvmy_data=np.load("my_data.npy")# Load datadata=rhv.Signal(my_data,sample_rate=50)# Convert to rhv Signal classpreprocessed=rhv.preprocess(data)# Preprocess: may interpolate data, check the docstring on `rapidhrv.preprocess`result=rhv.analyze(preprocessed)# Analyze signalDocumentationPlease see the includedtutorial notebook.DevelopmentIn order to get a working development environment,
please installPoetryfor your platform,
and runpoetry installto generate a virtual environment.If you plan on making any changes to the included notebooks,
please runnbstripout --installfrom within the poetry venv before committing any changes.To run said notebooks from the environment provided by poetry,
install the required dependencies withpoetry install --extras notebooks.
Package: rapid-innovation
Rapid Innovation PackageRapid Innovation is a Python package that provides a set of tools and utilities for rapid development and innovation.InstallationTo install Rapid Innovation, simply run:pip install rapid_innovationUsageTo use Rapid Innovation, simply import the desired module and call the desired function or class. For example:!pip install rapid-innovation
    from rapid.email import RapidEmailNotificationSMTP
    
    smtp_user = 'XXXXXXX'
    smtp_password = 'XXXXXX'
    
    renstmp = RapidEmailNotificationSMTP(smtp_user, smtp_password)
    
    to = ['abhisheknegi@rapidinnovation.dev']
    subject = 'Pip Package testing'
    content = 'Testing upload pip package.'
    
    renstmp.send_email(to, subject, content)LicenseRapid Innovation is released under the MIT License.
Package: rapid-layout
rapid-layout1. Install package by pypi.$pipinstallrapid-layout2. Run by script.RapidLayout has the defaultmodel_pathvalue, you can set the different value ofmodel_pathto use different models, e.g.layout_engine = RapidLayout(model_path='layout_publaynet.onnx')See details, forREADME_Layout.📌layout.pngsource:linkfromrapid_layoutimportRapidLayoutlayout_engine=RapidLayout()withopen('layout.png','rb')asf:img=f.read()layout_res,elapse=layout_engine(img)print(layout_res)3. Run by command line.Usage:$rapid_layout-h
usage:rapid_layout[-h][-v]-imgIMG_PATH[-mMODEL_PATH]optionalarguments:
-h,--helpshowthishelpmessageandexit-v,--visWhetertovisualizethelayoutresults.
-imgIMG_PATH,--img_pathIMG_PATHPathtoimageforlayout.
-mMODEL_PATH,--model_pathMODEL_PATHThemodelpathusedforinference.Example:$rapid_layout-v-imglayout.png4. Result.Return value.[{'bbox':array([321.4160495,91.53214898,562.06141263,199.85522603]),'label':'text'},{'bbox':array([58.67292211,107.29000663,300.25448676,199.68142]),'label':'table_caption'}]Visualize result.
Package: rapid-models
# rapid-models
Python package (Reciprocal Data and Physics models - RaPiD-models) to support more specific, accurate and timely decision support in operation of safety-critical systems, by combining physics-based modelling with data-driven machine learning and probabilistic uncertainty assessment.Free software: GNU General Public License v3Documentation:https://rapid-models.readthedocs.io.## Quickstart`sh $ git clonehttps://github.com/RaPiD-models/rapid_models.git$ cd rapid_models $ pip install-e. $ rapid_models--help`To develop, test, generate documentation, etc.`sh $ pip install-rrequirements_dev.txt `To generate documentation do, either:`sh $ cd docs $ make docs html `or`sh $ cd docs $sphinx-build-Mhtml . build `The html documentation will then be avaliable indocs/build/html/index.html## Features
FIXME: add features## Credits
This package was created with Cookiecutter and theaudreyr/cookiecutter-pypackageproject template.
* [Cookiecutter](https://github.com/audreyr/cookiecutter)
* [audreyr/cookiecutter-pypackage](https://github.com/audreyr/cookiecutter-pypackage)History0.1.0 (2021-09-21)First release on PyPI.
Package: rapido.core
rapido.corerapido.core allows to run Rapido applications.rapido.core can run on Zope or Pyramid. The initial target is Plone (usingrapido.plone), but a POC has been
successfully implemented on Substance D.Database designA Rapido application can be built from Plone using rapido.plone or provided from
sources (read from the local file system).Anyhow, at the end, the database design is just a set of YAML/HTML/Python files.Therapido.plone documentationgives a good overview of Rapido features.Record storageStorage is not handled directly by rapido.core.By default, we userapido.souperwhich allows to store records in asoup.Using ZODB is not mandatory, different storages could be easily implemented
(SQL-based storage, remote storage services, etc.).Changelog1.0.6 (2016-09-19)Breaking changes:Use ‘/blocks/’ in Rapido URLs (instead of ‘/block/’)New features:Allow regular GET and POST on elements (action elements make a redirect,
other elements just return the result).
[ebrehault]on_displayevent
[ebrehault]Manager vew permissions on blocks
[ebrehault]1.0.5 (2016-04-09)Allow REST POST to element
[simon-previdente]Raise compilation and execution errors
[ebrehault]Support callable layout
[ebrehault]Allow safe modules (datetime, random, time)
[ebrehault]1.0.4 (2016-03-02)No rendering on basic element to allow {elem.attr} or {elem[item]} in templatescompute elements only onceFixes1.0.3 (2016-01-06)Allow redirection after action, save, or delete
[ebrehault]REST endpoint to compute a block element
[ebrehault]1.0.2 (2015-11-17)set_block() methodfix datetimefix permissions1.0.1 (2015-11-08)More pythonic access to record items1.0 (2015-11-07)Initial release
Package: rapidocr-openvinogpu
Python RapidOCR OpenVINO with GPU (with GPU only)This is a modified verison of RapidOCR (https://github.com/RapidAI/RapidOCR) to support OpenVINO GPU. Currently works only with for fixed size images (max len of 960) and also needs the image size to a multiple of 32.Note: Works only with Intel GPUs. For other devices refer to RapidAI RapidOCR.Installation and Inference:Pip method:pip install rapidocr_openvinogpuimport rapidocr_openvinogpu as rograpid_ocr = rog.RapidOCR()img = cv2.imread(file_path)rapid_ocr(img)print(result)print(elapse_list)Using source codegit clone https://github.com/jaggiK/rapidocr_openvinogpu.gitpython3 setup.py installcd rapidocr_openvinogpuRun inference for all the images in a given directorypython3 demo.py -d <absolute_path/to/directory>Infering an image:python3 demo.py -f <absolute_path/to/image.jpg>To save inference results, use-vflag:python3 demo.py -d <absolute_path/to/directory> -v# this saves the visualization in "./inference_results/" in the current folderTo save inference results in a desired folder, use-vand-oflag:python3 demo.py -d <absolute_path/to/directory> -v -o <absolute_path/to/directory>
Package: rapidocr-pdf
RapidOCRPDFRelying onRapidOCR, quickly extract text from PDF, including scanned PDF and encrypted PDF.Layout restore is not included for now.1. Install package by pypi.# base rapidocr_onnxruntimepipinstallrapidocr_pdf[onnxruntime]# base rapidocr_openvinopipinstallrapidocr_pdf[openvino]2. UsageRun by script.fromrapidocr_pdfimportPDFExtracterpdf_extracter=PDFExtracter()pdf_path='tests/test_files/direct_and_image.pdf'texts=pdf_extracter(pdf_path)print(texts)Run by command line.$rapidocr_pdf-h
usage:rapidocr_pdf[-h][-pathFILE_PATH]options:
-h,--helpshowthishelpmessageandexit-pathFILE_PATH,--file_pathFILE_PATHFilepath,PDForimages

$rapidocr_pdf-pathtests/test_files/direct_and_image.pdf3. Ouput format.Input：Union[str, Path, bytes]Output：List[Page num,Page content+score], ：[['0','达大学拉斯维加斯分校）的一次中文评测中获得最','0.8969868'],['1','ABCNet: Real-time Scene Text Spotting with Adaptive Bezier-Curve Network∗\nYuliang Liu‡†','0.8969868'],]