brkraw 0.5.0rc1__py3-none-any.whl → 0.5.1__py3-none-any.whl

brkraw/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = '0.5.0rc1'
+__version__ = '0.5.1'
 from .apps.loader import BrukerLoader
 
 

brkraw/apps/hook/core.py

@@ -7,7 +7,7 @@ import importlib.metadata
 import logging
 import re
 from pathlib import Path
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple, Union, cast
 
 try:
     from importlib import resources
@@ -17,7 +17,7 @@ import yaml
 
 from ...core import config as config_core
 from ...core.entrypoints import list_entry_points
-from ...specs.converter.logic import DEFAULT_GROUP
+from ...specs.hook.logic import DEFAULT_GROUP
 from ..addon import installation as addon_install
 from ..addon import dependencies as addon_deps
 from ..addon.io import write_file as _write_file
@@ -28,6 +28,41 @@ REGISTRY_FILENAME = "hooks.yaml"
 MANIFEST_NAMES = ("brkraw_hook.yaml", "brkraw_hook.yml")
 
 
+def _metadata_get(
+    dist: Optional[importlib.metadata.Distribution],
+    key: str,
+    default: Optional[str] = None,
+) -> Optional[str]:
+    """Typed helper to read distribution metadata."""
+    if dist is None:
+        return default
+    meta = cast(Mapping[str, str], dist.metadata)
+    return meta.get(key, default)
+
+
+def _packages_distributions() -> Mapping[str, List[str]]:
+    packages_distributions = getattr(importlib.metadata, "packages_distributions", None)
+    if packages_distributions is not None:
+        return cast(Callable[[], Mapping[str, List[str]]], packages_distributions)()
+
+    mapping: Dict[str, List[str]] = {}
+    for dist in importlib.metadata.distributions():
+        read_text = getattr(dist, "read_text", None)
+        top_level_text = ""
+        if callable(read_text):
+            top_level = read_text("top_level.txt")
+            if isinstance(top_level, str):
+                top_level_text = top_level
+        dist_name = _metadata_get(dist, "Name")
+        if not dist_name:
+            continue
+        for package in top_level_text.splitlines():
+            package = package.strip()
+            if package:
+                mapping.setdefault(package, []).append(dist_name)
+    return mapping
+
+
 def list_hooks(*, root: Optional[Union[str, Path]] = None) -> List[Dict[str, Any]]:
     hooks = _collect_hooks()
     registry = _load_registry(root=root)
@@ -88,13 +123,26 @@ def uninstall_hook(
     *,
     root: Optional[Union[str, Path]] = None,
     force: bool = False,
-) -> Tuple[str, Dict[str, List[str]]]:
+) -> Tuple[str, Dict[str, List[str]], bool]:
     registry = _load_registry(root=root)
     hooks = registry.get("hooks", {})
     hook_name = _resolve_hook_name(target)
     entry = hooks.get(hook_name)
+    if entry is None:
+        entry_matches = [
+            name
+            for name, data in hooks.items()
+            if target in (data.get("entrypoints") or [])
+        ]
+        if len(entry_matches) == 1:
+            hook_name = entry_matches[0]
+            entry = hooks.get(hook_name)
+        elif entry_matches:
+            names = ", ".join(sorted(entry_matches))
+            raise ValueError(f"Multiple hooks match {target}: {names}")
     if entry is None:
         raise LookupError(f"Hook not installed: {hook_name}")
+    module_missing = not list_entry_points(DEFAULT_GROUP, name=hook_name)
     removed: Dict[str, List[str]] = {
         "specs": [],
         "pruner_specs": [],
@@ -113,7 +161,7 @@ def uninstall_hook(
             removed[kind].append(relpath)
     hooks.pop(hook_name, None)
     _save_registry(registry, root=root)
-    return hook_name, removed
+    return hook_name, removed, module_missing
 
 
 def _install_hook(
@@ -347,7 +395,7 @@ def _resolve_distribution(ep: importlib.metadata.EntryPoint) -> Optional[importl
     pkg = getattr(ep, "module", "").split(".")[0]
     if not pkg:
         return None
-    mapping = importlib.metadata.packages_distributions()
+    mapping = _packages_distributions()
     dist_names = mapping.get(pkg, [])
     if not dist_names:
         return None
@@ -360,26 +408,26 @@ def _resolve_distribution(ep: importlib.metadata.EntryPoint) -> Optional[importl
 def _dist_name(dist: Optional[importlib.metadata.Distribution]) -> Optional[str]:
     if dist is None:
         return None
-    return dist.metadata.get("Name")
+    return _metadata_get(dist, "Name")
 
 
 def _dist_version(dist: Optional[importlib.metadata.Distribution]) -> str:
     if dist is None:
         return "<Unknown>"
-    return dist.metadata.get("Version", "<Unknown>")
+    return _metadata_get(dist, "Version", "<Unknown>") or "<Unknown>"
 
 
 def _dist_description(dist: Optional[importlib.metadata.Distribution]) -> str:
     if dist is None:
         return "<Unknown>"
-    return dist.metadata.get("Summary", "<Unknown>")
+    return _metadata_get(dist, "Summary", "<Unknown>") or "<Unknown>"
 
 
 def _dist_author(dist: Optional[importlib.metadata.Distribution]) -> str:
     if dist is None:
         return "<Unknown>"
     for key in ("Author", "Author-email", "Maintainer", "Maintainer-email"):
-        value = dist.metadata.get(key)
+        value = _metadata_get(dist, key)
         if value:
             return value
     return "<Unknown>"
@@ -394,7 +442,7 @@ def _load_manifest(
     manifest = _find_manifest(dist, packages=packages)
     if manifest is None:
         raise FileNotFoundError(
-            f"No hook manifest found in {dist.metadata.get('Name', '<Unknown>')}"
+            f"No hook manifest found in {_metadata_get(dist, 'Name', '<Unknown>')}"
         )
     data = _read_yaml(manifest)
     return manifest, data

brkraw/apps/loader/core.py

@@ -19,7 +19,7 @@ from pathlib import Path
 
 from ...core import config as config_core
 from ...core.config import resolve_root
-from ...specs import converter as converter_core
+from ...specs import hook as converter_core
 from ...specs.pruner import prune_dataset_to_zip
 from ...specs.rules import load_rules, select_rule_use
 from ...dataclasses import Scan, Study
@@ -350,6 +350,7 @@ class BrukerLoader:
                         override_subject_type: Optional[SubjectType] = None,
                         override_subject_pose: Optional[SubjectPose] = None,
                         flip_x: bool = False, 
+                        flatten_fg: bool = False,
                         xyz_units: XYZUNIT = 'mm', 
                         t_units: TUNIT = 'sec'):
         """Return NIfTI image(s) for a scan/reco via attached helper.
@@ -377,6 +378,7 @@ class BrukerLoader:
             override_subject_type=override_subject_type,
             override_subject_pose=override_subject_pose,
             flip_x=flip_x,
+            flatten_fg=flatten_fg,
             xyz_units=xyz_units,
             t_units=t_units,
         )
@@ -392,6 +394,7 @@ class BrukerLoader:
         override_subject_type: Optional[SubjectType] = None,
         override_subject_pose: Optional[SubjectPose] = None,
         flip_x: bool = False,
+        flatten_fg: bool = False,
         xyz_units: XYZUNIT = "mm",
         t_units: TUNIT = "sec",
         hook_args_by_name: Optional[Mapping[str, Mapping[str, Any]]] = None,
@@ -406,6 +409,7 @@ class BrukerLoader:
             override_subject_type=override_subject_type,
             override_subject_pose=override_subject_pose,
             flip_x=flip_x,
+            flatten_fg=flatten_fg,
             xyz_units=xyz_units,
             t_units=t_units,
             hook_args_by_name=hook_args_by_name,

brkraw/apps/loader/helper.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 from types import MethodType
 from functools import partial
+import inspect
 from typing import TYPE_CHECKING, Optional, Tuple, Union, Any, Mapping, cast, List, Dict, Literal
 from pathlib import Path
 from warnings import warn
@@ -21,7 +22,7 @@ from ...specs.remapper import load_spec, map_parameters, load_context_map, apply
 from ...specs.rules import load_rules, select_rule_use
 from ...dataclasses import Reco, Scan, Study
 from .types import ScanLoader
-from ...specs import converter as converter_core
+from ...specs import hook as converter_core
 from ...resolver import affine as affine_resolver
 from ...resolver import image as image_resolver
 from ...resolver import fid as fid_resolver
@@ -106,11 +107,29 @@ def resolve_data_and_affine(
                 list(scan.avail.keys()),
             )
             continue
-        image_info = image_resolver.resolve(scan, rid)
-        # store subject-view affines (scanner unwrap happens in get_affine)
-        affine_info = affine_resolver.resolve(
-            scan, rid, decimals=affine_decimals, unwrap_pose=False,
-        )
+        try:
+            image_info = image_resolver.resolve(scan, rid)
+        except Exception as exc:
+            logger.warning(
+                "Failed to resolve image data for scan %s reco %s: %s",
+                getattr(scan, "scan_id", "?"),
+                rid,
+                exc,
+            )
+            image_info = None
+        try:
+            # store subject-view affines (scanner unwrap happens in get_affine)
+            affine_info = affine_resolver.resolve(
+                scan, rid, decimals=affine_decimals, unwrap_pose=False,
+            )
+        except Exception as exc:
+            logger.warning(
+                "Failed to resolve affine for scan %s reco %s: %s",
+                getattr(scan, "scan_id", "?"),
+                rid,
+                exc,
+            )
+            affine_info = None
 
         if hasattr(scan, "image_info"):
             scan.image_info[rid] = image_info
@@ -327,7 +346,7 @@ def get_affine(
     override_subject_type: Optional["SubjectType"] = None,
     override_subject_pose: Optional["SubjectPose"] = None,
     decimals: Optional[int] = None,
-    **_: Any,
+    **kwargs: Any,
 ) -> AffineReturn:
     """
     Return affine(s) for a reco in the requested coordinate space.
@@ -379,7 +398,8 @@ def get_affine(
 
     # "raw" does not need subject info
     if space == "raw":
-        return _finalize_affines(affines, num_slice_packs, decimals)
+        result = _finalize_affines(affines, num_slice_packs, decimals)
+        return _apply_affine_post_transform(result, kwargs=kwargs)
 
     # Need subject type/pose for unwrap and wrap
     visu_pars = get_file(self.avail[resolved_reco_id], "visu_pars")
@@ -392,7 +412,8 @@ def get_affine(
     ]
 
     if space == "scanner":
-        return _finalize_affines(affines_scanner, num_slice_packs, decimals)
+        result = _finalize_affines(affines_scanner, num_slice_packs, decimals)
+        return _apply_affine_post_transform(result, kwargs=kwargs)
 
     # Step 2: wrap to subject RAS (optionally with override)
     use_type = override_subject_type or subj_type
@@ -402,7 +423,52 @@ def get_affine(
         affine_resolver.wrap_to_subject_ras(affine, use_type, use_pose)
         for affine in affines_scanner
     ]
-    return _finalize_affines(affines_subject_ras, num_slice_packs, decimals)
+    result = _finalize_affines(affines_subject_ras, num_slice_packs, decimals)
+    return _apply_affine_post_transform(result, kwargs=kwargs)
+
+
+def _apply_affine_post_transform(affines: AffineReturn, *, kwargs: Mapping[str, Any]) -> AffineReturn:
+    """Apply optional flips/rotations to affines right before returning.
+
+    These transforms are applied in world space and do not depend on output
+    `space`. They are controlled via extra kwargs (intentionally not strict):
+
+    - flip_x / flip_y / flip_z: bool-like
+    - rad_x / rad_y / rad_z: radians (float-like)
+    """
+
+    def as_bool(value: Any) -> bool:
+        if isinstance(value, str):
+            return value.strip().lower() in {"1", "true", "yes", "y", "on"}
+        return bool(value)
+
+    def as_float(value: Any) -> float:
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return 0.0
+
+    flip_x = as_bool(kwargs.get("flip_x", False))
+    flip_y = as_bool(kwargs.get("flip_y", False))
+    flip_z = as_bool(kwargs.get("flip_z", False))
+    rad_x = as_float(kwargs.get("rad_x", 0.0))
+    rad_y = as_float(kwargs.get("rad_y", 0.0))
+    rad_z = as_float(kwargs.get("rad_z", 0.0))
+
+    if not (flip_x or flip_y or flip_z or rad_x or rad_y or rad_z):
+        return affines
+
+    def apply_one(a: np.ndarray) -> np.ndarray:
+        out = np.asarray(a, dtype=float)
+        if flip_x or flip_y or flip_z:
+            out = affine_resolver.flip_affine(out, flip_x=flip_x, flip_y=flip_y, flip_z=flip_z)
+        if rad_x or rad_y or rad_z:
+            out = affine_resolver.rotate_affine(out, rad_x=rad_x, rad_y=rad_y, rad_z=rad_z)
+        return np.asarray(out, dtype=float)
+
+    if isinstance(affines, tuple):
+        return tuple(apply_one(np.asarray(a)) for a in affines)
+    return apply_one(np.asarray(affines))
 
 
 def get_nifti1image(
@@ -414,6 +480,7 @@ def get_nifti1image(
     override_subject_type: Optional[SubjectType] = None,
     override_subject_pose: Optional[SubjectPose] = None,
     flip_x: bool = False,
+    flatten_fg: bool = False,
     xyz_units: XYZUNIT = "mm",
     t_units: TUNIT = "sec",
     hook_args_by_name: Optional[Mapping[str, Mapping[str, Any]]] = None,
@@ -446,17 +513,19 @@ def get_nifti1image(
     if resolved_reco_id is None:
         return None
     hook_kwargs = _resolve_hook_kwargs(self, hook_args_by_name)
-    if hook_kwargs:
-        dataobjs = self.get_dataobj(resolved_reco_id, **hook_kwargs)
+    data_kwargs = _filter_hook_kwargs(self.get_dataobj, hook_kwargs)
+    if data_kwargs:
+        dataobjs = self.get_dataobj(resolved_reco_id, **data_kwargs)
     else:
         dataobjs = self.get_dataobj(resolved_reco_id)
-    if hook_kwargs:
+    affine_kwargs = _filter_hook_kwargs(self.get_affine, hook_kwargs)
+    if affine_kwargs:
         affines = self.get_affine(
             resolved_reco_id,
             space=space,
             override_subject_type=override_subject_type,
             override_subject_pose=override_subject_pose,
-            **hook_kwargs,
+            **affine_kwargs,
         )
     else:
         affines = self.get_affine(
@@ -476,6 +545,10 @@ def get_nifti1image(
 
     niiobjs = []
     for i, dataobj in enumerate(dataobjs):
+        if flatten_fg and dataobj.ndim > 4:
+            spatial_shape = dataobj.shape[:3]
+            flattened = int(np.prod(dataobj.shape[3:]))
+            dataobj = dataobj.reshape((*spatial_shape, flattened), order="A")
         affine = affines[i]
         niiobj = Nifti1Image(dataobj, affine)
         nifti1header_contents = nifti_resolver.resolve(
@@ -503,6 +576,7 @@ def convert(
     override_subject_type: Optional[SubjectType] = None,
     override_subject_pose: Optional[SubjectPose] = None,
     flip_x: bool = False,
+    flatten_fg: bool = False,
     xyz_units: XYZUNIT = "mm",
     t_units: TUNIT = "sec",
     hook_args_by_name: Optional[Mapping[str, Mapping[str, Any]]] = None,
@@ -518,6 +592,7 @@ def convert(
         override_subject_type=override_subject_type,
         override_subject_pose=override_subject_pose,
         flip_x=flip_x,
+        flatten_fg=flatten_fg,
         xyz_units=xyz_units,
         t_units=t_units,
         hook_args_by_name=hook_args_by_name,
@@ -534,9 +609,75 @@ def _resolve_hook_kwargs(
     if not isinstance(hook_name, str) or not hook_name:
         return {}
     values = hook_args_by_name.get(hook_name)
+    if values is None:
+        seen: set[str] = set()
+
+        def _add(candidate: str) -> None:
+            cand = candidate.strip()
+            if not cand or cand in seen:
+                return
+            seen.add(cand)
+
+        _add(hook_name)
+        _add(hook_name.lower())
+        _add(hook_name.replace("_", "-"))
+        _add(hook_name.replace("-", "_"))
+        _add(hook_name.lower().replace("_", "-"))
+        _add(hook_name.lower().replace("-", "_"))
+        _add(f"brkraw-{hook_name}")
+        _add(f"brkraw_{hook_name}")
+        _add(f"brkraw-{hook_name.lower()}")
+        _add(f"brkraw_{hook_name.lower()}")
+        _add(f"brkraw-{hook_name.lower().replace('_', '-')}")
+        _add(f"brkraw_{hook_name.lower().replace('-', '_')}")
+
+        for candidate in sorted(seen):
+            if candidate == hook_name:
+                continue
+            candidate_values = hook_args_by_name.get(candidate)
+            if candidate_values is not None:
+                logger.debug(
+                    "Using hook args for %r from alias %r.",
+                    hook_name,
+                    candidate,
+                )
+                values = candidate_values
+                break
     return dict(values) if isinstance(values, Mapping) else {}
 
 
+def _filter_hook_kwargs(func: Any, hook_kwargs: Mapping[str, Any]) -> Dict[str, Any]:
+    """Drop unsupported hook kwargs for a callable.
+
+    This keeps YAML/CLI presets safe when converter hooks do not accept
+    arbitrary kwargs.
+    """
+    if not hook_kwargs:
+        return {}
+    try:
+        sig = inspect.signature(func)
+    except (TypeError, ValueError):
+        return dict(hook_kwargs)
+    for param in sig.parameters.values():
+        if param.kind == inspect.Parameter.VAR_KEYWORD:
+            return dict(hook_kwargs)
+    allowed = {
+        param.name
+        for param in sig.parameters.values()
+        if param.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+        and param.name != "self"
+    }
+    filtered = {key: value for key, value in hook_kwargs.items() if key in allowed}
+    dropped = [key for key in hook_kwargs.keys() if key not in allowed]
+    if dropped:
+        logger.debug(
+            "Ignoring unsupported hook args for %s: %s",
+            getattr(func, "__name__", "<callable>"),
+            ", ".join(sorted(dropped)),
+        )
+    return filtered
+
+
 def _resolve_metadata_spec(
     scan: "ScanLoader",
     spec: Optional[Union[Mapping[str, Any], str, Path]],

brkraw/apps/loader/info/scan.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import Any, cast, TYPE_CHECKING, Dict, Optional, Union
 from pathlib import Path
+import logging
 from ....specs.remapper import load_spec, map_parameters
 from ....specs.remapper.validator import validate_spec
 
@@ -9,6 +10,8 @@ from ....specs.remapper.validator import validate_spec
 if TYPE_CHECKING:
     from ..types import ScanLoader, RecoLoader
 
+logger = logging.getLogger("brkraw")
+
 
 def resolve(
     scan: "ScanLoader",
@@ -59,14 +62,24 @@ def resolve(
     if len(scan.avail):
         results['Reco(s)'] = {}
         for reco_id in scan.avail.keys():
-            reco_spec = {"Type": {"sources": [
+            reco_spec = {
+                "Type": {
+                    "sources": [
                         {
-                            'file': "visu_pars",
-                            'key': "VisuCoreFrameType",
-                            'reco_id': reco_id
+                            "file": "visu_pars",
+                            "key": "VisuCoreFrameType",
+                            "reco_id": reco_id,
                         }
                     ]
                 }
             }
-            results['Reco(s)'][reco_id] = map_parameters(scan, reco_spec)
+            try:
+                results["Reco(s)"][reco_id] = map_parameters(scan, reco_spec)
+            except (FileNotFoundError, AttributeError) as exc:
+                logger.warning(
+                    "visu_pars missing for scan %s reco %s; skipping reco entry: %s",
+                    getattr(scan, "scan_id", "unknown"),
+                    reco_id,
+                    exc,
+                )
     return results

brkraw/apps/loader/types.py

@@ -75,6 +75,7 @@ class GetNifti1ImageType(Protocol):
         override_subject_type: Optional[SubjectType],
         override_subject_pose: Optional[SubjectPose],
         flip_x: bool,
+        flatten_fg: bool,
         xyz_units: XYZUNIT,
         t_units: TUNIT,
         **kwargs: Any,
@@ -95,6 +96,7 @@ class ConvertType(Protocol):
         override_subject_type: Optional[SubjectType],
         override_subject_pose: Optional[SubjectPose],
         flip_x: bool,
+        flatten_fg: bool,
         xyz_units: XYZUNIT,
         t_units: TUNIT,
         **kwargs: Any,
@@ -147,7 +149,8 @@ class ScanLoader(Scan, BaseLoader):
             space: AffineSpace = "subject_ras",
             override_subject_type: Optional[SubjectType],
             override_subject_pose: Optional[SubjectPose],
-            decimals: Optional[int] = None
+            decimals: Optional[int] = None,
+            **kwargs: Any,
             ) -> Optional[Union[Tuple["np.ndarray", ...], "np.ndarray"]]:
         ...
 
@@ -160,6 +163,7 @@ class ScanLoader(Scan, BaseLoader):
             override_subject_type: Optional[SubjectType],
             override_subject_pose: Optional[SubjectPose],
             flip_x: bool, 
+            flatten_fg: bool,
             xyz_units: XYZUNIT, 
             t_units: TUNIT
             ) -> Optional[Union[Tuple["Nifti1Image", ...], "Nifti1Image"]]:
@@ -175,6 +179,7 @@ class ScanLoader(Scan, BaseLoader):
             override_subject_type: Optional[SubjectType],
             override_subject_pose: Optional[SubjectPose],
             flip_x: bool,
+            flatten_fg: bool,
             xyz_units: XYZUNIT,
             t_units: TUNIT,
             hook_args_by_name: Optional[Mapping[str, Mapping[str, Any]]] = None,