UI adjustments

src/gcmd_classifier/ui/gradio_app.py

@@ -34,6 +34,46 @@ _DEMO_NO_TOPIC_RESPONSE = {
 ModelClientFactory = Callable[[ModelSettings], ModelClient]
 ClassifyFunction = Callable[..., ArticleResult]
 
+CLASSIFICATION_TABLE_COLUMNS = [
+    "GCMD Keyword Path",
+    "Evidence",
+    "Support",
+    "Review Required",
+]
+
+_GRADIO_CSS = """
+.input-panel textarea,
+.input-panel input {
+  font-size: 0.95rem;
+}
+.summary-panel {
+  border: 1px solid var(--border-color-primary);
+  border-radius: 8px;
+  padding: 0.75rem 1rem;
+}
+.results-table {
+  width: 100%;
+  overflow-x: auto;
+}
+.results-table table {
+  min-width: 1100px;
+}
+.results-table th,
+.results-table td {
+  vertical-align: top;
+}
+.results-table td:nth-child(1),
+.results-table td:nth-child(2) {
+  min-width: 420px;
+  white-space: normal;
+}
+.results-table td:nth-child(3),
+.results-table td:nth-child(4) {
+  min-width: 140px;
+  white-space: nowrap;
+}
+"""
+
 
 def create_demo(
     *,
@@ -45,6 +85,7 @@ def create_demo(
     """Construct the Gradio demo without moving classification logic into the UI."""
     gr = _import_gradio()
     active_settings = settings or ModelSettings.from_environment()
+    mode_label = "fake/demo" if active_settings.provider == "fake" else active_settings.provider
 
     def submit(title: str, abstract: str, doi: str | None, year: int | float | None):
         return run_demo_classification(
@@ -58,26 +99,53 @@ def create_demo(
             classify_func=classify_func,
         )
 
-    return gr.Interface(
-        fn=submit,
-        inputs=[
-            gr.Textbox(label="Title", lines=1, placeholder="Enter article title"),
-            gr.Textbox(label="Abstract", lines=8, placeholder="Paste article abstract"),
-            gr.Textbox(label="DOI (optional)", lines=1, placeholder="10.xxxx/example"),
-            gr.Number(label="Year (optional)", precision=0, value=None),
-        ],
-        outputs=[
-            gr.Markdown(label="Classification Summary"),
-            gr.JSON(label="Detailed ArticleResult JSON"),
-            gr.JSON(label="Warnings and Errors"),
-        ],
+    with gr.Blocks(
         title="GCMD Science Keyword Classifier MVP",
-        description=(
+        css=_GRADIO_CSS,
+    ) as demo:
+        gr.Markdown(
+            "# GCMD Science Keyword Classifier MVP\n"
             "Lightweight demonstration UI. Classification is performed by the tested "
-            "pipeline service; the UI only collects input and displays structured output."
-        ),
-        allow_flagging="never",
-    )
+            "pipeline service; the UI only collects input and displays structured output.\n\n"
+            f"**Mode:** `{mode_label}`  **Model:** `{active_settings.model_name}`"
+        )
+        with gr.Group(elem_classes=["input-panel"]):
+            title_input = gr.Textbox(label="Title", lines=2, placeholder="Enter article title")
+            abstract_input = gr.Textbox(
+                label="Abstract",
+                lines=8,
+                placeholder="Paste article abstract",
+            )
+            with gr.Row():
+                doi_input = gr.Textbox(
+                    label="DOI (optional)",
+                    lines=1,
+                    placeholder="10.xxxx/example",
+                )
+                year_input = gr.Number(label="Year (optional)", precision=0, value=None)
+            submit_button = gr.Button("Classify", variant="primary")
+
+        gr.Markdown("## Result Summary")
+        summary_output = gr.Markdown(elem_classes=["summary-panel"])
+        gr.Markdown("## Classification Results")
+        table_output = gr.Dataframe(
+            headers=CLASSIFICATION_TABLE_COLUMNS,
+            datatype=["str"] * len(CLASSIFICATION_TABLE_COLUMNS),
+            interactive=False,
+            wrap=False,
+            label="Accepted Classifications",
+            elem_classes=["results-table"],
+        )
+        with gr.Row():
+            json_output = gr.JSON(label="Detailed ArticleResult JSON")
+            diagnostics_output = gr.JSON(label="Warnings and Errors")
+
+        submit_button.click(
+            fn=submit,
+            inputs=[title_input, abstract_input, doi_input, year_input],
+            outputs=[summary_output, table_output, json_output, diagnostics_output],
+        )
+    return demo
 
 
 def run_demo_classification(
@@ -90,7 +158,7 @@ def run_demo_classification(
     settings: ModelSettings | None = None,
     model_client_factory: ModelClientFactory | None = None,
     classify_func: ClassifyFunction | None = None,
-) -> tuple[str, dict[str, Any], dict[str, Any]]:
+) -> tuple[str, list[list[object]], dict[str, Any], dict[str, Any]]:
     """Run one UI classification request and return display-ready values."""
     active_settings = settings or ModelSettings.from_environment()
     warnings: list[OutputWarning] = []
@@ -118,7 +186,8 @@ def run_demo_classification(
         if warnings:
             result = result.model_copy(update={"warnings": (*warnings, *result.warnings)})
         return (
-            format_classification_summary(result),
+            format_compact_summary(result),
+            classification_table_rows(result),
             result.model_dump(mode="json"),
             diagnostics_payload(result),
         )
@@ -126,6 +195,7 @@ def run_demo_classification(
         error = OutputError(code=exc.__class__.__name__, message=str(exc), stage="ui")
         return (
             f"**Processing failed**\n\n{_md(error.message)}",
+            [],
             {"error": error.model_dump(mode="json")},
             {
                 "warnings": [warning.model_dump(mode="json") for warning in warnings],
@@ -134,6 +204,43 @@ def run_demo_classification(
         )
 
 
+def format_compact_summary(result: ArticleResult) -> str:
+    """Format compact run metadata above the full-width classification table."""
+    metadata = result.processing_metadata
+    outcome = None if result.classification_outcome is None else result.classification_outcome.value
+    review_count = sum(record.review_required for record in result.classifications)
+    lines = [
+        f"**processing_status:** `{result.processing_status.value}`",
+        f"**classification_outcome:** `{outcome}`",
+        f"**model_provider:** `{metadata.model_provider or ''}`",
+        f"**model_name:** `{metadata.model_name or ''}`",
+        f"**classifications:** `{len(result.classifications)}`",
+        f"**requiring_review:** `{review_count}`",
+    ]
+    if result.classification_outcome is ArticleClassificationOutcome.NOT_CLASSIFIED:
+        lines.append(f"**no_classification_reason:** {_md(result.no_classification_reason or '')}")
+    if result.errors:
+        lines.append(f"**errors:** `{len(result.errors)}`")
+    if result.warnings:
+        lines.append(f"**warnings:** `{len(result.warnings)}`")
+    return "  \n".join(lines)
+
+
+def classification_table_rows(result: ArticleResult) -> list[list[object]]:
+    """Return full-width table rows for accepted classifications."""
+    return [classification_table_row(record) for record in result.classifications]
+
+
+def classification_table_row(record: ClassificationRecord) -> list[object]:
+    """Return one display row for the Gradio results Dataframe."""
+    return [
+        record.canonical_path,
+        record.classifier_evidence or "",
+        "" if record.support_type is None else record.support_type.value,
+        record.review_required,
+    ]
+
+
 def format_classification_summary(result: ArticleResult) -> str:
     """Format the important ArticleResult fields for the demo summary panel."""
     outcome = None if result.classification_outcome is None else result.classification_outcome.value

tests/test_ui.py

@@ -28,29 +28,47 @@ PROTOTYPE_PATH = Path("prototype/app_hf_poc.py")
 
 
 class FakeComponent:
-    def __init__(self, **kwargs: Any) -> None:
+    instances: list[FakeComponent] = []
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.args = args
         self.kwargs = kwargs
+        self.click_kwargs: dict[str, Any] | None = None
+        type(self).instances.append(self)
 
+    def click(self, **kwargs: Any) -> None:
+        self.click_kwargs = kwargs
 
-class FakeInterface:
-    launched = 0
 
+class FakeLayout:
     def __init__(self, **kwargs: Any) -> None:
         self.kwargs = kwargs
-        self.fn = kwargs["fn"]
-        self.inputs = kwargs["inputs"]
-        self.outputs = kwargs["outputs"]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, traceback) -> None:
+        return None
+
+
+class FakeBlocks(FakeLayout):
+    launched = 0
 
     def launch(self) -> None:
         type(self).launched += 1
 
 
 def _fake_gradio_module() -> SimpleNamespace:
+    FakeComponent.instances = []
     return SimpleNamespace(
-        Interface=FakeInterface,
+        Blocks=FakeBlocks,
+        Group=FakeLayout,
+        Row=FakeLayout,
         Textbox=FakeComponent,
         Number=FakeComponent,
         Markdown=FakeComponent,
+        Dataframe=FakeComponent,
+        Button=FakeComponent,
         JSON=FakeComponent,
     )
 
@@ -123,9 +141,15 @@ def test_create_demo_constructs_gradio_interface(monkeypatch) -> None:
 
     demo = gradio_app.create_demo(vocabulary=load_vocabulary(FIXTURE_PATH))
 
-    assert isinstance(demo, FakeInterface)
-    assert len(demo.inputs) == 4
-    assert len(demo.outputs) == 3
+    assert isinstance(demo, FakeBlocks)
+    assert "results-table" in gradio_app._GRADIO_CSS
+    dataframes = [
+        component
+        for component in FakeComponent.instances
+        if component.kwargs.get("headers") == gradio_app.CLASSIFICATION_TABLE_COLUMNS
+    ]
+    assert dataframes
+    assert dataframes[0].kwargs["wrap"] is False
 
 
 def test_ui_module_does_not_classify_or_call_model_at_import_time(monkeypatch) -> None:
@@ -142,14 +166,14 @@ def test_ui_module_does_not_classify_or_call_model_at_import_time(monkeypatch) -
 
 
 def test_root_app_imports_without_launching_server(monkeypatch) -> None:
-    FakeInterface.launched = 0
+    FakeBlocks.launched = 0
     monkeypatch.setitem(sys.modules, "gradio", _fake_gradio_module())
     sys.modules.pop("app", None)
 
     module = importlib.import_module("app")
 
-    assert isinstance(module.demo, FakeInterface)
-    assert FakeInterface.launched == 0
+    assert isinstance(module.demo, FakeBlocks)
+    assert FakeBlocks.launched == 0
 
 
 def test_root_app_is_thin_launcher_without_classification_logic() -> None:
@@ -171,7 +195,7 @@ def test_ui_calls_pipeline_service(monkeypatch) -> None:
 
     monkeypatch.setattr(gradio_app.pipeline_service, "classify_article", fake_classify)
 
-    summary, payload, diagnostics = gradio_app.run_demo_classification(
+    summary, table, payload, diagnostics = gradio_app.run_demo_classification(
         Title="A title",
         Abstract="",
         DOI="10.example/ui",
@@ -182,6 +206,7 @@ def test_ui_calls_pipeline_service(monkeypatch) -> None:
 
     assert calls["count"] == 1
     assert "not_classified" in summary
+    assert table == []
     assert payload["DOI"] == "10.example/ui"
     assert diagnostics["errors"] == []
 
@@ -204,6 +229,52 @@ def test_classified_result_includes_uuid_and_canonical_path() -> None:
     assert "The article discusses atmospheric carbon dioxide." in summary
 
 
+def test_compact_summary_includes_status_model_and_review_counts() -> None:
+    article = ArticleRecord(DOI="10.example/summary", Title="Summary", Year=2025, Abstract="Text.")
+    result = _classified_result(article).model_copy(
+        update={
+            "processing_metadata": ProcessingMetadata(
+                model_provider="fake",
+                model_name="fake-model",
+            ),
+            "classifications": (
+                _classification_record().model_copy(update={"review_required": True}),
+            ),
+        }
+    )
+
+    summary = gradio_app.format_compact_summary(result)
+
+    assert "processing_status" in summary
+    assert "classification_outcome" in summary
+    assert "model_provider:** `fake`" in summary
+    assert "model_name:** `fake-model`" in summary
+    assert "classifications:** `1`" in summary
+    assert "requiring_review:** `1`" in summary
+
+
+def test_classification_table_rows_include_only_demo_relevant_fields() -> None:
+    article = ArticleRecord(DOI="10.example/table", Title="Table", Year=2025, Abstract="Text.")
+    result = _classified_result(article)
+
+    rows = gradio_app.classification_table_rows(result)
+
+    assert gradio_app.CLASSIFICATION_TABLE_COLUMNS == [
+        "GCMD Keyword Path",
+        "Evidence",
+        "Support",
+        "Review Required",
+    ]
+    assert rows == [
+        [
+            "ATMOSPHERE > ATMOSPHERIC CHEMISTRY > CARBON > CARBON DIOXIDE",
+            "The article discusses atmospheric carbon dioxide.",
+            "explicit",
+            False,
+        ]
+    ]
+
+
 def test_errors_and_warnings_are_displayed() -> None:
     article = ArticleRecord(
         DOI="10.example/diagnostics",
@@ -232,7 +303,7 @@ def test_empty_abstract_is_accepted_by_ui_input_path(monkeypatch) -> None:
 
     monkeypatch.setattr(gradio_app.pipeline_service, "classify_article", fake_classify)
 
-    summary, payload, _ = gradio_app.run_demo_classification(
+    summary, table, payload, _ = gradio_app.run_demo_classification(
         Title="Title only",
         Abstract="",
         DOI="10.example/title-only",
@@ -242,6 +313,7 @@ def test_empty_abstract_is_accepted_by_ui_input_path(monkeypatch) -> None:
     )
 
     assert seen["abstract"] == ""
+    assert table == []
     assert payload["Abstract"] == ""
     assert "not_classified" in summary