halib 0.2.28__tar.gz → 0.2.30__tar.gz

{halib-0.2.28 → halib-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halib
-Version: 0.2.28
+Version: 0.2.30
 Summary: Small library for common tasks
 Author: Hoang Van Ha
 Author-email: hoangvanhauit@gmail.com
@@ -57,6 +57,12 @@ Dynamic: summary
 
 ## v0.2.x (Experiment & Core Updates)
 
+### **v0.2.30**
+
+- ✨ **New Feature:**: add `common.common.log_func` as decorator to log function entry, exit, with execution time and arguments.
+
+- 🚀 **Improvement:**: enhance `utils.dict.DictUtils` with `deep_exclude/include` and `prune` function
+
 ### **v0.2.28**
 
 - ✨ **New Feature:** Implement `utils.slack.SlackUtils` class for managing Slack channel message deletion

{halib-0.2.28 → halib-0.2.30}/README.md

@@ -2,6 +2,12 @@
 
 ## v0.2.x (Experiment & Core Updates)
 
+### **v0.2.30**
+
+- ✨ **New Feature:**: add `common.common.log_func` as decorator to log function entry, exit, with execution time and arguments.
+
+- 🚀 **Improvement:**: enhance `utils.dict.DictUtils` with `deep_exclude/include` and `prune` function
+
 ### **v0.2.28**
 
 - ✨ **New Feature:** Implement `utils.slack.SlackUtils` class for managing Slack channel message deletion

{halib-0.2.28 → halib-0.2.30}/halib/__init__.py

@@ -10,6 +10,7 @@ __all__ = [
     "fs",
     "inspect",
     "load_yaml",
+    "log_func",
     "logger",
     "norm_str",
     "now_str",
@@ -17,6 +18,7 @@ __all__ = [
     "omegaconf",
     "OmegaConf",
     "os",
+    "pad_string",
     "pd",
     "plt",
     "pprint_box",
@@ -66,6 +68,8 @@ from .common.common import (
     pprint_local_path,
     pprint_stack_trace,
     tcuda,
+    log_func,
+    pad_string,
 )
 
 # for log

{halib-0.2.28 → halib-0.2.30}/halib/common/common.py

@@ -14,6 +14,10 @@ from pathlib import Path, PureWindowsPath
 from typing import Optional
 from loguru import logger
 
+import functools
+from typing import Callable, List, Literal, Union
+import time
+import math
 
 console = Console()
 
@@ -48,6 +52,78 @@ def now_str(sep_date_time="."):
     return now_string
 
 
+def pad_string(
+    text: str,
+    target_width: Union[int, float] = -1,
+    pad_char: str = ".",
+    pad_sides: List[Literal["left", "right"]] = ["left", "right"],  # type: ignore
+) -> str:
+    """
+    Pads a string to a specific width or a relative multiplier width.
+
+    Args:
+        text: The input string.
+        target_width:
+            - If int (e.g., 20): The exact total length of the resulting string.
+            - If float (e.g., 1.5): Multiplies original length (must be >= 1.0).
+              (e.g., length 10 * 1.5 = target width 15).
+        pad_char: The character to use for padding.
+        pad_sides: A list containing "left", "right", or both.
+    """
+    current_len = len(text)
+
+    # 1. Calculate the final integer target width
+    if isinstance(target_width, float):
+        if target_width < 1.0:
+            raise ValueError(f"Float target_width must be >= 1.0, got {target_width}")
+        # Use math.ceil to ensure we don't under-pad (e.g. 1.5 * 5 = 7.5 -> 8)
+        final_width = math.ceil(current_len * target_width)
+    else:
+        final_width = target_width
+
+    # 2. Return early if no padding needed
+    if current_len >= final_width:
+        return text
+
+    # 3. Calculate total padding needed
+    padding_needed = final_width - current_len
+
+    # CASE 1: Pad Both Sides (Center)
+    if "left" in pad_sides and "right" in pad_sides:
+        left_pad_count = padding_needed // 2
+        right_pad_count = padding_needed - left_pad_count
+        return (pad_char * left_pad_count) + text + (pad_char * right_pad_count)
+
+    # CASE 2: Pad Left Only (Right Align)
+    elif "left" in pad_sides:
+        return (pad_char * padding_needed) + text
+
+    # CASE 3: Pad Right Only (Left Align)
+    elif "right" in pad_sides:
+        return text + (pad_char * padding_needed)
+
+    return text
+
+
+# ==========================================
+# Usage Examples
+# ==========================================
+if __name__ == "__main__":
+    s = "Hello"
+
+    # 1. Default (Both sides / Center)
+    print(f"'{pad_string(s, 11)}'")
+    # Output: "'***Hello***'"
+
+    # 2. Left Only
+    print(f"'{pad_string(s, 10, '-', ['left'])}'")
+    # Output: "'-----Hello'"
+
+    # 3. Right Only
+    print(f"'{pad_string(s, 10, '.', ['right'])}'")
+    # Output: "'Hello.....'"
+
+
 def norm_str(in_str):
     # Replace one or more whitespace characters with a single underscore
     norm_string = re.sub(r"\s+", "_", in_str)
@@ -140,9 +216,12 @@ def pprint_stack_trace(
             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]")
+            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:
@@ -181,20 +260,60 @@ def pprint_local_path(
     return file_uri
 
 
+def log_func(
+    func: Optional[Callable] = None, *, log_time: bool = False, log_args: bool = False
+):
+    """
+    A decorator that logs the start/end of a function.
+    Supports both @log_func and @log_func(log_time=True) usage.
+    """
+    # 1. HANDLE ARGUMENTS: If called as @log_func(log_time=True), func is None.
+    # We return a 'partial' function that remembers the args and waits for the func.
+    if func is None:
+        return functools.partial(log_func, log_time=log_time, log_args=log_args)
+
+    # 2. HANDLE DECORATION: If called as @log_func, func is the actual function.
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Safe way to get name (handles partials/lambdas)
+        func_name = getattr(func, "__name__", "Unknown_Func")
+
+        # Note: Ensure 'ConsoleLog' context manager is available in your scope
+        with ConsoleLog(func_name):
+            start = time.perf_counter()
+            try:
+                result = func(*args, **kwargs)
+            finally:
+                # We use finally to ensure logging happens even if func crashes
+                end = time.perf_counter()
+
+                if log_time or log_args:
+
+                    console.print(pad_string(f"Func <{func_name}> summary", 80))
+                    if log_time:
+                        console.print(f"{func_name} took {end - start:.6f} seconds")
+                    if log_args:
+                        console.print(f"Args: {args}, Kwargs: {kwargs}")
+
+        return result
+
+    return wrapper
+
+
 def tcuda():
     NOT_INSTALLED = "Not Installed"
     GPU_AVAILABLE = "GPU(s) Available"
     ls_lib = ["torch", "tensorflow"]
     lib_stats = {lib: NOT_INSTALLED for lib in ls_lib}
     for lib in ls_lib:
-        spec = importlib.util.find_spec(lib)
+        spec = importlib.util.find_spec(lib)  # ty:ignore[possibly-missing-attribute]
         if spec:
             if lib == "torch":
                 import torch
 
                 lib_stats[lib] = str(torch.cuda.device_count()) + " " + GPU_AVAILABLE
             elif lib == "tensorflow":
-                import tensorflow as tf
+                import tensorflow as tf  # type: ignore
 
                 lib_stats[lib] = (
                     str(len(tf.config.list_physical_devices("GPU")))

halib-0.2.30/halib/utils/dict.py

@@ -0,0 +1,317 @@
+from future.utils.surrogateescape import fn
+import copy
+import json
+import hashlib
+from rich.pretty import pprint
+from typing import Dict, Any, Callable, Optional, List, Tuple
+
+
+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
+
+    @staticmethod
+    def get_unique_hash(input_dict, length=12):
+        """
+        Returns a unique hash string for a dictionary.
+
+        :param input_dict: The dictionary params
+        :param length: The desired length of the hash string (default 12)
+        """
+        assert length >= 12, "Hash length must be at least 12 to ensure uniqueness."
+        # 1. Sort keys to ensure {a:1, b:2} == {b:2, a:1}
+        config_str = json.dumps(input_dict, sort_keys=True)
+
+        # 2. Generate full SHA-256 hash (64 chars long)
+        full_hash = hashlib.sha256(config_str.encode("utf-8")).hexdigest()
+
+        # 3. Truncate to desired length
+        return full_hash[:length]
+
+    @staticmethod
+    def deep_exclude(
+        d: Dict[str, Any],
+        keys_to_exclude: List[str],
+        in_place: bool = False,
+        sep: str = ".",
+    ) -> Dict[str, Any]:
+        """
+        Removes keys from a nested dictionary based on a list of dot-notation paths.
+
+        Args:
+            d: The dictionary to filter.
+            keys_to_exclude: A list of flattened keys to exclude (e.g., ['model.layers.dropout']).
+            in_place: If True, modifies the dictionary directly.
+                      If False, creates and modifies a deep copy, leaving the original untouched.
+            sep: Separator used in the dot-notation keys (default: ".").
+
+        Returns:
+            The modified dictionary (either the original object or the new copy).
+
+        Example:
+            >>> data = {'a': {'b': 1, 'c': 2}}
+            >>> DictUtils.deep_exclude(data, ['a.b'], in_place=False)
+            {'a': {'c': 2}}
+        """
+        # 1. Handle the copy logic based on the in_place flag
+        if in_place:
+            target_dict = d
+        else:
+            target_dict = copy.deepcopy(d)
+
+        # 2. Iterate over each dot-notation key we want to delete
+        for flat_key in keys_to_exclude:
+            parts = flat_key.split(sep)
+
+            # 3. Traverse to the parent container of the key we want to delete
+            current_level = target_dict
+            parent_found = True
+
+            # Loop through path parts up to the second-to-last item (the parent)
+            for part in parts[:-1]:
+                if isinstance(current_level, dict) and part in current_level:
+                    current_level = current_level[part]
+                else:
+                    # The path doesn't exist in this dict, safely skip deletion
+                    parent_found = False
+                    break
+
+            # 4. Delete the final key (leaf) if the parent was found
+            if parent_found and isinstance(current_level, dict):
+                leaf_key = parts[-1]
+                if leaf_key in current_level:
+                    del current_level[leaf_key]
+
+        return target_dict
+
+    @staticmethod
+    def deep_include(
+        d: Dict[str, Any],
+        keys_to_include: List[str],
+        in_place: bool = False,
+        sep: str = ".",
+    ) -> Dict[str, Any]:
+        """
+        Filters a nested dictionary to keep ONLY the specified dot-notation paths.
+
+        Args:
+            d: The dictionary to filter.
+            keys_to_include: A list of flattened keys to include (e.g., ['a.b.c']).
+            in_place: If True, modifies the original dictionary.
+            sep: Separator used in the dot-notation keys.
+
+        Returns:
+            The filtered dictionary.
+        """
+        # 1. Create a fresh container for the keys we want to preserve
+        # Unlike deep_remove, it's often cleaner to build a new dict
+        # than to delete everything else.
+        new_dict = {}
+
+        for flat_key in keys_to_include:
+            parts = flat_key.split(sep)
+
+            # Pointers to traverse both dictionaries
+            current_source = d
+            current_target = new_dict
+
+            for i, part in enumerate(parts):
+                if isinstance(current_source, dict) and part in current_source:
+                    # Move down the source
+                    current_source = current_source[part]
+
+                    # If we are at the leaf of the 'keep' path, copy the value
+                    if i == len(parts) - 1:
+                        current_target[part] = copy.deepcopy(current_source)
+                    else:
+                        # If the path doesn't exist in our new_dict yet, create it
+                        if part not in current_target or not isinstance(
+                            current_target[part], dict
+                        ):
+                            current_target[part] = {}
+                        current_target = current_target[part]
+                else:
+                    # The path to keep doesn't exist in the source, skip it
+                    break
+
+        # 2. Handle the in_place logic
+        if in_place:
+            d.clear()
+            d.update(new_dict)
+            return d
+
+        return new_dict
+
+    @staticmethod
+    def apply_exclusion_mask(
+        d: Dict[str, Any],
+        config_mask: Dict[str, Any],
+        in_place: bool = False,
+        sep: str = ".",
+    ) -> Dict[str, Any]:
+        """
+        Uses a dictionary 'mask' to define what to throw away.
+        """
+        # Assuming your DictUtils.flatten returns a dict of {path: value}
+        flatten_dict = DictUtils.flatten(config_mask, sep=sep)
+        paths_to_exclude = list(flatten_dict.keys())
+        return DictUtils.deep_exclude(d, paths_to_exclude, in_place=in_place, sep=sep)
+
+    @staticmethod
+    def apply_inclusion_mask(
+        d: Dict[str, Any],
+        config_mask: Dict[str, Any],
+        in_place: bool = False,
+        sep: str = ".",
+    ) -> Dict[str, Any]:
+        """
+        Renamed from 'deep_keep_by_config'.
+        Uses a dictionary 'mask' to define what to allow.
+        """
+        flatten_dict = DictUtils.flatten(config_mask, sep=sep)
+        paths_to_include = list(flatten_dict.keys())
+        return DictUtils.deep_include(d, paths_to_include, in_place=in_place, sep=sep)
+
+    @staticmethod
+    def prune(d: Any, prune_values: Tuple[Any, ...] = (None, {}, [], "")) -> Any:
+        """
+        Recursively removes keys where values match any item in 'prune_values'.
+
+        Args:
+            d: The dictionary or list to clean.
+            prune_values: A tuple of values to be removed.
+                          Default is (None, {}, [], "") which removes all empty types.
+                          Pass specific values (e.g., ({}, "")) to keep None or [].
+
+        Returns:
+            The cleaned structure.
+        """
+        if isinstance(d, dict):
+            new_dict = {}
+            for k, v in d.items():
+                # 1. Recursively clean children first
+                cleaned_v = DictUtils.prune(v, prune_values)
+
+                # 2. Check if the CLEANED value is in the delete list
+                # We use strict check to ensure we don't delete 0 or False unless requested
+                if cleaned_v not in prune_values:
+                    new_dict[k] = cleaned_v
+            return new_dict
+
+        elif isinstance(d, list):
+            new_list = []
+            for v in d:
+                cleaned_v = DictUtils.prune(v, prune_values)
+                if cleaned_v not in prune_values:
+                    new_list.append(cleaned_v)
+            return new_list
+
+        else:
+            return d

{halib-0.2.28 → halib-0.2.30}/halib/utils/slack.py

@@ -3,7 +3,9 @@ from slack_sdk import WebClient
 from slack_sdk.errors import SlackApiError
 from rich.pretty import pprint
 
-
+"""
+Utilities for interacting with Slack for experiment notification via Wandb Logger.
+"""
 class SlackUtils:
     _instance = None
 

{halib-0.2.28 → halib-0.2.30}/halib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halib
-Version: 0.2.28
+Version: 0.2.30
 Summary: Small library for common tasks
 Author: Hoang Van Ha
 Author-email: hoangvanhauit@gmail.com
@@ -57,6 +57,12 @@ Dynamic: summary
 
 ## v0.2.x (Experiment & Core Updates)
 
+### **v0.2.30**
+
+- ✨ **New Feature:**: add `common.common.log_func` as decorator to log function entry, exit, with execution time and arguments.
+
+- 🚀 **Improvement:**: enhance `utils.dict.DictUtils` with `deep_exclude/include` and `prune` function
+
 ### **v0.2.28**
 
 - ✨ **New Feature:** Implement `utils.slack.SlackUtils` class for managing Slack channel message deletion

{halib-0.2.28 → halib-0.2.30}/setup.py

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

halib-0.2.28/halib/utils/dict.py

@@ -1,202 +0,0 @@
-from typing import Dict, Any, Callable, Optional
-from rich.pretty import pprint
-import json
-import hashlib
-
-
-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
-
-    @staticmethod
-    def get_unique_hash(input_dict, length=12):
-        """
-        Returns a unique hash string for a dictionary.
-
-        :param input_dict: The dictionary params
-        :param length: The desired length of the hash string (default 12)
-        """
-        assert length >= 12, "Hash length must be at least 12 to ensure uniqueness."
-        # 1. Sort keys to ensure {a:1, b:2} == {b:2, a:1}
-        config_str = json.dumps(input_dict, sort_keys=True)
-
-        # 2. Generate full SHA-256 hash (64 chars long)
-        full_hash = hashlib.sha256(config_str.encode("utf-8")).hexdigest()
-
-        # 3. Truncate to desired length
-        return full_hash[:length]
-
-
-def test_update():
-    # --- 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))
-
-
-def test_hash():
-    # --- Usage ---
-    cfg1 = {"learning_rate": 0.01, "batch_size": 32, "optimizer": "adam"}
-    cfg1_shuffle = {
-        "batch_size": 32,
-        "optimizer": "adam",
-        "learning_rate": 0.01,
-    }
-    cfg2 = {"learning_rate": 0.02, "batch_size": 32, "optimizer": "adam"}
-    hash1 = DictUtils.get_unique_hash(cfg1)
-    hash2 = DictUtils.get_unique_hash(cfg1_shuffle)
-    hash3 = DictUtils.get_unique_hash(cfg2)
-    pprint(f"Config 1 Hash: {hash1}")
-    pprint(f"Config 1_shuffle Hash: {hash2}")
-    pprint(f"Config 2 Hash: {hash3}")
-
-    assert hash1 == hash2, "Hashes should match for identical dicts."
-    assert hash1 != hash3, "Hashes should differ for different dicts."
-
-
-if __name__ == "__main__":
-    test_update()
-    test_hash()