data-designer 0.1.0__py3-none-any.whl

data_designer/cli/utils.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+def validate_url(url: str) -> bool:
+    """Validate that a string is a valid URL.
+
+    Args:
+        url: URL string to validate
+
+    Returns:
+        True if valid URL, False otherwise
+    """
+    if not url:
+        return False
+
+    # Basic validation - must start with http:// or https://
+    if not url.startswith(("http://", "https://")):
+        return False
+
+    # Must have at least a domain after the protocol
+    parts = url.split("://", 1)
+    if len(parts) != 2 or not parts[1]:
+        return False
+
+    return True
+
+
+def validate_numeric_range(value: str, min_value: float, max_value: float) -> tuple[bool, float | None]:
+    """Validate that a string is a valid number within a range.
+
+    Args:
+        value: String to validate and convert
+        min_value: Minimum allowed value (inclusive)
+        max_value: Maximum allowed value (inclusive)
+
+    Returns:
+        Tuple of (is_valid, parsed_value)
+        If invalid, parsed_value is None
+    """
+    try:
+        num = float(value)
+        if min_value <= num <= max_value:
+            return True, num
+        return False, None
+    except ValueError:
+        return False, None

data_designer/config/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0

data_designer/config/analysis/column_profilers.py

@@ -0,0 +1,89 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC
+from enum import Enum
+from typing import Optional, Union
+
+from pydantic import BaseModel, Field
+from rich.panel import Panel
+from rich.table import Column, Table
+from typing_extensions import TypeAlias
+
+from ..base import ConfigBase
+from ..utils.visualization import ColorPalette
+from .column_statistics import (
+    CategoricalDistribution,
+    CategoricalHistogramData,
+    ColumnDistributionType,
+    MissingValue,
+    NumericalDistribution,
+)
+from .utils.reporting import TITLE_STYLE, create_judge_score_summary_table
+
+
+class ColumnProfilerType(str, Enum):
+    JUDGE_SCORE = "judge-score"
+
+
+class ColumnProfilerResults(BaseModel, ABC):
+    def create_report_section(self) -> Panel:
+        return Panel(
+            f"Report section generation not implemented for '{self.__class__.__name__}'.",
+            title="Not Implemented",
+            border_style=f"bold {ColorPalette.YELLOW.value}",
+            padding=(1, 2),
+        )
+
+
+class JudgeScoreProfilerConfig(ConfigBase):
+    model_alias: str
+    summary_score_sample_size: Optional[int] = Field(default=20, ge=1)
+
+
+class JudgeScoreSample(BaseModel):
+    score: Union[int, str]
+    reasoning: str
+
+
+class JudgeScoreDistributions(BaseModel):
+    scores: dict[str, list[Union[int, str]]]
+    reasoning: dict[str, list[str]]
+    distribution_types: dict[str, ColumnDistributionType]
+    distributions: dict[str, Union[CategoricalDistribution, NumericalDistribution, MissingValue]]
+    histograms: dict[str, Union[CategoricalHistogramData, MissingValue]]
+
+
+class JudgeScoreSummary(BaseModel):
+    score_name: str
+    summary: str
+    score_samples: list[JudgeScoreSample]
+
+
+class JudgeScoreProfilerResults(ColumnProfilerResults):
+    column_name: str
+    summaries: dict[str, JudgeScoreSummary]
+    score_distributions: Union[JudgeScoreDistributions, MissingValue]
+
+    def create_report_section(self) -> Panel:
+        layout = Table.grid(Column(), expand=True, padding=(2, 0))
+
+        for score_name in self.summaries.keys():
+            layout.add_row(
+                create_judge_score_summary_table(
+                    score_name=score_name,
+                    histogram=self.score_distributions.histograms[score_name],
+                    summary=self.summaries[score_name].summary,
+                )
+            )
+
+        return Panel(
+            layout,
+            title=f"[{TITLE_STYLE}]LLM-as-a-Judge Score Profile: '{self.column_name}'[/{TITLE_STYLE}]",
+            padding=(1, 2),
+        )
+
+
+ColumnProfilerConfigT: TypeAlias = JudgeScoreProfilerConfig
+
+ColumnProfilerResultsT: TypeAlias = JudgeScoreProfilerResults

data_designer/config/analysis/column_statistics.py

@@ -0,0 +1,274 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, Literal, Optional, Union
+
+from pandas import Series
+from pydantic import BaseModel, ConfigDict, create_model, field_validator, model_validator
+from typing_extensions import Self, TypeAlias
+
+from ...plugin_manager import PluginManager
+from ..column_types import DataDesignerColumnType
+from ..sampler_params import SamplerType
+from ..utils.constants import EPSILON
+from ..utils.numerical_helpers import is_float, is_int, prepare_number_for_reporting
+
+
+class MissingValue(str, Enum):
+    CALCULATION_FAILED = "--"
+    OUTPUT_FORMAT_ERROR = "output_format_error"
+
+
+class ColumnDistributionType(str, Enum):
+    CATEGORICAL = "categorical"
+    NUMERICAL = "numerical"
+    TEXT = "text"
+    OTHER = "other"
+    UNKNOWN = "unknown"
+
+
+class BaseColumnStatistics(BaseModel, ABC):
+    model_config = ConfigDict(use_enum_values=True)
+
+    @abstractmethod
+    def create_report_row_data(self) -> dict[str, str]: ...
+
+
+class GeneralColumnStatistics(BaseColumnStatistics):
+    column_name: str
+    num_records: Union[int, MissingValue]
+    num_null: Union[int, MissingValue]
+    num_unique: Union[int, MissingValue]
+    pyarrow_dtype: str
+    simple_dtype: str
+    column_type: Literal["general"] = "general"
+
+    @field_validator("num_null", "num_unique", "num_records", mode="before")
+    def general_statistics_ensure_python_integers(cls, v: Union[int, MissingValue]) -> Union[int, MissingValue]:
+        return v if isinstance(v, MissingValue) else prepare_number_for_reporting(v, int)
+
+    @property
+    def percent_null(self) -> Union[float, MissingValue]:
+        return (
+            self.num_null
+            if self._is_missing_value(self.num_null)
+            else prepare_number_for_reporting(100 * self.num_null / (self.num_records + EPSILON), float)
+        )
+
+    @property
+    def percent_unique(self) -> Union[float, MissingValue]:
+        return (
+            self.num_unique
+            if self._is_missing_value(self.num_unique)
+            else prepare_number_for_reporting(100 * self.num_unique / (self.num_records + EPSILON), float)
+        )
+
+    @property
+    def _general_display_row(self) -> dict[str, str]:
+        pct_unique_str = f" ({self.percent_unique:.1f}%)" if not self._is_missing_value(self.percent_unique) else ""
+        return {
+            "column name": self.column_name,
+            "data type": self.simple_dtype,
+            "number unique values": f"{self.num_unique}{pct_unique_str}",
+        }
+
+    def create_report_row_data(self) -> dict[str, str]:
+        return self._general_display_row
+
+    def _is_missing_value(self, v: Union[float, int, MissingValue]) -> bool:
+        return v in set(MissingValue)
+
+
+class LLMTextColumnStatistics(GeneralColumnStatistics):
+    completion_tokens_mean: Union[float, MissingValue]
+    completion_tokens_median: Union[float, MissingValue]
+    completion_tokens_stddev: Union[float, MissingValue]
+    prompt_tokens_mean: Union[float, MissingValue]
+    prompt_tokens_median: Union[float, MissingValue]
+    prompt_tokens_stddev: Union[float, MissingValue]
+    column_type: Literal[DataDesignerColumnType.LLM_TEXT.value] = DataDesignerColumnType.LLM_TEXT.value
+
+    @field_validator(
+        "completion_tokens_mean",
+        "completion_tokens_median",
+        "completion_tokens_stddev",
+        "prompt_tokens_mean",
+        "prompt_tokens_median",
+        "prompt_tokens_stddev",
+        mode="before",
+    )
+    def llm_column_ensure_python_floats(cls, v: Union[float, int, MissingValue]) -> Union[float, int, MissingValue]:
+        return v if isinstance(v, MissingValue) else prepare_number_for_reporting(v, float)
+
+    def create_report_row_data(self) -> dict[str, Any]:
+        prompt_tokens_str = (
+            f"{self.prompt_tokens_median:.1f} +/- {self.prompt_tokens_stddev:.1f}"
+            if not self._is_missing_value(self.prompt_tokens_median)
+            else "--"
+        )
+        completion_tokens_str = (
+            f"{self.completion_tokens_median:.1f} +/- {self.completion_tokens_stddev:.1f}"
+            if not self._is_missing_value(self.completion_tokens_median)
+            else "--"
+        )
+        return {
+            **self._general_display_row,
+            "prompt tokens\nper record": prompt_tokens_str,
+            "completion tokens\nper record": completion_tokens_str,
+        }
+
+
+class LLMCodeColumnStatistics(LLMTextColumnStatistics):
+    column_type: Literal[DataDesignerColumnType.LLM_CODE.value] = DataDesignerColumnType.LLM_CODE.value
+
+
+class LLMStructuredColumnStatistics(LLMTextColumnStatistics):
+    column_type: Literal[DataDesignerColumnType.LLM_STRUCTURED.value] = DataDesignerColumnType.LLM_STRUCTURED.value
+
+
+class LLMJudgedColumnStatistics(LLMTextColumnStatistics):
+    column_type: Literal[DataDesignerColumnType.LLM_JUDGE.value] = DataDesignerColumnType.LLM_JUDGE.value
+
+
+class SamplerColumnStatistics(GeneralColumnStatistics):
+    sampler_type: SamplerType
+    distribution_type: ColumnDistributionType
+    distribution: Optional[Union[CategoricalDistribution, NumericalDistribution, MissingValue]]
+    column_type: Literal[DataDesignerColumnType.SAMPLER.value] = DataDesignerColumnType.SAMPLER.value
+
+    def create_report_row_data(self) -> dict[str, str]:
+        return {
+            **self._general_display_row,
+            "sampler type": self.sampler_type,
+        }
+
+
+class SeedDatasetColumnStatistics(GeneralColumnStatistics):
+    column_type: Literal[DataDesignerColumnType.SEED_DATASET.value] = DataDesignerColumnType.SEED_DATASET.value
+
+
+class ExpressionColumnStatistics(GeneralColumnStatistics):
+    column_type: Literal[DataDesignerColumnType.EXPRESSION.value] = DataDesignerColumnType.EXPRESSION.value
+
+
+class ValidationColumnStatistics(GeneralColumnStatistics):
+    num_valid_records: Union[int, MissingValue]
+    column_type: Literal[DataDesignerColumnType.VALIDATION.value] = DataDesignerColumnType.VALIDATION.value
+
+    @field_validator("num_valid_records", mode="before")
+    def code_validation_column_ensure_python_integers(cls, v: Union[int, MissingValue]) -> Union[int, MissingValue]:
+        return v if isinstance(v, MissingValue) else prepare_number_for_reporting(v, int)
+
+    @property
+    def percent_valid(self) -> Union[float, MissingValue]:
+        return (
+            self.num_valid_records
+            if self._is_missing_value(self.num_valid_records)
+            else prepare_number_for_reporting(100 * self.num_valid_records / (self.num_records + EPSILON), float)
+        )
+
+    def create_report_row_data(self) -> dict[str, str]:
+        percent_valid_str = f"{self.percent_valid:.1f}%" if not self._is_missing_value(self.percent_valid) else "--"
+        return {**self._general_display_row, "percent valid": percent_valid_str}
+
+
+class CategoricalHistogramData(BaseModel):
+    categories: list[Union[float, int, str]]
+    counts: list[int]
+
+    @model_validator(mode="after")
+    def ensure_python_types(self) -> Self:
+        """Ensure numerical values are Python objects rather than Numpy types."""
+        self.categories = [(float(x) if is_float(x) else (int(x) if is_int(x) else str(x))) for x in self.categories]
+        self.counts = [int(i) for i in self.counts]
+        return self
+
+    @classmethod
+    def from_series(cls, series: Series) -> Self:
+        counts = series.value_counts()
+        return cls(categories=counts.index.tolist(), counts=counts.tolist())
+
+
+class CategoricalDistribution(BaseModel):
+    most_common_value: Union[str, int]
+    least_common_value: Union[str, int]
+    histogram: CategoricalHistogramData
+
+    @field_validator("most_common_value", "least_common_value", mode="before")
+    def ensure_python_types(cls, v: Union[str, int]) -> Union[str, int]:
+        return str(v) if not is_int(v) else prepare_number_for_reporting(v, int)
+
+    @classmethod
+    def from_series(cls, series: Series) -> Self:
+        counts = series.value_counts()
+        return cls(
+            most_common_value=counts.index[0],
+            least_common_value=counts.index[-1],
+            histogram=CategoricalHistogramData.from_series(series),
+        )
+
+
+class NumericalDistribution(BaseModel):
+    min: Union[float, int]
+    max: Union[float, int]
+    mean: float
+    stddev: float
+    median: float
+
+    @field_validator("min", "max", "mean", "stddev", "median", mode="before")
+    def ensure_python_types(cls, v: Union[float, int]) -> Union[float, int]:
+        return prepare_number_for_reporting(v, int if is_int(v) else float)
+
+    @classmethod
+    def from_series(cls, series: Series) -> Self:
+        return cls(
+            min=series.min(skipna=True),
+            max=series.max(skipna=True),
+            mean=series.mean(skipna=True),
+            stddev=series.std(skipna=True),
+            median=series.median(skipna=True),
+        )
+
+
+ColumnStatisticsT: TypeAlias = Union[
+    GeneralColumnStatistics,
+    LLMTextColumnStatistics,
+    LLMCodeColumnStatistics,
+    LLMStructuredColumnStatistics,
+    LLMJudgedColumnStatistics,
+    SamplerColumnStatistics,
+    SeedDatasetColumnStatistics,
+    ValidationColumnStatistics,
+    ExpressionColumnStatistics,
+]
+
+
+DEFAULT_COLUMN_STATISTICS_MAP = {
+    DataDesignerColumnType.EXPRESSION: ExpressionColumnStatistics,
+    DataDesignerColumnType.LLM_CODE: LLMCodeColumnStatistics,
+    DataDesignerColumnType.LLM_JUDGE: LLMJudgedColumnStatistics,
+    DataDesignerColumnType.LLM_STRUCTURED: LLMStructuredColumnStatistics,
+    DataDesignerColumnType.LLM_TEXT: LLMTextColumnStatistics,
+    DataDesignerColumnType.SAMPLER: SamplerColumnStatistics,
+    DataDesignerColumnType.SEED_DATASET: SeedDatasetColumnStatistics,
+    DataDesignerColumnType.VALIDATION: ValidationColumnStatistics,
+}
+
+for plugin in PluginManager().get_column_generator_plugins():
+    # Dynamically create a statistics class for this plugin using Pydantic's create_model
+    plugin_stats_cls_name = f"{plugin.config_type_as_class_name}ColumnStatistics"
+
+    # Create the class with proper Pydantic field
+    plugin_stats_cls = create_model(
+        plugin_stats_cls_name,
+        __base__=GeneralColumnStatistics,
+        column_type=(Literal[plugin.name], plugin.name),
+    )
+
+    # Add the plugin statistics class to the union
+    ColumnStatisticsT |= plugin_stats_cls
+    DEFAULT_COLUMN_STATISTICS_MAP[DataDesignerColumnType(plugin.name)] = plugin_stats_cls

data_designer/config/analysis/dataset_profiler.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import cached_property
+from pathlib import Path
+from typing import Annotated, Optional, Union
+
+from pydantic import BaseModel, Field, field_validator
+
+from ..column_types import DataDesignerColumnType, get_column_display_order
+from ..utils.constants import EPSILON
+from ..utils.numerical_helpers import prepare_number_for_reporting
+from .column_profilers import ColumnProfilerResultsT
+from .column_statistics import ColumnStatisticsT
+from .utils.reporting import ReportSection, generate_analysis_report
+
+
+class DatasetProfilerResults(BaseModel):
+    num_records: int
+    target_num_records: int
+    column_statistics: list[Annotated[ColumnStatisticsT, Field(discriminator="column_type")]] = Field(..., min_length=1)
+    side_effect_column_names: Optional[list[str]] = None
+    column_profiles: Optional[list[ColumnProfilerResultsT]] = None
+
+    @field_validator("num_records", "target_num_records", mode="before")
+    def ensure_python_integers(cls, v: int) -> int:
+        return prepare_number_for_reporting(v, int)
+
+    @property
+    def percent_complete(self) -> float:
+        return 100 * self.num_records / (self.target_num_records + EPSILON)
+
+    @cached_property
+    def column_types(self) -> list[str]:
+        display_order = get_column_display_order()
+        return sorted(
+            list(set([c.column_type for c in self.column_statistics])),
+            key=lambda x: display_order.index(x) if x in display_order else len(display_order),
+        )
+
+    def get_column_statistics_by_type(self, column_type: DataDesignerColumnType) -> list[ColumnStatisticsT]:
+        return [c for c in self.column_statistics if c.column_type == column_type]
+
+    def to_report(
+        self,
+        save_path: Optional[Union[str, Path]] = None,
+        include_sections: Optional[list[Union[ReportSection, DataDesignerColumnType]]] = None,
+    ) -> None:
+        """Generate and print an analysis report based on the dataset profiling results.
+
+        Args:
+            save_path: Optional path to save the report. If provided, the report will be saved
+                  as either HTML (.html) or SVG (.svg) format. If None, the report will
+                  only be displayed in the console.
+            include_sections: Optional list of sections to include in the report. Choices are
+                  any DataDesignerColumnType, "overview" (the dataset overview section),
+                  and "column_profilers" (all column profilers in one section). If None,
+                  all sections will be included.
+        """
+        generate_analysis_report(self, save_path, include_sections=include_sections)

data_designer/config/analysis/utils/errors.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from ...errors import DataDesignerError
+
+
+class AnalysisReportError(DataDesignerError):
+    """Base exception for analysis report errors."""

data_designer/config/analysis/utils/reporting.py

@@ -0,0 +1,188 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Union
+
+from rich.align import Align
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.table import Column, Table
+from rich.text import Text
+
+from ...analysis.column_statistics import CategoricalHistogramData
+from ...column_types import COLUMN_TYPE_EMOJI_MAP, DataDesignerColumnType, get_column_display_order
+from ...utils.visualization import (
+    ColorPalette,
+    convert_to_row_element,
+    create_rich_histogram_table,
+    pad_console_element,
+)
+from .errors import AnalysisReportError
+
+if TYPE_CHECKING:
+    from ...analysis.dataset_profiler import DatasetProfilerResults
+
+HEADER_STYLE = "dim"
+RULE_STYLE = f"bold {ColorPalette.NVIDIA_GREEN.value}"
+ACCENT_STYLE = f"bold {ColorPalette.BLUE.value}"
+TITLE_STYLE = f"bold {ColorPalette.NVIDIA_GREEN.value}"
+HIST_NAME_STYLE = f"bold {ColorPalette.BLUE.value}"
+HIST_VALUE_STYLE = f"dim {ColorPalette.BLUE.value}"
+
+
+class ReportSection(str, Enum):
+    OVERVIEW = "overview"
+    COLUMN_PROFILERS = "column_profilers"
+
+
+DEFAULT_INCLUDE_SECTIONS = [
+    ReportSection.OVERVIEW,
+    ReportSection.COLUMN_PROFILERS,
+] + get_column_display_order()
+
+
+def generate_analysis_report(
+    analysis: DatasetProfilerResults,
+    save_path: Optional[Union[str, Path]] = None,
+    include_sections: Optional[list[Union[ReportSection, DataDesignerColumnType]]] = None,
+) -> None:
+    """Generate an analysis report for dataset profiling results.
+
+    This function creates a rich-formatted report that displays dataset overview statistics
+    and detailed column statistics organized by column type. The report includes visual
+    elements like tables, rules, and panels to present the analysis results in an
+    easy-to-read format.
+
+    Args:
+        analysis: The DatasetProfilerResults object containing the analysis data to report on.
+        save_path: Optional path to save the report. If provided, the report will be saved
+                  as either HTML (.html) or SVG (.svg) format. If None, the report will
+                  only be displayed in the console.
+        include_sections: Optional list of sections to include in the report. Choices are
+                  any Data Designer column type, "overview" (the dataset overview section),
+                  and "column_profilers" (all column profilers in one section). If None,
+                  all sections will be included.
+
+    Raises:
+        AnalysisReportError: If save_path is provided but doesn't have a .html or .svg extension.
+    """
+    render_list = []
+    table_kws = dict(show_lines=True, expand=True, title_style=TITLE_STYLE)
+    include_sections = include_sections or DEFAULT_INCLUDE_SECTIONS
+
+    title = Rule(title="🎨 Data Designer Dataset Profile", style=RULE_STYLE, end="\n\n")
+
+    render_list.append(title)
+
+    if ReportSection.OVERVIEW in include_sections:
+        table = Table(title="Dataset Overview", **table_kws)
+        table.add_column("number of records", header_style=HEADER_STYLE)
+        table.add_column("number of columns", header_style=HEADER_STYLE)
+        table.add_column("percent complete records", header_style=HEADER_STYLE)
+
+        table.add_row(
+            f"{analysis.num_records:,}",
+            f"{len(analysis.column_statistics):,}",
+            f"{analysis.percent_complete:.1f}%",
+        )
+
+        render_list.append(pad_console_element(table, (1, 0, 1, 0)))
+
+    displayed_column_types = set()
+    for column_type in analysis.column_types:
+        if column_type not in include_sections:
+            continue
+
+        displayed_column_types.add(column_type)
+        column_label = column_type.replace("_", " ").title().replace("Llm", "LLM")
+        table = Table(
+            title=f"{COLUMN_TYPE_EMOJI_MAP[column_type]} {column_label} Columns",
+            **table_kws,
+        )
+
+        column_stats_list = analysis.get_column_statistics_by_type(column_type)
+        for col in list(column_stats_list[0].create_report_row_data()):
+            if col == "column name":
+                table.add_column(col, header_style=HEADER_STYLE)
+            else:
+                table.add_column(col, justify="right", header_style=HEADER_STYLE)
+
+        for stats in column_stats_list:
+            table.add_row(*[convert_to_row_element(elem) for elem in stats.create_report_row_data().values()])
+
+        render_list.append(pad_console_element(table, (1, 0, 1, 0)))
+
+    if ReportSection.COLUMN_PROFILERS in include_sections:
+        for profile in analysis.column_profiles or []:
+            render_list.append(pad_console_element(profile.create_report_section()))
+
+    if any("llm" in col_type for col_type in displayed_column_types):
+        footnotes_text = (
+            "1. All token statistics are based on a sample of max(1000, len(dataset)) records.\n"
+            "2. Tokens are calculated using tiktoken's cl100k_base tokenizer."
+        )
+
+        render_list.append(
+            pad_console_element(
+                Panel(
+                    Text.from_markup(footnotes_text.strip()),
+                    title="Table Notes",
+                    border_style="dim",
+                    padding=(1, 2),
+                )
+            )
+        )
+
+    render_list.append(Rule(style=RULE_STYLE))
+
+    console = Console(record=save_path is not None)
+    console.print(Group(*render_list), markup=False)
+
+    if save_path is not None:
+        save_path = str(save_path)
+        if save_path.endswith(".html"):
+            console.save_html(save_path)
+        elif save_path.endswith(".svg"):
+            console.save_svg(save_path, title="")
+        else:
+            raise AnalysisReportError(
+                f"🛑 The extension of the save path must be either .html or .svg. You provided {save_path}."
+            )
+
+
+def create_judge_score_summary_table(
+    score_name: str,
+    histogram: CategoricalHistogramData,
+    summary: str,
+    accent_style: str = ACCENT_STYLE,
+    summary_border_style: str = "dim",
+) -> Table:
+    layout = Table.grid(Column(), Column(), expand=True, padding=(0, 2))
+
+    histogram_table = create_rich_histogram_table(
+        {str(s): c for s, c in zip(histogram.categories, histogram.counts)},
+        ("score", "count"),
+        name_style=HIST_NAME_STYLE,
+        value_style=HIST_VALUE_STYLE,
+    )
+
+    summary_panel = Panel(
+        Text(summary, justify="left"),
+        title=(
+            f"Score Summary: [not {summary_border_style}][{accent_style}]"
+            f"{score_name.upper()}[/{accent_style}][/not {summary_border_style}]"
+        ),
+        border_style=summary_border_style,
+    )
+
+    layout.add_row(
+        Align(summary_panel, vertical="top"),
+        Align(histogram_table, vertical="top"),
+    )
+
+    return layout