google-meridian 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

meridian/analysis/review/checks.py

@@ -15,7 +15,7 @@
 """Implementation of the Model Quality Checks."""
 
 import abc
-from collections.abc import Sequence
+from collections.abc import MutableMapping, Sequence
 import dataclasses
 from typing import Generic, TypeVar
 import warnings
@@ -77,31 +77,16 @@ class ConvergenceCheck(
     if not valid_rhat_items:
       return results.ConvergenceCheckResult(
           case=results.ConvergenceCases.CONVERGED,
-          details={
-              review_constants.RHAT: np.nan,
-              review_constants.PARAMETER: np.nan,
-              review_constants.CONVERGENCE_THRESHOLD: (
-                  self._config.convergence_threshold
-              ),
-          },
+          config=self._config,
+          max_rhat=np.nan,
+          max_parameter=np.nan,
       )
 
     max_parameter, max_rhat = max(max_rhats.items(), key=lambda item: item[1])
 
-    details = {
-        review_constants.RHAT: max_rhat,
-        review_constants.PARAMETER: max_parameter,
-        review_constants.CONVERGENCE_THRESHOLD: (
-            self._config.convergence_threshold
-        ),
-    }
-
     # Case 1: Converged.
     if max_rhat < self._config.convergence_threshold:
-      return results.ConvergenceCheckResult(
-          case=results.ConvergenceCases.CONVERGED,
-          details=details,
-      )
+      case = results.ConvergenceCases.CONVERGED
 
     # Case 2: Not fully converged, but potentially acceptable.
     elif (
@@ -109,17 +94,18 @@ class ConvergenceCheck(
         <= max_rhat
         < self._config.not_fully_convergence_threshold
     ):
-      return results.ConvergenceCheckResult(
-          case=results.ConvergenceCases.NOT_FULLY_CONVERGED,
-          details=details,
-      )
+      case = results.ConvergenceCases.NOT_FULLY_CONVERGED
 
     # Case 3: Not converged and unacceptable.
     else:  # max_rhat >= divergence_threshold
-      return results.ConvergenceCheckResult(
-          case=results.ConvergenceCases.NOT_CONVERGED,
-          details=details,
-      )
+      case = results.ConvergenceCases.NOT_CONVERGED
+
+    return results.ConvergenceCheckResult(
+        case=case,
+        config=self._config,
+        max_rhat=max_rhat,
+        max_parameter=max_parameter,
+    )
 
 
 # ==============================================================================
@@ -131,33 +117,25 @@ class BaselineCheck(
   """Checks for negative baseline probability."""
 
   def run(self) -> results.BaselineCheckResult:
-    prob = self._analyzer.negative_baseline_probability()
-    details = {
-        review_constants.NEGATIVE_BASELINE_PROB: prob,
-        review_constants.NEGATIVE_BASELINE_PROB_FAIL_THRESHOLD: (
-            self._config.negative_baseline_prob_fail_threshold
-        ),
-        review_constants.NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD: (
-            self._config.negative_baseline_prob_review_threshold
-        ),
-    }
+    prob = float(self._analyzer.negative_baseline_probability())
+
     # Case 1: FAIL
     if prob > self._config.negative_baseline_prob_fail_threshold:
-      return results.BaselineCheckResult(
-          case=results.BaselineCases.FAIL,
-          details=details,
-      )
+      case = results.BaselineCases.FAIL
+
     # Case 2: REVIEW
     elif prob >= self._config.negative_baseline_prob_review_threshold:
-      return results.BaselineCheckResult(
-          case=results.BaselineCases.REVIEW,
-          details=details,
-      )
+      case = results.BaselineCases.REVIEW
+
     # Case 3: PASS
     else:
-      return results.BaselineCheckResult(
-          case=results.BaselineCases.PASS, details=details
-      )
+      case = results.BaselineCases.PASS
+
+    return results.BaselineCheckResult(
+        case=case,
+        config=self._config,
+        negative_baseline_prob=prob,
+    )
 
 
 # ==============================================================================
@@ -189,45 +167,40 @@ class BayesianPPPCheck(
         >= np.abs(total_outcome_actual - total_outcome_expected_mean)
     )
 
-    details = {
-        review_constants.BAYESIAN_PPP: bayesian_ppp,
-    }
-
     if bayesian_ppp >= self._config.ppp_threshold:
-      return results.BayesianPPPCheckResult(
-          case=results.BayesianPPPCases.PASS,
-          details=details,
-      )
+      case = results.BayesianPPPCases.PASS
     else:
-      return results.BayesianPPPCheckResult(
-          case=results.BayesianPPPCases.FAIL,
-          details=details,
-      )
+      case = results.BayesianPPPCases.FAIL
+
+    return results.BayesianPPPCheckResult(
+        case=case,
+        config=self._config,
+        bayesian_ppp=bayesian_ppp,
+    )
 
 
 # ==============================================================================
 # Check: Goodness of Fit
 # ==============================================================================
-def _set_details_from_gof_dataframe(
-    details: dict[str, float],
+def _set_metrics_from_gof_dataframe(
+    metrics: MutableMapping[str, float],
     gof_df: pd.DataFrame,
     geo_granularity: str,
-    suffix: str | None = None,
+    suffix: str,
 ) -> None:
-  """Sets the `details` variable of the GoodnessOfFitCheckResult.
+  """Sets the `metrics` variable of the GoodnessOfFitCheckResult.
 
   This method takes a DataFrame containing goodness of fit metrics and pivots it
-  to a Series, which is then added to the `details` variable of the
+  to a Series, which is then added to the `metrics` variable of the
   `GoodnessOfFitCheckResult`.
 
   Args:
-    details: A dictionary to store the goodness of fit metrics in.
+    metrics: A dictionary to store the goodness of fit metrics in.
     gof_df: A DataFrame containing predictive accuracy of the whole data (if
       holdout set is not used) of filtered to a single evaluation set ("all",
       "train", or "test").
     geo_granularity: The geo granularity of the data ("geo" or "national").
-    suffix: A suffix to add to the metric names (e.g., "all", "train", "test").
-      If None, the metrics are added without a suffix.
+    suffix: A suffix to add to the metric names (e.g., "_train", "_test").
   """
   gof_metrics_pivoted = gof_df.pivot(
       index=constants.GEO_GRANULARITY,
@@ -235,22 +208,15 @@ def _set_details_from_gof_dataframe(
       values=constants.VALUE,
   )
   gof_metrics_series = gof_metrics_pivoted.loc[geo_granularity]
-  if suffix is not None:
-    details[f"{review_constants.R_SQUARED}_{suffix}"] = gof_metrics_series[
-        constants.R_SQUARED
-    ]
-    details[f"{review_constants.MAPE}_{suffix}"] = gof_metrics_series[
-        constants.MAPE
-    ]
-    details[f"{review_constants.WMAPE}_{suffix}"] = gof_metrics_series[
-        constants.WMAPE
-    ]
-  else:
-    details[review_constants.R_SQUARED] = gof_metrics_series[
-        constants.R_SQUARED
-    ]
-    details[review_constants.MAPE] = gof_metrics_series[constants.MAPE]
-    details[review_constants.WMAPE] = gof_metrics_series[constants.WMAPE]
+  metrics[f"{review_constants.R_SQUARED}{suffix}"] = gof_metrics_series[
+      constants.R_SQUARED
+  ]
+  metrics[f"{review_constants.MAPE}{suffix}"] = gof_metrics_series[
+      constants.MAPE
+  ]
+  metrics[f"{review_constants.WMAPE}{suffix}"] = gof_metrics_series[
+      constants.WMAPE
+  ]
 
 
 class GoodnessOfFitCheck(
@@ -269,7 +235,7 @@ class GoodnessOfFitCheck(
     gof_metrics = gof_df[gof_df[constants.GEO_GRANULARITY] == geo_granularity]
     is_holdout = constants.EVALUATION_SET_VAR in gof_df.columns
 
-    details = {}
+    metrics_dict = {}
     case = results.GoodnessOfFitCases.PASS
 
     if is_holdout:
@@ -281,29 +247,71 @@ class GoodnessOfFitCheck(
         set_metrics = gof_metrics[
             gof_metrics[constants.EVALUATION_SET_VAR] == evaluation_set
         ]
-        _set_details_from_gof_dataframe(
-            details=details,
+        _set_metrics_from_gof_dataframe(
+            metrics=metrics_dict,
             gof_df=set_metrics,
             geo_granularity=geo_granularity,
             suffix=suffix,
         )
-        if details[f"{review_constants.R_SQUARED}_{suffix}"] <= 0:
+        if metrics_dict[f"{review_constants.R_SQUARED}{suffix}"] <= 0:
           case = results.GoodnessOfFitCases.REVIEW
+      return results.GoodnessOfFitCheckResult(
+          case=case,
+          metrics=results.GoodnessOfFitMetrics(
+              r_squared=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.ALL_SUFFIX}"
+              ],
+              mape=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.ALL_SUFFIX}"
+              ],
+              wmape=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.ALL_SUFFIX}"
+              ],
+              r_squared_train=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.TRAIN_SUFFIX}"
+              ],
+              mape_train=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.TRAIN_SUFFIX}"
+              ],
+              wmape_train=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.TRAIN_SUFFIX}"
+              ],
+              r_squared_test=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.TEST_SUFFIX}"
+              ],
+              mape_test=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.TEST_SUFFIX}"
+              ],
+              wmape_test=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.TEST_SUFFIX}"
+              ],
+          ),
+          is_holdout=is_holdout,
+      )
     else:
-      _set_details_from_gof_dataframe(
-          details=details,
+      _set_metrics_from_gof_dataframe(
+          metrics=metrics_dict,
           gof_df=gof_metrics,
           geo_granularity=geo_granularity,
-          suffix=None,
+          suffix=review_constants.ALL_SUFFIX,
       )
-      if details[review_constants.R_SQUARED] <= 0:
+      if metrics_dict[review_constants.R_SQUARED] <= 0:
         case = results.GoodnessOfFitCases.REVIEW
-
-    return results.GoodnessOfFitCheckResult(
-        case=case,
-        details=details,
-        is_holdout=is_holdout,
-    )
+      return results.GoodnessOfFitCheckResult(
+          case=case,
+          metrics=results.GoodnessOfFitMetrics(
+              r_squared=metrics_dict[
+                  f"{review_constants.R_SQUARED}{review_constants.ALL_SUFFIX}"
+              ],
+              mape=metrics_dict[
+                  f"{review_constants.MAPE}{review_constants.ALL_SUFFIX}"
+              ],
+              wmape=metrics_dict[
+                  f"{review_constants.WMAPE}{review_constants.ALL_SUFFIX}"
+              ],
+          ),
+          is_holdout=is_holdout,
+      )
 
 
 # ==============================================================================
@@ -475,8 +483,10 @@ def _compute_channel_results(
     channel_results.append(
         results.ROIConsistencyChannelResult(
             case=case,
-            details={},
             channel_name=channel,
+            prior_roi_lo=np.nan,
+            prior_roi_hi=np.nan,
+            posterior_roi_mean=np.nan,
         )
     )
   for i, channel in enumerate(channel_data.all_channels):
@@ -491,14 +501,10 @@ def _compute_channel_results(
     channel_results.append(
         results.ROIConsistencyChannelResult(
             case=case,
-            details={
-                review_constants.PRIOR_ROI_LO: channel_data.prior_roi_los[i],
-                review_constants.PRIOR_ROI_HI: channel_data.prior_roi_his[i],
-                review_constants.POSTERIOR_ROI_MEAN: (
-                    channel_data.posterior_means[i]
-                ),
-            },
             channel_name=channel,
+            prior_roi_lo=channel_data.prior_roi_los[i],
+            prior_roi_hi=channel_data.prior_roi_his[i],
+            posterior_roi_mean=channel_data.posterior_means[i],
         )
     )
   return channel_results
@@ -558,7 +564,7 @@ def _compute_aggregate_result(
 
   return results.ROIConsistencyCheckResult(
       case=aggregate_case,
-      details=aggregate_details,
+      aggregate_details=aggregate_details,
       channel_results=channel_results,
   )
 
@@ -734,7 +740,7 @@ class PriorPosteriorShiftCheck(
         no_shift_channels.append(channel_name)
       channel_results.append(
           results.PriorPosteriorShiftChannelResult(
-              case=case, details={}, channel_name=channel_name
+              case=case, channel_name=channel_name
           )
       )
     return channel_results, no_shift_channels
@@ -752,17 +758,13 @@ class PriorPosteriorShiftCheck(
 
     if no_shift_channels:
       agg_case = results.PriorPosteriorShiftAggregateCases.REVIEW
-      final_details = {
-          "channels_str": ", ".join(
-              f"`{channel}`" for channel in no_shift_channels
-          )
-      }
     else:
       agg_case = results.PriorPosteriorShiftAggregateCases.PASS
-      final_details = {}
 
     return results.PriorPosteriorShiftCheckResult(
-        case=agg_case, details=final_details, channel_results=channel_results
+        case=agg_case,
+        channel_results=channel_results,
+        no_shift_channels=no_shift_channels,
     )
 
   def run(self) -> results.PriorPosteriorShiftCheckResult:

meridian/analysis/review/constants.py

@@ -32,9 +32,9 @@ NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD = (
 R_SQUARED = "r_squared"
 MAPE = "mape"
 WMAPE = "wmape"
-ALL_SUFFIX = "all"
-TRAIN_SUFFIX = "train"
-TEST_SUFFIX = "test"
+ALL_SUFFIX = ""
+TRAIN_SUFFIX = "_train"
+TEST_SUFFIX = "_test"
 EVALUATION_SET_SUFFIXES = (ALL_SUFFIX, TRAIN_SUFFIX, TEST_SUFFIX)
 MEAN = "mean"
 VARIANCE = "variance"

meridian/analysis/review/results.py

@@ -14,9 +14,13 @@
 
 """Data structures for the Model Quality Checks results."""
 
+import abc
+from collections.abc import Mapping
 import dataclasses
 import enum
 from typing import Any
+
+from meridian.analysis.review import configs
 from meridian.analysis.review import constants
 
 
@@ -58,11 +62,16 @@ class ModelCheckCase(BaseCase):
 
 
 @dataclasses.dataclass(frozen=True)
-class BaseResultData:
+class BaseResultData(abc.ABC):
   """Base class for check result data."""
 
   case: BaseCase
-  details: dict[str, Any]
+
+  @property
+  @abc.abstractmethod
+  def details(self) -> Mapping[str, Any]:
+    """Returns the details for message formatting."""
+    raise NotImplementedError
 
 
 @dataclasses.dataclass(frozen=True)
@@ -145,17 +154,18 @@ class ConvergenceCheckResult(CheckResult):
   """The immutable result of the Convergence Check."""
 
   case: ConvergenceCases
+  config: configs.ConvergenceConfig
+  max_rhat: float
+  max_parameter: str
 
-  def __post_init__(self):
-    if self.case == ConvergenceCases.CONVERGED and (
-        constants.CONVERGENCE_THRESHOLD not in self.details
-    ):
-      raise ValueError(
-          "The message template 'The model has likely converged, as all"
-          " parameters have R-hat values < {convergence_threshold}'. is"
-          " missing required formatting arguments: convergence_threshold."
-          f" Details: {self.details}."
-      )
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        constants.RHAT: self.max_rhat,
+        constants.PARAMETER: self.max_parameter,
+        constants.CONVERGENCE_THRESHOLD: self.config.convergence_threshold,
+    }
 
 
 # ==============================================================================
@@ -223,24 +233,21 @@ class BaselineCheckResult(CheckResult):
   """The immutable result of the Baseline Check."""
 
   case: BaselineCases
+  config: configs.BaselineConfig
+  negative_baseline_prob: float
 
-  def __post_init__(self):
-    if self.case is BaselineCases.PASS:
-      return
-    if any(
-        key not in self.details
-        for key in (
-            constants.NEGATIVE_BASELINE_PROB,
-            constants.NEGATIVE_BASELINE_PROB_FAIL_THRESHOLD,
-            constants.NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD,
-        )
-    ):
-      raise ValueError(
-          "The message template is missing required formatting arguments:"
-          " negative_baseline_prob, negative_baseline_prob_fail_threshold,"
-          " negative_baseline_prob_review_threshold. Details:"
-          f" {self.details}."
-      )
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        constants.NEGATIVE_BASELINE_PROB: self.negative_baseline_prob,
+        constants.NEGATIVE_BASELINE_PROB_FAIL_THRESHOLD: (
+            self.config.negative_baseline_prob_fail_threshold
+        ),
+        constants.NEGATIVE_BASELINE_PROB_REVIEW_THRESHOLD: (
+            self.config.negative_baseline_prob_review_threshold
+        ),
+    }
 
 
 # ==============================================================================
@@ -287,14 +294,15 @@ class BayesianPPPCheckResult(CheckResult):
   """The immutable result of the Bayesian Posterior Predictive P-value Check."""
 
   case: BayesianPPPCases
+  config: configs.BayesianPPPConfig
+  bayesian_ppp: float
 
-  def __post_init__(self):
-    if constants.BAYESIAN_PPP not in self.details:
-      raise ValueError(
-          "The message template is missing required formatting arguments:"
-          " bayesian_ppp. Details:"
-          f" {self.details}."
-      )
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        constants.BAYESIAN_PPP: self.bayesian_ppp,
+    }
 
 
 # ==============================================================================
@@ -337,55 +345,77 @@ class GoodnessOfFitCases(ModelCheckCase, enum.Enum):
     super().__init__(status, message_template, recommendation)
 
 
+@dataclasses.dataclass(frozen=True)
+class GoodnessOfFitMetrics:
+  """The metrics for the Goodness of Fit Check."""
+
+  r_squared: float
+  mape: float
+  wmape: float
+  r_squared_train: float | None = None
+  mape_train: float | None = None
+  wmape_train: float | None = None
+  r_squared_test: float | None = None
+  mape_test: float | None = None
+  wmape_test: float | None = None
+
+
 @dataclasses.dataclass(frozen=True)
 class GoodnessOfFitCheckResult(CheckResult):
   """The immutable result of the Goodness of Fit Check."""
 
   case: GoodnessOfFitCases
+  metrics: GoodnessOfFitMetrics
   is_holdout: bool = False
 
   def __post_init__(self):
     if self.is_holdout:
-      required_keys = []
-      for suffix in [
-          constants.ALL_SUFFIX,
-          constants.TRAIN_SUFFIX,
-          constants.TEST_SUFFIX,
-      ]:
-        required_keys.extend([
-            f"{constants.R_SQUARED}_{suffix}",
-            f"{constants.MAPE}_{suffix}",
-            f"{constants.WMAPE}_{suffix}",
-        ])
-      if any(key not in self.details for key in required_keys):
+      if any(
+          metric is None
+          for metric in (
+              self.metrics.r_squared_train,
+              self.metrics.mape_train,
+              self.metrics.wmape_train,
+              self.metrics.r_squared_test,
+              self.metrics.mape_test,
+              self.metrics.wmape_test,
+          )
+      ):
         raise ValueError(
             "The message template is missing required formatting arguments for"
-            f" holdout case. Required keys: {required_keys}. Details:"
-            f" {self.details}."
-        )
-    elif any(
-        key not in self.details
-        for key in (
-            constants.R_SQUARED,
-            constants.MAPE,
-            constants.WMAPE,
+            " holdout case. Required keys: r_squared_train, mape_train,"
+            " wmape_train, r_squared_test, mape_test, wmape_test. Metrics:"
+            f" {self.metrics}."
         )
-    ):
-      raise ValueError(
-          "The message template is missing required formatting arguments:"
-          " r_squared, mape, wmape. Details:"
-          f" {self.details}."
-      )
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """The check result details."""
+    return {
+        f"{constants.R_SQUARED}{constants.ALL_SUFFIX}": self.metrics.r_squared,
+        f"{constants.MAPE}{constants.ALL_SUFFIX}": self.metrics.mape,
+        f"{constants.WMAPE}{constants.ALL_SUFFIX}": self.metrics.wmape,
+        f"{constants.R_SQUARED}{constants.TRAIN_SUFFIX}": (
+            self.metrics.r_squared_train
+        ),
+        f"{constants.MAPE}{constants.TRAIN_SUFFIX}": self.metrics.mape_train,
+        f"{constants.WMAPE}{constants.TRAIN_SUFFIX}": self.metrics.wmape_train,
+        f"{constants.R_SQUARED}{constants.TEST_SUFFIX}": (
+            self.metrics.r_squared_test
+        ),
+        f"{constants.MAPE}{constants.TEST_SUFFIX}": self.metrics.mape_test,
+        f"{constants.WMAPE}{constants.TEST_SUFFIX}": self.metrics.wmape_test,
+    }
 
   @property
   def recommendation(self) -> str:
-    """Returns the check result message."""
+    """The check result message."""
     if self.is_holdout:
       report_str = (
-          "R-squared = {r_squared_all:.4f} (All),"
+          "R-squared = {r_squared:.4f} (All),"
           " {r_squared_train:.4f} (Train), {r_squared_test:.4f} (Test); MAPE"
-          " = {mape_all:.4f} (All), {mape_train:.4f} (Train),"
-          " {mape_test:.4f} (Test); wMAPE = {wmape_all:.4f} (All),"
+          " = {mape:.4f} (All), {mape_train:.4f} (Train),"
+          " {mape_test:.4f} (Test); wMAPE = {wmape:.4f} (All),"
           " {wmape_train:.4f} (Train), {wmape_test:.4f} (Test)".format(
               **self.details
           )
@@ -450,6 +480,18 @@ class ROIConsistencyChannelResult(ChannelResult):
   """The immutable result of ROI Consistency Check for a single channel."""
 
   case: ROIConsistencyChannelCases
+  prior_roi_lo: float
+  prior_roi_hi: float
+  posterior_roi_mean: float
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return {
+        constants.PRIOR_ROI_LO: self.prior_roi_lo,
+        constants.PRIOR_ROI_HI: self.prior_roi_hi,
+        constants.POSTERIOR_ROI_MEAN: self.posterior_roi_mean,
+    }
 
 
 @dataclasses.dataclass(frozen=True)
@@ -458,6 +500,12 @@ class ROIConsistencyCheckResult(CheckResult):
 
   case: ROIConsistencyAggregateCases
   channel_results: list[ROIConsistencyChannelResult]
+  aggregate_details: Mapping[str, Any]
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return self.aggregate_details
 
 
 # ==============================================================================
@@ -517,6 +565,11 @@ class PriorPosteriorShiftChannelResult(ChannelResult):
 
   case: PriorPosteriorShiftChannelCases
 
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return {}
+
 
 @dataclasses.dataclass(frozen=True)
 class PriorPosteriorShiftCheckResult(CheckResult):
@@ -524,6 +577,16 @@ class PriorPosteriorShiftCheckResult(CheckResult):
 
   case: PriorPosteriorShiftAggregateCases
   channel_results: list[PriorPosteriorShiftChannelResult]
+  no_shift_channels: list[str]
+
+  @property
+  def details(self) -> Mapping[str, Any]:
+    """Returns the check result details."""
+    return {
+        "channels_str": ", ".join(
+            f"`{channel}`" for channel in self.no_shift_channels
+        )
+    }
 
 
 # ==============================================================================
@@ -567,7 +630,7 @@ class ReviewSummary:
     return "\n".join(report)
 
   @property
-  def checks_status(self) -> dict[str, str]:
+  def checks_status(self) -> Mapping[str, str]:
     """Returns a dictionary of check names and statuses."""
     return {
         result.__class__.__name__: result.case.status.name