ngio 0.4.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

ngio/tables/backends/_utils.py

@@ -403,7 +403,7 @@ def convert_anndata_to_pandas(
         DataFrame: Converted and normalized pandas DataFrame.
     """
     pandas_df = anndata.to_df()
-    pandas_df[anndata.obs_keys()] = anndata.obs
+    pandas_df[anndata.obs.columns.to_list()] = anndata.obs
     pandas_df = normalize_pandas_df(
         pandas_df,
         index_key=index_key,

ngio/tables/v1/_roi_table.py

@@ -4,6 +4,7 @@ This class follows the roi_table specification at:
 https://fractal-analytics-platform.github.io/fractal-tasks-core/tables/
 """
 
+import warnings
 from collections.abc import Iterable
 from typing import Literal
 from uuid import uuid4
@@ -26,7 +27,6 @@ from ngio.utils import (
     NgioTableValidationError,
     NgioValueError,
     ZarrGroupHandler,
-    ngio_warn,
 )
 
 REQUIRED_COLUMNS = [
@@ -77,7 +77,9 @@ OPTIONAL_COLUMNS = ORIGIN_COLUMNS + TRANSLATION_COLUMNS + PLATE_COLUMNS + INDEX_
 def _check_optional_columns(col_name: str) -> None:
     """Check if the column name is in the optional columns."""
     if col_name not in OPTIONAL_COLUMNS + TIME_COLUMNS:
-        ngio_warn(f"Column {col_name} is not in the optional columns.")
+        warnings.warn(
+            f"Column {col_name} is not in the optional columns.", stacklevel=2
+        )
 
 
 def _dataframe_to_rois(
@@ -120,17 +122,17 @@ def _dataframe_to_rois(
         else:
             label = getattr(row, "label", None)
 
-        roi = Roi(
+        slices = {
+            "x": (row.x_micrometer, row.len_x_micrometer),
+            "y": (row.y_micrometer, row.len_y_micrometer),
+            "z": (z_micrometer, z_length_micrometer),
+        }
+        if t_second is not None or t_length_second is not None:
+            slices["t"] = (t_second, t_length_second)
+        roi = Roi.from_values(
             name=str(row.Index),
-            x=row.x_micrometer,  # type: ignore (type can not be known here)
-            y=row.y_micrometer,  # type: ignore (type can not be known here)
-            z=z_micrometer,
-            t=t_second,
-            x_length=row.len_x_micrometer,  # type: ignore (type can not be known here)
-            y_length=row.len_y_micrometer,  # type: ignore (type can not be known here)
-            z_length=z_length_micrometer,
-            t_length=t_length_second,
-            unit="micrometer",
+            slices=slices,
+            space="world",
             label=label,
             **extras,
         )
@@ -143,24 +145,39 @@ def _rois_to_dataframe(rois: dict[str, Roi], index_key: str | None) -> pd.DataFr
     data = []
     for roi in rois.values():
         # This normalization is necessary for backward compatibility
-        z_micrometer = roi.z if roi.z is not None else 0.0
-        len_z_micrometer = roi.z_length if roi.z_length is not None else 1.0
+        if roi.space != "world":
+            raise NotImplementedError(
+                "Only ROIs in world coordinates can be serialized."
+            )
 
+        z_slice = roi.get("z")
+        if z_slice is None:
+            z_micrometer = 0.0
+            len_z_micrometer = 1.0
+        else:
+            z_micrometer = z_slice.start if z_slice.start is not None else 0.0
+            len_z_micrometer = z_slice.length if z_slice.length is not None else 1.0
+
+        x_slice = roi.get("x")
+        if x_slice is None:
+            raise NgioValueError("ROI is missing 'x' slice.")
+        y_slice = roi.get("y")
+        if y_slice is None:
+            raise NgioValueError("ROI is missing 'y' slice.")
         row = {
             index_key: roi.get_name(),
-            "x_micrometer": roi.x,
-            "y_micrometer": roi.y,
+            "x_micrometer": x_slice.start if x_slice.start is not None else 0.0,
+            "y_micrometer": y_slice.start if y_slice.start is not None else 0.0,
             "z_micrometer": z_micrometer,
-            "len_x_micrometer": roi.x_length,
-            "len_y_micrometer": roi.y_length,
+            "len_x_micrometer": x_slice.length if x_slice.length is not None else 1.0,
+            "len_y_micrometer": y_slice.length if y_slice.length is not None else 1.0,
             "len_z_micrometer": len_z_micrometer,
         }
 
-        if roi.t is not None:
-            row["t_second"] = roi.t
-
-        if roi.t_length is not None:
-            row["len_t_second"] = roi.t_length
+        t_slice = roi.get("t")
+        if t_slice is not None:
+            row["t_second"] = t_slice.start if t_slice.start is not None else 0.0
+            row["len_t_second"] = t_slice.length if t_slice.length is not None else 1.0
 
         if roi.label is not None and index_key != "label":
             row["label"] = roi.label
@@ -183,7 +200,7 @@ class RoiDictWrapper:
         self._rois_by_name = {}
         self._rois_by_label = {}
         for roi in rois:
-            name = roi.get_name()
+            name = roi.name
             if name in self._rois_by_name:
                 name = f"{name}_{uuid4().hex[:8]}"
             self._rois_by_name[name] = roi

ngio/utils/__init__.py

@@ -1,13 +1,12 @@
 """Various utilities for the ngio package."""
 
-import os
-
 from ngio.utils._datasets import (
     download_ome_zarr_dataset,
     list_ome_zarr_datasets,
     print_datasets_infos,
 )
 from ngio.utils._errors import (
+    NgioError,
     NgioFileExistsError,
     NgioFileNotFoundError,
     NgioTableValidationError,
@@ -15,35 +14,32 @@ from ngio.utils._errors import (
     NgioValueError,
 )
 from ngio.utils._fractal_fsspec_store import fractal_fsspec_store
-from ngio.utils._logger import ngio_logger, ngio_warn, set_logger_level
 from ngio.utils._zarr_utils import (
     AccessModeLiteral,
+    NgioCache,
+    NgioSupportedStore,
     StoreOrGroup,
     ZarrGroupHandler,
+    copy_group,
     open_group_wrapper,
 )
 
-set_logger_level(os.getenv("NGIO_LOGGER_LEVEL", "WARNING"))
-
 __all__ = [
-    # Zarr
     "AccessModeLiteral",
-    # Errors
+    "NgioCache",
+    "NgioError",
     "NgioFileExistsError",
     "NgioFileNotFoundError",
+    "NgioSupportedStore",
     "NgioTableValidationError",
     "NgioValidationError",
     "NgioValueError",
     "StoreOrGroup",
     "ZarrGroupHandler",
-    # Other
+    "copy_group",
     "download_ome_zarr_dataset",
     "fractal_fsspec_store",
     "list_ome_zarr_datasets",
-    # Logger
-    "ngio_logger",
-    "ngio_warn",
     "open_group_wrapper",
     "print_datasets_infos",
-    "set_logger_level",
 ]

ngio/utils/_cache.py

@@ -0,0 +1,48 @@
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class NgioCache(Generic[T]):
+    """A simple cache for NGIO objects."""
+
+    def __init__(self, use_cache: bool = True):
+        self._cache: dict[str, T] = {}
+        self._use_cache = use_cache
+
+    def _cache_sanity_check(self) -> None:
+        if len(self._cache) > 0:
+            raise RuntimeError(
+                "Cache is disabled, but cache contains items. "
+                "This indicates a logic error."
+            )
+
+    @property
+    def use_cache(self) -> bool:
+        return self._use_cache
+
+    @property
+    def cache(self) -> dict[str, T]:
+        return self._cache
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self._cache) == 0
+
+    def get(self, key: str, default: T | None = None) -> T | None:
+        if not self._use_cache:
+            self._cache_sanity_check()
+            return default
+        return self._cache.get(key, default)
+
+    def set(self, key: str, value: T, overwrite: bool = True) -> None:
+        if not self._use_cache:
+            self._cache_sanity_check()
+            return
+        self._cache[key] = value
+
+    def clear(self) -> None:
+        if not self._use_cache:
+            self._cache_sanity_check()
+            return
+        self._cache.clear()