iqm-pulla 11.16.2__py3-none-any.whl → 12.0.0__py3-none-any.whl

iqm/pulla/pulla.py

@@ -11,17 +11,20 @@
 # 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.
+"""Pulse level access to IQM quantum computers."""
 
-"""Pulse level access library for IQM's circuit-to-pulse compiler and Station Control API."""
+from __future__ import annotations
 
-from collections.abc import Callable
+from copy import deepcopy
+from dataclasses import dataclass
 from importlib.metadata import version
 import logging
-import platform
-import time
 from typing import Any
 import uuid
 
+from iqm.iqm_client.iqm_client import IQMServerClientJob
+from iqm.iqm_server_client.iqm_server_client import _IQMServerClient
+from iqm.iqm_server_client.models import JobStatus
 import requests
 
 from exa.common.data.setting_node import SettingNode
@@ -36,19 +39,15 @@ from iqm.cpc.compiler.standard_stages import get_standard_stages
 from iqm.cpc.interface.compiler import CircuitExecutionOptions
 from iqm.pulla.calibration import CalibrationDataProvider
 from iqm.pulla.interface import (
-    CalibrationSet,
-    CalibrationSetId,
+    CalibrationSetValues,
     CHADRetrievalException,
     ChipLabelRetrievalException,
     SettingsRetrievalException,
-    StationControlResult,
-    TaskStatus,
 )
 from iqm.pulla.utils import extract_readout_controller_result_names, map_sweep_results_to_logical_qubits
 from iqm.pulse.playlist.channel import ChannelProperties, get_channel_properties_from_station_settings
 from iqm.pulse.playlist.playlist import Playlist
-from iqm.station_control.client.utils import get_progress_bar_callback, init_station_control
-from iqm.station_control.interface.models import JobExecutorStatus, SweepDefinition
+from iqm.station_control.interface.models import CircuitMeasurementResultsBatch, SweepDefinition
 
 #    ██████  ██    ██ ██      ██       █████
 #    ██   ██ ██    ██ ██      ██      ██   ██
@@ -57,44 +56,55 @@ from iqm.station_control.interface.models import JobExecutorStatus, SweepDefinit
 #    ██       ██████  ███████ ███████ ██   ██
 
 logger = logging.getLogger(__name__)
+init_loggers({"iqm": "INFO"})
 
 
 class Pulla:
-    """Pulse level access library for IQM's circuit-to-pulse compiler and Station Control API.
-    Conceptually, represents a connection to a remote quantum computer, and a provider of calibration data.
-    Can create a compiler instance ready to be used with the connected quantum computer.
+    """Pulse level access to IQM quantum computers.
+
+    Each instance of this class represents a connection to a remote quantum computer.
+    Can create a :class:`~iqm.cpc.compiler.compiler.Compiler` instance ready to be used with
+    the connected quantum computer.
 
     Args:
-        station_control_url: URL to a Station Control instance.
-        get_token_callback: An optional function that returns an authentication token for the Station Control API.
+        iqm_server_url: URL for accessing the server. Has to start with http or https.
+        quantum_computer: ID or alias of the quantum computer to connect to, if the IQM Server
+            instance controls more than one.
+        token: Long-lived authentication token in plain text format.
+            If ``token`` is given no other user authentication parameters should be given.
+        tokens_file: Path to a tokens file used for authentication.
+            If ``tokens_file`` is given no other user authentication parameters should be given.
+        client_signature: String that Pulla adds to User-Agent header of requests
+            it sends to the server. The signature is appended to IQMServerClient's own version
+            information and is intended to carry additional version information,
+            for example the version information of the caller.
 
     """
 
     def __init__(
         self,
-        station_control_url: str,
+        iqm_server_url: str,
         *,
-        get_token_callback: Callable[[], str] | None = None,
-        **kwargs,
+        quantum_computer: str | None = None,
+        token: str | None = None,
+        tokens_file: str | None = None,
+        client_signature: str | None = None,
     ):
-        self._signature = f"{platform.platform(terse=True)}"
-        self._signature += f", python {platform.python_version()}"
-        self._signature += f", iqm-pulla {version('iqm-pulla')}"
-
-        # The function to be passed to Station Control Client if the server requires authentication
-        self.get_token_callback = get_token_callback
-
-        # SC Client to be used for fetching calibration data, submitting sweeps, and retrieving results.
+        if not client_signature:
+            client_signature = f"iqm-pulla {version('iqm-pulla')}"
         try:
-            self._station_control = init_station_control(
-                station_control_url, get_token_callback=self.get_token_callback, **kwargs
+            self._iqm_server_client = _IQMServerClient(
+                iqm_server_url=iqm_server_url,
+                token=token,
+                tokens_file=tokens_file,
+                client_signature=client_signature,
+                quantum_computer=quantum_computer,
             )
-
         except Exception as e:
-            logger.error("Failed to initialize Station Control Client: %s", e)
-            raise ValueError("Failed to initialize Station Control Client") from e
-        # Separate wrapper on top of SC Client to simplify calibration data fetching.
-        self._calibration_data_provider = CalibrationDataProvider(self._station_control)
+            logger.error("Failed to initialize IQM Server client: %s", e)
+            raise ValueError("Failed to initialize IQM Server client") from e
+        # Separate wrapper on top of IQM Server client to simplify calibration data fetching.
+        self._calibration_data_provider = CalibrationDataProvider(self._iqm_server_client)
 
         # Data needed for the compiler.
         self._station_control_settings: SettingNode | None = None
@@ -107,13 +117,13 @@ class Pulla:
 
     def get_standard_compiler(
         self,
-        calibration_set: CalibrationSet | None = None,
+        calibration_set_values: CalibrationSetValues | None = None,
         circuit_execution_options: CircuitExecutionOptions | dict | None = None,
     ) -> Compiler:
         """Returns a new instance of the compiler with the default calibration set and standard stages.
 
         Args:
-            calibration_set: Calibration set to use. If None, the default calibration set will be used.
+            calibration_set_values: Calibration set to use. If None, the current calibration set will be used.
             circuit_execution_options: circuit execution options to use for the compiler. If a CircuitExecutionOptions
                 object is provided, the compiler use it as is. If a dict is provided, the default values will be
                 overridden for the present keys in that dict. If left ``None``, the default options will be used.
@@ -129,7 +139,7 @@ class Pulla:
                 **STANDARD_CIRCUIT_EXECUTION_OPTIONS_DICT | circuit_execution_options  # type: ignore
             )
         return Compiler(
-            calibration_set=calibration_set or self.fetch_latest_calibration_set()[0],
+            calibration_set_values=calibration_set_values or self.fetch_default_calibration_set()[0],
             chip_topology=self._chip_topology,
             channel_properties=self._channel_properties,
             component_channels=self._component_channels,
@@ -138,32 +148,38 @@ class Pulla:
             options=circuit_execution_options,
         )
 
-    def fetch_latest_calibration_set(self) -> tuple[CalibrationSet, CalibrationSetId]:
-        """Fetches the latest default calibration set from the server, and returns its decoded representation and id."""  # noqa: E501
-        latest_calibration_set, latest_calibration_set_id = self._calibration_data_provider.get_latest_calibration_set(
-            self.get_chip_label()
+    def fetch_default_calibration_set(self) -> tuple[CalibrationSetValues, uuid.UUID]:
+        """Fetch the default calibration set from the server, in a minimal format.
+
+        Returns:
+            Calibration set contents, calibration set ID.
+
+        """
+        default_calibration_set, default_calibration_set_id = (
+            self._calibration_data_provider.get_default_calibration_set()
         )
-        return latest_calibration_set, latest_calibration_set_id
+        return default_calibration_set, default_calibration_set_id
+
+    def fetch_calibration_set_values_by_id(self, calibration_set_id: uuid.UUID) -> CalibrationSetValues:
+        """Fetch a specific calibration set from the server.
 
-    def fetch_calibration_set_by_id(self, calibration_set_id: CalibrationSetId) -> CalibrationSet:
-        """Fetches a specific calibration set from the server, and returns its decoded representation.
-        All calibration sets are cached in-memory, so if the calibration set with the given id has already been fetched,
-        it will be returned immediately.
+        All calibration sets are cached in-memory, so if the calibration set with the given
+        id has already been fetched, it will be returned immediately.
 
         Args:
-            calibration_set_id: id of the calibration set to fetch.
+            calibration_set_id: ID of the calibration set to fetch.
+
+        Returns:
+            Calibration set contents.
 
         """
-        calibration_set = self._calibration_data_provider.get_calibration_set(calibration_set_id)
+        calibration_set = self._calibration_data_provider.get_calibration_set_values(calibration_set_id)
         return calibration_set
 
     def get_chip_label(self) -> str:
-        """Returns the chip label of the current quantum computer.
-
-        The chip label is fetched from the Station Control API.
-        """
+        """QPU label of the quantum computer we are connected to."""
         try:
-            duts = self._station_control.get_duts()
+            duts = self._iqm_server_client.get_duts()
         except requests.RequestException as e:
             raise ChipLabelRetrievalException(f"Failed to retrieve the chip label: {e}") from e
 
@@ -172,19 +188,20 @@ class Pulla:
         return duts[0].label
 
     def get_chip_topology(self) -> ChipTopology:
-        """Returns chip topology that was fetched from the IQM server during Pulla initialization."""
+        """QPU topology of the quantum computer we are connected to."""
+        self.get_chip_label()  # Called just to make sure that there will be only one DUT available
         try:
-            record = self._station_control.get_chip_design_record(self.get_chip_label())
+            chip_design_record = self._iqm_server_client.get_chip_design_records()[0]
         except Exception as e:
             raise CHADRetrievalException("Could not fetch chip design record") from e
-        return ChipTopology.from_chip_design_record(record)
+        return ChipTopology.from_chip_design_record(chip_design_record)
 
     def _get_station_control_settings(self) -> SettingNode:
-        """Returns the Station Control settings node that was fetched from the IQM server during Pulla initialization."""  # noqa: E501
+        """Station Control default settings tree."""
         if self._station_control_settings is None:
             # request the station settings, cache the results
             try:
-                self._station_control_settings = self._station_control.get_settings()
+                self._station_control_settings = self._iqm_server_client.get_settings()
             except Exception as e:
                 raise SettingsRetrievalException("Could not fetch station settings") from e
         return self._station_control_settings
@@ -204,25 +221,26 @@ class Pulla:
             self._get_station_control_settings(), self.get_chip_topology()
         )
 
-    def execute(
+    def submit_playlist(
         self,
         playlist: Playlist,
-        context: dict[str, Any],
         settings: SettingNode,
-        verbose: bool = True,
-        wait_completion: bool = True,
-    ) -> StationControlResult:
-        """Executes a quantum circuit on the remote quantum computer.
+        *,
+        context: dict[str, Any],
+        use_timeslot: bool = False,
+    ) -> SweepJob:
+        """Submit a Playlist of instruction schedules for execution on the remote quantum computer.
 
         Args:
-            playlist: Final schedule to be executed.
-            context: Context object of the successful compiler run, containing the readout mappings.
-            settings: Station settings.
-            verbose: Whether to print results.
-            wait_completion: If True, returns immediately with job ID. If False, waits for completion.
+            playlist: Schedules to execute.
+            settings: Station settings to be used for the execution.
+            context: Context object of the compiler run that produced ``playlist``, containing the readout mappings.
+                Required for postprocessing the results.
+            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.
 
         Returns:
-            results of the execution
+            Created job object, used to query the job status and the execution results.
 
         """
         readout_components = []
@@ -231,141 +249,63 @@ class Pulla:
                 if k == "readout":
                     readout_components.append(v)
 
-        sweep_response = self._station_control.sweep(
-            SweepDefinition(
-                sweep_id=uuid.uuid4(),
-                playlist=playlist,
-                return_parameters=list(extract_readout_controller_result_names(context["readout_mappings"])),
-                settings=settings,
-                dut_label=self.get_chip_label(),
-                sweeps=[],
-            )
+        sweep = SweepDefinition(
+            sweep_id=uuid.uuid4(),
+            playlist=playlist,
+            return_parameters=list(extract_readout_controller_result_names(context["readout_mappings"])),
+            settings=settings,
+            dut_label=self.get_chip_label(),
+            sweeps=[],
+        )
+        job_data = self._iqm_server_client.submit_sweep(sweep, use_timeslot=use_timeslot)
+        logger.info("Submitted a job with ID: %s", job_data.id)
+
+        # Initialize the job object, which can be then used to query
+        return SweepJob(
+            data=job_data,
+            _pulla=self,
+            _context=deepcopy(context),
         )
-        job_id = uuid.UUID(sweep_response["job_id"])
-
-        logger.info("Created job in queue with ID: %s", job_id)
-        if href := sweep_response.get("job_href"):
-            logger.info("Job link: %s", href)
-
-        if wait_completion:
-            return self.get_execution_result(job_id, context, verbose, wait_completion=True)
-        else:
-            return StationControlResult(sweep_id=job_id, task_id=job_id, status=TaskStatus.PENDING)
-
-    def get_execution_result(
-        self,
-        job_id: uuid.UUID,
-        context: dict[str, Any],
-        verbose: bool = True,
-        wait_completion: bool = True,
-    ) -> StationControlResult:
-        """Get execution results.
-
-        Args:
-            job_id: The ID of the job to process.
-            context: Context object of the successful compiler run, containing the readout mappings.
-            verbose: Whether to print results.
-            wait_completion: If True, waits for job completion. If False, returns current status.
 
-        Returns:
-            The processed station control result.
 
-        """
-        sc_result = StationControlResult(sweep_id=job_id, task_id=job_id, status=TaskStatus.PENDING)
+@dataclass
+class SweepJob(IQMServerClientJob):
+    """Status and results of a Pulla sweep job.
 
-        try:
-            if wait_completion:
-                logger.info("Waiting for the job to finish...")
-
-            while True:
-                job_data = self._station_control.get_job(job_id)
-                sc_result.status = TaskStatus.PENDING
-
-                if job_data.job_status <= JobExecutorStatus.EXECUTION_STARTED:  # type: ignore[operator]
-                    if wait_completion:
-                        # Wait in the task queue while showing a progress bar
-                        interrupted = self._station_control._wait_job_completion(  # type: ignore[attr-defined]
-                            str(job_id), get_progress_bar_callback()
-                        )
-                        if interrupted:
-                            raise KeyboardInterrupt
-                    else:
-                        # Non-blocking check - return current status
-                        sc_result.status = (
-                            TaskStatus.PROGRESS
-                            if job_data.job_status == JobExecutorStatus.EXECUTION_STARTED
-                            else TaskStatus.PENDING
-                        )
-                        return sc_result
-                else:
-                    # job is not in queue or executing, so we can query the sweep
-                    result_or_nothing = self._get_result_of_started_job(
-                        context, job_data, job_id, sc_result, wait_completion, verbose
-                    )
-                    if result_or_nothing is not None:
-                        return result_or_nothing
-
-                if wait_completion:
-                    time.sleep(1)
-                else:
-                    break
-
-        except KeyboardInterrupt as exc:
-            if wait_completion:
-                logger.info("Caught KeyboardInterrupt, revoking job %s", job_id)
-                self._station_control.abort_job(job_id)
-            raise KeyboardInterrupt from exc
-
-        return sc_result
-
-    def _get_result_of_started_job(
-        self,
-        context: dict[str, Any],
-        job_data: Any,
-        job_id: uuid.UUID,
-        sc_result: StationControlResult,
-        wait_completion: bool,
-        verbose: bool,
-    ) -> StationControlResult | None:
-        sweep_data = self._station_control.get_sweep(job_id)
-        if job_data.job_status == JobExecutorStatus.READY:
-            if wait_completion:
-                logger.info("Sweep status: %s", str(sweep_data.job_status))
-
-            sc_result.status = TaskStatus.READY
-            sc_result.result = map_sweep_results_to_logical_qubits(
-                self._station_control.get_sweep_results(job_id),
-                context["readout_mappings"],
-                context["options"].heralding_mode,
-            )
-            sc_result.start_time = sweep_data.begin_timestamp.isoformat() if sweep_data.begin_timestamp else None
-            sc_result.end_time = sweep_data.end_timestamp.isoformat() if sweep_data.end_timestamp else None
+    Created by :meth:`Pulla.submit_playlist`.
+    """
 
-            if verbose and wait_completion:
-                # TODO: Consider using just 'logger.debug' here and remove 'verbose'
-                logger.info(sc_result.result)
+    _pulla: Pulla
+    """Client instance used to create the job."""
 
-            return sc_result
+    _context: dict[str, Any]
+    """Final context object of the compiler run used to produce the sweep, contains information needed
+    for processing the results."""
 
-        if job_data.job_status == JobExecutorStatus.FAILED:
-            sc_result.status = TaskStatus.FAILED
-            sc_result.start_time = sweep_data.begin_timestamp.isoformat() if sweep_data.begin_timestamp else None
-            sc_result.end_time = sweep_data.end_timestamp.isoformat() if sweep_data.end_timestamp else None
-            sc_result.message = str(job_data.job_error)
-            if wait_completion:
-                logger.error("Submission failed! Error: %s", sc_result.message)
-            return sc_result
+    _result: CircuitMeasurementResultsBatch | None = None
+    """Sweep results converted to the circuit measurement results expected by the client."""
 
-        if job_data.job_status == JobExecutorStatus.ABORTED:
-            sc_result.status = TaskStatus.FAILED
-            sc_result.start_time = sweep_data.begin_timestamp.isoformat() if sweep_data.begin_timestamp else None
-            sc_result.end_time = sweep_data.end_timestamp.isoformat() if sweep_data.end_timestamp else None
-            sc_result.message = str(job_data.job_error)
-            if wait_completion:
-                logger.error("Submission was revoked!")
-            return sc_result
+    @property
+    def _iqm_server_client(self) -> _IQMServerClient:
+        return self._pulla._iqm_server_client
 
-        return None
+    def result(self) -> CircuitMeasurementResultsBatch | None:
+        """Get (and cache) the job result, if the job has completed.
 
+        Returns:
+            Circuit measurement results for the job, or None if the results are not available.
 
-init_loggers({"iqm": "INFO"})
+        """
+        if not self._result:
+            self.update()
+            # if successful, get the results (TODO what about possible partial data?)
+            if self.status != JobStatus.COMPLETED:
+                return None
+
+            sweep_results = self._iqm_server_client.get_job_artifact_sweep_results(self.job_id)
+            self._result = map_sweep_results_to_logical_qubits(
+                sweep_results,
+                self._context["readout_mappings"],
+                self._context["options"].heralding_mode,
+            )
+        return self._result

iqm/pulla/utils.py

@@ -38,7 +38,7 @@ from iqm.cpc.interface.compiler import (
     HeraldingMode,
     ReadoutMappingBatch,
 )
-from iqm.pulla.interface import HERALDING_KEY, CalibrationSet, CircuitMeasurementResultsBatch
+from iqm.pulla.interface import HERALDING_KEY, CalibrationSetValues
 from iqm.pulse.builder import CircuitOperation, ScheduleBuilder, build_quantum_ops
 from iqm.pulse.gate_implementation import CompositeGate, OpCalibrationDataTree
 from iqm.pulse.playlist.channel import ChannelProperties
@@ -46,7 +46,7 @@ from iqm.pulse.playlist.instructions import Instruction
 from iqm.pulse.playlist.schedule import Schedule, Segment
 from iqm.pulse.timebox import TimeBox
 from iqm.station_control.client.qon import locus_str_to_locus
-from iqm.station_control.interface.models.observation import ObservationBase
+from iqm.station_control.interface.models import CircuitMeasurementResultsBatch, ObservationBase, QubitMapping
 
 logger = logging.getLogger(__name__)
 
@@ -78,7 +78,7 @@ def circuit_operations_to_cpc(circ_ops: tuple[CircuitOperation], name: str | Non
     return CPC_Circuit(name=name, instructions=circ_ops)
 
 
-def iqm_circuit_to_gate_implementation(circuit: CPC_Circuit, qubit_mapping: dict[str, str]) -> type[CompositeGate]:
+def iqm_circuit_to_gate_implementation(circuit: CPC_Circuit, qubit_mapping: QubitMapping) -> type[CompositeGate]:
     """Wrap a circuit to a single GateImplementation that can then be registered as an independent "gate".
 
     Returns a composite GateImplementation which, when called, produces a TimeBox with the circuit contents
@@ -469,7 +469,7 @@ def get_hash_for(circuit: CPC_Circuit) -> int:
     return hash(str_repr)
 
 
-def calset_to_cal_data_tree(calibration_set: CalibrationSet) -> OpCalibrationDataTree:
+def calset_to_cal_data_tree(calibration_set_values: CalibrationSetValues) -> OpCalibrationDataTree:
     """Build an iqm-pulse QuantumOp calibration data tree from a calibration set.
 
     Splits the dotted observation names that are prefixed with "gates." into the corresponding
@@ -488,7 +488,7 @@ def calset_to_cal_data_tree(calibration_set: CalibrationSet) -> OpCalibrationDat
         set_path(node.setdefault(path[0], {}), path[1:], value)
 
     tree: OpCalibrationDataTree = {}
-    for key, value in calibration_set.items():
+    for key, value in calibration_set_values.items():
         path = key.split(".")
         if path[0] == "gates":
             if len(path) < 5:
@@ -502,7 +502,7 @@ def calset_to_cal_data_tree(calibration_set: CalibrationSet) -> OpCalibrationDat
 
 
 def initialize_schedule_builder(
-    calibration_set: CalibrationSet,
+    calibration_set_values: CalibrationSetValues,
     chip_topology: ChipTopology,
     channel_properties: dict[str, ChannelProperties],
     component_channels: dict[str, dict[str, str]],
@@ -510,7 +510,7 @@ def initialize_schedule_builder(
     """Initialize a new schedule builder for the station, validate that it is configured properly.
 
     Args:
-        calibration_set: calibration data for the station the circuits are executed on
+        calibration_set_values: calibration data for the station the circuits are executed on
         chip_topology: topology of the QPU the circuits are executed on
         channel_properties: properties of control channels on the station
         component_channels: QPU component to function to channel mapping
@@ -520,11 +520,13 @@ def initialize_schedule_builder(
     """
     op_table = build_quantum_ops({})
 
-    channel_properties = _update_channel_props_from_calibration(channel_properties, component_channels, calibration_set)
+    channel_properties = _update_channel_props_from_calibration(
+        channel_properties, component_channels, calibration_set_values
+    )
 
     builder = ScheduleBuilder(
         op_table,
-        calset_to_cal_data_tree(calibration_set),
+        calset_to_cal_data_tree(calibration_set_values),
         chip_topology,
         channel_properties,
         component_channels,
@@ -535,14 +537,14 @@ def initialize_schedule_builder(
 def _update_channel_props_from_calibration(  # noqa: ANN202
     channel_properties: dict[str, ChannelProperties],
     component_channels: dict[str, dict[str, str]],
-    calset: CalibrationSet,
+    calibration_set_values: CalibrationSetValues,
 ):
-    """Copy probe line center frequencies from a calset to their readout channel properties.
+    """Copy probe line center frequencies from calibration set values to their readout channel properties.
 
     Args:
         channel_properties: channel properties to update
         component_channels: mapping from QPU component to its functions/channels that perform them
-        calset: calibration data
+        calibration_set_values: calibration data
     Returns:
         updated channel properties
 
@@ -551,9 +553,11 @@ def _update_channel_props_from_calibration(  # noqa: ANN202
     replacements = {}
     for component, channels in component_channels.items():
         if "readout" in channels:
-            center_frequency = calset.get(f"controllers.{component}.readout.center_frequency")
+            center_frequency = calibration_set_values.get(f"controllers.{component}.readout.center_frequency")
             if center_frequency is None:
-                center_frequency = calset.get(f"controllers.{component}.readout.local_oscillator.frequency")
+                center_frequency = calibration_set_values.get(
+                    f"controllers.{component}.readout.local_oscillator.frequency"
+                )
             if center_frequency is None:
                 raise CalibrationError(
                     f"No calibration value found for the center frequency or local oscillator frequency of {component}."
@@ -603,7 +607,7 @@ def find_circuit_boundary(
 
 def build_settings(
     shots: int,
-    calibration_set: CalibrationSet,
+    calibration_set_values: CalibrationSetValues,
     builder: ScheduleBuilder,
     circuit_metrics: Iterable[CircuitMetrics],
     *,
@@ -613,7 +617,7 @@ def build_settings(
 
     Args:
         shots: number of times to execute/sample each circuit
-        calibration_set: calibration data for the station the circuits are executed on
+        calibration_set_values: calibration data for the station the circuits are executed on
         builder: schedule builder object, encapsulating station properties and gate calibration data
         circuit_metrics: statistics about the circuits to be executed
         options: various discrete options for circuit execution that affect compilation
@@ -654,7 +658,7 @@ def build_settings(
         # of circuits is needlessly complicated and usually would yield a small benefit
         measured_probe_lines=device.probe_lines,
         shots=shots,
-        calibration_set=calibration_set,
+        calibration_set_values=calibration_set_values,
         boundary_qubits=boundary_components & device.qubits,
         boundary_couplers=boundary_couplers,
         flux_pulsed_qubits=[

iqm/pulla/utils_qir.py

@@ -40,6 +40,7 @@ from qiskit.providers import BackendV2
 from iqm.cpc.compiler.compiler import Compiler
 from iqm.cpc.interface.compiler import Circuit as CPC_Circuit
 from iqm.pulse import CircuitOperation
+from iqm.station_control.interface.models import QubitMapping
 
 qir_logger = logging.getLogger(__name__)
 
@@ -148,7 +149,7 @@ def _parse_double(value: str) -> float:
 
 
 def qir_to_pulla(  # noqa: PLR0915, PLR0912
-    compiler: Compiler, qir: str | bytes, qubit_mapping: dict[str, str] | None = None
+    compiler: Compiler, qir: str | bytes, qubit_mapping: QubitMapping | None = None
 ) -> tuple[list[CPC_Circuit], Compiler]:
     """Convert a QIR module to a CPC circuit.
 
@@ -257,7 +258,7 @@ def qir_to_pulla(  # noqa: PLR0915, PLR0912
     return circuits, compiler
 
 
-def generate_qiskit_qir_qubit_mapping(qiskit_circuit: QuantumCircuit, qiskit_backend: BackendV2) -> dict[str, str]:
+def generate_qiskit_qir_qubit_mapping(qiskit_circuit: QuantumCircuit, qiskit_backend: BackendV2) -> QubitMapping:
     """qiskit-qir has a bug, which causes qubit pointers to not be generated correctly
     according to the final_layout. So we replicate this logic here and generate a new mapping.
     Then we assign qiskit-qir index to the qiskit logic qubit idx.