mmrelay 1.0__py3-none-any.whl

mmrelay/plugins/health_plugin.py

@@ -0,0 +1,64 @@
+import statistics
+
+from mmrelay.plugins.base_plugin import BasePlugin
+
+
+class Plugin(BasePlugin):
+    plugin_name = "health"
+
+    @property
+    def description(self):
+        return "Show mesh health using avg battery, SNR, AirUtil"
+
+    def generate_response(self):
+        from mmrelay.meshtastic_utils import connect_meshtastic
+
+        meshtastic_client = connect_meshtastic()
+        battery_levels = []
+        air_util_tx = []
+        snr = []
+
+        for _node, info in meshtastic_client.nodes.items():
+            if "deviceMetrics" in info:
+                if "batteryLevel" in info["deviceMetrics"]:
+                    battery_levels.append(info["deviceMetrics"]["batteryLevel"])
+                if "airUtilTx" in info["deviceMetrics"]:
+                    air_util_tx.append(info["deviceMetrics"]["airUtilTx"])
+            if "snr" in info:
+                snr.append(info["snr"])
+        print(str(snr))
+        # filter out none type values from snr and air_util_tx just in case
+        air_util_tx = [value for value in air_util_tx if value is not None]
+        snr = [value for value in snr if value is not None]
+
+        low_battery = len([n for n in battery_levels if n <= 10])
+        radios = len(meshtastic_client.nodes)
+        avg_battery = statistics.mean(battery_levels) if battery_levels else 0
+        mdn_battery = statistics.median(battery_levels)
+        avg_air = statistics.mean(air_util_tx) if air_util_tx else 0
+        mdn_air = statistics.median(air_util_tx)
+        avg_snr = statistics.mean(snr) if snr else 0
+        mdn_snr = statistics.median(snr)
+
+        return f"""Nodes: {radios}
+Battery: {avg_battery:.1f}% / {mdn_battery:.1f}% (avg / median)
+Nodes with Low Battery (< 10): {low_battery}
+Air Util: {avg_air:.2f} / {mdn_air:.2f} (avg / median)
+SNR: {avg_snr:.2f} / {mdn_snr:.2f} (avg / median)
+"""
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        return False
+
+    async def handle_room_message(self, room, event, full_message):
+
+        if not self.matches(event):
+            return False
+
+        await self.send_matrix_message(
+            room.room_id, self.generate_response(), formatted=False
+        )
+
+        return True

mmrelay/plugins/help_plugin.py

@@ -0,0 +1,55 @@
+import re
+
+from mmrelay.plugin_loader import load_plugins
+from mmrelay.plugins.base_plugin import BasePlugin
+
+
+class Plugin(BasePlugin):
+    plugin_name = "help"
+
+    def __init__(self):
+        self.plugin_name = "help"
+        super().__init__()
+
+    @property
+    def description(self):
+        return "List supported relay commands"
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        return False
+
+    def get_matrix_commands(self):
+        return [self.plugin_name]
+
+    def get_mesh_commands(self):
+        return []
+
+    async def handle_room_message(self, room, event, full_message):
+        # Pass the event to matches()
+        if not self.matches(event):
+            return False
+
+        command = None
+
+        match = re.match(r"^.*: !help\s+(.+)$", full_message)
+        if match:
+            command = match.group(1)
+
+        plugins = load_plugins()
+
+        if command:
+            reply = f"No such command: {command}"
+
+            for plugin in plugins:
+                if command in plugin.get_matrix_commands():
+                    reply = f"`!{command}`: {plugin.description}"
+        else:
+            commands = []
+            for plugin in plugins:
+                commands.extend(plugin.get_matrix_commands())
+            reply = "Available commands: " + ", ".join(commands)
+
+        await self.send_matrix_message(room.room_id, reply)
+        return True

mmrelay/plugins/map_plugin.py

@@ -0,0 +1,323 @@
+import io
+import math
+import random
+import re
+
+import PIL.ImageDraw
+import s2sphere
+import staticmaps
+from nio import AsyncClient, UploadResponse
+from PIL import Image
+
+from mmrelay.plugins.base_plugin import BasePlugin
+
+
+def textsize(self: PIL.ImageDraw.ImageDraw, *args, **kwargs):
+    x, y, w, h = self.textbbox((0, 0), *args, **kwargs)
+    return w, h
+
+
+# Monkeypatch fix for https://github.com/flopp/py-staticmaps/issues/39
+PIL.ImageDraw.ImageDraw.textsize = textsize
+
+
+class TextLabel(staticmaps.Object):
+    def __init__(self, latlng: s2sphere.LatLng, text: str, fontSize: int = 12) -> None:
+        staticmaps.Object.__init__(self)
+        self._latlng = latlng
+        self._text = text
+        self._margin = 4
+        self._arrow = 16
+        self._font_size = fontSize
+
+    def latlng(self) -> s2sphere.LatLng:
+        return self._latlng
+
+    def bounds(self) -> s2sphere.LatLngRect:
+        return s2sphere.LatLngRect.from_point(self._latlng)
+
+    def extra_pixel_bounds(self) -> staticmaps.PixelBoundsT:
+        # Guess text extents.
+        tw = len(self._text) * self._font_size * 0.5
+        th = self._font_size * 1.2
+        w = max(self._arrow, tw + 2.0 * self._margin)
+        return (int(w / 2.0), int(th + 2.0 * self._margin + self._arrow), int(w / 2), 0)
+
+    def render_pillow(self, renderer: staticmaps.PillowRenderer) -> None:
+        x, y = renderer.transformer().ll2pixel(self.latlng())
+        x = x + renderer.offset_x()
+
+        # Updated to use textbbox instead of textsize
+        bbox = renderer.draw().textbbox((0, 0), self._text)
+        tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        w = max(self._arrow, tw + 2 * self._margin)
+        h = th + 2 * self._margin
+
+        path = [
+            (x, y),
+            (x + self._arrow / 2, y - self._arrow),
+            (x + w / 2, y - self._arrow),
+            (x + w / 2, y - self._arrow - h),
+            (x - w / 2, y - self._arrow - h),
+            (x - w / 2, y - self._arrow),
+            (x - self._arrow / 2, y - self._arrow),
+        ]
+
+        renderer.draw().polygon(path, fill=(255, 255, 255, 255))
+        renderer.draw().line(path, fill=(255, 0, 0, 255))
+        renderer.draw().text(
+            (x - tw / 2, y - self._arrow - h / 2 - th / 2),
+            self._text,
+            fill=(0, 0, 0, 255),
+        )
+
+    def render_cairo(self, renderer: staticmaps.CairoRenderer) -> None:
+        x, y = renderer.transformer().ll2pixel(self.latlng())
+
+        ctx = renderer.context()
+        ctx.select_font_face("Sans", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
+
+        ctx.set_font_size(self._font_size)
+        x_bearing, y_bearing, tw, th, _, _ = ctx.text_extents(self._text)
+
+        w = max(self._arrow, tw + 2 * self._margin)
+        h = th + 2 * self._margin
+
+        path = [
+            (x, y),
+            (x + self._arrow / 2, y - self._arrow),
+            (x + w / 2, y - self._arrow),
+            (x + w / 2, y - self._arrow - h),
+            (x - w / 2, y - self._arrow - h),
+            (x - w / 2, y - self._arrow),
+            (x - self._arrow / 2, y - self._arrow),
+        ]
+
+        ctx.set_source_rgb(1, 1, 1)
+        ctx.new_path()
+        for p in path:
+            ctx.line_to(*p)
+        ctx.close_path()
+        ctx.fill()
+
+        ctx.set_source_rgb(1, 0, 0)
+        ctx.set_line_width(1)
+        ctx.new_path()
+        for p in path:
+            ctx.line_to(*p)
+        ctx.close_path()
+        ctx.stroke()
+
+        ctx.set_source_rgb(0, 0, 0)
+        ctx.set_line_width(1)
+        ctx.move_to(
+            x - tw / 2 - x_bearing, y - self._arrow - h / 2 - y_bearing - th / 2
+        )
+        ctx.show_text(self._text)
+        ctx.stroke()
+
+    def render_svg(self, renderer: staticmaps.SvgRenderer) -> None:
+        x, y = renderer.transformer().ll2pixel(self.latlng())
+
+        # guess text extents
+        tw = len(self._text) * self._font_size * 0.5
+        th = self._font_size * 1.2
+
+        w = max(self._arrow, tw + 2 * self._margin)
+        h = th + 2 * self._margin
+
+        path = renderer.drawing().path(
+            fill="#ffffff",
+            stroke="#ff0000",
+            stroke_width=1,
+            opacity=1.0,
+        )
+        path.push(f"M {x} {y}")
+        path.push(f" l {self._arrow / 2} {-self._arrow}")
+        path.push(f" l {w / 2 - self._arrow / 2} 0")
+        path.push(f" l 0 {-h}")
+        path.push(f" l {-w} 0")
+        path.push(f" l 0 {h}")
+        path.push(f" l {w / 2 - self._arrow / 2} 0")
+        path.push("Z")
+        renderer.group().add(path)
+
+        renderer.group().add(
+            renderer.drawing().text(
+                self._text,
+                text_anchor="middle",
+                dominant_baseline="central",
+                insert=(x, y - self._arrow - h / 2),
+                font_family="sans-serif",
+                font_size=f"{self._font_size}px",
+                fill="#000000",
+            )
+        )
+
+
+def anonymize_location(lat, lon, radius=1000):
+    # Generate random offsets for latitude and longitude
+    lat_offset = random.uniform(-radius / 111320, radius / 111320)
+    lon_offset = random.uniform(
+        -radius / (111320 * math.cos(lat)), radius / (111320 * math.cos(lat))
+    )
+
+    # Apply the offsets to the location coordinates
+    new_lat = lat + lat_offset
+    new_lon = lon + lon_offset
+
+    return new_lat, new_lon
+
+
+def get_map(locations, zoom=None, image_size=None, anonymize=True, radius=10000):
+    """
+    Anonymize a location to 10km by default
+    """
+    context = staticmaps.Context()
+    context.set_tile_provider(staticmaps.tile_provider_OSM)
+    context.set_zoom(zoom)
+
+    for location in locations:
+        if anonymize:
+            new_location = anonymize_location(
+                lat=float(location["lat"]),
+                lon=float(location["lon"]),
+                radius=radius,
+            )
+            radio = staticmaps.create_latlng(new_location[0], new_location[1])
+        else:
+            radio = staticmaps.create_latlng(
+                float(location["lat"]), float(location["lon"])
+            )
+        context.add_object(TextLabel(radio, location["label"], fontSize=50))
+
+    # render non-anti-aliased png
+    if image_size:
+        return context.render_pillow(image_size[0], image_size[1])
+    else:
+        return context.render_pillow(1000, 1000)
+
+
+async def upload_image(client: AsyncClient, image: Image.Image) -> UploadResponse:
+    buffer = io.BytesIO()
+    image.save(buffer, format="PNG")
+    image_data = buffer.getvalue()
+
+    response, maybe_keys = await client.upload(
+        io.BytesIO(image_data),
+        content_type="image/png",
+        filename="location.png",
+        filesize=len(image_data),
+    )
+
+    return response
+
+
+async def send_room_image(
+    client: AsyncClient, room_id: str, upload_response: UploadResponse
+):
+    await client.room_send(
+        room_id=room_id,
+        message_type="m.room.message",
+        content={
+            "msgtype": "m.image",
+            "url": upload_response.content_uri,
+            "body": "image.png",
+        },
+    )
+
+
+async def send_image(client: AsyncClient, room_id: str, image: Image.Image):
+    response = await upload_image(client=client, image=image)
+    await send_room_image(client, room_id, upload_response=response)
+
+
+class Plugin(BasePlugin):
+    plugin_name = "map"
+
+    def __init__(self):
+        self.plugin_name = "map"
+        super().__init__()
+
+    @property
+    def description(self):
+        return (
+            "Map of mesh radio nodes. Supports `zoom` and `size` options to customize"
+        )
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        return False
+
+    def get_matrix_commands(self):
+        return [self.plugin_name]
+
+    def get_mesh_commands(self):
+        return []
+
+    async def handle_room_message(self, room, event, full_message):
+        # Pass the whole event to matches() for compatibility w/ updated base_plugin.py
+        if not self.matches(event):
+            return False
+
+        from mmrelay.matrix_utils import connect_matrix
+        from mmrelay.meshtastic_utils import connect_meshtastic
+
+        matrix_client = await connect_matrix()
+        meshtastic_client = connect_meshtastic()
+
+        pattern = r"^.*:(?: !map(?: zoom=(\d+))?(?: size=(\d+),(\d+))?)?$"
+        match = re.match(pattern, full_message)
+
+        # Indicate this message is not meant for this plugin
+        if not match:
+            return False
+
+        zoom = match.group(1)
+        image_size = match.group(2, 3)
+
+        try:
+            zoom = int(zoom)
+        except:
+            zoom = self.config["zoom"] if "zoom" in self.config else 8
+
+        if zoom < 0 or zoom > 30:
+            zoom = 8
+
+        try:
+            image_size = (int(image_size[0]), int(image_size[1]))
+        except:
+            image_size = (
+                self.config["image_width"] if "image_width" in self.config else 1000,
+                self.config["image_height"] if "image_height" in self.config else 1000,
+            )
+
+        if image_size[0] > 1000 or image_size[1] > 1000:
+            image_size = (1000, 1000)
+
+        locations = []
+        for _node, info in meshtastic_client.nodes.items():
+            if "position" in info and "latitude" in info["position"]:
+                locations.append(
+                    {
+                        "lat": info["position"]["latitude"],
+                        "lon": info["position"]["longitude"],
+                        "label": info["user"]["shortName"],
+                    }
+                )
+
+        anonymize = self.config["anonymize"] if "anonymize" in self.config else True
+        radius = self.config["radius"] if "radius" in self.config else 1000
+
+        pillow_image = get_map(
+            locations=locations,
+            zoom=zoom,
+            image_size=image_size,
+            anonymize=anonymize,
+            radius=radius,
+        )
+
+        await send_image(matrix_client, room.room_id, pillow_image)
+
+        return True

mmrelay/plugins/mesh_relay_plugin.py

@@ -0,0 +1,134 @@
+import base64
+import json
+import re
+
+from meshtastic import mesh_pb2
+
+from mmrelay.plugins.base_plugin import BasePlugin, config
+
+
+class Plugin(BasePlugin):
+    plugin_name = "mesh_relay"
+    max_data_rows_per_node = 50
+
+    def normalize(self, dict_obj):
+        """
+        Packets are either a dict, string dict or string
+        """
+        if not isinstance(dict_obj, dict):
+            try:
+                dict_obj = json.loads(dict_obj)
+            except (json.JSONDecodeError, TypeError):
+                dict_obj = {"decoded": {"text": dict_obj}}
+
+        return self.strip_raw(dict_obj)
+
+    def process(self, packet):
+        packet = self.normalize(packet)
+
+        if "decoded" in packet and "payload" in packet["decoded"]:
+            if isinstance(packet["decoded"]["payload"], bytes):
+                packet["decoded"]["payload"] = base64.b64encode(
+                    packet["decoded"]["payload"]
+                ).decode("utf-8")
+
+        return packet
+
+    def get_matrix_commands(self):
+        return []
+
+    def get_mesh_commands(self):
+        return []
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        from mmrelay.matrix_utils import connect_matrix
+
+        packet = self.process(packet)
+        matrix_client = await connect_matrix()
+
+        packet_type = packet["decoded"]["portnum"]
+        if "channel" in packet:
+            channel = packet["channel"]
+        else:
+            channel = 0
+
+        channel_mapped = False
+        if config is not None:
+            matrix_rooms = config.get("matrix_rooms", [])
+            for room in matrix_rooms:
+                if room["meshtastic_channel"] == channel:
+                    channel_mapped = True
+                    break
+
+        if not channel_mapped:
+            self.logger.debug(f"Skipping message from unmapped channel {channel}")
+            return
+
+        await matrix_client.room_send(
+            room_id=room["id"],
+            message_type="m.room.message",
+            content={
+                "msgtype": "m.text",
+                "mmrelay_suppress": True,
+                "meshtastic_packet": json.dumps(packet),
+                "body": f"Processed {packet_type} radio packet",
+            },
+        )
+
+        return False
+
+    def matches(self, event):
+        # Check for the presence of necessary keys in the event
+        content = event.source.get("content", {})
+        body = content.get("body", "")
+
+        if isinstance(body, str):
+            match = re.match(r"^Processed (.+) radio packet$", body)
+            return bool(match)
+        return False
+
+    async def handle_room_message(self, room, event, full_message):
+        # Use the event for matching instead of full_message
+        if not self.matches(event):
+            return False
+
+        channel = None
+        if config is not None:
+            matrix_rooms = config.get("matrix_rooms", [])
+            for room_config in matrix_rooms:
+                if room_config["id"] == room.room_id:
+                    channel = room_config["meshtastic_channel"]
+
+        if not channel:
+            self.logger.debug(f"Skipping message from unmapped channel {channel}")
+            return False
+
+        packet_json = event.source["content"].get("meshtastic_packet")
+        if not packet_json:
+            self.logger.debug("Missing embedded packet")
+            return False
+
+        try:
+            packet = json.loads(packet_json)
+        except (json.JSONDecodeError, TypeError) as e:
+            self.logger.error(f"Error processing embedded packet: {e}")
+            return
+
+        from mmrelay.meshtastic_utils import connect_meshtastic
+
+        meshtastic_client = connect_meshtastic()
+        meshPacket = mesh_pb2.MeshPacket()
+        meshPacket.channel = channel
+        meshPacket.decoded.payload = base64.b64decode(packet["decoded"]["payload"])
+        meshPacket.decoded.portnum = packet["decoded"]["portnum"]
+        meshPacket.decoded.want_response = False
+        meshPacket.id = meshtastic_client._generatePacketId()
+
+        self.logger.debug("Relaying packet to Radio")
+
+        meshtastic_client._sendPacket(
+            meshPacket=meshPacket, destinationId=packet["toId"]
+        )
+        return True

mmrelay/plugins/nodes_plugin.py

@@ -0,0 +1,92 @@
+from datetime import datetime
+
+from mmrelay.plugins.base_plugin import BasePlugin
+
+
+def get_relative_time(timestamp):
+    now = datetime.now()
+    dt = datetime.fromtimestamp(timestamp)
+
+    # Calculate the time difference between the current time and the given timestamp
+    delta = now - dt
+
+    # Extract the relevant components from the time difference
+    days = delta.days
+    seconds = delta.seconds
+
+    # Convert the time difference into a relative timeframe
+    if days > 7:
+        return dt.strftime(
+            "%b %d, %Y"
+        )  # Return the timestamp in a specific format if it's older than 7 days
+    elif days >= 1:
+        return f"{days} days ago"
+    elif seconds >= 3600:
+        hours = seconds // 3600
+        return f"{hours} hours ago"
+    elif seconds >= 60:
+        minutes = seconds // 60
+        return f"{minutes} minutes ago"
+    else:
+        return "Just now"
+
+
+class Plugin(BasePlugin):
+    plugin_name = "nodes"
+
+    @property
+    def description(self):
+        return """Show mesh radios and node data
+
+$shortname $longname / $devicemodel / $battery $voltage / $snr / $lastseen
+"""
+
+    def generate_response(self):
+        from mmrelay.meshtastic_utils import connect_meshtastic
+
+        meshtastic_client = connect_meshtastic()
+
+        response = f"Nodes: {len(meshtastic_client.nodes)}\n"
+
+        for _node, info in meshtastic_client.nodes.items():
+            snr = ""
+            if "snr" in info and info["snr"] is not None:
+                snr = f"{info['snr']} dB "
+
+            last_heard = None
+            if "lastHeard" in info and info["lastHeard"] is not None:
+                last_heard = get_relative_time(info["lastHeard"])
+
+            voltage = "?V"
+            battery = "?%"
+            if "deviceMetrics" in info:
+                if (
+                    "voltage" in info["deviceMetrics"]
+                    and info["deviceMetrics"]["voltage"] is not None
+                ):
+                    voltage = f"{info['deviceMetrics']['voltage']}V "
+                if (
+                    "batteryLevel" in info["deviceMetrics"]
+                    and info["deviceMetrics"]["batteryLevel"] is not None
+                ):
+                    battery = f"{info['deviceMetrics']['batteryLevel']}% "
+
+            response += f"{info['user']['shortName']} {info['user']['longName']} / {info['user']['hwModel']} / {battery} {voltage} / {snr} / {last_heard}\n"
+
+        return response
+
+    async def handle_meshtastic_message(
+        self, packet, formatted_message, longname, meshnet_name
+    ):
+        return False
+
+    async def handle_room_message(self, room, event, full_message):
+        # Pass the event to matches()
+        if not self.matches(event):
+            return False
+
+        await self.send_matrix_message(
+            room_id=room.room_id, message=self.generate_response(), formatted=False
+        )
+
+        return True