# QuAIRKit
QuAIRKit is a Python SDK for algorithm development in quantum computing, quantum information, and quantum machine learning. It focuses on flexible design, real-time simulation and rapid verification of quantum and classical algorithms.
<p align="center">
<!-- docs -->
<a href="https://quairkit.com/QuAIRKit/latest/index.html">
<img src="https://img.shields.io/badge/docs-link-green.svg?style=flat-square&logo=read-the-docs"/>
</a>
<!-- PyPI -->
<a href="https://pypi.org/project/quairkit/">
<img src="https://img.shields.io/badge/pypi-v0.4.1-orange.svg?style=flat-square&logo=pypi"/>
</a>
<!-- Python -->
<a href="https://www.python.org/">
<img src="https://img.shields.io/badge/Python-3.8+-blue.svg?style=flat-square&logo=python"/>
</a>
<!-- License -->
<a href="./LICENSE">
<img src="https://img.shields.io/badge/license-Apache%202.0-blue.svg?style=flat-square&logo=apache"/>
</a>
<!-- Platform -->
<a href="https://github.com/PaddlePaddle/Quantum">
<img src="https://img.shields.io/badge/OS-MacOS%20|%20Windows%20|%20Linux-lightgrey.svg?style=flat-square"/>
</a>
</p>
QuAIRKit provides the following functionalities,
- Quantum algorithm simulation & optimization
- Quantum circuit simulation & visualization
- Quantum channel simulation
- Quantum algorithm/information tools
## Installation
The minimum Python environment for QuAIRKit is `3.8`. We recommend installing QuAIRKit with Python `3.10`.
```bash
conda create -n quair python=3.10
conda activate quair
conda install jupyter notebook
```
We recommend the following way of installing QuAIRKit with pip,
```bash
pip install quairkit
```
or download all the files and finish the installation locally,
```bash
git clone https://github.com/QuAIR/QuAIRKit
cd QuAIRKit
pip install -e . --config-settings editable_mode=strict
```
## Setup
After installation, you can import QuAIRKit in your Python code as follows:
```python
import quairkit as qkit
import torch # library for tensor manipulation
from quairkit import Circuit # standard quantum circuit interface
from quairkit.database import ... # common matrices, sets, Hamiltonian, states, etc.
from quairkit.qinfo import ... # common functions in quantum information processing
from quairkit.loss import ... # common loss operators in neural network training
```
QuAIRKit provides global setup functions to set the default data type, device and random seed.
```python
qkit.set_dtype('complex128') # default data type is 'complex64'
qkit.set_device('cuda') # make sure CUDA is setup with torch
qkit.set_seed(73) # set seeds for all random number generators
```
## Features
QuAIRKit provides a wide range of features for quantum computing, quantum information processing and quantum machine learning. Below are some of the key features:
### Batch computation
QuAIRKit supports batch computations for quantum circuit simulations, state measurement and quantum information processing. It is easy to use and can be customized for different quantum (machine learning) algorithms.
Below is an example of batch computation for quantum circuit simulation. Here a zero state is passed through four different quantum circuits, and compared with the target state.
```python
target_state = zero_state(1)
unitary_data = pauli_group(1) # I, Pauli-X/Y/Z
cir = Circuit(1)
cir.oracle(unitary_data, 0)
cir.ry(param=[0, 1, 2, 3])
output_state = cir() # zero-state input by default
print(state_fidelity(cir(), target_state))
```
```text
tensor([1.0000, 0.4794, 0.8415, 0.0707])
```
Above output is equivalent to
```math
\left|\bra{0} R_z(0)\,I \ket{0} \right|,\,\,
\left|\bra{0} R_z(1)\,X \ket{0} \right|,\,\,
\left|\bra{0} R_z(2)\,Y \ket{0} \right|,\,\,
\left|\bra{0} R_z(3)\,Z \ket{0} \right|
```
### Qudit computation
QuAIRKit also supports batch computations for quantum circuit simulations and most of the quantum information processing tools in qudit quantum computing, as shown below
```python
# claim three systems, with 1 qubit and 1 qutrit
cir = Circuit(2, system_dim=[2, 3])
# apply 6^2 Heisenberg-Weyl operators on all systems
cir.oracle(heisenberg_weyl(6), [0, 1])
# apply the H gate on the qubit, controlled by the qutrit
cir.oracle(h(), [1, 0], control_idx=0)
# trace out the qutrit system and get the qubit state
traced_state = cir().trace(1)
print('The 6th and 7th state for the batched qubit state is', traced_state[5:7])
```
```text
The 6th and 7th state for the batched qubit state is
---------------------------------------------------
Backend: density_matrix
System dimension: [2]
System sequence: [0]
Batch size: [2]
# 0:
[[1.+0.j 0.+0.j]
[0.+0.j 0.+0.j]]
# 1:
[[0.5+0.j 0.5+0.j]
[0.5+0.j 0.5+0.j]]
---------------------------------------------------
```
### Probabilistic computation
QuAIRKit supports probabilistic quantum circuit simulation, which allows you to simulate quantum circuits with probabilistic operations, such as measurement, partial post-selection, LOCC. This is useful in quantum communication protocols or quantum algorithm design. This functional is also compatible with batch computation and qudit computation.
Below is the implementation of a qubit teleportation protocol in QuAIRKit.
```python
M1_locc = torch.stack([eye(), x()]) # apply X gate for measure outcome 1
M2_locc = torch.stack([eye(), z()]) # apply Z gate for measure outcome 1
# setup protocol
cir = Circuit(3)
cir.cnot([0, 1])
cir.h(0)
cir.locc(M1_locc, [1, 2]) # measure on qubit 1, apply local operations on qubit 2
cir.locc(M2_locc, [0, 2]) # measure on qubit 0, apply local operations on qubit 2
# test with 100 random single-qubit (mixed) states
psi = random_state(1, size=100)
input_state = nkron(psi, bell_state(2))
output_state = cir(input_state).trace([0, 1]) # discard first two qubits
fid = state_fidelity(output_state.expec_state(), psi).mean().item()
print('The average fidelity of the teleportation protocol is', fid)
```
```text
The average fidelity of the teleportation protocol is 0.9999999999998951
```
### Other functionalities
#### Plot circuit with LaTeX
Circuit in QuAIRKIt can be plotted with Quantikz, a LaTeX package for quantum circuit visualization, which is useful for academic presentation. You can use the `plot` function to visualize the circuit. Make sure you have up-to-date LaTeX installed on your system, so that the `quantikz` package is available.
```python
cir: Circuit = ...
cir.plot(print_code=True) # plot the circuit with LaTeX code
```
See the [tutorial](tutorials/feature/plot.ipynb) for more details.
#### Third-party Cloud Integration
QuAIRKit supports third-party cloud integration, which allows you to run quantum circuits on real quantum devices with QuAIRKit interfaces. You can use the `set_backend` function to set the backend for measurement and computation of expectation value.
```python
class YourState(qkit.StateOperator):
def _execute(self, qasm: str, shots: int) -> Dict[str, int]:
r"""IMPLEMENT HERE to execute the circuit on the quantum cloud."""
qkit.set_backend(YourState)
```
See the [tutorial](tutorials/feature/cloud.ipynb) for more details.
#### Fast construction
QuAIRKit provides a fast and flexible way to construct quantum circuits, by self-managing the parameters. All parameters would be created randomly if not specified. QuAIRKit also supports built-in layer ansatz, such as `complex_entangled_layer`.
```python
cir = Circuit(2)
cir.rx() # apply Rx gates on all qubits with random parameters
cir.complex_entangled_layer(depth=2) # apply complex entangled layers of depth 2
cir.universal_two_qubits() # apply universal two-qubit gate with random parameters
```
`Circuit` is a child class of `torch.nn.Module`, so you can access its parameters and other attributes directly, or use it as a layer in a hybrid neural network.
#### Implicit transition
If you want to perform noise simulation or mixed-state-related tools, there is no need to specify the backend, or import other libraries. Just call the function, and QuAIRKit will transit the backend for you.
```python
cir = Circuit(3)
cir.complex_entangled_layer(depth=3)
print(cir().backend)
# partial transpose on the first two qubits
print(cir().transpose([0, 1]).backend)
cir.depolarizing(prob=0.1)
print(cir().backend)
```
```text
default-pure
default-mixed
default-mixed
```
## Tutorials
- [Introduction](tutorials/introduction)
- [Constructing quantum circuits in QuAIRKit](tutorials/introduction/circuit.ipynb)
- [Manipulation of quantum states in QuAIRKit](tutorials/introduction/state.ipynb)
- [Measuring quantum states in QuAIRKit](tutorials/introduction/measure.ipynb)
- [Hamiltonian in QuAIRKit](tutorials/introduction/Hamiltonian.ipynb)
- [Quantum information tools](tutorials/introduction/qinfo.ipynb)
- [Quantum gates and quantum channels](tutorials/introduction/operator.ipynb)
- [Training parameterized quantum circuits](tutorials/introduction/training.ipynb)
- [Feature](tutorials/feature)
- [Batch computation](tutorials/feature/batch.ipynb)
- [Drawing Quantum Circuits with QuAIRKit](tutorials/feature/plot.ipynb)
- [Neural network setup customization](tutorials/feature/custom.ipynb)
- [Introduction to qudit quantum computing](tutorials/feature/qudit.ipynb)
- [Running QuAIRKit with third-party quantum cloud platforms](tutorials/feature/cloud.ipynb)
- [Research](tutorials/research)
- [Analyze Barren Plateau in quantum neural networks](tutorials/research/bp.ipynb)
- [Hamiltonian simulation via Trotter decomposition](tutorials/research/trotter.ipynb)
- [Quantum State Teleportation and Distribution](tutorials/research/locc.ipynb)
- [Rediscovering Simon's algorithm with PQC](tutorials/research/simon.ipynb)
- [Training quantum process transformation with PQC](tutorials/research/comb.ipynb)
## Acknowledgements
We appreciate the kind support from the [Sourcery AI](https://sourcery.ai) that greatly enhances the coding & review quality of the QuAIRKit project.
Raw data
{
"_id": null,
"home_page": null,
"name": "quairkit",
"maintainer": null,
"docs_url": null,
"requires_python": "<4,>=3.8",
"maintainer_email": "\"QuAIR team.\" <leizhang116.4@gmail.com>",
"keywords": "quantum computing, quantum information, quantum machine learning, torch",
"author": null,
"author_email": "\"QuAIR team.\" <leizhang116.4@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/6b/db/8c78a524e43be67b399aabdd4624f73a778a2240475b94012eef40ae8fb0/quairkit-0.4.1.tar.gz",
"platform": null,
"description": "# QuAIRKit\r\n\r\nQuAIRKit is a Python SDK for algorithm development in quantum computing, quantum information, and quantum machine learning. It focuses on flexible design, real-time simulation and rapid verification of quantum and classical algorithms.\r\n\r\n<p align=\"center\">\r\n <!-- docs -->\r\n <a href=\"https://quairkit.com/QuAIRKit/latest/index.html\">\r\n <img src=\"https://img.shields.io/badge/docs-link-green.svg?style=flat-square&logo=read-the-docs\"/>\r\n </a>\r\n <!-- PyPI -->\r\n <a href=\"https://pypi.org/project/quairkit/\">\r\n <img src=\"https://img.shields.io/badge/pypi-v0.4.1-orange.svg?style=flat-square&logo=pypi\"/>\r\n </a>\r\n <!-- Python -->\r\n <a href=\"https://www.python.org/\">\r\n <img src=\"https://img.shields.io/badge/Python-3.8+-blue.svg?style=flat-square&logo=python\"/>\r\n </a>\r\n <!-- License -->\r\n <a href=\"./LICENSE\">\r\n <img src=\"https://img.shields.io/badge/license-Apache%202.0-blue.svg?style=flat-square&logo=apache\"/>\r\n </a>\r\n <!-- Platform -->\r\n <a href=\"https://github.com/PaddlePaddle/Quantum\">\r\n <img src=\"https://img.shields.io/badge/OS-MacOS%20|%20Windows%20|%20Linux-lightgrey.svg?style=flat-square\"/>\r\n </a>\r\n</p>\r\n\r\nQuAIRKit provides the following functionalities,\r\n\r\n- Quantum algorithm simulation & optimization\r\n- Quantum circuit simulation & visualization\r\n- Quantum channel simulation\r\n- Quantum algorithm/information tools\r\n\r\n## Installation\r\n\r\nThe minimum Python environment for QuAIRKit is `3.8`. We recommend installing QuAIRKit with Python `3.10`.\r\n\r\n```bash\r\nconda create -n quair python=3.10\r\nconda activate quair\r\nconda install jupyter notebook\r\n```\r\n\r\nWe recommend the following way of installing QuAIRKit with pip,\r\n\r\n```bash\r\npip install quairkit\r\n```\r\n\r\nor download all the files and finish the installation locally,\r\n\r\n```bash\r\ngit clone https://github.com/QuAIR/QuAIRKit\r\ncd QuAIRKit\r\npip install -e . --config-settings editable_mode=strict\r\n```\r\n\r\n## Setup\r\n\r\nAfter installation, you can import QuAIRKit in your Python code as follows:\r\n\r\n```python\r\nimport quairkit as qkit\r\nimport torch # library for tensor manipulation\r\n\r\nfrom quairkit import Circuit # standard quantum circuit interface\r\n\r\nfrom quairkit.database import ... # common matrices, sets, Hamiltonian, states, etc.\r\nfrom quairkit.qinfo import ... # common functions in quantum information processing\r\nfrom quairkit.loss import ... # common loss operators in neural network training\r\n```\r\n\r\nQuAIRKit provides global setup functions to set the default data type, device and random seed.\r\n\r\n```python\r\nqkit.set_dtype('complex128') # default data type is 'complex64'\r\nqkit.set_device('cuda') # make sure CUDA is setup with torch\r\nqkit.set_seed(73) # set seeds for all random number generators\r\n```\r\n\r\n## Features\r\n\r\nQuAIRKit provides a wide range of features for quantum computing, quantum information processing and quantum machine learning. Below are some of the key features:\r\n\r\n### Batch computation\r\n\r\nQuAIRKit supports batch computations for quantum circuit simulations, state measurement and quantum information processing. It is easy to use and can be customized for different quantum (machine learning) algorithms.\r\n\r\nBelow is an example of batch computation for quantum circuit simulation. Here a zero state is passed through four different quantum circuits, and compared with the target state.\r\n\r\n```python\r\ntarget_state = zero_state(1)\r\nunitary_data = pauli_group(1) # I, Pauli-X/Y/Z\r\n\r\ncir = Circuit(1)\r\ncir.oracle(unitary_data, 0)\r\ncir.ry(param=[0, 1, 2, 3])\r\n\r\noutput_state = cir() # zero-state input by default\r\nprint(state_fidelity(cir(), target_state)) \r\n```\r\n\r\n```text\r\ntensor([1.0000, 0.4794, 0.8415, 0.0707])\r\n```\r\n\r\nAbove output is equivalent to\r\n\r\n```math\r\n\\left|\\bra{0} R_z(0)\\,I \\ket{0} \\right|,\\,\\,\r\n\\left|\\bra{0} R_z(1)\\,X \\ket{0} \\right|,\\,\\,\r\n\\left|\\bra{0} R_z(2)\\,Y \\ket{0} \\right|,\\,\\,\r\n\\left|\\bra{0} R_z(3)\\,Z \\ket{0} \\right|\r\n```\r\n\r\n### Qudit computation\r\n\r\nQuAIRKit also supports batch computations for quantum circuit simulations and most of the quantum information processing tools in qudit quantum computing, as shown below\r\n\r\n```python\r\n# claim three systems, with 1 qubit and 1 qutrit\r\ncir = Circuit(2, system_dim=[2, 3])\r\n\r\n# apply 6^2 Heisenberg-Weyl operators on all systems\r\ncir.oracle(heisenberg_weyl(6), [0, 1])\r\n\r\n# apply the H gate on the qubit, controlled by the qutrit\r\ncir.oracle(h(), [1, 0], control_idx=0)\r\n\r\n# trace out the qutrit system and get the qubit state\r\ntraced_state = cir().trace(1)\r\n\r\nprint('The 6th and 7th state for the batched qubit state is', traced_state[5:7])\r\n```\r\n\r\n```text\r\nThe 6th and 7th state for the batched qubit state is \r\n---------------------------------------------------\r\n Backend: density_matrix\r\n System dimension: [2]\r\n System sequence: [0]\r\n Batch size: [2]\r\n\r\n # 0:\r\n[[1.+0.j 0.+0.j]\r\n [0.+0.j 0.+0.j]]\r\n # 1:\r\n[[0.5+0.j 0.5+0.j]\r\n [0.5+0.j 0.5+0.j]]\r\n---------------------------------------------------\r\n```\r\n\r\n### Probabilistic computation\r\n\r\nQuAIRKit supports probabilistic quantum circuit simulation, which allows you to simulate quantum circuits with probabilistic operations, such as measurement, partial post-selection, LOCC. This is useful in quantum communication protocols or quantum algorithm design. This functional is also compatible with batch computation and qudit computation.\r\n\r\nBelow is the implementation of a qubit teleportation protocol in QuAIRKit.\r\n\r\n```python\r\nM1_locc = torch.stack([eye(), x()]) # apply X gate for measure outcome 1\r\nM2_locc = torch.stack([eye(), z()]) # apply Z gate for measure outcome 1\r\n\r\n# setup protocol\r\ncir = Circuit(3)\r\ncir.cnot([0, 1])\r\ncir.h(0)\r\ncir.locc(M1_locc, [1, 2]) # measure on qubit 1, apply local operations on qubit 2\r\ncir.locc(M2_locc, [0, 2]) # measure on qubit 0, apply local operations on qubit 2\r\n\r\n# test with 100 random single-qubit (mixed) states\r\npsi = random_state(1, size=100)\r\ninput_state = nkron(psi, bell_state(2))\r\noutput_state = cir(input_state).trace([0, 1]) # discard first two qubits\r\n\r\nfid = state_fidelity(output_state.expec_state(), psi).mean().item()\r\nprint('The average fidelity of the teleportation protocol is', fid)\r\n```\r\n\r\n```text\r\nThe average fidelity of the teleportation protocol is 0.9999999999998951\r\n```\r\n\r\n### Other functionalities\r\n\r\n#### Plot circuit with LaTeX\r\n\r\nCircuit in QuAIRKIt can be plotted with Quantikz, a LaTeX package for quantum circuit visualization, which is useful for academic presentation. You can use the `plot` function to visualize the circuit. Make sure you have up-to-date LaTeX installed on your system, so that the `quantikz` package is available.\r\n\r\n```python\r\ncir: Circuit = ...\r\ncir.plot(print_code=True) # plot the circuit with LaTeX code\r\n```\r\n\r\nSee the [tutorial](tutorials/feature/plot.ipynb) for more details.\r\n\r\n#### Third-party Cloud Integration\r\n\r\nQuAIRKit supports third-party cloud integration, which allows you to run quantum circuits on real quantum devices with QuAIRKit interfaces. You can use the `set_backend` function to set the backend for measurement and computation of expectation value.\r\n\r\n```python\r\nclass YourState(qkit.StateOperator):\r\n def _execute(self, qasm: str, shots: int) -> Dict[str, int]:\r\n r\"\"\"IMPLEMENT HERE to execute the circuit on the quantum cloud.\"\"\"\r\n\r\nqkit.set_backend(YourState)\r\n```\r\n\r\nSee the [tutorial](tutorials/feature/cloud.ipynb) for more details.\r\n\r\n#### Fast construction\r\n\r\nQuAIRKit provides a fast and flexible way to construct quantum circuits, by self-managing the parameters. All parameters would be created randomly if not specified. QuAIRKit also supports built-in layer ansatz, such as `complex_entangled_layer`.\r\n\r\n```python\r\ncir = Circuit(2)\r\n\r\ncir.rx() # apply Rx gates on all qubits with random parameters\r\ncir.complex_entangled_layer(depth=2) # apply complex entangled layers of depth 2\r\ncir.universal_two_qubits() # apply universal two-qubit gate with random parameters\r\n```\r\n\r\n`Circuit` is a child class of `torch.nn.Module`, so you can access its parameters and other attributes directly, or use it as a layer in a hybrid neural network.\r\n\r\n#### Implicit transition\r\n\r\nIf you want to perform noise simulation or mixed-state-related tools, there is no need to specify the backend, or import other libraries. Just call the function, and QuAIRKit will transit the backend for you.\r\n\r\n```python\r\ncir = Circuit(3)\r\n\r\ncir.complex_entangled_layer(depth=3)\r\nprint(cir().backend)\r\n\r\n# partial transpose on the first two qubits\r\nprint(cir().transpose([0, 1]).backend)\r\n\r\ncir.depolarizing(prob=0.1)\r\nprint(cir().backend)\r\n```\r\n\r\n```text\r\ndefault-pure\r\ndefault-mixed\r\ndefault-mixed\r\n```\r\n\r\n## Tutorials\r\n\r\n- [Introduction](tutorials/introduction)\r\n - [Constructing quantum circuits in QuAIRKit](tutorials/introduction/circuit.ipynb)\r\n - [Manipulation of quantum states in QuAIRKit](tutorials/introduction/state.ipynb)\r\n - [Measuring quantum states in QuAIRKit](tutorials/introduction/measure.ipynb)\r\n - [Hamiltonian in QuAIRKit](tutorials/introduction/Hamiltonian.ipynb)\r\n - [Quantum information tools](tutorials/introduction/qinfo.ipynb)\r\n - [Quantum gates and quantum channels](tutorials/introduction/operator.ipynb)\r\n - [Training parameterized quantum circuits](tutorials/introduction/training.ipynb)\r\n\r\n- [Feature](tutorials/feature)\r\n - [Batch computation](tutorials/feature/batch.ipynb)\r\n - [Drawing Quantum Circuits with QuAIRKit](tutorials/feature/plot.ipynb)\r\n - [Neural network setup customization](tutorials/feature/custom.ipynb)\r\n - [Introduction to qudit quantum computing](tutorials/feature/qudit.ipynb)\r\n - [Running QuAIRKit with third-party quantum cloud platforms](tutorials/feature/cloud.ipynb)\r\n\r\n- [Research](tutorials/research)\r\n - [Analyze Barren Plateau in quantum neural networks](tutorials/research/bp.ipynb)\r\n - [Hamiltonian simulation via Trotter decomposition](tutorials/research/trotter.ipynb)\r\n - [Quantum State Teleportation and Distribution](tutorials/research/locc.ipynb)\r\n - [Rediscovering Simon's algorithm with PQC](tutorials/research/simon.ipynb)\r\n - [Training quantum process transformation with PQC](tutorials/research/comb.ipynb)\r\n\r\n## Acknowledgements\r\n\r\nWe appreciate the kind support from the [Sourcery AI](https://sourcery.ai) that greatly enhances the coding & review quality of the QuAIRKit project.\r\n",
"bugtrack_url": null,
"license": "Apache-2.0",
"summary": "QuAIRKit is a Python research toolbox for developing quantum computing, quantum information, and quantum machine learning algorithms.",
"version": "0.4.1",
"project_urls": {
"Documentation": "https://quairkit.com/QuAIRKit",
"Homepage": "https://www.quair.group",
"Repository": "https://github.com/QuAIR/QuAIRKit"
},
"split_keywords": [
"quantum computing",
" quantum information",
" quantum machine learning",
" torch"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "2aabae064cb420eb0363799762deb5eca3bf434ebd696e39bb8be76378fe5ed5",
"md5": "04eca9128b589cb6d1a01620a18d76ea",
"sha256": "b621c7a789160f19e52146d56f5779dc19196c30cc4774c4e02fb1b0a4656da3"
},
"downloads": -1,
"filename": "quairkit-0.4.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "04eca9128b589cb6d1a01620a18d76ea",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": "<4,>=3.8",
"size": 205612,
"upload_time": "2025-08-14T02:43:11",
"upload_time_iso_8601": "2025-08-14T02:43:11.028930Z",
"url": "https://files.pythonhosted.org/packages/2a/ab/ae064cb420eb0363799762deb5eca3bf434ebd696e39bb8be76378fe5ed5/quairkit-0.4.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "6bdb8c78a524e43be67b399aabdd4624f73a778a2240475b94012eef40ae8fb0",
"md5": "29feba5dac58c5beba355256eb3deb85",
"sha256": "8122e39ff33c095c30ab2a4474f1a9831dbdc22bce00ba555fbee9790d51eb80"
},
"downloads": -1,
"filename": "quairkit-0.4.1.tar.gz",
"has_sig": false,
"md5_digest": "29feba5dac58c5beba355256eb3deb85",
"packagetype": "sdist",
"python_version": "source",
"requires_python": "<4,>=3.8",
"size": 165000,
"upload_time": "2025-08-14T02:43:12",
"upload_time_iso_8601": "2025-08-14T02:43:12.467103Z",
"url": "https://files.pythonhosted.org/packages/6b/db/8c78a524e43be67b399aabdd4624f73a778a2240475b94012eef40ae8fb0/quairkit-0.4.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-14 02:43:12",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "QuAIR",
"github_project": "QuAIRKit",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "torch",
"specs": [
[
">=",
"2.4.0"
]
]
},
{
"name": "ipython",
"specs": []
},
{
"name": "scipy",
"specs": []
},
{
"name": "matplotlib",
"specs": []
},
{
"name": "pdf2image",
"specs": []
},
{
"name": "pytest-xdist",
"specs": []
},
{
"name": "sphinx",
"specs": [
[
">=",
"6.1.3"
]
]
},
{
"name": "readthedocs-sphinx-search",
"specs": []
},
{
"name": "sphinx-rtd-theme",
"specs": [
[
">=",
"1.3.0"
]
]
}
],
"lcname": "quairkit"
}
JSON
