ReticulumTelemetryHub 0.1.0__py3-none-any.whl → 0.143.0__py3-none-any.whl

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/magnetic_field.py

@@ -0,0 +1,68 @@
+"""SQLAlchemy model for the Magnetic Field sensor."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sqlalchemy import Float, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .sensor import Sensor
+from .sensor_enum import SID_MAGNETIC_FIELD
+
+
+class MagneticField(Sensor):
+    __tablename__ = "MagneticField"
+
+    id: Mapped[int] = mapped_column(ForeignKey("Sensor.id"), primary_key=True)
+    x: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+    y: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+    z: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+
+    def __init__(
+        self,
+        stale_time: float | None = 1,
+        data: Any | None = None,
+        active: bool = False,
+        synthesized: bool = False,
+        last_update: float = 0,
+        last_read: float = 0,
+    ) -> None:
+        super().__init__(
+            stale_time=stale_time,
+            data=data,
+            active=active,
+            synthesized=synthesized,
+            last_update=last_update,
+            last_read=last_read,
+        )
+        self.sid = SID_MAGNETIC_FIELD
+
+    def pack(self):  # type: ignore[override]
+        if self.x is None and self.y is None and self.z is None:
+            return None
+        return [self.x, self.y, self.z]
+
+    def unpack(self, packed: Any):  # type: ignore[override]
+        if packed is None:
+            self.x = None
+            self.y = None
+            self.z = None
+            return None
+
+        try:
+            self.x = packed[0]
+            self.y = packed[1]
+            self.z = packed[2]
+        except (IndexError, TypeError):
+            self.x = None
+            self.y = None
+            self.z = None
+            return None
+
+        return {"x": self.x, "y": self.y, "z": self.z}
+
+    __mapper_args__ = {
+        "polymorphic_identity": SID_MAGNETIC_FIELD,
+        "with_polymorphic": "*",
+    }

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/physical_link.py

@@ -0,0 +1,53 @@
+"""SQLAlchemy model for the Physical Link sensor."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sqlalchemy import Float, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .sensor import Sensor
+from .sensor_enum import SID_PHYSICAL_LINK
+
+
+class PhysicalLink(Sensor):
+    __tablename__ = "PhysicalLink"
+
+    id: Mapped[int] = mapped_column(ForeignKey("Sensor.id"), primary_key=True)
+    rssi: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+    snr: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+    q: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+
+    def __init__(self) -> None:
+        super().__init__(stale_time=5)
+        self.sid = SID_PHYSICAL_LINK
+
+    def pack(self):  # type: ignore[override]
+        if self.rssi is None and self.snr is None and self.q is None:
+            return None
+        return [self.rssi, self.snr, self.q]
+
+    def unpack(self, packed: Any):  # type: ignore[override]
+        if packed is None:
+            self.rssi = None
+            self.snr = None
+            self.q = None
+            return None
+
+        try:
+            self.rssi = packed[0]
+            self.snr = packed[1]
+            self.q = packed[2]
+        except (IndexError, TypeError):
+            self.rssi = None
+            self.snr = None
+            self.q = None
+            return None
+
+        return {"rssi": self.rssi, "snr": self.snr, "q": self.q}
+
+    __mapper_args__ = {
+        "polymorphic_identity": SID_PHYSICAL_LINK,
+        "with_polymorphic": "*",
+    }

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/pressure.py

@@ -0,0 +1,37 @@
+"""SQLAlchemy model for the Pressure sensor."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sqlalchemy import Float, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .sensor import Sensor
+from .sensor_enum import SID_PRESSURE
+
+
+class Pressure(Sensor):
+    __tablename__ = "Pressure"
+
+    id: Mapped[int] = mapped_column(ForeignKey("Sensor.id"), primary_key=True)
+    mbar: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+
+    def __init__(self) -> None:
+        super().__init__(stale_time=5)
+        self.sid = SID_PRESSURE
+
+    def pack(self):  # type: ignore[override]
+        return self.mbar
+
+    def unpack(self, packed: Any):  # type: ignore[override]
+        if packed is None:
+            self.mbar = None
+            return None
+        self.mbar = packed
+        return {"mbar": self.mbar}
+
+    __mapper_args__ = {
+        "polymorphic_identity": SID_PRESSURE,
+        "with_polymorphic": "*",
+    }

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/proximity.py

@@ -0,0 +1,37 @@
+"""SQLAlchemy model for the Proximity sensor."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sqlalchemy import Boolean, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .sensor import Sensor
+from .sensor_enum import SID_PROXIMITY
+
+
+class Proximity(Sensor):
+    __tablename__ = "Proximity"
+
+    id: Mapped[int] = mapped_column(ForeignKey("Sensor.id"), primary_key=True)
+    triggered: Mapped[Optional[bool]] = mapped_column(Boolean, nullable=True)
+
+    def __init__(self) -> None:
+        super().__init__(stale_time=1)
+        self.sid = SID_PROXIMITY
+
+    def pack(self):  # type: ignore[override]
+        return self.triggered
+
+    def unpack(self, packed: Any):  # type: ignore[override]
+        if packed is None:
+            self.triggered = None
+            return None
+        self.triggered = packed
+        return {"triggered": self.triggered}
+
+    __mapper_args__ = {
+        "polymorphic_identity": SID_PROXIMITY,
+        "with_polymorphic": "*",
+    }

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/received.py

@@ -0,0 +1,75 @@
+"""SQLAlchemy model for the Received sensor."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sqlalchemy import Float, ForeignKey, LargeBinary
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .sensor import Sensor
+from .sensor_enum import SID_RECEIVED
+
+
+class Received(Sensor):
+    __tablename__ = "Received"
+
+    id: Mapped[int] = mapped_column(ForeignKey("Sensor.id"), primary_key=True)
+    by: Mapped[Optional[bytes]] = mapped_column(LargeBinary, nullable=True)
+    via: Mapped[Optional[bytes]] = mapped_column(LargeBinary, nullable=True)
+    geodesic_distance: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+    euclidian_distance: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+
+    def __init__(self) -> None:
+        super().__init__(stale_time=5)
+        self.sid = SID_RECEIVED
+
+    def pack(self):  # type: ignore[override]
+        if (
+            self.by is None
+            and self.via is None
+            and self.geodesic_distance is None
+            and self.euclidian_distance is None
+        ):
+            return None
+
+        return [
+            self.by,
+            self.via,
+            self.geodesic_distance,
+            self.euclidian_distance,
+        ]
+
+    def unpack(self, packed: Any):  # type: ignore[override]
+        if packed is None:
+            self.by = None
+            self.via = None
+            self.geodesic_distance = None
+            self.euclidian_distance = None
+            return None
+
+        try:
+            self.by = packed[0]
+            self.via = packed[1]
+            self.geodesic_distance = packed[2]
+            self.euclidian_distance = packed[3]
+        except (IndexError, TypeError):
+            self.by = None
+            self.via = None
+            self.geodesic_distance = None
+            self.euclidian_distance = None
+            return None
+
+        return {
+            "by": self.by,
+            "via": self.via,
+            "distance": {
+                "geodesic": self.geodesic_distance,
+                "euclidian": self.euclidian_distance,
+            },
+        }
+
+    __mapper_args__ = {
+        "polymorphic_identity": SID_RECEIVED,
+        "with_polymorphic": "*",
+    }

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/rns_transport.py

@@ -0,0 +1,209 @@
+"""SQLAlchemy model for Reticulum transport telemetry."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from msgpack import packb, unpackb
+from sqlalchemy import Boolean, Float, ForeignKey, Integer, LargeBinary
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .sensor import Sensor
+from .sensor_enum import SID_RNS_TRANSPORT
+
+
+def _encode_payload(payload: Any) -> bytes | None:
+    """Serialize ``payload`` with msgpack if it is not ``None``."""
+
+    if payload is None:
+        return None
+    return packb(payload, use_bin_type=True)
+
+
+def _decode_payload(blob: bytes | None) -> Any:
+    """Deserialize msgpack ``blob`` into Python objects."""
+
+    if blob is None:
+        return None
+    return unpackb(blob, strict_map_key=False)
+
+
+class RNSTransport(Sensor):
+    """Telemetry sensor describing the local Reticulum transport state."""
+
+    __tablename__ = "RNSTransport"
+
+    SID = SID_RNS_TRANSPORT
+
+    id: Mapped[int] = mapped_column(
+        ForeignKey("Sensor.id", ondelete="CASCADE"), primary_key=True
+    )
+    transport_enabled: Mapped[bool] = mapped_column(Boolean, default=False)
+    transport_identity: Mapped[bytes | None] = mapped_column(LargeBinary, nullable=True)
+    transport_uptime: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    traffic_rxb: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    traffic_txb: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    speed_rx: Mapped[float | None] = mapped_column(Float, nullable=True)
+    speed_tx: Mapped[float | None] = mapped_column(Float, nullable=True)
+    speed_rx_inst: Mapped[float | None] = mapped_column(Float, nullable=True)
+    speed_tx_inst: Mapped[float | None] = mapped_column(Float, nullable=True)
+    memory_used: Mapped[float | None] = mapped_column(Float, nullable=True)
+    interface_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    link_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+
+    interfaces_blob: Mapped[bytes | None] = mapped_column(LargeBinary, nullable=True)
+    path_table_blob: Mapped[bytes | None] = mapped_column(LargeBinary, nullable=True)
+    ifstats_blob: Mapped[bytes | None] = mapped_column(LargeBinary, nullable=True)
+    extra_blob: Mapped[bytes | None] = mapped_column(LargeBinary, nullable=True)
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        if "stale_time" not in kwargs:
+            kwargs["stale_time"] = 60
+        super().__init__(*args, **kwargs)
+        self.sid = self.SID
+
+    @property
+    def interfaces(self) -> Any:
+        """Return the decoded interface list or mapping."""
+
+        return _decode_payload(self.interfaces_blob)
+
+    @interfaces.setter
+    def interfaces(self, value: Any) -> None:
+        self.interfaces_blob = _encode_payload(value)
+
+    @property
+    def path_table(self) -> Any:
+        return _decode_payload(self.path_table_blob)
+
+    @path_table.setter
+    def path_table(self, value: Any) -> None:
+        self.path_table_blob = _encode_payload(value)
+
+    @property
+    def ifstats(self) -> Any:
+        return _decode_payload(self.ifstats_blob)
+
+    @ifstats.setter
+    def ifstats(self, value: Any) -> None:
+        self.ifstats_blob = _encode_payload(value)
+
+    @property
+    def extras(self) -> Any:
+        return _decode_payload(self.extra_blob)
+
+    @extras.setter
+    def extras(self, value: Any) -> None:
+        self.extra_blob = _encode_payload(value)
+
+    def _populate_counts(self, interfaces: Any) -> None:
+        if self.interface_count is not None or interfaces is None:
+            return
+        if hasattr(interfaces, "__len__"):
+            try:
+                self.interface_count = len(interfaces)  # type: ignore[arg-type]
+                return
+            except TypeError:
+                pass
+        try:
+            self.interface_count = sum(1 for _ in interfaces)  # type: ignore[arg-type]
+        except TypeError:
+            pass
+
+    def pack(self) -> dict[str, Any] | None:  # type: ignore[override]
+        extras = self.extras or {}
+        payload: dict[str, Any] = dict(extras)
+
+        interfaces = self.interfaces
+        path_table = self.path_table
+        ifstats = self.ifstats
+
+        if ifstats is not None and interfaces is not None:
+            if isinstance(ifstats, dict) and "interfaces" not in ifstats:
+                merged = dict(ifstats)
+                merged["interfaces"] = interfaces
+                ifstats = merged
+        elif interfaces is not None:
+            ifstats = {"interfaces": interfaces}
+
+        interface_count = self.interface_count
+        if interface_count is None and isinstance(interfaces, list):
+            interface_count = len(interfaces)
+
+        payload.update(
+            {
+                "transport_enabled": bool(self.transport_enabled),
+                "transport_identity": (
+                    bytes(self.transport_identity) if self.transport_identity else None
+                ),
+                "transport_uptime": self.transport_uptime,
+                "traffic_rxb": self.traffic_rxb,
+                "traffic_txb": self.traffic_txb,
+                "speed_rx": self.speed_rx,
+                "speed_tx": self.speed_tx,
+                "speed_rx_inst": self.speed_rx_inst,
+                "speed_tx_inst": self.speed_tx_inst,
+                "memory_used": self.memory_used,
+                "interface_count": interface_count,
+                "link_count": self.link_count,
+            }
+        )
+
+        if interfaces is not None:
+            payload["interfaces"] = interfaces
+        if path_table is not None:
+            payload["path_table"] = path_table
+        if ifstats is not None:
+            payload["ifstats"] = ifstats
+
+        return payload
+
+    def unpack(self, packed: Any) -> Any:  # type: ignore[override]
+        if packed is None or not isinstance(packed, dict):
+            return None
+
+        data = dict(packed)
+
+        interfaces = data.pop("interfaces", None)
+        ifstats = data.pop("ifstats", None)
+        path_table = data.pop("path_table", None)
+
+        if interfaces is None and isinstance(ifstats, dict):
+            maybe_interfaces = ifstats.get("interfaces")
+            if maybe_interfaces is not None:
+                interfaces = maybe_interfaces
+
+        self.interfaces = interfaces
+        self.ifstats = ifstats
+        self.path_table = path_table
+
+        self.transport_enabled = bool(
+            data.pop("transport_enabled", self.transport_enabled)
+        )
+        self.transport_identity = data.pop(
+            "transport_identity", self.transport_identity
+        )
+        self.transport_uptime = data.pop("transport_uptime", self.transport_uptime)
+        self.traffic_rxb = data.pop("traffic_rxb", self.traffic_rxb)
+        self.traffic_txb = data.pop("traffic_txb", self.traffic_txb)
+        self.speed_rx = data.pop("speed_rx", self.speed_rx)
+        self.speed_tx = data.pop("speed_tx", self.speed_tx)
+        self.speed_rx_inst = data.pop("speed_rx_inst", self.speed_rx_inst)
+        self.speed_tx_inst = data.pop("speed_tx_inst", self.speed_tx_inst)
+        self.memory_used = data.pop("memory_used", self.memory_used)
+        self.interface_count = data.pop("interface_count", self.interface_count)
+        self.link_count = data.pop("link_count", self.link_count)
+
+        self._populate_counts(interfaces)
+
+        self.extras = data if data else None
+
+        return packed
+
+    __mapper_args__ = {
+        "polymorphic_identity": SID_RNS_TRANSPORT,
+        "with_polymorphic": "*",
+    }
+
+
+__all__ = ["RNSTransport"]

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/sensor.py

@@ -0,0 +1,65 @@
+from sqlalchemy import Column, ForeignKey, Integer, Float, Boolean, BLOB
+from msgpack import packb, unpackb
+from sqlalchemy.orm import DeclarativeMeta, relationship, Mapped, mapped_column
+
+from .. import Base
+
+
+class SensorDeclarativeMeta(DeclarativeMeta):
+    """Custom declarative metaclass that fills in mapper defaults."""
+
+    def __init__(cls, classname, bases, dict_, **kwargs):
+        if classname != "Sensor":
+            mapper_args = dict_.get("__mapper_args__")
+            if mapper_args is None or "polymorphic_identity" not in mapper_args:
+                mapper_args = dict(mapper_args or {})
+                mapper_args.setdefault("with_polymorphic", "*")
+                mapper_args.setdefault("polymorphic_identity", classname)
+                cls.__mapper_args__ = mapper_args
+        super().__init__(classname, bases, dict_, **kwargs)
+
+
+class Sensor(Base, metaclass=SensorDeclarativeMeta):
+    __tablename__ = "Sensor"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    sid = Column(Integer, nullable=False, default=0x00)
+    stale_time = Column(Float, nullable=True)
+    data = Column(BLOB, nullable=True)
+    synthesized = Column(Boolean, default=False)
+    telemeter_id: Mapped[int] = mapped_column(ForeignKey("Telemeter.id"))
+    telemeter = relationship("Telemeter", back_populates="sensors")
+
+    def __init__(
+        self,
+        stale_time=None,
+        data=None,
+        active=False,
+        synthesized=False,
+        last_update=0,
+        last_read=0,
+    ):
+        self.stale_time = stale_time
+        self.data = data
+        self.active = active
+        self.synthesized = synthesized
+        self.last_update = last_update
+        self.last_read = last_read
+
+    def packb(self):
+        return packb(self.pack())
+
+    def unpackb(self, packed):
+        return unpackb(self.unpack(packed))
+
+    def pack(self):
+        return self.data
+
+    def unpack(self, packed):
+        return packed
+
+    __mapper_args__ = {
+        "polymorphic_identity": "Sensor",
+        "with_polymorphic": "*",
+        "polymorphic_on": sid,
+    }

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/sensor_enum.py

@@ -0,0 +1,27 @@
+SID_NONE = 0x00
+SID_TIME = 0x01
+SID_LOCATION = 0x02
+SID_PRESSURE = 0x03
+SID_BATTERY = 0x04
+SID_PHYSICAL_LINK = 0x05
+SID_ACCELERATION = 0x06
+SID_TEMPERATURE = 0x07
+SID_HUMIDITY = 0x08
+SID_MAGNETIC_FIELD = 0x09
+SID_AMBIENT_LIGHT = 0x0A
+SID_GRAVITY = 0x0B
+SID_ANGULAR_VELOCITY = 0x0C
+SID_PROXIMITY = 0x0E
+SID_INFORMATION = 0x0F
+SID_RECEIVED = 0x10
+SID_POWER_CONSUMPTION = 0x11
+SID_POWER_PRODUCTION = 0x12
+SID_PROCESSOR = 0x13
+SID_RAM = 0x14
+SID_NVM = 0x15
+SID_TANK = 0x16
+SID_FUEL = 0x17
+SID_LXMF_PROPAGATION = 0x18
+SID_RNS_TRANSPORT = 0x19
+SID_CONNECTION_MAP = 0x1A
+SID_CUSTOM = 0xFF

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/sensor_mapping.py

@@ -0,0 +1,58 @@
+from .sensor_enum import *
+from .acceleration import Acceleration
+from .ambient_light import AmbientLight
+from .angular_velocity import AngularVelocity
+from .battery import Battery
+from .gravity import Gravity
+from .humidity import Humidity
+from .information import Information
+from .location import Location
+from .magnetic_field import MagneticField
+from .physical_link import PhysicalLink
+from .pressure import Pressure
+from .proximity import Proximity
+from .received import Received
+from .temperature import Temperature
+from .time import Time
+from .connection_map import ConnectionMap
+from .generic import (
+    Custom,
+    Fuel,
+    NonVolatileMemory,
+    PowerConsumption,
+    PowerProduction,
+    Processor,
+    RandomAccessMemory,
+    Tank,
+)
+from .lxmf_propagation import LXMFPropagation
+from .rns_transport import RNSTransport
+
+sid_mapping = {
+    SID_TIME: Time,
+    SID_LOCATION: Location,
+    SID_PRESSURE: Pressure,
+    SID_BATTERY: Battery,
+    SID_PHYSICAL_LINK: PhysicalLink,
+    SID_ACCELERATION: Acceleration,
+    SID_TEMPERATURE: Temperature,
+    SID_HUMIDITY: Humidity,
+    SID_MAGNETIC_FIELD: MagneticField,
+    SID_AMBIENT_LIGHT: AmbientLight,
+    SID_GRAVITY: Gravity,
+    SID_ANGULAR_VELOCITY: AngularVelocity,
+    SID_PROXIMITY: Proximity,
+    SID_INFORMATION: Information,
+    SID_RECEIVED: Received,
+    SID_POWER_CONSUMPTION: PowerConsumption,
+    SID_POWER_PRODUCTION: PowerProduction,
+    SID_PROCESSOR: Processor,
+    SID_RAM: RandomAccessMemory,
+    SID_NVM: NonVolatileMemory,
+    SID_TANK: Tank,
+    SID_FUEL: Fuel,
+    SID_LXMF_PROPAGATION: LXMFPropagation,
+    SID_RNS_TRANSPORT: RNSTransport,
+    SID_CONNECTION_MAP: ConnectionMap,
+    SID_CUSTOM: Custom,
+}

reticulum_telemetry_hub/lxmf_telemetry/model/persistance/sensors/temperature.py

@@ -0,0 +1,37 @@
+"""SQLAlchemy model for the Temperature sensor."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from sqlalchemy import Float, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .sensor import Sensor
+from .sensor_enum import SID_TEMPERATURE
+
+
+class Temperature(Sensor):
+    __tablename__ = "Temperature"
+
+    id: Mapped[int] = mapped_column(ForeignKey("Sensor.id"), primary_key=True)
+    c: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+
+    def __init__(self) -> None:
+        super().__init__(stale_time=5)
+        self.sid = SID_TEMPERATURE
+
+    def pack(self):  # type: ignore[override]
+        return self.c
+
+    def unpack(self, packed: Any):  # type: ignore[override]
+        if packed is None:
+            self.c = None
+            return None
+        self.c = packed
+        return {"c": self.c}
+
+    __mapper_args__ = {
+        "polymorphic_identity": SID_TEMPERATURE,
+        "with_polymorphic": "*",
+    }