dragon-ml-toolbox 20.13.0__tar.gz → 20.14.1__tar.gz

{dragon_ml_toolbox-20.13.0/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-20.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 20.13.0
+Version: 20.14.1
 Summary: Complete pipelines and helper tools for data science and machine learning projects.
 Author-email: Karl Luigi Loza Vidaurre <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-20.13.0 → dragon_ml_toolbox-20.14.1/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 20.13.0
+Version: 20.14.1
 Summary: Complete pipelines and helper tools for data science and machine learning projects.
 Author-email: Karl Luigi Loza Vidaurre <luigiloza@gmail.com>
 License-Expression: MIT

{dragon_ml_toolbox-20.13.0 → dragon_ml_toolbox-20.14.1}/ml_tools/ML_scaler/_ML_scaler.py

@@ -99,7 +99,7 @@ class DragonScaler:
             std = torch.sqrt(torch.clamp(variance, min=1e-8))
         
         if verbose >= 2:
-            _LOGGER.info(f"Scaler fitted on {n_total} samples for {num_continuous_features} features (Welford's).")
+            _LOGGER.info(f"Scaler fitted on {n_total} samples for {num_continuous_features} columns (Welford's).")
         return cls(mean=mean_global, std=std, continuous_feature_indices=continuous_feature_indices)
 
     @classmethod
@@ -121,7 +121,7 @@ class DragonScaler:
         std = torch.where(std == 0, torch.tensor(1.0, device=data.device), std)
         
         if verbose >= 2:
-            _LOGGER.info(f"Scaler fitted on tensor with {data.shape[0]} samples for {num_features} features.")
+            _LOGGER.info(f"Scaler fitted on tensor with {data.shape[0]} samples for {num_features} columns.")
         
         return cls(mean=mean, std=std, continuous_feature_indices=indices)
 

{dragon_ml_toolbox-20.13.0 → dragon_ml_toolbox-20.14.1}/ml_tools/data_exploration/__init__.py

@@ -33,6 +33,7 @@ from ._features import (
     reconstruct_one_hot,
     reconstruct_binary,
     reconstruct_multibinary,
+    filter_subset,
 )
 
 from ._schema_ops import (
@@ -51,6 +52,7 @@ __all__ = [
     "drop_columns_with_missing_data",
     "drop_macro",
     "clean_column_names",
+    "filter_subset",
     "plot_value_distributions",
     "split_features_targets", 
     "split_continuous_binary", 

{dragon_ml_toolbox-20.13.0 → dragon_ml_toolbox-20.14.1}/ml_tools/data_exploration/_analysis.py

@@ -34,7 +34,7 @@ def summarize_dataframe(df: pd.DataFrame, round_digits: int = 2):
     """
     summary = pd.DataFrame({
         'Data Type': df.dtypes,
-        'Completeness %': (df.notnull().mean() * 100).round(2),
+        'Completeness %': (df.notnull().mean() * 100).round(2), # type: ignore
         'Unique Values': df.nunique(),
         # 'Missing %': (df.isnull().mean() * 100).round(2)
     })

{dragon_ml_toolbox-20.13.0 → dragon_ml_toolbox-20.14.1}/ml_tools/data_exploration/_features.py

@@ -168,6 +168,13 @@ def split_continuous_categorical_targets(
         f"  - Categorical: {df_categorical.shape}\n"
         f"  - Targets: {df_targets.shape}"
     )
+    
+    if isinstance(df_continuous, pd.Series):
+        df_continuous = df_continuous.to_frame()
+    if isinstance(df_categorical, pd.Series):
+        df_categorical = df_categorical.to_frame()
+    if isinstance(df_targets, pd.Series):
+        df_targets = df_targets.to_frame()
 
     return df_continuous, df_categorical, df_targets
 
@@ -271,6 +278,7 @@ def encode_classification_target(
     df: pd.DataFrame,
     target_col: str,
     save_dir: Union[str, Path],
+    suffix: str = "",
     verbose: int = 2
 ) -> tuple[pd.DataFrame, dict[str, int]]:
     """
@@ -283,6 +291,7 @@ def encode_classification_target(
         df (pd.DataFrame): Input DataFrame.
         target_col (str): Name of the target column to encode.
         save_dir (str | Path): Directory where the class map JSON will be saved.
+        suffix (str): Suffix to append to the class map filename.
         verbose (int): Verbosity level for logging.
 
     Returns:
@@ -300,9 +309,17 @@ def encode_classification_target(
         _LOGGER.error(f"Target column '{target_col}' contains {n_missing} missing values. Please handle them before encoding.")
         raise ValueError()
     
+    # validate suffix and prepend underscore if needed
+    if suffix:
+        if not suffix.startswith("_"):
+            suffix = f"_{suffix}"
+        sanitized_suffix = suffix
+    else:
+        sanitized_suffix = ''
+        
     # Ensure directory exists
     save_path = make_fullpath(save_dir, make=True, enforce="directory")
-    file_path = save_path / "class_map.json"
+    file_path = save_path / f"class_map{sanitized_suffix}.json"
 
     # Get unique values and sort them to ensure deterministic encoding (0, 1, 2...)
     # Convert to string to ensure the keys in JSON are strings
@@ -322,10 +339,9 @@ def encode_classification_target(
             json.dump(class_map, f, indent=4)
             
         if verbose >= 2:
-            _LOGGER.info(f"Class mapping saved to: '{file_path}'")
-        
+            _LOGGER.info(f"Target '{target_col}' encoded with {len(class_map)} classes. Saved to {file_path}.")
+            
         if verbose >= 3:
-            _LOGGER.info(f"Target '{target_col}' encoded with {len(class_map)} classes.")
             # Print a preview
             if len(class_map) <= 10:
                 print(f"  Mapping: {class_map}")
@@ -657,3 +673,66 @@ def reconstruct_multibinary(
         _LOGGER.info(f"Reconstructed {converted_count} binary columns matching '{pattern}'.")
 
     return new_df, target_columns
+
+
+def filter_subset(
+    df: pd.DataFrame,
+    filters: Union[dict[str, Any], dict[str, list[Any]]],
+    drop_filter_cols: bool = True,
+    reset_index: bool = True,
+    verbose: int = 3
+) -> pd.DataFrame:
+    """
+    Filters the DataFrame based on a dictionary of column-value conditions.
+
+    Supports:
+    - Single value matching (e.g., {"Color": "Blue"})
+    - Multiple value matching (e.g., {"Color": ["Blue", "Red"]}) -> OR logic within column.
+    - Multiple column filtering (e.g., {"Color": "Blue", "Size": "Large"}) -> AND logic between columns.
+
+    Args:
+        df (pd.DataFrame): Input DataFrame.
+        filters (dict[str, Any] | dict[str, list[Any]]): Dictionary where keys are column names and values are the target values (scalar or list).
+        drop_filter_cols (bool): If True, drops the columns used for filtering from the result.
+        reset_index (bool): If True, resets the index of the resulting DataFrame.
+        verbose (int): Verbosity level.
+
+    Returns:
+        pd.DataFrame: The filtered DataFrame.
+    """
+    df_filtered = df.copy()
+
+    # Validate columns exist
+    missing_cols = [col for col in filters.keys() if col not in df.columns]
+    if missing_cols:
+        _LOGGER.error(f"Filter columns not found: {missing_cols}")
+        raise ValueError()
+
+    if verbose >= 2:
+        _LOGGER.info(f"Original shape: {df.shape}")
+
+    for col, value in filters.items():
+        # Handle list of values (OR logic within column)
+        if isinstance(value, list):
+            df_filtered = df_filtered[df_filtered[col].isin(value)]
+        # Handle single value
+        else:
+            # Warn if the value is a floating point due to potential precision issues
+            if isinstance(value, float) and verbose >= 1:
+                _LOGGER.warning(f"Filtering on column '{col}' with float value '{value}'.")
+            df_filtered = df_filtered[df_filtered[col] == value]
+
+    if drop_filter_cols:
+        if verbose >= 3:
+            _LOGGER.info(f"Dropping filter columns: {list(filters.keys())}")
+        df_filtered.drop(columns=list(filters.keys()), inplace=True)
+
+    if reset_index:
+        if verbose >= 3:
+            _LOGGER.info("Resetting index of the filtered DataFrame.")
+        df_filtered.reset_index(drop=True, inplace=True)
+
+    if verbose >= 2:
+        _LOGGER.info(f"Filtered shape: {df_filtered.shape}")
+
+    return df_filtered

{dragon_ml_toolbox-20.13.0 → dragon_ml_toolbox-20.14.1}/ml_tools/data_exploration/_plotting.py

@@ -475,6 +475,9 @@ def plot_correlation_heatmap(df: pd.DataFrame,
         save_path = make_fullpath(save_dir, make=True)
         # sanitize the plot title to save the file
         sanitized_plot_title = sanitize_filename(plot_title)
+        # prepend method to filename
+        sanitized_plot_title = f"{method}_{sanitized_plot_title}"
+        
         plot_filename = sanitized_plot_title + ".svg"
         
         full_path = save_path / plot_filename

{dragon_ml_toolbox-20.13.0 → dragon_ml_toolbox-20.14.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dragon-ml-toolbox"
-version = "20.13.0"
+version = "20.14.1"
 description = "Complete pipelines and helper tools for data science and machine learning projects."
 authors = [
     { name = "Karl Luigi Loza Vidaurre", email = "luigiloza@gmail.com" }