halib 0.1.7__py3-none-any.whl → 0.1.99__py3-none-any.whl

halib/__init__.py

@@ -0,0 +1,84 @@
+__all__ = [
+    "arrow",
+    "cmd",
+    "console_log",
+    "console",
+    "ConsoleLog",
+    "csvfile",
+    "DictConfig",
+    "filetype",
+    "fs",
+    "inspect",
+    "load_yaml",
+    "logger",
+    "norm_str",
+    "now_str",
+    "np",
+    "omegaconf",
+    "OmegaConf",
+    "os",
+    "pd",
+    "plt",
+    "pprint",
+    "pprint_box",
+    "pprint_local_path",
+    "px",
+    "pprint_local_path",
+    "rcolor_all_str",
+    "rcolor_palette_all",
+    "rcolor_palette",
+    "rcolor_str",
+    "re",
+    "rprint",
+    "sns",
+    "tcuda",
+    "timebudget",
+    "tqdm",
+    "warnings",
+    "time",
+]
+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 .cuda import tcuda
+from .common import (
+    console,
+    console_log,
+    ConsoleLog,
+    now_str,
+    norm_str,
+    pprint_box,
+    pprint_local_path,
+)
+
+# 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 .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.py

@@ -0,0 +1,151 @@
+import os
+import re
+import rich
+import arrow
+import pathlib
+from pathlib import Path
+import urllib.parse
+
+from rich import print
+from rich.panel import Panel
+from rich.console import Console
+from rich.pretty import pprint, Pretty
+from pathlib import PureWindowsPath
+
+
+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 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))
+
+
+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

halib/cuda.py

@@ -0,0 +1,39 @@
+import importlib
+from rich.pretty import pprint
+from rich.console import Console
+
+console = Console()
+
+
+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)
+        if spec:
+            if lib == "torch":
+                import torch
+
+                lib_stats[lib] = str(torch.cuda.device_count()) + " " + GPU_AVAILABLE
+            elif lib == "tensorflow":
+                import tensorflow as tf
+
+                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
+
+
+def main():
+    tcuda()
+
+
+if __name__ == "__main__":
+    main()

halib/dataset.py

@@ -0,0 +1,209 @@
+# This script create a test version
+# of the watcam (wc) dataset
+# for testing the tflite model
+
+from argparse import ArgumentParser
+
+from rich import inspect
+from common import console, seed_everything, ConsoleLog
+from sklearn.model_selection import StratifiedShuffleSplit, ShuffleSplit
+from tqdm import tqdm
+import os
+import click
+from torchvision.datasets import ImageFolder
+import shutil
+from rich.pretty import pprint
+from system import filesys as fs
+import glob
+
+
+def parse_args():
+    parser = ArgumentParser(description="desc text")
+    parser.add_argument(
+        "-indir",
+        "--indir",
+        type=str,
+        help="orignal dataset path",
+    )
+    parser.add_argument(
+        "-outdir",
+        "--outdir",
+        type=str,
+        help="dataset out path",
+        default=".",  # default to current dir
+    )
+    parser.add_argument(
+        "-val_size",
+        "--val_size",
+        type=float,
+        help="validation size",  # no default value to force user to input
+        default=0.2,
+    )
+    # add using StratifiedShuffleSplit or ShuffleSplit
+    parser.add_argument(
+        "-seed",
+        "--seed",
+        type=int,
+        help="random seed",
+        default=42,
+    )
+    parser.add_argument(
+        "-inplace",
+        "--inplace",
+        action="store_true",
+        help="inplace operation, will overwrite the outdir if exists",
+    )
+
+    parser.add_argument(
+        "-stratified",
+        "--stratified",
+        action="store_true",
+        help="use StratifiedShuffleSplit instead of ShuffleSplit",
+    )
+    parser.add_argument(
+        "-no_train",
+        "--no_train",
+        action="store_true",
+        help="only create test set, no train set",
+    )
+    parser.add_argument(
+        "-reverse",
+        "--reverse",
+        action="store_true",
+        help="combine train and val set back to original dataset",
+    )
+    return parser.parse_args()
+
+
+def move_images(image_paths, target_set_dir):
+    for img_path in tqdm(image_paths):
+        # get folder name of the image
+        img_dir = os.path.dirname(img_path)
+        out_cls_dir = os.path.join(target_set_dir, os.path.basename(img_dir))
+        if not os.path.exists(out_cls_dir):
+            os.makedirs(out_cls_dir)
+        # move the image to the class folder
+        shutil.move(img_path, out_cls_dir)
+
+
+def split_dataset_cls(
+    indir, outdir, val_size, seed, inplace, stratified_split, no_train
+):
+    seed_everything(seed)
+    console.rule("Config confirm?")
+    pprint(locals())
+    click.confirm("Continue?", abort=True)
+    assert os.path.exists(indir), f"{indir} does not exist"
+
+    if not inplace:
+        assert (not inplace) and (
+            not os.path.exists(outdir)
+        ), f"{outdir} already exists; SKIP ...."
+
+    if inplace:
+        outdir = indir
+    if not os.path.exists(outdir):
+        os.makedirs(outdir)
+
+    console.rule(f"Creating train/val dataset")
+
+    sss = (
+        ShuffleSplit(n_splits=1, test_size=val_size)
+        if not stratified_split
+        else StratifiedShuffleSplit(n_splits=1, test_size=val_size)
+    )
+
+    pprint({"split strategy": sss, "indir": indir, "outdir": outdir})
+    dataset = ImageFolder(
+        root=indir,
+        transform=None,
+    )
+    train_dataset_indices = None
+    val_dataset_indices = None  # val here means test
+    for train_indices, val_indices in sss.split(dataset.samples, dataset.targets):
+        train_dataset_indices = train_indices
+        val_dataset_indices = val_indices
+
+    # get image paths for train/val split dataset
+    train_image_paths = [dataset.imgs[i][0] for i in train_dataset_indices]
+    val_image_paths = [dataset.imgs[i][0] for i in val_dataset_indices]
+
+    # start creating train/val folders then move images
+    out_train_dir = os.path.join(outdir, "train")
+    out_val_dir = os.path.join(outdir, "val")
+    if inplace:
+        assert os.path.exists(out_train_dir) == False, f"{out_train_dir} already exists"
+        assert os.path.exists(out_val_dir) == False, f"{out_val_dir} already exists"
+
+    os.makedirs(out_train_dir)
+    os.makedirs(out_val_dir)
+
+    if not no_train:
+        with ConsoleLog(f"Moving train images to {out_train_dir} "):
+            move_images(train_image_paths, out_train_dir)
+    else:
+        pprint("test only, skip moving train images")
+        # remove out_train_dir
+        shutil.rmtree(out_train_dir)
+
+    with ConsoleLog(f"Moving val images to {out_val_dir} "):
+        move_images(val_image_paths, out_val_dir)
+
+    if inplace:
+        pprint(f"remove all folders, except train and val")
+        for cls_dir in os.listdir(outdir):
+            if cls_dir not in ["train", "val"]:
+                shutil.rmtree(os.path.join(indir, cls_dir))
+
+
+def reverse_split_ds(indir):
+    console.rule(f"Reversing split dataset <{indir}>...")
+    ls_dirs = os.listdir(indir)
+    # make sure there are only two dirs 'train' and 'val'
+    assert len(ls_dirs) == 2, f"Found more than 2 dirs: {len(ls_dirs) } dirs"
+    assert "train" in ls_dirs, f"train dir not found in {indir}"
+    assert "val" in ls_dirs, f"val dir not found in {indir}"
+    train_dir = os.path.join(indir, "train")
+    val_dir = os.path.join(indir, "val")
+    all_train_files = fs.filter_files_by_extension(
+        train_dir, ["jpg", "jpeg", "png", "bmp", "gif", "tiff"]
+    )
+    all_val_files = fs.filter_files_by_extension(
+        val_dir, ["jpg", "jpeg", "png", "bmp", "gif", "tiff"]
+    )
+    # move all files from train to indir
+    with ConsoleLog(f"Moving train images to {indir} "):
+        move_images(all_train_files, indir)
+    with ConsoleLog(f"Moving val images to {indir} "):
+        move_images(all_val_files, indir)
+    with ConsoleLog(f"Removing train and val dirs"):
+        # remove train and val dirs
+        shutil.rmtree(train_dir)
+        shutil.rmtree(val_dir)
+
+
+def main():
+    args = parse_args()
+    indir = args.indir
+    outdir = args.outdir
+    if outdir == ".":
+        # get current folder of the indir
+        indir_parent_dir = os.path.dirname(os.path.normpath(indir))
+        indir_name = os.path.basename(indir)
+        outdir = os.path.join(indir_parent_dir, f"{indir_name}_split")
+    val_size = args.val_size
+    seed = args.seed
+    inplace = args.inplace
+    stratified_split = args.stratified
+    no_train = args.no_train
+    reverse = args.reverse
+    if not reverse:
+        split_dataset_cls(
+            indir, outdir, val_size, seed, inplace, stratified_split, no_train
+        )
+    else:
+        reverse_split_ds(indir)
+
+
+if __name__ == "__main__":
+    main()