fix: make PDF reports optional and robust in limited environments

Author: maskedsyntax

hashprep/reports/__init__.py

@@ -1 +1,2 @@
 from .generators import generate_report as generate_report
+from .generators import get_generators as get_generators

hashprep/reports/generators.py

@@ -7,20 +7,34 @@ def generate(self, summary, full=False, output_file=None):
         pass
 
 
-# Lazy loading report classes
 def _load_generators():
+    """
+    Lazily load report generators.
+
+    PDF generation relies on WeasyPrint and system libraries that may not be
+    available in all environments. We treat the PDF generator as optional and
+    only enable it when its dependencies import cleanly.
+    """
     from .html import HtmlReport
     from .json import JsonReport
     from .markdown import MarkdownReport
-    from .pdf import PdfReport
 
-    return {
+    generators = {
         "md": MarkdownReport(),
         "json": JsonReport(),
         "html": HtmlReport(),
-        "pdf": PdfReport(),
     }
 
+    try:
+        from .pdf import PdfReport  # type: ignore
+    except Exception:
+        # PDF generation is unavailable (missing WeasyPrint or system deps)
+        generators["pdf"] = None
+    else:
+        generators["pdf"] = PdfReport()
+
+    return generators
+
 
 # get generators dictionary
 def get_generators():
@@ -34,6 +48,16 @@ def generate_report(summary, format="md", full=False, output_file=None, theme="m
     if format not in generators:
         raise ValueError(f"Unsupported format: {format}")
 
-    if format in ["html", "pdf"]:
-        return generators[format].generate(summary, full, output_file, theme=theme)
+    if format == "pdf":
+        pdf_generator = generators.get("pdf")
+        if pdf_generator is None:
+            raise RuntimeError(
+                "PDF report generation is unavailable. "
+                "Install WeasyPrint and its system dependencies to enable PDF output."
+            )
+        return pdf_generator.generate(summary, full, output_file, theme=theme)
+
+    if format == "html":
+        return generators["html"].generate(summary, full, output_file, theme=theme)
+
     return generators[format].generate(summary, full, output_file)

tests/test_cli.py

@@ -10,6 +10,8 @@
 
 import pytest
 
+from hashprep.reports import get_generators
+
 
 @pytest.fixture
 def titanic_csv():
@@ -33,6 +35,10 @@ def run_cli(args, cwd=None):
     return result
 
 
+_GENERATORS = get_generators()
+_PDF_AVAILABLE = _GENERATORS.get("pdf") is not None
+
+
 class TestCLIScan:
     """Test 'hashprep scan' command."""
 
@@ -176,14 +182,20 @@ def test_report_pdf(self, titanic_csv, temp_output_dir):
         """Test PDF report generation."""
         result = run_cli(["report", titanic_csv, "--format", "pdf", "--full"], cwd=temp_output_dir)
 
-        assert result.returncode == 0
-        assert "train_hashprep_report.pdf" in result.stdout
+        if not _PDF_AVAILABLE:
+            # When PDF generation is unavailable, the CLI should exit non-zero
+            # with a clear error message propagated from generate_report.
+            assert result.returncode != 0
+            assert "PDF report generation is unavailable" in (result.stderr + result.stdout)
+        else:
+            assert result.returncode == 0
+            assert "train_hashprep_report.pdf" in result.stdout
 
-        report_file = os.path.join(temp_output_dir, "train_hashprep_report.pdf")
-        assert os.path.exists(report_file)
-        # Check PDF magic number
-        with open(report_file, "rb") as f:
-            assert f.read(4) == b"%PDF"
+            report_file = os.path.join(temp_output_dir, "train_hashprep_report.pdf")
+            assert os.path.exists(report_file)
+            # Check PDF magic number
+            with open(report_file, "rb") as f:
+                assert f.read(4) == b"%PDF"
 
     def test_report_with_code_generation(self, titanic_csv, temp_output_dir):
         """Test report with code generation."""
@@ -280,7 +292,12 @@ def test_full_workflow(self, titanic_csv, temp_output_dir):
         # Step 3: Generate all report formats
         for fmt in ["md", "json", "html", "pdf"]:
             result = run_cli(["report", titanic_csv, "--format", fmt, "--full"], cwd=temp_output_dir)
-            assert result.returncode == 0
+            if fmt == "pdf" and not _PDF_AVAILABLE:
+                # In environments without PDF support, CLI should fail cleanly
+                assert result.returncode != 0
+                assert "PDF report generation is unavailable" in (result.stderr + result.stdout)
+            else:
+                assert result.returncode == 0
 
         # Step 4: Generate code
         result = run_cli(["report", titanic_csv, "--with-code"], cwd=temp_output_dir)

tests/test_library_api.py

@@ -11,10 +11,14 @@
 import pytest
 
 from hashprep import DatasetAnalyzer
-from hashprep.reports import generate_report
+from hashprep.reports import generate_report, get_generators
 from hashprep.utils.sampling import SamplingConfig
 
 
+_GENERATORS = get_generators()
+_PDF_AVAILABLE = _GENERATORS.get("pdf") is not None
+
+
 @pytest.fixture
 def sample_dataframe():
     """Create a sample DataFrame for testing."""
@@ -226,6 +230,9 @@ def test_pdf_report(self, sample_dataframe):
             output_file = f.name
 
         try:
+            if not _PDF_AVAILABLE:
+                pytest.skip("PDF generation is unavailable in this environment")
+
             report = generate_report(summary, format="pdf", full=True, output_file=output_file)
 
             assert report is not None
@@ -394,6 +401,9 @@ def test_titanic_all_report_formats(self, titanic_csv):
                 output_file = f.name
 
             try:
+                if fmt == "pdf" and not _PDF_AVAILABLE:
+                    pytest.skip("PDF generation is unavailable in this environment")
+
                 if fmt == "html":
                     report = generate_report(summary, format=fmt, full=True, output_file=output_file, theme="minimal")
                 else: