Saravanan666/pypi-org huggingface dataset:
Package: pyqcm
PyqcmPyqcm is a Python/C++ library that implements a few quantum cluster methods with an exact diagonalization impurity solver.
Quantum cluster methods are used in the study of strongly correlated electrons to provide an approximate solution to Hubbard-like models.
The methods covered by this library are Cluster Perturbation Theory (CPT), the Variational Cluster Approach (VCA) and Cellular (or Cluster) Dynamical Mean Field Theory (CDMFT).
The impurity solver (the technique used to compute the cluster's interacting Green function) is exact diagonalization from sparse matrices, using the Lanczos algorithm and variants thereof.
The core library is written in C++ for performance, but the interface is in Python, for ease of use and inter-operability with the numerical Python ecosystem.
The library is distributed under the GPL license.A comprehensive paper describing the different methods and version 2.1 of the software is available onarXiv repository.InstallationPyqcm depends on a BLAS-LAPACK implementation available on your system (such as OpenBLAS) and the Eigen template librairie.
These dependencies can be installed using theaptpackage manager on Debian system as (Ubuntu):sudo apt install libopenblas-dev libeigen3-devOnce installed, Pyqcm can be installed using thepippackage manager as:pip install pyqcmNote only sources distribution are available and compilation is carried on the target system.
This is for enabling the most appropriate optimizations at building time for faster running time.
By default, a build-capability build of Pyqcm is carried.
Pyqcm is compatible (i.e. have been tested) on various Linux distribution on x86 computers (Intel and AMD) and Apple ARM processors.
Finely tuned installation can be acheived by specifiyng the environment variableCMAKE_ARGSbefore to install Pyqcm viapip(see the sectionAdvanced installationon the documentation).Examples and documentationPyqcm documentation is hosted on ReadTheDocs and is available athttps://qcm-wed.readthedocs.io/.EXAMPLES can be found in the notebooks/ folder, either in plain python files (*.py) or in the form of Jupyter notebooks (*.ipynb).ContactQuestions and comments can be addressed to:david.senechal@usherbrooke.ca
Package: pyqcore
PyQCore is a client in Python to access our high speed reservoir computing engine, WebQore.We are in an early-release beta. Expect some adventures and rough edges.Update2019.06.13  Release 0.2.1:  Addsofmax_topoption toclassification_predictto show the softmax values with predicted classes.
2019.03.08  Release 0.2.0:  Addregression_train,regression_test,regression_predict.More about PyQCoreAbout QuantumCore EngineInstallationGetting StartedCommunicationLicenseMore about PyQCoreAt a granular level, PyQcore is a library that consists of the following components:ComponentDescriptionpyqcore.client.SimpleQCoreClienta client class that makes model on WebQore Enginepyqcore.examples.jpvow.load_jpvowa function that loads sample data fromUCI repositoryand return as sklearn formatThis library is enable to use the WebQore Engine in your codes. Also you need get license code from QuantumCore website to use this library(QuantumCore Inc.).About QuantumCore EngineWebQore Engine is developed byQuantumCore Inc.This new model is 4Kx faster and lighter than previous LSTM or RNN model without GPU. Also you do not have to adjust parameters anymore.The Engine you use with this library is currently running on t2.micro on AWS (check out the speck here).The company also plans to impliment this algorithm on small edge computer.InstallationThis library requiresPython > 3.5.Installing PyQcore is not difficult. Just run the command below:pip install pyqcoreOr clone this repository and run:python setup.py installGetting StartedRefer oursample scrptsortutorial notebook.Make sure that you need get license code fromQuantumCore Inc.CommunicationGitHub issues: bug reports, feature requests, install issues, RFCs, thoughts, etc.Mailing List: please send any issue atinfo-dev@qcore.co.jpLicenseCopyright (c) 2019 QuantumCore Inc.
Package: pyqcstrc
PyQCstrc: python library for quasi-crystal structureInstallationvia PIP:pip install --upgrade pip
pip install pyqcstrcFro more information, see the web sitehttps://www.rs.tus.ac.jp/tsunetomo.yamada/pyqcstrc/Supported versionsPython>=3.7Operating systems: Linux, macOS, and WindowsRequirementsCython>=0.29.21numpy>=1.20.0scipy>=1.6.0LicenseThis work is licensed under anMIT license.
Package: pyqcy
pyqcy[pyksi:] is an automated testing framework for Python
inspired by the wonderfulQuickChecklibrary for Haskell.What’s the idea?Instead of writing fully-fledged test cases, withpyqcyyou simply define logicalpropertiesthat your code
is expected to satisfy. Based on that,pyqcywill
automatically generate test cases for you - hundreds of them,
in fact!How does it look like?For starters, try this:from pyqcy import qc, int_, main

@qc
def addition_actually_works(
    x=int_(min=0), y=int_(min=0)
):
    the_sum = x + y
    assert the_sum >= x and the_sum >= y

if __name__ == '__main__':
    main()$ pip install pyqcy
$ python test.py
addition_actually_works: passed 100 tests.pyqcygenerated 100 test cases and checked whether
they all pass. For a few lines of code, that’s rather nice,
isn’t it? :)Of course, you are not limited to integers - there is
built-in support for all standard types, including lists
and dictionaries. Custom classes can be used as well:
just specify how to generate an@arbitraryobject
of your class, and you’re set.Hey, I like it!Then check these links to find out more:websitedocumentationgithub
Package: pyqdbm
This requires QDBM C Library (http://fallabs.com/qdbm/index.html)Example code:from qdbm import depotdb = depot.open(“test.db”, “n”) # depot.open(FILENAME, FLAG)db[“apple”] = “red”       # add data
db[“lemon”] = “black”
db[“orange”] = “orange”db[“lemon”] = “yellow”    # update dataprint db[“lemon”]   # get value that key is “lemon”print db.get(“orange”, “unknown”)  # get data with default value (returns orange)print db.get(“melon”, “unknown”)   # get data with default value (returns unknown)print db.keys()               # get list of keys (Python2), get iterator of keys (Python3)print db.listkeys()           # get list of keys (Python3)for k in db.iterkeys():       # get iterator of keys (Python2)print kfor k in db.keys():           # get iterator of keys (Python3)print kfor k, v in db.iteritems():   # get iterator of (key, value) (Python2)print k, vfor k, v in db.items():       # get iterator of (key, value) (Python3)print k, vfor v in db.itervalues():     # get iterator of values (Python2)print vfor v in db.values():         # get iterator of values (Python3)print vdb.close()                    # close database objectFlags:r: Read Onlyw: Read / Writec: Read / Write (create if not exists)n: Read / Write (always create new file)
Package: pyqdf
Python for Qlik Deployment Framework ProjectsGet StartedRepositoryClass to represent the project repository in Qlik Deployment Framework.ContainerClass to represent each container in Qlik Deployment Framework.For default the pattern of container is base on 'Qlik Sense Only'QVSClass to represent each qvs file inside of container in Qlik Deployment Framework.For default the pattern of container is base on 'Qlik Sense Only'QVFClass to represent each qvf application inside of container in Qlik Deployment Framework.LicensePYQDF as a whole is licensed under the GNU Public License, Version 3. Individual files may have a different, but compatible license.See LICENSE for details.
Package: pyqed
Molecular QEDFree software: MIT licenseDocumentation:https://mqed.readthedocs.io/en/latest/FeaturesComputational techniques for molecular quantum electrodynamics (MQED)nonlinear molecular spectroscopypolariton chemistryquantum light spectroscopylaser-driven matter, etc.AuthorBing Guemail: bingg at uci dot eduHistory0.1.0 (2018-08-11)First release on PyPI.
Package: pyqentangle
Quantum Entanglement in PythonVersionThe releases ofpyqentangle2.x.x is incompatible with previous releases.The releases ofpyqentangle3.x.x is incompatible with previous releases.Since release 3.1.0, the support for Python 2.7 and 3.5 has been decomissioned.
Since release 3.3.0, support for Python 3.6 is diminished, but that for Python 3.11 is added.InstallationThis package can be installed usingpip.>>> pip install -U pyqentangleTo use it, enter>>> import pyqentangle
>>> import numpy as npSchmidt Decomposition for Discrete Bipartite StatesWe first express the bipartite state in terms of a tensor. For example, if the state is|01>+|10>, then express it as>>> tensor = np.array([[0., np.sqrt(0.5)], [np.sqrt(0.5), 0.]])To perform the Schmidt decompostion, just enter:>>> pyqentangle.schmidt_decomposition(tensor)
[(0.7071067811865476, array([ 0., -1.]), array([-1., -0.])),
 (0.7071067811865476, array([-1.,  0.]), array([-0., -1.]))]For each tuple in the returned list, the first element is the Schmidt coefficients, the second the component for first subsystem, and the third the component for the second subsystem.Schmidt Decomposition for Continuous Bipartite StatesWe can perform Schmidt decomposition on continuous systems too. For example, define the following normalized wavefunction:>>> fcn = lambda x1, x2: np.exp(-0.5 * (x1 + x2) ** 2) * np.exp(-(x1 - x2) ** 2) * np.sqrt(np.sqrt(8.) / np.pi)Then perform the Schmidt decomposition,>>> modes = pyqentangle.continuous_schmidt_decomposition(biwavefcn, -10., 10., -10., 10., keep=10)where it describes the ranges of x1 and x2 respectively, andkeep=10specifies only top 10 Schmidt modes are kept. Then we can read the Schmidt coefficients:>>> list(map(lambda dec: dec[0], modes))
[0.9851714310094161,
 0.1690286950361957,
 0.02900073920775954,
 0.004975740210361192,
 0.0008537020544076649,
 0.00014647211608480773,
 2.51306421011773e-05,
 4.311736522272035e-06,
 7.39777032460608e-07,
 1.2692567250688184e-07]The second and the third elements in each tuple in the listdecompositionsare lambda functions for the modes of susbsystems A and B respectively. The Schmidt functions can be plotted:>>> xarray = np.linspace(-10., 10., 100)

    plt.subplot(3, 2, 1)
    plt.plot(xarray, modes[0][1](xarray))
    plt.subplot(3, 2, 2)
    plt.plot(xarray, modes[0][2](xarray))

    plt.subplot(3, 2, 3)
    plt.plot(xarray, modes[1][1](xarray))
    plt.subplot(3, 2, 4)
    plt.plot(xarray, modes[1][2](xarray))

    plt.subplot(3, 2, 5)
    plt.plot(xarray, modes[2][1](xarray))
    plt.subplot(3, 2, 6)
    plt.plot(xarray, modes[2][2](xarray))Useful LinksStudy of Entanglement in Quantum Computers:https://datawarrior.wordpress.com/2017/09/20/a-first-glimpse-of-rigettis-quantum-computing-cloud/Github page:https://github.com/stephenhky/pyqentanglePyPI page:https://pypi.python.org/pypi/pyqentangle/Documentation:http://pyqentangle.readthedocs.io/RQEntangle:https://CRAN.R-project.org/package=RQEntangle(corresponding R library)ReferenceArtur Ekert, Peter L. Knight, "Entangled quantum systems and the Schmidt decomposition",Am. J. Phys.63, 415 (1995).AcknowledgementHossein Seifoory
Package: pyqg
pyqg is a python solver for quasigeostrophic systems. Quasigeostophic
equations are an approximation to the full fluid equations of motion in
the limit of strong rotation and stratitifcation and are most applicable
to geophysical fluid dynamics problems.Students and researchers in ocean and atmospheric dynamics are the intended
audience of pyqg. The model is simple enough to be used by students new to
the field yet powerful enough for research. We strive for clear documentation
and thorough testing.pyqg supports a variety of different configurations using the same
computational kernel. The different configurations are evolving and are
described in detail in the documentation. The kernel, implement in cython,
uses a pseudo-spectral method which is heavily dependent of the fast Fourier
transform. For this reason, pyqg depends on pyfftw and the FFTW Fourier
Transform library. The kernel is multi-threaded but does not support mpi.
Optimal performance will be achieved on a single system with many cores.LinksHTML documentation:https://pyqg.readthedocs.ioIssue tracker:https://github.com/pyqg/pyqg/issuesSource code:https://github.com/pyqg/pyqg
Package: pyqg-jax
PyQG JAX PortThis is a partial port ofPyQGtoJAXwhich enables GPU acceleration,
batching, automatic differentiation, etc.Documentation:https://pyqg-jax.readthedocs.io/en/latest/Source Code:https://github.com/karlotness/pyqg-jaxBug Reports:https://github.com/karlotness/pyqg-jax/issues⚠️Warning:this is a partial, early stage port. There may be bugs
and other numerical issues. The API may evolve as work continues.InstallationInstall fromPyPIusing pip:$python-mpipinstallpyqg-jaxor fromconda-forge:$condainstall-cconda-forgepyqg-jaxThis should install required dependencies, but JAX itself may require
special attention, particularly for GPU support.
Follow theJAX installation instructions.UsageDocumentationis a work in progress. The parametersQGModelimplemented here are the same as for the model in the original PyQG,
so consult thepyqg
documentationfor details.However, there are a few overarching changes used to make the models
JAX-compatible:The model state is now a separate, immutable object rather than
being attributes of theQGModelclassTime-stepping is now separated from the models. Usesteppers.AB3Stepperfor the same time stepping as in the originalQGModel.Random initialization requires an explicitkeyvariable as with
all JAX random number generation.TheQGModeluses double precision (float64) values for part of its
computation regardless of the precision setting. Make sure JAX is set
to enable 64-bit.See the
documentationfor details. One option is to set the following environment variable:exportJAX_ENABLE_X64=Trueor use the%envmagicin a Jupyter notebook.Short ExampleA short example initializing aQGModel, adding a parameterization,
and taking a single step (for more, see theexamplesin
the documentation).>>>importpyqg_jax>>>importjax>>># Construct model, parameterization, and time-stepper>>>stepped_model=pyqg_jax.steppers.SteppedModel(...model=pyqg_jax.parameterizations.smagorinsky.apply_parameterization(...pyqg_jax.qg_model.QGModel(),...constant=0.08,...),...stepper=pyqg_jax.steppers.AB3Stepper(dt=3600.0),...)>>># Initialize the model state (wrapped in stepper and parameterization state)>>>stepper_state=stepped_model.create_initial_state(...jax.random.key(0)...)>>># Compute next state>>>next_stepper_state=stepped_model.step_model(stepper_state)>>># Unwrap the result from the stepper and parameterization>>>next_param_state=next_stepper_state.state>>>next_model_state=next_param_state.model_state>>>final_q=next_model_state.qFor repeated time-stepping combinestep_modelwithjax.lax.scan.LicenseThis software is distributed under the MIT license. See LICENSE.txt
for the license text.
Package: pyqif
pyqifA tool for Quantitative information flow applications.
At this point the tool calculates a hyper distribution from a channel marix and a prior distribution.How to run:After installation do:pyqifTakes ordered inputs from stdin:Channel label, ex:CPrior lenght & channel's output size, ex:3 4Pior distribution, ex:1/3 0.3333333 1/3Channel matrix, line by line:1/4 1/4 1/4 1/4
0.25 0.25 0.25 0.25
1/4 1/4 1/4 1/4FlagsHelpPrints command's help.pyqif --helpVerboseActivates verbose execution mode.pyqif --verboseLatexSwitches output type to latex. The latex code format is appropriate for markdown documents that use$$as math block dellimiters.pyqif --latexExamplesFile inputExecuting tool redirecting input fromfile.Creating examplefile:C
3 4
1/4 1/2 1/4
1/2 1/2 0 0
0 1/4 1/2 1/4
1/2 1/3 1/6 0pyqif  < fileLatex ooutputExecuting tool with redirected input and output. In this scenario thetest.mdfile will cointains the formatted results.pyqif -l < file > test.md
Package: pyqiita
pyqiitaThis is an API wrapper for Qiita API v2.How to installon your console...pipinstallpyqiitaUsage...examplefromqiipyimportClientclient=Client(token="Your_Qiita_Access_Token")user=client.get_authenticated_user_data()print("my description is "+user.description)# ---# my name is ...How to get Qiita API Token ?Move to this url.SelectApplications.Get Access Token fromPersonal access tokens
Package: pyqimageview
A short, integratable and reusable Qt5 image widget based (properly) on QGraphicsView and QGraphicsSceneManipulation FeaturesPan (control + left mouse button)Zoom to selection (shift + left mouse button)Zoom in/out (mouse scrolling)Supported Image datatypesOpenCVNumPyQtAuthorJason Newton <nevion@gmail.com>
Package: pyqint
PyQIntPurposePyQInt is a Python package for calculating one- and two-electron integrals as
encountered in electronic structure calculations. Since integral evaluation can
be quite computationally intensive, the evaluation is programmed in C++ and
connected to Python using Cython.PyQInt mainly serves as an educational package to teach students how to perform
(simple) electronic structure calculations wherein the most difficult task,
i.e. the integral evaluation, is already encapsulated in a handy set of
routines. With PyQInt, the student can for example build their own Hartree-Fock
routine. Some common electronic structure routine, most notably the
Hartree-Fock algorithm, is also readily available.NoteAlthough PyQInt connects to a C++ backend, it is certainly not optimized for
speed and might be (too) slow for anything outside of the calculation of the
electronic structure of simple molecules.DocumentationPyQInt comes with detailed documentation and examples, which can be found
athttps://pyqint.imc-tue.nl.FeaturesThe following molecular integrals are supported by PyQIntOverlap integralKinetic integralDipole integralNuclear integralTwo-electron repulsion integralas well as the following geometric derivativesOverlap integralKinetic integralNuclear integralTwo-electron repulsion integralPyQInt offers additional features such asPerformingrestricted Hartree-Fockcalculations usingDIISCalculation ofCrystal Orbital Hamilton PopulationcoefficientsConstruction of localized orbitals using theBoys-Foster methodVisualization of molecular orbitalsAll routines are (automatically) tested and verified against several open-source
as well as commercial programs that use cartesian Gaussian orbitals. Nevertheless,
if you spot any mistake, please kindly open anissuein this Github repository.In the image below, the (canonical) molecular orbitals as found using a restricted
Hartree-Fock calculation for the CO molecule are shown.
Package: pyqir
PyQIRThepyqirpackage provides the ability to generateQIRas well as an easy way to
parse and analyze QIR.QIR generation is intended to be used by code automating translation processes
enabling the conversion in some format to QIR via Python; i.e., this is a
low-level API intended to be used as a bridge to existing Python frameworks
enabling the generation of QIR rather than directly consumed by an end-user. It
isnotintended to be used as a framework for algorithm and application
development.InstallationThe package is released on PyPI and can be installed via pip:pipinstallpyqirExamplesPyQIR examples can be found in this repository'sexamples folder.GenerationThe following code creates QIR for a Bell pair before measuring each qubit and
returning the result. The unoptimized QIR is displayed in the terminal when
executed:frompyqirimportBasicQisBuilder,SimpleModulemodule=SimpleModule("Bell",num_qubits=2,num_results=2)qis=BasicQisBuilder(module.builder)qis.h(module.qubits[0])qis.cx(module.qubits[0],module.qubits[1])qis.mz(module.qubits[0],module.results[0])qis.mz(module.qubits[1],module.results[1])print(module.ir())The QIR output will look like:; ModuleID = 'Bell'source_filename="Bell"%Qubit=typeopaque%Result=typeopaquedefinevoid@main()#0{entry:callvoid@__quantum__qis__h__body(%Qubit*null)callvoid@__quantum__qis__cnot__body(%Qubit*null,%Qubit*inttoptr(i641to%Qubit*))callvoid@__quantum__qis__mz__body(%Qubit*null,%Result*null)callvoid@__quantum__qis__mz__body(%Qubit*inttoptr(i641to%Qubit*),%Result*inttoptr(i641to%Result*))retvoid}declarevoid@__quantum__qis__h__body(%Qubit*)declarevoid@__quantum__qis__cnot__body(%Qubit*,%Qubit*)declarevoid@__quantum__qis__mz__body(%Qubit*,%Result*writeonly)#1attributes#0={"entry_point""output_labeling_schema""qir_profiles"="custom""required_num_qubits"="2""required_num_results"="2"}attributes#1={"irreversible"}!llvm.module.flags=!{!0,!1,!2,!3}!0=!{i321,!"qir_major_version",i321}!1=!{i327,!"qir_minor_version",i320}!2=!{i321,!"dynamic_qubit_management",i1false}!3=!{i321,!"dynamic_result_management",i1false}ContributingThere are many ways in which you can contribute to PyQIR, whether by
contributing a feature or by engaging in discussions; we value contributions in
all shapes and sizes! We refer tothis documentfor
guidelines and ideas for how you can get involved.Contributing a pull request to this repo requires to agree to aContributor
License Agreement
(CLA)declaring
that you have the right to, and actually do, grant us the rights to use your
contribution. A CLA-bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately. Simply follow the
instructions provided by the bot. You will only need to do this once.
Package: pyqlc
qlc-python-SDKExamplesCreate 3 random accountsfrompyqlc.clientimportClientdefexample():qlc=Client("http://127.0.0.1:9735")accounts=qlc.Account.newAccounts(3)foridx,addrinenumerate(accounts):print(f"{idx}==>{addr}")example()"""Output:0 ==> {'address': 'qlc_1i5emtz19w75cnzpcm3gn96smp4se8s5cn8potw7si456tapz3npemjwwami','privKey': b'cc8f2fb68202526ebab7a968fa81883c29785dc4599e46126f422b11f4402f3f406c9ebe03f0a3553f654c2ea1c999d85961b23550d6aeb85cc04326916f8696','pubKey': b'406c9ebe03f0a3553f654c2ea1c999d85961b23550d6aeb85cc04326916f8696','seed': '7e6cbeb02e3247ae82fd0f0eb5030ed857c516f5fa4bba513ede65dffa863d31'}1 ==> {'address': 'qlc_3duidxc7cuizuoj8gx7crpykbibweqe9kpc9fsgohz6arfzowoki5ip7ddcw','privKey': b'ba9f8339fc6b0950d5b3afa3aaaad1518d32d098aa3f2715e1247acf45a72569af705f54556e1fdd626774aac5bd24c13c65d87959476e5d57fc88c37f5e5650','pubKey': b'af705f54556e1fdd626774aac5bd24c13c65d87959476e5d57fc88c37f5e5650','seed': '256d61e9a26f1209e62daff747e2caa959211324c1ffee04df3bbdeaa5c197d4'}2 ==> {'address': 'qlc_3pe9cd67cbhtjgh67g79qdi9o8poto9jnyznsk5ofb6u8xaf1urnytsno345','privKey': b'5e8d3b00cef26f73660144287dbe0c705825ba780fcba1828d41dd423cd5dc7ad98752c85525fa8b9e42b8a7bae07a9ad5d54f1a7bf4cc8756a49b3750d06f14','pubKey': b'd98752c85525fa8b9e42b8a7bae07a9ad5d54f1a7bf4cc8756a49b3750d06f14','seed': 'd20d72e3fb07b4936d8eee49cb23cf4e796fca566af07eaaf6c8578ab257103b'}"""Sending transactionfrompyqlc.clientimportClientimportjsondefmain():qlc=Client("https://rpc.qlcchain.online/")Alice={"address":"qlc_3xc5fbrqck6mrxrrx7hjnqf6jgyqsnkeg39k5mjw44m8aj3f1zdfh7cw8kzz","private_key":"8e6bc788bbeae46f26315dd91bbbc6891278bf3bfb228aa901b39f3f1c169efbf5436a71754893c7718e95f1a5da48bbd7cd24c704f21ce3c10a664332d07d6d"}seed=qlc.Account.newSeed(local=True)new_account=qlc.Account.create(seed=seed,index=0,local=True)Bob={"address":new_account["address"]}send_block=qlc.Ledger.generateSendBlock(From=Alice["address"],to=Bob["address"],tokenName="QGAS",amount=1,privKey=Alice["private_key"])print(f"block ={json.dumps(send_block,indent=4)}")_hash=qlc.Ledger.process(**send_block)print(f"hash ={_hash}")main()"""Output:block = {"type": "Send","token": "ea842234e4dc5b17c33b35f99b5b86111a3af0bd8e4a8822602b866711de6d81","address": "qlc_3xc5fbrqck6mrxrrx7hjnqf6jgyqsnkeg39k5mjw44m8aj3f1zdfh7cw8kfz","balance": "346854","vote": "0","network": "0","storage": "0","oracle": "0","previous": "738642163581ddab31e171813abd1301bb7d14c7f470ca91f65717710c45a464","link": "42d2f239db3798b1f60b182e72790e71fe805e0eb62eef7a2e06646d71cfc695","message": "0000000000000000000000000000000000000000000000000000000000000000","povHeight": 514397,"timestamp": 1613280327,"extra": "0000000000000000000000000000000000000000000000000000000000000000","representative": "qlc_1111111111111111111111111111111111111111111111111111hifc8npp","work": "0000000000a70611","signature": "f01b8100ab050bd8efed9585f88ae4777c86fd050053b43a3bca2ec5e04c5cefdc12b108eaec792bb70ebe546a7dbdf6f63ca34a4eb6cf95b93259cae6cc970b"}hash = 6014521eb956b589013540174951ba690cde4f2d98b0fbc291f0f94ac1bbbb87"""Requirements$pip3install-rrequirements.txt