google-meridian 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

meridian/model/eda/eda_engine.py

@@ -48,9 +48,6 @@ _CORRELATION_MATRIX_NAME = 'correlation_matrix'
 _OVERALL_PAIRWISE_CORR_THRESHOLD = 0.999
 _GEO_PAIRWISE_CORR_THRESHOLD = 0.999
 _NATIONAL_PAIRWISE_CORR_THRESHOLD = 0.999
-_EMPTY_DF_FOR_EXTREME_CORR_PAIRS = pd.DataFrame(
-    columns=[_CORR_VAR1, _CORR_VAR2, _CORRELATION_COL_NAME]
-)
 _Q1_THRESHOLD = 0.25
 _Q3_THRESHOLD = 0.75
 _IQR_MULTIPLIER = 1.5
@@ -261,37 +258,57 @@ def _find_extreme_corr_pairs(
   corr_tri = _get_upper_triangle_corr_mat(extreme_corr_da)
   extreme_corr_da = corr_tri.where(abs(corr_tri) > extreme_corr_threshold)
 
-  df = extreme_corr_da.to_dataframe(name=_CORRELATION_COL_NAME).dropna()
-  if df.empty:
-    return _EMPTY_DF_FOR_EXTREME_CORR_PAIRS.copy()
-  return df.sort_values(
-      by=_CORRELATION_COL_NAME, ascending=False, inplace=False
+  return (
+      extreme_corr_da.to_dataframe(name=_CORRELATION_COL_NAME)
+      .dropna()
+      .assign(**{
+          eda_constants.ABS_CORRELATION_COL_NAME: (
+              lambda x: x[_CORRELATION_COL_NAME].abs()
+          )
+      })
+      .sort_values(
+          by=eda_constants.ABS_CORRELATION_COL_NAME,
+          ascending=False,
+          inplace=False,
+      )
   )
 
 
-def _calculate_std(
+def _get_outlier_bounds(
     input_da: xr.DataArray,
-) -> tuple[xr.Dataset, pd.DataFrame]:
-  """Helper function to compute std with and without outliers.
+) -> tuple[xr.DataArray, xr.DataArray]:
+  """Computes lower and upper bounds for outliers across time using the IQR method.
 
   Args:
-    input_da: A DataArray for which to calculate the std.
+    input_da: A DataArray for which to calculate outlier bounds.
 
   Returns:
-    A tuple where the first element is a Dataset with two data variables:
-    'std_incl_outliers' and 'std_excl_outliers'. The second element is a
-    DataFrame with columns for variables, geo (if applicable), time, and
-    outlier values.
+    A tuple containing the lower and upper bounds of outliers as DataArrays.
   """
-  std_with_outliers = input_da.std(dim=constants.TIME, ddof=1)
-
   # TODO: Allow users to specify custom outlier definitions.
   q1 = input_da.quantile(_Q1_THRESHOLD, dim=constants.TIME)
   q3 = input_da.quantile(_Q3_THRESHOLD, dim=constants.TIME)
   iqr = q3 - q1
   lower_bound = q1 - _IQR_MULTIPLIER * iqr
   upper_bound = q3 + _IQR_MULTIPLIER * iqr
+  return lower_bound, upper_bound
+
+
+def _calculate_std(
+    input_da: xr.DataArray,
+) -> xr.Dataset:
+  """Helper function to compute std with and without outliers.
+
+  Args:
+    input_da: A DataArray for which to calculate the std.
+
+  Returns:
+    A Dataset with two data variables: 'std_with_outliers' and
+    'std_without_outliers'.
+  """
+  std_with_outliers = input_da.std(dim=constants.TIME, ddof=1)
 
+  lower_bound, upper_bound = _get_outlier_bounds(input_da)
   da_no_outlier = input_da.where(
       (input_da >= lower_bound) & (input_da <= upper_bound)
   )
@@ -301,17 +318,34 @@ def _calculate_std(
       _STD_WITH_OUTLIERS_VAR_NAME: std_with_outliers,
       _STD_WITHOUT_OUTLIERS_VAR_NAME: std_without_outliers,
   })
+  return std_ds
+
+
+def _calculate_outliers(
+    input_da: xr.DataArray,
+) -> pd.DataFrame:
+  """Helper function to extract outliers from a DataArray across time.
+
+  Args:
+    input_da: A DataArray from which to extract outliers.
 
+  Returns:
+    A DataFrame with columns for variables, geo (if applicable), time, and
+    outlier values.
+  """
+  lower_bound, upper_bound = _get_outlier_bounds(input_da)
   outlier_da = input_da.where(
       (input_da < lower_bound) | (input_da > upper_bound)
   )
-
-  outlier_df = outlier_da.to_dataframe(name=_OUTLIERS_COL_NAME).dropna()
-  outlier_df = outlier_df.assign(
-      **{_ABS_OUTLIERS_COL_NAME: np.abs(outlier_df[_OUTLIERS_COL_NAME])}
-  ).sort_values(by=_ABS_OUTLIERS_COL_NAME, ascending=False, inplace=False)
-
-  return std_ds, outlier_df
+  outlier_df = (
+      outlier_da.to_dataframe(name=_OUTLIERS_COL_NAME)
+      .dropna()
+      .assign(
+          **{_ABS_OUTLIERS_COL_NAME: lambda x: np.abs(x[_OUTLIERS_COL_NAME])}
+      )
+      .sort_values(by=_ABS_OUTLIERS_COL_NAME, ascending=False, inplace=False)
+  )
+  return outlier_df
 
 
 def _calculate_vif(input_da: xr.DataArray, var_dim: str) -> xr.DataArray:
@@ -327,7 +361,9 @@ def _calculate_vif(input_da: xr.DataArray, var_dim: str) -> xr.DataArray:
   """
   num_vars = input_da.sizes[var_dim]
   np_data = input_da.values.reshape(-1, num_vars)
-  np_data_with_const = sm.add_constant(np_data, prepend=True)
+  np_data_with_const = sm.add_constant(
+      np_data, prepend=True, has_constant='add'
+  )
 
   # Compute VIF for each variable excluding const which is the first one in the
   # 'variable' dimension.
@@ -344,6 +380,117 @@ def _calculate_vif(input_da: xr.DataArray, var_dim: str) -> xr.DataArray:
   return vif_da
 
 
+def _check_cost_media_unit_inconsistency(
+    cost_da: xr.DataArray,
+    media_units_da: xr.DataArray,
+) -> pd.DataFrame:
+  """Checks for inconsistencies between cost and media units.
+
+  Args:
+    cost_da: DataArray containing cost data.
+    media_units_da: DataArray containing media unit data.
+
+  Returns:
+    A DataFrame of inconsistencies where either cost is zero and media units
+    are
+    positive, or cost is positive and media units are zero.
+  """
+  cost_media_units_ds = xr.merge([cost_da, media_units_da])
+
+  # Condition 1: cost == 0 and media unit > 0
+  zero_cost_positive_mask = (cost_da == 0) & (media_units_da > 0)
+  zero_cost_positive_media_unit_df = (
+      cost_media_units_ds.where(zero_cost_positive_mask).to_dataframe().dropna()
+  )
+
+  # Condition 2: cost > 0 and media unit == 0
+  positive_cost_zero_mask = (cost_da > 0) & (media_units_da == 0)
+  positive_cost_zero_media_unit_df = (
+      cost_media_units_ds.where(positive_cost_zero_mask).to_dataframe().dropna()
+  )
+
+  return pd.concat(
+      [zero_cost_positive_media_unit_df, positive_cost_zero_media_unit_df]
+  )
+
+
+def _check_cost_per_media_unit(
+    cost_ds: xr.Dataset,
+    media_units_ds: xr.Dataset,
+    level: eda_outcome.AnalysisLevel,
+) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+  """Helper to check if the cost per media unit is valid."""
+  findings = []
+  # Stack variables with the same dimension name, so that they can be operated
+  # on together.
+  cost_da = stack_variables(cost_ds, constants.CHANNEL).rename(constants.SPEND)
+  media_units_da = stack_variables(media_units_ds, constants.CHANNEL).rename(
+      constants.MEDIA_UNITS
+  )
+
+  cost_media_unit_inconsistency_df = _check_cost_media_unit_inconsistency(
+      cost_da,
+      media_units_da,
+  )
+  if not cost_media_unit_inconsistency_df.empty:
+    findings.append(
+        eda_outcome.EDAFinding(
+            severity=eda_outcome.EDASeverity.ATTENTION,
+            explanation=(
+                'There are instances of inconsistent cost and media units.'
+                ' This occurs when cost is zero but media units are positive,'
+                ' or when cost is positive but media units are zero. Please'
+                ' review the outcome artifact for more details.'
+            ),
+        )
+    )
+
+  # Calculate cost per media unit
+  # Avoid division by zero by setting cost to NaN where media units are 0.
+  # Note that both (cost == media unit == 0) and (cost > 0 and media unit ==
+  # 0) result in NaN, while the latter one is not desired.
+  cost_per_media_unit_da = xr.where(
+      media_units_da == 0,
+      np.nan,
+      cost_da / media_units_da,
+  )
+  cost_per_media_unit_da.name = eda_constants.COST_PER_MEDIA_UNIT
+
+  outlier_df = _calculate_outliers(cost_per_media_unit_da)
+  if not outlier_df.empty:
+    findings.append(
+        eda_outcome.EDAFinding(
+            severity=eda_outcome.EDASeverity.ATTENTION,
+            explanation=(
+                'There are outliers in cost per media unit across time.'
+                ' Please review the outcome artifact for more details.'
+            ),
+        )
+    )
+
+  # If no specific findings, add an INFO finding.
+  if not findings:
+    findings.append(
+        eda_outcome.EDAFinding(
+            severity=eda_outcome.EDASeverity.INFO,
+            explanation='Please review the cost per media unit data.',
+        )
+    )
+
+  artifact = eda_outcome.CostPerMediaUnitArtifact(
+      level=level,
+      cost_per_media_unit_da=cost_per_media_unit_da,
+      cost_media_unit_inconsistency_df=cost_media_unit_inconsistency_df,
+      outlier_df=outlier_df,
+  )
+
+  return eda_outcome.EDAOutcome(
+      check_type=eda_outcome.EDACheckType.COST_PER_MEDIA_UNIT,
+      findings=findings,
+      analysis_artifacts=[artifact],
+  )
+
+
 class EDAEngine:
   """Meridian EDA Engine."""
 
@@ -366,6 +513,7 @@ class EDAEngine:
 
   @functools.cached_property
   def controls_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled controls data array."""
     if self._meridian.input_data.controls is None:
       return None
     controls_scaled_da = _data_array_like(
@@ -400,6 +548,7 @@ class EDAEngine:
 
   @functools.cached_property
   def media_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw media data array."""
     if self._meridian.input_data.media is None:
       return None
     raw_media_da = self._truncate_media_time(self._meridian.input_data.media)
@@ -408,6 +557,7 @@ class EDAEngine:
 
   @functools.cached_property
   def media_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled media data array."""
     if self._meridian.input_data.media is None:
       return None
     media_scaled_da = _data_array_like(
@@ -485,6 +635,7 @@ class EDAEngine:
 
   @functools.cached_property
   def organic_media_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw organic media data array."""
     if self._meridian.input_data.organic_media is None:
       return None
     raw_organic_media_da = self._truncate_media_time(
@@ -495,6 +646,7 @@ class EDAEngine:
 
   @functools.cached_property
   def organic_media_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled organic media data array."""
     if self._meridian.input_data.organic_media is None:
       return None
     organic_media_scaled_da = _data_array_like(
@@ -540,6 +692,7 @@ class EDAEngine:
 
   @functools.cached_property
   def non_media_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled non-media treatments data array."""
     if self._meridian.input_data.non_media_treatments is None:
       return None
     non_media_scaled_da = _data_array_like(
@@ -615,12 +768,14 @@ class EDAEngine:
 
   @property
   def reach_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw reach data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.reach_raw_da
 
   @property
   def reach_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled reach data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.reach_scaled_da  # pytype: disable=attribute-error
@@ -641,6 +796,7 @@ class EDAEngine:
 
   @property
   def frequency_da(self) -> xr.DataArray | None:
+    """Returns the frequency data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.frequency_da  # pytype: disable=attribute-error
@@ -654,19 +810,21 @@ class EDAEngine:
 
   @property
   def rf_impressions_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw RF impressions data array."""
     if self._rf_data is None:
       return None
-    return self._rf_data.rf_impressions_raw_da
+    return self._rf_data.rf_impressions_raw_da  # pytype: disable=attribute-error
 
   @property
   def national_rf_impressions_raw_da(self) -> xr.DataArray | None:
     """Returns the national raw RF impressions data array."""
     if self._rf_data is None:
       return None
-    return self._rf_data.national_rf_impressions_raw_da
+    return self._rf_data.national_rf_impressions_raw_da  # pytype: disable=attribute-error
 
   @property
   def rf_impressions_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled RF impressions data array."""
     if self._rf_data is None:
       return None
     return self._rf_data.rf_impressions_scaled_da
@@ -690,12 +848,14 @@ class EDAEngine:
 
   @property
   def organic_reach_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw organic reach data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.reach_raw_da
 
   @property
   def organic_reach_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled organic reach data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.reach_scaled_da  # pytype: disable=attribute-error
@@ -716,6 +876,7 @@ class EDAEngine:
 
   @property
   def organic_rf_impressions_scaled_da(self) -> xr.DataArray | None:
+    """Returns the scaled organic RF impressions data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.rf_impressions_scaled_da
@@ -729,6 +890,7 @@ class EDAEngine:
 
   @property
   def organic_frequency_da(self) -> xr.DataArray | None:
+    """Returns the organic frequency data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.frequency_da  # pytype: disable=attribute-error
@@ -742,6 +904,7 @@ class EDAEngine:
 
   @property
   def organic_rf_impressions_raw_da(self) -> xr.DataArray | None:
+    """Returns the raw organic RF impressions data array."""
     if self._organic_rf_data is None:
       return None
     return self._organic_rf_data.rf_impressions_raw_da
@@ -755,6 +918,7 @@ class EDAEngine:
 
   @functools.cached_property
   def geo_population_da(self) -> xr.DataArray | None:
+    """Returns the geo population data array."""
     if self._is_national_data:
       return None
     return xr.DataArray(
@@ -766,6 +930,7 @@ class EDAEngine:
 
   @functools.cached_property
   def kpi_scaled_da(self) -> xr.DataArray:
+    """Returns the scaled KPI data array."""
     scaled_kpi_da = _data_array_like(
         da=self._meridian.input_data.kpi,
         values=self._meridian.kpi_scaled,
@@ -887,6 +1052,22 @@ class EDAEngine:
     da.name = constants.NATIONAL_TREATMENT_CONTROL_SCALED
     return da
 
+  @functools.cached_property
+  def treatments_without_non_media_scaled_ds(self) -> xr.Dataset:
+    """Returns a Dataset of scaled treatments excluding non-media."""
+    return self.treatment_control_scaled_ds.drop_dims(
+        [constants.NON_MEDIA_CHANNEL, constants.CONTROL_VARIABLE],
+        errors='ignore',
+    )
+
+  @functools.cached_property
+  def national_treatments_without_non_media_scaled_ds(self) -> xr.Dataset:
+    """Returns a Dataset of national scaled treatments excluding non-media."""
+    return self.national_treatment_control_scaled_ds.drop_dims(
+        [constants.NON_MEDIA_CHANNEL, constants.CONTROL_VARIABLE],
+        errors='ignore',
+    )
+
   @functools.cached_property
   def all_reach_scaled_da(self) -> xr.DataArray | None:
     """Returns a DataArray containing all scaled reach data.
@@ -993,6 +1174,30 @@ class EDAEngine:
     da.name = constants.NATIONAL_ALL_FREQUENCY
     return da
 
+  @functools.cached_property
+  def paid_raw_media_units_ds(self) -> xr.Dataset:
+    to_merge = [
+        da
+        for da in [
+            self.media_raw_da,
+            self.rf_impressions_raw_da,
+        ]
+        if da is not None
+    ]
+    return xr.merge(to_merge, join='inner')
+
+  @functools.cached_property
+  def national_paid_raw_media_units_ds(self) -> xr.Dataset:
+    to_merge = [
+        da
+        for da in [
+            self.national_media_raw_da,
+            self.national_rf_impressions_raw_da,
+        ]
+        if da is not None
+    ]
+    return xr.merge(to_merge, join='inner')
+
   @property
   def _critical_checks(
       self,
@@ -1430,8 +1635,8 @@ class EDAEngine:
     """
     if self._is_national_data:
       return self.check_national_pairwise_corr()
-    else:
-      return self.check_geo_pairwise_corr()
+
+    return self.check_geo_pairwise_corr()
 
   def _check_std(
       self,
@@ -1439,10 +1644,11 @@ class EDAEngine:
       level: eda_outcome.AnalysisLevel,
       zero_std_message: str,
   ) -> tuple[
-      Optional[eda_outcome.EDAFinding], eda_outcome.StandardDeviationArtifact
+      eda_outcome.EDAFinding | None, eda_outcome.StandardDeviationArtifact
   ]:
     """Helper to check standard deviation."""
-    std_ds, outlier_df = _calculate_std(data)
+    std_ds = _calculate_std(data)
+    outlier_df = _calculate_outliers(data)
 
     finding = None
     if (std_ds[_STD_WITHOUT_OUTLIERS_VAR_NAME] < _STD_THRESHOLD).any():
@@ -1631,8 +1837,8 @@ class EDAEngine:
     """
     if self._is_national_data:
       return self.check_national_std()
-    else:
-      return self.check_geo_std()
+
+    return self.check_geo_std()
 
   def check_geo_vif(self) -> eda_outcome.EDAOutcome[eda_outcome.VIFArtifact]:
     """Computes geo-level variance inflation factor among treatments and controls."""
@@ -1783,8 +1989,8 @@ class EDAEngine:
     """
     if self._is_national_data:
       return self.check_national_vif()
-    else:
-      return self.check_geo_vif()
+
+    return self.check_geo_vif()
 
   @property
   def kpi_has_variability(self) -> bool:
@@ -1821,6 +2027,60 @@ class EDAEngine:
         analysis_artifacts=[self._overall_scaled_kpi_invariability_artifact],
     )
 
+  def check_geo_cost_per_media_unit(
+      self,
+  ) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+    """Checks if the cost per media unit is valid for geo data.
+
+    Returns:
+      An EDAOutcome object with findings and result values.
+
+    Raises:
+      GeoLevelCheckOnNationalModelError: If the check is called for a national
+        model.
+    """
+    if self._is_national_data:
+      raise GeoLevelCheckOnNationalModelError(
+          'check_geo_cost_per_media_unit is not supported for national models.'
+      )
+    return _check_cost_per_media_unit(
+        self.all_spend_ds,
+        self.paid_raw_media_units_ds,
+        eda_outcome.AnalysisLevel.GEO,
+    )
+
+  def check_national_cost_per_media_unit(
+      self,
+  ) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+    """Checks if the cost per media unit is valid for national data.
+
+    Returns:
+      An EDAOutcome object with findings and result values.
+    """
+    return _check_cost_per_media_unit(
+        self.national_all_spend_ds,
+        self.national_paid_raw_media_units_ds,
+        eda_outcome.AnalysisLevel.NATIONAL,
+    )
+
+  def check_cost_per_media_unit(
+      self,
+  ) -> eda_outcome.EDAOutcome[eda_outcome.CostPerMediaUnitArtifact]:
+    """Checks if the cost per media unit is valid.
+
+    This function checks the following conditions:
+    1. cost == 0 and media unit > 0.
+    2. cost > 0 and media unit == 0.
+    3. cost_per_media_unit has outliers.
+
+    Returns:
+      An EDAOutcome object with findings and result values.
+    """
+    if self._is_national_data:
+      return self.check_national_cost_per_media_unit()
+
+    return self.check_geo_cost_per_media_unit()
+
   def run_all_critical_checks(self) -> list[eda_outcome.EDAOutcome]:
     """Runs all critical EDA checks.
 
@@ -1836,7 +2096,9 @@ class EDAEngine:
       except Exception as e:  # pylint: disable=broad-except
         error_finding = eda_outcome.EDAFinding(
             severity=eda_outcome.EDASeverity.ERROR,
-            explanation=f'An error occurred during check {check.__name__}: {e}',
+            explanation=(
+                f'An error occurred during running {check.__name__}: {e!r}'
+            ),
         )
         outcomes.append(
             eda_outcome.EDAOutcome(

meridian/model/eda/eda_outcome.py

@@ -29,6 +29,7 @@ __all__ = [
     "StandardDeviationArtifact",
     "VIFArtifact",
     "KpiInvariabilityArtifact",
+    "CostPerMediaUnitArtifact",
     "EDACheckType",
     "ArtifactType",
     "EDAOutcome",
@@ -101,7 +102,8 @@ class PairwiseCorrArtifact(AnalysisArtifact):
   Attributes:
     corr_matrix: Pairwise correlation matrix.
     extreme_corr_var_pairs: DataFrame of variable pairs exceeding the
-      correlation threshold.
+      correlation threshold. Includes 'correlation' and 'abs_correlation'
+      columns, and is sorted by 'abs_correlation' in descending order.
     extreme_corr_threshold: The threshold used to identify extreme correlation
       pairs.
   """
@@ -153,6 +155,23 @@ class KpiInvariabilityArtifact(AnalysisArtifact):
   kpi_stdev: xr.DataArray
 
 
+@dataclasses.dataclass(frozen=True)
+class CostPerMediaUnitArtifact(AnalysisArtifact):
+  """Encapsulates artifacts from a Cost per Media Unit analysis.
+
+  Attributes:
+    cost_per_media_unit_da: DataArray of cost per media unit.
+    cost_media_unit_inconsistency_df: DataFrame of time periods where cost and
+      media units are inconsistent (e.g., zero cost with positive media units,
+      or positive cost with zero media units).
+    outlier_df: DataFrame with outliers of cost per media unit.
+  """
+
+  cost_per_media_unit_da: xr.DataArray
+  cost_media_unit_inconsistency_df: pd.DataFrame
+  outlier_df: pd.DataFrame
+
+
 @enum.unique
 class EDACheckType(enum.Enum):
   """Enumeration for the type of an EDA check."""
@@ -161,6 +180,7 @@ class EDACheckType(enum.Enum):
   STANDARD_DEVIATION = enum.auto()
   MULTICOLLINEARITY = enum.auto()
   KPI_INVARIABILITY = enum.auto()
+  COST_PER_MEDIA_UNIT = enum.auto()
 
 
 ArtifactType = typing.TypeVar("ArtifactType", bound="AnalysisArtifact")

meridian/model/knots.py

@@ -19,6 +19,7 @@ from collections.abc import Collection, Sequence
 import copy
 import dataclasses
 import math
+import pprint
 from typing import Any
 from meridian import constants
 from meridian.data import input_data
@@ -289,6 +290,22 @@ class AKS:
     penalty = geo_scaling_factor * base_penalty
 
     aspline = self.aspline(x=x, y=y, knots=knots, penalty=penalty)
+    # Ensure defined knot range covers at least one of the available knot sets.
+    available_knots_lengths = np.unique(
+        np.fromiter(
+            (len(x) for x in aspline[constants.KNOTS_SELECTED]), dtype=int
+        )
+    ).tolist()
+    if not any(
+        min_internal_knots <= k <= max_internal_knots
+        for k in available_knots_lengths
+    ):
+      raise ValueError(
+          f'The range [{min_internal_knots}, {max_internal_knots}] does not'
+          ' contain any of the available knot lengths:'
+          f' {pprint.pformat(available_knots_lengths)}'
+      )
+
     n_knots = np.array([len(x) for x in aspline[constants.KNOTS_SELECTED]])
     feasible_idx = np.where(
         (n_knots >= min_internal_knots) & (n_knots <= max_internal_knots)

meridian/{analysis/templates → templates}/card.html.jinja

@@ -1,5 +1,5 @@
 {#
-Copyright 2024 Google LLC
+Copyright 2025 Google LLC
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

meridian/{analysis/templates → templates}/chart.html.jinja

@@ -1,5 +1,5 @@
 {#
-Copyright 2024 Google LLC
+Copyright 2025 Google LLC
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

meridian/{analysis/templates → templates}/chips.html.jinja

@@ -1,5 +1,5 @@
 {#
-Copyright 2024 Google LLC
+Copyright 2025 Google LLC
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

meridian/{analysis → templates}/formatter.py

@@ -88,7 +88,7 @@ AXIS_CONFIG = immutabledict.immutabledict({
 
 
 _template_loader = jinja2.FileSystemLoader(
-    os.path.abspath(os.path.dirname(__file__)) + '/templates'
+    os.path.abspath(os.path.dirname(__file__))
 )
 
 
@@ -206,6 +206,17 @@ def create_template_env() -> jinja2.Environment:
   )
 
 
+def create_summary_html(
+    template_env: jinja2.Environment,
+    title: str,
+    cards: Sequence[str],
+) -> str:
+  """Creates the HTML snippet for the summary page."""
+  return template_env.get_template('summary.html.jinja').render(
+      title=title, cards=cards
+  )
+
+
 def create_card_html(
     template_env: jinja2.Environment,
     card_spec: CardSpec,