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

oscura/automotive/dbc/__init__.py

@@ -3,10 +3,18 @@
 This module provides DBC file parsing and generation capabilities.
 """
 
-__all__ = ["DBCGenerator", "DBCParser", "load_dbc"]
+__all__ = ["DBCGenerator", "DBCMessage", "DBCNode", "DBCParser", "DBCSignal", "load_dbc"]
 
 try:
-    from oscura.automotive.dbc.generator import DBCGenerator
+    # Import comprehensive DBC generator from new location
+    from oscura.automotive.can.dbc_generator import (
+        DBCGenerator,
+        DBCMessage,
+        DBCNode,
+        DBCSignal,
+    )
+
+    # Parser stays in dbc module
     from oscura.automotive.dbc.parser import DBCParser, load_dbc
 except ImportError:
     # Optional dependencies not installed

oscura/automotive/dbc/generator.py

@@ -1,7 +1,10 @@
-"""DBC file generator from discovery documents.
+"""DBC file generator wrapper for backward compatibility.
 
-This module generates standard DBC files from Oscura discovery documents,
-enabling export of reverse-engineered protocols to industry-standard format.
+This module provides a backward-compatible wrapper around the comprehensive
+DBC generator in oscura.automotive.can.dbc_generator, supporting the legacy
+static method API used by existing code.
+
+For new code, import directly from oscura.automotive.can.dbc_generator instead.
 """
 
 from __future__ import annotations
@@ -10,16 +13,29 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from oscura.automotive.can.discovery import (
-        DiscoveryDocument,
-    )
+    from oscura.automotive.can.discovery import DiscoveryDocument
     from oscura.automotive.can.session import CANSession
 
+from oscura.automotive.can.dbc_generator import (
+    DBCGenerator as _DBCGeneratorImpl,
+)
+from oscura.automotive.can.dbc_generator import (
+    DBCMessage,
+    DBCSignal,
+)
+
 __all__ = ["DBCGenerator"]
 
 
 class DBCGenerator:
-    """Generate DBC files from discovery documents."""
+    """Backward-compatible DBC generator wrapper.
+
+    This class provides static methods for generating DBC files from
+    DiscoveryDocument and CANSession objects, maintaining API compatibility
+    with the original implementation.
+
+    For new code, use oscura.automotive.can.dbc_generator.DBCGenerator directly.
+    """
 
     @staticmethod
     def generate(
@@ -35,70 +51,76 @@ class DBCGenerator:
             output_path: Output DBC file path.
             min_confidence: Minimum confidence threshold for including signals.
             include_comments: Include evidence as comments in DBC.
+
+        Example:
+            >>> from oscura.automotive.can.discovery import DiscoveryDocument
+            >>> doc = DiscoveryDocument()
+            >>> # ... add messages and signals ...
+            >>> DBCGenerator.generate(doc, "output.dbc")
         """
-        path = Path(output_path)
 
-        lines = []
+        path = Path(output_path)
 
-        # DBC header
-        lines.append('VERSION ""')
-        lines.append("")
-        lines.append("NS_ :")
-        lines.append("")
-        lines.append("BS_:")
-        lines.append("")
-        lines.append("BU_:")  # No nodes defined
-        lines.append("")
+        # Create instance of new generator
+        gen = _DBCGeneratorImpl()
 
-        # Generate messages
-        for msg in sorted(discovery.messages.values(), key=lambda m: m.id):
+        # Convert discovery document to DBC format
+        for msg_id, msg_discovery in sorted(discovery.messages.items()):
             # Filter signals by confidence
-            signals = [s for s in msg.signals if s.confidence >= min_confidence]
+            signals = [s for s in msg_discovery.signals if s.confidence >= min_confidence]
 
             if not signals:
                 continue  # Skip messages with no high-confidence signals
 
-            # Message definition
-            # Format: BO_ <ID> <Name>: <DLC> <Transmitter>
-            transmitter = msg.transmitter if msg.transmitter else "Vector__XXX"
-            lines.append(f"BO_ {msg.id} {msg.name}: {msg.length} {transmitter}")
-
-            # Signals
+            # Convert signals to DBC format
+            dbc_signals = []
             for sig in signals:
-                # Format: SG_ <Name> : <StartBit>|<Length>@<ByteOrder><ValueType> (<Scale>,<Offset>) [<Min>|<Max>] "<Unit>" <Receiver>
-                byte_order = "0" if sig.byte_order == "big_endian" else "1"
-                value_type = "+" if sig.value_type == "unsigned" else "-"
-
-                min_val = sig.min_value if sig.min_value is not None else 0
-                max_val = sig.max_value if sig.max_value is not None else 0
-
-                signal_line = (
-                    f" SG_ {sig.name} : {sig.start_bit}|{sig.length}@{byte_order}{value_type} "
-                    f"({sig.scale},{sig.offset}) [{min_val}|{max_val}] "
-                    f'"{sig.unit}" Vector__XXX'
+                # Convert value_type: DBC only supports unsigned/signed, not float
+                # Floats are typically represented as unsigned in DBC
+                value_type: str = sig.value_type
+                if value_type not in ("unsigned", "signed"):
+                    value_type = "unsigned"
+
+                dbc_sig = DBCSignal(
+                    name=sig.name,
+                    start_bit=sig.start_bit,
+                    bit_length=sig.length,
+                    byte_order=sig.byte_order,
+                    value_type=value_type,  # type: ignore[arg-type]
+                    factor=sig.scale,
+                    offset=sig.offset,
+                    min_value=sig.min_value if sig.min_value is not None else 0.0,
+                    max_value=sig.max_value if sig.max_value is not None else 0.0,
+                    unit=sig.unit,
+                    receivers=["Vector__XXX"],
+                    comment="; ".join(sig.evidence) if include_comments and sig.evidence else "",
                 )
-
-                lines.append(signal_line)
-
-                # Add comment if evidence exists
-                if include_comments and sig.evidence:
-                    evidence_str = "; ".join(sig.evidence)
-                    # DBC comments format: CM_ SG_ <ID> <SignalName> "<Comment>";
-                    comment_line = f'CM_ SG_ {msg.id} {sig.name} "{evidence_str}";'
-                    lines.append("")
-                    lines.append(comment_line)
-
-            lines.append("")
-
-        # Write file with latin-1 encoding (DBC standard)
-        with open(path, "w", encoding="latin-1") as f:
-            f.write("\n".join(lines))
+                dbc_signals.append(dbc_sig)
+
+            # Create DBC message
+            dbc_msg = DBCMessage(
+                message_id=msg_id,
+                name=msg_discovery.name,
+                dlc=msg_discovery.length,
+                sender=msg_discovery.transmitter if msg_discovery.transmitter else "Vector__XXX",
+                signals=dbc_signals,
+                comment=msg_discovery.comment if msg_discovery.comment else "",
+                cycle_time=int(msg_discovery.cycle_time_ms)
+                if msg_discovery.cycle_time_ms is not None
+                else None,
+                send_type="Cyclic",
+            )
+
+            gen.add_message(dbc_msg)
+
+        # Generate DBC file
+        gen.generate(path)
 
     @staticmethod
     def generate_from_session(
         session: CANSession,
         output_path: Path | str,
-        min_confidence: float = 0.8,  # noqa: ARG004 - API compatibility parameter
+        min_confidence: float = 0.8,  # Reserved for future use
     ) -> None:
         """Generate DBC file from CANSession with documented signals.
 
@@ -106,6 +128,12 @@ class DBCGenerator:
             session: CANSession with documented signals.
             output_path: Output DBC file path.
             min_confidence: Minimum confidence threshold (reserved for future use).
+
+        Example:
+            >>> from oscura.automotive.can.session import CANSession
+            >>> session = CANSession.from_file("capture.blf")
+            >>> # ... document signals ...
+            >>> DBCGenerator.generate_from_session(session, "output.dbc")
         """
         from oscura.automotive.can.discovery import (
             DiscoveryDocument,
@@ -152,5 +180,5 @@ class DBCGenerator:
                 # Skip messages without documented signals
                 pass
 
-        # Generate DBC
+        # Generate DBC using main method
         DBCGenerator.generate(doc, output_path, min_confidence=0.0)

oscura/automotive/dbc/parser.py

@@ -30,7 +30,7 @@ class DBCParser:
             FileNotFoundError: If DBC file doesn't exist.
         """
         try:
-            import cantools  # type: ignore[import-untyped]
+            import cantools
         except ImportError as e:
             raise ImportError(
                 "cantools is required for DBC file support. "
@@ -58,7 +58,7 @@ class DBCParser:
         """
         # Get message definition from DBC
         try:
-            msg_def = self.db.get_message_by_frame_id(message.arbitration_id)  # type: ignore[union-attr]
+            msg_def = self.db.get_message_by_frame_id(message.arbitration_id)
         except KeyError as e:
             raise KeyError(f"Message ID 0x{message.arbitration_id:03X} not found in DBC") from e
 
@@ -70,7 +70,7 @@ class DBCParser:
 
         # Convert to DecodedSignal objects
         signals = {}
-        for signal_name, value in decoded_data.items():  # type: ignore[union-attr]
+        for signal_name, value in decoded_data.items():
             # Get signal definition from DBC
             signal_def = msg_def.get_signal_by_name(signal_name)
 
@@ -94,7 +94,7 @@ class DBCParser:
             # Create DecodedSignal
             decoded_sig = DecodedSignal(
                 name=signal_name,
-                value=float(value),  # type: ignore[arg-type]
+                value=float(value),
                 unit=sig_def.unit,
                 timestamp=message.timestamp,
                 definition=sig_def,
@@ -110,7 +110,7 @@ class DBCParser:
         Returns:
             Set of CAN arbitration IDs.
         """
-        return {msg.frame_id for msg in self.db.messages}  # type: ignore[union-attr]
+        return {msg.frame_id for msg in self.db.messages}
 
     def get_message_name(self, arbitration_id: int) -> str | None:
         """Get message name from DBC.
@@ -122,7 +122,7 @@ class DBCParser:
             Message name or None if not found.
         """
         try:
-            msg = self.db.get_message_by_frame_id(arbitration_id)  # type: ignore[union-attr]
+            msg = self.db.get_message_by_frame_id(arbitration_id)
             return str(msg.name)  # Explicit cast to str
         except KeyError:
             return None