truthound-dashboard 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

truthound_dashboard/core/reporters/pdf_reporter.py

@@ -0,0 +1,209 @@
+"""PDF report generator.
+
+Generates professional PDF reports using HTML-to-PDF conversion.
+Supports multiple themes and includes all validation details.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from .base import Reporter, ReportFormat, ReportMetadata, ReportTheme
+from .html_reporter import HTMLReporter
+
+if TYPE_CHECKING:
+    from truthound_dashboard.db.models import Validation
+
+logger = logging.getLogger(__name__)
+
+# Check if weasyprint is available
+_WEASYPRINT_AVAILABLE = False
+try:
+    import weasyprint  # noqa: F401
+    _WEASYPRINT_AVAILABLE = True
+except ImportError:
+    logger.debug("weasyprint not available, PDF generation will use HTML fallback")
+
+
+class PDFReporter(Reporter):
+    """PDF report generator using HTML-to-PDF conversion.
+
+    Uses weasyprint for high-quality PDF generation.
+    Falls back to HTML if weasyprint is not installed.
+    """
+
+    def __init__(self) -> None:
+        """Initialize PDF reporter with HTML reporter for content generation."""
+        self._html_reporter = HTMLReporter()
+
+    @property
+    def format(self) -> ReportFormat:
+        return ReportFormat.PDF
+
+    @property
+    def content_type(self) -> str:
+        return "application/pdf"
+
+    @property
+    def file_extension(self) -> str:
+        return ".pdf"
+
+    @classmethod
+    def is_available(cls) -> bool:
+        """Check if PDF generation is available."""
+        return _WEASYPRINT_AVAILABLE
+
+    async def _render_content(
+        self,
+        validation: Validation,
+        metadata: ReportMetadata,
+        include_samples: bool,
+        include_statistics: bool,
+    ) -> bytes:
+        """Render PDF report content.
+
+        Uses HTML reporter to generate content, then converts to PDF.
+        """
+        # Generate HTML content using the HTML reporter
+        html_content = await self._html_reporter._render_content(
+            validation=validation,
+            metadata=metadata,
+            include_samples=include_samples,
+            include_statistics=include_statistics,
+        )
+
+        # Add PDF-specific styles for better printing
+        pdf_styles = self._get_pdf_styles(metadata.theme)
+        html_content = html_content.replace(
+            "</style>",
+            f"{pdf_styles}\n    </style>"
+        )
+
+        # Convert HTML to PDF
+        if _WEASYPRINT_AVAILABLE:
+            return self._convert_to_pdf(html_content)
+        else:
+            # Return HTML as bytes if weasyprint is not available
+            logger.warning(
+                "weasyprint not installed. Install with: pip install weasyprint"
+            )
+            return html_content.encode("utf-8")
+
+    def _get_pdf_styles(self, theme: ReportTheme) -> str:
+        """Get additional CSS styles for PDF output."""
+        return """
+        /* PDF-specific styles */
+        @page {
+            size: A4;
+            margin: 1.5cm;
+
+            @top-center {
+                content: "Truthound Validation Report";
+                font-size: 10pt;
+                color: #64748b;
+            }
+
+            @bottom-right {
+                content: counter(page) " / " counter(pages);
+                font-size: 10pt;
+                color: #64748b;
+            }
+        }
+
+        @page :first {
+            @top-center { content: none; }
+        }
+
+        body {
+            font-size: 11pt;
+            line-height: 1.5;
+        }
+
+        .container {
+            max-width: 100%;
+        }
+
+        .header {
+            page-break-after: avoid;
+        }
+
+        .card {
+            page-break-inside: avoid;
+            margin-bottom: 0.75cm;
+        }
+
+        table {
+            font-size: 10pt;
+        }
+
+        th, td {
+            padding: 0.4rem 0.6rem;
+        }
+
+        .summary-grid {
+            grid-template-columns: repeat(5, 1fr);
+        }
+
+        .summary-item .value {
+            font-size: 1.5rem;
+        }
+
+        .footer {
+            page-break-before: avoid;
+            font-size: 9pt;
+        }
+
+        /* Remove hover effects for PDF */
+        tr:hover {
+            background: transparent !important;
+        }
+
+        /* Ensure badges print with colors */
+        .severity-badge,
+        .status-badge {
+            -webkit-print-color-adjust: exact;
+            print-color-adjust: exact;
+        }
+        """
+
+    def _convert_to_pdf(self, html_content: str) -> bytes:
+        """Convert HTML content to PDF bytes.
+
+        Args:
+            html_content: HTML string to convert.
+
+        Returns:
+            PDF content as bytes.
+        """
+        try:
+            import weasyprint
+            from weasyprint import CSS
+
+            # Additional CSS for better PDF rendering
+            extra_css = CSS(string="""
+                @page { margin: 1.5cm; }
+                body { -webkit-print-color-adjust: exact; }
+            """)
+
+            # Create PDF
+            html = weasyprint.HTML(string=html_content, base_url=".")
+            pdf_bytes = html.write_pdf(stylesheets=[extra_css])
+
+            return pdf_bytes
+
+        except Exception as e:
+            logger.error(f"Failed to convert HTML to PDF: {e}")
+            raise RuntimeError(f"PDF generation failed: {e}") from e
+
+    def _extract_issues(self, validation: Validation) -> list[dict[str, Any]]:
+        """Extract issues from validation result."""
+        return self._html_reporter._extract_issues(validation)
+
+    def _get_severity_color(self, severity: str, theme: ReportTheme) -> str:
+        """Get color for severity level."""
+        return self._html_reporter._get_severity_color(severity, theme)
+
+    def _get_status_indicator(self, passed: bool | None) -> str:
+        """Get status indicator text."""
+        return self._html_reporter._get_status_indicator(passed)

truthound_dashboard/core/reporters/registry.py

@@ -0,0 +1,272 @@
+"""Reporter registry and factory functions.
+
+This module provides a central registry for report generators and
+convenience functions for generating reports with i18n support.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from .base import Reporter, ReportFormat, ReportResult, ReportTheme
+from .i18n import SupportedLocale, get_supported_locales
+
+if TYPE_CHECKING:
+    from truthound_dashboard.db.models import Validation
+
+logger = logging.getLogger(__name__)
+
+
+class ReporterRegistry:
+    """Registry for report generators.
+
+    Maintains a mapping of formats to reporter implementations.
+    Supports custom reporter registration for extensibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize empty registry."""
+        self._reporters: dict[ReportFormat, type[Reporter]] = {}
+
+    def register(
+        self,
+        format_type: ReportFormat,
+        reporter_class: type[Reporter],
+    ) -> None:
+        """Register a reporter for a format.
+
+        Args:
+            format_type: Report format this reporter handles.
+            reporter_class: Reporter class to register.
+        """
+        self._reporters[format_type] = reporter_class
+        logger.debug(f"Registered reporter for format: {format_type.value}")
+
+    def get(self, format_type: ReportFormat) -> Reporter:
+        """Get a reporter instance for a format.
+
+        Args:
+            format_type: Desired report format.
+
+        Returns:
+            Reporter instance.
+
+        Raises:
+            ValueError: If no reporter is registered for the format.
+        """
+        reporter_class = self._reporters.get(format_type)
+        if reporter_class is None:
+            raise ValueError(
+                f"No reporter registered for format: {format_type.value}. "
+                f"Available formats: {self.available_formats}"
+            )
+        return reporter_class()
+
+    @property
+    def available_formats(self) -> list[str]:
+        """Get list of available format names."""
+        return [fmt.value for fmt in self._reporters.keys()]
+
+    def is_registered(self, format_type: ReportFormat) -> bool:
+        """Check if a format has a registered reporter.
+
+        Args:
+            format_type: Format to check.
+
+        Returns:
+            True if format is registered.
+        """
+        return format_type in self._reporters
+
+
+# Global registry instance
+_registry: ReporterRegistry | None = None
+
+
+def get_registry() -> ReporterRegistry:
+    """Get the global reporter registry.
+
+    Initializes with default reporters on first call.
+
+    Returns:
+        Global ReporterRegistry instance.
+    """
+    global _registry
+    if _registry is None:
+        _registry = ReporterRegistry()
+        _register_default_reporters(_registry)
+    return _registry
+
+
+def _register_default_reporters(registry: ReporterRegistry) -> None:
+    """Register all built-in reporters.
+
+    Args:
+        registry: Registry to populate.
+
+    Registers 6 reporters:
+    - HTML: Rich visual reports with themes
+    - CSV: Spreadsheet-compatible format
+    - JSON: Machine-readable structured data
+    - Markdown: Documentation-friendly format
+    - PDF: Print-ready documents
+    - JUnit: CI/CD integration (Jenkins, GitHub Actions, etc.)
+    """
+    from .csv_reporter import CSVReporter
+    from .html_reporter import HTMLReporter
+    from .json_reporter import JSONReporter
+    from .junit_reporter import JUnitReporter
+    from .markdown_reporter import MarkdownReporter
+    from .pdf_reporter import PDFReporter
+
+    registry.register(ReportFormat.HTML, HTMLReporter)
+    registry.register(ReportFormat.CSV, CSVReporter)
+    registry.register(ReportFormat.JSON, JSONReporter)
+    registry.register(ReportFormat.MARKDOWN, MarkdownReporter)
+    registry.register(ReportFormat.PDF, PDFReporter)
+    registry.register(ReportFormat.JUNIT, JUnitReporter)
+
+    logger.debug(f"Registered {len(registry.available_formats)} default reporters")
+
+
+def register_reporter(
+    format_type: ReportFormat,
+    reporter_class: type[Reporter],
+) -> None:
+    """Register a custom reporter.
+
+    Convenience function for registering custom reporters.
+
+    Args:
+        format_type: Report format to handle.
+        reporter_class: Reporter class to register.
+    """
+    get_registry().register(format_type, reporter_class)
+
+
+def get_reporter(
+    format_type: ReportFormat | str,
+    locale: SupportedLocale | str = SupportedLocale.ENGLISH,
+) -> Reporter:
+    """Get a reporter for a specific format with locale support.
+
+    Args:
+        format_type: Report format (enum or string).
+        locale: Target locale for report generation.
+
+    Returns:
+        Reporter instance for the format.
+
+    Raises:
+        ValueError: If format is not recognized or not registered.
+    """
+    if isinstance(format_type, str):
+        format_type = ReportFormat.from_string(format_type)
+
+    # Get the reporter class from registry
+    registry = get_registry()
+    reporter_class = registry._reporters.get(format_type)
+
+    if reporter_class is None:
+        raise ValueError(
+            f"No reporter registered for format: {format_type.value}. "
+            f"Available formats: {registry.available_formats}"
+        )
+
+    # Convert locale string to enum
+    if isinstance(locale, str):
+        locale = SupportedLocale.from_string(locale)
+
+    # Create reporter with locale if supported
+    try:
+        # Try to create with locale (for reporters that support it)
+        return reporter_class(locale=locale)
+    except TypeError:
+        # Fall back to no-arg constructor for reporters without locale
+        return reporter_class()
+
+
+def get_available_formats() -> list[str]:
+    """Get list of available report formats.
+
+    Returns:
+        List of format name strings.
+    """
+    return get_registry().available_formats
+
+
+async def generate_report(
+    validation: Validation,
+    *,
+    format: ReportFormat | str = ReportFormat.HTML,
+    theme: ReportTheme | str = ReportTheme.PROFESSIONAL,
+    locale: SupportedLocale | str = SupportedLocale.ENGLISH,
+    title: str | None = None,
+    include_samples: bool = True,
+    include_statistics: bool = True,
+    custom_metadata: dict[str, Any] | None = None,
+) -> ReportResult:
+    """Generate a report for a validation result.
+
+    High-level convenience function for report generation with i18n support.
+
+    Args:
+        validation: Validation model with results.
+        format: Output format (enum or string).
+        theme: Visual theme (enum or string).
+        locale: Report language (supports 15 languages).
+        title: Custom report title.
+        include_samples: Include sample problematic values.
+        include_statistics: Include data statistics.
+        custom_metadata: Additional metadata to include.
+
+    Returns:
+        ReportResult with generated content.
+
+    Example:
+        # Generate Korean HTML report with dark theme
+        report = await generate_report(
+            validation,
+            format="html",
+            theme="dark",
+            locale="ko"
+        )
+        with open(report.filename, "w") as f:
+            f.write(report.content)
+    """
+    # Convert string arguments to enums
+    if isinstance(format, str):
+        format = ReportFormat.from_string(format)
+    if isinstance(theme, str):
+        theme = ReportTheme(theme)
+
+    reporter = get_reporter(format, locale=locale)
+
+    return await reporter.generate(
+        validation,
+        theme=theme,
+        title=title,
+        include_samples=include_samples,
+        include_statistics=include_statistics,
+        custom_metadata=custom_metadata,
+    )
+
+
+def get_report_locales() -> list[dict[str, Any]]:
+    """Get list of supported report locales.
+
+    Returns:
+        List of locale info dictionaries with code, name, and metadata.
+
+    Example:
+        locales = get_report_locales()
+        # [{"code": "en", "english_name": "English", "native_name": "English", ...}, ...]
+    """
+    return get_supported_locales()
+
+
+def reset_registry() -> None:
+    """Reset the global registry (for testing)."""
+    global _registry
+    _registry = None