halib 0.2.30__py3-none-any.whl

halib/__init__.py

@@ -0,0 +1,94 @@
+__all__ = [
+    "arrow",
+    "cmd",
+    "console_log",
+    "console",
+    "ConsoleLog",
+    "csvfile",
+    "DictConfig",
+    "filetype",
+    "fs",
+    "inspect",
+    "load_yaml",
+    "log_func",
+    "logger",
+    "norm_str",
+    "now_str",
+    "np",
+    "omegaconf",
+    "OmegaConf",
+    "os",
+    "pad_string",
+    "pd",
+    "plt",
+    "pprint_box",
+    "pprint_local_path",
+    "pprint_stack_trace",
+    "pprint",
+    "px",
+    "rcolor_all_str",
+    "rcolor_palette_all",
+    "rcolor_palette",
+    "rcolor_str",
+    "re",
+    "rprint",
+    "sns",
+    "tcuda",
+    "time",
+    "timebudget",
+    "tqdm",
+    "warnings",
+]
+import warnings
+
+warnings.filterwarnings("ignore", message="Unable to import Axes3D")
+
+# common libraries
+import re
+from tqdm import tqdm
+import arrow
+import numpy as np
+import pandas as pd
+import os
+import time
+
+# my own modules
+from .filetype import *
+from .filetype.yamlfile import load_yaml
+from .system import cmd
+from .system import filesys as fs
+from .filetype import csvfile
+from .common.common import (
+    console,
+    console_log,
+    ConsoleLog,
+    now_str,
+    norm_str,
+    pprint_box,
+    pprint_local_path,
+    pprint_stack_trace,
+    tcuda,
+    log_func,
+    pad_string,
+)
+
+# for log
+from loguru import logger
+from rich import inspect
+from rich import print as rprint
+from rich.pretty import pprint
+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,
+)
+
+# for visualization
+import seaborn as sns
+import matplotlib.pyplot as plt
+import plotly.express as px

halib/common/common.py

@@ -0,0 +1,326 @@
+import os
+import sys
+import re
+import arrow
+import importlib
+
+import rich
+from rich import print
+from rich.panel import Panel
+from rich.console import Console
+from rich.pretty import pprint, Pretty
+
+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()
+
+
+def seed_everything(seed=42):
+    import random
+    import numpy as np
+
+    random.seed(seed)
+    np.random.seed(seed)
+    # import torch if it is available
+    try:
+        import torch
+
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+    except ImportError:
+        pprint("torch not imported, skipping torch seed_everything")
+        pass
+
+
+def now_str(sep_date_time="."):
+    assert sep_date_time in [
+        ".",
+        "_",
+        "-",
+    ], "sep_date_time must be one of '.', '_', or '-'"
+    now_string = arrow.now().format(f"YYYYMMDD{sep_date_time}HHmmss")
+    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)
+    # Remove leading and trailing spaces
+    norm_string = norm_string.strip()
+    return norm_string
+
+
+def pprint_box(obj, title="", border_style="green"):
+    """
+    Pretty print an object in a box.
+    """
+    rich.print(
+        Panel(Pretty(obj, expand_all=True), title=title, border_style=border_style)
+    )
+
+
+def console_rule(msg, do_norm_msg=True, is_end_tag=False):
+    msg = norm_str(msg) if do_norm_msg else msg
+    if is_end_tag:
+        console.rule(f"</{msg}>")
+    else:
+        console.rule(f"<{msg}>")
+
+
+def console_log(func):
+    def wrapper(*args, **kwargs):
+        console_rule(func.__name__)
+        result = func(*args, **kwargs)
+        console_rule(func.__name__, is_end_tag=True)
+        return result
+
+    return wrapper
+
+
+class ConsoleLog:
+    def __init__(self, message):
+        self.message = message
+
+    def __enter__(self):
+        console_rule(self.message)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        console_rule(self.message, is_end_tag=True)
+        if exc_type is not None:
+            print(f"An exception of type {exc_type} occurred.")
+            print(f"Exception message: {exc_value}")
+
+
+def linux_to_wins_path(path: str) -> str:
+    """
+    Convert a Linux-style WSL path (/mnt/c/... or /mnt/d/...) to a Windows-style path (C:\...).
+    """
+    # Handle only /mnt/<drive>/... style
+    if (
+        path.startswith("/mnt/")
+        and len(path) > 6
+        and path[5].isalpha()
+        and path[6] == "/"
+    ):
+        drive = path[5].upper()  # Extract drive letter
+        win_path = f"{drive}:{path[6:]}"  # Replace "/mnt/c/" with "C:/"
+    else:
+        win_path = path  # Return unchanged if not a WSL-style path
+    # Normalize to Windows-style backslashes
+    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:
+    """
+    Pretty-print a local path with emoji and clickable file:// URI.
+
+    Args:
+        local_path: Path to file or directory (Linux or Windows style).
+        get_wins_path: If True on Linux, convert WSL-style path to Windows style before printing.
+        tag: Optional console log tag.
+
+    Returns:
+        The file URI string.
+    """
+    p = Path(local_path).resolve()
+    type_str = "📄" if p.is_file() else "📁" if p.is_dir() else "❓"
+
+    if get_wins_path and os.name == "posix":
+        # Try WSL → Windows conversion
+        converted = linux_to_wins_path(str(p))
+        if converted != str(p):  # Conversion happened
+            file_uri = str(PureWindowsPath(converted).as_uri())
+        else:
+            file_uri = p.as_uri()
+    else:
+        file_uri = p.as_uri()
+
+    content_str = f"{type_str} [link={file_uri}]{file_uri}[/link]"
+
+    if tag:
+        with ConsoleLog(tag):
+            console.print(content_str)
+    else:
+        console.print(content_str)
+
+    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)  # 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  # type: ignore
+
+                lib_stats[lib] = (
+                    str(len(tf.config.list_physical_devices("GPU")))
+                    + " "
+                    + GPU_AVAILABLE
+                )
+    console.rule("<CUDA Library Stats>")
+    pprint(lib_stats)
+    console.rule("</CUDA Library Stats>")
+    return lib_stats

halib/common/rich_color.py

@@ -0,0 +1,285 @@
+from rich.console import Console
+from rich.pretty import pprint
+from rich.table import Table
+from rich.text import Text
+from rich.panel import Panel
+
+# List of colors
+# ! https://rich.readthedocs.io/en/stable/appendix/colors.html
+all_colors = [
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white",
+    "bright_black",
+    "bright_red",
+    "bright_green",
+    "bright_yellow",
+    "bright_blue",
+    "bright_magenta",
+    "bright_cyan",
+    "bright_white",
+    "grey0",
+    "navy_blue",
+    "dark_blue",
+    "blue3",
+    "blue1",
+    "dark_green",
+    "deep_sky_blue4",
+    "dodger_blue3",
+    "dodger_blue2",
+    "green4",
+    "spring_green4",
+    "turquoise4",
+    "deep_sky_blue3",
+    "dodger_blue1",
+    "dark_cyan",
+    "light_sea_green",
+    "deep_sky_blue2",
+    "deep_sky_blue1",
+    "green3",
+    "spring_green3",
+    "cyan3",
+    "dark_turquoise",
+    "turquoise2",
+    "green1",
+    "spring_green2",
+    "spring_green1",
+    "medium_spring_green",
+    "cyan2",
+    "cyan1",
+    "purple4",
+    "purple3",
+    "blue_violet",
+    "grey37",
+    "medium_purple4",
+    "slate_blue3",
+    "royal_blue1",
+    "chartreuse4",
+    "pale_turquoise4",
+    "steel_blue",
+    "steel_blue3",
+    "cornflower_blue",
+    "dark_sea_green4",
+    "cadet_blue",
+    "sky_blue3",
+    "chartreuse3",
+    "sea_green3",
+    "aquamarine3",
+    "medium_turquoise",
+    "steel_blue1",
+    "sea_green2",
+    "sea_green1",
+    "dark_slate_gray2",
+    "dark_red",
+    "dark_magenta",
+    "orange4",
+    "light_pink4",
+    "plum4",
+    "medium_purple3",
+    "slate_blue1",
+    "wheat4",
+    "grey53",
+    "light_slate_grey",
+    "medium_purple",
+    "light_slate_blue",
+    "yellow4",
+    "dark_sea_green",
+    "light_sky_blue3",
+    "sky_blue2",
+    "chartreuse2",
+    "pale_green3",
+    "dark_slate_gray3",
+    "sky_blue1",
+    "chartreuse1",
+    "light_green",
+    "aquamarine1",
+    "dark_slate_gray1",
+    "deep_pink4",
+    "medium_violet_red",
+    "dark_violet",
+    "purple",
+    "medium_orchid3",
+    "medium_orchid",
+    "dark_goldenrod",
+    "rosy_brown",
+    "grey63",
+    "medium_purple2",
+    "medium_purple1",
+    "dark_khaki",
+    "navajo_white3",
+    "grey69",
+    "light_steel_blue3",
+    "light_steel_blue",
+    "dark_olive_green3",
+    "dark_sea_green3",
+    "light_cyan3",
+    "light_sky_blue1",
+    "green_yellow",
+    "dark_olive_green2",
+    "pale_green1",
+    "dark_sea_green2",
+    "pale_turquoise1",
+    "red3",
+    "deep_pink3",
+    "magenta3",
+    "dark_orange3",
+    "indian_red",
+    "hot_pink3",
+    "hot_pink2",
+    "orchid",
+    "orange3",
+    "light_salmon3",
+    "light_pink3",
+    "pink3",
+    "plum3",
+    "violet",
+    "gold3",
+    "light_goldenrod3",
+    "tan",
+    "misty_rose3",
+    "thistle3",
+    "plum2",
+    "yellow3",
+    "khaki3",
+    "light_yellow3",
+    "grey84",
+    "light_steel_blue1",
+    "yellow2",
+    "dark_olive_green1",
+    "dark_sea_green1",
+    "honeydew2",
+    "light_cyan1",
+    "red1",
+    "deep_pink2",
+    "deep_pink1",
+    "magenta2",
+    "magenta1",
+    "orange_red1",
+    "indian_red1",
+    "hot_pink",
+    "medium_orchid1",
+    "dark_orange",
+    "salmon1",
+    "light_coral",
+    "pale_violet_red1",
+    "orchid2",
+    "orchid1",
+    "orange1",
+    "sandy_brown",
+    "light_salmon1",
+    "light_pink1",
+    "pink1",
+    "plum1",
+    "gold1",
+    "light_goldenrod2",
+    "navajo_white1",
+    "misty_rose1",
+    "thistle1",
+    "yellow1",
+    "light_goldenrod1",
+    "khaki1",
+    "wheat1",
+    "cornsilk1",
+    "grey100",
+    "grey3",
+    "grey7",
+    "grey11",
+    "grey15",
+    "grey19",
+    "grey23",
+    "grey27",
+    "grey30",
+    "grey35",
+    "grey39",
+    "grey42",
+    "grey46",
+    "grey50",
+    "grey54",
+    "grey58",
+    "grey62",
+    "grey66",
+    "grey70",
+    "grey74",
+    "grey78",
+    "grey82",
+    "grey85",
+    "grey89",
+    "grey93",
+]
+
+basic_colors = [
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white",
+    "bright_black",
+    "bright_red",
+    "bright_green",
+    "bright_yellow",
+    "bright_blue",
+    "bright_magenta",
+    "bright_cyan",
+    "bright_white",
+]
+
+def rcolor_all_str():
+    pprint(all_colors)
+
+def rcolor_basic_str():
+    pprint(basic_colors)
+
+def rcolor_str(in_str, color="white"):
+    assert color in all_colors, f"color must be one of {all_colors}"
+    return f"[{color}]{in_str}[/{color}]"
+
+def rcolor_palette(color_list):
+    # make sure all colors are valid (in all_colors)
+    for color in color_list:
+        assert (
+            color in all_colors
+        ), f"color must be a valid color. call <rcolor_all_str()> or <rcolor_palette_all()> to see all valid colors"
+    # Initialize console
+    console = Console()
+
+    # Create a table with horizontal lines and six columns
+    table = Table(show_header=True, header_style="bold magenta", show_lines=True)
+
+    # Define the columns
+    table.add_column("Color Name 1", style="bold")
+    table.add_column("Sample 1", style="bold")
+    table.add_column("Color Name 2", style="bold")
+    table.add_column("Sample 2", style="bold")
+    table.add_column("Color Name 3", style="bold")
+    table.add_column("Sample 3", style="bold")
+
+    # Adjust the number of rows needed for the table
+    num_colors = len(color_list)
+    num_rows = (num_colors + 2) // 3  # Ceiling division to ensure all colors fit
+
+    # Add rows to the table
+    for i in range(num_rows):
+        color1 = color_list[i * 3] if i * 3 < num_colors else ""
+        color2 = color_list[i * 3 + 1] if i * 3 + 1 < num_colors else ""
+        color3 = color_list[i * 3 + 2] if i * 3 + 2 < num_colors else ""
+        filled_rect1 = Text(" " * 10, style=f"on {color1}") if color1 else ""
+        filled_rect2 = Text(" " * 10, style=f"on {color2}") if color2 else ""
+        filled_rect3 = Text(" " * 10, style=f"on {color3}") if color3 else ""
+        table.add_row(color1, filled_rect1, color2, filled_rect2, color3, filled_rect3)
+
+    # Print the table
+    console.print(table)
+
+def rcolor_palette_basic():
+    rcolor_palette(basic_colors)
+
+def rcolor_palette_all():
+    rcolor_palette(all_colors)