dragon-ml-toolbox 12.9.1__tar.gz → 12.10.0__tar.gz

{dragon_ml_toolbox-12.9.1/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-12.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 12.9.1
+Version: 12.10.0
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: "Karl L. Loza Vidaurre" <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-12.9.1 → dragon_ml_toolbox-12.10.0/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 12.9.1
+Version: 12.10.0
 Summary: A collection of tools for data science and machine learning projects.
 Author-email: "Karl L. Loza Vidaurre" <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-12.9.1 → dragon_ml_toolbox-12.10.0}/ml_tools/custom_logger.py

@@ -4,6 +4,8 @@ from typing import Union, List, Dict, Any
 import traceback
 import json
 import csv
+from itertools import zip_longest
+from collections import Counter
 
 from .path_manager import sanitize_filename, make_fullpath
 from ._script_info import _script_info
@@ -13,7 +15,8 @@ from ._logger import _LOGGER
 __all__ = [
     "custom_logger",
     "save_list_strings",
-    "load_list_strings"
+    "load_list_strings",
+    "compare_lists"
 ]
 
 
@@ -177,5 +180,126 @@ def load_list_strings(text_file: Union[str,Path], verbose: bool=True) -> list[st
     return loaded_strings
 
 
+class _RobustEncoder(json.JSONEncoder):
+    """
+    Custom JSON encoder to handle non-serializable objects.
+
+    This handles:
+    1.  `type` objects (e.g., <class 'int'>) which result from
+        `check_type_only=True`.
+    2.  Any other custom class or object by falling back to its
+        string representation.
+    """
+    def default(self, o):
+        if isinstance(o, type):
+            return str(o)
+        try:
+            return super().default(o)
+        except TypeError:
+            return str(o)
+
+def compare_lists(
+    list_A: list,
+    list_B: list,
+    save_dir: Union[str, Path],
+    strict: bool = False,
+    check_type_only: bool = False
+) -> dict:
+    """
+    Compares two lists and saves a JSON report of the differences.
+
+    Args:
+        list_A (list): The first list to compare.
+        list_B (list): The second list to compare.
+        save_dir (str | Path): The directory where the resulting report will be saved.
+        strict (bool):
+            - If False: Performs a "bag" comparison. Order does not matter, but duplicates do.
+            - If True: Performs a strict, positional comparison.
+            
+        check_type_only (bool):
+            - If False: Compares items using `==` (`__eq__` operator).
+            - If True: Compares only the `type()` of the items.
+
+    Returns:
+        A dictionary detailing the differences. (saved to `save_dir`).
+    """
+    MISSING_A_KEY = "missing_in_A"
+    MISSING_B_KEY = "missing_in_B"
+    MISMATCH_KEY = "mismatch"
+    
+    results: dict[str, list] = {MISSING_A_KEY: [], MISSING_B_KEY: []}
+    
+    # make directory
+    save_path = make_fullpath(input_path=save_dir, make=True, enforce="directory")
+
+    if strict:
+        # --- STRICT (Positional) Mode ---
+        results[MISMATCH_KEY] = []
+        sentinel = object()
+
+        if check_type_only:
+            compare_func = lambda a, b: type(a) == type(b)
+        else:
+            compare_func = lambda a, b: a == b
+
+        for index, (item_a, item_b) in enumerate(
+            zip_longest(list_A, list_B, fillvalue=sentinel)
+        ):
+            if item_a is sentinel:
+                results[MISSING_A_KEY].append({"index": index, "item": item_b})
+            elif item_b is sentinel:
+                results[MISSING_B_KEY].append({"index": index, "item": item_a})
+            elif not compare_func(item_a, item_b):
+                results[MISMATCH_KEY].append(
+                    {
+                        "index": index,
+                        "list_A_item": item_a,
+                        "list_B_item": item_b,
+                    }
+                )
+
+    else:
+        # --- NON-STRICT (Bag) Mode ---
+        if check_type_only:
+            # Types are hashable, we can use Counter (O(N))
+            types_A_counts = Counter(type(item) for item in list_A)
+            types_B_counts = Counter(type(item) for item in list_B)
+
+            diff_A_B = types_A_counts - types_B_counts
+            for item_type, count in diff_A_B.items():
+                results[MISSING_B_KEY].extend([item_type] * count)
+
+            diff_B_A = types_B_counts - types_A_counts
+            for item_type, count in diff_B_A.items():
+                results[MISSING_A_KEY].extend([item_type] * count)
+
+        else:
+            # Items may be unhashable. Use O(N*M) .remove() method
+            temp_B = list(list_B)
+            missing_in_B = []
+
+            for item_a in list_A:
+                try:
+                    temp_B.remove(item_a)
+                except ValueError:
+                    missing_in_B.append(item_a)
+            
+            results[MISSING_A_KEY] = temp_B
+            results[MISSING_B_KEY] = missing_in_B
+
+    # --- Save the Report ---
+    try:
+        full_path = save_path / "list_comparison.json"
+
+        # Write the report dictionary to the JSON file
+        with open(full_path, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=4, cls=_RobustEncoder)
+            
+    except Exception as e:
+        _LOGGER.error(f"Failed to save comparison report to {save_path}: \n{e}")
+
+    return results
+
+
 def info():
     _script_info(__all__)

{dragon_ml_toolbox-12.9.1 → dragon_ml_toolbox-12.10.0}/ml_tools/data_exploration.py

@@ -1024,7 +1024,7 @@ def reconstruct_one_hot(
     df: pd.DataFrame,
     features_to_reconstruct: List[Union[str, Tuple[str, Optional[str]]]],
     separator: str = '_',
-    baseline_category_name: str = "Other",
+    baseline_category_name: Optional[str] = "Other",
     drop_original: bool = True,
     verbose: bool = True
 ) -> pd.DataFrame:
@@ -1056,7 +1056,7 @@ def reconstruct_one_hot(
         separator (str): 
             The character separating the base name from the categorical value in 
             the column names (e.g., '_' in 'B_a').
-        baseline_category_name (str):
+        baseline_category_name (str | None):
             The baseline category name to use by default if it is not explicitly provided.
         drop_original (bool): 
             If True, the original one-hot encoded columns will be dropped from 
@@ -1081,8 +1081,8 @@ def reconstruct_one_hot(
         _LOGGER.error("Input must be a pandas DataFrame.")
         raise TypeError()
     
-    if not isinstance(baseline_category_name, str):
-        _LOGGER.error("The baseline_category must be a string.")
+    if not (baseline_category_name is None or isinstance(baseline_category_name, str)):
+        _LOGGER.error("The baseline_category must be None or a string.")
         raise TypeError()
 
     new_df = df.copy()

{dragon_ml_toolbox-12.9.1 → dragon_ml_toolbox-12.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dragon-ml-toolbox"
-version = "12.9.1"
+version = "12.10.0"
 description = "A collection of tools for data science and machine learning projects."
 authors = [
     { name = "Karl L. Loza Vidaurre", email = "luigiloza@gmail.com" }