mmrelay 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

mmrelay/__init__.py

@@ -14,4 +14,4 @@ else:
         __version__ = version("mmrelay")
     except PackageNotFoundError:
         # If all else fails, use hardcoded version
-        __version__ = "1.1.0"
+        __version__ = "1.1.2"

mmrelay/log_utils.py

@@ -28,15 +28,52 @@ config = None
 # Global variable to store the log file path
 log_file_path = None
 
+# Track if component debug logging has been configured
+_component_debug_configured = False
+
+# Component logger mapping for data-driven configuration
+_COMPONENT_LOGGERS = {
+    "matrix_nio": ["nio", "nio.client", "nio.http", "nio.crypto"],
+    "bleak": ["bleak", "bleak.backends"],
+    "meshtastic": [
+        "meshtastic",
+        "meshtastic.serial_interface",
+        "meshtastic.tcp_interface",
+        "meshtastic.ble_interface",
+    ],
+}
+
+
+def configure_component_debug_logging():
+    """
+    Enables debug-level logging for selected external components based on configuration settings.
+
+    This function sets the log level to DEBUG for specific libraries (matrix_nio, bleak, meshtastic) if enabled in the global configuration under `logging.debug`. It ensures that component debug logging is configured only once per application run.
+    """
+    global _component_debug_configured, config
+
+    # Only configure once
+    if _component_debug_configured or config is None:
+        return
+
+    debug_config = config.get("logging", {}).get("debug", {})
+
+    for component, loggers in _COMPONENT_LOGGERS.items():
+        if debug_config.get(component, False):
+            for logger_name in loggers:
+                logging.getLogger(logger_name).setLevel(logging.DEBUG)
+
+    _component_debug_configured = True
+
 
 def get_logger(name):
     """
-    Create and configure a logger with console and optional file output, supporting colorized output and log rotation.
+    Create and configure a logger with console and optional rotating file output, using global configuration and command-line arguments.
 
-    The logger's level, color usage, and file logging behavior are determined by global configuration and command line arguments. Console output uses rich formatting if enabled. File logging supports log rotation and stores logs in a configurable or default location. The log file path is stored globally if the logger name is "M<>M Relay".
+    The logger supports colorized console output via Rich if enabled, and writes logs to a rotating file if configured or requested via command-line arguments. Log file location and rotation parameters are determined by priority: command-line argument, configuration file, or a default directory. The function ensures the log directory exists and stores the log file path globally if the logger name is "M<>M Relay".
 
     Parameters:
-        name (str): The name of the logger to create.
+        name (str): The name of the logger to create and configure.
 
     Returns:
         logging.Logger: The configured logger instance.
@@ -145,48 +182,3 @@ def get_logger(name):
         logger.addHandler(file_handler)
 
     return logger
-
-
-def setup_upstream_logging_capture():
-    """
-    Redirects warning and error log messages from upstream libraries and the root logger into the application's formatted logging system.
-
-    This ensures that log output from external dependencies (such as "meshtastic", "bleak", and "asyncio") appears with consistent formatting alongside the application's own logs. Only messages at WARNING level or higher are captured, and messages originating from the application's own loggers are excluded to prevent recursion.
-    """
-    # Get our main logger
-    main_logger = get_logger("Upstream")
-
-    # Create a custom handler that redirects root logger messages
-    class UpstreamLogHandler(logging.Handler):
-        def emit(self, record):
-            # Skip if this is already from our logger to avoid recursion
-            """
-            Redirects log records from external sources to the main logger, mapping their severity and prefixing with the original logger name.
-
-            Skips records originating from the application's own loggers to prevent recursion.
-            """
-            if record.name.startswith("mmrelay") or record.name == "Upstream":
-                return
-
-            # Map the log level and emit through our logger
-            if record.levelno >= logging.ERROR:
-                main_logger.error(f"[{record.name}] {record.getMessage()}")
-            elif record.levelno >= logging.WARNING:
-                main_logger.warning(f"[{record.name}] {record.getMessage()}")
-            elif record.levelno >= logging.INFO:
-                main_logger.info(f"[{record.name}] {record.getMessage()}")
-            else:
-                main_logger.debug(f"[{record.name}] {record.getMessage()}")
-
-    # Add our handler to the root logger
-    root_logger = logging.getLogger()
-    upstream_handler = UpstreamLogHandler()
-    upstream_handler.setLevel(logging.WARNING)  # Only capture warnings and errors
-    root_logger.addHandler(upstream_handler)
-
-    # Also set up specific loggers for known upstream libraries
-    for logger_name in ["meshtastic", "bleak", "asyncio"]:
-        upstream_logger = logging.getLogger(logger_name)
-        upstream_logger.addHandler(upstream_handler)
-        upstream_logger.setLevel(logging.WARNING)
-        upstream_logger.propagate = False  # Prevent duplicate messages via root logger

mmrelay/main.py

@@ -4,6 +4,7 @@ It uses Meshtastic-python and Matrix nio client library to interface with the ra
 """
 
 import asyncio
+import concurrent.futures
 import logging
 import signal
 import sys
@@ -20,7 +21,7 @@ from mmrelay.db_utils import (
     update_shortnames,
     wipe_message_map,
 )
-from mmrelay.log_utils import get_logger, setup_upstream_logging_capture
+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_member, on_room_message
@@ -50,12 +51,9 @@ def print_banner():
 
 async def main(config):
     """
-    Sets up and runs the asynchronous relay between Meshtastic and Matrix, managing connections, event handling, and graceful shutdown.
+    Run the main asynchronous relay loop, managing connections between Meshtastic and Matrix, event handling, and graceful shutdown.
 
-    This function initializes the database, configures logging, loads plugins, connects to both Meshtastic and Matrix, joins specified Matrix rooms, and registers event callbacks for message and membership events. It periodically updates node names from the Meshtastic network and manages the Matrix sync loop, handling reconnections and shutdown signals. If configured, it wipes the message map on startup and shutdown.
-
-    Parameters:
-        config: The loaded configuration dictionary containing Matrix, Meshtastic, and database settings.
+    Initializes the database, loads plugins, connects to Meshtastic and Matrix, joins configured Matrix rooms, and registers event callbacks for message and membership events. Periodically updates node names from the Meshtastic network and manages the Matrix sync loop, handling reconnections and shutdown signals. If configured, wipes the message map on both startup and shutdown.
     """
     # Extract Matrix configuration
     from typing import List
@@ -68,9 +66,6 @@ async def main(config):
     # Initialize the SQLite database
     initialize_database()
 
-    # Set up upstream logging capture to format library messages consistently
-    setup_upstream_logging_capture()
-
     # Check database config for wipe_on_restart (preferred format)
     database_config = config.get("database", {})
     msg_map_config = database_config.get("msg_map", {})
@@ -183,9 +178,31 @@ async def main(config):
         if meshtastic_utils.meshtastic_client:
             meshtastic_logger.info("Closing Meshtastic client...")
             try:
-                meshtastic_utils.meshtastic_client.close()
+                # Timeout wrapper to prevent infinite hanging during shutdown
+                # The meshtastic library can sometimes hang indefinitely during close()
+                # operations, especially with BLE connections. This timeout ensures
+                # the application can shut down gracefully within 10 seconds.
+
+                def _close_meshtastic():
+                    """
+                    Closes the Meshtastic client connection synchronously.
+                    """
+                    meshtastic_utils.meshtastic_client.close()
+
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                    future = executor.submit(_close_meshtastic)
+                    future.result(timeout=10.0)  # 10-second timeout
+
+                meshtastic_logger.info("Meshtastic client closed successfully")
+            except concurrent.futures.TimeoutError:
+                meshtastic_logger.warning(
+                    "Meshtastic client close timed out - forcing shutdown"
+                )
             except Exception as e:
-                meshtastic_logger.warning(f"Error closing Meshtastic client: {e}")
+                meshtastic_logger.error(
+                    f"Unexpected error during Meshtastic client close: {e}",
+                    exc_info=True,
+                )
 
         # Attempt to wipe message_map on shutdown if enabled
         if wipe_on_restart:
@@ -264,6 +281,9 @@ def run_main(args):
     set_config(db_utils, config)
     set_config(base_plugin, config)
 
+    # Configure component debug logging now that config is available
+    log_utils.configure_component_debug_logging()
+
     # Get config path and log file path for logging
     from mmrelay.config import config_path
     from mmrelay.log_utils import log_file_path

mmrelay/meshtastic_utils.py

@@ -47,7 +47,7 @@ reconnecting = False
 shutting_down = False
 reconnect_task = None  # To keep track of the reconnect task
 
-# Track pubsub subscription state to prevent duplicate subscriptions during reconnections
+# Subscription flags to prevent duplicate subscriptions
 subscribed_to_messages = False
 subscribed_to_connection_lost = False
 
@@ -57,7 +57,7 @@ def is_running_as_service():
     Determine if the application is running as a systemd service.
 
     Returns:
-        bool: True if running under systemd (either via environment variable or parent process), False otherwise.
+        bool: True if running under systemd (as indicated by the INVOCATION_ID environment variable or parent process), False otherwise.
     """
     # Check for INVOCATION_ID environment variable (set by systemd)
     if os.environ.get("INVOCATION_ID"):
@@ -88,16 +88,16 @@ 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 the configured connection type (serial, BLE, or TCP).
+    Establishes and manages 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. Handles reconnection logic, including closing any existing connection if `force_connect` is True. Retries connection attempts with exponential backoff until successful or shutdown is initiated. Subscribes to message and connection lost events only once per process to avoid duplicate 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.
 
     Parameters:
-        passed_config (dict, optional): Configuration dictionary to use for the connection. If provided, updates the global configuration.
+        passed_config (dict, optional): Configuration dictionary to use for the connection.
         force_connect (bool, optional): If True, forces a new connection even if one already exists.
 
     Returns:
-        Meshtastic interface client if the connection is successful, or None if the connection fails or shutdown is in progress.
+        meshtastic_client: The connected Meshtastic client instance, or None if connection fails or shutdown is in progress.
     """
     global meshtastic_client, shutting_down, config, matrix_rooms
     if shutting_down:
@@ -202,7 +202,7 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     f"Connected to {nodeInfo['user']['shortName']} / {nodeInfo['user']['hwModel']}"
                 )
 
-                # Subscribe to message and connection lost events (only if not already subscribed)
+                # Subscribe to message and connection lost events (only once per application run)
                 global subscribed_to_messages, subscribed_to_connection_lost
                 if not subscribed_to_messages:
                     pub.subscribe(on_meshtastic_message, "meshtastic.receive")
@@ -241,10 +241,13 @@ def connect_meshtastic(passed_config=None, force_connect=False):
     return meshtastic_client
 
 
-def on_lost_meshtastic_connection(interface=None):
+def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
     """
-    Callback invoked when the Meshtastic connection is lost.
-    Initiates a reconnect sequence unless shutting_down is True.
+    Handles loss of Meshtastic connection by initiating a reconnection sequence unless the system is shutting down or already reconnecting.
+
+    Args:
+        interface: The Meshtastic interface (optional, for compatibility)
+        detection_source: Source that detected the connection loss (for debugging)
     """
     global meshtastic_client, reconnecting, shutting_down, event_loop, reconnect_task
     with meshtastic_lock:
@@ -257,7 +260,7 @@ def on_lost_meshtastic_connection(interface=None):
             )
             return
         reconnecting = True
-        logger.error("Lost connection. Reconnecting...")
+        logger.error(f"Lost connection ({detection_source}). Reconnecting...")
 
         if meshtastic_client:
             try:
@@ -278,8 +281,9 @@ def on_lost_meshtastic_connection(interface=None):
 
 async def reconnect():
     """
-    Asynchronously attempts to reconnect with exponential backoff.
-    Stops if shutting_down is set.
+    Asynchronously attempts to reconnect to the Meshtastic device using exponential backoff, stopping if a 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.
     """
     global meshtastic_client, reconnecting, shutting_down
     backoff_time = 10
@@ -336,9 +340,9 @@ 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 interaction settings.
+    Process incoming Meshtastic messages and relay them to Matrix rooms or plugins according to message type and configuration.
 
-    Handles reactions and replies by relaying them to Matrix if enabled in the interaction settings. 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. Filters out messages from unmapped channels or disabled detection sensors, and 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 or disabled detection sensors are ignored. Ensures sender information is retrieved or stored as needed.
     """
     global config, matrix_rooms
 
@@ -643,53 +647,80 @@ def on_meshtastic_message(packet, interface):
 
 async def check_connection():
     """
-    Periodically checks the Meshtastic connection by calling localNode.getMetadata().
-    This creates an admin message to verify the connection is alive for all interface types.
-    If it fails or doesn't return the firmware version, we assume the connection is lost
-    and attempt to reconnect.
+    Periodically checks the health of the Meshtastic connection and triggers reconnection if the connection is lost.
+
+    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)
     """
-    global meshtastic_client, shutting_down, config, reconnecting
+    global meshtastic_client, shutting_down, config
 
     # Check if config is available
     if config is None:
         logger.error("No configuration available. Cannot check connection.")
         return
 
-    # Get heartbeat interval from config, default to 180 seconds
-    heartbeat_interval = config["meshtastic"].get("heartbeat_interval", 180)
     connection_type = config["meshtastic"]["connection_type"]
 
-    logger.info(
-        f"Starting connection heartbeat monitor (interval: {heartbeat_interval}s)"
-    )
+    # Get health check configuration
+    health_config = config["meshtastic"].get("health_check", {})
+    health_check_enabled = health_config.get("enabled", True)
+    heartbeat_interval = health_config.get("heartbeat_interval", 60)
 
-    while not shutting_down:
-        if meshtastic_client and not reconnecting:
-            try:
-                logger.debug(
-                    f"Checking {connection_type} connection health using getMetadata()"
-                )
-                output_capture = io.StringIO()
-                with contextlib.redirect_stdout(
-                    output_capture
-                ), contextlib.redirect_stderr(output_capture):
-                    meshtastic_client.localNode.getMetadata()
+    # Support legacy heartbeat_interval configuration for backward compatibility
+    if "heartbeat_interval" in config["meshtastic"]:
+        heartbeat_interval = config["meshtastic"]["heartbeat_interval"]
 
-                console_output = output_capture.getvalue()
-                if "firmware_version" not in console_output:
-                    raise Exception("No firmware_version in getMetadata output.")
+    # Exit early if health checks are disabled
+    if not health_check_enabled:
+        logger.info("Connection health checks are disabled in configuration")
+        return
 
-                logger.debug(f"{connection_type.capitalize()} connection healthy")
+    ble_skip_logged = False
 
-            except Exception as e:
-                # Only trigger reconnection if we're not already reconnecting
-                if not reconnecting:
-                    logger.warning(
-                        f"{connection_type.capitalize()} connection health check failed: {e}"
+    while not shutting_down:
+        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 not ble_skip_logged:
+                    logger.info(
+                        "BLE connection uses real-time disconnection detection - health checks disabled"
                     )
-                    on_lost_meshtastic_connection(meshtastic_client)
-                else:
-                    logger.debug("Skipping reconnection trigger - already reconnecting")
+                    ble_skip_logged = True
+            else:
+                try:
+                    output_capture = io.StringIO()
+                    with contextlib.redirect_stdout(
+                        output_capture
+                    ), contextlib.redirect_stderr(output_capture):
+                        meshtastic_client.localNode.getMetadata()
+
+                    console_output = output_capture.getvalue()
+                    if "firmware_version" not in console_output:
+                        raise Exception("No firmware_version in getMetadata output.")
+
+                except Exception as e:
+                    # Only trigger reconnection if we're not already reconnecting
+                    if not reconnecting:
+                        logger.error(
+                            f"{connection_type.capitalize()} connection health check failed: {e}"
+                        )
+                        on_lost_meshtastic_connection(
+                            interface=meshtastic_client,
+                            detection_source=f"health check failed: {str(e)}",
+                        )
+                    else:
+                        logger.debug(
+                            "Skipping reconnection trigger - already reconnecting"
+                        )
         elif reconnecting:
             logger.debug("Skipping connection check - reconnection in progress")
         elif not meshtastic_client:
@@ -707,21 +738,20 @@ def sendTextReply(
     channelIndex: int = 0,
 ):
     """
-    Send a text message as a reply to a previous message.
+    Send a Meshtastic text message as a reply to a specific previous message.
 
-    This function creates a proper Meshtastic reply by setting the reply_id field
-    in the Data protobuf message, which the standard sendText() method doesn't support.
+    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.
 
-    Args:
-        interface: The Meshtastic interface to send through
-        text: The text message to send
-        reply_id: The ID of the message this is replying to
-        destinationId: Where to send the message (default: broadcast)
-        wantAck: Whether to request acknowledgment
-        channelIndex: Which channel to send on
+    Parameters:
+        interface: The Meshtastic interface to send through.
+        text (str): The message content to send.
+        reply_id (int): The ID of the message being replied to.
+        destinationId: The recipient address (defaults to broadcast).
+        wantAck (bool): Whether to request acknowledgment for the message.
+        channelIndex (int): The channel index to send the message on.
 
     Returns:
-        The sent packet with populated ID field
+        The sent MeshPacket with its ID field populated.
     """
     logger.debug(f"Sending text reply: '{text}' replying to message ID {reply_id}")
 

mmrelay/tools/sample-docker-compose.yaml

@@ -3,6 +3,7 @@ services:
     build: .
     container_name: meshtastic-matrix-relay
     restart: unless-stopped
+    user: "${UID:-1000}:${GID:-1000}"
 
     environment:
       - TZ=UTC
@@ -28,5 +29,11 @@ services:
     #   - /dev/ttyUSB0:/dev/ttyUSB0
     #   - /dev/ttyACM0:/dev/ttyACM0
 
-    # For BLE connections, uncomment this:
+    # For BLE connections, uncomment these:
     # privileged: true
+    # network_mode: host
+    # Additional volumes for BLE (add to existing volumes section above):
+    #   - /var/run/dbus:/var/run/dbus:ro
+    #   - /sys/bus/usb:/sys/bus/usb:ro
+    #   - /sys/class/bluetooth:/sys/class/bluetooth:ro
+    #   - /sys/devices:/sys/devices:ro

mmrelay/tools/sample_config.yaml

@@ -18,11 +18,17 @@ meshtastic:
   broadcast_enabled: true # Must be set to true to enable Matrix to Meshtastic messages
   detection_sensor: true # Must be set to true to forward messages of Meshtastic's detection sensor module
   plugin_response_delay: 3 # Default response delay in seconds for plugins that respond on the mesh;
-  # heartbeat_interval: 180 # Interval in seconds to check connection health using getMetadata() (default: 180)
   message_interactions: # Configure reactions and replies (both require message storage in database)
     reactions: false # Enable reaction relaying between platforms
     replies: false   # Enable reply relaying between platforms
 
+  # Connection health monitoring configuration
+  #health_check:
+  #  enabled: true                    # Enable/disable periodic health checks (default: true)
+  #  heartbeat_interval: 60           # Interval in seconds between health checks (default: 60)
+  #                                   # Note: BLE connections use real-time disconnection detection and skip periodic checks
+  #                                   # Legacy: heartbeat_interval at meshtastic level still supported but deprecated
+
 logging:
   level: info
   #log_to_file: true                          # Set to true to enable file logging
@@ -31,6 +37,12 @@ logging:
   #backup_count: 1                            # Keeps 1 backup as the default if omitted
   #color_enabled: true                        # Set to false to disable colored console output
 
+  # Component-specific debug logging (useful for troubleshooting)
+  #debug:
+  #  matrix_nio: false                         # Enable matrix-nio debug logging for Matrix client issues
+  #  bleak: false                              # Enable BLE (bleak) debug logging for Bluetooth connection issues
+  #  meshtastic: false                         # Enable meshtastic library debug logging for device communication issues
+
 #database:
 #  path: ~/.mmrelay/data/meshtastic.sqlite   # Default location
 #  msg_map: # The message map is necessary for the relay_reactions functionality. If `relay_reactions` is set to false, nothing will be saved to the message map.

{mmrelay-1.1.0.dist-info → mmrelay-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.1.0
+Version: 1.1.2
 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
@@ -56,6 +56,7 @@ A powerful and easy-to-use relay between Meshtastic devices and Matrix chat room
 - Supports mapping multiple rooms and channels 1:1
 - Relays messages to/from an MQTT broker, if configured in the Meshtastic firmware
 - ✨️ _Bidirectional replies and reactions support_ ✨️ **NEW!!**
+- ✨️ _Native Docker support_ ✨️ **NEW!!**
 
 _We would love to support [Matrix E2EE rooms](https://github.com/geoffwhittington/meshtastic-matrix-relay/issues/33), but this is currently not implemented._
 
@@ -98,7 +99,7 @@ make logs    # View logs
 
 Docker provides isolated environment, easy deployment, automatic restarts, and volume persistence.
 
-For detailed Docker setup instructions, see the [Docker Guide](DOCKER.md).
+For detailed Docker setup instructions, see the [Docker Guide](docs/DOCKER.md).
 
 > **Note**: Docker builds currently use a temporary fork of the meshtastic library with BLE hanging fixes. PyPI releases use the upstream library. This will be resolved when the fixes are merged upstream.
 
@@ -172,5 +173,5 @@ See our Wiki page [Getting Started With Matrix & MM Relay](https://github.com/ge
 Join us!
 
 - Our project's room: [#mmrelay:matrix.org](https://matrix.to/#/#mmrelay:matrix.org)
-- Part of the Meshtastic Community Matrix space: [#meshnetclub:matrix.org](https://matrix.to/#/#meshnetclub:matrix.org)
+- Part of the Meshnet Club Matrix space: [#meshnetclub:matrix.org](https://matrix.to/#/#meshnetclub:matrix.org)
 - Public Relay Room: [#mmrelay-relay-room:matrix.org](https://matrix.to/#/#mmrelay-relay-room:matrix.org) - Where we bridge multiple meshnets. Feel free to join us, with or without a relay!

{mmrelay-1.1.0.dist-info → mmrelay-1.1.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
-mmrelay/__init__.py,sha256=wo5bAmayppAqLHI02pEu7w2K2_YUxHWbnanigSNlXa8,594
+mmrelay/__init__.py,sha256=ofK1VtDZwWBsSvfj0gcmsvkTTVHq_Go5MpGdU5NxdHM,594
 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=eTMMkYVWsmO_DkrBfnZMw4ohg_xa0S9TXJoBjRFTwzo,13590
-mmrelay/log_utils.py,sha256=ot0GpYppyNuPOWY8d3EXdLPojoJYEqfmUjVlcYm8neY,7532
-mmrelay/main.py,sha256=TL5xWFXIGwAQKau-hN4sRB0wxtNWzc629ry_qPbovv0,11585
+mmrelay/log_utils.py,sha256=1zVHBJ5qSOG1O4cq4Ebngq9dp81vaZOEq5khulAFuuM,6611
+mmrelay/main.py,sha256=-usvB02bl4ubwQ4obUzncV-5pKTRaplfOvvKcVNWBK8,12493
 mmrelay/matrix_utils.py,sha256=XSOHztRrdIjFGyYt8QhGBL6nMv_6iodeYL288pG9voA,45813
-mmrelay/meshtastic_utils.py,sha256=WdRiqbmCtUJrd45VZdJvfbrXct6rD09rtusi9nHMzc4,29163
+mmrelay/meshtastic_utils.py,sha256=9H5kt7X5KXx8FvnWm4fU-CVoFq35JjE-YQC2j98Miq0,31012
 mmrelay/plugin_loader.py,sha256=NRiXF6Ty1WD9jNXXKvzJh7kE0ba5oICXNVAfMaTPqH4,39247
 mmrelay/setup_utils.py,sha256=N6qdScHKHEMFKDmT1l7dcLDPNTusZXPkyxrLXjFLhRI,19910
 mmrelay/plugins/__init__.py,sha256=KVMQIXRhe0wlGj4O3IZ0vOIQRKFkfPYejHXhJL17qrc,51
@@ -23,12 +23,12 @@ mmrelay/plugins/telemetry_plugin.py,sha256=8SxWv4BLXMUTbiVaD3MjlMMdQyS7S_1OfLlVN
 mmrelay/plugins/weather_plugin.py,sha256=1bQhmiX-enNphzGoFVprU0LcZQX9BvGxWAJAG8Wekg0,8596
 mmrelay/tools/__init__.py,sha256=WFjDQjdevgg19_zT6iEoL29rvb1JPqYSd8708Jn5D7A,838
 mmrelay/tools/mmrelay.service,sha256=3vqK1VbfXvVftkTrTEOan77aTHeOT36hIAL7HqJsmTg,567
-mmrelay/tools/sample-docker-compose.yaml,sha256=eXi-7TGb4fjC4g0Q-qs55pBZ4UWNKAstSO1ozOXlrUI,939
+mmrelay/tools/sample-docker-compose.yaml,sha256=vVgJrh-6l48hkj5F-52JA5tpDWPBjiPQ36CE9Pkqn44,1251
 mmrelay/tools/sample.env,sha256=RP-o3rX3jnEIrVG2rqCZq31O1yRXou4HcGrXWLVbKKw,311
-mmrelay/tools/sample_config.yaml,sha256=0BKND0qbke8z9X9J9iHleu567dZt3RmHUxhZlQEEdFk,3290
-mmrelay-1.1.0.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
-mmrelay-1.1.0.dist-info/METADATA,sha256=IstoM9NyCmerUqL9QOEygC2BfAoxrHJLfXWY-J7kEd0,6658
-mmrelay-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mmrelay-1.1.0.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.1.0.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.1.0.dist-info/RECORD,,
+mmrelay/tools/sample_config.yaml,sha256=57LkzZUuCFNmfLzeBn9Vs1rtZ_DLdwjWLjiH3-bN6GY,4094
+mmrelay-1.1.2.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
+mmrelay-1.1.2.dist-info/METADATA,sha256=OeWp6ooATRMHmJuFjpdYHtKLZioC03-GYU2ci5WnFOg,6705
+mmrelay-1.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mmrelay-1.1.2.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.1.2.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.1.2.dist-info/RECORD,,