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

iqm/qiskit_iqm/iqm_job.py

@@ -17,79 +17,85 @@ from __future__ import annotations
 
 from collections import Counter
 from datetime import date
-from typing import TYPE_CHECKING
-import uuid
+from typing import TYPE_CHECKING, Any
 import warnings
 
 from iqm.iqm_client import (
     DEFAULT_TIMEOUT_SECONDS,
-    APITimeoutError,
+    CircuitBatch,
+    CircuitJob,
     CircuitMeasurementResults,
-    HeraldingMode,
-    IQMClient,
-    JobAbortionError,
-    RunRequest,
-    RunResult,
-    Status,
+    CircuitMeasurementResultsBatch,
 )
+from iqm.iqm_client import (
+    JobStatus as IQMJobStatus,
+)
+from iqm.iqm_client.errors import APITimeoutError
 from iqm.qiskit_iqm.qiskit_to_iqm import MeasurementKey
 import numpy as np
 from qiskit.providers import JobStatus, JobV1
 from qiskit.result import Counts, Result
 
+from exa.common.errors.station_control_errors import StationControlError
 from iqm.pulse import Circuit
+from iqm.station_control.interface.models import HeraldingMode
 
 if TYPE_CHECKING:
     from iqm.qiskit_iqm.iqm_provider import IQMBackend
 
 
 class IQMJob(JobV1):
-    """Implementation of Qiskit's job interface to handle circuit execution on an IQM server.
+    """Implementation of Qiskit's job interface to handle circuit execution on an IQM Server.
 
     Args:
         backend: Backend instance initiating this job.
-        job_id: String representation of the UUID generated by IQM server.
+        job: Circuit execution job generated by IQM Server.
         kwargs: Arguments to be passed to the initializer of the parent class.
 
     """
 
-    def __init__(self, backend: IQMBackend, job_id: str, **kwargs):
-        super().__init__(backend, job_id=job_id, **kwargs)
-        self._result: None | list[tuple[str, list[str]]] = None
-        self._calibration_set_id: uuid.UUID | None = None
-        self._request: RunRequest | None = None
-        self._client: IQMClient = backend.client
+    def __init__(self, backend: IQMBackend, job: CircuitJob, **kwargs):
+        super().__init__(backend, job_id=str(job.job_id))
+        # kwargs go into self.metadata, Qiskit doesn't currently do anything with it
+        self._iqm_job = job
+        self._iqm_result: None | list[tuple[str, list[str], Counts]] = None
         self.circuit_metadata: list | None = None  # Metadata that was originally associated with circuits by user
 
-    def _format_iqm_results(self, iqm_result: RunResult) -> list[tuple[str, list[str]]]:
+    @staticmethod
+    def _iqm_format_results(
+        iqm_results_batch: CircuitMeasurementResultsBatch,
+        circuits: CircuitBatch,
+        requested_shots: int,
+        expect_exact_shots: bool,
+    ) -> list[tuple[str, list[str], Counts]]:
         """Convert the measurement results for a batch of circuits into the Qiskit format.
 
         Args:
-            iqm_result: measurement results for the circuit batch
+            iqm_results_batch: measurement results for the circuit batch
+            circuits: circuits that were executed
+            requested_shots: number of shots requested
+            expect_exact_shots: iff True, we must get exactly as many shots as requested
         Returns:
-            A list of (circuit_name, measurements) tuples, one tuple for each circuit in the batch.
-            The measurements are a list of bitstrings, one per shot, representing the state of the classical
+            ``(circuit_name, measurements, counts)`` tuples, one tuple for each circuit in the batch.
+            ``measurements`` are a list of bitstrings, one per shot, representing the state of the classical
             registers after the shot.
 
         """
-        if iqm_result.measurements is None:
-            raise ValueError(
-                f'Cannot format IQM result without measurements. Job status is "{iqm_result.status.value.upper()}"'
-            )
-        requested_shots = self.metadata.get("shots", iqm_result.metadata.shots)
-        # If no heralding, for all circuits we expect the same number of shots which is the shots requested by user.
-        expect_exact_shots = iqm_result.metadata.heralding_mode == HeraldingMode.NONE
-
+        qiskit_measurement_results_batch = [
+            IQMJob._iqm_format_measurement_results(measurement_results, requested_shots, expect_exact_shots)
+            for measurement_results in iqm_results_batch
+        ]
         return [
             (
                 circuit.name if isinstance(circuit, Circuit) else f"circuit_{i}",
-                self._format_measurement_results(measurements, requested_shots, expect_exact_shots),
+                qiskit_measurement_results,
+                Counts(Counter(qiskit_measurement_results)),
             )
-            for i, (measurements, circuit) in enumerate(zip(iqm_result.measurements, iqm_result.metadata.circuits))
+            for i, (qiskit_measurement_results, circuit) in enumerate(zip(qiskit_measurement_results_batch, circuits))
         ]
 
     @staticmethod
-    def _format_measurement_results(
+    def _iqm_format_measurement_results(
         measurement_results: CircuitMeasurementResults, requested_shots: int, expect_exact_shots: bool = True
     ) -> list[str]:
         """Convert the measurement results from a circuit into the Qiskit format.
@@ -156,93 +162,104 @@ class IQMJob(JobV1):
 
         """
         try:
-            self._client.abort_job(uuid.UUID(self._job_id))
+            self._iqm_job.cancel()
             return True
-        except JobAbortionError as e:
+        except StationControlError as e:
             warnings.warn(f"Failed to cancel job: {e}")
             return False
 
     def result(self, *, timeout: float = DEFAULT_TIMEOUT_SECONDS, cancel_after_timeout: bool = False) -> Result:
-        """Retrieve results within defined timeout.
+        """Retrieve job result within defined timeout.
 
         Args:
-            timeout: Time limit for client to get result, in seconds.
+            timeout: Time limit for the job to finish, in seconds.
             cancel_after_timeout: Whether client will try to cancel the job if timeout exceeded.
 
         Returns:
-            Result if retrieved successfully.
+            Result if job finished within ``timeout``.
 
         Raises:
             APITimeoutError: Waiting for results exceeded timeout.
-            JobAbortionError: Job failed to abort after timeout exceeded and cancellation requested.
 
         """
-        if not self._result:
-            # Client will raise an error if it was unable to get the results within the timeout
-            try:
-                results = self._client.wait_for_results(uuid.UUID(self._job_id), timeout)
-            except APITimeoutError as err:
-                # Cancel the job if client was unable to get the results within the timeout
+        job = self._iqm_job
+        # TODO we might want to cache these
+        circuits, job_parameters = job.payload()
+        if job.status not in IQMJobStatus.terminal_statuses():
+            # wait for job to finish and cache the result
+            status = job.wait_for_completion(timeout_secs=timeout)
+            if status not in IQMJobStatus.terminal_statuses():
+                msg = f"The job {job.job_id} didn't finish in {timeout} seconds."
                 if cancel_after_timeout:
-                    try:
-                        self._client.abort_job(uuid.UUID(self._job_id))
-                    except JobAbortionError as e:
-                        raise JobAbortionError("Failed to cancel job.") from e
-                    raise APITimeoutError("Job cancelled successfully.") from err
-                raise
-            self._calibration_set_id = results.metadata.calibration_set_id
-            self._request = results.metadata.request
-            if results.metadata.timestamps is not None:
-                self.metadata["timestamps"] = results.metadata.timestamps.copy()
-            self._result = self._format_iqm_results(results)
-            # IQMBackend.run() populates IQMJob.circuit_metadata, so it may be None if this IQMJob
-            # was created manually from a job_id. In that case retrieve circuit metadata from
-            # RunResult.metadata.request.circuits[n].metadata
-            if self.circuit_metadata is None and results.metadata.request is not None:
-                self.circuit_metadata = [
-                    c.metadata if isinstance(c, Circuit) else {} for c in results.metadata.circuits
-                ]
-
-        result_dict = {
-            "backend_name": None,
-            "backend_version": None,
-            "qobj_id": None,
-            "job_id": self._job_id,
-            "success": True,
-            "results": [
+                    # Cancel the job if client was unable to get the results within the timeout
+                    job.cancel()
+                    msg += " Cancelled."
+                raise APITimeoutError(msg)
+
+            # retrieve the results if job completed successfully
+            if status == IQMJobStatus.COMPLETED and (result_batch := job.result()) is not None:
+                # now job has up-to-date information
+                # IQMBackend.run() populates IQMJob.circuit_metadata, so it may be None if this IQMJob
+                # was created manually from a job_id. In that case retrieve circuit metadata from
+                # the job payload which we just retrieved.
+                if self.circuit_metadata is None:
+                    self.circuit_metadata = [c.metadata if isinstance(c, Circuit) else {} for c in circuits]
+
+                # If no heralding, for all circuits we expect the same number of shots which is the
+                # shots requested by user.
+                self._iqm_result = self._iqm_format_results(
+                    result_batch,
+                    circuits,
+                    job_parameters.shots,
+                    job_parameters.heralding_mode == HeraldingMode.NONE,
+                )
+
+        # job has reached a terminal status, which means we can return a Result
+        result_dict: dict[str, Any] = {
+            "backend_name": self.backend().name,
+            "backend_version": "",
+            "qobj_id": "",
+            "job_id": str(job.job_id),
+            "success": False,
+            "date": date.today().isoformat(),
+            "results": [],
+            # the ones below go into result._metadata
+            "circuits": circuits,
+            "parameters": job_parameters,
+            "timeline": job.data.timeline.copy(),
+        }
+        if self._iqm_result:
+            result_dict["success"] = True  # job is successful iff it is IQMJobStatus.COMPLETED (and we got result data)
+            result_dict["results"] = [
                 {
                     "shots": len(measurement_results),
                     "success": True,
                     "data": {
                         "memory": measurement_results,
-                        "counts": Counts(Counter(measurement_results)),
+                        "counts": counts,
                         "metadata": self.circuit_metadata[i] if self.circuit_metadata is not None else {},
                     },
                     "header": {"name": name},
-                    "calibration_set_id": self._calibration_set_id,
+                    "calibration_set_id": job.data.compilation.calibration_set_id if job.data.compilation else None,
                 }
-                for i, (name, measurement_results) in enumerate(self._result)
-            ],
-            "date": date.today().isoformat(),
-            "request": self._request,
-            "timestamps": self.metadata.get("timestamps"),
-        }
+                for i, (name, measurement_results, counts) in enumerate(self._iqm_result)
+            ]
         return Result.from_dict(result_dict)
 
     def status(self) -> JobStatus:
-        if self._result:
-            return JobStatus.DONE
+        job = self._iqm_job
+        # terminal statuses need not be updated, they're terminal
+        status = job.status if job.status in IQMJobStatus.terminal_statuses() else job.update()
 
-        result = self._client.get_run_status(uuid.UUID(self._job_id))
-        if result.status == Status.PENDING_EXECUTION:
-            return JobStatus.RUNNING
-        if result.status == Status.READY:
+        if status == IQMJobStatus.COMPLETED:
             return JobStatus.DONE
-        if result.status in {Status.FAILED, Status.DELETION_FAILED}:
+        if status == IQMJobStatus.FAILED:
             return JobStatus.ERROR
-        if result.status in {Status.ABORTED, Status.DELETED}:
+        if status == IQMJobStatus.CANCELLED:
             return JobStatus.CANCELLED
-        # For everything else, we assume that it's in progress one way or another
+        if status == IQMJobStatus.PROCESSING:
+            return JobStatus.RUNNING
+        # IQMJobStatus.WAITING
         return JobStatus.QUEUED
 
     def queue_position(self, refresh: bool = False) -> int | None:
@@ -264,4 +281,5 @@ class IQMJob(JobV1):
 
     def error_message(self) -> str | None:
         """Returns the error message if job has failed, otherwise returns None."""
-        return self._client.get_run_status(uuid.UUID(self._job_id)).message
+        self._iqm_job.update()
+        return self._iqm_job._errors or None

iqm/qiskit_iqm/iqm_move_layout.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 """Generate an initial layout for a quantum circuit containing MOVE gates."""
 
-from iqm.iqm_client import DynamicQuantumArchitecture
 from iqm.qiskit_iqm.iqm_backend import IQMTarget
 from qiskit import QuantumCircuit
 from qiskit.circuit import Qubit
@@ -22,6 +21,8 @@ from qiskit.transpiler import PassManager, TranspilerError
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.passes import TrivialLayout
 
+from iqm.station_control.interface.models import DynamicQuantumArchitecture
+
 
 class IQMMoveLayout(TrivialLayout):
     """Create a layout that is valid on the dynamic quantum architecture of the

iqm/qiskit_iqm/iqm_naive_move_pass.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 """Naive transpilation for the IQM Star architecture."""
 
+from typing import Any
 import warnings
 
-from iqm.iqm_client import Circuit as IQMClientCircuit
 from iqm.iqm_client.transpile import ExistingMoveHandlingOptions, transpile_insert_moves
 import numpy as np
 from pydantic_core import ValidationError
@@ -26,6 +26,8 @@ from qiskit.dagcircuit import DAGCircuit
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.layout import Layout
 
+from iqm.pulse import Circuit
+
 from .iqm_backend import IQMBackendBase, IQMTarget
 from .iqm_move_layout import generate_initial_layout
 from .qiskit_to_iqm import deserialize_instructions, serialize_instructions
@@ -34,9 +36,9 @@ from .qiskit_to_iqm import deserialize_instructions, serialize_instructions
 class IQMNaiveResonatorMoving(TransformationPass):
     """Naive transpilation pass for resonator moving.
 
-    The logic of this pass is deferred to `iqm-client.transpile_insert_moves`.
-    This pass is a wrapper that converts the circuit into the IQMClient Circuit format,
-    runs the `transpile_insert_moves` function, and then converts the result back to a Qiskit circuit.
+    The logic of this pass is deferred to :func:`~iqm.iqm_client.transpile.transpile_insert_moves`.
+    This pass is a wrapper that converts the circuit into the IQM circuit format,
+    runs the ``transpile_insert_moves`` function, and then converts the result back to a Qiskit circuit.
 
     Args:
         target: Transpilation target.
@@ -60,13 +62,53 @@ class IQMNaiveResonatorMoving(TransformationPass):
         """Run the pass on a circuit.
 
         Args:
-            dag: DAG to map.
+            dag: DAG to insert MOVE gates into.
 
         Returns:
-            Mapped ``dag``.
+            The new ``dag`` now including MOVE gates as needed.
 
         Raises:
-            TranspilerError: The layout is not compatible with the DAG, or if the input gate set is incorrect.
+            TranspilerError: The layout is not compatible with the DAG, or if something goes wrong during transpilation.
+
+        """
+        if len(dag.op_nodes()) == 0:
+            return dag  # Empty circuit, no need to transpile.
+        symbolic_gates = self._remove_parameterized_gates(dag)
+        layout = self._calculate_initial_layout(dag)
+        new_dag = self._insert_move_gate(dag, layout)
+        self._insert_parameterized_gates(new_dag, symbolic_gates)
+        self.property_set["final_layout"] = self._calculate_final_layout(dag, layout)
+        return new_dag
+
+    def _calculate_initial_layout(self, dag: DAGCircuit) -> Layout:
+        """Calculate the initial physical to logical qubit layout before the circuit.
+
+        Args:
+            dag: The transpiled DAGCircuit.
+
+        Returns:
+            The initial layout of which logical qubits are in which physical qubits at the start of the circuit.
+
+        """
+        # For some reason, the dag does not always contain the layout, so we need to do a bunch of fixing.
+        if self.property_set.get("layout"):
+            return self.property_set["layout"]
+        # Reconstruct the layout from the dag.
+        layout = Layout()
+        for qreg in dag.qregs:
+            layout.add_register(qreg)
+        for i, qubit in enumerate(dag.qubits):
+            layout.add(qubit, i)
+        return layout
+
+    def _remove_parameterized_gates(self, dag: DAGCircuit) -> dict[float, tuple[Any, ...]]:
+        """Remove parameterized gates from the DAGCircuit.
+
+        Args:
+            dag: The input DAGCircuit, which is changed in place.
+
+        Returns:
+            A mapping from symbolic index to the original gate parameters.
 
         """
         # TODO: Temporary hack to get the symbolic parameters to work: replace symbols with (inf, idx).
@@ -80,81 +122,98 @@ class IQMNaiveResonatorMoving(TransformationPass):
                 symbolic_gates[symbolic_index] = node.op.params
                 dag.substitute_node(node, RGate(np.inf, float(symbolic_index)))
                 symbolic_index += 1
+        return symbolic_gates
+
+    def _insert_parameterized_gates(self, dag: DAGCircuit, symbolic_gates: dict[float, tuple[Any, ...]]) -> None:
+        """Reinsert parameterized gates into the DAGCircuit.
+
+        Args:
+            dag: The input DAGCircuit, which is changed in place.
+            symbolic_gates: A mapping from symbolic index to the original gate parameters.
 
+        """
+        for node in dag.topological_op_nodes():
+            # This only works for prx gates because that has two parameters
+            # We use one to mark that it is a symbolic gate (np.inf) and the other to store the index.
+            if node.name == "r" and not np.isfinite(node.op.params[0]):
+                dag.substitute_node(node, RGate(*symbolic_gates[int(np.round(node.op.params[1]))]))
+
+    def _calculate_final_layout(self, dag: DAGCircuit, layout: Layout) -> Layout:
+        """Calculate the final physical to logical qubit layout after the circuit.
+        The original final layout from the previous passes uses the old qubit registers that are no longer valid.
+
+        Args:
+            dag: The original DAGCircuit without the inserted MOVE gates..
+            layout: The initial physical to logical qubit layout at the start of the circuit.
+
+        Returns:
+            The updated layout of which logical qubits are in which physical qubits at the end of the circuit.
+
+        """
+        if "final_layout" not in self.property_set or self.property_set["final_layout"] is None:
+            # If the final layout is not set, return the initial layout.
+            return layout
+        # This final layout only has a single QuantumRegister where the qubits might be swapped.
+        inv_layout = layout.get_physical_bits()
+        old_final_layout = self.property_set["final_layout"]
+        # Swap the physical bits to the new layout
+        to_swap = {
+            physical: dag.find_bit(virtual).index for physical, virtual in old_final_layout.get_physical_bits().items()
+        }
+        # Add identity mappings for qubits that are not in the old final layout.
+        to_swap.update({p: p for p in inv_layout if p not in to_swap})
+        # Build the new final layout.
+        return Layout({physical: inv_layout[to_swap[physical]] for physical in layout.get_physical_bits()})
+
+    def _insert_move_gate(self, dag: DAGCircuit, layout: Layout) -> DAGCircuit:
+        """Insert MOVE gates into the circuit using the IQM transpiler.
+
+        Args:
+            dag: The DAGCircuit to insert MOVE gates into; is not modified in place.
+            layout: The physical to logical qubit layout at the start of the circuit.
+
+        Returns:
+            The updated DAGCircuit with MOVE gates inserted.
+
+        """
+        # Convert the DAG to a QuantumCircuit
         circuit = dag_to_circuit(dag)
-        if len(circuit) == 0:
-            return dag  # Empty circuit, no need to transpile.
-        # For some reason, the dag does not contain the layout, so we need to do a bunch of fixing.
-        if self.property_set.get("layout"):
-            layout = self.property_set["layout"]
-        else:
-            # Reconstruct the layout from the dag.
-            layout = Layout()
-            for qreg in dag.qregs:
-                layout.add_register(qreg)
-            for i, qubit in enumerate(dag.qubits):
-                layout.add(qubit, i)
-
-        # Convert the circuit to the IQMClientCircuit format and run the transpiler.
-        iqm_circuit = IQMClientCircuit(
+        # Convert the circuit to the Circuit format
+        iqm_circuit = Circuit(
             name="Transpiling Circuit",
             instructions=tuple(serialize_instructions(circuit, self.idx_to_component, overwrite_layout=layout)),
             metadata=None,
         )
         try:
+            # Use the iqm-client transpiler to insert MOVE gates
             routed_iqm_circuit = transpile_insert_moves(
                 iqm_circuit,
                 self.architecture,
                 existing_moves=self.existing_moves_handling,
             )
+            # Turn the routed Circuit back into a Qiskit QuantumCircuit
             routed_circuit = deserialize_instructions(
                 list(routed_iqm_circuit.instructions), self.component_to_idx, layout
             )
-        except ValidationError as e:  # The Circuit without move gates is empty.
+        except ValidationError as e:
             errors = e.errors()
             if (
                 len(errors) == 1
                 and errors[0]["msg"] == "Value error, Each circuit should have at least one instruction."
-            ):
-                circ_args = [circuit.num_ancillas, circuit.num_clbits]
-                routed_circuit = QuantumCircuit(*layout.get_registers(), *(arg for arg in circ_args if arg > 0))
+            ):  # Error because the Circuit without move gates is empty.
+                routed_circuit = QuantumCircuit(
+                    *layout.get_registers(), *(arg for arg in [circuit.num_ancillas, circuit.num_clbits] if arg > 0)
+                )
             else:
                 raise e
 
         # Create the new DAG and make sure that the qubits are properly ordered.
-        ordered_qubits = [layout.get_physical_bits()[i] for i in range(len(layout.get_physical_bits()))]
-        new_dag = circuit_to_dag(
+        return circuit_to_dag(
             routed_circuit,
-            qubit_order=ordered_qubits,
+            qubit_order=[layout.get_physical_bits()[i] for i in range(len(layout.get_physical_bits()))],
             clbit_order=routed_circuit.clbits,
         )
 
-        # Reinsert the symbolic parameters.
-        for node in new_dag.topological_op_nodes():
-            # This only works for prx gates because that has two parameters
-            # We use one to mark that it is a symbolic gate (np.inf) and the other to store the index.
-            if node.name == "r" and not np.isfinite(node.op.params[0]):
-                new_dag.substitute_node(node, RGate(*symbolic_gates[int(np.round(node.op.params[1]))]))
-
-        # Update the final_layout with the correct bits.
-        if "final_layout" in self.property_set:
-            inv_layout = layout.get_physical_bits()
-            new_final_layout_dict = {
-                physical: inv_layout[dag.find_bit(virtual).index]
-                for physical, virtual in self.property_set["final_layout"].get_physical_bits().items()
-            }
-            resonator_dict = {
-                phys: inv_layout[new_dag.find_bit(virt).index]
-                for phys, virt in inv_layout.items()
-                if phys not in self.property_set["final_layout"].get_physical_bits()
-            }
-            new_final_layout_dict.update(resonator_dict)
-            self.property_set["final_layout"] = Layout(new_final_layout_dict)
-        else:
-            self.property_set["final_layout"] = layout
-
-        return new_dag
-
 
 def _get_scheduling_method(
     perform_move_routing: bool,