Saravanan666/pypi-org huggingface dataset:
Package: qibo
Qibo is an open-source full stack API for quantum simulation and quantum hardware control.Some of the key features of Qibo are:Definition of a standard language for the construction and execution of quantum circuits with device agnostic approach to simulation and quantum hardware control based on plug and play backend drivers.A continuously growing code-base of quantum algorithms applications presented with examples and tutorials.Efficient simulation backends with GPU, multi-GPU and CPU with multi-threading support.Simple mechanism for the implementation of new simulation and hardware backend drivers.DocumentationQibo documentation is availablehere.Minimum Working ExamplesA simpleQuantum Fourier Transform (QFT)example to test your installation:fromqibo.modelsimportQFT# Create a QFT circuit with 15 qubitscircuit=QFT(15)# Simulate final state wavefunction default initial state is |00>final_state=circuit()Here another example with more gates and shots simulation:importnumpyasnpfromqiboimportCircuit,gatesc=Circuit(2)c.add(gates.X(0))# Add a measurement register on both qubitsc.add(gates.M(0,1))# Execute the circuit with the default initial state |00>.result=c(nshots=100)In both cases, the simulation will run in a single device CPU or GPU in double precisioncomplex128.Citation policyIf you use the package please refer tothe documentationfor citation instructions.ContactsTo get in touch with the community and the developers, consider joining the Qibo workspace on Matrix:https://matrix.to/#/#qibo:matrix.orgSupporters and collaboratorsQuantum Research Center, Technology Innovation Institute (TII), United Arab EmiratesUniversità degli Studi di Milano (UNIMI), Italy.Istituto Nazionale di Fisica Nucleare (INFN), Italy.Università degli Studi di Milano-Bicocca (UNIMIB), Italy.European Organization for Nuclear research (CERN), Switzerland.Universitat de Barcelona (UB), Spain.Barcelona Supercomputing Center (BSC), Spain.Qilimanjaro Quantum Tech, Spain.Centre for Quantum Technologies (CQT), Singapore.Institute of High Performance Computing (IHPC), Singapore.National Supercomputing Centre (NSCC), Singapore.RIKEN Center for Computational Science (R-CCS), Japan.NVIDIA (cuQuantum), USA.
Package: qibocal
QibocalQibocal provides Quantum Characterization Validation and Verification protocols usingQiboandQibolab.Qibocal key features:Automatization of calibration protocols.Declarative inputs using runcard.Generation of a report.DocumentationQibocal documentation is availablehere.InstallationThe package can be installed by source:gitclonehttps://github.com/qiboteam/qibocal.gitcdqibocal
pipinstall.Developer instructionsFor development make sure to install the package usingpoetryand to install the pre-commit hooks:gitclonehttps://github.com/qiboteam/qibocal.gitcdqibocal
poetryinstall
pre-commitinstallMinimal working exampleThis section shows the steps to perform a resonator spectroscopy with Qibocal.Write a runcardA runcard contains all the essential information to run a specific task.
For our purposes, we can use the following:platform: tii1q

qubits: [0]

- id: resonator spectroscopy high power
  priority: 0
  operation: resonator_spectroscopy
  parameters:
    freq_width: 10_000_000
    freq_step: 500_000
    amplitude: 0.4
    power_level: high
    nshots: 1024
    relaxation_time: 0How to run protocolsTo run the protocols specified in theruncard, Qibocal uses theqq autocommandqqauto<runcard>-o<output_folder>if<output_folder>is specified, the results will be saved in it, otherwiseqqwill automatically create a default folder containing the current date and the username.Uploading reports to serverIn order to upload the report to a centralized server, send to the server administrators your public ssh key (from the machine(s) you are planning to upload the report) and then use theqq upload <output_folder>command. This program will upload your report to the server and generate an unique URL.ContributingContributions, issues and feature requests are welcome!
Feel free to checkCitation policyIf you use the package please refer tothe documentationfor citation instructions
Package: qibochem
QibochemQibochem is a plugin toQibofor quantum chemistry simulations.Some of the features of Qibochem are:General purposeMoleculeclassPySCF for calculating the molecular  1- and 2-electron integralsUser defined orbital active spaceUnitary Coupled Cluster AnsatzVarious Qibo backends (numpy, JIT, TN) for efficient simulationDocumentationThe Qibochem documentation can be foundhereMinimum working example:An example of building the UCCD ansatz with a H2 moleculeimport numpy as np
from qibo.models import VQE

from qibochem.driver.molecule import Molecule
from qibochem.ansatz.hf_reference import hf_circuit
from qibochem.ansatz.ucc import ucc_circuit

# Define the H2 molecule and obtain its 1-/2- electron integrals with PySCF
h2 = Molecule([('H', (0.0, 0.0, 0.0)), ('H', (0.0, 0.0, 0.7))])
h2.run_pyscf()
# Generate the molecular Hamiltonian
hamiltonian = h2.hamiltonian()

# Build a UCC circuit ansatz for running VQE
circuit = hf_circuit(h2.nso, sum(h2.nelec))
circuit += ucc_circuit(h2.nso, [0, 1, 2, 3])

# Create and run the VQE, starting with random initial parameters
vqe = VQE(circuit, hamiltonian)

initial_parameters = np.random.uniform(0.0, 2*np.pi, 8)
best, params, extra = vqe.minimize(initial_parameters)Citation policyIf you use the Qibochem plugin please refer to the documentation for citation instructions.ContactFor questions, comments and suggestions please contact us athttps://matrix.to/#/#qibo:matrix.orgContributingContributions, issues and feature requests are welcome.
Package: qibo-client
Qibo clientThe documentation of the project can be foundhere.InstallInstall first the package dependencies with the following commands.We recommend to start with a fresh virtual environment to avoid dependencies
conflicts with previously installed packages.python-mvenv./envsourceactivate./env/bin/activateTheqibo-clientpackage can be installed throughpip:pipinstallqibo-clientQuick startOnce installed, the provider allows to run quantum circuit computations on the
TiiQ remote server.:warning: Note: to run jobs on the remote cluster it is mandatory to own a
validated account.
Please, sign up tothis linkto
obtain the needed token to run computations on the cluster.The following snippet provides a basic usage example.
Replace theyour-tii-qrc-tokenstring with your user token received during the
registration process.importqiboimportqibo_client# create the circuit you want to runcircuit=qibo.models.QFT(5)# authenticate to server through the client instancetoken="your-tii-qrc-token"client=qibo_client.TII(token)# run the circuitresult=client.run_circuit(circuit,nshots=1000,dev="sim")
Package: qiboconnection
QiboconnectionPython library that allows you to execute quantum programs on Qilimanjaro's QPUs and simulators.ContributionsThank you for your interest in our project. While we appreciate your enthusiasm and interest in contributing, we would like to clarify our policy regarding external contributions.Our Contribution PolicyThis project is primarily intended for reference purposes, and we do not actively accept or manage external contributions, including pull requests and issue reports. Our development team maintains this codebase for internal use and does not have the capacity to review or merge contributions from the community.Why We Have This PolicyOur decision to limit external contributions is based on our specific project goals, resource constraints, and internal policies. While we understand the value of collaboration and open-source contributions, we have chosen to maintain this project as a reference rather than a collaborative, community-driven effort.Seeking Help and SupportIf you have questions about using this project or encounter issues, please feel free to open an issue in the repository for discussion. However, please be aware that our ability to provide support or address issues may be limited.Thank you for your understanding and for considering our project. We hope that you find it useful for your needs, and we wish you the best in your open-source endeavors.Sincerely,Qilimanjaro Quantum Tech
Package: qibolab
QibolabQibolab is the dedicatedQibobackend for
the automatic deployment of quantum circuits on quantum hardware.Some of the key features of Qibolab are:Deploy Qibo models on quantum hardware easily.Create custom experimental drivers for custom lab setup.Support multiple heterogeneous platforms.Use existing calibration procedures for experimentalists.DocumentationThe qibolab backend documentation is available athttps://qibo.science/qibolab/stable/.Minimum working exampleA simple example on how to connect to a platform and use it execute a pulse sequence:fromqibolabimportcreate_platform,ExecutionParametersfromqibolab.pulsesimportDrivePulse,ReadoutPulse,PulseSequence# Define PulseSequencesequence=PulseSequence()# Add some pulses to the pulse sequencesequence.add(DrivePulse(start=0,amplitude=0.3,duration=4000,frequency=200_000_000,relative_phase=0,shape="Gaussian(5)",# Gaussian shape with std = duration / 5channel=1,))sequence.add(ReadoutPulse(start=4004,amplitude=0.9,duration=2000,frequency=20_000_000,relative_phase=0,shape="Rectangular",channel=2,))# Define platform and load specific runcardplatform=create_platform("my_platform")# Connects to lab instruments using the details specified in the calibration settings.platform.connect()# Execute a pulse sequenceoptions=ExecutionParameters(nshots=1000)results=platform.execute_pulse_sequence(sequence,options)# Print the acquired shotsprint(results.samples)# Disconnect from the instrumentsplatform.disconnect()Here is another example on how to execute circuits:importqibofromqiboimportgates,models# Create circuit and add gatesc=models.Circuit(1)c.add(gates.H(0))c.add(gates.RX(0,theta=0.2))c.add(gates.X(0))c.add(gates.M(0))# Simulate the circuit using numpyqibo.set_backend("numpy")for_inrange(5):result=c(nshots=1024)print(result.probabilities())# Execute the circuit on hardwareqibo.set_backend("qibolab",platform="my_platform")for_inrange(5):result=c(nshots=1024)print(result.probabilities())Citation policyIf you use the package please refer tothe documentationfor citation instructions.
Package: qibosoq
QibosoqRepository for developing server side of RFSoC fpga boards
Qibosoq is a server for integratingQickin theQibolabecosystem
for executing arbitrary pulses sequences on QPUs.The complete documentation for can be found at:qibo.science/qibosoq/stableqibo.science/qibosoq/latestInstallationPlease refer to thedocumentationfor installation instructions.Configuration parametersInconfiguration.pysome default qibosoq parameters are hardcoded. They can be changed using environment variables (see documentation).IP of the serverPort of the serverPaths of log filesName of python loggersPath of bitstreamType of readout (multiplexed or not, depending on the loaded bitstream)Run the serverThe simplest way of executing the server is:sudo -E python -m qibosoqand the server can be closed withCtrl-C.Note that with this command the script will close as soon as the terminal where it's running it's closed.
To run the server in detached mode you can use:nohup sudo -E python -m qibosoq &And the server can be closed withsudo kill <PID>(PID will be saved in log).TII boardsWith TII boards the server can also be executed using the aliasserver-run-bkg.Also, two additional command are added in.bashrc:serverinfoandserverclose.serverinfowill print the PID if the server is running, otherwise will print "No running server".serverclosewill close the server, if it is running.All these commands require sudo privileges.ContributingContributions, issues and feature requests are welcome!
Feel free to check
Package: qibotf
qibotfThis package provides acceleration features forQibousingTensorFlowcustom operators.DocumentationThe qibotf backend documentation is available atqibo.readthedocs.io.Support and requirementsHere a compatibility matrix for the qibotf versions:qibotfref. qibotensorflowOS HardwareCUDA0.0.6>=0.1.72.8.0 for pip (>=2.2 for source)linux cpu/gpu, mac cpu(pip)/gpu(source)11.20.0.5>=0.1.72.7.1 for pip (>=2.2 for source)linux cpu/gpu, mac cpu(pip)/gpu(source)11.20.0.4>=0.1.72.7.0 for pip (>=2.2 for source)linux cpu/gpu, mac cpu(pip)/gpu(source)11.20.0.30.1.62.6.0 for pip (>=2.2 for source)linux cpu/gpu, mac cpu(pip)/gpu(source)11.20.0.20.1.62.5.0 for pip (>=2.2 for source)linux cpu/gpu, mac cpu(pip)/gpu(source)11.20.0.10.1.62.4.1 for pip (>=2.2 for source)linux cpu/gpu, mac cpu(pip)/gpu(source)11.0Citation policyIf you use the package please cite the following references:https://arxiv.org/abs/2009.01845https://doi.org/10.5281/zenodo.3997194
Package: qichacha
Xiang Wang @ 2019-02-18 15:41:48企查查api文档安装步骤申请自己的数据安装pip install qichacha创建clientfrom qichacha import QichachaClient
client = QichachaClient(key="您的key", secretkey="您的密钥", logger="您的logger，可以不填")调用接口client.search(name="小桔科技")接口详细文档企业工商数据查询企业关键字模糊查询接口文档地址>>> result, response = client.search(name="小桔科技")
>>> print(result)
[
    {
      "KeyNo": "4659626b1e5e43f1bcad8c268753216e",
      "Name": "北京小桔科技有限公司",
      "OperName": "程维",
      "StartDate": "2012-07-10T00:00:00",
      "Status": "存续（在营、开业、在册）",
      "No": "110108015068911",
      "CreditCode": "9111010859963405XW"
    },
    {
      "KeyNo": "4178fc374c59a79743c59ecaf098d4dd",
      "Name": "深圳市小桔科技有限公司",
      "OperName": "王举",
      "StartDate": "2015-04-22T00:00:00",
      "Status": "存续",
      "No": "440301112653267",
      "CreditCode": "91440300334945450M"
    },
    ...
]其他如有疑问或者需求提供其他接口，欢迎提交PR或者联系ramwin@qq.com
Package: qicna
About pyQICpyQICis a python package for generating quasi-isodynamic stellarator configurations using an expansion about magnetic axis.  pyQIC is written in pure python. This makes pyQIC user-friendly, with no need for compilation. though it is slower.This code implements the equations derived by Garren and Boozer (1991) for MHD equilibrium near the magnetic axis.RequirementspyQIChas minimal dependencies - it requires only python3, numpy, scipy, matplotlib. If you don't already have numpy, scipy and matplotlib, they will be installed automatically by thepip installstep in theRun the Codesection.USEFUL LINKSIf you need more help clickhereINSTALLATIONTo install the code you will need to follow the steps bellow:To install this code you will need to open your Shell and insert the following command:pip install .First of all you need to copy the folders and the files with the "git clone" command followed by the github repository's link.
Example:git clone _link_Then intall the package to your local python environment with:cd pyQIC
pip install -eThen you also need to install the librarys below:numpyscipymatplotlibExample:pip install numpy scipy matplotlibRUN THE CODETo run this code you will need to use your Python and insert the following command:from qic import Qic
stel = Qic.from_paper('r2 section 5.2')
Package: qif
libqifInstallpipinstallqifNeedspython>= 3.8 and asandybridgeor later CPUOn linuxpip>= 19 is needed (make sure topip install -U pip)A sample programfromqifimport*defcompute_bayes(C):pi=probab.uniform(C.shape[0])print("Channel:\n",C)print("Prior:\n",pi)print("Bayes vulnerability",measure.bayes_vuln.posterior(pi,C))print("Bayes mult-capacity",measure.bayes_vuln.mult_capacity(C))compute_bayes(channel.randu(5))# same, but using rational arithmeticqif.set_default_type(qif.rat)C=np.array([[rat(1,2),rat(1,4),rat(1,4)],[rat(1,6),rat(3,6),rat(2,6)],[rat(1,2),rat(1,2),rat(0)],])compute_bayes(C)DocumentationA list of methods provided byqifis availablehere.Use libqif with C++See theinstallation instructions.
Package: qif2ofx
qif2ofxConvert credit card transactions inQuicken Interchange format(QIF) toOpen Financial Exchange(OFX).
Use this if you can only comfortably import OFX in your finance tool of choice. For example, I usebeancount-import(what an excellent tool!), but so far it only directly supports ingesting OFX. My bank decides to only distribute in QIF, so hence this (lazy) way of solving the problem.The converter assumes you have credit card transactions in your QIF, and not whatever else QIF can be used to represent, because that's my only use-case so far.InstallThe following provides the executableqif2ofxand the python libraryqif2ofx:pip install qif2ofxUsageOFX is a lot richer than QIF, from what I gathered from briefly looking atthe specification(don't, if you want to preserve your sanity. It hurts my eyes. Why did they make all the tags in capital letters). QIF is basically a list of transactions, without real context, while OFX offers rich descriptions of all sorts of financial concepts. Hell, QIF doesn't even have a concept of currency. Hence to convert our QIF input to OFX we need to provide a bunch of metadata:qif2ofx \ 
  # A glob expression, or path for that matter, of QIF files
  # we'd like to convert to OFX
  --glob "path/to/**/*.qif" \

  # The currency we'd like to set in our OFX file. 
  --currency GBP \

  # Again, QIF has no notion of accounts, OFX does. Tools handling
  # OFX expect an account identifier so they can reconcile with
  # the appropriate account in the money management tool.
  --acctid puppiesThis is the bare minimum we need to generate a valid-ish OFX out of your QIF. You can set a few more options through the command line to control some details, seeqif2ofx --helpfor more details.
Package: qifparse
QIF Parserqifparse is a parser for Quicken interchange format files (.qif).Even if the qif format is:quite old nownot supported for import by Quicken any more,ambiguous in some data management (notably on dates)it’s still quite commonly used by many personal finance managers.UsageHere’s a sample parsing:>>> from qifparse.parser import QifParser
>>> qif = QifParser.parse(file('file.qif'))
>>> qif.get_accounts()
(<qifparse.qif.Account object at 0x16148d0>, <qifparse.qif.Account object at 0x1614850>)
>>> qif.accounts[0].name
'My Cash'
>>> qif.get_categories()
(<qifparse.qif.Category object at 0x15b3d10>, <qifparse.qif.Category object at 0x15b3450>)
>>> qif.accounts[0].get_transactions()
(<Transaction units=-6.5>, <Transaction units=-6.0>)
>>> str(qif)
'!Type:Cat\nNfood\nE\n^\nNfood:lunch\nE\n^\n!Account\nNMy Cash\nTCash\n^\n!Type:Cash...
...Here’s a sample of a structure creation:>>> qif_obj = qif.Qif()
>>> acc = qif.Account(name='My Cc', account_type='Bank')
>>> qif_obj.add_account(acc)
>>> cat = qif.Category(name='food')
>>> qif_obj.add_category(cat)
>>> tr1 = qif.Transaction(amount=0.55)
>>> acc.add_transaction(tr1, header='!Type:Bank')

>>> tr2 = qif.Transaction()
>>> tr2.amount = -6.55
>>> tr2.to_account = 'Cash'
>>> acc.add_transaction(tr2)
>>> acc.add(tr2)
>>> str(qif_obj)
'!Type:Cat\nNfood\nE\n^\n!Account\nNMy Cc\nTBank\n^\n!Type:Bank\nD02/11/2013\nT...
...More infosFor more informations about qif format:http://en.wikipedia.org/wiki/Quicken_Interchange_Formathttp://svn.gnucash.org/trac/browser/gnucash/trunk/src/import-export/qif-import/file-format.txtChangelog0.5 (2013-11-03)now transactions can also be outside accountsmoved properties to method in order to accept filters0.4 (2013-11-02)address can be multilinessplit can have the address attributeadd support for Classesadd support for MemorizedTransaction0.3 (2013-11-02)more refactoring, now the lib is much more simple and engineeredimproved fields validation0.2 (2013-11-02)huge refactor, now the structure can be create and modified programmatically0.1 (2013-11-01)first release on Pypi
Package: qifparser
QIF Parserqifparse is a parser for Quicken interchange format files (.qif).Even if the qif format is:quite old nownot supported for import by Quicken any more,ambiguous in some data management (notably on dates)it’s still quite commonly used by many personal finance managers.UsageHere’s a sample parsing:>>> from qifparse.parser import QifParser
>>> qif = QifParser.parse(file('file.qif'))
>>> qif.get_accounts()
(<qifparse.qif.Account object at 0x16148d0>, <qifparse.qif.Account object at 0x1614850>)
>>> qif.accounts[0].name
'My Cash'
>>> qif.get_categories()
(<qifparse.qif.Category object at 0x15b3d10>, <qifparse.qif.Category object at 0x15b3450>)
>>> qif.accounts[0].get_transactions()
(<Transaction units=-6.5>, <Transaction units=-6.0>)
>>> str(qif)
'!Type:Cat\nNfood\nE\n^\nNfood:lunch\nE\n^\n!Account\nNMy Cash\nTCash\n^\n!Type:Cash...
...Here’s a sample of a structure creation:>>> qif_obj = qif.Qif()
>>> acc = qif.Account(name='My Cc', account_type='Bank')
>>> qif_obj.add_account(acc)
>>> cat = qif.Category(name='food')
>>> qif_obj.add_category(cat)
>>> tr1 = qif.Transaction(amount=0.55)
>>> acc.add_transaction(tr1, header='!Type:Bank')

>>> tr2 = qif.Transaction()
>>> tr2.amount = -6.55
>>> tr2.to_account = 'Cash'
>>> acc.add_transaction(tr2)
>>> acc.add(tr2)
>>> str(qif_obj)
'!Type:Cat\nNfood\nE\n^\n!Account\nNMy Cc\nTBank\n^\n!Type:Bank\nD02/11/2013\nT...
...More infosFor more informations about qif format:http://en.wikipedia.org/wiki/Quicken_Interchange_Formathttp://svn.gnucash.org/trac/browser/gnucash/trunk/src/import-export/qif-import/file-format.txtChangelog0.6 (unreleased)fixed typo in account types0.5 (2013-11-03)now transactions can also be outside accountsmoved properties to method in order to accept filters0.4 (2013-11-02)address can be multilinessplit can have the address attributeadd support for Classesadd support for MemorizedTransaction0.3 (2013-11-02)more refactoring, now the lib is much more simple and engineeredimproved fields validation0.2 (2013-11-02)huge refactor, now the structure can be create and modified programmatically0.1 (2013-11-01)first release on Pypi
Package: qifqif
qifqif/kĭf kĭf/:adj. inv.arabic slang (كيف) for “it’s all the same”.n.CLI tool forcategorizingqif files. It can make all the difference.DescriptionCLI tool toenrichyour QIF files transactions with category
information, hencecutting down import time from minutes to mere
seconds.QIF is a format widely used by personal money management software such
asGnuCashto import information. Yet, the
import process is particularly tedious as it require to manually pair
the transactions contained in the file with categories (or “accounts”
for double-entry bookkeeping systems).qifqif augment your qif files by adding a category line for each
transaction, that additional information can then be used by accounting
software to perform automatic QIF imports. It picks categories by
searching for predefined keywords in transactions descriptions lines and
by repeating choices you previously made regarding similar transactions.FeaturesQuickstart:create categories by importing your existing accounts
withqifaccBlazing fast edits:thanks to well-thought-out defaults and<TAB>completionAuditing mode:review your transactions one by oneBatch mode (no interactive):for easy integration with scriptsEasy-going workflow:dreading the behemoth task of importing
years of accounting from a single file? Don’t be. Go at your own pace
and press<Ctrl+C>to exit anytime. On next run, editing will
resume right where you left it.Usageusage: qifqif.py [-h] [-a | -b] [-c CONFIG] [-d] [-f] [-o DEST] [-v] QIF_FILE

Enrich your .QIF files with tags. See https://github.com/Kraymer/qifqif for
more infos.

positional arguments:
  QIF_FILE              .QIF file to process

optional arguments:
  -h, --help            show this help message and exit
  -a, --audit-mode      pause after each transaction
  -b, --batch-mode      skip transactions that require user input
  -c CONFIG, --config CONFIG
                        configuration filename in json format. DEFAULT:
                        ~/.qifqif.json
  -d, --dry-run         just print instead of writing file
  -f, --force           discard transactions categories if not present in
                        configuration file. Repeat the flag (-ff) to force
                        editing of all transactions.
  -o DEST, --output DEST
                        output filename. DEFAULT: edit input file in-place
  -v, --version         display version information and exitMore infos on thedocumentationwebsite.Installationqiqif is written forPython 2.7+andPython
3.5+.Install withpipviapip install qifqifcommand.ChangelogAvailable onGithub Releases
page.FeedbacksPlease submit bugs and features requests on theIssue
tracker.