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

lxmf_telemetry/telemetry_controller.py

@@ -1,124 +0,0 @@
-from typing import Optional
-from datetime import datetime
-import LXMF
-import RNS
-from msgpack import packb, unpackb
-from lxmf_telemetry.model.persistance import Base
-from lxmf_telemetry.model.persistance.sensors.sensor import Sensor
-from lxmf_telemetry.model.persistance.telemeter import Telemeter
-
-from lxmf_telemetry.model.persistance.sensors.sensor_mapping import sid_mapping
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker, Session, joinedload
-
-_engine = create_engine("sqlite:///telemetry.db")
-Base.metadata.create_all(_engine)
-Session_cls = sessionmaker(bind=_engine)
-
-
-class TelemetryController:
-    """This class is responsible for managing the telemetry data."""
-
-    TELEMETRY_REQUEST = 1
-
-    def __init__(self) -> None:
-        pass
-
-    def get_telemetry(
-        self, start_time: Optional[datetime] = None, end_time: Optional[datetime] = None
-    ) -> list[Telemeter]:
-        """Get the telemetry data."""
-        with Session_cls() as ses:
-            query = ses.query(Telemeter)
-            if start_time:
-                query = query.filter(Telemeter.time >= start_time)
-            if end_time:
-                query = query.filter(Telemeter.time <= end_time)
-            tels = query.options(joinedload(Telemeter.sensors)).all()
-            return tels
-
-    def save_telemetry(self, telemetry_data: dict, peer_dest) -> None:
-        """Save the telemetry data."""
-        tel = self._deserialize_telemeter(telemetry_data, peer_dest)
-        with Session_cls() as ses:
-            ses.add(tel)
-            ses.commit()
-
-    def handle_message(self, message: LXMF.LXMessage) -> bool:
-        """Handle the incoming message."""
-        handled = False
-        if LXMF.FIELD_TELEMETRY in message.fields:
-            tel_data: dict = unpackb(
-                message.fields[LXMF.FIELD_TELEMETRY], strict_map_key=False
-            )
-            RNS.log(f"Telemetry data: {tel_data}")
-            self.save_telemetry(tel_data, RNS.hexrep(message.source_hash, False))
-            handled = True
-        if LXMF.FIELD_TELEMETRY_STREAM in message.fields:
-            tels_data = unpackb(
-                message.fields[LXMF.FIELD_TELEMETRY_STREAM], strict_map_key=False
-            )
-            for tel_data in tels_data:
-                self.save_telemetry(tel_data, RNS.hexrep(tel_data.pop(0)))
-            handled = True
-
-        return handled
-
-    def handle_command(self, command: dict, message: LXMF.LXMessage, my_lxm_dest) -> Optional[LXMF.LXMessage]:
-        """Handle the incoming command."""
-        if TelemetryController.TELEMETRY_REQUEST in command:
-            timebase = command[TelemetryController.TELEMETRY_REQUEST]
-            tels = self.get_telemetry(start_time=datetime.fromtimestamp(timebase))
-            packed_tels = []
-            dest = RNS.Destination(
-                message.source.identity,
-                RNS.Destination.OUT,
-                RNS.Destination.SINGLE,
-                "lxmf",
-                "delivery",
-            )
-            message = LXMF.LXMessage(
-                    dest,
-                    my_lxm_dest,
-                    "Telemetry data",
-                    desired_method=LXMF.LXMessage.DIRECT,
-                )
-            for tel in tels:
-                tel_data = self._serialize_telemeter(tel)
-                packed_tels.append(
-                    [
-                        bytes.fromhex(tel.peer_dest),
-                        round(tel.time.timestamp()),
-                        packb(tel_data),
-                        ['account', b'\x00\x00\x00', b'\xff\xff\xff'],
-                    ]
-                )
-            message.fields[LXMF.FIELD_TELEMETRY_STREAM] = packed_tels
-            print("+--- Sending telemetry data---------------------------------")
-            print(f"| Telemetry data: {packed_tels}")
-            print(f"| Message: {message}")
-            print("+------------------------------------------------------------")
-            return message
-        else:
-            return None
-
-    def _serialize_telemeter(self, telemeter: Telemeter) -> dict:
-        """Serialize the telemeter data."""
-        telemeter_data = {}
-        for sensor in telemeter.sensors:
-            sensor_data = sensor.pack()
-            telemeter_data[sensor.sid] = sensor_data
-        return telemeter_data
-
-    def _deserialize_telemeter(self, tel_data: dict, peer_dest: str) -> Telemeter:
-        """Deserialize the telemeter data."""
-        tel = Telemeter(peer_dest)
-        for sid in tel_data:
-            if sid in sid_mapping:
-                if tel_data[sid] is None:
-                    RNS.log(f"Sensor data for {sid} is None")
-                    continue
-                sensor = sid_mapping[sid]()
-                sensor.unpack(tel_data[sid])
-                tel.sensors.append(sensor)
-        return tel

reticulum_server/main.py

@@ -1,182 +0,0 @@
-import os
-import time
-import LXMF
-import RNS
-from lxmf_telemetry.telemetry_controller import TelemetryController
-
-# Constants
-STORAGE_PATH = "./tmp1"  # Path to store temporary files
-IDENTITY_PATH = os.path.join(STORAGE_PATH, "identity")  # Path to store identity file
-APP_NAME = LXMF.APP_NAME + ".delivery"  # Application name for LXMF
-
-tel_controller = TelemetryController()
-
-class AnnounceHandler:
-    def __init__(self, connections, my_lxmf_dest, lxm_router):
-        self.aspect_filter = APP_NAME  # Filter for LXMF announcements
-        self.connections = connections  # List to store connections
-        self.my_lxmf_dest = my_lxmf_dest  # LXMF destination
-        self.lxm_router = lxm_router  # LXMF router
-
-    def received_announce(self, destination_hash, announced_identity, app_data):
-        # Log the received announcement details
-        RNS.log("\t+--- LXMF Announcement -----------------------------------------")
-        RNS.log(f"\t| Source hash            : {RNS.prettyhexrep(destination_hash)}")
-        RNS.log(f"\t| Announced identity     : {announced_identity}")
-        RNS.log(f"\t| App data               : {app_data}")
-        RNS.log("\t+---------------------------------------------------------------")
-
-        # Create a new destination from the announced identity
-        dest = RNS.Destination(
-            announced_identity,
-            RNS.Destination.OUT,
-            RNS.Destination.SINGLE,
-            "lxmf",
-            "delivery",
-        )
-        self.connections.append(dest)  # Add the new destination to connections
-
-        # Create and send a message to the new destination
-        message = LXMF.LXMessage(
-            dest, self.my_lxmf_dest, "Hi there", desired_method=LXMF.LXMessage.DIRECT
-        )
-        self.lxm_router.handle_outbound(message)  # Handle outbound message
-
-def command_handler(commands: list, message: LXMF.LXMessage, lxm_router, my_lxmf_dest):
-    for command in commands:
-        print(f"Command: {command}")
-        msg = tel_controller.handle_command(command, message, my_lxmf_dest)
-        if msg:
-            lxm_router.handle_outbound(msg)
-
-def delivery_callback(message: LXMF.LXMessage, connections, my_lxmf_dest, lxm_router):
-    # Format the timestamp of the message
-    try:
-        time_string = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(message.timestamp))
-        signature_string = "Signature is invalid, reason undetermined"
-
-        # Determine the signature validation status
-        if message.signature_validated:
-            signature_string = "Validated"
-        elif message.unverified_reason == LXMF.LXMessage.SIGNATURE_INVALID:
-            signature_string = "Invalid signature"
-        elif message.unverified_reason == LXMF.LXMessage.SOURCE_UNKNOWN:
-            signature_string = "Cannot verify, source is unknown"
-
-        if message.signature_validated and LXMF.FIELD_COMMANDS in message.fields:
-            command_handler(message.fields[LXMF.FIELD_COMMANDS], message, lxm_router, my_lxmf_dest)
-            return
-        
-        if tel_controller.handle_message(message):
-            RNS.log("Telemetry data saved")
-            return
-
-        # Log the delivery details
-        RNS.log("\t+--- LXMF Delivery ---------------------------------------------")
-        RNS.log(f"\t| Source hash            : {RNS.prettyhexrep(message.source_hash)}")
-        RNS.log(f"\t| Source instance        : {message.get_source()}")
-        RNS.log(
-            f"\t| Destination hash       : {RNS.prettyhexrep(message.destination_hash)}"
-        )
-        #RNS.log(f"\t| Destination identity   : {message.source_identity}")
-        RNS.log(f"\t| Destination instance   : {message.get_destination()}")
-        RNS.log(f"\t| Transport Encryption   : {message.transport_encryption}")
-        RNS.log(f"\t| Timestamp              : {time_string}")
-        RNS.log(f"\t| Title                  : {message.title_as_string()}")
-        RNS.log(f"\t| Content                : {message.content_as_string()}")
-        RNS.log(f"\t| Fields                 : {message.fields}")
-        RNS.log(f"\t| Message signature      : {signature_string}")
-        RNS.log("\t+---------------------------------------------------------------")
-        for connection in connections:
-            if connection.hash != message.source_hash:
-                response = LXMF.LXMessage(
-                    connection,
-                    my_lxmf_dest,
-                    message.content_as_string(),
-                    desired_method=LXMF.LXMessage.DIRECT,
-                )
-                lxm_router.handle_outbound(response)  # Handle outbound response
-    except Exception as e:
-        RNS.log(f"Error: {e}")
-
-def load_or_generate_identity(identity_path):
-    # Load existing identity or generate a new one
-    if os.path.exists(identity_path):
-        try:
-            RNS.log("Loading existing identity")
-            return RNS.Identity.from_file(identity_path)
-        except:
-            RNS.log("Failed to load existing identity, generating new")
-    else:
-        RNS.log("Generating new identity")
-
-    identity = RNS.Identity()  # Create a new identity
-    identity.to_file(identity_path)  # Save the new identity to file
-    return identity
-
-
-
-def main():
-    global my_lxmf_dest
-    connections = []  # List to store connections
-    r = RNS.Reticulum()  # Initialize Reticulum
-    lxm_router = LXMF.LXMRouter(storagepath=STORAGE_PATH)  # Initialize LXMF router
-    # lxm_router.enable_propagation()
-    identity = load_or_generate_identity(IDENTITY_PATH)  # Load or generate identity
-    my_lxmf_dest = lxm_router.register_delivery_identity(
-        identity, "test_server"
-    )  # Register delivery identity
-    lxm_router.set_message_storage_limit(megabytes=5)
-    lxm_router.enable_propagation()
-
-    # Register delivery callback
-    lxm_router.register_delivery_callback(
-        lambda msg: delivery_callback(msg, connections, my_lxmf_dest, lxm_router)
-    )
-    # Register announce handler
-    RNS.Transport.register_announce_handler(
-        AnnounceHandler(connections, my_lxmf_dest, lxm_router)
-    )
-
-    # Announce LXMF identity
-    my_lxmf_dest.announce()
-    lxm_router.announce_propagation_node()
-    RNS.log("LXMF identity announced")
-    RNS.log("\t+--- LXMF Identity ---------------------------------------------")
-    RNS.log(f"\t| Hash                   : {RNS.prettyhexrep(my_lxmf_dest.hash)}")
-    RNS.log(
-        f"\t| Public key             : {RNS.prettyhexrep(my_lxmf_dest.identity.pub.public_bytes())}"
-    )
-    RNS.log("\t+---------------------------------------------------------------")
-
-    # Periodically announce the LXMF identity
-    while True:
-        choice = input("Enter your choice (exit/announce/telemetry): ")
-        
-        if choice == "exit":
-            break
-        elif choice == "announce":
-            my_lxmf_dest.announce()
-        elif choice == "announce_prop":
-            lxm_router.announce_propagation_node()
-        elif choice == "telemetry":
-            connection_hash = input("Enter the connection hash: ")
-            found = False
-            for connection in connections:
-                if connection.hexhash == connection_hash:
-                    message = LXMF.LXMessage(
-                    connection,
-                    my_lxmf_dest,
-                    "Requesting telemetry",
-                    desired_method=LXMF.LXMessage.DIRECT,
-                    fields={LXMF.FIELD_COMMANDS: [{TelemetryController.TELEMETRY_REQUEST: 1000000000}]}
-                    )
-                    lxm_router.handle_outbound(message)
-                    found = True
-                    break
-            if not found:
-                print("Connection not found")
-
-
-if __name__ == "__main__":
-    main()

reticulumtelemetryhub-0.1.0.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: ReticulumTelemetryHub
-Version: 0.1.0
-Summary: 
-Author: naman108
-Requires-Python: >=3.12,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: lxmf (>=0.4.4,<0.5.0)
-Requires-Dist: msgpack (>=1.0.8,<2.0.0)
-Requires-Dist: pytest (>=8.3.2,<9.0.0)
-Requires-Dist: sqlalchemy (>=2.0.32,<3.0.0)
-Description-Content-Type: text/markdown
-
-

reticulumtelemetryhub-0.1.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-lxmf_telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lxmf_telemetry/model/fields/field_telemetry_stream.py,sha256=d1cZ4MICGnJLh6n0kG0Rfh27h1rTiSlUNilgFHO9Q8o,139
-lxmf_telemetry/model/persistance/__init__.py,sha256=hD85jXD4cCPILUALrU0NB3Cy-bpaxPjkeeUsMYWjkLA,84
-lxmf_telemetry/model/persistance/appearance.py,sha256=D_IeRMW3OjdEzJB295h0lIHsRrG6JyeQmoC_Y2k085s,631
-lxmf_telemetry/model/persistance/peer.py,sha256=tvTePw_krqGzcZWAc8QI8WwP4BXQ5mgrVsj3gB0TLWs,488
-lxmf_telemetry/model/persistance/sensors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lxmf_telemetry/model/persistance/sensors/location.py,sha256=rMqsfCksHvp-Ol3YkfKHzkDBP4Wv-uki44oCHSHiKzM,2686
-lxmf_telemetry/model/persistance/sensors/magnetic_field.py,sha256=n5FBwUgYMTremcUUTp06ZiRE_ZiHtcjP9EUgk6rcd0U,1063
-lxmf_telemetry/model/persistance/sensors/sensor.py,sha256=6wajbHL1ns5khwuje7-DSQmUYGsCMclkccsy8LCAe-o,1502
-lxmf_telemetry/model/persistance/sensors/sensor_enum.py,sha256=JUjfjg4RKHGhyNjKURPOr1Ij9gge8tD1IBgWXSiRJX0,718
-lxmf_telemetry/model/persistance/sensors/sensor_mapping.py,sha256=3FREi7bhgXxSpVH6iZcWznKxvRwEQVCXuyBFwwSeuRk,237
-lxmf_telemetry/model/persistance/sensors/time.py,sha256=oor-uHLq05N-5TPvXzBIfTgXH0tAkQ7T61dXGCcyn1o,958
-lxmf_telemetry/model/persistance/telemeter.py,sha256=skhoPaifmQsypv11Aon4b8zQg84qohuVmYGJtSmqaU0,973
-lxmf_telemetry/telemetry_controller.py,sha256=wMmrNY-CRfbwfQvA4xWT1vPz1VnLER6cRrPictkkPC4,4961
-reticulum_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reticulum_server/main.py,sha256=BPLcln7ZQgaUREJvFgBZnkfLRtYZnEUx1M96fMq7PYY,7940
-reticulumtelemetryhub-0.1.0.dist-info/METADATA,sha256=Qe-h5spqSFpHa-AgNrGGzJ5_cfIf0olBpDu5tn_lTl4,422
-reticulumtelemetryhub-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-reticulumtelemetryhub-0.1.0.dist-info/RECORD,,