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

oscura/reporting/chart_selection.py

@@ -22,6 +22,47 @@ if TYPE_CHECKING:
 ChartType = Literal["line", "scatter", "bar", "histogram", "heatmap", "pie", "spectrum"]
 
 
+def _should_use_pie_chart(data_shape: tuple[int, ...], data: NDArray[np.float64] | None) -> bool:
+    """Check if data is suitable for pie chart.
+
+    Args:
+        data_shape: Shape of data array
+        data: Optional data array
+
+    Returns:
+        True if pie chart is appropriate
+    """
+    if not (len(data_shape) > 0 and data_shape[0] <= 6 and data is not None):
+        return False
+
+    all_non_negative = np.all(data >= 0)
+    if not bool(all_non_negative):
+        return False
+
+    total = np.sum(data)
+    return bool(total > 0 and np.allclose(data / total * 100, data / total * 100))
+
+
+def _select_chart_by_shape(data_shape: tuple[int, ...]) -> ChartType:
+    """Select chart type based on data shape.
+
+    Args:
+        data_shape: Shape of data array
+
+    Returns:
+        Appropriate chart type
+    """
+    if len(data_shape) == 1:
+        return "bar" if data_shape[0] < 20 else "histogram"
+
+    if len(data_shape) == 2:
+        if data_shape[0] > 50 and data_shape[1] > 50:
+            return "heatmap"
+        return "scatter"
+
+    return "line"
+
+
 def auto_select_chart(
     data_type: str,
     data_shape: tuple[int, ...],
@@ -67,62 +108,33 @@ def auto_select_chart(
     References:
         REPORT-028: Automated Chart Type Selection
     """
-    # Time series → line plot
-    if data_type == "time_series":
-        return "line"
-
-    # Frequency data → spectrum plot (log scale)
-    if data_type == "frequency":
-        return "spectrum"
+    # Direct type mappings
+    type_map: dict[str, ChartType] = {
+        "time_series": "line",
+        "frequency": "spectrum",
+        "distribution": "histogram",
+        "correlation": "scatter",
+        "matrix": "heatmap",
+        "parts": "pie",
+    }
 
-    # Distribution → histogram or box plot
-    if data_type == "distribution":
-        return "histogram"
+    if data_type in type_map:
+        return type_map[data_type]
 
-    # Categorical comparison → bar chart
+    # Categorical with possible pie chart
     if data_type == "categorical":
-        # If very few categories, pie chart might be appropriate
-        if len(data_shape) > 0 and data_shape[0] <= 6 and data is not None and np.all(data >= 0):
-            # Check if data represents parts of a whole
-            total = np.sum(data)
-            if total > 0 and np.allclose(data / total * 100, data / total * 100):
-                return "pie"
+        if _should_use_pie_chart(data_shape, data):
+            return "pie"
         return "bar"
 
-    # Comparison (continuous) → scatter plot
+    # Comparison with size-based selection
     if data_type == "comparison":
-        # If 2D data with moderate size, scatter plot
         if len(data_shape) >= 2 and data_shape[0] < 10000:
             return "scatter"
-        # Large comparison data → bar chart
         return "bar"
 
-    # Correlation → scatter plot with potential regression
-    if data_type == "correlation":
-        return "scatter"
-
-    # 2D matrix → heatmap
-    if data_type == "matrix":
-        return "heatmap"
-
-    # Parts-to-whole → pie chart
-    if data_type == "parts":
-        return "pie"
-
     # Default based on shape
-    if len(data_shape) == 1:
-        # 1D data: histogram for distributions, bar for small sets
-        if data_shape[0] < 20:
-            return "bar"
-        return "histogram"
-    elif len(data_shape) == 2:
-        # 2D data: heatmap for square-ish matrices, scatter for point clouds
-        if data_shape[0] > 50 and data_shape[1] > 50:
-            return "heatmap"
-        return "scatter"
-
-    # Fallback to line plot
-    return "line"
+    return _select_chart_by_shape(data_shape)
 
 
 def recommend_chart_with_reasoning(

oscura/reporting/comparison.py

@@ -82,12 +82,33 @@ def _generate_comparison_summary(
     current: dict[str, Any],
 ) -> str:
     """Generate comparison summary."""
-    summary_parts = []
+    summary_parts: list[str] = []
 
-    # Count changes
     baseline_meas = baseline.get("measurements", {})
     current_meas = current.get("measurements", {})
 
+    changed, improved, degraded = _categorize_parameter_changes(baseline_meas, current_meas)
+
+    _add_parameter_change_summary(
+        summary_parts, baseline_meas, current_meas, changed, improved, degraded
+    )
+    _add_pass_rate_comparison(summary_parts, baseline, current)
+
+    return "\n".join(summary_parts)
+
+
+def _categorize_parameter_changes(
+    baseline_meas: dict[str, Any], current_meas: dict[str, Any]
+) -> tuple[list[str], list[str], list[str]]:
+    """Categorize parameter changes.
+
+    Args:
+        baseline_meas: Baseline measurements.
+        current_meas: Current measurements.
+
+    Returns:
+        Tuple of (changed, improved, degraded) parameter lists.
+    """
     all_params = set(baseline_meas.keys()) | set(current_meas.keys())
     changed_params = []
     improved_params = []
@@ -98,10 +119,9 @@ def _generate_comparison_summary(
         curr_val = current_meas.get(param, {}).get("value")
 
         if base_val is not None and curr_val is not None:
-            if abs(curr_val - base_val) / abs(base_val) > 0.05:  # >5% change
+            if abs(curr_val - base_val) / abs(base_val) > 0.05:
                 changed_params.append(param)
 
-                # Determine if improved or degraded
                 base_passed = baseline_meas.get(param, {}).get("passed", True)
                 curr_passed = current_meas.get(param, {}).get("passed", True)
 
@@ -110,22 +130,50 @@ def _generate_comparison_summary(
                 elif base_passed and not curr_passed:
                     degraded_params.append(param)
 
+    return changed_params, improved_params, degraded_params
+
+
+def _add_parameter_change_summary(
+    summary_parts: list[str],
+    baseline_meas: dict[str, Any],
+    current_meas: dict[str, Any],
+    changed: list[str],
+    improved: list[str],
+    degraded: list[str],
+) -> None:
+    """Add parameter change summary.
+
+    Args:
+        summary_parts: List to append to.
+        baseline_meas: Baseline measurements.
+        current_meas: Current measurements.
+        changed: Changed parameters.
+        improved: Improved parameters.
+        degraded: Degraded parameters.
+    """
+    all_params = set(baseline_meas.keys()) | set(current_meas.keys())
     summary_parts.append(f"Comparing {len(all_params)} parameter(s) between baseline and current.")
 
-    if changed_params:
-        summary_parts.append(f"\n{len(changed_params)} measurement(s) changed significantly (>5%).")
+    if changed:
+        summary_parts.append(f"\n{len(changed)} measurement(s) changed significantly (>5%).")
 
-    if improved_params:
-        summary_parts.append(
-            f"\n✓ {len(improved_params)} parameter(s) improved (failures → passes)."
-        )
+    if improved:
+        summary_parts.append(f"\n✓ {len(improved)} parameter(s) improved (failures → passes).")
+
+    if degraded:
+        summary_parts.append(f"\n✗ {len(degraded)} parameter(s) degraded (passes → failures).")
 
-    if degraded_params:
-        summary_parts.append(
-            f"\n✗ {len(degraded_params)} parameter(s) degraded (passes → failures)."
-        )
 
-    # Pass/fail comparison
+def _add_pass_rate_comparison(
+    summary_parts: list[str], baseline: dict[str, Any], current: dict[str, Any]
+) -> None:
+    """Add pass rate comparison.
+
+    Args:
+        summary_parts: List to append to.
+        baseline: Baseline results.
+        current: Current results.
+    """
     baseline_pass = baseline.get("pass_count", 0)
     baseline_total = baseline.get("total_count", 0)
     current_pass = current.get("pass_count", 0)
@@ -140,8 +188,6 @@ def _generate_comparison_summary(
             f"\nPass rate: {baseline_rate:.1f}% → {current_rate:.1f}% ({delta:+.1f}% change)"
         )
 
-    return "\n".join(summary_parts)
-
 
 def _create_changes_section(
     baseline: dict[str, Any],

oscura/reporting/content/executive.py

@@ -67,18 +67,61 @@ def generate_executive_summary(
     References:
         REPORT-004: Executive Summary Auto-Generation
     """
-    # Extract basic counts
+    # Extract counts and violations
+    pass_count, total_count, fail_count, overall_status = _extract_counts(results)
+    critical_violations = _extract_critical_violations(results)
+
+    # Build key findings
+    min_margin = results.get("min_margin")
+    key_findings = _build_key_findings(
+        critical_violations, results.get("violations", []), min_margin
+    )
+
+    # Build summary text
+    summary_text = _build_summary_text(
+        overall_status,
+        pass_count,
+        total_count,
+        fail_count,
+        min_margin,
+        critical_violations,
+        key_findings,
+        length,
+        max_findings,
+    )
+
+    return ExecutiveSummary(
+        overall_status=overall_status,
+        pass_count=pass_count,
+        total_count=total_count,
+        key_findings=key_findings[:max_findings],
+        critical_violations=[str(v) for v in critical_violations],
+        min_margin_pct=min_margin,
+        summary_text=summary_text,
+    )
+
+
+def _extract_counts(results: dict[str, Any]) -> tuple[int, int, int, bool]:
+    """Extract pass/fail counts from results."""
     pass_count = results.get("pass_count", 0)
     total_count = results.get("total_count", 0)
     fail_count = total_count - pass_count if total_count else 0
     overall_status = fail_count == 0
+    return pass_count, total_count, fail_count, overall_status
 
-    # Extract violations
+
+def _extract_critical_violations(results: dict[str, Any]) -> list[Any]:
+    """Extract critical violations from results."""
     violations = results.get("violations", [])
-    critical_violations = [v for v in violations if v.get("severity", "").lower() == "critical"]
+    return [v for v in violations if v.get("severity", "").lower() == "critical"]
+
 
-    # Extract key findings
+def _build_key_findings(
+    critical_violations: list[Any], violations: list[Any], min_margin: float | None
+) -> list[str]:
+    """Build key findings list."""
     key_findings: list[str] = []
+
     if critical_violations:
         key_findings.append(
             f"{len(critical_violations)} critical violation(s) require immediate attention"
@@ -86,42 +129,51 @@ def generate_executive_summary(
     elif violations:
         key_findings.append(f"{len(violations)} violation(s) detected")
 
-    # Add margin information
-    min_margin = results.get("min_margin")
     if min_margin is not None and min_margin < 20:
         status = "critical" if min_margin < 10 else "marginal"
         key_findings.append(f"Minimum margin is {min_margin:.1f}% ({status})")
 
-    # Build summary text in natural language
+    return key_findings
+
+
+def _build_summary_text(
+    overall_status: bool,
+    pass_count: int,
+    total_count: int,
+    fail_count: int,
+    min_margin: float | None,
+    critical_violations: list[Any],
+    key_findings: list[str],
+    length: Literal["short", "detailed"],
+    max_findings: int,
+) -> str:
+    """Build natural language summary text."""
+    # Use list + join for O(n) string building instead of O(n²) +=
+    text_parts: list[str] = []
+
+    # Base status message
     if overall_status and total_count > 0:
-        summary_text = f"All {pass_count} tests passed."
+        text_parts.append(f"All {pass_count} tests passed.")
         if min_margin is not None and min_margin > 20:
-            summary_text += f" Minimum margin: {min_margin:.1f}%."
+            text_parts.append(f" Minimum margin: {min_margin:.1f}%.")
     elif total_count > 0:
         pct = fail_count / total_count * 100
-        summary_text = f"{fail_count} of {total_count} tests failed ({pct:.0f}% failure rate)."
+        text_parts.append(f"{fail_count} of {total_count} tests failed ({pct:.0f}% failure rate).")
     else:
-        summary_text = "Analysis completed successfully."
+        text_parts.append("Analysis completed successfully.")
 
+    # Add critical violations warning
     if critical_violations:
-        summary_text += (
+        text_parts.append(
             f" Critical: {len(critical_violations)} violation(s) require immediate action."
         )
 
-    # Add detailed findings for detailed mode
+    # Add detailed findings if requested
     if length == "detailed" and key_findings:
-        summary_text += "\n\nKey Findings:\n"
-        summary_text += "\n".join(f"  - {finding}" for finding in key_findings[:max_findings])
+        text_parts.append("\n\nKey Findings:\n")
+        text_parts.append("\n".join(f"  - {finding}" for finding in key_findings[:max_findings]))
 
-    return ExecutiveSummary(
-        overall_status=overall_status,
-        pass_count=pass_count,
-        total_count=total_count,
-        key_findings=key_findings[:max_findings],
-        critical_violations=[str(v) for v in critical_violations],
-        min_margin_pct=min_margin,
-        summary_text=summary_text,
-    )
+    return "".join(text_parts)
 
 
 __all__ = ["ExecutiveSummary", "generate_executive_summary"]

oscura/reporting/core_formats/multi_format.py

@@ -151,27 +151,30 @@ def _render_html(report: Report, path: Path, **kwargs: Any) -> None:
 
 def _render_markdown(report: Report, path: Path, **kwargs: Any) -> None:
     """Render to Markdown."""
-    # Generate Markdown content
-    content = f"# {report.config.title}\n\n"
+    # Use list + join for O(n) string building instead of O(n²) +=
+    content_parts = [f"# {report.config.title}\n\n"]
 
     if hasattr(report.config, "author") and report.config.author:
-        content += f"**Author:** {report.config.author}  \n"
+        content_parts.append(f"**Author:** {report.config.author}  \n")
 
-    content += f"**Date:** {report.config.created.strftime('%Y-%m-%d')}\n\n"
+    content_parts.append(f"**Date:** {report.config.created.strftime('%Y-%m-%d')}\n\n")
 
-    # Add sections
+    # Add sections with list.append instead of += in loops
     for section in report.sections:
         if not section.visible:
             continue
 
-        content += f"{'#' * (section.level + 1)} {section.title}\n\n"
+        content_parts.append(f"{'#' * (section.level + 1)} {section.title}\n\n")
 
         if isinstance(section.content, str):
-            content += section.content + "\n\n"
+            content_parts.append(section.content)
+            content_parts.append("\n\n")
         elif isinstance(section.content, list):
             for item in section.content:
-                content += str(item) + "\n\n"
+                content_parts.append(str(item))
+                content_parts.append("\n\n")
 
+    content = "".join(content_parts)
     path.write_text(content)