iqm-exa-common 25.34__py3-none-any.whl → 26.1__py3-none-any.whl

exa/common/api/proto_serialization/_parameter.py

@@ -27,13 +27,14 @@ _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,
+    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()}
-_data_types_inv[ppb.Parameter.DataType.DATA_TYPE_INT64] = DataType.NUMBER  # TODO add DataType.INT?
+_data_types_inv = {v: k for k, v in _DATA_TYPES.items() if k != DataType.NUMBER}
 
 
 def pack(parameter: Parameter) -> ppb.Parameter:

exa/common/api/proto_serialization/nd_sweep.py

@@ -18,8 +18,6 @@ import iqm.data_definitions.common.v1.sweep_pb2 as spb
 
 from exa.common.api.proto_serialization import sequence
 import exa.common.api.proto_serialization._parameter as param_proto
-from exa.common.control.sweep.fixed_sweep import FixedSweep
-from exa.common.control.sweep.option.fixed_options import FixedOptions
 from exa.common.control.sweep.sweep import Sweep
 from exa.common.data.parameter import DataType, Parameter
 from exa.common.sweep.util import NdSweep
@@ -41,10 +39,7 @@ def pack(nd_sweep: NdSweep, minimal: bool = True) -> spb.CartesianSweep:
 
 
 def unpack(proto: spb.CartesianSweep) -> NdSweep:
-    """Convert protobuf representation into a NdSweep. Reverse operation of :func:`.pack`.
-
-    Note: All sweeps will be of type :class:`.FixedSweep`.
-    """
+    """Convert protobuf representation into a NdSweep. Reverse operation of :func:`.pack`."""
     nd_sweep = []
     for parallel_proto in reversed(proto.parallel_sweeps):
         parallel = tuple(_unpack_single_sweep(sweep) for sweep in parallel_proto.single_parameter_sweeps)
@@ -59,10 +54,10 @@ def _pack_single_sweep(sweep: Sweep, minimal: bool) -> spb.SingleParameterSweep:
     return spb.SingleParameterSweep(**kwargs)
 
 
-def _unpack_single_sweep(proto: spb.SingleParameterSweep) -> FixedSweep:
+def _unpack_single_sweep(proto: spb.SingleParameterSweep) -> Sweep:
     sweep_values = sequence.unpack(proto.values)
     if proto.HasField("parameter"):
         parameter = param_proto.unpack(proto.parameter)
     else:
         parameter = Parameter(proto.parameter_name, data_type=DataType.ANYTHING)
-    return FixedSweep(parameter, FixedOptions(sweep_values))
+    return Sweep(parameter=parameter, data=sweep_values)

exa/common/api/proto_serialization/sequence.py

@@ -37,18 +37,18 @@ def pack(values: Sequence) -> dpb.Sequence:
     if not values:
         return target
     dtype = type(values[0])
-    if dtype == complex:  # noqa: E721
+    if dtype is complex:
         target_field = target.complex128_array
         target_field.real.MergeFrom(np.real(values))
         target_field.imag.MergeFrom(np.imag(values))
         return target
-    if dtype == bool:  # noqa: E721
+    if dtype is bool:
         target_field = target.bool_array
-    elif dtype == int:  # noqa: E721
+    elif dtype is int:
         target_field = target.int64_array
-    elif dtype == float:  # noqa: E721
+    elif dtype is float:
         target_field = target.float64_array
-    elif dtype == str:  # noqa: E721
+    elif dtype is str:
         target_field = target.string_array
     else:
         raise TypeError(f"Unsupported numpy array type {dtype} for a sequence.")

exa/common/api/proto_serialization/setting_node.py

@@ -85,4 +85,6 @@ def unpack(proto: spb.SettingNode) -> SettingNode:
     """
     settings = {key: _unpack_setting(content) for key, content in proto.settings.items()}
     nodes = {key: unpack(content) for key, content in proto.subnodes.items()}
-    return SettingNode(name=proto.name, **(settings | nodes))
+    # 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)

exa/common/control/sweep/exponential_sweep.py

@@ -14,19 +14,15 @@
 
 """Sweep specification with exponentially spaced values."""
 
-from dataclasses import dataclass, field
-import logging
-import math
-from typing import List, Union
-
-import numpy as np
+from typing import Any
+import warnings
 
 from exa.common.control.sweep.option import CenterSpanBaseOptions, StartStopBaseOptions
 from exa.common.control.sweep.sweep import Sweep
+from exa.common.data.parameter import Parameter
 from exa.common.errors.exa_error import InvalidSweepOptionsTypeError
 
 
-@dataclass(frozen=True)
 class ExponentialSweep(Sweep):
     """Generates parameter values spaced evenly on a geometric progression based on `options`.
 
@@ -41,43 +37,15 @@ class ExponentialSweep(Sweep):
 
     """
 
-    logger: logging.Logger = field(init=False)
-
-    def __post_init__(self):
-        object.__setattr__(self, "logger", logging.getLogger(__name__ + "." + self.__class__.__name__))
-        if isinstance(self.options, StartStopBaseOptions):
-            self.__from_start_stop_base(self.options)
-        elif isinstance(self.options, CenterSpanBaseOptions):
-            self.__from_center_span_base(self.options)
-        else:
-            raise InvalidSweepOptionsTypeError(str(type(self.options)))
-
-    def __from_start_stop_base(self, options: StartStopBaseOptions) -> None:
-        self.logger.debug(f"EXPONENTS: ({options.start}, {options.stop}) with base {options.base}")
-        self._validate_value(options.start, "start")
-        self._validate_value(options.stop, "stop")
-        if options.start == 0 or options.stop == 0:
-            raise ValueError("Exponential range sweep start and stop values must not be zero.")
-        options = StartStopBaseOptions(
-            math.pow(options.base, options.start),
-            math.pow(options.base, options.stop),
-            count=options.count,
-        )
-        object.__setattr__(self, "_data", self.__generate(options))
-
-    def __from_center_span_base(self, options: CenterSpanBaseOptions) -> None:
-        start = options.center - (options.span / 2)
-        stop = options.center + (options.span / 2)
-        self.logger.debug("EXPONENTS: ({}, {}) with base {}".format(start, stop, options.base))
-        (start, stop) = (start, stop) if options.asc else (stop, start)
-        start_stop_base_options = StartStopBaseOptions(
-            start,
-            stop,
-            count=options.count,
-            base=options.base,
-        )
-        self.__from_start_stop_base(start_stop_base_options)
-
-    @staticmethod
-    def __generate(options: StartStopBaseOptions) -> List[Union[int, float, complex]]:
-        return np.geomspace(options.start, options.stop, options.count, endpoint=True).tolist()
+    def __init__(
+        self,
+        parameter: Parameter,
+        options: StartStopBaseOptions | CenterSpanBaseOptions | None = None,
+        *,
+        data: list[Any] | None = None,
+        **kwargs,
+    ) -> None:
+        warnings.warn("ExponentialSweep is deprecated, use Sweep instead.", DeprecationWarning)
+        if options and not isinstance(options, StartStopBaseOptions | CenterSpanBaseOptions):
+            raise InvalidSweepOptionsTypeError(str(type(options)))
+        super().__init__(parameter, options, data=data, **kwargs)

exa/common/control/sweep/fixed_sweep.py

@@ -14,26 +14,22 @@
 
 """Sweep specification with arbitrary values."""
 
-from dataclasses import dataclass
-
-import numpy as np
+from typing import Any
+import warnings
 
 from exa.common.control.sweep.option import FixedOptions
 from exa.common.control.sweep.sweep import Sweep
+from exa.common.data.parameter import Parameter
 from exa.common.errors.exa_error import InvalidSweepOptionsTypeError
 
 
-@dataclass(frozen=True)
 class FixedSweep(Sweep):
     """A sweep over arbitrary set of values, given by `options`."""
 
-    def __post_init__(self):
-        if not isinstance(self.options, FixedOptions):
-            raise InvalidSweepOptionsTypeError(str(type(self.options)))
-
-        if not all(self.parameter.validate(value) for value in self.options.fixed):
-            raise ValueError(
-                f"Invalid fixed range data {self.options.fixed} for parameter type {self.parameter.data_type.name}."
-            )
-        data = np.asarray(self.options.fixed).tolist()
-        object.__setattr__(self, "_data", data)
+    def __init__(
+        self, parameter: Parameter, options: FixedOptions | None = None, *, data: list[Any] | None = None, **kwargs
+    ) -> None:
+        warnings.warn("FixedSweep is deprecated, use Sweep instead.", DeprecationWarning)
+        if options and not isinstance(options, FixedOptions):
+            raise InvalidSweepOptionsTypeError(str(type(options)))
+        super().__init__(parameter, options, data=data, **kwargs)

exa/common/control/sweep/linear_sweep.py

@@ -14,18 +14,15 @@
 
 """Sweep specification with linearly spaced values."""
 
-from dataclasses import dataclass
-import math
-from typing import Union
-
-import numpy as np
+from typing import Any
+import warnings
 
 from exa.common.control.sweep.option import CenterSpanOptions, StartStopOptions
 from exa.common.control.sweep.sweep import Sweep
+from exa.common.data.parameter import Parameter
 from exa.common.errors.exa_error import InvalidSweepOptionsTypeError
 
 
-@dataclass(frozen=True)
 class LinearSweep(Sweep):
     """Generates evenly spaced parameter values based on `options`.
 
@@ -38,37 +35,15 @@ class LinearSweep(Sweep):
 
     """
 
-    def __post_init__(self):
-        if isinstance(self.options, StartStopOptions):
-            self.__from_start_stop(self.options)
-        elif isinstance(self.options, CenterSpanOptions):
-            self.__from_center_span(self.options)
-        else:
-            raise InvalidSweepOptionsTypeError(str(type(self.options)))
-
-    def __from_start_stop(self, options: StartStopOptions) -> None:
-        self._validate_value(options.start, "start")
-        self._validate_value(options.stop, "stop")
-        self._validate_value(options.step, "step")
-        object.__setattr__(self, "_data", self.__generate(options))
-
-    def __from_center_span(self, options: CenterSpanOptions) -> None:
-        self._validate_value(options.center, "center")
-        self._validate_value(options.span, "span")
-        start = options.center - (options.span / 2)
-        stop = options.center + (options.span / 2)
-        (start, stop) = (start, stop) if options.asc else (stop, start)
-        start_stop_options = StartStopOptions(start, stop, count=options.count, step=options.step)
-        self.__from_start_stop(start_stop_options)
-
-    def __generate(self, options: StartStopOptions) -> list[Union[int, float, complex]]:
-        if options.step is not None:
-            count = 1 + math.ceil(abs(options.stop - options.start) / float(np.abs(options.step)))
-            data = self.__generate_by_count(options, count)
-        else:
-            data = self.__generate_by_count(options, options.count)
-        return data
-
-    @staticmethod
-    def __generate_by_count(options: StartStopOptions, count: int) -> list[Union[int, float, complex]]:
-        return np.linspace(options.start, options.stop, count, endpoint=True).tolist()
+    def __init__(
+        self,
+        parameter: Parameter,
+        options: StartStopOptions | CenterSpanOptions | None = None,
+        *,
+        data: list[Any] | None = None,
+        **kwargs,
+    ) -> None:
+        warnings.warn("LinearSweep is deprecated, use Sweep instead.", DeprecationWarning)
+        if options and not isinstance(options, StartStopOptions | CenterSpanOptions):
+            raise InvalidSweepOptionsTypeError(str(type(options)))
+        super().__init__(parameter, options, data=data, **kwargs)

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

@@ -11,12 +11,12 @@
 # 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.
+
 """Range specifications for Sweeps."""
 
 from .center_span_base_options import CenterSpanBaseOptions
 from .center_span_options import CenterSpanOptions
 from .fixed_options import FixedOptions
-from .function_options import FunctionOptions
 from .start_stop_base_options import StartStopBaseOptions
 from .start_stop_options import StartStopOptions
 from .sweep_options import SweepOptions

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

@@ -12,12 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Range specification used with ExponentialSweep."""
+"""Range specification used with exponential sweeps."""
 
 from dataclasses import dataclass
-from typing import Union
 
 from exa.common.control.sweep.option.constants import DEFAULT_BASE, DEFAULT_COUNT
+from exa.common.control.sweep.option.start_stop_base_options import StartStopBaseOptions
 from exa.common.control.sweep.option.sweep_options import SweepOptions
 
 
@@ -32,17 +32,17 @@ class CenterSpanBaseOptions(SweepOptions):
     """
 
     #: Value of interval center for the power.
-    center: Union[int, float]
+    center: int | float
     #: Size of the interval for the power
-    span: Union[int, float]
+    span: int | float
     #: Number of values to generate. Default to
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_COUNT`.
-    count: int = None
+    count: int | None = None
     #: Number, that is raised to the power of the range with the center `center` and the size of `span`.
     # Default to :const:`exa.common.control.sweep.option.constants.DEFAULT_BASE`.
-    base: Union[int, float] = None
+    base: int | float | None = None
     #: Order of generated values. Default to ascending
-    asc: bool = None
+    asc: bool | None = None
 
     def __post_init__(self):
         if self.count is None:
@@ -51,3 +51,10 @@ class CenterSpanBaseOptions(SweepOptions):
             object.__setattr__(self, "base", DEFAULT_BASE)
         if self.asc is None:
             object.__setattr__(self, "asc", True)
+
+    @property
+    def data(self) -> list[int | float | complex]:
+        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

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

@@ -15,9 +15,9 @@
 """Range specification to define a range around a center value."""
 
 from dataclasses import dataclass
-from typing import Union
 
 from exa.common.control.sweep.option.constants import DEFAULT_COUNT
+from exa.common.control.sweep.option.start_stop_options import StartStopOptions
 from exa.common.control.sweep.option.sweep_options import SweepOptions
 
 
@@ -32,17 +32,17 @@ class CenterSpanOptions(SweepOptions):
     """
 
     #: Value of interval center.
-    center: Union[int, float, complex]
+    center: int | float | complex
     #: Size of the interval.
-    span: Union[int, float, complex]
+    span: int | float | complex
     #: Number of values to generate.
     #: If `count` and `step` are empty, the default value of count is
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_COUNT`.
-    count: int = None
+    count: int | None = None
     #: Size of spacing between values.
-    step: Union[int, float, complex] = None
+    step: int | float | complex = None
     #: Order of generated values. Default to ascending
-    asc: bool = None
+    asc: bool | None = None
 
     def __post_init__(self):
         if self.count is not None and self.step is not None:
@@ -51,3 +51,10 @@ class CenterSpanOptions(SweepOptions):
             object.__setattr__(self, "count", DEFAULT_COUNT)
         if self.asc is None:
             object.__setattr__(self, "asc", True)
+
+    @property
+    def data(self) -> list[int | float | complex]:
+        start = self.center - (self.span / 2)
+        stop = self.center + (self.span / 2)
+        (start, stop) = (start, stop) if self.asc else (stop, start)
+        return StartStopOptions(start, stop, count=self.count, step=self.step).data

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

@@ -14,14 +14,14 @@
 
 """Helper constants for SweepOptions classes."""
 
-from typing import Any, Dict
+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, Any] = {
     "start": "start",
     "stop": "stop",
     "center": "center",

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

@@ -15,9 +15,11 @@
 """Range specification for arbitrary set of values."""
 
 from dataclasses import dataclass
-from typing import List, Union
+
+import numpy as np
 
 from exa.common.control.sweep.option.sweep_options import SweepOptions
+from exa.common.control.sweep.sweep_values import SweepValues
 
 
 @dataclass(frozen=True)
@@ -25,4 +27,8 @@ class FixedOptions(SweepOptions):
     """Range fixed options."""
 
     #: List of values.
-    fixed: List[Union[int, float, complex, bool, str]]
+    fixed: SweepValues
+
+    @property
+    def data(self) -> SweepValues:
+        return np.asarray(self.fixed).tolist()

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

@@ -15,7 +15,7 @@
 """Helper to create a SweepOptions instance from a dict."""
 
 import ast
-from typing import Any, Dict, List
+from typing import Any
 
 from exa.common.control.sweep.option import (
     CenterSpanBaseOptions,
@@ -28,7 +28,7 @@ from exa.common.control.sweep.option.constants import OPTIONS_TYPE
 from exa.common.control.sweep.option.sweep_options import SweepOptions
 
 
-def convert_to_options(config: Dict[str, Any]) -> SweepOptions:
+def convert_to_options(config: dict[str, Any]) -> SweepOptions:
     """Creates one of the options object based on configuration dictionary.
 
     - If configuration has keys ``start`` and ``stop``, :class:`.StartStopOptions` is created.
@@ -37,10 +37,6 @@ def convert_to_options(config: Dict[str, Any]) -> SweepOptions:
     - If configuration has keys ``center_exp`` and ``span_exp``, :class:`.CenterSpanBaseOptions` is created
     - If configuration has keys ``fixed``, :class:`.FixedOptions` is created.
 
-    .. note::
-        There is no support for callable options, so it is impossible to create
-        :class:`.FunctionOptions` out of configuration
-
     Args:
         config: Configuration dictionary.
 
@@ -72,9 +68,9 @@ def convert_to_options(config: Dict[str, Any]) -> SweepOptions:
         raise ValueError(f"Config {config} cannot be converted to range options")
 
 
-def __update_config(config: Dict[str, Any], keys: List[str]) -> Dict[str, Any]:
+def __update_config(config: dict[str, Any], keys: list[str]) -> dict[str, Any]:
     return {key: ast.literal_eval("".join(str(value).strip())) for key, value in config.items() if key in keys}
 
 
-def __rename_key(config: Dict[str, Any], old_key: str, new_key: str) -> None:
+def __rename_key(config: dict[str, Any], old_key: str, new_key: str) -> None:
     config[new_key] = config.pop(old_key)

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

@@ -12,14 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Range specification used with ExponentialSweep."""
+"""Range specification used with exponential sweeps."""
 
 from dataclasses import dataclass
-from typing import Union
+import logging
+import math
+
+import numpy as np
 
 from exa.common.control.sweep.option.constants import DEFAULT_BASE, DEFAULT_COUNT
 from exa.common.control.sweep.option.sweep_options import SweepOptions
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class StartStopBaseOptions(SweepOptions):
@@ -30,18 +35,27 @@ class StartStopBaseOptions(SweepOptions):
     """
 
     #: The power for the start of the interval.
-    start: Union[int, float, complex]
+    start: int | float | complex
     #: The power for the end of the interval.
-    stop: Union[int, float, complex]
+    stop: int | float | complex
     #: Number of values to generate. Default to
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_COUNT`.
-    count: int = None
+    count: int | None = None
     #: Number, that is raised to the power `start` or `stop`. Default to
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_BASE`.
-    base: Union[int, float] = None
+    base: int | float | None = None
 
     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]:
+        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)
+        return np.geomspace(start, stop, self.count, endpoint=True).tolist()

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

@@ -15,10 +15,13 @@
 """Range specification to define a linearly spaced interval."""
 
 from dataclasses import dataclass
-from typing import Union
+import math
+
+import numpy as np
 
 from exa.common.control.sweep.option.constants import DEFAULT_COUNT
 from exa.common.control.sweep.option.sweep_options import SweepOptions
+from exa.common.control.sweep.sweep_values import SweepValues
 
 
 @dataclass(frozen=True)
@@ -32,16 +35,16 @@ class StartStopOptions(SweepOptions):
     """
 
     #: Starting value of interval.
-    start: Union[int, float, complex]
+    start: int | float | complex
     #: Stopping value of interval.
-    stop: Union[int, float, complex]
+    stop: int | float | complex
     #: Number of values to generate. Must be non-negative.
     #: If `count` and `step` are empty, the default value of count is
     #: :const:`exa.common.control.sweep.option.constants.DEFAULT_COUNT`.
-    count: int = None
+    count: int | None = None
     #: Size of spacing between values. Must be non-zero.
     #: If both `count` and `step` are not empty, only `count` is used
-    step: Union[int, float, complex] = None
+    step: int | float | complex | None = None
 
     def __post_init__(self):
         if self.count is not None and self.step is not None:
@@ -55,3 +58,15 @@ class StartStopOptions(SweepOptions):
             )
         if self.count is not None and self.count <= 0:
             raise ValueError("Count value specified for range must be greater than zero.")
+
+    @property
+    def data(self) -> list[int | float | complex]:
+        if self.step is not None:
+            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)
+        return data
+
+    def _generate_by_count(self, count: int) -> SweepValues:
+        return np.linspace(self.start, self.stop, count, endpoint=True).tolist()

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

@@ -12,9 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""Base class for sweep options."""
+
 from dataclasses import dataclass
 
+from exa.common.control.sweep.sweep_values import SweepValues
+
 
 @dataclass(frozen=True)
 class SweepOptions:
     """Base immutable class for sweep options."""
+
+    @property
+    def data(self) -> SweepValues:
+        """List of values for :attr:`parameter`"""
+        raise NotImplementedError