haoline 0.3.0__py3-none-any.whl

haoline/pdf_generator.py

@@ -0,0 +1,265 @@
+# Copyright (c) 2025 HaoLine Contributors
+# SPDX-License-Identifier: MIT
+
+"""
+PDF generation for HaoLine using Playwright.
+
+This module provides PDF generation from HTML reports using Playwright,
+which renders the HTML with a real browser engine for high-quality output.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import pathlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .report import InspectionReport
+
+# Check for Playwright availability
+_HAS_PLAYWRIGHT = False
+try:
+    from playwright.async_api import async_playwright
+
+    _HAS_PLAYWRIGHT = True
+except ImportError:
+    pass
+
+
+def is_available() -> bool:
+    """Check if Playwright is available for PDF generation."""
+    return _HAS_PLAYWRIGHT
+
+
+class PDFGenerator:
+    """
+    Generate PDF reports from HTML using Playwright.
+
+    Playwright provides high-quality PDF rendering using Chromium,
+    ensuring consistent output across platforms.
+    """
+
+    def __init__(
+        self,
+        logger: logging.Logger | None = None,
+        page_format: str = "A4",
+        landscape: bool = False,
+        print_background: bool = True,
+        margin_top: str = "20mm",
+        margin_bottom: str = "20mm",
+        margin_left: str = "15mm",
+        margin_right: str = "15mm",
+    ):
+        """
+        Initialize PDF generator.
+
+        Args:
+            logger: Logger instance
+            page_format: Page format (A4, Letter, Legal, etc.)
+            landscape: Use landscape orientation
+            print_background: Include background colors/images
+            margin_top: Top margin (CSS units)
+            margin_bottom: Bottom margin (CSS units)
+            margin_left: Left margin (CSS units)
+            margin_right: Right margin (CSS units)
+        """
+        self.logger = logger or logging.getLogger("haoline.pdf")
+        self.page_format = page_format
+        self.landscape = landscape
+        self.print_background = print_background
+        self.margin = {
+            "top": margin_top,
+            "bottom": margin_bottom,
+            "left": margin_left,
+            "right": margin_right,
+        }
+
+    async def _generate_pdf_async(
+        self,
+        html_content: str,
+        output_path: pathlib.Path,
+    ) -> bool:
+        """
+        Async implementation of PDF generation.
+
+        Args:
+            html_content: HTML string to convert
+            output_path: Path for output PDF
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if not _HAS_PLAYWRIGHT:
+            self.logger.error(
+                "Playwright not installed. Install with: pip install playwright && playwright install chromium"
+            )
+            return False
+
+        try:
+            async with async_playwright() as p:
+                # Launch headless Chromium
+                browser = await p.chromium.launch(headless=True)
+                page = await browser.new_page()
+
+                # Set the HTML content
+                await page.set_content(html_content, wait_until="networkidle")
+
+                # Add custom CSS for better PDF rendering with smart page breaks
+                await page.add_style_tag(
+                    content="""@media print {
+body { -webkit-print-color-adjust: exact !important; print-color-adjust: exact !important; }
+.no-print, button, .toggle-btn, .search-box { display: none !important; }
+pre, code { white-space: pre-wrap !important; word-wrap: break-word !important; max-width: 100% !important; overflow-wrap: break-word !important; }
+p, li { orphans: 3; widows: 3; }
+h1, h2, h3, h4, h5, h6 { page-break-after: avoid !important; break-after: avoid !important; }
+section { page-break-inside: avoid; break-inside: avoid; }
+.kv-cache, .memory-breakdown, .visualizations, .graph-section, .layer-summary, .architecture, .hardware, .risks, .batch-scaling, .resolution-scaling { page-break-before: always !important; break-before: page !important; }
+.executive-summary, .metrics-cards, .param-details, .dataset-info, .system-requirements { page-break-inside: avoid !important; break-inside: avoid !important; }
+table { page-break-inside: avoid !important; break-inside: avoid !important; }
+tr { page-break-inside: avoid !important; break-inside: avoid !important; }
+figure, .chart-container, .visualization-item { page-break-inside: avoid !important; break-inside: avoid !important; }
+img { page-break-inside: avoid !important; break-inside: avoid !important; max-width: 100% !important; height: auto !important; }
+.metric-card, .card { page-break-inside: avoid !important; break-inside: avoid !important; }
+.risk-item, .risk-signal { page-break-inside: avoid !important; break-inside: avoid !important; }
+.comparison-table, .variant-table { page-break-inside: avoid !important; }
+.engine-panel, .summary-panel { page-break-inside: avoid !important; break-inside: avoid !important; }
+.recommendation, .calibration-rec { page-break-inside: avoid !important; break-inside: avoid !important; }
+}"""
+                )
+
+                # Wait for any images to load
+                await page.wait_for_load_state("networkidle")
+
+                # Generate PDF
+                await page.pdf(
+                    path=str(output_path),
+                    format=self.page_format,
+                    landscape=self.landscape,
+                    print_background=self.print_background,
+                    margin=self.margin,
+                    display_header_footer=True,
+                    header_template='<div style="font-size: 9px; color: #666; width: 100%; text-align: center; padding: 5px 0;">HaoLine Report</div>',
+                    footer_template='<div style="font-size: 9px; color: #666; width: 100%; text-align: center; padding: 5px 0;"><span class="pageNumber"></span> / <span class="totalPages"></span></div>',
+                )
+
+                await browser.close()
+                return True
+
+        except Exception as e:
+            self.logger.error(f"PDF generation failed: {e}")
+            return False
+
+    def generate_from_html(
+        self,
+        html_content: str,
+        output_path: pathlib.Path,
+    ) -> bool:
+        """
+        Generate PDF from HTML content.
+
+        Args:
+            html_content: HTML string to convert
+            output_path: Path for output PDF
+
+        Returns:
+            True if successful, False otherwise
+        """
+        output_path = pathlib.Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        self.logger.info(f"Generating PDF: {output_path}")
+
+        # Run async function
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        return loop.run_until_complete(self._generate_pdf_async(html_content, output_path))
+
+    def generate_from_html_file(
+        self,
+        html_path: pathlib.Path,
+        output_path: pathlib.Path,
+    ) -> bool:
+        """
+        Generate PDF from an HTML file.
+
+        Args:
+            html_path: Path to HTML file
+            output_path: Path for output PDF
+
+        Returns:
+            True if successful, False otherwise
+        """
+        html_path = pathlib.Path(html_path)
+        if not html_path.exists():
+            self.logger.error(f"HTML file not found: {html_path}")
+            return False
+
+        html_content = html_path.read_text(encoding="utf-8")
+        return self.generate_from_html(html_content, output_path)
+
+    def generate_from_report(
+        self,
+        report: InspectionReport,
+        output_path: pathlib.Path,
+        image_paths: dict[str, pathlib.Path] | None = None,
+    ) -> bool:
+        """
+        Generate PDF directly from an InspectionReport.
+
+        Args:
+            report: InspectionReport instance
+            output_path: Path for output PDF
+            image_paths: Optional dict of image paths for visualizations
+
+        Returns:
+            True if successful, False otherwise
+        """
+        # Generate HTML with embedded images (for PDF, all images are base64)
+        html_content = report.to_html(image_paths=image_paths)
+        return self.generate_from_html(html_content, output_path)
+
+
+async def generate_pdf_async(
+    html_content: str,
+    output_path: pathlib.Path,
+    **kwargs,
+) -> bool:
+    """
+    Convenience async function for PDF generation.
+
+    Args:
+        html_content: HTML string to convert
+        output_path: Path for output PDF
+        **kwargs: Additional options for PDFGenerator
+
+    Returns:
+        True if successful, False otherwise
+    """
+    generator = PDFGenerator(**kwargs)
+    return await generator._generate_pdf_async(html_content, output_path)
+
+
+def generate_pdf(
+    html_content: str,
+    output_path: pathlib.Path,
+    **kwargs,
+) -> bool:
+    """
+    Convenience function for PDF generation.
+
+    Args:
+        html_content: HTML string to convert
+        output_path: Path for output PDF
+        **kwargs: Additional options for PDFGenerator
+
+    Returns:
+        True if successful, False otherwise
+    """
+    generator = PDFGenerator(**kwargs)
+    return generator.generate_from_html(html_content, output_path)

haoline/privacy.py

@@ -0,0 +1,250 @@
+"""
+HaoLine Privacy Utilities.
+
+Functions for redacting sensitive information from model analysis reports.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def create_name_mapping(names: set[str]) -> dict[str, str]:
+    """
+    Create a deterministic mapping from original names to anonymized names.
+
+    Args:
+        names: Set of original names to anonymize.
+
+    Returns:
+        Dictionary mapping original names to anonymized names.
+    """
+    # Sort for deterministic ordering
+    sorted_names = sorted(names)
+
+    mapping: dict[str, str] = {}
+    counters: dict[str, int] = {}
+
+    for name in sorted_names:
+        # Determine the prefix based on naming patterns
+        prefix = _infer_prefix(name)
+        count = counters.get(prefix, 0) + 1
+        counters[prefix] = count
+        mapping[name] = f"{prefix}_{count:04d}"
+
+    return mapping
+
+
+def _infer_prefix(name: str) -> str:
+    """Infer an anonymized prefix based on the original name pattern."""
+    name_lower = name.lower()
+
+    # Common ONNX/model patterns
+    if any(x in name_lower for x in ["conv", "cnn"]):
+        return "conv"
+    if any(x in name_lower for x in ["bn", "batchnorm", "batch_norm"]):
+        return "bn"
+    if any(x in name_lower for x in ["relu", "gelu", "silu", "activation"]):
+        return "act"
+    if any(x in name_lower for x in ["fc", "linear", "dense", "gemm", "matmul"]):
+        return "linear"
+    if any(x in name_lower for x in ["attention", "attn", "self_attn"]):
+        return "attn"
+    if any(x in name_lower for x in ["embed", "embedding"]):
+        return "embed"
+    if any(x in name_lower for x in ["norm", "layernorm", "layer_norm"]):
+        return "norm"
+    if any(x in name_lower for x in ["pool", "avgpool", "maxpool"]):
+        return "pool"
+    if any(x in name_lower for x in ["reshape", "view", "flatten"]):
+        return "reshape"
+    if any(x in name_lower for x in ["concat", "cat"]):
+        return "concat"
+    if any(x in name_lower for x in ["add", "sum"]):
+        return "add"
+    if any(x in name_lower for x in ["mul", "multiply"]):
+        return "mul"
+    if any(x in name_lower for x in ["split", "chunk"]):
+        return "split"
+    if any(x in name_lower for x in ["transpose", "permute"]):
+        return "transpose"
+    if any(x in name_lower for x in ["weight", "bias", "param"]):
+        return "param"
+    if any(x in name_lower for x in ["input", "inp"]):
+        return "input"
+    if any(x in name_lower for x in ["output", "out"]):
+        return "output"
+
+    # Default
+    return "node"
+
+
+def collect_names_from_dict(data: dict[str, Any]) -> set[str]:
+    """
+    Recursively collect all string values that look like layer/tensor names.
+
+    Args:
+        data: Dictionary to scan (typically from report.to_dict()).
+
+    Returns:
+        Set of potential names to anonymize.
+    """
+    names: set[str] = set()
+    _collect_names_recursive(data, names)
+    return names
+
+
+def _collect_names_recursive(obj: Any, names: set[str], key: str = "") -> None:
+    """Recursively collect names from nested structures."""
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            # Keys that typically contain names
+            if k in (
+                "name",
+                "node_name",
+                "layer_name",
+                "tensor_name",
+                "op_name",
+                "input_name",
+                "output_name",
+            ):
+                if isinstance(v, str):
+                    names.add(v)
+            # Keys that map names to values
+            elif k in (
+                "by_node",
+                "by_name",
+                "input_shapes",
+                "output_shapes",
+                "shared_weights",
+            ):
+                if isinstance(v, dict):
+                    names.update(v.keys())
+            # Lists like largest_weights, largest_activations
+            elif k in ("largest_weights", "largest_activations"):
+                if isinstance(v, list):
+                    for item in v:
+                        if isinstance(item, dict) and "name" in item:
+                            names.add(item["name"])
+                        elif isinstance(item, (list, tuple)) and len(item) >= 1:
+                            if isinstance(item[0], str):
+                                names.add(item[0])
+
+            _collect_names_recursive(v, names, k)
+
+    elif isinstance(obj, list):
+        for item in obj:
+            _collect_names_recursive(item, names, key)
+
+
+def redact_dict(
+    data: dict[str, Any],
+    mapping: dict[str, str],
+) -> dict[str, Any]:
+    """
+    Apply name redaction to a dictionary (typically from report.to_dict()).
+
+    Args:
+        data: Dictionary to redact.
+        mapping: Mapping from original names to anonymized names.
+
+    Returns:
+        New dictionary with names replaced.
+    """
+    result = _redact_recursive(data, mapping)
+    # _redact_recursive always returns a dict when given a dict
+    assert isinstance(result, dict)
+    return result
+
+
+def _redact_recursive(obj: Any, mapping: dict[str, str]) -> Any:
+    """Recursively apply redaction to nested structures."""
+    if isinstance(obj, dict):
+        result = {}
+        for k, v in obj.items():
+            # Replace keys if they're in the mapping (for by_node, etc.)
+            new_key = mapping.get(k, k) if isinstance(k, str) else k
+            result[new_key] = _redact_recursive(v, mapping)
+        return result
+
+    elif isinstance(obj, list):
+        return [_redact_recursive(item, mapping) for item in obj]
+
+    elif isinstance(obj, str):
+        # Replace string values if they match a name
+        return mapping.get(obj, obj)
+
+    else:
+        return obj
+
+
+def create_summary_only_dict(data: dict[str, Any]) -> dict[str, Any]:
+    """
+    Strip a report dictionary to summary-only (no per-layer details).
+
+    Args:
+        data: Full report dictionary.
+
+    Returns:
+        Stripped dictionary with only aggregate stats.
+    """
+    # Fields to keep (aggregate only)
+    keep_fields = {
+        "metadata",
+        "generated_at",
+        "autodoc_version",
+        "architecture_type",
+    }
+
+    # Nested fields to summarize
+    summary_fields = {
+        "graph_summary": ["num_nodes", "num_inputs", "num_outputs", "op_type_counts"],
+        "param_counts": ["total", "trainable", "non_trainable", "is_quantized"],
+        "flop_counts": ["total"],
+        "memory_estimates": ["weights_bytes", "activations_bytes", "total_bytes"],
+    }
+
+    result: dict[str, Any] = {}
+
+    # Copy allowed fields
+    for field in keep_fields:
+        if field in data:
+            result[field] = data[field]
+
+    # Extract summary from nested fields
+    for field, allowed_keys in summary_fields.items():
+        if field in data and data[field]:
+            result[field] = {k: data[field][k] for k in allowed_keys if k in data[field]}
+
+    # Add aggregate risk info without details
+    if "risk_signals" in data and data["risk_signals"]:
+        result["risk_summary"] = {
+            "total_risks": len(data["risk_signals"]),
+            "high": sum(1 for r in data["risk_signals"] if r.get("severity") == "high"),
+            "medium": sum(1 for r in data["risk_signals"] if r.get("severity") == "medium"),
+            "low": sum(1 for r in data["risk_signals"] if r.get("severity") == "low"),
+        }
+
+    # Add detected block counts without names
+    if "detected_blocks" in data and data["detected_blocks"]:
+        block_counts: dict[str, int] = {}
+        for block in data["detected_blocks"]:
+            block_type = block.get("block_type", "unknown")
+            block_counts[block_type] = block_counts.get(block_type, 0) + 1
+        result["detected_block_counts"] = block_counts
+
+    # Add hardware summary without per-op breakdown
+    if "hardware_estimates" in data and data["hardware_estimates"]:
+        hw = data["hardware_estimates"]
+        result["hardware_estimates"] = {
+            k: hw[k]
+            for k in [
+                "latency_ms",
+                "throughput_samples_per_sec",
+                "estimated_power_w",
+                "bottleneck_summary",
+            ]
+            if k in hw
+        }
+
+    return result