oscura 0.8.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

oscura/automotive/uds/decoder.py

@@ -5,6 +5,7 @@ This module implements decoding for UDS diagnostic messages used in automotive E
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -12,7 +13,26 @@ if TYPE_CHECKING:
 
 from oscura.automotive.uds.models import UDSNegativeResponse, UDSService
 
-__all__ = ["UDSDecoder"]
+__all__ = ["UDSDecoder", "UDSResponse"]
+
+
+@dataclass
+class UDSResponse:
+    """A decoded UDS response message.
+
+    Attributes:
+        service: Service ID.
+        data: Response data payload.
+        timestamp: Message timestamp.
+        is_negative: True if negative response (NRC).
+        nrc: Negative Response Code (if is_negative=True).
+    """
+
+    service: int
+    data: bytes
+    timestamp: float
+    is_negative: bool = False
+    nrc: int | None = None
 
 
 # Service ID mappings per ISO 14229-1
@@ -146,6 +166,58 @@ class UDSDecoder:
 
         return False
 
+    @staticmethod
+    def decode(message: CANMessage) -> UDSResponse | None:
+        """Decode UDS message from CAN message (returns UDSResponse).
+
+        Args:
+            message: CAN message to decode.
+
+        Returns:
+            UDSResponse with decoded information, or None if not a valid UDS message.
+
+        Example:
+            >>> msg = CANMessage(id=0x7E0, timestamp=1.0, data=bytes([0x02, 0x10, 0x01]))
+            >>> response = UDSDecoder.decode(msg)
+            >>> print(f"Service: 0x{response.service:02X}")
+        """
+        if len(message.data) < 2:
+            return None
+
+        # Extract UDS payload from ISO-TP frame if needed
+        data = UDSDecoder._extract_uds_payload(message.data)
+        if not data:
+            return None
+
+        # Check for negative response
+        if data[0] == 0x7F:
+            neg_resp = UDSDecoder._decode_negative_response(data)
+            if neg_resp is None:
+                return None
+            return UDSResponse(
+                service=0x7F,
+                data=data,
+                timestamp=message.timestamp,
+                is_negative=True,
+                nrc=neg_resp.nrc,
+            )
+
+        # Determine SID and request/response type
+        sid_info = UDSDecoder._parse_sid_byte(data[0])
+        if sid_info is None:
+            return None
+
+        sid, canonical_sid, is_request = sid_info
+
+        # Return UDSResponse
+        return UDSResponse(
+            service=sid,
+            data=data,
+            timestamp=message.timestamp,
+            is_negative=False,
+            nrc=None,
+        )
+
     @staticmethod
     def decode_service(message: CANMessage) -> UDSService | UDSNegativeResponse | None:
         """Decode UDS service from CAN message.
@@ -198,7 +270,11 @@ class UDSDecoder:
     def _extract_uds_payload(message_data: bytes) -> bytes:
         """Extract UDS payload from CAN message data.
 
-        Handles ISO-TP single frame format (first byte ≤0x07 indicates length).
+        Handles ISO-TP frame formats:
+        - Single frame: 0x0X (X = length)
+        - First frame: 0x1X (X = upper nibble of length)
+        - Consecutive frame: 0x2X (X = sequence number)
+        - Flow control: 0x3X
 
         Args:
             message_data: Raw CAN message data.
@@ -206,14 +282,31 @@ class UDSDecoder:
         Returns:
             UDS payload bytes (empty if invalid).
         """
-        if message_data[0] <= 0x07:
-            # ISO-TP single frame: [length, ...UDS data...]
-            uds_length = message_data[0]
+        pci = message_data[0]
+        pci_type = (pci >> 4) & 0x0F
+
+        if pci_type == 0:
+            # ISO-TP single frame: [0x0X, ...UDS data...]
+            uds_length = pci & 0x0F
+            if len(message_data) < 1 + uds_length:
+                return b""
+            return message_data[1 : 1 + uds_length]
+        elif pci_type == 1:
+            # ISO-TP first frame: [0x1X, length_low, ...UDS data...]
+            # Skip PCI bytes (2 bytes) and return remaining as UDS payload
+            return message_data[2:]
+        elif pci_type == 2:
+            # ISO-TP consecutive frame: [0x2X, ...data...]
+            # Skip PCI byte and return data (but this is continuation, not standalone UDS)
+            return message_data[1:]
+        elif pci <= 0x07:
+            # Legacy single frame format (for compatibility)
+            uds_length = pci
             if len(message_data) < 1 + uds_length:
                 return b""
             return message_data[1 : 1 + uds_length]
         else:
-            # Direct UDS: all bytes are UDS data
+            # Direct UDS or unknown format: treat all bytes as UDS data
             return message_data
 
     @staticmethod

oscura/cli/analyze.py

@@ -222,14 +222,20 @@ def _characterize_signal(trace: Any) -> dict[str, Any]:
 
     rt = rise_time(trace)
     ft = fall_time(trace)
+    rt_val = rt["value"] if rt["applicable"] else None
+    ft_val = ft["value"] if ft["applicable"] else None
 
     return {
         "sample_rate": f"{sample_rate / 1e6:.1f} MHz",
         "samples": len(data),
         "duration": f"{len(data) / sample_rate * 1e3:.3f} ms",
         "amplitude": f"{float(data.max() - data.min()):.3f} V",
-        "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",
+        "rise_time": f"{rt_val * 1e9:.2f} ns"
+        if rt_val is not None and not np.isnan(rt_val)
+        else "N/A",
+        "fall_time": f"{ft_val * 1e9:.2f} ns"
+        if ft_val is not None and not np.isnan(ft_val)
+        else "N/A",
     }
 
 

oscura/cli/batch.py

@@ -169,17 +169,37 @@ def _analyze_single_file(file_path: str, analysis_type: str) -> dict[str, Any]:
         "file": str(Path(file_path).name),
         "status": "success",
         "analysis_type": analysis_type,
-        "samples": len(trace.data),  # type: ignore[union-attr]
+        "samples": len(trace.data),
         "sample_rate": f"{sample_rate / 1e6:.1f} MHz",
     }
 
     if analysis_type == "characterize":
         rt = rise_time(trace)  # type: ignore[arg-type]
         ft = fall_time(trace)  # type: ignore[arg-type]
+
+        # Handle both MeasurementResult dict and raw float/nan values (for test compatibility)
+        if isinstance(rt, dict):
+            rt_val = rt["value"] if rt.get("applicable", True) else None
+        elif isinstance(rt, (int, float)):  # type: ignore[unreachable]
+            rt_val = rt
+        else:
+            rt_val = None
+
+        if isinstance(ft, dict):
+            ft_val = ft["value"] if ft.get("applicable", True) else None
+        elif isinstance(ft, (int, float)):  # type: ignore[unreachable]
+            ft_val = ft
+        else:
+            ft_val = None
+
         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",
+                "rise_time": f"{rt_val * 1e9:.2f} ns"
+                if rt_val is not None and not np.isnan(rt_val)
+                else "N/A",
+                "fall_time": f"{ft_val * 1e9:.2f} ns"
+                if ft_val is not None and not np.isnan(ft_val)
+                else "N/A",
             }
         )
     elif analysis_type == "decode":
@@ -197,11 +217,22 @@ def _analyze_single_file(file_path: str, analysis_type: str) -> dict[str, Any]:
             peak_freq = freqs[peak_idx]
         else:
             peak_freq = 0.0
-        thd_val = thd(trace)  # type: ignore[arg-type]
+        thd_result = thd(trace)  # type: ignore[arg-type]
+
+        # Handle both MeasurementResult dict and raw float/nan values (for test compatibility)
+        if isinstance(thd_result, dict):
+            thd_val = thd_result["value"] if thd_result.get("applicable", True) else None
+        elif isinstance(thd_result, (int, float)):  # type: ignore[unreachable]
+            thd_val = thd_result
+        else:
+            thd_val = None
+
         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",
+                "thd": f"{thd_val:.1f} dB"
+                if thd_val is not None and not np.isnan(thd_val)
+                else "N/A",
             }
         )
 

oscura/cli/characterize.py

@@ -243,12 +243,26 @@ def _add_buffer_results(results: dict[str, Any], trace: Any, logic_family: str)
     os_pct = overshoot(trace)
     us_pct = undershoot(trace)
 
+    # Extract values from MeasurementResult dicts
+    rt_val = rt["value"] if isinstance(rt, dict) and rt.get("applicable") else None
+    ft_val = ft["value"] if isinstance(ft, dict) and ft.get("applicable") else None
+    os_val = os_pct["value"] if isinstance(os_pct, dict) and os_pct.get("applicable") else None
+    us_val = us_pct["value"] if isinstance(us_pct, dict) and us_pct.get("applicable") else None
+
     results.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",
-            "overshoot": f"{os_pct:.1f} %" if not np.isnan(os_pct) else "N/A",
-            "undershoot": f"{us_pct:.1f} %" if not np.isnan(us_pct) else "N/A",
+            "rise_time": f"{rt_val * 1e9:.2f} ns"
+            if rt_val is not None and not np.isnan(rt_val)
+            else "N/A",
+            "fall_time": f"{ft_val * 1e9:.2f} ns"
+            if ft_val is not None and not np.isnan(ft_val)
+            else "N/A",
+            "overshoot": f"{os_val:.1f} %"
+            if os_val is not None and not np.isnan(os_val)
+            else "N/A",
+            "undershoot": f"{us_val:.1f} %"
+            if us_val is not None and not np.isnan(us_val)
+            else "N/A",
             "status": "PASS",
         }
     )

oscura/cli/export.py

@@ -195,14 +195,56 @@ def _export_csv(session: Any, output_path: Path) -> None:
 
 
 def _export_matlab(session: Any, output_path: Path) -> None:
-    """Export to MATLAB format.
+    """Export to MATLAB .mat format.
+
+    Exports session data and traces to MATLAB-compatible .mat file using scipy.
 
     Args:
-        session: Session object.
-        output_path: Output file path.
+        session: Session object with traces attribute.
+        output_path: Output file path (.mat extension).
+
+    Raises:
+        ImportError: If scipy is not installed.
     """
-    # MATLAB export has been redesigned - use new AnalysisSession API
-    raise NotImplementedError("MATLAB export needs reimplementation with new API")
+    try:
+        from scipy.io import savemat
+    except ImportError as e:
+        raise ImportError(
+            "scipy is required for MATLAB export. Install with: pip install scipy"
+        ) from e
+
+    import numpy as np
+
+    # Collect data to export
+    matlab_data: dict[str, Any] = {}
+
+    # Export traces if available
+    if hasattr(session, "traces") and session.traces:
+        for i, trace in enumerate(session.traces):
+            trace_name = f"trace_{i + 1}"
+            if hasattr(trace, "data"):
+                matlab_data[f"{trace_name}_data"] = np.asarray(trace.data)
+            if hasattr(trace, "metadata") and hasattr(trace.metadata, "sample_rate"):
+                matlab_data[f"{trace_name}_sample_rate"] = trace.metadata.sample_rate
+
+    # Export results if available
+    if hasattr(session, "results") and session.results:
+        if isinstance(session.results, dict):
+            for key, value in session.results.items():
+                # Convert to numpy-compatible format
+                if isinstance(value, (int, float, bool)):
+                    matlab_data[key] = value
+                elif isinstance(value, (list, tuple)):
+                    matlab_data[key] = np.array(value)
+                elif isinstance(value, np.ndarray):
+                    matlab_data[key] = value
+
+    if not matlab_data:
+        matlab_data["message"] = "No data available for export"
+
+    # Save to .mat file
+    savemat(str(output_path), matlab_data)
+    click.echo(f"✓ Exported to MATLAB: {output_path}")
 
 
 def _export_wireshark(session: Any, output_path: Path) -> None:

oscura/cli/main.py

@@ -248,6 +248,7 @@ from oscura.cli.compare import compare
 from oscura.cli.config_cmd import config as config_cmd
 from oscura.cli.decode import decode
 from oscura.cli.export import export
+from oscura.cli.pipeline import pipeline
 from oscura.cli.validate_cmd import validate
 from oscura.cli.visualize import visualize
 
@@ -312,6 +313,7 @@ cli.add_command(config_cmd, name="config")
 cli.add_command(characterize)  # type: ignore[has-type]
 cli.add_command(batch)  # type: ignore[has-type]
 cli.add_command(compare)  # type: ignore[has-type]
+cli.add_command(pipeline)  # type: ignore[has-type]
 cli.add_command(shell)
 cli.add_command(tutorial)
 

oscura/cli/onboarding/wizard.py

@@ -224,8 +224,8 @@ class AnalysisWizard:
                 else:
                     print(f"  Sample rate: {rate / 1e3:.3f} kSa/s")
 
-            if hasattr(meta, "channel_name") and meta.channel_name:
-                print(f"  Channel: {meta.channel_name}")
+            if hasattr(meta, "channel") and meta.channel:
+                print(f"  Channel: {meta.channel}")
 
         if hasattr(trace, "data"):
             import numpy as np
@@ -375,13 +375,17 @@ class AnalysisWizard:
                 print(f"  SNR: {snr_val:.1f} dB")
 
                 # Recommendations based on quality
-                if thd_val > -40:
+                # Extract values from MeasurementResult dicts
+                thd_value = thd_val["value"] if isinstance(thd_val, dict) else thd_val
+                snr_value = snr_val["value"] if isinstance(snr_val, dict) else snr_val
+
+                if thd_value is not None and thd_value > -40:
                     self.result.recommendations.append(
-                        f"THD is {thd_val:.1f} dB - consider filtering to reduce distortion"
+                        f"THD is {thd_value:.1f} dB - consider filtering to reduce distortion"
                     )
-                if snr_val < 40:
+                if snr_value is not None and snr_value < 40:
                     self.result.recommendations.append(
-                        f"SNR is {snr_val:.1f} dB - signal is noisy, try averaging or filtering"
+                        f"SNR is {snr_value:.1f} dB - signal is noisy, try averaging or filtering"
                     )
 
             if choice in (2, 3):  # Anomalies