SuperModelingFactory 0.5.0__tar.gz → 0.5.2__tar.gz

{supermodelingfactory-0.5.0 → supermodelingfactory-0.5.2}/Modeling_Tool/Core/ODPS_Tool.py

@@ -17,6 +17,28 @@ pd.options.mode.chained_assignment = None  # default='warn'
 
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 
+
+def _split_odps_table_name(table_name):
+    """Return (qualifier, bare table name) for ODPS table identifiers.
+
+    MaxCompute accepts a project-qualified source in ``ALTER TABLE`` but the
+    ``RENAME TO`` target must be the bare table name within the same project.
+    """
+    table_name = str(table_name)
+    if "." not in table_name:
+        return "", table_name
+    qualifier, bare_name = table_name.rsplit(".", 1)
+    return qualifier, bare_name
+
+
+def _make_related_odps_table_name(table_name, suffix):
+    qualifier, bare_name = _split_odps_table_name(table_name)
+    related_bare = f"{bare_name}{suffix}"
+    if qualifier:
+        return f"{qualifier}.{related_bare}", related_bare
+    return related_bare, related_bare
+
+
 class ODPSRunner(object):
     _wide_schema_patch_lock = threading.RLock()
     _wide_schema_patch_ref_count = 0
@@ -292,8 +314,9 @@ class ODPSRunner(object):
         # Atomic swap path (default from 0.4.2). If any step before the final
         # swap fails, the original table is untouched.
         ts = datetime.now().strftime('%Y%m%d%H%M%S%f')
-        tmp_name = f"{table_name}__tmp_{ts}"
-        old_name = f"{table_name}__old_{ts}"
+        _, target_rename_name = _split_odps_table_name(table_name)
+        tmp_name, _ = _make_related_odps_table_name(table_name, f"__tmp_{ts}")
+        old_name, old_rename_name = _make_related_odps_table_name(table_name, f"__old_{ts}")
 
         # Step 1: write data into the temp table. If this fails, drop the
         # partial temp table and re-raise; the target table is untouched.
@@ -321,7 +344,7 @@ class ODPSRunner(object):
         target_exists = self.o.exist_table(table_name)
         if target_exists:
             try:
-                self.o.run_sql(f"ALTER TABLE {table_name} RENAME TO {old_name};")
+                self.o.run_sql(f"ALTER TABLE {table_name} RENAME TO {old_rename_name};")
             except Exception:
                 # Rename of the live target failed — do not touch it. Drop the
                 # tmp table so we don't leak it, then re-raise.
@@ -334,13 +357,13 @@ class ODPSRunner(object):
                 raise
 
         try:
-            self.o.run_sql(f"ALTER TABLE {tmp_name} RENAME TO {table_name};")
+            self.o.run_sql(f"ALTER TABLE {tmp_name} RENAME TO {target_rename_name};")
         except Exception:
             # tmp -> target rename failed. If we already moved the original,
             # try to restore it so the caller is not left with a missing table.
             if target_exists:
                 try:
-                    self.o.run_sql(f"ALTER TABLE {old_name} RENAME TO {table_name};")
+                    self.o.run_sql(f"ALTER TABLE {old_name} RENAME TO {target_rename_name};")
                     logger.warning(
                         f"upload_df: swap of {tmp_name} -> {table_name} failed; restored original from {old_name}"
                     )

{supermodelingfactory-0.5.0 → supermodelingfactory-0.5.2}/Modeling_Tool/Feature/Feature_Insights.py

@@ -4,9 +4,11 @@
 """
 
 import pandas as pd
+import warnings
 from tqdm import tqdm
 
 from .Distribution_Tool import proc_means_by_grp, proc_means_for_screening
+from Modeling_Tool._utils.robust import smf_logger
 import logging
 logger = logging.getLogger(__name__)
 
@@ -108,6 +110,7 @@ class VarExtractionInsights:
         self.seed = seed
         self.missing_rate_ref = missing_rate_ref
         self.spec_values = spec_values if spec_values is not None else []
+        self.failed_variables = []
 
     @staticmethod
     def remove_folder(file_path):
@@ -170,6 +173,7 @@ class VarExtractionInsights:
         """
         if dep is None:
             dep = self.dep
+        self.failed_variables = []
 
         from Modeling_Tool.Eval.Model_Eval_Tool import get_gains_table
 
@@ -200,9 +204,27 @@ class VarExtractionInsights:
                     attr_iv['var'] = var
                     iv_info_res.append(attr_iv)
 
-                except TypeError:
+                except (TypeError, ValueError, KeyError, ZeroDivisionError) as exc:
+                    row = smf_logger.record_and_continue(var, exc, stage="feature_insights")
+                    self.failed_variables.append((row["feature"], row["exception_type"]))
                     continue
 
+        if self.failed_variables:
+            failed = [name for name, _ in self.failed_variables]
+            warnings.warn(
+                f"{len(failed)}/{len(varlist)} variables failed insight computation: "
+                f"{failed[:10]}{'...' if len(failed) > 10 else ''} — see smf_logger for details",
+                UserWarning,
+                stacklevel=2,
+            )
+
+        output_cols = [
+            'var', 'n_all', 'n', 'ks_in_gains', 'lift_in_gains', 'iv',
+            'n_bump', 'missing_rate', 'min', 'mean', 'max', 'n_bins'
+        ]
+        if not iv_info_res:
+            return pd.DataFrame(columns=output_cols)
+
         iv_info_res = pd.concat(iv_info_res).sort_values("IV", ascending=False)
 
         high_iv_summary = iv_info_res.query(f"IV >= {iv_cut}").round(4)
@@ -222,10 +244,7 @@ class VarExtractionInsights:
             how='left'
         )
         fnl_summary.columns = [x.lower() for x in fnl_summary.columns]
-        fnl_summary = fnl_summary[[
-            'var', 'n_all', 'n', 'ks_in_gains', 'lift_in_gains', 'iv',
-            'n_bump', 'missing_rate', 'min', 'mean', 'max', 'n_bins'
-        ]]
+        fnl_summary = fnl_summary[output_cols]
 
         return fnl_summary
 

{supermodelingfactory-0.5.0 → supermodelingfactory-0.5.2}/Modeling_Tool/Feature/Feature_Screen.py

@@ -10,6 +10,7 @@ import numpy as np
 import pandas as pd
 
 from Modeling_Tool.Core.sample_weight_utils import resolve_sample_weight
+from Modeling_Tool._utils.sentinels import SMF_MISSING_BIN
 
 from .Weighted_Screen import (
     WeightedScreenResult,
@@ -163,7 +164,7 @@ def fit_screening_woe_engine(
 
     master_params = dict(woe_params or {})
     woe_suffix = master_params.pop("woe_suffix", "_woe")
-    missing_ref_value = master_params.pop("missing_ref_value", -999999)
+    missing_ref_value = master_params.pop("missing_ref_value", SMF_MISSING_BIN)
     master = WOE_Master(
         train_data=fit_ins,
         varlist=features,
@@ -224,7 +225,7 @@ def _woe_bins_unweighted_screen(
         missing_rate_ref=config.missing_rate_ref,
         on_empty_stage=config.on_empty_stage,
     )
-    binner = _resolve_screening_binner(splits, feature_cols, target_col, config, prefit_woe_engine)
+    binner = _resolve_screening_binner(splits, current, target_col, config, prefit_woe_engine)
 
     psi_table = pd.DataFrame(columns=["var", "psi_ins_oos", "psi_ins_oot", "psi_max"])
     if config.psi_enabled:
@@ -357,7 +358,7 @@ def _weighted_woe_bins_screen(
     if binner is None:
         binner = fit_screening_woe_engine(
             ins,
-            feature_cols,
+            current,
             target_col,
             woe_engine=config.woe_engine,
             woe_fit_query=config.woe_fit_query,
@@ -369,7 +370,7 @@ def _weighted_woe_bins_screen(
 
     psi_records: list[dict] = []
     if config.psi_enabled:
-        for var in feature_cols:
+        for var in current:
             if var not in ins.columns or ins[var].nunique(dropna=False) <= 1:
                 continue
             bins_ins = _bins_to_numpy(adapter.assign_bins(ins, var))
@@ -583,4 +584,4 @@ __all__ = [
     "feature_screen_from_dataframe",
     "fit_screening_woe_engine",
     "screen_config_from_mapping",
-]
+]

{supermodelingfactory-0.5.0 → supermodelingfactory-0.5.2}/Modeling_Tool/Feature/PSI_Tool.py

@@ -20,6 +20,58 @@ from Modeling_Tool.Core.Binning_Tool import quick_binning
 # ``Feature.Weighted_Screen`` and ``WOE_Adapter`` so downstream aggregators can
 # recognise it without special-casing.
 _MISSING_BIN = "__MISSING__"
+_PSI_BUCKET_POLICIES = {"floor_1e6", "smooth_laplace", "exclude"}
+
+
+def _validate_psi_bucket_policy(policy: str, caller: str) -> None:
+    if policy not in _PSI_BUCKET_POLICIES:
+        raise ValueError(
+            f"{caller}: psi_missing_bucket_policy must be one of "
+            f"{sorted(_PSI_BUCKET_POLICIES)}; got {policy!r}."
+        )
+
+
+def _psi_distributions_from_counts(
+    expected_count: pd.Series,
+    actual_count: pd.Series,
+    expected_total: float,
+    actual_total: float,
+    *,
+    content: float,
+    policy: str,
+) -> tuple[pd.Series, pd.Series, pd.Series, pd.Series]:
+    _validate_psi_bucket_policy(policy, "_psi_distributions_from_counts")
+    all_bins = expected_count.index.union(actual_count.index)
+    expected_aligned = expected_count.reindex(all_bins, fill_value=0).astype(float)
+    actual_aligned = actual_count.reindex(all_bins, fill_value=0).astype(float)
+    one_sided = (expected_aligned == 0) | (actual_aligned == 0)
+
+    expected_total = float(expected_total) if expected_total > 0 else 1.0
+    actual_total = float(actual_total) if actual_total > 0 else 1.0
+
+    if policy == "exclude":
+        keep = ~one_sided
+        expected_aligned = expected_aligned[keep]
+        actual_aligned = actual_aligned[keep]
+        if expected_aligned.empty:
+            empty = pd.Series(dtype=float)
+            return empty, empty, empty, empty
+        expected_pct = expected_aligned / expected_total
+        actual_pct = actual_aligned / actual_total
+    elif policy == "smooth_laplace" and bool(one_sided.any()):
+        n_buckets = max(len(all_bins), 1)
+        expected_pct = (expected_aligned + 1.0) / (expected_total + n_buckets)
+        actual_pct = (actual_aligned + 1.0) / (actual_total + n_buckets)
+    else:
+        expected_pct = (expected_aligned / expected_total).clip(lower=content)
+        actual_pct = (actual_aligned / actual_total).clip(lower=content)
+
+    psi_values = (actual_pct - expected_pct) * np.log(actual_pct / expected_pct)
+
+    floor_expected = (expected_aligned / expected_total).clip(lower=content)
+    floor_actual = (actual_aligned / actual_total).clip(lower=content)
+    floor_values = (floor_actual - floor_expected) * np.log(floor_actual / floor_expected)
+    return expected_pct, actual_pct, psi_values, floor_values
 
 # ============================================================================
 # Classes
@@ -59,7 +111,8 @@ class PSICalculator:
         min_bin_prop: float = 0.05,
         content: float = 1e-6,
         precision: int = 5,
-        missing_policy: str = "include"
+        missing_policy: str = "include",
+        psi_missing_bucket_policy: str = "smooth_laplace",
     ):
         """
         Initialize PSICalculator with configuration parameters.
@@ -90,12 +143,14 @@ class PSICalculator:
                 f"PSICalculator.__init__: missing_policy must be one of "
                 f"'include', 'drop', 'warn_and_drop'; got {missing_policy!r}."
             )
+        _validate_psi_bucket_policy(psi_missing_bucket_policy, "PSICalculator.__init__")
         self.buckets = buckets
         self.equal_freq = equal_freq
         self.min_bin_prop = min_bin_prop
         self.content = content
         self.precision = precision
         self.missing_policy = missing_policy
+        self.psi_missing_bucket_policy = psi_missing_bucket_policy
     
 #     def _calculate_single_psi(
 #         self,
@@ -434,7 +489,8 @@ class PSICalculator:
         group_by: Optional[str] = None,
         group_name: Optional[str] = None,
         return_details = False,
-        missing_policy: Optional[str] = None
+        missing_policy: Optional[str] = None,
+        psi_missing_bucket_policy: Optional[str] = None,
     ) -> pd.DataFrame:
         """
         Calculate grouped PSI comparing two datasets, using expected as benchmark.
@@ -463,6 +519,11 @@ class PSICalculator:
             Grouped PSI results.
         """
         effective_policy = missing_policy if missing_policy is not None else self.missing_policy
+        effective_bucket_policy = (
+            psi_missing_bucket_policy
+            if psi_missing_bucket_policy is not None
+            else self.psi_missing_bucket_policy
+        )
         return calculate_multigroup_psi_two_sets(
             expected_df = expected_df,
             actual_df = current_data,
@@ -475,7 +536,8 @@ class PSICalculator:
             precision = self.precision,
             group_name = group_name,
             return_details = return_details,
-            missing_policy = effective_policy
+            missing_policy = effective_policy,
+            psi_missing_bucket_policy = effective_bucket_policy,
         )
 
 
@@ -493,6 +555,7 @@ def _calculate_single_psi(
     content: float = 1e-6,
     precision: int = 5,
     missing_policy: str = "include",
+    psi_missing_bucket_policy: str = "smooth_laplace",
 ) -> Union[float, Tuple[float, pd.DataFrame]]:
     """
     Calculate Population Stability Index (PSI) for a single variable.
@@ -559,6 +622,7 @@ def _calculate_single_psi(
             f"_calculate_single_psi: missing_policy must be one of "
             f"'include', 'drop', 'warn_and_drop'; got {missing_policy!r}."
         )
+    _validate_psi_bucket_policy(psi_missing_bucket_policy, "_calculate_single_psi")
 
     # Record NaN counts before splitting so we can (a) re-attach the missing
     # bin under "include" and (b) warn under "warn_and_drop".
@@ -631,25 +695,24 @@ def _calculate_single_psi(
             )
         expected_denom = float(n_expected) if n_expected > 0 else 1.0
         actual_denom = float(n_actual) if n_actual > 0 else 1.0
-        expected_percents = expected_count / expected_denom
-        actual_percents = actual_count / actual_denom
     else:
         # "drop" / "warn_and_drop": legacy behaviour, denominators are the
         # NaN-dropped row counts, so missing-rate drift is invisible.
-        expected_percents = expected_bins.value_counts(normalize=True, sort=False)
-        actual_percents = actual_bins.value_counts(normalize=True, sort=False)
-    
-    # Ensure both series have the same bin indices
-    all_bins = expected_percents.index.union(actual_percents.index)
-    expected_percents = expected_percents.reindex(all_bins, fill_value=content)
-    actual_percents = actual_percents.reindex(all_bins, fill_value=content)
-    
-    # Clip to avoid division by zero
-    expected_percents = expected_percents.clip(lower=content)
-    actual_percents = actual_percents.clip(lower=content)
-    
-    # Calculate PSI
-    psi_values = (actual_percents - expected_percents) * np.log(actual_percents / expected_percents)
+        expected_denom = float(len(expected_bins)) if len(expected_bins) > 0 else 1.0
+        actual_denom = float(len(actual_bins)) if len(actual_bins) > 0 else 1.0
+
+    all_bins = expected_count.index.union(actual_count.index)
+    expected_count = expected_count.reindex(all_bins, fill_value=0).astype(float)
+    actual_count = actual_count.reindex(all_bins, fill_value=0).astype(float)
+
+    expected_percents, actual_percents, psi_values, psi_floor_values = _psi_distributions_from_counts(
+        expected_count,
+        actual_count,
+        expected_denom,
+        actual_denom,
+        content=content,
+        policy=psi_missing_bucket_policy,
+    )
     psi_total = psi_values.sum()
     
     if return_details:
@@ -658,8 +721,13 @@ def _calculate_single_psi(
             'actual_count': actual_count,
             'expected_percent': expected_percents,
             'actual_percent': actual_percents,
-            'psi_component': psi_values
+            'psi_component': psi_values,
+            'psi_component_floor_1e6': psi_floor_values,
         })
+        details["bucket_status"] = "common"
+        details.loc[(details["expected_count"] == 0) & (details["actual_count"] > 0), "bucket_status"] = "actual_only"
+        details.loc[(details["expected_count"] > 0) & (details["actual_count"] == 0), "bucket_status"] = "expected_only"
+        details["psi_missing_bucket_policy"] = psi_missing_bucket_policy
         return psi_total, details
     else:
         return psi_total
@@ -676,7 +744,8 @@ def calculate_psi(
     min_bin_prop: float = 0.05,
     content: float = 1e-6,
     precision: int = 5,
-    missing_policy: str = "include"
+    missing_policy: str = "include",
+    psi_missing_bucket_policy: str = "smooth_laplace",
 ) -> Union[float, pd.DataFrame, Tuple[Dict, Dict]]:
     """
     Calculate Population Stability Index (PSI) for a variable, optionally by groups.
@@ -767,7 +836,8 @@ def calculate_psi(
                     min_bin_prop,
                     content,
                     precision,
-                    missing_policy
+                    missing_policy,
+                    psi_missing_bucket_policy,
                 )
                 results[group] = psi_value
                 details_dict[group] = detail
@@ -781,7 +851,8 @@ def calculate_psi(
                     min_bin_prop,
                     content,
                     precision,
-                    missing_policy
+                    missing_policy,
+                    psi_missing_bucket_policy,
                 )
         
         if return_details:
@@ -800,7 +871,8 @@ def calculate_psi(
                 min_bin_prop, 
                 content, 
                 precision,
-                missing_policy
+                missing_policy,
+                psi_missing_bucket_policy,
             )
         else:
             return _calculate_single_psi(
@@ -812,7 +884,8 @@ def calculate_psi(
                 min_bin_prop, 
                 content, 
                 precision,
-                missing_policy
+                missing_policy,
+                psi_missing_bucket_policy,
             )
 
 
@@ -828,7 +901,8 @@ def calculate_within_psi(
     content: float = 1e-6,
     precision: int = 5,
     benchmark_display_name: Optional[str] = None,
-    missing_policy: str = "include"
+    missing_policy: str = "include",
+    psi_missing_bucket_policy: str = "smooth_laplace",
 ) -> Union[pd.DataFrame, Dict]:
     """
     Calculate PSI values within a single dataset, comparing groups to a benchmark.
@@ -904,7 +978,8 @@ def calculate_within_psi(
                 min_bin_prop=min_bin_prop, 
                 content=content, 
                 precision=precision,
-                missing_policy=missing_policy
+                missing_policy=missing_policy,
+                psi_missing_bucket_policy=psi_missing_bucket_policy,
             )
             res_dict[obs_value] = psi
             detail_dict[obs_value] = details
@@ -919,7 +994,8 @@ def calculate_within_psi(
                 min_bin_prop=min_bin_prop, 
                 content=content, 
                 precision=precision,
-                missing_policy=missing_policy
+                missing_policy=missing_policy,
+                psi_missing_bucket_policy=psi_missing_bucket_policy,
             )
             res_dict[obs_value] = psi
     
@@ -943,7 +1019,8 @@ def calculate_psi_within_dataset(
     min_bin_prop: float = 0.05,
     content: float = 1e-6,
     precision: int = 5,
-    missing_policy: str = "include"
+    missing_policy: str = "include",
+    psi_missing_bucket_policy: str = "smooth_laplace",
 ) -> pd.DataFrame:
     """
     Calculate PSI for multiple variables within a dataset, comparing groups to a benchmark.
@@ -1003,7 +1080,8 @@ def calculate_psi_within_dataset(
             min_bin_prop=min_bin_prop, 
             content=content, 
             precision=precision,
-            missing_policy=missing_policy
+            missing_policy=missing_policy,
+            psi_missing_bucket_policy=psi_missing_bucket_policy,
         ).sort_values([grp_name]).reset_index(drop=True)
         
         single_psi['var'] = var
@@ -1022,7 +1100,8 @@ def calculate_multivar_psi_two_sets(
     min_bin_prop: float = 0.05,
     content: float = 1e-6,
     precision: int = 5,
-    missing_policy: str = "include"
+    missing_policy: str = "include",
+    psi_missing_bucket_policy: str = "smooth_laplace",
 ) -> pd.DataFrame:
     """
     Calculate PSI for multiple variables by comparing two different datasets.
@@ -1077,8 +1156,13 @@ def calculate_multivar_psi_two_sets(
             target_col=var, 
             group_by=group_by, 
             buckets=buckets,
+            equal_freq=equal_freq,
+            min_bin_prop=min_bin_prop,
+            content=content,
+            precision=precision,
             return_details=False,
-            missing_policy=missing_policy
+            missing_policy=missing_policy,
+            psi_missing_bucket_policy=psi_missing_bucket_policy,
         )
         if group_by is None:
             single_psi = pd.DataFrame([single_psi], columns=['psi'])
@@ -1219,7 +1303,8 @@ def calculate_multigroup_psi_two_sets(
     precision: int = 5,
     group_name: Optional[str] = None,
     return_details: bool = False,
-    missing_policy: str = "include"
+    missing_policy: str = "include",
+    psi_missing_bucket_policy: str = "smooth_laplace",
 ) -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]:
     """
     Calculate grouped PSI using expected DataFrame as benchmark, applied to actual DataFrame groups.
@@ -1278,7 +1363,8 @@ def calculate_multigroup_psi_two_sets(
                         min_bin_prop=min_bin_prop,
                         content=content,
                         precision=precision,
-                        missing_policy=missing_policy
+                        missing_policy=missing_policy,
+                        psi_missing_bucket_policy=psi_missing_bucket_policy,
                     )
                     
                     psi_records.append({group_name: group, 'var': var, 'psi': psi_val})
@@ -1296,7 +1382,7 @@ def calculate_multigroup_psi_two_sets(
                         detail_df[group_name] = group
                         detail_df['var'] = var
                         
-                        required_cols = ['bin', 'expected_count', 'actual_count', 'expected_percent', 'actual_percent', 'psi_component', group_name, 'var']
+                        required_cols = ['bin', 'expected_count', 'actual_count', 'expected_percent', 'actual_percent', 'psi_component', 'bucket_status', 'psi_missing_bucket_policy', group_name, 'var']
                         for col in required_cols:
                             if col not in detail_df.columns:
                                 detail_df[col] = np.nan
@@ -1326,7 +1412,8 @@ def calculate_multigroup_psi_two_sets(
                     min_bin_prop=min_bin_prop,
                     content=content,
                     precision=precision,
-                    missing_policy=missing_policy
+                    missing_policy=missing_policy,
+                    psi_missing_bucket_policy=psi_missing_bucket_policy,
                 )
                 psi_records.append({'var': var, 'psi': psi_val})
                 
@@ -1338,7 +1425,7 @@ def calculate_multigroup_psi_two_sets(
                         index_col = detail_df.columns[0]
                         detail_df = detail_df.rename(columns={index_col: 'bin'})
                     detail_df['var'] = var
-                    required_cols = ['bin', 'expected_count', 'actual_count', 'expected_percent', 'actual_percent', 'psi_component', 'var']
+                    required_cols = ['bin', 'expected_count', 'actual_count', 'expected_percent', 'actual_percent', 'psi_component', 'bucket_status', 'psi_missing_bucket_policy', 'var']
                     for col in required_cols:
                         if col not in detail_df.columns:
                             detail_df[col] = np.nan
@@ -1362,7 +1449,8 @@ def calculate_multigroup_psi_two_sets(
                 min_bin_prop=min_bin_prop, 
                 content=content, 
                 precision=precision,
-                missing_policy=missing_policy
+                missing_policy=missing_policy,
+                psi_missing_bucket_policy=psi_missing_bucket_policy,
             )
             
             return group_psi

{supermodelingfactory-0.5.0 → supermodelingfactory-0.5.2}/Modeling_Tool/Feature/PSI_Tool.pyi

@@ -20,10 +20,10 @@ from tqdm import tqdm
 from Modeling_Tool.Core.Binning_Tool import quick_binning
 
 class PSICalculator:
-    def __init__(self, buckets: int = 10, equal_freq: bool = True, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, binning_engine: Any = None): ...
-    def calculate(self, expected_df: pd.DataFrame, current_data: pd.DataFrame, varlist: List[str], group_by: Optional[str] = None, group_name: Optional[str] = None, return_details = False) -> pd.DataFrame: ...
-def calculate_psi(expected: Union[pd.DataFrame, pd.Series], actual: Union[pd.DataFrame, pd.Series], target_col: str, buckets: int = 10, equal_freq: bool = True, group_by: Optional[Union[str, List[str]]] = None, return_details: bool = False, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5) -> Union[float, pd.DataFrame, Tuple[Dict, Dict]]: ...
-def calculate_within_psi(data: pd.DataFrame, grp_name: str, target_col: str, benchmark: Optional[Any] = None, equal_freq: bool = True, buckets: int = 10, return_details: bool = False, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, benchmark_display_name: Optional[str] = None) -> Union[pd.DataFrame, Dict]: ...
-def calculate_psi_within_dataset(data: pd.DataFrame, grp_name: str, varlist: List[str], benchmark: Optional[Any] = None, equal_freq: bool = True, buckets: int = 10, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5) -> pd.DataFrame: ...
-def calculate_multivar_psi_two_sets(expected_df: pd.DataFrame, actual_df: pd.DataFrame, varlist: List[str], group_by: Optional[Union[str, List[str]]] = None, buckets: int = 10, equal_freq: bool = True, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5) -> pd.DataFrame: ...
-def calculate_multigroup_psi_two_sets(expected_df: pd.DataFrame, actual_df: pd.DataFrame, varlist: List[str], group_by: Optional[Union[str, List[str]]] = None, buckets: int = 10, equal_freq: bool = True, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, group_name: Optional[str] = None, return_details: bool = False) -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]: ...
+    def __init__(self, buckets: int = 10, equal_freq: bool = True, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, missing_policy: str = "include", psi_missing_bucket_policy: str = "smooth_laplace", binning_engine: Any = None): ...
+    def calculate(self, expected_df: pd.DataFrame, current_data: pd.DataFrame, varlist: List[str], group_by: Optional[str] = None, group_name: Optional[str] = None, return_details = False, missing_policy: Optional[str] = None, psi_missing_bucket_policy: Optional[str] = None) -> pd.DataFrame: ...
+def calculate_psi(expected: Union[pd.DataFrame, pd.Series], actual: Union[pd.DataFrame, pd.Series], target_col: str, buckets: int = 10, equal_freq: bool = True, group_by: Optional[Union[str, List[str]]] = None, return_details: bool = False, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, missing_policy: str = "include", psi_missing_bucket_policy: str = "smooth_laplace") -> Union[float, pd.DataFrame, Tuple[Dict, Dict]]: ...
+def calculate_within_psi(data: pd.DataFrame, grp_name: str, target_col: str, benchmark: Optional[Any] = None, equal_freq: bool = True, buckets: int = 10, return_details: bool = False, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, benchmark_display_name: Optional[str] = None, missing_policy: str = "include", psi_missing_bucket_policy: str = "smooth_laplace") -> Union[pd.DataFrame, Dict]: ...
+def calculate_psi_within_dataset(data: pd.DataFrame, grp_name: str, varlist: List[str], benchmark: Optional[Any] = None, equal_freq: bool = True, buckets: int = 10, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, missing_policy: str = "include", psi_missing_bucket_policy: str = "smooth_laplace") -> pd.DataFrame: ...
+def calculate_multivar_psi_two_sets(expected_df: pd.DataFrame, actual_df: pd.DataFrame, varlist: List[str], group_by: Optional[Union[str, List[str]]] = None, buckets: int = 10, equal_freq: bool = True, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, missing_policy: str = "include", psi_missing_bucket_policy: str = "smooth_laplace") -> pd.DataFrame: ...
+def calculate_multigroup_psi_two_sets(expected_df: pd.DataFrame, actual_df: pd.DataFrame, varlist: List[str], group_by: Optional[Union[str, List[str]]] = None, buckets: int = 10, equal_freq: bool = True, min_bin_prop: float = 0.05, content: float = 1e-06, precision: int = 5, group_name: Optional[str] = None, return_details: bool = False, missing_policy: str = "include", psi_missing_bucket_policy: str = "smooth_laplace") -> Union[pd.DataFrame, Dict[str, pd.DataFrame]]: ...