oscura 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

oscura/reporting/index.py

@@ -312,26 +312,61 @@ class IndexGenerator:
 
         Requirements:
         """
-        # Extract timestamp properly from output_dir name
-        # Format is: YYYYMMDD_HHMMSS_name_analysis
-        dir_name = result.output_dir.name
-        timestamp = "N/A"
-        if "_" in dir_name:
-            parts = dir_name.split("_")
-            if len(parts) >= 2:
-                date_part = parts[0]  # YYYYMMDD
-                time_part = parts[1]  # HHMMSS
-                if len(date_part) == 8 and len(time_part) == 6:
-                    try:
-                        timestamp = (
-                            f"{date_part[:4]}-{date_part[4:6]}-{date_part[6:8]} "
-                            f"{time_part[:2]}:{time_part[2:4]}:{time_part[4:6]}"
-                        )
-                    except (IndexError, ValueError):
-                        timestamp = f"{date_part}_{time_part}"
-
-        # Basic metadata
-        context: dict[str, Any] = {
+        # Extract timestamp and basic metadata
+        timestamp = self._extract_timestamp(result.output_dir.name)
+        context = self._build_basic_metadata(result, timestamp)
+
+        # Build domain information
+        domains = self._build_domains_info(result)
+        context["domains"] = domains
+
+        # Build error information
+        if result.errors:
+            context["errors"] = self._build_errors_info(result.errors)
+
+        return context
+
+    def _extract_timestamp(self, dir_name: str) -> str:
+        """Extract formatted timestamp from directory name.
+
+        Args:
+            dir_name: Directory name in format YYYYMMDD_HHMMSS_name_analysis.
+
+        Returns:
+            Formatted timestamp string.
+        """
+        if "_" not in dir_name:
+            return "N/A"
+
+        parts = dir_name.split("_")
+        if len(parts) < 2:
+            return "N/A"
+
+        date_part = parts[0]  # YYYYMMDD
+        time_part = parts[1]  # HHMMSS
+
+        if len(date_part) == 8 and len(time_part) == 6:
+            try:
+                return (
+                    f"{date_part[:4]}-{date_part[4:6]}-{date_part[6:8]} "
+                    f"{time_part[:2]}:{time_part[2:4]}:{time_part[4:6]}"
+                )
+            except (IndexError, ValueError):
+                return f"{date_part}_{time_part}"
+
+        return "N/A"
+
+    def _build_basic_metadata(self, result: AnalysisResult, timestamp: str) -> dict[str, Any]:
+        """Build basic metadata context.
+
+        Args:
+            result: Analysis result.
+            timestamp: Formatted timestamp.
+
+        Returns:
+            Dictionary with basic metadata.
+        """
+        return {
             "title": "Analysis Report",
             "input_name": result.input_file or "In-Memory Data",
             "input_size": self._format_size(result.input_file),
@@ -345,44 +380,23 @@ class IndexGenerator:
             "has_errors": len(result.errors) > 0,
         }
 
-        # Build domain information
-        # domain_summaries contains {AnalysisDomain: {func_name: result, ...}}
+    def _build_domains_info(self, result: AnalysisResult) -> list[dict[str, Any]]:
+        """Build domain information list.
+
+        Args:
+            result: Analysis result.
+
+        Returns:
+            List of domain dictionaries.
+        """
         domains: list[dict[str, Any]] = []
+
         for domain, domain_results in result.domain_summaries.items():
-            # Count successful analyses in this domain
-            # domain_results is a dict of {function_name: result_value}
             analyses_count = len(domain_results) if isinstance(domain_results, dict) else 0
 
-            # Find plots for this domain
-            domain_plots = []
-            if result.plot_paths:
-                domain_id = domain.value
-                for plot_path in result.plot_paths:
-                    # Check if plot belongs to this domain
-                    plot_str = str(plot_path)
-                    if f"/{domain_id}/" in plot_str or plot_str.startswith(domain_id):
-                        domain_plots.append(
-                            {
-                                "title": plot_path.stem.replace("_", " ").title(),
-                                "path": str(plot_path.name)
-                                if plot_path.parent == result.output_dir
-                                else str(plot_path.relative_to(result.output_dir)),
-                                "filename": plot_path.name,
-                            }
-                        )
-
-            # Find data files for this domain
-            domain_data_files = []
-            domain_dir = result.domain_dirs.get(domain)
-            if domain_dir and domain_dir.exists():
-                for data_file in domain_dir.glob("*.json"):
-                    domain_data_files.append(
-                        {
-                            "filename": data_file.name,
-                            "path": str(data_file.relative_to(result.output_dir)),
-                            "format": "JSON",
-                        }
-                    )
+            # Find plots and data files for this domain
+            domain_plots = self._find_domain_plots(result, domain)
+            domain_data_files = self._find_domain_data_files(result, domain)
 
             # Build key findings from results
             key_findings = self._extract_key_findings(domain_results)
@@ -399,22 +413,80 @@ class IndexGenerator:
             }
             domains.append(domain_data)
 
-        context["domains"] = domains
+        return domains
 
-        # Build error information
-        if result.errors:
-            errors: list[dict[str, Any]] = []
-            for error in result.errors:
-                errors.append(
+    def _find_domain_plots(self, result: AnalysisResult, domain: Any) -> list[dict[str, Any]]:
+        """Find plots for a specific domain.
+
+        Args:
+            result: Analysis result.
+            domain: Analysis domain.
+
+        Returns:
+            List of plot dictionaries.
+        """
+        domain_plots: list[dict[str, Any]] = []
+        if not result.plot_paths:
+            return domain_plots
+
+        domain_id = domain.value
+        for plot_path in result.plot_paths:
+            plot_str = str(plot_path)
+            if f"/{domain_id}/" in plot_str or plot_str.startswith(domain_id):
+                domain_plots.append(
                     {
-                        "domain": error.domain.value,
-                        "analysis_name": error.function,
-                        "error_message": error.error_message,
+                        "title": plot_path.stem.replace("_", " ").title(),
+                        "path": str(plot_path.name)
+                        if plot_path.parent == result.output_dir
+                        else str(plot_path.relative_to(result.output_dir)),
+                        "filename": plot_path.name,
                     }
                 )
-            context["errors"] = errors
 
-        return context
+        return domain_plots
+
+    def _find_domain_data_files(self, result: AnalysisResult, domain: Any) -> list[dict[str, Any]]:
+        """Find data files for a specific domain.
+
+        Args:
+            result: Analysis result.
+            domain: Analysis domain.
+
+        Returns:
+            List of data file dictionaries.
+        """
+        domain_data_files = []
+        domain_dir = result.domain_dirs.get(domain)
+
+        if domain_dir and domain_dir.exists():
+            for data_file in domain_dir.glob("*.json"):
+                domain_data_files.append(
+                    {
+                        "filename": data_file.name,
+                        "path": str(data_file.relative_to(result.output_dir)),
+                        "format": "JSON",
+                    }
+                )
+
+        return domain_data_files
+
+    def _build_errors_info(self, errors: list[Any]) -> list[dict[str, Any]]:
+        """Build error information list.
+
+        Args:
+            errors: List of error objects.
+
+        Returns:
+            List of error dictionaries.
+        """
+        return [
+            {
+                "domain": error.domain.value,
+                "analysis_name": error.function,
+                "error_message": error.error_message,
+            }
+            for error in errors
+        ]
 
     def _extract_key_findings(self, domain_results: dict[str, Any]) -> list[str]:
         """Extract key findings from domain results for display.

oscura/reporting/output.py

@@ -11,6 +11,7 @@ from typing import Any
 
 import numpy as np
 import yaml
+from numpy.typing import NDArray
 
 from oscura.reporting.config import AnalysisDomain
 
@@ -39,88 +40,178 @@ def _sanitize_for_serialization(obj: Any, max_depth: int = 10) -> Any:
         # Don't sanitize Oscura types - let the JSONEncoder handle them
         if isinstance(obj, WaveformTrace | DigitalTrace | TraceMetadata):
             return obj
+
+        # Dispatch to type-specific sanitizers
         if isinstance(obj, dict):
-            # Sanitize both keys and values, convert non-string keys to strings
-            sanitized = {}
-            for k, v in obj.items():
-                # Convert bytes keys to hex strings
-                if isinstance(k, bytes):
-                    k = f"0x{k.hex()}"
-                # Convert other non-string keys to strings
-                elif not isinstance(k, str | int | float | bool | type(None)):
-                    k = str(k)
-                sanitized[k] = _sanitize_for_serialization(v, max_depth - 1)
-            return sanitized
+            return _sanitize_dict(obj, max_depth)
         elif isinstance(obj, list | tuple):
-            return [_sanitize_for_serialization(item, max_depth - 1) for item in obj]
+            return _sanitize_sequence(obj, max_depth)
         elif isinstance(obj, types.GeneratorType):
-            # Convert generators to lists, but catch errors
-            try:
-                items = list(obj)
-                return [_sanitize_for_serialization(item, max_depth - 1) for item in items]
-            except Exception:
-                # Return None for incompatible generators (cleaner than error string)
-                return None
+            return _sanitize_generator(obj, max_depth)
         elif isinstance(obj, np.ndarray):
-            # Limit large arrays
-            if obj.size > 10000:
-                return f"<ndarray shape={obj.shape} dtype={obj.dtype}>"
-            return obj.tolist()
-        elif isinstance(obj, np.generic):
-            # Catch all numpy scalar types (int, float, complex, bool, str, etc.)
-            # This includes np.integer, np.floating, np.bool_, np.complexfloating, etc.
-            return obj.item()
-        elif isinstance(obj, np.integer | np.floating):
-            # Redundant but kept for clarity
-            return obj.item()
-        elif isinstance(obj, np.bool_):
-            # Redundant but kept for clarity
-            return bool(obj)
+            return _sanitize_ndarray(obj)
+        elif isinstance(obj, np.generic | np.integer | np.floating | np.bool_):
+            return _sanitize_numpy_scalar(obj)
         elif isinstance(obj, float):
-            # Handle Python float inf/nan (not caught by JSONEncoder.default)
-            import math
-
-            if math.isinf(obj) or math.isnan(obj):
-                return None
-            return obj
+            return _sanitize_float(obj)
         elif isinstance(obj, complex):
-            # Handle complex numbers with inf/nan components
-            import math
-
-            if (
-                math.isinf(obj.real)
-                or math.isnan(obj.real)
-                or math.isinf(obj.imag)
-                or math.isnan(obj.imag)
-            ):
-                return None
-            return {"real": obj.real, "imag": obj.imag}
+            return _sanitize_complex(obj)
         elif isinstance(obj, bytes):
-            # Limit large byte sequences
-            if len(obj) > 1000:
-                return f"<bytes len={len(obj)}>"
-            return obj.hex()
+            return _sanitize_bytes(obj)
         elif hasattr(obj, "__dict__") and not isinstance(obj, type):
-            # Convert dataclasses and objects to dicts
-            try:
-                return {
-                    k: _sanitize_for_serialization(v, max_depth - 1)
-                    for k, v in obj.__dict__.items()
-                }
-            except Exception:
-                return str(obj)
+            return _sanitize_object(obj, max_depth)
         elif callable(obj):
             return f"<callable: {getattr(obj, '__name__', str(obj))}>"
         else:
-            # Try to convert to string as last resort
-            try:
-                return obj
-            except Exception:
-                return str(obj)
+            return obj
+
     except Exception as e:
         return f"<error: {type(e).__name__}: {str(e)[:50]}>"
 
 
+def _sanitize_dict(obj: dict[Any, Any], max_depth: int) -> dict[Any, Any]:
+    """Sanitize dictionary for serialization.
+
+    Args:
+        obj: Dictionary to sanitize.
+        max_depth: Remaining recursion depth.
+
+    Returns:
+        Sanitized dictionary with string keys.
+    """
+    sanitized = {}
+    for k, v in obj.items():
+        # Convert bytes keys to hex strings
+        if isinstance(k, bytes):
+            k = f"0x{k.hex()}"
+        # Convert other non-string keys to strings
+        elif not isinstance(k, str | int | float | bool | type(None)):
+            k = str(k)
+        sanitized[k] = _sanitize_for_serialization(v, max_depth - 1)
+    return sanitized
+
+
+def _sanitize_sequence(obj: list[Any] | tuple[Any, ...], max_depth: int) -> list[Any]:
+    """Sanitize list or tuple for serialization.
+
+    Args:
+        obj: Sequence to sanitize.
+        max_depth: Remaining recursion depth.
+
+    Returns:
+        Sanitized list.
+    """
+    return [_sanitize_for_serialization(item, max_depth - 1) for item in obj]
+
+
+def _sanitize_generator(obj: Any, max_depth: int) -> list[Any] | None:
+    """Sanitize generator for serialization.
+
+    Args:
+        obj: Generator to sanitize.
+        max_depth: Remaining recursion depth.
+
+    Returns:
+        Sanitized list or None if generator fails.
+    """
+    try:
+        items = list(obj)
+        return [_sanitize_for_serialization(item, max_depth - 1) for item in items]
+    except Exception:
+        return None
+
+
+def _sanitize_ndarray(obj: NDArray[Any]) -> str | list[Any]:
+    """Sanitize numpy array for serialization.
+
+    Args:
+        obj: Numpy array to sanitize.
+
+    Returns:
+        String representation for large arrays, list for small arrays.
+    """
+    if obj.size > 10000:
+        return f"<ndarray shape={obj.shape} dtype={obj.dtype}>"
+    result: list[Any] = obj.tolist()
+    return result
+
+
+def _sanitize_numpy_scalar(obj: Any) -> Any:
+    """Sanitize numpy scalar types for serialization.
+
+    Args:
+        obj: Numpy scalar to sanitize.
+
+    Returns:
+        Python native type.
+    """
+    if isinstance(obj, np.bool_):
+        return bool(obj)
+    return obj.item()
+
+
+def _sanitize_float(obj: float) -> float | None:
+    """Sanitize Python float for serialization.
+
+    Args:
+        obj: Float to sanitize.
+
+    Returns:
+        Float or None if inf/nan.
+    """
+    import math
+
+    if math.isinf(obj) or math.isnan(obj):
+        return None
+    return obj
+
+
+def _sanitize_complex(obj: complex) -> dict[str, float] | None:
+    """Sanitize complex number for serialization.
+
+    Args:
+        obj: Complex number to sanitize.
+
+    Returns:
+        Dictionary with real/imag or None if inf/nan components.
+    """
+    import math
+
+    if math.isinf(obj.real) or math.isnan(obj.real) or math.isinf(obj.imag) or math.isnan(obj.imag):
+        return None
+    return {"real": obj.real, "imag": obj.imag}
+
+
+def _sanitize_bytes(obj: bytes) -> str:
+    """Sanitize bytes for serialization.
+
+    Args:
+        obj: Bytes to sanitize.
+
+    Returns:
+        Hex string or size placeholder for large sequences.
+    """
+    if len(obj) > 1000:
+        return f"<bytes len={len(obj)}>"
+    return obj.hex()
+
+
+def _sanitize_object(obj: Any, max_depth: int) -> dict[str, Any] | str:
+    """Sanitize generic object for serialization.
+
+    Args:
+        obj: Object to sanitize.
+        max_depth: Remaining recursion depth.
+
+    Returns:
+        Sanitized dictionary or string representation.
+    """
+    try:
+        return {k: _sanitize_for_serialization(v, max_depth - 1) for k, v in obj.__dict__.items()}
+    except Exception:
+        return str(obj)
+
+
 class OutputManager:
     """Manages output directory structure and file operations for analysis reports.
 

oscura/reporting/pdf.py

@@ -132,108 +132,73 @@ def generate_pdf_report(
 def _create_styles() -> dict[str, ParagraphStyle]:
     """Create PDF paragraph styles."""
     base_styles = getSampleStyleSheet()
-
-    # Create a new dict to hold our custom styles
-    styles: dict[str, ParagraphStyle] = {}
-
-    # Copy base styles we want to keep
-    styles["Normal"] = base_styles["Normal"]
-
-    # Title style (24pt) - override default
-    styles["Title"] = ParagraphStyle(
-        name="Title",
-        parent=base_styles["Normal"],
-        fontSize=24,
-        textColor=colors.HexColor("#2c3e50"),
-        spaceAfter=12,
-        alignment=1,  # Center
-        fontName="Helvetica-Bold",
-    )
-
-    # Heading styles. - override defaults
-    styles["Heading1"] = ParagraphStyle(
-        name="Heading1",
-        parent=base_styles["Normal"],
-        fontSize=18,
-        textColor=colors.HexColor("#2c3e50"),
-        spaceBefore=12,
-        spaceAfter=6,
-        fontName="Helvetica-Bold",
-    )
-
-    styles["Heading2"] = ParagraphStyle(
-        name="Heading2",
-        parent=base_styles["Normal"],
-        fontSize=14,
-        textColor=colors.HexColor("#34495e"),
-        spaceBefore=10,
-        spaceAfter=4,
-        fontName="Helvetica-Bold",
-    )
-
-    styles["Heading3"] = ParagraphStyle(
-        name="Heading3",
-        parent=base_styles["Normal"],
-        fontSize=12,
-        textColor=colors.HexColor("#34495e"),
-        spaceBefore=8,
-        spaceAfter=4,
-        fontName="Helvetica-Bold",
-    )
-
-    # Body text (10pt, serif, 1.5 line spacing)
-    styles["Body"] = ParagraphStyle(
-        name="Body",
-        parent=base_styles["Normal"],
-        fontSize=10,
-        leading=15,  # 1.5 line spacing
-        fontName="Times-Roman",
-    )
-
-    # Metadata style
-    styles["Metadata"] = ParagraphStyle(
-        name="Metadata",
-        parent=base_styles["Normal"],
-        fontSize=9,
-        textColor=colors.HexColor("#555555"),
-        fontName="Helvetica",
-    )
-
-    # TOC style
-    styles["TOC"] = ParagraphStyle(
-        name="TOC",
-        parent=base_styles["Normal"],
-        fontSize=10,
-        leftIndent=20,
-        spaceAfter=4,
-    )
-
-    # Pass/Fail styles with visual emphasis.
-    styles["Pass"] = ParagraphStyle(
-        name="Pass",
-        parent=base_styles["Normal"],
-        fontSize=10,
-        textColor=colors.HexColor("#27ae60"),
-        fontName="Helvetica-Bold",
-    )
-
-    styles["Fail"] = ParagraphStyle(
-        name="Fail",
-        parent=base_styles["Normal"],
-        fontSize=10,
-        textColor=colors.HexColor("#e74c3c"),
-        fontName="Helvetica-Bold",
-    )
-
-    styles["Warning"] = ParagraphStyle(
-        name="Warning",
-        parent=base_styles["Normal"],
-        fontSize=10,
-        textColor=colors.HexColor("#f39c12"),
-        fontName="Helvetica-Bold",
-    )
-
-    return styles
+    base = base_styles["Normal"]
+
+    return {
+        "Normal": base,
+        "Title": ParagraphStyle(
+            "Title",
+            base,
+            fontSize=24,
+            textColor=colors.HexColor("#2c3e50"),
+            spaceAfter=12,
+            alignment=1,
+            fontName="Helvetica-Bold",
+        ),
+        "Heading1": ParagraphStyle(
+            "Heading1",
+            base,
+            fontSize=18,
+            textColor=colors.HexColor("#2c3e50"),
+            spaceBefore=12,
+            spaceAfter=6,
+            fontName="Helvetica-Bold",
+        ),
+        "Heading2": ParagraphStyle(
+            "Heading2",
+            base,
+            fontSize=14,
+            textColor=colors.HexColor("#34495e"),
+            spaceBefore=10,
+            spaceAfter=4,
+            fontName="Helvetica-Bold",
+        ),
+        "Heading3": ParagraphStyle(
+            "Heading3",
+            base,
+            fontSize=12,
+            textColor=colors.HexColor("#34495e"),
+            spaceBefore=8,
+            spaceAfter=4,
+            fontName="Helvetica-Bold",
+        ),
+        "Body": ParagraphStyle("Body", base, fontSize=10, leading=15, fontName="Times-Roman"),
+        "Metadata": ParagraphStyle(
+            "Metadata", base, fontSize=9, textColor=colors.HexColor("#555555"), fontName="Helvetica"
+        ),
+        "TOC": ParagraphStyle("TOC", base, fontSize=10, leftIndent=20, spaceAfter=4),
+        "Pass": ParagraphStyle(
+            "Pass",
+            base,
+            fontSize=10,
+            textColor=colors.HexColor("#27ae60"),
+            fontName="Helvetica-Bold",
+        ),
+        "Fail": ParagraphStyle(
+            "Fail",
+            base,
+            fontSize=10,
+            textColor=colors.HexColor("#e74c3c"),
+            fontName="Helvetica-Bold",
+        ),
+        "Warning": ParagraphStyle(
+            "Warning",
+            base,
+            fontSize=10,
+            textColor=colors.HexColor("#f39c12"),
+            fontName="Helvetica-Bold",
+        ),
+    }
 
 
 def _format_metadata(report: Report) -> str: