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

scenarioplanner/linkingapi/__init__.py

@@ -0,0 +1,47 @@
+# Copyright 2025 The Meridian Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Builds Looker Studio report URLs.
+
+This package provides tools to construct URLs for Looker Studio reports that
+embed data directly within the URL itself. This is achieved through the creation
+of shareable, pre-configured reports without requiring a separate, pre-existing
+data source.
+
+The primary functionality is exposed through the `url_generator` module.
+
+Typical Usage:
+
+  1. Use `url_generator.create_report_url()` to create the complete URL, based
+  on a `sheets.Spreadsheet` object.
+
+Example:
+
+```python
+from lookerstudio.linkingapi import url_generator
+from lookerstudio.converters import sheets
+
+# Generate the URL
+looker_studio_report_url = url_generator.create_report_url(
+    url="some_url",
+    id="some_id",
+    sheet_id_by_tab_name={},
+)
+# The `looker_studio_report_url` can now be shared to open a pre-populated
+# report.
+```
+"""
+
+from scenarioplanner.linkingapi import constants
+from scenarioplanner.linkingapi import url_generator

scenarioplanner/linkingapi/constants.py

@@ -0,0 +1,27 @@
+# Copyright 2025 The Meridian Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Constants shared for the Linking API usage for the Meridian UI.
+
+Defines constants used in the URL generation process, such as API endpoints and
+parameter names.
+"""
+
+REPORT_TEMPLATE_ID = 'fbd3aeff-fc00-45fd-83f7-1ec5f21c9f56'
+COMMUNITY_CONNECTOR_NAME = 'community'
+COMMUNITY_CONNECTOR_ID = (
+    'AKfycbz-xdEN-GbTuQ9MjEddS-64wLgXwMMTp9a4zFE4PO_kwT6wDgZPsN4Y19oKmLLHD6xk'
+)
+SHEETS_CONNECTOR_NAME = 'googleSheets'
+GA4_MEASUREMENT_ID = 'G-R6C81BNHJ4'

scenarioplanner/linkingapi/url_generator.py

@@ -0,0 +1,131 @@
+# Copyright 2025 The Meridian Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utility library for generating a Looker Studio report and outputting the URL.
+
+Contains the core logic for constructing the Looker Studio report URL, including
+setting the correct parameters.
+
+This library requires authentication.
+
+*   If you're developing locally, set up Application Default Credentials (ADC)
+in
+    your local environment:
+
+    <https://cloud.google.com/docs/authentication/application-default-credentials>
+
+*   If you're working in Colab, run the following command in a cell to
+    authenticate:
+
+    ```python
+    from google.colab import auth
+    auth.authenticate_user()
+    ```
+
+    This command opens a window where you can complete the authentication.
+"""
+
+import urllib.parse
+import warnings
+from scenarioplanner.converters import sheets
+from scenarioplanner.converters.dataframe import constants as dc
+from scenarioplanner.linkingapi import constants
+
+
+def create_report_url(spreadsheet: sheets.Spreadsheet) -> str:
+  """Creates a Looker Studio report URL based on the given spreadsheet.
+
+  If there are some sheet tabs that are not in `spreadsheet`, the report will
+  display its demo data.
+
+  Args:
+    spreadsheet: The spreadsheet object that contains the data to visualize in a
+      Looker Studio report.
+
+  Returns:
+    The URL of the Looker Studio report.
+  """
+  params = []
+
+  encoded_sheet_url = urllib.parse.quote_plus(spreadsheet.url)
+
+  params.append(f'c.reportId={constants.REPORT_TEMPLATE_ID}')
+  params.append(f'r.measurementId={constants.GA4_MEASUREMENT_ID}')
+
+  if dc.OPTIMIZATION_SPECS in spreadsheet.sheet_id_by_tab_name:
+    params.append(f'ds.dscc.connector={constants.COMMUNITY_CONNECTOR_NAME}')
+    params.append(f'ds.dscc.connectorId={constants.COMMUNITY_CONNECTOR_ID}')
+    params.append(f'ds.dscc.spreadsheetUrl={encoded_sheet_url}')
+  else:
+    warnings.warn(
+        'No optimization specs found in the spreadsheet. The report will'
+        ' display its demo data.'
+    )
+
+  params.append('ds.*.refreshFields=false')
+  params.append('ds.*.keepDatasourceName=true')
+  params.append(f'ds.*.connector={constants.SHEETS_CONNECTOR_NAME}')
+  params.append(f'ds.*.spreadsheetId={spreadsheet.id}')
+
+  if dc.MODEL_FIT in spreadsheet.sheet_id_by_tab_name:
+    worksheet_id = spreadsheet.sheet_id_by_tab_name[dc.MODEL_FIT]
+    params.append(f'ds.ds_model_fit.worksheetId={worksheet_id}')
+  else:
+    warnings.warn(
+        'No model fit found in the spreadsheet. The report will'
+        ' display its demo data.'
+    )
+
+  if dc.MODEL_DIAGNOSTICS in spreadsheet.sheet_id_by_tab_name:
+    worksheet_id = spreadsheet.sheet_id_by_tab_name[dc.MODEL_DIAGNOSTICS]
+    params.append(f'ds.ds_model_diag.worksheetId={worksheet_id}')
+  else:
+    warnings.warn(
+        'No model diagnostics found in the spreadsheet. The report will'
+        ' display its demo data.'
+    )
+
+  if dc.MEDIA_OUTCOME in spreadsheet.sheet_id_by_tab_name:
+    worksheet_id = spreadsheet.sheet_id_by_tab_name[dc.MEDIA_OUTCOME]
+    params.append(f'ds.ds_outcome.worksheetId={worksheet_id}')
+  else:
+    warnings.warn(
+        'No media outcome found in the spreadsheet. The report will'
+        ' display its demo data.'
+    )
+
+  if dc.MEDIA_SPEND in spreadsheet.sheet_id_by_tab_name:
+    worksheet_id = spreadsheet.sheet_id_by_tab_name[dc.MEDIA_SPEND]
+    params.append(f'ds.ds_spend.worksheetId={worksheet_id}')
+  else:
+    warnings.warn(
+        'No media spend found in the spreadsheet. The report will'
+        ' display its demo data.'
+    )
+
+  if dc.MEDIA_ROI in spreadsheet.sheet_id_by_tab_name:
+    worksheet_id = spreadsheet.sheet_id_by_tab_name[dc.MEDIA_ROI]
+    params.append(f'ds.ds_roi.worksheetId={worksheet_id}')
+  else:
+    warnings.warn(
+        'No media ROI found in the spreadsheet. The report will'
+        ' display its demo data.'
+    )
+
+  joined_params = '&'.join(params)
+  report_url = (
+      'https://lookerstudio.google.com/reporting/create?' + joined_params
+  )
+
+  return report_url

scenarioplanner/mmm_ui_proto_generator.py

@@ -0,0 +1,354 @@
+# Copyright 2025 The Meridian Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generates an `Mmm` (Marketing Mix Model) proto for Meridian UI.
+
+The MMM proto schema contains parts collected from the core model as well as
+analysis results from trained model processors.
+"""
+
+import abc
+from collections.abc import Collection, Sequence
+import dataclasses
+import datetime
+from typing import TypeVar
+import uuid
+import warnings
+
+from meridian.analysis import optimizer
+from meridian.data import time_coordinates as tc
+from meridian.model import model
+from mmm.v1 import mmm_pb2 as mmm_pb
+from scenarioplanner.converters.dataframe import constants as converter_constants
+from schema import mmm_proto_generator
+from schema.processors import budget_optimization_processor as bop
+from schema.processors import marketing_processor
+from schema.processors import model_fit_processor
+from schema.processors import model_processor
+from schema.processors import reach_frequency_optimization_processor as rfop
+from schema.utils import date_range_bucketing
+
+
+__all__ = [
+    "MmmUiProtoGenerator",
+    "create_mmm_ui_data_proto",
+    "create_tag",
+]
+
+
+_ALLOWED_SPEC_TYPES_FOR_UI = frozenset({
+    model_fit_processor.ModelFitSpec,
+    marketing_processor.MarketingAnalysisSpec,
+    bop.BudgetOptimizationSpec,
+})
+
+_SPEC_TYPES_CREATE_SUBSPECS = frozenset({
+    marketing_processor.MarketingAnalysisSpec,
+    bop.BudgetOptimizationSpec,
+    rfop.ReachFrequencyOptimizationSpec,
+})
+
+_DATE_RANGE_GENERATORS = frozenset({
+    date_range_bucketing.MonthlyDateRangeGenerator,
+    date_range_bucketing.QuarterlyDateRangeGenerator,
+    date_range_bucketing.YearlyDateRangeGenerator,
+})
+
+SpecType = TypeVar("SpecType", bound=model_processor.Spec)
+DatedSpecType = TypeVar("DatedSpecType", bound=model_processor.DatedSpec)
+OptimizationSpecType = TypeVar(
+    "OptimizationSpecType", bound=model_processor.OptimizationSpec
+)
+
+_DERIVED_RF_OPT_NAME_PREFIX = "derived RF optimization from "
+_DERIVED_RF_OPT_GRID_NAME_PREFIX = "derived_from_"
+
+
+class MmmUiProtoGenerator:
+  """Creates `Mmm` proto for the Meridian Scenario Planner UI (Looker Studio).
+
+  Currently, it only accepts specs for Model Fit, Marketing Analysis, and Budget
+  Optimization, but not stand-alone Reach Frequency Optimization specs.
+  Reach Frequency Optimization spec will be derived from the Budget Optimization
+  spec; this is done so that we can structurally pair them.
+
+  Attributes:
+    mmm: A trained Meridian model. A trained model has its posterior
+      distributions already sampled.
+    specs: A sequence of specs that specify the analyses to run on the model.
+    model_id: An optional model identifier.
+    time_breakdown_generators: A list of generators that break down the given
+      specs by automatically generated time buckets. Currently, this time period
+      breakdown is only done on Marketing Analysis specs and Budget Optimization
+      specs. All other specs are processed in their original forms. The set of
+      default bucketers break down sub-specs with the following time periods:
+      [All (original spec's time period), Yearly, Quarterly, Monthly]
+  """
+
+  def __init__(
+      self,
+      mmm: model.Meridian,
+      specs: Sequence[SpecType],
+      model_id: str = "",
+      time_breakdown_generators: Collection[
+          type[date_range_bucketing.DateRangeBucketer]
+      ] = _DATE_RANGE_GENERATORS,
+  ):
+    self._mmm = mmm
+    self._input_specs = specs
+    self._model_id = model_id
+    self._time_breakdown_generators = time_breakdown_generators
+
+  @property
+  def _time_coordinates(self) -> tc.TimeCoordinates:
+    return self._mmm.input_data.time_coordinates
+
+  def __call__(self) -> mmm_pb.Mmm:
+    """Creates `Mmm` proto for the Meridian Scenario Planner UI (Looker Studio).
+
+    Returns:
+      A proto containing the model kernel at rest and its analysis results given
+      user specs.
+    """
+    seen_group_ids = set()
+
+    copy_specs = []
+    for spec in self._input_specs:
+      if not any(isinstance(spec, t) for t in _ALLOWED_SPEC_TYPES_FOR_UI):
+        raise ValueError(f"Unsupported spec type: {spec.__class__.__name__}")
+
+      if isinstance(spec, bop.BudgetOptimizationSpec):
+        group_id = spec.group_id
+        if not group_id:
+          group_id = str(uuid.uuid4())
+          copy_specs.append(dataclasses.replace(spec, group_id=group_id))
+        else:
+          if group_id in seen_group_ids:
+            raise ValueError(
+                f"Duplicate group ID found: {group_id}. Please provide a unique"
+                " group ID for each Budget Optimization spec."
+            )
+          seen_group_ids.add(group_id)
+          copy_specs.append(spec)
+
+        # If there are RF channels, derive a RF optimization spec from the
+        # Budget Optimization spec.
+        if self._mmm.input_data.rf_channel is not None:
+          copy_specs.append(
+              self._derive_rf_opt_spec_from_budget_opt_spec(copy_specs[-1])
+          )
+      else:
+        copy_specs.append(spec)
+
+    sub_specs = []
+    for spec in copy_specs:
+      to_create_subspecs = self._time_breakdown_generators and any(
+          isinstance(spec, t) for t in _SPEC_TYPES_CREATE_SUBSPECS
+      )
+
+      if to_create_subspecs:
+        dates = self._enumerate_dates_open_end(spec)
+        sub_specs.extend(
+            _create_subspecs(spec, dates, self._time_breakdown_generators)
+        )
+      else:
+        sub_specs.append(spec)
+
+    return mmm_proto_generator.create_mmm_proto(
+        self._mmm,
+        sub_specs,
+        model_id=self._model_id,
+    )
+
+  def _derive_rf_opt_spec_from_budget_opt_spec(
+      self,
+      budget_opt_spec: bop.BudgetOptimizationSpec,
+  ) -> rfop.ReachFrequencyOptimizationSpec:
+    """Derives a ReachFrequencyOptimizationSpec from a BudgetOptimizationSpec."""
+    rf_opt_name = (
+        f"{_DERIVED_RF_OPT_NAME_PREFIX}{budget_opt_spec.optimization_name}"
+    )
+    rf_opt_grid_name = (
+        f"{_DERIVED_RF_OPT_GRID_NAME_PREFIX}{budget_opt_spec.optimization_name}"
+    )
+
+    return rfop.ReachFrequencyOptimizationSpec(
+        start_date=budget_opt_spec.start_date,
+        end_date=budget_opt_spec.end_date,
+        date_interval_tag=budget_opt_spec.date_interval_tag,
+        optimization_name=rf_opt_name,
+        grid_name=rf_opt_grid_name,
+        group_id=budget_opt_spec.group_id,
+        confidence_level=budget_opt_spec.confidence_level,
+    )
+
+  def _enumerate_dates_open_end(
+      self, spec: DatedSpecType
+  ) -> list[datetime.date]:
+    """Enumerates date points with an open end date.
+
+    The date points are enumerated from the data's time coordinates based on the
+    spec's start and end dates. The last date point is the exclusive end date as
+    same as the spec's end date, if specified.
+
+    Args:
+      spec: A dated spec.
+
+    Returns:
+      A list of date points.
+    """
+    inclusive_date_strs = spec.resolver(
+        self._mmm.input_data.time_coordinates
+    ).resolve_to_enumerated_selected_times()
+
+    if inclusive_date_strs is None:
+      dates = self._time_coordinates.all_dates
+    else:
+      dates = [tc.normalize_date(date_str) for date_str in inclusive_date_strs]
+
+    # If the end date is not specified, compute the exclusive end date based on
+    # the last date in the time coordinates.
+    exclusive_end_date = spec.end_date or dates[-1] + datetime.timedelta(
+        days=self._time_coordinates.interval_days
+    )
+
+    dates.append(exclusive_end_date)
+
+    return dates
+
+
+def create_mmm_ui_data_proto(
+    mmm: model.Meridian,
+    specs: Sequence[SpecType],
+    model_id: str = "",
+    time_breakdown_generators: Collection[
+        type[date_range_bucketing.DateRangeBucketer]
+    ] = _DATE_RANGE_GENERATORS,
+) -> mmm_pb.Mmm:
+  """Creates `Mmm` proto for the Meridian Scenario Planner UI (Looker Studio).
+
+  Currently, it only accepts specs for Model Fit, Marketing Analysis, and Budget
+  Optimization, but not stand-alone Reach Frequency Optimization specs.
+  Reach Frequency Optimization spec will be derived from the Budget Optimization
+  spec; this is done so that we can structurally pair them.
+
+  Args:
+    mmm: A trained Meridian model. A trained model has its posterior
+      distributions already sampled.
+    specs: A sequence of specs that specify the analyses to run on the model.
+    model_id: An optional model identifier.
+    time_breakdown_generators: A list of generators that break down the given
+      specs by automatically generated time buckets. Currently, this time period
+      breakdown is only done on Marketing Analysis specs and Budget Optimization
+      specs. All other specs are processed in their original forms. The set of
+      default bucketers break down sub-specs with the following time periods:
+      [All (original spec's time period), Yearly, Quarterly, Monthly]
+
+  Returns:
+    A proto containing the model kernel at rest and its analysis results given
+    user specs.
+  """
+  return MmmUiProtoGenerator(
+      mmm,
+      specs,
+      model_id,
+      time_breakdown_generators,
+  )()
+
+
+def create_tag(
+    generator_class: type[abc.ABC], start_date: datetime.date
+) -> str:
+  """Creates a human-readable tag for a spec."""
+  if generator_class == date_range_bucketing.YearlyDateRangeGenerator:
+    return f"Y{start_date.year}"
+  elif generator_class == date_range_bucketing.QuarterlyDateRangeGenerator:
+    return f"Y{start_date.year} Q{(start_date.month - 1) // 3 + 1}"
+  elif generator_class == date_range_bucketing.MonthlyDateRangeGenerator:
+    return f"Y{start_date.year} {start_date.strftime('%b')}"
+  else:
+    raise ValueError(f"Unsupported generator class: {generator_class}")
+
+
+def _normalize_optimization_spec_time_info(
+    spec: OptimizationSpecType,
+    date_interval_tag: str,
+) -> OptimizationSpecType:
+  """Adds time info to an optimization spec."""
+  formatted_date_interval_tag = date_interval_tag.replace(r" ", "_")
+  return dataclasses.replace(
+      spec,
+      group_id=f"{spec.group_id}:{date_interval_tag}",
+      optimization_name=f"{spec.optimization_name} for {date_interval_tag}",
+      grid_name=f"{spec.grid_name}_{formatted_date_interval_tag}",
+  )
+
+
+def _create_subspecs(
+    spec: DatedSpecType,
+    date_range: list[datetime.date],
+    time_breakdown_generators: Collection[
+        type[date_range_bucketing.DateRangeBucketer]
+    ],
+) -> list[DatedSpecType]:
+  """Breaks down a spec into sub-specs for each time bucket."""
+  specs = []
+
+  all_period_spec = dataclasses.replace(
+      spec,
+      date_interval_tag=converter_constants.ANALYSIS_TAG_ALL,
+  )
+  if isinstance(all_period_spec, model_processor.OptimizationSpec):
+    all_period_spec = _normalize_optimization_spec_time_info(
+        all_period_spec, converter_constants.ANALYSIS_TAG_ALL
+    )
+  specs.append(all_period_spec)
+
+  for generator_class in time_breakdown_generators:
+    generator = generator_class(date_range)  # pytype: disable=not-instantiable
+    date_intervals = generator.generate_date_intervals()
+    for start_date, end_date in date_intervals:
+      date_interval_tag = create_tag(generator_class, start_date)
+      new_spec = dataclasses.replace(
+          spec,
+          start_date=start_date,
+          end_date=end_date,
+          date_interval_tag=date_interval_tag,
+      )
+
+      if isinstance(new_spec, model_processor.OptimizationSpec):
+        new_spec = _normalize_optimization_spec_time_info(
+            new_spec, date_interval_tag
+        )
+
+        if (
+            isinstance(new_spec, bop.BudgetOptimizationSpec)
+            and isinstance(new_spec.scenario, optimizer.FixedBudgetScenario)
+            and new_spec.scenario.total_budget is not None
+        ):
+          # TODO: The budget amount should be adjusted based on the
+          # budget specified in the `all_period_spec` and the historical spend
+          # at the time period.
+          new_spec = dataclasses.replace(
+              new_spec,
+              scenario=optimizer.FixedBudgetScenario(total_budget=None),
+          )
+          warnings.warn(
+              "Using historical spend for budget optimization spec at the"
+              f" period of {date_interval_tag}",
+          )
+
+      specs.append(new_spec)
+
+  return specs

schema/__init__.py

@@ -14,11 +14,11 @@
 
 """Module containing MMM schema library."""
 
-try:  # pylint: disable=g-statement-before-imports
+try:
   # A quick check for schema dependencies.
   # If this fails, it's likely because meridian was installed without
   # `pip install google-meridian[schema]`.
-  from mmm.v1.model.meridian import meridian_model_pb2  # pylint: disable=g-import-not-at-top
+  from mmm.v1.model.meridian import meridian_model_pb2
 except ModuleNotFoundError as exc:
   raise ImportError(
       'Schema dependencies not found. Please install meridian with '
@@ -26,5 +26,8 @@ except ModuleNotFoundError as exc:
   ) from exc
 
 # pylint: disable=g-import-not-at-top
+from schema import mmm_proto_generator
+from schema import model_consumer
+from schema import processors
 from schema import serde
 from schema import utils

schema/mmm_proto_generator.py

@@ -0,0 +1,71 @@
+# Copyright 2025 The Meridian Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generates an `Mmm` (Marketing Mix Model) proto for Meridian.
+
+The MMM proto schema contains parts collected from the core model as well as
+analysis results from trained model processors.
+"""
+
+from collections.abc import Sequence
+from typing import TypeVar
+
+from meridian.model import model
+from mmm.v1 import mmm_pb2 as mmm_pb
+from schema import model_consumer
+from schema.processors import budget_optimization_processor
+from schema.processors import marketing_processor
+from schema.processors import model_fit_processor
+from schema.processors import model_processor
+from schema.processors import reach_frequency_optimization_processor
+
+
+__all__ = [
+    "create_mmm_proto",
+]
+
+
+_TYPES = (
+    model_fit_processor.ModelFitProcessor,
+    marketing_processor.MarketingProcessor,
+    budget_optimization_processor.BudgetOptimizationProcessor,
+    reach_frequency_optimization_processor.ReachFrequencyOptimizationProcessor,
+)
+
+SpecType = TypeVar("SpecType", bound=model_processor.Spec)
+DatedSpecType = TypeVar("DatedSpecType", bound=model_processor.DatedSpec)
+OptimizationSpecType = TypeVar(
+    "OptimizationSpecType", bound=model_processor.OptimizationSpec
+)
+
+
+def create_mmm_proto(
+    mmm: model.Meridian,
+    specs: Sequence[SpecType],
+    model_id: str = "",
+) -> mmm_pb.Mmm:
+  """Creates a model schema and analyses for various time buckets.
+
+  Args:
+    mmm: A trained Meridian model. A trained model has its posterior
+      distributions already sampled.
+    specs: A sequence of specs that specify the analyses to run on the model.
+    model_id: An optional model identifier.
+
+  Returns:
+    A proto containing the model kernel at rest and its analysis results given
+    user specs.
+  """
+  consumer = model_consumer.ModelConsumer(_TYPES)
+  return consumer(mmm, specs, model_id)