brkraw 0.5.2__py3-none-any.whl → 0.5.5__py3-none-any.whl

brkraw/cli/commands/session.py

@@ -98,14 +98,12 @@ def cmd_unset(args: argparse.Namespace) -> int:
         "BRKRAW_CONVERT_CONTEXT_MAP",
         "BRKRAW_CONVERT_SPACE",
         "BRKRAW_CONVERT_COMPRESS",
-        "BRKRAW_CONVERT_FLIP_X",
         "BRKRAW_CONVERT_FLATTEN_FG",
         "BRKRAW_CONVERT_OVERRIDE_SUBJECT_TYPE",
         "BRKRAW_CONVERT_OVERRIDE_SUBJECT_POSE",
         "BRKRAW_CONVERT_XYZ_UNITS",
         "BRKRAW_CONVERT_T_UNITS",
         "BRKRAW_CONVERT_HEADER",
-        "BRKRAW_CONVERT_FORMAT",
     ]
     targets: List[str] = []
     if args.path:
@@ -153,14 +151,12 @@ def cmd_env(_: argparse.Namespace) -> int:
     convert_context_map = os.environ.get("BRKRAW_CONVERT_CONTEXT_MAP")
     convert_compress = os.environ.get("BRKRAW_CONVERT_COMPRESS")
     convert_space = os.environ.get("BRKRAW_CONVERT_SPACE")
-    convert_flip_x = os.environ.get("BRKRAW_CONVERT_FLIP_X")
     convert_flatten_fg = os.environ.get("BRKRAW_CONVERT_FLATTEN_FG")
     convert_subject_type = os.environ.get("BRKRAW_CONVERT_OVERRIDE_SUBJECT_TYPE")
     convert_subject_pose = os.environ.get("BRKRAW_CONVERT_OVERRIDE_SUBJECT_POSE")
     convert_xyz_units = os.environ.get("BRKRAW_CONVERT_XYZ_UNITS")
     convert_t_units = os.environ.get("BRKRAW_CONVERT_T_UNITS")
     convert_header = os.environ.get("BRKRAW_CONVERT_HEADER")
-    convert_format = os.environ.get("BRKRAW_CONVERT_FORMAT")
     if (
         path is None
         and scan_id is None
@@ -175,14 +171,12 @@ def cmd_env(_: argparse.Namespace) -> int:
         and convert_context_map is None
         and convert_compress is None
         and convert_space is None
-        and convert_flip_x is None
         and convert_flatten_fg is None
         and convert_subject_type is None
         and convert_subject_pose is None
         and convert_xyz_units is None
         and convert_t_units is None
         and convert_header is None
-        and convert_format is None
     ):
         print("(none)")
         return 0
@@ -212,8 +206,6 @@ def cmd_env(_: argparse.Namespace) -> int:
         print(f"BRKRAW_CONVERT_SPACE={convert_space}")
     if convert_compress is not None:
         print(f"BRKRAW_CONVERT_COMPRESS={convert_compress}")
-    if convert_flip_x is not None:
-        print(f"BRKRAW_CONVERT_FLIP_X={convert_flip_x}")
     if convert_flatten_fg is not None:
         print(f"BRKRAW_CONVERT_FLATTEN_FG={convert_flatten_fg}")
     if convert_subject_type is not None:
@@ -226,8 +218,6 @@ def cmd_env(_: argparse.Namespace) -> int:
         print(f"BRKRAW_CONVERT_T_UNITS={convert_t_units}")
     if convert_header is not None:
         print(f"BRKRAW_CONVERT_HEADER={convert_header}")
-    if convert_format is not None:
-        print(f"BRKRAW_CONVERT_FORMAT={convert_format}")
     return 0
 
 
@@ -311,7 +301,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:  # type: ignore[na
         help=(
             "Set BRKRAW_CONVERT_<OPTION> as KEY=VALUE (repeatable). "
             "Keys: OUTPUT, PREFIX, SCAN_ID, RECO_ID, SIDECAR, CONTEXT_MAP, "
-            "COMPRESS, SPACE, FLIP_X, FLATTEN_FG, OVERRIDE_SUBJECT_TYPE, "
+            "COMPRESS, SPACE, FLATTEN_FG, OVERRIDE_SUBJECT_TYPE, "
             "OVERRIDE_SUBJECT_POSE, XYZ_UNITS, T_UNITS, HEADER, FORMAT."
         ),
     )

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.

brkraw/core/zip.py

@@ -588,6 +588,8 @@ class ZippedDir:
 def walk(
     zipobj: zipfile.ZipFile,
     top: str = "",
+    *,
+    sort_entries: bool = True,
 ) -> Iterable[Tuple[str, List[ZippedDir], List[ZippedFile]]]:
     """Walk through a ZipFile like os.walk, but with ZippedFile entries.
 
@@ -600,6 +602,9 @@ def walk(
         paths (for example "repo-abc/dir"). When top does not correspond to an
         explicit directory entry, the function still yields a subtree rooted at
         top, and dirpath values are archive paths under that prefix.
+    sort_entries : bool, optional
+        When True, sort directory names and file names for deterministic output.
+        Set to False for faster traversal when ordering does not matter.
 
     Yields
     ------
@@ -613,61 +618,70 @@ def walk(
     """
     tree_map: Dict[str, Dict[str, Any]] = defaultdict(lambda: {"dirs": set(), "files": {}})
 
-    # Normalize and index
-    for arcname in zipobj.namelist():
+    start = top.strip("/")
+    prefix = f"{start}/" if start else ""
+
+    def _is_dir(info: zipfile.ZipInfo) -> bool:
+        # ZipInfo.is_dir() exists on modern Python, but keep a safe fallback.
+        try:
+            return info.is_dir()  # type: ignore[attr-defined]
+        except Exception:
+            return info.filename.endswith("/")
+
+    # Single pass over the archive; restrict to subtree early when top is given.
+    for info in zipobj.infolist():
+        arcname = info.filename
         norm = arcname.rstrip("/")
+        if not norm:
+            continue
+
+        # Restrict to the requested subtree if provided.
+        if start:
+            if norm != start and not norm.startswith(prefix):
+                continue
+
         parts = norm.split("/")
         parent = "/".join(parts[:-1])  # "" at root
         leaf = parts[-1]
 
-        if arcname.endswith("/"):  # a directory entry
+        if _is_dir(info):
             tree_map[parent]["dirs"].add(leaf)
-        else:  # a file entry
-            tree_map[parent]["files"][leaf] = ZippedFile(
-                name=leaf, arcname=norm, zipobj=zipobj
-            )
+        else:
+            tree_map[parent]["files"][leaf] = ZippedFile(name=leaf, arcname=norm, zipobj=zipobj)
 
-        # ensure intermediate directories are known
+        # Ensure intermediate directories are known.
         for i in range(len(parts) - 1):
             up_parent = "/".join(parts[:i])
             up_child = parts[i]
             tree_map[up_parent]["dirs"].add(up_child)
 
-    start = top.rstrip("/")
-
-    # When top does not exist explicitly, build a filtered pseudo-map rooted at top
+    # If the subtree has no entries, return nothing.
     if start and start not in tree_map:
-        pseudo_map: Dict[str, Dict[str, Any]] = defaultdict(lambda: {"dirs": set(), "files": {}})
-        for arcname in zipobj.namelist():
-            if arcname.startswith(start + "/") or arcname.rstrip("/") == start:
-                norm = arcname.rstrip("/")
-                rel = norm[len(start):].lstrip("/")
-                parent = "/".join([start] + ([p for p in rel.split("/")[:-1]] if rel else []))
-                leaf = rel.split("/")[-1] if rel else start.split("/")[-1]
-                if arcname.endswith("/"):
-                    pseudo_map[parent]["dirs"].add(leaf)
-                else:
-                    pseudo_map[parent]["files"][leaf] = ZippedFile(leaf, norm, zipobj)
-                prefix_parts = parent.split("/") if parent else []
-                for i in range(len(prefix_parts)):
-                    up_parent = "/".join(prefix_parts[:i])
-                    up_child = prefix_parts[i]
-                    pseudo_map[up_parent]["dirs"].add(up_child)
-        tree_map = pseudo_map
-        if start and start not in tree_map:
-            return
+        return
 
     built_dirs: Dict[str, ZippedDir] = {}
 
     def _build(path: str) -> ZippedDir:
         if path in built_dirs:
             return built_dirs[path]
-        dirnames = sorted(tree_map[path]["dirs"])
-        files = [tree_map[path]["files"][k] for k in sorted(tree_map[path]["files"].keys())]
+
+        dirset = tree_map[path]["dirs"]
+        files_dict = tree_map[path]["files"]
+
+        if sort_entries:
+            dirnames = sorted(dirset)
+            filekeys = sorted(files_dict.keys())
+        else:
+            # Sets/dicts are already in-memory; avoid sorting for speed.
+            dirnames = list(dirset)
+            filekeys = list(files_dict.keys())
+
+        files = [files_dict[k] for k in filekeys]
         subs: List[ZippedDir] = []
         for name in dirnames:
             sub_path = f"{path}/{name}" if path else name
             subs.append(_build(sub_path))
+
         obj = ZippedDir(
             name=path.rsplit("/", 1)[-1] if path else "",
             path=path,

brkraw/dataclasses/__init__.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
-from .study import Study
+from .study import Study, LazyScan
 from .scan import Scan
 from .reco import Reco
 from .node import DatasetNode
 
 
 __all__ = [
-    'Study', 
+    'Study',
+    'LazyScan',
     'Scan', 
     'Reco', 
     'DatasetNode'