Saravanan666/pypi-org huggingface dataset:
Package: quantumstatetomography
Quantum State TomographyThis is a simple library is dedicated to performing tomography on an arbitrary amount of qubits / qudits. It uses the Maximum Likelihood Technique as described inJ.B. Altepeter et al.to approximate the density matrix of a given quantum state. It is able to perform QST on an arbitary amount of qubits and qudits. Please note that although it can perform these computations the approximation of quantum states can get worse as the amount of qubits / qudits scales.UsageThis library is installable with pip. To import the library, run the following command:pip install quantumstatetomographyIn the library, there are two main classes that are used to perform quantum tomography. the QubitTomo() class and the QuditTomo() class. These are initialized in the following way:import quantumstatetomography as qst
qubit_obj = qst.QubitTomo(n=2)orqudit_obj = qst.QuditTomo(n=1, dim=3)The class is filled with many functions and attributes that allow you to perform tomography on your data and analyse its results both quantatively and visually. For a more comprehensive tutorial on how to use this library, please check out tutorial.ipynb!Importing dataThis library supports importing quantum tomography data. It is currently only available for the QubitTomo() class. You can import your data as an excel (.xlsx) file whose columns are the measurements taken and their respective counts. For more information on how to format your data, please refer to example.xlsx!
Package: quantumsymmetry
quantumsymmetryQuantum computing research packageInstallation$pipinstallquantumsymmetryUsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensequantumsymmetrywas created by Dario Picozzi. It is licensed under the terms of the GNU General Public License v3.0 license.Creditsquantumsymmetrywas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: quantumtools
quantumtoolsmachine learning utilitiesUser Setuppip install quantumtoolsDevelopment setupNoteprependpy -3.8 -mif there are different pythonv versionsInstall poetrypip install poetry# develop in python 3.8Notein windows and vscode, need to ensure vscode env path is~/.virtualenvs"python.venvPath": "~/.virtualenvs"in settings.jsonandpy -3.8 -m poetry config virtualenvs.in-project falsepy -3.8 -m poetry config virtualenvs.path "~\.virtualenvs"to recreate env with updated pyproject.tomlenter python env withpy -3.8 -m poetry shellupdate_env.batpytest# to run testto add dependenciesenter python envpy -3.8 -m poetry shellpoetry add packagename@^#.#.#, @ is for version increasefor development dependenciespoetry add --group dev packagename@^#.#.#Dev ReferenceGenerate pyproject.toml interactively and create venvpoetry init  or poetry new packagenameAdd dependencypoetry add requests # Add --group dev for development dependenciesInstall dependencies into venvpoetry installActivate venvpoetry shellExit venvexitNOTE, to add for installs from github, usepoetry2setup > setup.py
Package: quantum-tree
This Python package implements quantum decision tree classifiers for binary data. The details of the method can be found inRepresentation of binary classification trees with binary features by quantum circuits.InstallationInstall viapipor clone this repository. In order to usepip, type:$pipinstallquantum-tree🌳UsageMinimal working example:# create quantum tree instancefromqtree.qtreeimportQTreeqtree=QTree(max_depth=1)# create simple training dataimportnumpyasnpX=np.array([[1,0,0],[0,1,0],[0,0,1]])# featuresy=np.array([[0,0],[0,1],[1,1]])# labels# fit quantum treeqtree.fit(X,y)# make quantum tree predictionqtree.predict([[0,0,1]])DocumentationDocumentation is available onhttps://qtree.readthedocs.io/en/latest.Demo notebooks can be found in theexamples/directory.📖CitationIf you find this code useful in your research, please consider citingRepresentation of binary classification trees with binary features by quantum circuits:@article{Heese2022representationof,
         doi ={10.22331/q-2022-03-30-676},
         url ={https://doi.org/10.22331/q-2022-03-30-676},
         title ={Representation of binary classification trees with binary features by quantum circuits},
         author ={Heese, Raoul and Bickert, Patricia and Niederle, Astrid Elisa},
         journal ={{Quantum}},
         issn ={2521-327X},
         publisher ={{Verein zur F{\"{o}}rderung des Open Access Publizierens in den Quantenwissenschaften}},
         volume ={6},
         pages ={676},
         month ={3},
         year ={2022}}This project is currently not under development and is not actively maintained.
Package: quantumtw
quantumtwThis project is developed by TENG-LIN YU. You can contact me by following methods:Mail:tlyu0419@gmail.comFacebook:https://www.facebook.com/tlyu0419requirementspip install requirementsquery_dateUnlike twstock packages, it requests the data by session.get() so that we don't need to sleep 5 seconds for each request.
Notice: You can't query data by the browser while running this function, or you will be banned by the website.query Highlights of Daily Tradingquery singal stockquery Top 150 stocksquery specific stocks.trade_signalsby Machine Learning modeltimeseriesby DomainsVisualize ResultNewsYahoo marketNotificationMailIf you only want to receive the result, you can send mail to me, and then I will send mail to you daily:)AnnouncementIt's just a toy project, the prediction of the stock price is based on historical data, but in fact, many circumstances could affect the stock price.
2610 is a bad example; another is a good example
so the project only offers trade signals; you need to consider other information and then buy or sell your stock.Ref packagesProphetFindMindFindLab機器學習於量化交易的挑戰與解法 - 韓承佑 | MOPCON 2019How to label trade signalsvariables
Package: quantum-viz
quantum-vizquantum-vizis the Python package companion ofquantum-viz.js, a JavaScript package that supports visualizing any arbitrary quantum gate, classical control logic and collapsed grouped blocks of gates using JSON-formatted input data.quantum-vizcontains a Jupyter widget and will also include support for translating quantum circuits written in common quantum programming libraries to JSON using thequantum-viz.jsJSON schema.InstallationYou can install thequantum-viz.js widgetviapipfrom PyPI:pipinstallquantum-vizExampleTo use the quantum-viz widget, run the below example code in aJupyter notebookcell:fromquantum_vizimportViewer# Create a quantum circuit that prepares a Bell statecircuit={"qubits":[{"id":0},{"id":1,"numChildren":1}],"operations":[{"gate":'H',"targets":[{"qId":0}],},{"gate":'X',"isControlled":"True","controls":[{"qId":0}],"targets":[{"qId":1}],},{"gate":'Measure',"isMeasurement":"True","controls":[{"qId":1}],"targets":[{"type":1,"qId":1,"cId":0}],},],}widget=Viewer(circuit)widget# Display the widgetQiskit IntegrationBy installing the optional[qiskit]dependency, you can leverage Qiskit'sQuantumCircuitAPIs
to define the circuit and render it using theViewerwidget on Jupyter, for example:fromqiskitimportQuantumRegister,ClassicalRegister,QuantumCircuitfromquantum_vizimportViewerqr=QuantumRegister(3,'q')anc=QuantumRegister(1,'ancilla')cr=ClassicalRegister(3,'c')qc=QuantumCircuit(qr,anc,cr)qc.h(qr[0:3])qc.x(anc[0])qc.h(anc[0])qc.cx(qr[0:3],anc[0])qc.h(qr[0:3])qc.barrier(qr)qc.measure(qr,cr)Viewer(qc)Optionally, you can also import thedisplaymethod fromquantum_viz.utilsto render the circuit on a new browser window:fromquantum_viz.utilsimportdisplaydisplay(qc)ContributingCheck out ourcontributing guidelinesto find out how you can contribute to quantum-viz.
Package: quantum-vqe
Quantum VQE PackageThe Quantum VQE (Variational Quantum Eigensolver) package is a Python library for simulating the VQE algorithm on quantum computers. It utilizes the Qiskit framework to create and optimize quantum circuits that estimate the ground state energy of a given Hamiltonian.FeaturesImplementation of the VQE algorithm using Qiskit.Functions to create variational ansatzes for quantum circuits.Optimization routines to find the minimum eigenvalue of the Hamiltonian.Utilities for validating input Hamiltonians.InstallationBefore installing the Quantum VQE package, ensure that you have Python 3.7 or higher and pip installed.To install the Quantum VQE package, run the following command in your terminal:pip install git+https://github.com/SweatyCrayfish/quantum_vqe.gitAlternatively, you can clone the repository and install the package locally:gitclonehttps://github.com/SweatyCrayfish/quantum_vqe.gitcdquantum_vqe
pipinstall.UsageHere is a simple example of how to use the Quantum VQE package to find the ground state energy of a Hamiltonian:fromqiskit.opflowimportX,Z,Ifromquantum_vqe.vqeimportcreate_vqe_ansatz,optimize_vqefromqiskitimportAerDefine your Hamiltonian. For example, for a simple 2-qubit system:hamiltonian=(X^X)+(Z^I)Definethequantumbackendbackend=Aer.get_backend('statevector_simulator')circuit,parameters=create_vqe_ansatz(num_qubits=2)Optimizethecircuitparametersresult=optimize_vqe(circuit,hamiltonian,backend)print(f"Ground state energy:{result.fun}")For more detailed examples, please refer to the examples/ directory in the repository.DevelopmentTo contribute to the Quantum VQE package, you can clone the repository and set up a development environment:gitclonehttps://github.com/SweatyCrayfish/quantum_vqe.gitcdquantum_vqe
pipinstall-e.TestingTo run the tests for the Quantum VQE package, navigate to the package root and execute:python -m unittest discover testsLicenseThis project is licensed under the MIT License - see the LICENSE file for details.AuthorsViktor Veselov - Initial workAcknowledgmentsThe Qiskit community for providing the framework to build upon.CitationIf you use this package in your research, please cite it as follows:@misc{quantum_vqe,
author = {Viktor Veselov},
title = {Quantum VQE: A Variational Quantum Eigensolver Package},
year = {2023},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {url{https://github.com/SweatyCrayfish/quantum_vqe}}}
Package: quantum-xir
XIRis an intermediate representation language for quantum circuits.FeaturesSimple. Easy to learn, write, and understand.Modular. Compose observables, gates, and entire XIR programs.Flexible. Declare or define your own gates and observables.InstallationXIR requires Python version 3.7 or above. Installation of XIR, as well as all
dependencies, can be done using pip:pip install quantum-xirExamplesA curated selection of XIR scripts can be found in theExamplespage of the Sphinx documentation; however, the example below demonstrates a general overview of the syntax:// Include additional script
use my_declarations;

// Declare custom gates
gate RX(theta) [w1];
gate RY(theta) [w1];
gate RZ(theta) [w1];
gate Toffoli [w1, w2, w3];

// Declare a function
func sin(x);

// Declare observables
obs X [w1]; obs Y [w1]; obs Z [w1];

// Declare outputs
out sample(shots) [0..8];
out expval(observable) [w1, w2];
out amplitude(state) [0..8];

// Define a composite gate.
gate R3T(theta)[a, b, c, d]:
    RX(theta: -2.3932854391951004) | [a];
    RY(theta) | [b];
    RZ(pi / sin(3 * 4 / 2 - 2)) | [c];
    Toffoli | [b, c, d];
end;

// Define an observable.
obs XYZ [w1, w2]:
    -1.6, X[w1];
    0.73, Y[w1] @ Z[w2];
end;

// Apply the gate twice.
R3T(1.23) | [0, 1, 2, 3];
R3T(theta: 3.21) | [4..8];

// Compute various outputs.
sample(shots: 1000) | [0..8];
expval(observable: XYZ) | [0, 3];
amplitude(state: [0, 1, 0, 1, 0, 0, 1, 1]) | [0..8];Contributing to XIRWe welcome contributions - simply fork the XIR repository, and then make apull
requestcontaining your
contribution. All contributors to XIR will be listed as authors on the releases.
See ourchangelogfor more details.We also encourage bug reports, suggestions for new features and enhancements,
and even links to cool projects or applications built on XIR. Visit thecontributions
pageto learn more about sharing your ideas with the XIR team.SupportSource Code:https://github.com/XanaduAI/xirIssue Tracker:https://github.com/XanaduAI/xir/issuesIf you are having issues, please let us know by posting the issue on our GitHub issue tracker.AuthorsXIR is the work ofmany contributors.LicenseXIR isfreeandopen source, released under theApache License, Version 2.0.
Package: quant-wheel
quant-wheelA template repository for building python packages. Please replace$packagewith the package's name.Installation$pipinstallquant-wheelSee AlsoGithub repositoryhttps://github.com/Chitaoji/quant-wheel/PyPI projecthttps://pypi.org/project/quant-wheel/LicenseThis project falls under the BSD 3-Clause License.Historyv0.0.0Initial release.
Package: quantworks
QuantWorksQuantWorks is anevent driven algorithmic tradingframework. It is a fork ofPyAlgoTrade(seeMotivation).QuantWorks provides a Python API forstrategyauthoring,backtesting,paper trading, and of courselive tradingvia theBrokerinterface.To get started using QuantWorks, please take a look at the originalPyAlgoTradetutorialand thefull documentation.Main FeaturesPython 3 developmentPython 2 support isNOTguaranteed in any capacity.Event driven.Supports Market, Limit, Stop and StopLimit orders.Supports any type of time-series data in Pandas or CSV format (like Yahoo! Finance, Google Finance, Quandl and NinjaTrader), as well as database (i.e. sqlite).Technical indicators and filters like SMA, WMA, EMA, RSI, Bollinger Bands, Hurst exponent and others.Performance metrics like Sharpe ratio and drawdown analysis.Event profiler.TA-Lib integration.MotivationQuantWorks is a fork ofPyAlgoTradeby@gbeced. This project aims to be:Modern: first-classPython 3development (Python 2 is EOL as of 2020)Extensible: as a framework, robust extension support is a must, and we encourage users of QuantWorks to give back by publishing their extensions (seeExtensions)Easy to Develop: state-of-the-art tooling (pytest, poetry, travis) and approachable design principles should make it easy for newcomers to contribute.Open: as a fork of an Apache 2.0 license project, QuantWorks maintains the spirit of FOSS development.CONTRIBUTING.md forthcomingDevelopmentQuantWorks is developed and tested using 3.7 and depends on:NumPy and SciPy.pytz.dateutil.requests.matplotlibfor plotting support.ws4pyfor Bitstamp support.tornadofor Bitstamp support.tweepyfor Twitter support.Developer ergonomics are provided bypoetrypytesttoxtravis-ciExtensionsBitstamp(bitcoin) live trading is implemented by thequantworks-bitstamppackage (https://pypi.org/project/quantworks-bitcoin/)Twitter real-time feeds are supported via thequantworks-twitterpackage (https://pypi.org/project/quantworks-twitter/)
Package: quao
quaoquao is a supporting library for Quantum Computing.InstallationInstall quao with pip (Python >=3.10)pipinstallquaoUsage/ExamplesfromquaoimportBackend,RequestData,Utils#Definesdknamesdk="qiskit"#Pre-processinginputdatadefpre_process(input):data=RequestData(input,sdk)returndata#Post-processingoutputdatadefpost_process(job):output=Utils.counts_post_process(job)returnoutputdefhandle(event,context):#1.Pre-processingrequestData=pre_process(event)#2.GenerateQuantumCircuitqc=generate_circuit(requestData.input)#3.VerifyandgetBackendinformationbackend=Backend(requestData,qc)#4.Submitjobandwaitupto1minforjobtocomplete.job=backend.submit_job(qc)#5.Post-processifjob.jobResult:job=post_process(job)response=Utils.generate_response(job)#6.SendbacktheresultreturnresponseAuthorsCITYNOW Co. Ltd.DocumentationTBA
Package: quara
Quara, which stands for “Quantum Characterization”, is an open-source library for characterizing elementary quantum operations. Currently protocols of standard tomography for quantum states, POVMs, and gates are implemented.Documentation:https://quara.readthedocs.io/en/stable/Tutorials:https://github.com/tknrsgym/quara/tree/master/tutorialsSource code:https://github.com/tknrsgym/quaraBug reports:https://github.com/tknrsgym/quara/issuesContributing:https://github.com/tknrsgym/quara/blob/master/docs/contributing.rstInstallPython version:3.7+pip install quaraUse with other optimization parsers and solversQuara can also be used with other optimization parsers and solvers. The currently supported combinations are as follows:parsersolverinstallCVXPYMOSEKSeethe CVXPY websiteInterface from different packagesQuara supports the wrappers for executing standard tomography from several packages. To use this wrapper, install the package to be used as follows:Qiskit:pip install qiskitQuTiP:pip install qutipForest:Install Forest SDK, pyQuil, QVM, and Quil Compiler. Seethe pyQuil websitefor installation instructions.See the tutorial for detailed instructions.Using Quara’s standard tomography features from QiskitUsing Quara’s standard tomography features from QuTiPUsing Quara’s standard tomography features from Forest [1qubit/2qubit]CitationIf you use Quara in your research, please cite as per the includedCITATION.cff file.LicenseApache License 2.0LICENSESupportsQuara development is supported byJST, PRESTO Grant Number JPMJPR1915, Japan.
Package: quara-poetry-core-next
Poetry CoreAPEP 517build backend implementation developed forPoetry. This project is intended to be a light weight, fully compliant,
self-contained package allowing PEP 517 compatible build frontends to build Poetry managed projects.UsageIn most cases, the usage of this package is transparent to the end-user as it is either made use by Poetry itself
or a PEP 517 frontend (eg:pip).In order to enable the usepoetry-coreas your build backend, the following snippet must be present in your
project'spyproject.tomlfile.[build-system]requires=["poetry-core"]build-backend="poetry.core.masonry.api"Once this is present, a PEP 517 frontend likepipcan build and install your project from source without the need
for Poetry or any of it's dependencies.# install to current environmentpipinstall/path/to/poetry/managed/project# build a wheel packagepipwheel/path/to/poetry/managed/projectWhy is this required?Prior to the release of version1.1.0, Poetry was a build as a project management tool that included a PEP 517
build backend. This was inefficient and time consuming in majority cases a PEP 517 build was required. For example,
bothpipandtox(with isolated builds) would install Poetry and all dependencies it required. Most of these
dependencies are not required when the objective is to simply build either a source or binary distribution of your
project.In order to improve the above situation,poetry-corewas created. Shared functionality pertaining to PEP 517 build
backends, including reading lock file,pyproject.tomland building wheel/sdist, were implemented in this package.  This
makes PEP 517 builds extremely fast for Poetry managed packages.
Package: quarchCalibration
QuarchCalibrationQuarchCalibration is a python package that allows calibration of Quarch modules.Change Log1.1.10Minor bug fixesNoise test made standalone and now uses QISUpdated production filepath of calibration report files1.1.9Minor bug fixesAdded support for QTL2910-021.1.8Updates for AC CalibrationMinor bug fixes1.1.7Minor error logging fixMinor device selection for AC calibration fix1.1.6Uptades for AC CalibrationMinor bug fixes1.1.5-Bug fixes1.1.4Fixes for edsff calibrationFixes for modules with no noise test1.1.3Added QTL1944_06Added Noise Test.1.1.2Added QTL2887  Gen5 EDSFF Fixture (E1)Added QTL2888  GEN5 EDSFF Fixture (E3)1.1.1Added QTL2674 EDSFF Fixture (E3)1.1.0Added QTL2788 Gen 5 SFF PAM Fixture calibration1.0.0Added QTL2673 EDSFF Fixture (E1)fixes for import bug0.0.0Initial separation of calibration from QuarchPy
Package: quarrel
querulous_quarrelNamed for a lovely groups of sparrows that happened to be flying by.  A library
that makes writing and executing queries a little easier for data scientists.quarrelusesconcentricandwaddleand is proudly sponsored by the m&a
team at cscgh.installationcd /path/to/repo
pip install quarrelquick startcreate a config fileoracle:
   host: oracle.example.com
   user: scott
   password: tiger
   sid: xeinitialize concentric with the config file from (1)from concentric.managers import setup_concentric

 setup_concentric('/path/to/oracle.yml')(optional) initialize the sql template directoriesfrom quarrel.settings import setup_quarrel
 setup_quarrel('/path/to/jinja2/sql/templates', '/path/to/jinja2/sql/queries')query the databasefrom quarrel.raw import query
 results = query('oracle', 'select sysdate from dual')raw results -- get raw results from the dbapi connectionquarrel.rawallows you to get the tuples as they were returned by the
underlying dbapi connection.  the header will be the cursor.description
returned from the query, and the results will be the list of tuples returned
by the query.> from quarrel.raw import query
> header, results = query('oracle', 'select sysdate d from dual')
> print(header[0][0])
D
> print(results)
[(datetime.datetime(2022, 6, 26, 15, 10, 59),)]cooked results -- get results as a list of dictsquarrel.cookedallows you to get alistofdicts which is slightly easier to
understand and work with but can be substantially slower as python will
construct a dict per row that is returned.  Each key of thedictwill be
thelower-cased column namespecified in the query.> from quarrel.cooked import query
> results = query('oracle', 'select sysdate d from dual')
> print(results)
[{'d': datetime.datetime(2022, 6, 26, 15, 14, 12)}]sqlalchemy resultsquarrel.sqlalchemyallows you to get alistofdicts as well.  However,
it uses sqlalchemy under the hood.  This can be useful when you need sql alchemy's
connection pooling features.> from quarrel.sqlalchemy import query
> results = query('oracle', 'select sysdate d from dual')
> print(results)
[{'d': datetime.datetime(2022, 6, 26, 15, 14, 12)}]pandas resultsquarrel.pandasallows you to get a dataframe using either the dbapi
connection or a sqlalchemy connection.> from quarrel.pandas import query
> results = query('oracle', 'select sysdate d from dual')
> print(results)
                    d
0 2022-06-26 15:20:34

> from quarrel.pandas import query_alchemy
> results = query_alchemy('oracle', 'select sysdate d from dual')
> print(results)
                    d
0 2022-06-26 15:20:34In order to use pandas, make sure you installpandassupport using
thepandasextrapip install quarrel[pandas]
Package: quarry
Quarry is a Python library that implements theMinecraft protocol. It allows
you to write special purpose clients, servers and proxies.InstallationUsepipto install quarry:$pipinstallquarryFeaturesSupports Minecraft versions 1.7 through 1.19.2Supports Python 3.7+Built upontwistedandcryptographyExposes base classes and hooks for implementing your own client, server or
proxyImplements many Minecraft data types, such as NBT, Anvil, chunk sections,
command graphs and entity metadataImplements the design of the protocol - packet headers, modes, compression,
encryption, login/session, etc.Implements all packets in “init”, “status” and “login” modesDoesnotimplement most packets in “play” mode - it is left up to you to
hook and implement the packets you’re interested in