Saravanan666/pypi-org huggingface dataset:
Package: reqdriver
reqdriverA Python package that seamlessly transfers arequests.Sessionto a Selenium WebDriver, maintaining session cookies and proxy settings. Ideal for web scraping and automated browsing with pre-established session states.FeaturesTransfer Session Cookies: Easily transfer cookies from arequests.Sessionto a Selenium WebDriver.Proxy Integration: Set up a Chrome WebDriver with the same proxy settings as yourrequests.Session.Flexible WebDriver Management: Use an existing WebDriver instance or let reqdriver create one for you.Custom WebDriver Options: Customize your WebDriver with additional options.InstallationpipinstallreqdriverUsageBasic UsageImport theRequestsDriverclass from thereqdriverpackage:fromreqdriverimportRequestsDriverimportrequestsTransferring CookiesTransfer cookies from arequests.Session:session=requests.Session()session.cookies.set('test_cookie','12345',domain='example.com')req_driver=RequestsDriver(session)req_driver.set_cookies('http://example.com')driver=req_driver.get_driver()driver.get('http://example.com')Setting ProxiesSet up a WebDriver with the same proxy settings as yourrequests.Session:session=requests.Session()session.proxies={'http':'http://192.168.3.2:8080'}req_driver=RequestsDriver(session)driver=req_driver.get_driver()driver.get('http://example.com')Using Custom WebDriver OptionsPass your custom Chrome WebDriver options:fromselenium.webdriver.chrome.optionsimportOptionscustom_options=Options()custom_options.add_argument('--headless')session=requests.Session()req_driver=RequestsDriver(session,custom_options=custom_options)driver=req_driver.get_driver()driver.get('http://example.com')Using Existing WebDriverPass your already created WebDriver instance:fromseleniumimportwebdriverexisting_driver=webdriver.Chrome(executable_path='path_to_chromedriver')session=requests.Session()req_driver=RequestsDriver(session,driver=existing_driver)req_driver.set_cookies('http://example.com')existing_driver.get('http://example.com')ContributingContributions are welcome! Feel free to open issues or submit pull requests.LicenseDistributed under the MIT License. SeeLICENSEfor more information.My linksWebsiteGitHubTwitterMediumEmail
Package: reqe
reqeA python network request library that will not throw exceptionsTable of ContentsBackgroundInstallUsageReferenceLicenseBackgroundWhen timeout, network connection error, server error, etc.,requestswill raise the exception, there will be a lot oftry ... except ...in the code.Under the above problems, I developed areqebased on the requests library, which is as simple as requestsInstallsource codegitclonegit@github.com:ophlr/reqe.gitpippipinstallreqeUsageimportreqe# use default setting, it can be used like requestresponse=reqe.get("https://www.baidu.com")ifresponse:print(response)# specify the params that you like# retries: How many retries, If you don’t want to resend the request, you can set retries to 0# delay: time between two requests# backoff: delay = delay * backoffresponse=reqe.get("https://www.google.com",retries=3,delay=3,backoff=2)# when `requests` raises an exception, `reqe` will catch it and let the response be Noneifresponse:print(response)# how to use reqe with sessionsession=reqe.session()response=session.get("https://www.google.com",retries=1,delay=3,backoff=2)print(response)ReferencerequestsLicenseApache 2.0
Package: reqgen
Requirements mergerReqGen is a requirements generator that searches recursively in a given path for all requirements.txt and merge them all in a single file with the newest versions found in the files.Free software: ISC licenseDocumentation:https://reqgen.readthedocs.org.FeaturesSearches recursively in a given pathCan be imported and used inside your own scriptsCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2016-05-31)First release on PyPI.
Package: reqhash
Calculate a hash value over a requirement file.reqhash parses referenced requirements and ignores changes in comments
and whitespace.reqhash is tested under Python 2.6, 2.7, 3.2, 3.3 and PyPy. To install
under 3.x, you have to use distribute, which is installed by default if you use
a current version of virtualenv.Author: Daniel Hepper <daniel@hepper.net>
License: MIT, see LICENSE.txtInstallationYou can install reqhash from PyPI:$ pip install reqhashOr directly from the repo:$ git clonehttps://github.com/dhepper/reqhash…
$ python setup.py installUsagereqhash [-h] filenameCalculate a digest for a requirements file.Positional arguments:
filename    path to requirements fileOptional arguments:
-h, –help  show this help message and exitExample$ reqhash requirements.txt
302bf9e94323ec2b6ca04b76cd407602
Package: reqompyler
ReqompylerTable of ContentsTable of ContentsDescriptionInstallationUsageCreditsDescriptionUsepip-toolsto compile a requirements.in folder into proper pinned dependencies.Installationpip install reqompylerUsage$reqompyler--helpUsage: reqompyler [OPTIONS]Console script for reqompyler.Options:-i, --in PATH      Path to requirements.in folder  [default:./requirements.in]-o, --output PATH  Path to pinned requirements folder  [default:./requirements]--tld PATH         Ideally the top-level-directory of the package (ie, werethere is a setup.py). If not None will be used to exporta copy of your dev.txt as requirements.txt  [default: .]--ignore TEXT      Requirements.in file (without extension) to ignore,if they are required by another they will be used but no dedicated.txt file will be generated.  [default: linting]--help             Show this message and exit.CreditsThis package was created withCookiecutterand thezurutech/cookie-monsterproject template.
Package: reqpi
The build-friendly PyPI fake.Introductionreqpi is a server that can pretend to be a PyPI clone,
but is optimized to be friendy to be a build system.
It creates ad-hoc end-points which serve an extremely
limited subset of PyPI.Usage$ twistd reqpi --http $PORT
$ url=`python -m reqpi gethash --url http://localhost:2000/ requirements.txt`
$ pip install --index-url $url requirements.txtThis will make sure that ifrequirements.txtis incomplete,
the build will fail, rather than getting the latest version of the dependency
that is missing.The URL should also work with other things that access PyPI, like PEX
or Pants. For appropriate ways to get those systems to access the ad-hoc
URL, refer to the package documentation.ContributingIf you would like to contribute code to this project you can do so through GitHub by
forking the repository and sending a pull request.When submitting code, please make every effort to follow existing conventions
and style in order to keep the code as readable as possible. Please also make
sure your code is correct by runningtox.Before your code can be accepted into the project you must also sign theIndividual Contributor License Agreement (CLA)CreditsThanks to our employer, Square, for sponsoring the time for us to write this.LicenseCopyright 2015 Square Inc.Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: reqplus
ReqplusA lib for strict Flask reqparseThis is an easy way to raise required parameters using reqparse from Flask Restful framework.InstallationpipinstallreqplusRequiredPython >= 3.7- Python is requiredPip is requiredFlask-RESTful 0.3.9Flask RestfulDevelopment1- Create a normal reqparse objectfromflask_restfulimportreqparseparser=reqparse.RequestParser(bundle_errors=True)parser.add_argument('id',type=int,required=True,location='args',help='Id is required')2- Insteated usingparse_argsreplace it forpre_parse_args,
StrictParser is required for usepre_parse_argsfromflask_restfulimportreqparsefromreqplusimportStrictParserparser=reqparse.RequestParser()parser.add_argument('id',type=int,required=True,location='args',help='Id is required')# Old one >>> args = parser.parse_args()args=StrictParser.pre_parse_args(parser)pre_parse_argswill return a dictionary with the values from the request like a normal reqparse implementation, if one parameter is required and isn't in the requestpre_parse_argswill raise an exception with thehelpmessage you set.Take care using required parameters, for required parameters you have to set the help parameter to display correctly the message.In a normal reqparse implementation you will use the next structure:# Taked from the official documentationfromflask_restfulimportreqparseparser=reqparse.RequestParser(bundle_errors=True)parser.add_argument('foo',type=int,required=True,help='foo error message')parser.add_argument('bar',type=int,required=True,help='bar error message')# Error response{"message":{"foo":"foo error message","bar":"bar error message"}}With this implementation you will get an object named "message" inside another object named "data" with every error message with a key named equal to the parameter name, for this case you have to validate in the exception section looking for an easy way to return this values.Normally an API returns static messages doing "try cath" blocks for raise all the incoming exceptions and returning messages like the following example:"message" :  "foo error message"With reqparse you will have the following message:"message" : "400 Bad Request: The browser (or proxy) sent a request that this server could not understand.".To improve this error reqplus intercept the incoming request and comparate it with de reqparse arguments raising an exception if any argument don't meet the conditions.pre_parse_argsalso accept the current parameters from reqparse and use the parameterbundle_errorsfrom reqparse declaration to bundle all the error from de validation in one exception.Example# strict=True# http_error_code=400args=StrictParser.pre_parse_args(parser,strict=True,http_error_code=400)Setbundle_errorsin false to get the first posible error# Old"message":{"foo":"foo error message","bar":"bar error message"}# New# bundle_errors:false"message":"foo error message"# bundle_errors:true"message":"foo error message, bar error message"CommentsAny recomendation is acepted.LicenceGNU - Yeah baby!
Package: reqrest
reqrestA package for using REST APIsPurposeA lot of APIs are REST based, reqrest provides an easy way to use them.UsageGetting started is easy, first install the package usingpip install reqrestNext import itfromreqrestimportRESTRESTAPI=REST('postman-echo.com')Then query your APIRESTAPI.get('/get')You can add custom headerscustom_headers={"authorization":"Basic dXNlcm5hbWU6cGFzc3dvcmQ="}RESTAPI=REST('postman-echo.com',headers=custom_headers)Or querystringsquerystring={}querystring[pagesize]=1000RESTAPI.get('/get',querystring=querystring)Have a read ofexamples/simple.pyAuthenticationYou can use basic_auth to create and store your headers / configheaders=Auth().read_config("basic_config.json")RESTAPI=REST('postman-echo.com',headers=headers)
Package: reqsit
# Reqsit[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
![example workflow](https://github.com/mattyWuh/reqsit/actions/workflows/ci.yml/badge.svg)A CLI tool for converting requirements.txt entries to a form accepted by pyproject.toml.
Pronounced “RECKS-IT”.## Getting started.Installreqsitwithpip,` pip install--userreqsit `Run by executing the command from the root folder of your project,` reqsit `If you prefer to use a name other thanrequirements.txtfor your requirements file, then add a–filenameargument.
For example, to use the filefoo.bar, enter` reqsit--filename=foo.bar`## How to contribute.
Package: reqsnaked
ReqsnakedReqsnaked is a blazing fast async/await HTTP client for Python written on Rust using reqwests.Works 15% faster thanaiohttpon averageRAII approach without context managersMemory-efficient lazy JSON parserFully-typed even being written on RustDocs:https://deknowny.github.io/reqsnaked/devel/Overviewimportasyncioimportdatetimeimportreqsnakedasyncdefmain():client=reqsnaked.Client(user_agent="Reqsnaked/1.0",headers={"X-Foo":"bar"},store_cookie=True)request=reqsnaked.Request("POST","https://httpbin.org/anything",multipart=reqsnaked.Multipart(reqsnaked.Part("foo",b"01010101",filename="foo.txt",mime="text/plain")),query={"foo":"bar"},headers={"X-Bar":"foo"},timeout=datetime.timedelta(seconds=30),)response=awaitclient.send(request)print(response.status)data=awaitresponse.json()data.show()asyncio.run(main())HTTPStatus.OK{"args":{"foo":"bar"},"data":"","files":{"foo":"01010101"},"form":{},"headers":{"Accept":"*/*","Accept-Encoding":"gzip, br","Content-Length":"246","Content-Type":"multipart/form-data; boundary=a59212f1bfcc112f-b3b83c8afd39b140-f302f74df067620a-a8a38a37c3355abe","Host":"httpbin.org","User-Agent":"Reqsnaked/1.0","X-Amzn-Trace-Id":"Root=1-63fcfd9b-412668b5117367524668f43b","X-Bar":"foo","X-Foo":"bar"},"json":null,"method":"POST","origin":"1.1.1.1","url":"https://httpbin.org/anything?foo=bar"}InstalllationCurrently the library is not published to PyPI, so the only way to install it is from GitHub:python-mpipinstall-Uhttps://github.com/deknowny/reqsnaked/archive/main.zip
Package: reqstool
Reqstool ClientOverviewReqstool is a tool for managing requirements with related software verification cases (aka tests) and verification results (test results).Requirements are defined in YAML files and can reference each other (depending on the variant different data will be parsed).Annotations are then used in code to specify where a requirement is implemented as well as tested.With this information and the actual test results (e.g., JUnit), use Reqstool to:Generate a report (AsciiDoc, which can be transformed into e.g. PDF) listing all requirements, where that requirement is implemented and tested, and whether the tests passed/failed. This report can be used e.g. with auditors ("Yes, we track this requirement, it's implemented (here) and it has been tested with a pass (here).")Status the software, i.e. get a list of all requirements, their status on implementation and tests. Reqstool will exit with a status code equal to the number of requirements that have not been implemented and tested with a pass. Hence, it can be used in a pipeline as a gate for deployment to production.InstallationYou need to have the following installed in order to use the tool:Python, 3.10 or laterpipTo use the tool, you need to install the PyPI packagereqstool.pipinstall-Ureqstool
reqstool-h# to confirm installationUsagereqstool[-h]{command:report-asciidoc,generate-json,status}{location:local,git,maven}...Use-h/--helpfor more information about each command and location.DocumentationFor full documentation seexxx.ContributingWe adhere to the latest version ofContributor Covenant.Fork repoBefore submitting a PRPerform formatting (black):hatch run lint:black src testsRun linter (flake8):hatch run lint:flake8Run tests:all:hatch run test:pytest --cov=reqstoolunit only:hatch run test:pytest --cov=reqstool  tests/unitintegration only:hatch run test:pytest --cov=reqstool  tests/integration
Package: reqstool-python-decorators
Reqstool Python DecoratorsDescriptionThis provides decorators and collecting of decorated code, formatting it and writing to yaml file.InstallationThe package name isreqstool-decorators.Using pip install:$pip install reqstool-decoratorsUsingpyproject.tomlHatchdependencies = [
    "reqstool-decorators == <version>"
]Poetry[tool.poetry.dependencies]
reqstool-decorators = "<version>"DecoratorsImport decorators:from reqstool-decorators.decorators.decorators import Requirements, SVCsExample usage of the decorators:@Requirements(REQ_111, REQ_222)
def somefunction():@SVCs(SVC_111, SVC_222)
def test_somefunction():ProcessorImport processor:from reqstool.processors.decorator_processor import ProcessDecoratorMain function to collect decorators data and generate yaml file:process_decorated_data(path_to_python_files)Herepath_to_python_filesis the directories to search through to find decorated code.Note:Yaml file is saved into the/distfolder, make sure the folder exists before running theprocess_decorated_datafunction.LicenseThis project is licensed under the MIT License - see the LICENSE.md file for details.
Package: reqt
Reqtreqtis a simple, asynchronous library that you can use to send large numbers of requests.importasyncioimportreqtasyncdefcustom_method(response):print(f"Status Code:{response.status}")print(f"Response:{response.content}")asyncdefmain():urls=["https://www.google.com"]awaitreqt.fetch_all(urls=urls,method=custom_method)loop=asyncio.get_event_loop()loop.run_until_complete(main())Requests allows you to send HTTP/1.1 requests extremely easily. Just giveurl addressesand process your results. It continues to be developed withnew featuresevery day!Installing Reqt and Supported VersionsReqt is available on PyPI:$python-mpipinstallreqtReqt officially supports Python 3+.
Package: reqto
reqtoA wrapper around requests to tackle unstable timeout issuesInstallationUse the package managerpipto install reqto.pipinstallreqtoUsageimportreqtoresponse=reqto.get(url,timeout=5,timeout_function=custom_function,timeout_args=custom_args)Exampleimportreqtodefcustom_function(parameter):print(parameter)package="reqto"response=reqto.get(f'https://pypi.org/pypi/{package}/json',timeout=5,timeout_function=custom_function,timeout_args="Timeout custom function called")"""Will call timeout_function instead of raising an exception on Timeout"""print(response)response=reqto.get(f'https://pypi.org/pypi/{package}/json',timeout=1)"""Will raise exception on Timeout"""print(response)Current scopeDone: GET, POST, PUT, DELETE, PATCH requests working fine with timeoutContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT
Package: requake
RequakeRepeating earthquakes search and analysis.(c) 2021 - Claudio Satrianosatriano@ipgp.frDescriptionRequake is a command line tool to search and analyse repeating earthquakes.It can either scan an existing earthquake catalog to search for similar events,
or perform template matching on a continuous waveform stream (this second mode
is not yet implemented).Catalogs and waveforms are downloaded using standardFDSN web services.Requake is written in Python and usesObsPyas backend.InstallationUsing pip and PyPI (preferred method)The latest release of Requake is available on thePython Package Index.You can install it easily throughpip:pip install requakeFrom the Requake GitHub repositoryIf you need an unreleased feature, or if you want to play with the source
code, you can pull the most recent code from theRequake GitHub repository.Clone the project:git clone https://github.com/SeismicSource/requake.git(avoid using the "Download ZIP" option from the green "Code" button, since
version number is lost), then install the code from within therequakemain
directory by running:pip install .If you want to simultaneously modify and use the code, you can install
in "editable mode":pip install -e .RunningCommand line argumentsRequake is based on a single executable, aptly namedrequake😉.To get help, use:requake -hThe different running modes are specified as "verbs" (positional arguments).
Currently supported verbs are:sample_config       write sample config file to current directory and exit
scan_catalog        scan an existing catalog for earthquake pairs
plot_pair           plot traces for a given event pair
build_families      build families of repeating earthquakes from a catalog
                    of pairs
plot_families       plot traces for one ore more event families
plot_timespans      plot family timespans
map_families        plot families on a map
flag_family         flag a family of repeating earthquakes as valid or not
                    valid. Note that all families are valid by default
                    when first created
build_templates     build waveform templates for one or more event
                    familiesCertain running modes (e.g.,plot_pair) require further arguments (use, e.g.,requake plot_pair -hto get help).Requake supports command line tab completion for arguments, thanks toargcomplete.
To enable command line tab completion, add the following line to your.bashrcor.zshrc:eval "$(register-python-argcomplete requake)"Typical workflowThe first thing you will want to do is to generate a sample config file:requake sample_configEdit the config file according to your needs, then build the catalog of event
pairs with:requake scan_catalogOnce done (it will take time!), you are ready to build
repeating earthquake families:requake build_familiesPerformancesrequake scan_catalogtook 53 minutes on my 2.7 GHz i7 MacBook Pro to
process 14,100,705 earthquake pairs.
Dowloaded traces are cached in memory to speed up execution. Processing is not
yet parallel: some improvements might come in future versions, when
parallelization will be implemented.requake build_familiesis fast™.
Package: requery
requery=======Simple way to store and use queries in database for use of DBA in Django Admin.. image:: https://d2weczhvl823v0.cloudfront.net/ebertti/requery/trend.png.. image:: https://pypip.in/v/requery/badge.png.. image:: https://pypip.in/d/requery/badge.pngInstallation------------1. ``pip install requery``2. Add ``requery`` to your ``INSTALLED_APPS`` in ``settings.py`` ::.. code-block:: pythonINSTALLED_APPS = (# ...'requery',)3. Run ``python manage.py migrate``Screenshot----------1) Create and edit queryYou can use ``:param_name`` to use to run your queries later... image:: https://raw.githubusercontent.com/ebertti/requery/master/screenshot/change_form.png2) Listing your queries stored in Django AdminYou can choose a query to run, just click in **Run**.. image:: https://raw.githubusercontent.com/ebertti/requery/master/screenshot/change_list.png3) Running and show resultFill the form with your parameters and click in **Run** to see the results.. image:: https://raw.githubusercontent.com/ebertti/requery/master/screenshot/running.pngPlease help us--------------This project is still under development. Feedback and suggestions are very welcome and I encourage you to use the `Issues list <http://github.com/ebertti/requery/issues>`_ on Github to provide that feedback.Authors-------The requery was original created by Ezequiel Bertti `@ebertti <https://github.com/ebertti>`_ and João Leite `@joaoleite <https://github.com/joaoleite>`_ in September 2012.Changelog---------* 0.3.5.1* Working on Python 3 - `@tomatohater <https://github.com/tomatohater>`_* 0.4.1.0* Allow receive list parameter as arguments for query* 0.4.1.1* Fix reverse url in template