halib 0.2.30__py3-none-any.whl

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/utils/dict_op.py

@@ -0,0 +1,9 @@
+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

halib/utils/gpu_mon.py

@@ -0,0 +1,58 @@
+# install `pynvml_utils` package first
+# see this repo: https://github.com/gpuopenanalytics/pynvml
+from pynvml_utils import nvidia_smi
+import time
+import threading
+from rich.pretty import pprint
+
+class GPUMonitor:
+    def __init__(self, gpu_index=0, interval=0.01):
+        self.nvsmi = nvidia_smi.getInstance()
+        self.gpu_index = gpu_index
+        self.interval = interval
+        self.gpu_stats = []
+        self._running = False
+        self._thread = None
+
+    def _monitor(self):
+        while self._running:
+            stats = self.nvsmi.DeviceQuery("power.draw, memory.used")["gpu"][
+                self.gpu_index
+            ]
+            # pprint(stats)
+            self.gpu_stats.append(
+                {
+                    "power": stats["power_readings"]["power_draw"],
+                    "power_unit": stats["power_readings"]["unit"],
+                    "memory": stats["fb_memory_usage"]["used"],
+                    "memory_unit": stats["fb_memory_usage"]["unit"],
+                }
+            )
+            time.sleep(self.interval)
+
+    def start(self):
+        if not self._running:
+            self._running = True
+            # clear previous stats
+            self.gpu_stats.clear()
+            self._thread = threading.Thread(target=self._monitor)
+            self._thread.start()
+
+    def stop(self):
+        if self._running:
+            self._running = False
+            self._thread.join()
+            # clear the thread reference
+            self._thread = None
+
+    def get_stats(self):
+        ## return self.gpu_stats
+        assert self._running is False, "GPU monitor is still running. Stop it first."
+
+        powers = [s["power"] for s in self.gpu_stats if s["power"] is not None]
+        memories = [s["memory"] for s in self.gpu_stats if s["memory"] is not None]
+        avg_power = sum(powers) / len(powers) if powers else 0
+        max_memory = max(memories) if memories else 0
+        # power_unit = self.gpu_stats[0]["power_unit"] if self.gpu_stats else "W"
+        # memory_unit = self.gpu_stats[0]["memory_unit"] if self.gpu_stats else "MiB"
+        return {"gpu_avg_power": avg_power, "gpu_avg_max_memory": max_memory}

halib/utils/list.py

@@ -0,0 +1,17 @@
+class ListUtils:
+    """Utility functions for list operations."""
+
+    @staticmethod
+    def subtract(list_a, list_b):
+        return [item for item in list_a if item not in list_b]
+
+    @staticmethod
+    def union(list_a, list_b, no_duplicate=False):
+        if no_duplicate:
+            return list(set(list_a) | set(list_b))
+        else:
+            return list_a + list_b
+
+    @staticmethod
+    def intersection(list_a, list_b):
+        return list(set(list_a) & set(list_b))

halib/utils/listop.py

@@ -0,0 +1,13 @@
+def subtract(list_a, list_b):
+    return [item for item in list_a if item not in list_b]
+
+
+def union(list_a, list_b, no_duplicate=False):
+    if no_duplicate:
+        return list(set(list_a) | set(list_b))
+    else:
+        return list_a + list_b
+
+
+def intersection(list_a, list_b):
+    return list(set(list_a) & set(list_b))

halib/utils/slack.py

@@ -0,0 +1,86 @@
+import time
+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
+
+    def __new__(cls, token=None):
+        """
+        Singleton __new__ method.
+        Ensures only one instance of SlackUtils exists.
+        """
+        if cls._instance is None:
+            if token is None:
+                raise ValueError(
+                    "A Slack Token is required for the first initialization."
+                )
+
+            # Create the instance
+            cls._instance = super(SlackUtils, cls).__new__(cls)
+
+            # Initialize the WebClient only once
+            cls._instance.client = WebClient(token=token)
+            cls._instance.token = token
+
+        return cls._instance
+
+    def clear_channel(self, channel_id, sleep_interval=1.0):
+        """
+        Fetches and deletes all messages in a specified channel.
+        """
+        cursor = None
+        deleted_count = 0
+
+        pprint(f"--- Starting cleanup for Channel ID: {channel_id} ---")
+
+        while True:
+            try:
+                # Fetch history in batches of 100
+                response = self.client.conversations_history(  # ty:ignore[unresolved-attribute]
+                    channel=channel_id, cursor=cursor, limit=100
+                )
+
+                messages = response.get("messages", [])
+
+                if not messages:
+                    pprint("No more messages found to delete.")
+                    break
+
+                for msg in messages:
+                    ts = msg.get("ts")
+
+                    try:
+                        # Attempt delete
+                        self.client.chat_delete(  # ty:ignore[unresolved-attribute]
+                            channel=channel_id, ts=ts
+                        )
+                        pprint(f"Deleted: {ts}")
+                        deleted_count += 1
+
+                        # Rate limit protection (Tier 3 limit)
+                        time.sleep(sleep_interval)
+
+                    except SlackApiError as e:
+                        error_code = e.response["error"]
+                        if error_code == "cant_delete_message":
+                            pprint(f"Skipped (Permission denied): {ts}")
+                        elif error_code == "message_not_found":
+                            pprint(f"Skipped (Already deleted): {ts}")
+                        else:
+                            pprint(f"Error deleting {ts}: {error_code}")
+                # Check for pagination
+                if response["has_more"]:
+                    cursor = response["response_metadata"]["next_cursor"]
+                else:
+                    break
+
+            except SlackApiError as e:
+                print(f"Critical API Error fetching history: {e.response['error']}")
+                break
+
+        print(f"--- Completed. Total messages deleted: {deleted_count} ---")

halib/utils/tele_noti.py

@@ -0,0 +1,166 @@
+# Watch a log file and send a telegram message when train reaches a certain epoch or end
+
+import os
+import yaml
+import asyncio
+import telegram
+import pandas as pd
+
+from rich.pretty import pprint
+from rich.console import Console
+import plotly.graph_objects as go
+
+from ..system import filesys as fs
+from ..filetype import textfile, csvfile
+
+from argparse import ArgumentParser
+
+tele_console = Console()
+
+
+def parse_args():
+    parser = ArgumentParser(description="desc text")
+    parser.add_argument(
+        "-cfg",
+        "--cfg",
+        type=str,
+        help="yaml file for tele",
+        default=r"E:\Dev\halib\cfg_tele_noti.yaml",
+    )
+
+    return parser.parse_args()
+
+
+def get_watcher_message_df(target_file, num_last_lines):
+    file_ext = fs.get_file_name(target_file, split_file_ext=True)[1]
+    supported_ext = [".txt", ".log", ".csv"]
+    assert (
+        file_ext in supported_ext
+    ), f"File extension {file_ext} not supported. Supported extensions are {supported_ext}"
+    last_lines_df = None
+    if file_ext in [".txt", ".log"]:
+        lines = textfile.read_line_by_line(target_file)
+        if num_last_lines > len(lines):
+            num_last_lines = len(lines)
+        last_line_arr = lines[-num_last_lines:]
+        # add a line start with word "epoch"
+        epoch_info_list = "Epoch: n/a"
+        for line in reversed(lines):
+            if "epoch" in line.lower():
+                epoch_info_list = line
+                break
+        last_line_arr.insert(0, epoch_info_list)  # insert at the beginning
+        dfCreator = csvfile.DFCreator()
+        dfCreator.create_table("last_lines", ["line"])
+        last_line_arr = [[line] for line in last_line_arr]
+        dfCreator.insert_rows("last_lines", last_line_arr)
+        dfCreator.fill_table_from_row_pool("last_lines")
+        last_lines_df = dfCreator["last_lines"].copy()
+    else:
+        df = pd.read_csv(target_file)
+        num_rows = len(df)
+        if num_last_lines > num_rows:
+            num_last_lines = num_rows
+        last_lines_df = df.tail(num_last_lines)
+    return last_lines_df
+
+
+def df2img(df: pd.DataFrame, output_img_dir, decimal_places, out_img_scale):
+    df = df.round(decimal_places)
+    fig = go.Figure(
+        data=[
+            go.Table(
+                header=dict(values=list(df.columns), align="center"),
+                cells=dict(
+                    values=df.values.transpose(),
+                    fill_color=[["white", "lightgrey"] * df.shape[0]],
+                    align="center",
+                ),
+            )
+        ]
+    )
+    if not os.path.exists(output_img_dir):
+        os.makedirs(output_img_dir)
+    img_path = os.path.normpath(os.path.join(output_img_dir, "last_lines.png"))
+    fig.write_image(img_path, scale=out_img_scale)
+    return img_path
+
+
+def compose_message_and_img_path(
+    target_file, project, num_last_lines, decimal_places, out_img_scale, output_img_dir
+):
+    context_msg = f">> Project: {project} \n>> File: {target_file} \n>> Last {num_last_lines} lines:"
+    msg_df = get_watcher_message_df(target_file, num_last_lines)
+    try:
+        img_path = df2img(msg_df, output_img_dir, decimal_places, out_img_scale)
+    except Exception as e:
+        pprint(f"Error: {e}")
+        img_path = None
+    return context_msg, img_path
+
+
+async def send_to_telegram(cfg_dict, interval_in_sec):
+    # pprint(cfg_dict)
+    token = cfg_dict["telegram"]["token"]
+    chat_id = cfg_dict["telegram"]["chat_id"]
+
+    noti_settings = cfg_dict["noti_settings"]
+    project = noti_settings["project"]
+    target_file = noti_settings["target_file"]
+    num_last_lines = noti_settings["num_last_lines"]
+    output_img_dir = noti_settings["output_img_dir"]
+    decimal_places = noti_settings["decimal_places"]
+    out_img_scale = noti_settings["out_img_scale"]
+
+    bot = telegram.Bot(token=token)
+    async with bot:
+        try:
+            context_msg, img_path = compose_message_and_img_path(
+                target_file,
+                project,
+                num_last_lines,
+                decimal_places,
+                out_img_scale,
+                output_img_dir,
+            )
+            time_now = next_time = pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S")
+            sep_line = "-" * 50
+            context_msg = f"{sep_line}\n>> Time: {time_now}\n{context_msg}"
+            # calculate the next time to send message
+            next_time = pd.Timestamp.now() + pd.Timedelta(seconds=interval_in_sec)
+            next_time = next_time.strftime("%Y-%m-%d %H:%M:%S")
+            next_time_info = f"Next msg: {next_time}"
+            tele_console.rule()
+            tele_console.print("[green] Send message to telegram [/green]")
+            tele_console.print(
+                f"[red] Next message will be sent at <{next_time}> [/red]"
+            )
+            await bot.send_message(text=context_msg, chat_id=chat_id)
+            if img_path:
+                await bot.send_photo(chat_id=chat_id, photo=open(img_path, "rb"))
+            await bot.send_message(text=next_time_info, chat_id=chat_id)
+        except Exception as e:
+            pprint(f"Error: {e}")
+            pprint("Message not sent to telegram")
+
+
+async def run_forever(cfg_path):
+    cfg_dict = yaml.safe_load(open(cfg_path, "r"))
+    noti_settings = cfg_dict["noti_settings"]
+    interval_in_min = noti_settings["interval_in_min"]
+    interval_in_sec = int(interval_in_min * 60)
+    pprint(
+        f"Message will be sent every {interval_in_min} minutes or {interval_in_sec} seconds"
+    )
+    while True:
+        await send_to_telegram(cfg_dict, interval_in_sec)
+        await asyncio.sleep(interval_in_sec)
+
+
+async def main():
+    args = parse_args()
+    await run_forever(args.cfg)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())