Saravanan666/pypi-org huggingface dataset:
Package: rdkit2ase
rdkit2ase - Interface between the rdkit and ASE package.Installation viapip install rdkit2ase.fromrdkit2aseimportrdkit2ase,ase2rdkitatoms:ase.Atoms=rdkit2ase(mol)mol=ase2rdkit(atoms)fromrdkit2aseimportsmiles2atomsatoms:ase.Atoms=smiles2atoms("O")print(atoms)>>>Atoms(symbols='OH2',pbc=False)Limitationsrdkit2ase.ase2rdkitwon't be able to detect higher order bonds.
Package: rdkit-doc-stubs
rdkit-doc-stubsThis repository needs to build the stubs for the RDKit package on the first start to avoid license issues.Sources are the RDKit documentation and mypy's stubgen.
On run of the install script, the documentation is downloaded and parsed.
While stubgen is run on the RDKit package. The stubs are then merged and
installed into the site-packages directory.Usagepip install rdkit-doc-stubs
python -m rdkit-stubs.install
Package: rdkit-pypi
🔥 RDKit Python WheelsThis repository holds the code to buildRDKitplatform wheels for Linux, macOS, and Windows on Github Action and Circle CI. The wheels contain the compiled platform-specific dynamic libraries (*.so,*.dylib, and*.dll) and are available atPyPI. RDKit can easily be installed usingpipinstallrdkitNOTE:Older versions of RDKit might be available at therdkit-pypiPyPI repository (pip install rdkit-pypi).rdkit-pypiis the old name of this project at PyPI. Future RDKit versions will be available at therdkitPyPI repository. Please update your dependencies, i.e., changerdkit-pypitordkit.Please open an issue if you find something missing or not working as expected.Available BuildsOSArchBitConditions3.73.83.93.103.11CILinuxintel64glibc >= 2.17 (e.g., Ubuntu 16.04+, CentOS 6+, ...)✔️✔️✔️✔️✔️Github ActionsLinuxaarch6464glibc >= 2.17 (e.g., Raspberry Pi, ...)✔️✔️✔️✔️✔️Circle CImacOSintel64>= macOS-11✔️✔️✔️✔️✔️Github ActionsmacOSarmv864>= macOS-11 (M1 hardware)✔️✔️✔️✔️Github ActionsWindowsintel64✔️✔️✔️✔️✔️Github ActionsInstallationPIPpython-mpipinstallrdkit
python-c"from rdkit import Chem; print(Chem.MolToMolBlock(Chem.MolFromSmiles('C1CCC1')))"Poetrypoetryaddrdkit
poetryrunpython-c"from rdkit import Chem; print(Chem.MolToMolBlock(Chem.MolFromSmiles('C1CCC1')))"Local builds on Linuxcibuildwheelrequirespatchelf(apt install patchelf)python3-mpipinstallcibuildwheel

gitclonehttps://github.com/kuelumbus/rdkit-pypi.gitcdrdkit-pypiCIBW_BUILD=cp37-manylinux_x86_64python3-mcibuildwheel--platformlinux--output-dirwheelhouse--config-filepyproject.tomlReplacecp37-manylinux_x86_64withcp38-manylinux_x86_64,cp39-manylinux_x86_64,cp310-manylinux_x86_64, orcp311-manylinux_x86_64to build for different Python versions.
Package: rdkit-step
SEAMM RDKit Plug-inA SEAMM plug-in for RDKitFree software: BSD-3-ClauseDocumentation:https://molssi-seamm.github.io/rdkit_step/index.htmlCode:https://github.com/molssi-seamm/rdkit_stepFeaturesPlease edit this section!AcknowledgementsThis package was created withCookiecutterand themolssi-seamm/cookiecutter-seamm-pluginproject template.Developed by the Molecular Sciences Software Institute (MolSSI),
which receives funding from theNational Science Foundationunder
award ACI-1547580History2023.2.22 – Fixed bug with dialogFixed bug creating dialog, due to changes in code SEAMM code.Made the dialog fit most of the window to make it easier to use.2022.1.11.1 – Initial release!The initial release of a SEAMM plug-in providing access the to features
(descriptors) available in RDKit.This version fixes a minor problem with the citation of the plug-in itself.2022.1.11 – Initial release!2021.9.16 (2021-09-16)Plug-in created using the SEAMM plug-in cookiecutter.
Package: rdkit-stubs
[PEP651 stub package for rdkit](https://peps.python.org/pep-0561/#stub-only-packages)These stubs were generated using [mypy stubgen](https://mypy.readthedocs.io/en/stable/stubgen.html)
and edited extensively to cleanup the parts that were most broken.The stubs are partially complete but there is more work to be done to remove the references
toAny. Contributions are welcome.This package currently targets rdkit version2022.03.3.## UseTo use these stubs, add therdkit-stubspackage to your python environment.` pip installrdkit-stubs`## DevelopingTo test your contributions to these stubs you can import the local package from another one of your
projects. First clone the repo thenpip install -e <path-to-this-repo>.## LicenseLicensed under either ofApache License, Version 2.0
([LICENSE-APACHE](LICENSE-APACHE) orhttp://www.apache.org/licenses/LICENSE-2.0)MIT license
([LICENSE-MIT](LICENSE-MIT) orhttp://opensource.org/licenses/MIT)at your option.## ContributionUnless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.
Package: rdkit-utilities
rdkit_utilitiesContained here are some helpful RDKit utilities for:generating conformersranking by MMFF electrostatic energy (for ELF conformer selection)selecting to maximize diversity via RMS (for ELF conformer selection)finding symmetric atoms in a moleculefinding the shell of neighbors around a central fragment, N bonds awayThere are also convenience functions for:loading molecules from any inputMolFromInputloading molecules from SMILES with keyword arguments forremoveHs, etc.loading molecules and reordering by atom map number, analogous to the OpenFF toolkitMolecule.from_mapped_smilesgenerally reordering conformersoptimizing molecules by specifying force field using a string nameFunctions are in files such asrdchem,rdDistGeom, etc. to try to keep to
RDKit's organisation convention. Similarly to RDKit, aChemandAllChemare provided with group imports.
Functions are written in PascalCase and keyword arguments in camelCase, also to
keep to RDKit convention.CopyrightCopyright (c) 2022, Lily WangAcknowledgementsProject based on theComputational Molecular Science Python Cookiecutterversion 1.5.
Package: rdklib
RDKlibRDKlib is a Python library to enable you torun custom AWS Config
Rules at scale. The library can be used to:Help you to focus only on the compliance logic, while the library
does the heavy liftingEase maintenance by moving the boilerplate code as a AWS Lambda
LayerEase deployment by using AWS Serverless Application RepositoryRDKLib works in synergy with theAWS Config Rule Development Kit.Getting StartedInstall the library locallypipinstallrdklibCreate a rule using the RDKThe runtime of your RDK rule have to be set to python3.11-lib in the RDK
to provide you the Rule template.For periodic trigger:rdkcreateYOUR_RULE_NAME--runtimepython3.11-lib--maximum-frequencyTwentyFour_HoursFor configuration change trigger (for example S3 Bucket):rdkcreateYOUR_RULE_NAME--runtimepython3.11-lib--resource-typesAWS::S3::BucketNote: you need toinstall the RDKfirst.Deploy your rule with RDKlib layerRDKLib is designed to work as a AWS Lambda Layer. It allows you to use the library without needing to include it in your deployment package.Install RDKlib layer (with AWS CLI)awsserverlessrepocreate-cloud-formation-change-set--application-idarn:aws:serverlessrepo:ap-southeast-1:711761543063:applications/rdklib--stack-nameRDKlib-Layer# Copy/paste the full change-set ARN to customize the following commandawscloudformationexecute-change-set--change-set-nameNAME_OF_THE_CHANGE_SETawscloudformationdescribe-stack-resources--stack-nameserverlessrepo-RDKlib-Layer# Copy the ARN of the Lambda layer in the "PhysicalResourceId" key (i.e. arn:aws:lambda:YOUR_REGION:YOUR_ACCOUNT:layer:rdklib-layer:1).Note: You can do the same step manually going tohttps://console.aws.amazon.com/lambda/home#/create/function?tab=serverlessAppsand find "rdklib"Deploy the rulerdkdeployYOUR_RULE_NAME--rdklib-layer-arnYOUR_RDKLIB_LAYER_ARNLicenseThis project is licensed under the Apache-2.0 License.Feedback / QuestionsFeel free to emailrdk-maintainers@amazon.comContactsBenjamin Morris-Maintainer, code, testingCarlo DePaolis-Maintainer, code, testingAcknowledgementsMark Beacom-Maintainer, code, testingMichael Borchert-Design, code, testing, feedbackRicky Chau-Maintainer, code, testingJulio Delgado Jr.-Design, testing, feedbackChris Gutierrez-Design, feedbackJoe Lee-Design, feedbackJonathan Rault-Maintainer, design, code, testing, feedback
Package: rdl
This tool is made specially for dump & load certain database of a redis server,
if you want to dump whole redis or replicate from one to another,
please checkoutredis bgsaveorredis replicationon google.NOTE: Packageredisis required to use this tool.Usageusage: rdl.py [-n N] [-h H] [-p P] [-f] [--help] ACTION FILE

Redis dump-load tool.

positional arguments:
  ACTION  `dump` or `load`.
  FILE    if action is dump, then its output file, if actions is load, then
          its source file.

optional arguments:
  -n N    Number of database to process.
  -h H    Redis host
  -p P    Redis port
  -f      Force or flush database before load
  --help  show this help message and exitExampleDump database 1 to fileredis.dump:$ ./rdl.py dump redis.dump -n 1Load to database 3 from fileredis.dump:$ ./rdl.py load redis.dump -n 3 -f
Package: rdlm
What is it ?RDLM(Restful Distributed Lock Manager) is a lock manager over HTTP
built onTornado.Special featuresRESTful interfaceTimeout automatic management (to avoid stale locks)Blocking wait for acquiring a lock (with customatizable timeout)Very fast (in memory)One unique single threaded processCan deal with thousands of locks and simultaneous connectionsAdministrative password protected requestsQuickstartInstallationpip install rdlm

Requirements:
- Python 2.6, 2.7, 3.2 or 3.3
- Tornado >= 2.3Starting the daemonrdlm-daemon.py --port=8888 --logging=debug

(rdlm-daemon.py --help for the full list of options)APIThe complete HTTP API is described inthis specific document.If you prefer a pure python API, you can also have a look at :this specific project.
Package: rdlm-py
What is it ?rdlm-pyis a python client for therestful-distributed-lock-manager
(RDLM).Special featuresClassic and administrative (password protected) requestsThree ways to use it (a classical API, a (more pythonic) ContextManager API, some CLI tools)QuickstartInstallationpip install rdlm-py

Requirements:
- Python 2.6, 2.7, 3.2 or 3.3
- Requests >= 1.2.3UsageSee theREADMEfor more details.
Package: rdlocrand
rdlocrand: Local Randomization Methods for RD DesignsDescriptionThe regression discontinuity (RD) design is a popular quasi-experimental design for causal inference and policy evaluation. Under the local randomization approach, RD designs can be interpreted as randomized experiments inside a window around the cutoff. Therdlocrandpackage provides tools to analyze RD designs under local randomization:rdrandinfto perform hypothesis testing using randomization inference.rdwinselectto select a window around the cutoff in which randomization is likely to hold.rdsensitivityto assess the sensitivity of the results to different window lengths and null hypotheses.rdrboundsto construct Rosenbaum bounds for sensitivity to unobserved confounders.For more details, and related Stata and R packages useful for the analysis of RD designs, visithttps://rdpackages.github.io/.ReferencesCattaneo, M.D., B. Frandsen, and R. Titiunik. (2015).Randomization Inference in the Regression Discontinuity Design: An Application to Party Advantages in the U.S. Senate.Journal of Causal Inference3(1): 1-24.Cattaneo, M.D., R. Titiunik, and G. Vazquez-Bare. (2016).Inference in Regression Discontinuity Designs under Local Randomization.Stata Journal16(2): 331-367.Cattaneo, M.D., R. Titiunik, and G. Vazquez-Bare. (2017).Comparing Inference Approaches for RD Designs: A Reexamination of the Effect of Head Start on Child Mortality.Journal of Policy Analysis and Management36(3): 643-681.Rosenbaum, P. (2002).Observational Studies. Springer.AuthorMatias Cattaneo, Princeton University. Email:cattaneo@princeton.eduRocio Titiunik, Princeton University. Email:titiunik@princeton.eduRicardo Masini, UC Davis. Email:rmasini@ucdavis.eduGonzalo Vazquez-Bare, UC Santa Barbara. Email:gvazquez@econ.ucsb.edu
Package: rdltr
rdltr1rdltris aread-it laterweb application: save articles for later reading.Categories and tags can be used to classify articles.It is also possible to add articles fromFreshRSS.A Firefox add-on is available:SamR1/rdltr-addon, allowing
to add article from browser side.➡️ seedocumentationfor installation instructions and features.Initially a small project to learn Vue (with Flask)2,rdltrusesreadability-lxmlto parse HTML
content.Notes:1. test coverage: only for Python2. application structure inspired by this tutorial:Full-stack single page application with Vue.js and Flask
Package: rdm6300
Using the RDM6300 RFID reader from pythonThe project is primarly geared towards using the RDM6300 with a Raspberry PI and Python 3.The unit tests are passing with Python 2, so it should work (tm), but I am using python3 for
developing the module.In theory the module should be working with anything that is compatible with the EM4100 wire
protocol.Please note that wiring the RDM6300 to an RPI is not entierly trivial (either it will not work, or
you are risking frying your PI), so before tring this out please make sure you had read my blog
post on this:https://the.mad-tinkerer.me/rdm-6300-raspberry-pi/The reader code has almost 100% unit test coverage, so the code should be quite stable.Please see the API documentationhereUsage (Easy mode)Assuming that you had wired the RDM6300 correctly you can execute the following to create a working
environment:$ virtualenv -p python3 virtualenv
$ . virtualenv/bin/activate
$ pip install rdm6300Afterwards you can use this code to start reading with the RFID reader (examples/simple.py):import rdm6300

reader = rdm6300.Reader('/dev/ttyS0')
print("Please insert an RFID card")
while True:
    card = reader.read()
    if card:
        print(f"[{card.value}] read card {card}")Usage (Real life scenario)see examples/complex.pyimport rdm6300

class Reader(rdm6300.BaseReader):
    def card_inserted(self, card):
        print(f"card inserted {card}")

    def card_removed(self, card):
        print(f"card removed {card}")

    def invalid_card(self, card):
        print(f"invalid card {card}")

r = Reader('/dev/ttyS0')
r.start()CreditsThe code is a rewrite of the library pyrfid:https://www.pm-codeworks.de/pyrfid.html
Package: rdm-distributions
Normal and Binomial Distributions (Basics)This project is just a package which calculates some basic statistics, handle simple operations and show some plots about the Normal and the Binomial statistical Distributions.IntallationDependenciesThis project requires the following:Python (>= 3.8)With the following packages:Matplotlib (>= 3.3)Scipy (>= 1.6)Project descriptionThis is a very basic package, which could grow in the future but there isn't a plan by now for future improvements.Now this package contains the following statistical distributions:GaussianBinomialand handles the following operations:Calculate the meanCalculate the standard deviationSum two distributions (only with the same p for Binomial)Plot PDF (probability density function)ContributingIf you are interested in contributing to this project, please contact me.Copyright and licenseThis analysis and the data used are here published under the GNU general public
license v3.0
Package: rdmlpython
The Real-time PCR Data Markup Language (RDML) is a structured and
universal data standard for exchanging quantitative PCR (qPCR)
data. The rdmlpython package allows to load, view, modify and
save RDML files.Typical usage may looks like this::#!/usr/bin/env pythonfrom rdmlpython as rdmldat = rdml.Rdml(‘sample.rdml’)sam = dat.samples()for sample in sam:print(sample[“id”] + “ - “ + sample[“type”])For more information visit:https://www.gear-genomics.com/rdml-tools/help.html#LRP-Library
Package: rdmo
RDMO - Research Data Management OrganiserRDMO is a tool to support the systematic planning, organisation and implementation of the data management throughout the course of a research project. RDMO is funded by the Deutsche Forschungsgemeinschaft (DFG).Home Pagehttps://rdmorganiser.github.ioSource codehttps://github.com/rdmorganiser/rdmoDocumentationhttps://rdmo.readthedocs.ioMailing listhttps://www.listserv.dfn.de/sympa/subscribe/rdmoSlackhttps://rdmo.slack.comDemohttps://rdmo.aip.deIf you encounter any problems or bugs with the RDMO Software, or if you want to request a feature, please file an issue here:https://github.com/rdmorganiser/rdmo/issues. For problems or suggestions with questionaires, the RDMO domain model or other content, please use the issues in therdmo-catalogrepository:https://github.com/rdmorganiser/rdmo-catalog/issues. In order to file issues, you will need a GitHub account.
Package: rdmulti
rdmulti: analysis of RD Designs with multiple cutoffs or scoresDescriptionThe regression discontinuity (RD) design is a popular quasi-experimental design for causal inference and policy evaluation. Therdmultipackage provides tools to analyze RD designs with multiple cutoffs or scores:rdmc()estimates pooled and cutoff-specific effects in multi-cutoff designs.rdmcplot()draws RD plots for multi-cutoff RD designs.rdms()estimates effects in cumulative cutoffs or multi-score designs.For more details, visithttps://rdpackages.github.io/rdmulti.ReferencesCalonico, S., M.D. Cattaneo, M. Farrell, and R. Titiunik. (2017).rdrobust: Software for Regression Discontinuity Designs.Stata Journal17(2): 372-404.Calonico, S., M.D. Cattaneo, and R. Titiunik. (2014).Robust Data-Driven Inference in the Regression-Discontinuity Design.Stata Journal14(4): 909-946.Calonico, S., M.D. Cattaneo, and R. Titiunik. (2015).rdrobust: An R Package for Robust Nonparametric Inference in Regression-Discontinuity Designs.R Journal7(1): 38-51.Cattaneo, M.D., L. Keele, R. Titiunik, and G. Vazquez-Bare. (2016).Interpreting Regression Discontinuity Designs with Multiple Cutoffs.Journal of Politics78(4): 1229-1248.Cattaneo, M.D., L. Keele, R. Titiunik, and G. Vazquez-Bare. (2020).Extrapolating Treatment Effects in Multi-Cutoff Regression Discontinuity Designs.Journal of the American Statistical Association116(536): 1941, 1952.Cattaneo, M.D., R. Titiunik, and G. Vazquez-Bare. (2020).Analysis of Regression Discontinuity Designs with Multiple Cutoffs or Multiple Scores.Stata Journal20(4): 866-891.Keele, L., and R. Titiunik. (2015).Geographic Boundaries as Regression Discontinuities.Political Analysis23(1): 127-155AuthorsMatias Cattaneo, Princeton University. Email:cattaneo@princeton.eduRocio Titiunik, Princeton University. Email:titiunik@princeton.eduRicardo Masini, UC Davis. Email:rmasini@ucdavis.eduGonzalo Vazquez-Bare, UC Santa Barbara. Email:gvazquez@econ.ucsb.edu
Package: rdo
rdostands for “RemoteDO” and is to help facilitate running commands
on “remote” machines. Specifically is meant to help you run and
develop code on a virtual machine, while avoiding having to shell into
the VM.UsageThe first step is to create a.rdo.conffile. Here is an example
usingrdowithVagrant.[default]
driver = vagrant
directory = /vagrantLets assume you have aVagrantfilein the root of your code base and
are mounting your code to/vagrant. Lets also assume you have aMakefileyou use to run different tasks for your project.Here is how you to run thebuildtask usingrdo:$ rdo make buildrdowill compose the correct command to run it on your
Vagrant VM. For example, the above would end up running:$ vagrant ssh -c "cd /vagrant && make build"Free software: BSD licenseDocumentation:https://rdo.readthedocs.org.
Package: rdopts
The package rdopts contains a simple command to read options from a
setuptools setup.cfg file.  To install it, simply use easy_install or
pip:#easy_install
easy_install rdopts

#pip
pip install rdoptsFor information on using this command once it’s installed, run the following
command (from any python setup.py file):python setup.py rdopts -hThis will show you all command-line options for rdopts.
Package: rdot
Rate Distortion Optimization ToolsIntroductionRDOT (Rate Distortion Optimization Tools) is a software library that aims to provide efficient, unified tools for computing rate distortion functions.For low cardinalities, the solutions to rate distortion (Shannon, 1959), information bottleneck (IB) (Tishby et al., 1999) and related objectives are feasible to solve with Blahut-Arimoto (BA) style algorithms. This library unifies several different variants on the rate distortion objective and provides solvers using BA and reverse deterministic annealing. Implementation is heavily inspired by, but slightly different or more general than, the librariesemboanddit. This library was created to overcome two shortcomings of these existing libraries:embois a fast implementation of generalized IB, but has no support for getting solution encoders, or using deterministic annealing, which is useful for preserving some structure between nearby optima.ditis a more general library supporting discrete information theory, but is slow.
In contrast,rdotis a fast, general implementation of rate-distortion objectives that yields all relevant components of fixed-point solutions.Installing RDOTFirst, set up a virtual environment (e.g. viaminiconda,conda create -n rdot python=3, andconda activate rdot).Method 1. Install via pypiInstall ULTK via pypi (We recommend doing this inside a virtual environment)pip install rdotMethod 2. Install locallyDownload or clone this repository and navigate to the root folder.Install ULTK (inside a virtual environment)pip install -e .Getting startedCheck out theexamples, which contains anotebookwalking through rate distortion problems, and a comparison of IB solutions forrdotandembo.To see more real usage examples, visit the codebase forcompression theory for concept learning, or for exploring IB-efficient vocabularies in the context ofsignaling games.ModulesThe main module isrdot.ba, which includes a unified hierarchy of optimizer classes for defining and solving rate distortion objectives.There are several auxiliary modules, including:rdot.distortionsfor defining distortion functions,rdot.informationhelper functions for working with distributions and information-theoretic quantities,rdot.probabilityhelper functions for working with distributions,rdot.postprocessinghelper functions for ensuring the quality of solutions computed viardot.ba.TestingUnit tests are written using pytest in thetest_rd.pyfile and executed via runningpytestfrom the root folder.References:> Shannon, C.E. (1959). Coding theorems for a discrete source with a fidelity criterion. Institute of Radio Engineers,
National Convention Record 4:142–163.Tishby, N., Pereira F.C., & Bialek, W. (1999). The information bottleneck method.Proceedings of the 37th Annual Allerton Conference on Communication, Control and Computing, eds Hajek B, Sreenivas RS (Univ of Illinois, Urbana, IL), pp 368– 377.
Package: rdp
Python/NumPy implementation of the Ramer-Douglas-Peucker algorithm
(Ramer 1972; Douglas and Peucker 1973) for 2D and 3D data.The Ramer-Douglas-Peucker algorithm is an algorithm for reducing the number
of points in a curve that is approximated by a series of points.InstallationpipinstallrdpUsageSimple pythonic interface:fromrdpimportrdprdp([[1,1],[2,2],[3,3],[4,4]])[[1,1],[4,4]]With epsilon=0.5:rdp([[1,1],[1,1.1],[2,2]],epsilon=0.5)[[1.0,1.0],[2.0,2.0]]Numpy interface:importnumpyasnpfromrdpimportrdprdp(np.array([1,1,2,2,3,3,4,4]).reshape(4,2))array([[1,1],[4,4]])LinksDocumentationGitHub PagePyPIReferencesDouglas, David H, and Thomas K Peucker. 1973. “Algorithms for the Reduction of the Number of Points Required to Represent a Digitized Line or Its Caricature.” Cartographica: The International Journal for Geographic Information and Geovisualization 10 (2): 112–122.Ramer, Urs. 1972. “An Iterative Procedure for the Polygonal Approximation of Plane Curves.” Computer Graphics and Image Processing 1 (3): 244–256.
Package: rdp-algo
Ramer-Douglas-PeuckerRamer-Douglas-Peucker python implementation.Installationpip install rdp-algoUsageThe rdp function supports both lists and numpy arrays of arbitrary dimensions.>>>fromrdp_algoimportrdp>>>rdp([[0,0],[1,1],[2,0]],epsilon=1)[[0,0],[2,0]]>>>importnumpyasnp>>>fromrdp_algoimportrdp>>>rdp(np.array([[0,0],[1,1],[2,0]]),epsilon=1)array([[0,0],[2,0]])