iqm-client 32.1.1__py3-none-any.whl → 33.0.1__py3-none-any.whl

iqm/qiskit_iqm/iqm_provider.py

@@ -21,13 +21,7 @@ from typing import Any
 from uuid import UUID
 import warnings
 
-from iqm.iqm_client import (
-    CircuitBatch,
-    CircuitCompilationOptions,
-    CircuitValidationError,
-    IQMClient,
-    RunRequest,
-)
+from iqm.iqm_client import CircuitCompilationOptions, CircuitValidationError, IQMClient
 from iqm.iqm_client.util import to_json_dict
 from iqm.qiskit_iqm import IQMFakeAphrodite, IQMFakeApollo, IQMFakeBackend, IQMFakeDeneb
 from iqm.qiskit_iqm.fake_backends import IQMFakeAdonis
@@ -39,6 +33,7 @@ from qiskit import QuantumCircuit
 from qiskit.providers import JobStatus, JobV1, Options
 
 from iqm.pulse import Circuit
+from iqm.station_control.interface.models import CircuitBatch, RunRequest
 
 try:
     __version__ = version("qiskit-iqm")
@@ -52,9 +47,9 @@ class IQMBackend(IQMBackendBase):
     """Backend for executing quantum circuits on IQM quantum computers.
 
     Args:
-        client: Client instance for communicating with an IQM server.
+        client: Client instance for communicating with an IQM Server.
         calibration_set_id: ID of the calibration set the backend will use.
-            ``None`` means the IQM server will be queried for the current default
+            ``None`` means the IQM Server will be queried for the current default
             calibration set.
         use_metrics: If True, the backend will query the server for calibration data and related
             quality metrics, and pass these to the transpilation target(s). The default value is set
@@ -80,7 +75,6 @@ class IQMBackend(IQMBackendBase):
         super().__init__(architecture, metrics=metrics, **kwargs)
         self.client: IQMClient = client
         self._max_circuits: int | None = None
-        self.name = "IQM Backend"
         self._calibration_set_id = architecture.calibration_set_id
 
     @classmethod
@@ -110,12 +104,16 @@ class IQMBackend(IQMBackendBase):
     def run(
         self,
         run_input: QuantumCircuit | list[QuantumCircuit],
+        *,
+        use_timeslot: bool = False,
         **options,
     ) -> IQMJob:
         """Run a quantum circuit or a list of quantum circuits on the IQM quantum computer represented by this backend.
 
         Args:
             run_input: The circuits to run.
+            use_timeslot: Submits the job to the timeslot queue if set to ``True``. If set to ``False``,
+                the job is submitted to the normal on-demand queue.
             options: Keyword arguments passed on to :meth:`create_run_request`, and documented there.
 
         Returns:
@@ -123,8 +121,8 @@ class IQMBackend(IQMBackendBase):
 
         """
         run_request = self.create_run_request(run_input, **options)
-        job_id = self.client.submit_run_request(run_request)
-        job = IQMJob(self, str(job_id), shots=run_request.shots)
+        circuit_job = self.client.submit_run_request(run_request, use_timeslot=use_timeslot)
+        job = IQMJob(self, circuit_job)
         job.circuit_metadata = [c.metadata if isinstance(c, Circuit) else {} for c in run_request.circuits]
         return job
 
@@ -134,7 +132,7 @@ class IQMBackend(IQMBackendBase):
         shots: int = 1024,
         circuit_compilation_options: CircuitCompilationOptions | None = None,
         circuit_callback: Callable[[list[QuantumCircuit]], Any] | None = None,
-        qubit_mapping: dict[int, str] | None = None,
+        qubit_index_to_name: dict[int, str] | None = None,
         **unknown_options,
     ) -> RunRequest:
         """Creates a run request without submitting it for execution.
@@ -161,8 +159,8 @@ class IQMBackend(IQMBackendBase):
                 As a side effect, you can also use this callback to modify the transpiled circuits
                 in-place, just before execution; however, we do not recommend to use it for this
                 purpose.
-            qubit_mapping: Mapping from qubit indices in the circuit to qubit names on the device. If ``None``,
-                :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
+            qubit_index_to_name: Mapping from qubit indices in the circuit to qubit names on the device.
+                If ``None``, :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
 
         Returns:
             The created run request object
@@ -195,7 +193,9 @@ class IQMBackend(IQMBackendBase):
         if circuit_callback:
             circuit_callback(circuits)
 
-        circuits_serialized: CircuitBatch = [self.serialize_circuit(circuit, qubit_mapping) for circuit in circuits]
+        circuits_serialized: CircuitBatch = [
+            self.serialize_circuit(circuit, qubit_index_to_name) for circuit in circuits
+        ]
 
         if self._use_default_calibration_set:
             default_calset_id = self.client.get_dynamic_quantum_architecture(None).calibration_set_id
@@ -230,13 +230,10 @@ class IQMBackend(IQMBackendBase):
             corresponding job
 
         """
-        return IQMJob(self, job_id)
-
-    def close_client(self) -> None:
-        """Close IQMClient's session with the authentication server."""
-        self.client.close_auth_session()
+        circuit_job = self.client.get_job(UUID(job_id))
+        return IQMJob(self, circuit_job)
 
-    def serialize_circuit(self, circuit: QuantumCircuit, qubit_mapping: dict[int, str] | None = None) -> Circuit:
+    def serialize_circuit(self, circuit: QuantumCircuit, qubit_index_to_name: dict[int, str] | None = None) -> Circuit:
         """Serialize a quantum circuit into the IQM data transfer format.
 
         Serializing is not strictly bound to the native gateset, i.e. some gates that are not explicitly mentioned in
@@ -254,8 +251,8 @@ class IQMBackend(IQMBackendBase):
 
         Args:
             circuit: quantum circuit to serialize
-            qubit_mapping: Mapping from qubit indices in the circuit to qubit names on the device. If not provided,
-                :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
+            qubit_index_to_name: Mapping from qubit indices in the circuit to qubit names on the device.
+                If ``None``, :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
 
         Returns:
             data transfer object representing the circuit
@@ -264,9 +261,9 @@ class IQMBackend(IQMBackendBase):
             ValueError: circuit contains an unsupported instruction or is not transpiled in general
 
         """
-        if qubit_mapping is None:
-            qubit_mapping = self._idx_to_qb
-        instructions = tuple(serialize_instructions(circuit, qubit_index_to_name=qubit_mapping))
+        if qubit_index_to_name is None:
+            qubit_index_to_name = self._idx_to_qb
+        instructions = tuple(serialize_instructions(circuit, qubit_index_to_name=qubit_index_to_name))
 
         try:
             metadata = to_json_dict(circuit.metadata)
@@ -291,7 +288,7 @@ facade_names: dict[str, IQMFakeBackend] = {
 class IQMFacadeBackend(IQMBackend):
     """Simulates locally the execution of quantum circuits on a remote mock IQM quantum computer.
 
-    This backend is meant to be used to run circuits on a mock IQM server that has no real quantum hardware,
+    This backend is meant to be used to run circuits on a mock IQM Server that has no real quantum hardware,
     and if the mock execution is successful, simulate the circuits locally using an error model that
     is broadly representative of the mocked QPU. Finally it returns the *simulated results*.
 
@@ -299,13 +296,13 @@ class IQMFacadeBackend(IQMBackend):
 
     .. important::
 
-       When using a facade backend, the IQM server URL of :class:`IQMProvider` should always point to a mock environment
+       When using a facade backend, the IQM Server URL of :class:`IQMProvider` should always point to a mock environment
        rather than a real quantum computer, as the execution results from the server will be discarded and replaced by
        a locally simulated result generated by Qiskit Aer. If you use a real quantum computer with a facade backend,
        you will just waste your credits and/or computation time.
 
     Args:
-        client: Client instance for communicating with an IQM server.
+        client: Client instance for communicating with an IQM Server.
         name: Name of the fake backend (simulator instance) to use. If None, will be determined automatically based
             on the static quantum architecture of the server.
         kwargs: Optional arguments to be passed to the parent class.
@@ -341,7 +338,13 @@ class IQMFacadeBackend(IQMBackend):
             return False
         return True
 
-    def run(self, run_input: QuantumCircuit | list[QuantumCircuit], **options) -> JobV1:
+    def run(
+        self,
+        run_input: QuantumCircuit | list[QuantumCircuit],
+        *,
+        use_timeslot: bool = False,
+        **options,
+    ) -> JobV1:
         circuits = [run_input] if isinstance(run_input, QuantumCircuit) else run_input
         circuits_validated_cregs: list[bool] = [self._validate_no_empty_cregs(circuit) for circuit in circuits]
         if not all(circuits_validated_cregs):
@@ -350,7 +353,7 @@ class IQMFacadeBackend(IQMBackend):
                 "see the user guide."
             )
 
-        iqm_backend_job = super().run(run_input, **options)
+        iqm_backend_job = super().run(run_input, use_timeslot=use_timeslot, **options)
         iqm_backend_job.result()  # get and discard results
         if iqm_backend_job.status() == JobStatus.ERROR:
             raise RuntimeError("Remote execution did not succeed.")
@@ -360,18 +363,28 @@ class IQMFacadeBackend(IQMBackend):
 class IQMProvider:
     """Provider for IQM backends.
 
-    IQMProvider connects to a quantum computer through an IQM server.
+    IQMProvider connects to a quantum computer through an IQM Server.
     If the server requires user authentication, you can provide it either using environment
     variables, or as keyword arguments to IQMProvider. The user authentication kwargs are passed
     through to :class:`~iqm.iqm_client.iqm_client.IQMClient` as is, and are documented there.
 
     Args:
-        url: URL of the IQM server (e.g. "https://cocos.resonance.meetiqm.com/garnet")
+        url: URL of the IQM Server (e.g. "https://resonance.meetiqm.com/").
+        quantum_computer: ID or alias of the quantum computer to connect to, if the IQM Server
+            instance controls more than one (e.g. "garnet"). ``None`` means connect to the
+            default one.
 
     """
 
-    def __init__(self, url: str, **user_auth_args):  # contains keyword args token or tokens_file
+    def __init__(
+        self,
+        url: str,
+        *,
+        quantum_computer: str | None = None,
+        **user_auth_args,  # contains keyword args token or tokens_file
+    ):
         self.url = url
+        self.quantum_computer = quantum_computer
         self.user_auth_args = user_auth_args
 
     def get_backend(
@@ -396,7 +409,7 @@ class IQMProvider:
             Backend instance for connecting to a quantum computer.
 
         """
-        client = IQMClient(self.url, **self.user_auth_args)
+        client = IQMClient(self.url, quantum_computer=self.quantum_computer, **self.user_auth_args)
 
         if name and name.startswith("facade_"):
             return IQMFacadeBackend(client, name=name, calibration_set_id=calibration_set_id, use_metrics=use_metrics)

iqm/qiskit_iqm/iqm_target.py

@@ -19,18 +19,15 @@ from collections.abc import Iterable
 import logging
 from typing import TypeAlias
 
-from iqm.iqm_client import (
-    DynamicQuantumArchitecture,
-    GateImplementationInfo,
-    GateInfo,
-    ObservationFinder,
-)
+from iqm.iqm_client import ObservationFinder
 from iqm.qiskit_iqm.move_gate import MoveGate
 from qiskit.circuit import Delay, Gate, IfElseOp, Parameter, Reset
 from qiskit.circuit.library import CZGate, IGate, Measure, RGate
 from qiskit.providers import QubitProperties
 from qiskit.transpiler import InstructionProperties, Target
 
+from iqm.station_control.interface.models import DynamicQuantumArchitecture, GateImplementationInfo, GateInfo
+
 Locus: TypeAlias = tuple[str, ...]
 """Sequence of QPU component names on which a gate acts."""
 LocusIdx: TypeAlias = tuple[int, ...]
@@ -83,6 +80,7 @@ class IQMTarget(Target):
         # (2) make all the IQMTarget.__init__ args keyword-only with non-colliding names, and init
         # the necessary superclass attributes ourselves.
         # (1) seems to break pickling during concurrent transpilation using Qiskit's ``transpile``, so we use (2).
+        # (2) is broken from Qiskit 2.2 onwards because Target.__init__ no longer has **kwargs nor *args.
         self.qubit_properties = self._create_qubit_properties(architecture.qubits, metrics)
 
         # Using iqm_ as a prefix to avoid name clashes with the base class.

iqm/qiskit_iqm/qiskit_to_iqm.py

@@ -25,14 +25,14 @@ from iqm.qiskit_iqm.move_gate import MoveGate
 from packaging.version import Version
 from qiskit import QuantumCircuit as QiskitQuantumCircuit
 from qiskit import __version__ as qiskit_version
-from qiskit.circuit import ClassicalRegister, Clbit, Operation, QuantumRegister
+from qiskit.circuit import ClassicalRegister, Clbit, Operation, QuantumRegister, Qubit
 from qiskit.transpiler.layout import Layout
 
 from iqm.pulse import CircuitOperation
 
 
 class InstructionNotSupportedError(RuntimeError):
-    """Raised when a given instruction is not supported by the IQM server."""
+    """Raised when a given instruction is not supported by the IQM Server."""
 
 
 @dataclass(frozen=True)
@@ -55,7 +55,7 @@ class MeasurementKey:
     ``IQMJob``, since otherwise users will not be able to retrieve results from a detached Python
     environment solely based on the job id. Another option is to use measurement key strings to
     store the required info. Qiskit does not use measurement keys, so we are free to use them
-    internally in the communication with the IQM server, and can encode the necessary information in
+    internally in the communication with the IQM Server, and can encode the necessary information in
     them.
 
     This class encapsulates the necessary info, and provides methods to transform between this
@@ -142,6 +142,54 @@ def _apply_condition(
         inst.args["feedback_qubit"] = physical_qubit_name
 
 
+def _calculate_ifblock_idx2name_mapping(
+    circuit: QiskitQuantumCircuit,
+    if_block_qubits: list[Qubit],
+    overwrite_layout: Layout | None,
+    qubit_index_to_name: dict[int, str],
+) -> dict[int, str]:
+    """Calculate mapping from if-block qubit registers to physical qubit names.
+
+    The if-block circuit has no qregs of its own, just references to the parent circuit qubits.
+    Depending on how the circuit was transpiled, the if-block Qubit Objects might
+    not be present in the parent Circuit. This method finds the appropriate physical qubits
+    to make a new qubit index to name mapping for it.
+
+    Args:
+        circuit: The parent quantum circuit containing the if-block.
+        if_block_qubits: The qubits used in the if-block.
+        overwrite_layout: An alternative layout indicating the physical qubit mapping to use for the serialized
+            instructions, this overwrites the circuit's layout.
+        qubit_index_to_name: Mapping from qubit indices to the corresponding qubit names as obtained from a backend.
+
+    """
+    # Check if we can use the overwrite layout
+    use_overwrite_layout = overwrite_layout is not None and all(
+        qb in overwrite_layout.get_physical_bits().values() for qb in if_block_qubits
+    )
+    if use_overwrite_layout:
+        physical_qubits = {q: i for i, q in overwrite_layout.get_physical_bits().items()}  # type: ignore[union-attr]
+        return {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block_qubits)}
+    # The if-block qubits are not in the circuit, so we hope they are in the layout
+    use_circuit_layout_guess = circuit.layout is not None and all(
+        qb in circuit.layout.initial_layout.get_physical_bits().values() for qb in if_block_qubits
+    )
+    if use_circuit_layout_guess:
+        physical_qubits = {q: i for i, q in circuit.layout.initial_layout.get_physical_bits().items()}
+        return {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block_qubits)}
+
+    # Hope that we can find the qubits in the circuit - can be wrong.
+    use_circuit_find_bit = all(qb in circuit.qubits for qb in if_block_qubits)
+    if use_circuit_find_bit:
+        return {k: qubit_index_to_name[circuit.find_bit(q).index] for k, q in enumerate(if_block_qubits)}
+    # Catch-all: we cannot determine the mapping, this should never happen.
+    raise ValueError(
+        "Could not determine the physical locations for if-block qubits. "
+        "The if-block uses {if_block_qubits} qubits, but the parent circuit has qubits {circuit.qubits}, "
+        "the circuit layout is {circuit.layout.initial_layout}, and the overwrite layout is {overwrite_layout}."
+    )
+
+
 def serialize_instructions(  # noqa: PLR0912, PLR0915
     circuit: QiskitQuantumCircuit,
     qubit_index_to_name: dict[int, str],
@@ -179,9 +227,16 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
     # maps clbits to the latest "measure" instruction to store its result there
     if clbit_to_measure is None:
         clbit_to_measure = {}
+    invalid_layout = circuit.layout is None or circuit.layout.initial_layout.get_registers() != set(circuit.qregs)
     for circuit_instruction in circuit.data:
         instruction = circuit_instruction.operation
-        qubit_names = tuple(qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits)
+        if invalid_layout:
+            qubit_names = tuple(
+                qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits
+            )
+        else:
+            physical_qubits = {q: i for i, q in circuit.layout.initial_layout.get_physical_bits().items()}
+            qubit_names = tuple(qubit_index_to_name[physical_qubits[qubit]] for qubit in circuit_instruction.qubits)
         if instruction.name == "r":
             angle = float(instruction.params[0])
             phase = float(instruction.params[1])
@@ -241,28 +296,10 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
             if_block, else_block = instruction.params
             if else_block is not None and len(else_block) > 0:  # Non-empty circuit in else-block
                 raise ValueError("The use of an else-block with if_test is not supported.")
-            # Serialize the if-block.
-            # NOTE The if-block circuit has no qregs of its own, just references to the parent circuit qregs,
-            # and it does not always have every parent circuit qubit.
-            # Hence we need to make a new qubit index to name mapping for it.
-
-            # NOTE Sometimes the qubits in the if-block are in the circuit and
-            # sometimes they are in the layout depending on how the circuit was transpiled.
-            # So let's find out where to get the physical qubits from.
-            use_overwrite_layout = overwrite_layout is not None and all(
-                qb in overwrite_layout.get_physical_bits().values() for qb in if_block.qubits
+            # Recursively serialize the if-block.
+            q_index_to_name = _calculate_ifblock_idx2name_mapping(
+                circuit, if_block.qubits, overwrite_layout, qubit_index_to_name
             )
-            if use_overwrite_layout:
-                physical_qubits = {q: i for i, q in overwrite_layout.get_physical_bits().items()}  # type: ignore[union-attr]
-                q_index_to_name = {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block.qubits)}
-            elif circuit.layout is None or all(qb in circuit.qubits for qb in if_block.qubits):
-                q_index_to_name = {
-                    k: qubit_index_to_name[circuit.find_bit(q).index] for k, q in enumerate(if_block.qubits)
-                }
-            else:
-                physical_qubits = {q: i for i, q in circuit.layout.initial_layout.get_physical_bits().items()}
-                q_index_to_name = {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block.qubits)}
-
             if_instructions = serialize_instructions(
                 if_block, q_index_to_name, allowed_nonnative_gates, clbit_to_measure=clbit_to_measure
             )

{iqm_client-32.1.1.dist-info → iqm_client-33.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-client
-Version: 32.1.1
+Version: 33.0.1
 Summary: Client library for accessing an IQM quantum computer
 Author-email: IQM Finland Oy <developers@meetiqm.com>
 License: Apache License
@@ -216,35 +216,25 @@ Requires-Python: <3.13,>=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
-Requires-Dist: iqm-station-control-client <12,>=11
-Requires-Dist: iqm-exa-common <28,>=27
-Requires-Dist: iqm-pulse <13,>=12
 Requires-Dist: numpy <3.0,>=1.26.4
 Requires-Dist: packaging ==24.1
 Requires-Dist: pydantic <3.0,>=2.9.2
 Requires-Dist: requests ==2.32.3
+Requires-Dist: iqm-pulse <13,>=12.7.1
+Requires-Dist: iqm-station-control-client <13,>=12.0.1
 Provides-Extra: cirq
-Requires-Dist: iqm-station-control-client <12,>=11 ; extra == 'cirq'
-Requires-Dist: iqm-exa-common <28,>=27 ; extra == 'cirq'
-Requires-Dist: iqm-pulse <13,>=12 ; extra == 'cirq'
 Requires-Dist: cirq-core[contrib] ~=1.2 ; extra == 'cirq'
 Requires-Dist: ply ==3.11 ; extra == 'cirq'
 Requires-Dist: llvmlite >=0.44.0 ; extra == 'cirq'
 Requires-Dist: numba >=0.61.0 ; extra == 'cirq'
 Provides-Extra: cli
-Requires-Dist: iqm-station-control-client <12,>=11 ; extra == 'cli'
-Requires-Dist: iqm-exa-common <28,>=27 ; extra == 'cli'
-Requires-Dist: iqm-pulse <13,>=12 ; extra == 'cli'
 Requires-Dist: click <9,>=8.1.6 ; extra == 'cli'
 Requires-Dist: jsonschema >=4.6.0 ; extra == 'cli'
 Requires-Dist: psutil >=5.9.2 ; extra == 'cli'
 Requires-Dist: types-psutil ; extra == 'cli'
 Requires-Dist: python-daemon >=2.3.0 ; extra == 'cli'
 Provides-Extra: qiskit
-Requires-Dist: iqm-station-control-client <12,>=11 ; extra == 'qiskit'
-Requires-Dist: iqm-exa-common <28,>=27 ; extra == 'qiskit'
-Requires-Dist: iqm-pulse <13,>=12 ; extra == 'qiskit'
-Requires-Dist: qiskit <=1.4.2,>=1.0 ; extra == 'qiskit'
+Requires-Dist: qiskit <2.2,>=1.0 ; extra == 'qiskit'
 Requires-Dist: qiskit-aer <0.18,>=0.13.1 ; extra == 'qiskit'
 
 IQM Client
@@ -260,16 +250,15 @@ adapters for `IQM's <https://www.meetiqm.com>`_ quantum computers, which allow y
   (currently only the Qiskit adapter contains IQM noise models)
 * Run quantum circuits on an IQM quantum computer
 
-Also includes a `CLI utility <https://docs.meetiqm.com/iqm-client/user_guide_cli.html>`_ for managing user
-authentication when using IQM quantum computers.
+Also includes a CLI utility for managing user authentication when using IQM quantum computers.
 
 Installation
 ============
 
-For executing code on an IQM quantum computer, you can use for example
-`Qiskit on IQM <https://docs.meetiqm.com/iqm-client/user_guide_qiskit.html>`_ or
-`Cirq on IQM <https://docs.meetiqm.com/iqm-client/user_guide_cirq.html>`_, which can be installed as optional
-features of IQM Client from the Python Package Index (PyPI), e.g.:
+For executing code on an IQM quantum computer, you can use for example the
+Qiskit on IQM or Cirq on IQM user guides found in the documentation.
+Qiskit on IQM and Cirq on IQM are optional features that can be installed alongside the base IQM Client library.
+An example showing how to install from the public Python Package Index (PyPI):
 
 .. code-block:: bash
 
@@ -281,8 +270,7 @@ features of IQM Client from the Python Package Index (PyPI), e.g.:
     Python environment, you should first uninstall them with ``$ pip uninstall qiskit-iqm cirq-iqm``.
     In this case, you should also include the ``--force-reinstall`` option in the ``iqm-client`` installation command.
 
-The `CLI utility <https://docs.meetiqm.com/iqm-client/user_guide_cli.html>`_ for managing user authentication can also
-be installed as an optional feature:
+The CLI utility for managing user authentication can also be installed as an optional feature:
 
 .. code-block:: bash
 
@@ -304,10 +292,15 @@ Documentation
 
 Documentation for the latest version is `available online <https://docs.meetiqm.com/iqm-client/>`_.
 You can build documentation for any older version locally by downloading the corresponding package from PyPI,
-and running the docs builder. For versions 20.12 and later this is done by running ``./docbuild`` in the
-``iqm-client`` root directory, and for earlier versions by running ``tox run -e docs``.
+and running the docs builder. For versions greater than equal to 20.12 but less than 33.0.0 this is done by
+running ``./docbuild`` in the ``iqm-client`` root directory, and for earlier versions by running ``tox run -e docs``.
 
 ``./docbuild`` or ``tox run -e docs`` will build the documentation at ``./build/sphinx/html``.
+
+Versions greater than or equal to 33.0.0 use the command:
+``sphinx-build -q -d build/.doctrees/iqm-client iqm-client/docs build/docs/iqm-client``
+(``build/docs/`` directory has to be created first).
+
 These commands require installing the ``sphinx`` and ``sphinx-book-theme`` Python packages and
 `graphviz <https://graphviz.org/>`_.
 

iqm_client-33.0.1.dist-info/RECORD

@@ -0,0 +1,63 @@
+iqm/cirq_iqm/__init__.py,sha256=1zTyxtF39OD11D00ZujgqciJ_9GBDYe-PVBLqZp4NaA,831
+iqm/cirq_iqm/extended_qasm_parser.py,sha256=csDzfHLhy_9maGbappLbnFo2NHQjQeyd-1F8P380Mbk,1917
+iqm/cirq_iqm/iqm_gates.py,sha256=xnZex5ZfNOk_WSsFjVCRybc14FlGNbmwOs3mIfOE_F8,2488
+iqm/cirq_iqm/iqm_sampler.py,sha256=b5CpcD7tgUAWKYdAKcFrshfv1I1GN5eC7mfMyXoGF_8,12606
+iqm/cirq_iqm/optimizers.py,sha256=Jcb6W7-M9wYa5mZztq33jQpWuIzD5ulE16ZperIc-wU,8566
+iqm/cirq_iqm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iqm/cirq_iqm/serialize.py,sha256=2w_8sk-X18qWb2FFocBP_MXJALoNmosZIs5Ilp7ueR8,8516
+iqm/cirq_iqm/transpiler.py,sha256=zjJzZb5HyjTfqhL0rMI3dt_3GPGLdVYah9UlGoC8hcc,2173
+iqm/cirq_iqm/devices/__init__.py,sha256=WxbvNAqmeoV4mNy9M9IpjwmyNDpAP7ec1XFdjN7w_YA,840
+iqm/cirq_iqm/devices/adonis.py,sha256=ZWaA4_OfO6fBcrLYHONTjtW8aSlVq2nwy9IiW529gQw,1390
+iqm/cirq_iqm/devices/aphrodite.py,sha256=0K8zRo6gVVadQo7LJfs6laUVLzS3fNkrXMrPlwieyJ8,4018
+iqm/cirq_iqm/devices/apollo.py,sha256=_k7L45zyHZnpdZWMMXO6zci3XY3UEnBj2RmvxM6D7Mg,2238
+iqm/cirq_iqm/devices/iqm_device.py,sha256=CyAP0kU9vfovNWvF4CVX8Wp6_QLxLN8fy9I2YZkHHwM,15425
+iqm/cirq_iqm/devices/iqm_device_metadata.py,sha256=3ONFzPa1G_nE4nSAldsd_Ly8i1__n2Sll43qN9yNQUw,7161
+iqm/cirq_iqm/examples/demo_adonis.py,sha256=rPd8VYqccYijG6t92hfvKsk8RAaMGHOmm4JelYjt3rw,1728
+iqm/cirq_iqm/examples/demo_apollo.py,sha256=vnDwcEXqEyew0cf4SDDQ2budP-giizSNJU3dgOw15H0,1751
+iqm/cirq_iqm/examples/demo_common.py,sha256=k0MAeLDNxZJGv8FNrgMEwaQZsuXeDY5NBM2rLSIQxvU,8745
+iqm/cirq_iqm/examples/demo_iqm_execution.py,sha256=_Wf6rsL_q93M5Ww6eurbXL8VPngGkxtpZBAbNpnn2ek,2440
+iqm/cirq_iqm/examples/usage.ipynb,sha256=Kyfyu_MwqzTavHVNjgrWJo1tZPeJwTw7ExcU0MFYNRk,34208
+iqm/iqm_client/__init__.py,sha256=43TjxuxX_iFl5h2GbQqyIkxmuraWkX4OyvF444Hlyvk,1306
+iqm/iqm_client/errors.py,sha256=weKTljBvDzJxK58NHCXaZXoITVMBvsOkvYP0abs5Dfc,1226
+iqm/iqm_client/iqm_client.py,sha256=OGKp6QDwtIY2RjJ8_uG44UJlMpm7VH_HTgqZFPPN2YA,22632
+iqm/iqm_client/models.py,sha256=UHlkdG0bjaksvyARYB4RZYx1EJ4nLMyHiPS_7-Bwr14,15888
+iqm/iqm_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iqm/iqm_client/transpile.py,sha256=ZicsOJiT5zEaaYMWuFddnJT2e4e9Oyu7B5pO8Z_ah7M,37334
+iqm/iqm_client/util.py,sha256=obzh1g6PNEXOj7k3gUkiylNUhyqutbWlxlEpfyyU_fk,1505
+iqm/iqm_client/validation.py,sha256=SyshUOxmnlwb0haWEAVkgynGOYUMV7Os281sUe29tpE,12621
+iqm/iqm_server_client/__init__.py,sha256=hqfe65DmdYu5qDbYsg3Uq94DRe2zkbMJP_XFYsMbGSQ,645
+iqm/iqm_server_client/errors.py,sha256=I48dRY_Sies2vQzyjzQxhHm_J5RopyL5hqAmlnBy67w,192
+iqm/iqm_server_client/iqm_server_client.py,sha256=en2C4hZ4VzHtg07EtxpuC-cFEw2kzTi1_GzfYKk-NWY,31365
+iqm/iqm_server_client/models.py,sha256=YpyppxEu2obSIaUvuc3_mRKcGscs8YLrcWrTk7EHKzM,5597
+iqm/iqm_server_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iqm/qiskit_iqm/__init__.py,sha256=VPmcMV5nBOEIhVsOceIUkdZtWJ3tGlaKrDFP-FRuOCs,1667
+iqm/qiskit_iqm/iqm_backend.py,sha256=3ydSroylh_Us-5RJfOQgOkL7eqF4fWe5ejXueDTcAj8,5584
+iqm/qiskit_iqm/iqm_circuit.py,sha256=jaPo3zc5FC0vAIumh5d56fr44fDaJXXwcquBzQEy1Yg,1400
+iqm/qiskit_iqm/iqm_circuit_validation.py,sha256=SzfCJclUh1kK6Kcz5puKlCtE0hZfWxYYKF35EagU204,1750
+iqm/qiskit_iqm/iqm_job.py,sha256=SdyZeQi5CoGxBeJyfIvOM7DA0ONJ5tbTHpk4hajpUFk,12395
+iqm/qiskit_iqm/iqm_move_layout.py,sha256=vFdba0DStu8Pebi3qxZBYOLCYC2Atl28YlSzbSGER4Y,10557
+iqm/qiskit_iqm/iqm_naive_move_pass.py,sha256=GcS2DyYWwG-qMyczXqTXxMxNqRB4IVeWNP3CzguKpBw,15639
+iqm/qiskit_iqm/iqm_provider.py,sha256=pK1CcAOQKG5jXYfjxshuVSmMLWQG1-k0cyghRmGpWN8,19273
+iqm/qiskit_iqm/iqm_target.py,sha256=nqurRgM_p2nOw8ty8ncw38vSErEdXpHSlbp7Rpavnc4,16232
+iqm/qiskit_iqm/iqm_transpilation.py,sha256=RccAHY7lNXvg7TWKG7fBNBCgFu5Xd9B_J9V9uKLlmuY,18336
+iqm/qiskit_iqm/move_gate.py,sha256=UbrQSfrpVV3QKGJ93TelxEfZkl1wY4uWL8IH_QDpGUw,2840
+iqm/qiskit_iqm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iqm/qiskit_iqm/qiskit_to_iqm.py,sha256=imMmuOi_tuujIrGzBFnGOtxpGHcIkncXutr5QFekJl4,20677
+iqm/qiskit_iqm/transpiler_plugins.py,sha256=BrCkUFQUdi0m8K8V0ERYgtPAkvoX4VlYIJwnFKyCN9Q,8831
+iqm/qiskit_iqm/examples/__init__.py,sha256=M4ElQHCo-WxtVXK39bF3QiFT3IGXPtZ1khqexHiTBEc,20
+iqm/qiskit_iqm/examples/bell_measure.py,sha256=pwSGeggb8HuUWh4SYUkbLDeZI00gxRmVw0svA_hbn-Y,3056
+iqm/qiskit_iqm/examples/transpile_example.py,sha256=FNpHy6nxJgaXhgbl7_SavHRNaNMyk4lSkd_0a2GSKh4,2410
+iqm/qiskit_iqm/fake_backends/__init__.py,sha256=fkw2UHT-3aJbAKvR1WYUN7_4N5Gdwpx9bm6vlWj1tm0,874
+iqm/qiskit_iqm/fake_backends/fake_adonis.py,sha256=DWftCPu6ElE4P47Z-y3bojg0unDJ6F5ur2aDqfoY85s,2248
+iqm/qiskit_iqm/fake_backends/fake_aphrodite.py,sha256=oB5wFtZ2VYy0TxoL-eBgYnVAwamGPYlzIQK89npwQUg,15533
+iqm/qiskit_iqm/fake_backends/fake_apollo.py,sha256=C05u3knnCsA8DCuWU31EwUvJ6xilef36J06GoE2vAe4,6623
+iqm/qiskit_iqm/fake_backends/fake_deneb.py,sha256=HstlV-PSbyCttY1uEyWr-YgsMNkv9Ntf6zffav837_4,3216
+iqm/qiskit_iqm/fake_backends/fake_garnet.py,sha256=GI0xafTCj1Um09qVuccO6GPOGBm6ygul_O40Wu220Ys,5555
+iqm/qiskit_iqm/fake_backends/iqm_fake_backend.py,sha256=IfVKxlPlAVCHTgli2scRP1gkVCXIiSuL6-QjjsZp83Q,16808
+iqm_client-33.0.1.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
+iqm_client-33.0.1.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
+iqm_client-33.0.1.dist-info/METADATA,sha256=yJ-Xub8FOJ-nI248Vlv15cG_8H38DvRxSp6JxFx3ucY,17435
+iqm_client-33.0.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_client-33.0.1.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
+iqm_client-33.0.1.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_client-33.0.1.dist-info/RECORD,,

iqm/iqm_client/api.py

@@ -1,90 +0,0 @@
-# Copyright 2024 IQM client developers
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""This module contains definitions of IQM Server API endpoints."""
-
-from enum import Enum, auto
-from posixpath import join
-
-
-class APIEndpoint(Enum):
-    """Supported API endpoints."""
-
-    GET_JOB_RESULT = auto()
-    GET_JOB_REQUEST_PARAMETERS = auto()
-    GET_JOB_CALIBRATION_SET_ID = auto()
-    GET_JOB_CIRCUITS_BATCH = auto()
-    GET_JOB_ERROR_LOG = auto()
-    SUBMIT_JOB = auto()
-    GET_JOB_COUNTS = auto()
-    GET_JOB_STATUS = auto()
-    GET_JOB_TIMELINE = auto()
-    ABORT_JOB = auto()
-
-
-class APIConfig:
-    """Provides supported API endpoints for a given API variant."""
-
-    def __init__(self, station_control_url: str):
-        """Args:
-        station_control_url: URL of the IQM server,
-            e.g. https://test.qc.iqm.fi/station or https://cocos.resonance.meetiqm.com/garnet
-
-        """
-        self.station_control_url = station_control_url
-        self.urls = self._get_api_urls()
-
-    @staticmethod
-    def _get_api_urls() -> dict[APIEndpoint, str]:
-        """Returns:
-        Relative URLs for each supported API endpoints.
-
-        """
-        return {
-            # TODO SW-1434: Use StationControlClient methods for communication instead of REST endpoints
-            APIEndpoint.GET_JOB_RESULT: "jobs/%s/measurements",
-            APIEndpoint.GET_JOB_REQUEST_PARAMETERS: "jobs/%s/request_parameters",
-            APIEndpoint.GET_JOB_CALIBRATION_SET_ID: "jobs/%s/calibration_set_id",
-            APIEndpoint.GET_JOB_CIRCUITS_BATCH: "jobs/%s/circuits_batch",
-            APIEndpoint.GET_JOB_ERROR_LOG: "jobs/%s/error_log",
-            APIEndpoint.SUBMIT_JOB: "circuits",
-            APIEndpoint.GET_JOB_COUNTS: "circuits/%s/counts",
-            APIEndpoint.GET_JOB_STATUS: "jobs/%s/status",
-            APIEndpoint.GET_JOB_TIMELINE: "jobs/%s/timeline",
-            APIEndpoint.ABORT_JOB: "jobs/%s/abort",
-        }
-
-    def is_supported(self, endpoint: APIEndpoint) -> bool:
-        """Args:
-            endpoint: API endpoint.
-
-        Returns:
-            True if the endpoint is supported, False otherwise.
-
-        """
-        return endpoint in self.urls
-
-    def url(self, endpoint: APIEndpoint, *args) -> str:
-        """Args:
-            endpoint: API endpoint.
-            args: Arguments to be passed to the URL.
-
-        Returns:
-            URL for the given endpoint.
-
-        Raises:
-            ValueError: If the endpoint is not supported.
-
-        """
-        url = self.urls.get(endpoint, "")
-        return join(self.station_control_url, url % args)