halib 0.2.20__tar.gz → 0.2.23__tar.gz

{halib-0.2.20 → halib-0.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halib
-Version: 0.2.20
+Version: 0.2.23
 Summary: Small library for common tasks
 Author: Hoang Van Ha
 Author-email: hoangvanhauit@gmail.com
@@ -56,7 +56,11 @@ Dynamic: summary
 
 ## v0.2.x (Experiment & Core Updates)
 
-### **v0.2.20**
+### **v0.2.23**
+- ✨ **New Feature:** Added `utils.dict.DictUtils` for advanced dictionary manipulations (merging, filtering, transforming).
+
+- ✨ **New Feature:** Added `common.common.pprint_stack_trace` to print stack traces with optional custom messages and force stop capability.
+
 - 🚀 **Improvement:**  `exp.perf.profiler` - allow to export *report dict* as csv files for further analysis
 
 ### **v0.2.19**

{halib-0.2.20 → halib-0.2.23}/README.md

@@ -2,7 +2,11 @@
 
 ## v0.2.x (Experiment & Core Updates)
 
-### **v0.2.20**
+### **v0.2.23**
+- ✨ **New Feature:** Added `utils.dict.DictUtils` for advanced dictionary manipulations (merging, filtering, transforming).
+
+- ✨ **New Feature:** Added `common.common.pprint_stack_trace` to print stack traces with optional custom messages and force stop capability.
+
 - 🚀 **Improvement:**  `exp.perf.profiler` - allow to export *report dict* as csv files for further analysis
 
 ### **v0.2.19**

{halib-0.2.20 → halib-0.2.23}/halib/__init__.py

@@ -19,11 +19,11 @@ __all__ = [
     "os",
     "pd",
     "plt",
-    "pprint",
     "pprint_box",
     "pprint_local_path",
+    "pprint_stack_trace",
+    "pprint",
     "px",
-    "pprint_local_path",
     "rcolor_all_str",
     "rcolor_palette_all",
     "rcolor_palette",
@@ -32,10 +32,10 @@ __all__ = [
     "rprint",
     "sns",
     "tcuda",
+    "time",
     "timebudget",
     "tqdm",
     "warnings",
-    "time",
 ]
 import warnings
 
@@ -64,7 +64,8 @@ from .common.common import (
     norm_str,
     pprint_box,
     pprint_local_path,
-    tcuda
+    pprint_stack_trace,
+    tcuda,
 )
 
 # for log
@@ -76,7 +77,12 @@ from timebudget import timebudget
 import omegaconf
 from omegaconf import OmegaConf
 from omegaconf.dictconfig import DictConfig
-from .common.rich_color import rcolor_str, rcolor_palette, rcolor_palette_all, rcolor_all_str
+from .common.rich_color import (
+    rcolor_str,
+    rcolor_palette,
+    rcolor_palette_all,
+    rcolor_all_str,
+)
 
 # for visualization
 import seaborn as sns

{halib-0.2.20 → halib-0.2.23}/halib/common/common.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import re
 import arrow
 import importlib
@@ -10,6 +11,8 @@ from rich.console import Console
 from rich.pretty import pprint, Pretty
 
 from pathlib import Path, PureWindowsPath
+from typing import Optional
+from loguru import logger
 
 
 console = Console()
@@ -114,6 +117,32 @@ def linux_to_wins_path(path: str) -> str:
     return str(PureWindowsPath(win_path))
 
 
+DEFAULT_STACK_TRACE_MSG = "Caused by halib.common.common.pprint_stack_trace"
+
+
+def pprint_stack_trace(
+    msg: str = DEFAULT_STACK_TRACE_MSG,
+    e: Optional[Exception] = None,
+    force_stop: bool = False,
+):
+    """
+    Print the current stack trace or the stack trace of an exception.
+    """
+    try:
+        if e is not None:
+            raise e
+        else:
+            raise Exception("pprint_stack_trace called")
+    except Exception as e:
+        # attach the exception trace to a warning
+        global DEFAULT_STACK_TRACE_MSG
+        if len(msg.strip()) == 0:
+            msg = DEFAULT_STACK_TRACE_MSG
+        logger.opt(exception=e).warning(msg)
+        if force_stop:
+            console.rule("[red]Force Stop Triggered in <halib.common.pprint_stack_trace>[/red]")
+            sys.exit(1)
+
 def pprint_local_path(
     local_path: str, get_wins_path: bool = False, tag: str = ""
 ) -> str:

{halib-0.2.20 → halib-0.2.23}/halib/exp/core/param_gen.py

@@ -4,6 +4,11 @@ import numpy as np
 from itertools import product
 from typing import Dict, Any, List, Iterator, Optional
 from ...filetype import yamlfile
+from ...utils.dict import DictUtils
+
+# Assuming DictUtils is available in the scope or imported
+# from .dict_utils import DictUtils
+
 
 class ParamGen:
     """
@@ -38,6 +43,7 @@ class ParamGen:
         keys (List[str]): List of flattened dot-notation keys being swept.
         values (List[List[Any]]): List of value options for each key.
     """
+
     def __init__(
         self, sweep_cfg: Dict[str, Any], base_cfg: Optional[Dict[str, Any]] = None
     ):
@@ -50,7 +56,12 @@ class ParamGen:
         self.base_cfg = base_cfg if base_cfg is not None else {}
 
         # Recursively flatten the nested sweep config into dot-notation keys
-        self.param_space = self._flatten_params(sweep_cfg)
+        # Refactored to use DictUtils, passing our custom leaf logic
+        flat_sweep = DictUtils.flatten(sweep_cfg, is_leaf_predicate=self._is_sweep_leaf)
+
+        # Expand values (ranges, strings) which DictUtils leaves as-is
+        self.param_space = {k: self._expand_val(v) for k, v in flat_sweep.items()}
+
         self.keys = list(self.param_space.keys())
         self.values = list(self.param_space.values())
 
@@ -66,13 +77,16 @@ class ParamGen:
 
             # 2. Deep copy base and update with current params
             new_cfg = copy.deepcopy(self.base_cfg)
-            new_cfg = self._apply_updates(new_cfg, flat_params)
+
+            # Refactored: Unflatten the specific params, then deep merge
+            update_structure = DictUtils.unflatten(flat_params)
+            DictUtils.deep_update(new_cfg, update_structure)
 
             # 3. Store metadata (Optional)
             # if "_meta" not in new_cfg:
             #     new_cfg["_meta"] = {}
             # We unflatten the sweep params here so the log is readable
-            # new_cfg["_meta"]["sweep_params"] = self._unflatten(flat_params)
+            # new_cfg["_meta"]["sweep_params"] = DictUtils.unflatten(flat_params)
 
             yield new_cfg
 
@@ -124,27 +138,8 @@ class ParamGen:
             combinations.append(flat_dict)
         return combinations
 
-    def _unflatten(self, flat_dict: Dict[str, Any]) -> Dict[str, Any]:
-        """Converts {'a.b': 1} back to {'a': {'b': 1}}."""
-        nested = {}
-        self._apply_updates(nested, flat_dict)
-        return nested
-
-    def _flatten_params(
-        self, cfg: Dict[str, Any], parent_key: str = ""
-    ) -> Dict[str, List[Any]]:
-        """Recursively converts nested dicts into flat dot-notation keys."""
-        flat = {}
-        for key, val in cfg.items():
-            current_key = f"{parent_key}.{key}" if parent_key else key
-
-            if self._is_sweep_leaf(val):
-                flat[current_key] = self._expand_val(val)
-            elif isinstance(val, dict):
-                flat.update(self._flatten_params(val, current_key))
-            else:
-                flat[current_key] = [val]
-        return flat
+    # Note: _unflatten, _flatten_params, and _apply_updates have been removed
+    # as they are replaced by DictUtils methods.
 
     def _is_sweep_leaf(self, val: Any) -> bool:
         if isinstance(val, list):
@@ -173,17 +168,3 @@ class ParamGen:
             return np.arange(val["start"], val["stop"], step).tolist()
 
         return [val]
-
-    def _apply_updates(
-        self, cfg: Dict[str, Any], updates: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Deep merges dot-notation updates into cfg."""
-        for key, val in updates.items():
-            parts = key.split(".")
-            target = cfg
-            for part in parts[:-1]:
-                if part not in target:
-                    target[part] = {}
-                target = target[part]
-            target[parts[-1]] = val
-        return cfg

{halib-0.2.20 → halib-0.2.23}/halib/exp/perf/perfcalc.py

@@ -210,7 +210,37 @@ class PerfCalc(ABC):  # Abstract base class for performance calculation
         **kwargs,
     ) -> Tuple[Union[List[OrderedDict], pd.DataFrame], Optional[str]]:
         """
-        Standard use case: Calculate metrics AND save to CSV.
+        Orchestrates the calculation of performance metrics and saves the results to a CSV.
+
+        This method acts as a pipeline:
+        1. Calculates metrics (Accuracy, F1, etc.) using `raw_metrics_data`.
+        2. Merges in `extra_data` (metadata) to the results.
+        3. Saves the combined data to a CSV file.
+
+        Args:
+            raw_metrics_data (Union[List[dict], dict]):
+                The input data required for metric calculations.
+                Structure: A dictionary where keys are metric names (e.g., 'accuracy')
+                and values are inputs (e.g., {'preds': ..., 'target': ...}).
+
+            extra_data (Optional[Union[List[dict], dict]]):
+                Static metadata or context to attach to the result rows.
+                These fields are NOT used for calculation but are passed through
+                to the final output (DataFrame/CSV).
+
+                Example:
+                    If extra_data={'model_version': 'v1.0', 'epoch': 5},
+                    the output CSV will include columns 'model_version' and 'epoch'.
+
+            *args, **kwargs:
+                Additional arguments passed to `calc_exp_perf_metrics` or `save_results_to_csv`
+                (e.g., `outfile`, `return_df`).
+
+        Returns:
+            Tuple[Union[List[OrderedDict], pd.DataFrame], Optional[str]]:
+                A tuple containing:
+                1. The results as a DataFrame (if return_df=True) or a list of dicts.
+                2. The path to the saved output file (or None if save failed).
         """
         metric_names = self.get_metric_backend().metric_names
 

halib-0.2.23/halib/utils/dict.py

@@ -0,0 +1,156 @@
+from typing import Dict, Any, Callable, Optional
+from rich.pretty import pprint
+
+class DictUtils:
+    """
+    General-purpose dictionary manipulation utilities.
+    """
+
+    @staticmethod
+    def flatten(
+        d: Dict[str, Any],
+        parent_key: str = "",
+        sep: str = ".",
+        is_leaf_predicate: Optional[Callable[[Any], bool]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Recursively flattens a nested dictionary.
+
+        Args:
+            d: The dictionary to flatten.
+            parent_key: Prefix for keys (used during recursion).
+            sep: Separator for dot-notation keys.
+            is_leaf_predicate: Optional function that returns True if a value should
+                               be treated as a leaf (value) rather than a branch to recurse.
+                               Useful if you have dicts you don't want flattened.
+        """
+        items = []
+        for k, v in d.items():
+            new_key = f"{parent_key}{sep}{k}" if parent_key else k
+
+            # Check if we should treat this as a leaf (custom logic)
+            if is_leaf_predicate and is_leaf_predicate(v):
+                items.append((new_key, v))
+            # Standard recursion
+            elif isinstance(v, dict):
+                items.extend(
+                    DictUtils.flatten(
+                        v, new_key, sep=sep, is_leaf_predicate=is_leaf_predicate
+                    ).items()
+                )
+            else:
+                items.append((new_key, v))
+        return dict(items)
+
+    @staticmethod
+    def unflatten(flat_dict: Dict[str, Any], sep: str = ".") -> Dict[str, Any]:
+        """
+        Converts flat dot-notation keys back to nested dictionaries.
+        e.g., {'a.b': 1} -> {'a': {'b': 1}}
+        """
+        nested = {}
+        for key, value in flat_dict.items():
+            DictUtils.deep_set(nested, key, value, sep=sep)
+        return nested
+
+    @staticmethod
+    def deep_update(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Recursively merges 'update' dict into 'base' dict.
+
+        Unlike the standard `dict.update()`, which replaces nested dictionaries entirely,
+        this method enters nested dictionaries and updates them key-by-key. This preserves
+        existing keys in 'base' that are not present in 'update'.
+
+        Args:
+            base: The original dictionary to modify.
+            update: The dictionary containing new values.
+
+        Returns:
+            The modified 'base' dictionary.
+
+        Example:
+            >>> base = {'model': {'name': 'v1', 'dropout': 0.5}}
+            >>> new_vals = {'model': {'name': 'v2'}}
+            >>> # Standard update would delete 'dropout'. deep_update keeps it:
+            >>> DictUtils.deep_update(base, new_vals)
+            {'model': {'name': 'v2', 'dropout': 0.5}}
+        """
+        for k, v in update.items():
+            if isinstance(v, dict) and k in base and isinstance(base[k], dict):
+                DictUtils.deep_update(base[k], v)
+            else:
+                base[k] = v
+        return base
+
+    @staticmethod
+    def deep_set(d: Dict[str, Any], dot_key: str, value: Any, sep: str = ".") -> None:
+        """
+        Sets a value in a nested dictionary using a dot-notation key path.
+        Automatically creates any missing intermediate dictionaries.
+
+        Args:
+            d: The dictionary to modify.
+            dot_key: The path to the value (e.g., "model.backbone.layers").
+            value: The value to set.
+            sep: The separator used in the key (default is ".").
+
+        Example:
+            >>> cfg = {}
+            >>> DictUtils.deep_set(cfg, "a.b.c", 10)
+            >>> print(cfg)
+            {'a': {'b': {'c': 10}}}
+        """
+        parts = dot_key.split(sep)
+        target = d
+        for part in parts[:-1]:
+            if part not in target:
+                target[part] = {}
+            target = target[part]
+            if not isinstance(target, dict):
+                # Handle conflict if a path was previously a value (e.g. overwriting a leaf)
+                target = {}
+        target[parts[-1]] = value
+
+
+if __name__ == "__main__":
+    # --- Setup ---
+    base_config = {
+        "model": {
+            "name": "ResNet50",
+            "layers": 50,
+            "details": {
+                "activation": "relu",
+                "dropout": 0.5,  # <--- We want to keep this
+            },
+        },
+        "epochs": 10,
+    }
+
+    new_settings = {
+        "model": {"details": {"activation": "gelu"}}  # <--- We only want to change this
+    }
+
+    b1 = base_config.copy()
+    b2 = base_config.copy()
+    n1 = new_settings.copy()
+    n2 = new_settings.copy()
+
+    pprint("Base Config:")
+    pprint(base_config)
+    pprint("New Settings:")
+    pprint(new_settings)
+    print("*" * 40)
+    pprint(
+        "Task: Update base_config with new_settings, preserving unspecified nested keys."
+    )
+    print("*" * 40)
+
+    # --- Standard Update (The Problem) ---
+    pprint("Normal Update Result:")
+    b1.update(n1)
+    pprint(b1)  # type: ignore[return-value]
+
+    # --- Deep Update (The Solution) ---
+    pprint("Deep Update Result:")
+    pprint(DictUtils.deep_update(b2, n2))

{halib-0.2.20 → halib-0.2.23}/halib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halib
-Version: 0.2.20
+Version: 0.2.23
 Summary: Small library for common tasks
 Author: Hoang Van Ha
 Author-email: hoangvanhauit@gmail.com
@@ -56,7 +56,11 @@ Dynamic: summary
 
 ## v0.2.x (Experiment & Core Updates)
 
-### **v0.2.20**
+### **v0.2.23**
+- ✨ **New Feature:** Added `utils.dict.DictUtils` for advanced dictionary manipulations (merging, filtering, transforming).
+
+- ✨ **New Feature:** Added `common.common.pprint_stack_trace` to print stack traces with optional custom messages and force stop capability.
+
 - 🚀 **Improvement:**  `exp.perf.profiler` - allow to export *report dict* as csv files for further analysis
 
 ### **v0.2.19**

{halib-0.2.20 → halib-0.2.23}/setup.py

@@ -8,7 +8,7 @@ with open("requirements.txt", "r", encoding="utf-8") as f:
 
 setuptools.setup(
     name="halib",
-    version="0.2.20",
+    version="0.2.23",
     author="Hoang Van Ha",
     author_email="hoangvanhauit@gmail.com",
     description="Small library for common tasks",

halib-0.2.20/halib/utils/dict.py

@@ -1,9 +0,0 @@
-def flatten_dict(d, parent_key="", sep="."):
-    items = {}
-    for k, v in d.items():
-        key = f"{parent_key}{sep}{k}" if parent_key else k
-        if isinstance(v, dict):
-            items.update(flatten_dict(v, key, sep=sep))
-        else:
-            items[key] = v
-    return items