Saravanan666/pypi-org huggingface dataset:
Package: qollib
QoLlibA Quality of Life (QoL) library that accumulates useful tools, hacks and such.Usage ExamplesAll available methods are available from the code documentation.
Below we only highlight specific use-cases that need a bit more attention.Please be also invited to have a look at the unit tests (/testsfolder) for further code examples.ProcessingTo run code (quasi-)parallel in multiple processes or threads thethreadedandsimultaneousmethods
from theprocessingpackage remove a lot of overhead.Given a method that we want to execute in paralleldeflong_running_calculation(num:float)->float:# omitted for readabilitypasswe can simply call:simultaneous(long_running_calculation,[42,1337,3.141,5,6,123.456,1e-6])However, common use case is that the ordering of concurrently generated results is important.
E.g., when processing individual rows in an image. A simple trick to achieve this is to return atuplefrom the
processing method.importnumpyasnpdefrotate_row(data:tuple)->tuple:"""| 0          | 1             | 2| row number | rot mat       | row datadat = (row: int,     rot: np.array, stokes: np.array):return: (row: int, rotated_row: np.array)"""rotated=np.zeros_like(data[2]).Tforcolinrange(data[2].shape[1]):rotated[col]=np.dot(data[1],data[2][:,col])returndata[0],rotatedOnce our result is in this form, we can re-establish the ordering after execution by transforming the
result into adict:args=[(row,rot,frame[:,row])forrowinrange(frame.shape[1])]res=dict(simultaneous(rotate_row,args))rotated=np.array([res[r]forrinrange(frame.shape[1])])Also, when working with classes, the executing method must be accessible from outside the instance scope.
This is best achieved with using@staticmethods.classExampleClass:# ... lots of implementation details parallelize@staticmethoddefparallelize(args):passsimultaneous(ExampleClass.parallelize,args)StringsWhen dealing with user input it is neat to allow users to specify shapes for numpy arrays as strings in
the common numpy format, e.g.,[13:37, :, 42]. To extract thetupleofslicesto forward this to numpy
we provide theparse_shape(str)method:data=np.arrange(10,10)roi=parse_shape('[1,2:4]')print(data[roi])#=> [12, 13]
Package: qolor-tyme
Qolor TymeThis is a Toastmasters-inspired speech timer for use during online daily scrum meeting updates.It is based on PyQt, which is Python API for Qt (pronounced "cute") cross-platform GUI framework, hence the name Qolor Tyme.I honestly don't know why they called it PyQt instead of QtPy, which would have made it "cutie-pie"¯\_(ツ)_/¯InstallationUsepip:pipinstallqolor-tymeRunningRun it as the package. It accepts an optional timeout interval (default is 90 seconds per Agile guidelines)python-mqolor_tyme120This will configure it for 2 minutes timeout. Then, twenty seconds before the timeout the color will change to yellow, five seconds before the timeout it will change to red, and when it times out it will blink red.The window is set up to be "always on top", so no matter what you (as a scrum master) share on your screen during the meeting, the timer will always be visible.
Package: qolsys-client
qolsys_clientPython package to talk to Qolsys Alarm PanelsThis package was inspired by a conversation on the Home Assistant forum:https://community.home-assistant.io/t/qolsys-iq-panel-2-and-3rd-party-integration/231405Run main.py (--help for parameters and help)Publish JSON formatted messages to the mqtt topic (qolsys/requests by default):{"event":"INFO", "token":"blah"}
{"event":"ARM", "arm_type":"stay", "partition_id": 0, "token":"blah"}
{"event":"ARM", "arm_type":"away", "partition_id": 0, "token":"blah"}
{"event":"DISARM", "usercode":"0000", "token":"blah"}Events will publish to the following topics:qolsys/INFOqolsys/ZONE_EVENTqolsys/ZONE_UPDATEI have a node-red workflow listening to those events creating the sensors
Package: qomohub
qomohub (qomolangma-datahub)Signal datahub of Geoscience Language Model Qomolangmabackend:DataLabfrom ExpressAIdata source:GAKGqomohubcan be installed from PyPi and it is dependent on DataLabpipinstall--upgradepip
pipinstallqomohub
python-mnltk.downloaderomw-1.4# to support more feature calculationUsagefromqomohubimportload_signalsignal=load_signal("ddescholar_title_abstract")print(signal['train'][0])
Package: qonstellation
Qonstellation ClientThe Qonstellation Client is a basic Python package that can work with theQonstellation APIInstallationYou can install the Qonstellation Client fromPyPI:pip install qonstellationThe reader is supported on Python 2.7, as well as Python 3.4 and above.How to useThe Real Python Feed Reader is a command line application, namedrealpython. To see a list of thelatest Real Python tutorialssimply call the program:>>> from qonstellation import api
>>> success, error = api.login(token='xxx')
(True, '')
Package: qonto-client
Qonto python clientProvides a basic interface for querying and exporting Qonto transactions using thev2 APIRequirementspython3 with pipInstallationpip install qonto_clientgit clone https://github.com/krezreb/qonto-client.git
cd qonto-client
pip3 install  --user -r requirements.txtConfiguring Qonto API accessTo use the export export scripts, you'll need your Qonto API ID and secret key, available in your Qonto settings.  You'll also need your IBAN, upper case without spacesSetID,KEY,IBANenvironment variablesexport ID=your_org-12345
export KEY=YOURSECRETKEY12345678
export IBAN=FR7612345000019876543212345Exporting to ExcelA script to export to Excel is providedTo Export all transactions:python3 export_xlsx.pyExport all transactions from last monthpython3 export_xlsx.py --last-monthExporting OFXA script to export to OFX is provided, Export all transactions as OFX formatpython3 export_ofx.pyExport all transactions from last month as OFX formatpython3 export_ofx.py --last-monthAll options available via the--helpcommandpython3 export_ofx.py --helpFound a BUG, need a feature?This project was written over a weekend because of a last minute requirement.  Documentation and features are sketchy.
If you found a problem with the code or want a new feature, Open an issue 🍺 ☕
Package: qontrol
Qontrol APIIntegrated photonic devices need large-scale, precise electronic control. We can provide the precision and power you need, at a scale only limited by your ambition. Let’s take photonics into the future.
Seeour websitefor more details!Python Library for interfacing withQontrolintegrated optics control hardware. This module lets you control Qontrol hardware modules, natively in Python. It provides
a main Qontroller class which handles enumeration, low-level communications, sequencing,
error-handling, and log maintenance. Subclasses of Qontroller implement module-specific
features (e.g. DC current or voltage interfaces, positional interfaces).Learn more, atwww.qontrol.co.uk/support, or get in touch with us atsupport@qontrol.co.uk. Contribute atwww.github.com/takeqontrol/api.Table of contentsInstallationUsageCreditsLicenseInstallationRequirements:A Python 3.6 or greater interpreter.Dependenciespyserialto enable the Serial interface communications with the Qontrollers.PyPi InstallationThe most stable Qontrol Python API is available through the Python Package Index PyPI. Using a bash terminal or similar, this can be installed as follows:pipinstallqontrolA check that the installation has been successfully performed is:>>>importqontrol>>>qontrol.run_interactive_shell()--------------QontrolInteractiveShell--------------Local Development - Github InstallationThe latest development version is available through Github as instructed below.gitclonehttps://github.com/takeqontrol/api.gitcdapi/Local installation can be performed using thesetup.pyinstallation script.pythonsetup.pydevelopUsageSee help and documentation athttps://takeqontrol.github.io/api/CreditsList of contributors and authors:
QontrolJoshua W. SilverstoneRaffaele SantagatiDario QuinteroContributionsIf you want to contribute to this library contactsupport@qontrol.co.ukLicenseCopyright  © 2020 Qontrol Ltd. 2020Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: qonversion-sdk
Qonversion Python SDKThe Qonversion Python SDK provides convenient access to the Qonversion API from
applications written in the Python language.InstallationYou don't need this source code unless you want to modify the package. If you just
want to use the package, just run:pipinstall--upgradeqonversion-sdkInstall from source with:pythonsetup.pyinstallRequirementsPython 3.6+DevelopmentRun the following command to set up the development virtualenv:makeRun all tests on all supported Python versions:maketestRun all tests for a specific Python version (modify-eaccording to your Python target):TOX_ARGS="-e py37"maketestRun all tests in a single file:TOX_ARGS="-e py37 -- tests/path/to/test.py"maketestRun a single test suite:TOX_ARGS="-e py37 -- tests/path/to/test.py::TestName"maketestRun a single test:TOX_ARGS="-e py37 -- tests/path/to/test.py::TestName::test_method"maketestRun the linter with:makelintThe library uses [Black][black] for code formatting. Code must be formatted
with Black before PRs are submitted, otherwise CI will fail. Run the formatter
with:makeformat
Package: qoo
qoois a very simple Amazon SQS client, written in Python. It
aims to be much more straight-forward to use than boto3, and specializes
only in Amazon SQS, ignoring the rest of the AWS ecosystem.FeaturesEasier interaction with SQS queuesAutomatic support forAWS_ACCESS_KEY_ID,AWS_SECRET_ACCESS_KEY, andAWS_DEFAULT_REGIONenvironment variables.automatic useful message/job metadataUsageInstallationpipinstallqooBasic Usageimportqoo# list SQS queue namesqoo.list_queues()# get an existing queuequeue=qoo.get("$QUEUE_NAME")# or create a queuequeue=qoo.create("$QUEUE_NAME")# send a job, pass info/keys as kwargsqueue.send(info="foo",user_id="test_user")# etc.# get an approximate count of messages in the queuelen(queue)# approximate total messagesqueue.approx_not_visible# approximate number of message in the visibility timeout# get a jobjob=queue.receive(wait_time=1)job.elapsed# time between sending the job and receiving itjob.md5_matches# boolean property to show that the md5 of the job matches what was sent# and the data from the job is automatically converted into attrsjob.info# the string "foo"job.user_id# the string "test_user"# delete the job from the SQS queuejob.delete()TestingTests can be run with tox!# run teststox
Package: qop
QOPMake quantum operators and algebras native in pythonBehold, the power of qop.Bosonfromqop.bosonimport*assert(b0.D*b0)**3==b0.D*b0+3*b0.D**2*b0**2+b0.D**3*b0**3Fermionfromqop.fermionimport*assert(c0.D*c0)**3==c0.D*c0Hardcore Bosonfromqop.hardcorebosonimport*assert(hb0.D*hb0)**2==hb0.D*hb0asserthb0*hb1==hb1*hb0Spinfromqop.spinimport*asserts0.x*s0.y==1j/2*s0.zasserts0.z*s1.x==-2j*s1.x*s0.x*s0.yGrassmann numbersfromqop.grassmannimport*assert(1+g(0)*g(1))**2==1+2*g(0)*g(1)Quaternion numbersfromqop.quaternionimport*assert(1-qi)/(1-qj)==0.5*(1-qi+qj-qk)Symbolsfromqop.symbolimport*a=Symbol("a")assertnp.conj(2+a).evaluate({"a":1j})==2-1jQuantum statesfromqop.fermionimport*fromqop.stateimport*assertSf("1").D|c1.D*c1|c1.D|Sf()==1.0And mix all, we haveU=Symbol("U")assertSf("12").D|U*(np.array([c1.D,c2.D])@np.array([c1,c2]))**2|Sf("12")==4*UOr einsum with opt_einsumfromopt_einsumimportcontractfromqop.symbolimport*a,b,c,d=Symbols("abcd")simplify(contract("ijk,i->jk",d*np.ones([3,3,3]),np.array([a,b,c])))See more examples in tests.
Package: qoqo
qoqoQuantum Operation Quantum OperationYes we usereduplicationqoqo/roqoqo is a toolkit to represent quantum circuits byHQS Quantum Simulations.For a detailed introduction see theuser documentationand theqoqo examples repositoryWhat roqoqo/qoqo is:A toolkit to represent quantum programs including circuits and measurement informationA thin runtime to run quantum measurementsA way to serialize quantum circuits and measurement informationA set of optional interfaces to devices, simulators and toolkits (e.g.qoqo_quest,qoqo_mock,qoqo_qasm)What roqoqo/qoqo isnot:A decomposer translating circuits to a specific set of gatesA quantum circuit optimizerA collection of quantum algorithmsqoqo provides the Python interface to the underlying roqoqo library, including:ACircuitclass to represent quantum circuitsAQuantumProgramclass to represent quantum programsClasses representing single-qubit, two-qubit, multi-qubit and measurement operations that can be executed (decomposed) on any universal quantum computerClasses representing so-called PRAGMA operations that only apply to certain hardware, simulators or annotate circuits with additional informationSupport for symbolic variablesReadout based on classical registersMeasurement classes for evaluating observable measurements based on raw readout date returned by quantum computer backendsSerialization to json and deserialization from json for circuits and measurement information. Serialization support can easily be expanded to other targets with the help of the serde crate.This project is partly supported byPlanQK.InstallationOn Linux, macOS and Windows on x86 precompiled packages can be found on PyPi and installed viapipinstallqoqoIf no pre-built python wheel is available for your architecture you can install qoqo from the source distribution using a rust toolchain (for example available via rustup) and maturin (also available via pip). After installing the rust toolchain and maturing run the same pip install command as above. In some cases on macOS it can be necessary to provide specific linker arguments as shown below:# can be necessary on macOSpipinstallqoqoWhen using qoqo in a rust project providing a python interface addqoqo={version="1.0.0",default-features=false}to the[dependencies]section of the project Cargo.toml.
Package: qoqo-aqt
qoqo-aqtAQT-backend for the qoqo/roqoqo quantum toolkit byHQS Quantum Simulations.The qoqo_aqt/roqoqo-aqt packages provide backends for qoqo/roqoqo that allow the users to run quantum circuits on AQT simulators or AQT hardware.
AQT endpoints (simulators or hardware) are accessed via a web-interface.
To run circuits with these backends the user needs a valid access token for the AQT services and an internet connection.This repository contains two components:The qoqo_aqt backend for the qoqo python interface to roqoqoThe roqoqo-aqt backend for roqoqo directlyqoqo_aqtAQT-backend for the qoqo quantum toolkit byHQS Quantum Simulations.A short tutorial can be found in Tutorial_qoqo.md in the git repository.InstallationOn  macOS on x86 precompiled packages can be found on PyPi and installed viapipinstallqoqo_aqtAt the moment an issue with building manylinux python wheels prevents us from distributing precompiled packages for linux.
For now please use the same method as for other platforms to install qoqo_aqt on linux.For other platforms we recommend checking out the latest tagged version from github and using thematurintool to build a python package for qoqo locally and install it via pip.
Please note that the package should be built from the top level directory of the workspace selecting the qoqo package with the-m qoqo/Cargo.tomloption.
Specifically for macOS on Apple Silicon the following build command should be used.RUSTFLAGS="-C link-arg=-undefined -C link-arg=dynamic_lookup"maturinbuild-mqoqo_aqt/Cargo.toml--release
pipinstalltarget/wheels/$NAME_OF_WHEELA source distribution now exists but requires a Rust install with a rust version > 1.56 and a maturin version { >= 0.14, <0.15 } in order to be built.roqoqo-aqtAQT-Backend for the roqoqo quantum toolkit byHQS Quantum Simulations.A short tutorial can be found in Tutorial_roqoqo.md in the git repository.General NotesThis software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.This project is partly supported byPlanQK.ContributingWe welcome contributions to the project. If you want to contribute code, please have a look at CONTRIBUTE.md for our code contribution guidelines.OpenSSLAcknowledgments related to using OpenSSL for http requests:"This product includes software developed by the OpenSSL Project
for use in the OpenSSL Toolkit (http://www.openssl.org/)."This product includes cryptographic software written by Eric Young
(eay@cryptsoft.com).  This product includes software written by Tim
Hudson (tjh@cryptsoft.com).
Package: qoqo-calculator-pyo3
qoqo-calculatorqoqo-calculator is the calculator backend of the qoqo quantum computing toolkit byHQS Quantum Simulations.This repository contains two components:The core qoqo_calculator rust libraryThe python interface qoqo_calculator_pyo3qoqo_calculatorqoqo-calculator is the calculator backend of the qoqo quantum computing toolkit byHQS Quantum Simulations.qoqo-calculator providesA calculator that evaluates symbolic string expressions to float valuesCalculatorFloat: a struct that can represent a float value or a string based symbolic expressionCalculatorComplex: a struct that represents complex numbers where real and imaginary parts can be CalculatorFloatqoqo_calculator_py03Python interface to qoqo calculator, the calculator backend of the qoqo quantum computing toolkit byHQS Quantum Simulations.qoqo-calculator-py03 providesA calculator python class that evaluates symbolic string expressions to float valuesA CalculatorFloat python class that can represent a float value or a string based symbolic expressionA CalculatorComplex python class that represents complex numbers where real and imaginary parts can be CalculatorFloatInstallationThis package can be installed directly from pypi usingpipinstallqoqo-calculator-pyo3For x86 based Linux, Windows and macOS machines pre-built binaries are available. For other platforms a working rust toolchain andmaturinare required to build the source distribution that is also available on PyPi.ContributingWe welcome contributions to the project. If you want to contribute code, please have a look at CONTRIBUTE.md for our code contribution guidelines.
Package: qoqo-for-braket-devices
qoqo_for_braket_devicesBraket devices interface for the qoqo quantum toolkit byHQS Quantum Simulations.In order to make the update a device instance with Braket's information possible, the user has to run the following code before using this package:TODOInstallationWe provide pre-built binaries for linux, macos and windows on x86_64 hardware and macos on arm64. Simply install the pre-built wheels withpipinstallqoqo-for-braket-devicesGeneralBraket is under the Apache-2.0 license ( seehttps://github.com/aws/amazon-braket-sdk-python/blob/main/LICENSE).qoqo_for_braket_devices itself is also provided under the Apache-2.0 license.TestingThis software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.If you find unexpected behaviour please open a github issue.
Package: qoqo-iqm
qoqo-iqmNote: At the moment this backend can only be used to test the connection
to the testbed. It will NOT return data from a valid simulation of a quantum circuit.IQM-backend for the qoqo/roqoqo quantum toolkit byHQS Quantum Simulations.The qoqo_iqm/roqoqo-iqm packages provide backends for qoqo/roqoqo that allow the users to run quantum circuits on the IQM web API testbed.
The testbed is  accessed via a web REST-API.
To run circuits or QuantumPrograms with this backend you need a valid access token. The access token can be set via the environment variableIQM_TOKENS_FILEthat contains the path to thetokens.jsonfile.This repository contains two components:The qoqo_iqm backend for the qoqo python interface to roqoqoThe roqoqo-iqm backend for roqoqo directlyqoqo_iqmInstallationWe provide pre-built binaries for linux, macos and windows on x86_64 hardware and macos on arm64. Simply install the pre-built wheels withpipinstallqoqo_iqmroqoqo-iqmIQM-Backend for the roqoqo quantum toolkit byHQS Quantum Simulations.ContributingWe welcome contributions to the project. If you want to contribute code, please have a look at CONTRIBUTE.md for our code contribution guidelines.OpenSSLAcknowledgments related to using OpenSSL for http requests:"This product includes software developed by the OpenSSL Project
for use in the OpenSSL Toolkit (http://www.openssl.org/)."This product includes cryptographic software written by Eric Young
(eay@cryptsoft.com).  This product includes software written by Tim
Hudson (tjh@cryptsoft.com).
Package: qoqo-mock
qoqo-mockMocking backend for the qoqo/roqoqo quantum toolkit byHQS Quantum Simulations.This repository contains two components:The qoqo_mock backend for the qoqo python interface to roqoqoThe roqoqo_mock backend for roqoqo directlyqoqo-mockMocking backend for the qoqo quantum toolkit byHQS Quantum Simulations.qoqo-mock provides a mocked benchmarking backend for qoqo.
qoqo circuits can be sent to the mock backend and all steps of a full hardware backend are applied, except calling actual quantum hardware. Measurements return random results.This backend is designed purely for benchmarking purposes.A source distribution now exists but requires a Rust install with a rust version > 1.47 and a maturin version { >= 0.12, <0.13 } in order to be built.roqoqo-mockMocking backend for the roqoqo quantum toolkit byHQS Quantum Simulations.roqoqo-mock provides a mocked benchmarking backend for roqoqo.
roqoqo circuits can be sent to the mock backend and all steps of a full hardware backend are applied, except calling actual quantum hardware. Measurements return random results.This backend is designed purely for benchmarking purposes.General NotesThis software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.ContributingWe welcome contributions to the project. If you want to contribute code, please have a look at CONTRIBUTE.md for our code contribution guidelines.
Package: qoqo-myqlm
qoqo_myqlmMyQLM interface for for the qoqo quantum toolkit byHQS Quantum Simulations.Generalqoqo-myqlm provides the interface to the Atos MyQLM software.
MyQLM is under the myQLM license ( seehttps://myqlm.github.io/myqlm_specific/license.htmlfor further infomation).
qoqo-myqlm itself is provided under the Apache-2.0 license but can only be used after installing myQLM and agreeing to the myQLM license.TestingDue to the myQLM license we are limited in the automatic code quality checks we can perform for qoqo-myqlm. If you find unexpected behaviour please open a github issue. You can also run the pytests in qoqo_myqlm/tests/ locally.This software is still in the beta stage. Functions and documentation are not yet complete and breaking changes can occur.Installationqoqo_myqlm is available on PyPi (https://pypi.org/project/qoqo-myqlm/), and can be installed via pip:
pip install qoqo-myqlm