iqm-pulla 7.22.0__py3-none-any.whl → 8.0.0__py3-none-any.whl

iqm/pulla/calibration.py

@@ -16,9 +16,14 @@
 
 from copy import deepcopy
 import logging
+import uuid
 
+from exa.common.data.value import ObservationValue
 from iqm.pulla.interface import CalibrationSet, CalibrationSetId
-from iqm.station_control.client.station_control import StationControlClient
+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__)
 
@@ -28,8 +33,8 @@ 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
+    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:
@@ -37,7 +42,7 @@ class CalibrationDataProvider:
         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)
+                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:
@@ -47,10 +52,44 @@ class CalibrationDataProvider:
         """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)
+            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
 
-        return self.get_calibration_set(latest_cal_set_id), 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]
+
+    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/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 JobStatus
-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,24 +248,22 @@ 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 <= JobStatus.EXECUTION_START:
+                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
 
-                elif sweep_data.job_status == JobStatus.READY:
+                elif sweep_data.job_status == JobExecutorStatus.READY:
                     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_client.get_sweep_results(job_id),
+                        self._station_control.get_sweep_results(job_id),
                         context["readout_mappings"],
                         context["options"].heralding_mode,
                     )
@@ -278,24 +278,24 @@ class Pulla:
 
                     return sc_result
 
-                elif sweep_data.job_status == JobStatus.FAILED:
+                elif sweep_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
-                    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
 
-                elif sweep_data.job_status == JobStatus.ABORTED:
+                elif sweep_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
-                    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/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/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.22.0.dist-info → iqm_pulla-8.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulla
-Version: 7.22.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 <8,>=7
+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 <8,>=7 ; 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 <8,>=7 ; 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 <8,>=7 ; extra == 'qiskit'
+Requires-Dist: iqm-station-control-client <10,>=9 ; extra == 'qiskit'
 Requires-Dist: iqm-pulse <10,>=9 ; extra == 'qiskit'
-Requires-Dist: iqm-client[qiskit] <28,>=27 ; extra == 'qiskit'
-Requires-Dist: iqm-client <28,>=27 ; extra == 'qiskit'
+Requires-Dist: iqm-client[qiskit] <30,>=29 ; extra == 'qiskit'
+Requires-Dist: iqm-client <30,>=29 ; extra == 'qiskit'
 
 IQM Pulla
 #########

{iqm_pulla-7.22.0.dist-info → iqm_pulla-8.0.0.dist-info}/RECORD

@@ -10,17 +10,18 @@ iqm/cpc/compiler/station_settings.py,sha256=VuwD2TkraCXJql59nRE3RgiQXEmor8oCor1P
 iqm/cpc/interface/__init__.py,sha256=mvhNx1I9K5Sg40CwPntWj35M3Bni__23PWEw_qYaXtQ,611
 iqm/cpc/interface/compiler.py,sha256=VBIAU3J4_BvC4tPwapLEUNe6OSwIW7LID7RJ7yRWCHc,10036
 iqm/pulla/__init__.py,sha256=fj5Qh8R9K-z6q5g9-CySBZsG8d33nU7hCHrqIIB8_-0,901
-iqm/pulla/calibration.py,sha256=9hWTsFg8cjvI-6k-he8cimKuR4WhIpoJX1f5g-VxyVY,2597
+iqm/pulla/calibration.py,sha256=tZJ_q9i1ndRxuPZIaDCyznxNu1LIUIwJ53Vf3t9VOkY,4537
 iqm/pulla/interface.py,sha256=yymQo4REHYcUOWgPxPYq9IixS9bBZ27LXLQgJhzET58,5400
-iqm/pulla/pulla.py,sha256=v-0Nkjclon2axRLWHuLm0QTLUVh8r9j0VT6sOkxRLOI,14203
-iqm/pulla/utils.py,sha256=3mEbX16wyqUfn9jDQ7JmKmdss9qqJ9zKTNTpTtyMw3U,24712
+iqm/pulla/pulla.py,sha256=PTSU0ft0Q0gt4k6n_gj4sznxnT9cAgd37eGeDhu9S5A,14007
+iqm/pulla/quantum_architecture.py,sha256=T3rrv4sg1zD6bCY5Jb6Lp8yE3E0YVTh2nK0KZttjK6s,6208
+iqm/pulla/utils.py,sha256=ZIJCmdufUjV_OJnaKTGWy64rhPOPDS0PYt1LtYdpTIc,24618
 iqm/pulla/utils_cirq.py,sha256=8SBy6w7cr4AmnCgKwh7dBWwBGfGKxnoEMv9-1yfKs0A,777
 iqm/pulla/utils_dd.py,sha256=SxYAuRBgvYELKjeXpFbP4mM0xCCivDk7WUHw7oEXfMo,1695
 iqm/pulla/utils_qir.py,sha256=6-VrdSXGZJnr2gNy9VEg449hIRv_P59iEvsFZPUlIn4,10018
 iqm/pulla/utils_qiskit.py,sha256=SG_YHHlQnmutlXiDayh-U1aYl4r2dJJHmAX0l5q0BdQ,10078
-iqm_pulla-7.22.0.dist-info/AUTHORS.rst,sha256=iCStz7WP5Jk7uMnn9jRA4ybS14X4yeUW2SsWE-OTaRk,328
-iqm_pulla-7.22.0.dist-info/LICENSE.txt,sha256=cCj_biRA4Q8A77vxR8AuvAf-DZ5G79yxR_3lYY6TrmA,11333
-iqm_pulla-7.22.0.dist-info/METADATA,sha256=NlUg0EV022mVEneQgQWw9CjSTB3K9oHraSof1fecZPo,17687
-iqm_pulla-7.22.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_pulla-7.22.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_pulla-7.22.0.dist-info/RECORD,,
+iqm_pulla-8.0.0.dist-info/AUTHORS.rst,sha256=iCStz7WP5Jk7uMnn9jRA4ybS14X4yeUW2SsWE-OTaRk,328
+iqm_pulla-8.0.0.dist-info/LICENSE.txt,sha256=cCj_biRA4Q8A77vxR8AuvAf-DZ5G79yxR_3lYY6TrmA,11333
+iqm_pulla-8.0.0.dist-info/METADATA,sha256=1HJknYlgrrfOHwaq8LP659CX9lyMqICX5IJzO7hVp_Y,17691
+iqm_pulla-8.0.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_pulla-8.0.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_pulla-8.0.0.dist-info/RECORD,,