Deperately trying to figure out angular

backend/MeshtasticLogger.py

@@ -0,0 +1,73 @@
+import meshtastic
+import meshtastic.serial_interface
+from pubsub import pub
+from MeshtasticDataClasses import RxPacket,to_rx_packet
+from MeshtasticDataClasses import NodeData,to_node_data
+from datetime import datetime
+
+class MeshtasticLogger:
+    def __init__(self, interface: meshtastic.serial_interface.SerialInterface, log_path : str, channel : int = 1, message_received_callback = None):
+        # Subscribe to the recieve text event topic
+        pub.subscribe(self.onReceive, "meshtastic.receive.text")
+        self.interface = interface
+        self.channel: int = channel
+        self.log_path: str = log_path
+        self.message_received_callback = message_received_callback
+    
+    def _cap_string_length_bytes(self, message : str, max_bytes: int):
+        '''
+        Cap the length of a string to be under max_bytes. It will just drop the excess from the string.
+        '''
+        capped_message = ""
+        capped_message_byte_length = 0
+        for char in message:
+            next_char_byte_size = len(char.encode('utf-8'))
+            if capped_message_byte_length + next_char_byte_size <= max_bytes:
+                capped_message_byte_length += next_char_byte_size
+                capped_message += char
+        return capped_message
+
+    def _log(self, message: str):
+        print(message)
+        with open(self.log_path, "a") as file:
+            file.write(message)
+    
+    def send(self, message: str):
+        self.interface.sendText(message, channelIndex=self.channel)
+        timestamp: str = datetime.now().strftime("%m-%d %I:%M:%S %p")
+        self._log(f"{timestamp}   You on channel {self.channel}: {message}\n")
+        
+            
+    def onReceive(self, packet: dict, interface: meshtastic.serial_interface.SerialInterface):
+        # parse the packet we recieved into a data class so we have nice type hints
+        try:
+            parsed_packet: RxPacket = to_rx_packet(packet)
+        except Exception as e:
+            self._log(e)
+            return
+            
+        # get the current time
+        timestamp: str = datetime.now().strftime("%m-%d %I:%M:%S %p")
+        
+        # try to grab the sender's ID. Otherwise it will just be unkown sender
+        sender_node_name = "Unkown Sender"
+        if parsed_packet.fromId in interface.nodes:
+            try:
+                sender_node: NodeData = to_node_data(interface.nodes[parsed_packet.fromId])
+            except Exception as e:
+                self._log(e)
+                return
+            sender_node_name = sender_node.user.longName
+        
+        # construct and _log the message
+        message = f"{timestamp}   {sender_node_name}: On Channel {parsed_packet.channel}, message: {parsed_packet.decoded.text}\n"
+        self._log(message)
+
+        # parrot out the message but make sure the message length doesn't go above 233 bytes
+        if parsed_packet.channel == 1:
+            print("Parroting message")
+            interface.sendText(self._cap_string_length_bytes(message, 233), channelIndex=self.channel)
+        
+        if not self.message_received_callback is None:
+            self.message_received_callback(message)
+