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

oscura/reporting/argument_preparer.py

@@ -316,25 +316,72 @@ class ArgumentPreparer:
         kwargs: dict[str, Any] = {}
         data_length = len(raw_data) if hasattr(raw_data, "__len__") else 0
 
+        # Add window_size if needed
+        kwargs.update(self._add_window_size_param(params, sig, data_length, kwargs))
+
+        # Add min_width if needed
+        kwargs.update(self._add_min_width_param(params, sig, sample_rate, kwargs))
+
+        # Add max_width if needed
+        kwargs.update(self._add_max_width_param(params, sig, data_length, sample_rate, kwargs))
+
+        # Add threshold if needed
+        kwargs.update(self._add_threshold_param(params, sig, raw_data, kwargs))
+
+        # Add window_duration if needed
+        kwargs.update(
+            self._add_window_duration_param(params, sig, data_length, sample_rate, kwargs)
+        )
+
+        return kwargs
+
+    def _add_window_size_param(
+        self, params: list[str], sig: inspect.Signature, data_length: int, kwargs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Add window_size parameter."""
+        result = {}
         if "window_size" in params:
             if self._param_needs_value(sig, "window_size") and "window_size" not in kwargs:
                 window_size: Any = max(10, data_length // 10)
-                kwargs["window_size"] = window_size
-                logger.debug(f"Using auto-detected window_size: {kwargs['window_size']}")
+                result["window_size"] = window_size
+                logger.debug(f"Using auto-detected window_size: {window_size}")
+        return result
 
+    def _add_min_width_param(
+        self, params: list[str], sig: inspect.Signature, sample_rate: float, kwargs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Add min_width parameter."""
+        result = {}
         if "min_width" in params:
             if self._param_needs_value(sig, "min_width") and "min_width" not in kwargs:
                 min_width: Any = max(1e-9, 10.0 / sample_rate)
-                kwargs["min_width"] = min_width
-                logger.debug(f"Using auto-detected min_width: {kwargs['min_width']:.2e}s")
+                result["min_width"] = min_width
+                logger.debug(f"Using auto-detected min_width: {min_width:.2e}s")
+        return result
 
+    def _add_max_width_param(
+        self,
+        params: list[str],
+        sig: inspect.Signature,
+        data_length: int,
+        sample_rate: float,
+        kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Add max_width parameter."""
+        result = {}
         if "max_width" in params:
             if self._param_needs_value(sig, "max_width") and "max_width" not in kwargs:
                 total_duration = data_length / sample_rate if data_length > 0 else 1e-3
                 max_width: Any = min(1e-3, total_duration)
-                kwargs["max_width"] = max_width
-                logger.debug(f"Using auto-detected max_width: {kwargs['max_width']:.2e}s")
+                result["max_width"] = max_width
+                logger.debug(f"Using auto-detected max_width: {max_width:.2e}s")
+        return result
 
+    def _add_threshold_param(
+        self, params: list[str], sig: inspect.Signature, raw_data: Any, kwargs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Add threshold parameter."""
+        result = {}
         if "threshold" in params and "threshold" not in kwargs:
             param_info = sig.parameters.get("threshold")
             has_default = (
@@ -344,21 +391,29 @@ class ArgumentPreparer:
                 try:
                     if isinstance(raw_data, np.ndarray) and raw_data.size > 0:
                         threshold: Any = float(np.median(raw_data))
-                        kwargs["threshold"] = threshold
-                        logger.debug(f"Using auto-detected threshold: {kwargs['threshold']:.3f}")
+                        result["threshold"] = threshold
+                        logger.debug(f"Using auto-detected threshold: {threshold:.3f}")
                 except Exception as e:
                     logger.debug(f"Could not auto-detect threshold: {e}")
+        return result
 
+    def _add_window_duration_param(
+        self,
+        params: list[str],
+        sig: inspect.Signature,
+        data_length: int,
+        sample_rate: float,
+        kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Add window_duration parameter."""
+        result = {}
         if "window_duration" in params:
             if self._param_needs_value(sig, "window_duration") and "window_duration" not in kwargs:
                 total_duration = data_length / sample_rate if data_length > 0 else 1.0
                 window_duration: Any = min(1.0, total_duration / 10.0)
-                kwargs["window_duration"] = window_duration
-                logger.debug(
-                    f"Using auto-detected window_duration: {kwargs['window_duration']:.3f}s"
-                )
-
-        return kwargs
+                result["window_duration"] = window_duration
+                logger.debug(f"Using auto-detected window_duration: {window_duration:.3f}s")
+        return result
 
     def _param_needs_value(self, sig: inspect.Signature, param_name: str) -> bool:
         """Check if parameter needs a value (no default or default is None)."""

oscura/reporting/auto_report.py

@@ -102,7 +102,9 @@ class Report:
         """
         self.output_path = path
 
-        html_content = f"""<!DOCTYPE html>
+        # Use list + join for O(n) string building instead of O(n²) +=
+        html_parts = [
+            f"""<!DOCTYPE html>
 <html>
 <head>
     <meta charset="UTF-8">
@@ -155,26 +157,33 @@ class Report:
         <p><strong>Date:</strong> {self.metadata.date}</p>
         <p><strong>Author:</strong> {self.metadata.author}</p>
 """
+        ]
+
         if self.metadata.project:
-            html_content += f"        <p><strong>Project:</strong> {self.metadata.project}</p>\n"
+            html_parts.append(f"        <p><strong>Project:</strong> {self.metadata.project}</p>\n")
 
         if self.metadata.tags:
-            html_content += (
+            html_parts.append(
                 f"        <p><strong>Tags:</strong> {', '.join(self.metadata.tags)}</p>\n"
             )
 
-        html_content += "    </div>\n\n"
+        html_parts.append("    </div>\n\n")
 
+        # Build sections with list.append instead of += in loop
         for section in self.sections:
             if section in self.content:
                 section_title = section.replace("_", " ").title()
-                html_content += f"""    <div class="section">
+                html_parts.append(
+                    f"""    <div class="section">
         <h2>{section_title}</h2>
         <p>{self.content[section]}</p>
     </div>
 """
-        html_content += """</body>
-</html>"""
+                )
+
+        html_parts.append("</body>\n</html>")
+        html_content = "".join(html_parts)
+
         with open(path, "w") as f:
             f.write(html_content)
 
@@ -188,23 +197,30 @@ class Report:
         """
         self.output_path = path
 
-        md_content = f"# {self.metadata.title}\n\n"
-        md_content += f"**Date:** {self.metadata.date}  \n"
-        md_content += f"**Author:** {self.metadata.author}  \n"
+        # Use list + join for O(n) string building instead of O(n²) +=
+        md_parts = [
+            f"# {self.metadata.title}\n\n",
+            f"**Date:** {self.metadata.date}  \n",
+            f"**Author:** {self.metadata.author}  \n",
+        ]
 
         if self.metadata.project:
-            md_content += f"**Project:** {self.metadata.project}  \n"
+            md_parts.append(f"**Project:** {self.metadata.project}  \n")
 
         if self.metadata.tags:
-            md_content += f"**Tags:** {', '.join(self.metadata.tags)}  \n"
+            md_parts.append(f"**Tags:** {', '.join(self.metadata.tags)}  \n")
 
-        md_content += "\n---\n\n"
+        md_parts.append("\n---\n\n")
 
+        # Build sections with list.append instead of += in loop
         for section in self.sections:
             if section in self.content:
                 section_title = section.replace("_", " ").title()
-                md_content += f"## {section_title}\n\n"
-                md_content += self.content[section] + "\n\n"
+                md_parts.append(f"## {section_title}\n\n")
+                md_parts.append(self.content[section])
+                md_parts.append("\n\n")
+
+        md_content = "".join(md_parts)
 
         with open(path, "w") as f:
             f.write(md_content)
@@ -397,6 +413,67 @@ def _generate_detailed_results(trace: WaveformTrace, context: dict[str, Any]) ->
     return results
 
 
+def _generate_section_content(
+    sections: list[str], trace: WaveformTrace, context: dict[str, Any]
+) -> dict[str, str]:
+    """Generate content for requested sections.
+
+    Args:
+        sections: List of section names to generate
+        trace: Waveform trace
+        context: Analysis context
+
+    Returns:
+        Dictionary mapping section names to content
+    """
+    content = {}
+
+    if "executive_summary" in sections or "summary" in sections:
+        content["executive_summary"] = _generate_executive_summary(trace, context)
+
+    if "key_findings" in sections or "findings" in sections:
+        content["key_findings"] = _generate_key_findings(trace, context)
+
+    if "methodology" in sections:
+        content["methodology"] = _generate_methodology(trace, context)
+
+    if "detailed_results" in sections or "results" in sections:
+        content["detailed_results"] = _generate_detailed_results(trace, context)
+
+    if "recommendations" in sections:
+        content["recommendations"] = (
+            "Recommendations based on analysis:\n\n"
+            "1. Signal quality is acceptable for analysis\n"
+            "2. Consider additional captures for verification\n"
+            "3. Review anomalies if present\n"
+        )
+
+    return content
+
+
+def _determine_plot_types(trace: WaveformTrace, options: dict[str, Any]) -> list[str]:
+    """Determine which plots to include in report.
+
+    Args:
+        trace: Waveform trace
+        options: Report options
+
+    Returns:
+        List of plot type names
+    """
+    configured_plot_types = options.get("plot_types", [])
+    if configured_plot_types:
+        # Cast to list[str] - we know it contains strings from config
+        return [str(p) for p in configured_plot_types]
+
+    # Auto-select based on signal characteristics
+    plot_types = ["time_domain_waveform"]
+    if len(trace.data) > 100:
+        plot_types.append("fft_spectrum")
+
+    return plot_types
+
+
 def generate_report(
     trace: WaveformTrace,
     *,
@@ -437,55 +514,15 @@ def generate_report(
     context = context or {}
     options = options or {}
 
-    # Determine sections to include
-    default_sections = [
-        "executive_summary",
-        "key_findings",
-        "methodology",
-        "detailed_results",
-    ]
-
+    default_sections = ["executive_summary", "key_findings", "methodology", "detailed_results"]
     sections = options.get("select_sections", default_sections)
 
-    # Generate content for each section
-    content = {}
-
-    if "executive_summary" in sections or "summary" in sections:
-        content["executive_summary"] = _generate_executive_summary(trace, context)
-
-    if "key_findings" in sections or "findings" in sections:
-        content["key_findings"] = _generate_key_findings(trace, context)
-
-    if "methodology" in sections:
-        content["methodology"] = _generate_methodology(trace, context)
-
-    if "detailed_results" in sections or "results" in sections:
-        content["detailed_results"] = _generate_detailed_results(trace, context)
-
-    if "recommendations" in sections:
-        content["recommendations"] = (
-            "Recommendations based on analysis:\n\n"
-            "1. Signal quality is acceptable for analysis\n"
-            "2. Consider additional captures for verification\n"
-            "3. Review anomalies if present\n"
-        )
-
-    # Determine plot types to include
-    plot_types = options.get("plot_types", [])
-    if not plot_types:
-        # Auto-select based on signal characteristics
-        plot_types = ["time_domain_waveform"]
-
-        # Add spectral if signal looks periodic
-        if len(trace.data) > 100:
-            plot_types.append("fft_spectrum")
+    content = _generate_section_content(sections, trace, context)
+    plot_types = _determine_plot_types(trace, options)
 
-    # Estimate page count (rough estimate)
-    page_count = 1  # Title page
-    page_count += len(sections)  # One page per section
-    page_count += (len(plot_types) + 1) // 2  # 2 plots per page
+    # Estimate page count
+    page_count = 1 + len(sections) + (len(plot_types) + 1) // 2
 
-    # Create report object
     report = Report(
         sections=list(sections),
         plots=plot_types,
@@ -493,7 +530,6 @@ def generate_report(
         content=content,
     )
 
-    # Set custom metadata if provided
     if "custom_header" in options:
         report.metadata.title = options["custom_header"]
 

oscura/reporting/batch.py

@@ -114,8 +114,6 @@ def batch_report(
     References:
         RPT-003: Batch Report Generation
     """
-    import oscura as osc
-    from oscura.reporting.template_system import load_template
 
     output_path = Path(output_dir)
     output_path.mkdir(parents=True, exist_ok=True)
@@ -124,81 +122,156 @@ def batch_report(
     batch_results: list[dict[str, Any]] = []
 
     # Load template
+    report_template = _load_report_template(template)
+
+    # Get DUT ID extractor
+    extractor = dut_id_extractor or _default_dut_id_extractor
+
+    # Process each file
+    batch_results = _process_files(
+        files,
+        extractor,
+        analyzer,
+        result,
+        output_path,
+        report_template,
+        output_format,
+        file_pattern,
+        generate_individual,
+    )
+
+    # Generate summary report if requested
+    if generate_summary and batch_results:
+        _create_summary_report(batch_results, output_path, summary_filename, output_format, result)
+
+    return result
+
+
+def _load_report_template(template: str) -> Any:
+    """Load report template with fallback to default."""
+    from oscura.reporting.template_system import load_template
+
     try:
-        report_template = load_template(template)
+        return load_template(template)
     except ValueError:
         logger.warning(f"Template '{template}' not found, using 'default'")
-        report_template = load_template("default")
+        return load_template("default")
 
-    # Default DUT ID extractor
-    if dut_id_extractor is None:
 
-        def dut_id_extractor(p: Path) -> str:
-            return Path(p).stem
+def _default_dut_id_extractor(path: Path) -> str:
+    """Extract DUT ID from file path (default: use stem)."""
+    return Path(path).stem
+
+
+def _process_files(
+    files: list[str | Path],
+    dut_id_extractor: Callable[[Path], str],
+    analyzer: Callable[[Any], dict[str, Any]] | None,
+    result: BatchReportResult,
+    output_path: Path,
+    report_template: Any,
+    output_format: str,
+    file_pattern: str,
+    generate_individual: bool,
+) -> list[dict[str, Any]]:
+    """Process all files and generate individual reports."""
+
+    batch_results: list[dict[str, Any]] = []
 
-    # Process each file
     for file_path in files:
         file_path = Path(file_path)
         dut_id = dut_id_extractor(file_path)
 
-        try:
-            # Load trace
-            trace = osc.load(str(file_path))
+        dut_result = _process_single_file(file_path, dut_id, analyzer, result)
 
-            # Run analysis
-            if analyzer is not None:
-                dut_result = analyzer(trace)
-            else:
-                # Default analysis
-                dut_result = _default_analysis(trace)
+        if dut_result is not None:
+            batch_results.append(dut_result)
 
-            # Add DUT metadata
-            dut_result["dut_id"] = dut_id
-            dut_result["source_file"] = str(file_path)
+            if generate_individual:
+                _save_individual_report(
+                    dut_result,
+                    dut_id,
+                    output_path,
+                    file_pattern,
+                    output_format,
+                    report_template,
+                    result,
+                )
+
+    return batch_results
+
+
+def _process_single_file(
+    file_path: Path,
+    dut_id: str,
+    analyzer: Callable[[Any], dict[str, Any]] | None,
+    result: BatchReportResult,
+) -> dict[str, Any] | None:
+    """Process a single DUT file and update result statistics."""
+    import oscura as osc
 
-            batch_results.append(dut_result)
+    try:
+        trace = osc.load(str(file_path))
+        dut_result = analyzer(trace) if analyzer else _default_analysis(trace)
 
-            # Check pass/fail
-            if dut_result.get("pass_count", 0) == dut_result.get("total_count", 0):
-                result.passed_duts += 1
-            else:
-                result.failed_duts += 1
+        dut_result["dut_id"] = dut_id
+        dut_result["source_file"] = str(file_path)
 
-            result.total_duts += 1
+        # Update pass/fail counts
+        if dut_result.get("pass_count", 0) == dut_result.get("total_count", 0):
+            result.passed_duts += 1
+        else:
+            result.failed_duts += 1
 
-            # Generate individual report if requested
-            if generate_individual:
-                ext = output_format.lower()
-                individual_filename = file_pattern.format(dut_id=dut_id, ext=ext)
-                individual_path = output_path / individual_filename
-
-                try:
-                    _generate_individual_report(
-                        dut_result, individual_path, report_template, output_format
-                    )
-                    result.individual_report_paths.append(individual_path)
-                except Exception as e:
-                    logger.error(f"Failed to generate report for {dut_id}: {e}")
-                    result.errors.append((dut_id, str(e)))
-
-        except Exception as e:
-            logger.error(f"Failed to process {file_path}: {e}")
-            result.errors.append((str(file_path), str(e)))
+        result.total_duts += 1
+        return dut_result
 
-    # Generate summary report if requested
-    if generate_summary and batch_results:
-        ext = output_format.lower()
-        summary_path = output_path / summary_filename.format(ext=ext)
+    except Exception as e:
+        logger.error(f"Failed to process {file_path}: {e}")
+        result.errors.append((str(file_path), str(e)))
+        return None
 
-        try:
-            summary_report = generate_batch_report(batch_results)
-            _save_report(summary_report, summary_path, output_format)
-            result.summary_report_path = summary_path
-        except Exception as e:
-            logger.error(f"Failed to generate summary report: {e}")
-            result.errors.append(("summary", str(e)))
 
-    return result
+def _save_individual_report(
+    dut_result: dict[str, Any],
+    dut_id: str,
+    output_path: Path,
+    file_pattern: str,
+    output_format: str,
+    report_template: Any,
+    result: BatchReportResult,
+) -> None:
+    """Save individual DUT report."""
+    ext = output_format.lower()
+    individual_filename = file_pattern.format(dut_id=dut_id, ext=ext)
+    individual_path = output_path / individual_filename
+
+    try:
+        _generate_individual_report(dut_result, individual_path, report_template, output_format)
+        result.individual_report_paths.append(individual_path)
+    except Exception as e:
+        logger.error(f"Failed to generate report for {dut_id}: {e}")
+        result.errors.append((dut_id, str(e)))
+
+
+def _create_summary_report(
+    batch_results: list[dict[str, Any]],
+    output_path: Path,
+    summary_filename: str,
+    output_format: str,
+    result: BatchReportResult,
+) -> None:
+    """Create and save summary report."""
+    ext = output_format.lower()
+    summary_path = output_path / summary_filename.format(ext=ext)
+
+    try:
+        summary_report = generate_batch_report(batch_results)
+        _save_report(summary_report, summary_path, output_format)
+        result.summary_report_path = summary_path
+    except Exception as e:
+        logger.error(f"Failed to generate summary report: {e}")
+        result.errors.append(("summary", str(e)))
 
 
 def _default_analysis(trace: Any) -> dict[str, Any]: