upgini 1.2.166a4253.dev2__tar.gz → 1.2.167a4220.dev1__tar.gz

{upgini-1.2.166a4253.dev2 → upgini-1.2.167a4220.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: upgini
-Version: 1.2.166a4253.dev2
+Version: 1.2.167a4220.dev1
 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.dev1/src/upgini/__about__.py

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

{upgini-1.2.166a4253.dev2 → upgini-1.2.167a4220.dev1}/src/upgini/features_enricher.py

@@ -92,10 +92,14 @@ from upgini.utils.deduplicate_utils import (
     clean_full_duplicates,
     remove_fintech_duplicates,
 )
+from upgini.report.assemble import assemble_report_data
+from upgini.report.html import generate_html_report
 from upgini.utils.display_utils import (
     display_html_dataframe,
     do_without_pandas_limits,
+    ipython_available,
     prepare_and_show_report,
+    show_button_open_report,
     show_request_quote_button,
 )
 from upgini.utils.email_utils import (
@@ -175,6 +179,9 @@ class FeaturesEnricher(TransformerMixin):
 
     shared_datasets: list of str, optional (default=None)
         list of private shared dataset ids for custom search
+
+    reports_path: str, optional (default=None)
+        Directory for the HTML search report. Defaults to a `reports` folder in the current working directory.
     """
 
     TARGET_NAME = "target"
@@ -252,6 +259,7 @@ class FeaturesEnricher(TransformerMixin):
         sample_config: SampleConfig | None = None,
         print_trace_id: bool = False,
         print_loaded_report: bool = True,
+        reports_path: str | None = None,
         **kwargs,
     ):
         self.bundle = get_custom_bundle(custom_bundle_config)
@@ -310,6 +318,7 @@ class FeaturesEnricher(TransformerMixin):
         self.relevant_data_sources: pd.DataFrame = self.EMPTY_DATA_SOURCES
         self._relevant_data_sources_wo_links: pd.DataFrame = self.EMPTY_DATA_SOURCES
         self.metrics: pd.DataFrame | None = None
+        self.metrics_metric_name: str | None = None
         self.feature_names_ = []
         self.external_source_feature_names = []
         self.feature_importances_ = []
@@ -319,6 +328,9 @@ class FeaturesEnricher(TransformerMixin):
         self.disable_force_downsampling = disable_force_downsampling
         self.print_trace_id = print_trace_id
         self.add_info: AddInfo | None = None
+        self.reports_path = reports_path
+        self.search_duration_seconds: float | None = None
+        self.report_file_path: str | None = None
 
         if search_id:
             search_task = SearchTask(search_id, rest_client=self.rest_client, logger=self.logger)
@@ -1138,18 +1150,9 @@ class FeaturesEnricher(TransformerMixin):
                     uplift_perc = None
                     enriched_estimator = None
                     ensemble_score_column = self._get_ensemble_score_column(fitting_X, fitting_enriched_X)
-                    if set(fitting_X.columns) != set(fitting_enriched_X.columns):
-                        if self.baseline_score_column is not None and ensemble_score_column is not None:
-                            self.logger.info(
-                                f"Only ensemble model returned; calculate enriched {metric} via roc_auc "
-                                f"on ensemble score column: {ensemble_score_column}"
-                            )
-                        else:
-                            self.logger.info(
-                                f"Calculate enriched {metric} on train combined "
-                                f"features: {fitting_enriched_X.columns.to_list()}"
-                            )
-                        enriched_estimator = EstimatorWrapper.create(
+
+                    def evaluate_enriched(score_column, description: str):
+                        wrapper = EstimatorWrapper.create(
                             estimator,
                             self.logger,
                             model_task_type,
@@ -1161,22 +1164,48 @@ class FeaturesEnricher(TransformerMixin):
                             text_features=text_features,
                             has_time=has_time,
                         )
-                        enriched_cv_result = enriched_estimator.cross_val_predict(
-                            fitting_enriched_X, enriched_y_sorted, ensemble_score_column
+                        cv_result = wrapper.cross_val_predict(
+                            fitting_enriched_X, enriched_y_sorted, score_column
                         )
-                        enriched_metric = enriched_cv_result.get_display_metric()
-                        updating_shaps = enriched_cv_result.shap_values
-
-                        if enriched_metric is None:
-                            self.logger.warning(
-                                f"Enriched {metric} on train combined features is None (maybe all features was removed)"
-                            )
-                            enriched_estimator = None
-                        else:
-                            self.logger.info(f"Enriched {metric} on train combined features: {enriched_metric}")
-                        if baseline_metric is not None and enriched_metric is not None:
-                            uplift = (enriched_cv_result.metric - baseline_cv_result.metric) * multiplier
-                            uplift_perc = uplift / abs(baseline_cv_result.metric) * 100
+                        display_metric = cv_result.get_display_metric()
+                        if display_metric is None:
+                            self.logger.warning(f"Enriched {metric} {description} is None")
+                            return None, None, cv_result.shap_values, None, None
+                        self.logger.info(f"Enriched {metric} {description}: {display_metric}")
+                        sample_uplift = None
+                        sample_uplift_perc = None
+                        if baseline_metric is not None:
+                            sample_uplift = (cv_result.metric - baseline_cv_result.metric) * multiplier
+                            sample_uplift_perc = sample_uplift / abs(baseline_cv_result.metric) * 100
+                        return wrapper, display_metric, cv_result.shap_values, sample_uplift, sample_uplift_perc
+
+                    if ensemble_score_column is not None:
+                        self.logger.info(
+                            f"Only ensemble model returned; calculate enriched {metric} via roc_auc "
+                            f"on ensemble score column: {ensemble_score_column}"
+                        )
+                        (
+                            enriched_estimator,
+                            enriched_metric,
+                            updating_shaps,
+                            uplift,
+                            uplift_perc,
+                        ) = evaluate_enriched(
+                            ensemble_score_column,
+                            f"on ensemble score column {ensemble_score_column}",
+                        )
+                    elif set(fitting_X.columns) != set(fitting_enriched_X.columns):
+                        self.logger.info(
+                            f"Calculate enriched {metric} on train combined "
+                            f"features: {fitting_enriched_X.columns.to_list()}"
+                        )
+                        (
+                            enriched_estimator,
+                            enriched_metric,
+                            updating_shaps,
+                            uplift,
+                            uplift_perc,
+                        ) = evaluate_enriched(None, "on train combined features")
 
                     train_metrics = {
                         self.bundle.get("quality_metrics_segment_header"): self.bundle.get(
@@ -1323,6 +1352,7 @@ class FeaturesEnricher(TransformerMixin):
                     elif uplift_col in metrics_df.columns and (metrics_df[uplift_col] < 0).any():
                         self.logger.warning("Uplift is negative")
 
+                    self.metrics_metric_name = metric
                     return metrics_df
             except Exception as e:
                 error_message = "Failed to calculate metrics" + (
@@ -2224,6 +2254,69 @@ class FeaturesEnricher(TransformerMixin):
         column = new_external[0]
         return column if self._is_ensemble_feature(column) else None
 
+    def _has_single_ensemble_score(self) -> bool:
+        return self._get_single_ensemble_score_name() is not None
+
+    def _get_single_ensemble_score_name(self) -> str | None:
+        selected = list(self.feature_names_ or [])
+        ensemble = [name for name in selected if self._is_ensemble_feature(name)]
+        if len(ensemble) != 1:
+            return None
+        etalon_columns = set()
+        if self._search_task is not None:
+            etalon_columns = {
+                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]
+
+    def _reports_dir(self) -> Path:
+        return Path(self.reports_path) if self.reports_path else Path.cwd() / "reports"
+
+    def _reference_rows(self) -> int | None:
+        if self.X is None:
+            return None
+        rows = _num_samples(self.X)
+        for eval_pair in self.eval_set or []:
+            rows += _num_samples(eval_pair[0])
+        return rows
+
+    def _report_sample_names(self) -> list[str]:
+        samples = [self.bundle.get("quality_metrics_train_segment")]
+        for idx, _ in enumerate(self.eval_set or []):
+            samples.append(self.bundle.get("quality_metrics_eval_segment").format(idx + 1))
+        return samples
+
+    def _assemble_report_data(self):
+        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,
+            search_keys=[str(sk) for sk in self.search_keys.values()],
+            search_duration_seconds=self.search_duration_seconds,
+            reference_rows=self._reference_rows(),
+            samples=self._report_sample_names(),
+            metrics_df=self.metrics,
+            metric_name=self.metrics_metric_name,
+            bundle=self.bundle,
+        )
+
+    def _write_score_report(self) -> str | None:
+        if self._search_task is None or not self._has_single_ensemble_score():
+            return None
+        report_data = self._assemble_report_data()
+        html = generate_html_report(report_data)
+        reports_dir = self._reports_dir()
+        reports_dir.mkdir(parents=True, exist_ok=True)
+        path = reports_dir / f"upgini-report-{report_data.metadata.search_id}.html"
+        path.write_text(html, encoding="utf-8")
+        self.report_file_path = str(path)
+        self.logger.info(f"Score report saved to {path}")
+        return self.report_file_path
+
     def _is_ensemble_feature(self, column_name: str) -> bool:
         renaming = self.fit_columns_renaming or {}
         aliases = self._column_name_aliases([column_name], renaming)
@@ -4126,6 +4219,7 @@ if response.status_code == 200:
         self._fit_match_search_keys = None
         self.__cached_sampled_datasets = dict()
         self.metrics = None
+        self.metrics_metric_name = None
         self.fit_columns_renaming = None
         self.fit_dropped_features = set()
         self.fit_generated_features = []
@@ -4536,6 +4630,7 @@ if response.status_code == 200:
 
             self._search_task.poll_result(self._get_trace_id(), quiet=True)
             self.__persist_transform_match_hashes()
+            self.search_duration_seconds = time.time() - start_time
 
             seconds_left = time.time() - start_time
             progress = SearchProgress(97.0, ProgressStage.GENERATING_REPORT, seconds_left)
@@ -5942,6 +6037,15 @@ if response.status_code == 200:
 
     def __show_report_button(self, display_id: str | None = None, display_handle=None):
         try:
+            report_path = self._write_score_report()
+            if report_path is not None:
+                if not ipython_available():
+                    print(f"Full report saved to {report_path}")
+                    return
+                return show_button_open_report(
+                    report_path, 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.dev1/src/upgini/report/__init__.py

@@ -0,0 +1,5 @@
+from upgini.report.assemble import assemble_report_data, format_search_duration
+from upgini.report.data import ReportData
+from upgini.report.html import generate_html_report
+
+__all__ = ["ReportData", "assemble_report_data", "format_search_duration", "generate_html_report"]

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

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+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
+from upgini.resource_bundle import ResourceBundle
+
+
+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,
+    bundle: ResourceBundle,
+) -> ReportData:
+    generated_at = generated_at or datetime.now(timezone.utc)
+    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=list(samples or []),
+        ),
+        quality_by_sample=_quality_samples(metrics_df, metric_name, bundle),
+    )
+
+
+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
+
+    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_str(row[baseline_col]) if baseline_col in metrics_df.columns else None,
+                enriched=_as_str(row[enriched_col]) if enriched_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 _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)

upgini-1.2.167a4220.dev1/src/upgini/report/data.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ReportMetadata:
+    search_id: str
+    generated_at: str
+    pylib_version: str
+    search_keys: list[str] = field(default_factory=list)
+    search_duration: Optional[str] = None
+    reference_rows: Optional[int] = None
+    samples: list[str] = field(default_factory=list)
+
+
+@dataclass
+class QualitySample:
+    evaluation_scope: str
+    metric: str
+    baseline: Optional[str] = None
+    enriched: Optional[str] = None
+    uplift: Optional[float] = None
+    relative_uplift: Optional[str] = None
+
+
+@dataclass
+class FeatureRow:
+    name: str
+    shap: Optional[float] = None
+    psi: Optional[float] = None
+    drift: Optional[float] = None
+    coverage: Optional[float] = None
+    provider: str = ""
+    source: str = ""
+    stability_status: Optional[str] = None
+
+
+@dataclass
+class SourceRow:
+    provider: str
+    source: str
+    shap_sum: Optional[float] = None
+    feature_count: Optional[int] = None
+
+
+@dataclass
+class SearchResultsSummary:
+    relevant_features: Optional[int] = None
+    model_features: Optional[int] = None
+    data_sources: Optional[int] = None
+    stable_features_share: Optional[float] = None
+
+
+@dataclass
+class ModelFeatureShap:
+    rank: int
+    feature: str
+    provider: str = ""
+    mean_abs_shap: Optional[float] = None
+
+
+@dataclass
+class ReportData:
+    metadata: ReportMetadata
+    quality_by_sample: list[QualitySample] = field(default_factory=list)
+    summary: SearchResultsSummary = field(default_factory=SearchResultsSummary)
+    features: list[FeatureRow] = field(default_factory=list)
+    sources: list[SourceRow] = field(default_factory=list)
+    autofe: list[dict[str, str]] = field(default_factory=list)
+    model_feature_shap: list[ModelFeatureShap] = field(default_factory=list)

upgini-1.2.167a4220.dev1/src/upgini/report/html.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+from html import escape
+from typing import Optional
+
+from upgini.report.data import FeatureRow, QualitySample, ReportData, SearchResultsSummary, SourceRow
+
+
+def generate_html_report(data: ReportData) -> str:
+    meta = data.metadata
+    keys = ", ".join(meta.search_keys) if meta.search_keys else "—"
+    samples = ", ".join(meta.samples) if meta.samples else "—"
+    duration = meta.search_duration or "—"
+    rows = f"{meta.reference_rows:,}" if meta.reference_rows is not None else "—"
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Upgini search report {escape(meta.search_id)}</title>
+  <style>
+    :root {{
+      --bg: #f4f1ea;
+      --ink: #1c1917;
+      --muted: #57534e;
+      --card: #fffdf8;
+      --line: #e7e0d4;
+      --accent: #0f766e;
+      --accent-ink: #134e4a;
+      --chip: #ecfdf5;
+    }}
+    * {{ box-sizing: border-box; }}
+    body {{
+      margin: 0;
+      color: var(--ink);
+      background: var(--bg);
+      font-family: "Source Sans 3", "Segoe UI", Helvetica, Arial, sans-serif;
+      line-height: 1.45;
+    }}
+    header {{
+      background: #1c1917;
+      color: #fafaf9;
+      padding: 28px 32px 24px;
+    }}
+    header .kicker {{
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+      font-size: 12px;
+      color: #a8a29e;
+      margin-bottom: 8px;
+    }}
+    h1 {{ margin: 0 0 12px; font-size: 28px; font-weight: 600; }}
+    .chips {{ display: flex; flex-wrap: wrap; gap: 8px; }}
+    .chip {{
+      background: #292524;
+      color: #e7e5e4;
+      border-radius: 999px;
+      padding: 4px 10px;
+      font-size: 13px;
+    }}
+    main {{ max-width: 1080px; margin: 0 auto; padding: 24px 20px 48px; }}
+    section {{
+      background: var(--card);
+      border: 1px solid var(--line);
+      border-radius: 12px;
+      padding: 20px 22px;
+      margin-bottom: 16px;
+    }}
+    h2 {{ margin: 0 0 14px; font-size: 18px; }}
+    .meta-grid, .cards {{
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+      gap: 12px;
+    }}
+    .meta-item .label, .card .label {{
+      color: var(--muted);
+      font-size: 12px;
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+    }}
+    .meta-item .value, .card .value {{
+      font-size: 20px;
+      font-weight: 600;
+      margin-top: 4px;
+    }}
+    table {{
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 14px;
+    }}
+    th, td {{
+      text-align: left;
+      padding: 8px 10px;
+      border-bottom: 1px solid var(--line);
+      vertical-align: top;
+    }}
+    th {{ color: var(--muted); font-weight: 600; font-size: 12px; text-transform: uppercase; }}
+    .num {{ text-align: right; font-variant-numeric: tabular-nums; }}
+    .uplift {{ color: var(--accent-ink); font-weight: 600; }}
+    .empty {{ color: var(--muted); }}
+  </style>
+</head>
+<body>
+  <header>
+    <div class="kicker">Upgini search report</div>
+    <h1>FIT completed successfully</h1>
+    <div class="chips">
+      <span class="chip">search_id={escape(meta.search_id)}</span>
+      <span class="chip">{escape(keys)}</span>
+    </div>
+  </header>
+  <main>
+    <section>
+      <h2>Overview</h2>
+      <div class="meta-grid">
+        {_meta_item("Generated", meta.generated_at)}
+        {_meta_item("PyLib version", meta.pylib_version)}
+        {_meta_item("Search duration", duration)}
+        {_meta_item("Rows processed", rows)}
+        {_meta_item("Samples", samples)}
+      </div>
+    </section>
+    {_summary_section(data.summary)}
+    {_quality_section(data.quality_by_sample)}
+    {_features_section(data.features)}
+    {_sources_section(data.sources)}
+    {_autofe_section(data.autofe)}
+  </main>
+</body>
+</html>
+"""
+
+
+def _meta_item(label: str, value: str) -> str:
+    return (
+        f'<div class="meta-item"><div class="label">{escape(label)}</div>'
+        f'<div class="value">{escape(str(value))}</div></div>'
+    )
+
+
+def _card(label: str, value) -> str:
+    return (
+        f'<div class="card"><div class="label">{escape(label)}</div>'
+        f'<div class="value">{escape(str(value))}</div></div>'
+    )
+
+
+def _dash(value: Optional[object]) -> str:
+    if value is None or value == "":
+        return "—"
+    return str(value)
+
+
+def _summary_section(summary: SearchResultsSummary) -> str:
+    if all(
+        value is None
+        for value in (
+            summary.relevant_features,
+            summary.model_features,
+            summary.data_sources,
+            summary.stable_features_share,
+        )
+    ):
+        return ""
+    stable = (
+        f"{summary.stable_features_share * 100:.0f}%"
+        if summary.stable_features_share is not None
+        else "—"
+    )
+    return f"""<section>
+      <h2>Summary</h2>
+      <div class="cards">
+        {_card("Features found", _dash(summary.relevant_features))}
+        {_card("Used in model", _dash(summary.model_features))}
+        {_card("Data sources", _dash(summary.data_sources))}
+        {_card("Stable features", stable)}
+      </div>
+    </section>"""
+
+
+def _quality_section(samples: list[QualitySample]) -> str:
+    if not samples:
+        return '<section><h2>Key result</h2><p class="empty">Metrics were not calculated for this search.</p></section>'
+    metric = samples[0].metric or "score"
+    rows = []
+    for sample in samples:
+        rows.append(
+            "<tr>"
+            f"<td>{escape(sample.evaluation_scope)}</td>"
+            f"<td class='num'>{escape(_dash(sample.baseline))}</td>"
+            f"<td class='num'>{escape(_dash(sample.enriched))}</td>"
+            f"<td class='num uplift'>{escape(_dash(sample.uplift))}</td>"
+            f"<td class='num uplift'>{escape(_dash(sample.relative_uplift))}</td>"
+            "</tr>"
+        )
+    return f"""<section>
+      <h2>Key result · {escape(metric)}</h2>
+      <table>
+        <thead>
+          <tr>
+            <th>Scope</th>
+            <th class="num">Baseline</th><th class="num">Enriched</th>
+            <th class="num">Uplift, abs</th><th class="num">Uplift, %</th>
+          </tr>
+        </thead>
+        <tbody>{''.join(rows)}</tbody>
+      </table>
+    </section>"""
+
+
+def _features_section(features: list[FeatureRow]) -> str:
+    if not features:
+        return ""
+    rows = []
+    for idx, feature in enumerate(features, start=1):
+        rows.append(
+            "<tr>"
+            f"<td class='num'>{idx}</td>"
+            f"<td>{escape(feature.name)}</td>"
+            f"<td>{escape(feature.provider)}</td>"
+            f"<td>{escape(feature.source)}</td>"
+            f"<td class='num'>{escape(_dash(feature.shap))}</td>"
+            f"<td class='num'>{escape(_dash(feature.psi))}</td>"
+            f"<td class='num'>{escape(_dash(feature.drift))}</td>"
+            f"<td class='num'>{escape(_dash(feature.coverage))}</td>"
+            "</tr>"
+        )
+    return f"""<section>
+      <h2>Search results · features</h2>
+      <table>
+        <thead>
+          <tr>
+            <th class="num">#</th><th>Feature</th><th>Provider</th><th>Source</th>
+            <th class="num">SHAP</th><th class="num">PSI</th>
+            <th class="num">Drift</th><th class="num">Coverage %</th>
+          </tr>
+        </thead>
+        <tbody>{''.join(rows)}</tbody>
+      </table>
+    </section>"""
+
+
+def _sources_section(sources: list[SourceRow]) -> str:
+    if not sources:
+        return ""
+    rows = []
+    for source in sources:
+        rows.append(
+            "<tr>"
+            f"<td>{escape(source.provider)}</td>"
+            f"<td>{escape(source.source)}</td>"
+            f"<td class='num'>{escape(_dash(source.shap_sum))}</td>"
+            f"<td class='num'>{escape(_dash(source.feature_count))}</td>"
+            "</tr>"
+        )
+    return f"""<section>
+      <h2>Search results · sources</h2>
+      <table>
+        <thead>
+          <tr><th>Provider</th><th>Source</th><th class="num">SHAP sum</th><th class="num">Features</th></tr>
+        </thead>
+        <tbody>{''.join(rows)}</tbody>
+      </table>
+    </section>"""
+
+
+def _autofe_section(autofe: list[dict[str, str]]) -> str:
+    if not autofe:
+        return ""
+    columns = list(autofe[0].keys())
+    head = "".join(f"<th>{escape(col)}</th>" for col in columns)
+    rows = []
+    for item in autofe:
+        rows.append("<tr>" + "".join(f"<td>{escape(item.get(col, ''))}</td>" for col in columns) + "</tr>")
+    return f"""<section>
+      <h2>AutoFE</h2>
+      <table>
+        <thead><tr>{head}</tr></thead>
+        <tbody>{''.join(rows)}</tbody>
+      </table>
+    </section>"""

{upgini-1.2.166a4253.dev2 → upgini-1.2.167a4220.dev1}/src/upgini/utils/display_utils.py

@@ -327,6 +327,37 @@ def prepare_and_show_report(
         return show_button_download_pdf(report, display_id=display_id, display_handle=display_handle)
 
 
+def show_button_open_report(
+    path: str, title="Open full report", display_id: Optional[str] = None, display_handle=None
+):
+    import webbrowser
+    from pathlib import Path
+
+    from IPython.display import HTML, display
+    from ipywidgets import Button, Layout
+
+    resolved = Path(path).resolve()
+    path_html = f'<div style="margin-top:6px;font-size:12px;color:#57534e">{resolved}</div>'
+    link_html = f"""<div>
+        <a href="{resolved.as_uri()}" target="_blank" rel="noopener noreferrer">
+            <button type="button">{title}</button>
+        </a>
+        {path_html}
+    </div>"""
+    if display_handle is not None:
+        display_handle.update(HTML(link_html))
+        return
+
+    button = Button(description=title, layout=Layout(width="auto"))
+
+    def on_click(b):
+        webbrowser.open(resolved.as_uri())
+
+    button.on_click(on_click)
+    display(button)
+    return display(HTML(path_html), display_id=display_id)
+
+
 def show_button_download_pdf(
     source: str, title="\U0001f4ca Download PDF report", display_id: Optional[str] = None, display_handle=None
 ):

upgini-1.2.166a4253.dev2/src/upgini/__about__.py

@@ -1 +0,0 @@
-__version__ = "1.2.166.a4253.dev2"