ngio 0.1.6__py3-none-any.whl → 0.2.0a1__py3-none-any.whl

ngio/ngff_meta/meta_handler.py

@@ -1,92 +0,0 @@
-"""Handler for reading and writing NGFF image metadata."""
-
-from typing import Literal, Protocol
-
-from ngio.io import AccessModeLiteral, Group, StoreOrGroup
-from ngio.ngff_meta.fractal_image_meta import ImageLabelMeta
-from ngio.ngff_meta.v04.zarr_utils import (
-    NgffImageMetaZarrHandlerV04,
-)
-
-
-class NgffImageMetaHandler(Protocol):
-    """Handler for NGFF image metadata."""
-
-    def __init__(
-        self,
-        store: StoreOrGroup,
-        meta_mode: Literal["image", "label"],
-        cache: bool = False,
-        mode: AccessModeLiteral = "a",
-    ):
-        """Initialize the handler."""
-        ...
-
-    @property
-    def group(self) -> Group:
-        """Return the Zarr group."""
-        ...
-
-    @property
-    def store(self) -> StoreOrGroup:
-        """Return the Zarr store."""
-        ...
-
-    @property
-    def zarr_version(self) -> int:
-        """Return the Zarr version."""
-        ...
-
-    @staticmethod
-    def check_version(store: StoreOrGroup) -> bool:
-        """Check if the version of the metadata is supported."""
-        ...
-
-    def load_meta(self) -> ImageLabelMeta:
-        """Load the OME-NGFF 0.4 metadata."""
-        ...
-
-    def write_meta(self, meta: ImageLabelMeta) -> None:
-        """Write the OME-NGFF 0.4 metadata."""
-        ...
-
-    def update_cache(self, meta: ImageLabelMeta) -> None:
-        """Update the cached metadata."""
-        ...
-
-    def clear_cache(self) -> None:
-        """Clear the cached metadata."""
-        ...
-
-
-_available_load_ngff_image_meta_handlers = {
-    "0.4": NgffImageMetaZarrHandlerV04,
-}
-
-
-def find_ngff_image_meta_handler_version(store: StoreOrGroup) -> str:
-    """Find the version of the NGFF image metadata."""
-    for version, handler in _available_load_ngff_image_meta_handlers.items():
-        if handler.check_version(store=store):
-            return version
-
-    supported_versions = ", ".join(_available_load_ngff_image_meta_handlers.keys())
-    raise ValueError(
-        f"The Zarr store does not contain a supported version. \
-            Supported OME-Ngff versions are: {supported_versions}."
-    )
-
-
-def get_ngff_image_meta_handler(
-    store: StoreOrGroup,
-    meta_mode: Literal["image", "label"],
-    version: str | None = None,
-    cache: bool = False,
-    mode: AccessModeLiteral = "a",
-) -> NgffImageMetaHandler:
-    """Load the NGFF image metadata handler."""
-    if version is None:
-        version = find_ngff_image_meta_handler_version(store)
-
-    handler = _available_load_ngff_image_meta_handlers[version]
-    return handler(store=store, meta_mode=meta_mode, cache=cache, mode=mode)

ngio/ngff_meta/utils.py

@@ -1,235 +0,0 @@
-"""Utility functions for creating and modifying metadata."""
-
-from collections.abc import Collection
-from typing import Any
-
-from ngio.ngff_meta.fractal_image_meta import (
-    Axis,
-    Channel,
-    ChannelNames,
-    ChannelVisualisation,
-    Dataset,
-    ImageMeta,
-    LabelMeta,
-    Omero,
-    PixelSize,
-    SpaceNames,
-    SpaceUnits,
-    TimeNames,
-    TimeUnits,
-)
-
-
-def _create_multiscale_meta(
-    on_disk_axis: Collection[str] = ("t", "c", "z", "y", "x"),
-    pixel_sizes: PixelSize | None = None,
-    xy_scaling_factor: float = 2.0,
-    z_scaling_factor: float = 1.0,
-    pixel_units: SpaceUnits | str = SpaceUnits.micrometer,
-    time_spacing: float = 1.0,
-    time_units: TimeUnits | str | None = None,
-    levels: int | list[str] = 5,
-) -> list[Dataset]:
-    """Create a image metadata object from scratch."""
-    allowed_axes_names = (
-        SpaceNames.allowed_names()
-        + TimeNames.allowed_names()
-        + ChannelNames.allowed_names()
-    )
-    for ax in on_disk_axis:
-        if ax not in allowed_axes_names:
-            raise ValueError(
-                f"Invalid axis name: {ax}, allowed names: {allowed_axes_names}"
-            )
-
-    if isinstance(pixel_units, str):
-        pixel_units = SpaceUnits(pixel_units)
-
-    if pixel_sizes is None:
-        pixel_sizes = PixelSize(z=1.0, y=1.0, x=1.0, unit=pixel_units)
-
-    pixel_sizes_dict = pixel_sizes.as_dict()
-    pixel_sizes_dict["t"] = time_spacing
-
-    scaling_factor_dict = {
-        "z": z_scaling_factor,
-        "y": xy_scaling_factor,
-        "x": xy_scaling_factor,
-    }
-
-    if time_units is None:
-        time_units = TimeUnits.s
-
-    if isinstance(time_units, str):
-        time_units = TimeUnits(time_units)
-
-    axes = Axis.batch_create(on_disk_axis, time_unit=time_units, space_unit=pixel_units)
-    datasets = []
-
-    if isinstance(levels, int):
-        paths = [str(i) for i in range(levels)]
-    elif isinstance(levels, list):
-        if not all(isinstance(level, str) for level in levels):
-            raise ValueError(f"All levels must be strings. Got: {levels}")
-        paths = levels
-
-    for level, path in enumerate(paths):
-        scale = [
-            pixel_sizes_dict.get(ax, 1.0) * scaling_factor_dict.get(ax, 1.0) ** level
-            for ax in on_disk_axis
-        ]
-
-        datasets.append(
-            Dataset(
-                path=path,
-                on_disk_axes=axes,
-                on_disk_scale=scale,
-                on_disk_translation=None,
-            )
-        )
-    return datasets
-
-
-def create_image_metadata(
-    on_disk_axis: Collection[str] = ("t", "c", "z", "y", "x"),
-    pixel_sizes: PixelSize | None = None,
-    xy_scaling_factor: float = 2.0,
-    z_scaling_factor: float = 1.0,
-    time_spacing: float = 1.0,
-    time_units: TimeUnits | str = TimeUnits.s,
-    levels: int | list[str] = 5,
-    name: str | None = None,
-    channel_labels: list[str] | None = None,
-    channel_wavelengths: list[str] | None = None,
-    channel_visualization: list[ChannelVisualisation] | None = None,
-    omero_kwargs: dict[str, Any] | None = None,
-    version: str = "0.4",
-) -> ImageMeta:
-    """Create a image metadata object from scratch.
-
-    Args:
-        on_disk_axis: The names of the axes. The order will correspond to the
-            on-disk order. Axes order should follow the canonical order
-            (t, c, z, y, x). Note that a different order can still be used
-            to store the data on disk if NGFF version used is supports it.
-        pixel_sizes: The pixel sizes for the z, y, x axes.
-        xy_scaling_factor: The scaling factor for the y and x axes, to be used
-            for the pyramid building.
-        z_scaling_factor: The scaling factor for the z axis, to be used for the
-            pyramid building. Note that several tools may not support scaling
-            different than 1.0 for the z axis.
-        time_spacing: The time spacing (If the time axis is present).
-        time_units: The units of the time spacing (If the time axis is present).
-        levels: The number of levels in the pyramid or the list of paths.
-        name: The name of the metadata.
-        channel_labels: The names of the channels.
-        channel_wavelengths: The wavelengths of the channels.
-        channel_visualization: The visualization of the channels.
-        omero_kwargs: The additional omero kwargs.
-        version: The version of NGFF metadata.
-
-    """
-    datasets = _create_multiscale_meta(
-        on_disk_axis=on_disk_axis,
-        pixel_sizes=pixel_sizes,
-        xy_scaling_factor=xy_scaling_factor,
-        z_scaling_factor=z_scaling_factor,
-        time_spacing=time_spacing,
-        time_units=time_units,
-        levels=levels,
-    )
-
-    if channel_labels is None:
-        return ImageMeta(
-            version=version,
-            name=name,
-            datasets=datasets,
-            omero=None,
-        )
-
-    if channel_wavelengths is None:
-        channel_wavelengths = channel_labels
-    else:
-        if len(channel_wavelengths) != len(channel_labels):
-            raise ValueError(
-                "The number of channel wavelengths must match the number of "
-                "channel labels."
-            )
-
-    if channel_visualization is None:
-        channel_visualization = [
-            ChannelVisualisation(color=label) for label in channel_labels
-        ]
-    else:
-        if len(channel_visualization) != len(channel_labels):
-            raise ValueError(
-                "The number of channel kwargs must match the number of channel labels."
-            )
-
-    channels = []
-    for label, wavelengths, ch_visualization in zip(
-        channel_labels, channel_wavelengths, channel_visualization, strict=True
-    ):
-        channels.append(
-            Channel(
-                label=label,
-                wavelength_id=wavelengths,
-                channel_visualisation=ch_visualization,
-            )
-        )
-
-    omero_kwargs = {} if omero_kwargs is None else omero_kwargs
-    omero = Omero(channels=channels, **omero_kwargs)
-
-    return ImageMeta(
-        version=version,
-        name=name,
-        datasets=datasets,
-        omero=omero,
-    )
-
-
-def create_label_metadata(
-    on_disk_axis: Collection[str] = ("t", "c", "z", "y", "x"),
-    pixel_sizes: PixelSize | None = None,
-    xy_scaling_factor: float = 2.0,
-    z_scaling_factor: float = 1.0,
-    time_spacing: float = 1.0,
-    time_units: TimeUnits | str | None = None,
-    levels: int | list[str] = 5,
-    name: str | None = None,
-    version: str = "0.4",
-) -> LabelMeta:
-    """Create a label metadata object from scratch.
-
-    Args:
-        on_disk_axis: The names of the axes. The order will correspond to the
-            on-disk order. Axes order should follow the canonical order
-            (t, c, z, y, x). Note that a different order can still be used
-            to store the data on disk if NGFF version used is supports it.
-        pixel_sizes: The pixel sizes for the z, y, x axes.
-        xy_scaling_factor: The scaling factor for the y and x axes, to be used
-            for the pyramid building.
-        z_scaling_factor: The scaling factor for the z axis, to be used for the
-            pyramid building. Note that several tools may not support scaling
-            different than 1.0 for the z axis.
-        time_spacing: The time spacing (If the time axis is present).
-        time_units: The units of the time spacing (If the time axis is present).
-        levels: The number of levels in the pyramid or the list of paths.
-        name: The name of the metadata.
-        version: The version of NGFF metadata.
-    """
-    datasets = _create_multiscale_meta(
-        on_disk_axis=on_disk_axis,
-        pixel_sizes=pixel_sizes,
-        xy_scaling_factor=xy_scaling_factor,
-        z_scaling_factor=z_scaling_factor,
-        time_spacing=time_spacing,
-        time_units=time_units,
-        levels=levels,
-    )
-    return LabelMeta(
-        version=version,
-        name=name,
-        datasets=datasets,
-    )

ngio/ngff_meta/v04/__init__.py

@@ -1,6 +0,0 @@
-"""Pydantic Models related to OME-NGFF 0.4 specs."""
-
-from ngio.ngff_meta.v04.specs import NgffImageMeta04
-from ngio.ngff_meta.v04.zarr_utils import NgffImageMetaZarrHandlerV04
-
-__all__ = ["NgffImageMetaZarrHandlerV04", "NgffImageMeta04"]

ngio/ngff_meta/v04/specs.py

@@ -1,158 +0,0 @@
-"""Implementations of the OME-NGFF 0.4 specs using Pydantic models.
-
-See https://ngff.openmicroscopy.org/0.4/ for detailed specs.
-"""
-
-from typing import Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-from ngio.utils._pydantic_utils import (
-    SKIP_NGFF_VALIDATION,
-    BaseWithExtraFields,
-    unique_items_validator,
-)
-
-
-class Window04(BaseModel):
-    """Model for `Channels.Window`."""
-
-    max: int | float
-    min: int | float
-    start: int | float
-    end: int | float
-
-
-class Channel04(BaseWithExtraFields):
-    """Model for `Omero.channels`."""
-
-    label: str
-    color: str
-    active: bool = True
-    window: Window04 | None = None
-
-
-class Omero04(BaseWithExtraFields):
-    """Model for `NgffImageMeta.Omero`."""
-
-    channels: list[Channel04]
-    version: Literal["0.4"] = "0.4"
-
-
-class Axis04(BaseModel):
-    """Model for `Multiscale.axes` elements."""
-
-    name: str
-    type: str
-    unit: str | None = None
-
-
-class ScaleCoordinateTransformation04(BaseModel):
-    """Model for a scale transformation.
-
-    This corresponds to scale-type elements of
-    `Dataset.coordinateTransformations` or
-    `Multiscale.coordinateTransformations`.
-    """
-
-    type: Literal["scale"]
-    scale: list[float] = Field(..., min_length=2)
-
-
-class TranslationCoordinateTransformation04(BaseModel):
-    """Model for a translation transformation.
-
-    This corresponds to translation-type elements of
-    `Dataset.coordinateTransformations` or
-    `Multiscale.coordinateTransformations`.
-    """
-
-    type: Literal["translation"]
-    translation: list[float] = Field(..., min_length=2)
-
-
-Transformation04 = (
-    ScaleCoordinateTransformation04 | TranslationCoordinateTransformation04
-)
-
-
-class Dataset04(BaseModel):
-    """Model for `Multiscale.datasets` elements."""
-
-    path: str
-    coordinateTransformations: list[Transformation04] = Field(
-        ..., min_length=1, max_length=2
-    )
-
-    @field_validator("coordinateTransformations")
-    @classmethod
-    def _check_scale_exists(cls, v):
-        # check if at least one scale transformation exists
-        if SKIP_NGFF_VALIDATION:
-            return v
-
-        num_scale = sum(
-            1 for item in v if isinstance(item, ScaleCoordinateTransformation04)
-        )
-        if num_scale != 1:
-            raise ValueError("Exactly one scale transformation is required.")
-
-        num_translation = sum(
-            1 for item in v if isinstance(item, TranslationCoordinateTransformation04)
-        )
-        if num_translation > 1:
-            raise ValueError("At most one translation transformation is allowed.")
-
-        return v
-
-
-class Multiscale04(BaseModel):
-    """Model for `NgffImageMeta.multiscales` elements."""
-
-    name: str | None = None
-    datasets: list[Dataset04] = Field(..., min_length=1)
-    version: Literal["0.4"] | None = "0.4"
-    axes: list[Axis04] = Field(..., max_length=5, min_length=2)
-    coordinateTransformations: list[Transformation04] | None = None
-    _check_unique = field_validator("axes")(unique_items_validator)
-
-    @field_validator("axes")
-    @classmethod
-    def _check_axes_order(cls, v):
-        # check if the order of axes is correct
-        if SKIP_NGFF_VALIDATION:
-            return v
-
-        axes_types = [axis.type for axis in v]
-
-        if "time" in axes_types:
-            time_position = axes_types.index("time")
-            if time_position != 0:
-                raise ValueError("Time axis should be the first axis.")
-
-            axes_types = axes_types.pop(0)
-
-        if len(axes_types) < 2:
-            raise ValueError("At least two spatial axes are required.")
-
-        reversed_axes_types = axes_types[::-1]
-
-        channel_type_flag = False
-        for ax_type in reversed_axes_types:
-            if ax_type == "space":
-                if channel_type_flag:
-                    raise ValueError("Channel axis should precede spatial axes.")
-            else:
-                channel_type_flag = True
-        return v
-
-
-class NgffImageMeta04(BaseWithExtraFields):
-    """Model for the metadata of a NGFF image."""
-
-    multiscales: list[Multiscale04] = Field(
-        ...,
-        min_length=1,
-    )
-    omero: Omero04 | None = None
-    _check_unique = field_validator("multiscales")(unique_items_validator)