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

ngio/tables/v1/_roi_table.py

@@ -4,7 +4,6 @@ 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
@@ -27,6 +26,7 @@ from ngio.utils import (
     NgioTableValidationError,
     NgioValueError,
     ZarrGroupHandler,
+    ngio_warn,
 )
 
 REQUIRED_COLUMNS = [
@@ -77,9 +77,7 @@ 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:
-        warnings.warn(
-            f"Column {col_name} is not in the optional columns.", stacklevel=2
-        )
+        ngio_warn(f"Column {col_name} is not in the optional columns.")
 
 
 def _dataframe_to_rois(
@@ -88,10 +86,10 @@ def _dataframe_to_rois(
 ) -> dict[str, Roi]:
     """Convert a DataFrame to a WorldCooROI object."""
     # Validate the columns of the DataFrame
-    _missing_columns = set(required_columns).difference(set(dataframe.columns))
-    if len(_missing_columns) != 0:
+    _required_columns = set(dataframe.columns).intersection(set(required_columns))
+    if len(_required_columns) != len(required_columns):
         raise NgioTableValidationError(
-            f"Could not find required columns: {_missing_columns} in the table."
+            f"Could not find required columns: {_required_columns} in the table."
         )
 
     extra_columns = set(dataframe.columns).difference(
@@ -122,17 +120,17 @@ def _dataframe_to_rois(
         else:
             label = getattr(row, "label", None)
 
-        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(
+        roi = Roi(
             name=str(row.Index),
-            slices=slices,
-            space="world",
+            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",
             label=label,
             **extras,
         )
@@ -145,39 +143,24 @@ 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
-        if roi.space != "world":
-            raise NotImplementedError(
-                "Only ROIs in world coordinates can be serialized."
-            )
+        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
 
-        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": 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,
+            "x_micrometer": roi.x,
+            "y_micrometer": roi.y,
             "z_micrometer": z_micrometer,
-            "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_x_micrometer": roi.x_length,
+            "len_y_micrometer": roi.y_length,
             "len_z_micrometer": len_z_micrometer,
         }
 
-        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.t is not None:
+            row["t_second"] = roi.t
+
+        if roi.t_length is not None:
+            row["len_t_second"] = roi.t_length
 
         if roi.label is not None and index_key != "label":
             row["label"] = roi.label
@@ -200,7 +183,7 @@ class RoiDictWrapper:
         self._rois_by_name = {}
         self._rois_by_label = {}
         for roi in rois:
-            name = roi.name
+            name = roi.get_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,12 +1,13 @@
 """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,
@@ -14,32 +15,35 @@ 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",
-    "NgioCache",
-    "NgioError",
+    # Errors
     "NgioFileExistsError",
     "NgioFileNotFoundError",
-    "NgioSupportedStore",
     "NgioTableValidationError",
     "NgioValidationError",
     "NgioValueError",
     "StoreOrGroup",
     "ZarrGroupHandler",
-    "copy_group",
+    # Other
     "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/_datasets.py

@@ -155,11 +155,5 @@ def download_ome_zarr_dataset(
         path=download_dir,
         processor=processor,
         progressbar=progressbar,
-        # Add User-Agent to avoid 403 errors from Zenodo
-        downloader=pooch.HTTPDownloader(
-            headers={
-                "User-Agent": f"pooch/{pooch.__version__} (https://github.com/BioVisionCenter/ngio)"
-            }
-        ),
     )
     return processor.output_file()

ngio/utils/_logger.py

@@ -0,0 +1,50 @@
+import logging
+import time
+from functools import cache
+
+from ngio.utils._errors import NgioValueError
+
+# Configure the logger
+ngio_logger = logging.getLogger("NgioLogger")
+ngio_logger.setLevel(logging.ERROR)
+
+# Set up a console handler with a custom format
+console_handler = logging.StreamHandler()
+formatter = logging.Formatter(
+    "%(asctime)s - %(levelname)s - %(name)s - "
+    "[%(module)s.%(funcName)s:%(lineno)d]: %(message)s"
+)
+console_handler.setFormatter(formatter)
+
+# Add the handler to the logger
+ngio_logger.addHandler(console_handler)
+
+
+def set_logger_level(level: str) -> None:
+    """Set the logger level.
+
+    Args:
+        level: The level to set the logger to.
+            Must be one of "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL".
+    """
+    if level not in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
+        raise NgioValueError(f"Invalid log level: {level}")
+
+    ngio_logger.setLevel(level)
+
+
+@cache
+def _warn(message: str, ttl_hash: int) -> None:
+    """Log a warning message with a time-to-live (TTL) hash."""
+    ngio_logger.warning(message, stacklevel=3)
+
+
+def ngio_warn(message: str, cooldown: int = 2) -> None:
+    """Log a warning message.
+
+    Args:
+        message: The warning message to log.
+        cooldown: The cooldown period in seconds to avoid repeated logging.
+    """
+    ttl_hash = time.time() // cooldown
+    _warn(message, ttl_hash)