modacor 1.0.0__py3-none-any.whl

modacor/io/io_sources.py

@@ -0,0 +1,208 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Malte Storm", "Brian R. Pauw"]
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "06/06/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+__all__ = ["IoSources"]
+
+
+from typing import Any, Optional
+
+import numpy as np
+from attrs import define, field
+
+from modacor.io.io_source import ArraySlice, IoSource
+
+
+@define
+class IoSources:
+    """
+    IoSources is a collection of al the defined IoSource instances to load data.
+
+    It provides the interface to register new sources and access the different
+    data sources through a single interface.
+    """
+
+    defined_sources: dict[str, IoSource] = field(factory=dict)
+
+    def register_source(self, source: IoSource, source_reference: str | None = None) -> None:
+        """
+        Register a new source class with the given name. If no source_reference is provided, the
+        source's own source_reference attribute will be used.
+
+        Parameters
+        ----------
+        source : IoSource
+            The class of the source to register.
+        source_reference : str
+            The reference name of the source to register.
+        """
+        if not isinstance(source, IoSource):
+            raise TypeError("source_class must be a subclass of IoSource")
+        if source_reference is None:
+            source_reference = source.source_reference
+        if not isinstance(source_reference, str):
+            raise TypeError("source_name must be a string")
+        if source_reference in self.defined_sources:
+            raise ValueError(f"Source {source_reference} already registered.")
+        self.defined_sources[source_reference] = source
+
+    def get_source(self, source_reference: str) -> IoSource:
+        """
+        Get the source class associated with the given name.
+
+        Parameters
+        ----------
+        source_reference : str
+            The reference name of the source to access.
+
+        Returns
+        -------
+        IoSource :
+            The source class associated with the provided name.
+        """
+        if source_reference not in self.defined_sources:
+            raise KeyError(f"Source {source_reference} not registered.")
+        return self.defined_sources[source_reference]
+
+    def split_data_reference(self, data_reference: str) -> tuple[str, str]:
+        """
+        Split the data reference into source reference and data key.
+
+        The data_reference is composed of the source reference and the internal
+        data reference, separated by "::".
+
+        Parameters
+        ----------
+        data_reference : str
+            The reference name of the source to access.
+
+        Returns
+        -------
+        tuple[str, str] :
+            A tuple containing the source reference and the data key.
+        """
+        _split = data_reference.split("::", 1)
+        if len(_split) != 2:
+            raise ValueError(
+                "data_reference must be in the format 'source_ref::data_key' with a "
+                "double colon separating both entries."
+            )
+        return _split[0], _split[1]
+
+    def get_data(self, data_reference: str, load_slice: Optional[ArraySlice] = ...) -> np.ndarray:
+        """
+        Get data from the specified source using the provided data key.
+
+        The data_reference is composed of the source reference and the internal
+        data reference, separated by "::".
+
+        Parameters
+        ----------
+        data_reference : str
+            The reference name of the source to access.
+        load_slice : Optional[ArraySlice]
+            A slice or tuple of slices to apply to the data. If None or ellipsis, the entire data is returned.
+
+        Returns
+        -------
+        Any :
+            The data associated with the provided key.
+        """
+        _source_ref, _data_key = self.split_data_reference(data_reference)
+        _source = self.get_source(_source_ref)
+        return _source.get_data(_data_key, load_slice=load_slice)
+
+    def get_data_shape(self, data_reference: str) -> np.ndarray:
+        """
+        Get data from the specified source using the provided data key.
+
+        The data_reference is composed of the source reference and the internal
+        data reference, separated by "::".
+
+        Parameters
+        ----------
+        data_reference : str
+            The reference name of the source to access.
+
+        Returns
+        -------
+        Any :
+            The data associated with the provided key.
+        """
+        _source_ref, _data_key = self.split_data_reference(data_reference)
+        _source = self.get_source(_source_ref)
+        return _source.get_data_shape(_data_key)
+
+    def get_data_dtype(self, data_reference: str) -> np.ndarray:
+        """
+        Get data from the specified source using the provided data key.
+
+        The data_reference is composed of the source reference and the internal
+        data reference, separated by "::".
+
+        Parameters
+        ----------
+        data_reference : str
+            The reference name of the source to access.
+
+        Returns
+        -------
+        Any :
+            The data associated with the provided key.
+        """
+        _source_ref, _data_key = self.split_data_reference(data_reference)
+        _source = self.get_source(_source_ref)
+        return _source.get_data_dtype(_data_key)
+
+    def get_data_attributes(self, data_reference: str) -> np.ndarray:
+        """
+        Get data from the specified source using the provided data key.
+
+        The data_reference is composed of the source reference and the internal
+        data reference, separated by "::".
+
+        Parameters
+        ----------
+        data_reference : str
+            The reference name of the source to access.
+        index : int
+            The index to access the data.
+
+        Returns
+        -------
+        Any :
+            The data associated with the provided key.
+        """
+        _source_ref, _data_key = self.split_data_reference(data_reference)
+        _source = self.get_source(_source_ref)
+        return _source.get_data_attributes(_data_key)
+
+    def get_static_metadata(self, data_reference: str) -> Any:
+        """
+        Get static metadata from the specified source using the provided data key.
+
+        The data_reference is composed of the source reference and the internal
+        data reference, separated by "::".
+
+        Parameters
+        ----------
+        data_reference : str
+            The reference name of the source to access.
+
+        Returns
+        -------
+        Any :
+            The static metadata associated with the provided key.
+        """
+        _source_ref, _data_key = data_reference.split("::", 1)
+        _source = self.get_source(_source_ref)
+        return _source.get_static_metadata(_data_key)

modacor/io/processing_path.py

@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]
+__copyright__ = "Copyright 2026, The MoDaCor team"
+__date__ = "09/01/2026"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+__all__ = ["ProcessingPath", "parse_processing_path", "resolve_processing_path", "infer_units_for_path"]
+
+from dataclasses import dataclass
+from pathlib import PurePosixPath
+from typing import Any
+
+from modacor import ureg
+from modacor.dataclasses.basedata import BaseData
+from modacor.dataclasses.processing_data import ProcessingData
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessingPath:
+    original: str
+    databundle_key: str
+    basedata_name: str
+    subpath: tuple[str, ...]
+
+
+def parse_processing_path(path: str) -> ProcessingPath:
+    if not isinstance(path, str) or not path.strip():
+        raise TypeError("ProcessingData path must be a non-empty string.")
+
+    original = path.strip()
+    # normalize like posix path; allow leading '/'
+    pp = PurePosixPath(original)
+    parts = tuple(p for p in pp.parts if p != "/")
+
+    if len(parts) < 2:
+        raise ValueError(f"ProcessingData path must be at least '<bundle>/<basedata>' (got: {original}).")
+
+    return ProcessingPath(
+        original=original,
+        databundle_key=parts[0],
+        basedata_name=parts[1],
+        subpath=parts[2:],
+    )
+
+
+def resolve_processing_path(processing_data: ProcessingData, path: str) -> Any:
+    pp = parse_processing_path(path)
+    bd = processing_data[pp.databundle_key][pp.basedata_name]
+    if not isinstance(bd, BaseData):
+        raise TypeError(f"Path {pp.original} did not resolve to a BaseData at the root.")
+
+    obj: Any = bd
+    for key in pp.subpath:
+        if isinstance(obj, BaseData):
+            if key == "signal":
+                obj = obj.signal
+                continue
+            if key == "weights":
+                obj = obj.weights
+                continue
+            if key == "uncertainties":
+                obj = obj.uncertainties
+                continue
+            if key == "variances":
+                obj = obj.variances
+                continue
+
+        if isinstance(obj, dict):
+            obj = obj[key]
+        else:
+            if not hasattr(obj, key):
+                raise AttributeError(
+                    f"Object of type {type(obj).__name__} has no attribute '{key}' (path: {pp.original})"
+                )
+            obj = getattr(obj, key)
+
+    return obj
+
+
+def infer_units_for_path(processing_data: ProcessingData, path: str) -> str:
+    """
+    Stable unit inference for CSV header row 2.
+
+    - .../signal -> bd.units
+    - .../uncertainties/<k> -> bd.units
+    - .../variances/<k> -> bd.units**2
+    - .../weights -> dimensionless
+    - otherwise -> ""
+    """
+    pp = parse_processing_path(path)
+    bd: BaseData = processing_data[pp.databundle_key][pp.basedata_name]
+
+    if len(pp.subpath) == 0:
+        return ""  # no guessing
+
+    first = pp.subpath[0]
+    if first == "signal":
+        return str(bd.units)
+    if first == "uncertainties":
+        return str(bd.units)
+    if first == "variances":
+        return str(bd.units**2)
+    if first == "weights":
+        return str(ureg.dimensionless)
+
+    return ""

modacor/io/tiled/__init__.py

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2026, The MoDaCor team"
+__date__ = "20/01/2026"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+__all__ = ["TiledSource"]
+
+from .tiled_source import TiledSource