halib 0.2.30__py3-none-any.whl

halib/filesys.py

@@ -0,0 +1,117 @@
+import glob
+import os
+import shutil
+from distutils.dir_util import copy_tree
+
+
+def is_exit(path):
+    return os.path.exists(path)
+
+
+def is_directory(path):
+    return os.path.isdir(path)
+
+
+def get_current_dir():
+    return os.getcwd()
+
+
+def change_current_dir(new_dir):
+    if is_directory(new_dir):
+        os.chdir(new_dir)
+
+
+def get_dir_name(directory):
+    return os.path.basename(os.path.normpath(directory))
+
+
+def get_parent_dir(directory, return_full_path=False):
+    if not return_full_path:
+        return os.path.basename(os.path.dirname(directory))
+    else:
+        return os.path.dirname(directory)
+
+
+def make_dir(directory):
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+
+def copy_dir(src_dir, dst_dir, dirs_exist_ok=True, ignore_patterns=None):
+    shutil.copytree(src_dir, dst_dir, dirs_exist_ok=dirs_exist_ok,
+                    ignore=ignore_patterns)
+
+
+def delete_dir(directory):
+    shutil.rmtree(directory)
+
+
+def list_dirs(directory):
+    folders = list(filter(lambda x: os.path.isdir(os.path.join(directory, x)),
+                          os.listdir(directory)))
+    return folders
+
+
+def list_files(directory):
+    files = list(filter(lambda x: os.path.isfile(os.path.join(directory, x)),
+                        os.listdir(directory)))
+    return files
+
+
+def filter_files_by_extension(directory, ext, recursive=True):
+    if is_directory(directory):
+        result_files = []
+        if isinstance(ext, list):
+            ext_list = ext
+        else:
+            ext_list = [ext]
+        if not recursive:
+            filter_pattern = f'{directory}/*'
+        else:
+            filter_pattern = f'{directory}/**/*'
+
+        for ext_item in ext_list:
+            ext_filter = f'{filter_pattern}.{ext_item}'
+            files = glob.glob(filter_pattern, recursive=True)
+            files = [f for f in files if is_file(f) and f.endswith(ext_item)]
+            result_files.extend(files)
+        return result_files
+    else:
+        raise OSError("Directory not exists")
+
+
+def is_file(path):
+    return os.path.isfile(path)
+
+
+def get_file_name(file_path, split_file_ext=False):
+    if is_file(file_path):
+        if split_file_ext:
+            filename, file_extension = os.path.splitext(os.path.basename(file_path))
+            return filename, file_extension
+        else:
+            return os.path.basename(file_path)
+    else:
+        raise OSError("Not a file")
+
+
+def get_absolute_path(file_path):
+    return os.path.abspath(file_path)
+
+
+# dest can be a directory
+def copy_file(source, dest):
+    shutil.copy2(source, dest)
+
+
+def delete_file(path):
+    if is_file(path):
+        os.remove(path)
+
+
+def rename_dir_or_file(old, new):
+    os.renames(old, new)
+
+
+def move_dir_or_file(source, destination):
+    shutil.move(source, destination)

halib/filetype/csvfile.py

@@ -0,0 +1,192 @@
+import csv
+import textwrap
+import pandas as pd
+import pygwalker as pyg
+from tabulate import tabulate
+from rich.console import Console
+from itables import init_notebook_mode, show
+
+console = Console()
+
+def read(file, separator=","):
+    df = pd.read_csv(file, separator)
+    return df
+
+
+def read_auto_sep(filepath, sample_size=2048, **kwargs):
+    """
+    Read a CSV file with automatic delimiter detection.
+
+    Parameters
+    ----------
+    filepath : str
+        Path to the CSV file.
+    sample_size : int, optional
+        Number of bytes to read for delimiter sniffing.
+    **kwargs : dict
+        Extra keyword args passed to pandas.read_csv.
+
+    Returns
+    -------
+    df : pandas.DataFrame
+    """
+    with open(filepath, "r", newline="", encoding=kwargs.get("encoding", "utf-8")) as f:
+        sample = f.read(sample_size)
+        f.seek(0)
+        try:
+            dialect = csv.Sniffer().sniff(sample, delimiters=[",", ";", "\t", "|", ":"])
+            sep = dialect.delimiter
+        except csv.Error:
+            sep = ","  # fallback if detection fails
+
+    return pd.read_csv(filepath, sep=sep, **kwargs)
+
+# for append, mode = 'a'
+def fn_write(df, outfile, mode="w", header=True, index_label=None):
+    if not outfile.endswith(".csv"):
+        outfile = f"{outfile}.csv"
+    if index_label is not None:
+        df.to_csv(outfile, mode=mode, header=header, index_label=index_label)
+    else:
+        df.to_csv(outfile, mode=mode, header=header, index=False)
+
+
+def fn_make_df_with_columns(columns):
+    df = pd.DataFrame(columns=columns)
+    return df
+
+
+def fn_insert_rows(df, singleRow_or_rowList):
+    row_data = (
+        singleRow_or_rowList
+        if type(singleRow_or_rowList[0]) is list
+        else [singleRow_or_rowList]
+    )
+    new_row_df = pd.DataFrame(row_data, columns=df.columns)
+    df = pd.concat([df, new_row_df], ignore_index=True)
+    return df
+
+    # Auto-wrap function for each cell
+def auto_wrap(cell, width=40):
+    return textwrap.fill(str(cell), width=width)
+
+def fn_display_df(df, max_col_width=40):
+    # Apply wrapping; tablefmt="psql" for PostgreSQL-like output
+    # wrapped_df = df.applymap(lambda x: auto_wrap(x, width=max_col_width))
+    # fix the future warning of applymap
+    wrapped_df = df.apply(
+        lambda col: col.map(lambda x: auto_wrap(x, width=max_col_width))
+    )
+    print(tabulate(wrapped_df, headers="keys", tablefmt="grid", numalign="right"))
+
+def showdf(df, display_mode="itable", in_jupyter=True, all_interactive=False):
+    if display_mode == "itable":
+        if in_jupyter:
+            init_notebook_mode(all_interactive=all_interactive)
+        show(
+            df,
+            # layout={"top1": "searchPanes"},
+            # searchPanes={"layout": "column-3", "cascadePanes": True},
+            caption="table caption",
+            layout={"top1": "searchBuilder"},
+            buttons=["csvHtml5", "excelHtml5", "colvis"],
+            search={"regex": True, "caseInsensitive": True},
+            paging=False,  # no paging
+            scrollY="300px",  # height of table
+            scrollCollapse=True,
+            showIndex=True,  # show row no.
+            select=True,  # allow row selected
+            keys=True,  # enable navigate using arrow keys
+        )
+    elif display_mode == "pygwalker":
+        return pyg.walk(df)
+    else:
+        raise ValueError("Invalid display mode, current support [itable, pygwalker]")
+
+
+def fn_config_display_pd(
+    max_rows=None,
+    max_columns=None,
+    display_width=1000,
+    col_header_justify="center",
+    precision=10,
+):
+    pd.set_option("display.max_rows", max_rows)
+    pd.set_option("display.max_columns", max_columns)
+    pd.set_option("display.width", display_width)
+    pd.set_option("display.colheader_justify", col_header_justify)
+    pd.set_option("display.precision", precision)
+
+
+class DFCreator(dict):
+    """docstring for ClassName."""
+
+    def __init__(self, *arg, **kw):
+        super(DFCreator, self).__init__(*arg, **kw)
+        self.row_pool_dict = {}
+
+    def create_table(self, table_name, columns):
+        self[table_name] = pd.DataFrame(columns=columns)
+        self.row_pool_dict[table_name] = []
+
+    """Instead of inserting to dataframe, insert to row pool for fast computation"""
+
+    def insert_rows(self, table_name, singleRow_or_rowList):
+        rows_data = (
+            singleRow_or_rowList
+            if type(singleRow_or_rowList[0]) is list
+            else [singleRow_or_rowList]
+        )
+        self.row_pool_dict[table_name].extend(rows_data)
+
+    """Fill from row pool to actual table dataframe"""
+
+    def fill_table_from_row_pool(self, table_name):
+        if len(self.row_pool_dict[table_name]) > 0:
+            # concat row pool to table dataframe
+            self[table_name] = fn_insert_rows(
+                self[table_name], self.row_pool_dict[table_name]
+            )
+            # free the pool
+            self.row_pool_dict[table_name] = []
+
+    def write_table(
+        self,
+        table_name,
+        output_dir,
+        out_file_name=None,
+        mode="w",
+        header=True,
+        index_label=None,
+    ):
+        self.fill_table_from_row_pool(table_name)
+
+        if not out_file_name:
+            outfile = f"{output_dir}/{table_name}.csv"
+        else:
+            outfile = f"{output_dir}/{out_file_name}.csv"
+
+        fn_write(self[table_name], outfile, mode, header, index_label)
+
+    def write_all_table(self, output_dir, mode="w", header=True, index_label=None):
+        for table_name in self.keys():
+            outfile = f"{output_dir}/{table_name}.csv"
+            fn_write(self[table_name], outfile, mode, header, index_label)
+
+    def display_table(self, table_name):
+        self.fill_table_from_row_pool(table_name)
+        fn_display_df(self[table_name])
+
+    def display_table_schema(self, table_name):
+        columns = list(self[table_name].columns)
+        console.print(f"TABLE {table_name}: {columns}", style="bold blue")
+
+    def display_all_table_schema(self):
+        table_names = list(self.keys())
+        for table_name in table_names:
+            self.display_table_schema(table_name)
+
+    def display_all_table(self):
+        for table_name in self.keys():
+            console.rule(table_name)
+            self.display_table(table_name)

halib/filetype/ipynb.py

@@ -0,0 +1,61 @@
+import ipynbname
+from pathlib import Path
+from contextlib import contextmanager
+
+from ..common.common import now_str
+
+@contextmanager
+def gen_ipynb_name(
+    filename,
+    add_time_stamp=False,
+    nb_prefix="nb__",
+    separator="__",
+):
+    """
+    Context manager that prefixes the filename with the notebook name.
+    Output: NotebookName_OriginalName.ext
+    """
+    try:
+        nb_name = ipynbname.name()
+    except FileNotFoundError:
+        nb_name = "script"  # Fallback
+
+    p = Path(filename)
+
+    # --- FIX START ---
+
+    # 1. Get the parts separately
+    original_stem = p.stem  # "test" (no extension)
+    extension = p.suffix  # ".csv"
+
+    now_string = now_str() if add_time_stamp else ""
+
+    # 2. Construct the base name (Notebook + Separator + OriginalName)
+    base_name = f"{nb_prefix}{nb_name}{separator}{original_stem}"
+
+    # 3. Append timestamp if needed
+    if now_string:
+        base_name = f"{base_name}{separator}{now_string}"
+
+    # 4. Add the extension at the VERY END
+    new_filename = f"{base_name}{extension}"
+
+    # --- FIX END ---
+
+    final_path = p.parent / new_filename
+
+    # Assuming you use 'rich' console based on your snippet
+    # console.rule()
+    # print(f"📝 Saving as: {final_path}")
+
+    yield str(final_path)
+
+
+if __name__ == "__main__":
+    # --- Usage Example ---
+    # Assume Notebook Name is: "MyThesisWork"
+    filename = "results.csv"
+    with gen_ipynb_name(filename) as filename_ipynb:
+        # filename_ipynb is now: "MyThesisWork_results.csv"
+        print(f"File to save: {filename_ipynb}")
+        # df.to_csv(filename_ipynb)

halib/filetype/jsonfile.py

@@ -0,0 +1,19 @@
+import json
+
+def read(file):
+    with open(file) as f:
+        data = json.load(f)
+        return data
+
+def write(data_dict, outfile):
+    with open(outfile, "w") as json_file:
+        json.dump(data_dict, json_file)
+
+def beautify(json_str):
+    formatted_json = json_str
+    try:
+        parsed = json.loads(json_str)
+        formatted_json = json.dumps(parsed, indent=4, sort_keys=True)
+    except Exception as e:
+        pass
+    return formatted_json

halib/filetype/textfile.py

@@ -0,0 +1,12 @@
+def read_line_by_line(file_path):
+    with open(file_path, "r") as file:
+        lines = file.readlines()
+        lines = [line.rstrip() for line in lines]
+        return lines
+
+def write(lines, outfile, append=False):
+    mode = "a" if append else "w"
+    with open(outfile, mode, encoding="utf-8") as f:
+        for line in lines:
+            f.write(line)
+            f.write("\n")

halib/filetype/videofile.py

@@ -0,0 +1,266 @@
+import os
+import cv2
+import enlighten
+
+from enum import Enum
+from tube_dl import Youtube, Playlist
+from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip
+
+from . import textfile
+from . import csvfile
+from ..system import filesys
+
+class VideoUtils:
+    @staticmethod
+    def _default_meta_extractor(video_path):
+        """Default video metadata extractor function."""
+        # Open the video file
+        cap = cv2.VideoCapture(video_path)
+
+        # Check if the video was opened successfully
+        if not cap.isOpened():
+            print(f"Error: Could not open video file {video_path}")
+            return None
+
+        # Get the frame count
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        # Get the FPS
+        fps = cap.get(cv2.CAP_PROP_FPS)
+
+        # get frame size
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+        # Release the video capture object
+        cap.release()
+
+        meta_dict = {
+            "video_path": video_path,
+            "width": width,
+            "height": height,
+            "frame_count": frame_count,
+            "fps": fps,
+        }
+        return meta_dict
+
+    @staticmethod
+    def get_video_meta_dict(video_path, meta_dict_extractor_func=None):
+        assert os.path.exists(video_path), f"Video file {video_path} does not exist"
+        if meta_dict_extractor_func and callable(meta_dict_extractor_func):
+            assert (
+                meta_dict_extractor_func.__code__.co_argcount == 1
+            ), "meta_dict_extractor_func must take exactly one argument (video_path)"
+            meta_dict = meta_dict_extractor_func(video_path)
+            assert isinstance(
+                meta_dict, dict
+            ), "meta_dict_extractor_func must return a dictionary"
+            assert "video_path" in meta_dict, "meta_dict must contain 'video_path'"
+        else:
+            meta_dict = VideoUtils._default_meta_extractor(video_path=video_path)
+        return meta_dict
+
+    @staticmethod
+    def get_video_dir_meta_df(
+        video_dir,
+        video_exts=[".mp4", ".avi", ".mov", ".mkv"],
+        search_recursive=False,
+        csv_outfile=None,
+    ):
+        assert os.path.exists(video_dir), f"Video directory {video_dir} does not exist"
+        video_files = filesys.filter_files_by_extension(
+            video_dir, video_exts, recursive=search_recursive
+        )
+        assert (
+            len(video_files) > 0
+        ), f"No video files found in {video_dir} with extensions {video_exts}"
+        video_meta_list = []
+        for vfile in video_files:
+            meta_dict = VideoUtils.get_video_meta_dict(vfile)
+            if meta_dict:
+                video_meta_list.append(meta_dict)
+        dfmk = csvfile.DFCreator()
+        columns = list(video_meta_list[0].keys())
+        assert len(columns) > 0, "No video metadata found"
+        assert "video_path" in columns, "video_path column not found in video metadata"
+        # move video_path to the first column
+        columns.remove("video_path")
+        columns.insert(0, "video_path")
+        dfmk.create_table("video_meta", columns)
+        rows = [[meta[col] for col in columns] for meta in video_meta_list]
+        dfmk.insert_rows("video_meta", rows)
+        dfmk.fill_table_from_row_pool("video_meta")
+
+        if csv_outfile:
+            dfmk["video_meta"].to_csv(csv_outfile, index=False, sep=";")
+        return dfmk["video_meta"].copy()
+
+
+    # -----------------------------
+    # FFmpeg Horizontal Stack
+    # -----------------------------
+    @staticmethod
+    def hstack(video_files, output_file):
+        """Horizontally stack multiple videos using FFmpeg."""
+        tmp_file = "video_list.txt"
+        try:
+            with open(tmp_file, "w") as f:
+                for video in video_files:
+                    f.write(f"file '{video}'\n")
+
+            ffmpeg_cmd = (
+                f"ffmpeg -f concat -safe 0 -i {tmp_file} "
+                f'-filter_complex "[0:v][1:v][2:v]hstack=inputs={len(video_files)}[v]" '
+                f'-map "[v]" -c:v libx264 -preset fast -crf 22 {output_file}'
+            )
+
+            os.system(ffmpeg_cmd)
+            print(f"[INFO] Video stacked successfully: {output_file}")
+
+        except Exception as e:
+            print(f"[ERROR] Video stacking failed: {e}")
+        finally:
+            if os.path.exists(tmp_file):
+                os.remove(tmp_file)
+
+
+class VideoResolution(Enum):
+    VR480p = "720x480"
+    VR576p = "1280x720"
+    VR720p_hd = "1280x720"
+    VR1080p_full_hd = "1920x1080 "
+    VR4K_uhd = "3840x2160"
+    VR8K_uhd = "7680x4320"
+
+    def __str__(self):
+        return "%s" % self.value
+
+
+def get_video_resolution_size(video_resolution):
+    separator = "x"
+    resolution_str = str(video_resolution)
+    info_arr = resolution_str.split(separator)
+    width, height = int(info_arr[0]), int(info_arr[1])
+    return width, height
+
+
+def get_videos_by_resolution(
+    directory, video_resolution, video_ext="mp4", include_better=True
+):
+    video_paths = filesys.filter_files_by_extension(directory, video_ext)
+    filtered_video_paths = []
+    for path in video_paths:
+        vid = cv2.VideoCapture(path)
+        height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT)
+        width = vid.get(cv2.CAP_PROP_FRAME_WIDTH)
+        valid = False
+        video_width, video_height = get_video_resolution_size(video_resolution)
+        if not include_better:
+            if width == video_width and height == video_height:
+                valid = True
+        else:
+            if width >= video_width and height >= video_height:
+                valid = True
+
+        if valid:
+            filtered_video_paths.append(path)
+    return filtered_video_paths
+
+
+# time in seconds
+def trim_video(source, destination, start_time, end_time):
+    ffmpeg_extract_subclip(source, start_time, end_time, targetname=destination)
+
+
+progress_bar = None
+
+def on_progress(bytes_done, total_bytes):
+    global progress_bar
+    if progress_bar is None:
+        progress_bar = enlighten.get_manager().counter(
+            total=20, desc="Downloading", unit="byte", color="blue"
+        )
+
+    progress_bar.total = total_bytes
+    progress_bar.count = bytes_done
+    progress_bar.update(incr=0)
+    # print(bytes_done)
+    if bytes_done >= total_bytes:
+        progress_bar.close()
+        progress_bar = None
+
+
+def get_youtube_url(full_url_or_video_code):
+    if "youtube" in full_url_or_video_code:
+        url = full_url_or_video_code
+    else:
+        url = f"https://youtube.com/watch?v={full_url_or_video_code}"
+    return url
+
+
+def download_yt_video(
+    full_url_or_video_code,
+    save_folder="./",
+    report_progress=False,
+    video_idx="1",
+    total_video="1",
+):
+    url = get_youtube_url(full_url_or_video_code)
+    filesys.make_dir(save_folder)
+    filesys.change_current_dir(save_folder)
+    try:
+        yt = Youtube(url)
+        title_en = yt.title.encode("ascii", "ignore")
+        file_download = yt.formats.first()
+        if report_progress:
+            print(f"\n[{video_idx}/{total_video}][DOWNLOAD]{title_en}")
+            file_download.download(onprogress=on_progress, skip_existing=True)
+    except TypeError:
+        print(f"[ERROR] download {url}")
+
+
+def download_playlist(
+    playlist_url, save_folder="./", report_progress=False, start_pattern=None
+):
+    print(f"[DOWNLOAD PLAYLIST] {playlist_url}")
+    pl = Playlist(playlist_url).videos
+    total_video = len(pl)
+    should_start = False
+    url = None
+    count = 0
+    for idx, code in enumerate(pl):
+        try:
+            url = f"https://youtube.com/watch?v={code}"
+            yt = Youtube(url)
+            count += 1
+            if start_pattern is None:
+                should_start = True
+            elif start_pattern in yt.title:
+                should_start = True
+            if should_start:
+                download_yt_video(
+                    url,
+                    save_folder,
+                    report_progress,
+                    video_idx=str(count),
+                    total_video=str(total_video),
+                )
+
+        except TypeError:
+            print(f"[ERROR] download {url}")
+    enlighten.get_manager().stop()
+
+
+# Pntt https://www.youtube.com/playlist?list=PLYaaU301HUe06Zlf3qv9q2dnVulj35gOb
+# Format line: playlist_save_folder_path [SPACE] playlist_url
+def download_multiple_playlist_in_files(text_file, report_progress=False):
+    playlists = textfile.read_line_by_line(text_file)
+    for folder_plUrl in playlists:
+        folder = folder_plUrl.split()[0]
+        plUrl = folder_plUrl.split()[1]
+        download_playlist(plUrl, save_folder=folder, report_progress=report_progress)
+
+
+# test code
+# pl = 'https://youtube.com/playlist?list=PLYaaU301HUe03PabLEGbMGB8nhHgq58Zr'
+# download_playlist(pl, './test', report_progress=True)