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

iqm/iqm_server_client/models.py

@@ -0,0 +1,179 @@
+# Copyright 2025 IQM client developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Data models used by IQMServerClient."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from enum import StrEnum
+from typing import Literal, TypeAlias
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from iqm.station_control.interface.models import ObservationSetWithObservations
+from iqm.station_control.interface.pydantic_base import PydanticBase
+
+CalibrationSet: TypeAlias = ObservationSetWithObservations
+QualityMetricSet: TypeAlias = ObservationSetWithObservations
+
+
+# Keep 'str' for potential new sources
+Source: TypeAlias = Literal["iqm-server", "iqm-station-control"] | str
+"""Type indicating the source of a particular job-related object from the server."""
+
+
+class QuantumComputer(PydanticBase):
+    """Quantum computer attributes."""
+
+    id: UUID
+    """Unique ID of the quantum computer."""
+    alias: str
+    """Quantum computer alias that can be used as a substitute for id in API calls."""
+
+
+class ListQuantumComputersResponse(PydanticBase):
+    """Response of GET /v1/quantum-computers"""
+
+    quantum_computers: list[QuantumComputer]
+    """List of available quantum computers."""
+
+
+class ProgressInfo(PydanticBase):
+    """Progress information about completing an arbitrary task.
+
+    Used e.g. for tracking job completion.
+    """
+
+    value: int
+    """Current progress indicator value."""
+    max_value: int
+    """When we hit this, the task is done."""
+
+
+class JobExecution(PydanticBase):
+    """Progress information about job execution."""
+
+    progress: dict[str, ProgressInfo]
+    """Mapping from label to its progress information (value, max_value)."""
+
+
+class JobCompilation(PydanticBase):
+    """Progress information about job compilation."""
+
+    calibration_set_id: UUID | None = None
+    """ID of the calibration set used by the compiler."""
+
+
+class JobMessage(PydanticBase):
+    """Message log for a job."""
+
+    source: Source
+    """Source of the message."""
+    message: str
+    """Content of the message."""
+
+    def __str__(self) -> str:
+        """Prettyprinting."""
+        return f"{self.source}: {self.message}"
+
+
+class JobError(PydanticBase):
+    """Error log for a job."""
+
+    source: Source
+    """Source of the error."""
+    message: str
+    """Verbose error message."""
+    error_code: str | None = None
+    """Short error code classifying the error category."""
+
+    def __str__(self) -> str:
+        """Prettyprinting."""
+        return f"{self.source}: {self.error_code}: {self.message}"
+
+
+class TimelineEntry(BaseModel):
+    """Timeline entry for a job."""
+
+    source: Source
+    """Source of the timeline entry."""
+    status: str
+    """Name of the execution step that was reached."""
+    timestamp: datetime
+    """Time at which ``status`` was reached."""
+
+
+class JobStatus(StrEnum):
+    """Job statuses in IQMServer."""
+
+    WAITING = "waiting"
+    """Job is in a queue, waiting to be executed."""
+    PROCESSING = "processing"
+    """Job is being executed."""
+    COMPLETED = "completed"
+    """Job has completed successfully."""
+    FAILED = "failed"
+    """Job has failed."""
+    CANCELLED = "cancelled"
+    """Job has been cancelled by the user or the admin."""
+
+    @classmethod
+    def terminal_statuses(cls) -> frozenset[JobStatus]:
+        """Statuses from which the execution can't continue."""
+        return frozenset({cls.COMPLETED, cls.FAILED, cls.CANCELLED})
+
+
+# Note: there is another, related JobData class for StationControlClient
+class JobData(PydanticBase):
+    """Status, artifacts and metadata of a job."""
+
+    id: UUID
+    """Unique ID of the job."""
+    status: JobStatus
+    """Current job status."""
+    execution: JobExecution | None = None
+    """Execution information for the job."""
+    compilation: JobCompilation | None = None
+    """Compilation information for the job."""
+    messages: list[JobMessage] = Field(default=[])
+    """Informational messages for the job."""
+    errors: list[JobError] = Field(default=[])
+    """Errors for a failed job."""
+    queue_position: int | None = None
+    """Iff the status is JobStatus.WAITING, the number of jobs ahead of this job in the queue.
+    Otherwise None."""
+    timeline: list[TimelineEntry] = Field(default=[])
+    """Server-side statuses reached by the job so far. May include statuses from several services."""
+
+    def find_timeline_entry(
+        self,
+        *,
+        status: str,
+        source: Source | None = None,
+    ) -> TimelineEntry | None:
+        """Search the timeline for an entry matching the given criteria.
+
+        Args:
+            status: Status of the searched timeline entry.
+            source: Source of the searched timeline entry. If None, accepts any source.
+
+        Returns:
+            The first matching entry or ``None`` if the job timeline does not have any matching entries.
+
+        """
+        for timeline_entry in self.timeline:
+            if timeline_entry.status == status and (timeline_entry.source == source or source is None):
+                return timeline_entry
+        return None

iqm/qiskit_iqm/__init__.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """Qiskit adapter for IQM's quantum computers."""
 
+import warnings
+
 from iqm.qiskit_iqm.fake_backends import IQMErrorProfile, IQMFakeAdonis, IQMFakeAphrodite, IQMFakeApollo, IQMFakeDeneb
 from iqm.qiskit_iqm.fake_backends.iqm_fake_backend import IQMFakeBackend
 from iqm.qiskit_iqm.iqm_circuit import IQMCircuit
@@ -23,4 +25,10 @@ from iqm.qiskit_iqm.iqm_provider import IQMBackend, IQMProvider, __version__
 from iqm.qiskit_iqm.iqm_transpilation import IQMOptimizeSingleQubitGates, optimize_single_qubit_gates
 from iqm.qiskit_iqm.move_gate import MoveGate
 from iqm.qiskit_iqm.transpiler_plugins import *  # noqa: F403
+from packaging.version import Version
 from qiskit import __version__ as qiskit_version
+
+if Version(qiskit_version) < Version("2.0.0"):
+    warnings.warn(
+        DeprecationWarning("Support for Qiskit versions < 2.0 is deprecated and will be removed in a future release.")
+    )

iqm/qiskit_iqm/examples/bell_measure.py

@@ -27,7 +27,7 @@ def bell_measure(server_url: str, token: str | None = None, shots: int = 1000) -
     """Execute a quantum circuit that prepares and measures a generalized Bell (aka GHZ) state.
 
     Args:
-        server_url: URL of the IQM server used for execution
+        server_url: URL of the IQM Server used for execution
         token: API token for authentication. If not given, uses :env:`IQM_TOKEN`.
         shots: Requested number of shots.
 
@@ -66,7 +66,7 @@ def bell_measure(server_url: str, token: str | None = None, shots: int = 1000) -
 if __name__ == "__main__":
     argparser = argparse.ArgumentParser()
     argparser.add_argument(
-        "--url", required=True, help='IQM server URL, for example "https://cocos.resonance.meetiqm.com/garnet"'
+        "--url", required=True, help='IQM Server URL, for example "https://cocos.resonance.meetiqm.com/garnet"'
     )
     argparser.add_argument(
         "--token",

iqm/qiskit_iqm/examples/transpile_example.py

@@ -18,15 +18,20 @@ https://docs.meetiqm.com/iqm-client/user_guide_qiskit.html
 
 import argparse
 
-from iqm.qiskit_iqm.iqm_provider import IQMProvider
+from iqm.qiskit_iqm.iqm_provider import IQMBackend, IQMProvider
 from qiskit import QuantumCircuit, transpile
 
 
+def num_connected_qubits(backend: IQMBackend) -> int:
+    """Return the size of the largest connected component of the backend coupling map."""
+    return max(backend.coupling_map.connected_components(), key=lambda cmap: cmap.size()).size()
+
+
 def transpile_example(server_url: str) -> tuple[QuantumCircuit, dict[str, int]]:
     """Run a GHZ circuit transpiled using the Qiskit transpile function.
 
     Args:
-        server_url: URL of the IQM server used for execution
+        server_url: URL of the IQM Server used for execution
 
     Returns:
         transpiled circuit, a mapping of bitstrings representing qubit measurement results to counts for each result
@@ -34,7 +39,7 @@ def transpile_example(server_url: str) -> tuple[QuantumCircuit, dict[str, int]]:
     """
     backend = IQMProvider(server_url).get_backend()
 
-    num_qubits = min(backend.num_qubits, 5)  # use at most 5 qubits
+    num_qubits = min(num_connected_qubits(backend), 5)  # use at most 5 qubits
     circuit = QuantumCircuit(num_qubits)
     circuit.h(0)
     for i in range(1, num_qubits):
@@ -51,7 +56,7 @@ if __name__ == "__main__":
     argparser = argparse.ArgumentParser()
     argparser.add_argument(
         "--url",
-        help="IQM server URL",
+        help="IQM Server URL",
         # For example https://cocos.resonance.meetiqm.com/garnet
         default="https://<IQM SERVER>",
     )

iqm/qiskit_iqm/fake_backends/fake_adonis.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 """Fake backend for IQM's 5-qubit Adonis architecture."""
 
-from iqm.iqm_client import StaticQuantumArchitecture
 from iqm.qiskit_iqm.fake_backends.iqm_fake_backend import IQMErrorProfile, IQMFakeBackend
 
+from iqm.station_control.interface.models import StaticQuantumArchitecture
+
 
 def IQMFakeAdonis() -> IQMFakeBackend:
     """Return IQMFakeBackend instance representing IQM's Adonis architecture."""

iqm/qiskit_iqm/fake_backends/fake_aphrodite.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 """Fake (i.e. simulated) backend for IQM's 54-qubit Aphrodite architecture"""
 
-from iqm.iqm_client import StaticQuantumArchitecture
 from iqm.qiskit_iqm.fake_backends.iqm_fake_backend import IQMErrorProfile, IQMFakeBackend
 
+from iqm.station_control.interface.models import StaticQuantumArchitecture
+
 
 def IQMFakeAphrodite() -> IQMFakeBackend:
     """Return IQMFakeBackend instance representing IQM's Aphrodite architecture."""

iqm/qiskit_iqm/fake_backends/fake_apollo.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 """Fake (i.e. simulated) backend for IQM's 20-qubit Apollo architecture"""
 
-from iqm.iqm_client import StaticQuantumArchitecture
 from iqm.qiskit_iqm.fake_backends.iqm_fake_backend import IQMErrorProfile, IQMFakeBackend
 
+from iqm.station_control.interface.models import StaticQuantumArchitecture
+
 
 def IQMFakeApollo() -> IQMFakeBackend:
     """Return IQMFakeBackend instance representing IQM's Apollo architecture."""

iqm/qiskit_iqm/fake_backends/fake_deneb.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 """Fake backend for IQM's 6-qubit Deneb architecture."""
 
-from iqm.iqm_client import StaticQuantumArchitecture
 from iqm.qiskit_iqm.fake_backends.iqm_fake_backend import IQMErrorProfile, IQMFakeBackend
 
+from iqm.station_control.interface.models import StaticQuantumArchitecture
+
 
 def IQMFakeDeneb() -> IQMFakeBackend:
     """Return IQMFakeBackend instance representing IQM's Deneb architecture."""

iqm/qiskit_iqm/fake_backends/iqm_fake_backend.py

@@ -20,13 +20,6 @@ from dataclasses import dataclass
 from itertools import permutations
 from uuid import UUID
 
-from iqm.iqm_client import (
-    DynamicQuantumArchitecture,
-    GateImplementationInfo,
-    GateInfo,
-    Locus,
-    StaticQuantumArchitecture,
-)
 from iqm.qiskit_iqm.iqm_backend import IQM_TO_QISKIT_GATE_NAME, IQMBackendBase
 from iqm.qiskit_iqm.iqm_circuit_validation import validate_circuit
 from iqm.qiskit_iqm.iqm_transpilation import IQMReplaceGateWithUnitaryPass
@@ -37,6 +30,14 @@ from qiskit_aer import AerSimulator
 from qiskit_aer.noise import NoiseModel, QuantumError
 from qiskit_aer.noise.errors import depolarizing_error, thermal_relaxation_error
 
+from iqm.station_control.interface.models import (
+    DynamicQuantumArchitecture,
+    GateImplementationInfo,
+    GateInfo,
+    Locus,
+    StaticQuantumArchitecture,
+)
+
 
 def _dqa_from_sqa(
     sqa: StaticQuantumArchitecture,

iqm/qiskit_iqm/iqm_backend.py

@@ -19,14 +19,13 @@ from abc import ABC
 import logging
 from typing import Final
 
-from iqm.iqm_client import (
-    DynamicQuantumArchitecture,
-    ObservationFinder,
-)
+from iqm.iqm_client import ObservationFinder
 from iqm.qiskit_iqm.iqm_target import IQMTarget
 from qiskit.providers import BackendV2
 from qiskit.transpiler import Target
 
+from iqm.station_control.interface.models import DynamicQuantumArchitecture
+
 IQM_TO_QISKIT_GATE_NAME: Final[dict[str, str]] = {"prx": "r", "cz": "cz"}
 logger = logging.getLogger(__name__)
 

iqm/qiskit_iqm/iqm_circuit_validation.py

@@ -13,26 +13,27 @@
 # limitations under the License.
 """Helper functions for circuit validation."""
 
-from iqm.iqm_client import Circuit as IQMClientCircuit
-from iqm.iqm_client import MoveGateValidationMode
 from iqm.iqm_client.validation import validate_circuit_instructions
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 from iqm.qiskit_iqm.qiskit_to_iqm import serialize_instructions
 from qiskit import QuantumCircuit
 
+from iqm.pulse import Circuit
+from iqm.station_control.interface.models import MoveGateValidationMode
+
 
 def validate_circuit(  # noqa: ANN201
     circuit: QuantumCircuit,
     backend: IQMBackendBase,
     validate_moves: MoveGateValidationMode | None = None,
-    qubit_mapping: dict[int, str] | None = None,
+    qubit_index_to_name: dict[int, str] | None = None,
 ):
     """Validate a circuit against the backend."""
-    if qubit_mapping is None:
-        qubit_mapping = backend._idx_to_qb
-    new_circuit = IQMClientCircuit(
+    if qubit_index_to_name is None:
+        qubit_index_to_name = backend._idx_to_qb
+    new_circuit = Circuit(
         name="Validation circuit",
-        instructions=tuple(serialize_instructions(circuit=circuit, qubit_index_to_name=qubit_mapping)),
+        instructions=tuple(serialize_instructions(circuit=circuit, qubit_index_to_name=qubit_index_to_name)),
         metadata=None,
     )
     if validate_moves is None: