upgini 1.2.167a4220.dev5__tar.gz → 1.2.167a4220.dev7__tar.gz

{upgini-1.2.167a4220.dev5 → upgini-1.2.167a4220.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: upgini
-Version: 1.2.167a4220.dev5
+Version: 1.2.167a4220.dev7
 Summary: Intelligent data search & enrichment for Machine Learning
 Project-URL: Bug Reports, https://github.com/upgini/upgini/issues
 Project-URL: Homepage, https://upgini.com/

upgini-1.2.167a4220.dev7/src/upgini/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.167.a4220.dev7"

{upgini-1.2.167a4220.dev5 → upgini-1.2.167a4220.dev7}/src/upgini/features_enricher.py

@@ -98,7 +98,7 @@ from upgini.utils.deduplicate_utils import (
     clean_full_duplicates,
     remove_fintech_duplicates,
 )
-from upgini.report.assemble import assemble_report_data
+from upgini.report.assemble import assemble_report_data, autofe_rows_from_description, build_search_results
 from upgini.report.html import generate_html_report
 from upgini.report.stats import make_report_frame
 from upgini.utils.display_utils import (
@@ -2292,17 +2292,25 @@ class FeaturesEnricher(TransformerMixin):
         ensemble = [name for name in selected if self._is_ensemble_feature(name)]
         if len(ensemble) != 1:
             return None
-        etalon_columns = set()
+        renaming = self.fit_columns_renaming or {}
+        allowed = self._column_name_aliases([ensemble[0]], renaming) | self._etalon_feature_aliases()
+        if any(name not in allowed for name in selected):
+            return None
+        return ensemble[0]
+
+    def _etalon_feature_aliases(self) -> set[str]:
+        renaming = self.fit_columns_renaming or {}
+        names: set[str] = set()
         if self._search_task is not None:
-            etalon_columns = {
+            names.update(
                 meta.name
                 for meta in (self._search_task.get_all_features_metadata_v2() or [])
                 if meta.source == "etalon"
-            }
-        extras = [name for name in selected if name != ensemble[0] and name not in etalon_columns]
-        if extras:
-            return None
-        return ensemble[0]
+            )
+        if isinstance(self.X, pd.DataFrame):
+            generated = self._column_name_aliases(self.fit_generated_features or [], renaming)
+            names.update(column for column in self.X.columns if column not in generated)
+        return self._column_name_aliases(names, renaming)
 
     def _reference_rows(self) -> int | None:
         if self.X is None:
@@ -2437,6 +2445,7 @@ class FeaturesEnricher(TransformerMixin):
         return max(self.__cached_sampled_datasets.values(), key=lambda item: len(item[0]) if item[0] is not None else 0)
 
     def _assemble_report_data(self):
+        features, sources, model_shap, summary, autofe = self._report_search_results()
         search_id = self._search_task.search_task_id if self._search_task is not None else (self.search_id or "")
         return assemble_report_data(
             search_id=search_id,
@@ -2446,13 +2455,31 @@ class FeaturesEnricher(TransformerMixin):
             samples=self._report_sample_names(),
             metrics_df=self.metrics_raw if self.metrics_raw is not None else self.metrics,
             metric_name=self.metrics_metric_name,
-            model_features=self._ensemble_model_feature_count(),
+            model_features=summary.model_features,
             is_binary=self.model_task_type == ModelTaskType.BINARY,
             dataset_samples=self._report_dataset_samples(),
             scored_samples=self._report_scored_samples(),
             bundle=self.bundle,
+            summary=summary,
+            features=features,
+            sources=sources,
+            autofe=autofe,
+            model_feature_shap=model_shap,
         )
 
+    def _report_search_results(self):
+        features_meta = []
+        if self._search_task is not None:
+            features_meta = list(self._search_task.get_all_features_metadata_v2() or [])
+        features, sources, model_shap, summary = build_search_results(
+            model_names=self._ensemble_model_feature_names(),
+            features_meta=features_meta,
+            base_columns=self._ensemble_base_columns(),
+            is_ensemble=self._is_ensemble_feature,
+        )
+        autofe = autofe_rows_from_description(self.get_autofe_features_description(), self.bundle)
+        return features, sources, model_shap, summary, autofe
+
     def _score_report_html(self) -> str | None:
         if self._search_task is None or not self._has_single_ensemble_score():
             return None
@@ -2493,13 +2520,24 @@ class FeaturesEnricher(TransformerMixin):
                 names.add(meta.alias)
         return names
 
-    def _ensemble_model_feature_count(self) -> int | None:
-        names = {
-            column.original_name
+    def _ensemble_base_columns(self) -> list[tuple[str, str]]:
+        return [
+            (column.original_name, column.hashed_name)
             for meta, _ in self._ensemble_generated_metadata()
             for column in meta.base_columns
-        }
-        return len(names) or None
+        ]
+
+    def _ensemble_model_feature_names(self) -> list[str]:
+        return sorted(
+            {
+                original
+                for original, hashed in self._ensemble_base_columns()
+                if not self._is_ensemble_feature(original) and not self._is_ensemble_feature(hashed)
+            }
+        )
+
+    def _ensemble_model_feature_count(self) -> int | None:
+        return len(self._ensemble_model_feature_names()) or None
 
     def _psi_exceeds_threshold(self, psi: float | None, threshold: float) -> bool:
         return psi is not None and not pd.isna(psi) and psi > threshold
@@ -6194,19 +6232,24 @@ if response.status_code == 200:
             print(self._internal_features_info)
 
     def __show_report_button(self, display_id: str | None = None, display_handle=None):
+        if self._has_single_ensemble_score():
+            try:
+                report_html = self._score_report_html()
+                if report_html:
+                    if not ipython_available():
+                        return
+                    search_id = (
+                        self._search_task.search_task_id if self._search_task is not None else (self.search_id or "")
+                    )
+                    return show_button_open_report(
+                        report_html,
+                        download_name=f"upgini-report-{search_id}.html",
+                        display_id=display_id,
+                        display_handle=display_handle,
+                    )
+            except Exception:
+                self.logger.exception("Failed to generate HTML report, falling back to PDF")
         try:
-            report_html = self._score_report_html() or self.report_html
-            if report_html:
-                if not ipython_available():
-                    return
-                search_id = self._search_task.search_task_id if self._search_task is not None else (self.search_id or "")
-                return show_button_open_report(
-                    report_html,
-                    download_name=f"upgini-report-{search_id}.html",
-                    display_id=display_id,
-                    display_handle=display_handle,
-                )
-
             eval_sets_drift_df = self._get_eval_sets_drift_summary()
 
             return prepare_and_show_report(

upgini-1.2.167a4220.dev7/src/upgini/report/assemble.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+import os
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+import pandas as pd
+
+from upgini.__about__ import __version__
+from upgini.metadata import FeaturesMetadataV2
+from upgini.report.data import (
+    FeatureRow,
+    ModelFeatureShap,
+    QualitySample,
+    ReportData,
+    ReportMetadata,
+    SampleStats,
+    SearchResultsSummary,
+    SourceRow,
+)
+from upgini.report.stats import PSI_CRITICAL, PSI_WARNING, compute_report_charts
+from upgini.resource_bundle import ResourceBundle
+from upgini.utils.feature_info import FeatureInfo
+
+UPGINI_REPORT_BRANDING_URL = "UPGINI_REPORT_BRANDING_URL"
+_STABILITY_PSI = 0.2
+
+
+def format_search_duration(seconds: Optional[float]) -> Optional[str]:
+    if seconds is None:
+        return None
+    total = max(0, int(round(seconds)))
+    hours, remainder = divmod(total, 3600)
+    minutes, secs = divmod(remainder, 60)
+    if hours:
+        return f"{hours} h {minutes} min {secs} sec"
+    if minutes:
+        return f"{minutes} min {secs} sec"
+    return f"{secs} sec"
+
+
+def assemble_report_data(
+    *,
+    search_id: str,
+    search_keys: list[str],
+    generated_at: Optional[datetime] = None,
+    pylib_version: Optional[str] = None,
+    search_duration_seconds: Optional[float] = None,
+    reference_rows: Optional[int] = None,
+    samples: Optional[list[str]] = None,
+    metrics_df: Optional[pd.DataFrame] = None,
+    metric_name: Optional[str] = None,
+    model_features: Optional[int] = None,
+    is_binary: bool = False,
+    dataset_samples: Optional[dict[str, pd.DataFrame]] = None,
+    scored_samples: Optional[dict[str, pd.DataFrame]] = None,
+    bundle: ResourceBundle,
+    summary: Optional[SearchResultsSummary] = None,
+    features: Optional[list[FeatureRow]] = None,
+    sources: Optional[list[SourceRow]] = None,
+    autofe: Optional[list[dict[str, str]]] = None,
+    model_feature_shap: Optional[list[ModelFeatureShap]] = None,
+) -> ReportData:
+    generated_at = generated_at or datetime.now(timezone.utc)
+    sample_names = list(samples or [])
+    chart_stats, charts = compute_report_charts(
+        sample_names=sample_names,
+        dataset_samples=dataset_samples,
+        scored_samples=scored_samples,
+        metric_name=metric_name,
+        is_binary=is_binary,
+    )
+    summary = summary or SearchResultsSummary(model_features=model_features)
+    if summary.model_features is None:
+        summary.model_features = model_features
+    return ReportData(
+        metadata=ReportMetadata(
+            search_id=search_id,
+            generated_at=generated_at.strftime("%Y-%m-%d %H:%M UTC"),
+            pylib_version=pylib_version or __version__,
+            search_keys=list(search_keys or []),
+            search_duration=format_search_duration(search_duration_seconds),
+            reference_rows=reference_rows,
+            samples=sample_names,
+            logo_url=_branding_url(),
+        ),
+        quality_by_sample=_quality_samples(metrics_df, metric_name, bundle),
+        summary=summary,
+        sample_stats=chart_stats or _sample_stats(sample_names, metrics_df, bundle),
+        is_binary=is_binary,
+        features=list(features or []),
+        sources=list(sources or []),
+        autofe=list(autofe or []),
+        model_feature_shap=list(model_feature_shap or []),
+        charts=charts,
+    )
+
+
+def build_search_results(
+    *,
+    model_names: list[str],
+    features_meta: list[FeaturesMetadataV2],
+    base_columns: list[tuple[str, str]],
+    is_ensemble: Callable[[str], bool],
+) -> tuple[list[FeatureRow], list[SourceRow], list[ModelFeatureShap], SearchResultsSummary]:
+    meta_by_name = _features_meta_index(features_meta, base_columns)
+    model_rows = [_feature_row(name, meta_by_name.get(name)) for name in model_names]
+    model_rows.sort(key=lambda row: (row.shap is None, -abs(row.shap or 0.0), row.name))
+    model_shap = [
+        ModelFeatureShap(
+            rank=index,
+            feature=row.name,
+            provider=row.provider,
+            mean_abs_shap=None if row.shap is None else abs(row.shap),
+        )
+        for index, row in enumerate(model_rows, start=1)
+    ]
+    join_rows = [
+        _feature_row(meta.name, meta)
+        for meta in features_meta
+        if meta.source != "etalon" and not is_ensemble(meta.name)
+    ]
+    sources = _source_rows(join_rows)
+    relevant = sum(1 for row in join_rows if _has_nonzero_shap(row))
+    contributed = len({(row.provider, row.source) for row in join_rows if row.provider and _has_nonzero_shap(row)})
+    model_count = len(model_names) or None
+    stable = sum(1 for row in model_rows if row.psi is not None and row.psi < _STABILITY_PSI)
+    summary = SearchResultsSummary(
+        relevant_features=relevant,
+        model_features=model_count,
+        data_sources=len(sources),
+        stable_features_share=(stable / len(model_rows)) if model_rows else None,
+        contributed_sources=contributed,
+        stable_features=stable if model_rows else None,
+    )
+    return model_rows, sources, model_shap, summary
+
+
+def autofe_rows_from_description(df: Optional[pd.DataFrame], bundle: ResourceBundle) -> list[dict[str, str]]:
+    if df is None or df.empty:
+        return []
+    sources_col = bundle.get("autofe_descriptions_sources")
+    name_col = bundle.get("autofe_descriptions_feature_name")
+    func_col = bundle.get("autofe_descriptions_function")
+    rows: list[dict[str, str]] = []
+    for _, row in df.iterrows():
+        source_features = []
+        for index in (1, 2):
+            col = bundle.get("autofe_descriptions_feature").format(index)
+            value = _as_str(row[col]) if col in df.columns else None
+            if value:
+                source_features.append(value)
+        rows.append(
+            {
+                "sources": (_as_str(row[sources_col]) or "") if sources_col in df.columns else "",
+                "generatedFeature": (_as_str(row[name_col]) or "") if name_col in df.columns else "",
+                "sourceFeatures": ", ".join(source_features),
+                "functions": (_as_str(row[func_col]) or "") if func_col in df.columns else "",
+            }
+        )
+    return rows
+
+
+def _branding_url() -> Optional[str]:
+    env_url = os.getenv(UPGINI_REPORT_BRANDING_URL)
+    if env_url and env_url.strip():
+        return env_url.strip()
+    return None
+
+
+def _quality_samples(
+    metrics_df: Optional[pd.DataFrame], metric_name: Optional[str], bundle: ResourceBundle
+) -> list[QualitySample]:
+    if metrics_df is None or metrics_df.empty:
+        return []
+    segment_col = bundle.get("quality_metrics_segment_header")
+    uplift_col = bundle.get("quality_metrics_uplift_header")
+    uplift_pct_col = bundle.get("quality_metrics_uplift_perc_header")
+    baseline_col = bundle.get("quality_metrics_baseline_header").format(metric_name) if metric_name else None
+    enriched_col = bundle.get("quality_metrics_enriched_header").format(metric_name) if metric_name else None
+    baseline_std_col = bundle.get("quality_metrics_baseline_std_header").format(metric_name) if metric_name else None
+    enriched_std_col = bundle.get("quality_metrics_enriched_std_header").format(metric_name) if metric_name else None
+
+    samples: list[QualitySample] = []
+    for _, row in metrics_df.iterrows():
+        samples.append(
+            QualitySample(
+                evaluation_scope=(_as_str(row[segment_col]) or "") if segment_col in metrics_df.columns else "",
+                metric=metric_name or "",
+                baseline=_as_float(row[baseline_col]) if baseline_col in metrics_df.columns else None,
+                baseline_std=_as_float(row[baseline_std_col]) if baseline_std_col in metrics_df.columns else None,
+                enriched=_as_float(row[enriched_col]) if enriched_col in metrics_df.columns else None,
+                enriched_std=_as_float(row[enriched_std_col]) if enriched_std_col in metrics_df.columns else None,
+                uplift=_as_float(row[uplift_col]) if uplift_col in metrics_df.columns else None,
+                relative_uplift=_as_str(row[uplift_pct_col]) if uplift_pct_col in metrics_df.columns else None,
+            )
+        )
+    return samples
+
+
+def _sample_stats(
+    sample_names: list[str], metrics_df: Optional[pd.DataFrame], bundle: ResourceBundle
+) -> list[SampleStats]:
+    segment_col = bundle.get("quality_metrics_segment_header")
+    rows_col = bundle.get("quality_metrics_rows_header")
+    mean_col = bundle.get("quality_metrics_mean_target_header")
+    by_name: dict[str, SampleStats] = {}
+    if metrics_df is not None and not metrics_df.empty and segment_col in metrics_df.columns:
+        for _, row in metrics_df.iterrows():
+            name = _as_str(row[segment_col])
+            if not name:
+                continue
+            by_name[name] = SampleStats(
+                sample=name,
+                rows=_as_int(row[rows_col]) if rows_col in metrics_df.columns else None,
+                mean_target=_as_float(row[mean_col]) if mean_col in metrics_df.columns else None,
+            )
+    names = sample_names or list(by_name)
+    stats = [by_name.get(name) or SampleStats(sample=name) for name in names]
+    seen = set(names)
+    stats.extend(sample for name, sample in by_name.items() if name not in seen)
+    return stats
+
+
+def _as_str(value) -> Optional[str]:
+    return None if pd.isna(value) else str(value)
+
+
+def _as_float(value) -> Optional[float]:
+    return None if pd.isna(value) else float(value)
+
+
+def _as_int(value) -> Optional[int]:
+    return None if pd.isna(value) else int(value)
+
+
+def _features_meta_index(
+    features_meta: list[FeaturesMetadataV2], base_columns: list[tuple[str, str]]
+) -> dict[str, FeaturesMetadataV2]:
+    index = {meta.name: meta for meta in features_meta}
+    for original, hashed in base_columns:
+        matched = index.get(hashed) or index.get(original)
+        if matched is None:
+            continue
+        index[original] = matched
+        index[hashed] = matched
+    return index
+
+
+def _feature_row(name: str, meta: Optional[FeaturesMetadataV2]) -> FeatureRow:
+    if meta is None:
+        return FeatureRow(name=name)
+    info = FeatureInfo.from_metadata(meta, None, meta.source == "etalon", False)
+    return FeatureRow(
+        name=name,
+        shap=meta.shap_value,
+        psi=meta.psi_value,
+        drift=meta.drift_score,
+        coverage=meta.hit_rate,
+        provider=info.internal_provider,
+        source=info.internal_source,
+        stability_status=_psi_status(meta.psi_value),
+    )
+
+
+def _source_rows(rows: list[FeatureRow]) -> list[SourceRow]:
+    grouped: dict[tuple[str, str], list[FeatureRow]] = {}
+    for row in rows:
+        if not row.provider:
+            continue
+        grouped.setdefault((row.provider, row.source), []).append(row)
+    sources = [
+        SourceRow(
+            provider=provider,
+            source=source,
+            shap_sum=sum(item.shap for item in items if item.shap is not None),
+            feature_count=len(items),
+        )
+        for (provider, source), items in grouped.items()
+    ]
+    sources.sort(key=lambda row: (-(row.shap_sum or 0.0), row.provider, row.source))
+    return sources
+
+
+def _psi_status(psi: Optional[float]) -> Optional[str]:
+    if psi is None or pd.isna(psi):
+        return None
+    if psi > PSI_CRITICAL:
+        return "risk"
+    if psi >= PSI_WARNING:
+        return "watch"
+    return "good"
+
+
+def _has_nonzero_shap(row: FeatureRow) -> bool:
+    return row.shap is not None and row.shap != 0

{upgini-1.2.167a4220.dev5 → upgini-1.2.167a4220.dev7}/src/upgini/report/data.py

@@ -69,6 +69,8 @@ class SearchResultsSummary:
     model_features: Optional[int] = None
     data_sources: Optional[int] = None
     stable_features_share: Optional[float] = None
+    contributed_sources: Optional[int] = None
+    stable_features: Optional[int] = None
 
 
 @dataclass

{upgini-1.2.167a4220.dev5 → upgini-1.2.167a4220.dev7}/src/upgini/report/html.py

@@ -4,7 +4,7 @@ import json
 from pathlib import Path
 from typing import Optional
 
-from upgini.report.data import ReportCharts, ReportData, SampleStats, SearchResultsSummary
+from upgini.report.data import FeatureRow, ReportCharts, ReportData, SampleStats, SearchResultsSummary, SourceRow
 from upgini.report.stats import MEAN_AXIS_PADDING
 
 _TEMPLATE_PATH = Path(__file__).with_name("template.html")
@@ -37,15 +37,14 @@ def _report_payload(data: ReportData) -> dict:
         "scoreAnalysis": _score_analysis_payload(charts, samples),
         "scoreDistribution": _score_distribution_payload(charts, samples),
         "scoreStability": _score_stability_payload(charts, samples),
-        "features": [],
-        "featureStability": {"bySample": {}},
+        "features": _features_payload(data.features),
         "shap": {"topN": 5},
         "searchResults": {
             "relevantFeaturesCount": _dash(data.summary.relevant_features),
             "dataSourcesCount": _dash(data.summary.data_sources),
-            "autofeCount": _dash(len(data.autofe) if data.autofe else None),
-            "sources": [],
-            "autofe": [],
+            "autofeCount": _dash(len(data.autofe)),
+            "sources": _sources_payload(data.sources),
+            "autofe": list(data.autofe),
         },
     }
 
@@ -141,11 +140,46 @@ def _summary_cards(summary: SearchResultsSummary) -> list[dict]:
     stability = None
     if summary.stable_features_share is not None:
         stability = f"{summary.stable_features_share * 100:.0f}%"
+    sources_caption = ""
+    if summary.contributed_sources is not None:
+        sources_caption = f"{summary.contributed_sources} contributed"
+    stability_caption = ""
+    if summary.stable_features is not None and summary.model_features is not None:
+        stability_caption = f"{summary.stable_features} of {summary.model_features} are stable"
     return [
         {"label": "Features found", "value": _dash(summary.relevant_features), "caption": ""},
         {"label": "Used in model", "value": _dash(summary.model_features), "caption": ""},
-        {"label": "Data sources", "value": _dash(summary.data_sources), "caption": ""},
-        {"label": "Stability", "value": _dash(stability), "caption": ""},
+        {"label": "Data sources", "value": _dash(summary.data_sources), "caption": sources_caption},
+        {"label": "Stability", "value": _dash(stability), "caption": stability_caption},
+    ]
+
+
+def _features_payload(features: list[FeatureRow]) -> list[dict]:
+    return [
+        {
+            "name": row.name,
+            "provider": row.provider,
+            "source": row.source,
+            "importance": abs(row.shap) if row.shap is not None else 0,
+            "shap": row.shap,
+            "coverage": row.coverage,
+            "status": row.stability_status,
+            "psi": row.psi,
+            "drift": row.drift,
+        }
+        for row in features
+    ]
+
+
+def _sources_payload(sources: list[SourceRow]) -> list[dict]:
+    return [
+        {
+            "provider": row.provider,
+            "source": row.source,
+            "aggregateShap": row.shap_sum,
+            "relevantFeatures": row.feature_count,
+        }
+        for row in sources
     ]
 
 

{upgini-1.2.167a4220.dev5 → upgini-1.2.167a4220.dev7}/src/upgini/report/template.html

@@ -30,8 +30,6 @@
       <a class="nav-link" href="#score-stability"><span class="nav-dot"></span>Score stability</a>
       <a class="nav-link" href="#features-shap"><span class="nav-dot"></span>Features SHAP</a>
       <a class="nav-link" href="#search-results"><span class="nav-dot"></span>Search results</a>
-      <a class="nav-link" href="#feature-stability"><span class="nav-dot"></span>Feature stability</a>
-      <div class="run-note"><strong>Search completed</strong><span id="runNoteDuration"></span><br><span id="runNoteRows"></span></div>
     </aside>
     <main class="main">
       <section id="overview" class="section" style="margin-top:0">
@@ -87,11 +85,6 @@
         <div class="result-pane" id="result-sources"><div class="table-actions"><button class="button ghost copy-table" data-copy="sourceTable">Copy</button><button class="button ghost csv-table" data-table="sourceTable">Download CSV</button></div><div class="panel table-wrap"><table class="data-table"><thead><tr><th>Provider</th><th>Source</th><th>Aggregate SHAP</th><th>Relevant features</th><th>Action</th></tr></thead><tbody id="sourceTable"></tbody></table></div></div>
         <div class="result-pane" id="result-autofe"><div class="table-actions"><button class="button ghost copy-table" data-copy="autofeTable">Copy</button><button class="button ghost csv-table" data-table="autofeTable">Download CSV</button></div><div class="panel table-wrap"><table class="data-table"><thead><tr><th>Sources</th><th>Generated feature</th><th>Source features</th><th>Functions</th></tr></thead><tbody id="autofeTable"></tbody></table></div></div>
       </section>
-
-      <section id="feature-stability" class="section">
-        <div class="section-head"><div><h2>Feature stability</h2><p>Monthly PSI and direction-invariant univariate ROC-AUC for model features only.</p></div><div class="toolbar"><select id="stabilityFeature" class="control" aria-label="Model feature"></select><button class="button ghost chart-export" data-chart="featureStabilityChart">Save PNG</button></div></div>
-        <div class="panel chart-panel"><div class="legend"><span><i style="background:#1645ee"></i>Monthly PSI</span><span><i style="background:#53cc61"></i>Univariate ROC-AUC</span></div><div class="canvas-wrap"><canvas id="featureStabilityChart" aria-label="Feature monthly PSI and ROC AUC" width="1596" height="560"></canvas><div class="chart-tooltip" id="featureTooltip"></div></div></div>
-      </section>
     </main>
   </div>
 </div>
@@ -158,10 +151,6 @@ const REPORT_DATA = __REPORT_DATA__;
       });
     }
     setText('searchIdChip', 'search_id=' + m.searchId);
-    const sources = m.sourcesCount == null ? '—' : m.sourcesCount;
-    const rows = m.totalRows == null ? '—' : num(m.totalRows);
-    setText('runNoteDuration', `${m.searchDuration || '—'} · ${sources} sources`);
-    setText('runNoteRows', `${rows} rows processed`);
     setText('statusLine', m.statusLine);
     setText('heroTitle', m.reportTitle);
     setText('heroSubtitle', m.reportSubtitle);
@@ -551,48 +540,6 @@ const REPORT_DATA = __REPORT_DATA__;
     document.getElementById('emptyState').style.display = rows.length ? 'none' : 'block';
   }
 
-  /* ---------------------------------------------------- feature stability */
-  function renderFeatureSelect() {
-    const s = document.getElementById('stabilityFeature');
-    s.innerHTML = (D.features || []).map((f, i) => `<option value="${i}">#${i + 1} ${f.name}</option>`).join('');
-    s.addEventListener('change', drawFeatureStability);
-  }
-  function currentStabilityFeature() {
-    return D.features[+document.getElementById('stabilityFeature').value || 0];
-  }
-  function drawFeatureStability() {
-    const cfg = D.featureStability || {};
-    const { c, w, h } = setupCanvas('featureStabilityChart');
-    const feature = currentStabilityFeature();
-    const s = feature && cfg.bySample ? cfg.bySample[feature.name] : null;
-    if (!feature || !s || !MONTH_COUNT) return;
-    const psi = align(s.psi), auc = align(s.auc);
-    hits.feature = [];
-    const labelGutter = 46;                    // room for the ROC-AUC axis labels
-    const seriesGutter = 22;                   // keeps the last point off those labels
-    const plotRight = w - labelGutter - seriesGutter;
-    const x = i => 48 + (MONTH_COUNT === 1 ? (plotRight - 48) / 2 : i * (plotRight - 48) / (MONTH_COUNT - 1));
-    const yp = v => 18 + (cfg.psiAxisMax - v) / cfg.psiAxisMax * (h - 62);
-    const ya = v => 18 + (cfg.aucAxis.max - v) / cfg.aucAxis.range * (h - 62);
-
-    // grid + dual axis labels: PSI on the left, univariate ROC-AUC on the right
-    c.font = '10px Inter, sans-serif';
-    for (let i = 0; i < 5; i++) {
-      const y = 18 + i * (h - 62) / 4;
-      c.strokeStyle = '#e8eeec'; c.beginPath(); c.moveTo(40, y); c.lineTo(w - labelGutter, y); c.stroke();
-      c.fillStyle = '#5f79c9';
-      c.fillText((cfg.psiAxisMax - i * cfg.psiAxisMax / 4).toFixed(2), 4, y + 3);
-      c.fillStyle = '#5aa86a';
-      c.fillText((cfg.aucAxis.max - i * cfg.aucAxis.range / 4).toFixed(2), w - labelGutter + 10, y + 3);
-    }
-    strokeSeries(c, psi.map((v, i) => v == null ? null : { x: x(i), y: yp(v) }), '#1645ee', 4);
-    strokeSeries(c, auc.map((v, i) => v == null ? null : { x: x(i), y: ya(v) }), '#53cc61', 4);
-    MONTHS.forEach((m, i) => {
-      hits.feature.push({ x: x(i), y: 18, w: 18, h: h - 55, index: i });
-      c.fillStyle = '#7d8885'; c.fillText(m.split(' ')[0], x(i) - 8, h - 22); c.fillText(m.split(' ')[1], x(i) - 12, h - 9);
-    });
-  }
-
   /* -------------------------------------------------------------- tooltips */
   function bindTooltip(canvasId, tooltipId, hitKey, htmlFor) {
     const cv = document.getElementById(canvasId), tip = document.getElementById(tooltipId);
@@ -630,14 +577,6 @@ const REPORT_DATA = __REPORT_DATA__;
       return `<b>${MONTHS[i]} · ${selectedLabel('psiSample')}</b><br>PSI: ${fmt3(s.psi[i])}` +
         `<br>Rows: ${num(s.rows[i])}<br>Score coverage: ${s.scoreCoverage[i].toFixed(1)}%<br>Reference: first period (baseline month)`;
     });
-    bindTooltip('featureStabilityChart', 'featureTooltip', 'feature', i => {
-      const cfg = D.featureStability, f = currentStabilityFeature(), s = cfg.bySample[f.name];
-      const auc = s.auc[i], raw = i % 3 === 0 ? 1 - auc : auc;
-      return `<b>${f.name} · ${MONTHS[i]}</b><br>SHAP rank/value: #${D.features.indexOf(f) + 1} / ${fmt3(Math.abs(f.shap))}` +
-        `<br>PSI: ${fmt3(s.psi[i])}<br>AUC: ${fmt3(auc)}<br>Raw AUC / direction: ${fmt3(raw)} / ${raw < .5 ? 'inverse' : 'direct'}` +
-        `<br>Rows: ${num(s.rows[i])}<br>Labeled: ${num(s.labeled[i])}<br>Positive count: ${num(Math.round(s.labeled[i] * D.meta.targetRate))}` +
-        `<br>Coverage: ${pct1(f.coverage)}<br>Missing rate: ${(100 - f.coverage).toFixed(1)}%`;
-    });
   }
 
   /* -------------------------------------------------------- sample tooltip */
@@ -712,7 +651,7 @@ const REPORT_DATA = __REPORT_DATA__;
     });
   }
 
-  function drawAll() { drawChart(); drawSample(); drawScore(); drawDistribution(); drawPsi(); drawFeatureStability(); }
+  function drawAll() { drawChart(); drawSample(); drawScore(); drawDistribution(); drawPsi(); }
 
   /* ------------------------------------------------------------------ init */
   renderHeader();
@@ -724,7 +663,6 @@ const REPORT_DATA = __REPORT_DATA__;
   renderSearchResults();
   renderFeatures();
   renderShap();
-  renderFeatureSelect();
   bindControls();
   bindAllTooltips();
   bindSampleTooltip();

upgini-1.2.167a4220.dev5/src/upgini/__about__.py

@@ -1 +0,0 @@
-__version__ = "1.2.167.a4220.dev5"

upgini-1.2.167a4220.dev5/src/upgini/report/assemble.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-import os
-from datetime import datetime, timezone
-from typing import Optional
-
-import pandas as pd
-
-from upgini.__about__ import __version__
-from upgini.report.data import QualitySample, ReportData, ReportMetadata, SampleStats, SearchResultsSummary
-from upgini.report.stats import compute_report_charts
-from upgini.resource_bundle import ResourceBundle
-
-UPGINI_REPORT_BRANDING_URL = "UPGINI_REPORT_BRANDING_URL"
-
-
-def format_search_duration(seconds: Optional[float]) -> Optional[str]:
-    if seconds is None:
-        return None
-    total = max(0, int(round(seconds)))
-    hours, remainder = divmod(total, 3600)
-    minutes, secs = divmod(remainder, 60)
-    if hours:
-        return f"{hours} h {minutes} min {secs} sec"
-    if minutes:
-        return f"{minutes} min {secs} sec"
-    return f"{secs} sec"
-
-
-def assemble_report_data(
-    *,
-    search_id: str,
-    search_keys: list[str],
-    generated_at: Optional[datetime] = None,
-    pylib_version: Optional[str] = None,
-    search_duration_seconds: Optional[float] = None,
-    reference_rows: Optional[int] = None,
-    samples: Optional[list[str]] = None,
-    metrics_df: Optional[pd.DataFrame] = None,
-    metric_name: Optional[str] = None,
-    model_features: Optional[int] = None,
-    is_binary: bool = False,
-    dataset_samples: Optional[dict[str, pd.DataFrame]] = None,
-    scored_samples: Optional[dict[str, pd.DataFrame]] = None,
-    bundle: ResourceBundle,
-) -> ReportData:
-    generated_at = generated_at or datetime.now(timezone.utc)
-    sample_names = list(samples or [])
-    chart_stats, charts = compute_report_charts(
-        sample_names=sample_names,
-        dataset_samples=dataset_samples,
-        scored_samples=scored_samples,
-        metric_name=metric_name,
-        is_binary=is_binary,
-    )
-    return ReportData(
-        metadata=ReportMetadata(
-            search_id=search_id,
-            generated_at=generated_at.strftime("%Y-%m-%d %H:%M UTC"),
-            pylib_version=pylib_version or __version__,
-            search_keys=list(search_keys or []),
-            search_duration=format_search_duration(search_duration_seconds),
-            reference_rows=reference_rows,
-            samples=sample_names,
-            logo_url=_branding_url(),
-        ),
-        quality_by_sample=_quality_samples(metrics_df, metric_name, bundle),
-        summary=SearchResultsSummary(model_features=model_features),
-        sample_stats=chart_stats or _sample_stats(sample_names, metrics_df, bundle),
-        is_binary=is_binary,
-        charts=charts,
-    )
-
-
-def _branding_url() -> Optional[str]:
-    env_url = os.getenv(UPGINI_REPORT_BRANDING_URL)
-    if env_url and env_url.strip():
-        return env_url.strip()
-    return None
-
-
-def _quality_samples(
-    metrics_df: Optional[pd.DataFrame], metric_name: Optional[str], bundle: ResourceBundle
-) -> list[QualitySample]:
-    if metrics_df is None or metrics_df.empty:
-        return []
-    segment_col = bundle.get("quality_metrics_segment_header")
-    uplift_col = bundle.get("quality_metrics_uplift_header")
-    uplift_pct_col = bundle.get("quality_metrics_uplift_perc_header")
-    baseline_col = bundle.get("quality_metrics_baseline_header").format(metric_name) if metric_name else None
-    enriched_col = bundle.get("quality_metrics_enriched_header").format(metric_name) if metric_name else None
-    baseline_std_col = bundle.get("quality_metrics_baseline_std_header").format(metric_name) if metric_name else None
-    enriched_std_col = bundle.get("quality_metrics_enriched_std_header").format(metric_name) if metric_name else None
-
-    samples: list[QualitySample] = []
-    for _, row in metrics_df.iterrows():
-        samples.append(
-            QualitySample(
-                evaluation_scope=(_as_str(row[segment_col]) or "") if segment_col in metrics_df.columns else "",
-                metric=metric_name or "",
-                baseline=_as_float(row[baseline_col]) if baseline_col in metrics_df.columns else None,
-                baseline_std=_as_float(row[baseline_std_col]) if baseline_std_col in metrics_df.columns else None,
-                enriched=_as_float(row[enriched_col]) if enriched_col in metrics_df.columns else None,
-                enriched_std=_as_float(row[enriched_std_col]) if enriched_std_col in metrics_df.columns else None,
-                uplift=_as_float(row[uplift_col]) if uplift_col in metrics_df.columns else None,
-                relative_uplift=_as_str(row[uplift_pct_col]) if uplift_pct_col in metrics_df.columns else None,
-            )
-        )
-    return samples
-
-
-def _sample_stats(
-    sample_names: list[str], metrics_df: Optional[pd.DataFrame], bundle: ResourceBundle
-) -> list[SampleStats]:
-    segment_col = bundle.get("quality_metrics_segment_header")
-    rows_col = bundle.get("quality_metrics_rows_header")
-    mean_col = bundle.get("quality_metrics_mean_target_header")
-    by_name: dict[str, SampleStats] = {}
-    if metrics_df is not None and not metrics_df.empty and segment_col in metrics_df.columns:
-        for _, row in metrics_df.iterrows():
-            name = _as_str(row[segment_col])
-            if not name:
-                continue
-            by_name[name] = SampleStats(
-                sample=name,
-                rows=_as_int(row[rows_col]) if rows_col in metrics_df.columns else None,
-                mean_target=_as_float(row[mean_col]) if mean_col in metrics_df.columns else None,
-            )
-    names = sample_names or list(by_name)
-    stats = [by_name.get(name) or SampleStats(sample=name) for name in names]
-    seen = set(names)
-    stats.extend(sample for name, sample in by_name.items() if name not in seen)
-    return stats
-
-
-def _as_str(value) -> Optional[str]:
-    return None if pd.isna(value) else str(value)
-
-
-def _as_float(value) -> Optional[float]:
-    return None if pd.isna(value) else float(value)
-
-
-def _as_int(value) -> Optional[int]:
-    return None if pd.isna(value) else int(value)