pyfastnet 2.0.1__tar.gz → 2.0.2__tar.gz

{pyfastnet-2.0.1/pyfastnet.egg-info → pyfastnet-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfastnet
-Version: 2.0.1
+Version: 2.0.2
 Summary: A Python library for decoding FastNet protocol data streams.
 Home-page: https://github.com/ghotihook/pyfastnet
 Author: Alex Salmon

{pyfastnet-2.0.1 → pyfastnet-2.0.2}/fastnet_decoder/decode_fastnet.py

@@ -24,8 +24,6 @@ def _display_from_layout(layout: str, formatted: str) -> str:
 
 def decode_frame(frame: bytes) -> dict:
     try:
-        logger.debug(f"Starting frame decoding. Frame length: {len(frame)}, Frame contents: {frame.hex()}")
-
         to_address      = frame[0]
         from_address    = frame[1]
         body_size       = frame[2]
@@ -34,76 +32,75 @@ def decode_frame(frame: bytes) -> dict:
         body            = frame[5:-1]
         body_checksum   = frame[-1]
 
-        logger.debug(
-            f"Parsed header: to_address=0x{to_address:02X}, from_address=0x{from_address:02X}, "
-            f"body_size={body_size}, command=0x{command:02X}, header_checksum=0x{header_checksum:02X}"
-        )
-
         if calculate_checksum(frame[:4]) != header_checksum:
-            logger.debug(f"Header checksum mismatch. Frame dropped: {frame.hex()}")
+            logger.debug(f"FRAME discard  header-checksum  [{frame.hex()[:16]}...]")
             return {"error": "Header checksum mismatch"}
 
         if calculate_checksum(body) != body_checksum:
-            logger.debug(f"Body checksum mismatch. Frame dropped: {frame.hex()}")
+            logger.debug(f"FRAME discard  body-checksum  [{frame.hex()[:16]}...]")
             return {"error": "Body checksum mismatch"}
 
         if len(body) < 2 or len(body) != body_size:
-            logger.debug(f"Invalid body size: Expected {body_size}, Actual {len(body)}. Frame: {frame.hex()}")
+            logger.debug(f"FRAME discard  body-size  expected={body_size}  actual={len(body)}")
             return {"error": "Invalid body size"}
 
-        logger.debug("Header and body checksums are valid.")
-
         decoded_data = {
-            "to_address":  ADDRESS_LOOKUP.get(to_address,   f"Unknown (0x{to_address:02X})"),
+            "to_address":   ADDRESS_LOOKUP.get(to_address,   f"Unknown (0x{to_address:02X})"),
             "from_address": ADDRESS_LOOKUP.get(from_address, f"Unknown (0x{from_address:02X})"),
-            "command":     COMMAND_LOOKUP.get(command,       f"Unknown (0x{command:02X})"),
-            "values":      {}
+            "command":      COMMAND_LOOKUP.get(command,       f"Unknown (0x{command:02X})"),
+            "values":       {}
         }
 
         index = 0
         while index < len(body):
             if index + 1 >= len(body):
-                logger.debug(
-                    f"Insufficient bytes to decode channel ID and format byte at index {index}. "
-                    f"Remaining length: {len(body) - index}"
-                )
+                logger.debug(f"  CH  incomplete header at index={index}")
                 return {"error": "Insufficient bytes for channel header"}
 
-            channel_id  = body[index]
-            format_byte = body[index + 1]
-            index      += 2
+            channel_id   = body[index]
+            format_byte  = body[index + 1]
+            channel_name = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
+            index       += 2
 
             data_length = FORMAT_SIZE_MAP.get(format_byte & 0x0F, 0)
             if index + data_length > len(body):
                 logger.debug(
-                    f"Incomplete data for channel 0x{channel_id:02X}. "
-                    f"Expected length: {data_length}, Available: {len(body) - index}"
+                    f"  CH  0x{channel_id:02X} {channel_name}  "
+                    f"incomplete  need={data_length}B  have={len(body) - index}B"
                 )
                 return {"error": f"Incomplete data for channel 0x{channel_id:02X}"}
 
             data_bytes = body[index:index + data_length]
             index     += data_length
 
-            decoded_value = decode_format_and_data(channel_id, format_byte, data_bytes)
-            channel_name  = CHANNEL_LOOKUP.get(channel_id, f"Unknown (0x{channel_id:02X})")
+            logger.debug(
+                f"  CH  0x{channel_id:02X} {channel_name}  "
+                f"fmt=0x{format_byte:02X}  data=[{data_bytes.hex()}]"
+            )
 
+            decoded_value = decode_format_and_data(channel_id, format_byte, data_bytes)
             decoded_data["values"][channel_name] = decoded_value
-            logger.debug(f"Decoded value for channel {channel_name}: {decoded_value}")
+
+            if decoded_value:
+                logger.debug(
+                    f"       value={decoded_value['value']}  "
+                    f"display='{decoded_value['display_text']}'  "
+                    f"layout={decoded_value['layout']}"
+                )
 
         return decoded_data
 
     except Exception as e:
-        logger.error(f"Unexpected error during frame decoding: {e}. Frame contents: {frame.hex()}")
+        logger.error(f"Unexpected error decoding frame: {e}  [{frame.hex()}]")
         return {"error": "Decoding failure"}
 
 
 def decode_ascii_frame(frame: bytes) -> dict:
     try:
-        to_address      = frame[0]
-        from_address    = frame[1]
-        command         = frame[3]
-        header_checksum = frame[4]
-        body            = frame[5:-1]
+        to_address   = frame[0]
+        from_address = frame[1]
+        command      = frame[3]
+        body         = frame[5:-1]
 
         channel_id   = body[0]
         data_bytes   = body[2:]
@@ -112,13 +109,15 @@ def decode_ascii_frame(frame: bytes) -> dict:
         try:
             ascii_text = data_bytes.decode("ascii").strip()
         except UnicodeDecodeError as e:
-            logger.warning(f"Failed to decode ASCII text: {e}")
+            logger.warning(f"  CH  0x{channel_id:02X} {channel_name}  ASCII decode failed: {e}")
             return {"error": "ASCII decode failed"}
 
+        logger.debug(f"  CH  0x{channel_id:02X} {channel_name}  ascii='{ascii_text}'")
+
         return {
-            "to_address":  ADDRESS_LOOKUP.get(to_address,   f"Unknown (0x{to_address:02X})"),
+            "to_address":   ADDRESS_LOOKUP.get(to_address,   f"Unknown (0x{to_address:02X})"),
             "from_address": ADDRESS_LOOKUP.get(from_address, f"Unknown (0x{from_address:02X})"),
-            "command":     COMMAND_LOOKUP.get(command,       f"Unknown (0x{command:02X})"),
+            "command":      COMMAND_LOOKUP.get(command,       f"Unknown (0x{command:02X})"),
             "values": {
                 channel_name: {
                     "channel_id":   f"0x{channel_id:02X}",
@@ -136,14 +135,11 @@ def decode_ascii_frame(frame: bytes) -> dict:
 
 def decode_format_and_data(channel_id, format_byte, data_bytes):
     try:
-        logger.debug(f"Decoding channel ID: 0x{channel_id:02X}, format byte: 0x{format_byte:02X}, data: {data_bytes.hex()}")
-
         divisor     = _DIVISOR_MAP[(format_byte >> 6) & 0b11]
         dp          = _DP_MAP[divisor]
         format_bits = format_byte & 0b1111
 
         if len(data_bytes) == 0:
-            logger.debug("decode_format_and_data: Empty data bytes; cannot decode.")
             return None
 
         layout = None
@@ -193,7 +189,6 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
                 return None
             value        = None
             display_text = "".join(SEGMENT_B.get(b, "?") for b in data_bytes)
-            logger.debug(f"Decoded 7-segment text: {display_text}")
 
         elif format_bits == 0x07:
             if len(data_bytes) != 4:
@@ -222,7 +217,7 @@ def decode_format_and_data(channel_id, format_byte, data_bytes):
             display_text = f"{first:.{dp}f} / {second:.{dp}f}"
 
         else:
-            logger.debug(f"Unsupported format: 0x{format_bits:02X}.")
+            logger.debug(f"       unsupported format 0x{format_bits:02X}")
             return None
 
         return {

pyfastnet-2.0.2/fastnet_decoder/frame_buffer.py

@@ -0,0 +1,103 @@
+from .utils import calculate_checksum
+from .mappings import COMMAND_LOOKUP, IGNORED_COMMANDS
+from .decode_fastnet import decode_frame, decode_ascii_frame
+from .logger import logger
+from queue import Queue, Full
+
+
+class FrameBuffer:
+    """
+    Manages an incoming byte stream, extracts valid FastNet frames,
+    decodes them, and queues the results.
+
+    Typical workflow:
+        1. Feed raw bytes via add_to_buffer()
+        2. Call get_complete_frames() to process the buffer
+        3. Pull decoded frames from frame_queue
+    """
+
+    def __init__(self, max_buffer_size=8192, max_queue_size=1000):
+        self.buffer = bytearray()
+        self.max_buffer_size = max_buffer_size
+        self.frame_queue = Queue(maxsize=max_queue_size)
+
+    def add_to_buffer(self, new_data):
+        if not isinstance(new_data, (bytes, bytearray)):
+            logger.error("Invalid data type passed to add_to_buffer. Expected bytes or bytearray.")
+            return
+
+        self.buffer.extend(new_data)
+        logger.debug(f"BUF   +{len(new_data)}B  total={len(self.buffer)}B")
+
+        if len(self.buffer) > self.max_buffer_size:
+            logger.warning("Buffer size exceeded maximum limit. Trimming the oldest data.")
+            self.buffer = self.buffer[-self.max_buffer_size:]
+
+    def get_complete_frames(self):
+        """Extract, validate, and queue complete frames from the buffer."""
+        while len(self.buffer) >= 6:
+            to_address      = self.buffer[0]
+            from_address    = self.buffer[1]
+            body_size       = self.buffer[2]
+            command         = self.buffer[3]
+            header_checksum = self.buffer[4]
+
+            command_name     = COMMAND_LOOKUP.get(command, f"Unknown (0x{command:02X})")
+            full_frame_length = 5 + body_size + 1
+
+            if len(self.buffer) < full_frame_length:
+                logger.debug(f"FRAME wait    need={full_frame_length}B  have={len(self.buffer)}B")
+                break
+
+            frame         = self.buffer[:full_frame_length]
+            body          = self.buffer[5:full_frame_length - 1]
+            body_checksum = self.buffer[full_frame_length - 1]
+            frame_hex     = bytes(frame[:8]).hex()
+
+            if calculate_checksum(self.buffer[:4]) != header_checksum:
+                logger.debug(f"FRAME discard  header-checksum  [{frame_hex}...]")
+                self.buffer = self.buffer[1:]
+                continue
+
+            if calculate_checksum(body) != body_checksum:
+                logger.debug(f"FRAME discard  body-checksum  [{frame_hex}...]")
+                self.buffer = self.buffer[1:]
+                continue
+
+            self.buffer = self.buffer[full_frame_length:]
+
+            if command_name in IGNORED_COMMANDS:
+                logger.debug(f"FRAME skip    cmd={command_name}")
+                continue
+
+            logger.debug(
+                f"FRAME cmd={command_name}  "
+                f"0x{to_address:02X}←0x{from_address:02X}  "
+                f"body={body_size}B  [{frame_hex}...]"
+            )
+            self.decode_and_queue_frame(frame, command_name)
+
+    def decode_and_queue_frame(self, frame, command_name):
+        """Decode a frame and add it to the queue if valid."""
+        decoder = decode_ascii_frame if command_name == "LatLon" else decode_frame
+        decoded_frame = decoder(frame)
+        if decoded_frame and "values" in decoded_frame:
+            channel_names = list(decoded_frame["values"].keys())
+            names_str = ", ".join(channel_names[:4])
+            if len(channel_names) > 4:
+                names_str += f", +{len(channel_names) - 4} more"
+            try:
+                self.frame_queue.put_nowait(decoded_frame)
+                logger.debug(f"QUEUE {len(channel_names)} channel(s)  [{names_str}]")
+            except Full:
+                logger.warning("Frame queue full, dropping frame.")
+        else:
+            logger.debug(f"QUEUE fail    decode error  [{frame.hex()[:16]}...]")
+
+    def get_buffer_size(self):
+        return len(self.buffer)
+
+    def get_buffer_contents(self):
+        hex_contents = self.buffer.hex()
+        logger.debug(f"BUF   contents  [{hex_contents}]")
+        return hex_contents

{pyfastnet-2.0.1 → pyfastnet-2.0.2}/fastnet_decoder/logger.py

@@ -1,26 +1,20 @@
 import logging
 
-# Create a logger
-logger = logging.getLogger("fastnet_decoder")
+logger = logging.getLogger("pyfastnet")
 
-# Default log level
 DEFAULT_LOG_LEVEL = logging.INFO
 
-# Avoid duplicate handlers
 if not logger.hasHandlers():
     handler = logging.StreamHandler()
-    formatter = logging.Formatter("%(asctime)s [%(levelname)s] [%(module)s] %(message)s")
+    formatter = logging.Formatter("%(asctime)s [pyfastnet] %(levelname)-5s %(message)s")
     handler.setFormatter(formatter)
     logger.addHandler(handler)
 
 logger.setLevel(DEFAULT_LOG_LEVEL)
 
+
 def set_log_level(level_name: str):
-    """
-    Sets the log level dynamically at runtime.
-    Args:
-        level_name (str): Name of the log level (e.g., "DEBUG", "INFO", "WARNING").
-    """
+    """Sets the log level dynamically at runtime."""
     level = getattr(logging, level_name.upper(), DEFAULT_LOG_LEVEL)
     logger.setLevel(level)
     logger.info(f"Log level set to {level_name.upper()}.")

{pyfastnet-2.0.1 → pyfastnet-2.0.2/pyfastnet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfastnet
-Version: 2.0.1
+Version: 2.0.2
 Summary: A Python library for decoding FastNet protocol data streams.
 Home-page: https://github.com/ghotihook/pyfastnet
 Author: Alex Salmon

{pyfastnet-2.0.1 → pyfastnet-2.0.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pyfastnet",
-    version="2.0.1",  # Ensure this matches your intended version
+    version="2.0.2",  # Ensure this matches your intended version
     author="Alex Salmon",
     author_email="alex@ivila.net",
     description="A Python library for decoding FastNet protocol data streams.",

pyfastnet-2.0.1/fastnet_decoder/frame_buffer.py

@@ -1,198 +0,0 @@
-from .utils import calculate_checksum  # Import checksum function from utils.py
-from .mappings import COMMAND_LOOKUP, IGNORED_COMMANDS
-from .decode_fastnet import decode_frame, decode_ascii_frame
-from .logger import logger
-from queue import Queue
-
-
-"""
-FrameBuffer Class
-=================
-
-The `FrameBuffer` class is responsible for managing a stream of incoming data, validating and extracting complete 
-frames, and decoding those frames using the FastNet protocol. It is designed to handle real-time data input, making 
-it suitable for scenarios like serial communication with hardware devices.
-
-Core Responsibilities:
------------------------
-1. **Buffer Management**:
-   - The class maintains an internal `bytearray` buffer to store incoming raw data.
-   - New data can be added to the buffer using the `add_to_buffer` method.
-   - The buffer automatically trims its size to a configurable maximum (`max_buffer_size`) to avoid unbounded memory usage.
-
-2. **Frame Extraction**:
-   - The `get_complete_frames` method scans the buffer for complete frames based on the FastNet protocol structure:
-     - A frame consists of a 5-byte header, a variable-length body, and a checksum.
-     - Both the header and body checksums are validated before processing the frame.
-   - Frames that are incomplete or fail checksum validation are skipped, and the buffer is adjusted to search for the next valid frame.
-
-3. **Frame Decoding**:
-   - After extracting a valid frame, the method determines the appropriate decoder (ASCII or standard) based on the command type.
-   - Decoded frames are added to an internal queue (`frame_queue`) for further processing.
-
-4. **Command Filtering**:
-   - Certain command types, such as "Keep Alive" or "Light Intensity," can be ignored based on a configurable list of ignored commands 
-     (managed in the `mappings.py` file).
-
-Key Features:
--------------
-- **Thread-Safe Queue**:
-  The `frame_queue` is implemented using Python's `queue.Queue`, enabling safe concurrent access from multiple threads 
-  (if needed).
-
-- **Error Handling**:
-  - The class is robust against malformed or corrupted data. Frames with invalid checksums are discarded without crashing the application.
-  - Warnings and errors are logged for debugging purposes.
-
-- **Modularity**:
-  - The decoding logic is separated from the frame extraction, adhering to the single-responsibility principle.
-  - The list of ignored commands is managed in `mappings.py`, promoting modularity and ease of configuration.
-
-Typical Workflow:
------------------
-1. Raw data (e.g., from a serial port) is fed into the buffer using the `add_to_buffer` method.
-2. The `get_complete_frames` method scans the buffer for valid frames, processes them, and adds decoded frames to the `frame_queue`.
-3. Another part of the application (e.g., a main loop) retrieves and processes frames from the queue for further action (e.g., broadcasting NMEA sentences).
-
-Configuration Parameters:
--------------------------
-- `max_buffer_size`: Limits the size of the internal buffer. Older data is discarded when the buffer exceeds this size.
-- `max_queue_size`: Specifies the maximum number of frames that can be stored in the `frame_queue`.
-
-Use Cases:
-----------
-The `FrameBuffer` class is ideal for:
-- Real-time data processing systems where incoming data must be validated and decoded before use.
-- Applications where reliability is critical, such as navigation systems or hardware communication protocols.
-
-Example:
---------
-# Initialize the FrameBuffer
-frame_buffer = FrameBuffer(max_buffer_size=8192, max_queue_size=1000)
-
-# Add raw data to the buffer
-frame_buffer.add_to_buffer(new_data)
-
-# Extract and decode complete frames
-frame_buffer.get_complete_frames()
-
-# Process frames from the queue
-while not frame_buffer.frame_queue.empty():
-    frame = frame_buffer.frame_queue.get()
-    # Process the decoded frame
-"""
-
-
-class FrameBuffer:
-    """
-    A class that manages an incoming data stream, extracts valid frames,
-    and decodes them using the FastNet protocol.
-    """
-    def __init__(self, max_buffer_size=8192, max_queue_size=1000):
-        self.buffer = bytearray()
-        self.max_buffer_size = max_buffer_size
-        self.frame_queue = Queue(maxsize=max_queue_size)  # Shared instance for frames
-
-    def add_to_buffer(self, new_data):
-        """
-        Adds new data to the buffer.
-
-        Args:
-            new_data (bytes): New data from the serial input.
-        """
-        if not isinstance(new_data, (bytes, bytearray)):
-            logger.error("Invalid data type passed to add_to_buffer. Expected bytes or bytearray.")
-            return
-
-        self.buffer.extend(new_data)
-        logger.debug(f"Added {len(new_data)} bytes to buffer. Buffer size: {len(self.buffer)} bytes.")
-
-        # Prevent the buffer from growing indefinitely
-        if len(self.buffer) > self.max_buffer_size:
-            logger.warning("Buffer size exceeded maximum limit. Trimming the oldest data.")
-            self.buffer = self.buffer[-self.max_buffer_size:]  # Keep the latest data only
-
-  
-    def get_complete_frames(self):
-        """
-        Extract and validate complete frames from the buffer, then add them to the internal queue.
-        """
-        while len(self.buffer) >= 6:  # Minimum frame size (5 header + 1 body checksum)
-            to_address = self.buffer[0]
-            from_address = self.buffer[1]
-            body_size = self.buffer[2]
-            command = self.buffer[3]
-            header_checksum = self.buffer[4]
-
-            # Identify command name from lookup
-            command_name = COMMAND_LOOKUP.get(command, f"Unknown (0x{command:02X})")
-
-            # Calculate full frame length
-            full_frame_length = 5 + body_size + 1  # Header (5 bytes) + body + body checksum
-            if len(self.buffer) < full_frame_length:
-                logger.debug(f"Incomplete frame: waiting for more bytes (needed {full_frame_length}, got {len(self.buffer)})")
-                break
-
-            # Extract frame data
-            frame = self.buffer[:full_frame_length]
-            body = self.buffer[5:full_frame_length - 1]
-            body_checksum = self.buffer[full_frame_length - 1]
-
-            # Verify header and body checksums
-            if calculate_checksum(self.buffer[:4]) != header_checksum:
-                logger.debug("Header checksum mismatch. Dropping first byte.")
-                self.buffer = self.buffer[1:]
-                continue
-
-            if calculate_checksum(body) != body_checksum:
-                logger.debug("Body checksum mismatch. Dropping first byte.")
-                self.buffer = self.buffer[1:]
-                continue
-
-            # Remove frame from buffer after validation
-            self.buffer = self.buffer[full_frame_length:]
-
-            # Skip ignored commands
-            if command_name in IGNORED_COMMANDS:
-                logger.debug(f"Skipping ignored command: {command_name}")
-                continue
-
-            # Decode the frame
-            self.decode_and_queue_frame(frame, command_name)
-
-
-    def decode_and_queue_frame(self, frame, command_name):
-        """Decode a frame and add it to the queue if valid."""
-        decoder = decode_ascii_frame if command_name == "LatLon" else decode_frame
-        decoded_frame = decoder(frame)
-        if decoded_frame:
-            try:
-                self.frame_queue.put_nowait(decoded_frame)
-                logger.debug(f"Added frame to queue: {decoded_frame}")
-            except queue.Full:
-                logger.warning("Frame queue is full. Dropping frame.")
-        else:
-            logger.debug(f"Failed to decode frame: {frame.hex()}")
-
-        
-                
-    def get_buffer_size(self):
-        """
-        Returns the current size of the buffer.
-        
-        Returns:
-            int: The number of bytes currently in the buffer.
-        """
-        return len(self.buffer)
-
-
-    def get_buffer_contents(self):
-        """
-        Returns the contents of the buffer as a hex string.
-        
-        Returns:
-            str: The hexadecimal representation of the buffer contents.
-        """
-        hex_contents = self.buffer.hex()
-        logger.debug(f"Buffer contents: {hex_contents}")
-        return hex_contents