gov-uk-dashboards 26.8.0__py3-none-any.whl → 26.26.0__py3-none-any.whl

gov_uk_dashboards/components/plotly/stacked_barchart.py

@@ -23,7 +23,7 @@ from gov_uk_dashboards.constants import (
     SUBTITLE,
     VALUE,
 )
-from gov_uk_dashboards.colours import AFAccessibleColours
+from gov_uk_dashboards.colours import AFAccessibleColours, ONSAccessibleColours
 from gov_uk_dashboards.components.helpers.display_chart_or_table_with_header import (
     display_chart_or_table_with_header,
 )
@@ -73,6 +73,8 @@ class StackedBarChart:
         alternative_data_button_text: Optional[str] = None,
         alternative_all_data_button_text: Optional[str] = None,
         total_trace_name: Optional[str] = None,
+        y_axis_tick_prefix: Optional[str] = "£",
+        x_hoverformat: Optional[str] = "%b %Y",
     ):
         """Initializes the StackedBarChart instance.
         To display the chart, call the `get_stacked_bar_chart()` method.
@@ -122,6 +124,8 @@ class StackedBarChart:
         self.alternative_data_button_text = alternative_data_button_text
         self.alternative_all_data_button_text = alternative_all_data_button_text
         self.total_trace_name = total_trace_name
+        self.y_axis_tick_prefix = y_axis_tick_prefix
+        self.x_hoverformat = x_hoverformat
         self.fig = self.create_stacked_bar_chart()
 
     def get_stacked_bar_chart(self) -> html.Div:
@@ -211,14 +215,17 @@ class StackedBarChart:
                     legendrank=999,
                 )
             )
-        colour_list = (
-            AFAccessibleColours.CATEGORICAL.value
-            if len(self.trace_name_list) != 2
-            else [
+
+        if len(self.trace_name_list) > 6:
+            colour_list = ONSAccessibleColours.CATEGORICAL_MANY.value
+        elif len(self.trace_name_list) != 2:
+            colour_list = AFAccessibleColours.CATEGORICAL.value
+        else:
+            colour_list = [
                 AFAccessibleColours.DARK_BLUE.value,
                 AFAccessibleColours.ORANGE.value,
             ]  # if 2 lines should use dark blue & orange as have highest contrast ratio
-        )
+
         for _, (df, trace_name, colour) in enumerate(
             zip(
                 self._get_df_list_for_bar_chart(),
@@ -262,7 +269,7 @@ class StackedBarChart:
             font={"size": CHART_LABEL_FONT_SIZE},
             yaxis={
                 # "range": [min_y * 1.1, max_y * 1.1],
-                "tickprefix": "£",
+                "tickprefix": self.y_axis_tick_prefix,
                 "exponentformat": "B",
                 # "tickmode": "array",
                 # "tickvals": tickvals,
@@ -270,12 +277,13 @@ class StackedBarChart:
             },
             showlegend=True,
             barmode="relative",
-            xaxis={"categoryorder": "category ascending"},
+            xaxis={"categoryorder": "array", "categoryarray": self.trace_name_list},
             xaxis_title=self.x_axis_column if self.show_x_axis_title else None,
             ## copied from timeseries
             hovermode="x unified" if self.x_unified_hovermode is True else "closest",
             hoverdistance=self.hover_distance,  # Increase distance to simulate hover 'always on'
         )
+        self._format_xaxis(fig)
         return fig
 
     def create_bar_chart_trace(
@@ -320,13 +328,13 @@ class StackedBarChart:
         if self.x_unified_hovermode is True:
             return f"{trace_name}: " + "%{customdata[0]}<extra></extra>"
         hover_text_headers = self.hover_data[trace_name][HOVER_TEXT_HEADERS]
-        hover_template = (
-            f"{trace_name}<br>"
-            f"{hover_text_headers[0]}"
-            ": %{customdata[0]}<br>"
-            f"{hover_text_headers[1]}"
-            ": %{customdata[1]}<extra></extra>"
-        )
+        hover_template = f"{trace_name}<br>"
+
+        for i, header in enumerate(hover_text_headers):
+            hover_template += f"{header}: %{{customdata[{i}]}}<br>"
+
+        # Remove the last <br> and add <extra></extra>
+        hover_template = hover_template.rstrip("<br>") + "<extra></extra>"
         return hover_template
 
     def _get_custom_data(self, trace_name, df):
@@ -397,6 +405,36 @@ class StackedBarChart:
         tickvals = list(range(int(start), int(end) + 1, int(step_size)))
         return tickvals
 
+    def _format_xaxis(self, fig):
+        if self.xaxis_tick_text_format == "quarter":
+            df = self.df.with_columns(
+                pl.col(self.x_axis_column).str.strptime(pl.Date, "%Y-%m-%d")
+            )
+
+            first_year = df.select(pl.col(self.x_axis_column).min()).item().year
+            next_year = first_year + 1
+
+            max_in_first_year = (
+                df.filter(pl.col(self.x_axis_column).dt.year() == first_year)
+                .select(pl.col(self.x_axis_column).max())
+                .item()
+            )
+            min_in_next_year = (
+                df.filter(pl.col(self.x_axis_column).dt.year() == next_year)
+                .select(pl.col(self.x_axis_column).min())
+                .item()
+            )
+
+            tick0 = max_in_first_year + (min_in_next_year - max_in_first_year) / 2
+
+            fig.update_xaxes(
+                tick0=tick0,  # start tick halfway between Dec & Mar
+                dtick="M12",  # one tick per year
+                tickformat="%Y",
+                hoverformat=self.x_hoverformat,
+            )
+        return fig
+
 
 def get_tracenamelist_and_legend_order(df_function, barchart_measures=None):
     """

gov_uk_dashboards/components/plotly/time_series_chart.py

@@ -63,6 +63,9 @@ class TimeSeriesChart:
         hover_data: HoverDataByTrace,
         filtered_df: pl.DataFrame,
         trace_name_list: list[str],
+        dashed_trace_name_list: list[str] = None,
+        trace_colour_groups: list[str, str] = None,
+        initially_hidden_traces: Optional[list[str]] = None,
         hover_data_for_traces_with_different_hover_for_last_point: Optional[
             HoverDataByTrace
         ] = None,
@@ -86,6 +89,7 @@ class TimeSeriesChart:
         additional_line: Optional[dict] = None,
         hover_distance: Optional[int] = 1,
         footnote: Optional[str] = None,
+        stacked: Optional[bool] = False,
     ):  # pylint: disable=duplicate-code
         self.title_data = title_data
         self.y_axis_column = y_axis_column
@@ -95,6 +99,9 @@ class TimeSeriesChart:
         )
         self.filtered_df = filtered_df
         self.trace_name_list = trace_name_list
+        self.dashed_trace_name_list = dashed_trace_name_list
+        self.trace_colour_groups = trace_colour_groups
+        self.initially_hidden_traces = initially_hidden_traces
         self.legend_dict = legend_dict
         self.trace_name_column = trace_name_column
         self.xaxis_tick_text_format = xaxis_tick_text_format
@@ -124,6 +131,7 @@ class TimeSeriesChart:
         self.number_of_traces_colour_shift_dict = number_of_traces_colour_shift_dict
         self.additional_line = additional_line
         self.hover_distance = hover_distance
+        self.stacked = stacked
         self.colour_list = self._get_colour_list()
         self.fig = self.create_time_series_chart()
         self.footnote = footnote
@@ -253,7 +261,12 @@ class TimeSeriesChart:
                 self.create_time_series_trace(
                     df.sort(self.x_axis_column),
                     trace_name,
-                    line_style={"dash": "solid", "color": colour},
+                    line_style=(
+                        {"dash": "dot", "color": colour}
+                        if self.dashed_trace_name_list is not None
+                        and trace_name in self.dashed_trace_name_list
+                        else {"dash": "solid", "color": colour}
+                    ),
                     marker={"symbol": marker, "size": marker_sizes, "opacity": 1},
                     legendgroup=legendgroup,
                 ),
@@ -415,6 +428,14 @@ class TimeSeriesChart:
             marker (dict[str,str]): Properties for marker parameter.
             legendgroup (str): Name to group by in legend,
         """
+        if (
+            self.initially_hidden_traces is not None
+            and trace_name in self.initially_hidden_traces
+        ):
+            visible = "legendonly"
+        else:
+            visible = True
+
         return go.Scatter(
             x=df[self.x_axis_column],
             y=df[self.y_axis_column],
@@ -428,6 +449,8 @@ class TimeSeriesChart:
                 trace_name in self.legend_dict if self.legend_dict is not None else True
             ),
             legendgroup=legendgroup,
+            stackgroup="one" if self.stacked else None,
+            visible=visible,
         )
 
     def _get_hover_template(self, df, trace_name):
@@ -500,6 +523,7 @@ class TimeSeriesChart:
             return self.legend_dict[trace_name]
         return trace_name
 
+    # pylint: disable=too-many-statements
     def _get_x_axis_content(self):
         """Generates tick text and values for the x-axis based on the unique years calculated from
         the DATE_VALID column in the dataframe.
@@ -599,6 +623,30 @@ class TimeSeriesChart:
             ]
 
             range_x = [0.5, 4.5]
+        elif self.xaxis_tick_text_format == XAxisFormat.WEEK.value:
+            df = self.filtered_df.with_columns(
+                pl.col(self.x_axis_column)
+                .str.strptime(pl.Datetime, "%Y-%m-%d", strict=False)
+                .alias(self.x_axis_column)
+            ).sort(self.x_axis_column)
+
+            start_datetime = df[self.x_axis_column].min() - relativedelta(weeks=1)
+            latest_datetime = df[self.x_axis_column].max() + relativedelta(weeks=1)
+
+            start_of_week = start_datetime - relativedelta(
+                days=start_datetime.weekday()
+            )
+
+            tick_values = []
+            tick_text = []
+
+            current = start_of_week
+            while current <= latest_datetime:
+                tick_values.append(current)
+                tick_text.append(current.strftime("%d %b %Y"))  # e.g. "29 Sep 2025"
+                current += relativedelta(weeks=1)
+
+            range_x = [start_datetime, latest_datetime]
         else:
             raise ValueError(
                 f"Invalid xaxis_tick_text_format: {self.xaxis_tick_text_format}"
@@ -608,9 +656,16 @@ class TimeSeriesChart:
     def _get_y_axis_range_max(self):
         """Get the y axis range maximum value to ensure there is an axis label greater than the
         maximum y value."""
-        largest_number_of_weeks = self.filtered_df[self.y_axis_column].max()
-
-        y_axis_max = largest_number_of_weeks + (0.3 * largest_number_of_weeks)
+        if self.stacked:
+            largest_y_value = (
+                self.filtered_df.group_by(self.x_axis_column)  # group by date
+                .agg(pl.col(self.y_axis_column).sum())  # total per date
+                .select(pl.col(self.y_axis_column).max())  # largest daily total
+                .item()  # extract scalar
+            )
+        else:
+            largest_y_value = self.filtered_df[self.y_axis_column].max()
+        y_axis_max = largest_y_value + (0.3 * largest_y_value)
         return y_axis_max
 
     def _get_df_list_for_time_series(self) -> list[pl.DataFrame]:
@@ -624,27 +679,97 @@ class TimeSeriesChart:
         return df_list
 
     def _get_colour_list(self):
-        """Returns a list of colours."""
+        """Returns a list of colours (one per trace in trace_name_list).
+
+        If `trace_colour_groups` is provided, traces in the same group share a colour.
+        Traces not in any group get their own colour from the palette.
+        """
+        palette = self._get_base_palette()
+        palette = self._apply_colour_shift(palette)
+
+        groups = getattr(self, "trace_colour_groups", None) or []
+        if not groups:
+            return palette[: len(self.trace_name_list)]
+
+        trace_to_group_id = self._build_trace_to_group_id(groups)
+        return self._assign_colours_with_groups(palette, trace_to_group_id)
+
+    def _get_base_palette(self) -> list[str]:
         number_of_traces = len(self.trace_name_list)
         if number_of_traces == 2 and self.filled_traces_dict is None:
-            colour_list = [
+            return [
                 AFAccessibleColours.DARK_BLUE.value,
                 AFAccessibleColours.ORANGE.value,
-            ]  # if 2 lines should use dark blue & orange as have highest contrast ratio
-        else:
-            colour_list = AFAccessibleColours.CATEGORICAL.value.copy()
+            ]
+        return AFAccessibleColours.CATEGORICAL.value.copy()
+
+    def _apply_colour_shift(self, palette: list[str]) -> list[str]:
+        """Apply number_of_traces_colour_shift_dict; may replace palette with explicit list."""
+        number_of_traces = len(self.trace_name_list)
         colour_shift_dict = (
             {"default": 0}
             if self.number_of_traces_colour_shift_dict is None
             else self.number_of_traces_colour_shift_dict
         )
-
         colour_shift_value = colour_shift_dict.get(
             number_of_traces, colour_shift_dict["default"]
         )
+
         if isinstance(colour_shift_value, list):
-            return colour_shift_value  # list of colours
-        while colour_shift_value > 0:
-            colour_list.append(colour_list.pop(0))
-            colour_shift_value -= 1
-        return colour_list
+            return colour_shift_value
+
+        # rotate left by colour_shift_value
+        shift = int(colour_shift_value)
+        if shift <= 0:
+            return palette
+
+        shift = shift % len(palette)
+        return palette[shift:] + palette[:shift]
+
+    def _build_trace_to_group_id(self, groups: list[list[str]]) -> dict[str, int]:
+        """Validate groups and return a mapping of trace -> group_id."""
+        trace_set = set(self.trace_name_list)
+        trace_to_group_id: dict[str, int] = {}
+
+        for group_id, group in enumerate(groups):
+            for trace in group:
+                if trace not in trace_set:
+                    raise ValueError(
+                        f"trace_colour_groups contains '{trace}', but it's not in trace_name_list."
+                    )
+                if trace in trace_to_group_id:
+                    raise ValueError(
+                        f"Trace '{trace}' appears in more than one trace_colour_group."
+                    )
+                trace_to_group_id[trace] = group_id
+
+        return trace_to_group_id
+
+    def _assign_colours_with_groups(
+        self,
+        palette: list[str],
+        trace_to_group_id: dict[str, int],
+    ) -> list[str]:
+        """Assign one colour per group (first-seen), and one per ungrouped trace."""
+        group_colour: dict[int, str] = {}
+        trace_colour: dict[str, str] = {}
+        colour_idx = 0
+
+        # assign colours to groups in order of first appearance in trace_name_list
+        for trace in self.trace_name_list:
+            group_id = trace_to_group_id.get(trace)
+            if group_id is not None and group_id not in group_colour:
+                group_colour[group_id] = palette[colour_idx % len(palette)]
+                colour_idx += 1
+
+        # apply group colours to grouped traces
+        for trace, group_id in trace_to_group_id.items():
+            trace_colour[trace] = group_colour[group_id]
+
+        # assign colours to ungrouped traces
+        for trace in self.trace_name_list:
+            if trace not in trace_colour:
+                trace_colour[trace] = palette[colour_idx % len(palette)]
+                colour_idx += 1
+
+        return [trace_colour[t] for t in self.trace_name_list]

gov_uk_dashboards/constants.py

@@ -39,3 +39,22 @@ LATEST_YEAR = "latest_year"
 PREVIOUS_YEAR = "previous_year"
 PREVIOUS_2YEAR = "previous_2year"
 TWENTY_NINETEEN = "twenty_nineteen"
+
+NOTIFICATION_STYLE_RED = {"borderColor": "#d4351c", "backgroundColor": "#d4351c"}
+NOTIFICATION_STYLE_ORANGE = {"borderColor": "#f47738", "backgroundColor": "#f47738"}
+NOTIFICATION_STYLE_YELLOW = {"borderColor": "#ffdd00", "backgroundColor": "#ffdd00"}
+NOTIFICATION_STYLE_GREEN = {"borderColor": "#00703c", "backgroundColor": "#00703c"}
+
+BANNER_STYLE = {
+    "display": "flex",
+    "visibility": "visible",
+    "margin": "-10px -15px 0px -15px",
+}
+
+ERROR_MESSAGE_BANNER_STYLE = {
+    "width": "100%",
+    "paddingLeft": "30px",
+    "paddingRight": "30px",
+    "justifyContent": "left",
+    "backgroundColor": "#FFDD00",
+}

gov_uk_dashboards/formatting/number_formatting.py

@@ -29,3 +29,10 @@ def add_commas(number: int, remove_decimal_places: bool = False) -> str:
     if remove_decimal_places:
         return f"{number:,.0f}"
     return f"{number:,}"
+
+
+def format_percentage(percentage):
+    """Formats percentages to remove decimal place on numbers 10 or more"""
+    if abs(percentage) < 10:
+        return percentage
+    return int(percentage)

gov_uk_dashboards/lib/datetime_functions/datetime_functions.py

@@ -7,6 +7,91 @@ import re
 from typing import Optional
 
 
+def convert_date(
+    date_input,
+    input_format=None,
+    output_format=None,
+    convert_to_datetime=False,
+    abbreviate_jun_jul=False,
+):
+    """
+    Convert a date input (string, date, or datetime) into either a datetime object or a formatted
+        string.
+
+    Behaviour:
+    - If `date_input` is a string, `input_format` must be provided and is used with
+        `datetime.strptime`.
+    - If `convert_to_datetime` is True, returns a `datetime.datetime` (at midnight if the input was
+        a `date`), and `output_format` is ignored.
+    - If `convert_to_datetime` is False, `output_format` must be provided and is used with
+        `strftime`.
+
+    Month abbreviation tweak:
+    - If `abbreviate_jun_jul` is False (default), and your `output_format` produces abbreviated
+        months (e.g., via `%b`), any standalone "Jun" or "Jul" tokens in the formatted output are
+        expanded to "June" / "July".
+    - If `abbreviate_jun_jul` is True, the output is left exactly as produced by `strftime`.
+
+    Args:
+        date_input (str | datetime.datetime | datetime.date):
+            The date to convert.
+        input_format (str | None):
+            Format string for parsing `date_input` when it is a string. Required if `date_input` is
+            a string.
+        output_format (str | None):
+            Format string used when returning a string. Required if `convert_to_datetime` is False.
+        convert_to_datetime (bool):
+            If True, return a `datetime.datetime`. If False, return a formatted string.
+        abbreviate_jun_jul (bool):
+            If False, expand "Jun"/"Jul" to "June"/"July" in the final formatted string.
+
+    Returns:
+        datetime.datetime | str:
+            A datetime object if `convert_to_datetime` is True, otherwise a formatted string.
+
+    Raises:
+        ValueError:
+            If `date_input` is a string and `input_format` is None, or if parsing fails.
+            If `convert_to_datetime` is False and `output_format` is None.
+        TypeError:
+            If `date_input` is not a string, date, or datetime.
+    """
+    # Parse / normalise to datetime
+    if isinstance(date_input, str):
+        if input_format is None:
+            raise ValueError(
+                "input_format must be provided when date_input is a string"
+            )
+        try:
+            dt = datetime.strptime(date_input, input_format)
+        except ValueError as e:
+            raise ValueError(
+                f"Could not parse date_input={date_input!r} with input_format={input_format!r}"
+            ) from e
+    elif isinstance(date_input, datetime):
+        dt = date_input
+    elif isinstance(date_input, date):
+        dt = datetime.combine(date_input, datetime.min.time())
+    else:
+        raise TypeError("date_input must be a str, datetime.datetime, or datetime.date")
+
+    if convert_to_datetime:
+        return dt
+
+    if output_format is None:
+        raise ValueError(
+            "output_format must be provided when convert_to_datetime is False"
+        )
+
+    output_str = dt.strftime(output_format)
+
+    if not abbreviate_jun_jul:
+        output_str = re.sub(r"\bJun\b", "June", output_str)
+        output_str = re.sub(r"\bJul\b", "July", output_str)
+
+    return output_str
+
+
 def convert_date_string_to_text_string(
     date_str: str,
     date_format: Optional[str] = "%Y-%m-%d",

gov_uk_dashboards/lib/http_headers.py

@@ -15,9 +15,10 @@ def setup_application_http_response_headers(dash_app: dash.Dash):
             "script-src 'self' 'unsafe-inline' https://*.googletagmanager.com "
             "https://cdn.jsdelivr.net/npm/web-vitals@4.2.4/dist/web-vitals.min.js "
             "https://cdn.jsdelivr.net/npm/html2canvas@1.4.1/dist/html2canvas.min.js "
-            "https://*.google-analytics.com;"
+            "https://*.google-analytics.com https://js.monitor.azure.com/scripts/b/ai.3.gbl.min.js;"
             "connect-src 'self' https://*.googletagmanager.com https://*.google-analytics.com "
-            "https://*.analytics.google.com; "
+            "https://*.analytics.google.com https://js.monitor.azure.com "
+            "https://*.applicationinsights.azure.com/v2/track; "
             "img-src 'self' https://*.googletagmanager.com https://*.google-analytics.com "
             "https://*.analytics.google.com data: https://*.tile.openstreetmap.org; "
         )

gov_uk_dashboards/lib/testing_functions/data_test_assertions.py

@@ -46,7 +46,7 @@ def cvs_contains_no_duplicate_rows(csv_absolute_filepath: str):
     Returns: bool: True if there were no duplicates in the df, False otherwise.
     """
 
-    df = pl.read_csv(csv_absolute_filepath)
+    df = pl.read_csv(csv_absolute_filepath, infer_schema_length=1000)
     num_duplicate_rows = df.is_duplicated().sum()
     assert (
         num_duplicate_rows == 0
@@ -71,7 +71,7 @@ def inferred_df_has_correct_column_types(
         for field, typ in schema.__annotations__.items()
     }
 
-    df = pl.read_csv(csv_absolute_filepath)
+    df = pl.read_csv(csv_absolute_filepath, infer_schema_length=1000)
     assert df.schema == expected_schema
 
 
@@ -86,7 +86,7 @@ def df_has_valid_schema(csv_absolute_filepath: str, schema: Type[BaseModel]):
         schema (Type[BaseModel]): Pydantic model class to extract the expected column types
     """
 
-    df = pl.read_csv(csv_absolute_filepath)
+    df = pl.read_csv(csv_absolute_filepath, infer_schema_length=1000)
 
     if hasattr(schema, "from_polars"):  # column level validation
         try:

gov_uk_dashboards/lib/testing_functions/data_test_helper_functions.py

@@ -30,7 +30,7 @@ def extract_main_type(typ):
 
         # If it's a tuple containing types, filter out NoneType and return the first non-None
         non_none_args = [
-            arg for arg in args if arg is not type(None)
+            arg for arg in args if not isinstance(arg, type(None))
         ]  # Remove NoneType
         return (
             non_none_args[0] if non_none_args else typ
@@ -240,6 +240,7 @@ def value_matches_regex_pattern_or_alternative_value(
         "url": r"https?:\/\/(www\.)?[a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-zA-Z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)",  # pylint: disable=line-too-long
         "x_weeks_and_y_days": r"^\d+\s+weeks\s+and\s+\d+\s+days$",
         "area_code": r"^^E(?:0[6789]|[01][06789])\d{6}$",
+        "region_code": r"^E1200000[1-9]$",
         "YYYY-YY": r"^\d{4}-\d{2}$",
         "YYYY-MM": r"^\d{4}-(0[1-9]|1[0-2])$",
     }

gov_uk_dashboards/log_kpi.py

@@ -0,0 +1,37 @@
+"""Logging utility for KPI runs.
+
+This module provides a reusable function `log_message` that appends
+a message to a KPI log file, prefixed with a UK-time timestamp
+(including milliseconds). It can be called directly from the command
+line or imported and reused in other scripts.
+"""
+
+import sys
+import os
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+# Path to KPI log file (should be provided via environment variable)
+KPI_LOG = os.environ.get("KPI_LOG_FILE")
+UK_TZ = ZoneInfo("Europe/London")
+
+
+def log_message(message: str) -> None:
+    """Write a message to the KPI log with a UK-time timestamp.
+
+    Args:
+        message (str): The log message to append.
+    """
+    timestamp = datetime.now(UK_TZ).strftime("%Y-%m-%d %H:%M:%S.%f")[:-4]  # keep ms
+    line = f"[{timestamp}] {message}\n"
+
+    with open(KPI_LOG, "a", encoding="utf-8") as f:
+        f.write(line)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        sys.exit(1)
+
+    MESSAGE = " ".join(sys.argv[1:])
+    log_message(MESSAGE)

gov_uk_dashboards/template.html

@@ -45,7 +45,7 @@
 
       }, 200);
       
-  </script>
+    </script>
   </head>
   <body class="govuk-template__body">
     <div class="visually-hidden" id="readTitle" role="status"></div>

gov_uk_dashboards/template.py

@@ -13,6 +13,9 @@ def read_template(favicon_path: str = r"assets\images\MHCLG_favicon.png") -> str
     :return: String version of the template.
     """
     gtag = os.environ.get("GTAG", "")
+    app_insights_conn_string = os.environ.get(
+        "APPLICATIONINSIGHTS_CONNECTION_STRING", ""
+    )
     path = os.path.join(os.path.dirname(__file__), "template.html")
 
     with open(path, encoding="utf-8") as file:
@@ -20,4 +23,7 @@ def read_template(favicon_path: str = r"assets\images\MHCLG_favicon.png") -> str
 
         rendered_template = template.replace("{{favicon_path}}", favicon_path)
         rendered_template = rendered_template.replace("{{gtag}}", gtag)
+        rendered_template = rendered_template.replace(
+            "{{app_insights_conn_string}}", app_insights_conn_string
+        )
         return rendered_template

{gov_uk_dashboards-26.8.0.dist-info → gov_uk_dashboards-26.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gov_uk_dashboards
-Version: 26.8.0
+Version: 26.26.0
 Summary: Provides access to functionality common to creating a data dashboard.
 Author: Department for Levelling Up, Housing and Communities
 Description-Content-Type: text/markdown
@@ -9,7 +9,7 @@ Requires-Dist: setuptools<81.0,>=59.8
 Requires-Dist: dash~=3.0
 Requires-Dist: numpy>=2.3.2
 Requires-Dist: dash_bootstrap_components~=2.0.3
-Requires-Dist: plotly~=6.2.0
+Requires-Dist: plotly<6.6,>=6.2
 Requires-Dist: flask-basicauth~=0.2.0
 Dynamic: author
 Dynamic: description