iqm-exa-common 26.25.0__tar.gz → 26.27.0__tar.gz

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/CHANGELOG.rst

@@ -2,6 +2,22 @@
 Changelog
 =========
 
+Version 26.27.0 (2025-07-04)
+============================
+
+Features
+--------
+
+- Setting now has a private field _source and an associated property which can be used to store e.g. the observation that is the source of the Setting's value.
+
+Version 26.26.0 (2025-07-02)
+============================
+
+Bug fixes
+---------
+
+- Fix type errors raised by mypy.
+
 Version 26.25.0 (2025-06-17)
 ============================
 

{iqm_exa_common-26.25.0/src/iqm_exa_common.egg-info → iqm_exa_common-26.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-exa-common
-Version: 26.25.0
+Version: 26.27.0
 Summary: Framework for control and measurement of superconducting qubits: common library
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License:                                  Apache License

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/control/sweep/option/center_span_options.py

@@ -40,7 +40,7 @@ class CenterSpanOptions(SweepOptions):
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_COUNT`.
     count: int | None = None
     #: Size of spacing between values.
-    step: int | float | complex = None
+    step: int | float | complex | None = None
     #: Order of generated values. Default to ascending
     asc: bool | None = None
 

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/control/sweep/option/start_stop_base_options.py

@@ -35,26 +35,22 @@ class StartStopBaseOptions(SweepOptions):
     """
 
     #: The power for the start of the interval.
-    start: int | float | complex
+    start: int | float
     #: The power for the end of the interval.
-    stop: int | float | complex
+    stop: int | float
     #: Number of values to generate. Default to
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_COUNT`.
-    count: int | None = None
+    count: int = DEFAULT_COUNT
     #: Number, that is raised to the power `start` or `stop`. Default to
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_BASE`.
-    base: int | float | None = None
+    base: int = DEFAULT_BASE
 
     def __post_init__(self):
-        if self.count is None:
-            object.__setattr__(self, "count", DEFAULT_COUNT)
-        if self.base is None:
-            object.__setattr__(self, "base", DEFAULT_BASE)
         if self.start == 0 or self.stop == 0:
             raise ValueError("Exponential range sweep start and stop values must not be zero.")
 
     @property
-    def data(self) -> list[int | float | complex]:
+    def data(self) -> list[int | float]:
         logger.debug(f"EXPONENTS: ({self.start}, {self.stop}) with base {self.base}")
         start = math.pow(self.base, self.start)
         stop = math.pow(self.base, self.stop)

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/control/sweep/option/start_stop_options.py

@@ -65,7 +65,7 @@ class StartStopOptions(SweepOptions):
             count = 1 + math.ceil(abs(self.stop - self.start) / float(np.abs(self.step)))
             data = self._generate_by_count(count)
         else:
-            data = self._generate_by_count(self.count)
+            data = self._generate_by_count(self.count if self.count is not None else DEFAULT_COUNT)
         return data
 
     def _generate_by_count(self, count: int) -> SweepValues:

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/control/sweep/sweep_values.py

@@ -28,9 +28,8 @@ def validate_sweep_values(sweep_values: Any) -> Any:
     if isinstance(sweep_values, np.ndarray):
         sweep_values = sweep_values.tolist()
     for index, value in enumerate(sweep_values):
-        if isinstance(value, dict):
-            if "__complex__" in value:
-                sweep_values[index] = complex(value["real"], value["imag"])
+        if isinstance(value, dict) and "__complex__" in value:
+            sweep_values[index] = complex(value["real"], value["imag"])
     return sweep_values
 
 
@@ -51,7 +50,7 @@ def serialize_sweep_values(sweep_values: Any) -> Any:
 
 
 SweepValues = Annotated[
-    list[Any] | np.ndarray[Any],
+    list[Any] | np.ndarray,
     PlainValidator(validate_sweep_values),
     PlainSerializer(serialize_sweep_values),
     WithJsonSchema(core_schema.any_schema()),

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/data/base_model.py

@@ -1,3 +1,4 @@
+from collections.abc import Mapping
 from typing import Any, Self
 
 import pydantic
@@ -24,7 +25,7 @@ class BaseModel(pydantic.BaseModel):
         frozen=True,  # This makes instances of the model potentially hashable if all the attributes are hashable
     )
 
-    def model_copy(self, *, update: dict[str, Any] | None = None, deep: bool = True) -> Self:
+    def model_copy(self, *, update: Mapping[str, Any] | None = None, deep: bool = True) -> Self:
         """Returns a copy of the model.
 
         Overrides the Pydantic default 'model_copy' to set 'deep=True' by default.

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/data/parameter.py

@@ -61,7 +61,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 +73,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):
@@ -116,7 +118,7 @@ class DataType(IntEnum):
         else:
             return False
 
-    def _cast(self, value: str) -> Any:  # noqa: PLR0911
+    def _cast(self, value: str | None) -> Any:  # noqa: PLR0911
         if value is None:
             return None
         elif self in [DataType.FLOAT, DataType.NUMBER]:
@@ -135,7 +137,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
@@ -238,13 +240,12 @@ class Parameter(BaseModel):
                     raise ValidationError("Parameter 'element_indices' must be one or more ints.")
             object.__setattr__(self, "element_indices", idxs)
             # there may be len(idxs) num of "__" separated indices at the end, remove those to get the parent name
-            parent_name = self.name.replace("__" + "__".join([str(idx) for idx in idxs]), "")
+            seperated_indices = "__".join([str(idx) for idx in idxs])
+            parent_name = self.name.replace("__" + seperated_indices, "")
             object.__setattr__(self, "_parent_name", parent_name)
             object.__setattr__(self, "_parent_label", self.label.replace(f" {idxs}", ""))
             object.__setattr__(self, "label", f"{self._parent_label} {idxs}")
-            name = self._parent_name
-            for index in idxs:
-                name += f"__{index}"
+            name = parent_name + "__" + seperated_indices
             object.__setattr__(self, "name", name)
 
     @property
@@ -272,7 +273,7 @@ class Parameter(BaseModel):
     def build_data_set(
         variables: list[tuple[Parameter, list[Any]]],
         data: tuple[Parameter, SweepValues],
-        attributes: dict[str, Any] = None,
+        attributes: dict[str, Any] | None = None,
         extra_variables: list[tuple[str, int]] | None = None,
     ):
         """Build an xarray Dataset, where the only DataArray is given by `results` and coordinates are given by
@@ -289,9 +290,9 @@ class Parameter(BaseModel):
              extra_variables: Valueless dimensions and their sizes.
 
         """
-        variable_names = []
-        variable_sizes = []
-        variable_data_arrays = {}
+        variable_names: list[str] = []
+        variable_sizes: list[int] = []
+        variable_data_arrays: dict[str, xr.DataArray] = {}
         for variable in variables:
             variable_names.append(variable[0].name)
             variable_sizes.append(len(variable[1]))
@@ -326,9 +327,9 @@ class Parameter(BaseModel):
     def build_data_array(
         self,
         data: np.ndarray,
-        dimensions: list[Hashable] = None,
-        coords: dict[Hashable, Any] = None,
-        metadata: dict[str, Any] = None,
+        dimensions: list[str] | list[Hashable] | None = None,
+        coords: dict[Hashable, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> xr.DataArray:
         """Attach Parameter information to a numerical array.
 
@@ -365,7 +366,7 @@ class Parameter(BaseModel):
         da = xr.DataArray(name=self.name, data=data, attrs=attrs, dims=dimensions, coords=coords)
         # copying the coordinate metadata, if present, to the new DataArray coordinates
         if coords:
-            for key in [k for k in coords.keys() if isinstance(coords[k], xr.DataArray)]:
+            for key in [k for k in coords if isinstance(coords[k], xr.DataArray)]:
                 da[key].attrs = coords[key].attrs
         return da
 
@@ -408,12 +409,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__(
@@ -423,6 +431,7 @@ class Setting(BaseModel):
             path=path,
             **kwargs,
         )
+        self._source = source
 
     @model_validator(mode="after")
     def validate_parameter_value_after(self) -> Self:
@@ -436,8 +445,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."
@@ -446,7 +464,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):
@@ -474,24 +492,28 @@ class Setting(BaseModel):
         return self.parameter.unit
 
     @property
-    def element_indices(self) -> tuple[int, ...] | None:
+    def element_indices(self) -> int | list[int] | None:
         """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)
 
     @staticmethod
-    def remove_by_name(name: str, values: set[Setting] = None) -> set[Setting]:
-        if values is None:
-            values = set()
+    def remove_by_name(name: str, values: set[Setting]) -> set[Setting]:
         removed = copy.deepcopy(values)
-        removed.discard(Setting.get_by_name(name, values))
+        if setting := Setting.get_by_name(name, values):
+            removed.discard(setting)
         return removed
 
     @staticmethod
-    def replace(settings: Setting | list[Setting], values: set[Setting] = None) -> set[Setting]:
+    def replace(settings: Setting | list[Setting], values: set[Setting] | None = None) -> set[Setting]:
         if values is None:
             values = set()
         if not isinstance(settings, list):
@@ -518,7 +540,7 @@ class Setting(BaseModel):
         diff = first.difference(second)
         for s in first.intersection(second):
             a, b = [Setting.get_by_name(s.parameter.name, group) for group in [first, second]]
-            if a.value != b.value:
+            if a is not None and b is not None and a.value != b.value:
                 diff.add(a)
         return diff
 
@@ -555,7 +577,7 @@ class Setting(BaseModel):
     def __hash__(self):
         return hash(self.parameter)
 
-    def __eq__(self, other: Setting):
+    def __eq__(self, other: Any) -> bool:
         if not (isinstance(other, Setting) and self.parameter == other.parameter):
             return False
         if isinstance(self.value, np.ndarray):

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/data/setting_node.py

@@ -217,19 +217,19 @@ 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
 
 logger = logging.getLogger(__name__)
 
 
-def _fix_path_recursive(node: SettingNode | dict, path: str) -> SettingNode | dict:
+def _fix_path_recursive(node: SettingNode, path: str) -> SettingNode:
     """Recursively travel the settings tree and fix the ``path``attribute (also aligns ``name``,
     based on the node type). Deep copies all the child nodes.
     """
-    settings = {}
-    subtrees = {}
+    settings: dict[str, Setting] = {}
+    subtrees: dict[str, SettingNode] = {}
     for key, setting in node.settings.items():
         child_path = f"{path}.{key}"
         update_dict = {"path": child_path}
@@ -305,8 +305,8 @@ class SettingNode(BaseModel):
         generate_paths: bool = True,
         **kwargs,
     ):
-        settings: dict[str, Any] = settings or {}
-        subtrees: dict[str, Any] = subtrees or {}
+        settings = settings or {}
+        subtrees = subtrees or {}
 
         for key, child in kwargs.items():
             if isinstance(child, Setting):
@@ -603,7 +603,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)
@@ -650,7 +650,7 @@ class SettingNode(BaseModel):
         append_lines(self, lines, [])
         print("\n", "\n".join(lines))
 
-    def __eq__(self, other: SettingNode):
+    def __eq__(self, other: Any) -> bool:
         return isinstance(other, SettingNode) and (
             (self.name, self.settings, self.subtrees) == (other.name, other.settings, other.subtrees)
         )
@@ -678,16 +678,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,13 +710,17 @@ 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:
+    def setting_with_path_name(self, setting: Setting) -> Setting | None:
         """Get a copy of a setting with its name replaced with the path name."""
-        return self.find_by_name(setting.name).with_path_name()
+        first_item = self.find_by_name(setting.name)
+        if isinstance(first_item, Setting):
+            return first_item.with_path_name()
+        return None
 
     def diff(self, other: SettingNode, *, path: str = "") -> list[str]:
         """Recursive diff between two SettingNodes.
@@ -855,6 +865,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.
 
@@ -870,6 +881,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 {}
@@ -888,7 +901,7 @@ class SettingNode(BaseModel):
             latest_node[fragment] = SettingNode(name=fragment, align_name=latest_node.align_name)
             latest_node = latest_node[fragment]
         # finally add the nodes
-        nodes_to_add = nodes.values() if isinstance(nodes, dict) else nodes
+        nodes_to_add: Iterable[Setting | Parameter | SettingNode] = nodes.values() if isinstance(nodes, dict) else nodes
         nodes_keys = list(nodes.keys()) if isinstance(nodes, dict) else []
         for idx, node in enumerate(nodes_to_add):
             key = nodes_keys[idx] if isinstance(nodes, dict) else node.name.split(".")[-1]
@@ -896,9 +909,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.
@@ -926,10 +940,7 @@ class SettingNode(BaseModel):
             ):
                 if isinstance(locus, str):
                     locus = locus.split("__")
-                if gate_settings.symmetric.value:
-                    loci = list(permutations(locus))
-                else:
-                    loci = [tuple(locus)]
+                loci = list(permutations(locus)) if gate_settings.symmetric.value else [tuple(locus)]
                 for permuted_locus in loci:
                     locus_str = "__".join(permuted_locus)
                     if locus_str in gate_settings[impl].override_default_for_loci.value:
@@ -987,7 +998,7 @@ class SettingNode(BaseModel):
             The locus node (string) paths corresponding to this gate.
 
         """
-        node_paths = []
+        node_paths: list[str] = []
         if "gates" not in self.children or gate not in self.gates.children:
             return node_paths
         if implementations is not None:
@@ -1034,7 +1045,21 @@ class SettingNode(BaseModel):
 
         raise ValueError(f"Locus {locus} cannot be found in the gate properties characterization settings.")
 
-    def _get_symmetric_loci(self, gate: str, implementation: str, locus: str) -> list[str]:
+    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:
                 str_loci = ["__".join(sort_components(locus))]

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/helpers/data_helper.py

@@ -13,13 +13,15 @@
 # limitations under the License.
 
 
+from collections.abc import Hashable
+
 import xarray as xr
 
 """Helper methods for data manipulation.
 """
 
 
-def add_data_array(ds: xr.Dataset, da: xr.DataArray, name: str | None = None) -> xr.Dataset:
+def add_data_array(ds: xr.Dataset, da: xr.DataArray, name: Hashable | None = None) -> xr.Dataset:
     """Add data array `da` to dataset `ds`.
 
     Unlike the default xarray command, preserves metadata of the dataset.
@@ -50,7 +52,7 @@ def add_data_array(ds: xr.Dataset, da: xr.DataArray, name: str | None = None) ->
     ds[name] = da
     for key in ds.coords:
         if attributes.get(key):
-            ds.coords[key].attrs = attributes.get(key)
+            ds.coords[key].attrs = attributes.get(key)  # type:ignore[assignment]
     for key in ds.data_vars:
         if attributes.get(key):
             ds.data_vars[key].attrs = attributes[key]

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/helpers/software_version_helper.py

@@ -30,7 +30,7 @@ def _is_editable(pkg_name: str) -> bool:
     ``importlib.metadata``, so it might break anytime.
     """
     dist = distribution(pkg_name)
-    return dist.files and dist.files[0].name.startswith("__editable__.")
+    return dist.files is not None and dist.files[0].name.startswith("__editable__.")
 
 
 def get_all_software_versions(reload_module: bool = False) -> dict[str, str]:

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/qcm_data/chad_model.py

@@ -17,13 +17,14 @@
 from collections.abc import Collection
 from functools import cached_property
 import re
+from typing import Any
 
 from pydantic import Field, field_validator
 
 from exa.common.qcm_data.immutable_base_model import ImmutableBaseModel
 
 
-def _natural_sort_key(name: str) -> tuple[int, ...]:
+def _natural_sort_key(name: str) -> tuple[int | str | Any, ...]:
     return tuple(int(item) if item.isdigit() else item.lower() for item in re.split(r"(\d+)", name))
 
 
@@ -76,7 +77,7 @@ class Components(ImmutableBaseModel):
 
     @cached_property
     def all(self) -> dict[str, Component]:
-        components: tuple[Qubit, Coupler, ProbeLine, Launcher, ComputationalResonator] = (
+        components: tuple[Qubit | Coupler | ProbeLine | Launcher | ComputationalResonator, ...] = (
             self.qubits + self.couplers + self.probe_lines + self.launchers + self.computational_resonators
         )
         return {component.name: component for component in components}

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/qcm_data/chip_topology.py

@@ -109,7 +109,7 @@ class ChipTopology:
             coupler: tuple(sort_components(components)) for coupler, components in couplers.items()
         }
         """Map from each coupler to all other components it connects to. The values are sorted."""
-        component_to_couplers = {}
+        component_to_couplers: dict = {}
         for coupler, components in couplers.items():
             for c in components:
                 component_to_couplers.setdefault(c, set()).add(coupler)
@@ -128,7 +128,7 @@ class ChipTopology:
         Components without connection to a probe line don't appear.
         """
 
-        self._locus_mappings: dict[Locus, dict[tuple[str, ...]]] = {
+        self._locus_mappings: dict[str, dict[Locus, tuple[str, ...]]] = {
             DEFAULT_1QB_MAPPING: {(qubit,): (qubit,) for qubit in self.qubits_sorted},
             DEFAULT_2QB_MAPPING: {
                 frozenset(comps): (coupler,)
@@ -244,7 +244,7 @@ class ChipTopology:
         """Get probelines that are connected to any of the given components."""
         return {self.component_to_probe_line[c] for c in components if c in self.component_to_probe_line}
 
-    def get_connected_coupler_map(self, components: Collection[str]) -> ComponentMap:
+    def get_connected_coupler_map(self, components: Collection[str]) -> dict[str, tuple[str, ...]]:
         """Returns a `ComponentMap`, including only the couplers between components that both are in the given subset.
 
         Args:
@@ -261,7 +261,7 @@ class ChipTopology:
         }
 
     @staticmethod
-    def limit_values(dct: ComponentMap, limit_to: Collection[str]) -> ComponentMap:
+    def limit_values(dct: ComponentMap, limit_to: Collection[str]) -> dict[str, Collection[str]]:
         """Prunes the given dictionary (e.g. a coupler-to-qubits map) to a subset of values.
 
         Used to prune e.g. :attr:`coupler_to_components` to a subset of relevant elements.
@@ -313,7 +313,7 @@ class ChipTopology:
         self._validate_locus_mapping(mapping)
         self._locus_mappings[name] = mapping
 
-    def _validate_locus_mapping(self, mapping: dict[str | tuple[str], Locus] | None = None) -> None:
+    def _validate_locus_mapping(self, mapping: dict[Locus, tuple[str, ...]]) -> None:
         """Validate that the components given in mapping are found in self and the mapping is correctly formed."""
         for locus, mapped in mapping.items():
             if not isinstance(locus, tuple) and not isinstance(locus, frozenset):
@@ -325,7 +325,7 @@ class ChipTopology:
                 if locus_component not in self.all_components:
                     raise ValueError(f"Locus component {locus_component} is not found in this ChipTopology.")
 
-    def map_locus(self, locus: Locus, name: str | None = None) -> str | tuple[str] | None:
+    def map_locus(self, locus: Locus, name: str | None = None) -> str | tuple[str, ...] | None:
         """Returns the mapped components for the given locus and the given gate.
 
         If the locus or the gate is not found from the locus mappings of self, returns None.
@@ -388,7 +388,7 @@ class ChipTopology:
                 name = DEFAULT_1QB_MAPPING
             elif default_mapping_dimension == 2:
                 name = DEFAULT_2QB_MAPPING
-        return [locus for locus in self._locus_mappings.get(name, {})]
+        return list(self._locus_mappings.get(name, {}))
 
     def get_common_computational_resonator(self, first_qubit: str, second_qubit: str) -> str:
         """Convenience method for getting the name of a computational resonator which is connected to both specified

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0}/src/exa/common/qcm_data/qcm_data_client.py

@@ -62,7 +62,7 @@ class QCMDataClient:
         # Make the cache containers local to the instances so that the reference from cache to the instance
         # gets scraped off with the instance
         # https://rednafi.github.io/reflections/dont-wrap-instance-methods-with-functoolslru_cache-decorator-in-python.html
-        self._send_request = cache(self._send_request)
+        self._send_request = cache(self._send_request)  # type:ignore[method-assign]
 
     @property
     def root_url(self) -> str:

{iqm_exa_common-26.25.0 → iqm_exa_common-26.27.0/src/iqm_exa_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-exa-common
-Version: 26.25.0
+Version: 26.27.0
 Summary: Framework for control and measurement of superconducting qubits: common library
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License:                                  Apache License

iqm_exa_common-26.27.0/version.txt

@@ -0,0 +1 @@
+26.27.0

iqm_exa_common-26.25.0/version.txt

@@ -1 +0,0 @@
-26.25.0