upgini 1.2.167a4220.dev2__tar.gz → 1.2.167a4220.dev3__tar.gz

{upgini-1.2.167a4220.dev2 → upgini-1.2.167a4220.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: upgini
-Version: 1.2.167a4220.dev2
+Version: 1.2.167a4220.dev3
 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.dev2 → upgini-1.2.167a4220.dev3}/pyproject.toml

@@ -73,6 +73,9 @@ packages = [
     "src/upgini"
 ]
 
+[tool.hatch.build.targets.wheel.force-include]
+"src/upgini/report/template.html" = "upgini/report/template.html"
+
 [tool.hatch.build]
 include = [
   "/src/utils/Roboto-Regular.ttf",

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

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

{upgini-1.2.167a4220.dev2 → upgini-1.2.167a4220.dev3}/src/upgini/features_enricher.py

@@ -185,9 +185,6 @@ 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"
@@ -265,7 +262,6 @@ 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)
@@ -335,9 +331,8 @@ 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
+        self.report_html: str | None = None
 
         if search_id:
             search_task = SearchTask(search_id, rest_client=self.rest_client, logger=self.logger)
@@ -2305,9 +2300,6 @@ class FeaturesEnricher(TransformerMixin):
             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
@@ -2337,18 +2329,12 @@ class FeaturesEnricher(TransformerMixin):
             bundle=self.bundle,
         )
 
-    def _write_score_report(self) -> str | None:
+    def _score_report_html(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
+        self.report_html = generate_html_report(report_data)
+        return self.report_html
 
     def _is_ensemble_feature(self, column_name: str) -> bool:
         renaming = self.fit_columns_renaming or {}
@@ -4267,7 +4253,7 @@ if response.status_code == 200:
         self.metrics = None
         self.metrics_raw = None
         self.metrics_metric_name = None
-        self.report_file_path = None
+        self.report_html = None
         self.fit_columns_renaming = None
         self.fit_dropped_features = set()
         self.fit_generated_features = []
@@ -6085,13 +6071,16 @@ 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() or self.report_file_path
-            if report_path:
+            report_html = self._score_report_html() or self.report_html
+            if report_html:
                 if not ipython_available():
-                    print(f"Full report saved to {report_path}")
                     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_path, display_id=display_id, display_handle=display_handle
+                    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()

{upgini-1.2.167a4220.dev2 → upgini-1.2.167a4220.dev3}/src/upgini/report/assemble.py

@@ -79,8 +79,9 @@ def _quality_samples(
                 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,
-                std=_metric_std(row, metrics_df.columns, enriched_std_col, baseline_std_col),
+                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,
             )
@@ -112,16 +113,6 @@ def _sample_stats(
     return stats
 
 
-def _metric_std(row, columns, enriched_std_col: Optional[str], baseline_std_col: Optional[str]) -> Optional[float]:
-    if enriched_std_col in columns:
-        std = _as_float(row[enriched_std_col])
-        if std is not None:
-            return std
-    if baseline_std_col in columns:
-        return _as_float(row[baseline_std_col])
-    return None
-
-
 def _as_str(value) -> Optional[str]:
     return None if pd.isna(value) else str(value)
 

{upgini-1.2.167a4220.dev2 → upgini-1.2.167a4220.dev3}/src/upgini/report/data.py

@@ -21,11 +21,16 @@ class QualitySample:
     evaluation_scope: str
     metric: str
     baseline: Optional[float] = None
+    baseline_std: Optional[float] = None
     enriched: Optional[float] = None
-    std: Optional[float] = None
+    enriched_std: Optional[float] = None
     uplift: Optional[float] = None
     relative_uplift: Optional[str] = None
 
+    @property
+    def std(self) -> Optional[float]:
+        return self.enriched_std if self.enriched_std is not None else self.baseline_std
+
 
 @dataclass
 class SampleStats:

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

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from upgini.report.data import ReportData, SampleStats, SearchResultsSummary
+
+_TEMPLATE_PATH = Path(__file__).with_name("template.html")
+_SAMPLE_COLORS = ("#1645ee", "#20aab4", "#53cc61", "#e19132", "#d45b5b")
+
+
+def generate_html_report(data: ReportData) -> str:
+    template = _TEMPLATE_PATH.read_text(encoding="utf-8")
+    if "__REPORT_DATA__" not in template:
+        raise RuntimeError("Report template is missing the REPORT_DATA placeholder")
+    payload = json.dumps(_report_payload(data), ensure_ascii=False, indent=2)
+    payload = payload.replace("<", "\\u003c").replace(">", "\\u003e")
+    return template.replace("__REPORT_DATA__", payload, 1)
+
+
+def _report_payload(data: ReportData) -> dict:
+    samples = _samples(data)
+    return {
+        "meta": _meta(data, samples),
+        "timeline": {"months": [], "periodOptions": [], "defaultPeriod": 0},
+        "samples": samples,
+        "keyResult": _key_result(data),
+        "summaryCards": _summary_cards(data.summary),
+        "sampleStats": _sample_stats_payload(data, samples),
+        "scoreAnalysis": {"bySample": {}},
+        "scoreDistribution": {"bySample": {}},
+        "scoreStability": {"bySample": {}},
+        "features": [],
+        "featureStability": {"bySample": {}},
+        "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": [],
+        },
+    }
+
+
+def _meta(data: ReportData, samples: list[dict]) -> dict:
+    meta = data.metadata
+    payload = {
+        "reportTitle": "Feature enrichment report",
+        "reportSubtitle": (
+            "Impact of external data on model quality, score dynamics, and the stability of discovered features."
+        ),
+        "searchId": meta.search_id,
+        "generatedAt": meta.generated_at,
+        "pylibVersion": meta.pylib_version,
+        "searchKeys": list(meta.search_keys),
+        "sampleNames": [sample["id"] for sample in samples],
+        "searchDuration": meta.search_duration,
+        "sourcesCount": data.summary.data_sources,
+        "totalRows": meta.reference_rows,
+        "statusLine": "FIT completed successfully",
+        "downloadFileName": f"upgini-report-{meta.search_id}.html",
+    }
+    if meta.logo_url:
+        payload["partnerLogo"] = {"src": meta.logo_url, "alt": "", "height": 30}
+    return payload
+
+
+def _samples(data: ReportData) -> list[dict]:
+    names = [stats.sample for stats in data.sample_stats] or list(data.metadata.samples)
+    return [
+        {
+            "id": _slug(name),
+            "label": name,
+            "caption": "",
+            "color": _SAMPLE_COLORS[index % len(_SAMPLE_COLORS)],
+        }
+        for index, name in enumerate(names)
+    ]
+
+
+def _key_result(data: ReportData) -> dict:
+    metrics: dict[str, dict] = {}
+    for sample in data.quality_by_sample:
+        key = _slug(sample.metric or "score")
+        bucket = metrics.setdefault(key, {"name": sample.metric or "score", "bySample": {}})
+        bucket["bySample"][_slug(sample.evaluation_scope)] = {
+            "baseline": sample.baseline,
+            "baselineCi": sample.baseline_std,
+            "enriched": sample.enriched,
+            "enrichedCi": sample.enriched_std,
+        }
+    default_metric = next(iter(metrics), "")
+    has_std = any(
+        sample.baseline_std is not None or sample.enriched_std is not None for sample in data.quality_by_sample
+    )
+    return {
+        "title": "Key result",
+        "headline": "",
+        "defaultMetric": default_metric,
+        "confidenceNote": "± values are cross-validation standard deviation" if has_std else "",
+        "columns": {
+            "sample": "Sample",
+            "baseline": "Baseline",
+            "enriched": "Enriched",
+            "upliftAbs": "Uplift, abs",
+            "upliftPct": "Uplift, %",
+        },
+        "metrics": metrics,
+    }
+
+
+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}%"
+    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": ""},
+    ]
+
+
+def _sample_stats_payload(data: ReportData, samples: list[dict]) -> dict:
+    by_id = {_slug(stats.sample): stats for stats in data.sample_stats}
+    rows = [
+        _stat_row("Date range", samples, by_id, lambda stats: stats.date_range),
+        _stat_row("Count", samples, by_id, lambda stats: _format_int(stats.rows)),
+        _stat_row("Count (target)", samples, by_id, lambda stats: _format_int(stats.labeled)),
+    ]
+    if data.is_binary:
+        rows.append(_stat_row("Count 1's (target)", samples, by_id, lambda stats: _format_int(stats.positive)))
+    rows.extend(
+        [
+            _stat_row("Mean (target)", samples, by_id, lambda stats: _format_mean(stats.mean_target)),
+            _stat_row("Count (unlabeled)", samples, by_id, lambda stats: _format_int(stats.unlabeled)),
+        ]
+    )
+    return {"rows": rows, "monthlyAxis": [], "monthlyPoints": []}
+
+
+def _stat_row(label: str, samples: list[dict], by_id: dict[str, SampleStats], value) -> dict:
+    values = {}
+    for sample in samples:
+        stats = by_id.get(sample["id"]) or SampleStats(sample=sample["label"])
+        values[sample["id"]] = _dash(value(stats))
+    return {"label": label, "values": values}
+
+
+def _slug(name: str) -> str:
+    return name.strip().lower().replace(" ", "_")
+
+
+def _dash(value: Optional[object]) -> str:
+    if value is None or value == "":
+        return "—"
+    return str(value)
+
+
+def _format_int(value: Optional[int]) -> Optional[str]:
+    return f"{value:,}" if value is not None else None
+
+
+def _format_mean(value: Optional[float]) -> Optional[str]:
+    return f"{value:.3f}" if value is not None else None