backscattermeter_analyzer 2.1.0__tar.gz → 2.2.0__tar.gz

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backscattermeter_analyzer
-Version: 2.1.0
+Version: 2.2.0
 Summary: Tool to work on the backscattermeter at LAPP
 Project-URL: Documentation, https://git.linarphy.net/linarphy/backscattermeter_analyzer/wiki
 Project-URL: Homepage, https://git.linarphy.net/linarphy/backscattermeter_analyzer
@@ -15,7 +15,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.12
+Requires-Python: >=3.14.7
 Requires-Dist: gwpy>=3.0.12
 Requires-Dist: lalsuite>=7.26.15
 Requires-Dist: pyqt6>=6.9.1

backscattermeter_analyzer-2.2.0/mise.toml

@@ -0,0 +1,6 @@
+[tools]
+python = "3.14.7"
+uv = "0.11.33"
+just = "1.51.0"
+hatch = "1.16.5"
+markdownlint-cli2 = "0.22.1"

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "backscattermeter_analyzer"
-version = "2.1.0"
+version = "2.2.0"
 description = "Tool to work on the backscattermeter at LAPP"
 authors = [{ name = "linarphy", email = "linarphy@linarphy.net" }]
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.14.7"
 classifiers = [
   "Programming Language :: Python :: 3",
   "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",

backscattermeter_analyzer-2.2.0/src/backscattermeter_analyzer/__init__.py

@@ -0,0 +1,25 @@
+"""Entry-point package."""
+
+from .axis import Axis  # noqa: I001
+from .direction import Direction
+
+from .hardware import Backscattermeter, Camera, MotorJump, MotorPath
+from .io import register_measurement_hdf5
+
+from .characterize import DistanceRatio, DistanceResult
+from .utils import Distance, Measurement
+
+register_measurement_hdf5()
+
+__all__ = [
+    "Axis",
+    "Backscattermeter",
+    "Camera",
+    "Direction",
+    "Distance",
+    "DistanceRatio",
+    "DistanceResult",
+    "Measurement",
+    "MotorJump",
+    "MotorPath",
+]

backscattermeter_analyzer-2.2.0/src/backscattermeter_analyzer/characterize/__init__.py

@@ -0,0 +1,9 @@
+"""Sub-package focused on setup chacterization."""
+
+from .distance import Ratio as DistanceRatio
+from .distance import Result as DistanceResult
+
+__all__ = [
+    "DistanceRatio",
+    "DistanceResult",
+]

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/src/backscattermeter_analyzer/characterize/distance/__init__.py

@@ -103,15 +103,11 @@ We have l, and j via (6), which can be used to check consistency
 To get the distance associated to each step, we have to
 """
 
-from .distance import Distance
-from .measurement import Measurement
 from .ratio import Ratio
 from .result import Result
 from .vector import Vector
 
 __all__ = [
-    "Distance",
-    "Measurement",
     "Ratio",
     "Result",
     "Vector",

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/src/backscattermeter_analyzer/characterize/distance/ratio.py

@@ -11,12 +11,13 @@ from numpy.linalg import norm
 from backscattermeter_analyzer import Axis, Direction
 from backscattermeter_analyzer.utils.distance.motor import WithMotorJump
 
-from .result import Result
 from .vector import Vector
 
 if TYPE_CHECKING:
     from backscattermeter_analyzer.utils.distance import Distance
 
+    from .result import Result
+
 
 @dataclass
 class Ratio:
@@ -36,7 +37,7 @@ class Ratio:
     @staticmethod
     def compute(
         results: list[Result], reference: tuple[Axis, Direction]
-    ) -> "Ratio":
+    ) -> Ratio:
         """Compute the distance ratio from multiple results."""
         distances: dict[tuple[Axis, Direction], list[Distance]] = {
             (Axis.X, Direction.POSITIVE): [],

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/src/backscattermeter_analyzer/characterize/distance/result.py

@@ -1,6 +1,7 @@
 """Result class."""
 
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
 from astropy.time import TimeDelta
@@ -8,12 +9,12 @@ from astropy.uncertainty import normal
 from numpy import mean, std
 
 from backscattermeter_analyzer.utils.distance import Distance
-from backscattermeter_analyzer.utils.measurement import Measurement
 from backscattermeter_analyzer.utils.measurement.motor import (
     WithMotorPath,
 )
 
-from .utils import split_stable_segment
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.utils.measurement import Measurement
 
 
 @dataclass
@@ -25,7 +26,7 @@ class Result:
     identifier: str = field(default_factory=lambda: str(uuid4()))
 
     @staticmethod
-    def analyze(measurement: Measurement) -> "Result":
+    def analyze(measurement: Measurement) -> Result:
         """Generate a result from a measurement by analysing it."""
         motor_state = measurement.state.motor
         if not isinstance(motor_state, WithMotorPath):
@@ -40,10 +41,10 @@ class Result:
 
         transition_duration = mean(durations) / 4
 
-        segments = split_stable_segment(
-            transition_duration=transition_duration.to("s"),
-            data=measurement.data,
-            transition_number=len(jumps),
+        segments = measurement.split(
+            number=len(jumps),
+            duration=transition_duration,
+            transformation=lambda _, x: abs(x.diff()),
         )
 
         positions = [

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/src/backscattermeter_analyzer/characterize/distance/vector.py

@@ -1,16 +1,20 @@
 """Vector class."""
 
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
 from astropy.uncertainty import Distribution, normal
-from gwpy.detector.channel import Channel
 from numpy import mean, sqrt
 
-from backscattermeter_analyzer import Axis, Direction
-from backscattermeter_analyzer.utils.distance import Distance
 from backscattermeter_analyzer.utils.distance.motor import WithMotorJump
 
+if TYPE_CHECKING:
+    from gwpy.detector.channel import Channel
+
+    from backscattermeter_analyzer import Axis, Direction
+    from backscattermeter_analyzer.utils.distance import Distance
+
 
 @dataclass
 class Vector:
@@ -28,7 +32,7 @@ class Vector:
     step: dict[str | Channel, Distribution] = field(
         init=False,
         doc="displacement for one step",
-    )  # type: ignore[ty:no-matching-overload]
+    )
     identifier: str = field(default_factory=lambda: str(uuid4()))
 
     def __post_init__(self) -> None:

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/src/backscattermeter_analyzer/hardware/motor/jump.py

@@ -1,8 +1,10 @@
 """Jump class."""
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from backscattermeter_analyzer import Axis, Direction
+if TYPE_CHECKING:
+    from backscattermeter_analyzer import Axis, Direction
 
 
 @dataclass

{backscattermeter_analyzer-2.1.0 → backscattermeter_analyzer-2.2.0}/src/backscattermeter_analyzer/hardware/motor/path.py

@@ -1,16 +1,19 @@
 """Path class."""
 
 from collections.abc import Iterable
+from typing import TYPE_CHECKING
 
 from astropy.time import TimeDelta
 
 from backscattermeter_analyzer import Axis, Direction
-from backscattermeter_analyzer.hardware.motor.step_numbers import (
-    StepNumbers,
-)
 
 from .jump import Jump
 
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.hardware.motor.step_numbers import (
+        StepNumbers,
+    )
+
 
 class Path(Iterable):
     """A sequence of MotorJump."""
@@ -30,7 +33,7 @@ class Path(Iterable):
         self._inner = data
         self._idx = 0
 
-    def __iter__(self) -> "Path":
+    def __iter__(self) -> Path:
         """Default __iter__ function."""
 
         return self
@@ -63,7 +66,7 @@ class Path(Iterable):
         duration: TimeDelta,
         speed: int,
         step_numbers: StepNumbers,
-    ) -> "Path":
+    ) -> Path:
         """Generate a motor path with a snail structure."""
 
         x_p = Jump(

backscattermeter_analyzer-2.2.0/src/backscattermeter_analyzer/io/hdf5/measurement/__init__.py

@@ -0,0 +1,9 @@
+"""Sub-package managing HDF5 conversion of Measurement."""
+
+from .main import read, register_measurement, write
+
+__all__ = [
+    "read",
+    "register_measurement",
+    "write",
+]

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/io/hdf5/measurement.py → backscattermeter_analyzer-2.2.0/src/backscattermeter_analyzer/io/hdf5/measurement/main.py

@@ -1,4 +1,4 @@
-"""Hdf5 conversion for Measurement."""
+"""Hdf5 conversion for the main metadata of a Measurement."""
 
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -6,22 +6,59 @@ from typing import TYPE_CHECKING
 from h5py import File, Group
 
 from backscattermeter_analyzer.hardware import Backscattermeter
-from backscattermeter_analyzer.io.registry.default import (
-    default_registry,
-)
-
-from .utils import (
+from backscattermeter_analyzer.io.hdf5.utils import (
+    get_group,
     group_to_timeseriesdict,
     is_hdf5,
     timeseriesdict_to_group,
 )
+from backscattermeter_analyzer.io.registry.default import (
+    default_registry,
+)
+
+from .motor import read as read_motor
+from .motor import write as write_motor
 
 if TYPE_CHECKING:
-    from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa:E501,TC004
+    from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa: E501
         Measurement,
     )
 
 
+def _read(input_: Group, path: str | None = None) -> Measurement:
+    """Read a Measurement object from a group, internal function."""
+    from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa: PLC0415,E501
+        Measurement,
+    )
+    from backscattermeter_analyzer.utils.measurement.motor.state import (  # noqa: PLC0415,E501
+        State as MotorState,
+    )
+
+    # input_ is now a Group (a File is a Group)
+    item = get_group(input_, path)
+
+    group_data = item.get("data", default=None)
+    if group_data is None:
+        message = f"No 'data' group in {path} from {input_}."
+        raise ValueError(message)
+    if not isinstance(group_data, Group):
+        message = f"'data' must be a group in {path} from {input_}."
+        raise TypeError(message)
+
+    measurement = Measurement(
+        data=group_to_timeseriesdict(group_data),
+        backscattermeter=Backscattermeter(),
+    )
+
+    measurement.state.motor = MotorState.read(  # type: ignore[ty:call-non-callable]
+        input_=item,
+        measurement=measurement,
+        format_="hdf5",
+    )
+
+    return measurement
+
+
 def read(input_: Path | Group, path: str | None = None) -> Measurement:
     """
     Read a Measurement object from an HDF5 component/file.
@@ -29,7 +66,7 @@ def read(input_: Path | Group, path: str | None = None) -> Measurement:
     Parameters
     ----------
     input_: Path | Group
-        If a string or a Path, the filename to read the table from.
+        If a Path, the filename to read the measurement from.
         If an h5py object, either the file or the group object to read
         the Measurement from.
     path: str | None
@@ -37,45 +74,52 @@ def read(input_: Path | Group, path: str | None = None) -> Measurement:
         This should be relative to the input if the input is a Group.
 
     """
-    from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa: PLC0415,E501
-        Measurement,
-    )
 
     if isinstance(input_, Path):
-        input_ = File(input_)
+        with File(input_) as file:
+            return _read(input_=file, path=path)
 
-    # input_ is now a Group (a File is a Group)
+    return _read(input_=input_, path=path)
+
+
+def _write(
+    measurement: Measurement,
+    output: Group,
+    path: str | None = None,
+    *,
+    append: bool = False,
+    overwrite: bool = False,
+) -> None:
+    """Write a Measurement object to a group, internal function."""
+
+    # output is now a Group (a File is a Group)
     if path is not None:
-        item = input_.get(path, default=None)
-        if item is None:
-            message = f"{path} is not a valid path in {input_}."
-            raise ValueError(message)
-        if not isinstance(item, Group):
+        item = output.get(path, default=None)
+        if item is not None and not (append and overwrite):
             message = (
-                f"{path} from {input_} is a {type(item)}, not a Group."
+                f"{path} already exists in {output}, add `append=True` "
+                "and `overwrite=True` to proceed anyway."
             )
-            raise TypeError(message)
+            raise ValueError(message)
+        if item is not None:
+            if not isinstance(item, Group):
+                message = (
+                    f"{path} from {output} is a {type(item)}"
+                    ", not a Group."
+                )
+                raise TypeError(message)
+            item.clear()
+        else:
+            item = output.create_group(name=path)
     else:
-        item = input_
+        item = output
 
-    group_data = item.get("data", default=None)
-    if group_data is None:
-        message = f"No 'data' group in {path} from {input_}."
-        raise ValueError(message)
-    if not isinstance(group_data, Group):
-        message = f"'data' must be a group in {path} from {input_}."
-        raise TypeError(message)
+    timeseriesdict_to_group(item, "data", measurement.data)
 
-    measurement = Measurement(
-        data=group_to_timeseriesdict(group_data),
-        backscattermeter=Backscattermeter(),
+    measurement.state.motor.write(  # type: ignore[ty:call-non-callable]
+        output=item, append=True, overwrite=True, format_="hdf5"
     )
 
-    if isinstance(input_, File):
-        input_.close()
-
-    return measurement
-
 
 def write(
     measurement: Measurement,
@@ -97,7 +141,7 @@ def write(
         a Group, the group object to write the measurement to, depending
         on `path` value.
     path: str | None
-        The path to which to write the table inside the HDF5 file.
+        The path to which to write the measurement inside the HDF5 file.
         This should be relative to the output Group (or the root Group
         if output is a Path). Default to None.
     append: bool
@@ -111,38 +155,28 @@ def write(
     """
 
     if isinstance(output, Path):
+        mode = "x"
         if overwrite and not append:
-            output = File(output, mode="w")
+            mode = "w"
         elif append:
-            output = File(output, mode="r+")
-        else:
-            output = File(output, mode="x")
-
-    # output is now a Group (a File is a Group)
-    if path is not None:
-        item = output.get(path, default=None)
-        if item is None:
-            message = f"{path} is not a valid path in {output}."
-            raise ValueError(message)
-        if not isinstance(item, Group):
-            message = (
-                f"{path} from {output} is a {type(item)}, not a Group."
+            mode = "r+"
+
+        with File(output, mode=mode) as file:
+            return _write(
+                measurement=measurement,
+                output=file,
+                path=path,
+                append=append,
+                overwrite=overwrite,
             )
-            raise TypeError(message)
-    else:
-        item = output
-
-    element_number = len(item.keys())
-    if element_number != 0 and append:
-        item.clear()
-    elif element_number != 0 and not append:
-        message = f"{path} from {output} is not an empty group."
-        raise ValueError(message)
-
-    timeseriesdict_to_group(item, "data", measurement.data)
 
-    if isinstance(output, File):
-        output.close()
+    return _write(
+        measurement=measurement,
+        output=output,
+        path=path,
+        append=append,
+        overwrite=overwrite,
+    )
 
 
 def register_measurement() -> None:
@@ -150,7 +184,13 @@ def register_measurement() -> None:
     from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa: PLC0415,E501
         Measurement,
     )
+    from backscattermeter_analyzer.utils.measurement.motor.state import (  # noqa: PLC0415, E501
+        State as MotorState,
+    )
 
     default_registry.register_identifier("hdf5", Measurement, is_hdf5)
     default_registry.register_reader("hdf5", Measurement, read)
     default_registry.register_writer("hdf5", Measurement, write)
+    default_registry.register_identifier("hdf5", MotorState, is_hdf5)
+    default_registry.register_reader("hdf5", MotorState, read_motor)
+    default_registry.register_writer("hdf5", MotorState, write_motor)