Saravanan666/pypi-org huggingface dataset:
Package: rfc7539
AboutRFC7539is an IETF specification for an authenticated encryption algorithm that will be
incorporated into TLSv1.3. It is comprised of a stream cipher (ChaCha20) and a MAC (Poly1305), both
written by Daniel J. Bernstein. The C implementations for both of these primitives are taken from
the NSS library (the reason being that openSSL has license incompatibilities and also requires the
openSSL headers which is more overhead than we need to implement these fairly basic primitives).
The NSS code has been slightly modified to account for the 96 bit nonce and 32 bit counter
specified in the RFC.InstallationMethod 1pipinstallrfc7539Method 2gitclonehttps://github.com/AntonKueltz/rfc7539.gitcdrfc7539pythonsetup.pyinstallBasic APIaead.encrypt_and_tagTakes a key, nonce, plaintext and additional data and returns a ciphertext and MAC.defencrypt_and_tag(key:bytes,nonce:bytes,plaintext:bytes,aad:bytes)->(bytes,bytes)aead.verify_and_decryptTakes a key, nonce, ciphertext, MAC and additional data and returns a plaintext.defverify_and_decrypt(key:bytes,nonce:bytes,ciphertext:bytes,mac:bytes,aad:bytes)->bytesExample UsageYou should use the authenticated encryption mode unless you really need to use one of the primitives
by itself:fromrfc7539importaeadfromosimporturandomkey=urandom(32)# key is 32 bytesnonce=b'thisisanonce'# nonce is 12 bytes (DO NOT REUSE A NONCE WITH THE SAME KEY)message=b'Some message to be encrypted'additional_data=b'Some additional data'# this will not be encrypted but will be verified for integrity# encryptionciphertext,mac=aead.encrypt_and_tag(key,nonce,message,additional_data)# decryption (which yields plaintext == message)plaintext=aead.verify_and_decrypt(key,nonce,ciphertext,mac,additional_data)Note that all operations in this package work on bytes. You’ll need to call e.g.encode()on strings
before passing them as arguments.
Package: rfc7748
rfc7748 (Elliptic Curves for Security)A pure Python implemention of rfc7748.Usage:# this code supports both python 2 and 3frombinasciiimporthexlifyfromrfc7748importx25519private_key=b'1'*32public_key=x25519.scalar_base_mult(private_key)print(hexlify(public_key))peer_public_key=b'2'*32shared_secret=x25519.scalar_mult(private_key,peer_public_key)print(hexlify(shared_secret))'''output:b'04f5f29162c31a8defa18e6e742224ee806fc1718a278be859ba5620402b8f3a'b'a6d830c3561f210fc006c77768369af0f5b3e3e502e74bd3e80991d7cb7bfa50''''
Package: rf-captchalibrary
CaptchaLibraryLibrary Scope:GLOBALCreated:23/09/2019 15:58 UTC-8Author:Joshua Kim Rivera | email:joshua.rivera@mnltechnology.comCompany:Spiralworks Technologies Inc.Contents:CaptchaLibraryContentsIntroductionInstallationUsageGenerating DocumentationDependenciesIntroductionCaptchaLibraryis aRobotframeworkTest Library for decoding Captchas.View the latest keywordDocumentation here.InstallationOption 1Install using pypi, run:pipinstallrf-captchalibraryOption 2With recent version ofpip, it is possible to install directly from GitHub repository. To Install latest source
from the master branch, use this command:pipinstallgit+https://github.com/MainSystemDev/rf-captchalibrary.gitPlease note that installation will take some time, becausepipwill
clone theCaptchaLibraryproject to a temporary directory and then
perform the installation.UsageTo use CaptchaLibrary in Robot Framework tests, the library needs to
first be imported using theLibrarysetting as any other library.
It is important to Note that CaptchaLibrary requires the serviceUrl as parameter
upon import, see example below.*** Settings ***DocumentationSimple example using CaptchaLibraryLibraryCaptchaLibraryserviceUrl=sample.captcha.service.url*** Variables ***${sample_variable}*** Test Cases ***Test Case Sample One${captcha}Decode Base64 Captchapath/to/imageLog To Console${captcha}Generating DocumentationTo Generate the keyword Documentation, simple run:python-mrobot.libdocCaptchaLibrarydocumentation.htmlNote that the library must first be installed before generating a documentation.DependenciesRequestsPillow
Package: rfc-cli
rfc-cliA command line viewer for RFCsInstallationInstall with pip using any of these commandspipinstallrfc# Generalpip3installrfc# Mostly MacOS/Linuxpython-mpipinstallrfc# Generalpython3-mpipinstallrfc# Mostly MacOS/Linuxpy-mpipinstallrfc# WindowsUsagerfcshow2822# Read the RFC 2822rfcshowdraft-ietf-core-coap-18# Read IETF draft core-coap version 18
Package: rfcctl
rfcctl: RFC like document manager&cop; 2023 SiLeader.How to use1. Add contextAdd context to usecontext addsubcommand.rfcctlcontextadd--name<CONTEXT_NAME>--user<USERNAME>/path/to/directory--nameis context name alias--useris writer username--switchoption is switch this context as default context--initial-statusis RFC's initial status. default is Draft--obsoleted-statusis obsoleted RFC's status. default is Obsoleted--initoption is createskeleton.mdin this directory2. Create new RFCCreate new RFC file fromskeleton.mdto usecreatesubcommand.rfcctlcreate--category-tree<CATEGORY><SUBCATEGORYinCATEGORY>...--title'My new RFC'3. Update RFC metadataUpdate RFC's obsoleted metadata to useupdatesubcommand.rfcctlupdateLicenseApache License 2.0See LICENSE
Package: rfcdl
rfcdlAlways keep a copy of your favoriteRFCs.rfcdl lets you download and synchronize RCFs in high-speed.🚀 InstallationFrom PyPIpipinstallrfcdlFrom Source./setup.pyinstallFedorasudodnfcoprenableeikendev/rfcdl
sudodnfinstallpython3-rfcdl📄 UsageThis tool can be used to download a large number ofRFC documentsin a short period of time.
I used it to keep a local mirror of all RFCs on my machines continuously synchronized.For a quick introduction, let me show how you would use the tool to get started.This is how you download the RFCs initially.rfcdl-d~/download/rfc/As can be seen above, you have to specify a directory where all RFC documents will be saved in.
Upon the next invocation ofrfcdl, only the RFCs missing in that directory will be downloaded.This can then be combined with an alias that lets you read the local copy of any RFC.
The following command opens the RFC 8032 for me in less.rfc8032Check outmy dotfilesto see how this is implemented.ArgumentsIf you only want to download a random subset of all RFCs, use the--samplesflag.
This can be used for testing.
For instance, the following will download 20 random RFC documents.rfcdl-d~/download/rfc/--samples20Sincerfcdldownloads multiple files in parallel by default, one can specify how many simultaneous downloads are allowed using the--limitflag.
The following invocation will only download at most ten files in parallel.rfcdl-d~/download/rfc/--limit10To explicitly state how many timesrfcdlshould download a file upon error, the--retriesflag can be used.
This can be useful in case one expects a bad connection.
This is how you could tell the tool to try to download each file at maximum five times.rfcdl-d~/download/rfc/--retries5⚙ ConfigurationA configuration file can be saved to~/.config/rfcdl/config.inito avoid specifying the path for each invocation.
Of course,$XDG_CONFIG_HOMEcan be set to change your configuration path.
Alternatively, the path to the configuration file can be set via the--config-fileargument.[GENERAL]RootDir=~/download/rfc/💻 DevelopmentThe source code is located onGitHub.
To check out the repository, the following command can be used.gitclonehttps://github.com/eikendev/rfcdl.git
Package: rfc-generator
RFC GeneratorA package used to generate rfc for PF and PM given input information.How to useAfter installing the package use following import:from rfc_generator import RFC_PF, RFC_PMThen use following commands:rfc_pf = RFC_PF(nombres='firstname and/or secondname',apellido_paterno='paternal_last_name',apellido_materno='maternal_last_name', [Optional]fecha_nacimiento='birthdate' [format='YYYY-MM-DD'])rfc = rfc_pf.generate()Or:rfc_pm = RFC_PM(nombre_empresa='company name',fecha_constitucion='foundation date' [format='YYYY-MM-DD'])rfc = rfc_pm.generate()
Package: rfcmirror
This package contains script to mirror RFC index and full text to local
directory, and to create a full text search based on whoosh module to
search the contents of RFCs.ConfigurationThe code reads two different configuration paths, home directory configuration
overriding the system wide configuration:/etc/rfcmirror.conf
$HOME/.rfcmirror.confThe configuration file can contain following settings:pager = Pager program used to read RFC, defaults to more
cachedir = Path to local RFC cache, defaults to /var/db/rfc
index_url = URL to RFC index, defaulthttp://www.ietf.org/download/rfc-index.txtindex_name = RFC index filename, default rfc-index.txt
rfc_base_url = Base download URL for RFC downloads, default ttp://www.ietf.org/rfc/
skipped = Defaults to RFCs to skip, default 8,9,51,418,530,598Usually it’s enough to simply add cachedir if you want to run the program with
files in your home directory.Commandsrfc-cache-update -uv
- Imports and parses the rfc-index.txt
- Downloads any missing and not skipped RFC texts
- Updates whoosh cache with the contents of the rfcrfc <number>
- Shows RFC with given numberrfc <text>
- Shows RFCs matching the text in rfc description
rfc -b <text>
- Shows RFCs matching the text in rfc description and body
Package: rfcnt
rfcnta rainflow counting algorithm Python package"Rainflow Counting" consists of four main steps:Hysteresis FilteringPeak-Valley FilteringDiscretizationFour Point Counting Method:* D  
           / \       Closed, if min(B,C) >= min(A,D) && max(B,C) <= max(A,D)  
    B *<--/          Slope B-C is counted and removed from residue  
     / \ /  
    /   * C  
 \ /  
  * AThese steps are fully documented in standards such asASTM E1049 "Standard Practices for Cycle Counting in Fatigue Analysis" [1]This implementation uses the 4-point algorithm mentioned in [3,4] and the 3-point HCM method proposed in [2] as well as the ASTM E 1049 (2011) standard in [1].
To take the residue into account, you may implement a custom method or use some
predefined functions.Installpip install {packagename}.tar.gz --no-build-isolation --no-depswhere{packagename}is the current package release, for example:pip install rfcnt-0.4.6.tar.gz --no-build-isolation --no-depsTestrfcntpackages include some unit tests, which can be run:python -m rfcnt.run_testsExamplesFor a quick introduction you can run and inspect a small example:python -m rfcnt.run_examplesReferences:[1] "Standard Practices for Cycle Counting in Fatigue Analysis."ASTM Standard E 1049, 1985 (2011).
West Conshohocken, PA: ASTM International, 2011.[2] "Rainflow - HCM / Ein Hysteresisschleifen-Zaehlalgorithmus auf werkstoffmechanischer Grundlage"U.H. Clormann, T. Seeger1985 TU Darmstadt, Fachgebiet Werkstoffmechanik[3] "Zaehlverfahren zur Bildung von Kollektiven und Matrizen aus Zeitfunktionen"FVA-Richtlinie, 2010.[https://fva-net.de/fileadmin/content/Richtlinien/FVA-Richtlinie_Zaehlverfahren_2010.pdf][4] Siemens Product Lifecycle Management Software Inc., 2018.[https://community.plm.automation.siemens.com/t5/Testing-Knowledge-Base/Rainflow-Counting/ta-p/383093]
Package: rfcommands
RF CommandsRF Commands is a set of tools used byRiboFlowpipeline to
compile alignment statistics, deduplicate, etc.InstallationPippip install rfcommandsGithubYou can install the latest version from github:pip install git+https://github.com/ribosomeprofiling/rfcommands.gitDocumentationAvailable inReadthedocsUsagerfc <command> [arguments]For help:rfc --help
Package: rfconv
RFConvRectified ConvolutionPretrained ModelmodelbaselinerectifiedResNet-5076.6677.10ResNet-10178.1378.74ResNeXt-50_32x4d78.1778.48ResNeSt-50_2s8x78.7379.38Verify Models:Prepare ImageNet dataset:cdscripts/dataset/# assuming you have downloaded the dataset in the current folderpythonprepare_imagenet.py--download-dir./Test Model# use resnest50 as an examplecdscripts/
pythonverify.py--modelresnet50--crop-size224
Package: rf-counterfactuals
Random forest counterfactualsThe RFC is a library specialised to be use in the domain of Explainable Artificial Intelligence (XAI).
It allows to search for an explanation for pretrained Random Forest Classifier model (from scikit-learn library) in the form of counterfactual examples.
The library also allow to specify constraints (frozen attribute, monotonnicity) for attributes in the specified dataset.
An algorithm is an extended version of Gabriele Tolomei et al. algorithm (link to github).An extended version has:multiclass classification problem's explainability,gives new methods of selecting counterfactual examples,provides new distance functions (specially HOEM)it is optimized to provide explanation as fast as possible with multiprocessing calculationThis work is done for purpose of my master's thesis.InstallationThis package was tested on Windows 10 and Ubuntu 20.04 platforms.To install package:pip install rf_counterfactualsManual installation (for developers)To run unittests:cd tests
python -m pytestTo build up a pywheel file:python setup.py bdist_wheeSimple example on iris datasetfrom rf_counterfactuals import RandomForestExplainer, visualize

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

### Load iris dataset as Pandas Dataframe (other formats aren't supported yet) and split. Then train RF classifier on it
X, y = load_iris(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67, random_state=420, stratify=y)
rf = RandomForestClassifier()
rf.fit(X_train, y_train)

### Make an RandomForestExplainer object with input of: RandomForest model, training data
rfe = RandomForestExplainer(rf, X_train, y_train)

### Look for counterfactual examples (max/limit 1) in test data, which lead to change label's value from '0'('setosa') to '2'('virginica')
### Counterfactual examples are selected based on 'hoem' metric's value
X_test_label_0 = X_test[y_test==0]
counterfactuals = rfe.explain_with_single_metric(X_test_label_0, 2, metric='hoem', limit=1)

### Visualize an example row (row_no = 0) of data with its counterfactual
row_index_to_visualize = 0

row = X_test_label_0.iloc[row_index_to_visualize]

# First counterfactual found for row 0th
cf = counterfactuals[row_index_to_visualize].iloc[0]

print(f"row label: {rf.predict(row.to_frame(0).T)[0]} |\t cf label: {rf.predict(cf.to_frame(0).T)[0]}")
print(visualize(rfe, row, cf))output (it may vary because of used random seed to split dataset):row label: 0 |	 cf label: 2
                     X     X'  difference constraints
sepal length (cm)  5.8  6.333       0.533            
sepal width (cm)   4.0  4.000       0.000            
petal length (cm)  1.2  5.076       3.876            
petal width (cm)   0.2  0.200       0.000AuthorMaciej Leszczyk, Poznan University of Technologymaciej.leszczyk98(at)gmail.com
Package: rfcparser
RfcparserRfcparser is a Python tool that makes it easy to parse common RFC syntaxes. Rfcparser takes a raw string as input, parses, validates, and returns Python objects to simplify the processing of RFC syntaxes.Installing$ pip install rfcparseror$ git clone https://github.com/karosis88/rfcparser.git
$ pip install ./rfcparserUsageExamples and detailed instructions on how to use the Rfcparser library to parse RFC syntaxes.In most cases, you will primarily use the 'core' module, which offers a convenient interface for parsing your raw input string>>>fromrfcparserimportcoreRfcparser offers a specific class for each grammar, with a class name following the pattern of "PREFIX PARSER RFC-NUMBER"Fortunately, most modern IDEs now offer autocompletion, which will assist you in locating the parser classes you need to use.URI parsing>>>uri="https://login:password@127.0.0.1:1010/path?name=test#fr">>>parsed_uri=core.UriParser3986().parse(uri)With Rfcparser, you now have access to a 'parsed_uri' that is not just a plain string, but rather a Python object. This makes it easier to work with the URI, and you don't need to worry about compatibility issues with other applications as the library parses syntaxes according to the latest RFC standards.>>>parsed_uri.scheme'https'>>>parsed_uri.userinfo'login:password'>>>parsed_uri.ip'127.0.0.1'>>>parsed_uri.port1010>>>parsed_uri.path'/path'>>>parsed_uri.query{'name':'test'}>>>parsed_uri.fragment'fr'Date-Time parser>>>date_str="Tue, 07-Feb-2023 13:20:04 GMT">>>parsed_date=core.DateParser6265().parse(date_str)>>>type(parsed_date)<class'datetime.datetime'>>>>parsed_date.day7
Package: rfc_reader
# rfc_readerThe CLI RFC reader :- Open any published RFC with your favorite program- Quickly search through RFC summaries with `rfc -k <keyword>`- Full offline access `~/.rfc/`## Installation :Either clone the repo and run```shellpython setup.py install```or simply use pip :```shellpip install rfc_reader```## Usage :Type `rfc -h` or `rfc --help` to invoke the following help :```shellusage: rfc [-h] [--update] [--pager PAGER] [-k KEYWORD] [--version][RFC_NUMBER]rfc is the python RFC reader. It stores a local copy of all the RFC documentsand allows one to search a read through them.For more info and contact : Seehttps://github.com/monsieurh/rfc_readerpositional arguments:RFC_NUMBER            Opens the RFC_NUMBER for readingoptional arguments:-h, --help            show this help message and exit--update              Updates the local copy of RFC documents with thelatest (weekly) publication of the IETF--pager PAGER, -p PAGERUses the given program to open RFC documents. Defaultprogram is env var $PAGER or `less` if not found-k KEYWORD, --keyword KEYWORDPrints the summary of all known RFC documents matchingthe keyword and exits--version             show program's version number and exitReleased under GPLv3```## Behavior :rfc_reader will download and/or update all RFC txt documents from [rfc-editor-website](https://www.rfc-editor.org/) and store them in `~/.rfc/`.## Examples :`rfc 2119` opens the Key words RFC in the default `$PAGER` program (usually `less`)`rfc -p gedit 2119` opens the same document in gedit`rfc -k UDP` outputs the summary of all RFC documents including the word 'UDP'## History :- 1.0 :- adds XDG compliant storage path ([MartijnBraam](https://github.com/MartijnBraam))- doesn't show ugly `^L` characters with default pager ([objectified](https://github.com/objectified))- v0.9 :- bugfix- v0.8 :- `-k` is now case insensitive- Now compatible with python2 ([joshfriend](https://github.com/joshfriend))- v0.7 :- Fixes `-k` ordering by RFC number## Running tests :Simply use `python2 -m unittest discover -v` or `python3 -m unittest discover -v`
Package: rfcs
The complete command-line tool for searching and viewing RFCs. It provides a
convenient interface for the API provided byIETFrfcs provides four major subcommands:rfcs search QUERY- Search for RFCs matching a particular query.rfcs info RFC- Get information on a particular RFC.rfcs text RFC- View the RFC’s text.rfcs url RFC--formatFMT- Get a url to view the RFC, in a format
of{text, html, pdf, bibtex}.Installationpipinstallrfcs
Package: rfc-tidy
rfc-tidyA simple tool that cleans up RFC XML.UsageInstall from pypi with:pipinstall--userrfc-tidyLikeblack,rfc-tidycannot be tuned.  Feed XML intostdin, get XML
fromstdout(it also accepts the input file as the first argument).rfc-tidy<draft-blah-blah-blah.xml>draft-tidied.xmlFeaturesAdds<bcp14>tags for your "MUST", "SHOULD", and "MAY" statements in text.Removes extraneous XML, comments, and whitespace.Indents elements consistently.Replaces non-ASCII characters in text with XML numeric entities so that you
don't miss them.Sorts attributes by name.
Package: rfctools-common
RFC Editor Tools Utility CodeThis module contains a set of utility functions used by some of the RFC Editor tools.
Long term, the goal is to incorperate these functions back into xml2rfc but having it
separate allows for an easier modification of the functions as needed.ChangelogVersion 0.6.1 (Fri 24 Jan)Remove module six from the setupVersion 0.6.0 (Fri 10 Oct)Update to the latest set of schema filesUpdate the entity definition file with more valuesVersion 0.5.17 (Fri 16 Aug)Remove Python 3.4 from the supported liste
Package: rfc-xmldiff
Create a difference on two RFC XML filesThis program takes two XML files containing SVG or RFC documents and creates an HTML
file which shows the differences between the two documents.TheRFC Editoris in the process of changing the canonical input format ofInternet-DraftandRFCdocuments.  Further information on the process can be found
on the RFC Editor at theRFC Editorsite.Usagerfc-xmldiff accepts a pair of XML documents as input and outputs an HTML document.Basic Usage:rfc-xmldiff[options] SOURCE1 SOURCE2OptionsThe following parameters affect how rfc-xmldiff behaves, however none are required.ShortLongDescription-C--clear-cachepurge the cache and exit-h--helpshow the help message and exit-N--no-networkdon’t use the network to resolve references-q--quietdon’t print anything-r--rawdon’t use the xml2rfc vocabulary when matching-v--verboseprint extra information-V--versiondisplay the version number and exit-X--no-xincludedon’t resolve xi:include elements-oFILENAME--out=FILENAMEspecify an output filename-tFILENAME--template=FILENAMEspecify HTML template filename-D--no-defaultsdon’t load attribute defaults from the dtd.--resource-url=URLspecify the URL for resources in the templateTemplatesTwo template files are installed with the package:single.html - provides just the XML difference between the two files.base.html - provides three columns containing the left source files, the XML difference and the right source files.   Uses color to highlight changes. This is the default template.wdiff.html - provides three columns containing the left source files, the XML difference and the right source files.  Uses color and strike throughs to highlight changes.For new template files, the following variables are define:title - provides a default window titlebody - contains the XML difference HTMLleftSourceNames - the list of all input files for the left sourcesleftFile - contains the left source filesrigthSourceNames - the list of all input files for the right sourcesrightFile - contains the right source filesresource_dir - contains the URL to find the resources.  This defaults to the Template directory of the package.allScript - contains the contents of resize.js so the resulting html file is self contained.Dependenciesrfc-xmldiff depends on the following packages:lxml(>= 4.1.1)requests(>= 2.5.0)rfctools_common(>= 0.5.10)cffi(>= 1.0.0)ChangelogVersion 0.5.19 (Thur 29 Aug)Change source repositoryVersion 0.5.18 (Fri 16 Aug)Fix error building paragraphs with ‘li’Fix error in JavaScriptRemove Python 3.4 from the supported listCorrect problem with writing unicode on Python 2.7Version 0.5.18 (Fri 16 Aug)Fix error building paragraphs with ‘li’Fix error in JavaScriptRemove Python 3.4 from the supported listCorrect problem with writing unicode on Python 2.7