iqm-station-control-client 3.12__py3-none-any.whl → 3.14__py3-none-any.whl

iqm/station_control/client/iqm_server/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 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.
+"""StationControlClient implementation for IQM Server"""

iqm/station_control/client/iqm_server/error.py

@@ -0,0 +1,30 @@
+# Copyright 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.
+
+from exa.common.errors.server_errors import StationControlError
+
+
+class IqmServerError(StationControlError):
+    def __init__(self, message: str, status_code: str, error_code: str | None = None, details: dict | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.error_code = error_code
+        self.details = details
+
+    def __str__(self):
+        s = f"{self.message} (status_code = {self.status_code}, error_code = {self.error_code}"
+        if details := self.details:
+            s += f", details = {details}"
+        s += ")"
+        return s

iqm/station_control/client/iqm_server/grpc_utils.py

@@ -0,0 +1,154 @@
+# Copyright 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.
+"""Internal utility functions used by IqmServerClient."""
+
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from datetime import datetime
+import uuid
+
+from google.protobuf import json_format, struct_pb2, timestamp_pb2
+import grpc
+from grpc import Compression
+from pydantic import HttpUrl
+
+from iqm.station_control.client.iqm_server import proto
+from iqm.station_control.client.iqm_server.error import IqmServerError
+
+
+class ClientCallDetails(grpc.ClientCallDetails):
+    def __init__(self, details):
+        self.method = details.method
+        self.metadata = list(details.metadata or [])
+        self.timeout = details.timeout
+        self.credentials = details.credentials
+        self.wait_for_ready = details.wait_for_ready
+        self.compression = details.compression
+
+
+class ApiTokenAuth(grpc.UnaryUnaryClientInterceptor, grpc.UnaryStreamClientInterceptor):
+    def __init__(self, get_token_callback: Callable[[], str]):
+        self.get_token_callback = get_token_callback
+
+    def _add_auth_header(self, client_call_details) -> ClientCallDetails:
+        details = ClientCallDetails(client_call_details)
+        token = self.get_token_callback()
+        details.metadata.append(("authorization", f"Bearer {token}"))
+        return details
+
+    def intercept_unary_stream(self, continuation, client_call_details, request):
+        return continuation(self._add_auth_header(client_call_details), request)
+
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        return continuation(self._add_auth_header(client_call_details), request)
+
+
+@dataclass(frozen=True, kw_only=True)
+class ConnectionParameters:
+    server_address: str
+    is_secure: bool
+    quantum_computer: str
+    use_timeslot: bool
+
+
+def parse_connection_params(qc_url: str) -> ConnectionParameters:
+    # Security measure: mitigate UTF-8 read order control character
+    # exploits by allowing only ASCII urls
+    if not qc_url.isascii():
+        raise ValueError("Invalid quantum computer URL")
+
+    # IQM Server QC urls are now form "https://cocos.<server_base_url>/<qc_name>[:timeslot]"
+    # In the future, "cocos." subdomain will be dropped. The parsing logic should work with
+    # the both url formats
+    url = HttpUrl(qc_url)
+    qc_name = (url.path or "").split("/")[-1].removesuffix(":timeslot")
+    use_timeslot = qc_url.endswith(":timeslot")
+    if not qc_name:
+        raise ValueError("Invalid quantum computer URL: device name is missing")
+
+    is_secure = url.scheme == "https"
+    hostname = (url.host or "").removeprefix("cocos.")
+    port = url.port or (443 if is_secure else 80)
+
+    return ConnectionParameters(
+        server_address=f"{hostname}:{port}",
+        is_secure=is_secure,
+        quantum_computer=qc_name,
+        use_timeslot=use_timeslot,
+    )
+
+
+def create_channel(
+    connection_params: ConnectionParameters,
+    get_token_callback: Callable[[], str] | None = None,
+    enable_compression: bool = True,
+) -> grpc.Channel:
+    compression = Compression.Gzip if enable_compression else None
+    options = [
+        # Let's try to parametrize this at least when we're merging station-control-client and iqm-client
+        ("grpc.keepalive_time_ms", 5000),
+        ("grpc.keepalive_permit_without_calls", 1),
+        ("grpc.http2.max_pings_without_data", 0),
+        ("grpc.keepalive_timeout_ms", 1000),
+    ]
+    address = connection_params.server_address
+    channel = (
+        grpc.secure_channel(
+            address, credentials=grpc.ssl_channel_credentials(), options=options, compression=compression
+        )
+        if connection_params.is_secure
+        else grpc.insecure_channel(address, options=options, compression=compression)
+    )
+    if get_token_callback is not None:
+        channel = grpc.intercept_channel(channel, ApiTokenAuth(get_token_callback))
+    return channel
+
+
+def to_proto_uuid(value: uuid.UUID) -> proto.Uuid:
+    return proto.Uuid(raw=value.bytes)
+
+
+def from_proto_uuid(value: proto.Uuid) -> uuid.UUID:
+    if value.WhichOneof("data") == "str":
+        return uuid.UUID(hex=value.str)
+    return uuid.UUID(bytes=value.raw)
+
+
+def to_datetime(timestamp: timestamp_pb2.Timestamp) -> datetime:
+    return timestamp.ToDatetime()
+
+
+def load_all(chunks: Iterable[proto.DataChunk]) -> bytes:
+    result = bytearray()
+    for chunk in chunks:
+        result.extend(chunk.data)
+    return bytes(result)
+
+
+def extract_error(error: grpc.RpcError, title: str | None = None) -> IqmServerError:
+    message = error.details()
+    status_code = str(error.code().name)
+    metadata = {k: v for k, v in list(error.initial_metadata()) + list(error.trailing_metadata())}
+    error_code = str(metadata.get("error_code")) if "error_code" in metadata else None
+    details = None
+    if details_bin := metadata.get("grpc-status-details-bin"):
+        value_proto = struct_pb2.Value()
+        value_proto.ParseFromString(details_bin)
+        details = json_format.MessageToJson(value_proto)
+    return IqmServerError(
+        message=f"{title}: {message}" if title else message,
+        status_code=status_code,
+        error_code=error_code,
+        details=details,
+    )

iqm/station_control/client/iqm_server/iqm_server_client.py

@@ -0,0 +1,332 @@
+# Copyright 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.
+"""StationControlClient implementation for IQM Server"""
+
+from collections.abc import Callable, Iterable
+from contextlib import contextmanager
+import dataclasses
+from io import BytesIO
+import json
+import logging
+from time import sleep
+from typing import Any, TypeVar, cast
+import uuid
+
+import grpc
+from iqm.models.channel_properties import ChannelProperties
+
+from exa.common.data.setting_node import SettingNode
+from exa.common.data.value import ObservationValue, validate_value
+from iqm.station_control.client.iqm_server import proto
+from iqm.station_control.client.iqm_server.error import IqmServerError
+from iqm.station_control.client.iqm_server.grpc_utils import (
+    create_channel,
+    extract_error,
+    from_proto_uuid,
+    load_all,
+    parse_connection_params,
+    to_datetime,
+    to_proto_uuid,
+)
+from iqm.station_control.client.iqm_server.meta_class import IqmServerClientMeta
+from iqm.station_control.client.list_models import DutFieldDataList, DutList
+from iqm.station_control.client.serializers import deserialize_sweep_results, serialize_sweep_task_request
+from iqm.station_control.client.serializers.channel_property_serializer import unpack_channel_properties
+from iqm.station_control.client.serializers.setting_node_serializer import deserialize_setting_node
+from iqm.station_control.client.serializers.task_serializers import deserialize_sweep_task_request
+from iqm.station_control.client.station_control import StationControlClient
+from iqm.station_control.interface.models import (
+    DutData,
+    DutFieldData,
+    Statuses,
+    SweepData,
+    SweepDefinition,
+    SweepResults,
+    SweepStatus,
+)
+from iqm.station_control.interface.models.sweep import SweepBase
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class IqmServerClient(StationControlClient, metaclass=IqmServerClientMeta):
+    def __init__(
+        self,
+        root_url: str,
+        get_token_callback: Callable[[], str] | None = None,
+        grpc_channel: grpc.Channel | None = None,
+    ):
+        self.root_url = root_url
+        self._connection_params = parse_connection_params(root_url)
+        self._cached_resources = {}
+        self._latest_submitted_sweep = None
+        self._channel = grpc_channel or create_channel(self._connection_params, get_token_callback)
+        self._current_qc = resolve_current_qc(self._channel, self._connection_params.quantum_computer)
+
+    def __del__(self):
+        try:
+            self._channel.close()
+        except Exception:
+            pass
+
+    def get_about(self) -> dict:
+        return self._get_resource("about", parse_json)
+
+    def get_configuration(self) -> dict:
+        return self._get_resource("configuration", parse_json)
+
+    def get_settings(self) -> SettingNode:
+        return self._get_resource("settings", deserialize_setting_node).copy()
+
+    def get_chip_design_record(self, dut_label: str) -> dict:
+        return self._get_resource(f"chip-design-records/{dut_label}", parse_json)
+
+    def get_channel_properties(self) -> dict[str, ChannelProperties]:
+        return self._get_resource("channel-properties", unpack_channel_properties)
+
+    def get_duts(self) -> list[DutData]:
+        return self._get_resource("duts", lambda data: DutList.model_validate(parse_json(data)))
+
+    def get_dut_fields(self, dut_label: str) -> list[DutFieldData]:
+        return self._get_resource(
+            f"dut-fields/{dut_label}", lambda data: DutFieldDataList.model_validate(parse_json(data))
+        )
+
+    def sweep(self, sweep_definition: SweepDefinition) -> dict:
+        with wrap_error("Job submission failed"):
+            jobs = proto.JobsStub(self._channel)
+            job: proto.JobV1 = jobs.SubmitJobV1(
+                proto.SubmitJobRequestV1(
+                    qc_id=self._current_qc.id,
+                    type=proto.JobType.PULSE,
+                    payload=serialize_sweep_task_request(sweep_definition, queue_name="sweeps"),
+                    use_timeslot=self._connection_params.use_timeslot,
+                )
+            )
+            # Optimization: we know that in most of the cases the submitted sweep is queried
+            # right after submitting it so we can cache reference to the submitted sweep here
+            # to avoid extra request to the server
+            job_id = from_proto_uuid(job.id)
+            self._latest_submitted_sweep = dataclasses.replace(sweep_definition, sweep_id=job_id)
+            return {
+                "sweep_id": str(job_id),
+                "task_id": str(job_id),
+            }
+
+    def get_sweep(self, sweep_id: uuid.UUID) -> SweepData:
+        with wrap_error("Job loading failed"):
+            jobs = proto.JobsStub(self._channel)
+            job_lookup = proto.JobLookupV1(id=to_proto_uuid(sweep_id))
+            job: proto.JobV1 = jobs.GetJobV1(job_lookup)
+            # IQM server job does not include any details about the sweep properties so we need to
+            # construct the resulting sweep data using the payload (= input sweep) and metadata
+            # from the IQM server job
+            sweep = self._get_cached_sweep(sweep_id) or payload_to_sweep(load_all(jobs.GetJobPayloadV1(job_lookup)))
+            return SweepData(
+                created_timestamp=to_datetime(job.created_at),
+                modified_timestamp=to_datetime(job.updated_at),
+                begin_timestamp=to_datetime(job.execution_started_at) if job.HasField("execution_started_at") else None,
+                end_timestamp=to_datetime(job.execution_ended_at) if job.HasField("execution_ended_at") else None,
+                sweep_status=to_sweep_status(job.status),
+                # Sweep definition is a subclass of SweepBase so we can just copy all SweepBase fields
+                # from the input sweep to the sweep data
+                **{f.name: getattr(sweep, f.name) for f in dataclasses.fields(SweepBase)},
+            )
+
+    def get_sweep_results(self, sweep_id: uuid.UUID) -> SweepResults:
+        with wrap_error("Job result loading failed"):
+            jobs = proto.JobsStub(self._channel)
+            data_chunks = jobs.GetJobResultsV1(proto.JobLookupV1(id=to_proto_uuid(sweep_id)))
+            return deserialize_sweep_results(load_all(data_chunks))
+
+    def revoke_sweep(self, sweep_id: uuid.UUID) -> None:
+        with wrap_error("Job cancellation failed"):
+            jobs = proto.JobsStub(self._channel)
+            jobs.CancelJobV1(proto.JobLookupV1(id=to_proto_uuid(sweep_id)))
+
+    def get_task(self, task_id: uuid.UUID) -> dict:
+        with wrap_error("Job loading failed"):
+            jobs = proto.JobsStub(self._channel)
+            job: proto.JobV1 = jobs.GetJobV1(proto.JobLookupV1(id=to_proto_uuid(task_id)))
+            return {
+                # It would be nice to have these typed somewhere...
+                "task_id": str(from_proto_uuid(job.id)),
+                "task_status": to_task_status(job.status),
+                "task_result": {"message": ""},
+                "task_error": job.error if job.HasField("error") else "",
+                "position": job.queue_position if job.HasField("queue_position") else None,
+                "is_position_capped": False,
+            }
+
+    def _wait_task_completion(
+        self,
+        task_id: str,
+        update_progress_callback: Callable[[Statuses], None] | None,
+    ) -> bool:
+        with wrap_error("Job subscription failed"):
+            try:
+                notify = update_progress_callback or (lambda _: None)
+                job_id = uuid.UUID(task_id)
+                initial_queue_position = None
+                status = None
+                # SubscribeToJobV1 runs until job reaches its final status (completed, failed, interrupted)
+                job_events = subscribe_to_job_events(self._channel, job_id)
+                for job in job_events:
+                    status = job.status
+                    if status == proto.JobStatus.IN_QUEUE:
+                        if initial_queue_position is None:
+                            initial_queue_position = job.queue_position
+                        queue_progress = initial_queue_position - job.queue_position
+                        notify([("Progress in queue", queue_progress, initial_queue_position)])
+                # In case of success, mark progress bar to 100% (looks nicer)
+                if initial_queue_position is not None and status == proto.JobStatus.COMPLETED:
+                    notify([("Progress in queue", initial_queue_position, initial_queue_position)])
+                return False
+            except KeyboardInterrupt:
+                return True
+
+    def get_calibration_set_values(self, calibration_set_id: uuid.UUID) -> dict[str, ObservationValue]:
+        with wrap_error("Calibration set loading failed"):
+            calibrations = proto.CalibrationsStub(self._channel)
+            data_chunks = calibrations.GetFullCalibrationDataV1(
+                proto.CalibrationLookupV1(
+                    id=to_proto_uuid(calibration_set_id),
+                )
+            )
+            _, cal_set_values = parse_calibration_set(load_all(data_chunks))
+            return cal_set_values
+
+    def get_latest_calibration_set_id(self, dut_label: str) -> uuid.UUID:
+        with wrap_error("Calibration set metadata loading failed"):
+            calibrations = proto.CalibrationsStub(self._channel)
+            metadata: proto.CalibrationMetadataV1 = calibrations.GetLatestQuantumComputerCalibrationV1(
+                proto.LatestQuantumComputerCalibrationLookupV1(
+                    qc_id=self._current_qc.id,
+                )
+            )
+            if metadata.dut_label != dut_label:
+                raise ValueError(f"No calibration set for dut_label = {dut_label}")
+            return from_proto_uuid(metadata.id)
+
+    def _get_cached_sweep(self, sweep_id: uuid.UUID) -> SweepDefinition | None:
+        latest_submitted = self._latest_submitted_sweep
+        if latest_submitted and latest_submitted.sweep_id == sweep_id:
+            return latest_submitted
+        return None
+
+    def _get_resource(self, resource_name: str, deserialize: Callable[[bytes], T]) -> T:
+        with wrap_error(f"Failed to load QC resource '{resource_name}'"):
+            if (cached := self._cached_resources.get(resource_name)) is not None:
+                return cached
+            qcs = proto.QuantumComputersStub(self._channel)
+            data_chunks = qcs.GetQuantumComputerResourceV1(
+                proto.QuantumComputerResourceLookupV1(
+                    qc_id=self._current_qc.id,
+                    resource_name=resource_name,
+                )
+            )
+            resource = deserialize(load_all(data_chunks))
+            self._cached_resources[resource_name] = resource
+            return resource
+
+
+def resolve_current_qc(channel: grpc.Channel, alias: str) -> proto.QuantumComputerV1:
+    qcs = proto.QuantumComputersStub(channel)
+    qc_list: proto.QuantumComputersListV1 = qcs.ListQuantumComputersV1(proto.ListQuantumComputerFiltersV1())
+    for qc in qc_list.items:
+        if qc.alias == alias:
+            return qc
+    raise ValueError(f"Quantum computer '{alias}' does not exist")
+
+
+def subscribe_to_job_events(channel: grpc.Channel, job_id: uuid.UUID) -> Iterable[proto.JobV1]:
+    jobs = proto.JobsStub(channel)
+    attempts = 1
+    while True:
+        try:
+            events = jobs.SubscribeToJobV1(proto.JobLookupV1(id=to_proto_uuid(job_id)))
+            for event in events:
+                job_event = cast(proto.JobEventV1, event)
+                if job_event.HasField("update"):
+                    yield job_event.update
+            return
+        except grpc.RpcError as e:
+            # Server may cancel subscription due to e.g. restarts, in which case we can just retry after some waiting
+            error = extract_error(e)
+            if error.error_code == "server_cancel" and attempts <= 10:
+                attempts += 1
+                sleep(5)
+                continue
+            raise e
+
+
+def parse_calibration_set(cal_set_data: bytes) -> tuple[uuid.UUID, dict[str, ObservationValue]]:
+    # IQM server calibration sets are in cocos calibration set JSON format, we can get
+    # both id and observations from it
+    cal_set = parse_json(cal_set_data)
+    cal_set_id = cal_set["calibration_set_id"]
+    observations = cal_set.get("observations", {})
+    cal_set_values = {k: validate_value(v["value"]) for k, v in observations.items()}
+    return cal_set_id, cal_set_values
+
+
+def payload_to_sweep(job_payload: bytes) -> SweepDefinition:
+    sweep, _ = deserialize_sweep_task_request(job_payload)
+    return sweep
+
+
+def to_sweep_status(job_status: proto.JobStatus) -> SweepStatus:
+    match job_status:
+        case proto.JobStatus.IN_QUEUE:
+            return SweepStatus.PENDING
+        case proto.JobStatus.EXECUTING:
+            return SweepStatus.PROGRESS
+        case proto.JobStatus.FAILED:
+            return SweepStatus.FAILURE
+        case proto.JobStatus.COMPLETED:
+            return SweepStatus.SUCCESS
+        case proto.JobStatus.INTERRUPTED:
+            return SweepStatus.INTERRUPTED
+        case proto.JobStatus.CANCELLED:
+            return SweepStatus.REVOKED
+    raise ValueError(f"Unknown job status: '{job_status}'")
+
+
+def to_task_status(job_status: proto.JobStatus) -> str:
+    match job_status:
+        case proto.JobStatus.IN_QUEUE:
+            return "PENDING"
+        case proto.JobStatus.EXECUTING:
+            return "STARTED"
+        case proto.JobStatus.FAILED | proto.JobStatus.INTERRUPTED | proto.JobStatus.CANCELLED:
+            return "FAILURE"
+        case proto.JobStatus.COMPLETED:
+            return "SUCCESS"
+    raise ValueError(f"Unknown job status: '{job_status}'")
+
+
+def parse_json(data: bytes) -> Any:
+    return json.load(BytesIO(data))
+
+
+@contextmanager
+def wrap_error(title: str):
+    try:
+        yield
+    except grpc.RpcError as e:
+        raise extract_error(e, title) from e
+    except Exception as e:
+        raise IqmServerError(message=f"{title}: {e}", status_code=str(grpc.StatusCode.INTERNAL.name)) from e

iqm/station_control/client/iqm_server/meta_class.py

@@ -0,0 +1,38 @@
+# Copyright 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.
+import inspect
+
+
+class IqmServerClientMeta(type):
+    """Custom metaclass that automatically adds '<feature> not implemented'
+    stub implementations for all StationControlClient functions that are
+    not overridden by IqmServerClient.
+    """
+
+    def __new__(cls, name, bases, dct):
+        for f_name, _ in inspect.getmembers(
+            bases[0], predicate=lambda m: inspect.isfunction(m) and not m.__name__.startswith("__")
+        ):
+            if f_name not in dct:
+                dct[f_name] = _not_implemented_stub(f_name)
+        return super().__new__(cls, name, bases, dct)
+
+
+def _not_implemented_stub(feature: str):
+    """Generate a function that raises NotImplementedError."""
+
+    def stub(*args, **kwargs):
+        raise NotImplementedError(f"'{feature}' is not implemented for this backend")
+
+    return stub

iqm/station_control/client/iqm_server/proto/__init__.py

@@ -0,0 +1,43 @@
+# Copyright 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.
+from .calibration_pb2 import (
+    CalibrationLookupV1,
+    CalibrationMetadataV1,
+    LatestQuantumComputerCalibrationLookupV1,
+)
+from .calibration_pb2_grpc import CalibrationsStub, CalibrationsServicer, Calibrations
+from .common_pb2 import Empty, DataChunk, Keepalive
+from .job_pb2 import (
+    JobType,
+    JobStatus,
+    JobInputSummaryV1,
+    JobV1,
+    JobLookupV1,
+    SubmitJobRequestV1,
+    JobEventV1,
+)
+from .job_pb2_grpc import JobsStub, JobsServicer, Jobs
+from .qc_pb2 import (
+    QuantumComputerLookupV1,
+    QuantumComputerResourceLookupV1,
+    ListQuantumComputerFiltersV1,
+    QuantumComputerV1,
+    QuantumComputersListV1,
+)
+from .qc_pb2_grpc import (
+    QuantumComputersStub,
+    QuantumComputersServicer,
+    QuantumComputers,
+)
+from .uuid_pb2 import Uuid

iqm/station_control/client/iqm_server/proto/calibration_pb2.py

@@ -0,0 +1,48 @@
+# Copyright 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.
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: calibration.proto
+# Protobuf Python Version: 4.25.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
+from . import common_pb2 as common__pb2
+from . import uuid_pb2 as uuid__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x11\x63\x61libration.proto\x12\niqm.server\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x0c\x63ommon.proto\x1a\nuuid.proto\"K\n(LatestQuantumComputerCalibrationLookupV1\x12\x1f\n\x05qc_id\x18\x01 \x02(\x0b\x32\x10.iqm.server.Uuid\"3\n\x13\x43\x61librationLookupV1\x12\x1c\n\x02id\x18\x01 \x02(\x0b\x32\x10.iqm.server.Uuid\"\x8a\x01\n\x15\x43\x61librationMetadataV1\x12\x1c\n\x02id\x18\x01 \x02(\x0b\x32\x10.iqm.server.Uuid\x12.\n\ncreated_at\x18\x02 \x02(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x11\n\tdut_label\x18\x03 \x02(\t\x12\x10\n\x08is_valid\x18\x04 \x02(\x08\x32\xbf\x02\n\x0c\x43\x61librations\x12\x80\x01\n%GetLatestQuantumComputerCalibrationV1\x12\x34.iqm.server.LatestQuantumComputerCalibrationLookupV1\x1a!.iqm.server.CalibrationMetadataV1\x12V\n\x10GetCalibrationV1\x12\x1f.iqm.server.CalibrationLookupV1\x1a!.iqm.server.CalibrationMetadataV1\x12T\n\x18GetFullCalibrationDataV1\x12\x1f.iqm.server.CalibrationLookupV1\x1a\x15.iqm.server.DataChunk0\x01')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'calibration_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_LATESTQUANTUMCOMPUTERCALIBRATIONLOOKUPV1']._serialized_start=92
+  _globals['_LATESTQUANTUMCOMPUTERCALIBRATIONLOOKUPV1']._serialized_end=167
+  _globals['_CALIBRATIONLOOKUPV1']._serialized_start=169
+  _globals['_CALIBRATIONLOOKUPV1']._serialized_end=220
+  _globals['_CALIBRATIONMETADATAV1']._serialized_start=223
+  _globals['_CALIBRATIONMETADATAV1']._serialized_end=361
+  _globals['_CALIBRATIONS']._serialized_start=364
+  _globals['_CALIBRATIONS']._serialized_end=683
+# @@protoc_insertion_point(module_scope)