iqm-station-control-client 8.1.0__py3-none-any.whl → 9.1.0__py3-none-any.whl

iqm/station_control/interface/station_control.py

@@ -0,0 +1,511 @@
+# 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.
+"""Station control interface."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Sequence
+import logging
+from typing import TypeVar
+from uuid import UUID
+
+from iqm.models.channel_properties import ChannelProperties
+
+from exa.common.data.setting_node import SettingNode
+from iqm.station_control.interface.list_with_meta import ListWithMeta
+from iqm.station_control.interface.models import (
+    DutData,
+    DutFieldData,
+    DynamicQuantumArchitecture,
+    GetObservationsMode,
+    JobData,
+    ObservationData,
+    ObservationDefinition,
+    ObservationLite,
+    ObservationSetData,
+    ObservationSetDefinition,
+    ObservationSetUpdate,
+    ObservationUpdate,
+    QualityMetrics,
+    RunData,
+    RunDefinition,
+    RunLite,
+    SequenceMetadataData,
+    SequenceMetadataDefinition,
+    SequenceResultData,
+    SequenceResultDefinition,
+    SoftwareVersionSet,
+    StaticQuantumArchitecture,
+    Statuses,
+    SweepData,
+    SweepDefinition,
+    SweepResults,
+)
+from iqm.station_control.interface.pydantic_base import PydanticBase
+
+logger = logging.getLogger(__name__)
+TypePydanticBase = TypeVar("TypePydanticBase", bound=PydanticBase)
+
+
+class StationControlInterface(ABC):
+    """Station control interface.
+
+    Station control interface implementation should implement generic query methods for certain objects,
+    like :meth:`query_observations`, :meth:`query_observation_sets`, and :meth:`query_sequence_metadatas`.
+    These methods accept only keyword arguments as parameters, which are based on the syntax ``field__lookup=value``.
+    Note double-underscore in the name, to separate field names like ``dut_field`` from lookup types like ``in``.
+    The syntax is based on Django implementation, documented
+    `here <https://docs.djangoproject.com/en/5.0/ref/models/querysets/#field-lookups>`__ and
+    `here <https://docs.djangoproject.com/en/5.0/ref/contrib/postgres/fields/#querying-arrayfield>`__.
+
+    As a convenience, when no lookup type is provided (like in ``dut_label="foo"``),
+    the lookup type is assumed to be exact (``dut_label__exact="foo"``). Other supported lookup types are:
+
+        - range: Range test (inclusive).
+            For example, ``created_timestamp__range=(datetime(2023, 10, 12), datetime(2024, 10, 14))``
+        - in: In a given iterable; often a list, tuple, or queryset.
+            For example, ``dut_field__in=["QB1.frequency", "gates.measure.constant.QB2.frequency"]``
+        - icontains: Case-insensitive containment test.
+            For example, ``origin_uri__icontains="local"``
+        - overlap: Returns objects where the data shares any results with the values passed.
+            For example, ``tags__overlap=["calibration=good", "2023-12-04"]``
+        - contains: The returned objects will be those where the values passed are a subset of the data.
+            For example, ``tags__contains=["calibration=good", "2023-12-04"]``
+        - isnull: Takes either True or False, which correspond to SQL queries of IS NULL and IS NOT NULL, respectively.
+            For example, ``end_timestamp__isnull=False``
+
+    In addition to model fields (like "dut_label", "dut_field", "created_timestamp", "invalid", etc.),
+    all of our generic query methods accept also following shared query parameters:
+
+        - latest: str. Return only the latest item for this field, based on "created_timestamp".
+            For example, ``latest="invalid"`` would return only one result (latest "created_timestamp")
+            for each different "invalid" value in the database. Thus, maximum three results would be returned,
+            one for each invalid value of `True`, `False`, and `None`.
+        - order_by: str. Prefix with "-" for descending order, for example "-created_timestamp".
+        - limit: int: Default 20. If 0 (or negative number) is given, then pagination is not used, i.e. limit=infinity.
+        - offset: int. Default 0.
+
+    Our generic query methods are not fully generalized yet, thus not all fields and lookup types are supported.
+    Check query methods own documentation for details about currently supported query parameters.
+
+    Generic query methods will return a list of objects, but with additional (optional) "meta" attribute,
+    which contains metadata, like pagination details. The client can ignore this data,
+    or use it to implement pagination logic for example to fetch all results available.
+
+    """
+
+    @abstractmethod
+    def get_about(self) -> dict:
+        """Return information about the station control."""
+
+    @abstractmethod
+    def get_health(self) -> dict:
+        """Return the status of the station control service."""
+
+    @abstractmethod
+    def get_configuration(self) -> dict:
+        """Return the configuration of the station control."""
+
+    @abstractmethod
+    def get_exa_configuration(self) -> str:
+        """Return the recommended EXA configuration from the server."""
+
+    @abstractmethod
+    def get_or_create_software_version_set(self, software_version_set: SoftwareVersionSet) -> int:
+        """Get software version set ID from the database, or create one if it doesn't exist."""
+
+    @abstractmethod
+    def get_settings(self) -> SettingNode:
+        """Return a tree representation of the default settings as defined in the configuration file."""
+
+    @abstractmethod
+    def get_chip_design_record(self, dut_label: str) -> dict:
+        """Get a raw chip design record matching the given chip label."""
+
+    @abstractmethod
+    def get_channel_properties(self) -> dict[str, ChannelProperties]:
+        """Get channel properties from the station.
+
+        Channel properties contain information regarding hardware limitations e.g. sampling rate, granularity
+        and supported instructions.
+
+        Returns:
+            Mapping from channel name to AWGProperties or ReadoutProperties.
+
+        """
+
+    @abstractmethod
+    def sweep(self, sweep_definition: SweepDefinition) -> dict:
+        """Execute an N-dimensional sweep of selected variables and save sweep and results.
+
+        The raw data for each spot in the sweep is saved as numpy arrays,
+        and the complete data for the whole sweep is saved as an x-array dataset
+        which has the `sweep_definition.sweeps` as coordinates and
+        data of `sweep_definition.return_parameters` data as DataArrays.
+
+        The values of `sweep_definition.playlist` will be uploaded to the controllers given by the keys of
+        `sweep_definition.playlist`.
+
+        Args:
+            sweep_definition: The content of the sweep to be created.
+
+        Returns:
+            Dict containing the task ID  and sweep ID, and corresponding hrefs, of a successful sweep execution
+            in monolithic mode or successful submission to the task queue in remote mode.
+
+        Raises:
+            ExaError if submitting a sweep failed.
+
+        """
+
+    @abstractmethod
+    def get_sweep(self, sweep_id: UUID) -> SweepData:
+        """Get N-dimensional sweep data from the database."""
+
+    @abstractmethod
+    def delete_sweep(self, sweep_id: UUID) -> None:
+        """Delete sweep in the database."""
+
+    @abstractmethod
+    def get_sweep_results(self, sweep_id: UUID) -> SweepResults:
+        """Get N-dimensional sweep results from the database."""
+
+    @abstractmethod
+    def run(
+        self,
+        run_definition: RunDefinition,
+        update_progress_callback: Callable[[Statuses], None] | None = None,
+        wait_job_completion: bool = True,
+    ) -> bool:
+        """Execute an N-dimensional sweep of selected variables and save run, sweep and results."""
+
+    @abstractmethod
+    def get_run(self, run_id: UUID) -> RunData:
+        """Get run data from the database."""
+
+    @abstractmethod
+    def query_runs(self, **kwargs) -> ListWithMeta[RunLite]:
+        """Query runs from the database.
+
+        Runs are queried by the given query parameters. Currently supported query parameters:
+            - run_id: uuid.UUID
+            - run_id__in: list[uuid.UUID]
+            - sweep_id: uuid.UUID
+            - sweep_id__in: list[uuid.UUID]
+            - username: str
+            - username__in: list[str]
+            - username__contains: str
+            - username__icontains: str
+            - experiment_label: str
+            - experiment_label__in: list[str]
+            - experiment_label__contains: str
+            - experiment_label__icontains: str
+            - experiment_name: str
+            - experiment_name__in: list[str]
+            - experiment_name__contains: str
+            - experiment_name__icontains: str
+            - software_version_set_id: int
+            - software_version_set_id__in: list[int]
+            - begin_timestamp__range: tuple[datetime, datetime]
+            - end_timestamp__range: tuple[datetime, datetime]
+            - end_timestamp__isnull: bool
+
+        Returns:
+            Queried runs with some query related metadata.
+
+        """
+
+    @abstractmethod
+    def create_observations(
+        self, observation_definitions: Sequence[ObservationDefinition]
+    ) -> ListWithMeta[ObservationData]:
+        """Create observations in the database.
+
+        Args:
+            observation_definitions: A sequence of observation definitions,
+                each containing the content of the observation which will be created.
+
+        Returns:
+            Created observations, each including also the database created fields like ID and timestamps.
+
+        """
+
+    @abstractmethod
+    def get_observations(
+        self,
+        *,
+        mode: GetObservationsMode,
+        dut_label: str | None = None,
+        dut_field: str | None = None,
+        tags: list[str] | None = None,
+        invalid: bool | None = False,
+        run_ids: list[UUID] | None = None,
+        sequence_ids: list[UUID] | None = None,
+        limit: int | None = None,
+    ) -> list[ObservationData]:
+        """Get observations from the database.
+
+        Observations are queried by the given query parameters.
+
+        Args:
+            mode: The "mode" used to query the observations. Possible values "all_latest", "tags_and", or "tags_or".
+
+                  - "all_latest":Query all the latest observations for the given ``dut_label``.
+                    No other query parameters are accepted.
+                  - "tags_and": Query observations. Query all the observations that have all the given ``tags``.
+                    By default, only valid observations are included.
+                    All other query parameters can be used to narrow down the query,
+                    expect "run_ids" and "sequence_ids".
+                  - "tags_or": Query all the latest observations that have at least one of the given ``tags``.
+                    Additionally, ``dut_label`` must be given. No other query parameters are used.
+                  - "sequence": Query observations originating from a list of run and/or sequence IDs.
+                    No other query parameters are accepted.
+            dut_label: DUT label of the device the observations pertain to.
+            dut_field: Name of the property the observation is about.
+            tags: Human-readable tags of the observation.
+            invalid: Flag indicating if the object is invalid. Automated systems must not use invalid objects.
+                If ``None``, both valid and invalid objects are included.
+            run_ids: The run IDs for which to query the observations.
+            sequence_ids: The sequence IDs for which to query the observations.
+            limit: Indicates the maximum number of items to return.
+
+        Returns:
+            Observations, each including also the database created fields like ID and timestamps.
+
+        """
+
+    @abstractmethod
+    def query_observations(self, **kwargs) -> ListWithMeta[ObservationData]:
+        """Query observations from the database.
+
+        Observations are queried by the given query parameters. Currently supported query parameters:
+            - observation_id: int
+            - observation_id__in: list[int]
+            - dut_label: str
+            - dut_field: str
+            - dut_field__in: list[str]
+            - tags__overlap: list[str]
+            - tags__contains: list[str]
+            - invalid: bool
+            - source__run_id__in: list[uuid.UUID]
+            - source__sequence_id__in: list[uuid.UUID]
+            - source__type: str
+            - uncertainty__isnull: bool
+            - created_timestamp__range: tuple[datetime, datetime]
+            - observation_set_ids__overlap: list[uuid.UUID]
+            - observation_set_ids__contains: list[uuid.UUID]
+
+        Returns:
+            Queried observations with some query related metadata.
+
+        """
+
+    @abstractmethod
+    def update_observations(self, observation_updates: Sequence[ObservationUpdate]) -> list[ObservationData]:
+        """Update observations in the database.
+
+        Args:
+            observation_updates: A sequence of observation updates,
+                each containing the content of the observation which will be updated.
+
+        Returns:
+            Updated observations, each including also the database created fields like ID and timestamps.
+
+        """
+
+    @abstractmethod
+    def query_observation_sets(self, **kwargs) -> ListWithMeta[ObservationSetData]:
+        """Query observation sets from the database.
+
+        Observation sets are queried by the given query parameters. Currently supported query parameters:
+            - observation_set_id: UUID
+            - observation_set_id__in: list[UUID]
+            - observation_set_type: Literal["calibration-set", "generic-set", "quality-metric-set"]
+            - observation_ids__overlap: list[int]
+            - observation_ids__contains: list[int]
+            - describes_id: UUID
+            - describes_id__in: list[UUID]
+            - invalid: bool
+            - created_timestamp__range: tuple[datetime, datetime]
+            - end_timestamp__isnull: bool
+            - dut_label: str
+            - dut_label__in: list[str]
+
+        Returns:
+            Queried observation sets with some query related metadata
+
+        """
+
+    @abstractmethod
+    def create_observation_set(self, observation_set_definition: ObservationSetDefinition) -> ObservationSetData:
+        """Create an observation set in the database.
+
+        Args:
+            observation_set_definition: The content of the observation set to be created.
+
+        Returns:
+            The content of the observation set.
+
+        Raises:
+            ExaError: If creation failed.
+
+        """
+
+    @abstractmethod
+    def get_observation_set(self, observation_set_id: UUID) -> ObservationSetData:
+        """Get an observation set from the database.
+
+        Args:
+            observation_set_id: Observation set to retrieve.
+
+        Returns:
+            The content of the observation set.
+
+        Raises:
+            ExaError: If retrieval failed.
+
+        """
+
+    @abstractmethod
+    def update_observation_set(self, observation_set_update: ObservationSetUpdate) -> ObservationSetData:
+        """Update an observation set in the database.
+
+        Args:
+            observation_set_update: The content of the observation set to be updated.
+
+        Returns:
+            The content of the observation set.
+
+        Raises:
+            ExaError: If updating failed.
+
+        """
+
+    @abstractmethod
+    def finalize_observation_set(self, observation_set_id: UUID) -> None:
+        """Finalize an observation set in the database.
+
+        A finalized set is nearly immutable, allowing to change only ``invalid`` flag after finalization.
+
+        Args:
+            observation_set_id: Observation set to finalize.
+
+        Raises:
+            ExaError: If finalization failed.
+
+        """
+
+    @abstractmethod
+    def get_observation_set_observations(self, observation_set_id: UUID) -> list[ObservationLite]:
+        """Get the constituent observations of an observation set from the database.
+
+        Args:
+            observation_set_id: UUID of the observation set to retrieve.
+
+        Returns:
+            Observations belonging to the given observation set.
+
+        """
+
+    @abstractmethod
+    def get_default_calibration_set(self) -> ObservationSetData:
+        """Get default calibration set from the database."""
+
+    @abstractmethod
+    def get_default_calibration_set_observations(self) -> list[ObservationLite]:
+        """Get default calibration set observations from the database."""
+
+    @abstractmethod
+    def get_default_dynamic_quantum_architecture(self) -> DynamicQuantumArchitecture:
+        """Get dynamic quantum architecture for the default calibration set."""
+
+    @abstractmethod
+    def get_dynamic_quantum_architecture(self, calibration_set_id: UUID) -> DynamicQuantumArchitecture:
+        """Get dynamic quantum architecture for the given calibration set ID.
+
+        Returns:
+            Dynamic quantum architecture of the station for the given calibration set ID.
+
+        """
+
+    @abstractmethod
+    def get_default_calibration_set_quality_metrics(self) -> QualityMetrics:
+        """Get the latest quality metrics for the current default calibration set."""
+
+    @abstractmethod
+    def get_calibration_set_quality_metrics(self, calibration_set_id: UUID) -> QualityMetrics:
+        """Get the latest quality metrics for the given calibration set ID."""
+
+    @abstractmethod
+    def get_duts(self) -> list[DutData]:
+        """Get DUTs of the station control."""
+
+    @abstractmethod
+    def get_dut_fields(self, dut_label: str) -> list[DutFieldData]:
+        """Get DUT fields for the specified DUT label from the database."""
+
+    @abstractmethod
+    def query_sequence_metadatas(self, **kwargs) -> ListWithMeta[SequenceMetadataData]:
+        """Query sequence metadatas from the database.
+
+        Sequence metadatas are queried by the given query parameters. Currently supported query parameters:
+            - origin_id: str
+            - origin_id__in: list[str]
+            - origin_uri: str
+            - origin_uri__icontains: str
+            - created_timestamp__range: tuple[datetime, datetime]
+
+        Returns:
+            Sequence metadatas with some query related metadata.
+
+        """
+
+    @abstractmethod
+    def create_sequence_metadata(
+        self, sequence_metadata_definition: SequenceMetadataDefinition
+    ) -> SequenceMetadataData:
+        """Create sequence metadata in the database."""
+
+    @abstractmethod
+    def save_sequence_result(self, sequence_result_definition: SequenceResultDefinition) -> SequenceResultData:
+        """Save sequence result in the database.
+
+        This method creates the object if it doesn't exist and completely replaces the "data" and "final" if it does.
+        Timestamps are assigned by the database. "modified_timestamp" is not set on initial creation,
+        but it's updated on each subsequent call.
+        """
+
+    @abstractmethod
+    def get_sequence_result(self, sequence_id: UUID) -> SequenceResultData:
+        """Get sequence result from the database."""
+
+    @abstractmethod
+    def get_static_quantum_architecture(self, dut_label: str) -> StaticQuantumArchitecture:
+        """Get static quantum architecture of the station for the given DUT label.
+
+        Returns:
+            Static quantum architecture of the station for the given DUT label.
+
+        """
+
+    @abstractmethod
+    def get_job(self, job_id: UUID) -> JobData:
+        """Get job data."""
+
+    @abstractmethod
+    def abort_job(self, job_id: UUID) -> None:
+        """Either remove a job from the queue, or abort it gracefully if it's already executing.
+
+        The status of the job will be set to ``JobStatus.ABORTED``.
+        If the job is not found or is already finished nothing happens.
+        """

{iqm_station_control_client-8.1.0.dist-info → iqm_station_control_client-9.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-station-control-client
-Version: 8.1.0
+Version: 9.1.0
 Summary: Python client for communicating with Station Control Service
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License
@@ -214,7 +214,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: iqm-exa-common <27,>=26
-Requires-Dist: iqm-data-definitions <3.0,>=2.8
+Requires-Dist: iqm-data-definitions <3.0,>=2.13
 Requires-Dist: opentelemetry-exporter-otlp ==1.25.0
 Requires-Dist: protobuf <5.0,>=4.25.3
 Requires-Dist: grpcio <2.0,>=1.65.4

{iqm_station_control_client-8.1.0.dist-info → iqm_station_control_client-9.1.0.dist-info}/RECORD

@@ -1,12 +1,11 @@
-iqm/station_control/client/__init__.py,sha256=BmBIBdZa10r-IWCFzZ1-0DG6GQKPIXqGXltfXop4ZeQ,942
-iqm/station_control/client/list_models.py,sha256=SjD0DbCrM9z1SSuGoQS83lyJmDLuMOatpJUoW8itW9s,2335
-iqm/station_control/client/station_control.py,sha256=ShSgH1lgaKE6UtcDcfwOg7vAINs_WKf2jynnL9ax50E,39661
-iqm/station_control/client/utils.py,sha256=cpS3hXEeeIXeqd_vBnnwo3JHS83FrNpG07SiTUwUx-I,1650
+iqm/station_control/client/__init__.py,sha256=1ND-AkIE9xLGIscH3WN44eyll9nlFhXeyCm-8EDFGQ4,942
+iqm/station_control/client/list_models.py,sha256=xnGk7Yzy-9bGBv_6eUzyai5hNJmG9ACUyu02ifSeSTE,2467
+iqm/station_control/client/station_control.py,sha256=4xUiI5Rw---TQDTWhN5FJb-nqhq6PE8q6DGSPfaH6l4,28154
+iqm/station_control/client/utils.py,sha256=-6K4KgOgA4iyUCqX-w26JvFxlwlGBehGj4tIWCEbn74,3360
 iqm/station_control/client/iqm_server/__init__.py,sha256=nLsRHN1rnOKXwuzaq_liUpAYV3sis5jkyHccSdacV7U,624
-iqm/station_control/client/iqm_server/error.py,sha256=ZLV2-gxFLHZjZVkI3L5sWcBMiay7NT-ijIEvrXgVJT8,1166
-iqm/station_control/client/iqm_server/grpc_utils.py,sha256=ee42C31_JIXlP6ikZQbohgUQjqCvcSSxIW_9lm9MMV8,5727
-iqm/station_control/client/iqm_server/iqm_server_client.py,sha256=6TuzBCv0yygy5B7re_nvK3NjEw_zSnP2ExBAHP0HyoY,14777
-iqm/station_control/client/iqm_server/meta_class.py,sha256=pePJ0Xy0aiJg-bZWK8D87gblq6imfXLsZHjpZkf5D9s,1399
+iqm/station_control/client/iqm_server/error.py,sha256=a8l7UTnzfbD8KDHP-uOve77S6LR1ai9uM_J_xHbLs0Y,1175
+iqm/station_control/client/iqm_server/grpc_utils.py,sha256=67-uxYnNQ9NkC6t8V1_e9XFuIYv47K1I4A39MfHncVM,5825
+iqm/station_control/client/iqm_server/iqm_server_client.py,sha256=Ey478VqH6vZm7oVoBn7Ht6PzZHDJg0y6Smiqo9W1mdU,19601
 iqm/station_control/client/iqm_server/proto/__init__.py,sha256=mOJQ_H-NEyJMffRaDSSZeXrScHaHaHEXULv-O_OJA3A,1345
 iqm/station_control/client/iqm_server/proto/calibration_pb2.py,sha256=gum0DGmqxhbfaar8SqahmSif1pB6hgo0pVcnoi3VMUo,3017
 iqm/station_control/client/iqm_server/proto/calibration_pb2.pyi,sha256=4lTHY_GhrsLIHqoGDkNLYu56QHzX_iHEbLaYq-HR1m8,2016
@@ -25,30 +24,33 @@ iqm/station_control/client/iqm_server/proto/uuid_pb2.pyi,sha256=9LXcqNoQS1iapCso
 iqm/station_control/client/iqm_server/proto/uuid_pb2_grpc.py,sha256=SF40l84__r-OGGNYBru5ik9gih-XqeTq2iwM5gMN5Qc,726
 iqm/station_control/client/iqm_server/testing/__init__.py,sha256=wCNfJHIR_bqG3ZBlgm55v90Rih7VCpfctoIMfwRMgjk,567
 iqm/station_control/client/iqm_server/testing/iqm_server_mock.py,sha256=X_Chi8TKx95PiuhFfGnRu9LxeIpnKKynW_8tXwxFQD8,3340
-iqm/station_control/client/serializers/__init__.py,sha256=Hui5SrT4NVeV-27g116ZJgvRQo8ednLMsGpu4V39g1k,1436
-iqm/station_control/client/serializers/channel_property_serializer.py,sha256=ChlX8B-blM5hjv3pUExHOd-vE3O_myPwILu36KZYYNU,7121
-iqm/station_control/client/serializers/datetime_serializers.py,sha256=Ke6VRHa_359xYxXTegs8iweoDfuGeBDgkoOtGBbyC1Q,1122
-iqm/station_control/client/serializers/playlist_serializers.py,sha256=S8RuKdqeJxqUf7_kqTDXIKnuo6g-WpzGY7cesSQa3Rw,18086
-iqm/station_control/client/serializers/run_serializers.py,sha256=4zH0I5EvvaP7wgLMprXXWa36nAPO4Lv0fPkCrDC_v-g,6698
-iqm/station_control/client/serializers/setting_node_serializer.py,sha256=m4Sbm8Qr3GiSNiE-Jh8gFEgfscfN1xxELb0vCa9cK70,1197
-iqm/station_control/client/serializers/struct_serializer.py,sha256=QztBsbRlRG_UrtpQLE3bi0WKEVn48kVB91H1g26PvqQ,3270
-iqm/station_control/client/serializers/sweep_serializers.py,sha256=MbmAei4o8jl4a8vxmkLmj5hc3fCTMbHrtejk2aLafB4,5782
-iqm/station_control/client/serializers/task_serializers.py,sha256=KTd3zdfqr9kSIiEbwsoSNiSu_hxzFfDOlLuttoyBfps,3700
-iqm/station_control/interface/__init__.py,sha256=MIQla-cBKPbZqBkp-LNyPfjiV0gzf-IFEwrMMhsnKlg,785
-iqm/station_control/interface/list_with_meta.py,sha256=GAXIDEXKeua6-2FoQ_O1tkhx-d8pBMGHaIkdvgg-cag,1185
-iqm/station_control/interface/pydantic_base.py,sha256=MVzcsH7wG1DON-qTw6KLpUDay7_b_9CDQgymVzg9HwI,1303
-iqm/station_control/interface/models/__init__.py,sha256=NpUt2IcWVVAiYZTdl6uOMk0IVWmLgJrC9D9irIZvF4c,1595
-iqm/station_control/interface/models/dut.py,sha256=dd1SpcsBe4P057jvcPqv39SjzekewwP07hThFe5ulNA,1216
+iqm/station_control/client/serializers/__init__.py,sha256=eSAjgO5DME9jR1VmtA5-ewJG7rZ6AiWgAc-gs640_20,1436
+iqm/station_control/client/serializers/channel_property_serializer.py,sha256=VuWRqyPTeKK0gPHgE2r29k5JcdkTzDOOAdcC5hd7Nok,7283
+iqm/station_control/client/serializers/datetime_serializers.py,sha256=PzSDJFc81BtfTfBDJdeh98pfpwIhloxko-I4HjvjAEM,1122
+iqm/station_control/client/serializers/playlist_serializers.py,sha256=ueB6IzeNx9Ube3phV9vqPY6NaSnO92p5wOdHqOtYUaI,18086
+iqm/station_control/client/serializers/run_serializers.py,sha256=6a6c13mgydP02qIcuPPGCmY7CgQEWe4LKXOQ_TrvD00,6698
+iqm/station_control/client/serializers/setting_node_serializer.py,sha256=ghqgINjEH0-rn_q8A8GFP9wOk4RVqC97HeAkFB4vwrk,1197
+iqm/station_control/client/serializers/struct_serializer.py,sha256=7LSlrGVz0c-yiy9NitshWHr3OSqRMFZRTu5k-vNxeDE,3270
+iqm/station_control/client/serializers/sweep_serializers.py,sha256=NEywml9VqVfeCTONxITo8bUweaA2bKybEY2lFHqKunU,5729
+iqm/station_control/client/serializers/task_serializers.py,sha256=mj5HWOolXLsqGaky7OYAWCW-BVp1RKN7vPtyiYpMaO8,3700
+iqm/station_control/interface/__init__.py,sha256=bBjhkiUSdwmx-CoNrT8pI4eGStI9RFUcW5CdpIRrd5k,785
+iqm/station_control/interface/list_with_meta.py,sha256=IPuho6LOiOCKEaz-QWnhbPwmWIDmcWD9JIqWf-2dxAU,1185
+iqm/station_control/interface/pydantic_base.py,sha256=pQCa-8SRgBKMSwG-KyXA1HcIxE_qGMJt9g_eOGdZ31g,1303
+iqm/station_control/interface/station_control.py,sha256=Uh9bDEZjc9M5KOYsGjPMYVhnYsfVQfjT05sUjUSoDXA,20303
+iqm/station_control/interface/models/__init__.py,sha256=Kg-XRLuU7G4Zjtu8LhYD-v3zkCYHzLFaNvC_nukezlQ,1968
+iqm/station_control/interface/models/dut.py,sha256=Hc_0XllXeIPGWhHsY7PC_jMpi7swpqo3jQQEQVnF3AM,1216
+iqm/station_control/interface/models/dynamic_quantum_architecture.py,sha256=5W8e5oRNxvXm2nI36NipDrErg2vHdpC8zzpeGyqSNDQ,3621
 iqm/station_control/interface/models/jobs.py,sha256=4CVVGMsUOm_UO4w7UH-Shq7cbZe_5MkhGDpoBwHoHkc,5105
 iqm/station_control/interface/models/monitor.py,sha256=ItlgxtBup1hHg64uKeMKiFE7MaRRqSYdVRttsFD_XeU,1352
-iqm/station_control/interface/models/observation.py,sha256=Jce4lIsUtHRIFT3nr-cbKvh3dbR2Y_yM5x0yyvUdjF8,3261
-iqm/station_control/interface/models/observation_set.py,sha256=Ko2o3-9I38NfjNF2IQPcwfbwpkTQ3PIU7fUiSaDleX8,3031
-iqm/station_control/interface/models/run.py,sha256=m-iE3QMPQUOF7bsw8JCAM1Bd6bDVhAgxrtc_AC7rCkc,4097
-iqm/station_control/interface/models/sequence.py,sha256=uOqMwF1x-vW6UHs2WnPD3PsuSgV3a8OTAsgn_4UENLw,2723
-iqm/station_control/interface/models/sweep.py,sha256=uzpbQ_nky7UxNE4c15U4oDN96f_-SgPDNVK9Sjdan3Q,2509
-iqm/station_control/interface/models/type_aliases.py,sha256=3LB9viZVi8osavY5kKF8TH1crayG7-MLjgBqXDCqL2s,1018
-iqm_station_control_client-8.1.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_station_control_client-8.1.0.dist-info/METADATA,sha256=JIak37YrbVnuaupwBxYbRSn4Mc6nCfEmO5rawNnnlQI,14009
-iqm_station_control_client-8.1.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_station_control_client-8.1.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_station_control_client-8.1.0.dist-info/RECORD,,
+iqm/station_control/interface/models/observation.py,sha256=FwhlI2xXZ_2-PA-LcDvscHuTbfdTWhw67zSNa9Buuvg,3261
+iqm/station_control/interface/models/observation_set.py,sha256=ZNgc-5Yn2o3hmXpjb-3yWGVTz9HNpovu5hhSvDvg5b4,3582
+iqm/station_control/interface/models/run.py,sha256=uEuAMryG-AjAIBTchftw94GpoSBE5SQK2qmlZZ4tq5k,4097
+iqm/station_control/interface/models/sequence.py,sha256=boWlMfP3woVgVObW3OaNbxsUV_qHYP1DA-oIBWj6XIo,2723
+iqm/station_control/interface/models/static_quantum_architecture.py,sha256=gsfJKlYsfZVEK3dqEKXkBSIHiY14DGwNbhPJdNHMtNM,1435
+iqm/station_control/interface/models/sweep.py,sha256=HFoFIrKhlYmHIBfGltY2O9_J28OvkkZILRbDHuqR0wc,2509
+iqm/station_control/interface/models/type_aliases.py,sha256=gEYJ8zOpV1m0NVyYUbAL43psp9Lxw_0t68mYlI65Sds,1262
+iqm_station_control_client-9.1.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_station_control_client-9.1.0.dist-info/METADATA,sha256=dMBDpRAswdP4cKl7dZd81DCW4cQRKRtXyIeIoHa-9HM,14010
+iqm_station_control_client-9.1.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_station_control_client-9.1.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_station_control_client-9.1.0.dist-info/RECORD,,

iqm/station_control/client/iqm_server/meta_class.py

@@ -1,38 +0,0 @@
-# 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