iqm-pulla 11.17.0__py3-none-any.whl → 12.0.1__py3-none-any.whl

iqm/cpc/compiler/compiler.py

@@ -15,7 +15,7 @@
 
 This is the core module of ``CPC``. It contains the functionality to define a compiler, whose job is to
 convert quantum circuits and calibration data into configuration settings and instruction schedules that
-can be executed by the IQM server on quantum hardware.
+can be executed by the IQM Server on quantum hardware.
 """
 
 from __future__ import annotations
@@ -42,7 +42,7 @@ from iqm.cpc.interface.compiler import (
     MoveGateFrameTrackingMode,
     MoveGateValidationMode,
 )
-from iqm.pulla.interface import CalibrationSet
+from iqm.pulla.interface import CalibrationSetValues
 from iqm.pulla.utils import (
     _update_channel_props_from_calibration,
     build_settings,
@@ -181,13 +181,15 @@ class CompilationStage:
 
 
 class Compiler:
-    """Stateful object that contains a calibration set, a schedule builder, and a set
+    """Compiles quantum circuits (via time boxes) into instruction schedules.
+
+    Stateful object that contains a calibration set, a schedule builder, and a set
     of compilation stages.
 
     The compiler's state does not include the data to be compiled.
 
     Args:
-        calibration_set: Calibration data.
+        calibration_set_values: Calibration data.
         chip_topology: Physical layout and connectivity of the quantum chip.
         channel_properties: Control channel properties for the station.
         component_channels: Mapping from QPU component name to a mapping from ``('drive', 'flux', 'readout')``
@@ -210,7 +212,7 @@ class Compiler:
     def __init__(  # noqa: PLR0913
         self,
         *,
-        calibration_set: CalibrationSet,
+        calibration_set_values: CalibrationSetValues,
         chip_topology: ChipTopology,
         channel_properties: dict[str, ChannelProperties],
         component_channels: dict[str, dict[str, str]],
@@ -220,14 +222,14 @@ class Compiler:
         pp_stages: Collection[CompilationStage] | None = None,
         strict: bool = False,  # consider extending to e.g. errors: Literal["raise", "warning", "ignore"] = "warning"
     ):
-        self._calibration_set = calibration_set
+        self._calibration_set_values = calibration_set_values
         self.component_mapping = component_mapping
         self.options = options
         self.stages = stages or []
         self.pp_stages = pp_stages or []
 
         self.builder: ScheduleBuilder = initialize_schedule_builder(
-            calibration_set, chip_topology, channel_properties, component_channels
+            calibration_set_values, chip_topology, channel_properties, component_channels
         )
         try:
             self.builder.validate_calibration()
@@ -241,11 +243,11 @@ class Compiler:
         Must be called automatically by any method that modifies the calibration set, or the op_table
         """
         _updated_channel_properties = _update_channel_props_from_calibration(
-            self.builder.channels, self.builder.component_channels, self._calibration_set
+            self.builder.channels, self.builder.component_channels, self._calibration_set_values
         )
         self.builder = ScheduleBuilder(
             self.builder.op_table,
-            calset_to_cal_data_tree(self._calibration_set),
+            calset_to_cal_data_tree(self._calibration_set_values),
             self.builder.chip_topology,
             _updated_channel_properties,
             self.builder.component_channels,
@@ -255,18 +257,18 @@ class Compiler:
         except ValueError as exc:
             raise CalibrationError(f"{exc}") from exc
 
-    def get_calibration(self) -> CalibrationSet:
+    def get_calibration_set_values(self) -> CalibrationSetValues:
         """Returns a copy of the current local calibration set."""
-        return deepcopy(self._calibration_set)
+        return deepcopy(self._calibration_set_values)
 
-    def set_calibration(self, calibration: CalibrationSet) -> None:
+    def set_calibration_set_values(self, calibration_set_values: CalibrationSetValues) -> None:
         """Sets the current calibration set to a given calibration set, then refreshes the compiler.
 
         Args:
-            calibration: The calibration set to be set as the current calibration set.
+            calibration_set_values: The calibration set to be set as the current calibration set.
 
         """
-        self._calibration_set = calibration
+        self._calibration_set_values = calibration_set_values
         self._refresh()
 
     @property
@@ -323,7 +325,7 @@ class Compiler:
         locus_str = "__".join(locus)
         for param, value in params.items():
             path = f"gates.{gate_name}.{impl_name}.{locus_str}.{param}"
-            self._calibration_set[path] = value
+            self._calibration_set_values[path] = value
 
         self._refresh()
 
@@ -422,7 +424,7 @@ class Compiler:
         Used automatically by :meth:`compile`.
         """
         return {
-            "calibration_set": self._calibration_set,
+            "calibration_set": self._calibration_set_values,
             "builder": self.builder,
             "component_mapping": self.component_mapping,
             "options": self.options,
@@ -430,9 +432,7 @@ class Compiler:
             "chip_topology": self.builder.chip_topology,
         }
 
-    def compile(
-        self, data: Iterable[Any], context: dict[str, Any] | None = None
-    ) -> tuple[Iterable[Any], dict[str, Any]]:
+    def compile(self, data: Iterable[Any], context: dict[str, Any] | None = None) -> tuple[Any, dict[str, Any]]:
         """Run all compiler stages.
 
             Initial context will be derived using :meth:`compiler_context` unless a custom
@@ -470,7 +470,7 @@ class Compiler:
 
     def run_stages(
         self, stages: Collection[CompilationStage], data: Iterable[Any], context: dict[str, Any]
-    ) -> tuple[Iterable[Any], dict[str, Any]]:
+    ) -> tuple[Any, dict[str, Any]]:
         """Run the given stages in given order on the given data.
 
         Args:
@@ -514,20 +514,16 @@ class Compiler:
             calibration_set = context["calibration_set"]
             circuit_metrics = context["circuit_metrics"]
             options = context["options"]
-            custom_settings = context.get("custom_settings")
         except Exception as exc:
             raise InsufficientContextError(f"Missing context data for building settings: {exc}") from exc
 
         settings = build_settings(
             shots=shots,
-            calibration_set=calibration_set,
+            calibration_set_values=calibration_set,
             builder=builder,
             circuit_metrics=circuit_metrics,
             options=options,
         )
-        # if custom_settings are given, use them to override similarly named generated settings
-        if custom_settings is not None:
-            settings = SettingNode.merge(custom_settings, settings)
 
         # fill in the schedule durations to the metrics
         end_delay = calibration_set["controllers.options.end_delay"]

iqm/cpc/compiler/dd.py

@@ -18,7 +18,6 @@ import logging
 import math
 
 from iqm.cpc.compiler.errors import ClientError
-from iqm.cpc.interface.compiler import DDStrategy, PRXSequence
 from iqm.pulla.utils import (
     InstructionLocation,
     locate_instructions,
@@ -30,6 +29,7 @@ from iqm.pulse.playlist.instructions import Instruction, Wait
 from iqm.pulse.playlist.schedule import Schedule, Segment
 from iqm.pulse.scheduler import Block
 from iqm.pulse.timebox import TimeBox
+from iqm.station_control.interface.models.circuit import DDStrategy, PRXSequence
 
 cpc_logger = logging.getLogger("cpc")
 

iqm/cpc/compiler/standard_stages.py

@@ -69,9 +69,11 @@ Breakdown of compiler passes of each stage:
 """
 
 from collections import Counter
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from copy import copy, deepcopy
-from typing import Any
+from dataclasses import replace
+import logging
+from typing import Any, TypeAlias
 
 import numpy as np
 
@@ -105,7 +107,6 @@ from iqm.pulla.interface import (
     HERALDING_KEY,
     MEASUREMENT_MODE_KEY,
     RESTRICTED_MEASUREMENT_KEYS,
-    CalibrationErrors,
 )
 from iqm.pulse.base_utils import merge_dicts
 from iqm.pulse.builder import CircuitOperation, ScheduleBuilder, validate_quantum_circuit
@@ -116,6 +117,12 @@ from iqm.pulse.playlist.playlist import Playlist
 from iqm.pulse.quantum_ops import QuantumOpTable
 from iqm.pulse.timebox import MultiplexedProbeTimeBox, TimeBox
 
+CalibrationErrors: TypeAlias = dict[tuple[str, str, Locus], str]
+"""Map from OIL tuple to a CalibrationError message."""
+
+
+logger = logging.getLogger(__name__)
+
 
 # Compilation functions
 def _map_old_operation_names(instructions: Iterable[CircuitOperation]) -> None:
@@ -519,8 +526,15 @@ def validate_execution_options(circuits: Iterable[Circuit_], options: CircuitExe
         MoveGateValidationMode.ALLOW_PRX,
     ]:
         raise CircuitError("Full MOVE gate frame tracking requires MOVE gate validation to be 'strict' or 'allow_prx'.")
+    if options.convert_terminal_measurements and options.active_reset_cycles is not None:
+        options = replace(options, convert_terminal_measurements=False)
+        logger.warning(
+            "When using active reset, the terminal measurements must also be calibrated to minimize leakage."
+            " Thus the terminal measurements cannot be converted to use the fidelity-optimized"
+            " `measure_fidelity` operation."
+        )
 
-    return circuits
+    return circuits, {"options": options}
 
 
 @compiler_pass
@@ -764,7 +778,7 @@ def clean_schedule(schedules: Iterable[Schedule], builder: ScheduleBuilder) -> l
 
 
 @compiler_pass
-def build_playlist(schedules: Iterable[Schedule], builder: ScheduleBuilder) -> tuple[Playlist, dict[str, Any]]:
+def build_playlist(schedules: Sequence[Schedule], builder: ScheduleBuilder) -> tuple[Playlist, dict[str, Any]]:
     """Build the playlist from the schedules."""
     playlist = builder.build_playlist(schedules)[0]
     return playlist, {"schedules": schedules}  # save the schedules for building settings, debugging, etc

iqm/cpc/compiler/station_settings.py

@@ -77,7 +77,7 @@ from typing import TYPE_CHECKING
 from exa.common.data.parameter import CollectionType, DataType, Parameter, Setting
 from exa.common.data.setting_node import SettingNode
 from iqm.cpc.compiler.errors import CalibrationError
-from iqm.pulla.interface import CalibrationSet
+from iqm.pulla.interface import CalibrationSetValues
 
 if TYPE_CHECKING:
     from exa.common.data.value import ObservationValue
@@ -118,7 +118,7 @@ class Map:
 
 def find_observation(
     observation_path: str,
-    calibration_set: CalibrationSet,
+    calibration_set_values: CalibrationSetValues,
     *,
     required: bool = True,
 ) -> ObservationValue:
@@ -126,7 +126,7 @@ def find_observation(
 
     Args:
         observation_path: observation we want to find in ``calibration_set``
-        calibration_set: mapping of observation paths to observation values
+        calibration_set_values: mapping of observation paths to observation values
         required: iff ``True`` and the observation cannot be found, raise an error
 
     Returns:
@@ -137,7 +137,7 @@ def find_observation(
             found in ``calibration_set``
 
     """
-    obs_value = calibration_set.get(observation_path)
+    obs_value = calibration_set_values.get(observation_path)
     if obs_value is None and required:
         raise CalibrationError(f"Missing calibration observation: {observation_path}")
     return obs_value  # type: ignore[return-value]
@@ -371,7 +371,7 @@ def build_station_settings(
     circuit_couplers: Iterable[str],
     measured_probe_lines: Iterable[str],
     shots: int,
-    calibration_set: CalibrationSet,
+    calibration_set_values: CalibrationSetValues,
     boundary_qubits: Iterable[str],
     boundary_couplers: Iterable[str],
     flux_pulsed_qubits: Collection[str],
@@ -384,7 +384,7 @@ def build_station_settings(
         circuit_couplers: coupler names used in the circuit
         measured_probe_lines: probe line names used in the measurements
         shots: number of times to repeat each circuit's execution
-        calibration_set: calibration set as a mapping from observation paths to observation values
+        calibration_set_values: calibration set as a mapping from observation paths to observation values
         boundary_qubits: physical qubits connected to the boundary_couplers but not in circuit_qubits
         boundary_couplers: coupler names of couplers connected to the circuit boundary but not in circuit_couplers
         flux_pulsed_qubits: names of qubits that have flux pulse capability
@@ -406,7 +406,9 @@ def build_station_settings(
 
         """
         for obs_map in observation_maps:
-            value = find_observation(obs_map.observation_path(component), calibration_set, required=obs_map.required)
+            value = find_observation(
+                obs_map.observation_path(component), calibration_set_values, required=obs_map.required
+            )
             if value is not None:
                 _create_and_add_setting(obs_map.settings_path(component), obs_map.parameter, value, root)
 

iqm/cpc/interface/compiler.py

@@ -22,6 +22,13 @@ from exa.common.data.setting_node import SettingNode
 from iqm.pulse import Circuit
 from iqm.pulse.builder import Locus
 from iqm.pulse.playlist.playlist import Playlist
+from iqm.station_control.interface.models import (
+    DDMode,
+    DDStrategy,
+    HeraldingMode,
+    MoveGateFrameTrackingMode,
+    MoveGateValidationMode,
+)
 
 CircuitBatch: TypeAlias = list[Circuit]
 """Type that represents a list of quantum circuits to be executed together in a single batch."""
@@ -42,78 +49,6 @@ class MeasurementMode(StrEnum):
     This is typically how measurement is calibrated."""
 
 
-class HeraldingMode(StrEnum):
-    """Heralding mode for circuit execution."""
-
-    NONE = "none"
-    """Do not do any heralding."""
-    ZEROS = "zeros"
-    """Perform a heralding measurement on all the components used in each circuit (if they have
-    measurement data available in the calset), only retain shots where all the components
-    are measured to be in the zero state."""
-
-
-class DDMode(StrEnum):
-    """Dynamical Decoupling (DD) mode for circuit execution."""
-
-    DISABLED = "disabled"
-    """Do not apply dynamical decoupling."""
-    ENABLED = "enabled"
-    """Apply dynamical decoupling."""
-
-
-PRXSequence: TypeAlias = list[tuple[float, float]]
-"""A sequence of PRX gates. A generic PRX gate is defined by rotation angle and phase angle, Theta and Phi
-respectively."""
-
-
-@dataclass
-class DDStrategy:
-    """Describes a particular dynamical decoupling strategy.
-
-    The current standard DD stategy can be found in :attr:`.STANDARD_DD_STRATEGY`,
-    but users can use this class to provide their own dynamical decoupling strategies.
-
-    See :cite:`Ezzell_2022` for information on DD sequences.
-    """
-
-    merge_contiguous_waits: bool = True
-    """Merge contiguous ``Wait`` instructions into one if they are separated only by ``Block`` instructions."""
-
-    target_qubits: frozenset[str] | None = None
-    """Qubits on which dynamical decoupling should be applied. If ``None``, all qubits are targeted."""
-
-    skip_leading_wait: bool = True
-    """Skip processing leading ``Wait`` instructions."""
-
-    skip_trailing_wait: bool = True
-    """Skip processing trailing ``Wait`` instructions."""
-
-    gate_sequences: list[tuple[int, str | PRXSequence, str]] = field(default_factory=list)
-    """Available decoupling gate sequences to chose from in this strategy.
-
-    Each sequence is defined by a tuple of ``(ratio, gate pattern, align)``:
-
-        * ratio: Minimal duration for the sequence (in PRX gate durations).
-
-        * gate pattern: Gate pattern can be defined in two ways. It can be a string containing "X" and "Y" characters,
-          encoding a PRX gate sequence. For example, "YXYX" corresponds to the
-          XY4 sequence, "XYXYYXYX" to the EDD sequence, etc. If more flexibility is needed, a gate pattern can be
-          defined as a sequence of PRX gate argument tuples (that contain a rotation angle and a phase angle). For
-          example, sequence "YX" could be written as ``[(math.pi, math.pi / 2), (math.pi, 0)]``.
-
-        * align: Controls the alignment of the sequence within the time window it is inserted in. Supported values:
-
-          - "asap": Corresponds to a ASAP-aligned sequence with no waiting time before the first pulse.
-          - "center": Corresponds to a symmetric sequence.
-          - "alap": Corresponds to a ALAP-aligned sequence.
-
-    The Dynamical Decoupling algorithm uses the best fitting gate sequence by first sorting them
-    by ``ratio`` in descending order. Then the longest fitting pattern is determined by comparing ``ratio``
-    with the duration of the time window divided by the PRX gate duration.
-    """
-
-
 class CircuitBoundaryMode(StrEnum):
     """Circuit boundary mode for circuit compilation."""
 
@@ -130,32 +65,6 @@ class CircuitBoundaryMode(StrEnum):
     """Circuit boundary consists of all the QPU elements that are not used in the circuit."""
 
 
-class MoveGateValidationMode(StrEnum):
-    """MOVE gate validation mode for circuit compilation."""
-
-    STRICT = "strict"
-    """Perform standard MOVE gate validation: MOVE(qubit, resonator) gates must only
-    appear in sandwiches (pairs). Inside a sandwich there must be no gates acting on the
-    MOVE qubit, and no other MOVE gates acting on the resonator."""
-    ALLOW_PRX = "allow_prx"
-    """Allow PRX gates on the MOVE qubit inside MOVE sandwiches during validation."""
-    NONE = "none"
-    """Do not perform any MOVE gate validation."""
-
-
-class MoveGateFrameTrackingMode(StrEnum):
-    """MOVE gate frame tracking mode for circuit compilation."""
-
-    FULL = "full"
-    """Perform complete MOVE gate frame tracking, applying both the explicit z rotations
-    on the resonator and the dynamic phase correction due to qubit-resonator detuning to
-    the qubit at the end of a MOVE sandwich."""
-    NO_DETUNING_CORRECTION = "no_detuning_correction"
-    """Do not apply the detuning correction at the end of a MOVE sandwich."""
-    NONE = "none"
-    """Do not perform any MOVE gate frame tracking."""
-
-
 @dataclass(frozen=True)
 class CircuitExecutionOptions:
     """Various discrete options for quantum circuit execution."""

iqm/pulla/calibration.py

@@ -16,13 +16,13 @@
 
 from copy import deepcopy
 import logging
-import uuid
+from uuid import UUID
 
-from iqm.pulla.interface import CalibrationSet, CalibrationSetId
+from iqm.iqm_server_client.iqm_server_client import _IQMServerClient
+
+from iqm.pulla.interface import CalibrationSetValues
 from iqm.pulla.utils import calset_from_observations
-from iqm.station_control.client.iqm_server.iqm_server_client import IqmServerClient
-from iqm.station_control.interface.models import ObservationSetData
-from iqm.station_control.interface.station_control import StationControlInterface
+from iqm.station_control.interface.models import StrUUID
 
 logger = logging.getLogger(__name__)
 
@@ -30,66 +30,45 @@ CalibrationDataFetchException = RuntimeError
 
 
 class CalibrationDataProvider:
-    """Access calibration info via station control client and cache data in memory."""
+    """Access calibration info via IQM Server and cache data in memory."""
 
-    def __init__(self, station_control: StationControlInterface):
-        self._station_control = station_control
-        self._calibration_sets: dict[CalibrationSetId, CalibrationSet] = {}
+    def __init__(self, iqm_server_client: _IQMServerClient):
+        self._iqm_server_client = iqm_server_client
+        self._calibration_sets: dict[UUID, CalibrationSetValues] = {}
 
-    def get_calibration_set(self, cal_set_id: CalibrationSetId) -> CalibrationSet:
+    def get_calibration_set_values(self, calibration_set_id: UUID) -> CalibrationSetValues:
         """Get the calibration set contents from the database and cache it."""
-        logger.debug("Get the calibration set from the database: cal_set_id=%s", cal_set_id)
+        logger.debug("Get the calibration set from the database: cal_set_id=%s", calibration_set_id)
         try:
-            if cal_set_id not in self._calibration_sets:
-                cal_set_values = self.get_calibration_set_values(cal_set_id)
-                self._calibration_sets[cal_set_id] = cal_set_values
-            return deepcopy(self._calibration_sets[cal_set_id])
+            if calibration_set_id not in self._calibration_sets:
+                cal_set_values = self._get_calibration_set_values(calibration_set_id)
+                self._calibration_sets[calibration_set_id] = cal_set_values
+            return deepcopy(self._calibration_sets[calibration_set_id])
         except Exception as e:
             raise CalibrationDataFetchException("Could not fetch calibration set from the database.") from e
 
-    def get_latest_calibration_set(self, chip_label: str) -> tuple[CalibrationSet, CalibrationSetId]:
-        """Get the latest calibration set id for ``chip_label`` from the database, return it and the set contents."""
-        logger.debug("Get the latest calibration set for chip label: chip_label=%s", chip_label)
+    def get_default_calibration_set(self) -> tuple[CalibrationSetValues, UUID]:
+        """Get the default calibration set id from the database, return it and the set contents."""
+        logger.debug("Get the default calibration set")
         try:
-            if isinstance(self._station_control, IqmServerClient):
-                latest_cal_set_id = self._station_control.get_latest_calibration_set_id(chip_label)
-            else:
-                latest_calibration_set = self._get_latest_calibration_set(chip_label)
-                latest_cal_set_id = latest_calibration_set.observation_set_id
-            calset = self.get_calibration_set(latest_cal_set_id)
+            default_calibration_set = self._iqm_server_client.get_calibration_set("default")
+            default_calibration_set_values = self.get_calibration_set_values(default_calibration_set.observation_set_id)
         except Exception as e:
             raise CalibrationDataFetchException(
-                f"Could not fetch latest calibration set id from the database: {e}"
+                f"Could not fetch default calibration set id from the database: {e}"
             ) from e
-        return calset, latest_cal_set_id
-
-    def _get_latest_calibration_set(self, dut_label: str) -> ObservationSetData:
-        observation_sets = self._station_control.query_observation_sets(
-            observation_set_type="calibration-set",
-            dut_label=dut_label,
-            invalid=False,
-            end_timestamp__isnull=False,  # Finalized
-            order_by="-end_timestamp",
-            limit=1,
-        )
-        return observation_sets[0]
+        return default_calibration_set_values, default_calibration_set.observation_set_id
 
-    def get_calibration_set_values(self, calibration_set_id: uuid.UUID) -> CalibrationSet:
+    def _get_calibration_set_values(self, calibration_set_id: StrUUID) -> CalibrationSetValues:
         """Get saved calibration set observations by UUID.
 
         Args:
-            calibration_set_id: UUID of the calibration set to retrieve.
+            calibration_set_id: UUID of the calibration set to retrieve or "default".
 
         Returns:
             Dictionary of observations belonging to the given calibration set.
 
         """
-        if isinstance(self._station_control, IqmServerClient):
-            calibration_set_values = self._station_control.get_calibration_set_values(calibration_set_id)
-        else:
-            observation_set = self._station_control.get_observation_set(calibration_set_id)
-            if observation_set.observation_set_type != "calibration-set":
-                raise ValueError("Observation set type is not 'calibration-set'")
-            observations = self._station_control.get_observation_set_observations(calibration_set_id)
-            calibration_set_values = calset_from_observations(observations)
+        calibration_set = self._iqm_server_client.get_calibration_set(calibration_set_id)
+        calibration_set_values = calset_from_observations(calibration_set.observations)
         return calibration_set_values

iqm/pulla/interface.py

@@ -12,18 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Common data types and exceptions for the IQM Pulla interface.
+"""Common data types and exceptions for the IQM Pulla interface."""
 
-Many of these must be identical to those in iqm-client.
-"""
-
-from dataclasses import dataclass
-from enum import StrEnum
 from typing import TypeAlias
-from uuid import UUID
 
 from exa.common.data.value import ObservationValue
-from iqm.cpc.interface.compiler import Locus
 
 
 class CHADRetrievalException(Exception):
@@ -38,56 +31,8 @@ class ChipLabelRetrievalException(Exception):
     """Exception for chip label retrieval failures."""
 
 
-# Map from OIL tuple to a CalibrationError.
-CalibrationErrors: TypeAlias = dict[tuple[str, str, Locus], str]
-
-
-class TaskStatus(StrEnum):
-    """Status of a Station Control task."""
-
-    READY = "READY"
-    """Task has completed successfully"""
-
-    FAILED = "FAILED"
-    """Task has failed"""
-
-    PROGRESS = "PROGRESS"
-    """Task is being executed"""
-
-    PENDING = "PENDING"
-    """Task is waiting to be executed"""
-
-
-CalibrationSet: TypeAlias = dict[str, ObservationValue]
-CalibrationSetId: TypeAlias = UUID
-
-CircuitMeasurementResults: TypeAlias = dict[str, list[list[int]]]
-"""Measurement results from a single circuit/schedule. For each measurement operation in the circuit,
-maps the measurement key to the corresponding results. The outer list elements correspond to shots,
-and the inner list elements to the qubits measured in the measurement operation."""
-
-CircuitMeasurementResultsBatch: TypeAlias = list[CircuitMeasurementResults]
-"""Type that represents measurement results for a batch of circuits."""
-
-
-@dataclass
-class StationControlResult:
-    """Result of a station control task"""
-
-    sweep_id: UUID
-    """ID of the executed sweep"""
-    task_id: UUID  # TODO? Rename to job_id
-    """ID of the station control task"""
-    status: TaskStatus
-    """Status of the station control task"""
-    start_time: str | None = None
-    """Time when the sweep began in the station control"""
-    end_time: str | None = None
-    """Time when the sweep ended in the station control"""
-    result: CircuitMeasurementResultsBatch | None = None
-    """Sweep results converted to the circuit measurement results expected by the client"""
-    message: str | None = None
-    """Information about task failure"""
+CalibrationSetValues: TypeAlias = dict[str, ObservationValue]
+"""Map from observation name to its value."""
 
 
 ACQUISITION_LABEL_KEY = "m{idx}"