backscattermeter_analyzer 2.1.1__tar.gz → 2.2.1__tar.gz

{backscattermeter_analyzer-2.1.1 → backscattermeter_analyzer-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backscattermeter_analyzer
-Version: 2.1.1
+Version: 2.2.1
 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.1/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.1 → backscattermeter_analyzer-2.2.1}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "backscattermeter_analyzer"
-version = "2.1.1"
+version = "2.2.1"
 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.1/src/backscattermeter_analyzer/characterize/angle/result.py

@@ -0,0 +1,73 @@
+"""Result class."""
+
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from backscattermeter_analyzer import Direction, Distance
+from backscattermeter_analyzer.characterize.distance import (
+    Result as DistanceResult,
+)
+from backscattermeter_analyzer.utils.measurement.angle import (
+    WithManualAngle,
+)
+from backscattermeter_analyzer.utils.measurement.motor import (
+    WithMotorPath,
+)
+
+if TYPE_CHECKING:
+    from backscattermeter_analyzer import Axis, Measurement
+
+
+@dataclass
+class Result:
+    """Result of an analysis of an angle measurement."""
+
+    @staticmethod
+    def analyze(*measurements: Measurement) -> Result:
+        """
+        Link manual angle measurements and motorized angle measurements.
+
+        Parameters
+        ----------
+        *measurements: Measurement
+            Manuals and Motorized measurements.
+
+        """
+
+        dict_manual: dict[tuple[Axis, Direction], list[Distance]] = {}
+        motor_measurements: list[DistanceResult] = []
+
+        for measurement in measurements:
+            angle_state = measurement.state.angle
+            motor_state = measurement.state.motor
+            if isinstance(angle_state, WithManualAngle):
+                if isinstance(motor_state, WithMotorPath):
+                    message = (
+                        "Cannot have a measurement with a manual "
+                        "angle and a motor path at the same time"
+                    )
+                    raise TypeError(message)
+                direction = Direction(angle_state.angle.pdf_mean < 0)
+                result = DistanceResult.analyze(measurement)
+                if (angle_state.axis, direction) not in dict_manual:
+                    distances = 0
+                    dict_manual[(angle_state.axis, direction)] = (
+                        result.distances
+                    )
+                else:
+                    dict_manual[(angle_state.axis, direction)].append(
+                        measurement
+                    )
+            else:
+                if not isinstance(motor_state, WithMotorPath):
+                    message = (
+                        "Cannot have a measurement with no manual "
+                        "angle nor motor path."
+                    )
+                    raise TypeError(message)
+                motor_measurements.append(
+                    DistanceResult.analyze(measurement)
+                )
+
+        return Result()

{backscattermeter_analyzer-2.1.1 → backscattermeter_analyzer-2.2.1}/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.1 → backscattermeter_analyzer-2.2.1}/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.1 → backscattermeter_analyzer-2.2.1}/src/backscattermeter_analyzer/characterize/distance/result.py

@@ -1,19 +1,64 @@
 """Result class."""
 
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 from astropy.time import TimeDelta
 from astropy.uncertainty import normal
 from numpy import mean, std
 
+from backscattermeter_analyzer.io.registry import (
+    UnifiedReadWrite,
+    UnifiedReadWriteMethod,
+)
 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
+
+_Base = UnifiedReadWrite["Result"]
+
+
+class Read(_Base):
+    """
+    Read and parse a Result.
+
+    This function provides the Result interface to the
+    backscattermeter_analyzer unified I/O layer.
+    """
+
+    def __init__(
+        self, instance: Result | None, class_: type[Result]
+    ) -> None:
+        """Initialize this class."""
+        super().__init__(instance, class_, "read")
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Result:
+        """Run the main function."""
+        return self._registry.read(self._class_, *args, **kwargs)
+
+
+class Write(_Base):
+    """
+    Write a Result object out in the specified format.
+
+    This function provides the Result interface to the
+    backscattermeter_analyzer unified I/O layer.
+    """
+
+    def __init__(
+        self, instance: Result | None, class_: type[Result]
+    ) -> None:
+        """Initialize this class."""
+        super().__init__(instance, class_, "write")
+
+    def __call__(self, *args: Any, **kwargs: Any) -> object | None:
+        """Run the main function."""
+        return self._registry.write(self._instance, *args, **kwargs)
 
 
 @dataclass
@@ -22,10 +67,14 @@ class Result:
 
     measurement: Measurement
     distances: list[Distance]
+
     identifier: str = field(default_factory=lambda: str(uuid4()))
 
+    read = UnifiedReadWriteMethod(Read)
+    write = UnifiedReadWriteMethod(Write)
+
     @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 +89,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.1 → backscattermeter_analyzer-2.2.1}/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.2.1/src/backscattermeter_analyzer/exception/__init__.py

@@ -0,0 +1,9 @@
+"""Store every exceptions of `backscattermeter_analyzer`."""
+
+from .base import BaseError
+from .io import BaseIOError
+
+__all__ = [
+    "BaseError",
+    "BaseIOError",
+]

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/base.py

@@ -0,0 +1,5 @@
+"""Base class."""
+
+
+class BaseError(Exception):
+    """Parent of every exception in `backscattermeter_analyzer`."""

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/__init__.py

@@ -0,0 +1,7 @@
+"""Store exceptions on I/O process."""
+
+from .base import BaseIOError
+
+__all__ = [
+    "BaseIOError",
+]

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/base.py

@@ -0,0 +1,7 @@
+"""BaseIOError class."""
+
+from backscattermeter_analyzer.exception.base import BaseError
+
+
+class BaseIOError(BaseError):
+    """Base IO Error."""

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/registry/__init__.py

@@ -0,0 +1,15 @@
+"""Exception about registry registration."""
+
+from .already_defined import AlreadyDefinedError
+from .ambiguous_format import AmbiguousFormatError
+from .base import RegistryError
+from .identification import IdentificationError
+from .not_defined import NotDefinedError
+
+__all__ = [
+    "AlreadyDefinedError",
+    "AmbiguousFormatError",
+    "IdentificationError",
+    "NotDefinedError",
+    "RegistryError",
+]

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/registry/already_defined.py

@@ -0,0 +1,34 @@
+"""AlreadyDefinedError class."""
+
+from .base import RegistryError
+
+
+class AlreadyDefinedError(RegistryError):
+    """A function that link a format to a class is already defined."""
+
+    def __init__(
+        self, data_format: str, data_class: type, function_type: str
+    ) -> None:
+        """
+        Error initialization.
+
+        Parameters
+        ----------
+        data_format: str
+            Data format linked to the registry entry.
+        data_class: type
+            Type linked to the registry entry.
+        function_type: str
+            Type of the entry (identifier, writer, reader, etc.).
+
+        Notes
+        -----
+        data_class - write -> data_format
+        data_format - read -> data_class
+
+        """
+        super().__init__(
+            f"{function_type.capitalize()} for format `{data_format}`"
+            f" and class `{data_class}` is already defined. Use "
+            "`force=True` to overwrite and ignore the existing entry."
+        )

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/registry/ambiguous_format.py

@@ -0,0 +1,22 @@
+"""AmbiguousFormatError class."""
+
+from .base import RegistryError
+
+
+class AmbiguousFormatError(RegistryError):
+    """Ambiguous format."""
+
+    def __init__(self, valid_formats: str) -> None:
+        """
+        Error initialization.
+
+        Parameters
+        ----------
+        valid_formats: str
+            Valid formats.
+
+        """
+
+        super().__init__(
+            f"Format is ambiguous. Options are: {valid_formats}."
+        )

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/registry/base.py

@@ -0,0 +1,7 @@
+"""RegistryError class."""
+
+from backscattermeter_analyzer.exception.io import BaseIOError
+
+
+class RegistryError(BaseIOError):
+    """Error on Unified I/O registry operation."""

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/registry/identification.py

@@ -0,0 +1,23 @@
+"""IdentificationError class."""
+
+from .base import RegistryError
+
+
+class IdentificationError(RegistryError):
+    """Impossible to identify format without explicit format arg."""
+
+    def __init__(self, format_table: str) -> None:
+        """
+        Error initialization.
+
+        Parameters
+        ----------
+        format_table: str
+            Available format table.
+
+        """
+        super().__init__(
+            "Format could not be identified based on the file name or "
+            "contents, please provide a `format` argument.\n"
+            f"The available formats are:\n{format_table}"
+        )

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/exception/io/registry/not_defined.py

@@ -0,0 +1,29 @@
+"""NotDefinedError class."""
+
+from .base import RegistryError
+
+
+class NotDefinedError(RegistryError):
+    """A function that link a format to a class does not exist."""
+
+    def __init__(
+        self, data_format: str, data_class: type, function_type: str
+    ) -> None:
+        """
+        Error initialization.
+
+        Parameters
+        ----------
+        data_format: str
+            Data format linked to the non-existing registry entry.
+        data_class: type
+            Type linked to the non-existing registry entry.
+        function_type: str
+            Type of the non-existing entry (identifier, writer, reader,
+            etc.)
+
+        """
+        super().__init__(
+            f"No {function_type} defined for format {data_format} and "
+            f"class {data_class}."
+        )

{backscattermeter_analyzer-2.1.1 → backscattermeter_analyzer-2.2.1}/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.1 → backscattermeter_analyzer-2.2.1}/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.1/src/backscattermeter_analyzer/io/hdf5/__init__.py

@@ -0,0 +1,11 @@
+"""Sub-package for writing and parsing hdf5 files."""
+
+from .distance import register_distance as register_distance_hdf5
+from .measurement import (
+    register_measurement as register_measurement_hdf5,
+)
+
+__all__ = [
+    "register_distance_hdf5",
+    "register_measurement_hdf5",
+]

backscattermeter_analyzer-2.2.1/src/backscattermeter_analyzer/io/hdf5/distance/__init__.py

@@ -0,0 +1,7 @@
+"""Sub-package managing HDF5 conversion of Distance."""
+
+from .main import register_distance
+
+__all__ = [
+    "register_distance",
+]