truthound-dashboard 1.3.1__py3-none-any.whl → 1.4.1__py3-none-any.whl

truthound_dashboard/core/reporters/json_reporter.py

@@ -0,0 +1,160 @@
+"""JSON report generator.
+
+Generates machine-readable JSON reports suitable for API consumption
+and integration with other tools.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from .base import Reporter, ReportFormat, ReportMetadata
+
+if TYPE_CHECKING:
+    from truthound_dashboard.db.models import Validation
+
+
+class JSONReporter(Reporter):
+    """JSON report generator.
+
+    Produces structured JSON reports with complete validation data.
+    Supports pretty printing and compact output modes.
+    """
+
+    def __init__(
+        self,
+        indent: int | None = 2,
+        ensure_ascii: bool = False,
+    ) -> None:
+        """Initialize JSON reporter.
+
+        Args:
+            indent: Indentation for pretty printing. None for compact output.
+            ensure_ascii: Whether to escape non-ASCII characters.
+        """
+        self._indent = indent
+        self._ensure_ascii = ensure_ascii
+
+    @property
+    def format(self) -> ReportFormat:
+        return ReportFormat.JSON
+
+    @property
+    def content_type(self) -> str:
+        return "application/json; charset=utf-8"
+
+    @property
+    def file_extension(self) -> str:
+        return ".json"
+
+    async def _render_content(
+        self,
+        validation: Validation,
+        metadata: ReportMetadata,
+        include_samples: bool,
+        include_statistics: bool,
+    ) -> str:
+        """Render JSON report content."""
+        issues = self._extract_issues(validation)
+
+        # Process issues to optionally remove samples
+        if not include_samples:
+            issues = [
+                {k: v for k, v in issue.items() if k != "sample_values"}
+                for issue in issues
+            ]
+
+        report_data: dict[str, Any] = {
+            "metadata": {
+                "title": metadata.title,
+                "generated_at": metadata.generated_at.isoformat(),
+                "format": metadata.format.value,
+                "theme": metadata.theme.value,
+            },
+            "validation": {
+                "id": validation.id,
+                "source_id": validation.source_id,
+                "source_name": metadata.source_name,
+                "status": validation.status,
+                "passed": validation.passed,
+            },
+            "summary": {
+                "total_issues": validation.total_issues or 0,
+                "critical_issues": validation.critical_issues or 0,
+                "high_issues": validation.high_issues or 0,
+                "medium_issues": validation.medium_issues or 0,
+                "low_issues": validation.low_issues or 0,
+                "has_critical": validation.has_critical or False,
+                "has_high": validation.has_high or False,
+            },
+            "issues": issues,
+        }
+
+        # Add statistics if requested
+        if include_statistics:
+            report_data["statistics"] = {
+                "row_count": validation.row_count,
+                "column_count": validation.column_count,
+                "duration_ms": validation.duration_ms,
+                "started_at": (
+                    validation.started_at.isoformat()
+                    if validation.started_at
+                    else None
+                ),
+                "completed_at": (
+                    validation.completed_at.isoformat()
+                    if validation.completed_at
+                    else None
+                ),
+                "created_at": (
+                    validation.created_at.isoformat()
+                    if validation.created_at
+                    else None
+                ),
+            }
+
+        # Add error info if present
+        if validation.error_message:
+            report_data["error"] = {
+                "message": validation.error_message,
+            }
+
+        return json.dumps(
+            report_data,
+            indent=self._indent,
+            ensure_ascii=self._ensure_ascii,
+            default=self._json_serializer,
+        )
+
+    def _json_serializer(self, obj: Any) -> Any:
+        """Custom JSON serializer for non-serializable objects.
+
+        Args:
+            obj: Object to serialize.
+
+        Returns:
+            Serializable representation.
+
+        Raises:
+            TypeError: If object cannot be serialized.
+        """
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+
+
+class CompactJSONReporter(JSONReporter):
+    """Compact JSON reporter without formatting.
+
+    Produces minified JSON for reduced file size.
+    """
+
+    def __init__(self) -> None:
+        """Initialize compact JSON reporter."""
+        super().__init__(indent=None, ensure_ascii=False)

truthound_dashboard/core/reporters/junit_reporter.py

@@ -0,0 +1,233 @@
+"""JUnit XML report generator.
+
+Generates JUnit-compatible XML reports for CI/CD integration.
+Output can be consumed by Jenkins, GitHub Actions, GitLab CI, etc.
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from .base import Reporter, ReportFormat, ReportMetadata, ReportTheme
+
+if TYPE_CHECKING:
+    from truthound_dashboard.db.models import Validation
+
+
+class JUnitReporter(Reporter):
+    """JUnit XML report generator for CI/CD integration.
+
+    Produces JUnit-compatible XML that can be consumed by:
+    - Jenkins JUnit Plugin
+    - GitHub Actions
+    - GitLab CI
+    - Azure DevOps
+    - CircleCI
+    - Any tool supporting JUnit XML format
+    """
+
+    @property
+    def format(self) -> ReportFormat:
+        return ReportFormat.JUNIT
+
+    @property
+    def content_type(self) -> str:
+        return "application/xml; charset=utf-8"
+
+    @property
+    def file_extension(self) -> str:
+        return ".xml"
+
+    async def _render_content(
+        self,
+        validation: Validation,
+        metadata: ReportMetadata,
+        include_samples: bool,
+        include_statistics: bool,
+    ) -> str:
+        """Render JUnit XML report content."""
+        issues = self._extract_issues(validation)
+
+        # Create root element (testsuites)
+        testsuites = ET.Element("testsuites")
+        testsuites.set("name", "Truthound Validation")
+        testsuites.set("tests", str(len(issues) + 1))  # +1 for overall test
+        testsuites.set("failures", str(validation.total_issues or 0))
+        testsuites.set("errors", str(validation.critical_issues or 0))
+        testsuites.set("time", str((validation.duration_ms or 0) / 1000))
+
+        # Create testsuite for this validation
+        testsuite = ET.SubElement(testsuites, "testsuite")
+        testsuite.set("name", f"Validation: {metadata.source_name or validation.source_id}")
+        testsuite.set("tests", str(len(issues) + 1))
+        testsuite.set("failures", str(validation.total_issues or 0))
+        testsuite.set("errors", str(validation.critical_issues or 0))
+        testsuite.set("time", str((validation.duration_ms or 0) / 1000))
+        testsuite.set("timestamp", validation.created_at.isoformat() if validation.created_at else datetime.utcnow().isoformat())
+
+        # Add properties
+        properties = ET.SubElement(testsuite, "properties")
+        self._add_property(properties, "source_id", validation.source_id)
+        self._add_property(properties, "validation_id", validation.id)
+        self._add_property(properties, "row_count", str(validation.row_count or 0))
+        self._add_property(properties, "column_count", str(validation.column_count or 0))
+        self._add_property(properties, "status", validation.status)
+        self._add_property(properties, "passed", str(validation.passed).lower())
+
+        # Add overall validation test case
+        overall_test = ET.SubElement(testsuite, "testcase")
+        overall_test.set("name", "Overall Validation")
+        overall_test.set("classname", f"truthound.{metadata.source_name or validation.source_id}")
+        overall_test.set("time", str((validation.duration_ms or 0) / 1000))
+
+        if not validation.passed:
+            failure = ET.SubElement(overall_test, "failure")
+            failure.set("message", f"Validation failed with {validation.total_issues} issues")
+            failure.set("type", "ValidationFailure")
+            failure.text = self._generate_failure_details(validation, issues)
+
+        # Add individual test cases for each issue type
+        issue_groups = self._group_issues_by_type(issues)
+        for issue_type, group_issues in issue_groups.items():
+            testcase = ET.SubElement(testsuite, "testcase")
+            testcase.set("name", f"Check: {issue_type}")
+            testcase.set("classname", f"truthound.validators.{issue_type}")
+            testcase.set("time", "0")
+
+            if group_issues:
+                # Determine severity for failure type
+                max_severity = max(
+                    (self._severity_order(i.get("severity", "low")) for i in group_issues),
+                    default=0
+                )
+
+                if max_severity >= 3:  # critical
+                    error = ET.SubElement(testcase, "error")
+                    error.set("message", f"Critical: {len(group_issues)} issues found")
+                    error.set("type", "CriticalValidationError")
+                    error.text = self._format_issues_detail(group_issues, include_samples)
+                else:
+                    failure = ET.SubElement(testcase, "failure")
+                    failure.set("message", f"{len(group_issues)} issues found")
+                    failure.set("type", "ValidationFailure")
+                    failure.text = self._format_issues_detail(group_issues, include_samples)
+
+        # Add system-out with summary
+        system_out = ET.SubElement(testsuite, "system-out")
+        system_out.text = self._generate_summary(validation, metadata)
+
+        # Convert to string with proper formatting
+        return self._prettify_xml(testsuites)
+
+    def _add_property(self, parent: ET.Element, name: str, value: str) -> None:
+        """Add a property element."""
+        prop = ET.SubElement(parent, "property")
+        prop.set("name", name)
+        prop.set("value", value)
+
+    def _severity_order(self, severity: str) -> int:
+        """Get numeric order for severity."""
+        order = {"low": 0, "medium": 1, "high": 2, "critical": 3}
+        return order.get(severity.lower(), 0)
+
+    def _group_issues_by_type(self, issues: list[dict[str, Any]]) -> dict[str, list[dict[str, Any]]]:
+        """Group issues by their type."""
+        groups: dict[str, list[dict[str, Any]]] = {}
+        for issue in issues:
+            issue_type = issue.get("issue_type", "unknown")
+            if issue_type not in groups:
+                groups[issue_type] = []
+            groups[issue_type].append(issue)
+        return groups
+
+    def _generate_failure_details(
+        self,
+        validation: Validation,
+        issues: list[dict[str, Any]],
+    ) -> str:
+        """Generate detailed failure message."""
+        lines = [
+            f"Validation Status: {validation.status}",
+            f"Total Issues: {validation.total_issues}",
+            f"Critical: {validation.critical_issues}",
+            f"High: {validation.high_issues}",
+            f"Medium: {validation.medium_issues}",
+            f"Low: {validation.low_issues}",
+            "",
+            "Issue Summary:",
+        ]
+
+        for issue in issues[:10]:  # Limit to first 10
+            lines.append(
+                f"  - [{issue.get('severity', 'unknown').upper()}] "
+                f"{issue.get('column', 'N/A')}: {issue.get('issue_type', 'unknown')} "
+                f"({issue.get('count', 0)} occurrences)"
+            )
+
+        if len(issues) > 10:
+            lines.append(f"  ... and {len(issues) - 10} more issues")
+
+        return "\n".join(lines)
+
+    def _format_issues_detail(
+        self,
+        issues: list[dict[str, Any]],
+        include_samples: bool,
+    ) -> str:
+        """Format issues for display in XML."""
+        lines = []
+        for issue in issues:
+            line = (
+                f"Column: {issue.get('column', 'N/A')}, "
+                f"Count: {issue.get('count', 0)}"
+            )
+            if issue.get("details"):
+                line += f", Details: {issue.get('details')}"
+
+            if include_samples and issue.get("sample_values"):
+                samples = [str(v)[:30] for v in issue["sample_values"][:3]]
+                line += f", Samples: [{', '.join(samples)}]"
+
+            lines.append(line)
+
+        return "\n".join(lines)
+
+    def _generate_summary(
+        self,
+        validation: Validation,
+        metadata: ReportMetadata,
+    ) -> str:
+        """Generate summary for system-out."""
+        return f"""
+Truthound Validation Report
+===========================
+Source: {metadata.source_name or validation.source_id}
+Validation ID: {validation.id}
+Generated: {metadata.generated_at.isoformat()}
+
+Data Statistics:
+  Rows: {validation.row_count or 'N/A'}
+  Columns: {validation.column_count or 'N/A'}
+
+Validation Results:
+  Status: {validation.status}
+  Passed: {validation.passed}
+  Duration: {(validation.duration_ms or 0) / 1000:.2f}s
+
+Issue Summary:
+  Total: {validation.total_issues or 0}
+  Critical: {validation.critical_issues or 0}
+  High: {validation.high_issues or 0}
+  Medium: {validation.medium_issues or 0}
+  Low: {validation.low_issues or 0}
+"""
+
+    def _prettify_xml(self, elem: ET.Element) -> str:
+        """Return pretty-printed XML string."""
+        from xml.dom import minidom
+
+        rough_string = ET.tostring(elem, encoding="unicode", method="xml")
+        reparsed = minidom.parseString(rough_string)
+        return reparsed.toprettyxml(indent="  ", encoding=None)

truthound_dashboard/core/reporters/markdown_reporter.py

@@ -0,0 +1,207 @@
+"""Markdown report generator.
+
+Generates Markdown reports suitable for documentation, GitHub,
+and other platforms that render Markdown.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from .base import Reporter, ReportFormat, ReportMetadata, ReportTheme
+
+if TYPE_CHECKING:
+    from truthound_dashboard.db.models import Validation
+
+
+class MarkdownReporter(Reporter):
+    """Markdown report generator.
+
+    Produces GitHub-flavored Markdown reports with tables and badges.
+    """
+
+    def __init__(self, flavor: str = "github") -> None:
+        """Initialize Markdown reporter.
+
+        Args:
+            flavor: Markdown flavor (github, standard).
+        """
+        self._flavor = flavor
+
+    @property
+    def format(self) -> ReportFormat:
+        return ReportFormat.MARKDOWN
+
+    @property
+    def content_type(self) -> str:
+        return "text/markdown; charset=utf-8"
+
+    @property
+    def file_extension(self) -> str:
+        return ".md"
+
+    async def _render_content(
+        self,
+        validation: Validation,
+        metadata: ReportMetadata,
+        include_samples: bool,
+        include_statistics: bool,
+    ) -> str:
+        """Render Markdown report content."""
+        sections = []
+
+        # Header
+        sections.append(self._render_header(validation, metadata))
+
+        # Status badge
+        sections.append(self._render_status_badge(validation))
+
+        # Summary
+        sections.append(self._render_summary(validation))
+
+        # Statistics
+        if include_statistics:
+            sections.append(self._render_statistics(validation))
+
+        # Issues table
+        issues = self._extract_issues(validation)
+        sections.append(self._render_issues_table(issues, include_samples))
+
+        # Footer
+        sections.append(self._render_footer(metadata))
+
+        return "\n\n".join(filter(None, sections))
+
+    def _render_header(self, validation: Validation, metadata: ReportMetadata) -> str:
+        """Render report header."""
+        source_name = metadata.source_name or validation.source_id
+        generated = metadata.generated_at.strftime("%Y-%m-%d %H:%M:%S UTC")
+
+        return f"""# {metadata.title}
+
+**Source:** {source_name}
+**Generated:** {generated}
+**Validation ID:** `{validation.id}`"""
+
+    def _render_status_badge(self, validation: Validation) -> str:
+        """Render status badge."""
+        if validation.passed:
+            badge = "![Status](https://img.shields.io/badge/Status-PASSED-success)"
+        else:
+            badge = "![Status](https://img.shields.io/badge/Status-FAILED-critical)"
+
+        return badge
+
+    def _render_summary(self, validation: Validation) -> str:
+        """Render validation summary."""
+        return f"""## Summary
+
+| Metric | Count |
+|--------|-------|
+| Total Issues | {validation.total_issues or 0} |
+| Critical | {validation.critical_issues or 0} |
+| High | {validation.high_issues or 0} |
+| Medium | {validation.medium_issues or 0} |
+| Low | {validation.low_issues or 0} |"""
+
+    def _render_statistics(self, validation: Validation) -> str:
+        """Render data statistics."""
+        duration = validation.duration_ms
+        duration_str = f"{duration / 1000:.2f}s" if duration else "N/A"
+
+        started = (
+            validation.started_at.strftime("%Y-%m-%d %H:%M:%S")
+            if validation.started_at
+            else "N/A"
+        )
+        completed = (
+            validation.completed_at.strftime("%Y-%m-%d %H:%M:%S")
+            if validation.completed_at
+            else "N/A"
+        )
+
+        row_count = f"{validation.row_count:,}" if validation.row_count else "N/A"
+
+        return f"""## Statistics
+
+| Metric | Value |
+|--------|-------|
+| Row Count | {row_count} |
+| Column Count | {validation.column_count or 'N/A'} |
+| Duration | {duration_str} |
+| Status | {validation.status} |
+| Started At | {started} |
+| Completed At | {completed} |"""
+
+    def _render_issues_table(
+        self, issues: list[dict[str, Any]], include_samples: bool
+    ) -> str:
+        """Render issues as Markdown table."""
+        if not issues:
+            return """## Issues
+
+No issues found. All validations passed."""
+
+        # Build table header
+        headers = ["Column", "Issue Type", "Severity", "Count", "Details"]
+        if include_samples:
+            headers.append("Samples")
+
+        header_row = "| " + " | ".join(headers) + " |"
+        separator = "| " + " | ".join(["---"] * len(headers)) + " |"
+
+        # Build rows
+        rows = []
+        for issue in issues:
+            severity = issue.get("severity", "medium")
+            severity_badge = self._get_severity_badge(severity)
+
+            row = [
+                f"`{issue.get('column', 'N/A')}`",
+                issue.get("issue_type", "Unknown"),
+                severity_badge,
+                str(issue.get("count", 0)),
+                (issue.get("details", "") or "")[:50],
+            ]
+
+            if include_samples:
+                samples = issue.get("sample_values", [])
+                samples_str = ", ".join(str(v)[:20] for v in samples[:3])
+                if samples_str:
+                    samples_str = f"`{samples_str}`"
+                row.append(samples_str or "-")
+
+            rows.append("| " + " | ".join(row) + " |")
+
+        return f"""## Issues ({len(issues)})
+
+{header_row}
+{separator}
+{chr(10).join(rows)}"""
+
+    def _get_severity_badge(self, severity: str) -> str:
+        """Get Markdown badge for severity level.
+
+        Args:
+            severity: Severity level.
+
+        Returns:
+            Markdown badge string.
+        """
+        colors = {
+            "critical": "critical",
+            "high": "orange",
+            "medium": "yellow",
+            "low": "blue",
+        }
+        color = colors.get(severity.lower(), "lightgrey")
+
+        if self._flavor == "github":
+            return f"![{severity}](https://img.shields.io/badge/{severity}-{color})"
+        return f"**{severity.upper()}**"
+
+    def _render_footer(self, metadata: ReportMetadata) -> str:
+        """Render report footer."""
+        return """---
+
+*Generated by [Truthound Dashboard](https://github.com/truthound/truthound-dashboard)*"""