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

iqm/cirq_iqm/devices/iqm_device_metadata.py

@@ -20,9 +20,10 @@ from collections.abc import Iterable
 import cirq
 from cirq import Gate, NamedQid, devices, ops
 from iqm.cirq_iqm.serialize import _IQM_CIRQ_OP_MAP
-from iqm.iqm_client import DynamicQuantumArchitecture
 import networkx as nx
 
+from iqm.station_control.interface.models import DynamicQuantumArchitecture
+
 
 @cirq.value.value_equality
 class IQMDeviceMetadata(devices.DeviceMetadata):

iqm/cirq_iqm/examples/demo_common.py

@@ -138,7 +138,7 @@ def simulate_without_measurements(
     return state
 
 
-def pause() -> None:
+def pause() -> None:  # noqa: D103
     input("\npress enter\n")
 
 

iqm/cirq_iqm/examples/demo_iqm_execution.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 """Demonstrates executing a quantum circuit on an IQM quantum computer.
 
-Set the STATION_CONTROL_URL environment variable before running this script.
+Set the IQM_SERVER_URL environment variable before running this script.
 Also, if the server you are running against requires authentication you will also have to use
 the IQM_TOKENS_FILE or the IQM_TOKEN variable to set the access token.
 
 E.g.
 
-    export STATION_CONTROL_URL="https://example.com/station"
+    export IQM_SERVER_URL="https://example.com"
     export IQM_TOKENS_FILE="/path/to/my/tokens.json"
     export IQM_TOKEN="<token here>"
 """
@@ -45,7 +45,7 @@ def demo_run_circuit() -> None:
     print("Original circuit:\n")
     print(circuit)
 
-    sampler = IQMSampler(os.environ["STATION_CONTROL_URL"])
+    sampler = IQMSampler(os.environ["IQM_SERVER_URL"])
 
     circuit_routed, _, _ = sampler.device.route_circuit(circuit)
     circuit_decomposed = sampler.device.decompose_circuit(circuit_routed)

iqm/cirq_iqm/iqm_sampler.py

@@ -25,20 +25,29 @@ import warnings
 import cirq
 from iqm.cirq_iqm.devices.iqm_device import IQMDevice, IQMDeviceMetadata
 from iqm.cirq_iqm.serialize import serialize_circuit
-from iqm.iqm_client import CircuitBatch, CircuitCompilationOptions, IQMClient, JobAbortionError, RunRequest
+from iqm.iqm_client import APITimeoutError, CircuitCompilationOptions, CircuitExecutionError, IQMClient
+from iqm.iqm_server_client.models import JobStatus
 import numpy as np
 
+from exa.common.errors.station_control_errors import StationControlError
+from iqm.station_control.interface.models import CircuitBatch, RunRequest
+
 
 class IQMSampler(cirq.work.Sampler):
     """Circuit sampler for executing quantum circuits on IQM quantum computers.
 
-    IQMSampler connects to a quantum computer through an IQM server.
+    IQMSampler 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 IQMSampler. 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. Has to start with http or https.
+        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.
+        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.
         device: Device to execute the circuits on. If ``None``, the device will be created based
             on the calibration-specific dynamic quantum architecture obtained from
             :class:`~iqm.iqm_client.iqm_client.IQMClient`.
@@ -54,17 +63,20 @@ class IQMSampler(cirq.work.Sampler):
         self,
         url: str,
         *,
+        quantum_computer: str | None = None,
         device: IQMDevice | None = None,
         calibration_set_id: UUID | None = None,
-        run_sweep_timeout: int | None = None,
+        run_sweep_timeout: float | None = None,
         compiler_options: CircuitCompilationOptions | None = None,
+        use_timeslot: bool = False,
         **user_auth_args,  # contains keyword args token or tokens_file
     ):
-        self._client = IQMClient(url, **user_auth_args)
+        self._client = IQMClient(url, quantum_computer=quantum_computer, **user_auth_args)
         dqa = self._client.get_dynamic_quantum_architecture(calibration_set_id)
         server_device_metadata = IQMDeviceMetadata.from_architecture(dqa)
         self._use_default_calibration_set = calibration_set_id is None
         self._calibration_set_id = dqa.calibration_set_id
+        self._use_timeslot = use_timeslot
         if device is None:
             self._device = IQMDevice(server_device_metadata)
         else:
@@ -85,13 +97,6 @@ class IQMSampler(cirq.work.Sampler):
         """Returns the device used by the sampler."""
         return self._device
 
-    def close_client(self):  # noqa: ANN201
-        """Close IQMClient's session with the user authentication server. Discard the client."""
-        if not self._client:
-            return
-        self._client.close_auth_session()
-        self._client = None
-
     def run_sweep(  # type: ignore[override]
         self, program: cirq.Circuit, params: cirq.Sweepable, repetitions: int = 1
     ) -> list[IQMResult]:
@@ -122,7 +127,6 @@ class IQMSampler(cirq.work.Sampler):
             ValueError: circuits are not valid for execution
             CircuitExecutionError: something went wrong on the server
             APITimeoutError: server did not return the results in the allocated time
-            RuntimeError: IQM client session has been closed
 
         """
         results, metadata = self._send_circuits(
@@ -153,9 +157,6 @@ class IQMSampler(cirq.work.Sampler):
 
         serialized_circuits: CircuitBatch = [serialize_circuit(circuit) for circuit in programs]
 
-        if not self._client:
-            raise RuntimeError("Cannot submit circuits since session to IQM client has been closed.")
-
         different_calset_ids = set()
         for circuit in programs:
             if hasattr(circuit, "iqm_calibration_set_id"):
@@ -192,7 +193,7 @@ class IQMSampler(cirq.work.Sampler):
     ) -> tuple[list[dict[str, np.ndarray]], ResultMetadata]:
         """Sends a batch of circuits to be executed and retrieves the results.
 
-        If a user interrupts the program while it is waiting for results, attempts to abort the submitted job.
+        If a user interrupts the program while it is waiting for results, attempts to cancel the submitted job.
 
         Args:
             circuits: quantum circuits to execute
@@ -201,29 +202,46 @@ class IQMSampler(cirq.work.Sampler):
         Returns:
             circuit execution results, result metadata
 
+        Raises:
+            CircuitExecutionError: something went wrong on the server
+            APITimeoutError: server did not return the results in the allocated time
+
         """
         run_request = self.create_run_request(circuits, repetitions=repetitions)
-        job_id = self._client.submit_run_request(run_request)
-
-        timeout_arg = [self._run_sweep_timeout] if self._run_sweep_timeout is not None else []
+        job = self._client.submit_run_request(run_request, use_timeslot=self._use_timeslot)
 
         try:
-            results = self._client.wait_for_results(job_id, *timeout_arg)
-
+            if self._run_sweep_timeout is not None:
+                status = job.wait_for_completion(timeout_secs=self._run_sweep_timeout)
+            else:
+                status = job.wait_for_completion()
         except KeyboardInterrupt:
+            # user pressed Ctrl-C before the job finished
             try:
-                self._client.abort_job(job_id)
-            except JobAbortionError as e:
-                warnings.warn(f"Failed to abort job: {e}")
+                job.cancel()
+            except StationControlError as e:
+                warnings.warn(f"Failed to cancel job: {e}")
             finally:
                 sys.exit()
 
-        if results.measurements is None:
-            raise RuntimeError("No measurements returned from IQM quantum computer.")
+        if status not in JobStatus.terminal_statuses():
+            # cancel jobs which did not complete in time
+            # FIXME this is bad UX, we should return a job object instead so the user can decide if they want to cancel
+            job.cancel()
+            raise APITimeoutError(f"Job {job.job_id} didn't finish in the given time. Cancelled.")
+
+        if status != JobStatus.COMPLETED:
+            raise CircuitExecutionError(f"Job {job.job_id} did not finish successfully: {status}: {job._errors}")
+
+        result = job.result()
+        if result is None:
+            raise RuntimeError("No measurements received from IQM Server.")
 
         return (
-            [{k: np.array(v) for k, v in measurements.items()} for measurements in results.measurements],
-            ResultMetadata(job_id, results.metadata.calibration_set_id, run_request),
+            [{k: np.array(v) for k, v in measurements.items()} for measurements in result],
+            ResultMetadata(
+                job.job_id, job.data.compilation.calibration_set_id if job.data.compilation else None, run_request
+            ),
         )
 
     @staticmethod

iqm/cirq_iqm/serialize.py

@@ -90,7 +90,7 @@ def circuit_operation_to_operation(circuit_operation: CircuitOperation) -> Opera
 
 
 class OperationNotSupportedError(RuntimeError):
-    """Raised when a given operation is not supported by the IQM server."""
+    """Raised when a given operation is not supported by the IQM Server."""
 
 
 def operation_to_circuit_operation(operation: Operation) -> CircuitOperation:

iqm/cirq_iqm/transpiler.py

@@ -21,6 +21,8 @@ from cirq import Circuit
 from iqm.cirq_iqm.serialize import deserialize_circuit, serialize_circuit
 from iqm.iqm_client import ExistingMoveHandlingOptions, transpile_insert_moves
 
+from iqm.station_control.interface.models import QubitMapping
+
 if TYPE_CHECKING:
     from iqm.cirq_iqm.devices import IQMDevice
 
@@ -29,7 +31,7 @@ def transpile_insert_moves_into_circuit(
     cirq_circuit: Circuit,
     device: IQMDevice,
     existing_moves: ExistingMoveHandlingOptions = ExistingMoveHandlingOptions.KEEP,
-    qubit_mapping: dict[str, str] | None = None,
+    qubit_mapping: QubitMapping | None = None,
 ) -> Circuit:
     """Transpile the circuit to insert MOVE gates where needed.
 

iqm/iqm_client/__init__.py

@@ -17,8 +17,6 @@ from importlib.metadata import PackageNotFoundError, version
 import sys
 import warnings
 
-from iqm.iqm_client.api import *  # noqa: F403
-from iqm.iqm_client.authentication import *  # noqa: F403
 from iqm.iqm_client.errors import *  # noqa: F403
 from iqm.iqm_client.iqm_client import *  # noqa: F403
 from iqm.iqm_client.models import *  # noqa: F403

iqm/iqm_client/errors.py

@@ -14,14 +14,6 @@
 """This module contains error classes required by IQMClient."""
 
 
-class ClientAuthenticationError(RuntimeError):
-    """Something went wrong with user authentication."""
-
-
-class ClientConfigurationError(RuntimeError):
-    """Wrong configuration provided."""
-
-
 class CircuitValidationError(RuntimeError):
     """Circuit validation failed."""
 
@@ -31,16 +23,13 @@ class CircuitTranspilationError(RuntimeError):
 
 
 class CircuitExecutionError(RuntimeError):
-    """Something went wrong on the server."""
+    """Something went wrong on the server.
+
+    Should be used in sync calls that must return valid circuit execution results.
+    Async calls may instead return a job object that indicates the
+    excution did not succeed without raising anything.
+    """
 
 
 class APITimeoutError(CircuitExecutionError):
     """Executing a job on the server took too long."""
-
-
-class JobAbortionError(RuntimeError):
-    """Job abortion failed."""
-
-
-class EndpointRequestError(RuntimeError):
-    """Retrieving something from a server endpoint failed because we did not understand the response."""