Refactor code structure for improved readability and maintainability

Author: legout

dashboard/__init__.py

@@ -28,7 +28,7 @@ def load_json_report(file_path: Union[str, Path]) -> Dict[str, Any]:
             raise FileNotFoundError(f"Report file not found: {path}")
 
         try:
-            with open(path, 'r', encoding='utf-8') as f:
+            with open(path, 'r',) as f:
                 return json.load(f)
         except json.JSONDecodeError as e:
             raise ValueError(f"Invalid JSON format in {path}: {e}")

dashboard/core/data_processor.py

@@ -0,0 +1,33 @@
+# VeritaScribe Datastar Dashboard
+
+This directory contains the `datastar`-powered rewrite of the VeritaScribe error management dashboard.
+
+## Overview
+
+This application provides a real-time, interactive interface for analyzing and managing VeritaScribe error reports. It is built with modern, Python-centric tools to ensure a clean, maintainable, and highly reactive user experience without the need for custom JavaScript.
+
+## Technology Stack
+
+-   **Backend Framework:** [`fasthtml`](https://github.com/AnswerDotAI/fasthtml)
+-   **Reactivity:** [`datastar`](https://github.com/starfederation/datastar) and [`datastar-py`](https://github.com/starfederation/datastar-py)
+-   **UI Components:** [`daisyUI`](https://daisyui.com/)
+-   **Styling:** [`Tailwind CSS`](https://tailwindcss.com/) (via CDN)
+
+## Project Structure
+
+The application is organized into the following key files:
+
+-   [`app.py`](dashboard/datastar_app/app.py): The main `fasthtml` application. It defines all URL routes, handles server-side logic, and streams updates to the client using Server-Sent Events (SSE).
+-   [`stores.py`](dashboard/datastar_app/stores.py): Defines the server-side state management using a simple Python dataclass. The `app_state` object holds the application's state, which is projected to the UI via `datastar` signals.
+-   [`components.py`](dashboard/datastar_app/components.py): Contains reusable functions that generate `daisyui`-styled HTML components. These functions are used by the routes in `app.py` to build the UI.
+-   `static/`: This directory is reserved for any static assets, although this project currently relies on CDNs for all frontend dependencies.
+
+## Running the Application
+
+To run the dashboard, execute the main launch script from the root of the project:
+
+```bash
+python dashboard/launch_fasthtml.py
+```
+
+The application will be available at `http://localhost:8000`.

dashboard/datastar_app/README.md

@@ -0,0 +1,243 @@
+from fasthtml.common import *
+from typing import AsyncIterator, Optional, Dict, Any
+from starlette.responses import StreamingResponse
+import json
+import tempfile
+import os
+from core.error_manager import ErrorManager
+from core.data_processor import DataProcessor
+from core.models import FilterCriteria, ErrorStatus, ErrorType, Severity
+from .stores import app_state, project_signals
+
+
+# # Try to import datastar-py SSE helper; provide a minimal fallback if missing
+# try:
+from datastar_py import ServerSentEventGenerator as SSE  # type: ignore
+# except Exception:  # pragma: no cover
+#     class SSE:  # Fallback SSE generator
+#         @staticmethod
+#         def patch_elements(html: str) -> str:
+#             # Minimal SSE format: the datastar client can interpret payloads as needed
+#             return f"data: {json.dumps({'patch': {'elements': html}})}\n\n"
+
+#         @staticmethod
+#         def patch_signals(signals: Dict[str, Any]) -> str:
+#             return f"data: {json.dumps({'patch': {'signals': signals}})}\n\n"
+
+
+app, rt = fast_app()
+error_manager = ErrorManager()
+
+# Load initial data on startup
+dp = DataProcessor()
+initial_report = dp.load_and_convert_report("demo_thesis.pdf")
+error_manager.import_analysis_report(initial_report)
+app_state.selected_document = initial_report.document_path
+app_state.errors = error_manager.get_errors(app_state.selected_document)
+
+
+def sse_response(events: AsyncIterator[bytes]) -> StreamingResponse:
+    # Generic SSE response helper for FastHTML (Starlette ASGI)
+    headers = {"Cache-Control": "no-cache", "X-Accel-Buffering": "no"}
+    return StreamingResponse(events, media_type="text/event-stream", headers=headers)
+
+
+async def stream_patch(elements_html: Optional[str] = None, signals: Optional[Dict[str, Any]] = None) -> AsyncIterator[bytes]:
+    if elements_html:
+        yield SSE.patch_elements(elements_html).encode()
+    if signals is not None:
+        yield SSE.patch_signals(signals).encode()
+
+
+@rt("/")
+def get_home():
+    # Initial shell; regions lazy-load via datastar actions on-load
+    from .components import page_layout, filter_sidebar, stats_cards, error_table
+    counts = {
+        "total": len(app_state.errors),
+        "pending": sum(getattr(e, "status", None) == ErrorStatus.PENDING for e in app_state.errors),
+        "completed": sum(getattr(e, "status", None) == ErrorStatus.RESOLVED for e in app_state.errors),
+    }
+    return page_layout(
+        "VeritaScribe Dashboard",
+        filter_sidebar(),
+        stats_cards(counts),
+        error_table(app_state.errors),
+    )
+
+
+@rt("/dashboard/stats")
+def get_stats():
+    from .components import stats_cards
+    counts = {
+        "total": len(app_state.errors),
+        "pending": sum(getattr(e, "status", None) == ErrorStatus.PENDING for e in app_state.errors),
+        "completed": sum(getattr(e, "status", None) == ErrorStatus.RESOLVED for e in app_state.errors),
+    }
+    html = str(stats_cards(counts))  # FastTags stringify to HTML
+
+    async def gen():
+        async for chunk in stream_patch(elements_html=html, signals=project_signals()):
+            yield chunk
+
+    return sse_response(gen())
+
+
+@rt("/dashboard/errors")
+def get_errors():
+    from .components import error_table
+    html = str(error_table(app_state.errors))
+
+    async def gen():
+        async for chunk in stream_patch(elements_html=html):
+            yield chunk
+
+    return sse_response(gen())
+
+
+@rt("/dashboard/import_form")
+def get_import_form():
+    from .components import upload_form
+    html = str(upload_form())
+
+    async def gen():
+        async for chunk in stream_patch(elements_html=html):
+            yield chunk
+
+    return sse_response(gen())
+
+
+@rt("/dashboard/filter")
+def post_filter(status: str = "", error_type: str = "", severity: str = "", q: str = ""):
+    # Build FilterCriteria and query errors via ErrorManager
+    fc = FilterCriteria()
+
+    # Normalize "all" sentinel values and map to enums if provided
+    if status and status.lower() not in ("all", "all statuses"):
+        try:
+            fc.status = [ErrorStatus(status)]
+        except Exception:
+            pass
+
+    if error_type and error_type.lower() not in ("all", "all types"):
+        try:
+            fc.error_type = [ErrorType(error_type)]
+        except Exception:
+            pass
+
+    if severity and severity.lower() not in ("all", "all severities"):
+        try:
+            fc.severity = [Severity(severity)]
+        except Exception:
+            pass
+
+    if q and q.strip():
+        fc.search_text = q.strip()
+
+    app_state.filter_criteria = fc
+    app_state.errors = error_manager.get_errors(app_state.selected_document, fc)
+
+    from .components import error_table
+    html = str(error_table(app_state.errors))
+
+    async def gen():
+        async for chunk in stream_patch(elements_html=html, signals=project_signals()):
+            yield chunk
+
+    return sse_response(gen())
+
+
+@rt("/errors/{error_id}/status")
+def post_error_status(error_id: str, status: str):
+    # Update in DB
+    try:
+        new_status = ErrorStatus(status)
+    except Exception:
+        new_status = None
+
+    if new_status is not None:
+        error_manager.update_error(error_id, {"status": new_status})
+        # Update in-memory state to remain consistent
+        for e in app_state.errors:
+            if getattr(e, "error_id", None) == error_id:
+                e.status = new_status
+                break
+
+    from .components import error_row
+    target = next((e for e in app_state.errors if getattr(e, "error_id", None) == error_id), None)
+    row_html = str(error_row(target)) if target else ""
+
+    async def gen():
+        async for chunk in stream_patch(elements_html=row_html, signals=project_signals()):
+            yield chunk
+
+    return sse_response(gen())
+
+
+@rt("/errors/bulk")
+def post_bulk(action: str):
+    # Apply action to selected errors from signals (if needed, read_signals could be parsed from request)
+    updates: Dict[str, Any] = {}
+
+    if action == "mark_resolved":
+        updates["status"] = ErrorStatus.RESOLVED
+    elif action == "mark_dismissed":
+        updates["status"] = ErrorStatus.DISMISSED
+    elif action == "assign_to_me":
+        updates["assigned_to"] = "web_user"
+        updates["status"] = ErrorStatus.IN_PROGRESS
+
+    if updates and app_state.selected_errors:
+        error_manager.bulk_update_errors(app_state.selected_errors, updates)
+
+    app_state.errors = error_manager.get_errors(app_state.selected_document, app_state.filter_criteria)
+
+    from .components import error_table
+    html = str(error_table(app_state.errors))
+
+    async def gen():
+        async for chunk in stream_patch(elements_html=html, signals=project_signals()):
+            yield chunk
+
+    return sse_response(gen())
+
+
+@rt("/upload")
+async def post_upload(file: UploadFile):
+    dp = DataProcessor()
+    # Persist uploaded file temporarily for DataProcessor
+    data = await file.read()
+    with tempfile.NamedTemporaryFile(mode="wb", suffix=".json", delete=False) as tf:
+        tf.write(data)
+        temp_path = tf.name
+
+    try:
+        report = dp.load_and_convert_report(temp_path)
+        # Persist and reload via ErrorManager
+        error_manager.import_analysis_report(report)
+        app_state.selected_document = report.document_path
+        app_state.errors = error_manager.get_errors(app_state.selected_document, app_state.filter_criteria)
+
+        from .components import stats_cards, error_table
+        msg = Div("Upload successful", cls="alert alert-success")
+        counts = {
+            "total": len(app_state.errors),
+            "pending": sum(getattr(e, "status", None) == ErrorStatus.PENDING for e in app_state.errors),
+            "completed": sum(getattr(e, "status", None) == ErrorStatus.RESOLVED for e in app_state.errors),
+        }
+        html = str(Div(msg, stats_cards(counts), error_table(app_state.errors)))
+    finally:
+        try:
+            os.remove(temp_path)
+        except Exception:
+            pass
+
+    async def gen():
+        async for chunk in stream_patch(elements_html=html, signals=project_signals()):
+            yield chunk
+
+    return sse_response(gen())
+
+
+if __name__ == "__main__":
+    serve()