Support multiple verbosity in dump comparator

python/sglang/srt/debug_utils/comparator/display.py

@@ -6,6 +6,7 @@
 from typing import TYPE_CHECKING, Any, Optional
 
 import polars as pl
+import rich.table
 
 if TYPE_CHECKING:
     from rich.table import Table
@@ -68,6 +69,19 @@ def _build_rich_table(df: pl.DataFrame, *, title: Optional[str] = None) -> "Tabl
     return table
 
 
+def _render_polars_as_rich_table(
+    df: pl.DataFrame, *, title: Optional[str] = None
+) -> "rich.table.Table":
+    from rich.table import Table
+
+    table = Table(title=title)
+    for col in df.columns:
+        table.add_column(col)
+    for row in df.iter_rows():
+        table.add_row(*[str(v) for v in row])
+    return table
+
+
 def _collect_rank_info(
     df: pl.DataFrame, dump_dir: Path
 ) -> Optional[list[dict[str, Any]]]:

python/sglang/srt/debug_utils/comparator/output_formatter.py

@@ -6,7 +6,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from rich.console import Group
 from rich.markup import escape
@@ -38,12 +38,16 @@
         _TableRecord,
     )
 
+Verbosity = Literal["minimal", "normal", "verbose"]
+
 
 # ── Record-level rendering (body + logs) ─────────────────────────────
 
 
-def _render_record_rich(record: _OutputRecord) -> RenderableType:
-    body: RenderableType = record._format_rich_body()
+def _render_record_rich(
+    record: _OutputRecord, *, verbosity: Verbosity = "normal"
+) -> RenderableType:
+    body: RenderableType = record._format_rich_body(verbosity=verbosity)
 
     log_lines: list[str] = _format_log_lines_rich(
         errors=record.errors, infos=record.infos
@@ -100,7 +104,9 @@ def _format_config_body(record: ConfigRecord) -> str:
     return f"Config: {record.config}"
 
 
-def _format_config_rich_body(record: ConfigRecord) -> RenderableType:
+def _format_config_rich_body(
+    record: ConfigRecord, verbosity: Verbosity = "normal"
+) -> RenderableType:
     lines: list[str] = [f"  [bold]{k}[/] : {v}" for k, v in record.config.items()]
     return Panel("\n".join(lines), title="Comparator Config", border_style="cyan")
 
@@ -112,7 +118,9 @@ def _format_skip_body(record: SkipComparisonRecord) -> str:
     return f"Skip: {record.name}{record._format_location_suffix()} ({record.reason})"
 
 
-def _format_skip_rich_body(record: SkipComparisonRecord) -> RenderableType:
+def _format_skip_rich_body(
+    record: SkipComparisonRecord, verbosity: Verbosity = "normal"
+) -> RenderableType:
     suffix: str = record._format_location_suffix()
     return (
         f"[dim]⊘ {escape(record.name)}{suffix} ── skipped ({escape(record.reason)})[/]"
@@ -132,7 +140,9 @@ def _format_table_body(record: _TableRecord) -> str:
     )
 
 
-def _format_table_rich_body(record: _TableRecord) -> RenderableType:
+def _format_table_rich_body(
+    record: _TableRecord, verbosity: Verbosity = "normal"
+) -> RenderableType:
     import polars as pl
 
     from sglang.srt.debug_utils.comparator.display import (
@@ -157,13 +167,15 @@ def _format_tensor_comparison_body(record: TensorComparisonRecord) -> str:
 
 
 def _format_tensor_comparison_rich_body(
-    record: TensorComparisonRecord,
+    record: TensorComparisonRecord, verbosity: Verbosity = "normal"
 ) -> RenderableType:
     from sglang.srt.debug_utils.comparator.tensor_comparator.formatter import (
         format_comparison_rich,
     )
 
-    return record._format_location_prefix_rich() + format_comparison_rich(record=record)
+    return record._format_location_prefix_rich() + format_comparison_rich(
+        record=record, verbosity=verbosity
+    )
 
 
 # ── NonTensorComparisonRecord ────────────────────────────────────────
@@ -181,7 +193,7 @@ def _format_non_tensor_body(record: NonTensorComparisonRecord) -> str:
 
 
 def _format_non_tensor_rich_body(
-    record: NonTensorComparisonRecord,
+    record: NonTensorComparisonRecord, verbosity: Verbosity = "normal"
 ) -> RenderableType:
     suffix: str = record._format_location_suffix()
     name: str = escape(record.name)
@@ -210,7 +222,9 @@ def _format_summary_body(record: SummaryRecord) -> str:
     )
 
 
-def _format_summary_rich_body(record: SummaryRecord) -> RenderableType:
+def _format_summary_rich_body(
+    record: SummaryRecord, verbosity: Verbosity = "normal"
+) -> RenderableType:
     text: str = (
         f"[bold green]{record.passed} passed[/] │ "
         f"[bold red]{record.failed} failed[/] │ "

python/sglang/srt/debug_utils/comparator/output_types.py

@@ -7,6 +7,26 @@
 from rich.console import RenderableType
 from rich.markup import escape
 
+from sglang.srt.debug_utils.comparator.output_formatter import (  # noqa: F401 — re-export
+    _format_aligner_plan as _format_aligner_plan,
+)
+from sglang.srt.debug_utils.comparator.output_formatter import (
+    _format_config_body,
+    _format_config_rich_body,
+    _format_log_body,
+    _format_non_tensor_body,
+    _format_non_tensor_rich_body,
+    _format_skip_body,
+    _format_skip_rich_body,
+    _format_summary_body,
+    _format_summary_rich_body,
+    _format_table_body,
+    _format_table_rich_body,
+    _format_tensor_comparison_body,
+    _format_tensor_comparison_rich_body,
+    _render_record_rich,
+    _render_record_text,
+)
 from sglang.srt.debug_utils.comparator.tensor_comparator.types import (
     DiffInfo,
     TensorComparisonInfo,
@@ -17,7 +37,6 @@
     from sglang.srt.debug_utils.comparator.aligner.entrypoint.traced_types import (
         TracedAlignerPlan,
     )
-    from sglang.srt.debug_utils.comparator.aligner.entrypoint.types import AlignerPlan
     from sglang.srt.debug_utils.comparator.report_sink import Verbosity
 
 
@@ -83,21 +102,13 @@ class _OutputRecord(_StrictBase):
     @abstractmethod
     def _format_body(self) -> str: ...
 
-    def _format_rich_body(self) -> RenderableType:
+    def _format_rich_body(self, verbosity: Verbosity = "normal") -> RenderableType:
         return self._format_body()
 
-    def to_rich(self) -> RenderableType:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _render_record_rich,
-        )
-
-        return _render_record_rich(self)
+    def to_rich(self, verbosity: Verbosity = "normal") -> RenderableType:
+        return _render_record_rich(self, verbosity=verbosity)
 
     def to_text(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _render_record_text,
-        )
-
         return _render_record_text(self)
 
 
@@ -124,46 +135,15 @@ def _format_location_suffix(self) -> str:
         return ""
 
 
-class RecordLocation(_StrictBase):
-    step: Optional[int] = None
-
-
-class _BaseComparisonRecord(_OutputRecord):
-    location: RecordLocation = Field(default_factory=RecordLocation)
-
-    def _format_location_prefix(self) -> str:
-        if self.location.step is not None:
-            return f"[step={self.location.step}] "
-        return ""
-
-    def _format_location_prefix_rich(self) -> str:
-        if self.location.step is not None:
-            return escape(f"[step={self.location.step}]") + " "
-        return ""
-
-    def _format_location_suffix(self) -> str:
-        if self.location.step is not None:
-            return f" (step={self.location.step})"
-        return ""
-
-
 class ConfigRecord(_OutputRecord):
     type: Literal["config"] = "config"
     config: dict[str, Any]
 
     def _format_body(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_config_body,
-        )
-
         return _format_config_body(self)
 
-    def _format_rich_body(self) -> RenderableType:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_config_rich_body,
-        )
-
-        return _format_config_rich_body(self)
+    def _format_rich_body(self, verbosity: Verbosity = "normal") -> RenderableType:
+        return _format_config_rich_body(self, verbosity=verbosity)
 
 
 class SkipComparisonRecord(_BaseComparisonRecord):
@@ -178,18 +158,10 @@ def category(self) -> str:
         return "skipped"
 
     def _format_body(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_skip_body,
-        )
-
         return _format_skip_body(self)
 
-    def _format_rich_body(self) -> RenderableType:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_skip_rich_body,
-        )
-
-        return _format_skip_rich_body(self)
+    def _format_rich_body(self, verbosity: Verbosity = "normal") -> RenderableType:
+        return _format_skip_rich_body(self, verbosity=verbosity)
 
 
 class _TableRecord(_OutputRecord):
@@ -200,9 +172,10 @@ class _TableRecord(_OutputRecord):
     def _table_title(self) -> str: ...
 
     def _format_body(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_table_body,
-        )
+        return _format_table_body(self)
+
+    def _format_rich_body(self, verbosity: Verbosity = "normal") -> RenderableType:
+        return _format_table_rich_body(self, verbosity=verbosity)
 
         return _format_table_body(self)
 
@@ -245,18 +218,10 @@ def category(self) -> str:
         return "passed" if self.diff is not None and self.diff.passed else "failed"
 
     def _format_body(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_tensor_comparison_body,
-        )
-
         return _format_tensor_comparison_body(self)
 
-    def _format_rich_body(self) -> RenderableType:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_tensor_comparison_rich_body,
-        )
-
-        return _format_tensor_comparison_rich_body(self)
+    def _format_rich_body(self, verbosity: Verbosity = "normal") -> RenderableType:
+        return _format_tensor_comparison_rich_body(self, verbosity=verbosity)
 
 
 class NonTensorComparisonRecord(_BaseComparisonRecord):
@@ -275,9 +240,10 @@ def category(self) -> str:
         return "passed" if self.values_equal else "failed"
 
     def _format_body(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_non_tensor_body,
-        )
+        return _format_non_tensor_body(self)
+
+    def _format_rich_body(self, verbosity: Verbosity = "normal") -> RenderableType:
+        return _format_non_tensor_rich_body(self, verbosity=verbosity)
 
         return _format_non_tensor_body(self)
 
@@ -306,40 +272,20 @@ def _validate_totals(self) -> "SummaryRecord":
         return self
 
     def _format_body(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_summary_body,
-        )
-
         return _format_summary_body(self)
 
-    def _format_rich_body(self) -> RenderableType:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_summary_rich_body,
-        )
-
-        return _format_summary_rich_body(self)
+    def _format_rich_body(self, verbosity: Verbosity = "normal") -> RenderableType:
+        return _format_summary_rich_body(self, verbosity=verbosity)
 
+        return _format_summary_body(self)
 
 class LogRecord(_OutputRecord):
     type: Literal["log"] = "log"
 
     def _format_body(self) -> str:
-        from sglang.srt.debug_utils.comparator.output_formatter import (
-            _format_log_body,
-        )
-
         return _format_log_body(self)
 
 
-# Re-export _format_aligner_plan for backward compatibility (used by tests)
-def _format_aligner_plan(traced_plan: TracedAlignerPlan) -> str:
-    from sglang.srt.debug_utils.comparator.output_formatter import (
-        _format_aligner_plan as _impl,
-    )
-
-    return _impl(traced_plan)
-
-
 AnyRecord = Annotated[
     Union[
         ConfigRecord,

python/sglang/srt/debug_utils/comparator/report_sink.py

@@ -80,7 +80,7 @@ def _print_to_stdout(self, record: _OutputRecord) -> None:
             print(record.model_dump_json())
         else:
             console: Console = self._get_console()
-            console.print(record.to_rich())
+            console.print(record.to_rich(verbosity=self._verbosity))
             console.print()  # blank line between records