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

exa/common/data/settingnode_v2.html.jinja2

@@ -29,7 +29,7 @@
 {% endmacro %}
 
 {% macro slisttabrow(key, s) %}
-    <tr>
+    <tr style={{"color:gray" if s.read_only else ""}}>
         <td style="text-align: left">
             <span style="font-family: monospace;
                          font-weight: bold"
@@ -59,18 +59,18 @@
 {% macro snlist(s, lvl=0) %}
     {% if slistmode %}
         <ul style="padding-left: 2em; list-style: none;">
-            {% for key, subs in s._settings.items() %}{{ slistitem(key, subs) }}{% endfor %}
+            {% for key, subs in s.settings.items() %}{{ slistitem(key, subs) }}{% endfor %}
         </ul>
     {% else %}
-        {% if s._settings %}
+        {% if s.settings %}
             <table style="margin-left: 1em;">
-                {% for key, subs in s._settings.items() %}{{ slisttabrow(key, subs) }}{% endfor %}
+                {% for key, subs in s.settings.items() %}{{ slisttabrow(key, subs) }}{% endfor %}
             </table>
         {% endif %}
     {% endif %}
-    {% if s._subtrees %}
+    {% if s.subtrees %}
         <ul class="exa-subtree">
-            {% for key, subsn in s._subtrees.items() %}{{ snlistitem(key, subsn, lvl+1) }}{% endfor %}
+            {% for key, subsn in s.subtrees.items() %}{{ snlistitem(key, subsn, lvl+1) }}{% endfor %}
         </ul>
     {% endif %}
 {% endmacro %}

exa/common/data/value.py

@@ -0,0 +1,49 @@
+import base64
+from typing import Annotated, Any
+
+import numpy as np
+from pydantic import PlainSerializer, PlainValidator, WithJsonSchema
+from pydantic_core import core_schema
+
+
+def validate_value(value: Any) -> Any:
+    """Validate (i.e. deserialize) JSON serializable value to Python type, to support complex and ndarray types."""
+    if isinstance(value, dict):
+        if "__complex__" in value:
+            value = complex(value["real"], value["imag"])
+        elif "__ndarray__" in value:
+            data = base64.b64decode(value["data"])
+            value = np.frombuffer(data, value["dtype"]).reshape(value["shape"])
+    return value
+
+
+def serialize_value(value: Any) -> Any:
+    """Serialize value type to JSON serializable type, to support complex and ndarray types."""
+    if isinstance(value, complex):
+        value = {"__complex__": "true", "real": value.real, "imag": value.imag}
+    elif isinstance(value, np.ndarray):
+        # ensure array buffer is contiguous and in C order
+        value = np.require(value, requirements=["A", "C"])
+        data = base64.b64encode(value.data)
+        value = {"__ndarray__": "true", "data": data, "dtype": str(value.dtype), "shape": value.shape}
+    return value
+
+
+# TODO: We might want to rename these to ObservationValue and ObservationUncertainty, respectively.
+Value = Annotated[
+    bool | str | int | float | complex | np.ndarray,
+    PlainValidator(validate_value),
+    PlainSerializer(serialize_value),
+    WithJsonSchema(core_schema.any_schema()),
+]
+Uncertainty = Annotated[
+    int | float | complex | np.ndarray,
+    PlainValidator(validate_value),
+    PlainSerializer(serialize_value),
+    WithJsonSchema(core_schema.any_schema()),
+]
+
+# TODO (Marko): Consider if we want to rename these?
+#  We have "as" imports so seems like more descriptive name would be better.
+ObservationValue = Value
+ObservationUncertainty = Uncertainty

exa/common/logger/logger.py

@@ -19,7 +19,7 @@ from typing import Any, Callable, Optional
 BRIEF_DATEFMT = "%m-%d %H:%M:%S"
 
 BRIEF = "[{asctime};{levelname:.1}{extra_info}] {message}"
-VERBOSE = "[{asctime};{levelname};{processName}({process});{threadName}({thread});{name};{filename}:{lineno}:{funcName}{extra_info}] {message}"  # pylint:disable=line-too-long  # noqa: E501
+VERBOSE = "[{asctime};{levelname};{processName}({process});{threadName}({thread});{name};{filename}:{lineno}:{funcName}{extra_info}] {message}"  # noqa: E501
 
 
 class ExtraFormatter(logging.Formatter):

exa/common/qcm_data/file_adapter.py

@@ -17,7 +17,7 @@ from http import HTTPStatus
 import io
 import locale
 from pathlib import Path
-from urllib.parse import parse_qs, urlparse
+from urllib.parse import urlparse
 from urllib.request import url2pathname
 
 from requests import Response
@@ -37,12 +37,8 @@ class FileAdapter(BaseAdapter):
             raise ValueError("Invalid request method %s" % request.method)
 
         url_parts = urlparse(request.url)
-        params: dict = parse_qs(url_parts.query, keep_blank_values=True)
 
-        if "chip_label" in params:  # For deprecated CHAD and QDP files
-            path = url2pathname(str(Path(url_parts.path, f"{params['chip_label'][0]}.json")))
-        else:
-            path = url_parts.netloc + f"{str(Path(url2pathname(url_parts.path)))}.json"
+        path = url_parts.netloc + f"{str(Path(url2pathname(url_parts.path)))}.json"
         response = Response()
         try:
             response.status_code = HTTPStatus.OK

exa/common/qcm_data/qcm_data_client.py

@@ -19,7 +19,7 @@ from functools import cache
 import json
 import logging
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from packaging.version import Version
 import requests
@@ -101,42 +101,6 @@ class QCMDataClient:
         self._validate_chip_design_record(data, chip_label)
         return data
 
-    def get_chad(self, chip_label: str) -> Optional[dict]:
-        """DEPRECATED. Use :meth:`get_chip_design_record` instead."""
-        url_tail = f"/v2/chads/?chip_label={chip_label}&limit=1"
-        try:
-            response = self._send_request(self.session.get, f"{self.root_url}{url_tail}")
-        except RequestError as err:
-            if self._fallback_root_url:
-                response = self._send_request(self.session.get, f"{self._fallback_root_url}{url_tail}")
-            else:
-                raise err
-        data = response.json()["data"]
-        if data:
-            chad = data[0]
-            self._validate_chip_design_record(chad, chip_label)
-            return chad
-        return None
-
-    def get_qubit_design_properties(self, chip_label: str) -> dict | None:
-        """DEPRECATED. Use :meth:`get_chip_design_record` instead."""
-        self.logger.warning(
-            "QCMDataClient.get_qubit_design_properties is deprecated, use QCMDataClient.get_chip_design_record instead."
-        )
-        url_tail = f"/qubit-design-properties/?chip_label={chip_label}&limit=10&content_format=json"
-        try:
-            response = self._send_request(self.session.get, f"{self.root_url}{url_tail}")
-        except RequestError as err:
-            if self._fallback_root_url:
-                response = self._send_request(self.session.get, f"{self._fallback_root_url}{url_tail}")
-            else:
-                raise err
-        data = response.json()["data"]
-        if data:
-            qdp = data[0]
-            return qdp
-        return None
-
     def _send_request(self, http_method: Callable[..., requests.Response], url: str) -> requests.Response:
         # Send the request and return the response.
         # Will raise an error if respectively an error response code is returned.

exa/common/sweep/database_serialization.py

@@ -18,16 +18,14 @@ serializing and deserializing sweep arguments before saving them to database.
 """
 
 import json
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
-from exa.common.api.model.parameter_model import ParameterModel
-from exa.common.api.model.setting_node_model import SettingNodeModel
-from exa.common.api.model.sweep_model import SweepModel
 from exa.common.control.sweep.sweep import Sweep
-from exa.common.data.parameter import Parameter, Setting
+from exa.common.data.parameter import Parameter
 from exa.common.data.setting_node import SettingNode
+from exa.common.helpers import json_helper
 from exa.common.helpers.json_helper import decode_json, get_json_encoder
-from exa.common.sweep.util import NdSweep, Sweeps, linear_index_sweep
+from exa.common.sweep.util import NdSweep, Sweeps
 
 
 def encode_nd_sweeps(sweeps: NdSweep, **kwargs) -> str:
@@ -45,22 +43,7 @@ def encode_nd_sweeps(sweeps: NdSweep, **kwargs) -> str:
     return json.dumps(sweeps, **kwargs)
 
 
-def encode_return_parameters_legacy(return_parameters: dict[Parameter, Optional[NdSweep]], **kwargs) -> str:
-    """Encode sweeps to a JSON string.
-
-    Args:
-        return_parameters: Return parameters as specified by :meth:`~.Backend.sweep`.
-        kwargs: keyword arguments passed to json.dumps
-
-    Returns:
-        json as a string
-
-    """
-    kwargs.setdefault("cls", _SweepDataEncoder)
-    return json.dumps(return_parameters, **kwargs)
-
-
-def encode_return_parameters(return_parameters: dict[Parameter, Optional[NdSweep]], **kwargs) -> str:
+def encode_return_parameters(return_parameters: dict[Parameter, NdSweep | None], **kwargs) -> str:
     """Encode sweeps to a JSON string.
 
     Args:
@@ -102,40 +85,7 @@ def decode_and_validate_sweeps(sweeps_json: str) -> Sweeps:
     return cast(Sweeps, decoded)
 
 
-def decode_return_parameters_legacy(json_str: str) -> dict[Parameter, Optional[NdSweep]]:
-    """Deserialize return parameters.
-
-    For backwards compatibility, changes values of the return parameters dict to a new,
-    more general format: NdSweeps, which is a list of tuples of Sweeps.
-
-    A key in the dict may be a Parameter or a Setting; both will be converted to a Parameter.
-    The values in the dict are converted with the following rules:
-
-    * 1 is converted to an empty NdSweep, i.e., a scalar.
-    * Other integers are converted to a :func:`.linear_index_sweep`
-    * `Sweep` is converted to an NdSweep that contains only the sweep
-    * NdSweep and None are not converted.
-
-    Args:
-        json_str: JSON representation of the ``return_parameters`` loaded
-            from e.g. persistence
-
-    Return:
-        a reconstituted, typed ``return_parameters`` structure
-
-    """
-
-    def decode_key(key: str) -> Parameter:
-        parameter_or_setting: dict[str, Any] = json.loads(key)
-        parameter_dict = parameter_or_setting.get("parameter", parameter_or_setting)
-        return ParameterModel(**parameter_dict).decode()
-
-    raw: dict[str, Any] = _loads(json_str)
-    decoded: dict[Setting, Union[NdSweep, Sweep, int]] = {decode_key(key): value for key, value in raw.items()}
-    return _legacy_return_parameters_to_new_format(decoded)
-
-
-def decode_return_parameters(json_str: str) -> dict[Parameter, Optional[NdSweep]]:
+def decode_return_parameters(json_str: str) -> dict[Parameter, NdSweep | None]:
     """Deserialize return parameters.
 
     For backwards compatibility, changes values of the return parameters dict to a new,
@@ -164,8 +114,7 @@ def decode_return_parameters(json_str: str) -> dict[Parameter, Optional[NdSweep]
         raise ValueError(f"Outer type is not list type when decoding: {json_str}")
 
     return_parameters = {
-        ParameterModel(**param_and_sweeps["parameter"]).decode(): param_and_sweeps["hard_sweeps"]
-        for param_and_sweeps in decoded
+        Parameter(**param_and_sweeps["parameter"]): param_and_sweeps["hard_sweeps"] for param_and_sweeps in decoded
     }
     return return_parameters
 
@@ -181,37 +130,8 @@ def decode_settings(json_str: str) -> SettingNode:
         deserialized settings
 
     """
-    return SettingNodeModel(**json.loads(json_str)).decode()
-
-
-def _legacy_return_parameters_to_new_format(
-    old: dict[Union[Parameter, Setting], Union[NdSweep, Sweep, int, None]],
-) -> dict[Parameter, NdSweep]:
-    """For backwards compatibility, changes values of the return parameters dict to a new,
-    more general format: NdSweeps, which is a list of tuples of Sweeps.
-
-    Args:
-        old: return parameters in old format.
-
-    Returns:
-        `old` coerced to the new format.
-
-    """
-    new = {}
-    for key, value in old.items():
-        parameter = key.parameter if isinstance(key, Setting) else key
-
-        # Previously, int meant "I don't know the numerical coordinates of this hard sweep, so
-        # just give me a dummy sweep with integers from 0 to <coord>"
-        if isinstance(value, int):
-            # Length 1 means scalar, so no hard sweeps at all
-            new_value = linear_index_sweep(parameter, value) if value != 1 else []
-        elif isinstance(value, Sweep):
-            new_value = [(value,)]
-        else:
-            new_value = value
-        new[parameter] = new_value
-    return new
+    json_loads = json.loads(json_str)
+    return SettingNode(**json_loads)
 
 
 def _loads(*args, **kwargs) -> Any:
@@ -228,12 +148,22 @@ def _loads(*args, **kwargs) -> Any:
     """
 
     def _decode_json(obj: Any) -> Any:
+        if isinstance(obj, dict) and "parameter" in obj:
+            # This is kind of a hack to provide backwards compatibility for old data.
+            #  Pydantic doesn't allow extra attributes with the current setup,
+            #  but old database data can have "parent_name" and "parent_label", which are not part of the model.
+            obj["parameter"].pop("parent_name", None)
+            obj["parameter"].pop("parent_label", None)
+
         if isinstance(obj, dict) and {"parameter", "data"}.issubset(obj):
-            return SweepModel(**obj).decode()
-        return decode_json(obj)
+            data = [json_helper.decode_json(d) for d in obj["data"]]
+            return Sweep(parameter=Parameter(**obj["parameter"]), data=data)
+        json_data_return = decode_json(obj)
+        return json_data_return
 
     kwargs.setdefault("object_hook", _decode_json)
-    return json.loads(*args, **kwargs)
+    loads = json.loads(*args, **kwargs)
+    return loads
 
 
 class _SweepDataEncoder(json.JSONEncoder):
@@ -250,12 +180,14 @@ class _SweepDataEncoder(json.JSONEncoder):
 
         """
         if isinstance(obj, Sweep):
-            return json.loads(SweepModel.encode(obj).model_dump_json())
-        if isinstance(obj, Parameter):
-            return json.loads(ParameterModel.encode(obj).model_dump_json())
-        if isinstance(obj, tuple):
-            return get_json_encoder()[tuple](obj)
-        return super().default(obj)
+            obj = obj.model_copy().model_dump()
+        elif isinstance(obj, Parameter):
+            obj = obj.model_copy().model_dump()
+        elif isinstance(obj, tuple):
+            obj = get_json_encoder()[tuple](obj)
+        else:
+            obj = super().default(obj)
+        return obj
 
     # JSONEncoder doesn't call `default` method for tuple, because
     # it knows how to serialize it. In order to use custom encoder

exa/common/sweep/util.py

@@ -16,7 +16,6 @@
 user-friendly format to canonic ones.
 """
 
-from exa.common.control.sweep.linear_sweep import LinearSweep
 from exa.common.control.sweep.option import StartStopOptions
 from exa.common.control.sweep.sweep import Sweep
 from exa.common.data.parameter import Parameter
@@ -75,7 +74,7 @@ def convert_sweeps_to_list_of_tuples(sweeps: Sweeps) -> NdSweep:
     return new_list
 
 
-def linear_index_sweep(parameter: Parameter, length: int) -> list[tuple[LinearSweep]]:
+def linear_index_sweep(parameter: Parameter, length: int) -> list[tuple[Sweep]]:
     """Produce an NdSweep over a dummy index.
 
     Can be used in places where a "hardware sweep" is needed but not really meaningful.
@@ -91,9 +90,9 @@ def linear_index_sweep(parameter: Parameter, length: int) -> list[tuple[LinearSw
     """
     return [
         (
-            LinearSweep(
-                Parameter(name=parameter.name + "_index", label=parameter.label + " index"),
-                StartStopOptions(0, length - 1, count=length),
+            Sweep(
+                parameter=Parameter(name=parameter.name + "_index", label=parameter.label + " index"),
+                data=StartStopOptions(0, length - 1, count=length).data,
             ),
         )
     ]

{iqm_exa_common-25.34.dist-info → iqm_exa_common-26.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-exa-common
-Version: 25.34
+Version: 26.1
 Summary: Framework for control and measurement of superconducting qubits: common library
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License
@@ -215,7 +215,7 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: iqm-data-definitions <3.0,>=2.6
 Requires-Dist: numpy <3.0,>=1.25.2
-Requires-Dist: pydantic <3.0,>=2.9.2
+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

iqm_exa_common-26.1.dist-info/RECORD

@@ -0,0 +1,54 @@
+exa/common/__init__.py,sha256=AqxwNht57urLqMxFblY7SgxjzkQYW7pRRUUPS1j1Gck,962
+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=gFIAncWpOhy4V56DKYdKoasEIpGu1yUerSuRQf65unY,4828
+exa/common/api/proto_serialization/nd_sweep.py,sha256=B36KY32wTNFJE3Bk2QlN4BeMO0Se7AtwOectlIh5SCM,2661
+exa/common/api/proto_serialization/sequence.py,sha256=2_84ILndHsc9c9KPKvckySIPJHByoH2fXIF-fTjrzvI,2377
+exa/common/api/proto_serialization/setting_node.py,sha256=KCNpwgwIrgyuXsgt-rAm3oEQqKlIxtN8JBUDFaQTJ48,3940
+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=NjO0wiovyV4HTbS3hs0tptmPGSsQLNS9h-mYFQJzX8c,2039
+exa/common/control/sweep/fixed_sweep.py,sha256=hfIv9-f-7WsIavs7JxwcBs-lSZTxV0D51Xv6gH3sywM,1411
+exa/common/control/sweep/linear_sweep.py,sha256=Xn7gjysIQ2Xu_l15yBsqlUvnK5AJdN7KRaa3sNSjzd8,1884
+exa/common/control/sweep/sweep.py,sha256=0ZzhbzcAQaByiX7dz5jDH0r1zmyEiW2B-v8edIyTDs8,3442
+exa/common/control/sweep/sweep_values.py,sha256=pGvds0ZVgMIL6ztE6hGXEzC9E7rvAzeVwvHCG5v6XC8,2298
+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_options.py,sha256=3YI6DpBAXhon_DMRGzf-YugodSP1KX01MBtiqTvCJDM,2475
+exa/common/control/sweep/option/constants.py,sha256=vdYrbi3EBlIST5mO498W2F6s-xqyoEVBAZ6zQEiHmmY,1417
+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/start_stop_base_options.py,sha256=hZCIflh8NzK48cLLMer9U2yDRTM6mCEEuuF2zAZ2CYU,2361
+exa/common/control/sweep/option/start_stop_options.py,sha256=HaQFNlhRPep2yrn_LuOkuZ0imwBEidpD0BTPWf-Svf4,3038
+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=WWbQk5-9coz3qj4IzkEKvIkdcwHISi7XPb14K7ZTPHg,1936
+exa/common/data/parameter.py,sha256=uUMyVt4wfKkwehd9CHbBPOGQ_PSnlI06pNMPjBySDGs,22999
+exa/common/data/setting_node.py,sha256=WldawevXuOb2uN-bjZ04hWijKqX_MOdkyMsgxOZbrek,43190
+exa/common/data/settingnode_v2.html.jinja2,sha256=mo-rlLLmU-Xxf6znJAisispAZK8sbV-2C13byKAtj_Q,3166
+exa/common/data/value.py,sha256=etAYhIKyRmy30uzSd7MpzUhGhvCXcfhMq-PPteG8EcY,1893
+exa/common/errors/__init__.py,sha256=ArMBdpmx1EUenBpzrSNG63kmUf7PM0gCqSYnaCnL9Qk,597
+exa/common/errors/exa_error.py,sha256=eB_c-Qp1OchcBMr3LSyYitity4SochQh-nAghZmGLJU,975
+exa/common/helpers/__init__.py,sha256=IgtVD3tojIFA4MTV2mT5uYM6jb2qny9kBIIhEZT2PuI,610
+exa/common/helpers/data_helper.py,sha256=vhzJ63g1S2JqnCj0WJJuqWcuiIwKATnQeHdWw_3gkZg,1934
+exa/common/helpers/json_helper.py,sha256=VTcYU8FRgv3tXPifuogUWmVAzt_4JoQ_laTHolyodtA,2672
+exa/common/helpers/numpy_helper.py,sha256=KKKyZ_fD0O1gn7_InEQROYnX3WGMA6C1qHh8KzzjtUI,1062
+exa/common/helpers/software_version_helper.py,sha256=kpuQer4p1p4cj9_CzwziBSCX7wuH-FvfNw8G8U-EI3Y,5162
+exa/common/logger/__init__.py,sha256=1bIsGxHzfujXlkgtcAnWToKMkw3dpU5PEd_7LE_NpgQ,686
+exa/common/logger/logger.py,sha256=qQOl2MEBlw69zKEKNWSPOFi7DSLOfsMXNmJYapqzlXY,5684
+exa/common/qcm_data/__init__.py,sha256=VtsYkGoaniSjCkY0oQlqkcYJCtmC2sTDxfrIe_kpqZg,567
+exa/common/qcm_data/chad_model.py,sha256=MQ1xuRODOA6uzb3GJ4fgYx9cXS8z1DeRGw6HYKA9Sio,11223
+exa/common/qcm_data/chip_topology.py,sha256=OJU8-CXV7wfdxrn0HqryNZmxGRoffrg0vi0aMaiYbbY,19328
+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=tuNEosERVjtGYEq7RWaBzxST7OvRAWxN-VRYmhJLLN8,6094
+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.1.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_exa_common-26.1.dist-info/METADATA,sha256=d5as1iS3mrwzyUGIUrLxB13yjHEgfiP76prxvM_epQM,14548
+iqm_exa_common-26.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_exa_common-26.1.dist-info/top_level.txt,sha256=Clphg2toaZ3_jSFRPhjMNEmLurkMNMc4lkK2EFYsSlM,4
+iqm_exa_common-26.1.dist-info/RECORD,,

exa/common/api/model/__init__.py

@@ -1,15 +0,0 @@
-# Copyright 2024 IQM
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Pydantic models for serializing control and data structures."""

exa/common/api/model/parameter_model.py

@@ -1,111 +0,0 @@
-# Copyright 2024 IQM
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Pydantic model for Parameter."""
-
-from __future__ import annotations
-
-from typing import Optional, Tuple
-
-from pydantic import BaseModel, ConfigDict
-
-from exa.common.data.parameter import CollectionType, DataType, Parameter
-
-
-class ParameterModel(BaseModel):
-    """Pydantic parameter model"""  # noqa: D200
-
-    name: str
-    parent_name: Optional[str] = None
-    label: Optional[str] = None
-    parent_label: Optional[str] = None
-    unit: Optional[str] = None
-    data_type: Optional[int | Tuple[int, ...]] = None
-    collection_type: Optional[int] = None
-    element_indices: Optional[int | list[int]] = None
-
-    def __hash__(self):
-        return hash(
-            (
-                self.name,
-                self.parent_name,
-                self.label,
-                self.unit,
-                self.data_type,
-                self.collection_type,
-                self.element_indices,
-            )
-        )
-
-    def __eq__(self, other: ParameterModel):
-        return isinstance(other, ParameterModel) and (
-            (
-                self.name,
-                self.parent_name,
-                self.label,
-                self.parent_label,
-                self.unit,
-                self.data_type,
-                self.collection_type,
-                self.element_indices,
-            )
-            == (
-                other.name,
-                other.parent_name,
-                other.label,
-                other.parent_label,
-                other.unit,
-                other.data_type,
-                other.collection_type,
-                other.element_indices,
-            )
-        )
-
-    model_config = ConfigDict(extra="allow")
-
-    def decode(self) -> Parameter:
-        """Creates instance of :class:`exa.common.data.parameter.Parameter` out of pydantic `ParameterModel`"""
-        if self.data_type is not None:
-            if isinstance(self.data_type, tuple):
-                dt = tuple(DataType(dt) for dt in self.data_type)
-            else:
-                dt = DataType(self.data_type)
-        else:
-            dt = None
-        ct = CollectionType(self.collection_type) if self.collection_type is not None else None
-        if self.element_indices is None:
-            return Parameter(self.name, self.label, self.unit, dt, ct)
-        return Parameter(self.parent_name, self.parent_label, self.unit, dt, ct, self.element_indices)
-
-    @classmethod
-    def encode(cls, parameter: Parameter) -> ParameterModel:
-        """Creates pydantic `ParameterModel` out of :class:`exa.common.data.parameter.Parameter` instance"""
-        if parameter.data_type is not None:
-            if isinstance(parameter.data_type, tuple):
-                dt = tuple(dt.value for dt in parameter.data_type)
-            else:
-                dt = parameter.data_type.value
-        else:
-            dt = None
-        ct = parameter.collection_type.value if parameter.collection_type is not None else None
-        return ParameterModel(
-            name=parameter.name,
-            parent_name=parameter.parent_name,
-            label=parameter.label,
-            parent_label=parameter.parent_label,
-            unit=parameter.unit,
-            data_type=dt,
-            collection_type=ct,
-            element_indices=parameter.element_indices,
-        )

exa/common/api/model/setting_model.py

@@ -1,63 +0,0 @@
-# Copyright 2024 IQM
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Pydantic model for Setting."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from pydantic import BaseModel, ConfigDict, field_serializer
-
-from exa.common.api.model.parameter_model import ParameterModel
-from exa.common.data.parameter import Setting
-from exa.common.helpers import json_helper
-from exa.common.helpers.numpy_helper import coerce_numpy_type_to_native
-
-
-class SettingModel(BaseModel):
-    """Pydantic setting model"""  # noqa: D200
-
-    parameter: ParameterModel
-    value: Any = None
-
-    def __hash__(self):
-        return hash((self.parameter, self.value))
-
-    def __eq__(self, other: SettingModel):
-        return isinstance(other, SettingModel) and ((self.parameter, self.value) == (other.parameter, other.value))
-
-    model_config = ConfigDict(extra="allow")
-
-    @field_serializer("value")
-    def serialize_value(self, value: Any, _info):
-        encoder = json_helper.get_json_encoder().get(type(value))
-        if encoder:
-            return encoder(value)
-        return value
-
-    def decode(self) -> Setting:
-        """Creates instance of :class:`exa.common.data.parameter.Setting` out of pydantic `SettingModel`"""
-        value = json_helper.decode_json(self.value)
-        parameter = ParameterModel.decode(self.parameter)
-        return Setting(parameter=parameter, value=value)
-
-    @classmethod
-    def encode(cls, setting: Setting) -> SettingModel:
-        """Creates pydantic :class:`SettingModel` out of :class:`~exa.common.data.parameter.Setting` instance.
-
-        Converts numpy scalars to native types to avoid problems with JSON encoding.
-        """
-        value = coerce_numpy_type_to_native(setting.value)
-        return SettingModel(parameter=ParameterModel.encode(setting.parameter), value=value)