Merge pull request #6 from generalmattza/main

daily uodates

Author: davidson-engineering

src/app_monitor/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.0"
+__version__ = "0.1.4"
 
 
 from .app_monitor import TerminalManager, SocketManager

src/app_monitor/app_monitor.py

@@ -1,10 +1,12 @@
 import asyncio
 from copy import deepcopy
 import sys
+import asyncio
+import json
+from flask_socketio import SocketIO
 
 from app_monitor.elements_base import (
     ProgressBar,
-    Table,
     TextElement,
     RangeBar,
     MonitorGroup,
@@ -105,11 +107,6 @@ async def update_fixed_rate(self, frequency=30):
         )
 
 
-import asyncio
-import json
-from flask_socketio import SocketIO
-
-
 class SocketManager(MonitorManager):
     """Subclass of MonitorManager that adds functionality to push data to a WebSocket."""
 

src/app_monitor/elements_advanced.py

@@ -1,4 +1,20 @@
+from dataclasses import asdict, dataclass
+from typing import Mapping
 from app_monitor.elements_base import MonitorElement, ProgressBar, Table, TextElement
+from app_monitor.text_formatter import TextFormat
+
+
+class UnpackMixin(Mapping):
+    def __iter__(self):
+        return iter(asdict(self).keys())
+
+    def __len__(self):
+        return len(asdict(self))
+
+    def __getitem__(self, key):
+        if key not in asdict(self):
+            raise KeyError(f"Key {key} not found in {self.__class__.__name__}")
+        return getattr(self, key)
 
 
 class CoordinateTextElement(TextElement):
@@ -22,6 +38,60 @@ def update(self, x=None, y=None, z=None, units=None):
         )
 
 
+class ScaledTextElement(TextElement):
+    def __init__(
+        self, element_id, units="", static_text=None, scale=1, text_format=None
+    ):
+        super().__init__(
+            element_id=element_id,
+            text="",
+            static_text=static_text,
+            text_format=text_format,
+        )
+        self.scale = scale
+        self.units = units
+
+    def update(self, text):
+        scaled_value = float(text) * self.scale
+        return super().update(scaled_value)
+
+
+@dataclass
+class TextElementSettings(UnpackMixin):
+    element_id: str
+    text_format: TextFormat = None
+    static_text: str = ""
+    text: str = ""
+    width: int = None
+    _factory: TextElement = TextElement
+
+    def build(self):
+        return self._factory(
+            element_id=self.element_id,
+            text=self.text,
+            static_text=self.static_text,
+            text_format=self.text_format,
+            width=self.width,
+        )
+
+
+@dataclass
+class ScaledTextElementSettings(TextElementSettings):
+    scale: float = 1
+    units: str = ""
+
+    _factory: ScaledTextElement = ScaledTextElement
+
+    def build(self):
+        return self._factory(
+            element_id=self.element_id,
+            units=self.units,
+            static_text=self.static_text,
+            scale=self.scale,
+            text_format=self.text_format,
+        )
+
+
 # Machine state class
 class MachineState(MonitorElement):
     """Class for rendering machine states using binary values."""

src/app_monitor/elements_base.py

@@ -34,7 +34,7 @@ def __init__(self, element_id=None, border=False, width=MAX_MONITOR_WIDTH):
         """
         self.element_id = element_id or self.get_unique_id()
         self.border = border
-        self.width = width
+        self.width = MAX_MONITOR_WIDTH if width is None else width
 
     def display(self):
         """Render the monitor element for display."""

src/app_monitor/server.py

@@ -3,7 +3,8 @@
 import zmq
 import zmq.asyncio
 import serial
-
+import struct
+from collections import OrderedDict
 from .logger import logger
 
 
@@ -64,6 +65,7 @@ def __init__(
         port="/dev/ttyUSB0",
         baudrate=9600,
         decoder=None,
+        validator=None,
     ):
         super().__init__(monitor_manager)
         if serial_instance:
@@ -76,6 +78,7 @@ def __init__(
         self.port = self.serial_connection.port
         self.baudrate = self.serial_connection.baudrate
         self.decoder = decoder
+        self.validator = validator
 
     def detect_devices(
         self,
@@ -115,9 +118,12 @@ async def start(self, frequency: float = 30):
                 if self.serial_connection.in_waiting:
                     # Read available data on the serial port
                     if data := self.serial_connection.readline():
-                        if self.decoder:
+                        if self.validator:
+                            data = self.validator.validate(data)
+                        if self.decoder and data:
                             data = self.decoder.decode(data)
-                        self.process_update(data)
+                        if data:
+                            self.process_update(data)
                 await asyncio.sleep(1 / frequency)
 
         except Exception as e:
@@ -151,4 +157,34 @@ def __init__(self, keys, separator=","):
 
     def decode(self, packet):
         data = packet.decode("utf-8").strip().split(self.separator)
-        return dict(zip(self.keys, data))
+        return OrderedDict(zip(self.keys, data))
+
+
+class StructDecoder(Decoder):
+    def __init__(self, data_keys, packet_format=None):
+        self.packet_format = packet_format
+        self.data_keys = data_keys
+
+    def decode(self, packet):
+        if self.packet_format:
+            packet = struct.unpack(self.packet_format, packet)
+        if self.data_keys:
+            packet = OrderedDict(zip(self.data_keys, packet))
+        return packet
+
+
+class Validator:
+    @abstractmethod
+    def validate(self, packet): ...
+
+class WindowValidator(Validator):
+    def __init__(self, window_size=10, start_byte=0xA5, end_byte=0x5A):
+        self.window_size = window_size
+        self.start_byte = start_byte
+        self.end_byte = end_byte
+
+    def validate(self, packet):
+        if len(packet) == self.window_size and packet[0] == self.start_byte and packet[-1] == self.end_byte:
+            # Return packet without start and end bytes
+            return packet[1:-1]
+        return False