upgini 1.2.167a4220.dev2__tar.gz → 1.2.167a4220.dev4__tar.gz

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

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

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

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

@@ -100,6 +100,7 @@ from upgini.utils.deduplicate_utils import (
 )
 from upgini.report.assemble import assemble_report_data
 from upgini.report.html import generate_html_report
+from upgini.report.stats import make_report_frame
 from upgini.utils.display_utils import (
     display_html_dataframe,
     do_without_pandas_limits,
@@ -185,9 +186,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 +263,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 +332,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 +2301,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
@@ -2316,17 +2309,135 @@ class FeaturesEnricher(TransformerMixin):
             rows += _num_samples(eval_pair[0])
         return rows
 
+    def _search_key_names(self) -> list[str]:
+        return [key.name for key in self.search_keys.values()]
+
     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 _report_dataset_samples(self) -> dict[str, pd.DataFrame]:
+        names = self._report_sample_names()
+        if self.df_with_original_index is not None:
+            return self._report_samples_from_combined(self.df_with_original_index, names, self.fit_search_keys)
+        if self.X is None or self.y is None:
+            return {}
+        date_col = self._get_date_column(self.search_keys)
+        frames = {names[0]: self._report_xy_frame(self.X, self.y, date_col)}
+        for idx, (eval_x, eval_y) in enumerate(self.eval_set or []):
+            if idx + 1 >= len(names):
+                break
+            frames[names[idx + 1]] = self._report_xy_frame(eval_x, eval_y, date_col)
+        return frames
+
+    def _report_samples_from_combined(
+        self, df: pd.DataFrame, names: list[str], search_keys: dict[str, SearchKey] | None
+    ) -> dict[str, pd.DataFrame]:
+        date_col = self._get_date_column(search_keys or {})
+        if EVAL_SET_INDEX not in df.columns:
+            return {names[0]: self._report_df_frame(df, date_col)} if names else {}
+        frames: dict[str, pd.DataFrame] = {}
+        for eval_idx in sorted(pd.unique(df[EVAL_SET_INDEX].dropna())):
+            name_idx = int(eval_idx)
+            if name_idx >= len(names):
+                continue
+            frames[names[name_idx]] = self._report_df_frame(df[df[EVAL_SET_INDEX] == eval_idx], date_col)
+        return frames
+
+    def _report_xy_frame(self, X, y, date_col: str | None) -> pd.DataFrame:
+        date = X[date_col] if isinstance(X, pd.DataFrame) and date_col and date_col in X.columns else None
+        return make_report_frame(y, date=date)
+
+    def _report_df_frame(self, df: pd.DataFrame, date_col: str | None) -> pd.DataFrame:
+        target = df[TARGET] if TARGET in df.columns else pd.Series(np.nan, index=df.index)
+        return self._report_xy_frame(df, target, date_col)
+
+    def _report_scored_samples(self) -> dict[str, pd.DataFrame]:
+        cached = self._peek_cached_sampled()
+        if cached is None:
+            return {}
+        X_sampled, y_sampled, enriched_X, eval_set_sampled_dict, search_keys, columns_renaming, _generated = cached
+        score_col = self._report_score_column(enriched_X)
+        if score_col is None:
+            return {}
+        date_col = self._get_date_column(search_keys or {})
+        names = self._report_sample_names()
+        frames = {
+            names[0]: self._report_scored_frame(
+                X_sampled, y_sampled, enriched_X, score_col, date_col, columns_renaming
+            )
+        }
+        for idx, (eval_X, enriched_eval_X, eval_y) in eval_set_sampled_dict.items():
+            name_idx = idx + 1
+            if name_idx >= len(names):
+                continue
+            frames[names[name_idx]] = self._report_scored_frame(
+                eval_X, eval_y, enriched_eval_X, score_col, date_col, columns_renaming
+            )
+        return frames
+
+    def _report_scored_frame(
+        self,
+        X: pd.DataFrame,
+        y,
+        enriched: pd.DataFrame,
+        score_col: str,
+        date_col: str | None,
+        columns_renaming: dict[str, str] | None,
+    ) -> pd.DataFrame:
+        target = y
+        if target is None and TARGET in enriched.columns:
+            target = enriched[TARGET]
+        date_name = self._report_existing_column(date_col, columns_renaming, X, enriched)
+        baseline_name = self._report_existing_column(self.baseline_score_column, columns_renaming, X, enriched)
+        return make_report_frame(
+            target,
+            date=self._report_column_values(date_name, X, enriched),
+            score=enriched[score_col] if score_col in enriched.columns else None,
+            baseline=self._report_column_values(baseline_name, X, enriched),
+        )
+
+    def _report_score_column(self, enriched_X: pd.DataFrame) -> str | None:
+        name = self._get_single_ensemble_score_name()
+        if name and name in enriched_X.columns:
+            return name
+        return None
+
+    def _report_existing_column(
+        self, name: str | None, renaming: dict[str, str] | None, *frames: pd.DataFrame
+    ) -> str | None:
+        if not name:
+            return None
+        aliases = self._column_name_aliases([name], renaming or {})
+        for frame in frames:
+            if not isinstance(frame, pd.DataFrame):
+                continue
+            for col in frame.columns:
+                if col in aliases:
+                    return col
+        return None
+
+    @staticmethod
+    def _report_column_values(column: str | None, *frames: pd.DataFrame):
+        if not column:
+            return None
+        for frame in frames:
+            if isinstance(frame, pd.DataFrame) and column in frame.columns:
+                return frame[column]
+        return None
+
+    def _peek_cached_sampled(self):
+        if not self.__cached_sampled_datasets:
+            return None
+        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):
         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_keys=self._search_key_names(),
             search_duration_seconds=self.search_duration_seconds,
             reference_rows=self._reference_rows(),
             samples=self._report_sample_names(),
@@ -2334,21 +2445,17 @@ class FeaturesEnricher(TransformerMixin):
             metric_name=self.metrics_metric_name,
             model_features=self._ensemble_model_feature_count(),
             is_binary=self.model_task_type == ModelTaskType.BINARY,
+            dataset_samples=self._report_dataset_samples(),
+            scored_samples=self._report_scored_samples(),
             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 +4374,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 +6192,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()
@@ -6103,7 +6213,7 @@ if response.status_code == 200:
                 autofe_descriptions_df=self.get_autofe_features_description(),
                 search_id=self._search_task.search_task_id,
                 email=self.rest_client.get_current_email(),
-                search_keys=[str(sk) for sk in self.search_keys.values()],
+                search_keys=self._search_key_names(),
                 eval_sets_drift_df=eval_sets_drift_df,
                 display_id=display_id,
                 display_handle=display_handle,

upgini-1.2.167a4220.dev4/src/upgini/report/__init__.py

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

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from datetime import datetime, timezone
 from typing import Optional
 
@@ -7,8 +8,11 @@ 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:
@@ -36,11 +40,19 @@ def assemble_report_data(
     metric_name: Optional[str] = None,
     model_features: Optional[int] = None,
     is_binary: bool = False,
-    logo_url: Optional[str] = None,
+    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,
@@ -50,15 +62,23 @@ def assemble_report_data(
             search_duration=format_search_duration(search_duration_seconds),
             reference_rows=reference_rows,
             samples=sample_names,
-            logo_url=logo_url or None,
+            logo_url=_branding_url(),
         ),
         quality_by_sample=_quality_samples(metrics_df, metric_name, bundle),
         summary=SearchResultsSummary(model_features=model_features),
-        sample_stats=_sample_stats(sample_names, metrics_df, bundle),
+        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]:
@@ -79,8 +99,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 +133,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.dev4}/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:
@@ -74,6 +79,70 @@ class ModelFeatureShap:
     mean_abs_shap: Optional[float] = None
 
 
+@dataclass
+class MonthlySamplePoint:
+    month: str
+    sample: str
+    total: int
+    labeled: int
+    unlabeled: int
+    positive: int
+    mean: Optional[float] = None
+
+
+@dataclass
+class QualityMonthly:
+    evaluation_scope: str
+    metric: str
+    baseline: list[Optional[float]] = field(default_factory=list)
+    enriched: list[Optional[float]] = field(default_factory=list)
+
+
+@dataclass
+class ScoreMonthlyStats:
+    sample: str
+    mean_score: list[Optional[float]] = field(default_factory=list)
+    mean_target: list[Optional[float]] = field(default_factory=list)
+    labeled: list[Optional[int]] = field(default_factory=list)
+    unlabeled: list[Optional[int]] = field(default_factory=list)
+
+
+@dataclass
+class ScoreHistogram:
+    sample: str
+    target_0: list[float] = field(default_factory=list)
+    target_1: list[float] = field(default_factory=list)
+    n_target_0: int = 0
+    n_target_1: int = 0
+
+
+@dataclass
+class ScorePsi:
+    sample: str
+    psi: list[Optional[float]] = field(default_factory=list)
+    rows: list[Optional[int]] = field(default_factory=list)
+    coverage: list[Optional[float]] = field(default_factory=list)
+
+
+@dataclass
+class ReportCharts:
+    timeline_months: list[str] = field(default_factory=list)
+    period_options: list[int] = field(default_factory=list)
+    default_period: int = 0
+    sample_monthly: list[MonthlySamplePoint] = field(default_factory=list)
+    monthly_count_max: int = 0
+    quality_monthly: list[QualityMonthly] = field(default_factory=list)
+    score_monthly: list[ScoreMonthlyStats] = field(default_factory=list)
+    score_count_axis_max: int = 0
+    histogram_bin_edges: list[float] = field(default_factory=list)
+    histograms: list[ScoreHistogram] = field(default_factory=list)
+    histogram_density_max: float = 0.0
+    score_psi: list[ScorePsi] = field(default_factory=list)
+    psi_axis_max: float = 0.32
+    psi_warning: float = 0.1
+    psi_critical: float = 0.25
+
+
 @dataclass
 class ReportData:
     metadata: ReportMetadata
@@ -85,3 +154,4 @@ class ReportData:
     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)
+    charts: ReportCharts = field(default_factory=ReportCharts)