ngio 0.3.5__py3-none-any.whl → 0.4.0a1__py3-none-any.whl

ngio/ome_zarr_meta/ngio_specs/_ngio_image.py

@@ -6,7 +6,7 @@ But they can be built from the OME standard metadata, and the
 can be converted to the OME standard.
 """
 
-from collections.abc import Collection
+from collections.abc import Sequence
 from typing import Any, Literal, TypeVar
 
 import numpy as np
@@ -19,7 +19,7 @@ from ngio.ome_zarr_meta.ngio_specs._axes import (
     TimeUnits,
     canonical_axes,
 )
-from ngio.ome_zarr_meta.ngio_specs._channels import Channel, ChannelsMeta
+from ngio.ome_zarr_meta.ngio_specs._channels import ChannelsMeta
 from ngio.ome_zarr_meta.ngio_specs._dataset import Dataset
 from ngio.ome_zarr_meta.ngio_specs._pixel_size import PixelSize
 from ngio.utils import NgioValidationError, NgioValueError
@@ -60,24 +60,24 @@ class AbstractNgioImageMeta:
     def __repr__(self):
         class_name = type(self).__name__
         paths = [dataset.path for dataset in self.datasets]
-        on_disk_axes = self.axes_mapper.on_disk_axes_names
+        on_disk_axes = self.axes_mapper.axes_names
         return f"{class_name}(name={self.name}, datasets={paths}, axes={on_disk_axes})"
 
     @classmethod
     def default_init(
         cls,
-        levels: int | Collection[str],
-        axes_names: Collection[str],
+        levels: int | Sequence[str],
+        axes_names: Sequence[str],
         pixel_size: PixelSize,
-        scaling_factors: Collection[float] | None = None,
+        scaling_factors: Sequence[float] | None = None,
         name: str | None = None,
         version: NgffVersions = DefaultNgffVersion,
     ):
         """Initialize the ImageMeta object."""
         axes = canonical_axes(
             axes_names,
-            space_units=pixel_size.space_unit,  # type: ignore[arg-type]
-            time_units=pixel_size.time_unit,  # type: ignore[arg-type]
+            space_units=pixel_size.space_unit,
+            time_units=pixel_size.time_unit,
         )
 
         px_size_dict = pixel_size.as_dict()
@@ -136,7 +136,7 @@ class AbstractNgioImageMeta:
     @property
     def version(self) -> NgffVersions:
         """Version of the OME-NFF metadata used to build the object."""
-        return self._version  # type: ignore[return-value]
+        return self._version  # type: ignore (version is a Literal type)
 
     @property
     def name(self) -> str | None:
@@ -321,11 +321,11 @@ class AbstractNgioImageMeta:
     def scaling_factor(self, path: str | None = None) -> list[float]:
         """Get the scaling factors from a dataset to its lower resolution."""
         if self.levels == 1:
-            return [1.0] * len(self.axes_mapper.on_disk_axes_names)
+            return [1.0] * len(self.axes_mapper.axes_names)
         dataset, lr_dataset = self._get_closest_datasets(path=path)
 
         scaling_factors = []
-        for ax_name in self.axes_mapper.on_disk_axes_names:
+        for ax_name in self.axes_mapper.axes_names:
             s_d = dataset.get_scale(ax_name)
             s_lr_d = lr_dataset.get_scale(ax_name)
             scaling_factors.append(s_lr_d / s_d)
@@ -462,62 +462,5 @@ class NgioImageMeta(AbstractNgioImageMeta):
         )
         self.set_channels_meta(channels_meta=channels_meta)
 
-    @property
-    def channels(self) -> list[Channel]:
-        """Get the channels in the image."""
-        if self._channels_meta is None:
-            return []
-        assert self.channels_meta is not None
-        return self.channels_meta.channels
-
-    @property
-    def channel_labels(self) -> list[str]:
-        """Get the labels of the channels in the image."""
-        return [channel.label for channel in self.channels]
-
-    @property
-    def channel_wavelength_ids(self) -> list[str | None]:
-        """Get the wavelength IDs of the channels in the image."""
-        return [channel.wavelength_id for channel in self.channels]
-
-    def _get_channel_idx_by_label(self, label: str) -> int | None:
-        """Get the index of a channel by its label."""
-        if self._channels_meta is None:
-            return None
-
-        if label not in self.channel_labels:
-            raise NgioValueError(f"Channel with label {label} not found.")
-
-        return self.channel_labels.index(label)
-
-    def _get_channel_idx_by_wavelength_id(self, wavelength_id: str) -> int | None:
-        """Get the index of a channel by its wavelength ID."""
-        if self._channels_meta is None:
-            return None
-
-        if wavelength_id not in self.channel_wavelength_ids:
-            raise NgioValueError(
-                f"Channel with wavelength ID {wavelength_id} not found."
-            )
-
-        return self.channel_wavelength_ids.index(wavelength_id)
-
-    def get_channel_idx(
-        self, label: str | None = None, wavelength_id: str | None = None
-    ) -> int | None:
-        """Get the index of a channel by its label or wavelength ID."""
-        # Only one of the arguments must be provided
-        if sum([label is not None, wavelength_id is not None]) != 1:
-            raise NgioValueError("get_channel_idx must receive only one argument.")
-
-        if label is not None:
-            return self._get_channel_idx_by_label(label)
-        elif wavelength_id is not None:
-            return self._get_channel_idx_by_wavelength_id(wavelength_id)
-        else:
-            raise NgioValueError(
-                "get_channel_idx must receive either label or wavelength_id."
-            )
-
 
 NgioImageLabelMeta = NgioImageMeta | NgioLabelMeta

ngio/ome_zarr_meta/v04/_v04_spec_utils.py

@@ -316,7 +316,7 @@ def _ngio_to_v04_multiscale(name: str | None, datasets: list[Dataset]) -> Multis
     """
     ax_mapper = datasets[0].axes_mapper
     v04_axes = []
-    for axis in ax_mapper.on_disk_axes:
+    for axis in ax_mapper.axes:
         v04_axes.append(
             AxisV04(
                 name=axis.on_disk_name,

ngio/resources/__init__.py

@@ -0,0 +1,54 @@
+"""Predefined resources for testing and demonstration purposes."""
+
+from pathlib import Path
+from typing import Literal
+
+from ngio.resources.resource_model import LabelsInfo, SampleInfo
+
+resources = Path(__file__).parent.resolve()
+
+_resources = {
+    "Cardiomyocyte": SampleInfo(
+        img_path=resources
+        / "20200812-CardiomyocyteDifferentiation14-Cycle1_B03"
+        / "raw.jpg",
+        labels=[
+            LabelsInfo(
+                name="nuclei",
+                label_path=resources
+                / "20200812-CardiomyocyteDifferentiation14-Cycle1_B03"
+                / "nuclei.png",
+                create_masking_table=False,
+                ensure_unique_labels=True,
+            ),
+            LabelsInfo(
+                name="nuclei_mask",
+                label_path=resources
+                / "20200812-CardiomyocyteDifferentiation14-Cycle1_B03"
+                / "mask.png",
+                create_masking_table=True,
+                ensure_unique_labels=False,
+            ),
+        ],
+        xy_pixelsize=0.325,
+        z_spacing=1.0,
+        time_spacing=1.0,
+        name="Cardiomyocyte Differentiation",
+        info="20200812-CardiomyocyteDifferentiation14-Cycle1_B03",
+    )
+}
+
+AVAILABLE_SAMPLES = Literal["Cardiomyocyte"]
+
+
+def get_sample_info(name: AVAILABLE_SAMPLES) -> SampleInfo:
+    """Get a predefined resource by name."""
+    image_info = _resources.get(name)
+    if image_info is None:
+        raise ValueError(
+            f"Sample '{name}' not found. Available samples: {_resources.keys()}"
+        )
+    return image_info
+
+
+__all__ = ["AVAILABLE_SAMPLES", "LabelsInfo", "SampleInfo"]

ngio/resources/resource_model.py

@@ -0,0 +1,35 @@
+"""Models for programmatic description of image resources."""
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from ngio.ome_zarr_meta.ngio_specs import (
+    DefaultSpaceUnit,
+    DefaultTimeUnit,
+    SpaceUnits,
+    TimeUnits,
+)
+
+
+class LabelsInfo(BaseModel):
+    """Metadata for a label image."""
+
+    name: str
+    label_path: Path
+    ensure_unique_labels: bool = True
+    create_masking_table: bool = False
+
+
+class SampleInfo(BaseModel):
+    """Metadata necessary to create an OME-Ngff from image files."""
+
+    img_path: Path
+    labels: list[LabelsInfo] = Field(default_factory=list)
+    xy_pixelsize: float
+    z_spacing: float = 1.0
+    time_spacing: float = 1.0
+    space_unit: SpaceUnits = DefaultSpaceUnit
+    time_unit: TimeUnits = DefaultTimeUnit
+    name: str | None = None
+    info: str | None = None

ngio/tables/backends/_abstract_backend.py

@@ -210,7 +210,6 @@ class AbstractTableBackend(ABC):
         self,
         table_data: TabularData,
         metadata: dict | None = None,
-        mode: Literal["pandas", "anndata", "polars"] | None = None,
     ) -> None:
         """Serialize the table to the store, and write the metadata.
 
@@ -218,11 +217,11 @@ class AbstractTableBackend(ABC):
         Based on the explicit mode or the type of the table,
         it will call the appropriate write method.
         """
-        if mode == "pandas" or isinstance(table_data, DataFrame):
-            self.write_from_pandas(table_data)  # type: ignore[arg-type]
-        elif mode == "anndata" or isinstance(table_data, AnnData):
-            self.write_from_anndata(table_data)  # type: ignore[arg-type]
-        elif mode == "polars" or isinstance(table_data, PolarsDataFrame | LazyFrame):
+        if isinstance(table_data, DataFrame):
+            self.write_from_pandas(table_data)
+        elif isinstance(table_data, AnnData):
+            self.write_from_anndata(table_data)
+        elif isinstance(table_data, PolarsDataFrame | LazyFrame):
             self.write_from_polars(table_data)
         else:
             raise NgioValueError(

ngio/tables/backends/_anndata.py

@@ -58,7 +58,7 @@ class AnnDataBackend(AbstractTableBackend):
                 "Please make sure to use a compatible "
                 "store like a zarr.DirectoryStore."
             )
-        table.write_zarr(full_url)  # type: ignore
+        table.write_zarr(full_url)  # type: ignore (AnnData writer requires a str path)
 
     def write_from_pandas(self, table: DataFrame) -> None:
         """Serialize the table from a pandas DataFrame."""

ngio/tables/backends/_anndata_utils.py

@@ -17,11 +17,11 @@ from ngio.utils import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Collection
+    from collections.abc import Callable, Sequence
 
 
 def custom_anndata_read_zarr(
-    store: StoreOrGroup, elem_to_read: Collection[str] | None = None
+    store: StoreOrGroup, elem_to_read: Sequence[str] | None = None
 ) -> AnnData:
     """Read from a hierarchical Zarr array store.
 
@@ -31,7 +31,7 @@ def custom_anndata_read_zarr(
 
     Args:
         store (StoreOrGroup): A store or group to read the AnnData from.
-        elem_to_read (Collection[str] | None): The elements to read from the store.
+        elem_to_read (Sequence[str] | None): The elements to read from the store.
     """
     group = open_group_wrapper(store=store, mode="r")
 

ngio/tables/backends/_non_zarr_backends.py

@@ -80,7 +80,7 @@ class NonZarrBaseBackend(AbstractTableBackend):
         """Load the table from an FS store."""
         full_url = self._group_handler.full_url
         parquet_path = f"{full_url}/{self.table_name}"
-        store_fs = self._group_handler.store.fs  # type: ignore
+        store_fs = self._group_handler.store.fs  # type: ignore (in this context, store_fs is a fs.FSStore)
         with store_fs.open(parquet_path, "rb") as f:
             dataframe = reader(f)
         return dataframe

ngio/tables/backends/_table_backends.py

@@ -127,7 +127,6 @@ class TableBackendProtocol(Protocol):
         self,
         table_data: DataFrame | AnnData | PolarsDataFrame | LazyFrame,
         metadata: dict[str, str] | None = None,
-        mode: Literal["pandas", "anndata", "polars"] | None = None,
     ) -> None:
         """This is a generic write method.
 

ngio/tables/backends/_utils.py

@@ -126,10 +126,10 @@ def _check_for_mixed_types(series: pd.Series) -> None:
     Raises:
         NgioTableValidationError: If the column has mixed types.
     """
-    if series.apply(type).nunique() > 1:  # type: ignore
+    if series.apply(type).nunique() > 1:  # type: ignore (type lint fails here)
         raise NgioTableValidationError(
             f"Column {series.name} has mixed types: "
-            f"{series.apply(type).unique()}. "  # type: ignore
+            f"{series.apply(type).unique()}. "  # type: ignore (type lint fails here)
             "Type of all elements must be the same."
         )
 
@@ -186,7 +186,7 @@ def normalize_pandas_df(
     pandas_df = _validate_index_key_df(pandas_df, index_key)
     pandas_df = _validate_cast_index_dtype_df(pandas_df, index_type)
     if pandas_df.index.name is not None:
-        index_key = pandas_df.index.name
+        index_key = str(pandas_df.index.name)
 
     if reset_index and pandas_df.index.name is not None:
         pandas_df = pandas_df.reset_index()