mmrelay 1.2.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

mmrelay/plugins/mesh_relay_plugin.py

@@ -87,20 +87,19 @@ class Plugin(BasePlugin):
     async def handle_meshtastic_message(
         self, packet, formatted_message, longname, meshnet_name
     ):
-        """Handle incoming meshtastic message and relay to Matrix.
+        """
+        Relay a Meshtastic packet to a configured Matrix room.
 
-        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
+        Normalizes and prepares the incoming Meshtastic packet, determines its channel (defaults to 0 if absent), and, if that channel is mapped in plugin configuration, sends the processed packet to the mapped Matrix room. The sent Matrix event includes a JSON-serialized `meshtastic_packet` in the content and sets `mmrelay_suppress` to True to mark it as a bridged packet. If the packet's channel is not mapped, the function returns without sending anything.
 
-        Returns:
-            bool: Always returns False to allow other plugins to process the same packet
+        Parameters:
+            packet: Raw Meshtastic packet (dict, JSON string, or other) to be normalized and relayed.
+            formatted_message (str): Human-readable message extracted from the packet (not used for routing).
+            longname (str): Long name of the sending node (informational).
+            meshnet_name (str): Name of the mesh network (informational).
 
-        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.
+        Returns:
+            None
         """
         from mmrelay.matrix_utils import connect_matrix
 
@@ -123,7 +122,7 @@ class Plugin(BasePlugin):
 
         if not channel_mapped:
             self.logger.debug(f"Skipping message from unmapped channel {channel}")
-            return
+            return None
 
         await matrix_client.room_send(
             room_id=room["id"],
@@ -136,19 +135,20 @@ class Plugin(BasePlugin):
             },
         )
 
-        return False
+        return None
 
     def matches(self, event):
-        """Check if Matrix event is a relayed radio packet.
-
-        Args:
-            event: Matrix room event object
-
+        """
+        Return True if the Matrix event's content body exactly matches the relayed-packet marker.
+        
+        Checks event.source["content"]["body"] (when a string) against the anchored pattern
+        "Processed <anything> radio packet" and returns True on match, otherwise False.
+        
+        Parameters:
+            event: Matrix event object with a .source mapping expected to contain a "content" dict.
+        
         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".
+            bool: True if the body matches the relayed-packet pattern, False otherwise.
         """
         # Check for the presence of necessary keys in the event
         content = event.source.get("content", {})
@@ -160,23 +160,28 @@ 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.
+        """
+        Relay an embedded Meshtastic packet from a Matrix room message to the 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
+        If the Matrix event contains an embedded meshtastic packet (detected via self.matches),
+        this function looks up the Meshtastic channel mapped to the Matrix room, parses the
+        embedded JSON packet from the event content, reconstructs a MeshPacket (decoding the
+        base64-encoded payload), and sends it on the radio via the Meshtastic client.
+
+        Parameters:
+            room: Matrix room object where the message was received (used to find room→channel mapping).
+            event: Matrix event containing the message; the embedded packet is read from event.source["content"].
+            full_message: Unused — matching and extraction are performed against `event`.
 
         Returns:
-            bool: True if packet relaying succeeded, False otherwise
+            None
 
-        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.
+        Side effects:
+            Sends a packet onto the Meshtastic radio network when a valid embedded packet and room→channel mapping exist.
         """
         # Use the event for matching instead of full_message
         if not self.matches(event):
-            return False
+            return None
 
         channel = None
         if config is not None:
@@ -185,20 +190,20 @@ class Plugin(BasePlugin):
                 if room_config["id"] == room.room_id:
                     channel = room_config["meshtastic_channel"]
 
-        if not channel:
+        if channel is None:
             self.logger.debug(f"Skipping message from unmapped channel {channel}")
-            return False
+            return None
 
         packet_json = event.source["content"].get("meshtastic_packet")
         if not packet_json:
             self.logger.debug("Missing embedded packet")
-            return False
+            return None
 
         try:
             packet = json.loads(packet_json)
         except (json.JSONDecodeError, TypeError) as e:
-            self.logger.error(f"Error processing embedded packet: {e}")
-            return
+            self.logger.exception(f"Error processing embedded packet: {e}")
+            return None
 
         from mmrelay.meshtastic_utils import connect_meshtastic
 
@@ -215,4 +220,4 @@ class Plugin(BasePlugin):
         meshtastic_client._sendPacket(
             meshPacket=meshPacket, destinationId=packet["toId"]
         )
-        return True
+        return None

mmrelay/plugins/weather_plugin.py

@@ -22,23 +22,22 @@ class Plugin(BasePlugin):
         """
         Generate a concise one-line weather forecast for the given GPS coordinates.
 
-        Builds and queries the Open-Meteo API for current conditions and hour-aligned forecasts ~+2h and ~+5h, formats temperatures according to the plugin configuration (`self.config["units"]`, default "metric"), and returns a single-line summary including current conditions and the two forecast points.
+        Queries the Open-Meteo API for current conditions and hour-aligned forecasts at approximately +2h and +5h, formats temperatures according to self.config.get("units", "metric") ("metric" -> °C, "imperial" -> °F), and returns a single-line summary like:
+        "Now: ☀️ Clear sky - 12.3°C | +2h: 🌧️ Light rain - 13.1°C 20% | +5h: ⛅️ Partly cloudy - 10.8°C 5%".
 
         Parameters:
             latitude (float): Latitude in decimal degrees.
             longitude (float): Longitude in decimal degrees.
 
         Returns:
-            str: A single-line forecast such as
-                 "Now: ☀️ Clear sky - 12.3°C | +2h: 🌧️ Light rain - 13.1°C 20% | +5h: ⛅️ Partly cloudy - 10.8°C 5%".
-                 On recoverable failures returns a short error message: "Weather data temporarily unavailable.",
-                 "Error fetching weather data.", or "Error parsing weather data.".
+            str: A one-line forecast string on success. On recoverable failures returns one of:
+                 - "Weather data temporarily unavailable." (missing hourly data),
+                 - "Error fetching weather data." (network/HTTP/request errors),
+                 - "Error parsing weather data." (malformed or unexpected API response).
 
         Notes:
-            - Temperature units are determined by `self.config.get("units", "metric")` ("metric" -> °C, "imperial" -> °F).
-            - The function attempts to anchor forecasts to hourly timestamps when available; if timestamps cannot be matched it falls back to hour-of-day indexing (may be less accurate).
-            - Network/HTTP errors and request-related exceptions are handled and result in the "Error fetching weather data." message.
-            - Malformed or incomplete API responses result in "Error parsing weather data." Unexpected exceptions are re-raised.
+            - The function attempts to anchor forecasts to hourly timestamps when available; if a timestamp match cannot be found it falls back to hour-of-day indexing.
+            - Network/request-related errors and parsing errors are handled as described above; unexpected exceptions are re-raised.
         """
         units = self.config.get("units", "metric")  # Default to metric
         temperature_unit = "°C" if units == "metric" else "°F"
@@ -198,20 +197,20 @@ class Plugin(BasePlugin):
                 if hasattr(requests, "RequestException") and isinstance(
                     e, requests.RequestException
                 ):
-                    self.logger.error(f"Error fetching weather data: {e}")
+                    self.logger.exception("Error fetching weather data")
                     return "Error fetching weather data."
             except (AttributeError, TypeError):
                 # Fallback to string-based detection if isinstance fails
                 exception_module = getattr(type(e), "__module__", "")
                 if "requests" in exception_module:
-                    self.logger.error(f"Error fetching weather data: {e}")
+                    self.logger.exception("Error fetching weather data")
                     return "Error fetching weather data."
 
             # Handle data parsing errors
             if isinstance(
                 e, (KeyError, IndexError, TypeError, ValueError, AttributeError)
             ):
-                self.logger.error(f"Malformed weather data: {e}")
+                self.logger.exception("Malformed weather data")
                 return "Error parsing weather data."
             else:
                 # Re-raise unexpected exceptions

mmrelay/runtime_utils.py

@@ -0,0 +1,35 @@
+"""Runtime environment helpers for MMRelay."""
+
+from __future__ import annotations
+
+import os
+
+from mmrelay.constants.network import SYSTEMD_INIT_SYSTEM
+
+
+def is_running_as_service() -> bool:
+    """
+    Return True if the current process appears to be running as a systemd service.
+
+    Checks whether the INVOCATION_ID environment variable is set (systemd-provided) and, if not,
+    inspects /proc/self/status to find the parent PID and then /proc/<ppid>/comm to compare the
+    parent process name against the expected systemd init binary name. If any file access,
+    permission, or parsing errors occur, the function returns False.
+    Returns:
+        bool: True when running under a systemd service, otherwise False.
+    """
+
+    if os.environ.get("INVOCATION_ID"):
+        return True
+
+    try:
+        with open("/proc/self/status", encoding="utf-8") as status_file:
+            for line in status_file:
+                if line.startswith("PPid:"):
+                    ppid = int(line.split()[1])
+                    with open(f"/proc/{ppid}/comm", encoding="utf-8") as comm_file:
+                        return comm_file.read().strip() == SYSTEMD_INIT_SYSTEM
+    except (FileNotFoundError, PermissionError, ValueError):
+        pass
+
+    return False