mmrelay 1.1.3__py3-none-any.whl → 1.1.4__py3-none-any.whl

mmrelay/meshtastic_utils.py

@@ -11,10 +11,50 @@ import meshtastic.serial_interface
 import meshtastic.tcp_interface
 import serial  # For serial port exceptions
 import serial.tools.list_ports  # Import serial tools for port listing
-from bleak.exc import BleakDBusError, BleakError
 from meshtastic.protobuf import mesh_pb2, portnums_pb2
 from pubsub import pub
 
+from mmrelay.constants.config import (
+    CONFIG_KEY_MESHNET_NAME,
+    CONFIG_SECTION_MESHTASTIC,
+)
+from mmrelay.constants.formats import (
+    DETECTION_SENSOR_APP,
+    EMOJI_FLAG_VALUE,
+    TEXT_MESSAGE_APP,
+)
+from mmrelay.constants.messages import (
+    DEFAULT_CHANNEL_VALUE,
+    PORTNUM_NUMERIC_VALUE,
+)
+from mmrelay.constants.network import (
+    CONFIG_KEY_BLE_ADDRESS,
+    CONFIG_KEY_CONNECTION_TYPE,
+    CONFIG_KEY_HOST,
+    CONFIG_KEY_SERIAL_PORT,
+    CONNECTION_TYPE_BLE,
+    CONNECTION_TYPE_NETWORK,
+    CONNECTION_TYPE_SERIAL,
+    CONNECTION_TYPE_TCP,
+    DEFAULT_BACKOFF_TIME,
+    DEFAULT_RETRY_ATTEMPTS,
+    ERRNO_BAD_FILE_DESCRIPTOR,
+    INFINITE_RETRIES,
+    SYSTEMD_INIT_SYSTEM,
+)
+
+# Import BLE exceptions conditionally
+try:
+    from bleak.exc import BleakDBusError, BleakError
+except ImportError:
+    # Define dummy exception classes if bleak is not available
+    class BleakDBusError(Exception):
+        pass
+
+    class BleakError(Exception):
+        pass
+
+
 from mmrelay.db_utils import (
     get_longname,
     get_message_map_by_meshtastic_id,
@@ -54,10 +94,10 @@ subscribed_to_connection_lost = False
 
 def is_running_as_service():
     """
-    Determine if the application is running as a systemd service.
+    Checks whether the application is running as a systemd service.
 
     Returns:
-        bool: True if running under systemd (as indicated by the INVOCATION_ID environment variable or parent process), False otherwise.
+        bool: True if running under systemd (detected via environment variable or parent process), otherwise False.
     """
     # Check for INVOCATION_ID environment variable (set by systemd)
     if os.environ.get("INVOCATION_ID"):
@@ -70,7 +110,7 @@ def is_running_as_service():
                 if line.startswith("PPid:"):
                     ppid = int(line.split()[1])
                     with open(f"/proc/{ppid}/comm") as p:
-                        return p.read().strip() == "systemd"
+                        return p.read().strip() == SYSTEMD_INIT_SYSTEM
     except (FileNotFoundError, PermissionError, ValueError):
         pass
 
@@ -88,22 +128,26 @@ def serial_port_exists(port_name):
 
 def connect_meshtastic(passed_config=None, force_connect=False):
     """
-    Establishes and manages a connection to a Meshtastic device using serial, BLE, or TCP, with automatic retries and event subscriptions.
+    Establishes a connection to a Meshtastic device using serial, BLE, or TCP, with automatic retries and event subscriptions.
 
-    If a configuration is provided, updates the global configuration and Matrix room mappings. If already connected and not forced, returns the existing client. Handles reconnection logic with exponential backoff, verifies serial port existence, and subscribes to message and connection lost events upon successful connection.
+    If a configuration is provided, updates the global configuration and Matrix room mappings. Prevents concurrent or duplicate connection attempts, validates required configuration fields, and supports both legacy and current connection types. Verifies serial port existence before connecting and handles connection failures with exponential backoff. Subscribes to message and connection lost events upon successful connection.
 
     Parameters:
-        passed_config (dict, optional): Configuration dictionary to use for the connection.
+        passed_config (dict, optional): Configuration dictionary for the connection.
         force_connect (bool, optional): If True, forces a new connection even if one already exists.
 
     Returns:
-        meshtastic_client: The connected Meshtastic client instance, or None if connection fails or shutdown is in progress.
+        The connected Meshtastic client instance, or None if connection fails or shutdown is in progress.
     """
-    global meshtastic_client, shutting_down, config, matrix_rooms
+    global meshtastic_client, shutting_down, reconnecting, config, matrix_rooms
     if shutting_down:
         logger.debug("Shutdown in progress. Not attempting to connect.")
         return None
 
+    if reconnecting:
+        logger.debug("Reconnection already in progress. Not attempting new connection.")
+        return None
+
     # Update the global config if a config is passed
     if passed_config is not None:
         config = passed_config
@@ -129,17 +173,37 @@ def connect_meshtastic(passed_config=None, force_connect=False):
             logger.error("No configuration available. Cannot connect to Meshtastic.")
             return None
 
+        # Check if meshtastic config section exists
+        if (
+            CONFIG_SECTION_MESHTASTIC not in config
+            or config[CONFIG_SECTION_MESHTASTIC] is None
+        ):
+            logger.error(
+                "No Meshtastic configuration section found. Cannot connect to Meshtastic."
+            )
+            return None
+
+        # Check if connection_type is specified
+        if (
+            CONFIG_KEY_CONNECTION_TYPE not in config[CONFIG_SECTION_MESHTASTIC]
+            or config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_CONNECTION_TYPE] is None
+        ):
+            logger.error(
+                "No connection type specified in Meshtastic configuration. Cannot connect to Meshtastic."
+            )
+            return None
+
         # Determine connection type and attempt connection
-        connection_type = config["meshtastic"]["connection_type"]
+        connection_type = config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_CONNECTION_TYPE]
 
         # Support legacy "network" connection type (now "tcp")
-        if connection_type == "network":
-            connection_type = "tcp"
+        if connection_type == CONNECTION_TYPE_NETWORK:
+            connection_type = CONNECTION_TYPE_TCP
             logger.warning(
                 "Using 'network' connection type (legacy). 'tcp' is now the preferred name and 'network' will be deprecated in a future version."
             )
-        retry_limit = 0  # 0 means infinite retries
-        attempts = 1
+        retry_limit = INFINITE_RETRIES  # 0 means infinite retries
+        attempts = DEFAULT_RETRY_ATTEMPTS
         successful = False
 
         while (
@@ -148,9 +212,15 @@ def connect_meshtastic(passed_config=None, force_connect=False):
             and not shutting_down
         ):
             try:
-                if connection_type == "serial":
+                if connection_type == CONNECTION_TYPE_SERIAL:
                     # Serial connection
-                    serial_port = config["meshtastic"]["serial_port"]
+                    serial_port = config["meshtastic"].get(CONFIG_KEY_SERIAL_PORT)
+                    if not serial_port:
+                        logger.error(
+                            "No serial port specified in Meshtastic configuration."
+                        )
+                        return None
+
                     logger.info(f"Connecting to serial port {serial_port}")
 
                     # Check if serial port exists before connecting
@@ -166,9 +236,9 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                         serial_port
                     )
 
-                elif connection_type == "ble":
+                elif connection_type == CONNECTION_TYPE_BLE:
                     # BLE connection
-                    ble_address = config["meshtastic"].get("ble_address")
+                    ble_address = config["meshtastic"].get(CONFIG_KEY_BLE_ADDRESS)
                     if ble_address:
                         logger.info(f"Connecting to BLE address {ble_address}")
 
@@ -183,9 +253,15 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                         logger.error("No BLE address provided.")
                         return None
 
-                elif connection_type == "tcp":
+                elif connection_type == CONNECTION_TYPE_TCP:
                     # TCP connection
-                    target_host = config["meshtastic"]["host"]
+                    target_host = config["meshtastic"].get(CONFIG_KEY_HOST)
+                    if not target_host:
+                        logger.error(
+                            "No host specified in Meshtastic configuration for TCP connection."
+                        )
+                        return None
+
                     logger.info(f"Connecting to host {target_host}")
 
                     # Connect without progress indicator
@@ -198,9 +274,12 @@ def connect_meshtastic(passed_config=None, force_connect=False):
 
                 successful = True
                 nodeInfo = meshtastic_client.getMyNodeInfo()
-                logger.info(
-                    f"Connected to {nodeInfo['user']['shortName']} / {nodeInfo['user']['hwModel']}"
-                )
+
+                # Safely access node info fields
+                user_info = nodeInfo.get("user", {}) if nodeInfo else {}
+                short_name = user_info.get("shortName", "unknown")
+                hw_model = user_info.get("hwModel", "unknown")
+                logger.info(f"Connected to {short_name} / {hw_model}")
 
                 # Subscribe to message and connection lost events (only once per application run)
                 global subscribed_to_messages, subscribed_to_connection_lost
@@ -216,26 +295,42 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     subscribed_to_connection_lost = True
                     logger.debug("Subscribed to meshtastic.connection.lost")
 
-            except (
-                serial.SerialException,
-                BleakDBusError,
-                BleakError,
-                Exception,
-            ) as e:
+            except (TimeoutError, ConnectionRefusedError, MemoryError) as e:
+                # Handle critical errors that should not be retried
+                logger.error(f"Critical connection error: {e}")
+                return None
+            except (serial.SerialException, BleakDBusError, BleakError) as e:
+                # Handle specific connection errors
                 if shutting_down:
                     logger.debug("Shutdown in progress. Aborting connection attempts.")
                     break
                 attempts += 1
                 if retry_limit == 0 or attempts <= retry_limit:
                     wait_time = min(
-                        attempts * 2, 30
-                    )  # Exponential backoff capped at 30s
+                        2**attempts, 60
+                    )  # Consistent exponential backoff, capped at 60s
                     logger.warning(
-                        f"Attempt #{attempts - 1} failed. Retrying in {wait_time} secs: {e}"
+                        f"Connection attempt {attempts} failed: {e}. Retrying in {wait_time} seconds..."
                     )
                     time.sleep(wait_time)
                 else:
-                    logger.error(f"Could not connect after {retry_limit} attempts: {e}")
+                    logger.error(f"Connection failed after {attempts} attempts: {e}")
+                    return None
+            except Exception as e:
+                if shutting_down:
+                    logger.debug("Shutdown in progress. Aborting connection attempts.")
+                    break
+                attempts += 1
+                if retry_limit == 0 or attempts <= retry_limit:
+                    wait_time = min(
+                        2**attempts, 60
+                    )  # Consistent exponential backoff, capped at 60s
+                    logger.warning(
+                        f"An unexpected error occurred on attempt {attempts}: {e}. Retrying in {wait_time} seconds..."
+                    )
+                    time.sleep(wait_time)
+                else:
+                    logger.error(f"Connection failed after {attempts} attempts: {e}")
                     return None
 
     return meshtastic_client
@@ -243,11 +338,11 @@ def connect_meshtastic(passed_config=None, force_connect=False):
 
 def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
     """
-    Handles loss of Meshtastic connection by initiating a reconnection sequence unless the system is shutting down or already reconnecting.
+    Initiate a reconnection sequence when the Meshtastic connection is lost, unless a shutdown or reconnection is already in progress.
 
-    Args:
-        interface: The Meshtastic interface (optional, for compatibility)
-        detection_source: Source that detected the connection loss (for debugging)
+    Parameters:
+        interface: Optional Meshtastic interface instance, included for compatibility.
+        detection_source (str): Identifier for the source that detected the connection loss, used for debugging.
     """
     global meshtastic_client, reconnecting, shutting_down, event_loop, reconnect_task
     with meshtastic_lock:
@@ -266,7 +361,7 @@ def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
             try:
                 meshtastic_client.close()
             except OSError as e:
-                if e.errno == 9:
+                if e.errno == ERRNO_BAD_FILE_DESCRIPTOR:
                     # Bad file descriptor, already closed
                     pass
                 else:
@@ -281,12 +376,12 @@ def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
 
 async def reconnect():
     """
-    Asynchronously attempts to reconnect to the Meshtastic device using exponential backoff, stopping if a shutdown is initiated.
+    Asynchronously attempts to reconnect to the Meshtastic device with exponential backoff, stopping if shutdown is initiated.
 
-    Reconnection attempts start with a 10-second delay, doubling up to a maximum of 5 minutes between attempts. If not running as a service, a progress bar is displayed during the wait. The process stops immediately if `shutting_down` is set to True or upon successful reconnection.
+    Reconnection starts with a 10-second delay, doubling up to a maximum of 5 minutes between attempts. If not running as a service, a progress bar is shown during the wait. The process stops immediately if shutdown is triggered or reconnection succeeds.
     """
     global meshtastic_client, reconnecting, shutting_down
-    backoff_time = 10
+    backoff_time = DEFAULT_BACKOFF_TIME
     try:
         while not shutting_down:
             try:
@@ -340,17 +435,21 @@ async def reconnect():
 
 def on_meshtastic_message(packet, interface):
     """
-    Processes incoming Meshtastic messages and relays them to Matrix rooms or plugins based on message type and configuration.
+    Processes an incoming Meshtastic message and relays it to Matrix rooms or plugins based on message type and configuration.
 
-    Handles reactions and replies by relaying them to Matrix if enabled. Normal text messages are relayed to all mapped Matrix rooms unless handled by a plugin or directed to the relay node. Non-text messages are passed to plugins for processing. Messages from unmapped channels or disabled detection sensors are ignored. Ensures sender information is retrieved or stored as needed.
+    Handles reactions and replies by relaying them to Matrix if enabled. Normal text messages are relayed to all mapped Matrix rooms unless handled by a plugin or directed to the relay node. Non-text messages are passed to plugins for processing. Messages from unmapped channels, disabled detection sensors, or during shutdown are ignored. Ensures sender information is retrieved or stored as needed.
     """
     global config, matrix_rooms
 
+    # Validate packet structure
+    if not packet or not isinstance(packet, dict):
+        logger.error("Received malformed packet: packet is None or not a dict")
+        return
+
     # Log that we received a message (without the full packet details)
-    if packet.get("decoded", {}).get("text"):
-        logger.info(
-            f"Received Meshtastic message: {packet.get('decoded', {}).get('text')}"
-        )
+    decoded = packet.get("decoded")
+    if decoded and isinstance(decoded, dict) and decoded.get("text"):
+        logger.info(f"Received Meshtastic message: {decoded.get('text')}")
     else:
         logger.debug("Received non-text Meshtastic message")
 
@@ -367,13 +466,13 @@ def on_meshtastic_message(packet, interface):
     message_storage_enabled(interactions)
 
     # Filter packets based on interaction settings
-    if packet.get("decoded", {}).get("portnum") == "TEXT_MESSAGE_APP":
+    if packet.get("decoded", {}).get("portnum") == TEXT_MESSAGE_APP:
         decoded = packet.get("decoded", {})
         # Filter out reactions if reactions are disabled
         if (
             not interactions["reactions"]
             and "emoji" in decoded
-            and decoded.get("emoji") == 1
+            and decoded.get("emoji") == EMOJI_FLAG_VALUE
         ):
             logger.debug(
                 "Filtered out reaction packet due to reactions being disabled."
@@ -400,7 +499,7 @@ def on_meshtastic_message(packet, interface):
     decoded = packet.get("decoded", {})
     text = decoded.get("text")
     replyId = decoded.get("replyId")
-    emoji_flag = "emoji" in decoded and decoded["emoji"] == 1
+    emoji_flag = "emoji" in decoded and decoded["emoji"] == EMOJI_FLAG_VALUE
 
     # Determine if this is a direct message to the relay node
     from meshtastic.mesh_interface import BROADCAST_NUM
@@ -415,7 +514,7 @@ def on_meshtastic_message(packet, interface):
         # Message to someone else; ignoring for broadcasting logic
         is_direct_message = False
 
-    meshnet_name = config["meshtastic"]["meshnet_name"]
+    meshnet_name = config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_MESHNET_NAME]
 
     # Reaction handling (Meshtastic -> Matrix)
     # If replyId and emoji_flag are present and reactions are enabled, we relay as text reactions in Matrix
@@ -510,12 +609,11 @@ def on_meshtastic_message(packet, interface):
         if channel is None:
             # If channel not specified, deduce from portnum
             if (
-                decoded.get("portnum") == "TEXT_MESSAGE_APP"
-                or decoded.get("portnum") == 1
+                decoded.get("portnum") == TEXT_MESSAGE_APP
+                or decoded.get("portnum") == PORTNUM_NUMERIC_VALUE
+                or decoded.get("portnum") == DETECTION_SENSOR_APP
             ):
-                channel = 0
-            elif decoded.get("portnum") == "DETECTION_SENSOR_APP":
-                channel = 0
+                channel = DEFAULT_CHANNEL_VALUE
             else:
                 logger.debug(
                     f"Unknown portnum {decoded.get('portnum')}, cannot determine channel"
@@ -534,7 +632,7 @@ def on_meshtastic_message(packet, interface):
             return
 
         # If detection_sensor is disabled and this is a detection sensor packet, skip it
-        if decoded.get("portnum") == "DETECTION_SENSOR_APP" and not config[
+        if decoded.get("portnum") == DETECTION_SENSOR_APP and not config[
             "meshtastic"
         ].get("detection_sensor", False):
             logger.debug(
@@ -585,15 +683,19 @@ def on_meshtastic_message(packet, interface):
         found_matching_plugin = False
         for plugin in plugins:
             if not found_matching_plugin:
-                result = asyncio.run_coroutine_threadsafe(
-                    plugin.handle_meshtastic_message(
-                        packet, formatted_message, longname, meshnet_name
-                    ),
-                    loop=loop,
-                )
-                found_matching_plugin = result.result()
-                if found_matching_plugin:
-                    logger.debug(f"Processed by plugin {plugin.plugin_name}")
+                try:
+                    result = asyncio.run_coroutine_threadsafe(
+                        plugin.handle_meshtastic_message(
+                            packet, formatted_message, longname, meshnet_name
+                        ),
+                        loop=loop,
+                    )
+                    found_matching_plugin = result.result()
+                    if found_matching_plugin:
+                        logger.debug(f"Processed by plugin {plugin.plugin_name}")
+                except Exception as e:
+                    logger.error(f"Plugin {plugin.plugin_name} failed: {e}")
+                    # Continue processing other plugins
 
         # If message is a DM or handled by plugin, do not relay further
         if is_direct_message:
@@ -642,36 +744,31 @@ def on_meshtastic_message(packet, interface):
         found_matching_plugin = False
         for plugin in plugins:
             if not found_matching_plugin:
-                result = asyncio.run_coroutine_threadsafe(
-                    plugin.handle_meshtastic_message(
-                        packet,
-                        formatted_message=None,
-                        longname=None,
-                        meshnet_name=None,
-                    ),
-                    loop=loop,
-                )
-                found_matching_plugin = result.result()
-                if found_matching_plugin:
-                    logger.debug(
-                        f"Processed {portnum} with plugin {plugin.plugin_name}"
+                try:
+                    result = asyncio.run_coroutine_threadsafe(
+                        plugin.handle_meshtastic_message(
+                            packet,
+                            formatted_message=None,
+                            longname=None,
+                            meshnet_name=None,
+                        ),
+                        loop=loop,
                     )
+                    found_matching_plugin = result.result()
+                    if found_matching_plugin:
+                        logger.debug(
+                            f"Processed {portnum} with plugin {plugin.plugin_name}"
+                        )
+                except Exception as e:
+                    logger.error(f"Plugin {plugin.plugin_name} failed: {e}")
+                    # Continue processing other plugins
 
 
 async def check_connection():
     """
-    Periodically checks the health of the Meshtastic connection and triggers reconnection if the connection is lost.
+    Periodically checks the health of the Meshtastic connection and triggers reconnection if the device becomes unresponsive.
 
-    Health checks can be enabled/disabled via configuration. When enabled, for non-BLE connections,
-    invokes `localNode.getMetadata()` at configurable intervals (default 60 seconds) to verify connectivity.
-    If the check fails or the firmware version is missing, initiates reconnection logic.
-
-    BLE connections rely on real-time disconnection detection and skip periodic health checks.
-    The function runs continuously until shutdown is requested.
-
-    Configuration:
-        health_check.enabled: Enable/disable health checks (default: true)
-        health_check.heartbeat_interval: Interval between checks in seconds (default: 60)
+    For non-BLE connections, performs a metadata check at configurable intervals to verify device responsiveness. If the check fails or the firmware version is missing, initiates reconnection unless already in progress. BLE connections are excluded from periodic checks due to real-time disconnection detection. The function runs continuously until shutdown is requested, with health check behavior controlled by configuration.
     """
     global meshtastic_client, shutting_down, config
 
@@ -680,7 +777,7 @@ async def check_connection():
         logger.error("No configuration available. Cannot check connection.")
         return
 
-    connection_type = config["meshtastic"]["connection_type"]
+    connection_type = config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_CONNECTION_TYPE]
 
     # Get health check configuration
     health_config = config["meshtastic"].get("health_check", {})
@@ -702,7 +799,7 @@ async def check_connection():
         if meshtastic_client and not reconnecting:
             # BLE has real-time disconnection detection in the library
             # Skip periodic health checks to avoid duplicate reconnection attempts
-            if connection_type == "ble":
+            if connection_type == CONNECTION_TYPE_BLE:
                 if not ble_skip_logged:
                     logger.info(
                         "BLE connection uses real-time disconnection detection - health checks disabled"
@@ -751,9 +848,7 @@ def sendTextReply(
     channelIndex: int = 0,
 ):
     """
-    Send a Meshtastic text message as a reply to a specific previous message.
-
-    Creates and sends a reply message by setting the `reply_id` field in the Meshtastic Data protobuf, enabling proper reply threading. Returns the sent packet with its ID populated.
+    Sends a text message as a reply to a specific previous message via the Meshtastic interface.
 
     Parameters:
         interface: The Meshtastic interface to send through.
@@ -764,10 +859,15 @@ def sendTextReply(
         channelIndex (int): The channel index to send the message on.
 
     Returns:
-        The sent MeshPacket with its ID field populated.
+        The sent MeshPacket with its ID field populated, or None if sending fails or the interface is unavailable.
     """
     logger.debug(f"Sending text reply: '{text}' replying to message ID {reply_id}")
 
+    # Check if interface is available
+    if interface is None:
+        logger.error("No Meshtastic interface available for sending reply")
+        return None
+
     # Create the Data protobuf message with reply_id set
     data_msg = mesh_pb2.Data()
     data_msg.portnum = portnums_pb2.PortNum.TEXT_MESSAGE_APP
@@ -781,9 +881,13 @@ def sendTextReply(
     mesh_packet.id = interface._generatePacketId()
 
     # Send the packet using the existing infrastructure
-    return interface._sendPacket(
-        mesh_packet, destinationId=destinationId, wantAck=wantAck
-    )
+    try:
+        return interface._sendPacket(
+            mesh_packet, destinationId=destinationId, wantAck=wantAck
+        )
+    except Exception as e:
+        logger.error(f"Failed to send text reply: {e}")
+        return None
 
 
 if __name__ == "__main__":

mmrelay/message_queue.py

@@ -13,18 +13,18 @@ from dataclasses import dataclass
 from queue import Empty, Queue
 from typing import Callable, Optional
 
+from mmrelay.constants.database import DEFAULT_MSGS_TO_KEEP
+from mmrelay.constants.network import MINIMUM_MESSAGE_DELAY
+from mmrelay.constants.queue import (
+    DEFAULT_MESSAGE_DELAY,
+    MAX_QUEUE_SIZE,
+    QUEUE_HIGH_WATER_MARK,
+    QUEUE_MEDIUM_WATER_MARK,
+)
 from mmrelay.log_utils import get_logger
 
 logger = get_logger(name="MessageQueue")
 
-# Default message delay in seconds (minimum 2.0 due to firmware constraints)
-DEFAULT_MESSAGE_DELAY = 2.2
-
-# Queue size configuration
-MAX_QUEUE_SIZE = 100
-QUEUE_HIGH_WATER_MARK = 75  # 75% of MAX_QUEUE_SIZE
-QUEUE_MEDIUM_WATER_MARK = 50  # 50% of MAX_QUEUE_SIZE
-
 
 @dataclass
 class QueuedMessage:
@@ -61,20 +61,20 @@ class MessageQueue:
 
     def start(self, message_delay: float = DEFAULT_MESSAGE_DELAY):
         """
-        Starts the message queue processor with the specified minimum delay between messages.
+        Start the message queue processor with a specified minimum delay between messages.
 
-        Enforces a minimum delay of 2.0 seconds due to firmware requirements. If the event loop is running, the processor task is started immediately; otherwise, startup is deferred until the event loop becomes available.
+        If the provided delay is below the firmware-enforced minimum, the minimum is used instead. The processor task is started immediately if the asyncio event loop is running; otherwise, startup is deferred until the event loop becomes available.
         """
         with self._lock:
             if self._running:
                 return
 
             # Validate and enforce firmware minimum
-            if message_delay < 2.0:
+            if message_delay < MINIMUM_MESSAGE_DELAY:
                 logger.warning(
-                    f"Message delay {message_delay}s below firmware minimum (2.0s), using 2.0s"
+                    f"Message delay {message_delay}s below firmware minimum ({MINIMUM_MESSAGE_DELAY}s), using {MINIMUM_MESSAGE_DELAY}s"
                 )
-                self._message_delay = 2.0
+                self._message_delay = MINIMUM_MESSAGE_DELAY
             else:
                 self._message_delay = message_delay
             self._running = True
@@ -372,13 +372,13 @@ class MessageQueue:
 
     def _handle_message_mapping(self, result, mapping_info):
         """
-        Stores and prunes message mapping information after a message is sent.
+        Update the message mapping database with information about a sent message and prune old mappings if configured.
 
         Parameters:
             result: The result object from the send function, expected to have an `id` attribute.
-            mapping_info (dict): Dictionary containing mapping details such as `matrix_event_id`, `room_id`, `text`, and optional `meshnet` and `msgs_to_keep`.
+            mapping_info (dict): Contains mapping details such as `matrix_event_id`, `room_id`, `text`, and optionally `meshnet` and `msgs_to_keep`.
 
-        This method updates the message mapping database with the new mapping and prunes old mappings if configured.
+        If required mapping fields are present, stores the mapping and prunes old entries based on the specified or default retention count.
         """
         try:
             # Import here to avoid circular imports
@@ -402,7 +402,7 @@ class MessageQueue:
                 logger.debug(f"Stored message map for meshtastic_id: {result.id}")
 
                 # Handle pruning if configured
-                msgs_to_keep = mapping_info.get("msgs_to_keep", 500)
+                msgs_to_keep = mapping_info.get("msgs_to_keep", DEFAULT_MSGS_TO_KEEP)
                 if msgs_to_keep > 0:
                     prune_message_map(msgs_to_keep)