iqm-exa-common 26.26.0__py3-none-any.whl → 26.28.0__py3-none-any.whl

exa/common/api/proto_serialization/_parameter.py

@@ -14,36 +14,36 @@
 
 """Pack and unpack parameters to protos and back."""
 
-import iqm.data_definitions.common.v1.parameter_pb2 as ppb
+from iqm.data_definitions.common.v1.parameter_pb2 import Parameter as ppb_Parameter
 
 from exa.common.data.parameter import CollectionType, DataType, Parameter
 
 _COLLECTION_TYPES = {
-    CollectionType.SCALAR: ppb.Parameter.CollectionType.COLLECTION_TYPE_SCALAR,
-    CollectionType.LIST: ppb.Parameter.CollectionType.COLLECTION_TYPE_SEQUENCE,
-    CollectionType.NDARRAY: ppb.Parameter.CollectionType.COLLECTION_TYPE_ARRAY,
+    CollectionType.SCALAR: ppb_Parameter.CollectionType.COLLECTION_TYPE_SCALAR,
+    CollectionType.LIST: ppb_Parameter.CollectionType.COLLECTION_TYPE_SEQUENCE,
+    CollectionType.NDARRAY: ppb_Parameter.CollectionType.COLLECTION_TYPE_ARRAY,
 }
 _collection_types_inv = {v: k for k, v in _COLLECTION_TYPES.items()}
 
 _DATA_TYPES = {
-    DataType.ANYTHING: ppb.Parameter.DataType.DATA_TYPE_UNSPECIFIED,
-    DataType.NUMBER: ppb.Parameter.DataType.DATA_TYPE_FLOAT64,  # Deprecated
-    DataType.STRING: ppb.Parameter.DataType.DATA_TYPE_STRING,
-    DataType.COMPLEX: ppb.Parameter.DataType.DATA_TYPE_COMPLEX128,
-    DataType.BOOLEAN: ppb.Parameter.DataType.DATA_TYPE_BOOL,
-    DataType.INT: ppb.Parameter.DataType.DATA_TYPE_INT64,
-    DataType.FLOAT: ppb.Parameter.DataType.DATA_TYPE_FLOAT64,
+    DataType.ANYTHING: ppb_Parameter.DataType.DATA_TYPE_UNSPECIFIED,
+    DataType.NUMBER: ppb_Parameter.DataType.DATA_TYPE_FLOAT64,  # Deprecated
+    DataType.STRING: ppb_Parameter.DataType.DATA_TYPE_STRING,
+    DataType.COMPLEX: ppb_Parameter.DataType.DATA_TYPE_COMPLEX128,
+    DataType.BOOLEAN: ppb_Parameter.DataType.DATA_TYPE_BOOL,
+    DataType.INT: ppb_Parameter.DataType.DATA_TYPE_INT64,
+    DataType.FLOAT: ppb_Parameter.DataType.DATA_TYPE_FLOAT64,
 }
 _data_types_inv = {v: k for k, v in _DATA_TYPES.items() if k != DataType.NUMBER}
 
 
-def pack(parameter: Parameter) -> ppb.Parameter:
+def pack(parameter: Parameter) -> ppb_Parameter:
     """Convert Parameter into protobuf representation."""
-    return ppb.Parameter(
+    return ppb_Parameter(
         name=parameter.name,
         label=parameter.label,
         unit=parameter.unit,
-        data_type=_DATA_TYPES.get(parameter.data_type, ppb.Parameter.DataType.DATA_TYPE_UNSPECIFIED),
+        data_type=_DATA_TYPES.get(parameter.data_type, ppb_Parameter.DataType.DATA_TYPE_UNSPECIFIED),  # type: ignore[arg-type]
         collection_type=_COLLECTION_TYPES[parameter.collection_type],
         element_indices=parameter.element_indices,
         parent_name=parameter.parent_name,
@@ -51,21 +51,21 @@ def pack(parameter: Parameter) -> ppb.Parameter:
     )
 
 
-def unpack(proto: ppb.Parameter) -> Parameter:
+def unpack(proto: ppb_Parameter) -> Parameter:
     """Convert protobuf representation into a Parameter."""
     if not proto.element_indices:
         return Parameter(
             name=proto.name,
             label=proto.label,
             unit=proto.unit,
-            data_type=_data_types_inv.get(proto.data_type),
-            collection_type=_collection_types_inv.get(proto.collection_type),
+            data_type=_data_types_inv.get(proto.data_type),  # type: ignore[arg-type]
+            collection_type=_collection_types_inv.get(proto.collection_type),  # type: ignore[arg-type]
         )
     return Parameter(
         name=proto.parent_name,
         label=proto.parent_label,
         unit=proto.unit,
-        data_type=_data_types_inv.get(proto.data_type),
-        collection_type=_collection_types_inv.get(proto.collection_type),
+        data_type=_data_types_inv.get(proto.data_type),  # type: ignore[arg-type]
+        collection_type=_collection_types_inv.get(proto.collection_type),  # type: ignore[arg-type]
         element_indices=list(proto.element_indices),
     )

exa/common/api/proto_serialization/array.py

@@ -14,11 +14,11 @@
 
 """Convert numpy arrays to protos and back."""
 
-import iqm.data_definitions.common.v1.data_types_pb2 as dpb
+from iqm.data_definitions.common.v1.data_types_pb2 import Array as dpb_Array
 import numpy as np
 
 
-def pack(array: np.ndarray) -> dpb.Array:
+def pack(array: np.ndarray) -> dpb_Array:
     """Packs a numeric numpy array into protobuf format.
 
     Args:
@@ -28,7 +28,7 @@ def pack(array: np.ndarray) -> dpb.Array:
         A protobuf instance that encapsulates `array`.
 
     """
-    target = dpb.Array()
+    target = dpb_Array()
     target.shape.MergeFrom(array.shape)
     if not array.size:  # MergeFrom throws with 0-sized iterables
         return target
@@ -54,7 +54,7 @@ def pack(array: np.ndarray) -> dpb.Array:
     return target
 
 
-def unpack(source: dpb.Array) -> np.ndarray:
+def unpack(source: dpb_Array) -> np.ndarray:
     """Unpacks protobuf to array. Reverse operation of :func:`.pack`.
 
     Args:

exa/common/api/proto_serialization/datum.py

@@ -16,13 +16,14 @@
 
 from collections.abc import Sequence
 
-import iqm.data_definitions.common.v1.data_types_pb2 as dpb
+from iqm.data_definitions.common.v1.data_types_pb2 import Complex128 as dpb_Complex128
+from iqm.data_definitions.common.v1.data_types_pb2 import Datum as dpb_Datum
 import numpy as np
 
 from exa.common.api.proto_serialization import array, sequence
 
 
-def pack(value: None | bool | str | int | float | complex | np.ndarray | Sequence) -> dpb.Datum:
+def pack(value: None | bool | str | int | float | complex | np.ndarray | Sequence) -> dpb_Datum:
     """Packs a string, numerical value, or an array thereof into protobuf format.
 
     Supported data types are:
@@ -48,25 +49,25 @@ def pack(value: None | bool | str | int | float | complex | np.ndarray | Sequenc
             f"Encoding of numpy type '{type(value)}' is not supported. Cast the value into a native type first."
         )
     if value is None:
-        return dpb.Datum(null_value=True)
+        return dpb_Datum(null_value=True)
     if isinstance(value, bool):
-        return dpb.Datum(bool_value=value)
+        return dpb_Datum(bool_value=value)
     if isinstance(value, str):
-        return dpb.Datum(string_value=value)
+        return dpb_Datum(string_value=value)
     if isinstance(value, int):
-        return dpb.Datum(sint64_value=value)
+        return dpb_Datum(sint64_value=value)
     if isinstance(value, float):
-        return dpb.Datum(float64_value=value)
+        return dpb_Datum(float64_value=value)
     if isinstance(value, complex):
-        return dpb.Datum(complex128_value=dpb.Complex128(real=value.real, imag=value.imag))
+        return dpb_Datum(complex128_value=dpb_Complex128(real=value.real, imag=value.imag))
     if isinstance(value, np.ndarray):
-        return dpb.Datum(array=array.pack(value))
+        return dpb_Datum(array=array.pack(value))
     if isinstance(value, Sequence):
-        return dpb.Datum(sequence=sequence.pack(value))
+        return dpb_Datum(sequence=sequence.pack(value))
     raise TypeError(f"Encoding of type '{type(value)}' is not supported.")
 
 
-def unpack(source: dpb.Datum) -> None | str | bool | int | float | complex | np.ndarray | list:
+def unpack(source: dpb_Datum) -> None | str | bool | int | float | complex | np.ndarray | list:
     """Unpacks a protobuf into a native Python type or a numpy array. Reverse operation of :func:`.pack`.
 
     Args:
@@ -122,19 +123,19 @@ def deserialize(source: bytes) -> None | str | bool | int | float | complex | np
           Deserialized data.
 
     """
-    proto = dpb.Datum()
+    proto = dpb_Datum()
     proto.ParseFromString(source)
     return unpack(proto)
 
 
-def _pack_complex128(value: np.complex128 | complex, target: dpb.Complex128 | None = None) -> dpb.Complex128:
+def _pack_complex128(value: np.complex128 | complex, target: dpb_Complex128 | None = None) -> dpb_Complex128:
     """Packs a numpy complex128 to the respective protobuf type."""
-    target = target or dpb.Complex128()
+    target = target or dpb_Complex128()
     target.real = value.real
     target.imag = value.imag
     return target
 
 
-def _unpack_complex128_value(complex128_value: dpb.Complex128) -> complex:
+def _unpack_complex128_value(complex128_value: dpb_Complex128) -> complex:
     """Unpack a protobuf to a native complex number."""
     return complex(complex128_value.real, complex128_value.imag)

exa/common/api/proto_serialization/nd_sweep.py

@@ -14,7 +14,9 @@
 
 """Convert NdSweeps to protos and back."""
 
-import iqm.data_definitions.common.v1.sweep_pb2 as spb
+from iqm.data_definitions.common.v1.sweep_pb2 import CartesianSweep as spb_CartesianSweep
+from iqm.data_definitions.common.v1.sweep_pb2 import ParallelSweep as spb_ParallelSweep
+from iqm.data_definitions.common.v1.sweep_pb2 import SingleParameterSweep as spb_SingleParameterSweep
 
 from exa.common.api.proto_serialization import sequence
 import exa.common.api.proto_serialization._parameter as param_proto
@@ -23,22 +25,22 @@ from exa.common.data.parameter import DataType, Parameter
 from exa.common.sweep.util import NdSweep
 
 
-def pack(nd_sweep: NdSweep, minimal: bool = True) -> spb.CartesianSweep:
+def pack(nd_sweep: NdSweep, minimal: bool = True) -> spb_CartesianSweep:
     """Convert an NdSweep into protobuf representation.
 
     Note: The protobuf does not make any distinction between different types of Sweeps, so the type information is lost.
     """
     parallels = []
     for parallel in nd_sweep:
-        parallel_proto = spb.ParallelSweep()
+        parallel_proto = spb_ParallelSweep()
         parallel_proto.single_parameter_sweeps.MergeFrom((_pack_single_sweep(sweep, minimal) for sweep in parallel))
         parallels.append(parallel_proto)
-    proto = spb.CartesianSweep()
+    proto = spb_CartesianSweep()
     proto.parallel_sweeps.MergeFrom(reversed(parallels))  # In data-definitions, order is outermost loop first
     return proto
 
 
-def unpack(proto: spb.CartesianSweep) -> NdSweep:
+def unpack(proto: spb_CartesianSweep) -> NdSweep:
     """Convert protobuf representation into a NdSweep. Reverse operation of :func:`.pack`."""
     nd_sweep = []
     for parallel_proto in reversed(proto.parallel_sweeps):
@@ -47,14 +49,14 @@ def unpack(proto: spb.CartesianSweep) -> NdSweep:
     return nd_sweep
 
 
-def _pack_single_sweep(sweep: Sweep, minimal: bool) -> spb.SingleParameterSweep:
-    kwargs = {"parameter_name": sweep.parameter.name, "values": sequence.pack(sweep.data)}
+def _pack_single_sweep(sweep: Sweep, minimal: bool) -> spb_SingleParameterSweep:
+    kwargs = {"parameter_name": sweep.parameter.name, "values": sequence.pack(sweep.data)}  # type: ignore[arg-type]
     if not minimal:
         kwargs["parameter"] = param_proto.pack(sweep.parameter)
-    return spb.SingleParameterSweep(**kwargs)
+    return spb_SingleParameterSweep(**kwargs)
 
 
-def _unpack_single_sweep(proto: spb.SingleParameterSweep) -> Sweep:
+def _unpack_single_sweep(proto: spb_SingleParameterSweep) -> Sweep:
     sweep_values = sequence.unpack(proto.values)
     if proto.HasField("parameter"):
         parameter = param_proto.unpack(proto.parameter)

exa/common/api/proto_serialization/sequence.py

@@ -16,11 +16,11 @@
 
 from collections.abc import Sequence
 
-import iqm.data_definitions.common.v1.data_types_pb2 as dpb
+from iqm.data_definitions.common.v1.data_types_pb2 import Sequence as dpb_Sequence
 import numpy as np
 
 
-def pack(values: Sequence) -> dpb.Sequence:
+def pack(values: Sequence) -> dpb_Sequence:
     """Packs a sequence of native Python types into protobuf format.
 
     Args:
@@ -33,7 +33,7 @@ def pack(values: Sequence) -> dpb.Sequence:
         ValueError in case of unsupported value.
 
     """
-    target = dpb.Sequence()
+    target = dpb_Sequence()
     if not values:
         return target
     dtype = type(values[0])
@@ -57,7 +57,7 @@ def pack(values: Sequence) -> dpb.Sequence:
     return target
 
 
-def unpack(source: dpb.Sequence) -> list:
+def unpack(source: dpb_Sequence) -> list:
     """Unpacks protobuf to list. Reverse operation of :func:`.pack`.
 
     Args:

exa/common/api/proto_serialization/setting_node.py

@@ -14,7 +14,7 @@
 
 """Convert SettingNodes to protos and back."""
 
-import iqm.data_definitions.common.v1.setting_pb2 as spb
+from iqm.data_definitions.common.v1.setting_pb2 import SettingNode as spb_SettingNode
 
 from exa.common.api.proto_serialization import datum
 import exa.common.api.proto_serialization._parameter as param_proto
@@ -23,7 +23,7 @@ from exa.common.data.setting_node import Setting, SettingNode
 from exa.common.helpers.numpy_helper import coerce_numpy_type_to_native
 
 
-def _pack_setting(setting: Setting, optimize: bool) -> spb.SettingNode.Setting:
+def _pack_setting(setting: Setting, optimize: bool) -> spb_SettingNode.Setting:
     """Convert a Setting into protobuf representation."""
     value = coerce_numpy_type_to_native(setting.value)
     try:
@@ -33,11 +33,11 @@ def _pack_setting(setting: Setting, optimize: bool) -> spb.SettingNode.Setting:
             f"Failed to convert a value to protobuf. Value={setting.value}, Parameter={setting.parameter}."
         ) from err
     if optimize:
-        return spb.SettingNode.Setting(parameter_name=setting.name, value=packed)
-    return spb.SettingNode.Setting(parameter=param_proto.pack(setting.parameter), value=packed)
+        return spb_SettingNode.Setting(parameter_name=setting.name, value=packed)
+    return spb_SettingNode.Setting(parameter=param_proto.pack(setting.parameter), value=packed)
 
 
-def _unpack_setting(proto: spb.SettingNode.Setting) -> Setting:
+def _unpack_setting(proto: spb_SettingNode.Setting) -> Setting:
     """Convert protobuf representation into a Setting."""
     if proto.WhichOneof("parameter_desc") == "parameter":
         parameter = param_proto.unpack(proto.parameter)
@@ -48,10 +48,10 @@ def _unpack_setting(proto: spb.SettingNode.Setting) -> Setting:
     except Exception as err:
         raise AttributeError(f"Unpacking of {parameter} {proto.value} failed.") from err
 
-    return Setting(parameter, value)
+    return Setting(parameter, value)  # type: ignore[arg-type]
 
 
-def pack(node: SettingNode, minimal: bool) -> spb.SettingNode:
+def pack(node: SettingNode, minimal: bool) -> spb_SettingNode:
     """Convert a SettingNode into protobuf representation.
 
     Silently coerces some datatypes to be compatible with the proto definition of ``Datum``:
@@ -69,10 +69,10 @@ def pack(node: SettingNode, minimal: bool) -> spb.SettingNode:
     """
     settings = {key: _pack_setting(item, minimal) for key, item in node.child_settings}
     nodes = {key: pack(item, minimal) for key, item in node.child_nodes}
-    return spb.SettingNode(name=node.name, settings=settings, subnodes=nodes)
+    return spb_SettingNode(name=node.name, settings=settings, subnodes=nodes)
 
 
-def unpack(proto: spb.SettingNode) -> SettingNode:
+def unpack(proto: spb_SettingNode) -> SettingNode:
     """Convert protobuf representation into a SettingNode. Reverse operation of :func:`.pack`
 
     Args:
@@ -87,4 +87,4 @@ def unpack(proto: spb.SettingNode) -> SettingNode:
     nodes = {key: unpack(content) for key, content in proto.subnodes.items()}
     # Names are currently NEVER aligned with the paths when deserializing. This is safe to do, since currently nothing
     # in the server-side assumes path==name, but if such logic is added this needs to be reconsidered.
-    return SettingNode(name=proto.name, **(settings | nodes), align_name=False)
+    return SettingNode(name=proto.name, **(settings | nodes), align_name=False)  # type: ignore[arg-type]  # type: ignore[arg-type]  # type: ignore[arg-type]

exa/common/control/sweep/option/center_span_base_options.py

@@ -57,4 +57,4 @@ class CenterSpanBaseOptions(SweepOptions):
         start = self.center - (self.span / 2)
         stop = self.center + (self.span / 2)
         (start, stop) = (start, stop) if self.asc else (stop, start)
-        return StartStopBaseOptions(start, stop, count=self.count, base=self.base).data
+        return StartStopBaseOptions(start, stop, count=self.count, base=self.base).data  # type:ignore[arg-type,return-value]

exa/common/control/sweep/option/constants.py

@@ -14,14 +14,12 @@
 
 """Helper constants for SweepOptions classes."""
 
-from typing import Any
-
 #: Default value for `count` value in options.
 DEFAULT_COUNT: int = 101
 #: Default value for `base` value in options.
 DEFAULT_BASE: int = 10
 #: Dictionary with all possible types of options
-OPTIONS_TYPE: dict[str, Any] = {
+OPTIONS_TYPE: dict[str, str | list[str]] = {
     "start": "start",
     "stop": "stop",
     "center": "center",

exa/common/control/sweep/option/option_converter.py

@@ -45,24 +45,24 @@ def convert_to_options(config: dict[str, Any]) -> SweepOptions:
 
     """
     config = {k.lower(): v for k, v in config.items()}
-    if {OPTIONS_TYPE.get("start"), OPTIONS_TYPE.get("stop")}.issubset(set(config)):
-        updated_config = __update_config(config, OPTIONS_TYPE.get("start_stop_list"))
+    if {OPTIONS_TYPE.get("start"), OPTIONS_TYPE.get("stop")}.issubset(set(config)):  # type:ignore[arg-type]
+        updated_config = __update_config(config, OPTIONS_TYPE.get("start_stop_list"))  # type:ignore[arg-type]
         return StartStopOptions(**updated_config)
-    elif {OPTIONS_TYPE.get("start_exp"), OPTIONS_TYPE.get("stop_exp")}.issubset(set(config)):
-        __rename_key(config, OPTIONS_TYPE.get("start_exp"), OPTIONS_TYPE.get("start"))
-        __rename_key(config, OPTIONS_TYPE.get("stop_exp"), OPTIONS_TYPE.get("stop"))
-        updated_config = __update_config(config, OPTIONS_TYPE.get("start_stop_base_list"))
+    elif {OPTIONS_TYPE.get("start_exp"), OPTIONS_TYPE.get("stop_exp")}.issubset(set(config)):  # type:ignore[arg-type]
+        __rename_key(config, OPTIONS_TYPE.get("start_exp"), OPTIONS_TYPE.get("start"))  # type:ignore[arg-type]
+        __rename_key(config, OPTIONS_TYPE.get("stop_exp"), OPTIONS_TYPE.get("stop"))  # type:ignore[arg-type]
+        updated_config = __update_config(config, OPTIONS_TYPE.get("start_stop_base_list"))  # type:ignore[arg-type]
         return StartStopBaseOptions(**updated_config)
-    elif {OPTIONS_TYPE.get("center"), OPTIONS_TYPE.get("span")}.issubset(set(config)):
-        updated_config = __update_config(config, OPTIONS_TYPE.get("center_span_list"))
+    elif {OPTIONS_TYPE.get("center"), OPTIONS_TYPE.get("span")}.issubset(set(config)):  # type:ignore[arg-type]
+        updated_config = __update_config(config, OPTIONS_TYPE.get("center_span_list"))  # type:ignore[arg-type]
         return CenterSpanOptions(**updated_config)
-    elif {OPTIONS_TYPE.get("center_exp"), OPTIONS_TYPE.get("span_exp")}.issubset(set(config)):
-        __rename_key(config, OPTIONS_TYPE.get("center_exp"), OPTIONS_TYPE.get("center"))
-        __rename_key(config, OPTIONS_TYPE.get("span_exp"), OPTIONS_TYPE.get("span"))
-        updated_config = __update_config(config, OPTIONS_TYPE.get("center_span_base_list"))
+    elif {OPTIONS_TYPE.get("center_exp"), OPTIONS_TYPE.get("span_exp")}.issubset(set(config)):  # type:ignore[arg-type]
+        __rename_key(config, OPTIONS_TYPE.get("center_exp"), OPTIONS_TYPE.get("center"))  # type:ignore[arg-type]
+        __rename_key(config, OPTIONS_TYPE.get("span_exp"), OPTIONS_TYPE.get("span"))  # type:ignore[arg-type]
+        updated_config = __update_config(config, OPTIONS_TYPE.get("center_span_base_list"))  # type:ignore[arg-type]
         return CenterSpanBaseOptions(**updated_config)
     elif OPTIONS_TYPE.get("fixed") in set(config):
-        updated_config = __update_config(config, OPTIONS_TYPE.get("fixed"))
+        updated_config = __update_config(config, OPTIONS_TYPE.get("fixed"))  # type:ignore[arg-type]
         return FixedOptions(**updated_config)
     else:
         raise ValueError(f"Config {config} cannot be converted to range options")

exa/common/control/sweep/option/start_stop_options.py

@@ -66,7 +66,7 @@ class StartStopOptions(SweepOptions):
             data = self._generate_by_count(count)
         else:
             data = self._generate_by_count(self.count if self.count is not None else DEFAULT_COUNT)
-        return data
+        return data  # type: ignore[return-value]
 
     def _generate_by_count(self, count: int) -> SweepValues:
         return np.linspace(self.start, self.stop, count, endpoint=True).tolist()

exa/common/control/sweep/sweep.py

@@ -55,7 +55,7 @@ class Sweep(BaseModel):
             else:
                 data = options.data
 
-        super().__init__(parameter=parameter, data=data, **kwargs)
+        super().__init__(parameter=parameter, data=data, **kwargs)  # type: ignore[call-arg]  # type: ignore[call-arg]
 
     def model_post_init(self, __context: Any) -> None:
         if not all(self.parameter.validate(value) for value in self.data):
@@ -71,7 +71,7 @@ class Sweep(BaseModel):
     def __from_start_stop(cls, parameter: Parameter, options: StartStopOptions) -> SweepValues:
         cls._validate_value(parameter, options.start, "start")
         cls._validate_value(parameter, options.stop, "stop")
-        cls._validate_value(parameter, options.step, "step")
+        cls._validate_value(parameter, options.step, "step")  # type: ignore[arg-type]
         return options.data
 
     @staticmethod

exa/common/data/parameter.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# mypy: ignore-errors
+
 """Physical quantities and instrument settings.
 
 A basic data structure in EXA is the :class:`~exa.common.data.parameter.Parameter`, which represents
@@ -61,7 +63,7 @@ import ast
 from collections.abc import Hashable
 import copy
 from enum import IntEnum
-from typing import Any, Self
+from typing import Any, Self, TypeAlias
 import warnings
 
 import numpy as np
@@ -73,7 +75,9 @@ from exa.common.data.base_model import BaseModel
 from exa.common.data.value import ObservationValue
 from exa.common.errors.station_control_errors import ValidationError
 
-CastType = str | list["CastType"] | None
+CastType: TypeAlias = str | list["CastType"] | None
+SourceType: TypeAlias = None | BaseModel | dict[str, Any]
+"""Type for Setting sources."""
 
 
 class DataType(IntEnum):
@@ -135,7 +139,7 @@ class DataType(IntEnum):
             raise TypeError("Boolean data types can only be 'false', 'true, '0' or '1' (case-insensitive)")
         elif self is DataType.STRING:
             return value
-        else:
+        else:  # TODO: can this be removed?
             try:
                 return ast.literal_eval(value)
             except (SyntaxError, ValueError):  # if the value can not be evaluated, return the original value
@@ -407,12 +411,19 @@ class Setting(BaseModel):
     path: str = ""
     """Path in the settings tree (starting from the root ``SettingNode``) for this setting."""
 
+    _source: SourceType = None
+    """The source for this Setting value. May contain an observation (ObservationDefinition or ObservationData)
+    or a source-dict (e.g. ``{"type": "configuration_source", "configurator": "defaults_from_yml"}``). By default,
+    ``None``, which denotes the source not being specified (e.g. hardcoded defaults). The source is stored in a private
+    attribute and thus is never serialized (the source field can contain non-serializable data such as Callables)."""
+
     def __init__(
         self,
         parameter: Parameter | None = None,
         value: ObservationValue | None = None,
         read_only: bool = False,
         path: str = "",
+        source: SourceType = None,
         **kwargs,
     ) -> None:
         super().__init__(
@@ -422,6 +433,7 @@ class Setting(BaseModel):
             path=path,
             **kwargs,
         )
+        self._source = source
 
     @model_validator(mode="after")
     def validate_parameter_value_after(self) -> Self:
@@ -435,8 +447,17 @@ class Setting(BaseModel):
             raise ValidationError(f"Invalid value '{self.value}' for parameter '{self.parameter}'.")
         return self
 
-    def update(self, value: ObservationValue) -> Setting:
-        """Create a new setting object with updated `value`."""
+    def update(self, value: ObservationValue, source: SourceType = None) -> Setting:
+        """Create a new setting object with updated value and source.
+
+        Args:
+            value: New value for the setting.
+            source: New source for the setting.
+
+        Returns:
+            Copy of ``self`` with modified properties.
+
+        """
         if self.read_only:
             raise ValueError(
                 f"Can't update the value of {self.parameter.name} to {value} since the setting is read-only."
@@ -445,7 +466,7 @@ class Setting(BaseModel):
             value = np.array(value)
         # Need to create a new Setting here instead of using Pydantic model_copy().
         # model_copy() can't handle backdoor settings without errors, i.e. values with a list of 2 elements.
-        return Setting(self.parameter, value, self.read_only, self.path)
+        return Setting(self.parameter, value, self.read_only, self.path, source=source)
 
     @property
     def name(self):
@@ -477,6 +498,11 @@ class Setting(BaseModel):
         """Element-wise indices of the parameter in ``self``."""
         return self.parameter.element_indices
 
+    @property
+    def source(self) -> SourceType:
+        """Return the source for this Setting's value."""
+        return self._source
+
     @staticmethod
     def get_by_name(name: str, values: set[Setting]) -> Setting | None:
         return next((setting for setting in values if setting.parameter.name == name), None)

exa/common/data/setting_node.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# mypy: ignore-errors
+
 """A tree-structured container for :class:`Settings <exa.common.data.parameter.Setting>`.
 
 The :class:`.SettingNode` class combines a bunch of Settings together.
@@ -217,7 +219,7 @@ import jinja2
 import numpy as np
 
 from exa.common.data.base_model import BaseModel
-from exa.common.data.parameter import CollectionType, Parameter, Setting
+from exa.common.data.parameter import CollectionType, Parameter, Setting, SourceType
 from exa.common.errors.exa_error import UnknownSettingError
 from exa.common.qcm_data.chip_topology import sort_components
 
@@ -603,7 +605,7 @@ class SettingNode(BaseModel):
         """
         for key, item in other.settings.items():
             if key in self.settings and (prioritize_other or (self[key].value is None)):
-                self.settings[key] = Setting(self.settings[key].parameter, item.value)
+                self.settings[key] = Setting(self.settings[key].parameter, item.value, source=self.settings[key].source)
         for key, item in other.subtrees.items():
             if key in self.subtrees:
                 self.subtrees[key].merge_values(copy(item), prioritize_other)
@@ -678,16 +680,22 @@ class SettingNode(BaseModel):
             new.subtrees[key] = cls.transform_node_types(subnode)
         return new
 
-    def set_from_dict(self, dct: dict[str, Any], strict: bool = False) -> None:
+    def set_from_dict(
+        self,
+        dct: dict[str, Any],
+        strict: bool = False,
+        source: SourceType = None,
+    ) -> None:
         """Recursively set values to Settings, taking values from a dictionary that has similar tree structure.
-        Keys that are not found in self are ignored, unless `strict` is True.
+        Keys that are not found in self are ignored, unless ``strict`` is True.
 
         Args:
             dct: Dictionary containing the new values to use.
-            strict: If True, will raise error if `dct` contains a setting that is not found in `self`.
+            strict: If True, will raise error if ``dct`` contains a setting that is not found in ``self``.
+            source: Source for the settings (this same source is applied to all settings from the dict).
 
         Raises:
-            UnknownSettingError: If the condition of `strict` happens.
+            UnknownSettingError: If the condition of ``strict`` happens.
 
         """
         for key, value in dct.items():
@@ -704,9 +712,10 @@ class SettingNode(BaseModel):
                     self.settings[key].name,
                     self.settings[key].parameter.data_type.cast(value),
                     path=self.settings[key].path,
+                    source=source,
                 )
             else:
-                self.settings[key] = self.settings[key].update(value)
+                self.settings[key] = self.settings[key].update(value, source=source)
 
     def setting_with_path_name(self, setting: Setting) -> Setting | None:
         """Get a copy of a setting with its name replaced with the path name."""
@@ -858,6 +867,7 @@ class SettingNode(BaseModel):
         nodes: Iterable[Setting | Parameter | SettingNode] | dict[str, Setting | Parameter | SettingNode],
         path: str,
         override_values: dict[str, Any] | None = None,
+        override_source: SourceType = None,
     ) -> None:
         """Add nodes to ``self`` while creating the missing nodes in-between.
 
@@ -873,6 +883,8 @@ class SettingNode(BaseModel):
                 found in self, the associated nodes will be created automatically.
             override_values: Optionally override the values for the `Settings` corresponding to ``nodes``. This dict
                 should have the same structure as ``nodes``, including matching names.
+            override_source: Optionally override the source for the ``Settings`` corresponding to ``nodes``. All the
+                settings will then have this same source.
 
         """
         override_values = override_values or {}
@@ -899,9 +911,10 @@ class SettingNode(BaseModel):
                 latest_node[key] = node
             else:
                 default_value = node.value if isinstance(node, Setting) else None
+                source = override_source or (node.source if isinstance(node, Setting) else None)
                 parameter = node.parameter if isinstance(node, Setting) else node
                 value = override_values.get(node.name) if override_values.get(node.name) is not None else default_value
-                latest_node[key] = Setting(parameter, value)
+                latest_node[key] = Setting(parameter, value, source=source)
 
     def get_default_implementation_name(self, gate: str, locus: str | Iterable[str]) -> str:
         """Get the default implementation name for a given gate and locus.
@@ -1034,6 +1047,20 @@ class SettingNode(BaseModel):
 
         raise ValueError(f"Locus {locus} cannot be found in the gate properties characterization settings.")
 
+    def set_source(self, source: SourceType, ignore_nones: bool = True) -> None:
+        """Set source recursively to all Settings in ``self``.
+
+        Args:
+            source: The source to set.
+            ignore_nones: If ``True``, the source will not be set for Settings with ``None`` value.
+
+        """
+        for setting in self.settings.values():
+            if not ignore_nones or setting.value is not None:
+                setting._source = source
+        for subtree in self.subtrees.values():
+            subtree.set_source(source, ignore_nones=ignore_nones)
+
     def _get_symmetric_loci(self, gate: str, implementation: str, locus: str | Iterable[str]) -> list[str]:
         if not isinstance(locus, str):
             if self.gate_definitions[gate][implementation].symmetric.value:

exa/common/helpers/data_helper.py

@@ -38,7 +38,7 @@ def add_data_array(ds: xr.Dataset, da: xr.DataArray, name: Hashable | None = Non
     """
     if name is None:
         if da.name is not None:
-            name = da.name
+            name = da.name  # type: ignore[assignment]
         else:
             raise ValueError("No name was given to the dataArray.")
     # Attributes of Dataset coordinates are dropped/replaced when adding a DataArray

exa/common/helpers/software_version_helper.py

@@ -18,7 +18,7 @@ import os
 import platform
 import subprocess
 
-import pkg_resources
+import pkg_resources  # type:ignore[import-untyped]
 
 
 def _is_editable(pkg_name: str) -> bool:

exa/common/qcm_data/chad_model.py

@@ -168,7 +168,7 @@ class CHAD(ImmutableBaseModel):
         launchers = {launcher.name: launcher for launcher in self.components.launchers}
 
         component: Qubit | Coupler
-        for component in [*self.components.qubits, *self.components.couplers]:
+        for component in [*self.components.qubits, *self.components.couplers]:  # type:ignore[assignment]
             component_type = "qubit" if isinstance(component, Qubit) else "coupler"
             if component.name in component_names:
                 for connection in component.connections:

exa/common/qcm_data/chip_topology.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# mypy: ignore-errors
+
 """Chip topology class for parsing CHAD and other QPU related data into human-usable form."""
 
 from __future__ import annotations

{iqm_exa_common-26.26.0.dist-info → iqm_exa_common-26.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-exa-common
-Version: 26.26.0
+Version: 26.28.0
 Summary: Framework for control and measurement of superconducting qubits: common library
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License
@@ -219,9 +219,12 @@ Requires-Dist: pydantic <3.0,>=2.10.4
 Requires-Dist: python-dotenv ==0.21.1
 Requires-Dist: xarray ==2024.10.0
 Requires-Dist: requests ==2.32.3
+Requires-Dist: types-requests
 Requires-Dist: ruamel-yaml ==0.17.32
 Requires-Dist: ruamel-yaml-clib ==0.2.8
 Requires-Dist: jinja2 ==3.0.3
+Requires-Dist: six ==1.16.0
+Requires-Dist: types-six
 
 EXA-common
 ==========

{iqm_exa_common-26.26.0.dist-info → iqm_exa_common-26.28.0.dist-info}/RECORD

@@ -1,57 +1,58 @@
 exa/common/__init__.py,sha256=AqxwNht57urLqMxFblY7SgxjzkQYW7pRRUUPS1j1Gck,962
+exa/common/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 exa/common/api/__init__.py,sha256=PAYujWNG8CtSQX_8U9gnubDh5cwGRhtOfLr0r0xGx3M,587
 exa/common/api/proto_serialization/__init__.py,sha256=Vn2C79OqovFu5wJus9EHsMtK3Of1JLJDcpg2QZKmXsY,1565
-exa/common/api/proto_serialization/_parameter.py,sha256=W0EBrVs3uZ-jX1HnlOrAB7_PKrzi8D_qNM0_SBht8XY,2895
-exa/common/api/proto_serialization/array.py,sha256=iht5WlfGEkzXM3PcOFDXxd2TgXWFyYNyPt44CMqXnl8,3110
-exa/common/api/proto_serialization/datum.py,sha256=i4Ri8VMfbCPV_d6763DDUdHX72tEWxpiOhvIr0lfSlY,4811
-exa/common/api/proto_serialization/nd_sweep.py,sha256=B36KY32wTNFJE3Bk2QlN4BeMO0Se7AtwOectlIh5SCM,2661
-exa/common/api/proto_serialization/sequence.py,sha256=mcjquVqVquQmhE5G7cbC3vRax9EkOS6iJk2QXBu1MoQ,2545
-exa/common/api/proto_serialization/setting_node.py,sha256=KCNpwgwIrgyuXsgt-rAm3oEQqKlIxtN8JBUDFaQTJ48,3940
+exa/common/api/proto_serialization/_parameter.py,sha256=d_LHc_Tl3OqiQmTGe6Y6mkHvQkknzFl5KPEJauPEKPM,3050
+exa/common/api/proto_serialization/array.py,sha256=CvuOV5jNyFAAdqrYsh_z4DeQA6kYvfidW9bEv_M7Ugo,3127
+exa/common/api/proto_serialization/datum.py,sha256=x9PJi3iiqAcG7aMUhBaho6vTNBQsm7pzY0HCFxB_zfM,4915
+exa/common/api/proto_serialization/nd_sweep.py,sha256=5Wi_iz4XqQE9GgSzt3vUTpYKwO5uCPGBa2OqwOMOXcQ,2912
+exa/common/api/proto_serialization/sequence.py,sha256=4yQgdTUenbsY8yNu7JqSQSq2Ushd1zlzuciaqmyP7OY,2568
+exa/common/api/proto_serialization/setting_node.py,sha256=oAlJOmkQTmMSd6wpofoDLz3YIlkiqxX7kY84WnZZ4b4,4073
 exa/common/control/__init__.py,sha256=00T_xV0lL20QZcEt__vWq81N1oGF0KpJMhTitfAI4VI,629
 exa/common/control/sweep/__init__.py,sha256=GzKoQdQsLutcHhmrLPyPrW1n7Cpg766p3OWDHlRpuTs,607
 exa/common/control/sweep/exponential_sweep.py,sha256=OIGqSifkAgQcS2EdffDpIjibB80XteLVF82kS63vPro,2121
 exa/common/control/sweep/fixed_sweep.py,sha256=QXO5lrllHHlhLiA95s8iTE82QkAEzgjJ2dA0flRJLhs,1493
 exa/common/control/sweep/linear_sweep.py,sha256=fX7OuZDYtUSGcAJLsGTVHcCIRkUHkZNLy5YSe_kgb8M,1966
-exa/common/control/sweep/sweep.py,sha256=0ZzhbzcAQaByiX7dz5jDH0r1zmyEiW2B-v8edIyTDs8,3442
+exa/common/control/sweep/sweep.py,sha256=CeCd7-nh0nIlaay4ggMICu61anVxlg3MISGhkK44-VQ,3520
 exa/common/control/sweep/sweep_values.py,sha256=c868qpnh3SP6DYN3eAt0SLaePuzzQwxTWYwnQwL4A-I,2277
 exa/common/control/sweep/option/__init__.py,sha256=Z01JS0FpchMvR8zfWBCs3jcPjh2H8X29YkN0SFxWLTY,906
-exa/common/control/sweep/option/center_span_base_options.py,sha256=8F2HqHeq9RSMqEms6icuUqLlzkL6jT991eeRrKgikM8,2520
+exa/common/control/sweep/option/center_span_base_options.py,sha256=uHWt4euQVF7EVXJid8wnIXo8PtJnyUdydxxAXPEMnV4,2558
 exa/common/control/sweep/option/center_span_options.py,sha256=WJ9tNaORsnSYojwx5qy3mSoHRmsV2cKMXP6LTRU41Zo,2482
-exa/common/control/sweep/option/constants.py,sha256=vdYrbi3EBlIST5mO498W2F6s-xqyoEVBAZ6zQEiHmmY,1417
+exa/common/control/sweep/option/constants.py,sha256=pHWOLQicxL-qX0iHQXlhPVNBGHPjvxZ9JBIZQDxEpCY,1405
 exa/common/control/sweep/option/fixed_options.py,sha256=SyGSiEanD3xz4Wcy1rd9r2wj7hNaG3lQYH67WQDc72I,1047
-exa/common/control/sweep/option/option_converter.py,sha256=RGNNQHNl8gTZUHO85IZseoo065s_kQSWP-AfrYhGbn4,3649
+exa/common/control/sweep/option/option_converter.py,sha256=CsiMY8-pnvdLsD7iLHPIkjbLUnfTnhZY8UxEdWuOaN4,3974
 exa/common/control/sweep/option/start_stop_base_options.py,sha256=09P03pexASngGWSSltVh8Ty-BsBmRkQ3iYODsr0ij5I,2145
-exa/common/control/sweep/option/start_stop_options.py,sha256=NAOCJgXvL5J4zewNvsIHMb6L-Bu_2drfwqifqT6z5Uk,3083
+exa/common/control/sweep/option/start_stop_options.py,sha256=vJottC6QX80MhVyg9_R9UFx6W1ijSHOVRzU9fDO3FLA,3113
 exa/common/control/sweep/option/sweep_options.py,sha256=BhKB7RHP0VXJ9iUQKVzeQOM4j_x9AsMhRJgoR3gkiaY,933
 exa/common/data/__init__.py,sha256=F5SRe5QHBTjef4XJVQ63kO5Oxc_AiZnPbV560i7La0Y,644
 exa/common/data/base_model.py,sha256=U508YCtvZabBGnKe1fqUimunmwGulOTM6DOKTUqnYp8,1835
-exa/common/data/parameter.py,sha256=GI-BJcXe53Mf2PXPzvftCV7L2kd_uC-hOjH_J__1MLc,23313
-exa/common/data/setting_node.py,sha256=obA9Rl3uSQ-pOoAAMzSQvzbRPygSIaFOM4W4foxKKKk,43344
+exa/common/data/parameter.py,sha256=AQxeTvItMjOvT2QUvhKCn9aK5ibrfaN8LI_Oc68ZzII,24420
+exa/common/data/setting_node.py,sha256=yZU8lltzK5qV4L5Xte3AOcG85Tgdg-3mrxCiTpwbW7Q,44548
 exa/common/data/settingnode_v2.html.jinja2,sha256=mo-rlLLmU-Xxf6znJAisispAZK8sbV-2C13byKAtj_Q,3166
 exa/common/data/value.py,sha256=mtMws5UPGx1pCADK6Q2Tx4BwCXznvVRSNQRfcQ3NMmY,1853
 exa/common/errors/__init__.py,sha256=ArMBdpmx1EUenBpzrSNG63kmUf7PM0gCqSYnaCnL9Qk,597
 exa/common/errors/exa_error.py,sha256=iw8ueZgqx1JXkfjRoJfPUsSE7cfhzIWpdDaFuka9Ss0,990
 exa/common/errors/station_control_errors.py,sha256=NEVW9QC-jJM36CQ8b9IIg9hZv5Utph9LXirxk5ZiuNM,4122
 exa/common/helpers/__init__.py,sha256=IgtVD3tojIFA4MTV2mT5uYM6jb2qny9kBIIhEZT2PuI,610
-exa/common/helpers/data_helper.py,sha256=1fd-k7k4Y5mD9xqjHwvfiHRvTAA5fttMHrempjke-Tw,1973
+exa/common/helpers/data_helper.py,sha256=-AP0vwrf7WgyumLsicDtNP2VP5rhG4_oiOZgG4alNb4,2001
 exa/common/helpers/deprecation.py,sha256=nY8484iun63JOBfBeh49Q6VD5xZ4_gT9fjPmH1RAXoI,397
 exa/common/helpers/json_helper.py,sha256=LoTrL6FREML1o0X3Zznf1baI4kn0kh03NE1nqBHgYss,2699
 exa/common/helpers/numpy_helper.py,sha256=KKKyZ_fD0O1gn7_InEQROYnX3WGMA6C1qHh8KzzjtUI,1062
-exa/common/helpers/software_version_helper.py,sha256=Spx_buLnzTawjU8KrGJcW0BJEvgv8W2cG8FxEDzIOSM,5143
+exa/common/helpers/software_version_helper.py,sha256=BUozde38-7X_NVh0lRY8VR2fvTEPLTz3nyEwSopEJEU,5174
 exa/common/helpers/yaml_helper.py,sha256=wLy-7Nyit597FoWBemduUilYP2VCk_aDDT8y62i3ox8,1626
 exa/common/logger/__init__.py,sha256=1bIsGxHzfujXlkgtcAnWToKMkw3dpU5PEd_7LE_NpgQ,686
 exa/common/logger/logger.py,sha256=0aSjkx4pXy_CCKtspOnFgwMmhZVFAZUlopQ6HUjBMko,5689
 exa/common/qcm_data/__init__.py,sha256=VtsYkGoaniSjCkY0oQlqkcYJCtmC2sTDxfrIe_kpqZg,567
-exa/common/qcm_data/chad_model.py,sha256=EVzEdN1uImbM2gAE9FCk7eBQrIrCxgDmVOLvESi8yyM,11236
-exa/common/qcm_data/chip_topology.py,sha256=qUBr4eDMy76RoOc1DX2sZ9vYzh3ubByEK1CZtr-LYcU,20004
+exa/common/qcm_data/chad_model.py,sha256=s8p9zaQsoo1douqXAuLbAV5hjOCbrhEJFNzi5Yq9y98,11263
+exa/common/qcm_data/chip_topology.py,sha256=-IsWh0hev_vnAWs0z3iWBvProe6LypgKs1Erp8HCb0M,20027
 exa/common/qcm_data/file_adapter.py,sha256=U1XZm_PEswkW7kAztbWFLMufz4mPKPupWbh5yJXdZCI,2263
 exa/common/qcm_data/immutable_base_model.py,sha256=QXmKIWQbsbWQvovXwKT1d9jtyf2LNJtjQquIwO52zOU,901
 exa/common/qcm_data/qcm_data_client.py,sha256=Rze6yQd0xUeH6eUMv3wduYbiDCTP3C4WECtCe7ONmyc,6061
 exa/common/sweep/__init__.py,sha256=uEKk5AtzSgSnf8Y0geRPwUpqXIBIXpeCxsN64sX7F1o,591
 exa/common/sweep/database_serialization.py,sha256=NUu1umxRQZpKtRmw1vNDsSbnofqbHvKFg_xQ2mdhY6k,7469
 exa/common/sweep/util.py,sha256=-QE2AaH-WDkYAVH5-Z-30leLgY0x4efmby4kc1JTCgY,3732
-iqm_exa_common-26.26.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_exa_common-26.26.0.dist-info/METADATA,sha256=iD1DF1AEmak_PpscF39c2mw4n3OH3lAvZe4lZ74m1ww,14659
-iqm_exa_common-26.26.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_exa_common-26.26.0.dist-info/top_level.txt,sha256=Clphg2toaZ3_jSFRPhjMNEmLurkMNMc4lkK2EFYsSlM,4
-iqm_exa_common-26.26.0.dist-info/RECORD,,
+iqm_exa_common-26.28.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_exa_common-26.28.0.dist-info/METADATA,sha256=KISV_HQf4F7z7rwX36K7ux-nHUrpqSqZRS72K9YlnA8,14742
+iqm_exa_common-26.28.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_exa_common-26.28.0.dist-info/top_level.txt,sha256=Clphg2toaZ3_jSFRPhjMNEmLurkMNMc4lkK2EFYsSlM,4
+iqm_exa_common-26.28.0.dist-info/RECORD,,