pixel-patrol-loader-bio 0.1.0__tar.gz

pixel_patrol_loader_bio-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: pixel-patrol-loader-bio
+Version: 0.1.0
+Summary: PixelPatrol add-on package for loading images with bioio and zarr
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: bioio>=3.0.0
+Requires-Dist: bioio-tifffile>=1.3.0
+Requires-Dist: bioio-ome-tiff>=1.3.0
+Requires-Dist: bioio-ome-zarr>=2.2.0
+Requires-Dist: bioio-imageio==1.3.0
+Requires-Dist: pixel-patrol-base>=0.1.0
+Requires-Dist: zarr>=3.1.1
+Requires-Dist: tifffile==2025.9.9

pixel_patrol_loader_bio-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "pixel-patrol-loader-bio"
+version = "0.1.0"
+description = "PixelPatrol add-on package for loading images with bioio and zarr"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "bioio>=3.0.0",
+    "bioio-tifffile>=1.3.0",
+    "bioio-ome-tiff>=1.3.0",
+    "bioio-ome-zarr>=2.2.0",
+    "bioio-imageio==1.3.0",
+    "pixel-patrol-base>=0.1.0",
+    "zarr>=3.1.1",
+    "tifffile==2025.9.9",
+]
+
+[tool.uv]
+package = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pixel_patrol_loader_bio"]
+
+[project.entry-points."pixel_patrol.loader_plugins"]
+pixel_patrol_loader_bio_loader_builtins = "pixel_patrol_loader_bio.plugin_registry:register_loader_plugins"
+
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-mock>=3.14.1",
+]
+
+[tool.uv.sources]
+pixel-patrol-base = { path = "../pixel-patrol-base" }

pixel_patrol_loader_bio-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio/config.py

@@ -0,0 +1,2 @@
+# TODO: Isnt this a problem - same config file for both loaders?
+STANDARD_DIM_ORDER = "TCZYXS"

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio/plugin_registry.py

@@ -0,0 +1,8 @@
+from pixel_patrol_loader_bio.plugins.loaders.bioio_loader import BioIoLoader
+from pixel_patrol_loader_bio.plugins.loaders.zarr_loader import ZarrLoader
+
+def register_loader_plugins():
+    return [
+        BioIoLoader,
+        ZarrLoader,
+    ]

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio/plugins/loaders/_utils.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+import zarr
+
+def is_zarr_store(path: Path) -> bool:
+    """
+    Robustly checks if a given path is a Zarr store (v2 or v3).
+
+    This function uses the zarr library to attempt opening the store, which
+    correctly handles both Zarr v2 and v3 specifications.
+
+    Args:
+        path: The pathlib.Path object to check.
+
+    Returns:
+        True if the path is a valid Zarr store, False otherwise.
+    """
+    try:
+        store_obj = zarr.open(store=str(path.absolute()), mode='r')
+
+        if isinstance(store_obj, zarr.Group):
+            # A group is "processable" if it has any custom attributes.
+            # A generic container group will have empty attrs.
+            return bool(store_obj.attrs)
+
+        return True
+
+    except Exception as e:
+        # Catches any error, indicating it's not a valid or accessible Zarr store.
+        return False

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio/plugins/loaders/bioio_loader.py

@@ -0,0 +1,111 @@
+import logging
+import math
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+import bioio_imageio
+import numpy as np
+import polars as pl
+from bioio import BioImage
+from bioio_base.exceptions import UnsupportedFileFormatError
+
+from pixel_patrol_base.core.record import record_from
+from pixel_patrol_loader_bio.plugins.loaders._utils import is_zarr_store
+
+logger = logging.getLogger(__name__)
+
+
+def _extract_metadata(img: Any) -> Dict[str, Any]:
+    """
+    Extract metadata from a BioImage-like object into a flat dict.
+    """
+    metadata: Dict[str, Any] = {}
+
+    # Dim order and per-dimension sizes (e.g., X_size, Y_size, Z_size, C_size, T_size)
+    dim_order = getattr(getattr(img, 'dims', None), 'order', '')
+    metadata["dim_order"] = dim_order
+    for letter in dim_order:
+        dim_size= getattr(img.dims, letter, None)
+        if not dim_size:
+            dim_size = 1
+        metadata[f"{letter}_size"] = int(dim_size)
+
+    dim_names = getattr(getattr(img, 'dims', None), 'names', None)
+    if isinstance(dim_names, (list, tuple)) and all(isinstance(x, str) for x in dim_names):
+        metadata["dim_names"] = list(dim_names)
+
+    metadata["n_images"] = len(img.scenes) if hasattr(img, "scenes") else 1
+
+    if hasattr(img, "physical_pixel_sizes"):
+        for ax in ("X", "Y", "Z", "T"):
+            metadata[f"pixel_size_{ax}"] = getattr(img.physical_pixel_sizes, ax, None)
+
+    if hasattr(img, "channel_names"):
+        metadata["channel_names"] = img.channel_names
+
+    if hasattr(img, "dtype"):
+        metadata["dtype"] = str(img.dtype)
+
+    if hasattr(img, "shape"):
+        metadata["shape"] = np.array(img.shape)
+        metadata["ndim"] = len(img.shape)
+        metadata["num_pixels"] = math.prod(img.shape)
+
+    return metadata
+
+
+def _load_bioio_image(file_path: Path) -> Optional[BioImage]:
+    """
+    Try BioImage, then fall back to imageio reader; return None if both fail.
+    """
+    try:
+        return BioImage(file_path)
+    except UnsupportedFileFormatError:
+        try:
+            return BioImage(file_path, reader=bioio_imageio.Reader)
+        except Exception as e:
+            logger.warning(f"Could not load '{file_path}' with BioImage (imageio fallback): {e}")
+            return None
+    except Exception as e:
+        logger.warning(f"Could not load '{file_path}' with BioImage: {e}")
+        return None
+
+class BioIoLoader:
+    """
+    Loader that produces an record from BioIO/BioImage.
+    Protocol: single `load()` method returning an Record.
+    """
+
+    NAME = "bioio"
+
+    SUPPORTED_EXTENSIONS: Set[str] = {"czi", "tif", "tiff", "ome.tif", "nd2", "lif", "jpg", "jpeg", "png", "bmp", "ome.zarr"}
+
+    OUTPUT_SCHEMA: Dict[str, Any] = {
+        "dim_order": str,
+        "dim_names": list,
+        "n_images": int,
+        "num_pixels": int,
+        "shape": pl.Array,       # or use `list` if you prefer to avoid polars types here
+        "ndim": int,
+        "channel_names": list,   # could be list[str]
+        "dtype": str,
+    }
+
+    OUTPUT_SCHEMA_PATTERNS: List[tuple[str, Any]] = [
+        (r"^pixel_size_[A-Za-z]$", float),
+        (r"^[A-Za-z]_size$", int),
+    ]
+
+    FOLDER_EXTENSIONS: Set[str] = {"zarr", "ome.zarr"}
+
+    def is_folder_supported(self, path: Path) -> bool:
+        return is_zarr_store(path)
+
+    def load(self, source: str):
+        img = _load_bioio_image(Path(source))
+        if img is None:
+            raise UnsupportedFileFormatError(self.NAME, path=source)
+
+        meta = _extract_metadata(img)
+        # dask-backed array; Record encapsulates axes/capabilities from meta["dim_order"]
+        return record_from(img.dask_data, meta, kind="intensity")

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio/plugins/loaders/zarr_loader.py

@@ -0,0 +1,198 @@
+import logging
+import string
+from pathlib import Path
+from typing import Any, Dict, Optional, Set, List, Mapping
+
+import dask.array as da
+import numpy as np
+import zarr
+
+from pixel_patrol_base.core.record import record_from
+from pixel_patrol_loader_bio.plugins.loaders._utils import is_zarr_store
+
+logger = logging.getLogger(__name__)
+
+
+def _load_zarr_array(path: Path) -> Optional[da.Array]:
+    try:
+        # 1) Try as a direct array path
+        return da.from_zarr(str(path))
+    except Exception as e1:
+        try:
+            # 2) Try as a group with NGFF multiscales
+            root = zarr.open(str(path), mode="r")
+            candidates = []
+
+            if isinstance(root, zarr.Group):
+                attrs = dict(root.attrs)
+                # NGFF: multiscales[0].datasets[*].path  (often "0")
+                for d in attrs.get("multiscales", [{}])[0].get("datasets", []):
+                    p = d.get("path")
+                    if p:
+                        candidates.append(p)
+
+                # Common fallbacks
+                candidates += ["0", "data"]
+
+                # Single-array group: use that array’s name
+                if not candidates:
+                    arrays = list(root.arrays())
+                    if len(arrays) == 1:
+                        candidates.append(arrays[0][0])
+
+                for comp in candidates:
+                    try:
+                        return da.from_zarr(str(path), component=comp)
+                    except Exception:
+                        pass
+
+            # 4) Last resort: open with zarr and wrap with dask
+            arr = zarr.open_array(str(path), mode="r")
+            return da.from_array(arr, chunks=arr.chunks)
+        except Exception as e2:
+            logger.warning(
+                f"Could not load '{path}' as a Zarr array (tried as array/group): {e1}; {e2}"
+            )
+            return None
+
+
+def _infer_dim_order(n: int) -> str:
+    """
+    Infer a simple dim order assuming the last two dims are YX.
+    Preceding dims are assigned A,B,C,... in order.
+    """
+    if n <= 2:
+        return "YX"[-n:]  # n==0 -> "", n==1 -> "X", n==2 -> "YX"
+    return string.ascii_uppercase[: n - 2] + "YX"
+
+
+def _read_zarr_root_and_primary_attrs(path: Path) -> Dict[str, Any]:
+    """
+    Read merged attributes from the Zarr root AND the primary child array
+    (first of "0" or "data" if present). Returns a flat dict.
+    """
+    attrs: Dict[str, Any] = {}
+    try:
+        root = zarr.open(str(path), mode="r")
+        attrs.update(dict(getattr(root, "attrs", {}) or {}))
+        try:
+            if hasattr(root, "arrays"):
+                for name, item in root.arrays():
+                    if name in ("data", "0"):
+                        attrs.update(dict(getattr(item, "attrs", {}) or {}))
+                        break
+        except Exception:
+            pass
+    except Exception as e:
+        logger.warning(f"Could not read Zarr attributes from '{path}': {e}")
+    return attrs
+
+
+def _extract_ngff_dim_names(attrs: Mapping[str, Any], ndim: int) -> Optional[List[str]]:
+    """
+    Parse OME-NGFF axes from attrs -> return dim_names if available
+    """
+    if not isinstance(attrs, dict):
+        return None
+
+    ms = attrs.get("multiscales")
+    if not (isinstance(ms, list) and ms):
+        return None
+
+    first = ms[0]
+    if not isinstance(first, dict):
+        return None
+
+    axes = first.get("axes")
+    if not isinstance(axes, list):
+        return None
+
+    if len(axes) != int(ndim):
+        logger.warning("NGFF: axes length (%s) != array ndim (%s); ignoring axes", len(axes), ndim)
+        return None
+
+    names: List[str] = []
+    for a in axes:
+        if isinstance(a, str):
+            n = a
+        elif isinstance(a, dict) and isinstance(a.get("name"), str):
+            n = a["name"]
+        else:
+            logger.warning("NGFF: malformed axis entry %r; ignoring axes", a)
+            return None
+        names.append(n)
+
+    return names
+
+
+def _extract_zarr_metadata(arr: da.Array, path: Path) -> Dict[str, Any]:
+    meta: Dict[str, Any] = {}
+    ndim = int(getattr(arr, "ndim", len(getattr(arr, "shape", []) or [])))
+
+    attrs = _read_zarr_root_and_primary_attrs(path)
+    if attrs:
+        meta["zarr_attributes"] = attrs
+
+    dim_names = _extract_ngff_dim_names(attrs, ndim)
+
+    if dim_names and all(isinstance(n, str) and len(n) == 1 for n in dim_names):
+        dim_order = "".join(n.upper() for n in dim_names)
+    else:
+        dim_order = _infer_dim_order(ndim)
+
+    if not dim_names:
+        dim_names = [f"dim{c}" for c in dim_order]
+
+    meta["dim_order"] = dim_order
+    meta["dim_names"] = dim_names
+
+    meta["shape"] = np.array(arr.shape, dtype=int)
+    meta["dtype"] = str(arr.dtype)
+    meta["ndim"] = arr.ndim
+    meta["num_pixels"] = int(np.prod(arr.shape))
+    chunks = getattr(arr, "chunksize", None)
+    meta["chunks"] = chunks if chunks is not None else arr.chunks
+
+    for i, ax in enumerate(dim_order):
+        meta[f"{ax}_size"] = int(arr.shape[i])
+
+    return meta
+
+
+class ZarrLoader:
+    """
+    Loader that produces an Record from Zarr.
+    Protocol: single `load()` returning an Record.
+    """
+
+    NAME = "zarr"
+
+    SUPPORTED_EXTENSIONS: Set[str] = {"zarr"}
+
+    OUTPUT_SCHEMA: Dict[str, Any] = {
+        "dim_order": str,
+        "dim_names": list,
+        "n_images": int,
+        "channel_names": list,
+        "dtype": str,
+        "zarr_attributes": dict,
+    }
+
+    OUTPUT_SCHEMA_PATTERNS = [
+        (r"^[A-Za-z]_size$", int),
+    ]
+
+    FOLDER_EXTENSIONS: Set[str] = {"zarr", "ome.zarr"}
+
+    def is_folder_supported(self, path: Path) -> bool:
+        return is_zarr_store(path)
+
+    def load(self, source: str):
+        path = Path(source)
+
+        arr = _load_zarr_array(path)
+        if arr is None:
+            raise RuntimeError(f"Cannot read Zarr array at: {source}")
+
+        meta = _extract_zarr_metadata(arr, path)
+        return record_from(arr, meta, kind="intensity")

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: pixel-patrol-loader-bio
+Version: 0.1.0
+Summary: PixelPatrol add-on package for loading images with bioio and zarr
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: bioio>=3.0.0
+Requires-Dist: bioio-tifffile>=1.3.0
+Requires-Dist: bioio-ome-tiff>=1.3.0
+Requires-Dist: bioio-ome-zarr>=2.2.0
+Requires-Dist: bioio-imageio==1.3.0
+Requires-Dist: pixel-patrol-base>=0.1.0
+Requires-Dist: zarr>=3.1.1
+Requires-Dist: tifffile==2025.9.9

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+pyproject.toml
+src/pixel_patrol_loader_bio/config.py
+src/pixel_patrol_loader_bio/plugin_registry.py
+src/pixel_patrol_loader_bio.egg-info/PKG-INFO
+src/pixel_patrol_loader_bio.egg-info/SOURCES.txt
+src/pixel_patrol_loader_bio.egg-info/dependency_links.txt
+src/pixel_patrol_loader_bio.egg-info/entry_points.txt
+src/pixel_patrol_loader_bio.egg-info/requires.txt
+src/pixel_patrol_loader_bio.egg-info/top_level.txt
+src/pixel_patrol_loader_bio/plugins/loaders/_utils.py
+src/pixel_patrol_loader_bio/plugins/loaders/bioio_loader.py
+src/pixel_patrol_loader_bio/plugins/loaders/zarr_loader.py
+tests/test_bioio_import.py
+tests/test_project_settings.py
+tests/test_records_df.py
+tests/test_zarr_image.py

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pixel_patrol.loader_plugins]
+pixel_patrol_loader_bio_loader_builtins = pixel_patrol_loader_bio.plugin_registry:register_loader_plugins

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio.egg-info/requires.txt

@@ -0,0 +1,8 @@
+bioio>=3.0.0
+bioio-tifffile>=1.3.0
+bioio-ome-tiff>=1.3.0
+bioio-ome-zarr>=2.2.0
+bioio-imageio==1.3.0
+pixel-patrol-base>=0.1.0
+zarr>=3.1.1
+tifffile==2025.9.9

pixel_patrol_loader_bio-0.1.0/src/pixel_patrol_loader_bio.egg-info/top_level.txt

@@ -0,0 +1 @@
+pixel_patrol_loader_bio

pixel_patrol_loader_bio-0.1.0/tests/test_bioio_import.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+from typing import Dict, Any
+
+import numpy as np
+import pytest
+
+from pixel_patrol_loader_bio.config import STANDARD_DIM_ORDER
+from pixel_patrol_loader_bio.plugins.loaders.bioio_loader import BioIoLoader
+from pixel_patrol_base.config import SPRITE_SIZE
+from pixel_patrol_base.core.processing import get_all_record_properties
+from pixel_patrol_base.plugin_registry import discover_processor_plugins
+
+
+@pytest.fixture(scope="module")
+def loader():
+    return BioIoLoader()
+
+@pytest.fixture(scope="module")
+def processors():
+    return discover_processor_plugins()
+
+@pytest.fixture(scope="module")
+def standard_dim_order():
+    return STANDARD_DIM_ORDER
+
+
+def get_image_files_from_data_dir(test_data_dir: Path):
+    """Helper to get all image files from the test_data_dir, excluding non-image files."""
+    return [f for f in test_data_dir.rglob("*")
+            if f.is_file() and f.name != "not_an_image.txt"]
+
+
+def test_nonexistent_path_raises(tmp_path, loader, processors):
+    missing = tmp_path / "nope.tiny_png"
+    assert get_all_record_properties(missing, loader=loader, processors=processors) == {}
+
+
+def test_unsupported_file(test_data_dir: Path, loader, processors):
+    non_image_file = test_data_dir / "not_an_image.txt"
+    properties = get_all_record_properties(non_image_file, loader=loader, processors=processors)
+    assert properties == {}, f"Expected empty dict for non-image file, got {properties}"
+
+
+def test_empty_or_corrupt_image(tmp_path, loader, processors):
+    f = tmp_path / "zero.tif"
+    f.write_bytes(b"")
+    assert get_all_record_properties(f, loader=loader, processors=processors) == {}
+
+
+def test_bioio_image_properties_per_file(
+    image_file_path: Path,
+    loader, processors,
+    standard_dim_order: str,
+    expected_image_data: Dict[str, Dict[str, Any]]
+):
+    """
+    Detailed metadata checks for files that have expectations in `expected_image_data`,
+    and general sanity checks for all other files.
+    """
+    file_name = image_file_path.name
+    actual_properties = get_all_record_properties(image_file_path, loader=loader, processors=processors)
+
+    assert actual_properties is not None, f"Failed to get properties for {file_name}"
+    assert actual_properties != {}, f"Properties dictionary is empty for {file_name}"
+
+    # Always enforce core presence
+    assert "shape" in actual_properties, f"Missing 'shape' for {file_name}"
+    assert "dtype" in actual_properties, f"Missing 'dtype' for {file_name}"
+    assert "ndim" in actual_properties, f"Missing 'ndim' for {file_name}"
+
+    # If we have expectations for this file, check them specifically.
+    expected = expected_image_data.get(file_name)
+    if expected:
+        if "dtype" in expected:
+            assert expected["dtype"] in str(actual_properties["dtype"]), \
+                f"Dtype mismatch for {file_name}: expected contains {expected['dtype']}, got {actual_properties['dtype']}"
+        if "min_ndim" in expected:
+            assert actual_properties["ndim"] >= expected["min_ndim"], \
+                f"ndim too small for {file_name}: expected >= {expected['min_ndim']}, got {actual_properties['ndim']}"
+
+
+def test_all_image_files_load_and_standardize(
+    image_file_path: Path,
+    loader, processors,
+    standard_dim_order: str
+):
+    """
+    Ensure all image files can be loaded by bioio, standardized, and a thumbnail generated.
+    """
+    file_name = image_file_path.name
+    properties = get_all_record_properties(image_file_path, loader=loader, processors=processors)
+
+    assert properties is not None, f"Failed to get properties for {file_name}"
+    assert properties != {}, f"Properties dictionary is empty for {file_name}"
+
+    assert "dim_order" in properties, f"Missing dim_order for {file_name}"
+    assert "thumbnail" in properties, f"Missing thumbnail for {file_name}"
+    assert isinstance(properties["thumbnail"], np.ndarray), f"Thumbnail not a numpy array for {file_name}"
+    assert properties["thumbnail"].shape == (SPRITE_SIZE, SPRITE_SIZE), \
+        f"Thumbnail size mismatch for {file_name}: Expected ({SPRITE_SIZE}, {SPRITE_SIZE}), Got {properties['thumbnail'].shape}"
+
+    assert "shape" in properties, f"Missing shape for {file_name}"
+    assert "dtype" in properties, f"Missing dtype for {file_name}"
+    assert "ndim" in properties, f"Missing ndim for {file_name}"

pixel_patrol_loader_bio-0.1.0/tests/test_project_settings.py

@@ -0,0 +1,211 @@
+import pytest
+import logging
+from pathlib import Path
+
+from pixel_patrol_loader_bio.plugins.loaders.bioio_loader import BioIoLoader
+from pixel_patrol_base.core.project import Project
+from pixel_patrol_base.core.project_settings import Settings
+from pixel_patrol_base import api
+
+logging.basicConfig(level=logging.INFO)
+
+
+@pytest.fixture
+def named_project_with_base_dir(tmp_path: Path) -> Project:
+    """Provides a Project instance with a base directory set."""
+    return api.create_project("TestProject", tmp_path, loader="bioio")
+
+
+def test_get_settings_initial(named_project_with_base_dir: Project):
+    """Test retrieving default settings from a newly created project."""
+    settings = api.get_settings(named_project_with_base_dir)
+    assert isinstance(settings, Settings)
+    assert settings.cmap == "rainbow"
+    assert settings.n_example_files == 9
+    assert settings.selected_file_extensions == set()
+
+
+def test_set_settings_valid(named_project_with_base_dir: Project):
+    """Test setting and retrieving valid new settings."""
+    new_settings = Settings(cmap="viridis", n_example_files=5, selected_file_extensions={"jpg", "png"})
+    updated_project = api.set_settings(named_project_with_base_dir, new_settings)
+    retrieved_settings = api.get_settings(updated_project)
+    assert retrieved_settings.cmap == "viridis"
+    assert retrieved_settings.n_example_files == 5
+    assert retrieved_settings.selected_file_extensions == {"jpg", "png"}
+
+
+def test_set_settings_invalid_cmap(named_project_with_base_dir: Project):
+    """Test setting settings with an invalid colormap name."""
+    invalid_settings = Settings(cmap="non_existent_cmap")
+    with pytest.raises(ValueError, match="Invalid colormap name"):
+        api.set_settings(named_project_with_base_dir, invalid_settings)
+
+
+def test_set_settings_invalid_n_example_images(named_project_with_base_dir: Project):
+    """Test setting n_example_images with invalid values (too low, too high, wrong type)."""
+    invalid_settings_low = Settings(n_example_files=0)
+    with pytest.raises(ValueError, match="Number of example files must be an integer between 1 and 19"):
+        api.set_settings(named_project_with_base_dir, invalid_settings_low)
+
+    invalid_settings_high = Settings(n_example_files=20)
+    with pytest.raises(ValueError, match="Number of example files must be an integer between 1 and 19"):
+        api.set_settings(named_project_with_base_dir, invalid_settings_high)
+
+    invalid_settings_type = Settings(n_example_files=9.5)
+    with pytest.raises(ValueError, match="Number of example files must be an integer between 1 and 19"):
+        api.set_settings(named_project_with_base_dir, invalid_settings_type)
+
+
+def test_set_settings_set_selected_file_extensions_empty_initially(named_project_with_base_dir: Project, caplog):
+    """Test that selected file extensions can be set to an empty set initially."""
+    new_settings = Settings(selected_file_extensions=set())
+    with caplog.at_level(logging.WARNING):
+        updated_project = api.set_settings(named_project_with_base_dir, new_settings)
+        assert api.get_settings(updated_project).selected_file_extensions == set()
+        assert "selected_file_extensions is an empty set - no file will be processed" in caplog.text
+
+
+def test_set_settings_set_selected_file_extensions_with_unsupported(named_project_with_base_dir: Project, caplog):
+    """Test setting extensions including unsupported types."""
+    mixed_extensions = {"jpg", "xyz", "tiff"}  # jpg, tiff are supported, xyz is not
+    expected_extensions = {"jpg", "tiff"}
+    with caplog.at_level(logging.WARNING):
+        new_settings = Settings(selected_file_extensions=mixed_extensions)
+        updated_project = api.set_settings(named_project_with_base_dir, new_settings)
+        assert api.get_settings(updated_project).selected_file_extensions == expected_extensions
+        assert "The following file extensions are not supported and will be ignored: xyz." in caplog.text
+
+
+def test_set_settings_set_selected_file_extensions_only_unsupported(named_project_with_base_dir: Project, caplog):
+    """Test setting extensions with only unsupported types results in empty set."""
+    unsupported_extensions = {"xyz", "abc"}
+    with caplog.at_level(logging.WARNING):
+        new_settings = Settings(selected_file_extensions=unsupported_extensions)
+        updated_project = api.set_settings(named_project_with_base_dir, new_settings)
+        assert api.get_settings(updated_project).selected_file_extensions == set()
+        assert "The following file extensions are not supported and will be ignored:" in caplog.text
+        assert "abc" in caplog.text
+        assert "xyz" in caplog.text
+        assert "No loader supported file extensions provided. No files will be processed." in caplog.text
+
+def test_set_settings_set_selected_file_extensions_to_all(named_project_with_base_dir: Project, caplog):
+    """Test setting selected_file_extensions to the string 'all'."""
+    new_settings = Settings(selected_file_extensions="all")
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(named_project_with_base_dir, new_settings)
+        assert api.get_settings(updated_project).selected_file_extensions == BioIoLoader.SUPPORTED_EXTENSIONS
+        assert "Using loader-supported extensions:" in caplog.text
+
+
+def test_set_settings_invalid_string_for_extensions(named_project_with_base_dir: Project, caplog):
+    """Test setting selected_file_extensions to an invalid string (not 'all')."""
+    invalid_settings = Settings(selected_file_extensions="invalid_string")
+    with pytest.raises(TypeError, match=r"selected_file_extensions must be 'all' or a Set\[str\]\."):
+        with caplog.at_level(logging.ERROR):
+            api.set_settings(named_project_with_base_dir, invalid_settings)
+            assert "Invalid type for selected_file_extensions: <class 'str'>." in caplog.text
+
+
+def test_set_settings_invalid_type_for_extensions(named_project_with_base_dir: Project, caplog):
+    """Test setting selected_file_extensions to an invalid type."""
+    invalid_settings = Settings(selected_file_extensions=["jpg", "png"])  # List instead of Set
+    with pytest.raises(TypeError, match=r"selected_file_extensions must be 'all' or a Set\[str\]\."):
+        with caplog.at_level(logging.ERROR):
+            api.set_settings(named_project_with_base_dir, invalid_settings)
+            assert "Invalid type for selected_file_extensions: <class 'list'>." in caplog.text
+
+
+def test_set_settings_change_selected_file_extensions_after_initial_set_different_set(
+        named_project_with_base_dir: Project, caplog):
+    initial_settings = Settings(selected_file_extensions={"jpg"})
+    project_with_ext = api.set_settings(named_project_with_base_dir, initial_settings)
+    assert api.get_settings(project_with_ext).selected_file_extensions == {"jpg"}
+
+    changed_settings = Settings(selected_file_extensions={"png"})
+
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(project_with_ext, changed_settings)
+        assert "selected_file_extensions already set; keeping existing value:" in caplog.text
+
+    assert api.get_settings(updated_project).selected_file_extensions == {"jpg"}
+
+
+def test_set_settings_change_selected_file_extensions_after_initial_set_to_empty(named_project_with_base_dir: Project,
+                                                                                 caplog):
+    initial_settings = Settings(selected_file_extensions={"jpg"})
+    project_with_ext = api.set_settings(named_project_with_base_dir, initial_settings)
+    assert api.get_settings(project_with_ext).selected_file_extensions == {"jpg"}
+
+    changed_settings = Settings(selected_file_extensions=set())
+
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(project_with_ext, changed_settings)
+        assert "selected_file_extensions already set; keeping existing value:" in caplog.text
+
+    assert api.get_settings(updated_project).selected_file_extensions == {"jpg"}
+
+
+def test_set_settings_change_selected_file_extensions_from_all_to_set(named_project_with_base_dir: Project, caplog):
+    initial_settings = Settings(selected_file_extensions="all")
+    project_with_ext = api.set_settings(named_project_with_base_dir, initial_settings)
+    assert api.get_settings(project_with_ext).selected_file_extensions == BioIoLoader.SUPPORTED_EXTENSIONS
+
+    changed_settings = Settings(selected_file_extensions={"jpg"})
+
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(project_with_ext, changed_settings)
+        # INFO message asserted in other tests; keeping behavior consistent.
+
+
+def test_set_settings_change_selected_file_extensions_from_set_to_all(named_project_with_base_dir: Project, caplog):
+    initial_settings = Settings(selected_file_extensions={"jpg"})
+    project_with_ext = api.set_settings(named_project_with_base_dir, initial_settings)
+    assert api.get_settings(project_with_ext).selected_file_extensions == {"jpg"}
+
+    changed_settings = Settings(selected_file_extensions="all")
+
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(project_with_ext, changed_settings)
+        assert "selected_file_extensions already set; keeping existing value:" in caplog.text
+
+    assert api.get_settings(updated_project).selected_file_extensions == {"jpg"}
+
+
+def test_set_settings_set_selected_file_extensions_to_same_set_already_defined(named_project_with_base_dir: Project,
+                                                                               caplog):
+    initial_settings = Settings(selected_file_extensions={"jpg"})
+    project_with_ext = api.set_settings(named_project_with_base_dir, initial_settings)
+    assert api.get_settings(project_with_ext).selected_file_extensions == {"jpg"}
+
+    same_settings = Settings(selected_file_extensions={"jpg"})
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(project_with_ext, same_settings)
+        assert api.get_settings(updated_project).selected_file_extensions == {"jpg"}
+        assert "selected_file_extensions already set; keeping existing value:" in caplog.text
+
+
+def test_set_settings_set_selected_file_extensions_to_all_when_already_default_set(named_project_with_base_dir: Project,
+                                                                                   caplog):
+    initial_settings = Settings(selected_file_extensions=BioIoLoader.SUPPORTED_EXTENSIONS)
+    project_with_ext = api.set_settings(named_project_with_base_dir, initial_settings)
+    assert api.get_settings(project_with_ext).selected_file_extensions == BioIoLoader.SUPPORTED_EXTENSIONS
+
+    new_settings = Settings(selected_file_extensions="all")
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(project_with_ext, new_settings)
+        assert api.get_settings(updated_project).selected_file_extensions == BioIoLoader.SUPPORTED_EXTENSIONS
+        assert "selected_file_extensions already set; keeping existing value:" in caplog.text
+
+
+def test_set_settings_set_selected_file_extensions_to_default_set_when_already_all_string(
+        named_project_with_base_dir: Project, caplog):
+    initial_settings = Settings(selected_file_extensions="all")
+    project_with_ext = api.set_settings(named_project_with_base_dir, initial_settings)
+    assert api.get_settings(project_with_ext).selected_file_extensions == BioIoLoader.SUPPORTED_EXTENSIONS
+
+    same_as_default_set_settings = Settings(selected_file_extensions=BioIoLoader.SUPPORTED_EXTENSIONS)
+    with caplog.at_level(logging.INFO):
+        updated_project = api.set_settings(project_with_ext, same_as_default_set_settings)
+        assert api.get_settings(updated_project).selected_file_extensions == BioIoLoader.SUPPORTED_EXTENSIONS
+        assert "selected_file_extensions already set; keeping existing value:" in caplog.text

pixel_patrol_loader_bio-0.1.0/tests/test_records_df.py

@@ -0,0 +1,392 @@
+from datetime import datetime
+from pathlib import Path
+from unittest.mock import patch
+
+import numpy as np
+import polars as pl
+import pytest
+import tifffile
+from PIL import Image
+
+from pixel_patrol_loader_bio.config import STANDARD_DIM_ORDER
+from pixel_patrol_loader_bio.plugins.loaders.bioio_loader import BioIoLoader
+from pixel_patrol_base.core import processing
+from pixel_patrol_base.core.processing import (
+    build_records_df,
+    _scan_dirs_for_extensions,
+    _build_deep_record_df,
+    PATHS_DF_EXPECTED_SCHEMA,
+)
+from pixel_patrol_base.plugin_registry import discover_processor_plugins
+from pixel_patrol_base.utils.df_utils import postprocess_basic_file_metadata_df
+
+@pytest.fixture
+def loader():
+    """Provides a fresh BioIoLoader for each test function."""
+    return BioIoLoader()
+
+@pytest.fixture
+def processors():
+    """Provides a fresh list of processor plugins for each test function."""
+    return discover_processor_plugins()
+
+
+def test_build_records_df_from_file_system_no_images(tmp_path):
+    non_image_dir = tmp_path / "non_image_files"
+    non_image_dir.mkdir()
+    (non_image_dir / "document.txt").write_text("This is a text file.")
+    (non_image_dir / "data.csv").write_text("1,2,3\n4,5,6")
+
+    paths = [non_image_dir]
+    extensions = {"png", "jpg"}
+
+    with patch('pixel_patrol_base.core.processing._build_deep_record_df', return_value=pl.DataFrame()) as mock_get_deep_records_df:
+        records_df = build_records_df(paths, extensions, "bioio")
+        assert records_df is None
+        mock_get_deep_records_df.assert_not_called()
+
+
+def test_scan_dirs_for_extensions_filters_correct_extensions(tmp_path):
+    dir1 = tmp_path / "dir1"; dir1.mkdir()
+    dir2 = tmp_path / "dir2"; dir2.mkdir()
+    (dir1 / "a.jpg").write_bytes(b"")
+    (dir1 / "b.png").write_bytes(b"")
+    (dir1 / "c.txt").write_bytes(b"")
+    (dir2 / "d.JPG").write_bytes(b"")
+    result = _scan_dirs_for_extensions([dir1, dir2], {"jpg", "png"})
+    expected = {
+        (dir1 / "a.jpg", dir1),
+        (dir1 / "b.png", dir1),
+        (dir2 / "d.JPG", dir2),
+    }
+    assert set(result) == expected
+
+def test_scan_dirs_for_extensions_handles_empty_directory_list():
+    result = _scan_dirs_for_extensions([], {"jpg", "png"})
+    assert result == []
+
+
+def test_build_deep_record_df_returns_dataframe_with_required_columns(tmp_path, monkeypatch, loader):
+    p1 = tmp_path / "img1.jpg"; p1.write_bytes(b"")
+    p2 = tmp_path / "img2.png"; p2.write_bytes(b"")
+    paths = [p1, p2]
+
+    def fake_get_all_record_properties(_path, loader, processors):
+        assert loader.NAME == "bioio"
+        return {"width": 100, "height": 200}
+
+    monkeypatch.setattr("pixel_patrol_base.core.processing.get_all_record_properties",
+                        fake_get_all_record_properties)
+
+    df = _build_deep_record_df(paths, loader)
+
+    assert isinstance(df, pl.DataFrame)
+    assert set(df.columns) == {"path", "width", "height"}
+    assert df.height == 2
+    assert df["width"].to_list() == [100, 100]
+    assert df["height"].to_list() == [200, 200]
+
+
+def test_get_all_image_properties_returns_empty_for_nonexistent_file(tmp_path, loader, processors):
+    missing = tmp_path / "no.png"
+    assert processing.get_all_record_properties(missing, loader=loader, processors=processors) == {}
+
+
+def test_get_all_image_properties_returns_empty_if_loading_fails(tmp_path, monkeypatch, loader, processors):
+    img_file = tmp_path / "img.jpg"
+    img_file.write_bytes(b"not really an image")
+    monkeypatch.setattr("pixel_patrol_loader_bio.plugins.loaders.bioio_loader._load_bioio_image", lambda p: None)
+    assert processing.get_all_record_properties(img_file, loader=loader, processors=processors) == {}
+
+class DummyImg:
+    # Mocks the 'dims' object required by bioio_loader
+    dims = type("D", (), {"order": STANDARD_DIM_ORDER})()
+
+    # Properties required by the loader to determine array properties
+    shape = tuple(
+        2 if d in ("Y", "X") else 1
+        for d in STANDARD_DIM_ORDER
+    )
+
+    # FIXED: dask_data must be a NumPy array with the correct shape/ndim, not None.
+    # This prevents _validate_and_fix_meta from incorrectly setting ndim to 0.
+    dask_data = np.zeros(shape, dtype=np.uint8)
+
+    # Other metadata properties used by the loader
+    channel_names = ["ch1", "ch2"]
+    ome_metadata = {}
+
+    physical_pixel_sizes = type(
+        "P",
+        (),
+        {"X": 0.5, "Y": 0.75, "Z": 1.0, "T": 1.0}
+    )()
+
+    # Mock methods required by the bioio_loader logic
+    def get_image_data(self):
+        # Return the actual array data
+        return np.asarray(self.dask_data)
+
+    def get_channel_names(self):
+        return self.channel_names
+
+    def get_physical_pixel_sizes(self):
+        # Mocks the method for other tests, uses the new attribute values
+        sizes = self.physical_pixel_sizes
+        return {'X': sizes.X, 'Y': sizes.Y, 'Z': sizes.Z, 'T': sizes.T}
+
+    def get_image_metadata(self):
+        return self.ome_metadata
+
+
+def test_get_all_image_properties_extracts_standard_and_requested_metadata(tmp_path, monkeypatch, loader, processors):
+    img_file = tmp_path / "img.png"
+    img_file.write_bytes(b"")
+
+    monkeypatch.setattr(
+        "pixel_patrol_loader_bio.plugins.loaders.bioio_loader._load_bioio_image",
+        lambda p: DummyImg()
+    )
+    props = processing.get_all_record_properties(
+        img_file, loader=loader, processors=[]
+    )
+    expected_shape = [
+        2 if d in ("Y", "X") else 1
+        for d in STANDARD_DIM_ORDER]
+
+    assert props["shape"] == expected_shape
+    assert props["ndim"] == len(STANDARD_DIM_ORDER)
+
+    assert props["pixel_size_X"] == 0.5
+    assert props["channel_names"] == ["ch1", "ch2"]
+
+
+def test_get_deep_image_df_ignores_paths_with_no_metadata(tmp_path, monkeypatch, loader, processors):
+    p_valid = tmp_path / "valid.jpg"; p_valid.write_bytes(b"")
+    p_invalid = tmp_path / "invalid.png"; p_invalid.write_bytes(b"")
+
+    def fake_get_all_image_properties(path, _loader, _processors):
+        return {"width": 10, "height": 20} if path == p_valid else {}
+
+    monkeypatch.setattr(
+        "pixel_patrol_base.core.processing.get_all_record_properties",
+        fake_get_all_image_properties
+    )
+
+    df = _build_deep_record_df([p_valid, p_invalid], loader_instance=loader)
+
+    assert isinstance(df, pl.DataFrame)
+    assert df.height == 1
+    assert df["path"].to_list() == [str(p_valid)]
+    assert df["width"].to_list() == [10]
+    assert df["height"].to_list() == [20]
+
+
+def test_build_records_df_from_file_system_with_images_returns_expected_columns_and_values(tmp_path, monkeypatch):
+
+    base = tmp_path / "root"
+    base.mkdir()
+    img1 = base / "graphic.png"; img1.write_text("dummy")
+    img2 = base / "photo1.jpg";  img2.write_text("dummy")
+    (base / "notes.txt").write_text("not an image")
+
+    expected_paths = [str(img1), str(img2)]
+
+    deep_df = pl.DataFrame({
+        "path": expected_paths,
+        "width": [64, 128],
+        "height": [48, 256],
+    })
+    monkeypatch.setattr(
+        "pixel_patrol_base.core.processing._build_deep_record_df",
+        lambda paths, cols: deep_df
+    )
+
+    result = build_records_df(
+        bases=[base],
+        selected_extensions={"jpg", "png"},
+        loader="bioio"
+    )
+
+    assert result is not None
+
+    expected_cols = set(PATHS_DF_EXPECTED_SCHEMA.keys()) | {"width", "height"}
+    assert expected_cols.issubset(set(result.columns))
+
+    assert set(result["path"].to_list()) == set(expected_paths)
+
+    result_dict = {
+        row["path"]: (row["width"], row["height"]) for row in result.iter_rows(named=True)
+    }
+    expected_dict = dict(zip(expected_paths, zip([64, 128], [48, 256])))
+    assert result_dict == expected_dict
+
+def test_build_records_df_from_file_system_merges_basic_and_deep_metadata_correctly(tmp_path, monkeypatch):
+
+    base = tmp_path / "root"
+    base.mkdir()
+    img1 = base / "one.jpg";  img1.write_text("x")
+    img2 = base / "two.png";  img2.write_text("y")
+
+    deep_df = pl.DataFrame({
+        "path": [str(img1), str(img2)],
+        "width": [10, 20],
+        "height": [15, 25],
+    })
+    monkeypatch.setattr(
+        "pixel_patrol_base.core.processing._build_deep_record_df",
+        lambda paths, cols: deep_df
+    )
+
+    result = build_records_df(
+        bases=[base],
+        selected_extensions={"jpg", "png"},
+        loader="bioio"
+    )
+
+    expected_cols = set(PATHS_DF_EXPECTED_SCHEMA.keys()) | {"width", "height"}
+    assert expected_cols.issubset(set(result.columns))
+
+    df = result.sort("path")
+    assert df["path"].to_list() == [str(img1), str(img2)]
+    assert df["width"].to_list() == [10, 20]
+    assert df["height"].to_list() == [15, 25]
+
+
+def test_postprocess_basic_file_metadata_df_adds_modification_month_and_imported_path_short(tmp_path):
+    from pathlib import Path
+    base = tmp_path
+    df = pl.DataFrame({
+        "path": [str(base / "sub" / "a.txt"), str(base / "sub" / "b.txt")],
+        "name": ["a.txt", "b.txt"],
+        "type": ["file", "file"],
+        "parent": [str(base / "sub"), str(base / "sub")],
+        "depth": [2, 2],
+        "size_bytes": [1024, 2048],
+        "modification_date": [
+            datetime(2025, 3, 15, 12, 0),
+            datetime(2025, 7, 1, 9, 30),
+        ],
+        "file_extension": ["txt", "txt"],
+        "size_readable": ["", ""],
+        "imported_path": [str(base), str(base)],
+    })
+
+    out = postprocess_basic_file_metadata_df(df)
+
+    assert set(PATHS_DF_EXPECTED_SCHEMA.keys()).issubset(set(out.columns))
+    assert out["modification_month"].to_list() == [3, 7]
+    actual_short = out["imported_path_short"].to_list()
+    expected_full = [str(base), str(base)]
+    expected_last = [Path(base).name, Path(base).name]
+    assert actual_short == expected_full or actual_short == expected_last
+    assert out["size_readable"].to_list() == ["1.0 KB", "2.0 KB"]
+
+def test_full_records_df_computes_real_mean_intensity(tmp_path, loader):
+    img_dir = tmp_path / "imgs"
+    img_dir.mkdir()
+
+    a = np.zeros((2,2,1), dtype=np.uint8)
+    from PIL import Image
+    Image.fromarray(a.squeeze(), mode="L").save(img_dir / "zero.png")
+
+    b = np.full((2,2,1), 255, dtype=np.uint8)
+    Image.fromarray(b.squeeze(), mode="L").save(img_dir / "full.png")
+
+    df = build_records_df(
+        bases=[img_dir],
+        selected_extensions={"png"},
+        loader=loader
+    )
+    assert isinstance(df, pl.DataFrame)
+    paths = df["path"].to_list()
+    assert sorted(Path(p).name for p in paths) == ["full.png", "zero.png"]
+
+    assert "mean_intensity" in df.columns
+
+    mip = { Path(p).name: v for p, v in zip(df["path"].to_list(), df["mean_intensity"].to_list()) }
+    assert mip["zero.png"] == 0.0
+    assert mip["full.png"] == 255.0
+
+
+def test_full_records_df_handles_5d_tif_t_z_c_dimensions(tmp_path, loader):
+    t_size, c_size, z_size, y_size, x_size = 2, 3, 4, 2, 2
+    arr = np.zeros((t_size, c_size, z_size, y_size, x_size), dtype=np.uint8)
+    for t in range(t_size):
+        for c in range(c_size):
+            for z in range(z_size):
+                arr[t, c, z, ...] = (t*z_size + z)*10 + c*5
+
+    path = tmp_path / "5d.tif"
+    tifffile.imwrite(str(path), arr, photometric='minisblack')
+
+    df = build_records_df(
+        bases=[tmp_path],
+        selected_extensions={"tif"},
+        loader=loader
+    )
+
+    expected_cols = {
+        f"mean_intensity_t{t}_c{c}_z{z}"
+        for t in range(t_size) for z in range(z_size) for c in range(c_size)
+    }
+    assert expected_cols.issubset(set(df.columns))
+
+    actual = {col: df[col][0] for col in expected_cols}
+    for t in range(t_size):
+        for z in range(z_size):
+            for c in range(c_size):
+                key = f"mean_intensity_t{t}_c{c}_z{z}"
+                expected = (t*z_size + z)*10 + c*5
+                assert actual[key] == expected, f"{key} was {actual[key]}, expected {expected}"
+
+    for t in range(t_size):
+        col = f"mean_intensity_t{t}"
+        assert col in df.columns
+        block_vals = [(t * z_size + z) * 10 + c * 5
+                      for c in range(c_size) for z in range(z_size)]
+        expected = sum(block_vals) / len(block_vals)
+        assert df[0, col] == expected
+
+    for c in range(c_size):
+        col = f"mean_intensity_c{c}"
+        assert col in df.columns
+        block_vals = [(t * z_size + z) * 10 + c * 5
+                      for t in range(t_size) for z in range(z_size)]
+        expected = sum(block_vals) / len(block_vals)
+        assert df[0, col] == expected
+
+    for z in range(z_size):
+        col = f"mean_intensity_z{z}"
+        assert col in df.columns
+        block_vals = [(t * z_size + z) * 10 + c * 5
+                      for t in range(t_size) for c in range(c_size)]
+        expected = sum(block_vals) / len(block_vals)
+        assert df[0, col] == expected
+
+    assert "mean_intensity" in df.columns
+    all_vals = [(t * z_size + z) * 10 + c * 5
+                for t in range(t_size) for c in range(c_size) for z in range(z_size)]
+    overall_expected = sum(all_vals) / len(all_vals)
+    assert df[0,"mean_intensity"] == overall_expected
+
+
+def test_full_records_df_handles_png_gray(tmp_path, loader):
+    arr = np.zeros((2, 2, 3), dtype=np.uint8)
+    arr[..., 0] = 10
+    arr[..., 1] = 20
+    arr[..., 2] = 30
+
+    path = tmp_path / "rgb.png"
+    Image.fromarray(arr).save(str(path))
+
+    df = build_records_df(
+        bases=[tmp_path],
+        selected_extensions={"png"},
+        loader=loader
+    )
+
+    assert "mean_intensity" in df.columns
+    raw_gray = np.mean(arr)
+    expected_gray = np.uint8(raw_gray)
+    assert df["mean_intensity"][0] == expected_gray

pixel_patrol_loader_bio-0.1.0/tests/test_zarr_image.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+import zarr
+from zarr.storage import LocalStore
+import polars as pl
+
+from pixel_patrol_loader_bio.plugins.loaders.bioio_loader import BioIoLoader
+from pixel_patrol_loader_bio.plugins.loaders.zarr_loader import ZarrLoader
+from pixel_patrol_base.core.processing import get_all_record_properties, build_records_df
+from pixel_patrol_base.plugin_registry import discover_processor_plugins
+
+
+@pytest.fixture
+def zarr_folder(tmp_path: Path) -> Path:
+    """
+    Create a minimal OME-Zarr folder with valid NGFF metadata using the modern LocalStore interface.
+    Returns the .zarr folder path.
+    """
+    zarr_path = tmp_path / "project" / "test_image.zarr"
+    zarr_path.parent.mkdir(parents=True, exist_ok=True)
+
+    shape = (1, 2, 1, 10, 10)
+    chunks = (1, 1, 1, 10, 10)
+    dtype = "uint16"
+    data = np.random.randint(0, 65535, size=shape, dtype=dtype)
+
+    # Use LocalStore for compatibility with modern Zarr v3+
+    store = LocalStore(str(zarr_path))
+    root = zarr.group(store=store)
+
+    arr = root.create_array(
+        "0",
+        shape=shape,
+        chunks=chunks,
+        dtype=dtype,
+        overwrite=True
+    )
+    arr[:] = data
+
+    # Add required NGFF metadata
+    root.attrs.put({
+        "multiscales": [{
+            "version": "0.4",
+            "datasets": [{"path": "0"}],
+
+            "axes": [
+                {"name": "t", "type": "time"},
+                {"name": "c", "type": "channel"},
+                {"name": "z", "type": "space"},
+                {"name": "y", "type": "space"},
+                {"name": "x", "type": "space"}
+            ]
+        }],
+        "omero": {
+            "channels": [
+                {"label": "Channel 0"},
+                {"label": "Channel 1"}
+            ]
+        }
+    })
+
+    return zarr_path
+
+def test_zarr_path_recognition_as_image(zarr_folder: Path):
+    """
+    Test that a .zarr folder is correctly recognized and included in paths_df with type='file'.
+    """
+    parent_dir = zarr_folder.parent
+    paths_df = build_records_df([parent_dir], selected_extensions='all', loader=ZarrLoader())
+    zarr_rows = paths_df.filter(pl.col("path") == str(zarr_folder))
+
+    assert not zarr_rows.is_empty(), "Zarr folder not found in paths_df"
+    assert zarr_rows[0, "type"] == "file", "Zarr folder should be recognized as type 'file'"
+    assert zarr_rows[0, "file_extension"] == "zarr", "Zarr folder should have 'zarr' as file_extension"
+
+
+# test decorator + signature (edit existing test)
+@pytest.mark.parametrize("loader", [ZarrLoader(), BioIoLoader()])
+def test_extract_metadata_from_zarr_using_bioio(zarr_folder: Path, loader):
+    """
+    Test that extract_image_metadata can process a .zarr folder and returns valid metadata.
+    """
+    metadata = get_all_record_properties(zarr_folder, loader=loader, processors=discover_processor_plugins())
+
+    assert isinstance(metadata, dict)
+
+    assert metadata.get("dim_order") in ["TCZYXS", "TCZYX", "TCYX", "CZYX", "CXY", "TYX"]  # TODO: probably need to change so dim order is always TCZYXS
+    assert metadata.get("dtype") == "uint16"
+    assert metadata.get("T_size") == 1
+    assert metadata.get("C_size") == 2
+    assert metadata.get("Z_size") == 1
+    assert metadata.get("Y_size") == 10
+    assert metadata.get("X_size") == 10
+
+    assert "num_pixels" in metadata and metadata["num_pixels"] == 1 * 2 * 1 * 10 * 10
+    assert "shape" in metadata and metadata["shape"]  == [1, 2, 1, 10, 10]
+    assert "ndim" in metadata and metadata["ndim"] == 5