oscura 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

oscura/inference/sequences.py

@@ -8,8 +8,6 @@ streams, identifying request-response pairs, and analyzing communication
 flows.
 """
 
-from __future__ import annotations
-
 from collections import defaultdict
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
@@ -83,7 +81,7 @@ class CommunicationFlow:
 
     flow_id: int
     messages: list[Any]
-    pairs: list[RequestResponsePair]
+    pairs: list["RequestResponsePair"]
     direction: str
     participants: list[str]
     duration: float
@@ -127,7 +125,7 @@ class SequencePatternDetector:
         messages: Sequence[Any],
         key: Callable[[Any], Any] | None = None,
         timestamp_key: Callable[[Any], float] | None = None,
-    ) -> list[SequencePattern]:
+    ) -> list["SequencePattern"]:
         """Detect sequential patterns in message stream.
 
         Implements RE-SEQ-002: Pattern detection workflow.
@@ -222,7 +220,7 @@ class SequencePatternDetector:
         messages: Sequence[Any],
         key: Callable[[Any], Any] | None = None,
         timestamp_key: Callable[[Any], float] | None = None,
-    ) -> list[SequencePattern]:
+    ) -> list["SequencePattern"]:
         """Detect patterns that occur at regular intervals.
 
         Implements RE-SEQ-002: Periodic pattern detection.
@@ -287,7 +285,7 @@ class SequencePatternDetector:
         candidates: dict[tuple[Any, ...], list[int]],
         identifiers: list[Any],
         timestamps: list[float] | None,
-    ) -> list[SequencePattern]:
+    ) -> list["SequencePattern"]:
         """Score candidate patterns.
 
         Args:
@@ -386,7 +384,7 @@ class RequestResponseCorrelator:
         request_filter: Callable[[Any], bool] | None = None,
         response_filter: Callable[[Any], bool] | None = None,
         timestamp_key: Callable[[Any], float] | None = None,
-    ) -> list[RequestResponsePair]:
+    ) -> list["RequestResponsePair"]:
         """Correlate requests with responses.
 
         Implements RE-SEQ-003: Request-response correlation workflow.
@@ -441,7 +439,7 @@ class RequestResponseCorrelator:
         messages: Sequence[Any],
         content_key: Callable[[Any], bytes],
         timestamp_key: Callable[[Any], float] | None = None,
-    ) -> list[RequestResponsePair]:
+    ) -> list["RequestResponsePair"]:
         """Correlate by analyzing message content similarity.
 
         Implements RE-SEQ-003: Content-based correlation.
@@ -500,10 +498,10 @@ class RequestResponseCorrelator:
 
     def extract_flows(
         self,
-        pairs: Sequence[RequestResponsePair],
+        pairs: Sequence["RequestResponsePair"],
         messages: Sequence[Any],
         flow_key: Callable[[Any], str] | None = None,
-    ) -> list[CommunicationFlow]:
+    ) -> list["CommunicationFlow"]:
         """Extract communication flows from pairs.
 
         Implements RE-SEQ-003: Flow extraction.
@@ -569,7 +567,7 @@ class RequestResponseCorrelator:
         self,
         requests: list[tuple[int, Any, float, Any]],
         responses: list[tuple[int, Any, float, Any]],
-    ) -> list[RequestResponsePair]:
+    ) -> list["RequestResponsePair"]:
         """Match request and response messages.
 
         Args:
@@ -664,7 +662,7 @@ def detect_sequence_patterns(
     min_length: int = 2,
     max_length: int = 10,
     min_frequency: int = 2,
-) -> list[SequencePattern]:
+) -> list["SequencePattern"]:
     """Detect sequential patterns in messages.
 
     Implements RE-SEQ-002: Sequence Pattern Detection.
@@ -699,7 +697,7 @@ def correlate_requests(
     response_filter: Callable[[Any], bool],
     timestamp_key: Callable[[Any], float] | None = None,
     max_latency: float = 10.0,
-) -> list[RequestResponsePair]:
+) -> list["RequestResponsePair"]:
     """Correlate request and response messages.
 
     Implements RE-SEQ-003: Request-Response Correlation.
@@ -760,7 +758,7 @@ def find_message_dependencies(
 
 
 def calculate_latency_stats(
-    pairs: Sequence[RequestResponsePair],
+    pairs: Sequence["RequestResponsePair"],
 ) -> dict[str, float]:
     """Calculate latency statistics for request-response pairs.
 

oscura/inference/state_machine.py

@@ -12,6 +12,8 @@ Key capabilities:
 - Export to NetworkX graph for analysis
 """
 
+from __future__ import annotations
+
 from copy import deepcopy
 from dataclasses import dataclass
 from typing import Any

oscura/integrations/llm.py

@@ -23,6 +23,8 @@ Examples:
     ... )
 """
 
+from __future__ import annotations
+
 import hashlib
 import json
 import os
@@ -1545,7 +1547,7 @@ def get_client_auto(**config_kwargs: Any) -> LLMClient:
 
 def get_client_with_failover(
     providers: list[str] | None = None, **config_kwargs: Any
-) -> "FailoverLLMClient":
+) -> FailoverLLMClient:
     """Get LLM client with automatic failover between providers.
 
     Failover logic (try OpenAI, fallback to Anthropic).

oscura/jupyter/display.py

@@ -12,8 +12,6 @@ Example:
     In [2]: display_trace(trace)  # Shows rich HTML summary
 """
 
-from __future__ import annotations
-
 from typing import Any
 
 try:

oscura/loaders/__init__.py

@@ -20,10 +20,73 @@ from __future__ import annotations
 import logging
 import warnings
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from oscura.core.exceptions import LoaderError, UnsupportedFormatError
-from oscura.core.types import DigitalTrace, WaveformTrace
+from oscura.core.types import DigitalTrace, IQTrace, WaveformTrace
+
+# Loader registry for cleaner dispatch
+_LOADER_REGISTRY: dict[str, tuple[str, str]] = {
+    "tektronix": ("oscura.loaders.tektronix", "load_tektronix_wfm"),
+    "tek": ("oscura.loaders.tektronix", "load_tektronix_wfm"),
+    "rigol": ("oscura.loaders.rigol", "load_rigol_wfm"),
+    "numpy": ("oscura.loaders.numpy_loader", "load_npz"),
+    "csv": ("oscura.loaders.csv_loader", "load_csv"),
+    "hdf5": ("oscura.loaders.hdf5_loader", "load_hdf5"),
+    "sigrok": ("oscura.loaders.sigrok", "load_sigrok"),
+    "vcd": ("oscura.loaders.vcd", "load_vcd"),
+    "pcap": ("oscura.loaders.pcap", "load_pcap"),
+    "wav": ("oscura.loaders.wav", "load_wav"),
+    "tdms": ("oscura.loaders.tdms", "load_tdms"),
+    "touchstone": ("oscura.loaders.touchstone", "load_touchstone"),
+}
+
+
+def _dispatch_loader(
+    loader_name: str, path: Path, **kwargs: Any
+) -> WaveformTrace | DigitalTrace | IQTrace:
+    """Dispatch to registered loader.
+
+    Args:
+        loader_name: Name of loader to use.
+        path: Path to file.
+        **kwargs: Additional arguments for loader.
+
+    Returns:
+        Loaded data.
+
+    Raises:
+        UnsupportedFormatError: If loader not registered.
+    """
+    if loader_name not in _LOADER_REGISTRY:
+        raise UnsupportedFormatError(
+            loader_name,
+            list(_LOADER_REGISTRY.keys()),
+            file_path=str(path),
+        )
+
+    module_path, func_name = _LOADER_REGISTRY[loader_name]
+
+    # Dynamically import the module
+    import importlib
+    import inspect
+
+    module = importlib.import_module(module_path)
+    loader_func = getattr(module, func_name)
+
+    # Filter kwargs to only include parameters the function accepts
+    sig = inspect.signature(loader_func)
+    valid_kwargs = {}
+    for key, value in kwargs.items():
+        if key in sig.parameters or any(
+            p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+        ):
+            valid_kwargs[key] = value
+
+    # Call loader with appropriate arguments
+    result = loader_func(path, **valid_kwargs)
+    return cast("WaveformTrace | DigitalTrace | IQTrace", result)
+
 
 # Import alias modules for DSL compatibility
 from oscura.loaders import (
@@ -180,56 +243,9 @@ def load(
     # Dispatch to appropriate loader
     if loader_name == "auto_wfm":
         return _load_wfm_auto(path, channel=channel, **kwargs)
-    elif loader_name in ("tektronix", "tek"):
-        from oscura.loaders.tektronix import load_tektronix_wfm
-
-        return load_tektronix_wfm(path, **kwargs)
-    elif loader_name == "rigol":
-        from oscura.loaders.rigol import load_rigol_wfm
-
-        return load_rigol_wfm(path, **kwargs)
-    elif loader_name == "numpy":
-        from oscura.loaders.numpy_loader import load_npz
-
-        return load_npz(path, channel=channel, **kwargs)
-    elif loader_name == "csv":
-        from oscura.loaders.csv_loader import load_csv
-
-        return load_csv(path, **kwargs)  # type: ignore[return-value]
-    elif loader_name == "hdf5":
-        from oscura.loaders.hdf5_loader import load_hdf5
-
-        return load_hdf5(path, channel=channel, **kwargs)  # type: ignore[return-value]
-    elif loader_name == "sigrok":
-        from oscura.loaders.sigrok import load_sigrok
-
-        return load_sigrok(path, channel=channel, **kwargs)
-    elif loader_name == "vcd":
-        from oscura.loaders.vcd import load_vcd
-
-        return load_vcd(path, **kwargs)
-    elif loader_name == "pcap":
-        from oscura.loaders.pcap import load_pcap
-
-        return load_pcap(path, **kwargs)  # type: ignore[return-value]
-    elif loader_name == "wav":
-        from oscura.loaders.wav import load_wav
-
-        return load_wav(path, channel=channel, **kwargs)
-    elif loader_name == "tdms":
-        from oscura.loaders.tdms import load_tdms
-
-        return load_tdms(path, channel=channel, **kwargs)
-    elif loader_name == "touchstone":
-        from oscura.analyzers.signal_integrity.sparams import load_touchstone
-
-        return load_touchstone(path)  # type: ignore[return-value]
     else:
-        raise UnsupportedFormatError(
-            loader_name,
-            list(SUPPORTED_FORMATS.keys()),
-            file_path=str(path),
-        )
+        # Use registry-based dispatch for all other loaders
+        return _dispatch_loader(loader_name, path, channel=channel, **kwargs)
 
 
 def _load_wfm_auto(

oscura/loaders/pcap.py

@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 
 # Try to import dpkt for full PCAP support
 try:
-    import dpkt  # type: ignore[import-untyped]
+    import dpkt  # type: ignore[import-not-found]
 
     DPKT_AVAILABLE = True
 except ImportError:

oscura/loaders/touchstone.py

@@ -0,0 +1,221 @@
+"""Touchstone file loader for S-parameter data.
+
+Supports .s1p through .s8p formats (Touchstone 1.0 and 2.0).
+
+Example:
+    >>> from oscura.loaders import load_touchstone
+    >>> s_params = load_touchstone("cable.s2p")
+    >>> print(f"Loaded {s_params.n_ports}-port, {len(s_params.frequencies)} points")
+
+References:
+    Touchstone 2.0 File Format Specification
+"""
+
+from __future__ import annotations
+
+import contextlib
+import re
+from pathlib import Path
+
+import numpy as np
+
+from oscura.analyzers.signal_integrity.sparams import SParameterData
+from oscura.core.exceptions import FormatError, LoaderError
+
+
+def load_touchstone(path: str | Path) -> SParameterData:
+    """Load S-parameter data from Touchstone file.
+
+    Supports .s1p through .s8p formats and both Touchstone 1.0
+    and 2.0 file formats.
+
+    Args:
+        path: Path to Touchstone file.
+
+    Returns:
+        SParameterData with loaded S-parameters.
+
+    Raises:
+        LoaderError: If file cannot be read.
+        FormatError: If file format is invalid.
+
+    Example:
+        >>> s_params = load_touchstone("cable.s2p")
+        >>> print(f"Loaded {s_params.n_ports}-port, {len(s_params.frequencies)} points")
+
+    References:
+        Touchstone 2.0 File Format Specification
+    """
+    path = Path(path)
+
+    if not path.exists():
+        raise LoaderError(f"File not found: {path}")
+
+    # Determine number of ports from extension
+    suffix = path.suffix.lower()
+    match = re.match(r"\.s(\d+)p", suffix)
+    if not match:
+        raise FormatError(f"Unsupported file extension: {suffix}")
+
+    n_ports = int(match.group(1))
+
+    try:
+        with open(path) as f:
+            lines = f.readlines()
+    except Exception as e:
+        raise LoaderError(f"Failed to read file: {e}")  # noqa: B904
+
+    return _parse_touchstone(lines, n_ports, str(path))
+
+
+def _parse_touchstone(
+    lines: list[str],
+    n_ports: int,
+    source_file: str,
+) -> SParameterData:
+    """Parse Touchstone file content.
+
+    Args:
+        lines: File lines.
+        n_ports: Number of ports.
+        source_file: Source file path.
+
+    Returns:
+        Parsed SParameterData.
+
+    Raises:
+        FormatError: If file format is invalid.
+    """
+    comments = []
+    option_line = None
+    data_lines = []
+
+    for line in lines:
+        line = line.strip()
+
+        if not line:
+            continue
+
+        if line.startswith("!"):
+            comments.append(line[1:].strip())
+        elif line.startswith("#"):
+            option_line = line
+        else:
+            data_lines.append(line)
+
+    # Parse option line
+    freq_unit = 1e9  # Default GHz
+    format_type = "ma"  # Default MA (magnitude/angle)
+    z0 = 50.0
+
+    if option_line:
+        option_line = option_line.lower()
+        parts = option_line.split()
+
+        for i, part in enumerate(parts):
+            if part in ("hz", "khz", "mhz", "ghz"):
+                freq_unit = {
+                    "hz": 1.0,
+                    "khz": 1e3,
+                    "mhz": 1e6,
+                    "ghz": 1e9,
+                }[part]
+            elif part in ("db", "ma", "ri"):
+                format_type = part
+            elif part == "r":
+                # Reference impedance follows
+                if i + 1 < len(parts):
+                    with contextlib.suppress(ValueError):
+                        z0 = float(parts[i + 1])
+
+    # Parse data
+    frequencies = []
+    s_data = []
+
+    # Number of S-parameters per frequency
+    n_s_params = n_ports * n_ports
+
+    i = 0
+    while i < len(data_lines):
+        # First line has frequency and first S-parameters
+        parts = data_lines[i].split()
+
+        if len(parts) < 1:
+            i += 1
+            continue
+
+        freq = float(parts[0]) * freq_unit
+        frequencies.append(freq)
+
+        # Collect all S-parameter values for this frequency
+        s_values = []
+
+        # Add values from first line
+        for j in range(1, len(parts), 2):
+            if j + 1 < len(parts):
+                val1 = float(parts[j])
+                val2 = float(parts[j + 1])
+                s_values.append((val1, val2))
+
+        i += 1
+
+        # Continue collecting from subsequent lines if needed
+        while len(s_values) < n_s_params and i < len(data_lines):
+            parts = data_lines[i].split()
+
+            # Check if this is a new frequency (has odd number of values)
+            try:
+                float(parts[0])
+                if len(parts) % 2 == 1:
+                    break  # New frequency line
+            except (ValueError, IndexError):
+                pass
+
+            for j in range(0, len(parts), 2):
+                if j + 1 < len(parts):
+                    val1 = float(parts[j])
+                    val2 = float(parts[j + 1])
+                    s_values.append((val1, val2))
+
+            i += 1
+
+        # Convert to complex based on format
+        s_complex = []
+        for val1, val2 in s_values:
+            if format_type == "ri":
+                # Real/Imaginary
+                s_complex.append(complex(val1, val2))
+            elif format_type == "ma":
+                # Magnitude/Angle (degrees)
+                mag = val1
+                angle_rad = np.radians(val2)
+                s_complex.append(mag * np.exp(1j * angle_rad))
+            elif format_type == "db":
+                # dB/Angle (degrees)
+                mag = 10 ** (val1 / 20)
+                angle_rad = np.radians(val2)
+                s_complex.append(mag * np.exp(1j * angle_rad))
+
+        # Reshape into matrix
+        if len(s_complex) == n_s_params:
+            s_matrix = np.array(s_complex).reshape(n_ports, n_ports)
+            s_data.append(s_matrix)
+
+    if len(frequencies) == 0:
+        raise FormatError("No valid frequency points found")
+
+    frequencies_arr = np.array(frequencies, dtype=np.float64)
+    s_matrix_arr = np.array(s_data, dtype=np.complex128)
+
+    return SParameterData(
+        frequencies=frequencies_arr,
+        s_matrix=s_matrix_arr,
+        n_ports=n_ports,
+        z0=z0,
+        format=format_type,
+        source_file=source_file,
+        comments=comments,
+    )
+
+
+__all__ = ["load_touchstone"]

oscura/math/arithmetic.py

@@ -14,8 +14,6 @@ References:
     IEEE 181-2011: Standard for Transitional Waveform Definitions
 """
 
-from __future__ import annotations
-
 import ast
 import operator
 from collections.abc import Callable

oscura/optimization/parallel.py

@@ -14,12 +14,15 @@ from concurrent.futures import (
     as_completed,
 )
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
 import numpy as np
 
 from oscura.core.exceptions import AnalysisError
 
+T = TypeVar("T")
+R = TypeVar("R")
+
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
@@ -29,7 +32,7 @@ logger = logging.getLogger(__name__)
 
 
 @dataclass
-class ParallelResult[R]:
+class ParallelResult(Generic[R]):
     """Result from parallel execution.
 
     Attributes:
@@ -93,7 +96,7 @@ def get_optimal_workers(max_workers: int | None = None) -> int:
     return min(max_workers, cpu_count)
 
 
-def parallel_map[T, R](
+def parallel_map(
     func: Callable[[T], R],
     iterable: Iterable[T],
     *,
@@ -171,7 +174,7 @@ def parallel_map[T, R](
     )
 
 
-def parallel_reduce[T, R](
+def parallel_reduce(
     func: Callable[[T], R],
     iterable: Iterable[T],
     reducer: Callable[[list[R]], Any],
@@ -219,7 +222,7 @@ def parallel_reduce[T, R](
     return reducer(result.results)
 
 
-def batch_parallel_map[T, R](
+def batch_parallel_map(
     func: Callable[[list[T]], list[R]],
     iterable: Iterable[T],
     *,
@@ -297,7 +300,7 @@ def batch_parallel_map[T, R](
     )
 
 
-def parallel_filter[T](
+def parallel_filter(
     func: Callable[[T], bool],
     iterable: Iterable[T],
     *,

oscura/pipeline/composition.py

@@ -4,8 +4,6 @@ This module implements compose() and pipe() functions for functional-style
 trace processing, with support for operator overloading.
 """
 
-from __future__ import annotations
-
 from collections.abc import Callable
 from functools import reduce, wraps
 from typing import Any, TypeVar

oscura/plugins/cli.py

@@ -4,8 +4,6 @@ This module provides command-line interface for plugin management including
 list, info, enable/disable, install, and validate operations.
 """
 
-from __future__ import annotations
-
 import hashlib
 import logging
 import shutil

oscura/reporting/comparison.py

@@ -9,8 +9,6 @@ Example:
     >>> report = generate_comparison_report(baseline, current, "comparison.pdf")
 """
 
-from __future__ import annotations
-
 from typing import Any, Literal
 
 from oscura.reporting.core import Report, ReportConfig, Section

oscura/reporting/config.py

@@ -594,7 +594,7 @@ def get_available_analyses(input_type: InputType) -> list[AnalysisDomain]:
 
 
 # Type alias for progress callbacks
-ProgressCallback = Callable[[ProgressInfo], None]
+ProgressCallback = Callable[["ProgressInfo"], None]
 
 
 __all__ = [

oscura/reporting/formatting/emphasis.py

@@ -3,6 +3,8 @@
 Simple text formatting for terminal output.
 """
 
+from __future__ import annotations
+
 from enum import Enum
 
 

oscura/reporting/formatting/numbers.py

@@ -4,8 +4,6 @@ Provides comprehensive number formatting with SI prefixes, engineering notation,
 locale support, and specification comparison capabilities.
 """
 
-from __future__ import annotations
-
 import math
 from datetime import datetime
 from typing import ClassVar

oscura/reporting/output.py

@@ -4,8 +4,6 @@ This module provides directory structure and file management for analysis
 report outputs, including plots, JSON/YAML data exports, and logs.
 """
 
-from __future__ import annotations
-
 import json
 from datetime import datetime
 from pathlib import Path
@@ -14,7 +12,7 @@ from typing import Any
 import numpy as np
 import yaml
 
-from oscura.reporting.config import AnalysisDomain  # noqa: TC001
+from oscura.reporting.config import AnalysisDomain
 
 
 def _sanitize_for_serialization(obj: Any, max_depth: int = 10) -> Any:

oscura/reporting/sections.py

@@ -9,8 +9,6 @@ Example:
     >>> section = create_title_section("Signal Analysis Report", author="Engineer")
 """
 
-from __future__ import annotations
-
 from datetime import datetime
 from typing import Any
 

oscura/search/anomaly.py

@@ -4,6 +4,8 @@ This module provides automated detection of glitches, timing violations,
 and protocol errors with context extraction for debugging.
 """
 
+from __future__ import annotations
+
 from typing import Any
 
 import numpy as np