Update app.py

app.py

@@ -30,12 +30,10 @@ import xgboost as xgb
 import lightgbm as lgb
 from catboost import CatBoostRegressor
 import tensorflow as tf
-# ---------- universal sklearn_tags patcher ----------
+# ===== Robust sklearn_tags compatibility layer =====
+# Works on sklearn<1.6 + 3rd-party wrappers that call super().sklearn_tags()
 def _safe_sklearn_tags(self):
-    """
-    Return sklearn tags without relying on super().sklearn_tags().
-    Uses get_tags() when available and falls back to {} otherwise.
-    """
+    """Return sklearn tags without relying on super().sklearn_tags()."""
     try:
         if hasattr(self, "get_tags"):
             return self.get_tags()
@@ -43,34 +41,52 @@ def _safe_sklearn_tags(self):
         pass
     return {}
 
-def ensure_sklearn_tags_on_mro(est):
-    """Attach a safe sklearn_tags() to every class in the estimator's MRO
-    that lacks it (or whose implementation fails)."""
-    try:
-        mro = getattr(est.__class__, "mro", lambda: [])()
-    except Exception:
-        mro = []
-    for cls in mro:
-        if cls is object:
+def _patch_class_and_mro(cls):
+    """Attach a safe sklearn_tags to cls and all parents in its MRO."""
+    if not cls or cls is object:
+        return
+    for c in getattr(cls, "mro", lambda: [])():
+        if c is object:
             continue
-        needs_patch = not hasattr(cls, "sklearn_tags") or not callable(getattr(cls, "sklearn_tags"))
-        if not needs_patch:
-            try:
-                # dry-run; if it errors, we’ll patch
-                getattr(est, "sklearn_tags")()
-                continue
-            except Exception:
-                needs_patch = True
-        if needs_patch:
-            try:
-                setattr(cls, "sklearn_tags", _safe_sklearn_tags)
-            except Exception:
+        try:
+            # If missing or likely to fail, replace with safe version
+            need = not hasattr(c, "sklearn_tags") or not callable(getattr(c, "sklearn_tags"))
+            if not need:
                 try:
-                    # fallback: instance-level bind
-                    setattr(est, "sklearn_tags", _safe_sklearn_tags.__get__(est, est.__class__))
-                except Exception:
+                    # Dry run on a dummy instance if possible
+                    # (Some classes require init args, so ignore errors.)
                     pass
-
+                except Exception:
+                    need = True
+            if need:
+                setattr(c, "sklearn_tags", _safe_sklearn_tags)
+        except Exception:
+            # As a last resort, patch instance later (handled in loader too)
+            pass
+
+# Patch common estimator classes up-front
+try:
+    _patch_class_and_mro(xgb.XGBRegressor)
+    _patch_class_and_mro(xgb.XGBClassifier)
+    _patch_class_and_mro(xgb.XGBRFRegressor)
+    _patch_class_and_mro(xgb.XGBRFClassifier)
+except Exception:
+    pass
+
+try:
+    _patch_class_and_mro(lgb.LGBMRegressor)
+    _patch_class_and_mro(lgb.LGBMClassifier)
+except Exception:
+    pass
+
+try:
+    _patch_class_and_mro(CatBoostRegressor)
+    # (Classifier not used here, but harmless to patch if you add later)
+    # from catboost import CatBoostClassifier
+    # _patch_class_and_mro(CatBoostClassifier)
+except Exception:
+    pass
+# ===== end compatibility layer =====
 
 # -----------------------------
 # Paths (relative in a Space)
@@ -626,10 +642,12 @@ _ENSEMBLES: dict[str, EnsembleBundle] = {}
 def _load_ensemble(target: str) -> EnsembleBundle:
     if target in _ENSEMBLES:
         return _ENSEMBLES[target]
+
     base = MODEL_DIR / target
     if not base.exists():
         raise FileNotFoundError(f"Model folder not found: {base}")
 
+    # Preprocess artifacts
     encoders_b = joblib.load(base / "encoders.joblib")
     imputer_b  = joblib.load(base / "imputer.joblib")
     scaler_b   = joblib.load(base / "scaler.joblib") if (base / "scaler.joblib").exists() else None
@@ -643,28 +661,28 @@ def _load_ensemble(target: str) -> EnsembleBundle:
     # XGB
     xgb_model = xgb.XGBRegressor()
     xgb_model.load_model(str(base / "xgb.json"))
-    ensure_sklearn_tags_on_mro(xgb_model)   # <-- add this
+    _patch_class_and_mro(xgb_model.__class__)
 
     # LGBM
     lgb_booster, lgb_model = None, None
     if (base / "lgb.txt").exists():
         lgb_booster = lgb.Booster(model_file=str(base / "lgb.txt"))
-        # Booster is not a sklearn estimator; no patch needed.
+        # Booster is not an sklearn estimator -> no patch needed
     elif (base / "lgb.joblib").exists():
         lgb_model = joblib.load(base / "lgb.joblib")
-        ensure_sklearn_tags_on_mro(lgb_model)  # <-- add this
+        _patch_class_and_mro(lgb_model.__class__)
     else:
         raise FileNotFoundError("Neither lgb.txt nor lgb.joblib found for LGBM.")
 
     # CAT
     cat_model = CatBoostRegressor()
     cat_model.load_model(str(base / "cat.cbm"))
-    ensure_sklearn_tags_on_mro(cat_model)   # <-- add this
+    _patch_class_and_mro(cat_model.__class__)
 
-    # MLP
+    # MLP (Keras)
     mlp_model = tf.keras.models.load_model(base / "mlp.keras")
-    # (tf models don’t use sklearn tags)
 
+    # Meta
     meta = joblib.load(base / "meta.joblib")
 
     bundle = EnsembleBundle(