diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index db60be0..8990803 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -18,12 +18,6 @@ repos: hooks: - id: isort args: ["--profile", "black"] - - repo: https://github.com/PyCQA/docformatter - rev: v1.7.5 - hooks: - - id: docformatter - additional_dependencies: [tomli] - args: [--in-place, --config, ./pyproject.toml] - repo: https://github.com/asottile/pyupgrade rev: v3.19.1 hooks: @@ -32,17 +26,4 @@ repos: rev: v2.5.0 hooks: - id: pycln - args: - - --config=pyproject.toml - - --all - - repo: https://github.com/adamchainz/blacken-docs - rev: 1.19.1 - hooks: - - id: blacken-docs - - repo: https://github.com/pycqa/pydocstyle - rev: 6.3.0 - hooks: - - id: pydocstyle - args: - - --select=D103,D200,D206,D300,D301 - files: ^src/ + args: [--config=pyproject.toml] diff --git a/doc/source/QiboTN.png b/doc/source/QiboTN.png new file mode 100644 index 0000000..be6d900 Binary files /dev/null and b/doc/source/QiboTN.png differ diff --git a/doc/source/getting-started/index.rst b/doc/source/getting-started/index.rst index 1cd4702..688df82 100644 --- a/doc/source/getting-started/index.rst +++ b/doc/source/getting-started/index.rst @@ -1,6 +1,7 @@ Getting started =============== + In this section we present the basic aspects of the Qibotn design and provide installation instructions. Please visit the following sections to understand how ``qibotn`` works. diff --git a/doc/source/getting-started/quickstart.rst b/doc/source/getting-started/quickstart.rst index 6650118..7500e6a 100644 --- a/doc/source/getting-started/quickstart.rst +++ b/doc/source/getting-started/quickstart.rst @@ -1,12 +1,18 @@ Quick start =========== -In this section, we provide an example of two qubit ciruit simulation using qibotn package in Qibo simulator. First, the backend is to be set with appropriate run card settings, followed by the circuit simulation using Qibo documentation. +In this section, we provide examples on how to use Qibotn to execute tensor network +simulation of quantum circuit. First, we show how to use the Cutensornet and Quimb +backends, while in a second moment we show a complete example of usage of the Quantum +Matcha Tea Backend. -Setting the backend -""""""""""""""""""" +Setting the backend with Cutensornet and Quimb +"""""""""""""""""""""""""""""""""""""""""""""" -QiboTN offers two backends: cutensornet (using cuQuantum library) and qutensornet (using Quimb library) for tensor network based simulations. At present, cutensornet backend works only for GPUs whereas qutensornet for CPUs. The backend can be set using the following command line. +Among the backends provided by Qibotn, we have cutensornet (using cuQuantum library) +and qutensornet (using Quimb library) for tensor network based simulations. +At present, cutensornet backend works only for GPUs whereas qutensornet for CPUs. +These backend can be set using the following command line. To use cuQuantum library, cutensornet can be specified as follows:: @@ -79,3 +85,54 @@ The following is a basic example to execute a two qubit circuit and print the fi # Print the final state print(result.state()) + + +Using the Quantum Matcha Tea backend +"""""""""""""""""""""""""""""""""""" + +In the following we show an example of how the Quantum Matcha Tea backend can be +used to execute a quantum circuit:: + + # We need Qibo to setup the circuit and the backend + from qibo import Circuit, gates + from qibo.models.encodings import ghz_state + from qibo.backends import construct_backend + + # We need Quantum Matcha Tea to customize the tensor network simulation + from qmatchatea import QCConvergenceParameters + + # Set the number of qubits + nqubits = 40 + + # Construct a circuit preparing a Quantum Fourier Transform + circuit = ghz_state(nqubits) + + # Construct the backend + backend = construct_backend(backend="qibotn", platform="qmatchatea") + + # Customize the low-level backend preferences according to Qibo's formalism + backend.set_device("/CPU:1") + backend.set_precision("double") + + # Customize the tensor network simulation itself + backend.configure_tn_simulation( + ansatz = "MPS", + convergence_params = QCConvergenceParameters(max_bond_dimension=50, cut_ratio=1e-6) + ) + + # Execute the tensor network simulation + outcome = backend.execute_circuit( + circuit = circuit, + nshots=1024, + ) + + # Print some results + print(outcome.probabilities()) + # Should print something like: {'0000000000000000000000000000000000000000': 0.5000000000000001, '1111111111111111111111111111111111111111': 0.5000000000000001} + print(outcome.frequencies()) + # Should print something like: {'0000000000000000000000000000000000000000': 488, '1111111111111111111111111111111111111111': 536} + + +By default, the simulator is choosing a specific method to compute the probabilities, +and for further information we recommend the user to refer to our High-Level-API +docstrings: :doc:`/api-reference/qibotn.backends`. diff --git a/doc/source/index.rst b/doc/source/index.rst index e30d36d..6dc2092 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -4,29 +4,54 @@ What is QiboTN? =============== -QiboTN is the dedicated `Qibo `_ backend to support large-scale simulation of quantum circuits and acceleration. +Qibotn is an high-level library which integrates tensor network simulation within +the `Qibo `_ ecosystem. -Supported Computation: +If you are familiar with Qibo, you will be well aware of the modularity we provide +through the use of our backends: after building a specific algorithm or quantum +circuit, any of our backends can be selected to perform operations on the +desired hardware (classical or quantum). -- Tensornet (TN) -- Matrix Product States (MPS) +Here, we extend this modularity to one of the most famous quantum inspired simulation +technique. -Tensor Network contractions to: +We do this by relying on well-known and maintained packages, and integrating their +operation into our own dedicated backends. -- dense vectors -- expecation values of given Pauli string +.. image:: QiboTN.png + + +As shown in the figure above, we currently support three different backends, which +correspond to the three mentioned packages: + - `cuQuantum `_: an NVIDIA SDK of optimized libraries and tools for accelerating quantum computing workflows (we refer to the specific `Cutensornet `_ library); + - `quimb `_: an easy but fast python library for ‘quantum information many-body’ calculations, focusing primarily on tensor networks; + - `Quantum Matcha Tea `_: a logical quantum computer emulator powered by matrix product states. + +.. warning:: + + There are currently two ways to use the three backends (`qmatchatea` is + slightly different from the others), but we are working to standardize the interface. + +Thanks to the mentioned packages, we currently support some tensor network ansatze: +Matrix Product States (MPS) on any mentioned backend, Tree Tensor Networks (TTN) +through the Quantum Matcha Tea backend and a more general Tensor Network (TN) ansatz through +Cutensornet and Quimb. + +Supported simulation features +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +We support Tensor Network contractions to: + +- dense vectors (all the backends) +- expecation values of given Pauli string (Cutensornet and Qmatchatea) The supported HPC configurations are: -- single-node CPU -- single-node GPU or GPUs -- multi-node multi-GPU with Message Passing Interface (MPI) -- multi-node multi-GPU with NVIDIA Collective Communications Library (NCCL) +- single-node CPU through Quimb and Qmatchatea +- single-node GPU or GPUs through Cutensornet and Qmatchatea +- multi-node multi-GPU with Message Passing Interface (MPI) through Cutensornet +- multi-node multi-GPU with NVIDIA Collective Communications Library (NCCL) through Cutensornet -Currently, the supported tensor network libraries are: - -- `cuQuantum `_, an NVIDIA SDK of optimized libraries and tools for accelerating quantum computing workflows. -- `quimb `_, an easy but fast python library for ‘quantum information many-body’ calculations, focusing primarily on tensor networks. How to Use the Documentation ============================ diff --git a/examples/qmatchatea_intro/qibojit_errs.npy b/examples/qmatchatea_intro/qibojit_errs.npy new file mode 100644 index 0000000..50a5db2 Binary files /dev/null and b/examples/qmatchatea_intro/qibojit_errs.npy differ diff --git a/examples/qmatchatea_intro/qibojit_times.npy b/examples/qmatchatea_intro/qibojit_times.npy new file mode 100644 index 0000000..6b80df6 Binary files /dev/null and b/examples/qmatchatea_intro/qibojit_times.npy differ diff --git a/examples/qmatchatea_intro/qmatcha_errs.npy b/examples/qmatchatea_intro/qmatcha_errs.npy new file mode 100644 index 0000000..e4162ec Binary files /dev/null and b/examples/qmatchatea_intro/qmatcha_errs.npy differ diff --git a/examples/qmatchatea_intro/qmatcha_times.npy b/examples/qmatchatea_intro/qmatcha_times.npy new file mode 100644 index 0000000..a1540fd Binary files /dev/null and b/examples/qmatchatea_intro/qmatcha_times.npy differ diff --git a/examples/qmatchatea_intro/qmatchatea_introduction.ipynb b/examples/qmatchatea_intro/qmatchatea_introduction.ipynb new file mode 100644 index 0000000..645ab1c --- /dev/null +++ b/examples/qmatchatea_intro/qmatchatea_introduction.ipynb @@ -0,0 +1,839 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "656bb283-ac6d-48d2-a029-3c417c9961f8", + "metadata": {}, + "source": [ + "## Introduction to Quantum Matcha Tea backend in QiboTN\n", + "\n", + "#### Some imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6722d94e-e311-48f9-b6df-c6d829bf67fb", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "from scipy import stats\n", + "\n", + "import qibo\n", + "from qibo import Circuit, gates, hamiltonians\n", + "from qibo.backends import construct_backend" + ] + }, + { + "cell_type": "markdown", + "id": "a009a5e0-cfd4-4a49-9f7c-e82f252c6147", + "metadata": {}, + "source": [ + "#### Some hyper parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "64162116-1555-4a68-811c-01593739d622", + "metadata": {}, + "outputs": [], + "source": [ + "# construct qibotn backend\n", + "qmatcha_backend = construct_backend(backend=\"qibotn\", platform=\"qmatchatea\")\n", + "\n", + "# set number of qubits\n", + "nqubits = 4\n", + "\n", + "# set numpy random seed\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "id": "252f5cd1-5932-4de6-8076-4a357d50ebad", + "metadata": {}, + "source": [ + "#### Constructing a parametric quantum circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4a22a172-f50d-411d-afa3-fa61937c7b3a", + "metadata": {}, + "outputs": [], + "source": [ + "def build_circuit(nqubits, nlayers):\n", + " \"\"\"Construct a parametric quantum circuit.\"\"\"\n", + " circ = Circuit(nqubits)\n", + " for _ in range(nlayers):\n", + " for q in range(nqubits):\n", + " circ.add(gates.RY(q=q, theta=0.))\n", + " circ.add(gates.RZ(q=q, theta=0.))\n", + " [circ.add(gates.CNOT(q%nqubits, (q+1)%nqubits) for q in range(nqubits))]\n", + " circ.add(gates.M(*range(nqubits)))\n", + " return circ" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "76f23c57-6d08-496b-9a27-52fb63bbfcb1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: ─RY─RZ─o─────X─RY─RZ─o─────X─RY─RZ─o─────X─M─\n", + "1: ─RY─RZ─X─o───|─RY─RZ─X─o───|─RY─RZ─X─o───|─M─\n", + "2: ─RY─RZ───X─o─|─RY─RZ───X─o─|─RY─RZ───X─o─|─M─\n", + "3: ─RY─RZ─────X─o─RY─RZ─────X─o─RY─RZ─────X─o─M─\n" + ] + } + ], + "source": [ + "circuit = build_circuit(nqubits=nqubits, nlayers=3)\n", + "circuit.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "07b2c097-cea2-42ec-8f1d-b4bbb5b71d98", + "metadata": {}, + "outputs": [], + "source": [ + "# Setting random parameters\n", + "circuit.set_parameters(\n", + " parameters=np.random.uniform(-np.pi, np.pi, len(circuit.get_parameters())),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fd0cea52-03f5-4366-a01a-a5a84aa8ebc7", + "metadata": {}, + "source": [ + "#### Setting up the tensor network simulator\n", + "\n", + "Depending on the simulator, various parameters can be set. In the case of Quantum Matcha, we direclty exploit the `qmatchatea` interface and we construct a `QCConvergenceParameters` object (for more info [this is the link to the qmatchatea code](https://baltig.infn.it/quantum_matcha_tea/py_api_quantum_matcha_tea/-/blob/master/qmatchatea/utils/utils.py?ref_type=heads#L540))." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "34452bfd-2287-4b38-8099-e072239eab74", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mqmatcha_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfigure_tn_simulation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mansatz\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'MPS'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmax_bond_dimension\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mcut_ratio\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1e-09\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtrunc_tracking_mode\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msvd_control\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'A'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mini_bond_dimension\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Configure TN simulation given Quantum Matcha Tea interface.\n", + "\n", + "Args:\n", + " ansatz (str): tensor network ansatz. It can be tree tensor network \"TTN\"\n", + " or Matrix Product States \"MPS\" (default).\n", + " max_bond_dimension : int, optional Maximum bond dimension of the problem. Default to 10.\n", + " cut_ratio : float, optional\n", + " Cut ratio for singular values. If :math:`\\lambda_n/\\lambda_1 <` cut_ratio then\n", + " :math:`\\lambda_n` is neglected. Default to 1e-9.\n", + " trunc_tracking_mode : str, optional\n", + " Modus for storing truncation, 'M' for maximum, 'C' for\n", + " cumulated (default).\n", + " svd_ctrl : character, optional\n", + " Control for the SVD algorithm. Available:\n", + " - \"A\" : automatic. Some heuristic is run to choose the best mode for the algorithm.\n", + " - \"V\" : gesvd. Safe but slow method.\n", + " - \"D\" : gesdd. Fast iterative method. It might fail. Resort to gesvd if it fails\n", + " - \"E\" : eigenvalue decomposition method. Faster on GPU. Available only when\n", + " contracting the singular value to left or right\n", + " - \"X\" : sparse eigenvalue decomposition method. Used when you reach the maximum\n", + " bond dimension.\n", + " - \"R\" : random svd method. Used when you reach the maximum bond dimension.\n", + " Default to 'A'.\n", + " ini_bond_dimension: int, optional\n", + " Initial bond dimension of the simulation. It is used if the initial state is random.\n", + " Default to 1.\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/PhD/qibotn/src/qibotn/backends/qmatchatea.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# And then call the dedicate configuration function\n", + "# which is especially written to match the QuantumMatchaTea requirements\n", + "qmatcha_backend.configure_tn_simulation?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2ee03e94-d794-4a51-9e76-01e8d8a259ba", + "metadata": {}, + "outputs": [], + "source": [ + "# Let's set a simple customization\n", + "qmatcha_backend.configure_tn_simulation(\n", + " ansatz=\"MPS\",\n", + " max_bond_dimension=10,\n", + " cut_ratio=1e-6,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "648d85b8-445d-4081-aeed-1691fbae67be", + "metadata": {}, + "source": [ + "#### Executing through the backend\n", + "\n", + "The `backend.execute_circuit` method can be used then. We can simulate results in three ways:\n", + "1. reconstruction of the final state (statevector like, only if `nqubits < 20` due to Quantum Matcha Tea setup);\n", + "2. computation of the relevant probabilities of the final state. There are three way of doing so, but we will see it directly into the docstrings;\n", + "3. reconstruction of the relevant state's frequencies (only if `nshots` is not `None`)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "221ef886-5578-4200-a019-dcafa51aada3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mqmatcha_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute_circuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0minitial_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnshots\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mprob_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mreturn_array\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mprob_kwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Execute a Qibo quantum circuit using tensor network simulation.\n", + "\n", + "This method returns a ``TensorNetworkResult`` object, which provides:\n", + " - Reconstruction of the system state (if the system size is < 20).\n", + " - Frequencies (if the number of shots is specified).\n", + " - Probabilities computed using various methods.\n", + "\n", + "The following probability computation methods are available, as implemented\n", + "in Quantum Matcha Tea:\n", + " - **\"E\" (Even):** Probabilities are computed by evenly descending the probability tree,\n", + " pruning branches (states) with probabilities below a threshold.\n", + " - **\"G\" (Greedy):** Probabilities are computed by following the most probable states\n", + " in descending order until reaching a given coverage (sum of probabilities).\n", + " - **\"U\" (Unbiased):** An optimal probability measure that is unbiased and designed\n", + " for best performance. See https://arxiv.org/abs/2401.10330 for details.\n", + "\n", + "Args:\n", + " circuit: A Qibo circuit to execute.\n", + " initial_state: The initial state of the system (default is the vacuum state\n", + " for tensor network simulations).\n", + " nshots: The number of shots for shot-noise simulation (optional).\n", + " prob_type: The probability computation method. Must be one of:\n", + " - \"E\" (Even)\n", + " - \"G\" (Greedy)\n", + " - \"U\" (Unbiased) [default].\n", + " prob_kwargs: Additional parameters required for probability computation:\n", + " - For \"U\", requires ``num_samples``.\n", + " - For \"E\" and \"G\", requires ``prob_threshold``.\n", + "\n", + "Returns:\n", + " TensorNetworkResult: An object with methods to reconstruct the state,\n", + " compute probabilities, and generate frequencies.\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/PhD/qibotn/src/qibotn/backends/qmatchatea.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qmatcha_backend.execute_circuit?" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "35a244c3-adba-4b8b-b28c-0ab592b0f7cf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'nqubits': 4,\n", + " 'backend': QMatchaTeaBackend(),\n", + " 'measures': None,\n", + " 'measured_probabilities': {'U': {'0000': (0.0, 0.009075021799813076),\n", + " '0001': (0.009075021799813076, 0.013505513590974613),\n", + " '0010': (0.01350551359097461, 0.03969337383808732),\n", + " '0011': (0.03969337383808732, 0.3501239760030636),\n", + " '0100': (0.3501239760030635, 0.3525850615313512),\n", + " '0101': (0.3525850615313512, 0.37831917247243874),\n", + " '0110': (0.37831917247243874, 0.5888353440545037),\n", + " '0111': (0.5888353440545037, 0.5934703289984129),\n", + " '1000': (0.5934703289984128, 0.6896713158046865),\n", + " '1001': (0.6896713158046865, 0.7110042815132214),\n", + " '1010': (0.7110042815132213, 0.7242989335460854),\n", + " '1011': (0.7242989335460854, 0.7640693817193864),\n", + " '1100': (0.7640693817193864, 0.7641799598480784),\n", + " '1101': (0.7641799598480784, 0.9530705920006985),\n", + " '1110': (0.9530705920006985, 0.989871146703016),\n", + " '1111': (0.989871146703016, 1.0000000000000002)},\n", + " 'E': [None],\n", + " 'G': [None]},\n", + " 'prob_type': 'U',\n", + " 'statevector': array([-0.0381929 -0.08727155j, -0.25811667+0.17197899j,\n", + " -0.04960402-0.00072563j, 0.00323629-0.01000523j,\n", + " 0.0625107 +0.14926578j, -0.11530027-0.00070762j,\n", + " -0.35885958-0.28589503j, -0.08233943+0.17326504j,\n", + " 0.06345512-0.02009824j, 0.03609859+0.14152688j,\n", + " -0.11045046+0.11633919j, -0.27587224+0.33583499j,\n", + " 0.46347251+0.30923103j, 0.02322259-0.19806857j,\n", + " -0.00893755+0.06749152j, -0.07071717-0.0716096j ])}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Simple execution (defaults)\n", + "outcome = qmatcha_backend.execute_circuit(circuit=circuit, return_array=True)\n", + "\n", + "# Print outcome\n", + "vars(outcome)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "60501c3d-2a44-421f-b434-4a508714b132", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'nqubits': 4,\n", + " 'backend': QMatchaTeaBackend(),\n", + " 'measures': None,\n", + " 'measured_probabilities': {'U': [None],\n", + " 'E': [None],\n", + " 'G': {'0010': 0.02618786024711271,\n", + " '0011': 0.3104306021649763,\n", + " '1100': 0.00011057812869196484,\n", + " '1101': 0.18889063215262014,\n", + " '0110': 0.21051617158206493,\n", + " '0111': 0.0046349849439092155}},\n", + " 'prob_type': 'G',\n", + " 'statevector': array([-0.0381929 -0.08727155j, -0.25811667+0.17197899j,\n", + " -0.04960402-0.00072563j, 0.00323629-0.01000523j,\n", + " 0.0625107 +0.14926578j, -0.11530027-0.00070762j,\n", + " -0.35885958-0.28589503j, -0.08233943+0.17326504j,\n", + " 0.06345512-0.02009824j, 0.03609859+0.14152688j,\n", + " -0.11045046+0.11633919j, -0.27587224+0.33583499j,\n", + " 0.46347251+0.30923103j, 0.02322259-0.19806857j,\n", + " -0.00893755+0.06749152j, -0.07071717-0.0716096j ])}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execution with a specific probability type\n", + "# We use here \"E\", which is cutting some of the components if under a threshold\n", + "outcome = qmatcha_backend.execute_circuit(\n", + " circuit=circuit,\n", + " prob_type=\"G\",\n", + " prob_threshold=0.7,\n", + " return_array=True,\n", + ")\n", + "\n", + "# Print outcome\n", + "vars(outcome)" + ] + }, + { + "cell_type": "markdown", + "id": "84ec0b48-f6b4-495c-93b8-8e42d1a8b0df", + "metadata": {}, + "source": [ + "---\n", + "\n", + "One can access to the specific contents of the simulation outcome." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c0443efc-21ef-4ed5-9cf4-785d204a1881", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Probabilities:\n", + " [2.61878602e-02 3.10430602e-01 1.10578129e-04 1.88890632e-01\n", + " 2.10516172e-01 4.63498494e-03]\n", + "\n", + "State:\n", + " [-0.0381929 -0.08727155j -0.25811667+0.17197899j -0.04960402-0.00072563j\n", + " 0.00323629-0.01000523j 0.0625107 +0.14926578j -0.11530027-0.00070762j\n", + " -0.35885958-0.28589503j -0.08233943+0.17326504j 0.06345512-0.02009824j\n", + " 0.03609859+0.14152688j -0.11045046+0.11633919j -0.27587224+0.33583499j\n", + " 0.46347251+0.30923103j 0.02322259-0.19806857j -0.00893755+0.06749152j\n", + " -0.07071717-0.0716096j ]\n", + "\n" + ] + } + ], + "source": [ + "print(f\"Probabilities:\\n {outcome.probabilities()}\\n\")\n", + "print(f\"State:\\n {outcome.state()}\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "9f477388-ca45-409a-a0ce-6603ec294e42", + "metadata": {}, + "source": [ + "---\n", + "\n", + "But frequencies cannot be accessed, since no shots have been set." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "8a868f3e-8383-47ee-a93a-27c5f85e48c5", + "metadata": {}, + "outputs": [], + "source": [ + "# print(f\"Frequencies:\\n {outcome.frequencies()}\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "8e9413c7-602a-44ed-a50c-1c3dd4dd7494", + "metadata": {}, + "source": [ + "---\n", + "\n", + "We can then repeat the execution by setting the number of shots" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "68122cd3-662f-4fd1-bb9c-d33b6f5448dd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'nqubits': 4,\n", + " 'backend': QMatchaTeaBackend(),\n", + " 'measures': {'0000': 12,\n", + " '0001': 5,\n", + " '0010': 20,\n", + " '0011': 307,\n", + " '0100': 5,\n", + " '0101': 35,\n", + " '0110': 207,\n", + " '0111': 4,\n", + " '1000': 107,\n", + " '1001': 19,\n", + " '1010': 11,\n", + " '1011': 41,\n", + " '1100': 1,\n", + " '1101': 199,\n", + " '1110': 37,\n", + " '1111': 14},\n", + " 'measured_probabilities': {'U': [None],\n", + " 'E': {'0011': 0.3104306021649763,\n", + " '0110': 0.21051617158206493,\n", + " '1000': 0.09620098680627374,\n", + " '1101': 0.18889063215262014},\n", + " 'G': [None]},\n", + " 'prob_type': 'E',\n", + " 'statevector': None}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execution with a specific probability type\n", + "# We use here \"E\", which is cutting some of the components if under a threshold\n", + "outcome = qmatcha_backend.execute_circuit(\n", + " circuit=circuit,\n", + " nshots=1024,\n", + " prob_type=\"E\",\n", + " prob_threshold=0.05,\n", + ")\n", + "\n", + "# Print outcome\n", + "vars(outcome)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ef0e9591-ccca-4cdd-a81b-2bfb3caaf3d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequencies:\n", + " {'0000': 12, '0001': 5, '0010': 20, '0011': 307, '0100': 5, '0101': 35, '0110': 207, '0111': 4, '1000': 107, '1001': 19, '1010': 11, '1011': 41, '1100': 1, '1101': 199, '1110': 37, '1111': 14}\n", + "\n" + ] + } + ], + "source": [ + "# And then finally access frequencies!\n", + "print(f\"Frequencies:\\n {outcome.frequencies()}\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "7fe725ff-533e-4648-9f8d-9cb6c0826354", + "metadata": {}, + "source": [ + "#### Testing the performances" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "9e9632d5-28dd-4846-8457-c579d0cb9453", + "metadata": {}, + "outputs": [], + "source": [ + "qmatcha_range = range(2, 100, 2)\n", + "qibojit_threshold = 28\n", + "qibojit_range = range(2, qibojit_threshold, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e6b1126-32ab-418d-b760-44ff62048f70", + "metadata": {}, + "outputs": [], + "source": [ + "qmatcha_times, qmatcha_errs = [], []\n", + "qibojit_times, qibojit_errs = [], []\n", + "\n", + "qibojit_backend = construct_backend(\"qibojit\", platform=\"numba\")\n", + "qibo.set_threads(2)\n", + "\n", + "\n", + "for q in qmatcha_range:\n", + " print(f\"Executing for {q} qubits\")\n", + " # Build the circuit\n", + " circuit = build_circuit(q, 1)\n", + "\n", + " reasonable_exp = min(13, int(q / 2))\n", + " \n", + " qmatcha_backend.configure_tn_simulation(\n", + " convergence_params=QCConvergenceParameters(max_bond_dimension=2**reasonable_exp),\n", + " ansatz=\"MPS\"\n", + " )\n", + "\n", + " tmp_qmatcha_times, tmp_qibojit_times = [], [] \n", + " for i in range(20):\n", + " # Set random parameters\n", + " circuit.set_parameters(parameters=np.random.uniform(-np.pi, np.pi, len(circuit.get_parameters())))\n", + " \n", + " # Measure QMatcha execution time\n", + " print(f\"1. ---- QMatcha\") if i == 0 else None\n", + " start_time = time.time()\n", + " outcome = qmatcha_backend.execute_circuit(circuit=circuit)\n", + " tmp_qmatcha_times.append(time.time() - start_time)\n", + "\n", + " if q < qibojit_threshold:\n", + " \n", + " if i == 0:\n", + " outcome = qibojit_backend.execute_circuit(circuit=circuit)\n", + " \n", + " # Measure Qibojit execution time\n", + " print(f\"2. ---- Qibojit\") if i == 0 else None\n", + " start_time = time.time()\n", + " outcome = qibojit_backend.execute_circuit(circuit=circuit)\n", + " tmp_qibojit_times.append(time.time() - start_time)\n", + " \n", + " qmatcha_times.append(np.median(tmp_qmatcha_times))\n", + " qmatcha_errs.append(stats.median_abs_deviation(tmp_qmatcha_times))\n", + " \n", + " if q < qibojit_threshold:\n", + " qibojit_times.append(np.median(tmp_qibojit_times))\n", + " qibojit_errs.append(stats.median_abs_deviation(tmp_qibojit_times))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5620f476-1bc7-4cf8-9868-b127c715b6ec", + "metadata": {}, + "outputs": [], + "source": [ + "# Saving data\n", + "# np.save(arr=qmatcha_times, file=\"qmatcha_times\")\n", + "# np.save(arr=qibojit_times, file=\"qibojit_times\")\n", + "# np.save(arr=qmatcha_errs, file=\"qmatcha_errs\")\n", + "# np.save(arr=qibojit_errs, file=\"qibojit_errs\")\n", + "\n", + "qmatcha_times = np.load(\"qmatcha_times.npy\")\n", + "qmatcha_errs = np.load(\"qmatcha_errs.npy\")\n", + "qibojit_times = np.load(\"qibojit_times.npy\")\n", + "qibojit_errs = np.load(\"qibojit_errs.npy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "32d605e9-672a-40b6-8a1a-eb17bbc3c45e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(6, 6 * 6/8))\n", + "plt.title(\"Simple test of CPU 12th Gen Intel® Core™ i7-1260P\")\n", + "plt.errorbar(qmatcha_range, qmatcha_times, yerr=qmatcha_errs, marker=\"o\", color=\"red\", label=\"QMatcha-numpy\", alpha=0.7)\n", + "plt.errorbar(qibojit_range, qibojit_times, yerr=qibojit_errs, marker=\"o\", color=\"blue\", label=\"Qibojit-numba\", alpha=0.7)\n", + "plt.legend()\n", + "plt.xlabel(\"Qubits\")\n", + "plt.ylabel(\"Time [s]\")\n", + "plt.grid(True)\n", + "plt.yscale(\"log\")" + ] + }, + { + "cell_type": "markdown", + "id": "dd84f1f3-7aa5-4ad1-ae09-81e0aff75b5b", + "metadata": {}, + "source": [ + "### Compute expectation values" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "0b46e315-7786-4247-bd2a-83ea1c5842eb", + "metadata": {}, + "outputs": [], + "source": [ + "from qibo.symbols import Z, X" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "37385485-e8a3-4ab0-ad44-bcc4e9da24ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: ─RY─RZ─o─────X─RY─RZ─o─────X─M─\n", + "1: ─RY─RZ─X─o───|─RY─RZ─X─o───|─M─\n", + "2: ─RY─RZ───X─o─|─RY─RZ───X─o─|─M─\n", + "3: ─RY─RZ─────X─o─RY─RZ─────X─o─M─\n" + ] + } + ], + "source": [ + "# We are going to compute the expval of an Hamiltonian\n", + "# On the state prepared by the following circuit\n", + "circuit.draw()\n", + "\n", + "circuit.set_parameters(\n", + " np.random.randn(len(circuit.get_parameters()))\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "ddecc910-7804-4199-8577-a7db38a16db8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Qibo 0.2.15|INFO|2025-02-10 16:44:30]: Using qibojit (numba) backend on /CPU:0\n" + ] + } + ], + "source": [ + "# We can create an Hamiltonian form\n", + "form = 0.5 * Z(0) * Z(1) +- 1.5 * X(0) * Z(2) + Z(3)\n", + "hamiltonian = hamiltonians.SymbolicHamiltonian(form)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "a6599df3-989e-4131-8664-3451d0cc4372", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mqmatcha_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpectation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobservable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Compute the expectation value of a Qibo-friendly ``observable`` on\n", + "the Tensor Network constructed from a Qibo ``circuit``.\n", + "\n", + "This method takes a Qibo-style symbolic Hamiltonian (e.g., `X(0)*Z(1) + 2.0*Y(2)*Z(0)`)\n", + "as the observable, converts it into a Quantum Matcha Tea (qmatchatea) observable\n", + "(using `TNObsTensorProduct` and `TNObsWeightedSum`), and computes its expectation\n", + "value using the provided circuit.\n", + "\n", + "Args:\n", + " circuit: A Qibo quantum circuit object on which the expectation value\n", + " is computed. The circuit should be compatible with the qmatchatea\n", + " Tensor Network backend.\n", + " observable: The observable whose expectation value we want to compute.\n", + " This must be provided in the symbolic Hamiltonian form supported by Qibo\n", + " (e.g., `X(0)*Y(1)` or `Z(0)*Z(1) + 1.5*Y(2)`).\n", + "\n", + "Returns:\n", + " qibotn.TensorNetworkResult class, providing methods to retrieve\n", + " probabilities, frequencies and state always according to the chosen\n", + " simulation setup.\n", + "\u001b[0;31mFile:\u001b[0m ~/Documents/PhD/qibotn/src/qibotn/backends/qmatchatea.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qmatcha_backend.expectation?" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "163b70a3-814a-4a62-a98a-2ffca933a544", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.21133814688683614" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qmatcha_backend.expectation(\n", + " circuit=circuit,\n", + " observable=hamiltonian,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "2d8c4a9c-eca3-49d0-bdbf-ab054172c4e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.2113381468868367" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Try with Qibo\n", + "\n", + "hamiltonian = hamiltonians.SymbolicHamiltonian(form)\n", + "hamiltonian.expectation(circuit().state())" + ] + }, + { + "cell_type": "markdown", + "id": "94df291c-9ddc-4b2e-8442-5fca00784bd8", + "metadata": {}, + "source": [ + "They match! 🥳" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/poetry.lock b/poetry.lock index dc2be14..6c1e6a4 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand. +# This file is automatically @generated by Poetry 1.7.0 and should not be changed by hand. [[package]] name = "alabaster" @@ -6,7 +6,6 @@ version = "0.7.16" description = "A light, configurable Sphinx theme" optional = false python-versions = ">=3.9" -groups = ["docs"] files = [ {file = "alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92"}, {file = "alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65"}, @@ -18,7 +17,6 @@ version = "1.14.1" description = "A database migration tool for SQLAlchemy." optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "alembic-1.14.1-py3-none-any.whl", hash = "sha256:1acdd7a3a478e208b0503cd73614d5e4c6efafa4e73518bb60e4f2846a37b1c5"}, {file = "alembic-1.14.1.tar.gz", hash = "sha256:496e888245a53adf1498fcab31713a469c65836f8de76e01399aa1c3e90dd213"}, @@ -38,7 +36,6 @@ version = "4.13.2" description = "ANTLR 4.13.2 runtime for Python 3" optional = false python-versions = "*" -groups = ["main"] files = [ {file = "antlr4_python3_runtime-4.13.2-py3-none-any.whl", hash = "sha256:fe3835eb8d33daece0e799090eda89719dbccee7aa39ef94eed3818cafa5a7e8"}, {file = "antlr4_python3_runtime-4.13.2.tar.gz", hash = "sha256:909b647e1d2fc2b70180ac586df3933e38919c85f98ccc656a96cd3f25ef3916"}, @@ -50,8 +47,6 @@ version = "0.1.4" description = "Disable App Nap on macOS >= 10.9" optional = false python-versions = ">=3.6" -groups = ["dev"] -markers = "sys_platform == \"darwin\"" files = [ {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, @@ -63,7 +58,6 @@ version = "3.3.8" description = "An abstract syntax tree for Python with inference support." optional = false python-versions = ">=3.9.0" -groups = ["analysis"] files = [ {file = "astroid-3.3.8-py3-none-any.whl", hash = "sha256:187ccc0c248bfbba564826c26f070494f7bc964fd286b6d9fff4420e55de828c"}, {file = "astroid-3.3.8.tar.gz", hash = "sha256:a88c7994f914a4ea8572fac479459f4955eeccc877be3f2d959a33273b0cf40b"}, @@ -78,7 +72,6 @@ version = "0.7.0" description = "Abstract your array operations." optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "autoray-0.7.0-py3-none-any.whl", hash = "sha256:03103957df3d1b66b8068158056c2909a72095b19d1b24262261276a714a5d07"}, {file = "autoray-0.7.0.tar.gz", hash = "sha256:7829d21258512f87e02f23ce74ae5759af4ce8998069d2cce53468f1d701a219"}, @@ -94,7 +87,6 @@ version = "2.16.0" description = "Internationalization utilities" optional = false python-versions = ">=3.8" -groups = ["docs"] files = [ {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, @@ -109,7 +101,6 @@ version = "0.2.0" description = "Specifications for callback functions passed in to an API" optional = false python-versions = "*" -groups = ["dev"] files = [ {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, @@ -121,7 +112,6 @@ version = "4.12.3" description = "Screen-scraping library" optional = false python-versions = ">=3.6.0" -groups = ["docs"] files = [ {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, @@ -143,19 +133,96 @@ version = "2024.12.14" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" -groups = ["docs"] files = [ {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"}, {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"}, ] +[[package]] +name = "cffi" +version = "1.17.1" +description = "Foreign Function Interface for Python calling C code." +optional = true +python-versions = ">=3.8" +files = [ + {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"}, + {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be"}, + {file = "cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c"}, + {file = "cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15"}, + {file = "cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401"}, + {file = "cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b"}, + {file = "cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655"}, + {file = "cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0"}, + {file = "cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4"}, + {file = "cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93"}, + {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3"}, + {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8"}, + {file = "cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65"}, + {file = "cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903"}, + {file = "cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e"}, + {file = "cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd"}, + {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed"}, + {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9"}, + {file = "cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d"}, + {file = "cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a"}, + {file = "cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1"}, + {file = "cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8"}, + {file = "cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1"}, + {file = "cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16"}, + {file = "cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e"}, + {file = "cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7"}, + {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[package.dependencies] +pycparser = "*" + [[package]] name = "charset-normalizer" version = "3.4.1" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de"}, {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176"}, @@ -257,7 +324,6 @@ version = "3.4.0" description = "CMA-ES, Covariance Matrix Adaptation Evolution Strategy for non-linear numerical optimization in Python" optional = false python-versions = "*" -groups = ["main"] files = [ {file = "cma-3.4.0-py3-none-any.whl", hash = "sha256:4140e490cc4e68cf8c7b1114e079c0561c9b78b1bf9ec69362c20865636ae5ca"}, {file = "cma-3.4.0.tar.gz", hash = "sha256:a1ebd969b99871be3715d5a24b7bf54cf04ea94e80d6b8536d7147620dd10f6c"}, @@ -276,12 +342,10 @@ version = "0.4.6" description = "Cross-platform colored terminal text." optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" -groups = ["main", "analysis", "dev", "docs", "tests"] files = [ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] -markers = {main = "sys_platform == \"win32\" or platform_system == \"Windows\"", analysis = "sys_platform == \"win32\"", dev = "sys_platform == \"win32\"", docs = "sys_platform == \"win32\"", tests = "sys_platform == \"win32\""} [[package]] name = "colorlog" @@ -289,7 +353,6 @@ version = "6.9.0" description = "Add colours to the output of Python's logging module." optional = false python-versions = ">=3.6" -groups = ["main"] files = [ {file = "colorlog-6.9.0-py3-none-any.whl", hash = "sha256:5906e71acd67cb07a71e779c47c4bcb45fb8c2993eebe9e5adcd6a6f1b283eff"}, {file = "colorlog-6.9.0.tar.gz", hash = "sha256:bfba54a1b93b94f54e1f4fe48395725a3d92fd2a4af702f6bd70946bdc0c6ac2"}, @@ -307,7 +370,6 @@ version = "1.3.0" description = "Python library for calculating contours of 2D quadrilateral grids" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7"}, {file = "contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42"}, @@ -392,7 +454,6 @@ version = "0.7.0" description = "Hyper optimized contraction trees for large tensor networks and einsums." optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "cotengra-0.7.0-py3-none-any.whl", hash = "sha256:ca1c75fec462fb75130a3a826db2d4565bbbf0641d5ce0a617e643211cd98307"}, {file = "cotengra-0.7.0.tar.gz", hash = "sha256:8ad9fabee899ac2f7b72359ace79a5496f15fd89b19049656082ef7773ca2b69"}, @@ -412,7 +473,6 @@ version = "7.6.10" description = "Code coverage measurement for Python" optional = false python-versions = ">=3.9" -groups = ["tests"] files = [ {file = "coverage-7.6.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5c912978f7fbf47ef99cec50c4401340436d200d41d714c7a4766f377c5b7b78"}, {file = "coverage-7.6.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a01ec4af7dfeb96ff0078ad9a48810bb0cc8abcb0115180c6013a6b26237626c"}, @@ -484,14 +544,61 @@ tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.1 [package.extras] toml = ["tomli"] +[[package]] +name = "cryptography" +version = "43.0.3" +description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." +optional = true +python-versions = ">=3.7" +files = [ + {file = "cryptography-43.0.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:bf7a1932ac4176486eab36a19ed4c0492da5d97123f1406cf15e41b05e787d2e"}, + {file = "cryptography-43.0.3-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63efa177ff54aec6e1c0aefaa1a241232dcd37413835a9b674b6e3f0ae2bfd3e"}, + {file = "cryptography-43.0.3-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e1ce50266f4f70bf41a2c6dc4358afadae90e2a1e5342d3c08883df1675374f"}, + {file = "cryptography-43.0.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:443c4a81bb10daed9a8f334365fe52542771f25aedaf889fd323a853ce7377d6"}, + {file = "cryptography-43.0.3-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:74f57f24754fe349223792466a709f8e0c093205ff0dca557af51072ff47ab18"}, + {file = "cryptography-43.0.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9762ea51a8fc2a88b70cf2995e5675b38d93bf36bd67d91721c309df184f49bd"}, + {file = "cryptography-43.0.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:81ef806b1fef6b06dcebad789f988d3b37ccaee225695cf3e07648eee0fc6b73"}, + {file = "cryptography-43.0.3-cp37-abi3-win32.whl", hash = "sha256:cbeb489927bd7af4aa98d4b261af9a5bc025bd87f0e3547e11584be9e9427be2"}, + {file = "cryptography-43.0.3-cp37-abi3-win_amd64.whl", hash = "sha256:f46304d6f0c6ab8e52770addfa2fc41e6629495548862279641972b6215451cd"}, + {file = "cryptography-43.0.3-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:8ac43ae87929a5982f5948ceda07001ee5e83227fd69cf55b109144938d96984"}, + {file = "cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:846da004a5804145a5f441b8530b4bf35afbf7da70f82409f151695b127213d5"}, + {file = "cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f996e7268af62598f2fc1204afa98a3b5712313a55c4c9d434aef49cadc91d4"}, + {file = "cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f7b178f11ed3664fd0e995a47ed2b5ff0a12d893e41dd0494f406d1cf555cab7"}, + {file = "cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:c2e6fc39c4ab499049df3bdf567f768a723a5e8464816e8f009f121a5a9f4405"}, + {file = "cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e1be4655c7ef6e1bbe6b5d0403526601323420bcf414598955968c9ef3eb7d16"}, + {file = "cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:df6b6c6d742395dd77a23ea3728ab62f98379eff8fb61be2744d4679ab678f73"}, + {file = "cryptography-43.0.3-cp39-abi3-win32.whl", hash = "sha256:d56e96520b1020449bbace2b78b603442e7e378a9b3bd68de65c782db1507995"}, + {file = "cryptography-43.0.3-cp39-abi3-win_amd64.whl", hash = "sha256:0c580952eef9bf68c4747774cde7ec1d85a6e61de97281f2dba83c7d2c806362"}, + {file = "cryptography-43.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d03b5621a135bffecad2c73e9f4deb1a0f977b9a8ffe6f8e002bf6c9d07b918c"}, + {file = "cryptography-43.0.3-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:a2a431ee15799d6db9fe80c82b055bae5a752bef645bba795e8e52687c69efe3"}, + {file = "cryptography-43.0.3-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:281c945d0e28c92ca5e5930664c1cefd85efe80e5c0d2bc58dd63383fda29f83"}, + {file = "cryptography-43.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f18c716be16bc1fea8e95def49edf46b82fccaa88587a45f8dc0ff6ab5d8e0a7"}, + {file = "cryptography-43.0.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4a02ded6cd4f0a5562a8887df8b3bd14e822a90f97ac5e544c162899bc467664"}, + {file = "cryptography-43.0.3-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:53a583b6637ab4c4e3591a15bc9db855b8d9dee9a669b550f311480acab6eb08"}, + {file = "cryptography-43.0.3-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1ec0bcf7e17c0c5669d881b1cd38c4972fade441b27bda1051665faaa89bdcaa"}, + {file = "cryptography-43.0.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2ce6fae5bdad59577b44e4dfed356944fbf1d925269114c28be377692643b4ff"}, + {file = "cryptography-43.0.3.tar.gz", hash = "sha256:315b9001266a492a6ff443b61238f956b214dbec9910a081ba5b6646a055a805"}, +] + +[package.dependencies] +cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""} + +[package.extras] +docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"] +docstest = ["pyenchant (>=1.6.11)", "readme-renderer", "sphinxcontrib-spelling (>=4.0.1)"] +nox = ["nox"] +pep8test = ["check-sdist", "click", "mypy", "ruff"] +sdist = ["build"] +ssh = ["bcrypt (>=3.1.5)"] +test = ["certifi", "cryptography-vectors (==43.0.3)", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] +test-randomorder = ["pytest-randomly"] + [[package]] name = "cupy-cuda11x" version = "11.6.0" description = "CuPy: NumPy & SciPy for GPU" optional = true python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"cuda\"" files = [ {file = "cupy_cuda11x-11.6.0-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:1b9914f57868a1559e9bfabfbae8c724585914e8e1f277acb9cdb6aa0756eaa4"}, {file = "cupy_cuda11x-11.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:ac8dd082ddb00996bc4d37cc5765907048f467aadb61bcbff25f3c2a88c50583"}, @@ -520,8 +627,6 @@ version = "23.10.0" description = "NVIDIA cuQuantum Python" optional = true python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"cuda\"" files = [ {file = "cuquantum_python_cu11-23.10.0-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:a0f0dfcb6239ec5fce836fa2f641820d3235ac7d83f391eac90952cf481da03f"}, {file = "cuquantum_python_cu11-23.10.0-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:ad5e38501cb53d50ba19fc48790f2c79fbc14c22e101d51a0b338f6c6971e6a0"}, @@ -542,8 +647,6 @@ version = "1.7.0" description = "cuStateVec - a component of NVIDIA cuQuantum SDK" optional = true python-versions = "*" -groups = ["main"] -markers = "extra == \"cuda\"" files = [ {file = "custatevec_cu11-1.7.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:dabdd80bab8e19413904c8377268dcfbc0468b3a8438a04cca422502c70b34d0"}, {file = "custatevec_cu11-1.7.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:11b3a2a79de52afaab1acc970e3d810d219e90170405aaded78ac6dcfa1bb389"}, @@ -555,8 +658,6 @@ version = "2.0.2" description = "NVIDIA cuTENSOR" optional = true python-versions = "*" -groups = ["main"] -markers = "extra == \"cuda\"" files = [ {file = "cutensor_cu11-2.0.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:e17003e5f5cf0e83292e9e7e380b64c87a311f8096b3a287a630cbab743ef52f"}, {file = "cutensor_cu11-2.0.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6d37a1164cb02d74322b35b09f018ce51aff078dedee10823820b9d878ebb8c3"}, @@ -569,8 +670,6 @@ version = "2.6.0" description = "cuTensorNet - a component of NVIDIA cuQuantum SDK" optional = true python-versions = "*" -groups = ["main"] -markers = "extra == \"cuda\"" files = [ {file = "cutensornet_cu11-2.6.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:ded8b2b3124fd2acd6ce9c13060b0ea17692bcbca727314b2930c6ab341035ef"}, {file = "cutensornet_cu11-2.6.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f7be9781de96cd897b59ac81cfb5c407a79a9781d236a25358656e24c9e81b71"}, @@ -585,7 +684,6 @@ version = "0.12.1" description = "Composable style cycles" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, @@ -601,7 +699,6 @@ version = "1.0.1" description = "Cython implementation of Toolz: High performance functional utilities" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "cytoolz-1.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cec9af61f71fc3853eb5dca3d42eb07d1f48a4599fa502cbe92adde85f74b042"}, {file = "cytoolz-1.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:140bbd649dbda01e91add7642149a5987a7c3ccc251f2263de894b89f50b6608"}, @@ -717,7 +814,6 @@ version = "5.1.1" description = "Decorators for Humans" optional = false python-versions = ">=3.5" -groups = ["dev"] files = [ {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, @@ -729,7 +825,6 @@ version = "0.3.9" description = "serialize all of Python" optional = false python-versions = ">=3.8" -groups = ["analysis"] files = [ {file = "dill-0.3.9-py3-none-any.whl", hash = "sha256:468dff3b89520b474c0397703366b7b95eebe6303f108adf9b19da1f702be87a"}, {file = "dill-0.3.9.tar.gz", hash = "sha256:81aa267dddf68cbfe8029c42ca9ec6a4ab3b22371d1c450abc54422577b4512c"}, @@ -745,7 +840,6 @@ version = "0.19" description = "Docutils -- Python Documentation Utilities" optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "docutils-0.19-py3-none-any.whl", hash = "sha256:5e1de4d849fee02c63b040a4a3fd567f4ab104defd8a5511fbbc24a8a017efbc"}, {file = "docutils-0.19.tar.gz", hash = "sha256:33995a6753c30b7f577febfc2c50411fec6aac7f7ffeb7c4cfe5991072dcf9e6"}, @@ -757,8 +851,6 @@ version = "1.2.2" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" -groups = ["tests"] -markers = "python_version < \"3.11\"" files = [ {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, @@ -773,8 +865,6 @@ version = "0.8.3" description = "Fast, re-entrant optimistic lock implemented in Cython" optional = true python-versions = "*" -groups = ["main"] -markers = "extra == \"cuda\"" files = [ {file = "fastrlock-0.8.3-cp27-cp27m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bbbe31cb60ec32672969651bf68333680dacaebe1a1ec7952b8f5e6e23a70aa5"}, {file = "fastrlock-0.8.3-cp27-cp27m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:45055702fe9bff719cdc62caa849aa7dbe9e3968306025f639ec62ef03c65e88"}, @@ -849,62 +939,61 @@ files = [ [[package]] name = "fonttools" -version = "4.55.3" +version = "4.55.7" description = "Tools to manipulate font files" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ - {file = "fonttools-4.55.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:1dcc07934a2165ccdc3a5a608db56fb3c24b609658a5b340aee4ecf3ba679dc0"}, - {file = "fonttools-4.55.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f7d66c15ba875432a2d2fb419523f5d3d347f91f48f57b8b08a2dfc3c39b8a3f"}, - {file = "fonttools-4.55.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27e4ae3592e62eba83cd2c4ccd9462dcfa603ff78e09110680a5444c6925d841"}, - {file = "fonttools-4.55.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:62d65a3022c35e404d19ca14f291c89cc5890032ff04f6c17af0bd1927299674"}, - {file = "fonttools-4.55.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d342e88764fb201286d185093781bf6628bbe380a913c24adf772d901baa8276"}, - {file = "fonttools-4.55.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:dd68c87a2bfe37c5b33bcda0fba39b65a353876d3b9006fde3adae31f97b3ef5"}, - {file = "fonttools-4.55.3-cp310-cp310-win32.whl", hash = "sha256:1bc7ad24ff98846282eef1cbeac05d013c2154f977a79886bb943015d2b1b261"}, - {file = "fonttools-4.55.3-cp310-cp310-win_amd64.whl", hash = "sha256:b54baf65c52952db65df39fcd4820668d0ef4766c0ccdf32879b77f7c804d5c5"}, - {file = "fonttools-4.55.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8c4491699bad88efe95772543cd49870cf756b019ad56294f6498982408ab03e"}, - {file = "fonttools-4.55.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5323a22eabddf4b24f66d26894f1229261021dacd9d29e89f7872dd8c63f0b8b"}, - {file = "fonttools-4.55.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5480673f599ad410695ca2ddef2dfefe9df779a9a5cda89503881e503c9c7d90"}, - {file = "fonttools-4.55.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da9da6d65cd7aa6b0f806556f4985bcbf603bf0c5c590e61b43aa3e5a0f822d0"}, - {file = "fonttools-4.55.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e894b5bd60d9f473bed7a8f506515549cc194de08064d829464088d23097331b"}, - {file = "fonttools-4.55.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:aee3b57643827e237ff6ec6d28d9ff9766bd8b21e08cd13bff479e13d4b14765"}, - {file = "fonttools-4.55.3-cp311-cp311-win32.whl", hash = "sha256:eb6ca911c4c17eb51853143624d8dc87cdcdf12a711fc38bf5bd21521e79715f"}, - {file = "fonttools-4.55.3-cp311-cp311-win_amd64.whl", hash = "sha256:6314bf82c54c53c71805318fcf6786d986461622dd926d92a465199ff54b1b72"}, - {file = "fonttools-4.55.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f9e736f60f4911061235603a6119e72053073a12c6d7904011df2d8fad2c0e35"}, - {file = "fonttools-4.55.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a8aa2c5e5b8b3bcb2e4538d929f6589a5c6bdb84fd16e2ed92649fb5454f11c"}, - {file = "fonttools-4.55.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07f8288aacf0a38d174445fc78377a97fb0b83cfe352a90c9d9c1400571963c7"}, - {file = "fonttools-4.55.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8d5e8916c0970fbc0f6f1bece0063363bb5857a7f170121a4493e31c3db3314"}, - {file = "fonttools-4.55.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae3b6600565b2d80b7c05acb8e24d2b26ac407b27a3f2e078229721ba5698427"}, - {file = "fonttools-4.55.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:54153c49913f45065c8d9e6d0c101396725c5621c8aee744719300f79771d75a"}, - {file = "fonttools-4.55.3-cp312-cp312-win32.whl", hash = "sha256:827e95fdbbd3e51f8b459af5ea10ecb4e30af50221ca103bea68218e9615de07"}, - {file = "fonttools-4.55.3-cp312-cp312-win_amd64.whl", hash = "sha256:e6e8766eeeb2de759e862004aa11a9ea3d6f6d5ec710551a88b476192b64fd54"}, - {file = "fonttools-4.55.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a430178ad3e650e695167cb53242dae3477b35c95bef6525b074d87493c4bf29"}, - {file = "fonttools-4.55.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:529cef2ce91dc44f8e407cc567fae6e49a1786f2fefefa73a294704c415322a4"}, - {file = "fonttools-4.55.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e75f12c82127486fac2d8bfbf5bf058202f54bf4f158d367e41647b972342ca"}, - {file = "fonttools-4.55.3-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:859c358ebf41db18fb72342d3080bce67c02b39e86b9fbcf1610cca14984841b"}, - {file = "fonttools-4.55.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:546565028e244a701f73df6d8dd6be489d01617863ec0c6a42fa25bf45d43048"}, - {file = "fonttools-4.55.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:aca318b77f23523309eec4475d1fbbb00a6b133eb766a8bdc401faba91261abe"}, - {file = "fonttools-4.55.3-cp313-cp313-win32.whl", hash = "sha256:8c5ec45428edaa7022f1c949a632a6f298edc7b481312fc7dc258921e9399628"}, - {file = "fonttools-4.55.3-cp313-cp313-win_amd64.whl", hash = "sha256:11e5de1ee0d95af4ae23c1a138b184b7f06e0b6abacabf1d0db41c90b03d834b"}, - {file = "fonttools-4.55.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:caf8230f3e10f8f5d7593eb6d252a37caf58c480b19a17e250a63dad63834cf3"}, - {file = "fonttools-4.55.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b586ab5b15b6097f2fb71cafa3c98edfd0dba1ad8027229e7b1e204a58b0e09d"}, - {file = "fonttools-4.55.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8c2794ded89399cc2169c4d0bf7941247b8d5932b2659e09834adfbb01589aa"}, - {file = "fonttools-4.55.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf4fe7c124aa3f4e4c1940880156e13f2f4d98170d35c749e6b4f119a872551e"}, - {file = "fonttools-4.55.3-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:86721fbc389ef5cc1e2f477019e5069e8e4421e8d9576e9c26f840dbb04678de"}, - {file = "fonttools-4.55.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:89bdc5d88bdeec1b15af790810e267e8332d92561dce4f0748c2b95c9bdf3926"}, - {file = "fonttools-4.55.3-cp38-cp38-win32.whl", hash = "sha256:bc5dbb4685e51235ef487e4bd501ddfc49be5aede5e40f4cefcccabc6e60fb4b"}, - {file = "fonttools-4.55.3-cp38-cp38-win_amd64.whl", hash = "sha256:cd70de1a52a8ee2d1877b6293af8a2484ac82514f10b1c67c1c5762d38073e56"}, - {file = "fonttools-4.55.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bdcc9f04b36c6c20978d3f060e5323a43f6222accc4e7fcbef3f428e216d96af"}, - {file = "fonttools-4.55.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c3ca99e0d460eff46e033cd3992a969658c3169ffcd533e0a39c63a38beb6831"}, - {file = "fonttools-4.55.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22f38464daa6cdb7b6aebd14ab06609328fe1e9705bb0fcc7d1e69de7109ee02"}, - {file = "fonttools-4.55.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed63959d00b61959b035c7d47f9313c2c1ece090ff63afea702fe86de00dbed4"}, - {file = "fonttools-4.55.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5e8d657cd7326eeaba27de2740e847c6b39dde2f8d7cd7cc56f6aad404ddf0bd"}, - {file = "fonttools-4.55.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:fb594b5a99943042c702c550d5494bdd7577f6ef19b0bc73877c948a63184a32"}, - {file = "fonttools-4.55.3-cp39-cp39-win32.whl", hash = "sha256:dc5294a3d5c84226e3dbba1b6f61d7ad813a8c0238fceea4e09aa04848c3d851"}, - {file = "fonttools-4.55.3-cp39-cp39-win_amd64.whl", hash = "sha256:aedbeb1db64496d098e6be92b2e63b5fac4e53b1b92032dfc6988e1ea9134a4d"}, - {file = "fonttools-4.55.3-py3-none-any.whl", hash = "sha256:f412604ccbeee81b091b420272841e5ec5ef68967a9790e80bffd0e30b8e2977"}, - {file = "fonttools-4.55.3.tar.gz", hash = "sha256:3983313c2a04d6cc1fe9251f8fc647754cf49a61dac6cb1e7249ae67afaafc45"}, + {file = "fonttools-4.55.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c2680a3e6e2e2d104a7ea81fb89323e1a9122c23b03d6569d0768887d0d76e69"}, + {file = "fonttools-4.55.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a7831d16c95b60866772a15fdcc03772625c4bb6d858e0ad8ef3d6e48709b2ef"}, + {file = "fonttools-4.55.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:833927d089e6585019f2c85e3f8f7d87733e3fe81cd704ebaca7afa27e2e7113"}, + {file = "fonttools-4.55.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7858dc6823296a053d85b831fa8428781c6c6f06fca44582bf7b6b2ff32a9089"}, + {file = "fonttools-4.55.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:05568a66b090ed9d79aefdce2ceb180bb64fc856961deaedc29f5ad51355ce2c"}, + {file = "fonttools-4.55.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2dbc08e227fbeb716776905a7bd3c4fc62c8e37c8ef7d481acd10cb5fde12222"}, + {file = "fonttools-4.55.7-cp310-cp310-win32.whl", hash = "sha256:6eb93cbba484a463b5ee83f7dd3211905f27a3871d20d90fb72de84c6c5056e3"}, + {file = "fonttools-4.55.7-cp310-cp310-win_amd64.whl", hash = "sha256:7ff8e606f905048dc91a55a06d994b68065bf35752ae199df54a9bf30013dcaa"}, + {file = "fonttools-4.55.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:916e1d926823b4b3b3815c59fc79f4ed670696fdd5fd9a5e690a0503eef38f79"}, + {file = "fonttools-4.55.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b89da448e0073408d7b2c44935f9fdae4fdc93644899f99f6102ef883ecf083c"}, + {file = "fonttools-4.55.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:087ace2d06894ccdb03e6975d05da6bb9cec0c689b2a9983c059880e33a1464a"}, + {file = "fonttools-4.55.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:775ed0700ee6f781436641f18a0c61b1846a8c1aecae6da6b395c4417e2cb567"}, + {file = "fonttools-4.55.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9ec71d0cc0242899f87e4c230ed0b22c7b8681f288fb80e3d81c2c54c5bd2c79"}, + {file = "fonttools-4.55.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d4b1c5939c0521525f45522823508e6fad21175bca978583688ea3b3736e6625"}, + {file = "fonttools-4.55.7-cp311-cp311-win32.whl", hash = "sha256:23df0f1003abaf8a435543f59583fc247e7ae1b047ee2263510e0654a5f207e0"}, + {file = "fonttools-4.55.7-cp311-cp311-win_amd64.whl", hash = "sha256:82163d58b43eff6e2025a25c32905fdb9042a163cc1ff82dab393e7ffc77a7d5"}, + {file = "fonttools-4.55.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:12e81d44f762156d28b5c93a6b65d98ed73678be45b22546de8ed29736c3cb96"}, + {file = "fonttools-4.55.7-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c26445a7be689f8b70df7d5d2e2c85ec4407bdb769902a23dd45ac44f767575d"}, + {file = "fonttools-4.55.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2cbafedb9462be7cf68c66b6ca1d8309842fe36b729f1b1969595f5d660e5c2"}, + {file = "fonttools-4.55.7-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4bde87985012adbd7559bc363d802fb335e92a07ff86a76cf02bebb0b8566d1"}, + {file = "fonttools-4.55.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:69ed0660750993150f7c4d966c0c1ffaa0385f23ccef85c2ff108062d80dd7ea"}, + {file = "fonttools-4.55.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3098355e7a7b5ac48d5dc29684a65271187b865b85675033958b57c40364ee34"}, + {file = "fonttools-4.55.7-cp312-cp312-win32.whl", hash = "sha256:ee7aa8bb716318e3d835ef473978e22b7a39c0f1b3b08cc0b0ee1bba6f73bc1e"}, + {file = "fonttools-4.55.7-cp312-cp312-win_amd64.whl", hash = "sha256:e696d6e2baf4cc57ded34bb87e5d3a9e4da9732f3d9e8e2c6db0746e57a6dc0b"}, + {file = "fonttools-4.55.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e10c7fb80cdfdc32244514cbea0906e9f53e3cc80d64d3389da09502fd999b55"}, + {file = "fonttools-4.55.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1101976c703ff4008a928fc3fef42caf06d035bfc4614230d7e797cbe356feb0"}, + {file = "fonttools-4.55.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e6dffe9cbcd163ef617fab1f81682e4d1629b7a5b9c5e598274dc2d03e88bcd"}, + {file = "fonttools-4.55.7-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77e5115a425d53be6e31cd0fe9210f62a488bccf81eb113ab5dd7f4fa88e4d81"}, + {file = "fonttools-4.55.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f0c45eae32d090763820756b18322a70571dada3f1cbe003debc37a9c35bc260"}, + {file = "fonttools-4.55.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd4ebc475d43f3de2b26e0cf551eff92c24e22d1aee03dc1b33adb52fc2e6cb2"}, + {file = "fonttools-4.55.7-cp313-cp313-win32.whl", hash = "sha256:371197de1283cc99f5f10eb91496520eb0e2d079312d014fd6cef9e802174c6a"}, + {file = "fonttools-4.55.7-cp313-cp313-win_amd64.whl", hash = "sha256:418ece624fbc04e199f58398ffef3eaad645baba65434871b09eb7350a3a346b"}, + {file = "fonttools-4.55.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:3976db357484bf4cb533dfd0d1a444b38ad06062458715ebf21e38c71aff325d"}, + {file = "fonttools-4.55.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:30c3501328363b73a90acc8a722dd199c993f2c4369ea16886128d94e91897ec"}, + {file = "fonttools-4.55.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0899cd23967950e7b902ea75af06cfe5f59ac71eb38e98a774c9e596790e6aa"}, + {file = "fonttools-4.55.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f669910b64d27750398f6c56c651367d4954b05c86ff067af1c9949e109cf1e2"}, + {file = "fonttools-4.55.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:1d4be8354c245c00aecfc90f5d3da8606226f0ac22e1cb0837b39139e4c2df85"}, + {file = "fonttools-4.55.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:9074a2848ea5b607377e16998dfcf90cf5eb614d0c388541b9782d5cc038e149"}, + {file = "fonttools-4.55.7-cp38-cp38-win32.whl", hash = "sha256:5ff0daf8b2e0612e5761fed2e4a2f54eff9d9ec0aeb4091c9f3666f9a118325e"}, + {file = "fonttools-4.55.7-cp38-cp38-win_amd64.whl", hash = "sha256:0ed25d7b5fa4ae6a805c2a9cc0e5307d45cbb3b8e155584fe932d0f3b6a997bf"}, + {file = "fonttools-4.55.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8ef5ee98fc320c158e4e459a5ee40d1ac3728d4ce11c3c8dfd854aa0aa5c042f"}, + {file = "fonttools-4.55.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:09740feed51f9ed816aebf5d82071b7fecf693ac3a7e0fc8ea433f5dc3bd92f5"}, + {file = "fonttools-4.55.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3d19ea483b3cd8833e9e2ee8115f3d2044d55d3743d84f9c23b48b52d7516d8"}, + {file = "fonttools-4.55.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c135c91d47351b84893fb6fcbb8f178eba14f7cb195850264c0675c85e4238b6"}, + {file = "fonttools-4.55.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:bee4920ebeb540849bc3555d871e2a8487e39ce8263c281f74d5b6d44d2bf1df"}, + {file = "fonttools-4.55.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f3b63648600dd0081bdd6856a86d014a7f1d2d11c3c974542f866478d832e103"}, + {file = "fonttools-4.55.7-cp39-cp39-win32.whl", hash = "sha256:d4bd27f0fa5120aaa39f76de5768959bc97300e0f59a3160d466b51436a38aea"}, + {file = "fonttools-4.55.7-cp39-cp39-win_amd64.whl", hash = "sha256:c665df9c9d99937a5bf807bace1c0c95bd13f55de8c82aaf9856b868dcbfe5d9"}, + {file = "fonttools-4.55.7-py3-none-any.whl", hash = "sha256:3304dfcf9ca204dd0ef691a287bd851ddd8e8250108658c0677c3fdfec853a20"}, + {file = "fonttools-4.55.7.tar.gz", hash = "sha256:6899e3d97225a8218f525e9754da0376e1c62953a0d57a76c5abaada51e0d140"}, ] [package.extras] @@ -927,7 +1016,6 @@ version = "2023.3.27" description = "A clean customisable Sphinx documentation theme." optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "furo-2023.3.27-py3-none-any.whl", hash = "sha256:4ab2be254a2d5e52792d0ca793a12c35582dd09897228a6dd47885dabd5c9521"}, {file = "furo-2023.3.27.tar.gz", hash = "sha256:b99e7867a5cc833b2b34d7230631dd6558c7a29f93071fdbb5709634bb33c5a5"}, @@ -945,8 +1033,6 @@ version = "3.1.1" description = "Lightweight in-process concurrent programming" optional = false python-versions = ">=3.7" -groups = ["main"] -markers = "platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\"" files = [ {file = "greenlet-3.1.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:0bbae94a29c9e5c7e4a2b7f0aae5c17e8e90acbfd3bf6270eeba60c39fce3563"}, {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fde093fb93f35ca72a556cf72c92ea3ebfda3d79fc35bb19fbe685853869a83"}, @@ -1027,13 +1113,50 @@ files = [ docs = ["Sphinx", "furo"] test = ["objgraph", "psutil"] +[[package]] +name = "h5py" +version = "3.12.1" +description = "Read and write HDF5 files from Python" +optional = true +python-versions = ">=3.9" +files = [ + {file = "h5py-3.12.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f0f1a382cbf494679c07b4371f90c70391dedb027d517ac94fa2c05299dacda"}, + {file = "h5py-3.12.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cb65f619dfbdd15e662423e8d257780f9a66677eae5b4b3fc9dca70b5fd2d2a3"}, + {file = "h5py-3.12.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b15d8dbd912c97541312c0e07438864d27dbca857c5ad634de68110c6beb1c2"}, + {file = "h5py-3.12.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59685fe40d8c1fbbee088c88cd4da415a2f8bee5c270337dc5a1c4aa634e3307"}, + {file = "h5py-3.12.1-cp310-cp310-win_amd64.whl", hash = "sha256:577d618d6b6dea3da07d13cc903ef9634cde5596b13e832476dd861aaf651f3e"}, + {file = "h5py-3.12.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ccd9006d92232727d23f784795191bfd02294a4f2ba68708825cb1da39511a93"}, + {file = "h5py-3.12.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ad8a76557880aed5234cfe7279805f4ab5ce16b17954606cca90d578d3e713ef"}, + {file = "h5py-3.12.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1473348139b885393125126258ae2d70753ef7e9cec8e7848434f385ae72069e"}, + {file = "h5py-3.12.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:018a4597f35092ae3fb28ee851fdc756d2b88c96336b8480e124ce1ac6fb9166"}, + {file = "h5py-3.12.1-cp311-cp311-win_amd64.whl", hash = "sha256:3fdf95092d60e8130ba6ae0ef7a9bd4ade8edbe3569c13ebbaf39baefffc5ba4"}, + {file = "h5py-3.12.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:06a903a4e4e9e3ebbc8b548959c3c2552ca2d70dac14fcfa650d9261c66939ed"}, + {file = "h5py-3.12.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7b3b8f3b48717e46c6a790e3128d39c61ab595ae0a7237f06dfad6a3b51d5351"}, + {file = "h5py-3.12.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:050a4f2c9126054515169c49cb900949814987f0c7ae74c341b0c9f9b5056834"}, + {file = "h5py-3.12.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c4b41d1019322a5afc5082864dfd6359f8935ecd37c11ac0029be78c5d112c9"}, + {file = "h5py-3.12.1-cp312-cp312-win_amd64.whl", hash = "sha256:e4d51919110a030913201422fb07987db4338eba5ec8c5a15d6fab8e03d443fc"}, + {file = "h5py-3.12.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:513171e90ed92236fc2ca363ce7a2fc6f2827375efcbb0cc7fbdd7fe11fecafc"}, + {file = "h5py-3.12.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:59400f88343b79655a242068a9c900001a34b63e3afb040bd7cdf717e440f653"}, + {file = "h5py-3.12.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3e465aee0ec353949f0f46bf6c6f9790a2006af896cee7c178a8c3e5090aa32"}, + {file = "h5py-3.12.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba51c0c5e029bb5420a343586ff79d56e7455d496d18a30309616fdbeed1068f"}, + {file = "h5py-3.12.1-cp313-cp313-win_amd64.whl", hash = "sha256:52ab036c6c97055b85b2a242cb540ff9590bacfda0c03dd0cf0661b311f522f8"}, + {file = "h5py-3.12.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d2b8dd64f127d8b324f5d2cd1c0fd6f68af69084e9e47d27efeb9e28e685af3e"}, + {file = "h5py-3.12.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4532c7e97fbef3d029735db8b6f5bf01222d9ece41e309b20d63cfaae2fb5c4d"}, + {file = "h5py-3.12.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fdf6d7936fa824acfa27305fe2d9f39968e539d831c5bae0e0d83ed521ad1ac"}, + {file = "h5py-3.12.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84342bffd1f82d4f036433e7039e241a243531a1d3acd7341b35ae58cdab05bf"}, + {file = "h5py-3.12.1-cp39-cp39-win_amd64.whl", hash = "sha256:62be1fc0ef195891949b2c627ec06bc8e837ff62d5b911b6e42e38e0f20a897d"}, + {file = "h5py-3.12.1.tar.gz", hash = "sha256:326d70b53d31baa61f00b8aa5f95c2fcb9621a3ee8365d770c551a13dbbcbfdf"}, +] + +[package.dependencies] +numpy = ">=1.19.3" + [[package]] name = "idna" version = "3.10" description = "Internationalized Domain Names in Applications (IDNA)" optional = false python-versions = ">=3.6" -groups = ["docs"] files = [ {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, @@ -1048,7 +1171,6 @@ version = "1.4.1" description = "Getting image size from png/jpeg/jpeg2000/gif file" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -groups = ["docs"] files = [ {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, @@ -1056,15 +1178,13 @@ files = [ [[package]] name = "importlib-metadata" -version = "8.5.0" +version = "8.6.1" description = "Read metadata from Python packages" optional = false -python-versions = ">=3.8" -groups = ["main", "docs"] -markers = "python_version < \"3.10\"" +python-versions = ">=3.9" files = [ - {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, - {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, + {file = "importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e"}, + {file = "importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580"}, ] [package.dependencies] @@ -1076,7 +1196,7 @@ cover = ["pytest-cov"] doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] enabler = ["pytest-enabler (>=2.2)"] perf = ["ipython"] -test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"] +test = ["flufl.flake8", "importlib_resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"] type = ["pytest-mypy"] [[package]] @@ -1085,8 +1205,6 @@ version = "6.5.2" description = "Read resources from Python packages" optional = false python-versions = ">=3.9" -groups = ["main"] -markers = "python_version < \"3.10\"" files = [ {file = "importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec"}, {file = "importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c"}, @@ -1109,7 +1227,6 @@ version = "2.0.0" description = "brain-dead simple config-ini parsing" optional = false python-versions = ">=3.7" -groups = ["tests"] files = [ {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, @@ -1121,7 +1238,6 @@ version = "7.34.0" description = "IPython: Productive Interactive Computing" optional = false python-versions = ">=3.7" -groups = ["dev"] files = [ {file = "ipython-7.34.0-py3-none-any.whl", hash = "sha256:c175d2440a1caff76116eb719d40538fbb316e214eda85c5515c303aacbfb23e"}, {file = "ipython-7.34.0.tar.gz", hash = "sha256:af3bdb46aa292bce5615b1b2ebc76c2080c5f77f54bda2ec72461317273e7cd6"}, @@ -1154,18 +1270,18 @@ test = ["ipykernel", "nbformat", "nose (>=0.10.1)", "numpy (>=1.17)", "pygments" [[package]] name = "isort" -version = "5.13.2" +version = "6.0.0" description = "A Python utility / library to sort Python imports." optional = false -python-versions = ">=3.8.0" -groups = ["analysis"] +python-versions = ">=3.9.0" files = [ - {file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"}, - {file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"}, + {file = "isort-6.0.0-py3-none-any.whl", hash = "sha256:567954102bb47bb12e0fae62606570faacddd441e45683968c8d1734fb1af892"}, + {file = "isort-6.0.0.tar.gz", hash = "sha256:75d9d8a1438a9432a7d7b54f2d3b45cad9a4a0fdba43617d9873379704a8bdf1"}, ] [package.extras] -colors = ["colorama (>=0.4.6)"] +colors = ["colorama"] +plugins = ["setuptools"] [[package]] name = "jedi" @@ -1173,7 +1289,6 @@ version = "0.19.2" description = "An autocompletion tool for Python that can be used for text editors." optional = false python-versions = ">=3.6" -groups = ["dev"] files = [ {file = "jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9"}, {file = "jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0"}, @@ -1193,7 +1308,6 @@ version = "3.1.5" description = "A very fast and expressive template engine." optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb"}, {file = "jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb"}, @@ -1211,7 +1325,6 @@ version = "1.4.2" description = "Lightweight pipelining with Python functions" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"}, {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"}, @@ -1223,7 +1336,6 @@ version = "1.4.7" description = "A fast implementation of the Cassowary constraint solver" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6"}, {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17"}, @@ -1347,7 +1459,6 @@ version = "3.0.0" description = "A lexer and codec to work with LaTeX code in Python." optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "latexcodec-3.0.0-py3-none-any.whl", hash = "sha256:6f3477ad5e61a0a99bd31a6a370c34e88733a6bad9c921a3ffcfacada12f41a7"}, {file = "latexcodec-3.0.0.tar.gz", hash = "sha256:917dc5fe242762cc19d963e6548b42d63a118028cdd3361d62397e3b638b6bc5"}, @@ -1359,7 +1470,6 @@ version = "0.43.0" description = "lightweight wrapper around basic LLVM functionality" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "llvmlite-0.43.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a289af9a1687c6cf463478f0fa8e8aa3b6fb813317b0d70bf1ed0759eab6f761"}, {file = "llvmlite-0.43.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d4fd101f571a31acb1559ae1af30f30b1dc4b3186669f92ad780e17c81e91bc"}, @@ -1390,7 +1500,6 @@ version = "1.3.8" description = "A super-fast templating language that borrows the best ideas from the existing templating languages." optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "Mako-1.3.8-py3-none-any.whl", hash = "sha256:42f48953c7eb91332040ff567eb7eea69b22e7a4affbc5ba8e845e8f730f6627"}, {file = "mako-1.3.8.tar.gz", hash = "sha256:577b97e414580d3e088d47c2dbbe9594aa7a5146ed2875d4dfa9075af2dd3cc8"}, @@ -1410,7 +1519,6 @@ version = "3.0.2" description = "Safely add untrusted strings to HTML/XML markup." optional = false python-versions = ">=3.9" -groups = ["main", "docs"] files = [ {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8"}, {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158"}, @@ -1481,7 +1589,6 @@ version = "3.9.4" description = "Python plotting package" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "matplotlib-3.9.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fdd7abfb706dfa8d307af64a87f1a862879ec3cd8d0ec8637458f0885b9c50"}, {file = "matplotlib-3.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d89bc4e85e40a71d1477780366c27fb7c6494d293e1617788986f74e2a03d7ff"}, @@ -1547,7 +1654,6 @@ version = "0.1.7" description = "Inline Matplotlib backend for Jupyter" optional = false python-versions = ">=3.8" -groups = ["dev"] files = [ {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, @@ -1562,7 +1668,6 @@ version = "0.7.0" description = "McCabe checker, plugin for flake8" optional = false python-versions = ">=3.6" -groups = ["analysis"] files = [ {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"}, {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, @@ -1574,8 +1679,6 @@ version = "3.1.6" description = "Python bindings for MPI" optional = true python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" -groups = ["main"] -markers = "extra == \"cuda\"" files = [ {file = "mpi4py-3.1.6-cp27-cp27m-win32.whl", hash = "sha256:95f27e00f3951f9c1533cd99ffeae2f384f7ba53cc3870ee06c3c88f9e5bd6c3"}, {file = "mpi4py-3.1.6-cp27-cp27m-win_amd64.whl", hash = "sha256:ea8a65f74707e1be5a0125ae3f4f6c0c475c3d845d623b9f5686a919c1119439"}, @@ -1604,7 +1707,6 @@ version = "1.3.0" description = "Python library for arbitrary-precision floating-point arithmetic" optional = false python-versions = "*" -groups = ["main"] files = [ {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, @@ -1622,7 +1724,6 @@ version = "3.2.1" description = "Python package for creating and manipulating graphs and networks" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "networkx-3.2.1-py3-none-any.whl", hash = "sha256:f18c69adc97877c42332c170849c96cefa91881c99a7cb3e95b7c659ebdc1ec2"}, {file = "networkx-3.2.1.tar.gz", hash = "sha256:9f1bb5cf3409bf324e0a722c20bdb4c20ee39bf1c30ce8ae499c8502b0b5e0c6"}, @@ -1641,7 +1742,6 @@ version = "0.60.0" description = "compiling Python code using LLVM" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "numba-0.60.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5d761de835cd38fb400d2c26bb103a2726f548dc30368853121d66201672e651"}, {file = "numba-0.60.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:159e618ef213fba758837f9837fb402bbe65326e60ba0633dbe6c7f274d42c1b"}, @@ -1676,7 +1776,6 @@ version = "1.26.4" description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, @@ -1722,7 +1821,6 @@ version = "1.0.0" description = "Reference OpenQASM AST in Python" optional = false python-versions = "*" -groups = ["main"] files = [ {file = "openqasm3-1.0.0-py3-none-any.whl", hash = "sha256:d4371737b4a49b0d56248ed3d30766a94000bccfb43303ec9c7ead351a1b6cc3"}, {file = "openqasm3-1.0.0.tar.gz", hash = "sha256:3f2bb1cca855cff114e046bac22d59adbf9b754cac6398961aa6d22588fb688e"}, @@ -1739,14 +1837,13 @@ tests = ["pytest (>=6.0)", "pyyaml"] [[package]] name = "optuna" -version = "4.1.0" +version = "4.2.0" description = "A hyperparameter optimization framework" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ - {file = "optuna-4.1.0-py3-none-any.whl", hash = "sha256:1763856b01c9238594d9d21db92611aac9980e9a6300bd658a7c6464712c704e"}, - {file = "optuna-4.1.0.tar.gz", hash = "sha256:b364e87a2038f9946c5e2770c130597538aac528b4a82c1cab5267f337ea7679"}, + {file = "optuna-4.2.0-py3-none-any.whl", hash = "sha256:539a47fda44104eb2b879c883d4640704b482df416ae99d0f24505f6e2280c28"}, + {file = "optuna-4.2.0.tar.gz", hash = "sha256:6ce226483317cf73df133d9ddf300091f946c0ad0dbdbc50b28891049b8400f2"}, ] [package.dependencies] @@ -1760,10 +1857,10 @@ tqdm = "*" [package.extras] benchmark = ["asv (>=0.5.0)", "cma", "virtualenv"] -checking = ["black", "blackdoc", "flake8", "isort", "mypy", "mypy-boto3-s3", "types-PyYAML", "types-redis", "types-setuptools", "types-tqdm", "typing-extensions (>=3.10.0.0)"] -document = ["ase", "cmaes (>=0.10.0)", "fvcore", "kaleido", "lightgbm", "matplotlib (!=3.6.0)", "pandas", "pillow", "plotly (>=4.9.0)", "scikit-learn", "sphinx", "sphinx-copybutton", "sphinx-gallery", "sphinx-rtd-theme (>=1.2.0)", "torch", "torchvision"] -optional = ["boto3", "cmaes (>=0.10.0)", "google-cloud-storage", "matplotlib (!=3.6.0)", "pandas", "plotly (>=4.9.0)", "redis", "scikit-learn (>=0.24.2)", "scipy", "torch"] -test = ["coverage", "fakeredis[lua]", "kaleido", "moto", "pytest", "scipy (>=1.9.2)", "torch"] +checking = ["black", "blackdoc", "flake8", "isort", "mypy", "mypy_boto3_s3", "types-PyYAML", "types-redis", "types-setuptools", "types-tqdm", "typing_extensions (>=3.10.0.0)"] +document = ["ase", "cmaes (>=0.10.0)", "fvcore", "kaleido (<0.4)", "lightgbm", "matplotlib (!=3.6.0)", "pandas", "pillow", "plotly (>=4.9.0)", "scikit-learn", "sphinx", "sphinx-copybutton", "sphinx-gallery", "sphinx-notfound-page", "sphinx_rtd_theme (>=1.2.0)", "torch", "torchvision"] +optional = ["boto3", "cmaes (>=0.10.0)", "google-cloud-storage", "grpcio", "matplotlib (!=3.6.0)", "pandas", "plotly (>=4.9.0)", "protobuf (>=5.28.1)", "redis", "scikit-learn (>=0.24.2)", "scipy", "torch"] +test = ["coverage", "fakeredis[lua]", "grpcio", "kaleido (<0.4)", "moto", "protobuf (>=5.28.1)", "pytest", "scipy (>=1.9.2)", "torch"] [[package]] name = "packaging" @@ -1771,7 +1868,6 @@ version = "24.2" description = "Core utilities for Python packages" optional = false python-versions = ">=3.8" -groups = ["main", "docs", "tests"] files = [ {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, @@ -1783,7 +1879,6 @@ version = "0.8.4" description = "A Python Parser" optional = false python-versions = ">=3.6" -groups = ["dev"] files = [ {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, @@ -1793,14 +1888,23 @@ files = [ qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] testing = ["docopt", "pytest"] +[[package]] +name = "pbr" +version = "6.1.0" +description = "Python Build Reasonableness" +optional = true +python-versions = ">=2.6" +files = [ + {file = "pbr-6.1.0-py2.py3-none-any.whl", hash = "sha256:a776ae228892d8013649c0aeccbb3d5f99ee15e005a4cbb7e61d55a067b28a2a"}, + {file = "pbr-6.1.0.tar.gz", hash = "sha256:788183e382e3d1d7707db08978239965e8b9e4e5ed42669bf4758186734d5f24"}, +] + [[package]] name = "pexpect" version = "4.9.0" description = "Pexpect allows easy control of interactive console applications." optional = false python-versions = "*" -groups = ["dev"] -markers = "sys_platform != \"win32\"" files = [ {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, @@ -1815,7 +1919,6 @@ version = "0.7.5" description = "Tiny 'shelve'-like database with concurrency support" optional = false python-versions = "*" -groups = ["dev"] files = [ {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, @@ -1827,7 +1930,6 @@ version = "11.1.0" description = "Python Imaging Library (Fork)" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "pillow-11.1.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:e1abe69aca89514737465752b4bcaf8016de61b3be1397a8fc260ba33321b3a8"}, {file = "pillow-11.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c640e5a06869c75994624551f45e5506e4256562ead981cce820d5ab39ae2192"}, @@ -1916,7 +2018,6 @@ version = "4.3.6" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." optional = false python-versions = ">=3.8" -groups = ["analysis"] files = [ {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, @@ -1933,7 +2034,6 @@ version = "1.5.0" description = "plugin and hook calling mechanisms for python" optional = false python-versions = ">=3.8" -groups = ["tests"] files = [ {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, @@ -1943,16 +2043,26 @@ files = [ dev = ["pre-commit", "tox"] testing = ["pytest", "pytest-benchmark"] +[[package]] +name = "ply" +version = "3.11" +description = "Python Lex & Yacc" +optional = true +python-versions = "*" +files = [ + {file = "ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce"}, + {file = "ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3"}, +] + [[package]] name = "prompt-toolkit" -version = "3.0.48" +version = "3.0.50" description = "Library for building powerful interactive command lines in Python" optional = false -python-versions = ">=3.7.0" -groups = ["dev"] +python-versions = ">=3.8.0" files = [ - {file = "prompt_toolkit-3.0.48-py3-none-any.whl", hash = "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e"}, - {file = "prompt_toolkit-3.0.48.tar.gz", hash = "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90"}, + {file = "prompt_toolkit-3.0.50-py3-none-any.whl", hash = "sha256:9b6427eb19e479d98acff65196a307c555eb567989e6d88ebbb1b509d9779198"}, + {file = "prompt_toolkit-3.0.50.tar.gz", hash = "sha256:544748f3860a2623ca5cd6d2795e7a14f3d0e1c3c9728359013f79877fc89bab"}, ] [package.dependencies] @@ -1964,7 +2074,6 @@ version = "6.1.1" description = "Cross-platform lib for process and system monitoring in Python." optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" -groups = ["main"] files = [ {file = "psutil-6.1.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:9ccc4316f24409159897799b83004cb1e24f9819b0dcf9c0b68bdcb6cefee6a8"}, {file = "psutil-6.1.1-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:ca9609c77ea3b8481ab005da74ed894035936223422dc591d6772b147421f777"}, @@ -1995,8 +2104,6 @@ version = "0.7.0" description = "Run a subprocess in a pseudo terminal" optional = false python-versions = "*" -groups = ["dev"] -markers = "sys_platform != \"win32\"" files = [ {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, @@ -2008,7 +2115,6 @@ version = "0.24.0" description = "A BibTeX-compatible bibliography processor in Python" optional = false python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*" -groups = ["docs"] files = [ {file = "pybtex-0.24.0-py2.py3-none-any.whl", hash = "sha256:e1e0c8c69998452fea90e9179aa2a98ab103f3eed894405b7264e517cc2fcc0f"}, {file = "pybtex-0.24.0.tar.gz", hash = "sha256:818eae35b61733e5c007c3fcd2cfb75ed1bc8b4173c1f70b56cc4c0802d34755"}, @@ -2028,7 +2134,6 @@ version = "1.0.3" description = "A docutils backend for pybtex." optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "pybtex-docutils-1.0.3.tar.gz", hash = "sha256:3a7ebdf92b593e00e8c1c538aa9a20bca5d92d84231124715acc964d51d93c6b"}, {file = "pybtex_docutils-1.0.3-py3-none-any.whl", hash = "sha256:8fd290d2ae48e32fcb54d86b0efb8d573198653c7e2447d5bec5847095f430b9"}, @@ -2038,13 +2143,23 @@ files = [ docutils = ">=0.14" pybtex = ">=0.16" +[[package]] +name = "pycparser" +version = "2.22" +description = "C parser in Python" +optional = true +python-versions = ">=3.8" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + [[package]] name = "pygments" version = "2.19.1" description = "Pygments is a syntax highlighting package written in Python." optional = false python-versions = ">=3.8" -groups = ["dev", "docs"] files = [ {file = "pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c"}, {file = "pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f"}, @@ -2055,14 +2170,13 @@ windows-terminal = ["colorama (>=0.4.6)"] [[package]] name = "pylint" -version = "3.3.3" +version = "3.3.4" description = "python code static checker" optional = false python-versions = ">=3.9.0" -groups = ["analysis"] files = [ - {file = "pylint-3.3.3-py3-none-any.whl", hash = "sha256:26e271a2bc8bce0fc23833805a9076dd9b4d5194e2a02164942cb3cdc37b4183"}, - {file = "pylint-3.3.3.tar.gz", hash = "sha256:07c607523b17e6d16e2ae0d7ef59602e332caa762af64203c24b41c27139f36a"}, + {file = "pylint-3.3.4-py3-none-any.whl", hash = "sha256:289e6a1eb27b453b08436478391a48cd53bb0efb824873f949e709350f3de018"}, + {file = "pylint-3.3.4.tar.gz", hash = "sha256:74ae7a38b177e69a9b525d0794bd8183820bfa7eb68cc1bee6e8ed22a42be4ce"}, ] [package.dependencies] @@ -2073,7 +2187,7 @@ dill = [ {version = ">=0.3.7", markers = "python_version >= \"3.12\""}, {version = ">=0.3.6", markers = "python_version >= \"3.11\" and python_version < \"3.12\""}, ] -isort = ">=4.2.5,<5.13.0 || >5.13.0,<6" +isort = ">=4.2.5,<5.13.0 || >5.13.0,<7" mccabe = ">=0.6,<0.8" platformdirs = ">=2.2.0" tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} @@ -2090,7 +2204,6 @@ version = "3.2.1" description = "pyparsing module - Classes and methods to define and execute parsing grammars" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1"}, {file = "pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a"}, @@ -2099,13 +2212,31 @@ files = [ [package.extras] diagrams = ["jinja2", "railroad-diagrams"] +[[package]] +name = "pyspnego" +version = "0.11.2" +description = "Windows Negotiate Authentication Client and Server" +optional = true +python-versions = ">=3.8" +files = [ + {file = "pyspnego-0.11.2-py3-none-any.whl", hash = "sha256:74abc1fb51e59360eb5c5c9086e5962174f1072c7a50cf6da0bda9a4bcfdfbd4"}, + {file = "pyspnego-0.11.2.tar.gz", hash = "sha256:994388d308fb06e4498365ce78d222bf4f3570b6df4ec95738431f61510c971b"}, +] + +[package.dependencies] +cryptography = "*" +sspilib = {version = ">=0.1.0", markers = "sys_platform == \"win32\""} + +[package.extras] +kerberos = ["gssapi (>=1.6.0)", "krb5 (>=0.3.0)"] +yaml = ["ruamel.yaml"] + [[package]] name = "pytest" version = "8.3.4" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" -groups = ["tests"] files = [ {file = "pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6"}, {file = "pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"}, @@ -2128,7 +2259,6 @@ version = "4.1.0" description = "Pytest plugin for measuring coverage." optional = false python-versions = ">=3.7" -groups = ["tests"] files = [ {file = "pytest-cov-4.1.0.tar.gz", hash = "sha256:3904b13dfbfec47f003b8e77fd5b589cd11904a21ddf1ab38a64f204d6a10ef6"}, {file = "pytest_cov-4.1.0-py3-none-any.whl", hash = "sha256:6ba70b9e97e69fcc3fb45bfeab2d0a138fb65c4d0d6a41ef33983ad114be8c3a"}, @@ -2147,7 +2277,6 @@ version = "1.1.5" description = "pytest plugin that allows you to add environment variables." optional = false python-versions = ">=3.8" -groups = ["tests"] files = [ {file = "pytest_env-1.1.5-py3-none-any.whl", hash = "sha256:ce90cf8772878515c24b31cd97c7fa1f4481cd68d588419fd45f10ecaee6bc30"}, {file = "pytest_env-1.1.5.tar.gz", hash = "sha256:91209840aa0e43385073ac464a554ad2947cc2fd663a9debf88d03b01e0cc1cf"}, @@ -2166,7 +2295,6 @@ version = "2.9.0.post0" description = "Extensions to the standard Python datetime module" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" -groups = ["main"] files = [ {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, @@ -2181,7 +2309,6 @@ version = "6.0.2" description = "YAML parser and emitter for Python" optional = false python-versions = ">=3.8" -groups = ["main", "docs"] files = [ {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"}, {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"}, @@ -2244,7 +2371,6 @@ version = "0.2.15" description = "A framework for quantum computing with hardware acceleration." optional = false python-versions = "<3.13,>=3.9" -groups = ["main"] files = [ {file = "qibo-0.2.15-py3-none-any.whl", hash = "sha256:51625e7b1ac7f21e335b50931230437cf866fae7284bdc6b3433e80925d0f091"}, {file = "qibo-0.2.15.tar.gz", hash = "sha256:e002b9f785e66f1eed3f22fecc98b0d79d60d68842bbee6098d6754da981eac1"}, @@ -2265,13 +2391,221 @@ tabulate = ">=0.9.0,<0.10.0" qulacs = ["qulacs (>=0.6.4,<0.7.0)"] torch = ["torch (>=2.1.1,<2.4)"] +[[package]] +name = "qiskit" +version = "0.38.0" +description = "Software for developing quantum computing programs" +optional = true +python-versions = ">=3.7" +files = [ + {file = "qiskit-0.38.0.tar.gz", hash = "sha256:f7bcd2470bed40b2d41bedb8389a0102cb24427579218ea83a240881b1df0282"}, +] + +[package.dependencies] +qiskit-aer = "0.11.0" +qiskit-ibmq-provider = "0.19.2" +qiskit-terra = "0.21.2" + +[package.extras] +all = ["ipywidgets (>=7.3.0)", "matplotlib (>=2.1)", "pillow (>=4.2.1)", "pydot", "pygments (>=2.4)", "pylatexenc (>=1.4)", "qiskit-experiments (>=0.2.0)", "qiskit-finance (>=0.3.3)", "qiskit-machine-learning (>=0.4.0)", "qiskit-nature (>=0.4.1)", "qiskit-optimization (>=0.4.0)", "seaborn (>=0.9.0)"] +experiments = ["qiskit-experiments (>=0.2.0)"] +finance = ["qiskit-finance (>=0.3.3)"] +machine-learning = ["qiskit-machine-learning (>=0.4.0)"] +nature = ["qiskit-nature (>=0.4.1)"] +optimization = ["qiskit-optimization (>=0.4.0)"] +visualization = ["ipywidgets (>=7.3.0)", "matplotlib (>=2.1)", "pillow (>=4.2.1)", "pydot", "pygments (>=2.4)", "pylatexenc (>=1.4)", "seaborn (>=0.9.0)"] + +[[package]] +name = "qiskit-aer" +version = "0.11.0" +description = "Qiskit Aer - High performance simulators for Qiskit" +optional = true +python-versions = ">=3.7" +files = [ + {file = "qiskit-aer-0.11.0.tar.gz", hash = "sha256:d56aa88da4c702f887c015a5f6752dfe90e67d9d348c2f63620e82ec58e83bee"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2ff8f8b5628e066a0426412752f89b46d657dc9cd1df3fd996d7d15e9464dcad"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:692eff531a5a2b86fa0e105616740cfcb3cc9aef195bacf56b3709a0fbc17f8d"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c88a6b84daab85272c4e80e4aef04a145b40f9e7408038b7bce26f8e7d8edd95"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71f3b5eea0838c0f54c4abe69bcde9e68959b315324f35a01d9becb60b454fb7"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:caa451d7ab50f85051615b9e1f3de6d1f2157bf3f20f1e4ce32012652d619c3e"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3e8f1a8a7feca4b32f7484ee396bd4d78268a7a60dabc1990baaf81b22db811c"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32fae81ebc9038ce460af5cb4c4b94c98ea97ea533c822c5cdb5dae1d1384840"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-win32.whl", hash = "sha256:294da358c1957b297fbc5a3d78b4fb42ce0aa4e36d6d3bf369816d64ad493c39"}, + {file = "qiskit_aer-0.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:b6490252343f3a50482c4d9c82ffed9199f6e4af147c5914644c01a67b106c0e"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:d61e97788e9ceb31f11b13d5f8beed52b532fc0fbfd68ce0a5227b7cf582016b"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:dd41f2f4c264625299a9997c9ad05cc4de6084c4d07a748e3234faf181db9c50"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6eca95a4f82296aa6ab4a2c3a4ba97c92bf112027b4b6c0c15625684dbe82af6"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:254c45b616ea276562e5cf48ae7b52d14dd04d224284c4ad80aed2fffca9cf8a"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cf326579c8c9ff5d793354e52fd86c6e15df27172ca843bef4920933227f6bf5"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:385da5170a18e042b5582949edd3f7664c88cf0eeb5ba2d27ab706dc44389785"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-win32.whl", hash = "sha256:0c25470ae47d8d65b563288bf4215edad9b872af46ed408191c0eeac84124e2f"}, + {file = "qiskit_aer-0.11.0-cp37-cp37m-win_amd64.whl", hash = "sha256:f4a3487d0516fb1b6ca8a8737d9bbecbf8a242226265936c1de5626a0bd5bd35"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d4e17ac45da04086590e51cae70af8fb9a350e2b181971b8d7705d869c9860a2"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:51f4d4b3fdd7aaae812e018a67ccb364fc801194a0e2e0f3f6623d9e1c1a8431"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:23c8afb685f1aeacd2a0a25bda65e331eef0278accb39d059b0b7ec9617c1c82"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff116ffc09227a01713e5e20d67f77b6443b2af53b51b6414e2fbc1d0c6727a6"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:070fb1fde1ae66b38fa1417474d3f7c3c38a9e3a5d15c51cc6f7d34ee3aff639"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c62cc3d068aa3f7ef78bb08c0b616e826a411366ee4b483224a50fad7e2b9c06"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd7d7eeaab23a07855e671ff169a01f8b1f3954fa9a58718378331a32650b75e"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-win32.whl", hash = "sha256:c3d0c8bd70fcbe65673ea17a7492d3ce9f7462fccd1e28be2ca9ebd59340101a"}, + {file = "qiskit_aer-0.11.0-cp38-cp38-win_amd64.whl", hash = "sha256:5758fe43dd3035d2bf8e0072db1a21207300dc8fe60ededa35f2657318cee341"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d4bbdefd1773822366708fff96ff58c5b2811e93e69007c1d78f1dc27a7f3dcd"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:bd8b840826970d29514ec2aada2e3f42e59700ab1c05713eb6d75d3ac65fbf5e"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:22652978c9338af4b9690066bb09726151ad7ed176e4a9cf4e7a48851eb798cf"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2a4cceac02f00c73fd37b465075c3ade7ab50702859321b02ebe7e18a593236c"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4eac1b583f488475c5bb8e394119fc0c2a833638dced3c3cc5155c0fdcf504d4"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9975959dd0fd0667318a0d41eadde2eb94907296ef8174ee79e380d3ef7ff742"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f67f1ec548d4304306c65b386e44cdba2a3b193197d8d940542cd8084042b27c"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-win32.whl", hash = "sha256:32c9dbe8e7fbfcb241396de9c48b589c358ffc20ba58030e52701db27ac89f07"}, + {file = "qiskit_aer-0.11.0-cp39-cp39-win_amd64.whl", hash = "sha256:41dccaa1b4eb7567aecefecbe66d7065f1c284c8616290ecd66b6f5ba9d1cb48"}, +] + +[package.dependencies] +numpy = ">=1.16.3" +qiskit-terra = ">=0.21.0" +scipy = ">=1.0" + +[package.extras] +dask = ["dask", "distributed"] + +[[package]] +name = "qiskit-ibmq-provider" +version = "0.19.2" +description = "Qiskit provider for accessing the quantum devices and simulators at IBMQ" +optional = true +python-versions = ">=3.7" +files = [ + {file = "qiskit-ibmq-provider-0.19.2.tar.gz", hash = "sha256:489407bed016a04e9db05a2d2c44b50843621408e392ace4d067bad071aa5fc9"}, + {file = "qiskit_ibmq_provider-0.19.2-py3-none-any.whl", hash = "sha256:d31786cf5a54f334387081d82b5b19c4269c176079fab5ad843f8fc8eadbce84"}, +] + +[package.dependencies] +numpy = ">=1.13" +python-dateutil = ">=2.8.0" +qiskit-terra = ">=0.18.0" +requests = ">=2.19" +requests-ntlm = ">=1.1.0" +urllib3 = ">=1.21.1" +websocket-client = ">=1.0.1" +websockets = {version = ">=10.0", markers = "python_version >= \"3.7\""} + +[package.extras] +visualization = ["ipython (>=5.0.0)", "ipyvue (>=1.4.1)", "ipyvuetify (>=1.1)", "ipywidgets (>=7.3.0)", "matplotlib (>=2.1)", "plotly (>=4.4)", "pyperclip (>=1.7)", "seaborn (>=0.9.0)", "traitlets (!=5.0.5)"] + +[[package]] +name = "qiskit-terra" +version = "0.21.2" +description = "Software for developing quantum computing programs" +optional = true +python-versions = ">=3.7" +files = [ + {file = "qiskit-terra-0.21.2.tar.gz", hash = "sha256:355fd3992965afdf2b402b2071b61175ad98498151e0991d229d7afc822a7ec2"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f3761cbbcc9c956cbb642ae24e1250a6a7db7c19daa98440ecab12c0403dfac6"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d8391ecf98a5a4854264e314ef0fcd189258dafffc5cfee9ca8e3d6f98e5a1cd"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a0d3f5fe530a65bc74a0357107b387539f892f88c42d36f2c79fa3aa91469154"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:268560694645393be65e85f610ad7ba3f3d37b522cebab8afec9c90b32f384d3"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5e29cf7cfe1498630814e8aa4182d48905306ec3c47cfb4ab30e1f793274d7d"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:66f9cef4cdb8cd01968b1b0eb9eae23dcb693458357cfd2b1fdd3de567eec7e6"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82a766c79a8a6ab392f0a9a8e9a30a0732826796c90718a77460eb8ff2b9f7b0"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:52cd8acdb61b56f21a773b3a4f2b01ccec6843f9beb98c8ad97984fcc7c66f9a"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-win32.whl", hash = "sha256:a213ae25513caa656e8708390e2e1b41a744b442bf2f8510df46c90822abf239"}, + {file = "qiskit_terra-0.21.2-cp310-cp310-win_amd64.whl", hash = "sha256:d17051c95adcf3fb5483a7b8e81e2096369e03a55526a1838cf930308a4b8edb"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:afde22a4c1ac224fef9aeb5201ca65a115f703d99f42fbae20b7832fd1b723e9"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:65db08b7fcd7a736df7c45c4c0e29a4705df2acbe2014ea78a6bedf4394b29da"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:488f8d4e37eec5370f53c5654f22131d6e5e1a4035ef086da3970901c14a79fd"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c7ce76062662898626846a28df82b9dd29bb4b93318d1036670134efda7d267"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd01554a8d7165dad3d6766853b9d7d8038d0b2441cb0c26ac4d8cdd9e492b24"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1652d93559dae2d1a5d8f3599ec64f6ce5ee8de4e33fedf04e3d29b4d4f3eb52"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-win32.whl", hash = "sha256:0a85d38c1727bd0d03a4f366f67bbeab18f888909a98b63b048f89cadbf52c4c"}, + {file = "qiskit_terra-0.21.2-cp37-cp37m-win_amd64.whl", hash = "sha256:92f530bf07172203ea8a9c169cc2a82d526cc6ca683e3733d14f994f5fb78822"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:53ca8d909671a698b55d23a920db1744d3220a073b83a53de41c98a50d72282e"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4c665c16c86355e913b0bdb5778555774a47ef8bda4717ebc0f03e6723a32b5d"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ab589e494306ced49643361322b3dc57921d9e35b2c16db4fb2f90fd33ab4bc2"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7efcb8535fbc518683eec1306cfa1561fb4e966a4d48e1640b5dad7413ba4777"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4feeed7aa3887342d0a648b6823332943097b03cda00eb9f30e42e85e93c8825"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:24a4a8a2520e477cd07dd448509d3651e681c4c9e626ce71011b399ba6315635"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a94358f87ec8bf5d3ef516056877c33a049f49d1c44392751310ad5bfde711c0"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cdd40b95f7916473b20c68dd68d0a3e69761262bd7ba2fc87ff44d7412de0831"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-win32.whl", hash = "sha256:5030dac8a714b38b0566634227371323aeb1e5bee0ee6877a37951802aaa1785"}, + {file = "qiskit_terra-0.21.2-cp38-cp38-win_amd64.whl", hash = "sha256:32464b0ab7611ce82f3bfe3ae8b7ebb9fa0ab577459ba01d17e541365bc0dafa"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:d59338fd7cfd12f53a9ba57a3eadb0c2539ef8eaabcdd34bc2815a50db0952d1"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:904f0dac9c14fa8104559fa073b4deead679f66e3a9521c4631ddd1f19880909"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:71fa936b3f214d0a0c2394f5122e78f3fd92573ca1814b659648ffc7e65d0bbe"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c9382e94febc68fec737f2c78292d90ed491be99ed1b91ffb37e55e08bbf097"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eefdb6afd459734b1881e3a5b91fc3df3a481705b42f4c49811a04ce20e83c32"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22c562997062b7831b3765a7a9da1504ffdb32af0bde4ef20d0397517696ec4b"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a2c6359d4f05eed1904c3b538db7c6fd8b171224593878d21f9ab60ee9a2117"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4cf59748974a73171b99fbc291313d62546ce25291f31315c4af4af1de57b6f"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-win32.whl", hash = "sha256:73c79654b66e4fc7c953ba094fc1b91973bc814eeeb58d51024b5ffdb88f2347"}, + {file = "qiskit_terra-0.21.2-cp39-cp39-win_amd64.whl", hash = "sha256:59f069f7997726a6fa5ac715d7f667aaf12c54acf26f2146900f673f12b69a4a"}, +] + +[package.dependencies] +dill = ">=0.3" +numpy = ">=1.17" +ply = ">=3.10" +psutil = ">=5" +python-dateutil = ">=2.8.0" +retworkx = ">=0.11.0" +scipy = ">=1.5" +stevedore = ">=3.0.0" +symengine = {version = ">=0.9", markers = "platform_machine == \"x86_64\" or platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"amd64\" or platform_machine == \"arm64\""} +sympy = ">=1.3" +tweedledum = ">=1.1,<2.0" + +[package.extras] +all = ["ipywidgets (>=7.3.0)", "matplotlib (>=3.3)", "pillow (>=4.2.1)", "pydot", "pygments (>=2.4)", "pylatexenc (>=1.4)", "python-constraint (>=1.4)", "seaborn (>=0.9.0)", "z3-solver (>=4.7)"] +bip-mapper = ["cplex", "docplex"] +crosstalk-pass = ["z3-solver (>=4.7)"] +csp-layout-pass = ["python-constraint (>=1.4)"] +toqm = ["qiskit-toqm (>=0.0.4)"] +visualization = ["ipywidgets (>=7.3.0)", "matplotlib (>=3.3)", "pillow (>=4.2.1)", "pydot", "pygments (>=2.4)", "pylatexenc (>=1.4)", "seaborn (>=0.9.0)"] + +[[package]] +name = "qmatchatea" +version = "1.1.4" +description = "Quantum matcha TEA python library for tensor network emulation of quantum circuits." +optional = true +python-versions = ">=3.8" +files = [ + {file = "qmatchatea-1.1.4-py3-none-any.whl", hash = "sha256:544886607e9799719a965701214a5b2ebf0584a746ca553543c03a032bfee60f"}, + {file = "qmatchatea-1.1.4.tar.gz", hash = "sha256:5598fac2ae55497b157a003ad6518df0a898f2448213d6eca8387e2b3b2eb63e"}, +] + +[package.dependencies] +joblib = "*" +matplotlib = ">=3.1.3" +mpi4py = "*" +numpy = ">=1.18.1" +qiskit = "0.38.0" +qtealeaves = ">=1.1.7,<=1.1.12" +scipy = ">=1.4.1" + +[[package]] +name = "qtealeaves" +version = "1.1.12" +description = "Quantum TEA's python tensor network library" +optional = true +python-versions = ">=3.8" +files = [ + {file = "qtealeaves-1.1.12-py3-none-any.whl", hash = "sha256:964e06dd0cd87639918c15cbc0114b4e5ed1dce09957f56df39d4dcc07c9bfbc"}, + {file = "qtealeaves-1.1.12.tar.gz", hash = "sha256:5c2ac927b61b22224480a7713c387bc423f59e57fa7dc7a59f196e8d9aa661e6"}, +] + +[package.dependencies] +h5py = "*" +joblib = "*" +matplotlib = "*" +mpmath = "*" +numpy = "*" +scipy = "*" + [[package]] name = "quimb" version = "1.10.0" description = "Quantum information and many-body library." optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "quimb-1.10.0-py3-none-any.whl", hash = "sha256:4d270e71c9f03a4a41862682fbffcd076c61d7e40c4b3785a31ae869ce8830c4"}, {file = "quimb-1.10.0.tar.gz", hash = "sha256:e79f1be2f9895d966479ccabbd5ec087fc047baad83d3fb08fed264e2d7cc3ff"}, @@ -2301,7 +2635,6 @@ version = "2.32.3" description = "Python HTTP for Humans." optional = false python-versions = ">=3.8" -groups = ["docs"] files = [ {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, @@ -2317,13 +2650,75 @@ urllib3 = ">=1.21.1,<3" socks = ["PySocks (>=1.5.6,!=1.5.7)"] use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] +[[package]] +name = "requests-ntlm" +version = "1.3.0" +description = "This package allows for HTTP NTLM authentication using the requests library." +optional = true +python-versions = ">=3.8" +files = [ + {file = "requests_ntlm-1.3.0-py3-none-any.whl", hash = "sha256:4c7534a7d0e482bb0928531d621be4b2c74ace437e88c5a357ceb7452d25a510"}, + {file = "requests_ntlm-1.3.0.tar.gz", hash = "sha256:b29cc2462623dffdf9b88c43e180ccb735b4007228a542220e882c58ae56c668"}, +] + +[package.dependencies] +cryptography = ">=1.3" +pyspnego = ">=0.4.0" +requests = ">=2.0.0" + +[[package]] +name = "retworkx" +version = "0.16.0" +description = "A python graph library implemented in Rust" +optional = true +python-versions = ">=3.9" +files = [ + {file = "retworkx-0.16.0-py3-none-any.whl", hash = "sha256:64fc8f7f00397f76e9add1ff1e1fff2e4560aca6d03a6f4dab9d811a36d0fca3"}, +] + +[package.dependencies] +numpy = ">=1.16.0,<3" +rustworkx = "0.16.0" + +[package.extras] +all = ["matplotlib (>=3.0)", "pillow (>=5.4)"] +graphviz = ["pillow (>=5.4)"] +mpl = ["matplotlib (>=3.0)"] + +[[package]] +name = "rustworkx" +version = "0.16.0" +description = "A python graph library implemented in Rust" +optional = true +python-versions = ">=3.9" +files = [ + {file = "rustworkx-0.16.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:476a6c67b0142acd941691943750cc6737a48372304489969c2b62d30aaf4c27"}, + {file = "rustworkx-0.16.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:bef2ef42870f806af93979b457e240f6dfa4f867ca33965c620f3a804409ed3a"}, + {file = "rustworkx-0.16.0-cp39-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0db3a73bf68b3e66c08322a2fc95d3aa663d037d9b4e49c3509da4898d3529cc"}, + {file = "rustworkx-0.16.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f12a13d7486234fa2a84746d5e41f436bf9df43548043e7a232f48804ff8c61"}, + {file = "rustworkx-0.16.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:89efd5c3a4653ddacc55ca39f28b261d43deec7d678f8f8fc6b76b5087f1dfea"}, + {file = "rustworkx-0.16.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec0c12aac8c54910ace20ac6ada4b890cd39f95f69100514715f8ad7af9041e4"}, + {file = "rustworkx-0.16.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d650e39fc1a1534335f7517358ebfc3478bb235428463cfcd7c5750d50377b33"}, + {file = "rustworkx-0.16.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:293180b83509ee9bff4c3af7ccc1024f6528d61b65d0cb7320bd31924f10cb71"}, + {file = "rustworkx-0.16.0-cp39-abi3-win32.whl", hash = "sha256:040c4368729cf502f756a3b0ff5f1c6915fc389f74dcc6afc6c3833688c97c01"}, + {file = "rustworkx-0.16.0-cp39-abi3-win_amd64.whl", hash = "sha256:905df608843c32fa45ac023687769fe13056edf7584474c801d5c50705d76e9b"}, + {file = "rustworkx-0.16.0.tar.gz", hash = "sha256:9f0dcb83f38d5ca2c3a683eb9b6951c8aec3262fbfe5141946a7ee5ba37e0bb6"}, +] + +[package.dependencies] +numpy = ">=1.16.0,<3" + +[package.extras] +all = ["matplotlib (>=3.0)", "pillow (>=5.4)"] +graphviz = ["pillow (>=5.4)"] +mpl = ["matplotlib (>=3.0)"] + [[package]] name = "scipy" version = "1.13.1" description = "Fundamental algorithms for scientific computing in Python" optional = false python-versions = ">=3.9" -groups = ["main"] files = [ {file = "scipy-1.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca"}, {file = "scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f"}, @@ -2366,7 +2761,6 @@ version = "75.8.0" description = "Easily download, build, install, upgrade, and uninstall Python packages" optional = false python-versions = ">=3.9" -groups = ["dev"] files = [ {file = "setuptools-75.8.0-py3-none-any.whl", hash = "sha256:e3982f444617239225d675215d51f6ba05f845d4eec313da4418fdbb56fb27e3"}, {file = "setuptools-75.8.0.tar.gz", hash = "sha256:c5afc8f407c626b8313a86e10311dd3f661c6cd9c09d4bf8c15c0e11f9f2b0e6"}, @@ -2387,7 +2781,6 @@ version = "1.17.0" description = "Python 2 and 3 compatibility utilities" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" -groups = ["main", "docs"] files = [ {file = "six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274"}, {file = "six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81"}, @@ -2399,7 +2792,6 @@ version = "2.2.0" description = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." optional = false python-versions = "*" -groups = ["docs"] files = [ {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, @@ -2411,7 +2803,6 @@ version = "2.6" description = "A modern CSS selector implementation for Beautiful Soup." optional = false python-versions = ">=3.8" -groups = ["docs"] files = [ {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, @@ -2423,7 +2814,6 @@ version = "5.3.0" description = "Python documentation generator" optional = false python-versions = ">=3.6" -groups = ["docs"] files = [ {file = "Sphinx-5.3.0.tar.gz", hash = "sha256:51026de0a9ff9fc13c05d74913ad66047e104f56a129ff73e174eb5c3ee794b5"}, {file = "sphinx-5.3.0-py3-none-any.whl", hash = "sha256:060ca5c9f7ba57a08a1219e547b269fadf125ae25b06b9fa7f66768efb652d6d"}, @@ -2459,7 +2849,6 @@ version = "1.0.0b2" description = "A modern skeleton for Sphinx themes." optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "sphinx_basic_ng-1.0.0b2-py3-none-any.whl", hash = "sha256:eb09aedbabfb650607e9b4b68c9d240b90b1e1be221d6ad71d61c52e29f7932b"}, {file = "sphinx_basic_ng-1.0.0b2.tar.gz", hash = "sha256:9ec55a47c90c8c002b5960c57492ec3021f5193cb26cebc2dc4ea226848651c9"}, @@ -2477,7 +2866,6 @@ version = "0.5.2" description = "Add a copy button to each of your code cells." optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "sphinx-copybutton-0.5.2.tar.gz", hash = "sha256:4cf17c82fb9646d1bc9ca92ac280813a3b605d8c421225fd9913154103ee1fbd"}, {file = "sphinx_copybutton-0.5.2-py3-none-any.whl", hash = "sha256:fb543fd386d917746c9a2c50360c7905b605726b9355cd26e9974857afeae06e"}, @@ -2496,7 +2884,6 @@ version = "2.0.0" description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" optional = false python-versions = ">=3.9" -groups = ["docs"] files = [ {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, @@ -2513,7 +2900,6 @@ version = "2.5.0" description = "Sphinx extension for BibTeX style citations." optional = false python-versions = ">=3.6" -groups = ["docs"] files = [ {file = "sphinxcontrib-bibtex-2.5.0.tar.gz", hash = "sha256:71b42e5db0e2e284f243875326bf9936aa9a763282277d75048826fef5b00eaa"}, {file = "sphinxcontrib_bibtex-2.5.0-py3-none-any.whl", hash = "sha256:748f726eaca6efff7731012103417ef130ecdcc09501b4d0c54283bf5f059f76"}, @@ -2532,7 +2918,6 @@ version = "2.0.0" description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" optional = false python-versions = ">=3.9" -groups = ["docs"] files = [ {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, @@ -2549,7 +2934,6 @@ version = "2.1.0" description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" optional = false python-versions = ">=3.9" -groups = ["docs"] files = [ {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, @@ -2566,7 +2950,6 @@ version = "1.0.1" description = "A sphinx extension which renders display math in HTML via JavaScript" optional = false python-versions = ">=3.5" -groups = ["docs"] files = [ {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, @@ -2581,7 +2964,6 @@ version = "0.9.10" description = "A Sphinx extension for rendering math in HTML pages" optional = false python-versions = ">=3.7" -groups = ["docs"] files = [ {file = "sphinxcontrib_katex-0.9.10-py3-none-any.whl", hash = "sha256:4e5f0b18761cd2cd058a1b2392f42a7edea4cc5beaa504a44aaee07d17ace9b7"}, {file = "sphinxcontrib_katex-0.9.10.tar.gz", hash = "sha256:309a92dae245dbc584ff7ea5fb6549727bae95e4e52008b74d259d2fd1ad0dec"}, @@ -2596,7 +2978,6 @@ version = "2.0.0" description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" optional = false python-versions = ">=3.9" -groups = ["docs"] files = [ {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, @@ -2613,7 +2994,6 @@ version = "2.0.0" description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" optional = false python-versions = ">=3.9" -groups = ["docs"] files = [ {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, @@ -2630,7 +3010,6 @@ version = "2.0.37" description = "Database Abstraction Library" optional = false python-versions = ">=3.7" -groups = ["main"] files = [ {file = "SQLAlchemy-2.0.37-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:da36c3b0e891808a7542c5c89f224520b9a16c7f5e4d6a1156955605e54aef0e"}, {file = "SQLAlchemy-2.0.37-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e7402ff96e2b073a98ef6d6142796426d705addd27b9d26c3b32dbaa06d7d069"}, @@ -2720,13 +3099,122 @@ postgresql-psycopgbinary = ["psycopg[binary] (>=3.0.7)"] pymysql = ["pymysql"] sqlcipher = ["sqlcipher3_binary"] +[[package]] +name = "sspilib" +version = "0.2.0" +description = "SSPI API bindings for Python" +optional = true +python-versions = ">=3.8" +files = [ + {file = "sspilib-0.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:34f566ba8b332c91594e21a71200de2d4ce55ca5a205541d4128ed23e3c98777"}, + {file = "sspilib-0.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b11e4f030de5c5de0f29bcf41a6e87c9fd90cb3b0f64e446a6e1d1aef4d08f5"}, + {file = "sspilib-0.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e82f87d77a9da62ce1eac22f752511a99495840177714c772a9d27b75220f78"}, + {file = "sspilib-0.2.0-cp310-cp310-win32.whl", hash = "sha256:e436fa09bcf353a364a74b3ef6910d936fa8cd1493f136e517a9a7e11b319c57"}, + {file = "sspilib-0.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:850a17c98d2b8579b183ce37a8df97d050bc5b31ab13f5a6d9e39c9692fe3754"}, + {file = "sspilib-0.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:a4d788a53b8db6d1caafba36887d5ac2087e6b6be6f01eb48f8afea6b646dbb5"}, + {file = "sspilib-0.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e0943204c8ba732966fdc5b69e33cf61d8dc6b24e6ed875f32055d9d7e2f76cd"}, + {file = "sspilib-0.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d1cdfc5ec2f151f26e21aa50ccc7f9848c969d6f78264ae4f38347609f6722df"}, + {file = "sspilib-0.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a6c33495a3de1552120c4a99219ebdd70e3849717867b8cae3a6a2f98fef405"}, + {file = "sspilib-0.2.0-cp311-cp311-win32.whl", hash = "sha256:400d5922c2c2261009921157c4b43d868e84640ad86e4dc84c95b07e5cc38ac6"}, + {file = "sspilib-0.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3e7d19c16ba9189ef8687b591503db06cfb9c5eb32ab1ca3bb9ebc1a8a5f35c"}, + {file = "sspilib-0.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:f65c52ead8ce95eb78a79306fe4269ee572ef3e4dcc108d250d5933da2455ecc"}, + {file = "sspilib-0.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:abac93a90335590b49ef1fc162b538576249c7f58aec0c7bcfb4b860513979b4"}, + {file = "sspilib-0.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1208720d8e431af674c5645cec365224d035f241444d5faa15dc74023ece1277"}, + {file = "sspilib-0.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e48dceb871ecf9cf83abdd0e6db5326e885e574f1897f6ae87d736ff558f4bfa"}, + {file = "sspilib-0.2.0-cp312-cp312-win32.whl", hash = "sha256:bdf9a4f424add02951e1f01f47441d2e69a9910471e99c2c88660bd8e184d7f8"}, + {file = "sspilib-0.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:40a97ca83e503a175d1dc9461836994e47e8b9bcf56cab81a2c22e27f1993079"}, + {file = "sspilib-0.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8ffc09819a37005c66a580ff44f544775f9745d5ed1ceeb37df4e5ff128adf36"}, + {file = "sspilib-0.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:40ff410b64198cf1d704718754fc5fe7b9609e0c49bf85c970f64c6fc2786db4"}, + {file = "sspilib-0.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:02d8e0b6033de8ccf509ba44fdcda7e196cdedc0f8cf19eb22c5e4117187c82f"}, + {file = "sspilib-0.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad7943fe14f8f6d72623ab6401991aa39a2b597bdb25e531741b37932402480f"}, + {file = "sspilib-0.2.0-cp313-cp313-win32.whl", hash = "sha256:b9044d6020aa88d512e7557694fe734a243801f9a6874e1c214451eebe493d92"}, + {file = "sspilib-0.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:c39a698491f43618efca8776a40fb7201d08c415c507f899f0df5ada15abefaa"}, + {file = "sspilib-0.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:863b7b214517b09367511c0ef931370f0386ed2c7c5613092bf9b106114c4a0e"}, + {file = "sspilib-0.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a0ede7afba32f2b681196c0b8520617d99dc5d0691d04884d59b476e31b41286"}, + {file = "sspilib-0.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:bd95df50efb6586054963950c8fa91ef994fb73c5c022c6f85b16f702c5314da"}, + {file = "sspilib-0.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9460258d3dc3f71cc4dcfd6ac078e2fe26f272faea907384b7dd52cb91d9ddcc"}, + {file = "sspilib-0.2.0-cp38-cp38-win32.whl", hash = "sha256:6fa9d97671348b97567020d82fe36c4211a2cacf02abbccbd8995afbf3a40bfc"}, + {file = "sspilib-0.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:32422ad7406adece12d7c385019b34e3e35ff88a7c8f3d7c062da421772e7bfa"}, + {file = "sspilib-0.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6944a0d7fe64f88c9bde3498591acdb25b178902287919b962c398ed145f71b9"}, + {file = "sspilib-0.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0216344629b0f39c2193adb74d7e1bed67f1bbd619e426040674b7629407eba9"}, + {file = "sspilib-0.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c5f84b9f614447fc451620c5c44001ed48fead3084c7c9f2b9cefe1f4c5c3d0"}, + {file = "sspilib-0.2.0-cp39-cp39-win32.whl", hash = "sha256:b290eb90bf8b8136b0a61b189629442052e1a664bd78db82928ec1e81b681fb5"}, + {file = "sspilib-0.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:404c16e698476e500a7fe67be5457fadd52d8bdc9aeb6c554782c8f366cc4fc9"}, + {file = "sspilib-0.2.0-cp39-cp39-win_arm64.whl", hash = "sha256:8697e5dd9229cd3367bca49fba74e02f867759d1d416a717e26c3088041b9814"}, + {file = "sspilib-0.2.0.tar.gz", hash = "sha256:4d6cd4290ca82f40705efeb5e9107f7abcd5e647cb201a3d04371305938615b8"}, +] + +[[package]] +name = "stevedore" +version = "5.4.0" +description = "Manage dynamic plugins for Python applications" +optional = true +python-versions = ">=3.9" +files = [ + {file = "stevedore-5.4.0-py3-none-any.whl", hash = "sha256:b0be3c4748b3ea7b854b265dcb4caa891015e442416422be16f8b31756107857"}, + {file = "stevedore-5.4.0.tar.gz", hash = "sha256:79e92235ecb828fe952b6b8b0c6c87863248631922c8e8e0fa5b17b232c4514d"}, +] + +[package.dependencies] +pbr = ">=2.0.0" + +[[package]] +name = "symengine" +version = "0.13.0" +description = "Python library providing wrappers to SymEngine" +optional = true +python-versions = "<4,>=3.8" +files = [ + {file = "symengine-0.13.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:259fd4111c7a70c72bdff5686de1949e8132baeb612eacdaf8837720c6fe449b"}, + {file = "symengine-0.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:44f2eb28a1e36db0bbd6679435412f79da9743bf9c1cb3eff25e0c343b7ddd48"}, + {file = "symengine-0.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d141712fa14d9138bd19e64b10392f850c68d88cd7db29f1bda33e32d1095559"}, + {file = "symengine-0.13.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:830226d933bfcdb93546e4062541627d9a3bc7a178a63fb16c002eb5c5221938"}, + {file = "symengine-0.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a08090163819a0bbfa97d64bd2d8dac2c5268147ed9c242799d7f7e8728a6f4e"}, + {file = "symengine-0.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:1e435dcd8ed25e4c7c21ab1c0376be910efc7f35da76d532367df27b359f0358"}, + {file = "symengine-0.13.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:da0eba7e106095cdce88eb275c8a9d7c4586ad88f229394c53e1184155c00745"}, + {file = "symengine-0.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b0c175f4f895a73a925508af03faf7efd6cad8593256bbdb5346bd996d3ec5c8"}, + {file = "symengine-0.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e58d1e2abd08381aa0cf24c88c0e8b7f592df92619b51e32d36835fbd2dd6ae8"}, + {file = "symengine-0.13.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1db745f2c7a3c5e83510cf4decb43201f43552dfb05ad8af9787c89708be9ede"}, + {file = "symengine-0.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2572c98b09ac284db6ecff63f6170461194dc94c4209afd34c092ec67873d85"}, + {file = "symengine-0.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:12727f02a2919f005aee48e68e0cbb70cf857b19385857b4d985d1c9b075f620"}, + {file = "symengine-0.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cf91d24f1bfd6d53228593c7804dd106b71b19674d5afc4fa322d516e1793bdd"}, + {file = "symengine-0.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c5615b7eb68890917abd390ebb10434a949165f6064741c1a8cc345fee14e855"}, + {file = "symengine-0.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb92bdf0890de264abaeacbfbdbd4dd7444b94057bd47958d913b662e549ad8a"}, + {file = "symengine-0.13.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7b3bce486fbc0b87970ed1b10ca9d5cafb1fd6b66382fe631261d83592851d7e"}, + {file = "symengine-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7e6bae9cfcdde2775d92fbb0abe3ef04e32f65ebc4c2d164ca33f4da202d4a7"}, + {file = "symengine-0.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:bced0a1dbdb94737c299384c85ddbad6944ce8dadc334f7bb8dbbd8f6c965807"}, + {file = "symengine-0.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d34df77971538e4c29f2d8e5ef7f459c2179465e6cdb7dfd48b79b87ecd8f4d"}, + {file = "symengine-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ab2661d9b18867e7c6edbfa7a74b8b0a2a694bd24aa08003dc3214f77cb9d6f2"}, + {file = "symengine-0.13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:53f27b9013878ee4419d8e853664d8ae4b68419e3f4b9b5b7f503d32bf904755"}, + {file = "symengine-0.13.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:27987f75ce08c64f453e2b9b74fec6ffc5ca418c4deca0b75580979d4a4e242a"}, + {file = "symengine-0.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9ea9410330ea15ed4137d7a0a3c43caccacb71490e18036ce5182d08c93baf8"}, + {file = "symengine-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:5031eb7a5c6675d5195bb57f93cc7d9ac5a7a9a826d4ad6f6b2927746ed7e6e6"}, + {file = "symengine-0.13.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ce0e5dfb19943bcf3e44a4485bcac4c5533ba3705c63083494eed0b3bf246076"}, + {file = "symengine-0.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c3b77dc54bf1181f6bd3b3338c4e6e5973a8b0fa20a189d15563ef5626e57b04"}, + {file = "symengine-0.13.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca7c3f6c168f6f5b06b421833c3d3baae56067a94b671bdffbe09b8e4fefd9be"}, + {file = "symengine-0.13.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:847523de682416811bacb3ad11507e663b3522fbb35cd27184757e9956d0eaf0"}, + {file = "symengine-0.13.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec2fc1b7d96426463f0c9011e9fb88459d906477c1baa8a996dde6fb2bfa99d4"}, + {file = "symengine-0.13.0-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:6e371bb2da3867085779c1c21bbb1c85f9634c76c8a76c08562ea113e3dfcd85"}, + {file = "symengine-0.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cf7c62478b19683d54e4d93faa5b89303beae25db0c503a105a70d266dc99fa9"}, + {file = "symengine-0.13.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdb21158cf3e2ba87e441f21ecc7724f108b8db17c0fd1880f9f531602bab1f3"}, + {file = "symengine-0.13.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1848d366b359ff69ef5dac148b30ca04c7339a7d3bcab28419d411e68c0cc011"}, + {file = "symengine-0.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:242f817e890a0a50d52ed6b2bfd1aad19636a58db700c7995bbe1ceeaebd9d08"}, + {file = "symengine-0.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:af79cf2b9645fb55216850185987b2e9347db71e42e87b6402e4bbd41710b316"}, + {file = "symengine-0.13.0-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:17ae9d1c781a60ac48d07fa30f39a2d237f9da95e9e81f6a24b1c16908e9cad2"}, + {file = "symengine-0.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5264157a95f6d09dd044cee6abcbc176e649c487638b7f32199f387f37ad82a5"}, + {file = "symengine-0.13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f01a6d0829b4881d5f831ae7848eb0d82b80d8b46b5689f1bf27069672370f75"}, + {file = "symengine-0.13.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:35ec68b11c2df2be1a236d0c028edb5b331909b16666d7a9fe99a4a5810afec7"}, + {file = "symengine-0.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4357fed87083e8719fcffd8bd0e7ddd16172e319343362512f681e472ac5668"}, + {file = "symengine-0.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a41be31816e5e51e9063bf26de07faf3751de7a133dbbec149632de702a28e18"}, + {file = "symengine-0.13.0.tar.gz", hash = "sha256:ab83a08897ebf12579702c2b71ba73d4732fb706cc4291d810aedf39c690c14c"}, +] + [[package]] name = "sympy" version = "1.13.3" description = "Computer algebra system (CAS) in Python" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "sympy-1.13.3-py3-none-any.whl", hash = "sha256:54612cf55a62755ee71824ce692986f23c88ffa77207b30c1368eda4a7060f73"}, {file = "sympy-1.13.3.tar.gz", hash = "sha256:b27fd2c6530e0ab39e275fc9b683895367e51d5da91baa8d3d64db2565fec4d9"}, @@ -2744,7 +3232,6 @@ version = "0.9.0" description = "Pretty-print tabular data" optional = false python-versions = ">=3.7" -groups = ["main"] files = [ {file = "tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f"}, {file = "tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c"}, @@ -2759,7 +3246,6 @@ version = "2.2.1" description = "A lil' TOML parser" optional = false python-versions = ">=3.8" -groups = ["analysis", "tests"] files = [ {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"}, {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"}, @@ -2794,7 +3280,6 @@ files = [ {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, ] -markers = {analysis = "python_version < \"3.11\"", tests = "python_full_version <= \"3.11.0a6\""} [[package]] name = "tomlkit" @@ -2802,7 +3287,6 @@ version = "0.13.2" description = "Style preserving TOML library" optional = false python-versions = ">=3.8" -groups = ["analysis"] files = [ {file = "tomlkit-0.13.2-py3-none-any.whl", hash = "sha256:7a974427f6e119197f670fbbbeae7bef749a6c14e793db934baefc1b5f03efde"}, {file = "tomlkit-0.13.2.tar.gz", hash = "sha256:fff5fe59a87295b278abd31bec92c15d9bc4a06885ab12bcea52c71119392e79"}, @@ -2814,7 +3298,6 @@ version = "1.0.0" description = "List processing tools and functional utilities" optional = false python-versions = ">=3.8" -groups = ["main"] files = [ {file = "toolz-1.0.0-py3-none-any.whl", hash = "sha256:292c8f1c4e7516bf9086f8850935c799a874039c8bcf959d47b600e4c44a6236"}, {file = "toolz-1.0.0.tar.gz", hash = "sha256:2c86e3d9a04798ac556793bced838816296a2f085017664e4995cb40a1047a02"}, @@ -2826,7 +3309,6 @@ version = "4.67.1" description = "Fast, Extensible Progress Meter" optional = false python-versions = ">=3.7" -groups = ["main"] files = [ {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"}, {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"}, @@ -2848,7 +3330,6 @@ version = "5.14.3" description = "Traitlets Python configuration system" optional = false python-versions = ">=3.8" -groups = ["dev"] files = [ {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, @@ -2858,18 +3339,68 @@ files = [ docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] +[[package]] +name = "tweedledum" +version = "1.1.1" +description = "A library for synthesizing and manipulating quantum circuits" +optional = true +python-versions = ">=3.6" +files = [ + {file = "tweedledum-1.1.1-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:b563c8324bbf5ed9ed57399a1eca34d8a82cb146b3011154e3df749753b75fe5"}, + {file = "tweedledum-1.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a5d734fed09a479afc0ec8fa91764ac9411821c27396e1b7d4a64393e689271d"}, + {file = "tweedledum-1.1.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a7dc0a9674e90808b26e24410bff7e5385d2b21ddf7068fc9c7d020ac46cefd8"}, + {file = "tweedledum-1.1.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:be97848edb19473eb653c58515605a636da1dc4a4650e291f3f05824c9dac005"}, + {file = "tweedledum-1.1.1-cp310-cp310-win32.whl", hash = "sha256:eae6a32207f3f8daf17806b90b2390e13f418b00a62384d029e13f215249df6b"}, + {file = "tweedledum-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:ab7a800d6266c98a30b0e8dc3e13cf49c8145012dfa199c9cc4d58d598a54218"}, + {file = "tweedledum-1.1.1-cp36-cp36m-macosx_10_15_x86_64.whl", hash = "sha256:6b8fa90b5303a6534ef332019ccdbb93ba969993cd7b78395ab31cb4c48a718e"}, + {file = "tweedledum-1.1.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:cad30654036a36afee0fb879a9cc3f26b33655d8a833425704b6dbb6d4caddfb"}, + {file = "tweedledum-1.1.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:4943f5d628f9adb95244b8bac79b7978f810bdaa5025e9930a625161a0d72dad"}, + {file = "tweedledum-1.1.1-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:09dbf20f792e97211270dfa2b3033ead0ce11fd65cc03781a542f36bccd7f1c1"}, + {file = "tweedledum-1.1.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bbe9a20d71576465051720eac72aa7f95fae39b4e4feea44f690e1ba856e99a"}, + {file = "tweedledum-1.1.1-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:57687300cca24c2f8fb340d6fa2233450a054647c736dc84958aac4d235b8542"}, + {file = "tweedledum-1.1.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:828808a47c2c67a10e1cf8692ede0bcf2732e5ace8b910bdcb7a2c0bb82440d8"}, + {file = "tweedledum-1.1.1-cp36-cp36m-win32.whl", hash = "sha256:451a10c32c58bf4726ce03f6cce9a93fb5332e679b7dbf48ef69c6fa93493243"}, + {file = "tweedledum-1.1.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f0500f8088cf142bfc4dd07a81f3a344603755602dc5f51acde588a36e538ed5"}, + {file = "tweedledum-1.1.1-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:86fac8e040d1645cfb3d623d949523eb1d367c2eee51fd5843536955104fd1ed"}, + {file = "tweedledum-1.1.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:fdee0b3b044db8e5d74001fbe25201e0db31be529d47785d2a70e22b7ff63f4a"}, + {file = "tweedledum-1.1.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0fd7ca92719fcb6a2437a16fd0281809fc57acb8a86ebf41fd06fe8faca1e14d"}, + {file = "tweedledum-1.1.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:003d92abb1c49e824b8c05857ae745959981174a082dd8c5a66ab1f55855ced3"}, + {file = "tweedledum-1.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b6b2fb3d20e21dbe97e9776d0c0b33c0a3dab8e4ac03a5434e9bfd11c9b3a998"}, + {file = "tweedledum-1.1.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:157392c983762e8a3f7ab523b0cfa4c78fbe83e28e0f1eee59e623636ddfe1ec"}, + {file = "tweedledum-1.1.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdb3c526f86fcd3d2c8794d1a3d5836ece2cf6f6c9d8e1ee8036b30d24ce29b1"}, + {file = "tweedledum-1.1.1-cp37-cp37m-win32.whl", hash = "sha256:57201c605b1d9045c135e72c521cbe537d8da6d534daa76e349c27fc1177681c"}, + {file = "tweedledum-1.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:099b1826f213bd4006dcd02526377b81134538fe1377e4cb70a07ba223ae958a"}, + {file = "tweedledum-1.1.1-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:80f99d7f9dee78f73796b9df2bc836c02f9bfc5a55eec65dda20899d96d09754"}, + {file = "tweedledum-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6f8cbd4cb6933d867e28ff7efc6030eceb1e4caef5c1bed5dfe7d097f63e6c28"}, + {file = "tweedledum-1.1.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:86da69130494c972d751ab61fdb209d40f079b77d5b3b833e83f26cee3c1a2fc"}, + {file = "tweedledum-1.1.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4385265171ee53d12d64429d65f0609f57a171d646a61366e3354eddc5c95778"}, + {file = "tweedledum-1.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:956f34ca2f6edaaafeaeef5f08db2abd54e4b5371a861ad68065d88b63d157b2"}, + {file = "tweedledum-1.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a3d4686fd1a8e8c86300e004acd73dd21e35a65f66625d784b2292280e46269"}, + {file = "tweedledum-1.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a08c535ef2ebcb326d2388bb4430d52f630ce43386f8b21a42e761e9e30394c4"}, + {file = "tweedledum-1.1.1-cp38-cp38-win32.whl", hash = "sha256:a032f0b6f6143dccee115b14a72780bc5813ccc552f3b1e9d519cb41e2d3ee50"}, + {file = "tweedledum-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:0da0905cd6c08b99d772b2b97f15ccfa80758c49143c3eff131b9480eba6f3fd"}, + {file = "tweedledum-1.1.1-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:1c73247309b6853b19906df594f7d0a8664bf3490ee2fb25621f617099525ffc"}, + {file = "tweedledum-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cd6cd64ccfc10db296f17e20713265bd91899774a34bcdf788c002c48514469e"}, + {file = "tweedledum-1.1.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b6aeba18fad932e7dd7715758c97f5aaa287b2726cb4ca9eea7d769fcd607f90"}, + {file = "tweedledum-1.1.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:3e243c2f70a4e4758cbdd45b31cdd72eb4816ace7029bdfe7e706cc37015f72e"}, + {file = "tweedledum-1.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:52f60f04dcc6e6162c3ce9eb058bb6853cfdd7c8dfefb1f1b428e94d0633a7cc"}, + {file = "tweedledum-1.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4710519655c55c0b74b6c8abc39f24493f3a8a6c7854af362f4c7953d16036b"}, + {file = "tweedledum-1.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c305fe9365f449cc3ad379ecf823f1ba6b734cdec56a618fbef11c83a54cede"}, + {file = "tweedledum-1.1.1-cp39-cp39-win32.whl", hash = "sha256:d4bf1f03d11cdc02c32a7771fa23c7de136e7cfa2920f508b2b3bc93d8b29c50"}, + {file = "tweedledum-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:98818ca8cae7a1d95ca05b219ffbcaf92a4fec200ff245e3ddf3ffc616977490"}, + {file = "tweedledum-1.1.1.tar.gz", hash = "sha256:58d6f7a988b10c31be3faa1faf3e58288ef7e8159584bfa6ded45742f390309f"}, +] + [[package]] name = "typing-extensions" version = "4.12.2" description = "Backported and Experimental Type Hints for Python 3.8+" optional = false python-versions = ">=3.8" -groups = ["main", "analysis"] files = [ {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, ] -markers = {analysis = "python_version < \"3.11\""} [[package]] name = "urllib3" @@ -2877,7 +3408,6 @@ version = "2.3.0" description = "HTTP library with thread-safe connection pooling, file post, and more." optional = false python-versions = ">=3.9" -groups = ["docs"] files = [ {file = "urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df"}, {file = "urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d"}, @@ -2895,20 +3425,111 @@ version = "0.2.13" description = "Measures the displayed width of unicode strings in a terminal" optional = false python-versions = "*" -groups = ["dev"] files = [ {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, ] +[[package]] +name = "websocket-client" +version = "1.8.0" +description = "WebSocket client for Python with low level API options" +optional = true +python-versions = ">=3.8" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[package.extras] +docs = ["Sphinx (>=6.0)", "myst-parser (>=2.0.0)", "sphinx-rtd-theme (>=1.1.0)"] +optional = ["python-socks", "wsaccel"] +test = ["websockets"] + +[[package]] +name = "websockets" +version = "14.2" +description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)" +optional = true +python-versions = ">=3.9" +files = [ + {file = "websockets-14.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e8179f95323b9ab1c11723e5d91a89403903f7b001828161b480a7810b334885"}, + {file = "websockets-14.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d8c3e2cdb38f31d8bd7d9d28908005f6fa9def3324edb9bf336d7e4266fd397"}, + {file = "websockets-14.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:714a9b682deb4339d39ffa674f7b674230227d981a37d5d174a4a83e3978a610"}, + {file = "websockets-14.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2e53c72052f2596fb792a7acd9704cbc549bf70fcde8a99e899311455974ca3"}, + {file = "websockets-14.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3fbd68850c837e57373d95c8fe352203a512b6e49eaae4c2f4088ef8cf21980"}, + {file = "websockets-14.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b27ece32f63150c268593d5fdb82819584831a83a3f5809b7521df0685cd5d8"}, + {file = "websockets-14.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4daa0faea5424d8713142b33825fff03c736f781690d90652d2c8b053345b0e7"}, + {file = "websockets-14.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:bc63cee8596a6ec84d9753fd0fcfa0452ee12f317afe4beae6b157f0070c6c7f"}, + {file = "websockets-14.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7a570862c325af2111343cc9b0257b7119b904823c675b22d4ac547163088d0d"}, + {file = "websockets-14.2-cp310-cp310-win32.whl", hash = "sha256:75862126b3d2d505e895893e3deac0a9339ce750bd27b4ba515f008b5acf832d"}, + {file = "websockets-14.2-cp310-cp310-win_amd64.whl", hash = "sha256:cc45afb9c9b2dc0852d5c8b5321759cf825f82a31bfaf506b65bf4668c96f8b2"}, + {file = "websockets-14.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3bdc8c692c866ce5fefcaf07d2b55c91d6922ac397e031ef9b774e5b9ea42166"}, + {file = "websockets-14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c93215fac5dadc63e51bcc6dceca72e72267c11def401d6668622b47675b097f"}, + {file = "websockets-14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1c9b6535c0e2cf8a6bf938064fb754aaceb1e6a4a51a80d884cd5db569886910"}, + {file = "websockets-14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a52a6d7cf6938e04e9dceb949d35fbdf58ac14deea26e685ab6368e73744e4c"}, + {file = "websockets-14.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9f05702e93203a6ff5226e21d9b40c037761b2cfb637187c9802c10f58e40473"}, + {file = "websockets-14.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22441c81a6748a53bfcb98951d58d1af0661ab47a536af08920d129b4d1c3473"}, + {file = "websockets-14.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd9b868d78b194790e6236d9cbc46d68aba4b75b22497eb4ab64fa640c3af56"}, + {file = "websockets-14.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a5a20d5843886d34ff8c57424cc65a1deda4375729cbca4cb6b3353f3ce4142"}, + {file = "websockets-14.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34277a29f5303d54ec6468fb525d99c99938607bc96b8d72d675dee2b9f5bf1d"}, + {file = "websockets-14.2-cp311-cp311-win32.whl", hash = "sha256:02687db35dbc7d25fd541a602b5f8e451a238ffa033030b172ff86a93cb5dc2a"}, + {file = "websockets-14.2-cp311-cp311-win_amd64.whl", hash = "sha256:862e9967b46c07d4dcd2532e9e8e3c2825e004ffbf91a5ef9dde519ee2effb0b"}, + {file = "websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c"}, + {file = "websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967"}, + {file = "websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990"}, + {file = "websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda"}, + {file = "websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95"}, + {file = "websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3"}, + {file = "websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9"}, + {file = "websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267"}, + {file = "websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe"}, + {file = "websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205"}, + {file = "websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce"}, + {file = "websockets-14.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f1372e511c7409a542291bce92d6c83320e02c9cf392223272287ce55bc224e"}, + {file = "websockets-14.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4da98b72009836179bb596a92297b1a61bb5a830c0e483a7d0766d45070a08ad"}, + {file = "websockets-14.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8a86a269759026d2bde227652b87be79f8a734e582debf64c9d302faa1e9f03"}, + {file = "websockets-14.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86cf1aaeca909bf6815ea714d5c5736c8d6dd3a13770e885aafe062ecbd04f1f"}, + {file = "websockets-14.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9b0f6c3ba3b1240f602ebb3971d45b02cc12bd1845466dd783496b3b05783a5"}, + {file = "websockets-14.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:669c3e101c246aa85bc8534e495952e2ca208bd87994650b90a23d745902db9a"}, + {file = "websockets-14.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eabdb28b972f3729348e632ab08f2a7b616c7e53d5414c12108c29972e655b20"}, + {file = "websockets-14.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2066dc4cbcc19f32c12a5a0e8cc1b7ac734e5b64ac0a325ff8353451c4b15ef2"}, + {file = "websockets-14.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ab95d357cd471df61873dadf66dd05dd4709cae001dd6342edafc8dc6382f307"}, + {file = "websockets-14.2-cp313-cp313-win32.whl", hash = "sha256:a9e72fb63e5f3feacdcf5b4ff53199ec8c18d66e325c34ee4c551ca748623bbc"}, + {file = "websockets-14.2-cp313-cp313-win_amd64.whl", hash = "sha256:b439ea828c4ba99bb3176dc8d9b933392a2413c0f6b149fdcba48393f573377f"}, + {file = "websockets-14.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7cd5706caec1686c5d233bc76243ff64b1c0dc445339bd538f30547e787c11fe"}, + {file = "websockets-14.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ec607328ce95a2f12b595f7ae4c5d71bf502212bddcea528290b35c286932b12"}, + {file = "websockets-14.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da85651270c6bfb630136423037dd4975199e5d4114cae6d3066641adcc9d1c7"}, + {file = "websockets-14.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3ecadc7ce90accf39903815697917643f5b7cfb73c96702318a096c00aa71f5"}, + {file = "websockets-14.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1979bee04af6a78608024bad6dfcc0cc930ce819f9e10342a29a05b5320355d0"}, + {file = "websockets-14.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dddacad58e2614a24938a50b85969d56f88e620e3f897b7d80ac0d8a5800258"}, + {file = "websockets-14.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:89a71173caaf75fa71a09a5f614f450ba3ec84ad9fca47cb2422a860676716f0"}, + {file = "websockets-14.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:6af6a4b26eea4fc06c6818a6b962a952441e0e39548b44773502761ded8cc1d4"}, + {file = "websockets-14.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:80c8efa38957f20bba0117b48737993643204645e9ec45512579132508477cfc"}, + {file = "websockets-14.2-cp39-cp39-win32.whl", hash = "sha256:2e20c5f517e2163d76e2729104abc42639c41cf91f7b1839295be43302713661"}, + {file = "websockets-14.2-cp39-cp39-win_amd64.whl", hash = "sha256:b4c8cef610e8d7c70dea92e62b6814a8cd24fbd01d7103cc89308d2bfe1659ef"}, + {file = "websockets-14.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d7d9cafbccba46e768be8a8ad4635fa3eae1ffac4c6e7cb4eb276ba41297ed29"}, + {file = "websockets-14.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c76193c1c044bd1e9b3316dcc34b174bbf9664598791e6fb606d8d29000e070c"}, + {file = "websockets-14.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd475a974d5352390baf865309fe37dec6831aafc3014ffac1eea99e84e83fc2"}, + {file = "websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c6c0097a41968b2e2b54ed3424739aab0b762ca92af2379f152c1aef0187e1c"}, + {file = "websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d7ff794c8b36bc402f2e07c0b2ceb4a2424147ed4785ff03e2a7af03711d60a"}, + {file = "websockets-14.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dec254fcabc7bd488dab64846f588fc5b6fe0d78f641180030f8ea27b76d72c3"}, + {file = "websockets-14.2-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:bbe03eb853e17fd5b15448328b4ec7fb2407d45fb0245036d06a3af251f8e48f"}, + {file = "websockets-14.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a3c4aa3428b904d5404a0ed85f3644d37e2cb25996b7f096d77caeb0e96a3b42"}, + {file = "websockets-14.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:577a4cebf1ceaf0b65ffc42c54856214165fb8ceeba3935852fc33f6b0c55e7f"}, + {file = "websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad1c1d02357b7665e700eca43a31d52814ad9ad9b89b58118bdabc365454b574"}, + {file = "websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f390024a47d904613577df83ba700bd189eedc09c57af0a904e5c39624621270"}, + {file = "websockets-14.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3c1426c021c38cf92b453cdf371228d3430acd775edee6bac5a4d577efc72365"}, + {file = "websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b"}, + {file = "websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5"}, +] + [[package]] name = "zipp" version = "3.21.0" description = "Backport of pathlib-compatible object wrapper for zip files" optional = false python-versions = ">=3.9" -groups = ["main", "docs"] -markers = "python_version < \"3.10\"" files = [ {file = "zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931"}, {file = "zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4"}, @@ -2926,6 +3547,6 @@ type = ["pytest-mypy"] cuda = ["cupy-cuda11x", "cuquantum-python-cu11", "mpi4py"] [metadata] -lock-version = "2.1" +lock-version = "2.0" python-versions = "^3.9,<3.13" -content-hash = "9bb131aa93c985589719d05b4a257d3741893cf44b239f5e1d192401635a59dc" +content-hash = "ab02da47daabe387a631d237597dff0ad3dc0041011b300e0bf381385b8e591d" diff --git a/pyproject.toml b/pyproject.toml index 928f5c9..fbea561 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -25,8 +25,10 @@ qibo = "^0.2.8" quimb = { version = "^1.6.0", extras = ["tensor"] } cupy-cuda11x = { version = "^11.6.0", optional = true } cuquantum-python-cu11 = { version = "^23.3.0", optional = true } +qmatchatea = { version = "^1.1.4", optional = true } mpi4py = { version = "^3.1.5", optional = true } + [tool.poetry.extras] cuda = ["cupy-cuda11x", "cuquantum-python-cu11", "mpi4py"] diff --git a/src/qibotn/backends/__init__.py b/src/qibotn/backends/__init__.py index 48a1570..8fdd367 100644 --- a/src/qibotn/backends/__init__.py +++ b/src/qibotn/backends/__init__.py @@ -2,12 +2,11 @@ from typing import Union from qibo.config import raise_error +from qibotn.backends.abstract import QibotnBackend from qibotn.backends.cutensornet import CuTensorNet # pylint: disable=E0401 from qibotn.backends.quimb import QuimbBackend # pylint: disable=E0401 -QibotnBackend = Union[CuTensorNet, QuimbBackend] - -PLATFORMS = ("cutensornet", "qutensornet") +PLATFORMS = ("cutensornet", "qutensornet", "qmatchatea") class MetaBackend: @@ -28,10 +27,14 @@ class MetaBackend: return CuTensorNet(runcard) elif platform == "qutensornet": # pragma: no cover return QuimbBackend(runcard) + elif platform == "qmatchatea": # pragma: no cover + from qibotn.backends.qmatchatea import QMatchaTeaBackend + + return QMatchaTeaBackend() else: raise_error( NotImplementedError, - f"Unsupported platform {platform}, please pick one in (`cutensornet`, `qutensornet)", + f"Unsupported platform {platform}, please pick one in {PLATFORMS}", ) def list_available(self) -> dict: diff --git a/src/qibotn/backends/abstract.py b/src/qibotn/backends/abstract.py new file mode 100644 index 0000000..24e87f6 --- /dev/null +++ b/src/qibotn/backends/abstract.py @@ -0,0 +1,35 @@ +from abc import ABC + +from qibo.config import raise_error + + +class QibotnBackend(ABC): + + def __init__(self): + super().__init__() + + def apply_gate(self, gate, state, nqubits): # pragma: no cover + raise_error(NotImplementedError, "QiboTN cannot apply gates directly.") + + def apply_gate_density_matrix(self, gate, state, nqubits): # pragma: no cover + raise_error(NotImplementedError, "QiboTN cannot apply gates directly.") + + def assign_measurements(self, measurement_map, circuit_result): + raise_error(NotImplementedError, "Not implemented in QiboTN.") + + def set_precision(self, precision): + if precision != self.precision: + super().set_precision(precision) + self._setup_backend_specifics() + + def set_device(self, device): + self.device = device + self._setup_backend_specifics() + + def configure_tn_simulation(self, **config): + """Configure the TN simulation that will be performed.""" + pass + + def _setup_backend_specifics(self): + """Configure the backend specific according to the used package.""" + pass diff --git a/src/qibotn/backends/cutensornet.py b/src/qibotn/backends/cutensornet.py index 1d38520..553fc51 100644 --- a/src/qibotn/backends/cutensornet.py +++ b/src/qibotn/backends/cutensornet.py @@ -1,12 +1,14 @@ import numpy as np -from qibo.backends.numpy import NumpyBackend +from qibo.backends import NumpyBackend from qibo.config import raise_error from qibo.result import QuantumState +from qibotn.backends.abstract import QibotnBackend + CUDA_TYPES = {} -class CuTensorNet(NumpyBackend): # pragma: no cover +class CuTensorNet(QibotnBackend, NumpyBackend): # pragma: no cover # CI does not test for GPU """Creates CuQuantum backend for QiboTN.""" @@ -77,23 +79,10 @@ class CuTensorNet(NumpyBackend): # pragma: no cover ), } - def apply_gate(self, gate, state, nqubits): # pragma: no cover - raise_error(NotImplementedError, "QiboTN cannot apply gates directly.") - - def apply_gate_density_matrix(self, gate, state, nqubits): # pragma: no cover - raise_error(NotImplementedError, "QiboTN cannot apply gates directly.") - - def assign_measurements(self, measurement_map, circuit_result): - raise_error(NotImplementedError, "Not implemented in QiboTN.") - def __del__(self): if hasattr(self, "cutn"): self.cutn.destroy(self.handle) - def set_precision(self, precision): - if precision != self.precision: - super().set_precision(precision) - def cuda_type(self, dtype="complex64"): """Get CUDA Type. diff --git a/src/qibotn/backends/qmatchatea.py b/src/qibotn/backends/qmatchatea.py new file mode 100644 index 0000000..27239ec --- /dev/null +++ b/src/qibotn/backends/qmatchatea.py @@ -0,0 +1,315 @@ +"""Implementation of Quantum Matcha Tea backend.""" + +import re +from dataclasses import dataclass + +import numpy as np +import qiskit +import qmatchatea +import qtealeaves +from qibo.backends import NumpyBackend +from qibo.config import raise_error + +from qibotn.backends.abstract import QibotnBackend +from qibotn.result import TensorNetworkResult + + +@dataclass +class QMatchaTeaBackend(QibotnBackend, NumpyBackend): + + def __init__(self): + super().__init__() + + self.name = "qibotn" + self.platform = "qmatchatea" + + # Set default configurations + self.configure_tn_simulation() + self._setup_backend_specifics() + + def configure_tn_simulation( + self, + ansatz: str = "MPS", + max_bond_dimension: int = 10, + cut_ratio: float = 1e-9, + trunc_tracking_mode: str = "C", + svd_control: str = "A", + ini_bond_dimension: int = 1, + ): + """Configure TN simulation given Quantum Matcha Tea interface. + + Args: + ansatz (str): tensor network ansatz. It can be tree tensor network "TTN" + or Matrix Product States "MPS" (default). + max_bond_dimension : int, optional Maximum bond dimension of the problem. Default to 10. + cut_ratio : float, optional + Cut ratio for singular values. If :math:`\\lambda_n/\\lambda_1 <` cut_ratio then + :math:`\\lambda_n` is neglected. Default to 1e-9. + trunc_tracking_mode : str, optional + Modus for storing truncation, 'M' for maximum, 'C' for + cumulated (default). + svd_ctrl : character, optional + Control for the SVD algorithm. Available: + - "A" : automatic. Some heuristic is run to choose the best mode for the algorithm. + - "V" : gesvd. Safe but slow method. + - "D" : gesdd. Fast iterative method. It might fail. Resort to gesvd if it fails + - "E" : eigenvalue decomposition method. Faster on GPU. Available only when + contracting the singular value to left or right + - "X" : sparse eigenvalue decomposition method. Used when you reach the maximum + bond dimension. + - "R" : random svd method. Used when you reach the maximum bond dimension. + Default to 'A'. + ini_bond_dimension: int, optional + Initial bond dimension of the simulation. It is used if the initial state is random. + Default to 1. + """ + + self.convergence_params = qmatchatea.QCConvergenceParameters( + max_bond_dimension=max_bond_dimension, + cut_ratio=cut_ratio, + trunc_tracking_mode=trunc_tracking_mode, + svd_ctrl=svd_control, + ini_bond_dimension=ini_bond_dimension, + ) + self.ansatz = ansatz + + def _setup_backend_specifics(self): + """Configure qmatchatea QCBackend object.""" + + qmatchatea_device = ( + "cpu" if "CPU" in self.device else "gpu" if "GPU" in self.device else None + ) + qmatchatea_precision = ( + "C" + if self.precision == "single" + else "Z" if self.precision == "double" else "A" + ) + + # TODO: once MPI is available for Python, integrate it here + self.qmatchatea_backend = qmatchatea.QCBackend( + backend="PY", # The only alternative is Fortran, but we use Python here + precision=qmatchatea_precision, + device=qmatchatea_device, + ansatz=self.ansatz, + ) + + def execute_circuit( + self, + circuit, + initial_state=None, + nshots=None, + prob_type=None, + return_array=False, + **prob_kwargs, + ): + """Execute a Qibo quantum circuit using tensor network simulation. + + This method returns a ``TensorNetworkResult`` object, which provides: + - Reconstruction of the system state (if the system size is < 20). + - Frequencies (if the number of shots is specified). + - Probabilities computed using various methods. + + The following probability computation methods are available, as implemented + in Quantum Matcha Tea: + - **"E" (Even):** Probabilities are computed by evenly descending the probability tree, + pruning branches (states) with probabilities below a threshold. + - **"G" (Greedy):** Probabilities are computed by following the most probable states + in descending order until reaching a given coverage (sum of probabilities). + - **"U" (Unbiased):** An optimal probability measure that is unbiased and designed + for best performance. See https://arxiv.org/abs/2401.10330 for details. + + Args: + circuit: A Qibo circuit to execute. + initial_state: The initial state of the system (default is the vacuum state + for tensor network simulations). + nshots: The number of shots for shot-noise simulation (optional). + prob_type: The probability computation method. Must be one of: + - "E" (Even) + - "G" (Greedy) + - "U" (Unbiased) [default]. + prob_kwargs: Additional parameters required for probability computation: + - For "U", requires ``num_samples``. + - For "E" and "G", requires ``prob_threshold``. + + Returns: + TensorNetworkResult: An object with methods to reconstruct the state, + compute probabilities, and generate frequencies. + """ + + # TODO: verify if the QCIO mechanism of matcha is supported by Fortran only + # as written in the docstrings or by Python too (see ``io_info`` argument of + # ``qmatchatea.interface.run_simulation`` function) + if initial_state is not None: + raise_error( + NotImplementedError, + f"Backend {self} currently does not support initial state.", + ) + + if prob_type == None: + prob_type = "U" + prob_kwargs = {"num_samples": 500} + + # TODO: check + circuit = self._qibocirc_to_qiskitcirc(circuit) + run_qk_params = qmatchatea.preprocessing.qk_transpilation_params(False) + + # Initialize the TNObservable object + observables = qtealeaves.observables.TNObservables() + + # Shots + if nshots is not None: + observables += qtealeaves.observables.TNObsProjective(num_shots=nshots) + + # Probabilities + observables += qtealeaves.observables.TNObsProbabilities( + prob_type=prob_type, + **prob_kwargs, + ) + + # State + observables += qtealeaves.observables.TNState2File(name="temp", formatting="U") + + results = qmatchatea.run_simulation( + circ=circuit, + convergence_parameters=self.convergence_params, + transpilation_parameters=run_qk_params, + backend=self.qmatchatea_backend, + observables=observables, + ) + + if circuit.num_qubits < 20 and return_array: + statevector = results.statevector + else: + statevector = None + + return TensorNetworkResult( + nqubits=circuit.num_qubits, + backend=self, + measures=results.measures, + measured_probabilities=results.measure_probabilities, + prob_type=prob_type, + statevector=statevector, + ) + + def expectation(self, circuit, observable): + """Compute the expectation value of a Qibo-friendly ``observable`` on + the Tensor Network constructed from a Qibo ``circuit``. + + This method takes a Qibo-style symbolic Hamiltonian (e.g., `X(0)*Z(1) + 2.0*Y(2)*Z(0)`) + as the observable, converts it into a Quantum Matcha Tea (qmatchatea) observable + (using `TNObsTensorProduct` and `TNObsWeightedSum`), and computes its expectation + value using the provided circuit. + + Args: + circuit: A Qibo quantum circuit object on which the expectation value + is computed. The circuit should be compatible with the qmatchatea + Tensor Network backend. + observable: The observable whose expectation value we want to compute. + This must be provided in the symbolic Hamiltonian form supported by Qibo + (e.g., `X(0)*Y(1)` or `Z(0)*Z(1) + 1.5*Y(2)`). + + Returns: + qibotn.TensorNetworkResult class, providing methods to retrieve + probabilities, frequencies and state always according to the chosen + simulation setup. + """ + + # From Qibo to Qiskit + circuit = self._qibocirc_to_qiskitcirc(circuit) + run_qk_params = qmatchatea.preprocessing.qk_transpilation_params(False) + + operators = qmatchatea.QCOperators() + observables = qtealeaves.observables.TNObservables() + # Add custom observable + observables += self._qiboobs_to_qmatchaobs(hamiltonian=observable) + + results = qmatchatea.run_simulation( + circ=circuit, + convergence_parameters=self.convergence_params, + transpilation_parameters=run_qk_params, + backend=self.qmatchatea_backend, + observables=observables, + operators=operators, + ) + + return np.real(results.observables["custom_hamiltonian"]) + + def _qibocirc_to_qiskitcirc(self, qibo_circuit) -> qiskit.QuantumCircuit: + """Convert a Qibo Circuit into a Qiskit Circuit.""" + # Convert the circuit to QASM 2.0 to qiskit + qasm_circuit = qibo_circuit.to_qasm() + qiskit_circuit = qiskit.QuantumCircuit.from_qasm_str(qasm_circuit) + + # Transpile the circuit to adapt it to the linear structure of the MPS, + # with the constraint of having only the gates basis_gates + qiskit_circuit = qmatchatea.preprocessing.preprocess( + qiskit_circuit, + qk_params=qmatchatea.preprocessing.qk_transpilation_params(), + ) + return qiskit_circuit + + def _qiboobs_to_qmatchaobs(self, hamiltonian, observable_name="custom_hamiltonian"): + """ + Convert a Qibo SymbolicHamiltonian into a qmatchatea TNObsWeightedSum observable. + + The SymbolicHamiltonian is expected to have a collection of terms, where each term has: + - `coefficient`: A numeric value. + - `factors`: A list of factors, each a string such as "X2" or "Z0", representing an operator + and the qubit it acts on. + + Args: + hamiltonian (qibo.SymbolicHamiltonian): The symbolic Hamiltonian containing the terms. + observable_name (str): The name for the resulting TNObsWeightedSum observable. + + Returns: + TNObsWeightedSum: An observable suitable for use with qmatchatea. + """ + coeff_list = [] + tensor_product_obs = None + + # Regex to split an operator factor (e.g., "X2" -> operator "X", qubit 2) + factor_pattern = re.compile(r"([^\d]+)(\d+)") + + # Iterate over each term in the symbolic Hamiltonian + for i, term in enumerate(hamiltonian.terms): + # Store the term's coefficient + coeff_list.append(term.coefficient) + + operator_names = [] + acting_on_qubits = [] + + # Process each factor in the term + for factor in term.factors: + # Assume each factor is a string like "Y2" or "Z0" + match = factor_pattern.match(str(factor)) + if match: + operator_name = match.group(1) + qubit_index = int(match.group(2)) + operator_names.append(operator_name) + acting_on_qubits.append([qubit_index]) + else: + raise ValueError( + f"Factor '{str(factor)}' does not match the expected format." + ) + + # Create a TNObsTensorProduct for this term. + term_tensor_prod = qtealeaves.observables.TNObsTensorProduct( + name=f"term_{i}", + operators=operator_names, + sites=acting_on_qubits, + ) + + # Combine tensor products from each term + if tensor_product_obs is None: + tensor_product_obs = term_tensor_prod + else: + tensor_product_obs += term_tensor_prod + + # Combine all terms into a weighted sum observable + obs_sum = qtealeaves.observables.TNObsWeightedSum( + name=observable_name, + tp_operators=tensor_product_obs, + coeffs=coeff_list, + use_itpo=False, + ) + return obs_sum diff --git a/src/qibotn/backends/quimb.py b/src/qibotn/backends/quimb.py index df6488a..13a8cf1 100644 --- a/src/qibotn/backends/quimb.py +++ b/src/qibotn/backends/quimb.py @@ -1,9 +1,11 @@ -from qibo.backends.numpy import NumpyBackend +from qibo.backends import NumpyBackend from qibo.config import raise_error from qibo.result import QuantumState +from qibotn.backends.abstract import QibotnBackend -class QuimbBackend(NumpyBackend): + +class QuimbBackend(QibotnBackend, NumpyBackend): def __init__(self, runcard): super().__init__() @@ -36,19 +38,6 @@ class QuimbBackend(NumpyBackend): self.platform = "QuimbBackend" self.versions["quimb"] = self.quimb.__version__ - def apply_gate(self, gate, state, nqubits): # pragma: no cover - raise_error(NotImplementedError, "QiboTN cannot apply gates directly.") - - def apply_gate_density_matrix(self, gate, state, nqubits): # pragma: no cover - raise_error(NotImplementedError, "QiboTN cannot apply gates directly.") - - def assign_measurements(self, measurement_map, circuit_result): - raise_error(NotImplementedError, "Not implemented in QiboTN.") - - def set_precision(self, precision): - if precision != self.precision: - super().set_precision(precision) - def execute_circuit( self, circuit, initial_state=None, nshots=None, return_array=False ): # pragma: no cover diff --git a/src/qibotn/result.py b/src/qibotn/result.py new file mode 100644 index 0000000..a37cc63 --- /dev/null +++ b/src/qibotn/result.py @@ -0,0 +1,66 @@ +from copy import deepcopy +from dataclasses import dataclass +from typing import Union + +from numpy import ndarray +from qibo.config import raise_error + +from qibotn.backends.abstract import QibotnBackend + + +@dataclass +class TensorNetworkResult: + """ + Object to store and process the output of a Tensor Network simulation of a quantum circuit. + + Args: + nqubits (int): number of qubits involved in the simulation; + backend (QibotnBackend): specific backend on which the simulation has been performed; + measures (dict): measures (if performed) during the tensor network simulation; + measured_probabilities (Union[dict, ndarray]): probabilities of the final state + according to the simulation; + prob_type (str): string identifying the method used to compute the probabilities. + Especially useful in case the `QmatchateaBackend` is selected. + statevector (ndarray): if computed, the reconstructed statevector. + """ + + nqubits: int + backend: QibotnBackend + measures: dict + measured_probabilities: Union[dict, ndarray] + prob_type: str + statevector: ndarray + + def __post_init__(self): + # TODO: define the general convention when using backends different from qmatchatea + if self.measured_probabilities is None: + self.measured_probabilities = {"default": self.measured_probabilities} + + def probabilities(self): + """Return calculated probabilities according to the given method.""" + if self.prob_type == "U": + measured_probabilities = deepcopy(self.measured_probabilities) + for bitstring, prob in self.measured_probabilities[self.prob_type].items(): + measured_probabilities[self.prob_type][bitstring] = prob[1] - prob[0] + probabilities = measured_probabilities[self.prob_type] + else: + probabilities = self.measured_probabilities[self.prob_type] + return self.backend.cast(list(probabilities.values()), dtype="double") + + def frequencies(self): + """Return frequencies if a certain number of shots has been set.""" + if self.measures is None: + raise_error( + ValueError, + f"To access frequencies, circuit has to be executed with a given number of shots != None", + ) + return self.measures + + def state(self): + """Return the statevector if the number of qubits is less than 20.""" + if self.nqubits < 20: + return self.statevector + raise_error( + NotImplementedError, + f"Tensor network simulation cannot be used to reconstruct statevector for >= 20 .", + ) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..0a18bfa --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,66 @@ +"""conftest.py. + +Pytest fixtures. +""" + +import sys + +import pytest + +# backends to be tested +# TODO: add cutensornet and quimb here as well +BACKENDS = ["qmatchatea"] + + +def get_backend(backend_name): + + from qibotn.backends.qmatchatea import QMatchaTeaBackend + + NAME2BACKEND = { + "qmatchatea": QMatchaTeaBackend, + } + + return NAME2BACKEND[backend_name]() + + +AVAILABLE_BACKENDS = [] +for backend_name in BACKENDS: + try: + _backend = get_backend(backend_name) + AVAILABLE_BACKENDS.append(backend_name) + except (ModuleNotFoundError, ImportError): + pass + + +def pytest_runtest_setup(item): + ALL = {"darwin", "linux"} + supported_platforms = ALL.intersection(mark.name for mark in item.iter_markers()) + plat = sys.platform + if supported_platforms and plat not in supported_platforms: # pragma: no cover + # case not covered by workflows + pytest.skip(f"Cannot run test on platform {plat}.") + + +@pytest.fixture +def backend(backend_name): + yield get_backend(backend_name) + + +def pytest_runtest_setup(item): + ALL = {"darwin", "linux"} + supported_platforms = ALL.intersection(mark.name for mark in item.iter_markers()) + plat = sys.platform + if supported_platforms and plat not in supported_platforms: # pragma: no cover + # case not covered by workflows + pytest.skip(f"Cannot run test on platform {plat}.") + + +def pytest_configure(config): + config.addinivalue_line("markers", "linux: mark test to run only on linux") + + +def pytest_generate_tests(metafunc): + module_name = metafunc.module.__name__ + + if "backend_name" in metafunc.fixturenames: + metafunc.parametrize("backend_name", AVAILABLE_BACKENDS) diff --git a/tests/test_circuit_execution.py b/tests/test_circuit_execution.py new file mode 100644 index 0000000..c5dfc86 --- /dev/null +++ b/tests/test_circuit_execution.py @@ -0,0 +1,91 @@ +import math + +import pytest +from qibo import Circuit, gates, hamiltonians +from qibo.symbols import X, Z + +from qibotn.backends.qmatchatea import QMatchaTeaBackend + + +def build_observable(nqubits): + """Helper function to construct a target observable.""" + hamiltonian_form = 0 + for i in range(nqubits): + hamiltonian_form += 0.5 * X(i % nqubits) * Z((i + 1) % nqubits) + + hamiltonian = hamiltonians.SymbolicHamiltonian(form=hamiltonian_form) + return hamiltonian, hamiltonian_form + + +def build_GHZ(nqubits): + """Helper function to construct a layered quantum circuit.""" + circ = Circuit(nqubits) + circ.add(gates.H(0)) + [circ.add(gates.CNOT(q, q + 1)) for q in range(nqubits - 1)] + return circ + + +def construct_targets(nqubits): + """Construct strings of 1s and 0s of size `nqubits`.""" + ones = "1" * nqubits + zeros = "0" * nqubits + return ones, zeros + + +@pytest.mark.parametrize("nqubits", [2, 10, 40]) +def test_probabilities(backend, nqubits): + + circ = build_GHZ(nqubits=nqubits) + + if isinstance(backend, QMatchaTeaBackend): + # unbiased prob + out_u = backend.execute_circuit( + circuit=circ, + prob_type="U", + num_samples=1000, + ).probabilities() + + math.isclose(out_u[0], 0.5, abs_tol=1e-7) + math.isclose(out_u[1], 0.5, abs_tol=1e-7) + + out_g = backend.execute_circuit( + circuit=circ, + prob_type="G", + prob_threshold=1.0, + ).probabilities() + + math.isclose(out_g[0], 0.5, abs_tol=1e-7) + math.isclose(out_g[1], 0.5, abs_tol=1e-7) + + out_e = backend.execute_circuit( + circuit=circ, + prob_type="E", + prob_threshold=0.2, + ).probabilities() + + math.isclose(out_e[0], 0.5, abs_tol=1e-7) + math.isclose(out_e[1], 0.5, abs_tol=1e-7) + + +@pytest.mark.parametrize("nqubits", [2, 10, 40]) +@pytest.mark.parametrize("nshots", [100, 1000]) +def test_shots(backend, nqubits, nshots): + circ = build_GHZ(nqubits=nqubits) + ones, zeros = construct_targets(nqubits) + + # For p = 0.5, sigma = sqrt(nshots * 0.5 * 0.5) = sqrt(nshots)/2. + sigma_threshold = 3 * (math.sqrt(nshots) / 2) + + outcome = backend.execute_circuit(circ, nshots=nshots) + frequencies = outcome.frequencies() + + shots_ones = frequencies.get(ones, 0) + shots_zeros = frequencies.get(zeros, 0) + + # Check that the counts for both outcomes are within the 3-sigma threshold of nshots/2. + assert ( + abs(shots_ones - (nshots / 2)) < sigma_threshold + ), f"Count for {ones} deviates too much: {shots_ones} vs expected {nshots/2}" + assert ( + abs(shots_zeros - (nshots / 2)) < sigma_threshold + ), f"Count for {zeros} deviates too much: {shots_zeros} vs expected {nshots/2}" diff --git a/tests/test_expectation.py b/tests/test_expectation.py new file mode 100644 index 0000000..d89c6f9 --- /dev/null +++ b/tests/test_expectation.py @@ -0,0 +1,47 @@ +import math +import random + +import pytest +from qibo import Circuit, construct_backend, gates, hamiltonians +from qibo.symbols import X, Z + + +def build_observable(nqubits): + """Helper function to construct a target observable.""" + hamiltonian_form = 0 + for i in range(nqubits): + hamiltonian_form += 0.5 * X(i % nqubits) * Z((i + 1) % nqubits) + + hamiltonian = hamiltonians.SymbolicHamiltonian(form=hamiltonian_form) + return hamiltonian, hamiltonian_form + + +def build_circuit(nqubits, nlayers, seed=42): + """Helper function to construct a layered quantum circuit.""" + random.seed(seed) + + circ = Circuit(nqubits) + for _ in range(nlayers): + for q in range(nqubits): + circ.add(gates.RY(q=q, theta=random.uniform(-math.pi, math.pi))) + circ.add(gates.RZ(q=q, theta=random.uniform(-math.pi, math.pi))) + [circ.add(gates.CNOT(q % nqubits, (q + 1) % nqubits) for q in range(nqubits))] + circ.add(gates.M(*range(nqubits))) + return circ + + +@pytest.mark.parametrize("nqubits", [2, 5, 10]) +def test_observable_expval(backend, nqubits): + numpy_backend = construct_backend("numpy") + ham, ham_form = build_observable(nqubits) + circ = build_circuit(nqubits=nqubits, nlayers=1) + + exact_expval = numpy_backend.calculate_expectation_state( + hamiltonian=ham, + state=circ().state(), + normalize=False, + ) + + tn_expval = backend.expectation(circuit=circ, observable=ham_form) + + assert math.isclose(exact_expval, tn_expval, abs_tol=1e-7)