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

reticulum_telemetry_hub/api/storage_models.py

@@ -0,0 +1,118 @@
+"""SQLAlchemy models for the Reticulum Community Hub API storage."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from datetime import timezone
+
+from sqlalchemy import Boolean
+from sqlalchemy import Column
+from sqlalchemy import DateTime
+from sqlalchemy import Integer
+from sqlalchemy import JSON
+from sqlalchemy import String
+from sqlalchemy.orm import declarative_base
+
+
+Base = declarative_base()
+
+
+def _utcnow() -> datetime:
+    """Return the current UTC datetime with timezone information."""
+    return datetime.now(timezone.utc)
+
+
+class TopicRecord(Base):  # pylint: disable=too-few-public-methods
+    """SQLAlchemy record for topics."""
+
+    __tablename__ = "topics"
+
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=False)
+    path = Column(String, nullable=False)
+    description = Column(String, nullable=True)
+    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+
+
+class SubscriberRecord(Base):  # pylint: disable=too-few-public-methods
+    """SQLAlchemy record for subscribers."""
+
+    __tablename__ = "subscribers"
+
+    id = Column(String, primary_key=True)
+    destination = Column(String, nullable=False)
+    topic_id = Column(String, nullable=True)
+    reject_tests = Column(Integer, nullable=True)
+    metadata_json = Column("metadata", JSON, nullable=True)
+    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+
+
+class ClientRecord(Base):  # pylint: disable=too-few-public-methods
+    """SQLAlchemy record for clients."""
+
+    __tablename__ = "clients"
+
+    identity = Column(String, primary_key=True)
+    last_seen = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+    metadata_json = Column("metadata", JSON, nullable=True)
+
+
+class FileRecord(Base):  # pylint: disable=too-few-public-methods
+    """SQLAlchemy record for stored files."""
+
+    __tablename__ = "file_records"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False)
+    path = Column(String, nullable=False)
+    media_type = Column(String, nullable=True)
+    category = Column(String, nullable=False)
+    size = Column(Integer, nullable=False)
+    topic_id = Column(String, nullable=True)
+    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+    updated_at = Column(
+        DateTime(timezone=True), default=_utcnow, onupdate=_utcnow, nullable=False
+    )
+
+
+class ChatMessageRecord(Base):  # pylint: disable=too-few-public-methods
+    """SQLAlchemy record for persisted chat messages."""
+
+    __tablename__ = "chat_messages"
+
+    id = Column(String, primary_key=True)
+    direction = Column(String, nullable=False)
+    scope = Column(String, nullable=False)
+    state = Column(String, nullable=False)
+    content = Column(String, nullable=False)
+    source = Column(String, nullable=True)
+    destination = Column(String, nullable=True)
+    topic_id = Column(String, nullable=True)
+    attachments_json = Column("attachments", JSON, nullable=True)
+    created_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+    updated_at = Column(
+        DateTime(timezone=True), default=_utcnow, onupdate=_utcnow, nullable=False
+    )
+
+
+class IdentityStateRecord(Base):  # pylint: disable=too-few-public-methods
+    """SQLAlchemy record for identity moderation state."""
+
+    __tablename__ = "identity_states"
+
+    identity = Column(String, primary_key=True)
+    is_banned = Column(Boolean, nullable=False, default=False)
+    is_blackholed = Column(Boolean, nullable=False, default=False)
+    updated_at = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+
+
+class IdentityAnnounceRecord(Base):  # pylint: disable=too-few-public-methods
+    """SQLAlchemy record for Reticulum announce metadata."""
+
+    __tablename__ = "identity_announces"
+
+    destination_hash = Column(String, primary_key=True)
+    display_name = Column(String, nullable=True)
+    first_seen = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+    last_seen = Column(DateTime(timezone=True), default=_utcnow, nullable=False)
+    source_interface = Column(String, nullable=True)

reticulum_telemetry_hub/atak_cot/__init__.py

@@ -0,0 +1,49 @@
+"""ATAK COT support classes and datapack utilities."""
+
+from __future__ import annotations
+
+from reticulum_telemetry_hub.atak_cot.base import Contact
+from reticulum_telemetry_hub.atak_cot.base import Group
+from reticulum_telemetry_hub.atak_cot.base import Point
+from reticulum_telemetry_hub.atak_cot.base import Status
+from reticulum_telemetry_hub.atak_cot.base import Takv
+from reticulum_telemetry_hub.atak_cot.base import Track
+from reticulum_telemetry_hub.atak_cot.base import Uid
+from reticulum_telemetry_hub.atak_cot.chat import Chat
+from reticulum_telemetry_hub.atak_cot.chat import ChatGroup
+from reticulum_telemetry_hub.atak_cot.chat import ChatHierarchy
+from reticulum_telemetry_hub.atak_cot.chat import ChatHierarchyContact
+from reticulum_telemetry_hub.atak_cot.chat import ChatHierarchyGroup
+from reticulum_telemetry_hub.atak_cot.chat import Link
+from reticulum_telemetry_hub.atak_cot.chat import Marti
+from reticulum_telemetry_hub.atak_cot.chat import MartiDest
+from reticulum_telemetry_hub.atak_cot.chat import Remarks
+from reticulum_telemetry_hub.atak_cot.detail import Detail
+from reticulum_telemetry_hub.atak_cot.event import Event
+from reticulum_telemetry_hub.atak_cot.event import Packable
+from reticulum_telemetry_hub.atak_cot.event import pack_data
+from reticulum_telemetry_hub.atak_cot.event import unpack_data
+
+__all__ = [
+    "Contact",
+    "Group",
+    "Point",
+    "Track",
+    "Takv",
+    "Uid",
+    "Status",
+    "Chat",
+    "ChatGroup",
+    "ChatHierarchy",
+    "ChatHierarchyContact",
+    "ChatHierarchyGroup",
+    "Link",
+    "Marti",
+    "MartiDest",
+    "Remarks",
+    "Detail",
+    "Event",
+    "Packable",
+    "pack_data",
+    "unpack_data",
+]

reticulum_telemetry_hub/atak_cot/base.py

@@ -0,0 +1,277 @@
+"""Data classes representing ATAK Cursor-on-Target primitives."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import xml.etree.ElementTree as ET
+
+
+@dataclass
+class Point:
+    """A geographic point element."""
+
+    lat: float
+    lon: float
+    hae: float
+    ce: float
+    le: float
+
+    @classmethod
+    def from_xml(cls, elem):
+        """Create a :class:`Point` from an XML ``<point>`` element."""
+
+        return cls(
+            lat=float(elem.get("lat", 0)),
+            lon=float(elem.get("lon", 0)),
+            hae=float(elem.get("hae", 0)),
+            ce=float(elem.get("ce", 0)),
+            le=float(elem.get("le", 0)),
+        )
+
+    def to_element(self):
+        """Return an XML element representing this point."""
+
+        attrib = {
+            "lat": str(self.lat),
+            "lon": str(self.lon),
+            "hae": str(self.hae),
+            "ce": str(self.ce),
+            "le": str(self.le),
+        }
+        return ET.Element("point", attrib)
+
+    def to_dict(self) -> dict:
+        """Return a serialisable dictionary representation."""
+
+        return {
+            "lat": self.lat,
+            "lon": self.lon,
+            "hae": self.hae,
+            "ce": self.ce,
+            "le": self.le,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Point":
+        """Create a :class:`Point` from a dictionary."""
+
+        return cls(
+            lat=float(data.get("lat", 0)),
+            lon=float(data.get("lon", 0)),
+            hae=float(data.get("hae", 0)),
+            ce=float(data.get("ce", 0)),
+            le=float(data.get("le", 0)),
+        )
+
+
+@dataclass
+class Contact:
+    """Identifies the sender of the COT message."""
+
+    callsign: str
+    endpoint: str | None = None
+
+    @classmethod
+    def from_xml(cls, elem):
+        """Construct a :class:`Contact` from an XML ``<contact>`` element."""
+
+        return cls(callsign=elem.get("callsign", ""), endpoint=elem.get("endpoint"))
+
+    def to_element(self):
+        """Return an XML element for the contact."""
+
+        attrib = {"callsign": self.callsign}
+        if self.endpoint:
+            attrib["endpoint"] = self.endpoint
+        return ET.Element("contact", attrib)
+
+    def to_dict(self) -> dict:
+        """Return a serialisable representation."""
+
+        data = {"callsign": self.callsign}
+        if self.endpoint:
+            data["endpoint"] = self.endpoint
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Contact":
+        """Create a :class:`Contact` from a dictionary."""
+
+        return cls(callsign=data.get("callsign", ""), endpoint=data.get("endpoint"))
+
+
+@dataclass
+class Group:
+    """Specifies group affiliation for the sender."""
+
+    name: str
+    role: str
+
+    @classmethod
+    def from_xml(cls, elem):
+        """Create a :class:`Group` from an XML ``<__group>`` element."""
+
+        return cls(name=elem.get("name", ""), role=elem.get("role", ""))
+
+    def to_element(self):
+        """Return an XML element for the group affiliation."""
+
+        return ET.Element("__group", {"name": self.name, "role": self.role})
+
+    def to_dict(self) -> dict:
+        """Return a serialisable representation."""
+
+        return {"name": self.name, "role": self.role}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Group":
+        """Create a :class:`Group` from a dictionary."""
+
+        return cls(name=data.get("name", ""), role=data.get("role", ""))
+
+
+@dataclass
+class Track:
+    """Represents movement information such as speed and bearing."""
+
+    course: float
+    speed: float
+
+    @classmethod
+    def from_xml(cls, elem):
+        """Parse an XML ``<track>`` element into a :class:`Track`."""
+
+        return cls(
+            course=float(elem.get("course", 0)), speed=float(elem.get("speed", 0))
+        )
+
+    def to_element(self):
+        """Return an XML element for the movement details."""
+
+        return ET.Element("track", {"course": str(self.course), "speed": str(self.speed)})
+
+    def to_dict(self) -> dict:
+        """Return a serialisable representation."""
+
+        return {"course": self.course, "speed": self.speed}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Track":
+        """Create a :class:`Track` from a dictionary."""
+
+        return cls(
+            course=float(data.get("course", 0)), speed=float(data.get("speed", 0))
+        )
+
+
+@dataclass
+class Takv:
+    """Describes the TAK client version and platform information."""
+
+    version: str
+    platform: str
+    os: str
+    device: str
+
+    @classmethod
+    def from_xml(cls, elem):
+        """Create a :class:`Takv` from an XML ``<takv>`` element."""
+
+        return cls(
+            version=elem.get("version", ""),
+            platform=elem.get("platform", ""),
+            os=elem.get("os", ""),
+            device=elem.get("device", ""),
+        )
+
+    def to_element(self):
+        """Return an XML element representing this TAK client."""
+
+        return ET.Element(
+            "takv",
+            {
+                "version": self.version,
+                "platform": self.platform,
+                "os": self.os,
+                "device": self.device,
+            },
+        )
+
+    def to_dict(self) -> dict:
+        """Return a serialisable representation."""
+
+        return {
+            "version": self.version,
+            "platform": self.platform,
+            "os": self.os,
+            "device": self.device,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Takv":
+        """Create a :class:`Takv` from a dictionary."""
+
+        return cls(
+            version=data.get("version", ""),
+            platform=data.get("platform", ""),
+            os=data.get("os", ""),
+            device=data.get("device", ""),
+        )
+
+
+@dataclass
+class Uid:
+    """Nested UID used by ATAK to describe the Droid identifier."""
+
+    droid: str
+
+    @classmethod
+    def from_xml(cls, elem):
+        """Construct a :class:`Uid` from an XML ``<uid>`` element."""
+
+        return cls(droid=elem.get("Droid", ""))
+
+    def to_element(self):
+        """Return an XML element representing the UID."""
+
+        return ET.Element("uid", {"Droid": self.droid})
+
+    def to_dict(self) -> dict:
+        """Return a serialisable representation."""
+
+        return {"Droid": self.droid}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Uid":
+        """Create a :class:`Uid` from a dictionary."""
+
+        return cls(droid=data.get("Droid", ""))
+
+
+@dataclass
+class Status:
+    """Represents battery status information."""
+
+    battery: float
+
+    @classmethod
+    def from_xml(cls, elem):
+        """Construct a :class:`Status` from an XML ``<status>`` element."""
+
+        return cls(battery=float(elem.get("battery", 0)))
+
+    def to_element(self):
+        """Return an XML element representing status."""
+
+        return ET.Element("status", {"battery": str(self.battery)})
+
+    def to_dict(self) -> dict:
+        """Return a serialisable representation."""
+
+        return {"battery": self.battery}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Status":
+        """Create a :class:`Status` from a dictionary."""
+
+        return cls(battery=float(data.get("battery", 0)))