Saravanan666/pypi-org huggingface dataset:
Package: rc-webserver
Resilient Circuits Web ServerProvides a Web server that can be extended by additional components.
This is useful for implementing a Threat Service, or for webhooks.To have your Python method called with requests at/path/endpoint,Make a class that inherits fromcircuits.web.BaseController,Setself.channel="path",Use therc_webserver.web.@exposeWebdecorator on a method, e.g.@exposeWeb("endpoint").Changelog2020-07-15: version 37.2Updated for python 3.EnvironmentThis package requires that it is installed on a RHEL platform and that the resilient-circuits application is running.
Install this package with 'pip', orpython setup.py install.
To set the config values in the app.config file runresilient-circuits config -u.Config values example:[webserver]

# IP or DNS for the web server. Default is localhost.
# server=0.0.0.0

# Port for the web server. Default is 9000.
# port=9000

# Set the web server to use secure protocol. secure=1 means HTTPS, and secure=0 means HTTP. Default is 0
# secure=1

# The cert file is the private key certificate for the TLS server. This is required if secure=1. Default is None.
# certfile=~/.resilient/ssl.cerRun with:resilient-circuits run.
Package: rd
Download large files across slow and unstable network reliably. Requires using
rd-api on server side. For more information on how it works, seerd-api.InstallationTo install this package:$pipinstall--userrd$rd--help$~/.local/bin/rd--help# if ~/.local/bin/ is not in PATHBaisc Usageserver side (requiresrd-api):$lsbigfile1bigfile2$rd-api--host0.0.0.0--port8082client side:$rdhttp://server-ip:8082/bigfile1Documentationseerd-api.ChangeLogv1.3.0.1 2022-03-15feature: add download progress loggingv1.2.0.0 2022-03-14feature: add –rolling-combine option. allow combine big file when disk space is low.v1.1.3.0 2022-03-14feature: code ported to ghc 8.10.7v1.0.0.3 2018-05-09init release.
Package: rd2md
rd2mdA converter to transform R doc files (.Rd) into markdown files (.md).Installationpipinstallrd2mdUsageIn the following command-line examples you can userd2mdorpython -m rd2md.rd2md[RD-DIRECTORY][MD-DIRECTORY]BASE-FILENAME-1BASE-FILENAME-2...where:[RD-DIRECTORY] is the directory of .Rd files (eg,R/man)[MD-DIRECTORY] is the output directory for markdown filesBASE-FILENAME is the name of an Rd file without the directory or extensionExampleTo useR/manas the directory of Rd files, anddocumentationas
the output directory, convertingR/man/create_experiment.Rdtodocumentation/create_experiment.mdandR/man/Experiment.Rdtodocumentation/Experiment.mddo this:rd2mdR/mandocumentationcreate_experimentExperiment
Package: rdabase
rdabaseRedistricting analytics data & shared codeInstallationTo get the data locally, clone the repository:$gitclonehttps://github.com/alecramsay/rdabase
$cdrdabaseTo use the shared code, install the package:$pipinstallrdabaseDataThe data are stored in thedatadirectory by state.
These pages describe each dataset:Data: Census and election data by precinct.Shapes: Shape properties by precinct.Graph: Precinct adjacency graph.At present, data forfifteen stateshave been extracted.
In the future, we may extract data for other states.CodeSome shared code and scripts are described here:Shared Code: Common code used in multiple applications.Scripts: Scripts to re-format the data for specific applications.SourcesThe data comes from the following sources:The total census population & VAP demographics data comes from the 2020_census_XX-N.csv
in the DRAvtd_dataGitHub repository,
where XX is the state abbreviation and N is the suffix.
We take the latest version of the data, which is the one with the highest N.The election data comes from the 2020_election_XX-N.csv in the same repo.The shapes are copies of tl_2020_FF_vtd20.zip fromthe Census Bureau,
where FF is the state FIPS code, e.g., 37 for North Carolina.Some things to be aware of:If it exists, we use the adjusted population data instead of the official 2020 census total population data.For Florida, the official VTDs from the Census Bureau are bad.
We used DRA's corrected precinct shapes (GeoJSON), removed the intersections, and then converted it to a shapefile.We simplify the precinct shapes (seeextract_shape_data.py) to approximate the simplification that DRA does, so compactness measurements align.Testing$pytest
Package: rdadata
rdadataRedistricting analytics data & shared codeInstallationTo get the data locally, clone the repository:$gitclonehttps://github.com/alecramsay/rdadata
$cdrdadataTo use the shared code, install the package:$pipinstallrdadataDataThe data are stored in thedatadirectory by state.
These pages describe each dataset:Data: Census and election data by precinct.Shapes: Shape properties by precinct.Graph: Precinct adjacency graph.At present, data forfifteen stateshave been extracted.
In the future, we may extract data for other states.CodeSome shared code and scripts are described here:Shared Code: Common code used in multiple applications.Scripts: Scripts to re-format the data for specific applications.SourcesThe data comes from the following sources:The total census population & VAP demographics data comes from the 2020_census_XX-N.csv
in the DRAvtd_dataGitHub repository,
where XX is the state abbreviation and N is the suffix.
We take the latest version of the data, which is the one with the highest N.The election data comes from the 2020_election_XX-N.csv in the same repo.The shapes are copies of tl_2020_FF_vtd20.zip fromthe Census Bureau,
where FF is the state FIPS code, e.g., 37 for North Carolina.Some things to be aware of:If it exists, we use the adjusted population data instead of the official 2020 census total population data.For Florida, the official VTDs from the Census Bureau are bad.
We used DRA's corrected precinct shapes (GeoJSON), removed the intersections, and then converted it to a shapefile.We simplify the precinct shapes (seeextract_shape_data.py) to approximate the simplification that DRA does, so compactness measurements align.Testing$pytest
Package: rdadccvt
rdadccvtBalzer's algorithm (DCCVT) to find a maximally population compact mapInstallationTo clone the repository:$gitclonehttps://github.com/alecramsay/rdadccvt
$cdrdadccvtTo install the package:$pipinstallrdadccvtThen copy thedccvtexecutable from thebindirectory to thebindirectory where you installed the package.UsageSee therdatools/rdarootandrdatools/rdaensemblerepositories for examples of how to use this package.
The former takes contiguous and 'roughly equal' population maps, and
minimizes the energy (maximizes the population compactness).
The latter uses Balzer's algorithm as part of a multi-step process to
create a contiguous and 'roughly equal' population map from a random
set of starting district centroids.
Package: rdafn
rdafnCompute Dave's Redistricting (DRA) analytics for an ensemble of redistricting plans.InstallationI've converted this into a pip installable package:$pipinstallrdafnAs noted next, you probably also want to clone the companionrdadatarepository.UsageThere are both code and script examples of how to use this code in thesampledirectory.
That directory also contains some sample results from the main scoring functionanalyze_plan().
The samples use data from the companionrdadatarepo.NotesWith four exceptions,analyze_plan()computes all the analytics that DRA does:For a variety of reasons, DRA's production TypeScript packagedra-analyticsdoes not calculate a few minor things that show up in the UI.
The Python portrdapydoes not either.
This repo uses the latter, so those few things also aren't in the "scorecard" output.To keep the results simple, district-level results are suppressed. The scorecard is a simple flat
dictionary of metric key/value pairs.To maximize throughput KIWYSI compactness is not calculated. The simple naive approach to performing
compactness calculations is to dissolve precinct shapes into district shapes, but dissolve is very
expensive operation. Analyzing a congressional plan for North Carolina take ~60 seconds. A much
faster approach is to convert precinct shapes into topologies using TopoJSON like DRA does and then
merging precincts into district shapes. That approach takes ~5 seconds, virtually all of the time
being calling TopoJSONmerge()from Python and marshalling the result back from JavaScript. I could
have chosen to implement a Python native version ofmerge(). Instead, I chose to skip KIWYSI
compactness (which requires actual district shapes) and just calculate the two main compactness
metrics in DRA: Reock and Polsby-Popper. Together these only depend on district area, perimeter, and
diameter, and with some pre-processing once per state (analogous to converting shapes into a topology)
these values can be imputed without ever creating the district shapes. The result is that analyzing
a congressional plan for North Carolina — calculatingallthe analytics — takes a small fraction
of a second.Finally, we've already created the precinct contiguity graphs as part of finding root map candidates
in mybaselineGitHub repo,
and we're also already using the graph in Todd'sensemblesrepo
to support generating spanning trees.
So, by definition, the plans in our ensembles are contiguous.
Hence, we don't check that.Testing$pytest--disable-warnings
Package: rdap
rdapRegistration Data Access Protocol toolsInstallationpipinstallrdapUsageusage: rdap [-h] [--debug] [--home HOME] [--verbose] [--quiet] [--version] [--output-format OUTPUT_FORMAT] [--show-requests] [--parse] [--rir] [--write-bootstrap-data] query [query ...]

rdap

positional arguments:
  query

options:
  -h, --help            show this help message and exit
  --debug               enable extra debug output
  --home HOME           specify the home directory, by default will check in order: $RDAP_HOME, ./.rdap, /home/grizz/.rdap, /home/grizz/.config/rdap
  --verbose             enable more verbose output
  --quiet               no output at all
  --version             show program's version number and exit
  --output-format OUTPUT_FORMAT
                        output format (yaml, json, text)
  --show-requests       show all requests
  --parse               parse data into object before display
  --rir                 display rir
  --write-bootstrap-data
                        write bootstrap data for type (as query)Config fileThe client uses the--homeoption to point to a directory, by default will check in order:$RDAP_HOME,./.rdap,~/.rdap,~/.config/rdapThe directory should have aconfig.yamlfile in it, defaults shown below.rdap:# URL to bootstrap the initial request offbootstrap_url:https://rdap.db.ripe.net/# boolean to use data from bootstrap_data_url instead of a bootstrap serverself_bootstrap:False# url to load bootstrap data frombootstrap_data_url:"https://data.iana.org/rdap/"# length of time in hours to keep bootstrap databootstrap_cache_ttl:25# how to format the outputoutput_format:yaml# API key for use at rdap.lacnic.netlacnic_apikey:None# role types to recursively query when processingrecurse_roles:["administrative","technical"]# HTTP request timeout in seconds, used for both connect and readtimeout:0.5LicenseCopyright 2016-2023 20C, LLCLicensed under the Apache License, Version 2.0 (the "License");
you may not use this softare 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: rdap-cli
AboutRDAP - Registration Data Access Protocol is an Internet protocol standardized in 2015 and thought of as an evolution of WHOIS. This has a defined structure so that the data can be manipulated more easily at the programming level. The data type will be a Json.This program is in charge of collecting all the relevant information related to a domain such as domain expiration date, nameservers, registration entity, domain registration date, if it is available to register or not.UtilsJson TLD file:Json FileRdap deployment:DATAProject format:formatRequirementsAlready exist a file called requirements.txt but for practical uses we are going to mention here too.PACKAGESVERSIONCOMMANDDOCSPyPIClick8.0.0pip install clickDOCSPyPIPython dateutil2.8.1pip install python-dateutilDOCSPyPIRequests2.22.0pip install requestsDOCSPyPITldextract3.1.0pip install tldextractDOCSPyPIValidators0.18.2pip install validatorsDOCSPyPIPyYAML5.4.1pip install PyYAMLDOCSPyPITabulate0.8.9pip install tabulateDOCSPyPIPre Commit2.13.0pip install pre-commitDOCSPyPIFlake83.9.2pip install flake8DOCSPyPIBlack21.6b0pip install blackDOCSPyPIFeaturesThis tool gives you the ability to look up the registration data for domain names.It allows the detection of unregistered domains.Provide useful information whether for personal or work use.Replaces traditional whois.Allow you to save the payload into multiple format files such as '.json' or '.txt'.It allows you to see your past searches with the help of a history.GuideYou can check the tutorialHERE
Package: rd-api
rd-api is an HTTP file server that provides static file hosting and reliable
download api forrd client.rd-api serves files under web-root. You can use it likepython3-mhttp.server.In addition, if rd command line tool is used to do the download, it will
download in a reliable way by downloading in 2MiB blocks and verify checksum
for each block.InstallationTo install this package:$sudoaptinstall-yredis-server# redis is used to cache block sha1sum$pipinstall--userrd-api$rd-api--help$~/.local/bin/rd-api--help# if ~/.local/bin/ is not in PATHBaisc Usageserver side:$lsbigfile1bigfile2$rd-api--host0.0.0.0--port8082client side (requiresrd client):$rdhttp://server-ip:8082/bigfile1DocumentationReliable download is implemented this way:User uses rd client to request a resource to download.rd client requests resource block metadata via the /rd/ api. Block metadata
contains block count, block id, block byte offset, block content sha1sum.rd-api calculates and serves block metadata to rd client incrementally.
Block metadata is cached in redis after calculation.rd client fetches block using HTTP/1.1 Range header and verifies sha1sum
incrementally. When all blocks are downloaded and verified, combine blocks
to get the final resource.rd client will retry on http errors and sha1sum verification failures.rd client supports continuing a partial download. You can press Ctrl-C to
stop download anytime, and continue later by running the same command again.Reliable download is written in Haskell, binary is distributed on PyPI for
easy installation on linux system. Reliable download only runs in linux.ChangeLogv1.1.3.0 2022-03-14bugfix: revised logging messages. rd-api supports –verbose option. debug msg is not shown by default.feature: code ported to ghc 8.10.7v1.1.0.0 2018-05-10feature: support passing arguments using env variables, for cli arg –redis-host, the env variable will be REDIS_HOST.bugfix: fix cli argument parsing for string typesv1.0.0.3 2018-05-09update installation doc, rd-api requires redis serverv1.0.0.2 2018-05-09init release.
Package: rd-api-py
rd_api_pyReal Debrid API Library for PythonInstallationInstall the packagepython-mpipinstallrd_api_pySet environment variables in.envinrd_refreshor your scriptRD_APITOKEN="your_token_here"SLEEP=100# Delay (ms) between requests - optional, default recommendedLONG_SLEEP=5000# Long delay (ms) every 500 requests - optional, default recommendedUsageAll operations are supported - see examples directoryfromrdapiimportRDRD=RD()print(RD.system.time().content)print(RD.user.get().json())print(RD.torrents.get(limit=10,page=1).json())importosfilepath='/path/to/bbb.torrent'print(RD.torrents.add_file(filepath=filepath).json())# etc...
Package: rdapy
rdapyRedistricting analytics in PythonThis repository (rdapy) re-implements
the main analytics used inDave's Redistricting,
ignoring a few DRA-specific aspects (in particular, the five [0-100] ratings).
Unlike the analytics used in the app (dra-analytics)
which are implememented in TypeScript, these are implemented in Python.CategoriesThe analytics are organized by area:Compactness: Various measures of compactnessEqual: Population deviationGraph: Checks for contiguity & embeddednessMinority: Minority opportunity metricsPartisan: Various measures of partisan bias & responsiveness, as well as support for rank-vote graphs and seats-votes curvesSplitting: County- & district-splitting and COI splittingThesamplesdirectory contains some simple examples of how to exercies these functions
and how to preprocess raw block-level data into the formats required by the analytics.InstallationpipinstallrdapyUsageimport rdapyEmail questions tofeedback.
Package: rdascore
rdascoreCompute Dave's Redistricting (DRA) analytics for an ensemble of redistricting plans.InstallationTo clone the repository:$gitclonehttps://github.com/alecramsay/rdascore
$cdrdascoreTo install the package:$pipinstallrdascoreAs noted next, you probably also want to clone the companionrdabaserepository.UsageThere are both code and script examples of how to use this code in thesampledirectory.
That directory also contains some sample results from the main scoring functionanalyze_plan().
The samples use data from the companionrdabaserepo.NotesWith four exceptions,analyze_plan()computes all the analytics that DRA does:For a variety of reasons, DRA's production TypeScript packagedra-analyticsdoes not calculate a few minor things that show up in the UI.
The Python portrdapydoes not either.
This repo uses the latter, so those few things also aren't in the "scorecard" output.To keep the results simple, district-level results are suppressed. The scorecard is a simple flat
dictionary of metric key/value pairs.To maximize throughput KIWYSI compactness is not calculated. The simple naive approach to performing
compactness calculations is to dissolve precinct shapes into district shapes, but dissolve is very
expensive operation. Analyzing a congressional plan for North Carolina take ~60 seconds. A much
faster approach is to convert precinct shapes into topologies using TopoJSON like DRA does and then
merging precincts into district shapes. That approach takes ~5 seconds, virtually all of the time
being calling TopoJSONmerge()from Python and marshalling the result back from JavaScript. I could
have chosen to implement a Python native version ofmerge(). Instead, I chose to skip KIWYSI
compactness (which requires actual district shapes) and just calculate the two main compactness
metrics in DRA: Reock and Polsby-Popper. Together these only depend on district area, perimeter, and
diameter, and with some pre-processing once per state (analogous to converting shapes into a topology)
these values can be imputed without ever creating the district shapes. The result is that analyzing
a congressional plan for North Carolina — calculatingallthe analytics — takes a small fraction
of a second.Finally, we've already created the precinct contiguity graphs as part of finding root map candidates
in mybaselineGitHub repo,
and we're also already using the graph in Todd'sensemblesrepo
to support generating spanning trees.
So, by definition, the plans in our ensembles are contiguous.
Hence, we don't check that.Testing$pytest--disable-warnings
Package: rdatasets
pyRdatasetspyRdatasets is a collection of 1300 datasets taken fromhttps://github.com/vincentarelbundock/Rdatasets.
The datasets were extracted from various R packages and stored as gzip packed pickle files in pandas DataFrame structure.
A description to each dataset can be found here:http://vincentarelbundock.github.io/Rdatasets/datasets.htmlThe package has a size around 25 Mb.Installationpip install rdatasetsUsage>>> from rdatasets import data
>>> dataset = data("iris")
>>> dataset
     Sepal.Length  Sepal.Width  Petal.Length  Petal.Width    Species
0             5.1          3.5           1.4          0.2     setosa
1             4.9          3.0           1.4          0.2     setosa
2             4.7          3.2           1.3          0.2     setosa
3             4.6          3.1           1.5          0.2     setosa
4             5.0          3.6           1.4          0.2     setosa
..            ...          ...           ...          ...        ...
145           6.7          3.0           5.2          2.3  virginica
146           6.3          2.5           5.0          1.9  virginica
147           6.5          3.0           5.2          2.0  virginica
148           6.2          3.4           5.4          2.3  virginica
149           5.9          3.0           5.1          1.8  virginica

[150 rows x 5 columns]
>>> data("forecast", "co2")
Could not read forecast/co2
Which item did you mean: ['gas', 'gold', 'taylor', 'wineind', 'woolyrnq']?
>>> data("forecast", "gas")
            time  value
0    1956.000000   1709
1    1956.083333   1646
2    1956.166667   1794
3    1956.250000   1878
4    1956.333333   2173
..           ...    ...
471  1995.250000  49013
472  1995.333333  56624
473  1995.416667  61739
474  1995.500000  66600
475  1995.583333  60054

[476 rows x 2 columns]The dataset description can be printed by:from rdatasets import data, descr
print(descr("iris"))A summary of all datasets is available as DataFrame object:from rdatasets import summary
summary()Thanks toThe archive of datasets distributed with R: ofhttps://github.com/vincentarelbundock/Rdatasets
Package: rdat-kit
RDATKit (RNA Dataset ToolKIT)RDATkitis a set of tools for parsing, analyzing, and publishing data of RNA chemical footprinting assays. It allows researchers to share their data using community standard formats, and helps them publish their results on indexable and shareable databases.RDATKitis a package provides a set ofPythonandMATLABscripts that facilitate saving and loading data to and from files withRDATformat. It also supports theISATABfile format.InstallationMATLABDownload the zip or tar file of the repository and unpack; orgitclonehttps://github.com/ribokit/RDATKit.gitInMATLAB, go to "Set Path". Then "Add with Subfolders" of the targetpath/to/RDATKit/MATLAB/.PythonTo installRDATKit, simply:pipinstallrdat_kitRDATKitrequires the followingPythonpackages as dependencies, all of which can be installed throughpip.numpy>=1.8.0scipy>=0.13.0xlrd>=0.9.2xlwt>=1.0.0DocumentationDocumentation is available athttps://ribokit.github.io/RDATKit/.LicenseCopyright © ofRDATKitSource Codeis described inLICENSE.md.Developed byDas lab,Leland Stanford Junior University.
Package: rdb2csv
rdb to csvThis is a tool to convert rdb to csv. rdb is the output file format by redis (http://redis.io/).
Use redis-rdb-tools (https://github.com/sripathikrishnan/redis-rdb-tools) for parsing rdb fileProgressredis-Strings(http://redis.io/commands#string) and redis-Hashes (http://redis.io/commands#hash) have been implemented.
Package: rdb2rdf
PyRDB2RDF providesRDFLibwith an interface to relational databases asRDFstores.  The underlying data is accessed viaSQLAlchemy.  It is
mapped to RDF according to the specifications ofRDB2RDF.  The
corresponding RDF graph is represented as an RDFLibgraph.Translating from relational data to RDF viadirect mappingis
currently supported.  Translating in the other direction and mapping
withR2RMLare planned but not yet implemented.Installationpipinstallrdb2rdfExamplesSerializing a database as N-TriplesSuppose the localPostgreSQLdatabasetest_dmcontains data that
we want to translate to RDF and serialize asN-Triples.  The following
code achieves that.importrdflibas_rdfimportsqlalchemyas_sqladb_str='postgresql://testuser:testpasswd@localhost/testdb'db=_sqla.create_engine(db_str)graph=_rdf.Graph('rdb2rdf_dm')graph.open(db)print(graph.serialize(format='nt'))Changelog0.1.2Updated references to Spruce projects (lang, iri, types) and Goose
Types.Improved the setup script.Improved documentation.0.1.1Added a missing installation dependency.0.1.0First public release.