updated logging

umnp/microcontroller/devices/network/ethernet_w5500.py

@@ -9,11 +9,12 @@ if sys.implementation.name == "micropython":
 
     # noinspection PyUnresolvedReferences
     import network
-    import umnp.proto.compat.logging as logging
+
 
 else:
     from umnp.microcontroller.umock import machine, network
-    import logging
+
+from umnp.proto.common.logging import log_info
 
 
 class EthernetW5500(EthernetAdapter):
@@ -94,7 +95,7 @@ class EthernetW5500(EthernetAdapter):
         return self._nic.config("mac")
 
     def reset(self):
-        logging.info("Resetting NIC")
+        log_info("Resetting NIC")
         self._nic.active(False)
         time.sleep(0.1)
         self._nic.active(True)

umnp/microcontroller/devices/network/udp.py

@@ -6,14 +6,13 @@ from umnp.microcontroller.devices.network import (
     LISTEN_TIMEOUT_MS,
     calculate_broadcast_ip,
 )
+from umnp.proto.common.logging import log_error
 
 if sys.implementation.name == "micropython":
     # noinspection PyUnresolvedReferences
     import uasyncio as asyncio
-    import umnp.proto.compat.logging as logging
-
 else:
-    import logging
+
     import asyncio
 DEFAULT_UMNP_DATA_IN_PORT = 7777
 DEFAULT_UMNP_COMMAND_IN_PORT = 7776
@@ -70,4 +69,4 @@ class UDPSender:
                 self.socket.sendto(msg, (self.broadcast_ip, self._target_port))
             except OSError as e:
                 self._error = True
-                logging.error(e)
+                log_error(str(e))

umnp/microcontroller/sensors/lps28dfw/__init__.py

@@ -3,19 +3,20 @@ import struct
 import sys
 import time
 
+from umnp.proto.common.logging import log_error
+
 try:
     from machine import I2C
 except ImportError:
     from umnp.microcontroller.umock.machine import I2C
 
 if sys.implementation.name == "micropython":
-    import umnp.proto.compat.logging as logging
+    pass
 else:
 
     def const(x):
         return x
 
-    import logging
 
 LPS28DFW_DEFAULT_ADDRESS = const(0x5D)
 LPS28DFW_READ = const(0xB9)
@@ -197,7 +198,7 @@ class LPS28DFW:
             p = await self.pressure()
             t = await self.temperature()
         except OSError as e:
-            logging.error(f"Unable to read measurement data: {e}")
+            log_error(f"Unable to read measurement data: {e}")
             return self._nan, self._nan
         return p, t
 

umnp/microcontroller/sensors/sht45/__init__.py

@@ -5,15 +5,16 @@ try:
 except ImportError:
     from umnp.microcontroller.umock.machine import I2C
 
+from umnp.proto.common.logging import log_error
 
 if sys.implementation.name == "micropython":
-    import umnp.proto.compat.logging as logging
+    pass
 else:
 
     def const(x):
         return x
 
-    import logging
+
 import asyncio
 import time
 
@@ -97,7 +98,7 @@ class SHT45:
         try:
             n_ack = self._i2c.writeto(self._i2c_address, cmd)
         except OSError as e:
-            logging.error(f"Unable to write to I2C bus: {e}")
+            log_error(f"Unable to write to I2C bus: {e}")
             return self._nan, self._nan
         if n_ack != 1:
             return temperature, rh
@@ -105,7 +106,7 @@ class SHT45:
         try:
             data = self._i2c.readfrom(self._i2c_address, 6)
         except OSError as e:
-            logging.error(f"Unable to read from I2C bus: {e}")
+            log_error(f"Unable to read from I2C bus: {e}")
             return self._nan, self._nan
         temperature = self._translate_temperature(data[0:3])
         rh = self._translate_rh(data[3:6])

umnp/proto/common/logging.py

+import sys
+
+if sys.implementation.name == "micropython":
+    def info(msg: str) -> None:
+        print(f"INFO: {msg}")
+
+
+    def error(msg: str) -> None:
+        print(f"ERROR: {msg}")
+else:
+    import logging
+
+    def log_info(msg: str) -> None:
+        logging.info(msg)
+
+    def log_error(msg: str) -> None:
+        logging.error(msg)

umnp/proto/compat/logging.py

-def info(msg: str) -> None:
-    print(f"INFO: {msg}")
-
-
-def error(msg: str) -> None:
-    print(f"ERROR: {msg}")

umnp/proto/message.py

+from umnp.proto.common.logging import log_error
+
 try:
     # noinspection PyUnresolvedReferences
     import typing
 except ImportError:
     pass
 
-try:
-    import logging
-except ImportError:
-    from umnp.proto.compat import logging
-
-
 from umnp.proto.common.timestamp import TimeStamp
 from umnp.proto.constants import MSG_BYTE_ORDER, MSG_LEN_PAYLOAD_SIZE
 from umnp.proto.message_header import MessageHeader
@@ -109,13 +105,13 @@ class Message:
             # print(f"expected: {payload=}")
             # raise OSError
         except (KeyError, ValueError):
-            logging.error("Invalid message: could not extract payload length")
+            log_error("Invalid message: could not extract payload length")
             return None
 
         offset += MSG_LEN_PAYLOAD_SIZE
         payload = data[offset:]
         if len(payload) != payload_length:
-            logging.error(
+            log_error(
                 f"Invalid message: mismatch between specified {payload_length} and actual payload length {len(payload)}."
             )
             return None
@@ -127,3 +123,6 @@ class Message:
 
     def __str__(self):
         return f"Message of type {self.type}"
+
+    def payload(self) -> str:
+        return self._data.decode("utf-8")

umnp/proto/message_header.py

+from umnp.proto.common.logging import log_error
 from umnp.proto.common.timestamp import TimeStamp, valid_timestamp
 from umnp.proto.constants import (
     MSG_PROTOCOL_VERSION,
@@ -9,11 +10,6 @@ from umnp.proto.constants import (
     MSG_LEN_SENDER_TYPE,
 )
 
-try:
-    import logging
-except ImportError:
-    from umnp.proto.compat import logging
-
 try:
     # noinspection PyUnresolvedReferences
     import typing
@@ -106,7 +102,7 @@ class MessageHeader:
         offset = 0
         protocol_bytes = -1
         if not (isinstance(data, bytes)):
-            logging.error("Invalid message header: not bytes")
+            log_error("Invalid message header: not bytes")
             return None
         try:
             protocol_bytes = data[:MSG_LEN_PROTOCOL_VERSION]
@@ -114,8 +110,8 @@ class MessageHeader:
 
             cls._version = protocol_version
         except (KeyError, ValueError):
-            logging.error(f"Protocol bytes: {protocol_bytes}")
-            logging.error("Invalid message header: could not extract version")
+            log_error(f"Protocol bytes: {protocol_bytes}")
+            log_error("Invalid message header: could not extract version")
             return None
         offset += MSG_LEN_PROTOCOL_VERSION
 
@@ -126,7 +122,7 @@ class MessageHeader:
             offset += MSG_LEN_SENDER_TYPE
             msg_sender_type = int.from_bytes(msg_sender_type_b, MSG_BYTE_ORDER)
         except (KeyError, ValueError):
-            logging.error("Invalid message sender information: could not extract data")
+            log_error("Invalid message sender information: could not extract data")
             return None
 
         try:
@@ -134,14 +130,14 @@ class MessageHeader:
             message_type = int.from_bytes(message_type_bytes, MSG_BYTE_ORDER)
 
         except (KeyError, ValueError):
-            logging.error("Invalid message payload: could not extract version")
+            log_error("Invalid message payload: could not extract version")
             return None
 
         offset += MSG_LEN_MESSAGE_TYPE
 
         if protocol_version < 0 or protocol_version > MSG_PROTOCOL_VERSION:
             err = f"Invalid protocol version {protocol_version}, outside of range [0, {MSG_PROTOCOL_VERSION}]"
-            logging.error(err)
+            log_error(err)
             return None
         message_ts = None
         try:
@@ -149,9 +145,7 @@ class MessageHeader:
             message_ts_int = int.from_bytes(message_ts, byteorder=MSG_BYTE_ORDER)
             timestamp = TimeStamp(message_ts_int)
         except (KeyError, ValueError) as e:
-            logging.error(
-                f"Invalid message timestamp: could not extract timestamp: {e}"
-            )
+            log_error(f"Invalid message timestamp: could not extract timestamp: {e}")
             return None
 
         return cls(