backscattermeter_analyzer 2.2.0__tar.gz → 2.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backscattermeter_analyzer
-Version: 2.2.0
+Version: 2.2.2
 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

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

@@ -1,6 +1,6 @@
 [project]
 name = "backscattermeter_analyzer"
-version = "2.2.0"
+version = "2.2.2"
 description = "Tool to work on the backscattermeter at LAPP"
 authors = [{ name = "linarphy", email = "linarphy@linarphy.net" }]
 readme = "README.md"

backscattermeter_analyzer-2.2.2/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.2.0 → backscattermeter_analyzer-2.2.2}/src/backscattermeter_analyzer/characterize/distance/result.py

@@ -1,13 +1,17 @@
 """Result class."""
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+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.motor import (
     WithMotorPath,
@@ -16,6 +20,46 @@ from backscattermeter_analyzer.utils.measurement.motor import (
 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
 class Result:
@@ -23,8 +67,12 @@ 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:
         """Generate a result from a measurement by analysing it."""

backscattermeter_analyzer-2.2.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2.2/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.2/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",
+]

backscattermeter_analyzer-2.2.2/src/backscattermeter_analyzer/io/hdf5/distance/main.py

@@ -0,0 +1,195 @@
+"""Hdf5 conversion for the main metadata of a Distance."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from astropy.uncertainty import Distribution
+from gwpy.detector.channel import Channel
+from h5py import Dataset, File, Group
+
+from backscattermeter_analyzer.io.hdf5.utils import (
+    dataset_to_distribution,
+    distribution_to_dataset,
+    get_group,
+    is_hdf5,
+)
+from backscattermeter_analyzer.io.registry.default import (
+    default_registry,
+)
+
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.utils import Distance
+
+
+def _read(input_: Group, path: str | None = None) -> Distance:
+    """Read a Distance object from a group, internal function."""
+    from backscattermeter_analyzer.utils import (
+        Distance,
+    )
+
+    item = get_group(input_, path)
+
+    group_distance = item.get("distance", default=None)
+    if group_distance is None:
+        message = f"No `distance` group in {path} from {input_.name}."
+        raise ValueError(message)
+    if not isinstance(group_distance, Group):
+        message = (
+            f"`distance` must be a group in {path} from {input_.name}."
+        )
+        raise TypeError(message)
+
+    distance: dict[str | Channel, Distribution] = {}
+    for dataset_distance in group_distance:
+        if not isinstance(group_distance[dataset_distance], Dataset):
+            message = (
+                f"`{dataset_distance}` is not a dataset in {path} from "
+                f"{input_.name}."
+            )
+            raise TypeError(message)
+        distance[dataset_distance] = dataset_to_distribution(
+            group_distance[dataset_distance]
+        )
+
+    identifier = item["identifier"]
+
+    return Distance(distance=distance, identifier=identifier)
+
+
+def read(input_: Path | Group, path: str | None = None) -> Distance:
+    """
+    Read a Distance object from an HDF5 component/file.
+
+    Parameters
+    ----------
+    input_: Path | Group
+        If a Path, the filename to read the distance from.
+        If an h5py object, either the file or the group object to read
+        the Distance from.
+    path: str | None
+        The path from which to read the distance inside the HDF5
+        file. This should be relative to the input if the input is a
+        Group.
+
+    """
+
+    if isinstance(input_, Path):
+        with File(input_) as file:
+            return _read(input_=file, path=path)
+
+    return _read(input_=input_, path=path)
+
+
+def _write(
+    distance: Distance,
+    output: Group,
+    path: str | None = None,
+    *,
+    append: bool = False,
+    overwrite: bool = False,
+) -> None:
+    """Write a Distance object to a group, internal function."""
+
+    if path is not None:
+        item = output.get(path, default=None)
+        if item is not None and not (append and overwrite):
+            message = (
+                f"`{path}` already exists in {output.name}, add "
+                "`append=True` and `overwrite=True` to proceed anyway."
+            )
+            raise ValueError(message)
+        if item is not None:
+            if not isinstance(item, Group):
+                message = (
+                    f"{path} from {output.name} is a {type(item)}"
+                    ", not a Group."
+                )
+                raise TypeError(message)
+            item.clear()
+        else:
+            item = output.create_group(name=path)
+    else:
+        item = output
+
+    item["identifier"] = distance.identifier
+    distance_group = item.create_group("distance")
+
+    for name, distance_item in distance.distance.items():
+        distribution_to_dataset(
+            store=distance_group,
+            name=str(name),
+            distribution=distance_item,
+        )
+
+
+def write(
+    distance: Distance,
+    output: Path | Group,
+    path: str | None = None,
+    *,
+    append: bool = False,
+    overwrite: bool = False,
+) -> None:
+    """
+    Write a Distance object to an HDF5 file.
+
+    Parameters
+    ----------
+    distance: Distance
+        Distance that is to be written to file.
+    output: Path | Group
+        If a Path, the path of the file to write the distance to. If
+        a Group, the group object to write the distance to, depending
+        on `path` value.
+    path: str | None
+        The path to which to write the distance 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
+        Whether to append the distance to an existing HDF5 file.
+        Default to False. This can delete a previous distance.
+    overwrite: bool
+        Whether to overwrite any existing file without warning. Default
+        to False. If `append=True` and `overwrite=True`, then only the
+        group will be replaced.
+
+    """
+
+    if isinstance(output, Path):
+        mode = "x"
+        if overwrite and not append:
+            mode = "w"
+        elif append:
+            mode = "r+"
+
+        with File(output, mode=mode) as file:
+            return _write(
+                distance=distance,
+                output=file,
+                path=path,
+                append=append,
+                overwrite=overwrite,
+            )
+
+    return _write(
+        distance=distance,
+        output=output,
+        path=path,
+        append=append,
+        overwrite=overwrite,
+    )
+
+
+def register_distance() -> None:
+    """Register Distance hdf5 conversion in Unified I/O."""
+    from backscattermeter_analyzer.utils import (
+        Distance,
+    )
+
+    from .motor import register_motor_state
+
+    register_motor_state()
+
+    default_registry.register_identifier("hdf5", Distance, is_hdf5)
+    default_registry.register_reader("hdf5", Distance, read)
+    default_registry.register_writer("hdf5", Distance, write)