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

oscura/automotive/dtc/data.json

@@ -266,12 +266,7 @@
       "category": "Powertrain",
       "severity": "High",
       "system": "Throttle Control",
-      "possible_causes": [
-        "TPS circuit shorted to voltage",
-        "Faulty TPS sensor",
-        "Wiring harness open",
-        "ECM problem"
-      ]
+      "possible_causes": ["TPS circuit shorted to voltage", "Faulty TPS sensor", "Wiring harness open", "ECM problem"]
     },
     "P0125": {
       "code": "P0125",
@@ -865,12 +860,7 @@
       "category": "Powertrain",
       "severity": "Medium",
       "system": "Emissions Control",
-      "possible_causes": [
-        "EGR valve stuck closed",
-        "EGR passages clogged",
-        "Faulty EGR valve",
-        "Vacuum leak"
-      ]
+      "possible_causes": ["EGR valve stuck closed", "EGR passages clogged", "Faulty EGR valve", "Vacuum leak"]
     },
     "P0401": {
       "code": "P0401",
@@ -891,12 +881,7 @@
       "category": "Powertrain",
       "severity": "Medium",
       "system": "Emissions Control",
-      "possible_causes": [
-        "EGR valve stuck open",
-        "Faulty EGR valve",
-        "EGR vacuum solenoid fault",
-        "ECM problem"
-      ]
+      "possible_causes": ["EGR valve stuck open", "Faulty EGR valve", "EGR vacuum solenoid fault", "ECM problem"]
     },
     "P0403": {
       "code": "P0403",
@@ -958,12 +943,7 @@
       "category": "Powertrain",
       "severity": "Low",
       "system": "Emissions Control",
-      "possible_causes": [
-        "Loose or missing fuel cap",
-        "EVAP system leak",
-        "Faulty purge valve",
-        "Faulty vent valve"
-      ]
+      "possible_causes": ["Loose or missing fuel cap", "EVAP system leak", "Faulty purge valve", "Faulty vent valve"]
     },
     "P0441": {
       "code": "P0441",
@@ -1075,12 +1055,7 @@
       "category": "Powertrain",
       "severity": "Low",
       "system": "Idle Control",
-      "possible_causes": [
-        "Vacuum leak",
-        "IAC valve fault",
-        "Dirty throttle body",
-        "PCV valve problem"
-      ]
+      "possible_causes": ["Vacuum leak", "IAC valve fault", "Dirty throttle body", "PCV valve problem"]
     },
     "P0507": {
       "code": "P0507",
@@ -1088,12 +1063,7 @@
       "category": "Powertrain",
       "severity": "Low",
       "system": "Idle Control",
-      "possible_causes": [
-        "Vacuum leak",
-        "IAC valve stuck open",
-        "PCV valve stuck open",
-        "EVAP purge valve leaking"
-      ]
+      "possible_causes": ["Vacuum leak", "IAC valve stuck open", "PCV valve stuck open", "EVAP purge valve leaking"]
     },
     "P0600": {
       "code": "P0600",
@@ -1127,12 +1097,7 @@
       "category": "Powertrain",
       "severity": "Critical",
       "system": "Engine Control Module",
-      "possible_causes": [
-        "ECM not programmed",
-        "ECM programming incomplete",
-        "Wrong software version",
-        "ECM fault"
-      ]
+      "possible_causes": ["ECM not programmed", "ECM programming incomplete", "Wrong software version", "ECM fault"]
     },
     "P0603": {
       "code": "P0603",
@@ -1205,12 +1170,7 @@
       "category": "Powertrain",
       "severity": "Medium",
       "system": "Charging System",
-      "possible_causes": [
-        "Faulty alternator",
-        "Wiring harness problem",
-        "Poor electrical connection",
-        "ECM fault"
-      ]
+      "possible_causes": ["Faulty alternator", "Wiring harness problem", "Poor electrical connection", "ECM fault"]
     },
     "P0625": {
       "code": "P0625",
@@ -1283,12 +1243,7 @@
       "category": "Powertrain",
       "severity": "High",
       "system": "Transmission",
-      "possible_causes": [
-        "Faulty input speed sensor",
-        "Wiring harness problem",
-        "Sensor reluctor damaged",
-        "TCM fault"
-      ]
+      "possible_causes": ["Faulty input speed sensor", "Wiring harness problem", "Sensor reluctor damaged", "TCM fault"]
     },
     "P0720": {
       "code": "P0720",
@@ -1491,12 +1446,7 @@
       "category": "Chassis",
       "severity": "High",
       "system": "ABS",
-      "possible_causes": [
-        "Faulty valve relay",
-        "Relay circuit problem",
-        "ABS module fault",
-        "Wiring harness issue"
-      ]
+      "possible_causes": ["Faulty valve relay", "Relay circuit problem", "ABS module fault", "Wiring harness issue"]
     },
     "C0161": {
       "code": "C0161",
@@ -2206,12 +2156,7 @@
       "category": "Body",
       "severity": "Low",
       "system": "Lighting System",
-      "possible_causes": [
-        "Burned out bulb",
-        "Wiring harness problem",
-        "Lamp socket corrosion",
-        "BCM fault"
-      ]
+      "possible_causes": ["Burned out bulb", "Wiring harness problem", "Lamp socket corrosion", "BCM fault"]
     },
     "B0601": {
       "code": "B0601",
@@ -2232,12 +2177,7 @@
       "category": "Body",
       "severity": "Low",
       "system": "Lighting System",
-      "possible_causes": [
-        "Burned out turn signal bulb",
-        "Wiring harness problem",
-        "Flasher relay fault",
-        "BCM fault"
-      ]
+      "possible_causes": ["Burned out turn signal bulb", "Wiring harness problem", "Flasher relay fault", "BCM fault"]
     },
     "B0603": {
       "code": "B0603",
@@ -2245,12 +2185,7 @@
       "category": "Body",
       "severity": "Low",
       "system": "Lighting System",
-      "possible_causes": [
-        "Burned out turn signal bulb",
-        "Wiring harness problem",
-        "Flasher relay fault",
-        "BCM fault"
-      ]
+      "possible_causes": ["Burned out turn signal bulb", "Wiring harness problem", "Flasher relay fault", "BCM fault"]
     },
     "B0604": {
       "code": "B0604",
@@ -2362,12 +2297,7 @@
       "category": "Body",
       "severity": "Low",
       "system": "Keyless Entry",
-      "possible_causes": [
-        "Key fob battery weak",
-        "Key fob not synchronized",
-        "BCM fault",
-        "Receiver antenna fault"
-      ]
+      "possible_causes": ["Key fob battery weak", "Key fob not synchronized", "BCM fault", "Receiver antenna fault"]
     },
     "B1300": {
       "code": "B1300",
@@ -2466,12 +2396,7 @@
       "category": "Network",
       "severity": "Critical",
       "system": "CAN Bus",
-      "possible_causes": [
-        "TCM not powered",
-        "CAN bus wiring problem",
-        "TCM internal fault",
-        "CAN bus short circuit"
-      ]
+      "possible_causes": ["TCM not powered", "CAN bus wiring problem", "TCM internal fault", "CAN bus short circuit"]
     },
     "U0102": {
       "code": "U0102",
@@ -2544,12 +2469,7 @@
       "category": "Network",
       "severity": "High",
       "system": "CAN Bus",
-      "possible_causes": [
-        "BCM not powered",
-        "CAN bus wiring problem",
-        "BCM internal fault",
-        "Ground connection issue"
-      ]
+      "possible_causes": ["BCM not powered", "CAN bus wiring problem", "BCM internal fault", "Ground connection issue"]
     },
     "U0141": {
       "code": "U0141",
@@ -2557,12 +2477,7 @@
       "category": "Network",
       "severity": "High",
       "system": "CAN Bus",
-      "possible_causes": [
-        "BCM not powered",
-        "CAN bus wiring problem",
-        "Module internal fault",
-        "Connector problem"
-      ]
+      "possible_causes": ["BCM not powered", "CAN bus wiring problem", "Module internal fault", "Connector problem"]
     },
     "U0151": {
       "code": "U0151",

oscura/automotive/flexray/fibex.py

@@ -299,7 +299,15 @@ class FIBEXImporter:
         if not fibex_path.exists():
             raise FileNotFoundError(f"FIBEX file not found: {fibex_path}")
 
-        tree = ET.parse(fibex_path)
+        # SEC-004: Protect against XXE attacks by disabling entity expansion
+        parser = ET.XMLParser()
+        try:
+            # Python < 3.12: entity attribute is writable
+            parser.entity = {}  # type: ignore[misc]
+        except AttributeError:
+            # Python >= 3.12: entity attribute is read-only, default behavior is safe
+            pass
+        tree = ET.parse(fibex_path, parser=parser)
         root = tree.getroot()
 
         # Extract cluster configuration

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