iqm-client 29.14.0__py3-none-any.whl → 30.0.0__py3-none-any.whl

iqm/iqm_client/cli/auth.py

@@ -42,6 +42,7 @@ class GrantType(str, Enum):
 
 class AuthRequest(BaseModel):
     """Request sent to authentication server for access token and refresh token, or for terminating the session.
+
     * Token request with grant type ``'password'`` starts a new session in the authentication server.
       It uses fields ``client_id``, ``grant_type``, ``username`` and ``password``.
     * Token request with grant type ``'refresh_token'`` is used for maintaining an existing session.

iqm/iqm_client/cli/token_manager.py

@@ -51,6 +51,7 @@ def start_token_manager(cycle: int, config: ConfigFile, single_run: bool = False
     """Refresh tokens periodically.
 
     For each refresh cycle new tokens are requested from auth server.
+
     - If refresh is successful next refresh is attempted in the next cycle.
     - If auth server does not respond refresh is attempted repeatedly until it succeeds or
       the existing refresh token expires.
@@ -104,11 +105,10 @@ def refresh_tokens(config: ConfigFile, current_tokens: dict, cycle: int) -> tupl
         cycle: refresh cycle length in seconds
 
     Returns:
-        Tuple[Optional[dict], bool, int] = (tokens, status, sleep_time)
-        tokens: dict containing new tokens or current tokens if auth server could not be connected or
-                None if auth server refused to provide new tokens.
-        status: bool, True if tokens were refreshed successfully, False otherwise
-        sleep_time: time to sleep before next refresh attempt
+        * dict containing new tokens or current tokens if auth server could not be connected or
+          None if auth server refused to provide new tokens
+        * bool, True if tokens were refreshed successfully, False otherwise
+        * time to sleep before next refresh attempt
 
     """
     access_token = current_tokens.get("access_token", "")

iqm/iqm_client/iqm_client.py

@@ -20,6 +20,7 @@ from functools import lru_cache
 from http import HTTPStatus
 from importlib.metadata import version
 import json
+import logging
 import os
 import platform
 import time
@@ -77,6 +78,9 @@ DEFAULT_TIMEOUT_SECONDS = 900
 SECONDS_BETWEEN_CALLS = float(os.environ.get("IQM_CLIENT_SECONDS_BETWEEN_CALLS", 1.0))
 
 
+logger = logging.getLogger(__name__)
+
+
 class IQMClient:
     """Provides access to IQM quantum computers.
 
@@ -907,11 +911,18 @@ class IQMClient:
             # model = model_class.model_validate_json(response.text)
         except json.decoder.JSONDecodeError as e:
             raise EndpointRequestError(f"Invalid response: {response.text}, {e!r}") from e
+
         return model
 
-    def get_structured_metrics(self, calibration_set_id: UUID | None = None) -> ObservationFinder:
+    def get_calibration_quality_metrics(self, calibration_set_id: UUID | None = None) -> ObservationFinder:
         """Retrieve the given calibration set and related quality metrics from the server.
 
+        .. warning::
+
+           This method is an experimental interface to the quality metrics and calibration data.
+           The API may change considerably in the next versions *with no backwards compatibility*,
+           including the API of the ObservationFinder class.
+
         Args:
             calibration_set_id: ID of the calibration set to retrieve.
                 If ``None``, the current default calibration set is retrieved.
@@ -925,8 +936,16 @@ class IQMClient:
             HTTPException: HTTP exceptions
 
         """
+        logger.warning(
+            "IQMClient.get_calibration_quality_metrics is an experimental method, and the API will likely change "
+            "in the future with no backwards compatibility."
+        )
+        return self._get_calibration_quality_metrics(calibration_set_id)
+
+    def _get_calibration_quality_metrics(self, calibration_set_id: UUID | None = None) -> ObservationFinder:
+        """See :meth:`get_calibration_quality_metrics`."""
         if isinstance(self._station_control, IqmServerClient):
-            raise ValueError("The get_structured_metrics method is not supported by IqmServerClient.")
+            raise ValueError("The _get_calibration_quality_metrics method is not supported by IqmServerClient.")
 
         if not calibration_set_id:
             # find out the default calset id
@@ -936,5 +955,4 @@ class IQMClient:
         calset_obs = self._station_control.get_observation_set_observations(calibration_set_id)
         quality_metrics = self._station_control.get_calibration_set_quality_metrics(calibration_set_id)
         qm_obs = quality_metrics.observations
-
-        return ObservationFinder(list(calset_obs) + qm_obs)
+        return ObservationFinder(calset_obs + qm_obs)

iqm/iqm_client/util.py

@@ -14,12 +14,10 @@
 """Helpful utilities that can be used together with IQMClient."""
 
 from json import JSONEncoder, dumps, loads
-from typing import Any, TypeVar
+from typing import Any
 
 import numpy as np
 
-T = TypeVar("T")
-
 
 class IQMJSONEncoder(JSONEncoder):
     """JSONEncoder that that adds support for some non-JSON datatypes"""

iqm/qiskit_iqm/examples/resonance_example.py

@@ -36,8 +36,8 @@ def resonance_example(server_url: str, api_token: str | None) -> dict[str, int]:
     """
     SHOTS = 1000
 
-    # Initialize a backend
-    backend = IQMProvider(server_url, token=api_token).get_backend()
+    # Initialize a backend without metrics as IQMClient._get_calibration_quality_metrics is not supported by resonance
+    backend = IQMProvider(server_url, token=api_token).get_backend(use_metrics=False)
 
     # Just to make sure that "get_static_quantum_architecture" method works
     static_quantum_architecture = backend.client.get_static_quantum_architecture()

iqm/qiskit_iqm/fake_backends/fake_adonis.py

@@ -44,5 +44,4 @@ def IQMFakeAdonis() -> IQMFakeBackend:
         },
         name="sample-chip",
     )
-
     return IQMFakeBackend(architecture, error_profile, name="IQMFakeAdonisBackend")

iqm/qiskit_iqm/iqm_backend.py

@@ -16,69 +16,89 @@
 from __future__ import annotations
 
 from abc import ABC
-import itertools
+import logging
 from typing import Final
 
 from iqm.iqm_client import (
     DynamicQuantumArchitecture,
-    GateImplementationInfo,
-    GateInfo,
+    ObservationFinder,
 )
-from iqm.qiskit_iqm.move_gate import MoveGate
-from qiskit.circuit import Delay, Parameter, Reset
-from qiskit.circuit.library import CZGate, IGate, Measure, RGate
+from iqm.qiskit_iqm.iqm_target import IQMTarget
 from qiskit.providers import BackendV2
 from qiskit.transpiler import Target
 
 IQM_TO_QISKIT_GATE_NAME: Final[dict[str, str]] = {"prx": "r", "cz": "cz"}
-
-Locus = tuple[str, ...]
-LocusIdx = tuple[int, ...]
+logger = logging.getLogger(__name__)
 
 
 class IQMBackendBase(BackendV2, ABC):
     """Abstract base class for various IQM-specific backends.
 
     Args:
-        architecture: Description of the quantum architecture associated with the backend instance.
+        architecture: Dynamic quantum architecture associated with the backend instance.
+        metrics: Optional calibration data and related quality metrics for the transpilation target.
+        name: Optional name for the backend instance.
 
     """
 
     def __init__(
         self,
         architecture: DynamicQuantumArchitecture,
+        *,
+        metrics: ObservationFinder | None = None,
+        name: str = "IQMBackend",
         **kwargs,
     ):
-        super().__init__(**kwargs)
+        super().__init__(name=name, **kwargs)
         self.architecture = architecture
-        """Dynamic quantum architecture of the backend instance."""
-
+        self.metrics = metrics
         # Qiskit uses integer indices to refer to qubits, so we need to map component names to indices.
         # Because of the way the Target and the transpiler interact, the resonators need to have higher indices than
         # qubits, or else transpiling with optimization_level=0 will fail because of lacking resonator indices.
         qb_to_idx = {qb: idx for idx, qb in enumerate(architecture.qubits + architecture.computational_resonators)}
 
-        self._target = IQMTarget(architecture, component_to_idx=qb_to_idx, include_resonators=False)
-        self._fake_target_with_moves = (
-            IQMTarget(architecture, component_to_idx=qb_to_idx, include_resonators=True)
+        # NOTE: both targets include fictional CZs
+        self._target = IQMTarget(
+            architecture=architecture,
+            component_to_idx=qb_to_idx,
+            include_resonators=False,
+            include_fictional_czs=True,
+            metrics=metrics,
+        )
+
+        self._target_with_resonators = (
+            IQMTarget(
+                architecture=architecture,
+                component_to_idx=qb_to_idx,
+                include_resonators=True,
+                include_fictional_czs=True,
+                metrics=metrics,
+            )
             if "move" in architecture.gates
             else None
         )
+
         self._qb_to_idx = qb_to_idx
         self._idx_to_qb = {v: k for k, v in qb_to_idx.items()}
-        self.name = "IQMBackend"
         self._coupling_map = self.target.build_coupling_map()
 
     @property
     def target(self) -> Target:
+        """Return the target without computational resonators."""
         return self._target
 
     @property
     def target_with_resonators(self) -> Target:
-        """Return the target with MOVE gates and resonators included."""
-        if self._fake_target_with_moves is None:
-            return self.target
-        return self._fake_target_with_moves
+        """Return the target with MOVE gates and resonators included.
+
+        Raises:
+            ValueError: The backend does not have resonators.
+
+        """
+        target = self._target_with_resonators
+        if target is None:
+            raise ValueError("The backend does not have computational resonators.")
+        return target
 
     @property
     def physical_qubits(self) -> list[str]:
@@ -90,12 +110,13 @@ class IQMBackendBase(BackendV2, ABC):
         return bool(self.architecture.computational_resonators)
 
     def get_real_target(self) -> Target:
-        """Return the real physical target of the backend without virtual CZ gates."""
+        """Return the real physical target of the backend without fictional CZ gates."""
         return IQMTarget(
             architecture=self.architecture,
             component_to_idx=self._qb_to_idx,
             include_resonators=True,
-            include_fake_czs=False,
+            include_fictional_czs=False,
+            metrics=self.metrics,
         )
 
     def qubit_name_to_index(self, name: str) -> int:
@@ -135,211 +156,3 @@ class IQMBackendBase(BackendV2, ABC):
     def get_scheduling_stage_plugin(self) -> str:
         """Return the plugin that should be used for scheduling the circuits on this backend."""
         return "iqm_default_scheduling"
-
-    def restrict_to_qubits(
-        self,
-        qubits: list[int] | list[str],
-        include_resonators: bool = False,
-        include_fake_czs: bool = True,
-    ) -> IQMTarget:
-        """Generated a restricted transpilation target from this backend that only contains the given qubits.
-
-        Args:
-            qubits: Qubits to restrict the target to. Can be either a list of qubit indices or qubit names.
-            include_resonators: Whether to restrict `self.target` or `self.target_with_resonators`.
-            include_fake_czs: Whether to include virtual CZs that are unsupported, but could be routed via MOVE.
-
-        Returns:
-            restricted target
-
-        """
-        qubits_str = [self._idx_to_qb[q] if isinstance(q, int) else str(q) for q in qubits]
-        return _restrict_dqa_to_qubits(self.architecture, qubits_str, include_resonators, include_fake_czs)
-
-
-def _restrict_dqa_to_qubits(
-    architecture: DynamicQuantumArchitecture,
-    qubits: list[str],
-    include_resonators: bool,
-    include_fake_czs: bool = True,
-) -> IQMTarget:
-    """Generated a restricted transpilation target from this backend that only contains the given qubits.
-
-    Args:
-        architecture: The dynamic quantum architecture to restrict.
-        qubits: Qubits to restrict the target to. Can be either a list of qubit indices or qubit names.
-        include_resonators: Whether to include MOVE gates in the target.
-        include_fake_czs: Whether to include virtual CZs that are not natively supported, but could be routed via MOVE.
-
-    Returns:
-        restricted target
-
-    """
-    new_gates = {}
-    for gate_name, gate_info in architecture.gates.items():
-        new_implementations = {}
-        for (
-            implementation_name,
-            implementation_info,
-        ) in gate_info.implementations.items():
-            new_loci = tuple(locus for locus in implementation_info.loci if all(q in qubits for q in locus))
-            if new_loci:
-                new_implementations[implementation_name] = GateImplementationInfo(loci=new_loci)
-        if new_implementations:
-            new_gates[gate_name] = GateInfo(
-                implementations=new_implementations,
-                default_implementation=gate_info.default_implementation,
-                override_default_implementation=gate_info.override_default_implementation,
-            )
-    new_arch = DynamicQuantumArchitecture(
-        calibration_set_id=architecture.calibration_set_id,
-        qubits=[q for q in qubits if q in architecture.qubits],
-        computational_resonators=[q for q in qubits if q in architecture.computational_resonators],
-        gates=new_gates,
-    )
-    return IQMTarget(
-        new_arch,
-        component_to_idx={name: idx for idx, name in enumerate(qubits)},
-        include_resonators=include_resonators,
-        include_fake_czs=include_fake_czs,
-    )
-
-
-class IQMTarget(Target):
-    """Transpilation target for an IQM architecture.
-
-    Contains the mapping of physical qubit name on the device to qubit index in the Target.
-
-    Args:
-        architecture: Quantum architecture that defines the target.
-        component_to_idx: Mapping from QPU component names to integer indices used by Qiskit to refer to them.
-        include_resonators: Whether to include MOVE gates in the target.
-        include_fake_czs: Whether to include virtual CZs that are not natively supported, but could be routed via MOVE.
-
-    """
-
-    def __init__(
-        self,
-        architecture: DynamicQuantumArchitecture,
-        component_to_idx: dict[str, int],
-        include_resonators: bool,
-        include_fake_czs: bool = True,
-    ):
-        super().__init__()
-        # Using iqm as a prefix to avoid name clashes with the base class.
-        self.iqm_dqa = architecture
-        self.iqm_component_to_idx = component_to_idx
-        self.iqm_idx_to_component = {v: k for k, v in component_to_idx.items()}
-        self.iqm_includes_resonators = include_resonators
-        self.iqm_includes_fake_czs = include_fake_czs
-        self._add_connections_from_DQA()
-
-    def _add_connections_from_DQA(self):
-        """Initializes the Target, making it represent the dynamic quantum architecture :attr:`iqm_dqa`."""
-        # mapping from op name to all its allowed loci
-        architecture = self.iqm_dqa
-        component_to_idx = self.iqm_component_to_idx
-        op_loci = {gate_name: gate_info.loci for gate_name, gate_info in architecture.gates.items()}
-
-        def locus_to_idx(locus: Locus) -> LocusIdx:
-            """Map the given locus to use component indices instead of component names."""
-            return tuple(component_to_idx[component] for component in locus)
-
-        def create_properties(name: str, *, symmetrize: bool = False) -> dict[tuple[int, ...], None]:
-            """Creates the Qiskit instruction properties dictionary for the given IQM native operation.
-
-            Currently we do not provide any actual properties for the operation, hence the all the
-            allowed loci map to None.
-            """
-            if self.iqm_includes_resonators:
-                loci = op_loci[name]
-            else:
-                # Remove the loci that correspond to resonators.
-                loci = [
-                    locus for locus in op_loci[name] if all(component in self.iqm_dqa.qubits for component in locus)
-                ]
-            if symmetrize:
-                # symmetrize the loci
-                loci = tuple(permuted_locus for locus in loci for permuted_locus in itertools.permutations(locus))
-            return {locus_to_idx(locus): None for locus in loci}
-
-        # like barrier, delay is always available for all single-qubit loci
-        self.add_instruction(Delay(0), {locus_to_idx((q,)): None for q in architecture.qubits})
-
-        if "measure" in op_loci:
-            self.add_instruction(Measure(), create_properties("measure"))
-
-        # identity gate does nothing and is removed in serialization, so we may as well allow it everywhere
-        # Except if it is defined for the resonator, the graph is disconnected and the transpiler will fail.
-        if self.iqm_includes_resonators:
-            self.add_instruction(
-                IGate(),
-                {locus_to_idx((component,)): None for component in architecture.components},
-            )
-        else:
-            self.add_instruction(
-                IGate(),
-                {locus_to_idx((component,)): None for component in architecture.qubits},
-            )
-
-        if "prx" in op_loci:
-            self.add_instruction(
-                RGate(Parameter("theta"), Parameter("phi")),
-                create_properties("prx"),
-            )
-
-        # HACK reset gate shares cc_prx loci for now
-        if "cc_prx" in op_loci:
-            self.add_instruction(Reset(), create_properties("cc_prx"))
-
-        if self.iqm_includes_resonators and "move" in op_loci:
-            self.add_instruction(MoveGate(), create_properties("move"))
-
-        if "cz" in op_loci:
-            if self.iqm_includes_fake_czs and "move" in op_loci:
-                # CZ and MOVE: star
-                cz_connections: dict[LocusIdx, None] = {}
-                cz_loci = op_loci["cz"]
-                for c1, c2 in cz_loci:
-                    if self.iqm_includes_resonators or all(component in self.iqm_dqa.qubits for component in (c1, c2)):
-                        idx_locus = locus_to_idx((c1, c2))
-                        cz_connections[idx_locus] = None
-
-                for c1, res in op_loci["move"]:
-                    for c2 in architecture.qubits:
-                        if c2 not in [c1, res]:
-                            # loop over c2 that is not c1
-                            if (c2, res) in cz_loci or (res, c2) in cz_loci:
-                                # This is a fake CZ and can be bidirectional.
-                                # cz routable via res between qubits, put into fake_cz_conn both ways
-                                idx_locus = locus_to_idx((c1, c2))
-                                cz_connections[idx_locus] = None
-                                cz_connections[idx_locus[::-1]] = None
-                self.add_instruction(CZGate(), cz_connections)
-            else:
-                # CZ but no MOVE: crystal
-                self.add_instruction(CZGate(), create_properties("cz"))
-
-    @property
-    def physical_qubits(self) -> list[str]:
-        """Return the ordered list of physical qubits in the backend."""
-        # Overrides the property from the superclass to contain the correct information.
-        return [self.iqm_idx_to_component[i] for i in range(self.num_qubits)]
-
-    def restrict_to_qubits(self, qubits: list[int] | list[str]) -> IQMTarget:
-        """Generated a restricted transpilation target from this Target that only contains the given qubits.
-
-        Args:
-            qubits: Qubits to restrict the target to. Can be either a list of qubit indices or qubit names.
-
-        Returns:
-            restricted target
-
-        """
-        qubits_str = [self.iqm_idx_to_component[q] if isinstance(q, int) else str(q) for q in qubits]
-        return _restrict_dqa_to_qubits(
-            self.iqm_dqa,
-            qubits_str,
-            self.iqm_includes_resonators,
-            self.iqm_includes_fake_czs,
-        )

iqm/qiskit_iqm/iqm_move_layout.py

@@ -11,12 +11,10 @@
 # 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.
-"""Generate an initial layout for a quantum circuit that is
-valid on the quantum architecture specification of the given backend.
-"""
+"""Generate an initial layout for a quantum circuit containing MOVE gates."""
 
 from iqm.iqm_client import DynamicQuantumArchitecture
-from iqm.qiskit_iqm.iqm_backend import IQMBackendBase, IQMTarget
+from iqm.qiskit_iqm.iqm_backend import IQMTarget
 from qiskit import QuantumCircuit
 from qiskit.circuit import Qubit
 from qiskit.dagcircuit import DAGCircuit
@@ -228,26 +226,20 @@ class IQMMoveLayout(TrivialLayout):
 
 
 def generate_initial_layout(
-    backend: IQMBackendBase,
+    target: IQMTarget,
     circuit: QuantumCircuit,
-    restrict_to_qubits: list[int] | list[str] | None = None,
 ) -> Layout:
-    """Generates an initial layout for the given circuit, when run against the given backend.
+    """Generate an initial layout for the given circuit, for running on the given Star architecture target.
 
     Args:
-        backend: IQM backend to run against.
-        circuit: Star architecture circuit for which a layout is to be generated.
-        restrict_to_qubits: Optional list of qubits to restrict the layout to.
+        target: IQM Star architecture target to run the circuit on, without fictional gates.
+        circuit: Quantum circuit for which a layout is to be generated.
 
     Returns:
-        Layout that maps the logical qubits of ``circuit`` to the physical qubits of ``backend`` so that
+        Layout that maps the virtual/logical qubits of ``circuit`` to the physical qubits of ``target`` so that
         all the gates in ``circuit`` are available on those loci.
 
     """
-    target = backend.get_real_target()
-    if restrict_to_qubits is not None:
-        target = target.restrict_to_qubits(restrict_to_qubits)
-
     layout_gen = IQMMoveLayout(target)
     pm = PassManager(layout_gen)
     pm.run(circuit)

iqm/qiskit_iqm/iqm_naive_move_pass.py

@@ -200,7 +200,7 @@ def _get_scheduling_method(
 def transpile_to_IQM(  # noqa: PLR0913
     circuit: QuantumCircuit,
     backend: IQMBackendBase,
-    target: IQMTarget | None = None,
+    *,
     initial_layout: Layout | dict | list | None = None,
     perform_move_routing: bool = True,
     optimize_single_qubits: bool = True,
@@ -214,16 +214,14 @@ def transpile_to_IQM(  # noqa: PLR0913
 
     Works with both the Crystal and Star architectures.
 
-    Note: When transpiling a circuit with MOVE gates, you might need to set the `optimization_level` lower.
-    If the `optimization_level` is set too high, the transpiler might add single qubit gates onto the resonator,
+    Note: When transpiling a circuit with MOVE gates, you might need to set ``optimization_level`` lower.
+    If ``optimization_level`` is set too high, the transpiler might add single qubit gates onto the resonator,
     which is not supported by the IQM Star architectures. If this in undesired, it is best to have the transpiler
     add the MOVE gates automatically, rather than manually adding them to the circuit.
 
     Args:
-        circuit: The circuit to be transpiled without MOVE gates.
-        backend: The target backend to compile to. Does not require a resonator.
-        target: An alternative target to compile to than the backend, using this option requires intimate knowledge
-            of the transpiler and thus it is not recommended to use.
+        circuit: The circuit to transpile.
+        backend: The backend to transpile to.
         initial_layout: The initial layout to use for the transpilation, same as :func:`~qiskit.compiler.transpile`.
         perform_move_routing: Whether to perform MOVE gate routing.
         optimize_single_qubits: Whether to optimize single qubit gates away.
@@ -233,30 +231,35 @@ def transpile_to_IQM(  # noqa: PLR0913
         existing_moves_handling: How to handle existing MOVE gates in the circuit, required if the circuit contains
             MOVE gates.
         restrict_to_qubits: Restrict the transpilation to only use these specific physical qubits. Note that you will
-            have to pass this information to the ``backend.run`` method as well as a dictionary.
+            also have to pass this information to :meth:`.IQMBackend.run` using the ``qubit_mapping`` parameter.
         qiskit_transpiler_kwargs: Arguments to be passed to the Qiskit transpiler.
 
     Returns:
         Transpiled circuit ready for running on the backend.
 
     """
-    if restrict_to_qubits is not None:
-        restrict_to_qubits = [backend.qubit_name_to_index(q) if isinstance(q, str) else q for q in restrict_to_qubits]
-
-    if target is None:
-        if circuit.count_ops().get("move", 0) > 0 or circuit.num_qubits > backend.num_qubits:
-            target = backend.target_with_resonators
-            # Create a sensible initial layout if none is provided
-            if initial_layout is None:
-                initial_layout = generate_initial_layout(backend, circuit, restrict_to_qubits)
-            if perform_move_routing and existing_moves_handling is None:
-                raise ValueError("The circuit contains MOVE gates but existing_moves_handling is not set.")
-        else:
-            target = backend.target
+    circuit_has_moves = circuit.count_ops().get("move", 0) > 0
+    # get the target from the backend
+    if circuit_has_moves:
+        target = backend.target_with_resonators
+        if perform_move_routing and existing_moves_handling is None:
+            raise ValueError("The circuit contains MOVE gates but existing_moves_handling is not set.")
+    else:
+        target = backend.target
 
     if restrict_to_qubits is not None:
+        # qubit names to qiskit indices
+        restrict_to_qubits = [backend.qubit_name_to_index(q) if isinstance(q, str) else q for q in restrict_to_qubits]
         target = target.restrict_to_qubits(restrict_to_qubits)
 
+    if circuit_has_moves and initial_layout is None:
+        # Create a sensible initial layout if none is provided, since
+        # the standard Qiskit transpile function does not do this well with resonators.
+        real_target = backend.get_real_target()
+        if restrict_to_qubits is not None:
+            real_target = real_target.restrict_to_qubits(restrict_to_qubits)
+        initial_layout = generate_initial_layout(real_target, circuit)
+
     # Determine which scheduling method to use
     scheduling_method = qiskit_transpiler_kwargs.pop("scheduling_method", None)
     if scheduling_method is None:

iqm/qiskit_iqm/iqm_provider.py

@@ -30,7 +30,7 @@ from iqm.iqm_client import (
     RunRequest,
 )
 from iqm.iqm_client.util import to_json_dict
-from iqm.qiskit_iqm import IQMFakeAphrodite, IQMFakeApollo, IQMFakeDeneb
+from iqm.qiskit_iqm import IQMFakeAphrodite, IQMFakeApollo, IQMFakeBackend, IQMFakeDeneb
 from iqm.qiskit_iqm.fake_backends import IQMFakeAdonis
 from iqm.qiskit_iqm.fake_backends.fake_garnet import IQMFakeGarnet
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
@@ -51,20 +51,31 @@ 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
             calibration set.
-        kwargs: optional arguments to be passed to the parent Backend initializer
+        use_metrics: Iff True, the backend will query the server for calibration data and related
+            quality metrics, and pass these to the transpilation target(s).
+        kwargs: Optional arguments to be passed to the parent Backend initializer.
 
     """
 
-    def __init__(self, client: IQMClient, *, calibration_set_id: str | UUID | None = None, **kwargs):
+    def __init__(
+        self,
+        client: IQMClient,
+        *,
+        calibration_set_id: str | UUID | None = None,
+        use_metrics: bool = True,
+        **kwargs,
+    ):
         if calibration_set_id is not None and not isinstance(calibration_set_id, UUID):
             calibration_set_id = UUID(calibration_set_id)
+
         self._use_default_calibration_set = calibration_set_id is None
         architecture = client.get_dynamic_quantum_architecture(calibration_set_id)
-        super().__init__(architecture, **kwargs)
+        metrics = client._get_calibration_quality_metrics(architecture.calibration_set_id) if use_metrics else None
+        super().__init__(architecture, metrics=metrics, **kwargs)
         self.client: IQMClient = client
         self._max_circuits: int | None = None
         self.name = "IQM Backend"
@@ -266,10 +277,10 @@ class IQMBackend(IQMBackendBase):
         return Circuit(name=circuit.name, instructions=instructions, metadata=metadata)
 
 
-facade_names = {
+facade_names: dict[str, IQMFakeBackend] = {
     "facade_adonis": IQMFakeAdonis(),
-    "facade_aphrodite": IQMFakeAphrodite(),
     "facade_apollo": IQMFakeApollo(),
+    "facade_aphrodite": IQMFakeAphrodite(),
     "facade_deneb": IQMFakeDeneb(),
     "facade_garnet": IQMFakeGarnet(),
 }
@@ -280,17 +291,38 @@ class IQMFacadeBackend(IQMBackend):
 
     Can be used to submit a circuit to a mock IQM server that has no real quantum hardware,
     and if the mock execution is successful, simulates the circuit locally using an error model that
-    is representative of the mocked QPU. Finally returns the simulated results.
+    is broadly representative of the mocked QPU. Finally returns the *simulated results*.
+
+    .. note::
+
+       There is usually no point in using a facade backend with a real quantum computer, since the computation
+       results will be replaced with a local simulation.
 
     Args:
         client: Client instance for communicating with an IQM server.
-        **kwargs: Optional arguments to be passed to the parent class.
+        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.
 
     """
 
-    def __init__(self, client: IQMClient, **kwargs):
+    def __init__(self, client: IQMClient, *, name: str | None = None, **kwargs):
         super().__init__(client, **kwargs)
-        self.backend = self._determine_facade_backend_from_sqa()
+        sqa = self.client.get_static_quantum_architecture()
+        if name is None:
+            # use a fake backend (local simulator) that matches the server
+            for backend in facade_names.values():
+                if backend.validate_compatible_architecture(sqa):
+                    self._fake_backend = backend
+                    return
+            raise ValueError("Quantum architecture of the server does not match any known IQMFakeBackend.")
+        else:
+            if name not in facade_names:
+                raise ValueError(f"Unknown facade backend: {name}")
+            backend = facade_names[name]
+            if not backend.validate_compatible_architecture(sqa):
+                raise ValueError("Quantum architecture of the server does not match the requested IQMFakeBackend.")
+            self._fake_backend = backend
 
     def _validate_no_empty_cregs(self, circuit: QuantumCircuit) -> bool:
         """Returns True if given circuit has no empty (unused) classical registers, False otherwise."""
@@ -303,26 +335,20 @@ class IQMFacadeBackend(IQMBackend):
             return False
         return True
 
-    def _determine_facade_backend_from_sqa(self) -> IQMFacadeBackend:
-        for backend in facade_names.values():
-            if backend.validate_compatible_architecture(self.client.get_static_quantum_architecture()):
-                return backend
-        raise ValueError("Quantum architecture of the remote quantum computer does not match facade input.")
-
     def run(self, run_input: QuantumCircuit | list[QuantumCircuit], **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):
             raise ValueError(
-                "One or more circuits contain unused classical registers. This is not allowed for Facade simulation, "
-                "see user guide."
+                "One or more circuits contain unused classical registers. This is not allowed for facade simulation, "
+                "see the user guide."
             )
 
         iqm_backend_job = super().run(run_input, **options)
         iqm_backend_job.result()  # get and discard results
         if iqm_backend_job.status() == JobStatus.ERROR:
             raise RuntimeError("Remote execution did not succeed.")
-        return self.backend.run(run_input, **options)
+        return self._fake_backend.run(run_input, **options)
 
 
 class IQMProvider:
@@ -334,7 +360,7 @@ class IQMProvider:
     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://cocos.resonance.meetiqm.com/garnet")
 
     """
 
@@ -343,24 +369,28 @@ class IQMProvider:
         self.user_auth_args = user_auth_args
 
     def get_backend(
-        self, name: str | None = None, calibration_set_id: UUID | None = None
-    ) -> IQMBackend | IQMFacadeBackend:
-        """An IQMBackend instance associated with this provider.
+        self,
+        name: str | None = None,
+        calibration_set_id: UUID | None = None,
+        *,
+        use_metrics: bool = True,
+    ) -> IQMBackend:
+        """IQMBackend instance associated with this provider.
 
         Args:
-            name: optional name of a custom facade backend
-            calibration_set_id: ID of the calibration set used to create the transpilation target of the backend.
+            name: Optional name of a facade backend to request, see :class:`IQMFacadeBackend`.
+            calibration_set_id: ID of the calibration set to be used with the backend.
+                Affects both the transpilation target and the circuit execution.
                 If None, the server default calibration set will be used.
+            use_metrics: Iff True, the backend will provide calibration data and related quality metrics
+                to the transpilation target to improve the transpilation.
+
+        Returns:
+            Backend instance for connecting to a quantum computer.
 
         """
         client = IQMClient(self.url, **self.user_auth_args)
 
         if name and name.startswith("facade_"):
-            if name in facade_names:
-                if not facade_names[name].validate_compatible_architecture(client.get_static_quantum_architecture()):
-                    raise ValueError("Quantum architecture of the remote quantum computer does not match facade input.")
-                return IQMFacadeBackend(client)
-
-            warnings.warn(f"Unknown facade backend: {name}. A regular backend associated with {self.url} will be used.")
-
-        return IQMBackend(client, calibration_set_id=calibration_set_id)
+            return IQMFacadeBackend(client, name=name, calibration_set_id=calibration_set_id, use_metrics=use_metrics)
+        return IQMBackend(client, calibration_set_id=calibration_set_id, use_metrics=use_metrics)

iqm/qiskit_iqm/iqm_target.py

@@ -0,0 +1,372 @@
+# Copyright 2022-2025 Qiskit on IQM 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.
+"""Transpilation target for IQM quantum computers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+import logging
+from typing import TypeAlias
+
+from iqm.iqm_client import (
+    DynamicQuantumArchitecture,
+    GateImplementationInfo,
+    GateInfo,
+    ObservationFinder,
+)
+from iqm.qiskit_iqm.move_gate import MoveGate
+from qiskit.circuit import Delay, Gate, Parameter, Reset
+from qiskit.circuit.library import CZGate, IGate, Measure, RGate
+from qiskit.providers import QubitProperties
+from qiskit.transpiler import InstructionProperties, Target
+
+Locus: TypeAlias = tuple[str, ...]
+"""Sequence of QPU component names on which a gate acts."""
+LocusIdx: TypeAlias = tuple[int, ...]
+"""Sequence of qubit indices on which a gate acts."""
+
+
+_QISKIT_IQM_GATE_MAP: dict[str, Gate] = {
+    "prx": RGate(Parameter("theta"), Parameter("phi")),
+    "measure": Measure(),
+    "reset": Reset(),
+    "cz": CZGate(),
+    "move": MoveGate(),
+    "id": IGate(),
+}
+"""Maps IQM native operation names to corresponding Qiskit gate objects."""
+
+logger = logging.getLogger(__name__)
+
+
+class IQMTarget(Target):
+    """Transpilation target for an IQM architecture.
+
+    Contains the mapping of physical qubit name on the device to qubit index in the Target.
+
+    Args:
+        architecture: Quantum architecture that defines the target.
+        component_to_idx: Mapping from QPU component names to integer indices used by Qiskit to refer to them.
+        include_resonators: Whether to include computational resonators (and MOVE gates) in the target,
+            if present in ``architecture``.
+        include_fictional_czs: Whether to include "fictional" CZs that are not natively supported,
+            but could be routed using MOVE.
+        metrics: Optional calibration data and related quality metrics to improve the transpilation.
+
+    """
+
+    def __init__(
+        self,
+        *,
+        architecture: DynamicQuantumArchitecture,
+        component_to_idx: dict[str, int],
+        include_resonators: bool,
+        include_fictional_czs: bool,
+        metrics: ObservationFinder | None = None,
+    ):
+        super().__init__()
+        # HACK: As of Qiskit 1.3, Target.__init__ does nothing with its args, instead Target.__new__
+        # handles them.  IQMTarget.__init__ has different args than Target.__init__, hence we must either
+        # (1) define IQMTarget.__new__ with matching args that calls Target.__new__, or
+        # (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).
+        self.qubit_properties = self._create_qubit_properties(architecture.qubits, metrics)
+
+        # Using iqm_ as a prefix to avoid name clashes with the base class.
+        self.iqm_dqa = architecture
+        self.iqm_component_to_idx = component_to_idx
+        self.iqm_idx_to_component = {v: k for k, v in component_to_idx.items()}
+        self.iqm_include_resonators = include_resonators
+        self.iqm_include_fictional_czs = include_fictional_czs
+        self.iqm_metrics = metrics
+        self._add_instructions_from_DQA()
+
+    def _add_instructions_from_DQA(self):
+        """Initializes the Target with instructions and properties that represent the
+        dynamic quantum architecture :attr:`iqm_dqa`.
+
+        """
+        dqa = self.iqm_dqa
+        # mapping from op name to all its allowed loci
+        op_loci = {gate_name: gate_info.loci for gate_name, gate_info in dqa.gates.items()}
+
+        def add_gate(gate: str) -> None:
+            """Adds ``gate`` instructions to the Target."""
+            props = {self.locus_to_idx(locus): self._create_gate_properties(gate, locus) for locus in op_loci[gate]}
+            self.add_instruction(_QISKIT_IQM_GATE_MAP[gate], props)
+
+        # identity gate does nothing and is removed in serialization, so we may as well allow it everywhere
+        # Except if it is defined for the resonator, the graph is disconnected and the transpiler will fail.
+        self.add_instruction(
+            IGate(),
+            {
+                self.locus_to_idx((component,)): None
+                for component in (dqa.components if self.iqm_include_resonators else dqa.qubits)
+            },
+        )
+
+        # like barrier, delay is always available for all single-qubit loci
+        self.add_instruction(Delay(0), {self.locus_to_idx((q,)): None for q in dqa.qubits})
+
+        if "measure" in op_loci:
+            add_gate("measure")
+
+        if "prx" in op_loci:
+            add_gate("prx")
+
+        # HACK reset gate shares cc_prx loci for now, until reset is also in the DQA/metrics
+        if "cc_prx" in op_loci:
+            self.add_instruction(
+                _QISKIT_IQM_GATE_MAP["reset"],
+                {self.locus_to_idx(locus): None for locus in op_loci["cc_prx"]},
+            )
+
+        if self.iqm_include_resonators and "move" in op_loci:
+            add_gate("move")
+
+        if "cz" in op_loci:
+            self._add_instructions_cz_gates(op_loci)
+
+    def _add_instructions_cz_gates(self, op_loci: dict[str, Iterable[Locus]]) -> None:
+        """Adds CZ gate instructions to the Qiskit Target.
+
+        This method handles both "real" and "fictional" CZ gates based on the
+        provided operation loci.
+
+        1.  **Real CZ Gates**:
+            A CZ gate for a locus is considered "real" if the locus
+            exists in ``dynamic_quantum_architecture.gates['cz']``.
+            A "real" CZ instruction is added if either the target is configured to
+            include resonators (:attr:`iqm_include_resonators` is True) or if all
+            the locus components are qubits.
+
+        2.  **Fictional CZ Gates**: For STAR QPU architectures, a "fictional" CZ between
+            two qubits that are not physically connected is defined
+            iff there is a CZ gate from one qubit to a resonator, and a MOVE gate
+            from the other qubit to the resonator.
+            See :mod:`iqm.iqm_client.transpile`.
+
+        Args:
+            op_loci: Mapping of operation names (e.g., "cz", "move") to their available loci.
+
+        """
+        cz_props: dict[LocusIdx, InstructionProperties] = {}
+        cz_loci = op_loci["cz"]
+
+        # 1. Add real CZs
+        for locus in cz_loci:
+            if self.iqm_include_resonators or all(component in self.iqm_dqa.qubits for component in locus):
+                locus_idx = self.locus_to_idx(locus)  # convert locus from IQM to Qiskit format
+                cz_props[locus_idx] = self._create_gate_properties("cz", locus)
+
+        # 2. Add fictional CZs if applicable
+        if self.iqm_include_fictional_czs and "move" in op_loci:
+            fictional_cz_loci = self._determine_fictional_cz_loci(op_loci["move"], cz_loci)
+            for q1, q2, res in fictional_cz_loci:
+                locus_idx = self.locus_to_idx((q1, q2))
+                props = self._create_fictional_cz_properties(q1, q2, res)
+                cz_props[locus_idx] = props
+                cz_props[locus_idx[::-1]] = props  # fictional CZs are symmetric
+                # TODO: if the fictional CZ can be implemented using both CZ(a,r) and MOVE(b,r), and
+                # CZ(b,r) and MOVE(a,r), props will be only included for one implementation at random.
+                # This is not necessarily the implementation the transpiler chooses!
+
+        if cz_props:
+            self.add_instruction(_QISKIT_IQM_GATE_MAP["cz"], cz_props)
+
+    def _create_fictional_cz_properties(self, q1: str, q2: str, res: str) -> InstructionProperties:
+        """Create ``InstructionProperties`` for a fictional CZ gate.
+
+        A fictional CZ gate is comprised of the sequence MOVE(q2, res), CZ(q1, res), MOVE(q2, res).
+
+        The duration and error for the fictional CZ gate are calculated as follows:
+
+        - Duration: 2 * duration_move(q2, res) + duration_cz(q1, res)
+        - Error: 1 - (1 - error_move(q2, res)))^2 * (1 - error_cz(q1, res))
+
+        See https://arxiv.org/pdf/2503.10903 for more details.
+
+        Args:
+            q1: CZ qubit.
+            q2: MOVE qubit.
+            res: Shared computational resonator through which the fictional CZ gate is routed.
+
+        Returns:
+            Instruction properties for the fictional CZ gate.
+
+        """
+        if self.iqm_metrics is None:
+            return None
+
+        props_cz = self._create_gate_properties("cz", (q1, res))
+        props_move = self._create_gate_properties("move", (q2, res))
+
+        if props_cz is None or props_move is None:
+            return None
+
+        duration = None
+        if props_move.duration is not None and props_cz.duration is not None:
+            duration = 2 * props_move.duration + props_cz.duration
+
+        error: float | None = None
+        if props_move.error is not None and props_cz.error is not None:
+            error = 1 - (1 - props_move.error) ** 2 * (1 - props_cz.error)
+
+        return InstructionProperties(duration=duration, error=error)
+
+    @staticmethod
+    def _determine_fictional_cz_loci(move_loci: Iterable[Locus], cz_loci: Iterable[Locus]) -> list[Locus]:
+        """Determine fictional CZ loci, i.e. pairs of qubits between which we can implement a CZ using MOVE gates and
+        an intermediate computational resonator.
+
+        Only applicable for the Star architecture.
+
+        Args:
+            move_loci: The loci for which a MOVE operation is defined.
+            cz_loci: The loci for which a CZ operation is defined.
+
+        Returns:
+            Loci for fictional CZ gates, *including the resonator*. Each locus is given as ``(q1, q2, res)``.
+
+        """
+        fictional_cz_loci: list[Locus] = []
+        for q1, res1 in cz_loci:
+            for q2, res2 in move_loci:
+                if res1 == res2 and q1 != q2:
+                    # shared resonator, different qubits
+                    fictional_cz_loci.append((q1, q2, res1))
+
+        return fictional_cz_loci
+
+    def locus_to_idx(self, locus: Locus) -> LocusIdx:
+        """Map the given locus to use component indices instead of component names."""
+        return tuple(self.iqm_component_to_idx[component] for component in locus)
+
+    @staticmethod
+    def _create_qubit_properties(
+        qubits: Iterable[str], metrics: ObservationFinder | None
+    ) -> list[QubitProperties] | None:
+        """Creates qubit properties from the quality metrics."""
+        if metrics is None:
+            return None
+
+        qubit_props = []
+        t1_times, t2_times = metrics.get_coherence_times(qubits)
+        for q in qubits:
+            frequency = metrics.get_qubit_frequency(q)
+            qubit_props.append(
+                QubitProperties(
+                    t1=t1_times.get(q),
+                    t2=t2_times.get(q),
+                    frequency=frequency,
+                )
+            )
+        return qubit_props
+
+    def _create_gate_properties(self, gate_name: str, locus: Locus) -> InstructionProperties | None:
+        """Creates InstructionProperties for a single gate on a specific locus.
+
+        Args:
+            gate_name: Name of the IQM native operation to look up properties for (e.g., 'cz' or 'move').
+            locus: Locus of the operation.
+
+        Returns:
+            Properties for the (default implementation of the) given gate at the given locus, or None if not available.
+
+        """
+        if self.iqm_metrics is None:
+            return None
+
+        # the properties are for the default implementation (other implementations may be available also)
+        impl_name = self.iqm_dqa.gates[gate_name].get_default_implementation(locus)
+        duration = self.iqm_metrics.get_gate_duration(gate_name, impl_name, locus)
+        fidelity = self.iqm_metrics.get_gate_fidelity(gate_name, impl_name, locus)
+        return InstructionProperties(duration=duration, error=None if fidelity is None else 1 - fidelity)
+
+    @property
+    def physical_qubits(self) -> list[str]:
+        """Return the ordered list of physical qubits in the target."""
+        # Overrides the property from the superclass to contain the correct information.
+        return [self.iqm_idx_to_component[i] for i in range(self.num_qubits)]
+
+    def restrict_to_qubits(self, qubits: list[int] | list[str]) -> IQMTarget:
+        """Generated a restricted transpilation target from this Target that only contains the given qubits.
+
+        Args:
+            qubits: Qubits to restrict the target to. Can be either a list of qubit indices or qubit names.
+
+        Returns:
+            restricted target
+
+        """
+        qubits_str = [self.iqm_idx_to_component[q] if isinstance(q, int) else str(q) for q in qubits]
+        return _restrict_dqa_to_qubits(
+            self.iqm_dqa,
+            qubits_str,
+            self.iqm_include_resonators,
+            self.iqm_include_fictional_czs,
+            metrics=self.iqm_metrics,
+        )
+
+
+def _restrict_dqa_to_qubits(
+    architecture: DynamicQuantumArchitecture,
+    components: list[str],
+    include_resonators: bool,
+    include_fictional_czs: bool,
+    metrics: ObservationFinder | None = None,
+) -> IQMTarget:
+    """Generated a restricted transpilation target that only contains the given QPU components.
+
+    Args:
+        architecture: The dynamic quantum architecture to restrict.
+        components: QPU components to restrict the target to. Qubits first, then resonators.
+        include_resonators: Whether to include computational resonators (and MOVE gates) in the target.
+        include_fictional_czs: Whether to include fictional CZs that are not natively supported,
+            but could be routed via MOVE.
+        metrics: Optional calibration data and related quality metrics to improve the transpilation.
+
+    Returns:
+        restricted target
+
+    """
+    # include gate loci that only involve the given components
+    c_set = set(components)
+    new_gates = {}
+    for gate_name, gate_info in architecture.gates.items():
+        new_implementations = {}
+        for implementation_name, implementation_info in gate_info.implementations.items():
+            new_loci = tuple(locus for locus in implementation_info.loci if set(locus) <= c_set)
+            if new_loci:
+                new_implementations[implementation_name] = GateImplementationInfo(loci=new_loci)
+        if new_implementations:
+            new_gates[gate_name] = GateInfo(
+                implementations=new_implementations,
+                default_implementation=gate_info.default_implementation,
+                override_default_implementation=gate_info.override_default_implementation,
+            )
+    new_arch = DynamicQuantumArchitecture(
+        calibration_set_id=architecture.calibration_set_id,
+        qubits=[q for q in architecture.qubits if q in c_set],
+        computational_resonators=[r for r in architecture.computational_resonators if r in c_set],
+        gates=new_gates,
+    )
+    return IQMTarget(
+        architecture=new_arch,
+        component_to_idx={name: idx for idx, name in enumerate(components)},
+        include_resonators=include_resonators,
+        include_fictional_czs=include_fictional_czs,
+        metrics=metrics,
+    )

{iqm_client-29.14.0.dist-info → iqm_client-30.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-client
-Version: 29.14.0
+Version: 30.0.0
 Summary: Client library for accessing an IQM quantum computer
 Author-email: IQM Finland Oy <developers@meetiqm.com>
 License: Apache License

{iqm_client-29.14.0.dist-info → iqm_client-30.0.0.dist-info}/RECORD

@@ -21,25 +21,26 @@ iqm/iqm_client/__init__.py,sha256=D-8W54EcQIxk_1JZo_86GYlR1YitHhPIiFwwLJ2IfGE,14
 iqm/iqm_client/api.py,sha256=_c6OVuv2dyzBF7J2XlK_qxisTSPyOiI4gYokZPsuaJY,3083
 iqm/iqm_client/authentication.py,sha256=kHFqPI6w3OAk9k5ioPxi-FrD2EP-vjn8Z_wZYccJVyE,12259
 iqm/iqm_client/errors.py,sha256=ty2P-sg80zlAoL3_kC3PlprgDUv4PI-KFhmmxaaapS0,1429
-iqm/iqm_client/iqm_client.py,sha256=yrrpJlSW4N9TCp5zeokHk2lU8N5guYpU643HCMX5oOI,40994
+iqm/iqm_client/iqm_client.py,sha256=oEeosKvXd_lVreB0r7TwHnYs6AAOjJs1sUDNk-AtzAk,41793
 iqm/iqm_client/models.py,sha256=Sdx_J7wBCM7E_arusU3eC6dQfqu5dpADywr-9JmFvsY,51597
 iqm/iqm_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iqm/iqm_client/transpile.py,sha256=eEv9eY5QG94Lke7Xp6BkQapl1rvlmlVQ_IkQFopPNQ8,36981
-iqm/iqm_client/util.py,sha256=FLRUhhi0YDxomVtilCVPJLixyijFtU10PVefIx-eelw,1516
+iqm/iqm_client/util.py,sha256=hGhl-r9afN3kNOjV9FoheSAPcQiKu7DdwX0FTFXxFl4,1489
 iqm/iqm_client/validation.py,sha256=IKXBxnhLLnEuUCU2J0q6VEYn9k-O9z_MI4ys7mpFZdE,11912
 iqm/iqm_client/cli/__init__.py,sha256=zzLDDz5rc3lJke3OKU8zxR5zQyQoM9oI2bLJ2YKk_zQ,692
-iqm/iqm_client/cli/auth.py,sha256=SCOZ6QHw9l8oE-A1QSYfAKYuqZxkZkYrwaNWzGFY1AU,6363
+iqm/iqm_client/cli/auth.py,sha256=kESEK9-vpEhrjba3Lb6Wqx24yGfbjxUASeCArnVRYrw,6364
 iqm/iqm_client/cli/cli.py,sha256=YhTgOGrvNXPwCdCKHcwLHeE_6C3n91MxFhvgQYT78C4,28633
 iqm/iqm_client/cli/models.py,sha256=Hu-t6c_07Cth3AuQBo0CDTcWVQg1xbJCpy_94V0o64U,1199
-iqm/iqm_client/cli/token_manager.py,sha256=e8M3UihnawxGlajAw5AP6x4TEH5PaCRQ4ADNnRw4wUI,6967
+iqm/iqm_client/cli/token_manager.py,sha256=125uRj8kBzKlWAhQWNf-8n-aDG6fQridVd95qCktzD4,6867
 iqm/qiskit_iqm/__init__.py,sha256=Mv9V_r8ZcmGC8Ke5S8-7yLOx02vjZ1qiVx8mtbOpwnY,1420
-iqm/qiskit_iqm/iqm_backend.py,sha256=WMGBg1jbtTvrmJ7ZrXVixgfb6Hm5qKa-2xi5R8cl0IM,14237
+iqm/qiskit_iqm/iqm_backend.py,sha256=HddizT6yHHq-MOG_U48n6ftE9AqmzaqbXYayEC1ljso,5548
 iqm/qiskit_iqm/iqm_circuit.py,sha256=fFQW8SRlgZjqZUOLfyuJhhXEDp5I1jopFWa1k4rb7ac,1384
 iqm/qiskit_iqm/iqm_circuit_validation.py,sha256=vE5CNyJOQ7OMRpQV-xsO1uf_NNFE8v6-TSzboFSrGYM,1721
 iqm/qiskit_iqm/iqm_job.py,sha256=Q26hk4JuZP48Xw3qVk4b44LrHbgNQp-mq_itF9umkqg,11666
-iqm/qiskit_iqm/iqm_move_layout.py,sha256=pHqV1G4bri3rFEsMBN6FrtQ0FXVNQG-Ymm4v7zdnilQ,10787
-iqm/qiskit_iqm/iqm_naive_move_pass.py,sha256=OQpKiiw-UoNdcjyqJ1Oay9zMsg5IihU-r4ZboXQptkA,12983
-iqm/qiskit_iqm/iqm_provider.py,sha256=5L2-GFbTqMlW7JTagRxl2pV2kw0KKA4hw2YGLYsoUvk,16640
+iqm/qiskit_iqm/iqm_move_layout.py,sha256=vIsuO-RUJF0ZxB7nPhfOJ2vaUt6mZCLZfQGc6PEBwnc,10486
+iqm/qiskit_iqm/iqm_naive_move_pass.py,sha256=jhTfvhrNDKt6NhhJg_3Y-5x6E1HRNzC_n4A27ZQTuvQ,12962
+iqm/qiskit_iqm/iqm_provider.py,sha256=AGXi2Knm035VTNr2lMgSr5oNAuhIHJqEWI6Z5c1L9Y8,17996
+iqm/qiskit_iqm/iqm_target.py,sha256=fj18g2-kvHztCZxcc3tUeoc4XZvhy_EAkn-kD59D8vw,15816
 iqm/qiskit_iqm/iqm_transpilation.py,sha256=2PyDAOukJpvSIVXmuYB8EWhmzlJHBUpzFPbW5VhfApg,9113
 iqm/qiskit_iqm/move_gate.py,sha256=QU9RKKVvbGq33qcIi9AKLcvQVQMibkgW4ibjzk-oVy4,2808
 iqm/qiskit_iqm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,19 +48,19 @@ iqm/qiskit_iqm/qiskit_to_iqm.py,sha256=9JGcR_7K1Y5W6_PBP1bVCZqy7khCOa-BU9m1I9MJB
 iqm/qiskit_iqm/transpiler_plugins.py,sha256=w0TXrAqtMZsPgGC1YcwiLvlBYVKDtpaCi_lnlLjTD2c,8717
 iqm/qiskit_iqm/examples/__init__.py,sha256=M4ElQHCo-WxtVXK39bF3QiFT3IGXPtZ1khqexHiTBEc,20
 iqm/qiskit_iqm/examples/bell_measure.py,sha256=iMZB_MNMf2XP6Eiv2XbhtNs4bXbMGQeMw7ohw2JWKS8,1903
-iqm/qiskit_iqm/examples/resonance_example.py,sha256=wzWOP4oob-Ckl-LR3LXznb_-cA-m7XY9FmU2Ua9nB3c,2861
+iqm/qiskit_iqm/examples/resonance_example.py,sha256=3eyHkmr6ZSLelSosjTSw1MLIOo3ioWhqBGRYXPFYRDA,2970
 iqm/qiskit_iqm/examples/transpile_example.py,sha256=hUxGPD_eLaZFFHAbegcjT9lNq7UAvGCzHfZFnuF6cbE,2099
 iqm/qiskit_iqm/fake_backends/__init__.py,sha256=fkw2UHT-3aJbAKvR1WYUN7_4N5Gdwpx9bm6vlWj1tm0,874
-iqm/qiskit_iqm/fake_backends/fake_adonis.py,sha256=OV66SmtEuA9CV7VpWV1T-U5H5XBtCK2SQJ2UlRwW4CU,2189
+iqm/qiskit_iqm/fake_backends/fake_adonis.py,sha256=g5QQ158vd49_SxzteDip97XMD3d50SJymx_rU7g7lzk,2188
 iqm/qiskit_iqm/fake_backends/fake_aphrodite.py,sha256=3oWZwPmtcsYkYpqVr36-C5K7KtyQGk84RCvZpaL_kLg,15473
 iqm/qiskit_iqm/fake_backends/fake_apollo.py,sha256=eT2vd3kQBi1rrvxCpePymBCfFK84dpwNpqGV_BkltwQ,6563
 iqm/qiskit_iqm/fake_backends/fake_deneb.py,sha256=RzQXmLXmBARDiMKVxk5Aw9fVbc6IYlW0A5jibk9iYD0,3156
 iqm/qiskit_iqm/fake_backends/fake_garnet.py,sha256=GI0xafTCj1Um09qVuccO6GPOGBm6ygul_O40Wu220Ys,5555
 iqm/qiskit_iqm/fake_backends/iqm_fake_backend.py,sha256=wJtfsxjPYbDKmzaz5R4AuaXvvPHa21WyPtRgNctL9eY,16785
-iqm_client-29.14.0.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
-iqm_client-29.14.0.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
-iqm_client-29.14.0.dist-info/METADATA,sha256=jx_pO9VfFL8L9-DiKK4LlE9_QASf0H6LUa9-ze8EC6A,17693
-iqm_client-29.14.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_client-29.14.0.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
-iqm_client-29.14.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_client-29.14.0.dist-info/RECORD,,
+iqm_client-30.0.0.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
+iqm_client-30.0.0.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
+iqm_client-30.0.0.dist-info/METADATA,sha256=u9RkPSf_wx9QF8i5xPHP6KGq_V7uvP5KWfi2serE9q4,17692
+iqm_client-30.0.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_client-30.0.0.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
+iqm_client-30.0.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_client-30.0.0.dist-info/RECORD,,