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

meridian/templates/formatter_test.py

@@ -0,0 +1,216 @@
+# 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.
+
+from xml.etree import ElementTree as ET
+
+from absl.testing import absltest
+from absl.testing import parameterized
+from meridian.templates import formatter
+
+
+class FormatterTest(parameterized.TestCase):
+
+  def test_custom_title_params_correct(self):
+    title_params = formatter.custom_title_params('test title')
+    self.assertEqual(
+        title_params.to_dict(),
+        {
+            'anchor': 'start',
+            'color': '#3C4043',
+            'font': 'Google Sans Display',
+            'fontSize': 18,
+            'fontWeight': 'normal',
+            'offset': 10,
+            'text': 'test title',
+        },
+    )
+
+  def test_bar_chart_width(self):
+    num_bars = 3
+    width = formatter.bar_chart_width(num_bars)
+    self.assertEqual(width, 186)
+
+  @parameterized.named_parameters(
+      ('zero_percent', 0.0, '0%'),
+      ('less_than_one_percent', 0.0005, '0.05%'),
+      ('one_percent', 0.01, '1%'),
+      ('greater_than_one_percent', 0.4257, '43%'),
+  )
+  def test_format_percent_correct(self, percent, expected):
+    formatted_percent = formatter.format_percent(percent)
+    self.assertEqual(formatted_percent, expected)
+
+  def test_compact_number_expr_default(self):
+    expr = formatter.compact_number_expr()
+    self.assertEqual(expr, "replace(format(datum.value, '.3~s'), 'G', 'B')")
+
+  def test_compact_number_expr_params(self):
+    expr = formatter.compact_number_expr('other', 2)
+    self.assertEqual(expr, "replace(format(datum.other, '.2~s'), 'G', 'B')")
+
+  @parameterized.named_parameters(
+      ('rounded_up_percent', 0.4257, 15, '42.6% (15)'),
+      ('rounded_down_percent', 0.4251, 15, '42.5% (15)'),
+      ('thousand_value', 0.42, 2e4, '42.0% (20k)'),
+      ('million_value', 0.42, 3e7, '42.0% (30M)'),
+      ('billion_value', 0.42, 4e9, '42.0% (4B)'),
+  )
+  def test_format_number_text_correct(self, percent, value, expected):
+    formatted_text = formatter.format_number_text(percent, value)
+    self.assertEqual(formatted_text, expected)
+
+  @parameterized.named_parameters(
+      ('zero_precision_thousands', 12345, '$', '$12k'),
+      ('round_up_thousands', 14900, '€', '€15k'),
+      ('million_value', 3.21e6, '£', '£3.2M'),
+      ('billion_value_round_up', 4.28e9, '¥', '¥4.3B'),
+      ('negative', -12345, '₮', '-₮12k'),
+  )
+  def test_format_monetary_num_correct(self, num, currency, expected):
+    formatted_number = formatter.format_monetary_num(num, currency)
+    self.assertEqual(formatted_number, expected)
+
+  @parameterized.named_parameters(
+      ('decimals', -0.1234, 2, '$', '-$0.12'),
+      ('zero_precision_thousands', 12345, 0, '', '12k'),
+      ('round_up_thousands', 14900, 0, '$', '$15k'),
+      ('million_value', 3.21e6, 2, '$', '$3.21M'),
+      ('negative', -12345, 0, '$', '-$12k'),
+  )
+  def test_compact_number_correct(self, num, precision, currency, expected):
+    formatted_number = formatter.compact_number(num, precision, currency)
+    self.assertEqual(formatted_number, expected)
+
+  def test_create_summary_html(self):
+    template_env = formatter.create_template_env()
+    title = 'Integration Test Report'
+    cards = ['<card>Card 1</card>', '<card>Card 2</card>']
+
+    html_result = formatter.create_summary_html(template_env, title, cards)
+
+    # Since summary.html contains DOCTYPE (which breaks ElementTree XML parser),
+    # we verify the output using string assertions.
+    self.assertIn('<!DOCTYPE html>', html_result)
+    self.assertIn(title, html_result)
+    self.assertIn('<card>Card 1</card>', html_result)
+    self.assertIn('<card>Card 2</card>', html_result)
+
+  def test_create_card_html_structure(self):
+    template_env = formatter.create_template_env()
+    card_spec = formatter.CardSpec(id='test_id', title='test_title')
+    stats_spec = formatter.StatsSpec(title='stats_title', stat='test_stat')
+    chart_spec = formatter.ChartSpec(
+        'test_chart_id', 'test_chart_json', 'test_chart_description'
+    )
+
+    card_html = ET.fromstring(
+        formatter.create_card_html(
+            template_env, card_spec, 'test_insights', [chart_spec], [stats_spec]
+        )
+    )
+    self.assertEqual(card_html.tag, 'card')
+    self.assertLen(card_html, 4)
+    self.assertEqual(card_html[0].tag, 'card-title')
+    self.assertEqual(card_html[1].tag, 'card-insights')
+    self.assertEqual(card_html[2].tag, 'stats-section')
+    self.assertEqual(card_html[3].tag, 'charts')
+
+  def test_create_card_html_text(self):
+    template_env = formatter.create_template_env()
+    card_spec = formatter.CardSpec(id='test_id', title='test_title')
+    chart_spec = formatter.ChartSpec(
+        'test_chart_id', 'test_chart_json', 'test_chart_description'
+    )
+    card_html = ET.fromstring(
+        formatter.create_card_html(
+            template_env, card_spec, 'test_insights', [chart_spec]
+        )
+    )
+    self.assertContainsSubset('test_title', card_html[0].text)
+    self.assertContainsSubset('test_insights', card_html[1][1].text)
+
+  def test_create_card_html_multiple_charts(self):
+    template_env = formatter.create_template_env()
+    card_spec = formatter.CardSpec(id='test_id', title='test_title')
+    chart_spec1 = formatter.ChartSpec(
+        'test_chart_id1', 'test_chart_json1', 'test_chart_description1'
+    )
+    chart_spec2 = formatter.ChartSpec(
+        'test_chart_id2', 'test_chart_json2', 'test_chart_description2'
+    )
+    card_html = ET.fromstring(
+        formatter.create_card_html(
+            template_env, card_spec, 'test_insights', [chart_spec1, chart_spec2]
+        )
+    )
+    charts = card_html[2]
+    self.assertLen(charts, 4)  # Each chart has 2 items, chart and script.
+
+  def test_create_card_html_chart_structure(self):
+    template_env = formatter.create_template_env()
+    card_spec = formatter.CardSpec(id='test_id', title='test_title')
+    chart_spec = formatter.ChartSpec(
+        'test_chart_id', 'test_chart_json', 'test_chart_description'
+    )
+    card_html = ET.fromstring(
+        formatter.create_card_html(
+            template_env, card_spec, 'test_insights', [chart_spec]
+        )
+    )
+    chart_html = card_html[2]
+    self.assertEqual(chart_html.tag, 'charts')
+    self.assertEqual(chart_html[0].tag, 'chart')
+    self.assertEqual(chart_html[0][0].tag, 'chart-embed')
+    self.assertEqual(chart_html[0][1].tag, 'chart-description')
+    self.assertContainsSubset('test_chart_description', chart_html[0][1].text)
+    self.assertEqual(chart_html[1].tag, 'script')
+    self.assertContainsSubset('test_chart_json', chart_html[1].text)
+
+  def test_create_card_html_mulitple_stats(self):
+    template_env = formatter.create_template_env()
+    card_spec = formatter.CardSpec(id='test_id', title='test_title')
+    stat1 = formatter.StatsSpec(title='stats_title1', stat='test_stat1')
+    stat2 = formatter.StatsSpec(title='stats_title2', stat='test_stat2')
+    card_html = ET.fromstring(
+        formatter.create_card_html(
+            template_env, card_spec, 'test_insights', stats_specs=[stat1, stat2]
+        )
+    )
+    stats = card_html[2]
+    self.assertLen(stats, 2)
+
+  def test_create_card_html_stats_structure(self):
+    template_env = formatter.create_template_env()
+    card_spec = formatter.CardSpec(id='test_id', title='test_title')
+    stats_spec = formatter.StatsSpec(
+        title='stats_title', stat='test_stat', delta='+0.3'
+    )
+    card_html = ET.fromstring(
+        formatter.create_card_html(
+            template_env, card_spec, 'test_insights', stats_specs=[stats_spec]
+        )
+    )
+    stats_html = card_html[2]
+    self.assertEqual(stats_html.tag, 'stats-section')
+    self.assertEqual(stats_html[0].tag, 'stats')
+    self.assertEqual(stats_html[0][0].tag, 'stats-title')
+    self.assertEqual(stats_html[0][0].text, 'stats_title')
+    self.assertEqual(stats_html[0][1].tag, 'stat')
+    self.assertEqual(stats_html[0][1].text, 'test_stat')
+    self.assertEqual(stats_html[0][2].tag, 'delta')
+    self.assertContainsSubset('+0.3', stats_html[0][2].text)
+
+
+if __name__ == '__main__':
+  absltest.main()

meridian/{analysis/templates → templates}/insights.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}/stats.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}/style.css

@@ -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}/style.scss

@@ -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}/summary.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.
@@ -42,7 +42,9 @@ limitations under the License.
       </div>
     </div>
 
-    {% include "chips.html.jinja" %}
+    {% if start_date is defined and start_date %}
+      {% include "chips.html.jinja" %}
+    {% endif %}
 
     <cards>
       {# Each card is laid out in a grid. See; .card display layout. #}

meridian/{analysis/templates → templates}/table.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/version.py

@@ -14,4 +14,4 @@
 
 """Module for Meridian version."""
 
-__version__ = "1.3.1"
+__version__ = "1.3.2"

schema/__init__.py

@@ -14,5 +14,17 @@
 
 """Module containing MMM schema library."""
 
+try:  # pylint: disable=g-statement-before-imports
+  # 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
+except ModuleNotFoundError as exc:
+  raise ImportError(
+      'Schema dependencies not found. Please install meridian with '
+      '`pip install google-meridian[schema]`.'
+  ) from exc
+
+# pylint: disable=g-import-not-at-top
 from schema import serde
 from schema import utils

meridian/model/eda/meridian_eda.py

@@ -1,220 +0,0 @@
-# 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.
-
-"""Module containing Meridian related exploratory data analysis (EDA) functionalities."""
-from __future__ import annotations
-
-from typing import Literal, TYPE_CHECKING, Union
-
-import altair as alt
-from meridian import constants
-from meridian.model.eda import constants as eda_constants
-import pandas as pd
-
-if TYPE_CHECKING:
-  from meridian.model import model  # pylint: disable=g-bad-import-order,g-import-not-at-top
-
-__all__ = [
-    'MeridianEDA',
-]
-
-
-class MeridianEDA:
-  """Class for running pre-modeling exploratory data analysis for Meridian InputData."""
-
-  _PAIRWISE_CORR_COLOR_SCALE = alt.Scale(
-      domain=[-1.0, 0.0, 1.0],
-      range=['#1f78b4', '#f7f7f7', '#e34a33'],  # Blue-light grey-Orange
-      type='linear',
-  )
-
-  def __init__(
-      self,
-      meridian: model.Meridian,
-  ):
-    self._meridian = meridian
-
-  def generate_and_save_report(self, filename: str, filepath: str):
-    """Generates and saves the 2 page HTML report containing findings in EDA about given InputData.
-
-    Args:
-      filename: The filename for the generated HTML output.
-      filepath: The path to the directory where the file will be saved.
-    """
-    # TODO: Implement.
-    raise NotImplementedError()
-
-  def plot_pairwise_correlation(
-      self, geos: Union[int, list[str], Literal['nationalize']] = 1
-  ) -> alt.Chart:
-    """Plots the Pairwise Correlation data.
-
-    Args:
-      geos: Defines which geos to plot. - int: The number of top geos to plot,
-        ranked by population. - list[str]: A specific list of geo names to plot.
-        - 'nationalize': Aggregates all geos into a single national view.
-        Defaults to 1 (plotting the top geo). If the data is already at a
-        national level, this parameter is ignored and a national plot is
-        generated.
-
-    Returns:
-      Altair chart(s) of the Pairwise Correlation data.
-    """
-    geos_to_plot = self._validate_and_get_geos_to_plot(geos)
-    is_national = self._meridian.is_national
-    nationalize_geos = geos == 'nationalize'
-
-    if is_national or nationalize_geos:
-      pairwise_corr_artifact = (
-          self._meridian.eda_engine.check_national_pairwise_corr().get_national_artifact
-      )
-      if pairwise_corr_artifact is None:
-        raise ValueError('EDAOutcome does not have national artifact.')
-    else:
-      pairwise_corr_artifact = (
-          self._meridian.eda_engine.check_geo_pairwise_corr().get_geo_artifact
-      )
-      if pairwise_corr_artifact is None:
-        raise ValueError('EDAOutcome does not have geo artifact.')
-    pairwise_corr_data = pairwise_corr_artifact.corr_matrix.to_dataframe()
-
-    charts = []
-    for geo_to_plot in geos_to_plot:
-      title = (
-          'Pairwise correlations among all treatments and controls for'
-          f' {geo_to_plot}'
-      )
-
-      if not (is_national or nationalize_geos):
-        plot_data = (
-            pairwise_corr_data.xs(geo_to_plot, level=constants.GEO)
-            .rename_axis(
-                index=[eda_constants.VARIABLE_1, eda_constants.VARIABLE_2]
-            )
-            .reset_index()
-        )
-      else:
-        plot_data = pairwise_corr_data.rename_axis(
-            index=[eda_constants.VARIABLE_1, eda_constants.VARIABLE_2]
-        ).reset_index()
-      plot_data.columns = [
-          eda_constants.VARIABLE_1,
-          eda_constants.VARIABLE_2,
-          eda_constants.CORRELATION,
-      ]
-      unique_variables = plot_data[eda_constants.VARIABLE_1].unique()
-      variable_to_index = {name: i for i, name in enumerate(unique_variables)}
-
-      plot_data['idx1'] = plot_data[eda_constants.VARIABLE_1].map(
-          variable_to_index
-      )
-      plot_data['idx2'] = plot_data[eda_constants.VARIABLE_2].map(
-          variable_to_index
-      )
-      lower_triangle_data = plot_data[plot_data['idx2'] > plot_data['idx1']]
-
-      charts.append(
-          self._plot_2d_heatmap(lower_triangle_data, title, unique_variables)
-      )
-    final_chart = (
-        alt.vconcat(*charts)
-        .resolve_legend(color='independent')
-        .configure_axis(labelAngle=315)
-        .configure_title(anchor='start')
-        .configure_view(stroke=None)
-    )
-    return final_chart
-
-  def _plot_2d_heatmap(
-      self, data: pd.DataFrame, title: str, unique_variables: list[str]
-  ) -> alt.Chart:
-    """Plots a 2D heatmap."""
-    # Base chart with position encodings
-    base = (
-        alt.Chart(data)
-        .encode(
-            x=alt.X(
-                f'{eda_constants.VARIABLE_1}:N',
-                title=None,
-                sort=unique_variables,
-                scale=alt.Scale(domain=unique_variables),
-            ),
-            y=alt.Y(
-                f'{eda_constants.VARIABLE_2}:N',
-                title=None,
-                sort=unique_variables,
-                scale=alt.Scale(domain=unique_variables),
-            ),
-        )
-        .properties(title=title)
-    )
-
-    # Heatmap layer (rectangles)
-    heatmap = base.mark_rect().encode(
-        color=alt.Color(
-            f'{eda_constants.CORRELATION}:Q',
-            scale=self._PAIRWISE_CORR_COLOR_SCALE,
-            legend=alt.Legend(title=eda_constants.CORRELATION),
-        ),
-        tooltip=[
-            eda_constants.VARIABLE_1,
-            eda_constants.VARIABLE_2,
-            alt.Tooltip(f'{eda_constants.CORRELATION}:Q', format='.3f'),
-        ],
-    )
-
-    # Text annotation layer (values)
-    text = base.mark_text().encode(
-        text=alt.Text(f'{eda_constants.CORRELATION}:Q', format='.3f'),
-        color=alt.value('black'),
-    )
-
-    # Combine layers and apply final configurations
-    chart = (heatmap + text).properties(width=350, height=350)
-
-    return chart
-
-  def _generate_pairwise_correlation_report(self) -> str:
-    """Creates the HTML snippet for Pairwise Correlation report section."""
-    # TODO: Implement.
-    raise NotImplementedError()
-
-  def _validate_and_get_geos_to_plot(
-      self, geos: Union[int, list[str], Literal['nationalize']]
-  ) -> list[str]:
-    """Validates and returns the geos to plot."""
-    ## Validate
-    is_national = self._meridian.is_national
-    if is_national or geos == 'nationalize':
-      geos_to_plot = [constants.NATIONAL_MODEL_DEFAULT_GEO_NAME]
-    elif isinstance(geos, int):
-      if geos > len(self._meridian.input_data.geo) or geos <= 0:
-        raise ValueError(
-            'geos must be a positive integer less than or equal to the number'
-            ' of geos in the data.'
-        )
-      geos_to_plot = self._meridian.input_data.get_n_top_largest_geos(geos)
-    else:
-      geos_to_plot = geos
-
-    if (
-        not is_national and geos != 'nationalize'
-    ):  # if national then geos_to_plot will be ignored
-      for geo in geos_to_plot:
-        if geo not in self._meridian.input_data.geo:
-          raise ValueError(f'Geo {geo} does not exist in the data.')
-      if len(geos_to_plot) != len(set(geos_to_plot)):
-        raise ValueError('geos must not contain duplicate values.')
-
-    return geos_to_plot