halib 0.1.61__py3-none-any.whl → 0.1.66__py3-none-any.whl

halib/research/metrics.py

@@ -0,0 +1,121 @@
+# -------------------------------
+# Metrics Backend Interface
+# -------------------------------
+import inspect
+from typing import Dict, Union, List, Any
+from abc import ABC, abstractmethod
+
+class MetricsBackend(ABC):
+    """Interface for pluggable metrics computation backends."""
+
+    def __init__(self, metrics_info: Union[List[str], Dict[str, Any]]):
+        """
+        Initialize the backend with optional metrics_info.
+        """
+        self.metric_info = metrics_info
+        self.validate_metrics_info(self.metric_info)
+
+    @property
+    def metric_names(self) -> List[str]:
+        """
+        Return a list of metric names.
+        If metric_info is a dict, return its keys; if it's a list, return it directly.
+        """
+        if isinstance(self.metric_info, dict):
+            return list(self.metric_info.keys())
+        elif isinstance(self.metric_info, list):
+            return self.metric_info
+        else:
+            raise TypeError("metric_info must be a list or a dict")
+
+    def validate_metrics_info(self, metrics_info):
+        if isinstance(metrics_info, list):
+            return metrics_info
+        elif isinstance(metrics_info, dict):
+            return {k: v for k, v in metrics_info.items() if isinstance(k, str)}
+        else:
+            raise TypeError(
+                "metrics_info must be a list of strings or a dict with string keys"
+            )
+
+    @abstractmethod
+    def compute_metrics(
+        self, metrics_info: Union[List[str], Dict[str, Any]],  metrics_data_dict: Dict[str, Any], *args, **kwargs
+    ) -> Dict[str, Any]:
+        pass
+
+    def calc_metrics(
+        self,  metrics_data_dict: Dict[str, Any], *args, **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Calculate metrics based on the provided metrics_info and data.
+        This method should be overridden by subclasses to implement specific metric calculations.
+        """
+        # prevalidate the metrics_data_dict
+        for metric in self.metric_names:
+            if metric not in metrics_data_dict:
+                raise ValueError(f"Metric '{metric}' not found in provided data.")
+        # Call the abstract method to compute metrics
+        return self.compute_metrics(self.metric_info, metrics_data_dict, *args, **kwargs)
+
+class TorchMetricsBackend(MetricsBackend):
+    """TorchMetrics-based backend implementation."""
+
+    def __init__(self, metrics_info: Union[List[str], Dict[str, Any]]):
+        try:
+            import torch
+            from torchmetrics import Metric
+        except ImportError:
+            raise ImportError(
+                "TorchMetricsBackend requires torch and torchmetrics to be installed."
+            )
+        self.metric_info = metrics_info
+        self.torch = torch
+        self.Metric = Metric
+        self.validate_metrics_info(metrics_info)
+
+    def validate_metrics_info(self, metrics_info):
+        if not isinstance(metrics_info, dict):
+            raise TypeError(
+                "TorchMetricsBackend requires metrics_info as a dict {name: MetricInstance}"
+            )
+        for k, v in metrics_info.items():
+            if not isinstance(k, str):
+                raise TypeError(f"Key '{k}' is not a string")
+            if not isinstance(v, self.Metric):
+                raise TypeError(f"Value for key '{k}' must be a torchmetrics.Metric")
+        return metrics_info
+
+    def compute_metrics(self, metrics_info, metrics_data_dict, *args, **kwargs):
+        out_dict = {}
+        for metric, metric_instance in metrics_info.items():
+            if metric not in metrics_data_dict:
+                raise ValueError(f"Metric '{metric}' not found in provided data.")
+
+            metric_data = metrics_data_dict[metric]
+            sig = inspect.signature(metric_instance.update)
+            expected_args = list(sig.parameters.values())
+
+            if isinstance(metric_data, dict):
+                args = [metric_data[param.name] for param in expected_args]
+            elif isinstance(metric_data, (list, tuple)):
+                args = metric_data
+            else:
+                raise TypeError(f"Unsupported data format for metric '{metric}'")
+
+            if len(expected_args) == 1:
+                metric_instance.update(args)
+            else:
+                metric_instance.update(*args)
+
+            computed_value = metric_instance.compute()
+            if isinstance(computed_value, self.torch.Tensor):
+                computed_value = (
+                    computed_value.item()
+                    if computed_value.numel() == 1
+                    else computed_value.tolist()
+                )
+
+
+            out_dict[metric] = computed_value
+        return out_dict

halib/research/perfcalc.py

@@ -8,65 +8,31 @@ from functools import wraps
 from rich.pretty import pprint
 
 from abc import ABC, abstractmethod
+from collections import OrderedDict
 
 from ..filetype import csvfile
 from ..common import now_str
 from ..research.perftb import PerfTB
+from ..research.metrics import *
 
-# try to import torch, and torchmetrics
-try:
-    import torch
-    import torchmetrics
-    from torchmetrics import Metric
-except ImportError:
-    raise ImportError("Please install torch and torchmetrics to use this module.")
+# # try to import torch, and torchmetrics
+# try:
+#     import torch
+#     import torchmetrics
+#     from torchmetrics import Metric
+# except ImportError:
+#     raise ImportError("Please install torch and torchmetrics to use this module.")
 
-def validate_torch_metrics(fn):
-    @wraps(fn)
-    def wrapper(self, *args, **kwargs):
-        result = fn(self, *args, **kwargs)
-
-        if not isinstance(result, dict):
-            raise TypeError("torch_metrics() must return a dictionary")
-
-        for k, v in result.items():
-            if not isinstance(k, str):
-                raise TypeError(f"Key '{k}' is not a string")
-            if not isinstance(v, Metric):
-                raise TypeError(
-                    f"Value for key '{k}' is not a torchmetrics.Metric (got {type(v).__name__})"
-                )
-
-        return result
-
-    return wrapper
-def valid_custom_fields(fn):
-    @wraps(fn)
-    def wrapper(self, *args, **kwargs):
-        rs = fn(self, *args, **kwargs)
-        if not isinstance(rs, tuple) or len(rs) != 2:
-            raise ValueError("Function must return a tuple (outdict, custom_fields)")
-        outdict, custom_fields = rs
-        if not isinstance(outdict, dict):
-            raise TypeError("Output must be a dictionary")
-        if not isinstance(custom_fields, list):
-            raise TypeError("Custom fields must be a list")
-        for field in custom_fields:
-            if not isinstance(field, str):
-                raise TypeError(f"Custom field '{field}' is not a string")
-        return outdict, custom_fields
-
-    return wrapper
 
 REQUIRED_COLS = ["experiment", "dataset"]
 CSV_FILE_POSTFIX = "__perf"
 
 class PerfCalc(ABC): # Abstract base class for performance calculation
     @abstractmethod
-    def get_exp_torch_metrics(self):
+    def get_experiment_name(self):
         """
-        Return a dictionary of torchmetrics to be used for performance calculation.
-        Example: {"accuracy": Accuracy(), "precision": Precision()}
+        Return the name of the experiment.
+        This function should be overridden by the subclass if needed.
         """
         pass
 
@@ -79,20 +45,22 @@ class PerfCalc(ABC): # Abstract base class for performance calculation
         pass
 
     @abstractmethod
-    def prepare_exp_data_for_metrics(self, metric_names, *args, **kwargs):
+    def get_metric_backend(self) -> MetricsBackend:
         """
-        Prepare the data for metrics.
-        This function should be overridden by the subclass if needed.
-        Must return a dictionary with keys as metric names and values as the data to be used for those metrics.
-        NOTE: that the data (for each metric) must be in the format expected by the torchmetrics instance (for that metric). E.g: {"accuracy": {"preds": [...], "target": [...]}, ...} since torchmetrics expects the data in a specific format.
+        Return a list of metric names to be used for performance calculation OR a dictionaray with keys as metric names and values as metric instances of torchmetrics.Metric. For example: {"accuracy": Accuracy(), "precision": Precision()}
+
         """
         pass
 
+    # ! can be override, but ONLY if torchmetrics are used
+    # Prepare the exp data for torch metrics.
     @abstractmethod
-    def get_experiment_name(self):
+    def prepare_metrics_data_dict(self, metric_names, *args, **kwargs):
         """
-        Return the name of the experiment.
+        Prepare the data for metrics.
         This function should be overridden by the subclass if needed.
+        Must return a dictionary with keys as metric names and values as the data to be used for those metrics.
+        NOTE: that the data (for each metric) must be in the format expected by the torchmetrics instance (for that metric). E.g: {"accuracy": {"preds": [...], "target": [...]}, ...} since torchmetrics expects the data in a specific format.
         """
         pass
 
@@ -102,63 +70,55 @@ class PerfCalc(ABC): # Abstract base class for performance calculation
         """
         return outdict, []
 
+    def __valid_calc_custom_fields(self, fun_results):
+        if not isinstance(fun_results, tuple) or len(fun_results) != 2:
+            raise ValueError("Function must return a tuple (outdict, custom_fields)")
+        outdict, custom_fields = fun_results
+        if not isinstance(outdict, dict):
+            raise TypeError("Output must be a dictionary")
+        if not isinstance(custom_fields, list):
+            raise TypeError("Custom fields must be a list")
+        for field in custom_fields:
+            if not isinstance(field, str):
+                raise TypeError(f"Custom field '{field}' is not a string")
+        return outdict, custom_fields
+
+    # ! only need to override this method if torchmetrics are not used
+    def calc_exp_perf_metrics(self, metric_names, *args, **kwargs):
+        metrics_backend = self.get_metric_backend()
+        out_dict = {"dataset": self.get_dataset_name(), "experiment": self.get_experiment_name()}
+        out_dict, custom_fields = self.__valid_calc_custom_fields(self.calc_exp_outdict_custom_fields(
+            outdict=out_dict, *args, **kwargs
+        ))
+        metrics_data_dict = self.prepare_metrics_data_dict(
+            metric_names, *args, **kwargs
+        )
+        metric_results = metrics_backend.calc_metrics(
+            metrics_data_dict=metrics_data_dict, *args, **kwargs
+        )
+        metric_results_prefix = {
+            f"metric_{k}": v for k, v in metric_results.items()
+        }
+        out_dict.update(metric_results_prefix)
+        ordered_cols = REQUIRED_COLS + custom_fields + list(metric_results_prefix.keys())
+        out_dict = OrderedDict(
+            (col, out_dict[col]) for col in ordered_cols if col in out_dict
+        )
+        return out_dict
+
     #! custom kwargs:
     #! outfile - if provided, will save the output to a CSV file with the given path
     #! outdir - if provided, will save the output to a CSV file in the given directory with a generated filename
     #! return_df - if True, will return a DataFrame instead of a dictionary
 
-    def calculate_exp_perf_metrics(self, *args, **kwargs):
+    def calc_save_exp_perfs(self, *args, **kwargs):
         """
         Calculate the metrics.
         This function should be overridden by the subclass if needed.
         Must return a dictionary with keys as metric names and values as the calculated metrics.
         """
-        metric_names = list(self.get_exp_torch_metrics().keys())
-        out_dict = {metric: None for metric in metric_names}
-        out_dict['dataset'] = self.get_dataset_name()
-        out_dict['experiment'] = self.get_experiment_name()
-        out_dict, custom_fields = self.calc_exp_outdict_custom_fields(
-            outdict=out_dict, *args, **kwargs
-        )
-        torch_metrics_dict = self.get_exp_torch_metrics()
-        all_metric_data = self.prepare_exp_data_for_metrics(
-            metric_names, *args, **kwargs
-        )
-        metric_col_names = []
-        for metric in metric_names:
-            if metric not in all_metric_data:
-                raise ValueError(f"Metric '{metric}' not found in provided data.")
-            tmetric = torch_metrics_dict[metric] # torchmetrics instance
-            metric_data = all_metric_data[metric]  # should be a dict of args/kwargs
-            # Inspect expected parameters for the metric's update() method
-            sig = inspect.signature(tmetric.update)
-            expected_args = list(sig.parameters.values())
-            # Prepare args in correct order
-            if isinstance(metric_data, dict):
-                # Match dict keys to parameter names
-                args = [metric_data[param.name] for param in expected_args]
-            elif isinstance(metric_data, (list, tuple)):
-                args = metric_data
-            else:
-                raise TypeError(f"Unsupported data format for metric '{metric}'")
-
-            # Call update and compute
-            if len(expected_args) == 1:
-                tmetric.update(args)  # pass as single argument
-            else:
-                tmetric.update(*args)    # unpack multiple arguments
-            computed_value = tmetric.compute()
-            # ensure the computed value converted to a scala value or list array
-            if isinstance(computed_value, torch.Tensor):
-                if computed_value.numel() == 1:
-                    computed_value = computed_value.item()
-                else:
-                    computed_value = computed_value.tolist()
-            col_name = f"metric_{metric}" if 'metric_' not in metric else metric
-            metric_col_names.append(col_name)
-            out_dict[col_name] = computed_value
-
-        # check if any kwargs named "outfile"
+        metric_names = self.get_metric_backend().metric_names
+        out_dict = self.calc_exp_perf_metrics(metric_names=metric_names, *args, **kwargs)
         csv_outfile = kwargs.get("outfile", None)
         if csv_outfile is not None:
             filePathNoExt, _ = os.path.splitext(csv_outfile)
@@ -171,7 +131,8 @@ class PerfCalc(ABC): # Abstract base class for performance calculation
 
         # convert out_dict to a DataFrame
         df = pd.DataFrame([out_dict])
-        ordered_cols = REQUIRED_COLS + custom_fields + metric_col_names
+        # get the orders of the columns as the orders or the keys in out_dict
+        ordered_cols = list(out_dict.keys())
         df = df[ordered_cols]  # reorder columns
 
         if csv_outfile:
@@ -182,9 +143,17 @@ class PerfCalc(ABC): # Abstract base class for performance calculation
         else:
             return out_dict, csv_outfile
 
+    @staticmethod
+    def default_exp_csv_filter_fn(exp_file_name: str) -> bool:
+        """
+        Default filter function for experiments.
+        Returns True if the experiment name does not start with "test_" or "debug_".
+        """
+        return "__perf.csv" in exp_file_name
+
     @classmethod
     def gen_perf_report_for_multip_exps(
-        cls, indir: str, exp_perf_csv_pattern="__perf", csv_sep=';'
+        cls, indir: str, exp_csv_filter_fn=default_exp_csv_filter_fn, csv_sep=";"
     ) -> PerfTB:
         """
         Generate a performance report by scanning experiment subdirectories.
@@ -221,6 +190,9 @@ class PerfCalc(ABC): # Abstract base class for performance calculation
             assert len(metric_cols) > 0, "No metric columns found in the DataFrame. Ensure that the CSV files contain metric columns starting with 'metric_'."
             final_cols = REQUIRED_COLS + metric_cols
             df = df[final_cols]
+            # !hahv debug
+            pprint('------ Final DataFrame Columns ------')
+            csvfile.fn_display_df(df)
             # ! validate all rows in df before returning
             # make sure all rows will have at least values for REQUIRED_COLS and at least one metric column
             for index, row in df.iterrows():
@@ -289,12 +261,12 @@ class PerfCalc(ABC): # Abstract base class for performance calculation
         ]
         if len(exp_dirs) == 0:
             csv_perf_files = glob.glob(
-                os.path.join(indir, f"*{exp_perf_csv_pattern}*.csv")
+                os.path.join(indir, f"*.csv")
             )
             csv_perf_files = [
                 file_item
                 for file_item in csv_perf_files
-                if exp_perf_csv_pattern in file_item
+                if exp_csv_filter_fn(file_item)
             ]
         else:
             # multiple experiment directories found
@@ -302,33 +274,22 @@ class PerfCalc(ABC): # Abstract base class for performance calculation
             for exp_dir in exp_dirs:
                 # pprint(f"Searching in experiment directory: {exp_dir}")
                 matched = glob.glob(
-                    os.path.join(exp_dir, f"*{exp_perf_csv_pattern}*.csv")
+                    os.path.join(exp_dir, f"*.csv")
                 )
+                matched = [
+                    file_item
+                    for file_item in matched
+                    if exp_csv_filter_fn(file_item)
+                ]
                 csv_perf_files.extend(matched)
 
         assert (
             len(csv_perf_files) > 0
-        ), f"No CSV files matching pattern '{exp_perf_csv_pattern}' found in the experiment directories."
+        ), f"No CSV files matching pattern '{exp_csv_filter_fn}' found in the experiment directories."
 
-        assert len(csv_perf_files) > 0, f"No CSV files matching pattern '{exp_perf_csv_pattern}' found in the experiment directories."
+        assert len(csv_perf_files) > 0, f"No CSV files matching pattern '{exp_csv_filter_fn}' found in the experiment directories."
 
         all_exp_perf_df = get_df_for_all_exp_perf(csv_perf_files, csv_sep=csv_sep)
         csvfile.fn_display_df(all_exp_perf_df)
         perf_tb = mk_perftb_report(all_exp_perf_df)
         return perf_tb
-
-
-def main():
-    indir = "./zreport/test"
-    report_outfile = "./zreport/all.csv"
-    exp_perf_csv_pattern = "__perf"
-    csv_sep = ";"
-    perftb = PerfCalc.gen_perf_report_for_multip_exps(
-        indir, exp_perf_csv_pattern, csv_sep
-    )
-    perftb.to_csv(report_outfile, sep=csv_sep)
-    inspect(perftb)
-    perftb.plot(save_path="./zreport/test_csv.svg", open_plot=True)
-
-if __name__ == "__main__":
-    main()

halib/utils/video.py

@@ -5,15 +5,17 @@ from ..system import filesys as fs
 
 
 class VideoUtils:
+
     @staticmethod
-    def get_video_meta_dict(video_path):
+    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, None
+            return None
 
         # Get the frame count
         frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
@@ -23,6 +25,7 @@ class VideoUtils:
 
         # Release the video capture object
         cap.release()
+
         meta_dict = {
             "video_path": video_path,
             "frame_count": frame_count,
@@ -31,6 +34,17 @@ class VideoUtils:
         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 = fs.filter_files_by_extension(video_dir, video_exts, recursive=search_recursive)

{halib-0.1.61.dist-info → halib-0.1.66.dist-info}/METADATA

@@ -1,180 +1,190 @@
-Metadata-Version: 2.1
-Name: halib
-Version: 0.1.61
-Summary: Small library for common tasks
-Author: Hoang Van Ha
-Author-email: hoangvanhauit@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: arrow
-Requires-Dist: click
-Requires-Dist: enlighten
-Requires-Dist: kaleido (==0.1.*)
-Requires-Dist: loguru
-Requires-Dist: more-itertools
-Requires-Dist: moviepy
-Requires-Dist: networkx
-Requires-Dist: numpy
-Requires-Dist: omegaconf
-Requires-Dist: opencv-python
-Requires-Dist: pandas
-Requires-Dist: Pillow
-Requires-Dist: Pyarrow
-Requires-Dist: pycurl
-Requires-Dist: python-telegram-bot
-Requires-Dist: requests
-Requires-Dist: rich
-Requires-Dist: scikit-learn
-Requires-Dist: matplotlib
-Requires-Dist: seaborn
-Requires-Dist: plotly
-Requires-Dist: pygwalker
-Requires-Dist: tabulate
-Requires-Dist: itables
-Requires-Dist: timebudget
-Requires-Dist: tqdm
-Requires-Dist: tube-dl
-Requires-Dist: wandb
-Requires-Dist: dataclass-wizard
-
-Helper package for coding and automation
-
-**Version 0.1.61**
-
-+ add `util/video`: add `VideoUtils` class to handle common video-related tasks
-+ add `util/gpu_mon`: add `GPUMonitor` class to monitor GPU usage and performance
-
-**Version 0.1.59**
-
-+ add `util/perfcalc`: abstract class for performance calculation. This class need to be inherited and implemented with specific performance calculation logic.
-
-**Version 0.1.55**
-
-+ add `util/dataclass_util` to help dynamically create `dataclass` classes from dictionary or YAML file, including support for nested dataclasses. From there, we can use `dataclass_wizard` to create a list of `dataclass` classes with the help from ChatGPT.
-
-**Version 0.1.52**
-
-+ add `research/perftb` module to allow creating and managing performance tables for experiments, including filtering by datasets, metrics, and experiments.
-
-**Version 0.1.50**
-
-+ add `pprint_local_path` to print local path (file/directory) in clickable link (as file URI)
-
-+ add `research` package to help with research tasks, including `benchquery` for benchmarking queries from dataframe
-+ add `wandb` module to allow easy sync offline data to Weights & Biases (wandb) and batch clear wandb runs.
-
-**Version 0.1.47**
-+ add `pprint_box` to print object/string in a box frame (like in `inspect`)
-
-**Version 0.1.46**
-+ filter the warning message of `UserWarning: Unable to import Axes3D.`
-+ auto_wrap_text for `fn_display_df` to avoid long text in the table
-
-**Version 0.1.42**
-+ add <rich_color.py>: add basic color list (for easy usage)
-
-**Version 0.1.41**
-+ add <rich_color.py> to display rich color information in <rich> python package (rcolor_str, rcolor_pallet_all, etc.)
-
-**Version 0.1.40**
-
-+  update <csvfile.py> to use `itables` and `pygwalker` to display dataframe in jupyter notebook.
-
-**Version 0.1.38**
-
-+  add <torchloader.py> to search for best cfg for torch dataloader (num_workers, batch_size, pin_memory, et.)
-
-**Version 0.1.37**
-
-+  add <dataset.py> to help split classification dataset into train/val(test)
----
-**Version 0.1.33**
-
-+ add `plot.py` module to plot DL model training history (with columlns: epoch, train_accuracy, val_accuracy, train_loss, val_loss) using `seaborn` and `matplotlib`
----
-**Version 0.1.29**
-
-+ for `tele_noti` module, `kaleido==0.1.*` is required for plotly since `kaleido 0.2.*` is not working (taking for ever to generate image)
----
-**Version 0.1.24**
-
-+ rename `sys` to `system` to avoid conflict with built-in `sys` module
-+ add `tele_noti` module to send notification to telegram after a specific interval for training progress monitoring
----
-**Version 0.1.22**
-
-+ add `cuda.py` module to check CUDA availability (for both pytorch and tensorflow)
----
-**Version 0.1.21**
-
-+ using `networkx` and `omegaconf` to allow yaml file inheritance and override
----
-**Version 0.1.15**
-
-+ `__init__.py`: add common logging library; also `console_log` decorator to log function (start and end)
-
----
-
-**Version 0.1.10**
-
-+ filesys: fix typo on "is_exit" to "is_exist"
-+ gdrive: now support uploading file to folder and return direct link (shareable link)
-
-**Version 0.1.9**
-
-+ add dependencies requirement.txt
-
-**Version 0.1.8**
-
-Fix bugs:
-
-+ [performance] instead of inserting directly new rows into table dataframe, first insert it into in-memory `row_pool_dict`, that fill data in that dict into the actual dataframe when needed.
-
----
-
-**Version 0.1.7**
-
-Fix bugs:
-
-+ fix insert into table so slow by allowing insert multiple rows at once
-
----
-
-**Version 0.1.6**
-
-New features:
-
-+ add DFCreator for manipulating table (DataFrame) - create, insert row, display, write to file
-
----
-
-**Version 0.1.5**
-
-New Features
-
-+ add cmd module
-+ new package structure
-
----
-
-**Version 0.1.4**
-
-New Features
-
-+ add support to create Bitbucket Project from template
-
----
-
-**Version 0.1.2**
-
-New Features
-
-+ add support to upload local to google drive.
-
-
+Metadata-Version: 2.4
+Name: halib
+Version: 0.1.66
+Summary: Small library for common tasks
+Author: Hoang Van Ha
+Author-email: hoangvanhauit@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: arrow
+Requires-Dist: click
+Requires-Dist: enlighten
+Requires-Dist: kaleido==0.1.*
+Requires-Dist: loguru
+Requires-Dist: more-itertools
+Requires-Dist: moviepy
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: omegaconf
+Requires-Dist: opencv-python
+Requires-Dist: pandas
+Requires-Dist: Pillow
+Requires-Dist: Pyarrow
+Requires-Dist: pycurl
+Requires-Dist: python-telegram-bot
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: scikit-learn
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Requires-Dist: plotly
+Requires-Dist: pygwalker
+Requires-Dist: tabulate
+Requires-Dist: itables
+Requires-Dist: timebudget
+Requires-Dist: tqdm
+Requires-Dist: tube_dl
+Requires-Dist: wandb
+Requires-Dist: dataclass-wizard
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Helper package for coding and automation
+
+**Version 0.1.66**
+
++ now use `uv` for venv management
++ `research/perfcalc`: support both torchmetrics and custom metrics for performance calculation
+
+**Version 0.1.61**
+
++ add `util/video`: add `VideoUtils` class to handle common video-related tasks
++ add `util/gpu_mon`: add `GPUMonitor` class to monitor GPU usage and performance
+
+**Version 0.1.59**
+
++ add `util/perfcalc`: abstract class for performance calculation. This class need to be inherited and implemented with specific performance calculation logic.
+
+**Version 0.1.55**
+
++ add `util/dataclass_util` to help dynamically create `dataclass` classes from dictionary or YAML file, including support for nested dataclasses. From there, we can use `dataclass_wizard` to create a list of `dataclass` classes with the help from ChatGPT.
+
+**Version 0.1.52**
+
++ add `research/perftb` module to allow creating and managing performance tables for experiments, including filtering by datasets, metrics, and experiments.
+
+**Version 0.1.50**
+
++ add `pprint_local_path` to print local path (file/directory) in clickable link (as file URI)
+
++ add `research` package to help with research tasks, including `benchquery` for benchmarking queries from dataframe
++ add `wandb` module to allow easy sync offline data to Weights & Biases (wandb) and batch clear wandb runs.
+
+**Version 0.1.47**
++ add `pprint_box` to print object/string in a box frame (like in `inspect`)
+
+**Version 0.1.46**
++ filter the warning message of `UserWarning: Unable to import Axes3D.`
++ auto_wrap_text for `fn_display_df` to avoid long text in the table
+
+**Version 0.1.42**
++ add <rich_color.py>: add basic color list (for easy usage)
+
+**Version 0.1.41**
++ add <rich_color.py> to display rich color information in <rich> python package (rcolor_str, rcolor_pallet_all, etc.)
+
+**Version 0.1.40**
+
++  update <csvfile.py> to use `itables` and `pygwalker` to display dataframe in jupyter notebook.
+
+**Version 0.1.38**
+
++  add <torchloader.py> to search for best cfg for torch dataloader (num_workers, batch_size, pin_memory, et.)
+
+**Version 0.1.37**
+
++  add <dataset.py> to help split classification dataset into train/val(test)
+---
+**Version 0.1.33**
+
++ add `plot.py` module to plot DL model training history (with columlns: epoch, train_accuracy, val_accuracy, train_loss, val_loss) using `seaborn` and `matplotlib`
+---
+**Version 0.1.29**
+
++ for `tele_noti` module, `kaleido==0.1.*` is required for plotly since `kaleido 0.2.*` is not working (taking for ever to generate image)
+---
+**Version 0.1.24**
+
++ rename `sys` to `system` to avoid conflict with built-in `sys` module
++ add `tele_noti` module to send notification to telegram after a specific interval for training progress monitoring
+---
+**Version 0.1.22**
+
++ add `cuda.py` module to check CUDA availability (for both pytorch and tensorflow)
+---
+**Version 0.1.21**
+
++ using `networkx` and `omegaconf` to allow yaml file inheritance and override
+---
+**Version 0.1.15**
+
++ `__init__.py`: add common logging library; also `console_log` decorator to log function (start and end)
+
+---
+
+**Version 0.1.10**
+
++ filesys: fix typo on "is_exit" to "is_exist"
++ gdrive: now support uploading file to folder and return direct link (shareable link)
+
+**Version 0.1.9**
+
++ add dependencies requirement.txt
+
+**Version 0.1.8**
+
+Fix bugs:
+
++ [performance] instead of inserting directly new rows into table dataframe, first insert it into in-memory `row_pool_dict`, that fill data in that dict into the actual dataframe when needed.
+
+---
+
+**Version 0.1.7**
+
+Fix bugs:
+
++ fix insert into table so slow by allowing insert multiple rows at once
+
+---
+
+**Version 0.1.6**
+
+New features:
+
++ add DFCreator for manipulating table (DataFrame) - create, insert row, display, write to file
+
+---
+
+**Version 0.1.5**
+
+New Features
+
++ add cmd module
++ new package structure
+
+---
+
+**Version 0.1.4**
+
+New Features
+
++ add support to create Bitbucket Project from template
+
+---
+
+**Version 0.1.2**
+
+New Features
+
++ add support to upload local to google drive.

{halib-0.1.61.dist-info → halib-0.1.66.dist-info}/RECORD

@@ -30,7 +30,8 @@ halib/online/projectmake.py,sha256=Zrs96WgXvO4nIrwxnCOletL4aTBge-EoF0r7hpKO1w8,4
 halib/research/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 halib/research/benchquery.py,sha256=FuKnbWQtCEoRRtJAfN-zaN-jPiO_EzsakmTOMiqi7GQ,4626
 halib/research/dataset.py,sha256=QU0Hr5QFb8_XlvnOMgC9QJGIpwXAZ9lDd0RdQi_QRec,6743
-halib/research/perfcalc.py,sha256=qKgoDbXQtyOpRgOjSMUus7r4mgyiH8Gu9o59sd48SAE,15147
+halib/research/metrics.py,sha256=hvXaAtgzdqwDxcBQdEJgorWQgf9gLk2LK4oKD_8FiM4,4792
+halib/research/perfcalc.py,sha256=9FoUuYJRXyoAakfTM1T2q039Wiw88fdw34eV2inktDM,13803
 halib/research/perftb.py,sha256=vazU-dYBJhfc4sK4zFgxOvzeXGi-5TyPHCt20ItiWhY,30463
 halib/research/plot.py,sha256=-pDUk4z3C_GnyJ5zWmf-mGMdT4gaipVJWzIgcpIPiRk,9448
 halib/research/torchloader.py,sha256=yqUjcSiME6H5W210363HyRUrOi3ISpUFAFkTr1w4DCw,6503
@@ -47,9 +48,9 @@ halib/utils/dict_op.py,sha256=wYE6Iw-_CnCWdMg9tpJ2Y2-e2ESkW9FxmdBkZkbUh80,299
 halib/utils/gpu_mon.py,sha256=vD41_ZnmPLKguuq9X44SB_vwd9JrblO4BDzHLXZhhFY,2233
 halib/utils/listop.py,sha256=Vpa8_2fI0wySpB2-8sfTBkyi_A4FhoFVVvFiuvW8N64,339
 halib/utils/tele_noti.py,sha256=-4WXZelCA4W9BroapkRyIdUu9cUVrcJJhegnMs_WpGU,5928
-halib/utils/video.py,sha256=mJQFHFbijmu3lo0NZk4Ed64Tfa1u5KxNJpd_TuckpPU,2228
-halib-0.1.61.dist-info/LICENSE.txt,sha256=qZssdna4aETiR8znYsShUjidu-U4jUT9Q-EWNlZ9yBQ,1100
-halib-0.1.61.dist-info/METADATA,sha256=1s7ikn1n88Ix9c_rB4OqSY9hmQ12sJMM-LE_4aIDWNM,5039
-halib-0.1.61.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-halib-0.1.61.dist-info/top_level.txt,sha256=7AD6PLaQTreE0Fn44mdZsoHBe_Zdd7GUmjsWPyQ7I-k,6
-halib-0.1.61.dist-info/RECORD,,
+halib/utils/video.py,sha256=ZqzNVPgc1RZr_T0OlHvZ6SzyBpL7O27LtB86JMbBuR0,3059
+halib-0.1.66.dist-info/licenses/LICENSE.txt,sha256=qZssdna4aETiR8znYsShUjidu-U4jUT9Q-EWNlZ9yBQ,1100
+halib-0.1.66.dist-info/METADATA,sha256=mtxt5CPm_a3fHh6K0uLV9QY1p4nSOBtbgcnQaYyBTXY,5541
+halib-0.1.66.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+halib-0.1.66.dist-info/top_level.txt,sha256=7AD6PLaQTreE0Fn44mdZsoHBe_Zdd7GUmjsWPyQ7I-k,6
+halib-0.1.66.dist-info/RECORD,,

{halib-0.1.61.dist-info → halib-0.1.66.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any