senoquant 1.0.0b1__py3-none-any.whl

senoquant/tabs/batch/io.py

@@ -0,0 +1,326 @@
+"""I/O helpers for batch processing.
+
+This module provides filesystem and image-loading utilities used by the
+batch backend. Functions are intentionally stateless and easy to mock in
+tests.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+
+from senoquant.reader import core as reader_core
+from .config import BatchChannelConfig
+
+
+def normalize_extensions(extensions: Iterable[str] | None) -> set[str] | None:
+    """Normalize extension list to lowercase with leading dots.
+
+    Parameters
+    ----------
+    extensions : iterable of str or None
+        Raw extension strings (with or without dots).
+
+    Returns
+    -------
+    set of str or None
+        Normalized extensions or None when no filtering is requested.
+    """
+    if extensions is None:
+        return None
+    normalized = set()
+    for ext in extensions:
+        if not ext:
+            continue
+        cleaned = ext.strip().lower()
+        if not cleaned:
+            continue
+        if not cleaned.startswith("."):
+            cleaned = f".{cleaned}"
+        normalized.add(cleaned)
+    return normalized or None
+
+
+def iter_input_files(
+    root: Path, extensions: set[str] | None, include_subfolders: bool
+) -> Iterable[Path]:
+    """Yield input files from a root folder.
+
+    Parameters
+    ----------
+    root : Path
+        Directory to scan.
+    extensions : set of str or None
+        Allowed file extensions. None disables filtering.
+    include_subfolders : bool
+        Whether to scan subfolders recursively.
+
+    Yields
+    ------
+    Path
+        File paths that match the extension criteria.
+    """
+    if not root.exists():
+        return
+    iterator = root.rglob("*") if include_subfolders else root.iterdir()
+    for path in iterator:
+        if not path.is_file():
+            continue
+        if extensions is None:
+            yield path
+            continue
+        name = path.name.lower()
+        if any(name.endswith(ext) for ext in extensions):
+            yield path
+
+
+def basename_for_path(path: Path) -> str:
+    """Return a filesystem-friendly base name for a file path.
+
+    Parameters
+    ----------
+    path : Path
+        Input file path.
+
+    Returns
+    -------
+    str
+        Base name with common microscopy extensions removed.
+    """
+    name = path.name
+    lowered = name.lower()
+    for ext in (".ome.tiff", ".ome.tif", ".tiff", ".tif"):
+        if lowered.endswith(ext):
+            return name[: -len(ext)]
+    if "." in name:
+        return name.rsplit(".", 1)[0]
+    return name
+
+
+def safe_scene_dir(scene_id: str) -> str:
+    """Return a sanitized scene identifier for folder naming.
+
+    Parameters
+    ----------
+    scene_id : str
+        Scene identifier from BioIO.
+
+    Returns
+    -------
+    str
+        Filesystem-safe scene folder name.
+    """
+    safe = scene_id.strip().replace("/", "_").replace("\\", "_")
+    return safe or "scene"
+
+
+def write_array(
+    output_dir: Path, name: str, data: np.ndarray, output_format: str
+) -> Path:
+    """Write an array to disk in the requested format.
+
+    Parameters
+    ----------
+    output_dir : Path
+        Destination folder.
+    name : str
+        Base name for the output file.
+    data : numpy.ndarray
+        Array data to serialize.
+    output_format : str
+        Output format (``"tif"`` or ``"npy"``).
+
+    Returns
+    -------
+    Path
+        Path to the written file.
+    """
+    output_format = output_format.lower().strip()
+    if output_format == "npy":
+        path = output_dir / f"{name}.npy"
+        np.save(path, data)
+        return path
+
+    path = output_dir / f"{name}.tif"
+    try:
+        import tifffile
+
+        tifffile.imwrite(str(path), data)
+        return path
+    except Exception:
+        fallback = output_dir / f"{name}.npy"
+        np.save(fallback, data)
+        return fallback
+
+
+def resolve_channel_index(
+    choice: str | int | None,
+    channel_map: list[BatchChannelConfig],
+) -> int:
+    """Resolve a channel selection into a numeric index.
+
+    Parameters
+    ----------
+    choice : str or int or None
+        Channel selection from the UI (name or index).
+    channel_map : list of BatchChannelConfig
+        Mapping from names to indices.
+
+    Returns
+    -------
+    int
+        Resolved channel index.
+
+    Raises
+    ------
+    ValueError
+        If the selection is missing or unknown.
+    """
+    if isinstance(choice, int):
+        return choice
+    if choice is None:
+        raise ValueError("Channel selection is required.")
+    text = str(choice).strip()
+    if not text:
+        raise ValueError("Channel selection is required.")
+    if text.isdigit():
+        return int(text)
+    for channel in channel_map:
+        if channel.name == text:
+            return channel.index
+    raise ValueError(f"Unknown channel selection: {text}.")
+
+
+def spot_label_name(
+    choice: str | int,
+    channel_map: list[BatchChannelConfig],
+) -> str:
+    """Build the output label name for a spot channel.
+
+    Parameters
+    ----------
+    choice : str or int
+        Channel selection.
+    channel_map : list of BatchChannelConfig
+        Channel mapping list for name lookup.
+
+    Returns
+    -------
+    str
+        Standardized spot label name.
+    """
+    if isinstance(choice, int):
+        name = str(choice)
+    else:
+        name = str(choice).strip()
+        if name.isdigit():
+            return f"spot_labels_{name}"
+        for channel in channel_map:
+            if channel.name == name:
+                name = channel.name
+                break
+    return f"spot_labels_{sanitize_label(name)}"
+
+
+def sanitize_label(name: str) -> str:
+    """Sanitize a label name for filesystem use."""
+    safe = []
+    for char in name.strip():
+        if char.isalnum():
+            safe.append(char)
+        else:
+            safe.append("_")
+    result = "".join(safe).strip("_")
+    return result or "spots"
+
+
+def load_channel_data(
+    path: Path,
+    channel_index: int,
+    scene_id: str | None,
+) -> tuple[np.ndarray | None, dict]:
+    """Load a single-channel image array for the given path.
+
+    Parameters
+    ----------
+    path : Path
+        Input file path.
+    channel_index : int
+        Channel index to extract.
+    scene_id : str or None
+        Optional scene identifier.
+
+    Returns
+    -------
+    tuple of (numpy.ndarray or None, dict)
+        The extracted image data and metadata.
+    """
+    image = reader_core._open_bioimage(str(path))
+    try:
+        if scene_id:
+            image.set_scene(scene_id)
+        metadata = {"physical_pixel_sizes": reader_core._physical_pixel_sizes(image)}
+        axes_present = reader_core._axes_present(image)
+        dims = getattr(image, "dims", None)
+        c_size = getattr(dims, "C", 1) if "C" in axes_present else 1
+        z_size = getattr(dims, "Z", 1) if "Z" in axes_present else 1
+
+        if c_size > 1:
+            order = "CZYX" if z_size > 1 else "CYX"
+        else:
+            order = "ZYX" if z_size > 1 else "YX"
+
+        kwargs: dict[str, int] = {}
+        if "T" in axes_present and "T" not in order:
+            kwargs["T"] = 0
+        if "C" in axes_present and "C" not in order:
+            kwargs["C"] = 0
+        if "Z" in axes_present and "Z" not in order:
+            kwargs["Z"] = 0
+
+        data = image.get_image_data(order, **kwargs)
+        if c_size > 1:
+            if channel_index >= c_size or channel_index < 0:
+                raise ValueError(
+                    f"Channel index {channel_index} out of range for {path.name}."
+                )
+            data = data[channel_index]
+        return np.asarray(data), metadata
+    finally:
+        if hasattr(image, "close"):
+            try:
+                image.close()
+            except Exception:
+                pass
+
+
+
+def list_scenes(path: Path) -> list[str]:
+    """Return scene identifiers for a BioIO image path.
+
+    Parameters
+    ----------
+    path : Path
+        Input file path.
+
+    Returns
+    -------
+    list of str
+        Scene identifiers, or an empty list if unavailable.
+    """
+    try:
+        image = reader_core._open_bioimage(str(path))
+    except Exception:
+        return []
+    try:
+        scenes = list(getattr(image, "scenes", []) or [])
+    finally:
+        if hasattr(image, "close"):
+            try:
+                image.close()
+            except Exception:
+                pass
+    return scenes

senoquant/tabs/batch/layers.py

@@ -0,0 +1,86 @@
+"""Lightweight layer shims used for batch processing.
+
+These classes emulate the minimal attributes used by feature exporters
+and quantification routines, without requiring a live napari viewer.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+import numpy as np
+
+class Image:
+    """Lightweight image layer placeholder.
+
+    Parameters
+    ----------
+    data : numpy.ndarray or None
+        Image data array.
+    name : str
+        Layer name.
+    metadata : dict or None, optional
+        Metadata dictionary (e.g., pixel sizes).
+    rgb : bool, optional
+        Whether the layer should be treated as RGB.
+    """
+
+    def __init__(
+        self,
+        data: np.ndarray | None,
+        name: str,
+        metadata: dict | None = None,
+        rgb: bool = False,
+    ) -> None:
+        self.data = data
+        self.name = name
+        self.metadata = metadata or {}
+        self.rgb = rgb
+
+
+class Labels:
+    """Lightweight labels layer placeholder.
+
+    Parameters
+    ----------
+    data : numpy.ndarray or None
+        Label image data.
+    name : str
+        Layer name.
+    metadata : dict or None, optional
+        Metadata dictionary (e.g., pixel sizes).
+    """
+
+    def __init__(
+        self,
+        data: np.ndarray | None,
+        name: str,
+        metadata: dict | None = None,
+    ) -> None:
+        self.data = data
+        self.name = name
+        self.metadata = metadata or {}
+
+
+class BatchViewer:
+    """Minimal viewer shim exposing layers for export routines.
+
+    Parameters
+    ----------
+    layers : iterable of object or None, optional
+        Initial layer collection.
+    """
+
+    def __init__(self, layers: Iterable[object] | None = None) -> None:
+        """Initialize the viewer shim."""
+        self.layers = list(layers) if layers is not None else []
+
+    def set_layers(self, layers: Iterable[object]) -> None:
+        """Replace the current layer collection.
+
+        Parameters
+        ----------
+        layers : iterable of object
+            New layer collection.
+        """
+        self.layers = list(layers)

senoquant/tabs/quantification/__init__.py

@@ -0,0 +1 @@
+"""Quantification tab modules."""

senoquant/tabs/quantification/backend.py

@@ -0,0 +1,228 @@
+"""Backend logic for the Quantification tab."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+import shutil
+import tempfile
+
+from .features import FeatureConfig
+
+
+@dataclass
+class FeatureExportResult:
+    """Output metadata for a single feature export.
+
+    Attributes
+    ----------
+    feature_id : str
+        Stable identifier for the exported feature instance.
+    feature_type : str
+        Feature type name used for routing (e.g., ``"Markers"``).
+    feature_name : str
+        Display name provided by the user.
+    temp_dir : Path
+        Temporary directory where the feature wrote its outputs.
+    outputs : list of Path
+        Explicit file paths returned by the feature processor.
+    """
+
+    feature_id: str
+    feature_type: str
+    feature_name: str
+    temp_dir: Path
+    outputs: list[Path] = field(default_factory=list)
+
+
+@dataclass
+class QuantificationResult:
+    """Aggregated output information for a quantification run.
+
+    Attributes
+    ----------
+    output_root : Path
+        Root output directory for the run.
+    temp_root : Path
+        Temporary root directory used during processing.
+    feature_outputs : list of FeatureExportResult
+        Per-feature export metadata for the run.
+    """
+
+    output_root: Path
+    temp_root: Path
+    feature_outputs: list[FeatureExportResult]
+
+
+class QuantificationBackend:
+    """Backend orchestrator for quantification exports.
+
+    Notes
+    -----
+    Feature export routines live with their feature implementations. The
+    backend iterates through configured feature contexts, asks each feature
+    handler to export into a temporary directory, and then routes those
+    outputs into a final output structure.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the backend state.
+
+        Attributes
+        ----------
+        metrics : list
+            Placeholder container for computed metrics.
+        """
+        self.metrics: list[object] = []
+
+    def process(
+        self,
+        features: Iterable[object],
+        output_path: str,
+        output_name: str,
+        export_format: str,
+        cleanup: bool = True,
+    ) -> QuantificationResult:
+        """Run feature exports and route their outputs.
+
+        Parameters
+        ----------
+        features : iterable of object
+            Feature UI contexts with ``state`` and ``feature_handler``.
+            Each handler should implement ``export(temp_dir, export_format)``.
+        output_path : str
+            Base output folder path.
+        output_name : str
+            Folder name used to group exported outputs.
+        export_format : str
+            File format requested by the user (``"csv"`` or ``"xlsx"``).
+        cleanup : bool, optional
+            Whether to delete temporary export folders after routing.
+
+        Returns
+        -------
+        QuantificationResult
+            Output metadata for the completed run.
+
+        Notes
+        -----
+        If a feature export does not return explicit output paths, the backend
+        will move all files found in the feature's temp directory. This allows
+        feature implementations to either return specific files or simply write
+        into the provided temporary directory.
+        """
+        output_root = self._resolve_output_root(output_path, output_name)
+        output_root.mkdir(parents=True, exist_ok=True)
+        temp_root = Path(tempfile.mkdtemp(prefix="senoquant-quant-"))
+
+        feature_outputs: list[FeatureExportResult] = []
+        for context in features:
+            feature = getattr(context, "state", None)
+            handler = getattr(context, "feature_handler", None)
+            if not isinstance(feature, FeatureConfig):
+                continue
+            temp_dir = temp_root / feature.feature_id
+            temp_dir.mkdir(parents=True, exist_ok=True)
+            outputs: list[Path] = []
+            if handler is not None and hasattr(handler, "export"):
+                outputs = [
+                    Path(path)
+                    for path in handler.export(temp_dir, export_format)
+                ]
+            feature_outputs.append(
+                FeatureExportResult(
+                    feature_id=feature.feature_id,
+                    feature_type=feature.type_name,
+                    feature_name=feature.name,
+                    temp_dir=temp_dir,
+                    outputs=outputs,
+                )
+            )
+
+        self._route_feature_outputs(output_root, feature_outputs)
+        if cleanup:
+            shutil.rmtree(temp_root, ignore_errors=True)
+        return QuantificationResult(
+            output_root=output_root,
+            temp_root=temp_root,
+            feature_outputs=feature_outputs,
+        )
+
+    def _resolve_output_root(self, output_path: str, output_name: str) -> Path:
+        """Resolve the final output root directory.
+
+        Parameters
+        ----------
+        output_path : str
+            Base output folder path.
+        output_name : str
+            Folder name used to group exported outputs.
+
+        Returns
+        -------
+        Path
+            Resolved output directory path.
+        """
+        base = Path(output_path) if output_path else Path.cwd()
+        if output_name:
+            return base / output_name
+        return base
+
+    def _route_feature_outputs(
+        self,
+        output_root: Path,
+        feature_outputs: Iterable[FeatureExportResult],
+    ) -> None:
+        """Move feature outputs from temp folders to the final location.
+
+        Parameters
+        ----------
+        output_root : Path
+            Destination root folder.
+        feature_outputs : iterable of FeatureExportResult
+            Export results to route.
+
+        Notes
+        -----
+        When a feature returns no explicit output list, all files present
+        in the temporary directory are routed instead. Subdirectories are
+        not traversed.
+        """
+        for feature_output in feature_outputs:
+            feature_dir = output_root / self._feature_dir_name(feature_output)
+            feature_dir.mkdir(parents=True, exist_ok=True)
+            outputs = feature_output.outputs
+            if outputs:
+                for path in outputs:
+                    if path.exists():
+                        shutil.move(str(path), feature_dir / path.name)
+            else:
+                for path in feature_output.temp_dir.glob("*"):
+                    if path.is_file():
+                        shutil.move(str(path), feature_dir / path.name)
+
+    def _feature_dir_name(self, feature_output: FeatureExportResult) -> str:
+        """Build a filesystem-friendly folder name for a feature.
+
+        Parameters
+        ----------
+        feature_output : FeatureExportResult
+            Export result metadata.
+
+        Returns
+        -------
+        str
+            Directory name for the feature outputs.
+
+        Notes
+        -----
+        Non-alphanumeric characters are replaced to avoid filesystem issues.
+        """
+        name = feature_output.feature_name.strip()
+        if not name:
+            name = feature_output.feature_type
+        safe = "".join(
+            char if char.isalnum() or char in "-_ " else "_" for char in name
+        )
+        return safe.replace(" ", "_").lower()