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

gov_uk_dashboards/lib/dap/get_dataframe_from_cds.py

@@ -1,109 +1,110 @@
-""" Returns a dataframe after connecting to CDS, otherwise uses a csv already saved in the file"""
-import os
-import json
-import pandas as pd
-import pyodbc
-import boto3
+"""Returns a dataframe after connecting to CDS, otherwise uses a csv already saved in the file"""
 
+# import os
+# import json
+# import pyodbc
+# import boto3
 
-def get_data_from_cds_or_fallback_to_csv(
-    cds_sql_query: str, csv_path: str, secret_name: str, cds_server_name: str
-) -> pd.DataFrame:
-    """Tries to return dataframe from CDS first via Pydash credentials,
-    otherwise via Amazon WorkSpaces,
-    otherwise via a file from folder.
-    Inputs:
-        cds_sql_query(str): SQL query string
-        csv_path(str): Filepath for location of csv to fallback to
-        secret_name(str): AWS Secrets Manager, secret name containing CDS credentials.
-        cds_server_name(str): CDS Server name used in connection string
-    Returns:
-        pd.DataFrame
-    """
-    if (
-        "DATA_FOLDER_LOCATION" in os.environ
-        and os.environ["DATA_FOLDER_LOCATION"] == "tests/"
-    ) or ("STAGE" in os.environ and os.environ["STAGE"] == "testing"):
-        return pd.read_csv(csv_path)
 
-    try:
-        conn = pyodbc.connect(
-            _get_pydash_connection_string(secret_name, cds_server_name)
-        )
-        print("Dataframe has been loaded from CDS using Pydash credentials")
+# def get_data_from_cds_or_fallback_to_csv(
+#     cds_sql_query: str, csv_path: str, secret_name: str, cds_server_name: str
+# ) -> pd.DataFrame:
+#     """Tries to return dataframe from CDS first via Pydash credentials,
+#     otherwise via Amazon WorkSpaces,
+#     otherwise via a file from folder.
+#     Inputs:
+#         cds_sql_query(str): SQL query string
+#         csv_path(str): Filepath for location of csv to fallback to
+#         secret_name(str): AWS Secrets Manager, secret name containing CDS credentials.
+#         cds_server_name(str): CDS Server name used in connection string
+#     Returns:
+#         pd.DataFrame
+#     """
+#     if (
+#         "DATA_FOLDER_LOCATION" in os.environ
+#         and os.environ["DATA_FOLDER_LOCATION"] == "tests/"
+#     ) or ("STAGE" in os.environ and os.environ["STAGE"] == "testing"):
+#         return pd.read_csv(csv_path)
 
-        return pd.read_sql_query(
-            cds_sql_query,
-            conn,
-        )
+#     try:
+#         conn = pyodbc.connect(
+#             _get_pydash_connection_string(secret_name, cds_server_name)
+#         )
+#         print("Dataframe has been loaded from CDS using Pydash credentials")
 
-    except Exception as credential_error:  # pylint: disable=broad-except
-        try:
-            print(
-                "Failed to load dataframe using Pydash credentials: ", credential_error
-            )
-            conn = pyodbc.connect(
-                "Driver={SQL Server};"
-                f"Server={cds_server_name};"
-                "Database=Dashboards;"
-                "Trusted_Connection=yes;"
-            )
-            print(
-                "Dataframe has been loaded from CDS using Windows login authentication"
-            )
+#         return pd.read_sql_query(
+#             cds_sql_query,
+#             conn,
+#         )
 
-            return pd.read_sql_query(
-                cds_sql_query,
-                conn,
-            )
+#     except Exception as credential_error:  # pylint: disable=broad-except
+#         try:
+#             print(
+#                 "Failed to load dataframe using Pydash credentials: ", credential_error
+#             )
+#             conn = pyodbc.connect(
+#                 "Driver={SQL Server};"
+#                 f"Server={cds_server_name};"
+#                 "Database=Dashboards;"
+#                 "Trusted_Connection=yes;"
+#             )
+#             print(
+#                 "Dataframe has been loaded from CDS using Windows login authentication"
+#             )
 
-        except pyodbc.Error as conn_error_except:
-            print(
-                "Failed to load dataframe using Windows login authentication: ",
-                conn_error_except,
-            )
-            print("Dataframe has been loaded from CSV")
-            return pd.read_csv(csv_path)
+#             return pd.read_sql_query(
+#                 cds_sql_query,
+#                 conn,
+#             )
 
+#         except pyodbc.Error as conn_error_except:
+#             print(
+#                 "Failed to load dataframe using Windows login authentication: ",
+#                 conn_error_except,
+#             )
+#             print("Dataframe has been loaded from CSV")
+#             return pd.read_csv(csv_path)
 
-def _get_pydash_connection_string(secret_name: str, cds_server_name: str):
-    """
-    Pydash aka DAP Hosting requires username and password
-    Inputs:
-        secret_name(str): AWS Secrets Manager, secret name containing CDS credentials.
-        cds_server_name(str): CDS Server name used in connection string
-    """
-    credentials = _pydash_sql_credentials(secret_name)
-    conn_string_dap = (
-        "Driver={/usr/lib/libmsodbcsql-18.so};"
-        f"Server={cds_server_name};"
-        "TrustServerCertificate=yes;"
-        "Database=Dashboards;"
-    )
-    return (
-        f"{conn_string_dap}UID={credentials['username']};PWD={credentials['password']};"
-    )
 
+# def _get_pydash_connection_string(secret_name: str, cds_server_name: str):
+#     """
+#     Pydash aka DAP Hosting requires username and password
+#     Inputs:
+#         secret_name(str): AWS Secrets Manager, secret name containing CDS credentials.
+#         cds_server_name(str): CDS Server name used in connection string
+#     """
+#     credentials = _pydash_sql_credentials(secret_name)
+#     conn_string_dap = (
+#         "Driver={/usr/lib/libmsodbcsql-18.so};"
+#         f"Server={cds_server_name};"
+#         "TrustServerCertificate=yes;"
+#         "Database=Dashboards;"
+#     )
+#     return (
+#         f"{conn_string_dap}UID={credentials['username']};PWD={credentials['password']};"
+#     )
 
-def _pydash_sql_credentials(secret_name: str):
-    """
-    Logging into CDS from Pydash requires user name and password.
-    This method will return a dictionary containing the keys "username" and "password".
-    Raises `botocore.exceptions.ClientError` if no credentials could be obtained
-    Inputs:
-        secret_name(str): AWS Secrets Manager, secret name containing CDS credentials.
-    Returns:
-        dict:   a dictionary containing the keys "username" and "password"
-    """
-    region_name = "eu-west-1"
-    # Create a Secrets Manager client
-    session = boto3.session.Session()
-    client = session.client(service_name="secretsmanager", region_name=region_name)
-    # https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html#SecretsManager.Client.get_secret_value
 
-    get_secret_value_response = client.get_secret_value(SecretId=secret_name)
+# def _pydash_sql_credentials(secret_name: str):
+#     """
+#     Logging into CDS from Pydash requires user name and password.
+#     This method will return a dictionary containing the keys "username" and "password".
+#     Raises `botocore.exceptions.ClientError` if no credentials could be obtained
+#     Inputs:
+#         secret_name(str): AWS Secrets Manager, secret name containing CDS credentials.
+#     Returns:
+#         dict:   a dictionary containing the keys "username" and "password"
+#     """
+#     region_name = "eu-west-1"
+#     # Create a Secrets Manager client
+#     session = boto3.session.Session()
+#     client = session.client(service_name="secretsmanager", region_name=region_name)
+#     # https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager
+# .html#SecretsManager.Client.get_secret_value
 
-    secret = get_secret_value_response["SecretString"]
+#     get_secret_value_response = client.get_secret_value(SecretId=secret_name)
 
-    credentials = json.loads(secret)
-    return credentials
+#     secret = get_secret_value_response["SecretString"]
+
+#     credentials = json.loads(secret)
+#     return credentials

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",
@@ -163,6 +248,11 @@ def get_todays_date_for_downloaded_csv() -> str:
     return str(datetime.today().strftime("%d/%m/%Y"))
 
 
+def convert_datetime_to_dd_mm_yyy_string(input_datetime: datetime):
+    """convert datetime to DD/MM/YYYY string"""
+    return str(input_datetime.strftime("%d/%m/%Y"))
+
+
 def date_string_is_full_month_and_full_year_format(date_string: str):
     """checks if a date string is in the format $B $Y"""
     try:
@@ -343,3 +433,31 @@ def convert_financial_quarter_to_financial_quarter_text(quarter: int):
         4: "Q4 (Jan-Mar)",
     }
     return quarter_map[quarter]
+
+
+def financial_year_january(date_str: str) -> str:
+    """
+    Given a date string, return the 1st of January (formatted as "YYYY-MM-DD")
+    for the financial year that the date falls into.
+
+    UK financial years run from April 1st to March 31st:
+    - If the date is between January 1st and March 31st (inclusive),
+      the financial year ends in that same year.
+    - Otherwise, the financial year ends in the following year.
+
+    Args:
+        date_str (str): Date string in the format "YYYY-MM-DD".
+
+    Returns:
+        str: A string in the format "YYYY-MM-DD" representing January 1st
+             of the relevant financial year.
+
+    Examples:
+        >>> financial_year_january("2024-02-15")
+        '2024-01-01'
+        >>> financial_year_january("2024-05-10")
+        '2025-01-01'
+    """
+    dt = datetime.strptime(date_str, "%Y-%m-%d").date()
+    year = dt.year if dt.month < 4 else dt.year + 1
+    return f"{year}-01-01"

gov_uk_dashboards/lib/download_functions/download_csv_with_headers.py

@@ -1,4 +1,5 @@
 """download_csv_with_headers"""
+
 import io
 import polars as pl
 from dash import dcc
@@ -8,108 +9,130 @@ from gov_uk_dashboards.lib.datetime_functions.datetime_functions import (
 
 
 def download_csv_with_headers(
-    list_of_df_title_subtitle_dicts: list[dict[str, str]],
+    list_of_df_title_subtitle_dicts: list[dict],
     name: str,
     sensitivity_label: str,
+    last_updated_date: str = None,
     additional_text: list[str] = None,
-):  # pylint: disable=too-many-locals
-    """Adds a header above multiple dataframes,
-    separates them with blank rows, and downloads as CSV.
-
-    Args:
-        list_of_df_title_subtitle_dicts (list[dict[]]): List of dictionaries containing keys: "df",
-        "title" and "subtitle"
-        name (str): Filename for CSV.
-        sensitivity_label (str): Sensitivity label. Str or None.
-        additional_text (list[str]): Additional text to inlcude in headers after data downloaded.
-            Str or None.
+):
     """
-
+    Prepares and returns a CSV download with one or more DataFrames, each optionally preceded by
+    titles, subtitles, footnotes, and metadata headers (e.g. sensitivity label, download date).
+
+    Parameters:
+        list_of_df_title_subtitle_dicts (list[dict]):
+            A list of dictionaries, each containing a Polars DataFrame ('df'), a title,
+            and optionally a subtitle and footnote.
+        name (str):
+            The filename (without extension) for the downloaded CSV.
+        sensitivity_label (str):
+            A label (e.g. OFFICIAL-SENSITIVE) to prepend at the top of the file.
+        last_updated_date (str, optional):
+            A string to indicate when the data was last updated.
+        additional_text (list[str], optional):
+            Extra lines to include before the data sections (e.g. disclaimers).
+
+    Returns:
+        flask.Response: A CSV file response using Dash's `dcc.send_string`.
+    """
+    # pylint: disable=too-many-locals
     csv_buffer = io.StringIO()
+    max_columns = _get_number_of_max_columns_from_all_dfs(
+        list_of_df_title_subtitle_dicts
+    )
+    # Get first df and first col to use to add header data
+    first_df = list_of_df_title_subtitle_dicts[0]["df"]
+    first_col = first_df.columns[0]
 
-    column_list = list(list_of_df_title_subtitle_dicts[0]["df"].columns)
-    column_dict = {column_name: column_name for column_name in column_list}
-    blank_dict = {
-        f"{i}": None
-        for i in range(
-            _get_number_of_max_columns_from_all_dfs(list_of_df_title_subtitle_dicts)
-            - len(column_list)
-        )
-    }  # range is missing columns in first df compared to max columns across all dfs
-
-    subtitle = list_of_df_title_subtitle_dicts[0]["subtitle"]
-    footnote = list_of_df_title_subtitle_dicts[0].get("footnote")
-    header_data = [
-        {column_list[0]: "Date downloaded: " + get_todays_date_for_downloaded_csv()},
-        *(
-            [{column_list[0]: text} for text in additional_text]
-            + [{column_list[0]: None}]
-            if additional_text is not None
-            else []
-        ),
-        {column_list[0]: list_of_df_title_subtitle_dicts[0]["title"]},
-        *(
-            [{column_list[0]: subtitle}] if subtitle is not None else []
-        ),  # Uses unpacking (*) to add the subtitle row if subtitle is not None. If subtitle is
-        # None, it unpacks an empty list, effectively skipping the row.
-        {column_list[0]: None},  # Blank row
-        *([{column_list[0]: footnote}] if footnote is not None else []),
-        {**column_dict, **blank_dict},
-    ]
+    header_data = []
 
     if sensitivity_label:
-        header_data = [{column_list[0]: sensitivity_label}] + header_data
-
-    pl.DataFrame(header_data).write_csv(csv_buffer, include_header=False)
+        header_data.append({first_col: sensitivity_label})
+
+    header_data.extend(
+        [
+            {first_col: f"Date downloaded: {get_todays_date_for_downloaded_csv()}"},
+            *(
+                [{first_col: f"Last updated: {last_updated_date}"}]
+                if last_updated_date
+                else []
+            ),
+            {first_col: None},
+            *(
+                [{first_col: text} for text in additional_text] + [{first_col: None}]
+                if additional_text
+                else []
+            ),
+            {first_col: list_of_df_title_subtitle_dicts[0]["title"]},
+            *(
+                [{first_col: list_of_df_title_subtitle_dicts[0]["subtitle"]}]
+                if list_of_df_title_subtitle_dicts[0]["subtitle"]
+                else []
+            ),
+            {first_col: None},
+            *(
+                [{first_col: list_of_df_title_subtitle_dicts[0].get("footnote")}]
+                if list_of_df_title_subtitle_dicts[0].get("footnote")
+                else []
+            ),
+        ]
+    )
+    _write_padded_rows_to_buffer(header_data, max_columns, csv_buffer)
     for i, data in enumerate(list_of_df_title_subtitle_dicts):
-        df = data["df"]
-        title = data["title"]
-        subtitle = data["subtitle"]
-        footnote = data.get("footnote")
-        if i > 0 and title is not None:
-            column_dict = {column_name: column_name for column_name in list(df.columns)}
-            header_data = [
-                {column_list[0]: title},
-                *(
-                    [{column_list[0]: subtitle}] if subtitle is not None else []
-                ),  # Uses unpacking (*) to add the subtitle row if subtitle is not None. If
-                # subtitle is None, it unpacks an empty list, effectively skipping the row.
-                {column_list[0]: None},  # Blank row
-                *([{column_list[0]: footnote}] if footnote is not None else []),
+        df, title, subtitle, footnote = (
+            data["df"],
+            data["title"],
+            data["subtitle"],
+            data.get("footnote"),
+        )
+
+        if i > 0 and title:
+            meta_rows = [
+                {first_col: title},
+                *([{first_col: subtitle}] if subtitle else []),
+                {first_col: None},
+                *([{first_col: footnote}] if footnote else []),
             ]
-            pl.DataFrame(header_data).write_csv(csv_buffer, include_header=False)
-        df.write_csv(csv_buffer, include_header=i > 0)
+            _write_padded_rows_to_buffer(meta_rows, max_columns, csv_buffer)
+
+        # Pad DF if needed
+        if df.shape[1] < max_columns:
+            column_names = list(df.columns)
+            header_row = {col: col for col in column_names}
+            data_rows = df.to_dicts()
+            data_rows.insert(0, header_row)
+            padded_rows = [pad_row(row, max_columns) for row in data_rows]
+            output_df = pl.DataFrame(padded_rows)
+            output_df.columns = [str(i) for i in range(max_columns)]
+            output_df.write_csv(csv_buffer, include_header=False)
+        else:
+
+            df.write_csv(csv_buffer)
 
         if i < len(list_of_df_title_subtitle_dicts) - 1:
-            blank_row = pl.DataFrame({df.columns[0]: [None]})
+            blank_row = pl.DataFrame([pad_row({}, max_columns)])
             blank_row.write_csv(csv_buffer, include_header=False)
 
+    # Return CSV for download
     csv_buffer.seek(0)
-    csv_data = (
-        "\ufeff" + csv_buffer.getvalue()
-    )  # Adding \ufeff ensures the correct character encoding is detected for £
-
+    csv_data = "\ufeff" + csv_buffer.getvalue()
     return dcc.send_string(csv_data, f"{name}.csv")
 
 
-def _get_number_of_max_columns_from_all_dfs(list_of_df_title_subtitle_dicts):
-    max_columns = 0
-    index_of_max_cols = -1
-
-    for idx, dic in enumerate(list_of_df_title_subtitle_dicts):
-        # Get the DataFrame
-        df = dic["df"]
+def pad_row(row: dict, max_columns: int) -> dict:
+    """Pad a row with None values to match max column width."""
+    padded = list(row.values()) + [None] * (max_columns - len(row))
+    return {str(i): val for i, val in enumerate(padded)}
 
-        # Get the number of columns
-        num_columns = df.shape[1]
 
-        # Update if this DataFrame has more columns
-        if num_columns > max_columns:
-            max_columns = num_columns
-            index_of_max_cols = idx
+def _write_padded_rows_to_buffer(
+    rows: list[dict], max_columns: int, buffer: io.StringIO
+):
+    """Pad and write a list of rows to the CSV buffer."""
+    padded_rows = [pad_row(row, max_columns) for row in rows]
+    pl.DataFrame(padded_rows).write_csv(buffer, include_header=False)
 
-    max_columns = len(
-        list(list_of_df_title_subtitle_dicts[index_of_max_cols]["df"].columns)
-    )
 
-    return max_columns
+def _get_number_of_max_columns_from_all_dfs(list_of_dicts: list[dict]) -> int:
+    """Get max column count across all DataFrames in list."""
+    return max(len(data["df"].columns) for data in list_of_dicts)

gov_uk_dashboards/lib/http_headers.py

@@ -1,6 +1,5 @@
 """http_headers"""
 
-
 import os
 import dash
 
@@ -12,7 +11,16 @@ def setup_application_http_response_headers(dash_app: dash.Dash):
     @server.after_request
     def add_headers(response):
         content_security_policy = (
-            "default-src 'self' 'unsafe-eval' 'unsafe-inline' data:"
+            "default-src 'self' 'unsafe-eval' 'unsafe-inline' data:; "
+            "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://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://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; "
         )
         frame_ancestors = os.environ.get("ALLOWED_FRAME_ANCESTORS")
         if frame_ancestors:

gov_uk_dashboards/lib/logging.py

@@ -1,4 +1,5 @@
 """Module for logging configuration"""
+
 import os
 
 import logging

gov_uk_dashboards/lib/testing_functions/barchart_data_test_assertions.py

@@ -0,0 +1,48 @@
+"""test_barchart_data"""
+
+import polars as pl
+from gov_uk_dashboards.components.plotly.stacked_barchart import StackedBarChart
+
+
+def validate_barchart_instance(barchart_instance: StackedBarChart, **context):
+    """
+    Helper function to validate a barchart_instance dataframe.
+
+    Args:
+        barchart_instance: The barchart object with dataframe and metadata
+        **context: Arbitrary key-value pairs (e.g., la="LA1", expenditure_area="Health").
+            These will be included in the assertion message if provided.
+    """
+    barchart_df = barchart_instance.df
+    trace_name_list = barchart_instance.trace_name_list
+    trace_name_column = barchart_instance.trace_name_column
+    x_axis_column = barchart_instance.x_axis_column
+    unique_x_axis_values = set(barchart_df[x_axis_column].unique())
+    context_str = ", ".join(f"{k}={v}" for k, v in context.items())
+
+    for trace_name in trace_name_list:
+        if not trace_name_column:
+            df = barchart_df
+        else:
+            trace_values = barchart_df[trace_name_column].unique().to_list()
+            if trace_name not in trace_values:
+                raise AssertionError(
+                    f"Trace '{trace_name}' expected in column '{trace_name_column}' "
+                    f"but not found for {context_str}"
+                )
+            df = barchart_df.filter(pl.col(trace_name_column) == trace_name)
+
+        # Check trace has at least one row
+        assert df.height > 0, f"Trace '{trace_name}' has no data for {context_str}"
+
+        # Check trace has all required x-axis values
+        x_values_for_trace = set(df[x_axis_column].unique())
+        assert x_values_for_trace == unique_x_axis_values, (
+            f"{unique_x_axis_values - x_values_for_trace} missing for trace '{trace_name}' for "
+            f"{context_str}"
+        )
+
+        # Check x-axis uniqueness
+        assert (
+            df[x_axis_column].is_unique().to_numpy()[0]
+        ), f"x_axis-column: {x_axis_column} contains duplicate values. For {context_str}"