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

brkraw/apps/loader/helper.py

@@ -1,19 +1,25 @@
-"""Internal helper functions for BrukerLoader.
-
-Last updated: 2025-12-30
-"""
-
 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 typing import (
+    TYPE_CHECKING, 
+    cast, 
+    Optional,
+    Tuple, 
+    Union, 
+    Any, 
+    Mapping, 
+    List, 
+    Dict
+)
 from pathlib import Path
 from warnings import warn
 import logging
 
 import numpy as np
+from numpy.typing import NDArray
 from nibabel.nifti1 import Nifti1Image
 
 from ...core.config import resolve_root
@@ -21,22 +27,38 @@ from ...core.parameters import Parameters
 from ...specs.remapper import load_spec, map_parameters, load_context_map, apply_context_map
 from ...specs.rules import load_rules, select_rule_use
 from ...dataclasses import Reco, Scan, Study
-from .types import ScanLoader, ToFilename, ConvertType, GetDataobjType, GetAffineType
 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
 from ...resolver import nifti as nifti_resolver
 from ...resolver.helpers import get_file
-
+from .types import (
+    ScanLoader, 
+    ConvertType, 
+    GetDataobjType, 
+    GetAffineType
+)
 if TYPE_CHECKING:
     from ...resolver.nifti import Nifti1HeaderContents
-    from .types import SubjectType, SubjectPose, XYZUNIT, TUNIT, AffineReturn, AffineSpace
+    from .types import (
+        SubjectType, 
+        SubjectPose, 
+        XYZUNIT, 
+        TUNIT,
+        Dataobjs,
+        Affines,
+        AffineSpace,
+        ConvertedObj,
+        Metadata
+    )
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 __all__ = [
+    "resolve_reco_id",
     "resolve_data_and_affine",
+    "resolve_converter_hook",
     "search_parameters",
     "get_dataobj",
     "get_affine",
@@ -55,7 +77,7 @@ def make_dir(names: List[str]):
     return _dir
 
 
-def _resolve_reco_id(
+def resolve_reco_id(
     scan: Union["Scan", "ScanLoader"],
     reco_id: Optional[int],
 ) -> Optional[int]:
@@ -79,7 +101,7 @@ def _resolve_reco_id(
 
 
 def resolve_data_and_affine(
-    scan: Union["Scan", "ScanLoader"],
+    scan: "Scan",
     reco_id: Optional[int] = None,
     *,
     affine_decimals: int = 6,
@@ -92,6 +114,9 @@ def resolve_data_and_affine(
         affine_decimals: Decimal rounding applied to resolved affines.
     """
     scan = cast(ScanLoader, scan)
+    scan.get_fid = MethodType(fid_resolver.resolve, scan)
+    scan.image_info = {}
+    scan.affine_info = {}
 
     reco_ids = [reco_id] if reco_id is not None else list(scan.avail.keys())
     if not reco_ids:
@@ -108,7 +133,7 @@ def resolve_data_and_affine(
             )
             continue
         try:
-            image_info = image_resolver.resolve(scan, rid)
+            image_info = image_resolver.resolve(scan, rid, load_data=False)
         except Exception as exc:
             logger.warning(
                 "Failed to resolve image data for scan %s reco %s: %s",
@@ -122,6 +147,7 @@ def resolve_data_and_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",
@@ -131,15 +157,65 @@ def resolve_data_and_affine(
             )
             affine_info = None
 
-        if hasattr(scan, "image_info"):
-            scan.image_info[rid] = image_info
-        else:
-            setattr(scan, "image_info", {rid: image_info})
-        if hasattr(scan, "affine_info"):
-            scan.affine_info[rid] = affine_info
+        scan.image_info[rid] = image_info
+        scan.affine_info[rid] = affine_info
+
+def _load_rules(base):
+    try:
+        rules = load_rules(root=base, validate=False)
+    except Exception:
+        rules = {}
+    return rules
+
+
+def resolve_converter_hook(
+    scan: "Scan",
+    base: Path,
+    *,
+    affine_decimals: int = 6,
+):
+    scan = cast(ScanLoader, scan)
+    rules = _load_rules(base)
+    if rules:
+        try:
+            hook_name = select_rule_use(
+                scan,
+                rules.get("converter_hook", []),
+                base=base,
+                resolve_paths=False,
+            )
+        except Exception as exc:
+            logger.debug(
+                "Converter hook rule selection failed for scan %s: %s",
+                getattr(scan, "scan_id", "?"),
+                exc,
+                exc_info=True,
+            )
+            hook_name = None
+    
+        if isinstance(hook_name, str):
+            try:
+                entry = converter_core.resolve_hook(hook_name)
+            except Exception as exc:
+                logger.warning(
+                    "Converter hook %r not available: %s",
+                    hook_name,
+                    exc,
+                )
+                entry = None
+            if entry:
+                logger.debug("Applying converter hook: %s", hook_name)
+                scan._converter_hook_name = hook_name
+                apply_converter_hook(
+                    scan,
+                    entry,
+                    affine_decimals=affine_decimals,
+                )
+            else:
+                logger.debug("Converter hook %r resolved to no entry.", hook_name)
         else:
-            setattr(scan, "affine_info", {rid: affine_info})
-    scan.get_fid = MethodType(fid_resolver.resolve, scan)
+            logger.debug("No converter hook selected for scan %s.", getattr(scan, "scan_id", "?"))
+    scan._hook_resolved = True
 
 
 def search_parameters(
@@ -242,7 +318,7 @@ def search_parameters(
         if scan_id is None:
             warn("To search from Study object, specifying <scan_id> is required.")
             return None
-        scan = self.get_scan(scan_id)
+        scan = cast(ScanLoader, self.get_scan(scan_id))
         scan_hits = search_node(scan)
         if reco_id is None:
             reco_hits = search_recos(scan)
@@ -281,10 +357,10 @@ def search_parameters(
 
 
 def _finalize_affines(
-    affines: list[np.ndarray],
+    affines: List[NDArray],
     num_slice_packs: int,
     decimals: Optional[int],
-) -> AffineReturn:
+) -> Affines:
     if num_slice_packs == 1:
         affine = affines[0]
         if decimals is not None:
@@ -298,38 +374,73 @@ def _finalize_affines(
 
 
 def get_dataobj(
-    self: Union["Scan", "ScanLoader"],
+    self: "ScanLoader",
     reco_id: Optional[int] = None,
-    **_: Any,
-) -> Optional[Union[Tuple["np.ndarray", ...], "np.ndarray"]]:
+    **kwargs: Dict[str, Any]
+) -> Dataobjs:
     """Return reconstructed data for a reco, split by slice pack if needed.
 
     Args:
         self: Scan or ScanLoader instance.
-    reco_id: Reco identifier to read (defaults to the first available).
+        reco_id: Reco identifier to read (defaults to the first available).
+        cycle_index: Optional cycle start index (last axis), reads all cycles when None.
+        cycle_count: Optional number of cycles to read from cycle_index; reads to end when None.
+            Ignored when the dataset reports <= 1 total cycle.
 
     Returns:
         Single ndarray when one slice pack exists; otherwise a tuple of arrays.
         Returns None when required metadata is unavailable.
     """
-    if not hasattr(self, "image_info") or not hasattr(self, "affine_info"):
-        return None
-    self = cast(ScanLoader, self)
-    resolved_reco_id = _resolve_reco_id(self, reco_id)
+    cycle_index = cast(Optional[int], kwargs.get('cycle_index'))
+    cycle_count = cast(Optional[int], kwargs.get('cycle_count'))
+    resolved_reco_id = resolve_reco_id(self, reco_id)
     if resolved_reco_id is None:
         return None
+    
     affine_info = self.affine_info.get(resolved_reco_id)
+    if affine_info is None:
+        logger.warning(
+            "affine_info is not available for scan %s",
+            getattr(self, "scan_id", "?")
+        )
+        return None
     image_info = self.image_info.get(resolved_reco_id)
-    if affine_info is None or image_info is None:
+    if image_info is None:
+        logger.warning(
+            "image_info is not available for scan %s",
+            getattr(self, "scan_id", "?")
+        )
         return None
 
-    num_slices = affine_info["num_slices"]
-    dataobj = image_info["dataobj"]
+    # Normalize cycle arguments if provided.
+    cycle_args_requested = cycle_index is not None or cycle_count is not None
+    if cycle_index is None and cycle_count is not None:
+        cycle_index = 0
+
+    # If the dataset has <= 1 cycle, ignore cycle slicing to avoid block reads.
+    if cycle_args_requested:
+        total_cycles = int(image_info["num_cycles"])
+        if total_cycles <= 1:
+            cycle_index = None
+            cycle_count = None
+            cycle_args_requested = False
+
+    if cycle_args_requested or image_info.get("dataobj") is None:
+        image_info = image_resolver.resolve(
+            self,
+            resolved_reco_id,
+            load_data=True,
+            cycle_index=cycle_index,
+            cycle_count=cycle_count,
+        )
+        self.image_info[resolved_reco_id] = image_info
 
+    num_slices = affine_info["num_slices"]
+    dataobj = cast(dict, image_info).get("dataobj")
     slice_pack = []
     slice_offset = 0
     for _num_slices in num_slices:
-        _dataobj = dataobj[:, :, slice(slice_offset, slice_offset + _num_slices)]
+        _dataobj = cast(NDArray, dataobj)[:, :, slice(slice_offset, slice_offset + _num_slices)]
         slice_offset += _num_slices
         slice_pack.append(_dataobj)
 
@@ -339,7 +450,7 @@ def get_dataobj(
 
 
 def get_affine(
-    self: Union["Scan", "ScanLoader"],
+    self: "ScanLoader",
     reco_id: Optional[int] = None,
     *,
     space: AffineSpace = "subject_ras",
@@ -347,7 +458,7 @@ def get_affine(
     override_subject_pose: Optional["SubjectPose"] = None,
     decimals: Optional[int] = None,
     **kwargs: Any,
-) -> AffineReturn:
+) -> Affines:
     """
     Return affine(s) for a reco in the requested coordinate space.
 
@@ -379,7 +490,7 @@ def get_affine(
         return None
 
     self = cast("ScanLoader", self)
-    resolved_reco_id = _resolve_reco_id(self, reco_id)
+    resolved_reco_id = resolve_reco_id(self, reco_id)
     if resolved_reco_id is None:
         return None
 
@@ -427,7 +538,7 @@ def get_affine(
     return _apply_affine_post_transform(result, kwargs=kwargs)
 
 
-def _apply_affine_post_transform(affines: AffineReturn, *, kwargs: Mapping[str, Any]) -> AffineReturn:
+def _apply_affine_post_transform(affines: Affines, *, kwargs: Mapping[str, Any]) -> Affines:
     """Apply optional flips/rotations to affines right before returning.
 
     These transforms are applied in world space and do not depend on output
@@ -458,7 +569,7 @@ def _apply_affine_post_transform(affines: AffineReturn, *, kwargs: Mapping[str,
     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:
+    def apply_one(a: NDArray) -> 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)
@@ -474,13 +585,13 @@ def _apply_affine_post_transform(affines: AffineReturn, *, kwargs: Mapping[str,
 def get_nifti1image(
     self: Union["Scan", "ScanLoader"],
     reco_id: int,
-    dataobjs: Tuple[np.ndarray, ...],
-    affines: Tuple[np.ndarray, ...],
+    dataobjs: Tuple[NDArray, ...],
+    affines: Tuple[NDArray, ...],
     *,
     xyz_units: XYZUNIT = "mm",
     t_units: TUNIT = "sec",
     override_header: Optional[Nifti1HeaderContents] = None,
-) -> Optional[Union[Tuple["Nifti1Image", ...], "Nifti1Image"]]:
+) -> ConvertedObj:
     """Return NIfTI image(s) for a reco.
 
     Args:
@@ -495,9 +606,12 @@ def get_nifti1image(
         metadata is unavailable.
     """
     self = cast(ScanLoader, self)
-    
+
     image_info = self.image_info.get(reco_id)
-    if dataobjs is None or affines is None or image_info is None:
+    if image_info is None:
+        return None
+
+    if dataobjs is None or affines is None:
         return None
 
     niiobjs = []
@@ -520,7 +634,7 @@ def get_nifti1image(
 
 
 def convert(
-    self: Union["Scan", "ScanLoader"],
+    self: "ScanLoader",
     reco_id: Optional[int] = None,
     *,
     space: AffineSpace = "subject_ras",
@@ -528,11 +642,9 @@ def convert(
     override_subject_type: Optional[SubjectType] = None,
     override_subject_pose: Optional[SubjectPose] = None,
     flatten_fg: bool = False,
-    xyz_units: XYZUNIT = "mm",
-    t_units: TUNIT = "sec",
     hook_args_by_name: Optional[Mapping[str, Mapping[str, Any]]] = None,
     **kwargs: Any,
-) -> Optional[Union["ToFilename", Tuple["ToFilename", ...]]]:
+) -> ConvertedObj:
     """Convert a reco to output object(s).
     
     Args:
@@ -541,12 +653,8 @@ def convert(
         override_subject_type: Subject type override for subject-view wrapping.
         override_subject_pose: Subject pose override for subject-view wrapping.
         flatten_fg: If True, flatten foreground dimensions.
-        xyz_units: Spatial units for NIfTI header.
-        t_units: Temporal units for NIfTI header.
         hook_args_by_name: Optional hook args mapping (split per helper signature).
         flatten_fg: If True, flatten foreground dimensions.
-        xyz_units: Spatial units for NIfTI header.
-        t_units: Temporal units for NIfTI header.
     Returns:
         Single NIfTI image when one slice pack exists; otherwise a tuple of
         images. Returns None when required metadata is unavailable.
@@ -555,9 +663,10 @@ def convert(
         hasattr(self, attr) for attr in ["image_info", "affine_info", "get_dataobj", "get_affine"]
     ):
         return None
-
+    
     self = cast(ScanLoader, self)
-    resolved_reco_id = _resolve_reco_id(self, reco_id)
+    resolved_reco_id = resolve_reco_id(self, reco_id)
+    logger.debug("Resolved reco_id = %s", resolved_reco_id)
     if resolved_reco_id is None:
         return None
 
@@ -577,12 +686,17 @@ def convert(
         )
     
     hook_kwargs = _resolve_hook_kwargs(self, hook_args_by_name)
-    data_kwargs = _filter_hook_kwargs(self.get_dataobj, hook_kwargs)
-    convert_kwargs = {
-        key: value
-        for key, value in hook_kwargs.items()
-        if key not in data_kwargs
-    }
+
+    # Merge explicit **kwargs (CLI/user) with hook kwargs. Explicit kwargs win.
+    merged_kwargs: Dict[str, Any] = dict(hook_kwargs) if hook_kwargs else {}
+    merged_kwargs.update(kwargs)
+
+    data_kwargs = _filter_hook_kwargs(self.get_dataobj, merged_kwargs)
+    # flip_* are affine-only options; never pass them to get_dataobj.
+    for key in ("flip_x", "flip_y", "flip_z"):
+        data_kwargs.pop(key, None)
+    
+    convert_kwargs = {key: value for key, value in merged_kwargs.items() if key not in data_kwargs}
     if data_kwargs:
         logger.debug(
             "Calling get_dataobj for scan %s reco %s with args %s",
@@ -598,7 +712,8 @@ def convert(
             resolved_reco_id,
         )
         dataobjs = self.get_dataobj(resolved_reco_id)
-    affine_kwargs = _filter_hook_kwargs(self.get_affine, hook_kwargs)
+
+    affine_kwargs = _filter_hook_kwargs(self.get_affine, merged_kwargs)
     convert_kwargs = {
         key: value
         for key, value in convert_kwargs.items()
@@ -646,7 +761,7 @@ def convert(
             flattened = int(np.prod(dataobj.shape[3:]))
             dataobjs[i] = dataobj.reshape((*spatial_shape, flattened), order="A")
     dataobjs = tuple(dataobjs)
-     
+
     converter_func = getattr(self, "converter_func", None)
     if isinstance(converter_func, ConvertType):
         hook_call_kwargs = _filter_hook_kwargs(converter_func, convert_kwargs)
@@ -663,8 +778,6 @@ def convert(
         )
 
     nifti1image_kwargs = {
-        "xyz_units": xyz_units,
-        "t_units": t_units,
         "override_header": override_header,
         **kwargs,
     }
@@ -813,7 +926,7 @@ def get_metadata(
     spec: Optional[Union[Mapping[str, Any], str, Path]] = None,
     context_map: Optional[Union[str, Path]] = None,
     return_spec: bool = False,
-):
+) -> Metadata:
     """Resolve metadata using a remapper spec.
 
     Args:
@@ -828,7 +941,7 @@ def get_metadata(
         return_spec is True, returns (metadata, spec_info).
     """
     scan = cast(ScanLoader, self)
-    resolved_reco_id = _resolve_reco_id(scan, reco_id)
+    resolved_reco_id = resolve_reco_id(scan, reco_id)
     if resolved_reco_id is None:
         if return_spec:
             return None, None

brkraw/apps/loader/info/scan.py

@@ -8,9 +8,9 @@ from ....specs.remapper.validator import validate_spec
 
 
 if TYPE_CHECKING:
-    from ..types import ScanLoader, RecoLoader
+    from ..types import ScanLoader
 
-logger = logging.getLogger("brkraw")
+logger = logging.getLogger(__name__)
 
 
 def resolve(

brkraw/apps/loader/info/transform.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import Union, Optional, Tuple, List, Any, cast
 from datetime import datetime, timezone, timedelta
-import numpy as np
 import re
 
 def strip_jcamp_string(value: Optional[str]) -> str:

brkraw/apps/loader/types.py

@@ -5,7 +5,7 @@ Last updated: 2025-12-30
 
 from __future__ import annotations
 
-from typing import Any, Union, Tuple, Dict, Optional, Protocol, Literal, Mapping, Callable, List, TYPE_CHECKING, runtime_checkable
+from typing import Any, Union, Tuple, Dict, Optional, Protocol, Literal, Mapping, List, TYPE_CHECKING, runtime_checkable
 if TYPE_CHECKING:
     from typing_extensions import ParamSpec, TypeAlias
 else:
@@ -16,21 +16,26 @@ else:
 from ...dataclasses.study import Study
 from ...dataclasses.scan import Scan
 from ...dataclasses.reco import Reco
+from ...resolver.affine import SubjectType, SubjectPose
 import numpy as np
+from numpy.typing import NDArray
 
 if TYPE_CHECKING:
     from pathlib import Path
     from ...core.parameters import Parameters
     from ...resolver.image import ResolvedImage
-    from ...resolver.affine import ResolvedAffine, SubjectType, SubjectPose
+    from ...resolver.affine import ResolvedAffine
     from ...resolver.nifti import Nifti1HeaderContents, XYZUNIT, TUNIT
-    from nibabel.nifti1 import Nifti1Image
-    
 
 
 InfoScope = Literal['full', 'study', 'scan']
-AffineReturn = Optional[Union[np.ndarray, Tuple[np.ndarray, ...]]]
+Dataobjs = Optional[Union[NDArray, Tuple[NDArray, ...]]]
+Affines = Optional[Union[NDArray, Tuple[NDArray, ...]]]
 AffineSpace = Literal["raw", "scanner", "subject_ras"]
+ConvertedObj = Optional[Union["ToFilename", Tuple["ToFilename", ...]]]
+Metadata = Optional[Union[Dict, Tuple[Optional[Dict], ...]]]
+HookArgs = Optional[Mapping[str, Mapping[str, Any]]]
+
 
 P = ParamSpec("P")
 
@@ -42,9 +47,11 @@ class GetDataobjType(Protocol[P]):
         self,
         scan: "Scan",
         reco_id: Optional[int],
+        cycle_index: Optional[int],
+        cycle_count: Optional[int],
         *args: P.args,
         **kwargs: P.kwargs
-    ) -> Optional[Union[Tuple["np.ndarray", ...], "np.ndarray"]]:
+    ) -> Dataobjs:
         ...
 
 
@@ -61,7 +68,7 @@ class GetAffineType(Protocol):
         override_subject_pose: Optional[SubjectPose],
         decimals: Optional[int] = None,
         **kwargs: Any
-    ) -> Optional[Union[Tuple["np.ndarray", ...], "np.ndarray"]]:
+    ) -> Affines:
         ...
 
 
@@ -74,7 +81,7 @@ class ConvertType(Protocol):
         dataobj: Union[Tuple["np.ndarray", ...], "np.ndarray"],
         affine: Union[Tuple["np.ndarray", ...], "np.ndarray"],
         **kwargs: Any,
-    ) -> Optional[Union["ToFilename", Tuple["ToFilename", ...]]]:
+    ) -> ConvertedObj:
         ...
 
 class ToFilename(Protocol):
@@ -108,6 +115,7 @@ class ScanLoader(Scan, BaseLoader):
     converter_func: Optional[ConvertType]
     _converter_hook: Optional[ConverterHook]
     _converter_hook_name: Optional[str]
+    _hook_resolved: bool = False
     
     
     def get_fid(self, 
@@ -119,8 +127,12 @@ class ScanLoader(Scan, BaseLoader):
 
     def get_dataobj(
             self, 
-            reco_id: Optional[int] = None
-            ) -> Optional[Union[Tuple["np.ndarray", ...], "np.ndarray"]]: 
+            reco_id: Optional[int] = None,
+            *,
+            cycle_index: Optional[int] = None,
+            cycle_count: Optional[int] = None,
+            **kwargs: Any
+            ) -> Dataobjs: 
         ...
 
     def get_affine(
@@ -132,7 +144,7 @@ class ScanLoader(Scan, BaseLoader):
             override_subject_pose: Optional[SubjectPose],
             decimals: Optional[int] = None,
             **kwargs: Any,
-            ) -> Optional[Union[Tuple["np.ndarray", ...], "np.ndarray"]]:
+            ) -> Affines:
         ...
 
     def get_nifti1image(
@@ -144,7 +156,7 @@ class ScanLoader(Scan, BaseLoader):
             override_header: Optional[Union[dict, "Nifti1HeaderContents"]],
             xyz_units: XYZUNIT, 
             t_units: TUNIT
-            ) -> Optional[Union[Tuple["Nifti1Image", ...], "Nifti1Image"]]:
+            ) -> ConvertedObj:
         ...
 
     def convert(
@@ -158,9 +170,9 @@ class ScanLoader(Scan, BaseLoader):
             flatten_fg: bool,
             xyz_units: XYZUNIT,
             t_units: TUNIT,
-            hook_args_by_name: Optional[Mapping[str, Mapping[str, Any]]] = None,
+            hook_args_by_name: HookArgs = None,
             **kwargs: Any,
-            ) -> Optional[Union["ToFilename", Tuple["ToFilename", ...]]]:
+            ) -> ConvertedObj:
         ...
 
     def get_metadata(
@@ -169,7 +181,7 @@ class ScanLoader(Scan, BaseLoader):
             spec: Optional[Union[Mapping[str, Any], str, "Path"]] = None,
             context_map: Optional[Union[str, "Path"]] = None,
             return_spec: bool = False,
-            ) -> Optional[Union[dict, Tuple[Optional[dict], Optional[dict]]]]:
+            ) -> Metadata:
         ...
 
 
@@ -191,6 +203,14 @@ __all__ = [
     'StudyLoader',
     'ScanLoader',
     'RecoLoader',
+    'SubjectType',
+    'SubjectPose',
+    'Affines',
+    'Dataobjs',
+    'Metadata',
+    'ConvertedObj',
+    'HookArgs',
+    'AffineSpace',
 ]
 
 def __dir__() -> List[str]:

brkraw/cli/commands/addon.py

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