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

oscura/cli/batch.py

@@ -24,38 +24,38 @@ from oscura.cli.main import format_output
 logger = logging.getLogger("oscura.cli.batch")
 
 
-@click.command()  # type: ignore[misc]
-@click.argument("pattern")  # type: ignore[misc]
-@click.option(  # type: ignore[misc]
+@click.command()
+@click.argument("pattern")
+@click.option(
     "--analysis",
     type=click.Choice(["characterize", "decode", "spectrum"], case_sensitive=False),
     required=True,
     help="Type of analysis to perform on each file.",
 )
-@click.option(  # type: ignore[misc]
+@click.option(
     "--parallel",
     type=int,
     default=1,
     help="Number of files to process concurrently (default: 1).",
 )
-@click.option(  # type: ignore[misc]
+@click.option(
     "--output",
     type=click.Choice(["json", "csv", "html", "table"], case_sensitive=False),
     default="table",
     help="Output format (default: table).",
 )
-@click.option(  # type: ignore[misc]
+@click.option(
     "--save-summary",
     type=click.Path(),
     default=None,
     help="Save aggregated results to file (CSV format).",
 )
-@click.option(  # type: ignore[misc]
+@click.option(
     "--continue-on-error",
     is_flag=True,
     help="Continue processing even if individual files fail.",
 )
-@click.pass_context  # type: ignore[misc]
+@click.pass_context
 def batch(
     ctx: click.Context,
     pattern: str,
@@ -110,7 +110,7 @@ def batch(
 
     try:
         # Expand glob pattern
-        files = glob.glob(pattern, recursive=True)  # noqa: PTH207
+        files = glob.glob(pattern, recursive=True)
 
         if not files:
             click.echo(f"No files matched pattern: {pattern}", err=True)
@@ -145,133 +145,91 @@ def batch(
         ctx.exit(1)
 
 
-def _perform_batch_analysis(
-    files: list[str],
-    analysis_type: str,
-    parallel: int,
-    continue_on_error: bool,
-    verbose: int,
-) -> list[dict[str, Any]]:
-    """Perform batch analysis on multiple files.
-
-    Uses concurrent.futures for parallel processing when parallel > 1.
+def _analyze_single_file(file_path: str, analysis_type: str) -> dict[str, Any]:
+    """Analyze a single file and return results.
 
     Args:
-        files: List of file paths to process.
+        file_path: Path to waveform file to analyze.
         analysis_type: Type of analysis to perform.
-        parallel: Number of parallel workers.
-        continue_on_error: Whether to continue on errors.
-        verbose: Verbosity level.
 
     Returns:
-        List of result dictionaries, one per file.
-
-    Raises:
-        Exception: If analysis fails and continue_on_error is False.
+        Dictionary containing analysis results.
     """
-    from concurrent.futures import ThreadPoolExecutor, as_completed
+    import numpy as np
+
+    from oscura.analyzers.waveform.measurements import fall_time, rise_time
+    from oscura.analyzers.waveform.spectral import fft, thd
+    from oscura.inference import detect_protocol
+    from oscura.loaders import load
+
+    trace = load(file_path)
+    sample_rate = trace.metadata.sample_rate
+
+    result: dict[str, Any] = {
+        "file": str(Path(file_path).name),
+        "status": "success",
+        "analysis_type": analysis_type,
+        "samples": len(trace.data),  # type: ignore[union-attr]
+        "sample_rate": f"{sample_rate / 1e6:.1f} MHz",
+    }
 
-    def analyze_single_file(file_path: str) -> dict[str, Any]:
-        """Analyze a single file and return results.
-
-        Args:
-            file_path: Path to waveform file to analyze.
-
-        Returns:
-            Dictionary containing analysis results.
-        """
-        import numpy as np
-
-        from oscura.analyzers.waveform.measurements import fall_time, rise_time
-        from oscura.analyzers.waveform.spectral import fft, thd
-        from oscura.inference import detect_protocol
-        from oscura.loaders import load
-
-        # Load trace
-        trace = load(file_path)
-        sample_rate = trace.metadata.sample_rate
-
-        # Base result
-        result: dict[str, Any] = {
-            "file": str(Path(file_path).name),
-            "status": "success",
-            "analysis_type": analysis_type,
-            "samples": len(trace.data),  # type: ignore[union-attr]
-            "sample_rate": f"{sample_rate / 1e6:.1f} MHz",
-        }
-
-        # Add analysis-specific results
-        if analysis_type == "characterize":
-            # Pass WaveformTrace directly to functions (they expect WaveformTrace)
-            rt = rise_time(trace)  # type: ignore[arg-type]
-            ft = fall_time(trace)  # type: ignore[arg-type]
-            result.update(
-                {
-                    "rise_time": f"{rt * 1e9:.2f} ns" if not np.isnan(rt) else "N/A",
-                    "fall_time": f"{ft * 1e9:.2f} ns" if not np.isnan(ft) else "N/A",
-                }
-            )
-        elif analysis_type == "decode":
-            detected = detect_protocol(trace)  # type: ignore[arg-type]
-            result.update(
-                {
-                    "protocol": detected.get("protocol", "unknown"),
-                    "confidence": f"{detected.get('confidence', 0) * 100:.0f}%",
-                }
-            )
-        elif analysis_type == "spectrum":
-            # Pass WaveformTrace directly to FFT functions
-            freqs, mags = fft(trace)  # type: ignore[misc, arg-type]
-            if len(mags) > 0:
-                peak_idx = int(np.argmax(mags))
-                peak_freq = freqs[peak_idx]
-            else:
-                peak_freq = 0.0
-            thd_val = thd(trace)  # type: ignore[arg-type]
-            result.update(
-                {
-                    "peak_frequency": f"{peak_freq / 1e6:.3f} MHz",
-                    "thd": f"{thd_val:.1f} dB" if not np.isnan(thd_val) else "N/A",
-                }
-            )
+    if analysis_type == "characterize":
+        rt = rise_time(trace)  # type: ignore[arg-type]
+        ft = fall_time(trace)  # type: ignore[arg-type]
+        result.update(
+            {
+                "rise_time": f"{rt * 1e9:.2f} ns" if not np.isnan(rt) else "N/A",
+                "fall_time": f"{ft * 1e9:.2f} ns" if not np.isnan(ft) else "N/A",
+            }
+        )
+    elif analysis_type == "decode":
+        detected = detect_protocol(trace)  # type: ignore[arg-type]
+        result.update(
+            {
+                "protocol": detected.get("protocol", "unknown"),
+                "confidence": f"{detected.get('confidence', 0) * 100:.0f}%",
+            }
+        )
+    elif analysis_type == "spectrum":
+        freqs, mags = fft(trace)  # type: ignore[misc, arg-type]
+        if len(mags) > 0:
+            peak_idx = int(np.argmax(mags))
+            peak_freq = freqs[peak_idx]
+        else:
+            peak_freq = 0.0
+        thd_val = thd(trace)  # type: ignore[arg-type]
+        result.update(
+            {
+                "peak_frequency": f"{peak_freq / 1e6:.3f} MHz",
+                "thd": f"{thd_val:.1f} dB" if not np.isnan(thd_val) else "N/A",
+            }
+        )
 
-        return result
+    return result
+
+
+def _process_parallel(
+    files: list[str],
+    analysis_type: str,
+    parallel: int,
+    continue_on_error: bool,
+    verbose: int,
+) -> list[dict[str, Any]]:
+    """Process files in parallel using ThreadPoolExecutor."""
+    from concurrent.futures import ThreadPoolExecutor, as_completed
 
     results: list[dict[str, Any]] = []
 
-    if parallel > 1:
-        # Parallel processing using ThreadPoolExecutor
-        with ThreadPoolExecutor(max_workers=parallel) as executor:
-            future_to_file = {executor.submit(analyze_single_file, f): f for f in files}
-
-            for i, future in enumerate(as_completed(future_to_file), 1):
-                file_path = future_to_file[future]
-                if verbose:
-                    logger.info(f"[{i}/{len(files)}] Completed {Path(file_path).name}")
-
-                try:
-                    result = future.result()
-                    results.append(result)
-                except Exception as e:
-                    logger.error(f"Failed to process {file_path}: {e}")
-                    if continue_on_error:
-                        results.append(
-                            {
-                                "file": str(Path(file_path).name),
-                                "status": "error",
-                                "error": str(e),
-                            }
-                        )
-                    else:
-                        raise
-    else:
-        # Sequential processing
-        for i, file_path in enumerate(files, 1):
+    with ThreadPoolExecutor(max_workers=parallel) as executor:
+        future_to_file = {executor.submit(_analyze_single_file, f, analysis_type): f for f in files}
+
+        for i, future in enumerate(as_completed(future_to_file), 1):
+            file_path = future_to_file[future]
             if verbose:
-                logger.info(f"[{i}/{len(files)}] Processing {file_path}")
+                logger.info(f"[{i}/{len(files)}] Completed {Path(file_path).name}")
 
             try:
-                result = analyze_single_file(file_path)
+                result = future.result()
                 results.append(result)
             except Exception as e:
                 logger.error(f"Failed to process {file_path}: {e}")
@@ -289,6 +247,68 @@ def _perform_batch_analysis(
     return results
 
 
+def _process_sequential(
+    files: list[str],
+    analysis_type: str,
+    continue_on_error: bool,
+    verbose: int,
+) -> list[dict[str, Any]]:
+    """Process files sequentially."""
+    results: list[dict[str, Any]] = []
+
+    for i, file_path in enumerate(files, 1):
+        if verbose:
+            logger.info(f"[{i}/{len(files)}] Processing {file_path}")
+
+        try:
+            result = _analyze_single_file(file_path, analysis_type)
+            results.append(result)
+        except Exception as e:
+            logger.error(f"Failed to process {file_path}: {e}")
+            if continue_on_error:
+                results.append(
+                    {
+                        "file": str(Path(file_path).name),
+                        "status": "error",
+                        "error": str(e),
+                    }
+                )
+            else:
+                raise
+
+    return results
+
+
+def _perform_batch_analysis(
+    files: list[str],
+    analysis_type: str,
+    parallel: int,
+    continue_on_error: bool,
+    verbose: int,
+) -> list[dict[str, Any]]:
+    """Perform batch analysis on multiple files.
+
+    Uses concurrent.futures for parallel processing when parallel > 1.
+
+    Args:
+        files: List of file paths to process.
+        analysis_type: Type of analysis to perform.
+        parallel: Number of parallel workers.
+        continue_on_error: Whether to continue on errors.
+        verbose: Verbosity level.
+
+    Returns:
+        List of result dictionaries, one per file.
+
+    Raises:
+        Exception: If analysis fails and continue_on_error is False.
+    """
+    if parallel > 1:
+        return _process_parallel(files, analysis_type, parallel, continue_on_error, verbose)
+    else:
+        return _process_sequential(files, analysis_type, continue_on_error, verbose)
+
+
 def _generate_summary(results: list[dict[str, Any]]) -> dict[str, Any]:
     """Generate summary statistics from batch results.
 

oscura/cli/benchmark.py

@@ -0,0 +1,275 @@
+"""Oscura Benchmark Command - Performance Benchmarking.
+
+Provides CLI for performance benchmarking of analysis operations.
+
+
+Example:
+    $ oscura benchmark --operations all
+    $ oscura benchmark --operations decode --protocol uart
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+import click
+
+logger = logging.getLogger("oscura.cli.benchmark")
+
+
+@click.command()
+@click.option(
+    "--operations",
+    type=click.Choice(["all", "load", "decode", "fft", "measurements"], case_sensitive=False),
+    default="all",
+    help="Operations to benchmark.",
+)
+@click.option(
+    "--protocol",
+    type=str,
+    default="uart",
+    help="Protocol for decode benchmark.",
+)
+@click.option(
+    "--iterations",
+    type=int,
+    default=10,
+    help="Number of iterations per benchmark.",
+)
+@click.option(
+    "--output",
+    type=click.Choice(["json", "table"], case_sensitive=False),
+    default="table",
+    help="Output format.",
+)
+@click.pass_context
+def benchmark(
+    ctx: click.Context,
+    operations: str,
+    protocol: str,
+    iterations: int,
+    output: str,
+) -> None:
+    """Run performance benchmarks.
+
+    Measures performance of core operations like loading, decoding,
+    FFT, and measurements.
+
+    Args:
+        ctx: Click context object.
+        operations: Operations to benchmark.
+        protocol: Protocol for decode benchmark.
+        iterations: Number of iterations.
+        output: Output format.
+
+    Examples:
+
+        \b
+        # Benchmark all operations
+        $ oscura benchmark --operations all
+
+        \b
+        # Benchmark specific operation
+        $ oscura benchmark --operations decode --protocol uart --iterations 100
+    """
+    verbose = ctx.obj.get("verbose", 0)
+
+    if verbose:
+        logger.info(f"Running benchmark: {operations}")
+
+    try:
+        results: dict[str, Any] = {"iterations": iterations, "benchmarks": {}}
+
+        # Generate test data
+        test_data = _generate_test_data()
+
+        # Run benchmarks
+        if operations in ["all", "load"]:
+            results["benchmarks"]["load"] = _benchmark_load(test_data, iterations)
+
+        if operations in ["all", "decode"]:
+            results["benchmarks"]["decode"] = _benchmark_decode(test_data, protocol, iterations)
+
+        if operations in ["all", "fft"]:
+            results["benchmarks"]["fft"] = _benchmark_fft(test_data, iterations)
+
+        if operations in ["all", "measurements"]:
+            results["benchmarks"]["measurements"] = _benchmark_measurements(test_data, iterations)
+
+        # Output results
+        if output == "json":
+            import json
+
+            click.echo(json.dumps(results, indent=2))
+        else:
+            _print_table(results)
+
+    except Exception as e:
+        logger.error(f"Benchmark failed: {e}")
+        if verbose > 1:
+            raise
+        click.echo(f"Error: {e}", err=True)
+        ctx.exit(1)
+
+
+def _generate_test_data() -> Any:
+    """Generate test data for benchmarking.
+
+    Returns:
+        Test waveform trace.
+    """
+    import numpy as np
+
+    from oscura.core.types import TraceMetadata, WaveformTrace
+
+    # Generate 100k sample waveform
+    samples = 100000
+    sample_rate = 1e6
+    t = np.arange(samples) / sample_rate
+
+    # Mix of sine waves
+    data = np.sin(2 * np.pi * 1000 * t) + 0.5 * np.sin(2 * np.pi * 5000 * t)
+
+    return WaveformTrace(data=data, metadata=TraceMetadata(sample_rate=sample_rate))
+
+
+def _benchmark_load(test_data: Any, iterations: int) -> dict[str, Any]:
+    """Benchmark data loading.
+
+    Args:
+        test_data: Test data.
+        iterations: Number of iterations.
+
+    Returns:
+        Benchmark results.
+    """
+    import tempfile
+    from pathlib import Path
+
+    import numpy as np
+
+    from oscura.loaders import load
+
+    # Save test data to temp file (use .npz which is supported)
+    with tempfile.NamedTemporaryFile(suffix=".npz", delete=False) as f:
+        temp_path = Path(f.name)
+        np.savez(temp_path, data=test_data.data)
+
+    try:
+        start = time.time()
+        for _ in range(iterations):
+            _ = load(str(temp_path))
+        elapsed = time.time() - start
+
+        return {
+            "total_time": f"{elapsed:.3f}s",
+            "avg_time": f"{elapsed / iterations * 1000:.2f}ms",
+            "throughput": f"{iterations / elapsed:.1f} ops/sec",
+        }
+    finally:
+        temp_path.unlink()
+
+
+def _benchmark_decode(test_data: Any, protocol: str, iterations: int) -> dict[str, Any]:
+    """Benchmark protocol decoding.
+
+    Args:
+        test_data: Test data.
+        protocol: Protocol name.
+        iterations: Number of iterations.
+
+    Returns:
+        Benchmark results.
+    """
+    import numpy as np
+
+    from oscura.core.types import DigitalTrace
+
+    # Convert to digital
+    threshold = np.mean(test_data.data)
+    digital = test_data.data > threshold
+    digital_trace = DigitalTrace(data=digital, metadata=test_data.metadata)
+
+    start = time.time()
+    for _ in range(iterations):
+        if protocol.lower() == "uart":
+            from oscura.analyzers.protocols.uart import UARTDecoder
+
+            decoder = UARTDecoder(baudrate=9600)
+            _ = list(decoder.decode(digital_trace))
+
+    elapsed = time.time() - start
+
+    return {
+        "protocol": protocol,
+        "total_time": f"{elapsed:.3f}s",
+        "avg_time": f"{elapsed / iterations * 1000:.2f}ms",
+        "throughput": f"{iterations / elapsed:.1f} ops/sec",
+    }
+
+
+def _benchmark_fft(test_data: Any, iterations: int) -> dict[str, Any]:
+    """Benchmark FFT computation.
+
+    Args:
+        test_data: Test data.
+        iterations: Number of iterations.
+
+    Returns:
+        Benchmark results.
+    """
+    from oscura.analyzers.waveform.spectral import fft
+
+    start = time.time()
+    for _ in range(iterations):
+        _ = fft(test_data)
+    elapsed = time.time() - start
+
+    return {
+        "total_time": f"{elapsed:.3f}s",
+        "avg_time": f"{elapsed / iterations * 1000:.2f}ms",
+        "throughput": f"{iterations / elapsed:.1f} ops/sec",
+    }
+
+
+def _benchmark_measurements(test_data: Any, iterations: int) -> dict[str, Any]:
+    """Benchmark waveform measurements.
+
+    Args:
+        test_data: Test data.
+        iterations: Number of iterations.
+
+    Returns:
+        Benchmark results.
+    """
+    from oscura.analyzers.waveform.measurements import fall_time, rise_time
+
+    start = time.time()
+    for _ in range(iterations):
+        _ = rise_time(test_data)
+        _ = fall_time(test_data)
+    elapsed = time.time() - start
+
+    return {
+        "total_time": f"{elapsed:.3f}s",
+        "avg_time": f"{elapsed / iterations * 1000:.2f}ms",
+        "throughput": f"{iterations / elapsed:.1f} ops/sec",
+    }
+
+
+def _print_table(results: dict[str, Any]) -> None:
+    """Print results as table.
+
+    Args:
+        results: Benchmark results.
+    """
+    click.echo("\n=== Benchmark Results ===\n")
+    click.echo(f"Iterations: {results['iterations']}\n")
+
+    for name, bench in results["benchmarks"].items():
+        click.echo(f"{name.upper()}:")
+        for key, value in bench.items():
+            click.echo(f"  {key}: {value}")
+        click.echo()