halib 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

halib/exp/core/base_config.py

@@ -42,8 +42,10 @@ class AutoNamedCfg(YAMLWizard, NamedCfg):
             # or handled by the loader.
             pass
 
+
 T = TypeVar("T", bound=AutoNamedCfg)
 
+
 class BaseSelectorCfg(Generic[T]):
     """
     Base class to handle the logic of selecting an item from a list by name.
@@ -72,6 +74,8 @@ class ExpBaseCfg(ABC, YAMLWizard):
     3 - a method cfg
     """
 
+    cfg_name: Optional[str] = None
+
     # Save to yaml fil
     def save_to_outdir(
         self, filename: str = "__config.yaml", outdir=None, override: bool = False
@@ -103,13 +107,24 @@ class ExpBaseCfg(ABC, YAMLWizard):
         """Load a configuration from a custom YAML file."""
         pass
 
-    @abstractmethod
-    def get_cfg_name(self):
-        """
-        Get the name of the configuration.
-        This method should be implemented in subclasses.
-        """
-        pass
+    def get_cfg_name(self, sep: str = "__", *args, **kwargs) -> str:
+        # auto get the config name from dataset, method, metric
+        # 2. Generate the canonical Config Name
+        name_parts = []
+        general_info = self.get_general_cfg().get_name()
+        dataset_info = self.get_dataset_cfg().get_name()
+        method_info = self.get_method_cfg().get_name()
+        name_parts = [
+            general_info,
+            f"ds_{dataset_info}",
+            f"mt_{method_info}",
+        ]
+        if "extra" in kwargs:
+            extra_info = kwargs["extra"]
+            assert isinstance(extra_info, str), "'extra' kwarg must be a string."
+            name_parts.append(extra_info)
+        self.cfg_name = sep.join(name_parts)
+        return self.cfg_name
 
     @abstractmethod
     def get_outdir(self):
@@ -120,7 +135,7 @@ class ExpBaseCfg(ABC, YAMLWizard):
         return None
 
     @abstractmethod
-    def get_general_cfg(self):
+    def get_general_cfg(self) -> NamedCfg:
         """
         Get the general configuration like output directory, log settings, SEED, etc.
         This method should be implemented in subclasses.
@@ -135,6 +150,14 @@ class ExpBaseCfg(ABC, YAMLWizard):
         """
         pass
 
+    @abstractmethod
+    def get_method_cfg(self) -> NamedCfg:
+        """
+        Get the method configuration.
+        This method should be implemented in subclasses.
+        """
+        pass
+
     @abstractmethod
     def get_metric_cfg(self) -> NamedCfg:
         """

halib/exp/core/base_exp.py

@@ -1,147 +1,168 @@
+import os
+from rich.pretty import pprint
 from abc import ABC, abstractmethod
-from typing import Tuple, Any, Optional
-from .base_config import ExpBaseCfg
-from ..perf.perfcalc import PerfCalc
-from ..perf.perfmetrics import MetricsBackend
+from typing import List, Optional, TypeVar, Generic
 
-
-class ExpHook:
-    """Base interface for all experiment hooks."""
-    def on_before_run(self, exp): pass
-    def on_after_run(self, exp, results): pass
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from dataclass_wizard import YAMLWizard
 
 
-# ! SEE https://github.com/hahv/base_exp for sample usage
-class BaseExp(PerfCalc, ABC):
+class NamedCfg(ABC):
     """
-    Base class for experiments.
-    Orchestrates the experiment pipeline using a pluggable metrics backend.
+    Base class for named configurations.
+    All configurations should have a name.
     """
 
-    def __init__(self, config: ExpBaseCfg):
-        self.config = config
-        self.metric_backend = None
-        # Flag to track if init_general/prepare_dataset has run
-        self._is_env_ready = False
-        self.hooks = []
-
-    def register_hook(self, hook: ExpHook):
-        self.hooks.append(hook)
-
-    def _trigger_hooks(self, method_name: str, *args, **kwargs):
-        for hook in self.hooks:
-            method = getattr(hook, method_name, None)
-            if callable(method):
-                method(*args, **kwargs)
-
-    # -----------------------
-    # PerfCalc Required Methods
-    # -----------------------
-    def get_dataset_name(self):
-        return self.config.get_dataset_cfg().get_name()
-
-    def get_experiment_name(self):
-        return self.config.get_cfg_name()
-
-    def get_metric_backend(self):
-        if not self.metric_backend:
-            self.metric_backend = self.prepare_metrics(self.config.get_metric_cfg())
-        return self.metric_backend
-
-    # -----------------------
-    # Abstract Experiment Steps
-    # -----------------------
     @abstractmethod
-    def init_general(self, general_cfg):
-        """Setup general settings like SEED, logging, env variables."""
+    def get_name(self):
+        """
+        Get the name of the configuration.
+        This method should be implemented in subclasses.
+        """
         pass
 
+
+@dataclass
+class AutoNamedCfg(YAMLWizard, NamedCfg):
+    """
+    Mixin that automatically implements get_name() by returning self.name.
+    Classes using this MUST have a 'name' field.
+    """
+
+    name: Optional[str] = None
+
+    def get_name(self):
+        return self.name
+
+    def __post_init__(self):
+        # Enforce the "MUST" rule here
+        if self.name is None:
+            # We allow None during initial load, but it must be set before usage
+            # or handled by the loader.
+            pass
+
+
+T = TypeVar("T", bound=AutoNamedCfg)
+
+
+class BaseSelectorCfg(Generic[T]):
+    """
+    Base class to handle the logic of selecting an item from a list by name.
+    """
+
+    def _resolve_selection(self, items: List[T], selected_name: str, context: str) -> T:
+        if selected_name is None:
+            raise ValueError(f"No {context} selected in the configuration.")
+
+        # Create a lookup dict for O(1) access, or just iterate if list is short
+        for item in items:
+            if item.name == selected_name:
+                return item
+
+        raise ValueError(
+            f"{context.capitalize()} '{selected_name}' not found in the configuration list."
+        )
+
+
+class ExpBaseCfg(ABC, YAMLWizard):
+    """
+    Base class for configuration objects.
+    What a cfg class must have:
+    1 - a dataset cfg
+    2 - a metric cfg
+    3 - a method cfg
+    """
+
+    cfg_name: Optional[str] = None
+
+    # Save to yaml fil
+    def save_to_outdir(
+        self, filename: str = "__config.yaml", outdir=None, override: bool = False
+    ) -> None:
+        """
+        Save the configuration to the output directory.
+        """
+        if outdir is not None:
+            output_dir = outdir
+        else:
+            output_dir = self.get_outdir()
+        os.makedirs(output_dir, exist_ok=True)
+        assert (output_dir is not None) and (
+            os.path.isdir(output_dir)
+        ), f"Output directory '{output_dir}' does not exist or is not a directory."
+        file_path = os.path.join(output_dir, filename)
+        if os.path.exists(file_path) and not override:
+            pprint(
+                f"File '{file_path}' already exists. Use 'override=True' to overwrite."
+            )
+        else:
+            # method of YAMLWizard to_yaml_file
+            self.to_yaml_file(file_path)
+
+    @classmethod
     @abstractmethod
-    def prepare_dataset(self, dataset_cfg):
-        """Load/prepare dataset."""
+    # load from a custom YAML file
+    def from_custom_yaml_file(cls, yaml_file: str):
+        """Load a configuration from a custom YAML file."""
         pass
 
+    def get_cfg_name(self, sep: str = "__", *args, **kwargs) -> str:
+        if self.cfg_name is None:
+            # auto get the config name from dataset, method, metric
+            # 2. Generate the canonical Config Name
+            name_parts = []
+            general_info = self.get_general_cfg().get_name()
+            dataset_info = self.get_dataset_cfg().get_name()
+            method_info = self.get_method_cfg().get_name()
+            name_parts = [
+                general_info,
+                f"ds_{dataset_info}",
+                f"mt_{method_info}",
+            ]
+            if "extra" in kwargs:
+                extra_info = kwargs["extra"]
+                assert isinstance(extra_info, str), "'extra' kwarg must be a string."
+                name_parts.append(extra_info)
+            self.cfg_name = sep.join(name_parts)
+        return self.cfg_name
+
     @abstractmethod
-    def prepare_metrics(self, metric_cfg) -> MetricsBackend:
+    def get_outdir(self):
         """
-        Prepare the metrics for the experiment.
+        Get the output directory for the configuration.
         This method should be implemented in subclasses.
         """
-        pass
+        return None
 
     @abstractmethod
-    def exec_exp(self, *args, **kwargs) -> Optional[Tuple[Any, Any]]:
-        """Run experiment process, e.g.: training/evaluation loop.
-        Return: either `None` or a tuple of (raw_metrics_data, extra_data) for calc_and_save_exp_perfs
+    def get_general_cfg(self) -> NamedCfg:
+        """
+        Get the general configuration like output directory, log settings, SEED, etc.
+        This method should be implemented in subclasses.
         """
         pass
 
-    # -----------------------
-    # Internal Helpers
-    # -----------------------
-    def _validate_and_unpack(self, results):
-        if results is None:
-            return None
-        if not isinstance(results, (tuple, list)) or len(results) != 2:
-            raise ValueError("exec must return (metrics_data, extra_data)")
-        return results[0], results[1]
-
-    def _prepare_environment(self, force_reload: bool = False):
+    @abstractmethod
+    def get_dataset_cfg(self) -> NamedCfg:
         """
-        Common setup. Skips if already initialized, unless force_reload is True.
+        Get the dataset configuration.
+        This method should be implemented in subclasses.
         """
-        if self._is_env_ready and not force_reload:
-            # Environment is already prepared, skipping setup.
-            return
-
-        # 1. Run Setup
-        self.init_general(self.config.get_general_cfg())
-        self.prepare_dataset(self.config.get_dataset_cfg())
-
-        # 2. Update metric backend (refresh if needed)
-        self.metric_backend = self.prepare_metrics(self.config.get_metric_cfg())
-
-        # 3. Mark as ready
-        self._is_env_ready = True
+        pass
 
-    # -----------------------
-    # Main Experiment Runner
-    # -----------------------
-    def run_exp(self, should_calc_metrics=True, reload_env=False, *args, **kwargs):
+    @abstractmethod
+    def get_method_cfg(self) -> NamedCfg:
         """
-        Run the whole experiment pipeline.
-        :param reload_env: If True, forces dataset/general init to run again.
-        :param should_calc_metrics: Whether to calculate and save metrics after execution.
-        :kwargs Params:
-            + 'outfile' to save csv file results,
-            + 'outdir' to set output directory for experiment results.
-            + 'return_df' to return a DataFrame of results instead of a dictionary.
-
-        Full pipeline:
-            1. Init
-            2. Prepare Environment (General + Dataset + Metrics)
-            3. Save Config
-            4. Execute
-            5. Calculate & Save Metrics
+        Get the method configuration.
+        This method should be implemented in subclasses.
         """
-        self._prepare_environment(force_reload=reload_env)
-
-        self._trigger_hooks("before_run", self)
-
-        # Save config before running
-        self.config.save_to_outdir()
-
-        # Execute experiment
-        results = self.exec_exp(*args, **kwargs)
+        pass
 
-        if should_calc_metrics and results is not None:
-            metrics_data, extra_data = self._validate_and_unpack(results)
-            # Calculate & Save metrics
-            perf_results = self.calc_perfs(
-                raw_metrics_data=metrics_data, extra_data=extra_data, *args, **kwargs
-            )
-            self._trigger_hooks("after_run", self, perf_results)
-            return perf_results
-        else:
-            self._trigger_hooks("after_run", self, results)
-            return results
+    @abstractmethod
+    def get_metric_cfg(self) -> NamedCfg:
+        """
+        Get the metric configuration.
+        This method should be implemented in subclasses.
+        """
+        pass

halib/exp/perf/perfcalc.py

@@ -74,114 +74,191 @@ class PerfCalc(ABC):  # Abstract base class for performance calculation
                 "All dictionaries in raw_data_for_metrics must have the same keys as metric_names"
             )
 
-    # ! only need to override this method if torchmetrics are not used
-    def calc_exp_perf_metrics(
-        self, metric_names, raw_metrics_data, extra_data=None, *args, **kwargs
-    ):
-        assert isinstance(raw_metrics_data, dict) or isinstance(
-            raw_metrics_data, list
-        ), "raw_data_for_metrics must be a dictionary or a list"
-
-        if extra_data is not None:
-            assert isinstance(
-                extra_data, type(raw_metrics_data)
-            ), "extra_data must be of the same type as raw_data_for_metrics (dict or list)"
-        # prepare raw_metric data for processing
-        proc_metric_raw_data_ls = (
-            raw_metrics_data
-            if isinstance(raw_metrics_data, list)
-            else [raw_metrics_data.copy()]
-        )
-        self.valid_proc_metric_raw_data(metric_names, proc_metric_raw_data_ls)
-        # prepare extra data for processing
-        proc_extra_data_ls = []
-        if extra_data is not None:
-            proc_extra_data_ls = (
-                extra_data if isinstance(extra_data, list) else [extra_data.copy()]
-            )
-            assert len(proc_extra_data_ls) == len(
-                proc_metric_raw_data_ls
-            ), "extra_data must have the same length as raw_data_for_metrics if it is a list"
-        # validate the extra_data
-        self.valid_proc_extra_data(proc_extra_data_ls)
+    # =========================================================================
+    # 1. Formatting Logic (Decoupled)
+    # =========================================================================
+    def package_metrics(
+        self,
+        metric_results_list: List[dict],
+        extra_data_list: Optional[List[dict]] = None,
+    ) -> List[OrderedDict]:
+        """
+        Pure formatting function.
+        Takes ALREADY CALCULATED metrics and formats them
+        (adds metadata, prefixes keys, ensures column order).
+        """
+        # Normalize extra_data to a list if provided
+        if extra_data_list is None:
+            extra_data_list = [{} for _ in range(len(metric_results_list))]
+        elif isinstance(extra_data_list, dict):
+            extra_data_list = [extra_data_list]
+
+        assert len(extra_data_list) == len(
+            metric_results_list
+        ), "Length mismatch: metrics vs extra_data"
 
-        # calculate the metrics output results
-        metrics_backend = self.get_metric_backend()
         proc_outdict_list = []
-        for idx, raw_metrics_data in enumerate(proc_metric_raw_data_ls):
+
+        for metric_res, extra_item in zip(metric_results_list, extra_data_list):
+            # A. Base Metadata
             out_dict = {
                 "dataset": self.get_dataset_name(),
                 "experiment": self.get_experiment_name(),
             }
-            custom_fields = []
-            if len(proc_extra_data_ls) > 0:
-                # add extra data to the output dictionary
-                extra_data_item = proc_extra_data_ls[idx]
-                out_dict.update(extra_data_item)
-                custom_fields = list(extra_data_item.keys())
-            metric_results = metrics_backend.calc_metrics(
-                metrics_data_dict=raw_metrics_data, *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())
+
+            # B. Attach Extra Data
+            out_dict.update(extra_item)
+            custom_fields = list(extra_item.keys())
+
+            # C. Prefix Metric Keys (e.g., 'acc' -> 'metric_acc')
+            metric_results_prefixed = {f"metric_{k}": v for k, v in metric_res.items()}
+            out_dict.update(metric_results_prefixed)
+
+            # D. Order Columns
+            all_cols = (
+                REQUIRED_COLS + custom_fields + list(metric_results_prefixed.keys())
             )
-            out_dict = OrderedDict(
-                (col, out_dict[col]) for col in ordered_cols if col in out_dict
+            ordered_out = OrderedDict(
+                (col, out_dict[col]) for col in all_cols if col in out_dict
             )
-            proc_outdict_list.append(out_dict)
+            proc_outdict_list.append(ordered_out)
 
         return proc_outdict_list
 
-    #! 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 calc_perfs(
+    # =========================================================================
+    # 2. Calculation Logic (The Coordinator)
+    # =========================================================================
+    def calc_exp_perf_metrics(
         self,
+        metric_names: List[str],
         raw_metrics_data: Union[List[dict], dict],
         extra_data: Optional[Union[List[dict], dict]] = None,
         *args,
         **kwargs,
-    ) -> Tuple[Union[List[OrderedDict], pd.DataFrame], Optional[str]]:
+    ) -> List[OrderedDict]:
         """
-        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.
+        Full workflow: Validates raw data -> Calculates via Backend -> Packages results.
         """
-        metric_names = self.get_metric_backend().metric_names
-        out_dict_list = self.calc_exp_perf_metrics(
-            metric_names=metric_names,
-            raw_metrics_data=raw_metrics_data,
-            extra_data=extra_data,
-            *args,
-            **kwargs,
+        # Prepare Raw Data
+        raw_data_ls = (
+            raw_metrics_data
+            if isinstance(raw_metrics_data, list)
+            else [raw_metrics_data]
         )
+        self.valid_proc_metric_raw_data(metric_names, raw_data_ls)
+
+        # Prepare Extra Data (Validation only)
+        extra_data_ls = None
+        if extra_data:
+            extra_data_ls = extra_data if isinstance(extra_data, list) else [extra_data]
+            self.valid_proc_extra_data(extra_data_ls)
+
+        # Calculate Metrics via Backend
+        metrics_backend = self.get_metric_backend()
+        calculated_results = []
+
+        for data_item in raw_data_ls:
+            res = metrics_backend.calc_metrics(
+                metrics_data_dict=data_item, *args, **kwargs
+            )
+            calculated_results.append(res)
+
+        # Delegate to Formatting
+        return self.package_metrics(calculated_results, extra_data_ls)
+
+    # =========================================================================
+    # 3. File Saving Logic (Decoupled)
+    # =========================================================================
+    def save_results_to_csv(
+        self, out_dict_list: List[OrderedDict], **kwargs
+    ) -> Tuple[pd.DataFrame, Optional[str]]:
+        """
+        Helper function to convert results to DataFrame and save to CSV.
+        """
         csv_outfile = kwargs.get("outfile", None)
+
+        # Determine Output Path
         if csv_outfile is not None:
             filePathNoExt, _ = os.path.splitext(csv_outfile)
-            # pprint(f"CSV Outfile Path (No Ext): {filePathNoExt}")
             csv_outfile = f"{filePathNoExt}{CSV_FILE_POSTFIX}.csv"
         elif "outdir" in kwargs:
             csvoutdir = kwargs["outdir"]
             csvfilename = f"{now_str()}_{self.get_dataset_name()}_{self.get_experiment_name()}_{CSV_FILE_POSTFIX}.csv"
             csv_outfile = os.path.join(csvoutdir, csvfilename)
 
-        # convert out_dict to a DataFrame
+        # Convert to DataFrame
         df = pd.DataFrame(out_dict_list)
-        # get the orders of the columns as the orders or the keys in out_dict
-        ordered_cols = list(out_dict_list[0].keys())
-        df = df[ordered_cols]  # reorder columns
+        if out_dict_list:
+            ordered_cols = list(out_dict_list[0].keys())
+            df = df[ordered_cols]
+
+        # Save to File
         if csv_outfile:
             df.to_csv(csv_outfile, index=False, sep=";", encoding="utf-8")
-        return_df = kwargs.get("return_df", False)
-        if return_df:  # return DataFrame instead of dict if requested
-            return df, csv_outfile
-        else:
-            return out_dict_list, csv_outfile
+
+        return df, csv_outfile
+
+    # =========================================================================
+    # 4. Public API: Standard Calculation
+    # raw_metrics_data: example: [{"preds": ..., "target": ...}, ...]
+    # =========================================================================
+    def calc_perfs(
+        self,
+        raw_metrics_data: Union[List[dict], dict],
+        extra_data: Optional[Union[List[dict], dict]] = None,
+        *args,
+        **kwargs,
+    ) -> Tuple[Union[List[OrderedDict], pd.DataFrame], Optional[str]]:
+        """
+        Standard use case: Calculate metrics AND save to CSV.
+        """
+        metric_names = self.get_metric_backend().metric_names
+
+        # 1. Calculate & Package
+        out_dict_list = self.calc_exp_perf_metrics(
+            metric_names=metric_names,
+            raw_metrics_data=raw_metrics_data,
+            extra_data=extra_data,
+            *args,
+            **kwargs,
+        )
+
+        # 2. Save
+        df, csv_outfile = self.save_results_to_csv(out_dict_list, **kwargs)
+
+        return (
+            (df, csv_outfile)
+            if kwargs.get("return_df", False)
+            else (out_dict_list, csv_outfile)
+        )
+
+    # =========================================================================
+    # 5. Public API: Manual / External Metrics (The Shortcut)
+    # =========================================================================
+    def save_computed_perfs(
+        self,
+        metrics_data: Union[List[dict], dict],
+        extra_data: Optional[Union[List[dict], dict]] = None,
+        **kwargs,
+    ) -> Tuple[Union[List[OrderedDict], pd.DataFrame], Optional[str]]:
+
+        # Ensure list format
+        if isinstance(metrics_data, dict):
+            metrics_data = [metrics_data]
+        if isinstance(extra_data, dict):
+            extra_data = [extra_data]
+
+        # 1. Package (Format)
+        formatted_list = self.package_metrics(metrics_data, extra_data)
+
+        # 2. Save
+        df, csv_outfile = self.save_results_to_csv(formatted_list, **kwargs)
+
+        return (
+            (df, csv_outfile)
+            if kwargs.get("return_df", False)
+            else (formatted_list, csv_outfile)
+        )
 
     @staticmethod
     def default_exp_csv_filter_fn(exp_file_name: str) -> bool:

halib/filetype/yamlfile.py

@@ -11,6 +11,7 @@ from ..system.path import *
 
 console = Console()
 
+
 def _load_yaml_recursively(
     yaml_file, yaml_files=[], share_nx_graph=nx.DiGraph(), log_info=False
 ):
@@ -53,25 +54,16 @@ def load_yaml(yaml_file, to_dict=False, log_info=False):
     else:
         return omgconf
 
+
 def load_yaml_with_PC_abbr(
-    yaml_file, pc_abbr_to_working_disk=DEFAULT_ABBR_WORKING_DISK
+    yaml_file, abbr_disk_map=ABBR_DISK_MAP
 ):
-    # current PC abbreviation
-    pc_abbr = get_PC_abbr_name()
-
-    # current plaftform: windows or linux
-    current_platform = platform.system().lower()
-
-    assert pc_abbr in pc_abbr_to_working_disk, f"The is no mapping for {pc_abbr} to <working_disk>"
-
-    # working disk
-    working_disk = pc_abbr_to_working_disk.get(pc_abbr)
-
     # load yaml file
     data_dict = load_yaml(yaml_file=yaml_file, to_dict=True)
-
     # Normalize paths in the loaded data
-    data_dict = normalize_paths(data_dict, working_disk, current_platform)
+    data_dict = normalize_paths(
+        data_dict, get_working_disk(abbr_disk_map), get_os_platform()
+    )
     return data_dict
 
 

halib/system/path.py

@@ -2,9 +2,9 @@ from ..common.common import *
 from ..filetype import csvfile
 import pandas as pd
 import platform
+import re  # <--- [FIX 1] Added missing import
 
-
-PC_NAME_TO_ABBR = {
+PC_TO_ABBR = {
     "DESKTOP-JQD9K01": "MainPC",
     "DESKTOP-5IRHU87": "MSI_Laptop",
     "DESKTOP-96HQCNO": "4090_SV",
@@ -12,17 +12,16 @@ PC_NAME_TO_ABBR = {
     "DESKTOP-QNS3DNF": "1GPU_SV",
 }
 
-DEFAULT_ABBR_WORKING_DISK = {
+ABBR_DISK_MAP = {
     "MainPC": "E:",
     "MSI_Laptop": "D:",
     "4090_SV": "E:",
     "4GPU_SV": "D:",
 }
 
+
 def list_PCs(show=True):
-    df = pd.DataFrame(
-        list(PC_NAME_TO_ABBR.items()), columns=["PC Name", "Abbreviation"]
-    )
+    df = pd.DataFrame(list(PC_TO_ABBR.items()), columns=["PC Name", "Abbreviation"])
     if show:
         csvfile.fn_display_df(df)
     return df
@@ -34,13 +33,32 @@ def get_PC_name():
 
 def get_PC_abbr_name():
     pc_name = get_PC_name()
-    return PC_NAME_TO_ABBR.get(pc_name, "Unknown")
+    return PC_TO_ABBR.get(pc_name, "Unknown")
+
+
+def get_os_platform():
+    return platform.system().lower()
+
+
+def get_working_disk(abbr_disk_map=ABBR_DISK_MAP):
+    pc_abbr = get_PC_abbr_name()
+    return abbr_disk_map.get(pc_abbr, None)
 
 
 # ! This funcction search for full paths in the obj and normalize them according to the current platform and working disk
 # ! E.g: "E:/zdataset/DFire", but working_disk: "D:", current_platform: "windows" => "D:/zdataset/DFire"
 # ! E.g: "E:/zdataset/DFire", but working_disk: "D:", current_platform: "linux" => "/mnt/d/zdataset/DFire"
-def normalize_paths(obj, working_disk, current_platform):
+def normalize_paths(obj, working_disk=None, current_platform=None):
+    # [FIX 3] Resolve defaults inside function to be safer/cleaner
+    if working_disk is None:
+        working_disk = get_working_disk()
+    if current_platform is None:
+        current_platform = get_os_platform()
+
+    # [FIX 2] If PC is unknown, working_disk is None. Return early to avoid crash.
+    if working_disk is None:
+        return obj
+
     if isinstance(obj, dict):
         for key, value in obj.items():
             obj[key] = normalize_paths(value, working_disk, current_platform)
@@ -52,22 +70,25 @@ def normalize_paths(obj, working_disk, current_platform):
     elif isinstance(obj, str):
         # Normalize backslashes to forward slashes for consistency
         obj = obj.replace("\\", "/")
+
         # Regex for Windows-style path: e.g., "E:/zdataset/DFire"
         win_match = re.match(r"^([A-Z]):/(.*)$", obj)
         # Regex for Linux-style path: e.g., "/mnt/e/zdataset/DFire"
         lin_match = re.match(r"^/mnt/([a-z])/(.*)$", obj)
+
         if win_match or lin_match:
             rest = win_match.group(2) if win_match else lin_match.group(2)
+
             if current_platform == "windows":
                 # working_disk is like "D:", so "D:/" + rest
-                new_path = working_disk + "/" + rest
+                new_path = f"{working_disk}/{rest}"
             elif current_platform == "linux":
                 # Extract drive letter from working_disk (e.g., "D:" -> "d")
                 drive_letter = working_disk[0].lower()
-                new_path = "/mnt/" + drive_letter + "/" + rest
+                new_path = f"/mnt/{drive_letter}/{rest}"
             else:
-                # Unknown platform, return original
                 return obj
             return new_path
+
     # For non-strings or non-path strings, return as is
     return obj

{halib-0.2.5.dist-info → halib-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halib
-Version: 0.2.5
+Version: 0.2.7
 Summary: Small library for common tasks
 Author: Hoang Van Ha
 Author-email: hoangvanhauit@gmail.com
@@ -53,8 +53,9 @@ Dynamic: summary
 
 # Helper package for coding and automation
 
-**Version 0.2.5**
+**Version 0.2.7**
 + reorganize packages with most changes in `research` package; also rename `research` to `exp` (package for experiment management and utilities)
++ update `exp/perfcalc.py` to allow save computed performance to csv file (without explicit calling method `calc_perfs`)
 
 **Version 0.2.1**
 + `research/base_exp`: add `eval_exp` method to evaluate experiment (e.g., model evaluation on test set) after experiment running is done.

{halib-0.2.5.dist-info → halib-0.2.7.dist-info}/RECORD

@@ -21,8 +21,8 @@ halib/common/common.py,sha256=olkeXdFdojOkySP5aurzxKlehngRwBHdNBw5JfE4_fQ,5038
 halib/common/rich_color.py,sha256=tyK5fl3Dtv1tKsfFzt_5Rco4Fj72QliA-w5aGXaVuqQ,6392
 halib/exp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 halib/exp/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-halib/exp/core/base_config.py,sha256=MtkbToF078imMcsna5Dlv9q4ORKRKkOUCERX7JbVdzM,4180
-halib/exp/core/base_exp.py,sha256=fknJVmW6ubbapOggbkrbNWgc1ZXcUz_FE3wMyuIGX7M,5180
+halib/exp/core/base_config.py,sha256=Js2oVDt7qwT7eV_sOUWw6XXl569G1bX6ls-VYAx2gWY,5032
+halib/exp/core/base_exp.py,sha256=XjRHXbUHE-DCZLRDTteDF5gsxKN3mhGEe2zWL24JP80,5131
 halib/exp/core/param_gen.py,sha256=I9JHrDCaep4CjvApDoX0QzFuw38zMC2PsDFueuA7pjM,4271
 halib/exp/core/wandb_op.py,sha256=powL2QyLBqF-6PUGAOqd60s1npHLLKJxPns3S4hKeNo,4160
 halib/exp/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,7 +32,7 @@ halib/exp/data/torchloader.py,sha256=oWUplXlGd1IB6CqdRd-mGe-DfMjjZxz9hQ7SWONb-0s
 halib/exp/perf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 halib/exp/perf/flop_calc.py,sha256=Kb3Gwqc7QtGALZzfyYXBA_9SioReJpTJdUX84kqj-Aw,6907
 halib/exp/perf/gpu_mon.py,sha256=vD41_ZnmPLKguuq9X44SB_vwd9JrblO4BDzHLXZhhFY,2233
-halib/exp/perf/perfcalc.py,sha256=FSWDStz9f94dObyAHYHRtq4fuo0dIw7l9JH_x5Wd7cQ,16225
+halib/exp/perf/perfcalc.py,sha256=p7rhVShiie7DT_s50lbvbGftVCkrWE0tQGFLUEmTXi0,18326
 halib/exp/perf/perfmetrics.py,sha256=qRiNiCKGUSTLY7gPMVMuVHGAAyeosfGWup2eM4490aw,5485
 halib/exp/perf/perftb.py,sha256=IWElg3OB5dmhfxnY8pMZvkL2y_EnvLmEx3gJlpUR1Fs,31066
 halib/exp/perf/profiler.py,sha256=5ZjES8kAqEsSV1mC3Yr_1ivFLwQDc_yv4HY7dKt_AS0,11782
@@ -44,7 +44,7 @@ halib/filetype/ipynb.py,sha256=pd2LgmPa7ZbF0YlQJbeQZEsl6jHQUSoyVtkCT7WhU5Q,1657
 halib/filetype/jsonfile.py,sha256=2HcBqXYjLNvqFok3PHOgH59vlhDCZLZpt7ezvgx1TFM,474
 halib/filetype/textfile.py,sha256=3koEFyVme1SEHdud7TnjArHndoiqfMGfMdYY3NIFegM,397
 halib/filetype/videofile.py,sha256=wDyZp7Dh0ZuNgQUvt8gLTpy3Flx1jDr-QsO4-jzriGE,8104
-halib/filetype/yamlfile.py,sha256=ZV8-kL8MWVYC-HGjo6nv0gkJ4joauo43uqez5dqTOdk,2739
+halib/filetype/yamlfile.py,sha256=buvj016n3wmEBDfeDX9lbljqDk5R5OlKHuXDKSfIKK0,2411
 halib/online/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 halib/online/gdrive.py,sha256=RmF4y6UPxektkKIctmfT-pKWZsBM9FVUeld6zZmJkp0,7787
 halib/online/gdrive_mkdir.py,sha256=wSJkQMJCDuS1gxQ2lHQHq_IrJ4xR_SEoPSo9n_2WNFU,1474
@@ -91,7 +91,7 @@ halib/sys/filesys.py,sha256=ERpnELLDKJoTIIKf-AajgkY62nID4qmqmX5TkE95APU,2931
 halib/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 halib/system/cmd.py,sha256=b2x7JPcNnFjLGheIESVYvqAb-w2UwBM1PAwYxMZ5YjA,228
 halib/system/filesys.py,sha256=102J2fkQhmH1_-HQVy2FQ4NOU8LTjMWV3hToT_APtq8,4401
-halib/system/path.py,sha256=E1inJqRWqUYknP8Cdx0T5nUV-rLG9WYy2DiQmBxaQJc,2642
+halib/system/path.py,sha256=uCXTltd943L_2heU2HLwvXcgYJRd8-ZEzDe435419OQ,3165
 halib/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 halib/utils/dataclass_util.py,sha256=rj2IMLlUzbm2OlF5_B2dRTk9njZOaF7tTjYkOsq8uLY,1416
 halib/utils/dict.py,sha256=wYE6Iw-_CnCWdMg9tpJ2Y2-e2ESkW9FxmdBkZkbUh80,299
@@ -101,8 +101,8 @@ halib/utils/list.py,sha256=BM-8sRhYyqF7bh4p7TQtV7P_gnFruUCA6DTUOombaZg,337
 halib/utils/listop.py,sha256=Vpa8_2fI0wySpB2-8sfTBkyi_A4FhoFVVvFiuvW8N64,339
 halib/utils/tele_noti.py,sha256=-4WXZelCA4W9BroapkRyIdUu9cUVrcJJhegnMs_WpGU,5928
 halib/utils/video.py,sha256=zLoj5EHk4SmP9OnoHjO8mLbzPdtq6gQPzTQisOEDdO8,3261
-halib-0.2.5.dist-info/licenses/LICENSE.txt,sha256=qZssdna4aETiR8znYsShUjidu-U4jUT9Q-EWNlZ9yBQ,1100
-halib-0.2.5.dist-info/METADATA,sha256=AHNT2TyfsLLTRvf81f-Uc5lcPDE5AeSRAKfwp_te-DI,6714
-halib-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-halib-0.2.5.dist-info/top_level.txt,sha256=7AD6PLaQTreE0Fn44mdZsoHBe_Zdd7GUmjsWPyQ7I-k,6
-halib-0.2.5.dist-info/RECORD,,
+halib-0.2.7.dist-info/licenses/LICENSE.txt,sha256=qZssdna4aETiR8znYsShUjidu-U4jUT9Q-EWNlZ9yBQ,1100
+halib-0.2.7.dist-info/METADATA,sha256=jSjp5DPZ8A8ohlO-QQ__7mE0Z-fO7sdkZ5Bz6ssKnhU,6836
+halib-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+halib-0.2.7.dist-info/top_level.txt,sha256=7AD6PLaQTreE0Fn44mdZsoHBe_Zdd7GUmjsWPyQ7I-k,6
+halib-0.2.7.dist-info/RECORD,,