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

brkraw/cli/hook_args.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Mapping
+
+import yaml
+
+
+def merge_hook_args(
+    base: Mapping[str, Mapping[str, Any]],
+    override: Mapping[str, Mapping[str, Any]],
+) -> Dict[str, Dict[str, Any]]:
+    merged: Dict[str, Dict[str, Any]] = {}
+    for hook_name, values in base.items():
+        if not isinstance(hook_name, str) or not hook_name:
+            continue
+        if not isinstance(values, Mapping):
+            continue
+        merged[hook_name] = dict(values)
+    for hook_name, values in override.items():
+        if not isinstance(hook_name, str) or not hook_name:
+            continue
+        if not isinstance(values, Mapping):
+            continue
+        merged.setdefault(hook_name, {}).update(dict(values))
+    return merged
+
+
+def load_hook_args_yaml(paths: List[str]) -> Dict[str, Dict[str, Any]]:
+    """Load hook args mapping from YAML files.
+
+    Supported YAML formats:
+      - `{hooks: {hook_name: {key: value}}}`
+      - `{hook_name: {key: value}}`
+    """
+
+    merged: Dict[str, Dict[str, Any]] = {}
+
+    def normalize_doc(doc: Any, *, source: str) -> Dict[str, Dict[str, Any]]:
+        if doc is None:
+            return {}
+        hooks_obj = doc.get("hooks") if isinstance(doc, Mapping) else None
+        if hooks_obj is None and isinstance(doc, Mapping):
+            hooks_obj = doc
+        if not isinstance(hooks_obj, Mapping):
+            raise ValueError(f"Invalid hook args YAML in {source!r}: expected mapping.")
+
+        out: Dict[str, Dict[str, Any]] = {}
+        for hook_name, values in hooks_obj.items():
+            if not isinstance(hook_name, str) or not hook_name.strip():
+                continue
+            if values is None:
+                continue
+            if not isinstance(values, Mapping):
+                raise ValueError(
+                    f"Invalid hook args YAML in {source!r}: hook {hook_name!r} must map to a dict."
+                )
+            out[hook_name.strip()] = dict(values)
+        return out
+
+    for raw in paths:
+        source = raw.strip()
+        if not source:
+            continue
+        if source == "-":
+            doc = yaml.safe_load(sys.stdin.read())
+        else:
+            path = Path(source).expanduser()
+            if not path.exists():
+                raise ValueError(f"Hook args YAML not found: {source}")
+            doc = yaml.safe_load(path.read_text(encoding="utf-8"))
+        parsed = normalize_doc(doc, source=source)
+        merged = merge_hook_args(merged, parsed)
+
+    return merged
+
+
+__all__ = ["load_hook_args_yaml", "merge_hook_args"]
+

brkraw/core/config.py

@@ -42,6 +42,14 @@ output:
   slicepack_suffix: "_slpack{index}"
   # float_decimals: 6
 
+# Viewer settings for brkraw-viewer (optional GUI extension).
+viewer:
+  cache:
+    # Cache loaded scan data in memory to speed up space/pose changes.
+    enabled: true
+    # Maximum number of scan/reco entries to keep (LRU). 0 disables caching.
+    max_items: 10
+
 # rules_dir: rules
 # specs_dir: specs
 # pruner_specs_dir: pruner_specs

brkraw/core/layout.py

@@ -31,6 +31,7 @@ def render_layout(
     context_map: Optional[Union[str, Path]] = None,
     root: Optional[Union[str, Path]] = None,
     reco_id: Optional[int] = None,
+    counter: Optional[int] = None,
     override_info_spec: Optional[Union[str, Path]] = None,
     override_metadata_spec: Optional[Union[str, Path]] = None,
 ) -> str:
@@ -50,8 +51,8 @@ def render_layout(
         override_metadata_spec=override_metadata_spec,
     )
     if isinstance(layout_template, str) and layout_template:
-        return _render_layout_template(layout_template, info, scan_id)
-    return _render_fields(layout_entries, info, scan_id)
+        return _render_layout_template(layout_template, info, scan_id, reco_id=reco_id, counter=counter)
+    return _render_fields(layout_entries, info, scan_id, reco_id=reco_id, counter=counter)
 
 
 def load_layout_info(
@@ -111,6 +112,12 @@ def load_layout_info_parts(
         if not isinstance(mapped, dict):
             raise ValueError("override_info_spec must resolve to a mapping.")
         info = mapped
+        study_info = info_resolver.study(loader) or {}
+        if isinstance(study_info, dict):
+            if "Study" in study_info and "Study" not in info:
+                info["Study"] = study_info["Study"]
+            if "Subject" in study_info and "Subject" not in info:
+                info["Subject"] = study_info["Subject"]
     else:
         study_info = info_resolver.study(loader) or {}
         scan_info = info_resolver.scan(scan) or {}
@@ -152,19 +159,26 @@ def render_slicepack_suffixes(
     *,
     count: int,
     template: str = "_slpack{index}",
+    counter: Optional[int] = None,
 ) -> List[str]:
     suffixes: List[str] = []
     for idx in range(count):
-        suffixes.append(_render_slicepack_suffix(template, info, idx))
+        suffixes.append(_render_slicepack_suffix(template, info, idx, counter=counter))
     return suffixes
 
 
-def _render_slicepack_suffix(template: str, info: Mapping[str, Any], idx: int) -> str:
+def _render_slicepack_suffix(
+    template: str,
+    info: Mapping[str, Any],
+    idx: int,
+    *,
+    counter: Optional[int],
+) -> str:
     def _replace(match: re.Match[str]) -> str:
         tag = match.group(1)
         if tag.lower() == "index":
             return str(idx + 1)
-        value = _resolve_tag(tag, info, idx + 1)
+        value = _resolve_tag(tag, info, idx + 1, reco_id=None, counter=counter)
         chosen = _select_indexed_value(value, idx)
         if chosen is None:
             return str(idx + 1)
@@ -214,6 +228,9 @@ def _render_fields(
     fields: Optional[Iterable[Mapping[str, Any]]],
     info: Mapping[str, Any],
     scan_id: int,
+    *,
+    reco_id: Optional[int],
+    counter: Optional[int],
 ) -> str:
     parts: List[str] = []
     seps: List[Optional[str]] = []
@@ -250,7 +267,7 @@ def _render_fields(
                 entry_clean = key.replace(".", "").lower()
                 if not _ENTRY_PATTERN.match(entry_clean):
                     continue
-            value = _resolve_tag(key, info, scan_id)
+            value = _resolve_tag(key, info, scan_id, reco_id=reco_id, counter=counter)
             value_str = _format_value_with_options(
                 value,
                 value_pattern=value_pattern,
@@ -297,25 +314,53 @@ def _render_fields(
     return result
 
 
-def _render_layout_template(template: str, info: Mapping[str, Any], scan_id: int) -> str:
+def _render_layout_template(
+    template: str,
+    info: Mapping[str, Any],
+    scan_id: int,
+    *,
+    reco_id: Optional[int],
+    counter: Optional[int],
+) -> str:
     if not _LAYOUT_TAG.search(template):
         return template
-    rendered = _LAYOUT_TAG.sub(lambda m: _resolve_layout_tag(m, info, scan_id), template)
+    rendered = _LAYOUT_TAG.sub(
+        lambda m: _resolve_layout_tag(m, info, scan_id, reco_id=reco_id, counter=counter),
+        template,
+    )
     return rendered or template
 
 
-def _resolve_layout_tag(match: re.Match[str], info: Mapping[str, Any], scan_id: int) -> str:
+def _resolve_layout_tag(
+    match: re.Match[str],
+    info: Mapping[str, Any],
+    scan_id: int,
+    *,
+    reco_id: Optional[int],
+    counter: Optional[int],
+) -> str:
     tag = match.group(1) or ""
     if not tag:
         return ""
-    value = _resolve_tag(tag.strip(), info, scan_id)
+    value = _resolve_tag(tag.strip(), info, scan_id, reco_id=reco_id, counter=counter)
     rendered = _format_value(value)
     return rendered or ""
 
 
-def _resolve_tag(tag: str, info: Mapping[str, Any], scan_id: int) -> Any:
+def _resolve_tag(
+    tag: str,
+    info: Mapping[str, Any],
+    scan_id: int,
+    *,
+    reco_id: Optional[int] = None,
+    counter: Optional[int] = None,
+) -> Any:
     if tag in {"ScanID", "scan_id", "scanid"}:
         return scan_id
+    if tag in {"RecoID", "reco_id", "recoid"}:
+        return reco_id
+    if tag in {"Counter", "counter"}:
+        return counter
     if "." in tag:
         root_key, rest = tag.split(".", 1)
         root_val = info.get(root_key)

brkraw/default/rules/00_default.yaml

@@ -0,0 +1,4 @@
+metadata_spec:
+  - name: "metadata-dicom"
+    description: "Default metadata mapping for Bruker scans."
+    use: "specs/metadata_dicom.yaml"

brkraw/default/specs/metadata_dicom.yaml

@@ -0,0 +1,236 @@
+__meta__:
+  name: "metadata_dicom"
+  version: "0.0.1"
+  description: "DICOM metadata mapping for Bruker PvDataset."
+  category: "metadata_spec"
+  transforms_source: "metadata_transforms.py"
+
+ImageType:
+  sources:
+    - file: visu_pars
+      key: VisuSeriesTypeId
+  transform: strip_jcamp_string
+
+AcquisitionDateTime:
+  sources:
+    - file: visu_pars
+      key: VisuAcqDate
+  transform: strip_jcamp_string
+
+MagneticFieldStrength:
+  sources:
+    - file: visu_pars
+      key: VisuMagneticFieldStrength
+
+ScanningSequence:
+  sources:
+    - file: visu_pars
+      key: VisuAcqSequenceName
+  transform: strip_jcamp_string
+
+SequenceVariant:
+  sources:
+    - file: visu_pars
+      key: VisuAcqSequenceName
+  transform: strip_jcamp_string
+
+ScanOptions:
+  sources:
+    - file: visu_pars
+      key: VisuAcqSpectralSuppression
+  transform: strip_jcamp_string
+
+RepetitionTime:
+  sources:
+    - file: visu_pars
+      key: VisuAcqRepetitionTime
+
+EchoTime:
+  sources:
+    - file: visu_pars
+      key: VisuAcqEchoTime
+
+InversionTime:
+  sources:
+    - file: visu_pars
+      key: VisuAcqInversionTime
+
+FlipAngle:
+  sources:
+    - file: visu_pars
+      key: VisuAcqFlipAngle
+
+SliceThickness:
+  sources:
+    - file: visu_pars
+      key: VisuCoreSliceThickness
+
+PixelBandwidth:
+  sources:
+    - file: visu_pars
+      key: VisuAcqPixelBandwidth
+
+InPlanePhaseEncodingDirection:
+  sources:
+    - file: visu_pars
+      key: VisuAcqGradEncoding
+
+PercentSampling:
+  sources:
+    - file: visu_pars
+      key: VisuAcqPartialFourier
+
+PercentPhaseFieldOfView:
+  sources:
+    - file: visu_pars
+      key: VisuCoreExtent
+
+PixelSpacing:
+  inputs:
+    extent:
+      sources:
+        - file: visu_pars
+          key: VisuCoreExtent
+    size:
+      sources:
+        - file: visu_pars
+          key: VisuCoreSize
+  transform: pixel_spacing_from_extent
+
+SliceThickness_FG:
+  sources:
+    - file: visu_pars
+      key: VisuCoreSliceThickness
+
+ImagePositionPatient:
+  sources:
+    - file: visu_pars
+      key: VisuCorePosition
+  transform: as_list
+
+ImageOrientationPatient:
+  sources:
+    - file: visu_pars
+      key: VisuCoreOrientation
+  transform: as_list
+
+RescaleSlope_FG:
+  sources:
+    - file: visu_pars
+      key: VisuCoreDataSlope
+
+RescaleIntercept_FG:
+  sources:
+    - file: visu_pars
+      key: VisuCoreDataOffs
+
+RepetitionTime_FG:
+  sources:
+    - file: visu_pars
+      key: VisuAcqRepetitionTime
+
+EchoTime_FG:
+  sources:
+    - file: visu_pars
+      key: VisuAcqEchoTime
+
+FlipAngle_FG:
+  sources:
+    - file: visu_pars
+      key: VisuAcqFlipAngle
+
+EchoTrainLength:
+  sources:
+    - file: visu_pars
+      key: VisuAcqEchoTrainLength
+
+NumberOfAverages:
+  sources:
+    - file: visu_pars
+      key: VisuAcqNAverages
+
+PartialFourier:
+  sources:
+    - file: visu_pars
+      key: VisuAcqPartialFourier
+
+PhaseEncodingDirectionPositive:
+  sources:
+    - file: visu_pars
+      key: VisuAcqGradEncoding
+
+DiffusionBValue_FG:
+  sources:
+    - file: visu_pars
+      key: VisuAcqDiffusionBMatrix
+
+DiffusionGradientOrientation_FG:
+  sources:
+    - file: visu_pars
+      key: VisuAcqDiffusionGradOrient
+  transform: as_list
+
+MRSpectroscopyAcquisitionType:
+  sources:
+    - file: visu_pars
+      key: VisuMrsAcquisitionType
+  transform: strip_jcamp_string
+
+ResonantNucleus:
+  sources:
+    - file: visu_pars
+      key: VisuMrsResonantNuclei
+  transform: strip_jcamp_string
+
+SpectralWidth_MRS:
+  sources:
+    - file: visu_pars
+      key: VisuMrsSpectralWidth
+
+TransmitterFrequency_MRS:
+  sources:
+    - file: visu_pars
+      key: VisuMrsTransmitterFreq
+
+ChemicalShiftReference:
+  sources:
+    - file: visu_pars
+      key: VisuMrsChemicalShiftRef
+
+NumberOfZeroFills:
+  sources:
+    - file: visu_pars
+      key: VisuMrsZeroFill
+
+KSpaceFiltering:
+  sources:
+    - file: visu_pars
+      key: VisuAcqKSpaceFiltering
+
+PulseSequenceName_MRS:
+  sources:
+    - file: visu_pars
+      key: VisuAcqSequenceName
+  transform: strip_jcamp_string
+
+EchoTime_MRS:
+  sources:
+    - file: visu_pars
+      key: VisuAcqEchoTime
+
+RepetitionTime_MRS:
+  sources:
+    - file: visu_pars
+      key: VisuAcqRepetitionTime
+
+WaterSuppression:
+  sources:
+    - file: visu_pars
+      key: VisuAcqSpectralSuppression
+  transform: strip_jcamp_string
+
+VolumeLocalizationTechnique:
+  sources:
+    - file: visu_pars
+      key: VisuMrsLocalizationTechnique
+  transform: strip_jcamp_string

brkraw/default/specs/metadata_transforms.py

@@ -51,6 +51,24 @@ def as_list(value):
     return [value]
 
 
+def pixel_spacing_from_extent(extent=None, size=None):
+    if extent is None or size is None:
+        return None
+    arr_extent = np.asarray(extent, dtype=float).ravel()
+    arr_size = np.asarray(size, dtype=float).ravel()
+    if arr_extent.size == 0 or arr_size.size == 0:
+        return None
+    if arr_extent.size != arr_size.size:
+        count = min(arr_extent.size, arr_size.size)
+        if count == 0:
+            return None
+        arr_extent = arr_extent[:count]
+        arr_size = arr_size[:count]
+    with np.errstate(divide="ignore", invalid="ignore"):
+        spacing = arr_extent / arr_size
+    return spacing.tolist()
+
+
 def normalize_method(value: Optional[str]) -> str:
     return strip_jcamp_string(value).upper()
 

brkraw/resolver/affine.py

@@ -328,42 +328,66 @@ def resolve_matvec_and_shape(visu_pars,
     shape  = np.asarray(visu_pars.get("VisuCoreSize"), dtype=float)
 
     if dim == 2:
-        num_rotates = rotate.shape[0]
-        num_origins = origin.shape[0]
         num_slicepack = len(num_slices)
-        if num_rotates != num_origins:
-            raise ValueError("num_rotates != num_origins")
-
-        expected = int(num_slicepack * num_slices[spack_idx])
-        if rotate.ndim == 2 and rotate.shape[1] == 9 and rotate.shape[0] > expected:
-            if not np.allclose(rotate, rotate[0], atol=0, rtol=0):
-                logger.warning(
-                    "VisuCoreOrientation has %s entries but expected %s; "
-                    "using the first %s entry/entries.",
-                    rotate.shape[0],
-                    expected,
-                    expected,
-                )
-        if origin.ndim == 2 and origin.shape[1] == 3 and origin.shape[0] > expected:
-            if not np.allclose(origin, origin[0], atol=0, rtol=0):
-                logger.warning(
-                    "VisuCorePosition has %s entries but expected %s; "
-                    "using the first %s entry/entries.",
-                    origin.shape[0],
-                    expected,
-                    expected,
-                )
-        if rotate.ndim == 2 and rotate.shape[1] == 9 and rotate.shape[0] >= expected:
-            rotate = rotate[:expected, :]
-        if origin.ndim == 2 and origin.shape[1] == 3 and origin.shape[0] >= expected:
-            origin = origin[:expected, :]
-        rotate = rotate.reshape((num_slicepack, num_slices[spack_idx], 9))
-        origin = origin.reshape((num_slicepack, num_slices[spack_idx], 3))
-        _rotate = rotate[spack_idx]
-        _origin = origin[spack_idx]
+
+        if spack_idx < 0 or spack_idx >= num_slicepack:
+            raise IndexError(f"spack_idx out of range: {spack_idx} (num packs: {num_slicepack})")
+
+        total_slices = int(np.sum(np.asarray(num_slices, dtype=int)))
+        spack_slice_start = int(np.sum(np.asarray(num_slices[:spack_idx], dtype=int)))
+        spack_slice_end = spack_slice_start + int(num_slices[spack_idx])
+
+        def _select_slice_entries(arr: np.ndarray, *, width: int, name: str) -> np.ndarray:
+            arr = np.asarray(arr, dtype=float)
+            if arr.ndim == 1:
+                if arr.size == width:
+                    arr = arr.reshape((1, width))
+                else:
+                    raise ValueError(f"{name} has shape {arr.shape}, expected (*, {width})")
+            if arr.ndim != 2 or arr.shape[1] != width:
+                raise ValueError(f"{name} has shape {arr.shape}, expected (*, {width})")
+
+            # Prefer per-slice entries (concatenated across slice packs).
+            if arr.shape[0] > total_slices:
+                if not np.allclose(arr[:total_slices], arr[0], atol=0, rtol=0):
+                    logger.warning(
+                        "%s has %s entries but expected %s; using the first %s entries.",
+                        name,
+                        arr.shape[0],
+                        total_slices,
+                        total_slices,
+                    )
+                arr = arr[:total_slices, :]
+
+            if arr.shape[0] == total_slices:
+                return arr[spack_slice_start:spack_slice_end, :]
+
+            # Fallback: per-pack entries (one entry per slice pack).
+            if arr.shape[0] == num_slicepack:
+                if int(num_slices[spack_idx]) != 1:
+                    raise ValueError(
+                        f"{name} provides one entry per slice pack ({num_slicepack}) "
+                        f"but pack {spack_idx} has {num_slices[spack_idx]} slices; "
+                        "per-slice entries are required to resolve slice positions."
+                    )
+                return arr[spack_idx:spack_idx + 1, :]
+
+            raise ValueError(
+                f"{name} has {arr.shape[0]} entries, expected {total_slices} (per-slice) "
+                f"or {num_slicepack} (per-pack); method num_slices={num_slices}."
+            )
+
+        _rotate = _select_slice_entries(rotate, width=9, name="VisuCoreOrientation")
+        _origin = _select_slice_entries(origin, width=3, name="VisuCorePosition")
         _num_slices = num_slices[spack_idx]
         _slice_thickness = slice_thickness[spack_idx]
         
+        if _rotate.shape[0] > 1 and not np.allclose(_rotate, _rotate[0], atol=0, rtol=0):
+            logger.warning(
+                "VisuCoreOrientation varies across slices in pack %s; using the first slice orientation.",
+                spack_idx,
+            )
+
         row = _rotate[0, 0:3]
         col = _rotate[0, 3:6]
         slc = _rotate[0, 6:9]

brkraw/schema/context_map.yaml

@@ -55,3 +55,8 @@ $defs:
         type: object
         description: "Conditions evaluated against mapped values."
         additionalProperties: true
+      cases:
+        type: array
+        description: "Nested rule list evaluated after the parent rule matches."
+        items:
+          $ref: "#/$defs/Rule"

brkraw/schema/remapper.yaml

@@ -41,6 +41,10 @@ $defs:
         type: object
         additionalProperties: { $ref: "#/$defs/Input" }
         description: "Named inputs that are passed to a transform or returned as-is."
+      const: {}
+      ref:
+        type: string
+        description: "Dot path to a previously resolved output value."
       transform:
         anyOf:
           - type: string
@@ -52,6 +56,8 @@ $defs:
     oneOf:
       - required: ["sources"]
       - required: ["inputs"]
+      - required: ["const"]
+      - required: ["ref"]
 
   Source:
     type: object

brkraw/specs/__init__.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from . import converter, pruner, remapper, rules
+from . import hook, pruner, remapper, rules
 
 __all__ = [
-    "converter",
+    "hook",
     "pruner",
     "remapper",
     "rules",

brkraw/specs/{converter → hook}/logic.py

@@ -28,3 +28,4 @@ def resolve_hook(
 
 
 __all__ = ["DEFAULT_GROUP", "resolve_hook"]
+

brkraw/specs/{converter → hook}/validator.py

@@ -19,3 +19,4 @@ def validate_hook(hook: Any, *, raise_on_error: bool = True) -> List[str]:
     if errors and raise_on_error:
         raise ValueError("Invalid converter hook:\n" + "\n".join(errors))
     return errors
+