iqm-station-control-client 9.11.0__py3-none-any.whl → 9.13.0__py3-none-any.whl

iqm/station_control/client/list_models.py

@@ -16,7 +16,7 @@
 These are used mainly for easy serialization and deserialization of list of objects.
 """
 
-from typing import Generic, TypeAlias, TypeVar
+from typing import Generic, TypeVar
 
 from pydantic import ConfigDict, RootModel
 
@@ -64,12 +64,37 @@ class ListModel(RootModel):
     )
 
 
-DutList: TypeAlias = ListModel[list[DutData]]  # type: ignore[type-arg]
-DutFieldDataList: TypeAlias = ListModel[list[DutFieldData]]  # type: ignore[type-arg]
-ObservationDataList: TypeAlias = ListModel[list[ObservationData]]  # type: ignore[type-arg]
-ObservationDefinitionList: TypeAlias = ListModel[list[ObservationDefinition]]  # type: ignore[type-arg]
-ObservationLiteList: TypeAlias = ListModel[list[ObservationLite]]  # type: ignore[type-arg]
-ObservationUpdateList: TypeAlias = ListModel[list[ObservationUpdate]]  # type: ignore[type-arg]
-ObservationSetDataList: TypeAlias = ListModel[list[ObservationSetData]]  # type: ignore[type-arg]
-SequenceMetadataDataList: TypeAlias = ListModel[list[SequenceMetadataData]]  # type: ignore[type-arg]
-RunLiteList: TypeAlias = ListModel[list[RunLite]]  # type: ignore[type-arg]
+class DutList(ListModel):
+    root: list[DutData]
+
+
+class DutFieldDataList(ListModel):
+    root: list[DutFieldData]
+
+
+class ObservationDataList(ListModel):
+    root: list[ObservationData]
+
+
+class ObservationDefinitionList(ListModel):
+    root: list[ObservationDefinition]
+
+
+class ObservationLiteList(ListModel):
+    root: list[ObservationLite]
+
+
+class ObservationUpdateList(ListModel):
+    root: list[ObservationUpdate]
+
+
+class ObservationSetDataList(ListModel):
+    root: list[ObservationSetData]
+
+
+class SequenceMetadataDataList(ListModel):
+    root: list[SequenceMetadataData]
+
+
+class RunLiteList(ListModel):
+    root: list[RunLite]

iqm/station_control/client/qon.py

@@ -16,10 +16,12 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
-from dataclasses import dataclass, field
 from enum import StrEnum
 import logging
-from typing import Any, Final, TypeAlias
+from typing import Annotated, Any, Final, TypeAlias
+
+from pydantic import Field
+from pydantic.dataclasses import dataclass
 
 from iqm.station_control.interface.models.observation import ObservationBase
 
@@ -35,6 +37,9 @@ _SUFFIX_SEPARATOR: Final[str] = ":"
 LOCUS_SEPARATOR: Final[str] = "__"
 """Separates QPU components in a locus string."""
 
+_PATTERN: Final[str] = r"^[A-Za-z_][A-Za-z0-9_]*$"
+"""Regex that most observation name parts must follow."""
+
 Locus: TypeAlias = tuple[str, ...]
 """Sequence of QPU component physical names a quantum operation acts on. The order may matter."""
 
@@ -77,7 +82,7 @@ def _parse_suffixes(suffixes: Iterable[str]) -> Suffixes:
     return dict(sorted(suffix_dict.items()))
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, config={"extra": "forbid"})  # do not allow unknown keyword args
 class QON:
     """Qualified observation name.
 
@@ -103,7 +108,7 @@ class QON:
         raise NotImplementedError
 
     @classmethod
-    def from_str(cls, name: str) -> "QON":
+    def from_str(cls, name: str) -> QON:
         """Parse an observation name into a QON object.
 
         Args:
@@ -162,7 +167,7 @@ class QONCharacterization(QON):
         return _FIELD_SEPARATOR.join([self.domain, "model", self.component, self.quantity])
 
     @classmethod
-    def _parse(cls, rest: str) -> "QONCharacterization":
+    def _parse(cls, rest: str) -> QONCharacterization:
         """Parse a characterization observation name."""
         parts = rest.split(_FIELD_SEPARATOR, maxsplit=1)
         if len(parts) < 2:
@@ -175,8 +180,131 @@ class QONCharacterization(QON):
         )
 
 
+class QONMetricRegistry:
+    """Registry for QONMetric subclasses, mapping method names to parser classes.
+
+    Allows extensible registration of new metric parsing strategies for new methods.
+    """
+
+    _registry: dict[str, type[QONMetric]] = {}
+    """Mapping from QONMetric method name to the subclass that handles it."""
+    _inv_registry: dict[type[QONMetric], frozenset[str]] = {}
+    """Mapping from QONMetric subclass to the methods it handles."""
+
+    @classmethod
+    def register(cls, method_names: Iterable[str]):
+        """Decorator for registering a QONMetric subclass as the parser for one or more method names.
+
+        Args:
+            method_names: One or more method names to associate with the subclass.
+
+        Returns:
+            The decorator function.
+
+        """
+
+        def decorator(subclass: type[QONMetric]):
+            for name in method_names:
+                if (owner := cls._registry.get(name)) is not None:
+                    raise ValueError(f"Method {name} already registered to {owner.__name__}")
+                cls._registry[name] = subclass
+            cls._inv_registry[subclass] = frozenset(method_names)
+            return subclass
+
+        return decorator
+
+    @classmethod
+    def get_parser(cls, method_name: str) -> type[QONMetric]:
+        """Retrieve the parser class for a given method name.
+
+        Args:
+            method_name: The method name to look up.
+
+        Returns:
+            The QONMetric subclass registered for the method.
+
+        Raises:
+            UnknownObservationError: ``method_name`` is not registered.
+
+        """
+        try:
+            return cls._registry[method_name]
+        except KeyError:
+            raise UnknownObservationError("Unknown quality metric.")
+
+    @classmethod
+    def registered_methods(cls) -> list[str]:
+        """Get a list of all registered method names.
+
+        Returns:
+            List of registered method names.
+
+        """
+        return list(cls._registry.keys())
+
+
 @dataclass(frozen=True)
 class QONMetric(QON):
+    """Base class for QON representing a gate quality metric.
+
+    Subclasses implement parsing and string representation for specific methods.
+    """
+
+    method: Annotated[str, Field(pattern=_PATTERN)]
+    locus: str
+    """Sequence of names of QPU components on which the gate is applied, or on which the experiment is run."""
+    metric: Annotated[str, Field(pattern=r"^[A-Za-z_0-9][A-Za-z0-9_]*$")]
+    """Measured metric."""
+
+    def __post_init__(self):
+        if self.method not in QONMetricRegistry._inv_registry[self.__class__]:
+            raise UnknownObservationError(
+                f"{self.__class__.__name__} is not registered to handle the method {self.method}"
+            )
+
+    @property
+    def domain(self) -> Domain:
+        """Return the QON domain for metrics."""
+        return Domain.METRIC
+
+    @classmethod
+    def _parse(cls, method: str, method_specific_part: str) -> QONMetric:
+        """Parse a metric observation name using the appropriate registered subclass.
+
+        Args:
+            method: The method name.
+            method_specific_part: The method-specific part of the metric observation name.
+
+        Returns:
+            Parsed metric name.
+
+        Raises:
+            UnknownObservationError: ``method`` is not registered.
+
+        """
+        parser_cls = QONMetricRegistry.get_parser(method)
+        return parser_cls._parse(method, method_specific_part)
+
+
+@QONMetricRegistry.register(
+    [
+        "rb",
+        "irb",
+        "ssro",
+        "restless_ssro",
+        "readout_rb",
+        "qndness",
+        "msmt_qndness",
+        "npopex_echo",
+        "npopex_long",
+        "coherence_cz",
+        "ncz_swap",
+        "entanglement_coherence",
+        "conditional_reset",
+    ]
+)
+@dataclass(frozen=True)
+class QONGateMetric(QONMetric):
     """QON representing a gate quality metric.
 
     Has the form ``metrics.{method}.{method_specific_part}``.
@@ -209,97 +337,107 @@ class QONMetric(QON):
         locus: QB4
         metric: fidelity
         suffixes: {"par": "d2"}
-
-    ``metrics.ghz_state.QB1__QB2.coherence_lower_bound``
-
-        method: ghz_state
-        gate: None
-        implementation: None
-        locus: QB1__QB2
-        metric: coherence_lower_bound
-        suffixes: {}
-
     """
 
-    method: str
-    gate: str | None
+    gate: Annotated[str, Field(pattern=_PATTERN)]
     """Name of the gate/quantum operation."""
-    implementation: str | None
+    implementation: Annotated[str, Field(pattern=_PATTERN)]
     """Name of the gate implementation."""
-    locus: str
-    """Sequence of names of QPU components on which the gate/operation is applied."""
-    metric: str
-    """Measured metric."""
-    suffixes: Suffixes = field(default_factory=dict)
+    suffixes: Suffixes = Field(default_factory=dict)
     """Suffixes defining the metric further (if any)."""
 
-    @property
-    def domain(self) -> Domain:
-        return Domain.METRIC
-
     def __str__(self) -> str:
-        if self.method == "ghz_state":
-            parts = [self.domain, self.method, self.locus, self.metric]
-        else:
-            gate_str = self.gate if self.gate is not None else ""
-            impl_str = self.implementation if self.implementation is not None else ""
-            parts = [self.domain, self.method, gate_str, impl_str, self.locus, self.metric]
+        parts = [self.domain, self.method, self.gate, self.implementation, self.locus, self.metric]
         name = _FIELD_SEPARATOR.join(parts)
-        suffixes = _SUFFIX_SEPARATOR.join(f"{key}={value}" for key, value in self.suffixes.items())
-        if suffixes:
-            return f"{name}:{suffixes}"
+        if self.suffixes:
+            suffix_str = _SUFFIX_SEPARATOR.join(f"{k}={v}" for k, v in sorted(self.suffixes.items()))
+            return f"{name}:{suffix_str}"
         return name
 
     @classmethod
-    def _parse(cls, method: str, method_specific_part: str) -> "QONMetric":
-        """Parse a gate quality metric name.
+    def _parse(cls, method: str, method_specific_part: str) -> QONGateMetric:
+        """Parse a metric observation name that includes a gate and an implementation.
 
         Args:
-            method: Method used to measure the gate metric.
-            method_specific_part: Dot-separated fields specific to ``method``, possibly followed by suffixes.
+            method: The method name.
+            method_specific_part: The method-specific part of the metric observation name.
+
+        Returns:
+            Parsed metric name.
 
         Raises:
-            ValueError: Failed to parse ``name`` because it was syntactically incorrect.
-            UnknownObservationError: Failed to parse ``name`` because it contains unknown elements.
+            ValueError: Observation name is malformed.
 
         """
-        # gate metrics may have suffixes, split them off
-        fragments = method_specific_part.split(_SUFFIX_SEPARATOR)
-        suffixes = _parse_suffixes(fragments[1:])
-
-        # parse the rest of the method specific part
-        fields = fragments[0]
-        if method in ("rb", "irb", "ssro"):
-            # {gate}.{implementation}.{locus_str}.{metric}"
-            parts = fields.split(_FIELD_SEPARATOR, maxsplit=3)
-            if len(parts) < 4:
-                raise ValueError(f"{method} gate quality metric name has less than 6 parts")
-            gate, implementation, locus, metric = parts
-            return cls(
-                method=method,
-                gate=gate,
-                implementation=implementation,
-                locus=locus,
-                metric=metric,
-                suffixes=suffixes,
-            )
+        parts, suffixes = _split_obs_name(method_specific_part, maxsplit=3)
+        if len(parts) < 4:
+            raise ValueError(f"{method} gate quality metric name has less than 6 parts")
+        gate, implementation, locus, metric = parts
+        return cls(
+            method=method,
+            gate=gate,
+            implementation=implementation,
+            locus=locus,
+            metric=metric,
+            suffixes=suffixes,
+        )
 
-        if method == "ghz_state":
-            # {locus_str}.{metric}
-            parts = fields.split(_FIELD_SEPARATOR, maxsplit=1)
-            if len(parts) < 2:
-                raise ValueError(f"{method} gate quality metric name has less than 4 parts")
-            locus, metric = parts
-            return cls(
-                method=method,
-                gate=None,
-                implementation=None,
-                locus=locus,
-                metric=metric,
-                suffixes=suffixes,
-            )
 
-        raise UnknownObservationError("Unknown gate quality metric.")
+@QONMetricRegistry.register(["ghz_state", "coherence_gef", "relaxation_ef", "simultaneous_coherence_gef", "t1_coupled"])
+@dataclass(frozen=True)
+class QONSystemMetric(QONMetric):
+    """QON representing a system quality metric.
+
+    Has the form ``metrics.{method}.{locus}.{metric}``.
+
+    Can parse/represent e.g. the following metrics:
+
+    ``metrics.irb.circuit.random_circuit.QB4.fidelity:par=d2``
+
+        method: irb
+        gate: circuit
+        implementation: random_circuit
+        locus: QB4
+        metric: fidelity
+        suffixes: {"par": "d2"}
+
+    ``metrics.ghz_state.QB1__QB2.coherence_lower_bound``
+
+        method: ghz_state
+        locus: QB1__QB2
+        metric: coherence_lower_bound
+
+    Subclasses implement parsing and string representation for specific methods.
+    """
+
+    def __str__(self) -> str:
+        parts = [self.domain, self.method, self.locus, self.metric]
+        return _FIELD_SEPARATOR.join(parts)
+
+    @classmethod
+    def _parse(cls, method: str, method_specific_part: str) -> QONSystemMetric:
+        """Parse a metric observation name without a gate or an implementation.
+
+        Args:
+            method: The method name.
+            method_specific_part: The method-specific part of the metric observation name.
+
+        Returns:
+            Parsed metric name.
+
+        Raises:
+            ValueError: Observation name is malformed.
+
+        """
+        parts = method_specific_part.split(_FIELD_SEPARATOR, maxsplit=1)
+        if len(parts) < 2:
+            raise ValueError(f"{method} system quality metric name has less than 4 parts")
+        locus, metric = parts
+        return cls(
+            method=method,
+            locus=locus,
+            metric=metric,
+        )
 
 
 @dataclass(frozen=True)
@@ -309,7 +447,7 @@ class QONControllerSetting(QON):
     Has the form ``controllers.{controller}[.{subcontroller}]*.{setting}``.
     """
 
-    controller: str
+    controller: Annotated[str, Field(pattern=_PATTERN)]
     """Name of the controller."""
     rest: str
     """Possible subcontroller names in a dotted structure, ending in the setting name."""
@@ -322,7 +460,7 @@ class QONControllerSetting(QON):
         return _FIELD_SEPARATOR.join([self.domain, self.controller, self.rest])
 
     @classmethod
-    def _parse(cls, controller: str, controller_specific_part: str) -> "QONControllerSetting":
+    def _parse(cls, controller: str, controller_specific_part: str) -> QONControllerSetting:
         """Parse a controller setting observation name."""
         return cls(
             controller=controller,
@@ -337,9 +475,9 @@ class QONGateParam(QON):
     Has the form ``gates.{gate}.{implementation}.{locus_str}.{parameter}``.
     """
 
-    gate: str
+    gate: Annotated[str, Field(pattern=_PATTERN)]
     """Name of the gate/quantum operation."""
-    implementation: str | None
+    implementation: Annotated[str, Field(pattern=_PATTERN)]
     """Name of the gate implementation."""
     locus: str
     """Sequence of names of QPU components on which the gate is applied."""
@@ -351,11 +489,10 @@ class QONGateParam(QON):
         return Domain.GATE_PARAMETER
 
     def __str__(self) -> str:
-        impl_str = self.implementation if self.implementation is not None else ""
-        return _FIELD_SEPARATOR.join([self.domain, self.gate, impl_str, self.locus, self.parameter])
+        return _FIELD_SEPARATOR.join([self.domain, self.gate, self.implementation, self.locus, self.parameter])
 
     @classmethod
-    def _parse(cls, gate: str, rest: str) -> "QONGateParam":
+    def _parse(cls, gate: str, rest: str) -> QONGateParam:
         """Parse a gate parameter observation name."""
         parts = rest.split(_FIELD_SEPARATOR, maxsplit=2)
         if len(parts) < 3:
@@ -369,14 +506,14 @@ class QONGateParam(QON):
         )
 
 
-def _split_obs_name(obs_name: str) -> tuple[list[str], Suffixes]:
+def _split_obs_name(obs_name: str, *, maxsplit: int = -1) -> tuple[list[str], Suffixes]:
     """Split the given observation name into path elements and suffixes."""
     # some observation names may have suffixes, split them off
     fragments = obs_name.split(_SUFFIX_SEPARATOR)
     suffixes = _parse_suffixes(fragments[1:])
 
     # split the path elements
-    path = fragments[0].split(_FIELD_SEPARATOR)
+    path = fragments[0].split(_FIELD_SEPARATOR, maxsplit=maxsplit)
     return path, suffixes
 
 

iqm/station_control/client/station_control.py

@@ -62,7 +62,7 @@ from iqm.station_control.client.serializers import (
 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.sweep_serializers import deserialize_sweep_data
-from iqm.station_control.interface.list_with_meta import ListWithMeta
+from iqm.station_control.interface.list_with_meta import ListWithMeta, Meta
 from iqm.station_control.interface.models import (
     DutData,
     DutFieldData,
@@ -358,7 +358,7 @@ class StationControlClient(_StationControlClientBase):
     def create_observations(
         self, observation_definitions: Sequence[ObservationDefinition]
     ) -> ListWithMeta[ObservationData]:  # type: ignore[type-arg]
-        json_str = self._serialize_model(ObservationDefinitionList(observation_definitions))
+        json_str = self._serialize_model(ObservationDefinitionList(list(observation_definitions)))
         response = self._send_request(requests.post, "observations", json_str=json_str)
         return self._deserialize_response(response, ObservationDataList, list_with_meta=True)
 
@@ -394,7 +394,7 @@ class StationControlClient(_StationControlClientBase):
         return self._deserialize_response(response, ObservationDataList, list_with_meta=True)
 
     def update_observations(self, observation_updates: Sequence[ObservationUpdate]) -> list[ObservationData]:
-        json_str = self._serialize_model(ObservationUpdateList(observation_updates))
+        json_str = self._serialize_model(ObservationUpdateList(list(observation_updates)))
         response = self._send_request(requests.patch, "observations", json_str=json_str)
         return self._deserialize_response(response, ObservationDataList)
 
@@ -612,22 +612,23 @@ class StationControlClient(_StationControlClientBase):
     @staticmethod
     def _deserialize_response(
         response: requests.Response,
-        model_class: type[TypePydanticBase | ListModel[list[TypePydanticBase]]],  # type: ignore[type-arg]
+        model_class: type[TypePydanticBase | ListModel],
         *,
         list_with_meta: bool = False,
-    ) -> TypePydanticBase | ListWithMeta[TypePydanticBase]:  # type: ignore[type-arg]
+    ) -> TypePydanticBase | ListWithMeta:
         # Use "model_validate_json(response.text)" instead of "model_validate(response.json())".
         # This validates the provided data as a JSON string or bytes object.
         # If your incoming data is a JSON payload, this is generally considered faster.
         if list_with_meta:
-            response_with_meta = ResponseWithMeta.model_validate_json(response.text)  # type: ignore[var-annotated]
-            if response_with_meta.meta and response_with_meta.meta.errors:
-                logger.warning(
-                    "Errors in station control response:\n  - %s", "\n  - ".join(response_with_meta.meta.errors)
-                )
-            return ListWithMeta(model_class.model_validate(response_with_meta.items), meta=response_with_meta.meta)  # type: ignore[arg-type]
+            response_with_meta: ResponseWithMeta = ResponseWithMeta.model_validate_json(response.text)
+            meta = response_with_meta.meta or Meta()
+            if meta and meta.errors:
+                logger.warning("Errors in station control response:\n  - %s", "\n  - ".join(meta.errors))
+            return ListWithMeta(model_class.model_validate(response_with_meta.items), meta=meta)
         model = model_class.model_validate_json(response.text)
-        return model  # type: ignore[return-value]
+        if isinstance(model, ListModel):
+            return model.root
+        return model
 
 
 def _remove_empty_values(kwargs: dict[str, Any]) -> dict[str, Any]:

iqm/station_control/interface/list_with_meta.py

@@ -11,7 +11,7 @@
 # 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.
-"""Models to extend standard list with metadata."""
+"""Models to extend a standard list with metadata."""
 
 from collections.abc import Iterable
 from dataclasses import dataclass

{iqm_station_control_client-9.11.0.dist-info → iqm_station_control_client-9.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-station-control-client
-Version: 9.11.0
+Version: 9.13.0
 Summary: Python client for communicating with Station Control Service
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License

{iqm_station_control_client-9.11.0.dist-info → iqm_station_control_client-9.13.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 iqm/station_control/client/__init__.py,sha256=1ND-AkIE9xLGIscH3WN44eyll9nlFhXeyCm-8EDFGQ4,942
-iqm/station_control/client/list_models.py,sha256=7JJyn5jCBOvMBJWdsVsPRLhtChMxqLa6O9hElpeXEt8,2701
+iqm/station_control/client/list_models.py,sha256=w_KUflrR9J1ODphu7dy3BOj1d4fzNrHj0J0HfgNitO4,2508
 iqm/station_control/client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iqm/station_control/client/qon.py,sha256=--vWZ8ueX3pFIZPSt4N_5eQt4Ski_FJCceXDHKr77Ns,22782
-iqm/station_control/client/station_control.py,sha256=cQqHuTu3K7iVtZzdtIuihTXa_GPydyZFIjZtyCPzh7s,29208
+iqm/station_control/client/qon.py,sha256=_jGGTGIfoy1ANg65Ht07_7YKFAFxukxxV9lgcatq-hk,26865
+iqm/station_control/client/station_control.py,sha256=X19lCDgaoH36zOvNpsBxEE9BgijdeE2cp639S-G2hjw,29073
 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=a8l7UTnzfbD8KDHP-uOve77S6LR1ai9uM_J_xHbLs0Y,1175
@@ -36,7 +36,7 @@ iqm/station_control/client/serializers/struct_serializer.py,sha256=7LSlrGVz0c-yi
 iqm/station_control/client/serializers/sweep_serializers.py,sha256=iFeBb4RFbHpVZifyduUypACSvulhkzdQIyG0gDoXOwM,5807
 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/list_with_meta.py,sha256=M8BacgBDjbf7yabNK-OHCJWrci5hewXA9vd8MrqrZts,1187
 iqm/station_control/interface/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iqm/station_control/interface/pydantic_base.py,sha256=pQCa-8SRgBKMSwG-KyXA1HcIxE_qGMJt9g_eOGdZ31g,1303
 iqm/station_control/interface/station_control.py,sha256=5gtDouAQ13KnyXNQUcBrpKG9pZdjIsX6fLJU9bmYJxU,20433
@@ -52,8 +52,8 @@ iqm/station_control/interface/models/sequence.py,sha256=boWlMfP3woVgVObW3OaNbxsU
 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.11.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_station_control_client-9.11.0.dist-info/METADATA,sha256=IOUlvKf6Bc5KW2hHiXbdkq4giUymE_YH5U4AHzkRJUg,14107
-iqm_station_control_client-9.11.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_station_control_client-9.11.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_station_control_client-9.11.0.dist-info/RECORD,,
+iqm_station_control_client-9.13.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_station_control_client-9.13.0.dist-info/METADATA,sha256=hpH1t_jyd8TBZhZ_kSSk6pUlKKZmIyjJO0VKzYTjmRw,14107
+iqm_station_control_client-9.13.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_station_control_client-9.13.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_station_control_client-9.13.0.dist-info/RECORD,,