iqm-pulla 7.23.0__tar.gz → 8.0.0__tar.gz

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/CHANGELOG.rst

@@ -2,6 +2,15 @@
 Changelog
 =========
 
+Version 8.0.0 (2025-06-13)
+==========================
+
+Features
+--------
+
+- Move :func:`get_calibration_set_values` logic from Station Control to Pulla.
+- Move :func:`create_dynamic_quantum_architecture` logic from Cocos to Pulla.
+
 Version 7.23.0 (2025-06-12)
 ===========================
 

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulla
-Version: 7.23.0
+Version: 8.0.0
 Summary: Client library for pulse-level access to an IQM quantum computer
 Author-email: IQM Finland Oy <developers@meetiqm.com>
 License:                                  Apache License
@@ -217,30 +217,30 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
 Requires-Dist: iqm-exa-common<27,>=26
-Requires-Dist: iqm-station-control-client<9,>=8
+Requires-Dist: iqm-station-control-client<10,>=9
 Requires-Dist: iqm-pulse<10,>=9
-Requires-Dist: iqm-data-definitions<3.0,>=2.6
+Requires-Dist: iqm-data-definitions<3.0,>=2.13
 Requires-Dist: pylatexenc==2.10
 Requires-Dist: pydantic<3.0,>=2.10.4
 Provides-Extra: notebook
 Requires-Dist: iqm-exa-common<27,>=26; extra == "notebook"
-Requires-Dist: iqm-station-control-client<9,>=8; extra == "notebook"
+Requires-Dist: iqm-station-control-client<10,>=9; extra == "notebook"
 Requires-Dist: iqm-pulse<10,>=9; extra == "notebook"
 Requires-Dist: notebook<7,>=6.4.11; extra == "notebook"
 Requires-Dist: matplotlib<4,>=3.6.3; extra == "notebook"
 Requires-Dist: nbclient~=0.5.10; extra == "notebook"
 Provides-Extra: qir
 Requires-Dist: iqm-exa-common<27,>=26; extra == "qir"
-Requires-Dist: iqm-station-control-client<9,>=8; extra == "qir"
+Requires-Dist: iqm-station-control-client<10,>=9; extra == "qir"
 Requires-Dist: iqm-pulse<10,>=9; extra == "qir"
 Requires-Dist: iqm-pyqir==0.12.0; extra == "qir"
 Requires-Dist: iqm-qiskit-qir==0.8.0; extra == "qir"
 Provides-Extra: qiskit
 Requires-Dist: iqm-exa-common<27,>=26; extra == "qiskit"
-Requires-Dist: iqm-station-control-client<9,>=8; extra == "qiskit"
+Requires-Dist: iqm-station-control-client<10,>=9; extra == "qiskit"
 Requires-Dist: iqm-pulse<10,>=9; extra == "qiskit"
-Requires-Dist: iqm-client<29,>=28; extra == "qiskit"
-Requires-Dist: iqm-client[qiskit]<29,>=28; extra == "qiskit"
+Requires-Dist: iqm-client[qiskit]<30,>=29; extra == "qiskit"
+Requires-Dist: iqm-client<30,>=29; extra == "qiskit"
 
 IQM Pulla
 #########

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/docs/Quick Start.ipynb

@@ -367,7 +367,7 @@
     "quantum_computer_url = os.environ.get(\"RESONANCE_QUANTUM_COMPUTER_URL\") \n",
     "api_token = os.environ.get(\"RESONANCE_API_TOKEN\")\n",
     "\n",
-    "p = Pulla(quantum_computer_url, get_token_callback=lambda: api_token)\n",
+    "p = Pulla(quantum_computer_url, get_token_callback=lambda: f\"Bearer {api_token}\")\n",
     "provider = IQMProvider(quantum_computer_url, token=api_token)\n",
     "backend = provider.get_backend()\n",
     "\n",

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/requirements/base.in

@@ -1,3 +1,3 @@
-iqm-data-definitions >= 2.6, < 3.0
+iqm-data-definitions >= 2.13, < 3.0
 pylatexenc == 2.10
 pydantic >= 2.10.4, < 3.0

iqm_pulla-8.0.0/requirements/base.txt

@@ -0,0 +1,6 @@
+iqm-exa-common>=26,<27
+iqm-station-control-client>=9,<10
+iqm-pulse>=9,<10
+iqm-data-definitions >= 2.13, < 3.0
+pylatexenc == 2.10
+pydantic >= 2.10.4, < 3.0

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/requirements/notebook.txt

@@ -1,5 +1,5 @@
 iqm-exa-common>=26,<27
-iqm-station-control-client>=8,<9
+iqm-station-control-client>=9,<10
 iqm-pulse>=9,<10
 notebook >= 6.4.11, < 7
 matplotlib >= 3.6.3, < 4

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/requirements/qir.txt

@@ -1,5 +1,5 @@
 iqm-exa-common>=26,<27
-iqm-station-control-client>=8,<9
+iqm-station-control-client>=9,<10
 iqm-pulse>=9,<10
 iqm-pyqir==0.12.0
 iqm-qiskit-qir==0.8.0

iqm_pulla-8.0.0/requirements/qiskit.txt

@@ -0,0 +1,5 @@
+iqm-exa-common>=26,<27
+iqm-station-control-client>=9,<10
+iqm-pulse>=9,<10
+iqm-client[qiskit]>=29,<30
+iqm-client>=29,<30

iqm_pulla-8.0.0/src/iqm/pulla/calibration.py

@@ -0,0 +1,95 @@
+# Copyright 2024-2025 IQM
+#
+# 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.
+
+"""Provider of calibration sets and quality metrics from remote IQM servers."""
+
+from copy import deepcopy
+import logging
+import uuid
+
+from exa.common.data.value import ObservationValue
+from iqm.pulla.interface import CalibrationSet, CalibrationSetId
+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
+
+logger = logging.getLogger(__name__)
+
+CalibrationDataFetchException = RuntimeError
+
+
+class CalibrationDataProvider:
+    """Access calibration info via station control client and cache data in memory."""
+
+    def __init__(self, station_control: StationControlInterface):
+        self._station_control = station_control
+        self._calibration_sets: dict[CalibrationSetId, CalibrationSet] = {}
+
+    def get_calibration_set(self, cal_set_id: CalibrationSetId) -> CalibrationSet:
+        """Get the calibration set from the database and cache it."""
+        logger.debug("Get the calibration set from the database: cal_set_id=%s", cal_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])
+        except Exception as e:
+            raise CalibrationDataFetchException("Could not fetch calibration set from the database.") from e
+
+    def get_latest_calibration_set(self, chip_label) -> tuple[CalibrationSet, CalibrationSetId]:
+        """Get the latest calibration set id for chip label from the database."""
+        logger.debug("Get the latest calibration set for chip label: chip_label=%s", chip_label)
+        try:
+            if isinstance(self._station_control, IqmServerClient):
+                latest_cal_set_id = self._station_control.get_latest_calibration_set_id(chip_label)
+                latest_calibration_set = self.get_calibration_set(latest_cal_set_id), latest_cal_set_id
+            else:
+                latest_calibration_set = self._get_latest_calibration_set(chip_label)
+        except Exception as e:
+            raise CalibrationDataFetchException(
+                f"Could not fetch latest calibration set id from the database: {e}"
+            ) from e
+        return latest_calibration_set, latest_calibration_set.observation_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]
+
+    def get_calibration_set_values(self, calibration_set_id: uuid.UUID) -> dict[str, ObservationValue]:
+        """Get saved calibration set observations by UUID
+
+        Args:
+            calibration_set_id: UUID of the calibration set to retrieve.
+
+        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)
+        return calibration_set_values

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/src/iqm/pulla/pulla.py

@@ -47,10 +47,8 @@ from iqm.pulla.interface import (
 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.station_control import StationControlClient
-from iqm.station_control.client.utils import get_progress_bar_callback
-from iqm.station_control.interface.models import JobExecutorStatus
-from iqm.station_control.interface.models.sweep import SweepDefinition
+from iqm.station_control.client.utils import get_progress_bar_callback, init_station_control
+from iqm.station_control.interface.models import JobExecutorStatus, SweepDefinition
 
 #    ██████  ██    ██ ██      ██       █████
 #    ██   ██ ██    ██ ██      ██      ██   ██
@@ -88,14 +86,15 @@ class Pulla:
 
         # SC Client to be used for fetching calibration data, submitting sweeps, and retrieving results.
         try:
-            self._station_control_client = StationControlClient.init(
+            self._station_control = init_station_control(
                 station_control_url, get_token_callback=self.get_token_callback, **kwargs
             )
+
         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_client)
+        self._calibration_data_provider = CalibrationDataProvider(self._station_control)
 
         # Data needed for the compiler.
         self._station_control_settings: SettingNode | None = None
@@ -159,9 +158,12 @@ class Pulla:
         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."""  # noqa: E501
+        """Returns the chip label of the current quantum computer.
+
+        The chip label is fetched from the Station Control API.
+        """
         try:
-            duts = self._station_control_client.get_duts()
+            duts = self._station_control.get_duts()
         except requests.RequestException as e:
             raise ChipLabelRetrievalException(f"Failed to retrieve the chip label: {e}") from e
 
@@ -172,7 +174,7 @@ class Pulla:
     def get_chip_topology(self) -> ChipTopology:
         """Returns chip topology that was fetched from the IQM server during Pulla initialization."""
         try:
-            record = self._station_control_client.get_chip_design_record(self.get_chip_label())
+            record = self._station_control.get_chip_design_record(self.get_chip_label())
         except Exception as e:
             raise CHADRetrievalException("Could not fetch chip design record") from e
         return ChipTopology.from_chip_design_record(record)
@@ -182,7 +184,7 @@ class Pulla:
         if self._station_control_settings is None:
             # request the station settings, cache the results
             try:
-                self._station_control_settings = self._station_control_client.get_settings()
+                self._station_control_settings = self._station_control.get_settings()
             except Exception as e:
                 raise SettingsRetrievalException("Could not fetch station settings") from e
         return self._station_control_settings
@@ -227,7 +229,7 @@ class Pulla:
                 if k == "readout":
                     readout_components.append(v)
 
-        sweep_response = self._station_control_client.sweep(
+        sweep_response = self._station_control.sweep(
             SweepDefinition(
                 sweep_id=uuid.uuid4(),
                 playlist=playlist,
@@ -246,15 +248,13 @@ class Pulla:
             logger.info("Waiting for the job to finish...")
 
             while True:
-                sweep_data = self._station_control_client.get_sweep(job_id)
+                sweep_data = self._station_control.get_sweep(job_id)
                 sc_result = StationControlResult(sweep_id=job_id, task_id=job_id, status=TaskStatus.PENDING)
 
                 if sweep_data.job_status <= JobExecutorStatus.EXECUTION_STARTED:
                     # Wait in the task queue while showing a progress bar
 
-                    interrupted = self._station_control_client._wait_job_completion(
-                        str(job_id), get_progress_bar_callback()
-                    )
+                    interrupted = self._station_control._wait_job_completion(str(job_id), get_progress_bar_callback())
                     if interrupted:
                         raise KeyboardInterrupt
 
@@ -263,7 +263,7 @@ class Pulla:
 
                     sc_result.status = TaskStatus.READY
                     sc_result.result = map_sweep_results_to_logical_qubits(
-                        self._station_control_client.get_sweep_results(job_id),
+                        self._station_control.get_sweep_results(job_id),
                         context["readout_mappings"],
                         context["options"].heralding_mode,
                     )
@@ -284,7 +284,7 @@ class Pulla:
                         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
-                    job = self._station_control_client.get_job(job_id)
+                    job = self._station_control.get_job(job_id)
                     sc_result.message = job["job_error"]
                     logger.error("Submission failed! Error: %s", sc_result.message)
                     return sc_result
@@ -295,7 +295,7 @@ class Pulla:
                         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
-                    job = self._station_control_client.get_job(job_id)
+                    job = self._station_control.get_job(job_id)
                     sc_result.message = job["job_error"]
                     logger.error("Submission was revoked!")
                     return sc_result
@@ -304,7 +304,7 @@ class Pulla:
 
         except KeyboardInterrupt as exc:
             logger.info("Caught KeyboardInterrupt, revoking job %s", job_id)
-            self._station_control_client.abort_job(job_id)
+            self._station_control.abort_job(job_id)
             raise KeyboardInterrupt from exc
 
 

iqm_pulla-8.0.0/src/iqm/pulla/quantum_architecture.py

@@ -0,0 +1,142 @@
+"""Methods for creating static and dynamic quantum architectures."""
+
+from collections import Counter
+import logging
+from uuid import UUID
+
+from exa.common.qcm_data.chip_topology import ChipTopology, sort_components
+from iqm.pulse.builder import build_quantum_ops
+from iqm.station_control.interface.models import (
+    DynamicQuantumArchitecture,
+    GateImplementationInfo,
+    GateInfo,
+    Locus,
+    ObservationLite,
+    StaticQuantumArchitecture,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def create_static_quantum_architecture(chip_topology: ChipTopology) -> StaticQuantumArchitecture:
+    """Creates a static quantum architecture (SQA) for the given chip topology.
+
+    Args:
+        chip_topology: The chip topology.
+
+    Returns:
+         Static quantum architecture containing information about qubits, computational resonators, and connectivity.
+
+    """
+    # Components within each connection are sorted by coupler_to_components
+    unsorted_connections = list(chip_topology.coupler_to_components.values())
+    # Sort connections first based on the first component, then the second component etc. of each connection
+    sorted_components = sort_components({component for connection in unsorted_connections for component in connection})
+    component_to_index = {component: index for index, component in enumerate(sorted_components)}
+
+    def sort_key(connection: tuple[str, ...]) -> tuple[int, ...]:
+        return tuple(component_to_index[component] for component in connection)
+
+    # The components in each connection are already sorted, now we sort the connections
+    connectivity = sorted(unsorted_connections, key=sort_key)
+    return StaticQuantumArchitecture(
+        qubits=chip_topology.qubits_sorted,
+        computational_resonators=chip_topology.computational_resonators_sorted,
+        connectivity=connectivity,
+    )
+
+
+def create_dynamic_quantum_architecture(
+    calibration_set_id: UUID,
+    observations: list[ObservationLite],
+    chip_topology: ChipTopology,
+) -> DynamicQuantumArchitecture:
+    """Creates a dynamic quantum architecture (DQA) for the given calibration set.
+
+    Args:
+        calibration_set_id: ID of the calibration set used to create the DQA.
+        observations: Calibration set observations used to create the DQA.
+        chip_topology: The chip topology.
+
+    Returns:
+         Dynamic quantum architecture containing information about calibrated gates/operations.
+
+    """
+    qubits: set[str] = set()
+    computational_resonators: set[str] = set()
+    gates: dict[str, GateInfo] = {}
+
+    # known gates and implementations
+    quantum_op_table = build_quantum_ops({})
+
+    # error reporting
+    unknown_ops: set[str] = set()
+    unknown_implementations: set[str] = set()
+
+    def analyze_observation(obs_name: str) -> None:
+        """Deduce ops/implementations/loci and used QPU components from the gate cal data."""
+        parts = obs_name.split(".")
+        if parts[0] == "gates":
+            gate_name, gate_implementation, gate_locus = parts[1:4]
+            # ignore unknown gates and implementations (for backwards and forwards compatibility)
+            if (quantum_op := quantum_op_table.get(gate_name)) is None:
+                unknown_ops.add(gate_name)
+                return
+            if gate_implementation not in quantum_op.implementations:
+                unknown_implementations.add(f"{gate_name}.{gate_implementation}")
+                return
+
+            gate_info = gates.setdefault(
+                gate_name,
+                GateInfo(
+                    implementations={},
+                    default_implementation="",
+                    override_default_implementation={},
+                ),
+            )
+            gate_implementation_info = gate_info.implementations.setdefault(
+                gate_implementation, GateImplementationInfo(loci=tuple())
+            )
+            gate_locus_components = tuple(gate_locus.split("__"))
+            if gate_locus_components not in gate_implementation_info.loci:
+                gate_implementation_info.loci += (gate_locus_components,)
+            for locus_component in gate_locus_components:
+                if chip_topology.is_qubit(locus_component):
+                    qubits.add(locus_component)
+                if chip_topology.is_computational_resonator(locus_component):
+                    computational_resonators.add(locus_component)
+
+    for observation in observations:
+        analyze_observation(observation.dut_field)
+
+    for name in unknown_ops:
+        logger.info("Unknown operation '%s' found in calibration set %s", name, str(calibration_set_id))
+    for name in unknown_implementations:
+        logger.info("Unknown implementation '%s' found in calibration set %s", name, str(calibration_set_id))
+
+    # Now ``gates`` only contains known gates and implementations, and each implementation has
+    # at least one locus. Pick a default implementations for each available (gate, locus).
+    for gate_name, gate_info in gates.items():
+        locus_default_implementations: dict[Locus, str] = {}
+
+        # pick the default implementation for each locus using the hardcoded priority order
+        for implementation in quantum_op_table[gate_name].implementations:
+            if implementation in gate_info.implementations:
+                for locus in gate_info.implementations[implementation].loci:
+                    locus_default_implementations.setdefault(locus, implementation)
+
+        # choose default implementation to be the most common locus-specific default,
+        # and add the other locus-specific defaults to override_default_implementation
+        gate_info.default_implementation = Counter(locus_default_implementations.values()).most_common(1)[0][0]
+        gate_info.override_default_implementation = {
+            locus: implementation
+            for locus, implementation in locus_default_implementations.items()
+            if implementation != gate_info.default_implementation
+        }
+
+    return DynamicQuantumArchitecture(
+        calibration_set_id=calibration_set_id,
+        qubits=sort_components(qubits),
+        computational_resonators=sort_components(computational_resonators),
+        gates=gates,
+    )

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/src/iqm/pulla/utils.py

@@ -42,7 +42,6 @@ from iqm.pulse.playlist.channel import ChannelProperties
 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 import utils as station_control_client_utils
 from iqm.station_control.interface.models.observation import ObservationBase
 
 LOCUS_SEPARATOR = "__"  # EXA uses this, currently
@@ -602,4 +601,4 @@ def calset_from_observations(calset_observations: Iterable[ObservationBase]) ->
         calibration set
 
     """
-    return station_control_client_utils.calset_from_observations(calset_observations)
+    return {obs.dut_field: obs.value for obs in calset_observations}

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/src/iqm_pulla.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulla
-Version: 7.23.0
+Version: 8.0.0
 Summary: Client library for pulse-level access to an IQM quantum computer
 Author-email: IQM Finland Oy <developers@meetiqm.com>
 License:                                  Apache License
@@ -217,30 +217,30 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
 Requires-Dist: iqm-exa-common<27,>=26
-Requires-Dist: iqm-station-control-client<9,>=8
+Requires-Dist: iqm-station-control-client<10,>=9
 Requires-Dist: iqm-pulse<10,>=9
-Requires-Dist: iqm-data-definitions<3.0,>=2.6
+Requires-Dist: iqm-data-definitions<3.0,>=2.13
 Requires-Dist: pylatexenc==2.10
 Requires-Dist: pydantic<3.0,>=2.10.4
 Provides-Extra: notebook
 Requires-Dist: iqm-exa-common<27,>=26; extra == "notebook"
-Requires-Dist: iqm-station-control-client<9,>=8; extra == "notebook"
+Requires-Dist: iqm-station-control-client<10,>=9; extra == "notebook"
 Requires-Dist: iqm-pulse<10,>=9; extra == "notebook"
 Requires-Dist: notebook<7,>=6.4.11; extra == "notebook"
 Requires-Dist: matplotlib<4,>=3.6.3; extra == "notebook"
 Requires-Dist: nbclient~=0.5.10; extra == "notebook"
 Provides-Extra: qir
 Requires-Dist: iqm-exa-common<27,>=26; extra == "qir"
-Requires-Dist: iqm-station-control-client<9,>=8; extra == "qir"
+Requires-Dist: iqm-station-control-client<10,>=9; extra == "qir"
 Requires-Dist: iqm-pulse<10,>=9; extra == "qir"
 Requires-Dist: iqm-pyqir==0.12.0; extra == "qir"
 Requires-Dist: iqm-qiskit-qir==0.8.0; extra == "qir"
 Provides-Extra: qiskit
 Requires-Dist: iqm-exa-common<27,>=26; extra == "qiskit"
-Requires-Dist: iqm-station-control-client<9,>=8; extra == "qiskit"
+Requires-Dist: iqm-station-control-client<10,>=9; extra == "qiskit"
 Requires-Dist: iqm-pulse<10,>=9; extra == "qiskit"
-Requires-Dist: iqm-client<29,>=28; extra == "qiskit"
-Requires-Dist: iqm-client[qiskit]<29,>=28; extra == "qiskit"
+Requires-Dist: iqm-client[qiskit]<30,>=29; extra == "qiskit"
+Requires-Dist: iqm-client<30,>=29; extra == "qiskit"
 
 IQM Pulla
 #########

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/src/iqm_pulla.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ src/iqm/pulla/__init__.py
 src/iqm/pulla/calibration.py
 src/iqm/pulla/interface.py
 src/iqm/pulla/pulla.py
+src/iqm/pulla/quantum_architecture.py
 src/iqm/pulla/utils.py
 src/iqm/pulla/utils_cirq.py
 src/iqm/pulla/utils_dd.py

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/src/iqm_pulla.egg-info/requires.txt

@@ -1,13 +1,13 @@
 iqm-exa-common<27,>=26
-iqm-station-control-client<9,>=8
+iqm-station-control-client<10,>=9
 iqm-pulse<10,>=9
-iqm-data-definitions<3.0,>=2.6
+iqm-data-definitions<3.0,>=2.13
 pylatexenc==2.10
 pydantic<3.0,>=2.10.4
 
 [notebook]
 iqm-exa-common<27,>=26
-iqm-station-control-client<9,>=8
+iqm-station-control-client<10,>=9
 iqm-pulse<10,>=9
 notebook<7,>=6.4.11
 matplotlib<4,>=3.6.3
@@ -15,14 +15,14 @@ nbclient~=0.5.10
 
 [qir]
 iqm-exa-common<27,>=26
-iqm-station-control-client<9,>=8
+iqm-station-control-client<10,>=9
 iqm-pulse<10,>=9
 iqm-pyqir==0.12.0
 iqm-qiskit-qir==0.8.0
 
 [qiskit]
 iqm-exa-common<27,>=26
-iqm-station-control-client<9,>=8
+iqm-station-control-client<10,>=9
 iqm-pulse<10,>=9
-iqm-client<29,>=28
-iqm-client[qiskit]<29,>=28
+iqm-client[qiskit]<30,>=29
+iqm-client<30,>=29

{iqm_pulla-7.23.0 → iqm_pulla-8.0.0}/tests/conftest.py

@@ -18,6 +18,7 @@ from importlib.metadata import version
 import json
 import os
 from pathlib import Path
+from unittest.mock import Mock
 from uuid import UUID
 
 from httpx import Response as HTTPResponse
@@ -27,6 +28,7 @@ from iqm.iqm_client.models import (
     GateInfo,
 )
 from iqm.qiskit_iqm.iqm_provider import IQMBackend, IQMClient
+from mockito import ANY, mock, when
 import pytest
 import requests
 from requests import Response
@@ -80,18 +82,19 @@ def pulla_on_spark(request, monkeypatch):
         # TODO SW-1387: Use v1 API
         # if args[0] == f"{root_url}/station/v1/about":
         if args[0] == f"{root_url}/station/about":
-            response = Response()
+            response = Mock(spec=Response)
             response.status_code = HTTPStatus.OK
-            response.json = lambda: {
-                "software_versions": {"iqm-station-control-client": version("iqm-station-control-client")}
-            }
+            data = {"software_versions": {"iqm-station-control-client": version("iqm-station-control-client")}}
+            response.text = json.dumps(data)
+            response.json = lambda: data
+            response.ok = True
             return response
         # TODO SW-1387: Use v1 API
         # if args[0] == f"{root_url}/station/v1/duts":
         if args[0] == f"{root_url}/station/duts":
-            response = Response()
+            response = Mock(spec=Response)
             response.status_code = HTTPStatus.OK
-            response.json = lambda: [{"label": "M000_fake_0_0", "dut_type": "chip"}]
+            response.text = json.dumps([{"label": "M000_fake_0_0", "dut_type": "chip"}])
             return response
         # TODO SW-1387: Use v1 API
         # if args[0].startswith(f"{root_url}/station/v1/sweeps/"):
@@ -232,10 +235,13 @@ def qiskit_backend_spark(monkeypatch) -> IQMBackend:
     )
 
     monkeypatch.setattr(IQMClient, "get_dynamic_quantum_architecture", lambda self, calset_id: dqa)
-    if hasattr(IQMClient, "_check_versions"):  # _check_versions was introduced in a minor version of IQM Client
-        monkeypatch.setattr(IQMClient, "_check_versions", lambda self: None)
-    client = IQMClient(f"{root_url}/cocos", client_signature="test fixture")
-    return IQMBackend(client, calibration_set_id=calset_id)
+    monkeypatch.setattr(StationControlClient, "_check_api_versions", lambda self: None)
+    mock_about_response = mock(spec=Response)
+    when(mock_about_response).raise_for_status().thenReturn(None)
+    when(mock_about_response).json().thenReturn({})
+    when(requests).get(f"{root_url}/station/about", headers=ANY).thenReturn(mock_about_response)
+    iqm_client = IQMClient(f"{root_url}/station", client_signature="test fixture")
+    return IQMBackend(iqm_client, calibration_set_id=calset_id)
 
 
 @pytest.fixture

iqm_pulla-8.0.0/version.txt

@@ -0,0 +1 @@
+8.0.0

iqm_pulla-7.23.0/requirements/base.txt

@@ -1,6 +0,0 @@
-iqm-exa-common>=26,<27
-iqm-station-control-client>=8,<9
-iqm-pulse>=9,<10
-iqm-data-definitions >= 2.6, < 3.0
-pylatexenc == 2.10
-pydantic >= 2.10.4, < 3.0

iqm_pulla-7.23.0/requirements/qiskit.txt

@@ -1,5 +0,0 @@
-iqm-exa-common>=26,<27
-iqm-station-control-client>=8,<9
-iqm-pulse>=9,<10
-iqm-client>=28,<29
-iqm-client[qiskit]>=28,<29

iqm_pulla-7.23.0/src/iqm/pulla/calibration.py

@@ -1,56 +0,0 @@
-# Copyright 2024-2025 IQM
-#
-# 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.
-
-"""Provider of calibration sets and quality metrics from remote IQM servers."""
-
-from copy import deepcopy
-import logging
-
-from iqm.pulla.interface import CalibrationSet, CalibrationSetId
-from iqm.station_control.client.station_control import StationControlClient
-
-logger = logging.getLogger(__name__)
-
-CalibrationDataFetchException = RuntimeError
-
-
-class CalibrationDataProvider:
-    """Access calibration info via station control client and cache data in memory."""
-
-    def __init__(self, station_control_client: StationControlClient):
-        self._station_control_client = station_control_client
-        self._calibration_sets: dict[CalibrationSetId, CalibrationSet] = {}
-
-    def get_calibration_set(self, cal_set_id: CalibrationSetId) -> CalibrationSet:
-        """Get the calibration set from the database and cache it."""
-        logger.debug("Get the calibration set from the database: cal_set_id=%s", cal_set_id)
-        try:
-            if cal_set_id not in self._calibration_sets:
-                cal_set_values = self._station_control_client.get_calibration_set_values(cal_set_id)
-                self._calibration_sets[cal_set_id] = cal_set_values
-            return deepcopy(self._calibration_sets[cal_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) -> tuple[CalibrationSet, CalibrationSetId]:
-        """Get the latest calibration set id for chip label from the database."""
-        logger.debug("Get the latest calibration set for chip label: chip_label=%s", chip_label)
-        try:
-            latest_cal_set_id = self._station_control_client.get_latest_calibration_set_id(chip_label)
-        except Exception as e:
-            raise CalibrationDataFetchException(
-                f"Could not fetch latest calibration set id from the database: {e}"
-            ) from e
-
-        return self.get_calibration_set(latest_cal_set_id), latest_cal_set_id

iqm_pulla-7.23.0/version.txt

@@ -1 +0,0 @@
-7.23.0