Saravanan666/pypi-org huggingface dataset:
Package: relistats
Reliability engineering deals with estimating parameters or qualities of a product or
process or experiment. For simplicity, we assume that all units of a product or results
of an experiment are random variables. Collectively, let’s call them samples.
We assume that the samples are independent (one sample has no effect on another
sample) and identically distributed (the reliability or properties of underlying
random variable stay the same for each sample).ConceptsReliability is probability of success. The math assumes infinite number of samples,
but we can get access to only a finite number of samples. Therefore, we can compute
only an estimate of the actual reliability. Based on the number of samples, we
qualify the quality of this estimate usingconfidence.Confidence in reliability is probability that the actual reliability of the
population is at least the provided reliability level.
For example, we can say “If we see zero failures in 10 samples of a success-failure
experiment, we have 95% confidence that the reliability is at least about 74%”.Assurance simplifies reliability and confidence by setting both of them the same.
The result is just one number that is easier to communicate. For example, 90%
assurance means 90% reliability with 90% confidence. Given the number of samples
and number of failures, assurance is just one number.This library provides methods to calculate these statistics.Example usage in a python file:fromrelistats.binomialimportassurancen=22a=assurance(n,0)or0print(f"Assurance at{n}good samples:{a*100:.1f}%")SeePaper: S.M. Joshi, “Computation of Reliability Statistics for Success-Failure Experiments,”arXiv:2303.03167 [stat.ME], March 2023.Jupyter notebook showing how to use this library:relistats_notebookInteractive online version of the Jupyter notebook onGoogle Colab.Additional documentation:Usagefor installation and how to use.Backgroundfor concepts and mathematical background.CreditsThis package was created with Cookiecutter and thesourcery-ai/python-best-practices-cookiecutterproject template.
Package: reliure
Reliure: minimal framework for data processingreliureis a minimal and basic framework to manage pipeline of data
processing components in Python.DocumentationIn case your are not reading it yet, full documentation is available onReadTheDoc:http://reliure.readthedocs.orgInstallShould be simple as a pip command:$ pip install reliureLicensereliuresource code is available under theLGPL Version 3license, unless otherwise indicated.Requirementsreliureworks with both Python 2 and Python 3. it depends on:flaskfor web API mechanism,requestsfor API clients,graphvizfor engine schema generation,All this deps may be installed with:$ pip install -r requirements.txtTo develop reliure you will also need:py.testfor testingsphinxfor documenationDev dependances may be installed with:$ pip install -r requirements.dev.txtContributeThe following should create a pretty good development environment:$ git clone https://github.com/kodexlab/reliure.git
$ cd reliure
$ virtualenv ENV
$ source ENV/bin/activate
$ pip install -r requirements.txt
$ pip install -r requirements.dev.txtTo run tests:$ make testallTo build the doc:$ make docthen open:docs/_build/html/index.htmlWarningYou need to havereliureaccesible in the python path to run
tests (and to build doc). For that you can installreliureas a link in local virtualenv:$ pip install -e .(Note: this is indicadet inpytest good practice)If you dev, in the same time, an other package than need your last reliure version, you can use:$ pip install -e the_good_path/reliure  # link reliure in local python packages
Package: rellax
RellaxCommand Line Knowledge baseDescriptionCommand line driven knowledge base written in Python to aid and drive short term project focus. This tool is meant to aid in focusing and refocusing pentesting efforts. Imagine that you are on an engagement and wish to capture your iterative thought processes as you progress for later analsys and disection. This tool should be a subtle frictionless method for recording the internal monologue that will help show others and your self how you got from point A to B. I am attempting to avoid sqlite as a backend DB as all output from this exercise should be easily transportable to external documentation.Structure of stored dataThe below is a sample data store for a particular engagement filed called acme_engagement.json{
        "engagement" : "acme"
        "qna" : 
            [
                {
                    "question" : 
                        { "text" : "Is there a web presence for ACME?", 
                          "date" : "YYYYMMDD HH:MM:SS", 
                          "tags" : ["initial", "access", "permiter"]
                        }, 
                    "answers" : [
                            {"text" : "Yes there is a web site and a few api backends", 
                             "date" : "YYYYMMDD HH:MM:SS", 
                             "tags" : " ["web", "IIS"]}
                            {"text" : "There is also an email server", 
                             "date" : "YYYYMMDD HH:MM:SS"}
                        ]
                },
                {
                    "question" : 
                        { "text" : "Who administers the web server?",
                          "date" : "YYYYMMDD HH:MM:SS"
                        }, 
                },

            ]
    },As you can tell from the above json structure, the hope is to quickly write down a question to help quell the flow of endless inner thought and allow you to categorize and prioritize next steps. The hope is that you will be able to quickly list  previously asked questions and provide quick answers. Then once attempting to figure out what is left to do you can locate questions you asked of yourself and continue down through the rabbit hole.UsageWhen using this tool for the first time you will need to initialize the data storeusage: rellax.py init [-h]

Initialize json datastore

optional arguments:
  -h, --help  show this help message and exitOnce started you can then begin to create your knowledge base. Commands are fairly self explanatory. Add question, search for question, answer question..etc.usage: rellax.py [-h] {init,add,search,ans} ...

Command line Knowledgebase tracker

positional arguments:
  {init,add,search,ans}

optional arguments:
  -h, --help            show this help message and exit
Package: rellu
This project contains tooling and templates to ease creating releases
onGitHuband publishing them onPyPI. Designed to be used byRobot Frameworkand tools and libraries in its ecosystem, but can
naturally be used also by other projects.To be able to take this project into use, you should know at least
basics ofPython packaging.Main featuresUtilities that can be used by customInvoketasks. These utilities
are importable directly from therellu module:Setting project version, including automatically setting it to
the next suitable development version.Setting common labels in the issue tracker.Generating release notes based on issues in the tracker. Requires
project to use pre-defined labels.GenericInvoketasks in therellu.tasks module:Cleaning temporary files and directories.tasks.pyfile implementingInvoketasks using the aforementioned
utilities. Other projects can use it as an example or template.Step-by-step instructions for creating releases inBUILD.rstfile
usingInvoketasks defined in thetasks.pyfile, git, and other tools.
Also this file can be used as a template.setup.pyusing general good practices that can also be used as
a template. There’s also super simpleMANIFEST.in, but this project
doesn’t needsetup.cfg.DependenciesRellu is designed to be used together withInvokewhich is also used
internally. All project dependencies are listed in therequirements.txtandrequirements-build.txtfiles.Rellu itself works only with Python 3.6 or never, but projects it is used
with can naturally support also older Python releases. Rellu is developed and
tested on Linux, but ought to work just fine also on OSX. Using it on
Windows may work, but that’s not tested or supported.Required project setupTo be able to generate release notes automatically, issue trackers must
be configured using these rules:Milestones must match project versions and use formatv1.2orv1.2.1.Labels must be configured using the provided utility.Milestones and labels must be used consistently:Valid issues must have type defined as a labelbug,enhancementortask. Issues with the task type are not included in release notes.Issues should have priority set. See variousprio-labels.Issues belonging to a certain milestone should have that milestone set.Issues included into a certain preview releases should have a matching
label set (e.g.a1,b2,rc3).
Package: relnotegen
relnotegenOverviewrelnotegen is a Python-based tool designed to automate the process of generating and styling release notes for mobile applications. It extracts release information from markdown files stored in Azure DevOps wiki, formats this information into HTML using Jinja2 templates, and then applies Tailwind CSS for styling. The final HTML release notes can be uploaded to cloud storage or used in any other desired manner.FeaturesMarkdown to HTML: Converts markdown files from Azure DevOps wiki into HTML.Dynamic Styling: Uses Tailwind CSS to style the generated HTML release notes.Customizable Templates: Supports Jinja2 templates for HTML output, allowing for flexible and customizable formatting.Configurable: Easily configurable via a JSON file.Getting StartedPrerequisitesPython 3.6 or higherJinja2, markdown (Installable viapip)Access to Azure DevOps wiki markdown filesNode.js and npm (for Tailwind CSS)InstallationInstall the package via pip:$pipinstallrelnotegenConfigurationCreate therelnotegen.config.jsonfile to set your preferences. Here's an example (all fields are required):{"searchPath":"./mdown","template":"template.html","outputFile":"myapp-release-notes.html","templateParameters":{"pageTitle":"MyApp Release Notes","heading":"What's New","package":"Your App Name"}}UsageRun relnotegen:$relnotegenOutputThe script will generate an HTML file as specified in theoutputFileparameter.A corresponding CSS file (same name asoutputFile, but with.cssextension) will also be generated for styling.How It WorksCollect Markdown Files: Scans the specified directory for markdown files.Extract Release Info: Parses each markdown file for release data.Render HTML: Uses Jinja2 templates to format the extracted data into HTML.Generate CSS: Runs Tailwind CSS to style the HTML file.Only markdown files with the proper "frontmatter" are collected. The frontmatter starts and ends with three dashes. Here's an example (both fields are required):---
release-date: 2023-10-29version: 2.0.8---We worked hard to bring you the following updates:## Improvements <span class="ios"/><span class="android"/>-You can now order peperoni pizza-We removed pineapple as possible pizza toppings## Bug Fixes <span class="ios"/>-Fixed a crash issue when ordering more than 100 pizza'sCustomizationHTML Template: Modifytemplate.htmlto change the structure of the output HTML.CSS Styling: Edittemplate.cssto customize styles. Run Tailwind CSS to compile these styles into the final CSS.LicenseThis project is licensed under the MIT License.
Package: reloadable
ReloadableReruns a function upon failureUsageReloadableThe functionmy_funcwill run indefinitely until it stops raising exceptions,
which will never happen in this case.fromreloadableimportreloadable@reloadable()defmy_func():raiseException('Oops')This module is useful when we want to run something forever, like a code
that connects to a queue en fetches messages. Eventually it may disconnect and
raise an error trying to fetch a message, so reloadable can retry connecting.@reloadable()defget_message():conn=Queue(host='...',password='...')whileTrue:message=conn.fetch_message()# probably process message afterwards...You can config a callback function that receives an exception, which will be
called if it occurs.defshit_happens(exception):logger.exception(exception)@reloadable(exception_callback=shit_happens)defdont_stop():raiseException('Deal with it')You can also wait some time before the next respawn@reloadable(sleep_time=7)# wait 7 seconds before running `get_message` after a failuredefget_message():# some code...You can always stop reloadable with aKeyboardInterruptexception
(usually triggered by^C, but not necessarily).Another option is to configure the stop condition exception.@reloadable(stop_condition_exception=ValueError)defi_will_stop():raiseValueError('something went wrong')Or you can define it globally, which will be used if local stop condition wasn’t definedfromreloadableimportreloadable,configureconfigure(stop_condition_exception=KeyError)@reloadable()defi_will_stop():raiseKeyError('...')You may also want to limit the number of times that the decorator should try
rerun the function. If the function is calledmax_reloadstimes without a
success, it raises the last error.fromreloadableimportreloadable@reloadable(max_reloads=2)defa_func():raiseKeyError('...')Alternatively you can disable the reloadable decorator via configuration,
which is useful during unittests.fromreloadableimportconfigure,reloadableconfigure(enabled=False)@reloadable()# When disabled, it does nothingdefi_am_free():return'\o/'Retry on ErrorThe@retry_on_errordecorator is useful when you want to retry something on
error, but return the result once the decorated function finishes it’s
execution with success.importrequestsfromreloadable.decoratorsimportretry_on_error@retry_on_error(max_reloads=3)defmy_request():response=requests.get("https://www.sieve.com.br")# raises an error for 4xx and 5xx status codesresponse.raise_for_status()returnresponse.contentTestspython-munittest-vtestsInstallationpip install reloadable
Package: reloadcmd
=========reloadcmd=========Re-executes program when files are changed, moved or deletedUsage=====usage: monitor [-h] [-d DEBUG] [-p PATH] [-e [FILE_EXT [FILE_EXT ...]]] -cCOMMANDRestarts process when any files / directory changesoptional arguments:-h, --help            show this help message and exit-d DEBUG, --debug DEBUGDebug mode-p PATH, --path PATH  Which directory to watch for changes-e [FILE_EXT [FILE_EXT ...]], --extension [FILE_EXT [FILE_EXT ...]]Which file extensions to listen for-c COMMAND, --command COMMANDCommand to be executed``$ reloadcmd --command "while [ 1 -eq 1 ]; do echo 2; sleep 1; done"``Dependencies============* `watchdog <https://pypi.python.org/pypi/watchdog>`* `coloredlogs <https://pypi.python.org/pypi/coloredlogs>`
Package: reloader-cli
reloader-cliHelp in fine tuning your changes with this minimalist CLI tool that reloads your python script after every save.InstallationInstall reloader-cli with pippipinstallreloader-cliUsage/ExamplesTo use this tool, simply install it via pip and runreloader[my_app.py][main]By default this tool targets the run() function inside your app.py script.Running TestsTo run tests and see code coverage, run the following command:coveragerun-mpytest&&coveragereport-mOr if only to run tests, run:pytestKeep in mind the following modules are required for running these commands:coverage
  pytestLicenseTo view the license for using this tool, visit this link here:MITAuthors@Aman Ahmed SiddiquiSupport and SuggestionsFor any type of related support or you have some suggestions in mind, email me ataasiddiqui40@gmail.com.DebuggingFor debugging this tool, search for 'debugging' inside the file, and follow the instructions in the comments.
Package: reloadex
reloadexRestart wsgi server on Python code changes. Works on Windows and Linux.Installation and usageInstall:pipinstallreloadexInstall from git:pipinstallhttps://github.com/iljau/reloadex/archive/master.zip#egg=reloadexGiven exampleFlaskapplication.fromflaskimportFlaskapp=Flask(__name__)@app.route('/')defhello_world():return'Hello, World!'defmain():app.run()if__name__=="__main__":main()To run this app with reloader specify module name, filename or command. Following invocations are supported:reloadexmy_app.py
reloadexmy_app.py:main
reloadexmy_app:main
reloadex--cmd"python my_app.py"reloadex--cmdpythonmy_app.py
reloadex--uwsgi"uwsgi --http :9090 --lazy-apps --enable-threads --master --workers 1 --wsgi-file app_flask.py"Using python module invocation also works:python-mreloadexmy_app.pyReloader uses current working directory as root: there it looks for.reloadignoreand recursively watches all subdirectories.
If.reloadignoreis not found, reloads happen on*.pyfile changes.Getting source for local developmentgitclonegit@github.com:iljau/reloadex.gitcdreloadex
pipinstall-e.
Package: reloadium
DetailsReloadium adds hot reloading, profiling and AI features to your IDEInstallingIf you are a PyCharm user please check outReloadium pluginPlugins for other IDEs are coming soon.Reloadium can be also used as a standalone library by installing it manually with pip:pip install reloadiumUsingRunning python files:reloadium run example.pyRunning modules:reloadium run -m my_moduleTo apply your changes simply save a fileAIReloadium integrates with ChatGpt seamlessly providing additional context to your conversations resulting in much better replies.General Python FeaturesWhen altered, Reloadium will execute the current function again, providing developers with immediate feedback on the functionality of their code.Reloadium manages errors that occur while reloading functions, allowing you to correct any mistakes seamlessly.Reloadium has the ability to refresh files throughout the entire project by tracking dependencies.DjangoUpon saving, Reloadium performs hot reloading of views and automatically refreshes the page.To avoid generating undesired objects after reloading the current function, Reloadium reverts any database modifications.FlaskReloadium hot reloads Flask apps and automatically refreshes the page upon saving.This enables real-time content updates, significantly streamlining web development.SqlAlchemyReloadium will rollback database changes to prevent creating unwanted objects after reloading current function.PandasReloadium facilitates hot reloading of Pandas objects, making the manipulation of intricate dataframes for data science remarkably simple.
Package: reloadly-auth
Authentication APIThe implementation is based on theAuthentication API Docs.UsageCreate anAuthenticationAPIinstance by providing the Application credentials details (client id & secret) from
thedashboard.fromauthentication.client.AuthenticationAPIimportAuthenticationAPIfromcore.enums.ServiceimportServicesample=AuthenticationAPI()a=sample.clientCredentials(clientId="*****",clientSecret="*****"service=Service.AIRTIME_SANDBOX).getAccessToken(Service.AIRTIME_SANDBOX)print(a)
Package: reloc
RelocFeaturesServes as a simple file transfer service between client and server. Initially designed for easy transfer of files to single-board computers, such as the Raspberry Pi.Can be used both locally on the network or externally over the internet.Reloc can be used as a command-line application for easier transfer of files from the command prompt.Installation$pip3installrelocUsageServer-sideStart server where you want to receive files. If no path is specified the home folder is used. Two modes of the server can be used; internal or external. By using the internal mode, only connection over the local network is possible. By using external mode, connection to the server can be made over the internet if the specified port is open in the network.importreloc# Starting server to handle external connections, i.e. over the internet.server=reloc.server(mode='external',port=1750,def_path='/users/antonnormelius/documents')# Start listening for incoming data stream.server.receive()Client-sideClient is used to transfer files and folders to server. Observe that
the host and port for the client need to be the same as the host and port
for the server.importreloc# Connecting to external server.client=reloc.client(host='92.34.13.274',port=1750)# Sending a text file.filename='test.txt'client.transmit(filename)# Sending a folder.foldername='test'client.transmit(foldername)# Disconnect from the client.client.disconnect()Command-Line ApplicationReloc can be used as a command-line application in order to transfer files to the server
using the command prompt, i.e. terminal.Transfer of files/folders.# Send file internally.$relocsendfile.txt# Send folder internally.$relocsendfoldername# Send file externally.$relocsendfile.txt--host92.34.13.274--port1750# Send folder externally.$relocsendfoldername--host92.34.13.274--port1750Start server both internally and externally.# Start internal server, i.e. using localhost and predefined port.$relocstartinternal# Start external server. Observe that port needs to be specified.$relocstartexternal1750# Start external server on predefined host and port.$relocstartexternal1750--host192.168.1.10Releases0.0.4 - Major updates to how the CLI works.0.0.3 - Initial stable release.LicenseMIT
Package: relocate
RelocateDo you want to organise your files?ThenRelocateis here to help you. It will organise your files as per your requirement.Install the module from your command prompt.pip install relocateTo import the RELOCATE package, run the following.import relocateNow you can group your files, based on the following options.relocate.relocateNow()It will organise your files in separate folders, according to month of last modification and then according to extension.relocate.byMonthCreated()It will organise your files in separate folders, according to month of creation (for Windows) or according to month of last metadata change (for Unix).relocate.byYearCreated()It will organise your files in separate folders, according to year of creation.relocate.byMonthModified()It will organise your files in separate folders, according to month of last modification.relocate.byYearModified()It will organise your files in separate folders, according to year of last modification.relocate.byMonthLastAccessed()It will organise your files in separate folders, according to month of last access.relocate.byYearLastAccessed()It will organise your files in separate folders, according to year of last access.relocate.byExtension()It will organise your files in separate folders, according to file extension.relocate.bySize()It will organise your files in separate folders, according to file size.relocate.byFirstChar()It will organise your files in separate folders, according to first character of file name.Navigate to the RELOCATED folder,  and you will get your files in an organised manner.Do you want to undo the changes?Then navigate to RELOCATE folder, and run the following.relocate.undo()It will undo the changes. You will get all your files in this RELOCATED folder.For any queries, contact me onLinkedInChangelog:Version 2.1.0Addedrelocate.undo()Version 2.0.0Addedrelocate.byMonthCreated()Addedrelocate.byYearCreated()Addedrelocate.byMonthModified()Addedrelocate.byYearModified()Addedrelocate.byMonthLastAccessed()Addedrelocate.byYearLastAccessed()Addedrelocate.byExtension()Addedrelocate.bySize()Addedrelocate.byFirstChar()Version 1.3.1 , 1.3.0 , 1.2.0Addedrelocate.relocateNow()Bug Fixed
Package: reloci
relociThis can be used to reorganise photos into directories by date.UsageThis is a command line utility to copy or move files from one location
to another location using the metadata in the files to order them
into logical directories.$ reloci current/path/to/files path/to/destinationTo see all options use$ reloci --helpCurrently the files will be ordered based on the creation date of the
files. Use thedryrunoption to check if the planned move/copy matches
your expectations.Additionally there is a second command to view all relevant EXIF tags from a
single file, and how they are interpreted by the FileInfo class.$ reloci_info path/to/a/file.jpgInstallationIf desired create a virtual environment then install this package from PyPIpip install relociSetup for developmentCreate a new virtual env with Python 3.11 and install the requirements:conda create -n reloci python=3.11 --yes
pip install -e .[test]