tanml 0.1.6__py3-none-any.whl

tanml/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

tanml/check_runners/base_runner.py

@@ -0,0 +1,6 @@
+class BaseCheckRunner:
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def run(self, *args, **kwargs):
+        raise NotImplementedError("Each check runner must implement its own run method.")

tanml/check_runners/cleaning_repro_runner.py

@@ -0,0 +1,18 @@
+# tanml/check_runners/cleaning_repro_runner.py
+from tanml.checks.cleaning_repro import CleaningReproCheck
+
+def run_cleaning_repro_check(model, X_train, X_test, y_train, y_test,
+                             config, cleaned_data, *args, **kwargs):
+    # honour rules.yaml toggle
+    if not config.get("rules", {}).get("CleaningReproCheck", {}).get("enabled", True):
+        print("ℹ️ CleaningReproCheck skipped (disabled in rules.yaml)")
+        return None
+
+    # raw_df can come from rules.yaml *or* via kwargs (passed by ValidationEngine)
+    raw_data = config.get("raw_data") or kwargs.get("raw_df")
+    if raw_data is None:
+        print("⚠️ Skipping CleaningReproCheck — raw_data missing in config and kwargs")
+        return {"CleaningReproCheck": {"error": "raw_data not available"}}
+
+    check = CleaningReproCheck(raw_data, cleaned_data)
+    return {"CleaningReproCheck": check.run()}

tanml/check_runners/correlation_runner.py

@@ -0,0 +1,15 @@
+from tanml.checks.correlation import CorrelationCheck
+
+def CorrelationCheckRunner(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+    try:
+        cfg = rule_config.get("CorrelationCheck", {})
+        if not cfg.get("enabled", True):
+            print("ℹ️ CorrelationCheck skipped (disabled in rules.yaml)")
+            return None
+
+        check = CorrelationCheck(cleaned_df)
+        return check.run()
+
+    except Exception as e:
+        print(f"⚠️ CorrelationCheck failed: {e}")
+        return {"CorrelationCheck": {"error": str(e)}}

tanml/check_runners/data_quality_runner.py

@@ -0,0 +1,24 @@
+from tanml.checks.data_quality import DataQualityCheck
+
+def run_data_quality_check(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+    dq_cfg = rule_config.get("DataQualityCheck", {})
+    if not dq_cfg.get("enabled", True):
+        print("ℹ️ Skipping DataQualityCheck (disabled in rules.yaml)")
+        return {"DataQualityCheck": {"skipped": True}}
+
+    try:
+        check = DataQualityCheck(
+            model=model,
+            X_train=X_train,
+            X_test=X_test,
+            y_train=y_train,
+            y_test=y_test,
+            rule_config=dq_cfg,
+            cleaned_data=cleaned_df
+        )
+        result = check.run()
+        return {"DataQualityCheck": result}
+
+    except Exception as e:
+        print(f"⚠️ DataQualityCheck failed: {e}")
+        return {"DataQualityCheck": {"error": str(e)}}

tanml/check_runners/eda_runner.py

@@ -0,0 +1,21 @@
+from tanml.checks.eda import EDACheck
+
+def EDACheckRunner(
+    model, X_train, X_test, y_train, y_test,
+    rule_config, cleaned_df, *args, **kwargs
+):
+    try:
+        cfg = rule_config.get("EDACheck", {})
+        if not cfg.get("enabled", True):
+            print("ℹ️ EDACheck skipped (disabled in rules.yaml)")
+            return None
+
+        check = EDACheck(
+            cleaned_data=cleaned_df,
+            rule_config=rule_config  
+        )
+        return check.run()
+
+    except Exception as e:
+        print(f"⚠️ EDACheck failed: {e}")
+        return {"EDACheck": {"error": str(e)}}

tanml/check_runners/explainability_runner.py

@@ -0,0 +1,28 @@
+# tanml/check_runners/explainability_runner.py
+
+from tanml.checks.explainability.shap_check import SHAPCheck
+
+def run_shap_check(
+    model, X_train, X_test, y_train, y_test,
+    rule_config, cleaned_df, *args, **kwargs
+):
+    try:
+        cfg = rule_config.get("SHAPCheck", {})
+        if not cfg.get("enabled", True):
+            print("ℹ️ SHAPCheck skipped (disabled in rules.yaml)")
+            return None
+
+        check = SHAPCheck(
+            model=model,
+            X_train=X_train,
+            X_test=X_test,
+            y_train=y_train,
+            y_test=y_test,
+            rule_config=rule_config,
+            cleaned_df=cleaned_df,
+        )
+        return check.run()
+
+    except Exception as e:
+        print(f"⚠️ SHAPCheck failed: {e}")
+        return {"SHAPCheck": {"error": str(e)}}

tanml/check_runners/input_cluster_runner.py

@@ -0,0 +1,43 @@
+
+# -----------------------------------------------------------------------------
+# File: tanml/check_runners/input_cluster_runner.py
+# -----------------------------------------------------------------------------
+from pathlib import Path
+from typing import Any, Dict
+
+from tanml.checks.input_cluster import InputClusterCoverageCheck
+
+
+def run_input_cluster_check(
+    model,
+    X_train,
+    X_test,
+    y_train,
+    y_test,
+    rule_config,
+    cleaned_df,
+    expected_features,
+    *args,
+    **kwargs,
+):
+
+    cfg = rule_config.get("InputClusterCoverageCheck", {})
+    if not cfg.get("enabled", False):
+        print("ℹ️  InputClusterCoverageCheck skipped (disabled in rules.yaml)")
+        return {"skipped": True}
+
+    try:
+        result = InputClusterCoverageCheck(
+            cleaned_df=cleaned_df,
+            feature_names=expected_features,
+            rule_config=rule_config,
+        ).run()
+        return result
+
+    except Exception as e:
+        print(f"⚠️  InputClusterCoverageCheck failed: {e}")
+        return {"error": str(e)}
+
+    except Exception as e:  
+        print(f"⚠️  InputClusterCoverageCheck failed: {e}")
+        return {"InputClusterCheck": {"error": str(e)}}

tanml/check_runners/logistic_stats_runner.py

@@ -0,0 +1,28 @@
+from tanml.checks.logit_stats import LogisticStatsCheck
+from sklearn.linear_model import LogisticRegression
+
+def run_logistic_stats_check(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+    try:
+        # Check if model is a LogisticRegression or statsmodels object
+        is_logistic = isinstance(model, LogisticRegression) or (
+            hasattr(model, "llf") and hasattr(model, "params") and hasattr(model, "summary")
+        )
+
+        if not is_logistic:
+            print("ℹ️ LogisticStatsCheck skipped — model is not logistic or not recognized")
+            return None
+
+        # Use training data only for fitting stats
+        check = LogisticStatsCheck(model, X_train, y_train, rule_config)
+        output = check.run()
+
+        return {
+            "LogisticStatsCheck": output["table"],
+            "LogisticStatsFit": output["fit"],
+            "LogisticStatsSummary": output["summary"],
+            "LogisticStatsCheck_obj": output["object"]
+        }
+
+    except Exception as e:
+        print(f"⚠️ LogisticStatsCheck failed: {e}")
+        return {"LogisticStatsCheck": {"error": str(e)}}

tanml/check_runners/model_meta_runner.py

@@ -0,0 +1,23 @@
+from tanml.checks.model_meta import ModelMetaCheck
+
+def ModelMetaCheckRunner(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+    try:
+        cfg = rule_config.get("ModelMetaCheck", {})
+        if not cfg.get("enabled", True):
+            print("ℹ️ ModelMetaCheck skipped (disabled in rules.yaml)")
+            return None
+
+        check = ModelMetaCheck(
+            model=model,
+            X_train=X_train,
+            X_test=X_test,
+            y_train=y_train,
+            y_test=y_test,
+            rule_config=rule_config,
+            cleaned_data=cleaned_df
+        )
+        return check.run()
+
+    except Exception as e:
+        print(f"⚠️ ModelMetaCheck failed: {e}")
+        return {"ModelMetaCheck": {"error": str(e)}}

tanml/check_runners/performance_runner.py

@@ -0,0 +1,28 @@
+from tanml.checks.performance import PerformanceCheck
+
+def run_performance_check(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+    perf_cfg = rule_config.get("PerformanceCheck", {})
+    if not perf_cfg.get("enabled", True):
+        print("ℹ️ Skipping PerformanceCheck (disabled in rules.yaml)")
+        return {"PerformanceCheck": {"skipped": True}}
+
+    if X_test is None or y_test is None or len(X_test) == 0 or len(y_test) == 0:
+        print("⚠️ Skipping PerformanceCheck due to empty test data.")
+        return {"PerformanceCheck": {"error": "Test data is empty :skipping performance evaluation."}}
+
+    try:
+        check = PerformanceCheck(
+            model=model,
+            X_train=X_train,
+            X_test=X_test,
+            y_train=y_train,
+            y_test=y_test,
+            rule_config=perf_cfg,
+            cleaned_data=cleaned_df
+        )
+        result = check.run()
+        return {"PerformanceCheck": result}
+
+    except Exception as e:
+        print(f"⚠️ PerformanceCheck failed: {e}")
+        return {"PerformanceCheck": {"error": str(e)}}

tanml/check_runners/raw_data_runner.py

@@ -0,0 +1,41 @@
+from tanml.checks.raw_data import RawDataCheck
+import pandas as pd
+
+def run_raw_data_check(model, X_train, X_test, y_train, y_test,
+                       rule_config, cleaned_data, *args, **kwargs):
+    try:
+        # ---- locate raw data (DF or path) -------------
+        raw_obj = (
+            rule_config.get("raw_data") or
+            rule_config.get("paths", {}).get("raw_data")
+        )
+        if raw_obj is None:
+            print("ℹ️ RawDataCheck skipped — raw_data not provided in config.")
+            return None
+
+        # CSV path → load once
+        if isinstance(raw_obj, (str, bytes)):
+            raw_obj = pd.read_csv(raw_obj)
+
+        if not isinstance(raw_obj, pd.DataFrame):
+            print("ℹ️ RawDataCheck skipped — raw_data is not a DataFrame.")
+            return None
+
+        # ---- run the check -----------------------------
+        check = RawDataCheck(
+            model=model,
+            X_train=X_train,
+            X_test=X_test,
+            y_train=y_train,
+            y_test=y_test,
+            rule_config=rule_config,
+            cleaned_data=cleaned_data,
+            raw_data=raw_obj
+        )
+
+        stats = check.run()           
+        return stats["RawDataCheck"]   # hand the inner dict to ValidationEngine
+
+    except Exception as e:
+        print(f"⚠️ RawDataCheck failed: {e}")
+        return {"error": str(e)}

tanml/check_runners/rule_engine_runner.py

@@ -0,0 +1,5 @@
+from tanml.checks.rule_engine import RuleEngineCheck
+
+def RuleEngineCheckRunner(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+    check = RuleEngineCheck(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df)
+    return check.run()

tanml/check_runners/stress_test_runner.py

@@ -0,0 +1,26 @@
+from tanml.checks.stress_test import StressTestCheck
+
+def run_stress_test_check(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df, *args, **kwargs):
+    cfg = rule_config.get("StressTestCheck", {})
+    if not cfg.get("enabled", True):
+        print("ℹ️ Skipping StressTestCheck (disabled in rules.yaml)")
+        return {"StressTestCheck": {"skipped": True}}
+
+    try:
+        epsilon = cfg.get("epsilon", 0.01)
+        perturb_fraction = cfg.get("perturb_fraction", 0.2)
+
+        checker = StressTestCheck(model, X_test, y_test, epsilon, perturb_fraction)
+        result = checker.run()
+
+        # Ensure output is always a dictionary
+        if isinstance(result, list):
+            return {"StressTestCheck": {"table": result}}
+        elif hasattr(result, "to_dict"):
+            return {"StressTestCheck": {"table": result.to_dict(orient="records")}}
+        else:
+            return {"StressTestCheck": {"output": result}}
+
+    except Exception as e:
+        print(f"⚠️ StressTestCheck failed: {e}")
+        return {"StressTestCheck": {"error": str(e)}}

tanml/check_runners/vif_runner.py

@@ -0,0 +1,54 @@
+# tanml/check_runners/vif_runner.py
+
+from tanml.checks.vif import VIFCheck
+import pandas as pd
+from pathlib import Path
+
+def VIFCheckRunner(
+    model, X_train, X_test, y_train, y_test,
+    rule_config, cleaned_df, *args, **kwargs
+):
+    # Ensure cleaned_df is a DataFrame
+    if isinstance(cleaned_df, (str, Path)):
+        try:
+            cleaned_df = pd.read_csv(cleaned_df)
+        except Exception as e:
+            err = f"Could not read cleaned_df CSV: {e}"
+            print(f"⚠️ {err}")
+            return {"vif_table": [], "high_vif_features": [], "error": err}
+
+    try:
+        check = VIFCheck(model, X_train, X_test, y_train, y_test, rule_config, cleaned_df)
+        result = check.run()  # Could be dict or list
+
+        # Normalize result regardless of format
+        if isinstance(result, dict) and "vif_table" in result:
+            vif_rows = result["vif_table"]
+        elif isinstance(result, list):
+            vif_rows = result
+        else:
+            raise ValueError("Unexpected VIFCheck return shape")
+
+        # Rename 'feature' to 'Feature', round VIF values
+        for row in vif_rows:
+            if "Feature" not in row and "feature" in row:
+                row["Feature"] = row.pop("feature")
+            row["VIF"] = round(float(row["VIF"]), 2)
+
+        # Identify high VIF features
+        threshold = rule_config.get("vif_threshold", 5)
+        high_vif = [
+            row["Feature"] for row in vif_rows
+            if row.get("VIF") is not None and row["VIF"] > threshold
+        ]
+
+        # Return final output
+        return {
+            "vif_table": vif_rows,
+            "high_vif_features": high_vif,
+            "error": None,
+        }
+
+    except Exception as e:
+        print(f"⚠️ VIFCheck failed: {e}")
+        return {"vif_table": [], "high_vif_features": [], "error": str(e)}

tanml/checks/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+
+class BaseCheck(ABC):
+    def __init__(self, model, X_train, X_test, y_train, y_test, rule_config, cleaned_data):
+        self.model = model
+        self.X_train = X_train
+        self.X_test = X_test
+        self.y_train = y_train
+        self.y_test = y_test
+        self.rule_config = rule_config
+        self.cleaned_data = cleaned_data
+
+
+
+    @abstractmethod
+    def run(self):
+        """
+        This method must be implemented by every check.
+        It should return a dictionary of results.
+        """

tanml/checks/cleaning_repro.py

@@ -0,0 +1,47 @@
+import pandas as pd
+
+class CleaningReproCheck:
+    def __init__(self, raw_data, cleaned_data):
+        self.raw_data = raw_data
+        self.cleaned_data = cleaned_data
+
+    def run(self):
+        result = {}
+
+        try:
+            raw_df = self.raw_data
+            cleaned_df = self.cleaned_data
+
+            if not isinstance(raw_df, pd.DataFrame) or not isinstance(cleaned_df, pd.DataFrame):
+                raise ValueError("Missing or invalid raw_data / cleaned_data.")
+
+            validator_df = (
+                raw_df
+                .drop(columns=["constant_col"], errors="ignore")
+                .drop_duplicates()
+                .reset_index(drop=True)
+            )
+
+            result["dev_shape"]       = cleaned_df.shape
+            result["validator_shape"] = validator_df.shape
+            result["same_shape"]      = cleaned_df.shape == validator_df.shape
+
+            dev_cols = set(cleaned_df.columns)
+            val_cols = set(validator_df.columns)
+            result["extra_columns_in_dev"]   = sorted(list(dev_cols - val_cols))
+            result["missing_columns_in_dev"] = sorted(list(val_cols - dev_cols))
+
+            common = cleaned_df.columns.intersection(validator_df.columns)
+            if cleaned_df[common].shape == validator_df[common].shape:
+                mismatch_count = (
+                    cleaned_df[common].reset_index(drop=True) !=
+                    validator_df[common].reset_index(drop=True)
+                ).to_numpy().sum()
+                result["cell_mismatches"] = int(mismatch_count)
+            else:
+                result["cell_mismatches"] = "Column/shape mismatch — cannot compare"
+
+        except Exception as e:
+            result["error"] = str(e)
+
+        return result

tanml/checks/correlation.py

@@ -0,0 +1,61 @@
+from .base import BaseCheck
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+import os
+
+class CorrelationCheck(BaseCheck):
+    def __init__(self, cleaned_data: pd.DataFrame, output_dir: str = "reports/correlation"):
+        """
+        Computes Pearson and Spearman correlation matrices and saves them to disk,
+        along with a heatmap for visualization.
+        """
+        self.cleaned_data = cleaned_data
+        self.output_dir = output_dir
+        os.makedirs(self.output_dir, exist_ok=True)
+
+    def run(self):
+        # Select numeric features only
+        numeric_data = self.cleaned_data.select_dtypes(include="number")
+
+        if numeric_data.shape[1] < 2:
+            print("⚠️ Not enough numeric features for correlation.")
+            return {
+                "pearson_csv": None,
+                "spearman_csv": None,
+                "heatmap_path": None,
+                "error": "Not enough numeric features for correlation",
+            }
+
+        # Compute correlations
+        pearson_corr = numeric_data.corr(method="pearson")
+        spearman_corr = numeric_data.corr(method="spearman")
+
+        # Save CSVs
+        pearson_path = os.path.join(self.output_dir, "pearson_corr.csv")
+        spearman_path = os.path.join(self.output_dir, "spearman_corr.csv")
+        pearson_corr.to_csv(pearson_path)
+        spearman_corr.to_csv(spearman_path)
+
+        # Create heatmap
+        heatmap_path = os.path.join(self.output_dir, "heatmap.png")
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(
+            pearson_corr,
+            annot=True,
+            fmt=".2f",
+            cmap="coolwarm",
+            cbar_kws={"label": "Pearson Coefficient"},
+        )
+        plt.title("Pearson Correlation Heatmap")
+        plt.xticks(rotation=45, ha="right")
+        plt.yticks(rotation=0)
+        plt.tight_layout()
+        plt.savefig(heatmap_path)
+        plt.close()
+
+        return {
+            "pearson_csv": pearson_path,
+            "spearman_csv": spearman_path,
+            "heatmap_path": heatmap_path,
+        }

tanml/checks/data_quality.py

@@ -0,0 +1,26 @@
+from .base import BaseCheck
+import pandas as pd
+
+class DataQualityCheck(BaseCheck):
+    def __init__(self, model, X_train, X_test, y_train, y_test, rule_config, cleaned_data):
+        super().__init__(model, X_train, X_test, y_train, y_test, rule_config, cleaned_data)
+
+    def run(self):
+        df = self.cleaned_data
+        results = {}
+
+        if not isinstance(df, pd.DataFrame):
+            return {"error": "Cleaned data is not a valid DataFrame"}
+
+        # Missing value analysis
+        missing_ratio = df.isnull().mean()
+        results["avg_missing"] = round(missing_ratio.mean(), 4)
+        results["columns_with_missing"] = {
+            col: round(val, 4) for col, val in missing_ratio.items() if val > 0
+        }
+
+        # Constant columns (same value across all rows)
+        constant_cols = [col for col in df.columns if df[col].nunique(dropna=False) == 1]
+        results["constant_columns"] = constant_cols
+
+        return results

tanml/checks/eda.py

@@ -0,0 +1,67 @@
+from .base import BaseCheck
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+
+class EDACheck(BaseCheck):
+    def __init__(
+        self,
+        cleaned_data: pd.DataFrame,
+        rule_config: dict | None = None,
+        output_dir: str = "reports/eda",
+    ):
+        """
+        Basic Exploratory Data Analysis (EDA) check.
+
+        Generates summary statistics, missing values, and distribution plots.
+
+        Args:
+            cleaned_data (pd.DataFrame): Cleaned dataset to analyze.
+            rule_config (dict, optional): Rule configuration (YAML) to control plotting limits.
+            output_dir (str): Directory where EDA output files will be saved.
+        """
+        self.cleaned_data = cleaned_data
+        self.output_dir = output_dir
+        os.makedirs(self.output_dir, exist_ok=True)
+
+        # Max number of plots to generate (default = -1 = "all")
+        self.max_plots = (
+            rule_config.get("EDACheck", {}).get("max_plots", -1)
+            if rule_config is not None else -1
+        )
+
+    def run(self):
+        print(f"📊 DEBUG — max_plots from YAML = {self.max_plots}")
+
+        # 1. Generate summary stats and uniqueness/missing info
+        summary = self.cleaned_data.describe(include='all').T.fillna('')
+        missing = self.cleaned_data.isnull().mean().round(3)
+        n_unique = self.cleaned_data.nunique()
+
+        # 2. Save CSVs
+        summary_path = os.path.join(self.output_dir, "summary_stats.csv")
+        missing_path = os.path.join(self.output_dir, "missing_values.csv")
+        summary.to_csv(summary_path)
+        pd.DataFrame({
+            "missing_ratio": missing,
+            "n_unique": n_unique
+        }).to_csv(missing_path)
+
+        # 3. Create histograms for numeric columns
+        num_cols = self.cleaned_data.select_dtypes(include="number").columns
+        cols_to_plot = num_cols if self.max_plots in (-1, None) else num_cols[:self.max_plots]
+
+        for col in cols_to_plot:
+            plt.figure(figsize=(6, 4))
+            sns.histplot(self.cleaned_data[col], kde=True)
+            plt.title(f"Distribution of {col}")
+            plt.savefig(os.path.join(self.output_dir, f"dist_{col}.png"))
+            plt.close()
+
+        # 4. Return metadata
+        return {
+            "summary_stats":  summary_path,
+            "missing_values": missing_path,
+            "visualizations": [f"dist_{c}.png" for c in cols_to_plot],
+        }

tanml/checks/explainability/shap_check.py

@@ -0,0 +1,55 @@
+from tanml.checks.base import BaseCheck
+import shap
+import pandas as pd
+import matplotlib.pyplot as plt
+import traceback
+from pathlib import Path
+from datetime import datetime
+
+
+class SHAPCheck(BaseCheck):
+    def __init__(self, model, X_train, X_test, y_train, y_test, rule_config=None, cleaned_df=None):
+        super().__init__(model, X_train, X_test, y_train, y_test, rule_config, cleaned_data=cleaned_df)
+        self.cleaned_df = cleaned_df
+
+    def run(self):
+        result = {}
+
+        try:
+            expl_cfg = self.rule_config.get("explainability", {})
+            bg_n = expl_cfg.get("background_sample_size", 100)
+            test_n = expl_cfg.get("test_sample_size", 200)
+
+            X_sample = self.X_test[:test_n]
+            background = shap.utils.sample(self.X_train, bg_n, random_state=42)
+
+            X_sample = pd.DataFrame(X_sample)
+            background = pd.DataFrame(background)
+
+            explainer = shap.Explainer(self.model, background)
+            shap_exp = explainer(X_sample)
+
+            if shap_exp.values.ndim == 3:
+                shap_exp.values = shap_exp.values[:, :, 1]
+                shap_exp.base_values = shap_exp.base_values[:, 1]
+
+            segment = self.rule_config.get("meta", {}).get("segment", "global")
+            ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_path = Path(f"reports/images/shap_summary_{segment}_{ts}.png")
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            plt.figure(figsize=(8, 6))
+            shap.plots.beeswarm(shap_exp, show=False)
+            plt.savefig(output_path, bbox_inches="tight")
+            plt.close()
+
+            print(f"✅ SHAP plot saved at: {output_path}")
+            result["shap_plot_path"] = str(output_path)
+            result["status"] = "SHAP plot generated successfully"
+
+        except Exception:
+            err = traceback.format_exc()
+            print(f"⚠️ SHAPCheck failed:\n{err}")
+            result["status"] = f"SHAP plot failed:\n{err}"
+
+        return result