mmrelay 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

mmrelay/__init__.py

@@ -3,16 +3,15 @@ Meshtastic Matrix Relay - Bridge between Meshtastic mesh networks and Matrix cha
 """
 
 import os
-
-import pkg_resources
+from importlib.metadata import PackageNotFoundError, version
 
 # First try to get version from environment variable (GitHub tag)
 if "GITHUB_REF_NAME" in os.environ:
     __version__ = os.environ.get("GITHUB_REF_NAME")
 else:
-    # Fall back to setup.cfg metadata using pkg_resources (compatible with PyInstaller)
+    # Fall back to package metadata using importlib.metadata (modern replacement for pkg_resources)
     try:
-        __version__ = pkg_resources.get_distribution("mmrelay").version
-    except pkg_resources.DistributionNotFound:
+        __version__ = version("mmrelay")
+    except PackageNotFoundError:
         # If all else fails, use hardcoded version
-        __version__ = "1.0.8"
+        __version__ = "1.0.10"

mmrelay/main.py

@@ -23,7 +23,7 @@ from mmrelay.db_utils import (
 from mmrelay.log_utils import get_logger
 from mmrelay.matrix_utils import connect_matrix, join_matrix_room
 from mmrelay.matrix_utils import logger as matrix_logger
-from mmrelay.matrix_utils import on_room_message, on_room_member
+from mmrelay.matrix_utils import on_room_member, on_room_message
 from mmrelay.meshtastic_utils import connect_meshtastic
 from mmrelay.meshtastic_utils import logger as meshtastic_logger
 from mmrelay.plugin_loader import load_plugins

mmrelay/matrix_utils.py

@@ -524,7 +524,9 @@ async def on_room_message(
                 full_display_name = room_display_name
             else:
                 # Fallback to global display name if room-specific name is not available
-                display_name_response = await matrix_client.get_displayname(event.sender)
+                display_name_response = await matrix_client.get_displayname(
+                    event.sender
+                )
                 full_display_name = display_name_response.displayname or event.sender
 
             # If not from a remote meshnet, proceed as normal to relay back to the originating meshnet
@@ -771,32 +773,12 @@ async def on_room_member(room: MatrixRoom, event: RoomMemberEvent) -> None:
     """
     Callback to handle room member events, specifically tracking room-specific display name changes.
     This ensures we detect when users update their display names in specific rooms.
-    """
-    # Only track updates from active members
-    if event.membership != "join":
-        return
-
-    new_displayname = event.content.get("displayname")
-    old_displayname = event.prev_content.get("displayname") if event.prev_content else None
-    user_id = event.state_key
-    room_id = room.room_id
-
-    # Log display name changes for debugging
-    if new_displayname != old_displayname:
-        if new_displayname and old_displayname:
-            logger.info(
-                f"[Matrix] {user_id} updated room display name in {room_id}: "
-                f"'{old_displayname}' → '{new_displayname}'"
-            )
-        elif new_displayname and not old_displayname:
-            logger.info(
-                f"[Matrix] {user_id} set room display name in {room_id}: '{new_displayname}'"
-            )
-        elif not new_displayname and old_displayname:
-            logger.info(
-                f"[Matrix] {user_id} removed room display name in {room_id}: '{old_displayname}' → (global name)"
-            )
 
-    # Note: We don't need to maintain a separate cache here since matrix-nio
-    # automatically updates the room state and room.user_name() will return
-    # the updated room-specific display name immediately after this event.
+    Note: This callback doesn't need to do any explicit processing since matrix-nio
+    automatically updates the room state and room.user_name() will return the
+    updated room-specific display name immediately after this event.
+    """
+    # The callback is registered to ensure matrix-nio processes the event,
+    # but no explicit action is needed since room.user_name() automatically
+    # handles room-specific display names after the room state is updated.
+    pass

mmrelay/plugin_loader.py

@@ -57,6 +57,28 @@ def get_community_plugin_dirs():
 
 
 def clone_or_update_repo(repo_url, ref, plugins_dir):
+    """Clone or update a Git repository for community plugins.
+
+    Args:
+        repo_url (str): Git repository URL to clone/update
+        ref (dict): Reference specification with keys:
+                   - type: "tag" or "branch"
+                   - value: tag name or branch name
+        plugins_dir (str): Directory where the repository should be cloned
+
+    Returns:
+        bool: True if successful, False if clone/update failed
+
+    Handles complex Git operations including:
+    - Cloning new repositories with specific tags/branches
+    - Updating existing repositories and switching refs
+    - Installing requirements.txt dependencies via pip or pipx
+    - Fallback to default branches (main/master) when specified ref fails
+    - Robust error handling and logging
+
+    The function automatically installs Python dependencies if a requirements.txt
+    file is found in the repository root.
+    """
     # Extract the repository name from the URL
     repo_name = os.path.splitext(os.path.basename(repo_url.rstrip("/")))[0]
     repo_path = os.path.join(plugins_dir, repo_name)
@@ -497,6 +519,27 @@ def clone_or_update_repo(repo_url, ref, plugins_dir):
 
 
 def load_plugins_from_directory(directory, recursive=False):
+    """Load plugin classes from Python files in a directory.
+
+    Args:
+        directory (str): Directory path to search for plugin files
+        recursive (bool): Whether to search subdirectories recursively
+
+    Returns:
+        list: List of instantiated plugin objects found in the directory
+
+    Scans for .py files and attempts to import each as a module. Looks for
+    a 'Plugin' class in each module and instantiates it if found.
+
+    Features:
+    - Automatic dependency installation for missing imports (via pip/pipx)
+    - Compatibility layer for import paths (plugins vs mmrelay.plugins)
+    - Proper sys.path management for plugin directory imports
+    - Comprehensive error handling and logging
+
+    Skips files that don't define a Plugin class or have import errors
+    that can't be automatically resolved.
+    """
     plugins = []
     if os.path.isdir(directory):
         for root, _dirs, files in os.walk(directory):
@@ -617,6 +660,26 @@ def load_plugins_from_directory(directory, recursive=False):
 
 
 def load_plugins(passed_config=None):
+    """Load and initialize all active plugins based on configuration.
+
+    Args:
+        passed_config (dict, optional): Configuration dictionary to use.
+                                       If None, uses global config variable.
+
+    Returns:
+        list: List of active plugin instances sorted by priority
+
+    This is the main plugin loading function that:
+    - Loads core plugins from mmrelay.plugins package
+    - Processes custom plugins from ~/.mmrelay/plugins/custom and plugins/custom
+    - Downloads and loads community plugins from configured Git repositories
+    - Filters plugins based on active status in configuration
+    - Sorts active plugins by priority and calls their start() method
+    - Sets up proper plugin configuration and channel mapping
+
+    Only plugins explicitly marked as active=true in config are loaded.
+    Custom and community plugins are cloned/updated automatically.
+    """
     global sorted_active_plugins
     global plugins_loaded
     global config

mmrelay/plugins/base_plugin.py

@@ -20,6 +20,27 @@ config = None
 
 
 class BasePlugin(ABC):
+    """Abstract base class for all mmrelay plugins.
+
+    Provides common functionality for plugin development including:
+    - Configuration management and validation
+    - Database storage for plugin-specific data
+    - Channel and direct message handling
+    - Matrix message sending capabilities
+    - Scheduling support for background tasks
+    - Command matching and routing
+
+    Attributes:
+        plugin_name (str): Unique identifier for the plugin
+        max_data_rows_per_node (int): Maximum data rows stored per node (default: 100)
+        priority (int): Plugin execution priority (lower = higher priority, default: 10)
+
+    Subclasses must:
+    - Set plugin_name as a class attribute
+    - Implement handle_meshtastic_message() and handle_room_message()
+    - Optionally override other methods for custom behavior
+    """
+
     # Class-level default attributes
     plugin_name = None  # Must be overridden in subclasses
     max_data_rows_per_node = 100
@@ -27,9 +48,32 @@ class BasePlugin(ABC):
 
     @property
     def description(self):
+        """Get the plugin description for help text.
+
+        Returns:
+            str: Human-readable description of plugin functionality
+
+        Override this property in subclasses to provide meaningful help text
+        that will be displayed by the help plugin.
+        """
         return ""
 
     def __init__(self, plugin_name=None) -> None:
+        """Initialize the plugin with configuration and logging.
+
+        Args:
+            plugin_name (str, optional): Plugin name override. If not provided,
+                                       uses class-level plugin_name attribute.
+
+        Raises:
+            ValueError: If plugin_name is not set via parameter or class attribute
+
+        Sets up:
+        - Plugin-specific logger
+        - Configuration from global config
+        - Channel mapping and validation
+        - Response delay settings
+        """
         # Allow plugin_name to be passed as a parameter for simpler initialization
         # This maintains backward compatibility while providing a cleaner API
         super().__init__()
@@ -96,6 +140,19 @@ class BasePlugin(ABC):
             )
 
     def start(self):
+        """Start the plugin and set up scheduled tasks if configured.
+
+        Called automatically when the plugin is loaded. Checks plugin configuration
+        for scheduling settings and sets up background jobs accordingly.
+
+        Supported schedule formats in config:
+        - schedule.hours + schedule.at: Run every N hours at specific time
+        - schedule.minutes + schedule.at: Run every N minutes at specific time
+        - schedule.hours: Run every N hours
+        - schedule.minutes: Run every N minutes
+
+        Creates a daemon thread to run the scheduler if any schedule is configured.
+        """
         if "schedule" not in self.config or (
             "at" not in self.config["schedule"]
             and "hours" not in self.config["schedule"]
@@ -137,9 +194,27 @@ class BasePlugin(ABC):
 
     # trunk-ignore(ruff/B027)
     def background_job(self):
+        """Background task executed on schedule.
+
+        Override this method in subclasses to implement scheduled functionality.
+        Called automatically based on schedule configuration in start().
+
+        Default implementation does nothing.
+        """
         pass  # Implement in subclass if needed
 
     def strip_raw(self, data):
+        """Recursively remove 'raw' keys from data structures.
+
+        Args:
+            data: Data structure (dict, list, or other) to clean
+
+        Returns:
+            Cleaned data structure with 'raw' keys removed
+
+        Useful for cleaning packet data before logging or storage to remove
+        binary protobuf data that's not human-readable.
+        """
         if isinstance(data, dict):
             data.pop("raw", None)
             for k, v in data.items():
@@ -149,19 +224,59 @@ class BasePlugin(ABC):
         return data
 
     def get_response_delay(self):
+        """Get the configured response delay for meshtastic messages.
+
+        Returns:
+            int: Delay in seconds before sending responses (default: 3)
+
+        Used to prevent message flooding and ensure proper radio etiquette.
+        Delay is configured via meshtastic.plugin_response_delay in config.
+        """
         return self.response_delay
 
-    # Modified method to accept is_direct_message parameter
     def is_channel_enabled(self, channel, is_direct_message=False):
+        """Check if the plugin should respond on a specific channel.
+
+        Args:
+            channel: Channel identifier to check
+            is_direct_message (bool): Whether this is a direct message
+
+        Returns:
+            bool: True if plugin should respond, False otherwise
+
+        Direct messages always return True if the plugin is active.
+        For channel messages, checks if channel is in plugin's configured channels list.
+        """
         if is_direct_message:
             return True  # Always respond to DMs if the plugin is active
         else:
             return channel in self.channels
 
     def get_matrix_commands(self):
+        """Get list of Matrix commands this plugin responds to.
+
+        Returns:
+            list: List of command strings (without ! prefix)
+
+        Default implementation returns [plugin_name]. Override to provide
+        custom commands or multiple command aliases.
+        """
         return [self.plugin_name]
 
     async def send_matrix_message(self, room_id, message, formatted=True):
+        """Send a message to a Matrix room.
+
+        Args:
+            room_id (str): Matrix room identifier
+            message (str): Message content to send
+            formatted (bool): Whether to send as formatted HTML (default: True)
+
+        Returns:
+            dict: Response from Matrix API room_send
+
+        Connects to Matrix using matrix_utils and sends a room message
+        with optional HTML formatting via markdown.
+        """
         from mmrelay.matrix_utils import connect_matrix
 
         matrix_client = await connect_matrix()
@@ -178,9 +293,26 @@ class BasePlugin(ABC):
         )
 
     def get_mesh_commands(self):
+        """Get list of mesh/radio commands this plugin responds to.
+
+        Returns:
+            list: List of command strings (without ! prefix)
+
+        Default implementation returns empty list. Override to handle
+        commands sent over the mesh radio network.
+        """
         return []
 
     def store_node_data(self, meshtastic_id, node_data):
+        """Store data for a specific node, appending to existing data.
+
+        Args:
+            meshtastic_id (str): Node identifier
+            node_data: Data to store (single item or list)
+
+        Retrieves existing data, appends new data, trims to max_data_rows_per_node,
+        and stores back to database. Use for accumulating time-series data.
+        """
         data = self.get_node_data(meshtastic_id=meshtastic_id)
         data = data[-self.max_data_rows_per_node :]
         if isinstance(node_data, list):
@@ -190,21 +322,56 @@ class BasePlugin(ABC):
         store_plugin_data(self.plugin_name, meshtastic_id, data)
 
     def set_node_data(self, meshtastic_id, node_data):
+        """Replace all data for a specific node.
+
+        Args:
+            meshtastic_id (str): Node identifier
+            node_data: Data to store (replaces existing data)
+
+        Completely replaces existing data for the node, trimming to
+        max_data_rows_per_node if needed. Use when you want to reset
+        or completely replace a node's data.
+        """
         node_data = node_data[-self.max_data_rows_per_node :]
         store_plugin_data(self.plugin_name, meshtastic_id, node_data)
 
     def delete_node_data(self, meshtastic_id):
+        """Delete all stored data for a specific node.
+
+        Args:
+            meshtastic_id (str): Node identifier
+
+        Returns:
+            bool: True if deletion succeeded, False otherwise
+        """
         return delete_plugin_data(self.plugin_name, meshtastic_id)
 
     def get_node_data(self, meshtastic_id):
+        """Retrieve stored data for a specific node.
+
+        Args:
+            meshtastic_id (str): Node identifier
+
+        Returns:
+            list: Stored data for the node (JSON deserialized)
+        """
         return get_plugin_data_for_node(self.plugin_name, meshtastic_id)
 
     def get_data(self):
+        """Retrieve all stored data for this plugin across all nodes.
+
+        Returns:
+            list: List of tuples containing raw data entries
+
+        Returns raw data without JSON deserialization. Use get_node_data()
+        for individual node data that's automatically deserialized.
+        """
         return get_plugin_data(self.plugin_name)
 
     def get_plugin_data_dir(self, subdir=None):
         """
         Returns the directory for storing plugin-specific data files.
+
         Creates the directory if it doesn't exist.
 
         Args:
@@ -230,6 +397,17 @@ class BasePlugin(ABC):
         return plugin_dir
 
     def matches(self, event):
+        """Check if a Matrix event matches this plugin's commands.
+
+        Args:
+            event: Matrix room event to check
+
+        Returns:
+            bool: True if event matches plugin commands, False otherwise
+
+        Uses bot_command() utility to check if the event contains any of
+        the plugin's matrix commands with proper bot command syntax.
+        """
         from mmrelay.matrix_utils import bot_command
 
         # Pass the entire event to bot_command

mmrelay/plugins/debug_plugin.py

@@ -2,6 +2,19 @@ from mmrelay.plugins.base_plugin import BasePlugin
 
 
 class Plugin(BasePlugin):
+    """Debug plugin for logging packet information.
+
+    A low-priority plugin that logs all received meshtastic packets
+    for debugging and development purposes. Strips raw binary data
+    before logging to keep output readable.
+
+    Configuration:
+        priority: 1 (runs first, before other plugins)
+
+    Never intercepts messages (always returns False) so other plugins
+    can still process the same packets.
+    """
+
     plugin_name = "debug"
     priority = 1
 

mmrelay/plugins/help_plugin.py

@@ -5,13 +5,28 @@ from mmrelay.plugins.base_plugin import BasePlugin
 
 
 class Plugin(BasePlugin):
-    plugin_name = "help"
+    """Help command plugin for listing available commands.
+
+    Provides users with information about available relay commands
+    and plugin functionality.
+
+    Commands:
+        !help: List all available commands
+        !help <command>: Show detailed help for a specific command
+
+    Dynamically discovers available commands from all loaded plugins
+    and their descriptions.
+    """
 
-    # No __init__ method needed with the simplified plugin system
-    # The BasePlugin will automatically use the class-level plugin_name
+    plugin_name = "help"
 
     @property
     def description(self):
+        """Get plugin description.
+
+        Returns:
+            str: Description of help functionality
+        """
         return "List supported relay commands"
 
     async def handle_meshtastic_message(
@@ -20,9 +35,19 @@ class Plugin(BasePlugin):
         return False
 
     def get_matrix_commands(self):
+        """Get Matrix commands handled by this plugin.
+
+        Returns:
+            list: List containing the help command
+        """
         return [self.plugin_name]
 
     def get_mesh_commands(self):
+        """Get mesh commands handled by this plugin.
+
+        Returns:
+            list: Empty list (help only works via Matrix)
+        """
         return []
 
     async def handle_room_message(self, room, event, full_message):

mmrelay/plugins/map_plugin.py

@@ -156,6 +156,19 @@ class TextLabel(staticmaps.Object):
 
 
 def anonymize_location(lat, lon, radius=1000):
+    """Add random offset to GPS coordinates for privacy protection.
+
+    Args:
+        lat (float): Original latitude
+        lon (float): Original longitude
+        radius (int): Maximum offset distance in meters (default: 1000)
+
+    Returns:
+        tuple: (new_lat, new_lon) with random offset applied
+
+    Adds random offset within specified radius to obscure exact locations
+    while maintaining general geographic area for mapping purposes.
+    """
     # Generate random offsets for latitude and longitude
     lat_offset = random.uniform(-radius / 111320, radius / 111320)
     lon_offset = random.uniform(
@@ -233,6 +246,24 @@ async def send_image(client: AsyncClient, room_id: str, image: Image.Image):
 
 
 class Plugin(BasePlugin):
+    """Static map generation plugin for mesh node locations.
+
+    Generates static maps showing positions of mesh nodes with labeled markers.
+    Supports customizable zoom levels, image sizes, and privacy features.
+
+    Commands:
+        !map: Generate map with default settings
+        !map zoom=N: Set zoom level (0-30)
+        !map size=W,H: Set image dimensions (max 1000x1000)
+
+    Configuration:
+        zoom (int): Default zoom level (default: 8)
+        image_width/image_height (int): Default image size (default: 1000x1000)
+        anonymize (bool): Whether to offset coordinates for privacy (default: true)
+        radius (int): Anonymization offset radius in meters (default: 1000)
+
+    Uploads generated maps as images to Matrix rooms.
+    """
     plugin_name = "map"
 
     # No __init__ method needed with the simplified plugin system

mmrelay/plugins/mesh_relay_plugin.py

@@ -1,3 +1,5 @@
+# Note: This plugin was experimental and is not functional.
+
 import base64
 import json
 import re
@@ -8,12 +10,36 @@ from mmrelay.plugins.base_plugin import BasePlugin, config
 
 
 class Plugin(BasePlugin):
+    """Core mesh-to-Matrix relay plugin.
+
+    Handles bidirectional message relay between Meshtastic mesh network
+    and Matrix chat rooms. Processes radio packets and forwards them
+    to configured Matrix rooms, and vice versa.
+
+    This plugin is fundamental to the relay's core functionality and
+    typically runs with high priority to ensure messages are properly
+    bridged between the two networks.
+
+    Configuration:
+        max_data_rows_per_node: 50 (reduced storage for performance)
+    """
+
     plugin_name = "mesh_relay"
     max_data_rows_per_node = 50
 
     def normalize(self, dict_obj):
-        """
-        Packets are either a dict, string dict or string
+        """Normalize packet data to consistent dictionary format.
+
+        Args:
+            dict_obj: Packet data (dict, JSON string, or plain string)
+
+        Returns:
+            dict: Normalized packet dictionary with raw data stripped
+
+        Handles various packet formats:
+        - Dict objects (passed through)
+        - JSON strings (parsed)
+        - Plain strings (wrapped in TEXT_MESSAGE_APP format)
         """
         if not isinstance(dict_obj, dict):
             try:
@@ -24,6 +50,17 @@ class Plugin(BasePlugin):
         return self.strip_raw(dict_obj)
 
     def process(self, packet):
+        """Process and prepare packet data for relay.
+
+        Args:
+            packet: Raw packet data to process
+
+        Returns:
+            dict: Processed packet with base64-encoded binary payloads
+
+        Normalizes packet format and encodes binary payloads as base64
+        for JSON serialization and Matrix transmission.
+        """
         packet = self.normalize(packet)
 
         if "decoded" in packet and "payload" in packet["decoded"]:
@@ -35,14 +72,39 @@ class Plugin(BasePlugin):
         return packet
 
     def get_matrix_commands(self):
+        """Get Matrix commands handled by this plugin.
+
+        Returns:
+            list: Empty list (this plugin handles all traffic, not specific commands)
+        """
         return []
 
     def get_mesh_commands(self):
+        """Get mesh commands handled by this plugin.
+
+        Returns:
+            list: Empty list (this plugin handles all traffic, not specific commands)
+        """
         return []
 
     async def handle_meshtastic_message(
         self, packet, formatted_message, longname, meshnet_name
     ):
+        """Handle incoming meshtastic message and relay to Matrix.
+
+        Args:
+            packet: Raw packet data (dict or JSON) to relay
+            formatted_message (str): Human-readable message extracted from packet
+            longname (str): Long name of the sender node
+            meshnet_name (str): Name of the mesh network
+
+        Returns:
+            bool: Always returns False to allow other plugins to process the same packet
+
+        Processes the packet by normalizing and preparing it, connects to the Matrix client,
+        checks if the meshtastic channel is mapped to a Matrix room based on config,
+        and sends the packet to the appropriate Matrix room.
+        """
         from mmrelay.matrix_utils import connect_matrix
 
         packet = self.process(packet)
@@ -80,6 +142,17 @@ class Plugin(BasePlugin):
         return False
 
     def matches(self, event):
+        """Check if Matrix event is a relayed radio packet.
+
+        Args:
+            event: Matrix room event object
+
+        Returns:
+            bool: True if event contains embedded meshtastic packet JSON
+
+        Identifies Matrix messages that contain embedded meshtastic packet
+        data by matching the default relay message format "Processed <portnum> radio packet".
+        """
         # Check for the presence of necessary keys in the event
         content = event.source.get("content", {})
         body = content.get("body", "")
@@ -90,6 +163,20 @@ class Plugin(BasePlugin):
         return False
 
     async def handle_room_message(self, room, event, full_message):
+        """Handle incoming Matrix room message and relay to meshtastic mesh.
+
+        Args:
+            room: Matrix Room object where message was received
+            event: Matrix room event containing the message
+            full_message (str): Raw message body text
+
+        Returns:
+            bool: True if packet relaying succeeded, False otherwise
+
+        Checks if the Matrix event matches the expected embedded packet format,
+        retrieves the packet JSON, decodes it, reconstructs a MeshPacket,
+        connects to the meshtastic client, and sends the packet via the radio.
+        """
         # Use the event for matching instead of full_message
         if not self.matches(event):
             return False

{mmrelay-1.0.8.dist-info → mmrelay-1.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.0.8
+Version: 1.0.10
 Summary: Bridge between Meshtastic mesh networks and Matrix chat rooms
 Home-page: https://github.com/geoffwhittington/meshtastic-matrix-relay
 Author: Geoff Whittington, Jeremiah K., and contributors
@@ -25,7 +25,7 @@ Requires-Dist: schedule==1.2.2
 Requires-Dist: platformdirs==4.3.8
 Requires-Dist: py-staticmaps>=0.4.0
 Requires-Dist: rich==14.0.0
-Requires-Dist: setuptools==80.8.0
+Requires-Dist: setuptools==80.9.0
 Dynamic: license-file
 
 # M<>M Relay

{mmrelay-1.0.8.dist-info → mmrelay-1.0.10.dist-info}/RECORD

@@ -1,22 +1,22 @@
-mmrelay/__init__.py,sha256=m8l2zIk6h1Ba54Ru2fsB0Ujsi_4btG1sZ40XjtYK0Mg,588
+mmrelay/__init__.py,sha256=rWjkMuhqS5lSbzLMKWUx0-48C-MLUQjYdjvYLBj4vv0,595
 mmrelay/cli.py,sha256=hdPTlcGsXTJC9GEUiScG7b3IFp02B3lwhqgwFpU3NsM,13835
 mmrelay/config.py,sha256=5VZag8iSc5yLQgvwI76bbpizbtqag74cHnfXCrWHNyA,7910
 mmrelay/config_checker.py,sha256=UnoHVTXzfdTfFkbmXv9r_Si76v-sxXLb5FOaQSOM45E,4909
 mmrelay/db_utils.py,sha256=DP2YuKBZtV771wo9X-Z7Ww5txfaIR0inWh1K_oVZ7cA,11430
 mmrelay/log_utils.py,sha256=FXhaq4WSDHwlqiG3k1BbSxiOl5be4P4Kyr1gsIThOBw,4572
-mmrelay/main.py,sha256=4Cgv5bLwX9JLMAYmY4TePRY8XDMEKcj3ghYicBwednA,11301
-mmrelay/matrix_utils.py,sha256=7rjjHtm8JNXi2fgZ33L3VRvxomA9gQw3dJD6mqZi_lY,32770
+mmrelay/main.py,sha256=88hmJzv-Fw3CSjcMSlQWKjlZlIlZBjOujMfi85r5uCk,11301
+mmrelay/matrix_utils.py,sha256=D7zhTF6Jg7JVQbyQsu3htEKWhLtV5IUpJ-bTASnmEwI,32032
 mmrelay/meshtastic_utils.py,sha256=Pd0j7mz008ncBDIjRGyHOIb0U3vKq06uXWoJP-csHcQ,23381
-mmrelay/plugin_loader.py,sha256=Gg8E_TKqndMQHiVJwtmlIC-jCgcty-5EsX_5JJ6Onvo,36590
+mmrelay/plugin_loader.py,sha256=NRiXF6Ty1WD9jNXXKvzJh7kE0ba5oICXNVAfMaTPqH4,39247
 mmrelay/setup_utils.py,sha256=N6qdScHKHEMFKDmT1l7dcLDPNTusZXPkyxrLXjFLhRI,19910
 mmrelay/plugins/__init__.py,sha256=KVMQIXRhe0wlGj4O3IZ0vOIQRKFkfPYejHXhJL17qrc,51
-mmrelay/plugins/base_plugin.py,sha256=AlC7Y0jMh42jouXpJNtpvo4vMbS0KedOUFuJvWmZggY,8962
-mmrelay/plugins/debug_plugin.py,sha256=Jziht9Nj_bRO6Rmy7TjfBXaYo5eM3XsenbWFxPpyUs4,443
+mmrelay/plugins/base_plugin.py,sha256=Gf3xrWdYnXu2dnY4TcOhCGy9fZDISna8OI_Pgt_QX8Q,15415
+mmrelay/plugins/debug_plugin.py,sha256=adX0cRJHUEDLldajybPfiRDDlvytkZe5aN_dSgNKP2Y,870
 mmrelay/plugins/drop_plugin.py,sha256=0GOz0dgLnFST1HTgqrMayrjwmYlnu02QxfnTZtdPZ3U,4671
 mmrelay/plugins/health_plugin.py,sha256=svV_GfpAVL0QhiVzi3PVZ1mNpsOL1NHSmkRF-Mn_ExE,2250
-mmrelay/plugins/help_plugin.py,sha256=GP7i1iWNiJxb_Pbuod0ctveIQYL1FNN8ctUvy24yRNM,1506
-mmrelay/plugins/map_plugin.py,sha256=xqQvjuY-VVuuhVQyDJHnj9uZKYaXV0qSaBTbVwfVOfo,10078
-mmrelay/plugins/mesh_relay_plugin.py,sha256=E04JU4uKr7KTScahS0VKBJ1xwvq1ULJaeFVYEtceMvA,4273
+mmrelay/plugins/help_plugin.py,sha256=S7nBhsANK46Zv9wPHOVegPGcuYGMErBsxAnrRlSSCwg,2149
+mmrelay/plugins/map_plugin.py,sha256=eHV_t3TFcypBD4xT_OQx0hD6_iGkLJOADjwYVny0PvE,11292
+mmrelay/plugins/mesh_relay_plugin.py,sha256=PIQBACC7Yjq7hzKJJNycHTjkayEC9tsC8-JNG4q_AY8,7563
 mmrelay/plugins/nodes_plugin.py,sha256=RDabzyG5hKG5aYWecsRUcLSjMCCv6Pngmq2Qpld1A1U,2903
 mmrelay/plugins/ping_plugin.py,sha256=8uFnT3qfO3RBaTUOx348voIfKpzXB3zTfcT6Gtfc8kM,4070
 mmrelay/plugins/telemetry_plugin.py,sha256=8SxWv4BLXMUTbiVaD3MjlMMdQyS7S_1OfLlVNAUMSO0,6306
@@ -24,9 +24,9 @@ mmrelay/plugins/weather_plugin.py,sha256=1bQhmiX-enNphzGoFVprU0LcZQX9BvGxWAJAG8W
 mmrelay/tools/__init__.py,sha256=WFjDQjdevgg19_zT6iEoL29rvb1JPqYSd8708Jn5D7A,838
 mmrelay/tools/mmrelay.service,sha256=3vqK1VbfXvVftkTrTEOan77aTHeOT36hIAL7HqJsmTg,567
 mmrelay/tools/sample_config.yaml,sha256=iGOoVxELUEJwfmpFxyeWXXS0RWNsErnf8-6LXyIwH2k,3052
-mmrelay-1.0.8.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
-mmrelay-1.0.8.dist-info/METADATA,sha256=orw_9ScvoB4pOpJMkQ5WJvfLEZphl7N5OD0oRHpyIC8,5916
-mmrelay-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mmrelay-1.0.8.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.0.8.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.0.8.dist-info/RECORD,,
+mmrelay-1.0.10.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
+mmrelay-1.0.10.dist-info/METADATA,sha256=qKs8SIx9dDs3fwEmSd0Dj3Y8mdoKTpQRkyUwBhjUoTE,5917
+mmrelay-1.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mmrelay-1.0.10.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.0.10.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.0.10.dist-info/RECORD,,