brkraw 0.5.3__py3-none-any.whl → 0.5.6__py3-none-any.whl

brkraw/cli/commands/cache.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import argparse
+import logging
+from typing import Optional
+
+from ...core import cache
+
+logger = logging.getLogger(__name__)
+
+
+def cmd_cache(args: argparse.Namespace) -> int:
+    handler = getattr(args, "cache_func", None)
+    if handler is None:
+        args.parser.print_help()
+        return 2
+    return handler(args)
+
+
+def cmd_info(args: argparse.Namespace) -> int:
+    info = cache.get_info(root=args.root)
+    path = info["path"]
+    size = info["size"]
+    count = info["count"]
+
+    # Format size
+    unit = "B"
+    size_f = float(size)
+    for u in ["B", "KB", "MB", "GB", "TB"]:
+        unit = u
+        if size_f < 1024:
+            break
+        size_f /= 1024
+
+    print(f"Path:  {path}")
+    print(f"Size:  {size_f:.2f} {unit}")
+    print(f"Files: {count}")
+    return 0
+
+
+def cmd_clear(args: argparse.Namespace) -> int:
+    if not args.yes:
+        info = cache.get_info(root=args.root)
+        if info["count"] == 0:
+            print("Cache is already empty.")
+            return 0
+        path = info["path"]
+        prompt = f"Clear {info['count']} files from {path}? [y/N]: "
+        try:
+            reply = input(prompt).strip().lower()
+        except EOFError:
+            reply = ""
+        if reply not in {"y", "yes"}:
+            return 1
+    
+    cache.clear(root=args.root)
+    print("Cache cleared.")
+    return 0
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:  # type: ignore[name-defined]
+    cache_parser = subparsers.add_parser(
+        "cache",
+        help="Manage brkraw cache.",
+    )
+    cache_parser.add_argument(
+        "--root",
+        help="Override config root directory (default: BRKRAW_CONFIG_HOME or ~/.brkraw).",
+    )
+    cache_parser.set_defaults(func=cmd_cache, parser=cache_parser)
+    cache_sub = cache_parser.add_subparsers(dest="cache_command")
+
+    info_parser = cache_sub.add_parser("info", help="Show cache information.")
+    info_parser.set_defaults(cache_func=cmd_info)
+
+    clear_parser = cache_sub.add_parser("clear", help="Clear cache contents.")
+    clear_parser.add_argument(
+        "--yes", "-y",
+        action="store_true",
+        help="Do not prompt for confirmation.",
+    )
+    clear_parser.set_defaults(cache_func=cmd_clear)

brkraw/cli/commands/config.py

@@ -11,7 +11,7 @@ import subprocess
 
 from brkraw.core import config as config_core
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 
 def cmd_config(args: argparse.Namespace) -> int:
@@ -179,7 +179,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:  # type: ignore[na
     path_parser = config_sub.add_parser("path", help="Print a specific config path.")
     path_parser.add_argument(
         "name",
-        choices=["root", "config", "rules", "specs", "transforms"],
+        choices=["root", "config", "rules", "specs", "transforms", "cache"],
         help="Path key to print.",
     )
     path_parser.set_defaults(config_func=cmd_path)

brkraw/cli/commands/convert.py

@@ -11,7 +11,6 @@ import json
 import logging
 import os
 import re
-import sys
 from pathlib import Path
 from typing import Any, Mapping, Optional, Dict, List, Tuple, cast, get_args
 
@@ -27,7 +26,7 @@ from brkraw.resolver.affine import SubjectPose, SubjectType
 from brkraw.apps.loader.types import AffineSpace
 
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 _INVALID_CHARS = re.compile(r"[^A-Za-z0-9._-]+")
 
@@ -86,6 +85,28 @@ def cmd_convert(args: argparse.Namespace) -> int:
         return 2
     if not args.flatten_fg:
         args.flatten_fg = _env_flag("BRKRAW_CONVERT_FLATTEN_FG")
+
+    # resolve cycle_index/cycle_count from env
+    if args.cycle_index is None:
+        value = os.environ.get("BRKRAW_CONVERT_CYCLE_INDEX")
+        if value:
+            try:
+                args.cycle_index = int(value)
+            except ValueError:
+                logger.error("Invalid BRKRAW_CONVERT_CYCLE_INDEX: %s", value)
+                return 2
+    if args.cycle_count is None:
+        value = os.environ.get("BRKRAW_CONVERT_CYCLE_COUNT")
+        if value:
+            try:
+                args.cycle_count = int(value)
+            except ValueError:
+                logger.error("Invalid BRKRAW_CONVERT_CYCLE_COUNT: %s", value)
+                return 2
+    # if cycle_count is set but cycle_index is not, default cycle_index to 0
+    if args.cycle_index is None and args.cycle_count is not None:
+        args.cycle_index = 0
+
     if args.space is None:
         args.space = os.environ.get("BRKRAW_CONVERT_SPACE")
     if args.override_subject_type is None:
@@ -169,6 +190,7 @@ def cmd_convert(args: argparse.Namespace) -> int:
     hook_args_by_name = merge_hook_args(hook_args_by_name, hook_args_cli)
 
     loader = load(args.path, prefix="Loading")
+    logger.debug("Dataset: %s loaded", args.path)
     try:
         override_header = nifti_resolver.load_header_overrides(args.header)
     except ValueError:
@@ -224,7 +246,9 @@ def cmd_convert(args: argparse.Namespace) -> int:
         if scan_id is None:
             continue
         scan = loader.get_scan(scan_id)
+        logger.debug("Processing scan %s.", scan_id)
         reco_ids = [args.reco_id] if args.reco_id is not None else list(scan.avail.keys())
+        logger.debug("Recos: %s", reco_ids or "None")
         if not reco_ids:
             if getattr(scan, "_converter_hook", None):
                 reco_ids = [None]
@@ -252,18 +276,26 @@ def cmd_convert(args: argparse.Namespace) -> int:
                 nii_list: List[Any] = []
                 output_count = 1
             else:
-                nii = loader.convert(
-                    scan_id,
-                    reco_id=reco_id,
-                    space=cast(AffineSpace, args.space),
-                    override_header=cast(Nifti1HeaderContents, override_header) if override_header else None,
-                    override_subject_type=cast(Optional[SubjectType], args.override_subject_type),
-                    override_subject_pose=cast(Optional[SubjectPose], args.override_subject_pose),
-                    flatten_fg=args.flatten_fg,
-                    xyz_units=cast(XYZUNIT, args.xyz_units),
-                    t_units=cast(TUNIT, args.t_units),
-                    hook_args_by_name=hook_args_by_name,
-                )
+                try:
+                    nii = loader.convert(
+                        scan_id,
+                        reco_id=reco_id,
+                        space=cast(AffineSpace, args.space),
+                        override_header=cast(Nifti1HeaderContents, override_header) if override_header else None,
+                        override_subject_type=cast(Optional[SubjectType], args.override_subject_type),
+                        override_subject_pose=cast(Optional[SubjectPose], args.override_subject_pose),
+                        flatten_fg=args.flatten_fg,
+                        xyz_units=cast(XYZUNIT, args.xyz_units),
+                        t_units=cast(TUNIT, args.t_units),
+                        hook_args_by_name=hook_args_by_name,
+                        cycle_index=args.cycle_index,
+                        cycle_count=args.cycle_count,
+                    )
+                except Exception as exc:
+                    logger.error("Conversion failed for scan %s reco %s: %s", scan_id, reco_id, exc)
+                    if not batch_all and args.reco_id is not None:
+                        return 2
+                    continue
                 if nii is None:
                     if not batch_all and args.reco_id is not None:
                         logger.error("No NIfTI output generated for scan %s reco %s.", scan_id, reco_id)
@@ -845,6 +877,16 @@ def _add_convert_args(
         action="store_true",
         help="Flatten frame-group dimensions to 4D when data is 5D or higher.",
     )
+    parser.add_argument(
+        "--cycle-index",
+        type=int,
+        help="Start cycle index (last axis). When set, read only a subset of cycles.",
+    )
+    parser.add_argument(
+        "--cycle-count",
+        type=int,
+        help="Number of cycles to read starting at --cycle-index. When omitted, reads to the end.",
+    )
     parser.add_argument(
         "--no-compress",
         dest="compress",

brkraw/cli/commands/hook.py

@@ -15,7 +15,7 @@ from brkraw.core import formatter
 from brkraw.specs import hook as converter_core
 import yaml
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 
 def cmd_hook(args: argparse.Namespace) -> int:

brkraw/cli/commands/info.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from brkraw.core import config as config_core
 from brkraw.cli.utils import load
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 
 def cmd_info(args: argparse.Namespace) -> int:

brkraw/cli/commands/init.py

@@ -13,7 +13,7 @@ import yaml
 from brkraw.core import config as config_core
 from brkraw.apps import addon as addon_app
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 
 def cmd_init(args: argparse.Namespace) -> int:

brkraw/cli/commands/params.py

@@ -14,7 +14,7 @@ import numpy as np
 
 from brkraw.cli.utils import load
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 
 def cmd_params(args: argparse.Namespace) -> int:

brkraw/cli/commands/prune.py

@@ -6,7 +6,7 @@ import argparse
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Union
+from typing import Optional
 
 import yaml
 
@@ -14,7 +14,7 @@ from brkraw.cli.utils import spinner
 from brkraw.core import config as config_core
 from brkraw.specs.pruner import prune_dataset_to_zip_from_spec
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 
 def cmd_prune(args: argparse.Namespace) -> int:

brkraw/cli/main.py

@@ -1,5 +1,9 @@
 from __future__ import annotations
 
+import re
+import os
+import shutil
+import subprocess
 import argparse
 from typing import Callable, List, Optional
 from ..core.entrypoints import list_entry_points as _iter_entry_points
@@ -10,6 +14,50 @@ from brkraw.core import config as config_core
 PLUGIN_GROUP = "brkraw.cli"
 
 
+def _run_capture(cmd: list[str]) -> str:
+    p = subprocess.run(cmd, check=True, text=True, capture_output=True)
+    return p.stdout
+
+
+def _pv_autoset_env() -> None:
+    if shutil.which("pvcmd") is None:
+        return
+
+    p = subprocess.run(["pvcmd", "-e", "ParxServer"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    if p.returncode != 0:
+        return
+
+    out = _run_capture(["pvcmd", "-a", "ParxServer", "-r", "ListPs", "-csv"])
+    matches = [line for line in out.splitlines() if "REQUEST_ATTR" in line]
+
+    if len(matches) == 0:
+        raise SystemExit("ERROR: No ps entry with REQUEST_ATTR found")
+    if len(matches) > 1:
+        msg = "ERROR: Multiple ps entries with REQUEST_ATTR found\n" + "\n".join(matches)
+        raise SystemExit(msg)
+
+    line = matches[0]
+    parts = line.split(";")
+
+    m = None
+    for f in parts:
+        f = f.strip()
+        m = re.match(r"^(?P<exp_path>.+)/(?P<scan_id>\d+)/pdata/(?P<reco_id>\d+)$", f)
+        if m:
+            break
+
+    if not m:
+        raise SystemExit("ERROR: No valid <exp_path>/<scan_id>/pdata/<reco_id> path found")
+
+    exp_path = m.group("exp_path")
+    scan_id = m.group("scan_id")
+    reco_id = m.group("reco_id")
+
+    os.environ["BRKRAW_PATH"] = exp_path
+    os.environ["BRKRAW_SCAN_ID"] = scan_id
+    os.environ["BRKRAW_RECO_ID"] = reco_id
+
+
 def _register_entry_point_commands(
     subparsers: argparse._SubParsersAction,  # type: ignore[name-defined]
 ) -> None:
@@ -26,6 +74,7 @@ def _register_entry_point_commands(
     preferred = [
         "init",
         "config",
+        "cache",
         "session",
         "info",
         "params",
@@ -70,7 +119,8 @@ def main(argv: Optional[List[str]] = None) -> int:
     )
 
     _register_entry_point_commands(subparsers)
-
+    _pv_autoset_env()
+    
     args = parser.parse_args(argv)
     if not hasattr(args, "func"):
         parser.print_help()

brkraw/cli/utils.py

@@ -14,7 +14,7 @@ from typing import Iterator, List
 
 from brkraw.apps.loader import BrukerLoader
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 @contextmanager
 def spinner(prefix: str = "Loading") -> Iterator[None]:

brkraw/core/cache.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import os
+import logging
+import shutil
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from . import config
+
+logger = logging.getLogger("brkraw.cache")
+
+
+def get_info(
+    root: Optional[Union[str, Path]] = None,
+    path: Optional[Union[str, Path]] = None,
+) -> Dict[str, Any]:
+    """
+    Get information about the current cache directory.
+
+    Args:
+        root: Configuration root directory (used to resolve default cache path).
+        path: Explicit path to the cache directory. If provided, overrides 'root'.
+
+    Returns:
+        Dict with keys:
+            - path: Path to cache directory
+            - size: Total size in bytes
+            - count: Number of files
+    """
+    if path is not None:
+        cache_path = Path(path)
+    else:
+        cache_path = config.cache_dir(root)
+
+    if not cache_path.exists():
+        return {"path": cache_path, "size": 0, "count": 0}
+
+    total_size = 0
+    file_count = 0
+    
+    for dirpath, _, filenames in os.walk(str(cache_path), followlinks=True):
+        for f in filenames:
+            try:
+                fp = Path(dirpath) / f
+                if fp.is_symlink():
+                    continue
+                total_size += fp.stat().st_size
+                file_count += 1
+            except OSError as e:
+                continue
+    
+    return {
+        "path": cache_path,
+        "size": total_size,
+        "count": file_count
+    }
+
+
+def clear(
+    root: Optional[Union[str, Path]] = None,
+    path: Optional[Union[str, Path]] = None,
+) -> None:
+    """
+    Clear all files in the cache directory.
+
+    Args:
+        root: Configuration root directory (used to resolve default cache path).
+        path: Explicit path to the cache directory. If provided, overrides 'root'.
+    """
+    if path is not None:
+        cache_path = Path(path)
+    else:
+        cache_path = config.cache_dir(root)
+
+    if not cache_path.exists():
+        return
+
+    logger.info("Clearing cache at: %s", cache_path)
+    for item in cache_path.iterdir():
+        try:
+            if item.is_file() or item.is_symlink():
+                item.unlink()
+            elif item.is_dir():
+                shutil.rmtree(item)
+        except Exception as exc:
+            logger.warning("Failed to remove %s: %s", item, exc)

brkraw/core/config.py

@@ -65,6 +65,7 @@ class ConfigPaths:
     pruner_specs_dir: Path
     rules_dir: Path
     transforms_dir: Path
+    cache_dir: Path
 
 
 def resolve_root(root: Optional[Union[str, Path]] = None) -> Path:
@@ -85,6 +86,7 @@ def get_paths(root: Optional[Union[str, Path]] = None) -> ConfigPaths:
         pruner_specs_dir=base / "pruner_specs",
         rules_dir=base / "rules",
         transforms_dir=base / "transforms",
+        cache_dir=base / "cache",
     )
 
 
@@ -101,6 +103,7 @@ def get_path(name: str, root: Optional[Union[str, Path]] = None) -> Path:
         "pruner_specs": paths_obj.pruner_specs_dir,
         "rules": paths_obj.rules_dir,
         "transforms": paths_obj.transforms_dir,
+        "cache": paths_obj.cache_dir,
     }
     if name not in mapping:
         raise KeyError(f"Unknown config path: {name}")
@@ -126,6 +129,7 @@ def ensure_initialized(
     paths.pruner_specs_dir.mkdir(parents=True, exist_ok=True)
     paths.rules_dir.mkdir(parents=True, exist_ok=True)
     paths.transforms_dir.mkdir(parents=True, exist_ok=True)
+    paths.cache_dir.mkdir(parents=True, exist_ok=True)
     if create_config and not paths.config_file.exists():
         paths.config_file.write_text(DEFAULT_CONFIG_YAML, encoding="utf-8")
     return paths
@@ -140,6 +144,10 @@ def init(
     return ensure_initialized(root=root, create_config=create_config, exist_ok=exist_ok)
 
 
+def cache_dir(root: Optional[Union[str, Path]] = None) -> Path:
+    return get_paths(root=root).cache_dir
+
+
 def load_config(root: Optional[Union[str, Path]] = None) -> Optional[Dict[str, Any]]:
     paths = get_paths(root)
     if not paths.config_file.exists():
@@ -211,6 +219,7 @@ def clear_config(
     keep_specs: bool = False,
     keep_pruner_specs: bool = False,
     keep_transforms: bool = False,
+    keep_cache: bool = False,
 ) -> None:
     paths = get_paths(root=root)
     if not paths.root.exists():
@@ -225,6 +234,8 @@ def clear_config(
         _remove_tree(paths.pruner_specs_dir)
     if paths.transforms_dir.exists() and not keep_transforms:
         _remove_tree(paths.transforms_dir)
+    if paths.cache_dir.exists() and not keep_cache:
+        _remove_tree(paths.cache_dir)
     try:
         paths.root.rmdir()
     except OSError:
@@ -239,6 +250,7 @@ def clear(
     keep_specs: bool = False,
     keep_pruner_specs: bool = False,
     keep_transforms: bool = False,
+    keep_cache: bool = False,
 ) -> None:
     clear_config(
         root=root,
@@ -247,15 +259,19 @@ def clear(
         keep_specs=keep_specs,
         keep_pruner_specs=keep_pruner_specs,
         keep_transforms=keep_transforms,
+        keep_cache=keep_cache,
     )
 
 
 def configure_logging(
     *,
+    name: Optional[str] = None,
     root: Optional[Union[str, Path]] = None,
     level: Optional[Union[str, int]] = None,
     stream=None,
 ) -> logging.Logger:
+    if name is None:
+        name = "brkraw"
     config = resolve_config(root=root)
     if level is None:
         level = config.get("logging", {}).get("level", "INFO")
@@ -265,9 +281,9 @@ def configure_logging(
         if level == logging.INFO:
             fmt = "%(message)s"
         else:
-            fmt = "%(levelname)s %(asctime)s %(message)s"
+            fmt = "%(asctime)s(%(levelname).1s): %(name)s:%(funcName)s - %(message)s"
         logging.basicConfig(level=level, format=fmt, stream=stream)
-    return logging.getLogger("brkraw")
+    return logging.getLogger(name)
 
 
 def output_width(root: Optional[Union[str, Path]] = None, default: int = 120) -> int:

brkraw/core/fs.py

@@ -221,6 +221,7 @@ class DatasetFS:
         top: str = "",
         *,
         as_objects: bool = False,
+        sort_entries: bool = True,
     ) -> Iterable[Tuple[str, List, List]]:
         """Yield (dirpath, direntries, fileentries) with archive-style paths.
 
@@ -228,13 +229,17 @@ class DatasetFS:
             top: Optional subdirectory to start from (anchor-aware).
             as_objects: When True, return DatasetDir/ZippedDir and
                 DatasetFile/ZippedFile entries; otherwise return name strings.
+            sort_entries: When True, sort directory and file entries for deterministic output.
+                Set to False for faster traversal when ordering does not matter.
 
         Yields:
             Tuples of `(dirpath, direntries, fileentries)` using posix-style paths.
         """
         norm_top = top.strip("/")
-        if self._anchor and norm_top and not norm_top.startswith(self._anchor):
-            norm_top = f"{self._anchor}/{norm_top}"
+        if self._anchor and norm_top:
+            anchored = norm_top == self._anchor or norm_top.startswith(f"{self._anchor}/")
+            if not anchored:
+                norm_top = f"{self._anchor}/{norm_top}"
 
         if self._mode == "dir":
             base = self.root
@@ -254,17 +259,16 @@ class DatasetFS:
                 rel = os.path.relpath(dirpath, base)
                 rel = "" if rel == "." else rel.replace(os.sep, "/")
                 rel = self._ensure_anchor(rel)
-                dirnames = sorted(dirnames)
-                filenames = sorted(filenames)
+                if sort_entries:
+                    dirnames.sort()
+                    filenames.sort()
+
                 if as_objects:
                     dir_objs = [
                         DatasetDir(name=d, path=(f"{rel}/{d}".strip("/")), fs=self) for d in dirnames
                     ]
                     file_objs = [
-                        DatasetFile(
-                            name=f, path=(f"{rel}/{f}".strip("/")), fs=self
-                        )
-                        for f in filenames
+                        DatasetFile(name=f, path=(f"{rel}/{f}".strip("/")), fs=self) for f in filenames
                     ]
                     yield rel, dir_objs, file_objs
                 else:
@@ -272,10 +276,23 @@ class DatasetFS:
         else:
             assert self._zip is not None
             for dirpath, direntries, files in zipcore.walk(self._zip, top=norm_top):
+                if sort_entries:
+                    try:
+                        direntries = sorted(direntries, key=lambda d: d.name)
+                        files = sorted(files, key=lambda f: f.name)
+                    except Exception:
+                        # If entries are plain strings or otherwise unsortable, fall back.
+                        pass
+
                 if as_objects:
                     yield dirpath, direntries, files
                 else:
-                    yield dirpath, [d.name for d in direntries], [f.name for f in files]
+                    dnames = [d.name for d in direntries]
+                    fnames = [f.name for f in files]
+                    if sort_entries:
+                        dnames.sort()
+                        fnames.sort()
+                    yield dirpath, dnames, fnames
 
     def open_binary(self, relpath: str) -> IO[bytes]:
         """Open a file by archive-relative path.