dragon-ml-toolbox 12.9.2__tar.gz → 12.11.0__tar.gz

{dragon_ml_toolbox-12.9.2/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-12.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 12.9.2
+Version: 12.11.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.2 → dragon_ml_toolbox-12.11.0/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 12.9.2
+Version: 12.11.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.2 → dragon_ml_toolbox-12.11.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:
+        dict: 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.2 → dragon_ml_toolbox-12.11.0}/ml_tools/serde.py

@@ -83,8 +83,7 @@ def deserialize_object(
     filepath: Union[str, Path],
     expected_type: Optional[Type[T]] = None,
     verbose: bool = True,
-    raise_on_error: bool = True
-    ) -> Optional[T]:
+    ) -> T:
     """
     Loads a serialized object from a .joblib file.
 
@@ -96,22 +95,17 @@ def deserialize_object(
             like `list[str]` by checking the base type (e.g., `list`).
             Defaults to None, which skips the type check.
         verbose (bool): If True, logs success messages.
-        raise_on_error (bool): If True, raises exceptions on errors. If False, returns None instead.
 
     Returns:
-        (Any | None): The deserialized Python object, which will match the
-            `expected_type` if provided. Returns None if an error
-            occurs and `raise_on_error` is False.
+        (Any): The deserialized Python object, which will match the `expected_type` if provided.
     """
-    true_filepath = make_fullpath(filepath)
+    true_filepath = make_fullpath(filepath, enforce="file")
     
     try:
         obj = joblib.load(true_filepath)
     except (IOError, OSError, EOFError, TypeError, ValueError) as e:
         _LOGGER.error(f"Failed to deserialize object from '{true_filepath}'.")
-        if raise_on_error:
-            raise e
-        return None
+        raise e
     else:
         # --- Type Validation Step ---
         if expected_type:
@@ -126,9 +120,7 @@ def deserialize_object(
                     f"but found '{type(obj)}' in '{true_filepath}'."
                 )
                 _LOGGER.error(error_msg)
-                if raise_on_error:
-                    raise TypeError()
-                return None
+                raise TypeError()
         
         if verbose:
             _LOGGER.info(f"Loaded object of type '{type(obj)}' from '{true_filepath}'.")

{dragon_ml_toolbox-12.9.2 → dragon_ml_toolbox-12.11.0}/pyproject.toml

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