isar 1.15.0__py3-none-any.whl → 1.34.9__py3-none-any.whl

isar/robot/robot_upload_inspection.py

@@ -0,0 +1,75 @@
+import logging
+from queue import Queue
+from threading import Thread
+from typing import Tuple
+
+from robot_interface.models.exceptions.robot_exceptions import (
+    ErrorMessage,
+    RobotException,
+    RobotRetrieveInspectionException,
+)
+from robot_interface.models.inspection.inspection import Inspection
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.task import TASKS
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotUploadInspectionThread(Thread):
+    def __init__(
+        self,
+        upload_queue: Queue,
+        robot: RobotInterface,
+        task: TASKS,
+        mission: Mission,
+    ):
+        self.logger = logging.getLogger("robot")
+        self.robot: RobotInterface = robot
+        self.task: TASKS = task
+        self.upload_queue = upload_queue
+        self.mission: Mission = mission
+        Thread.__init__(self, name=f"Robot inspection upload thread - {task.id}")
+
+    def stop(self) -> None:
+        return
+
+    def run(self):
+        try:
+            inspection: Inspection = self.robot.get_inspection(task=self.task)
+            if self.task.inspection_id != inspection.id:
+                self.logger.warning(
+                    f"The inspection_id of task ({self.task.inspection_id}) "
+                    f"and result ({inspection.id}) is not matching. "
+                    f"This may lead to confusions when accessing the inspection later"
+                )
+
+        except (RobotRetrieveInspectionException, RobotException) as e:
+            error_message: ErrorMessage = ErrorMessage(
+                error_reason=e.error_reason, error_description=e.error_description
+            )
+            self.task.error_message = error_message
+            self.logger.error(
+                f"Failed to retrieve inspections because: {e.error_description}"
+            )
+            return
+
+        except Exception as e:
+            self.logger.error(
+                f"Failed to retrieve inspections because of unexpected error: {e}"
+            )
+            return
+
+        if not inspection:
+            self.logger.warning(
+                f"No inspection result data retrieved for task {str(self.task.id)[:8]}"
+            )
+
+        inspection.metadata.tag_id = self.task.tag_id
+
+        message: Tuple[Inspection, Mission] = (
+            inspection,
+            self.mission,
+        )
+        self.upload_queue.put(message)
+        self.logger.info(
+            f"Inspection result: {str(inspection.id)[:8]} queued for upload"
+        )

isar/script.py

@@ -0,0 +1,171 @@
+import logging
+import sys
+import time
+from logging import Logger
+from threading import Thread
+from typing import Any, List, Tuple
+
+import isar
+from isar.apis.api import API
+from isar.config.log import setup_loggers
+from isar.config.open_telemetry import setup_open_telemetry
+from isar.config.settings import robot_settings, settings
+from isar.models.events import Events
+from isar.modules import ApplicationContainer, get_injector
+from isar.robot.robot import Robot
+from isar.services.service_connections.mqtt.mqtt_client import MqttClient
+from isar.services.service_connections.mqtt.robot_heartbeat_publisher import (
+    RobotHeartbeatPublisher,
+)
+from isar.services.service_connections.mqtt.robot_info_publisher import (
+    RobotInfoPublisher,
+)
+from isar.state_machine.state_machine import StateMachine, main
+from isar.storage.uploader import Uploader
+from robot_interface.models.inspection.inspection import Inspection
+from robot_interface.models.mission.mission import Mission
+from robot_interface.robot_interface import RobotInterface
+
+
+def print_setting(
+    setting: str = "", value: Any = "", fillchar: str = " ", width: int = 48
+):
+    separator = ": " if value != "" else ""
+    text = setting.ljust(22, fillchar) + separator + str(value)
+    print("*", text.ljust(width - 4, fillchar), "*")
+
+
+def print_startup_info():
+    logger: Logger = logging.getLogger("main")
+    logger.info(
+        """
+         __   ________   ___        ________
+        / /  / ______/  /   |      / ____  /
+       / /  / /_____   / /| |     / /___/ /
+      / /  /_____  /  / __  |    / __  __/
+     / /  ______/ /  / /  | |   / /  | |
+    /_/  /_______/  /_/   |_|  /_/   |_|
+
+"""
+    )
+
+    def print_setting(setting: str = "", value: Any = "", fillchar: str = " "):
+        separator = ": " if value != "" else ""
+        logger.info(setting + separator + str(value))
+
+    logger.info(
+        f"Integration and Supervisory control of Autonomous Robots - Version: {isar.__version__}\n"
+    )
+
+    print_setting("ISAR settings")
+    print_setting("Robot package", settings.ROBOT_PACKAGE)
+    print_setting("Robot name", settings.ROBOT_NAME)
+    print_setting("Running on port", settings.API_PORT)
+    print_setting("Mission planner", settings.MISSION_PLANNER)
+    print_setting("Using local storage", settings.STORAGE_LOCAL_ENABLED)
+    print_setting("Using blob storage", settings.STORAGE_BLOB_ENABLED)
+    print_setting("Blob storage account", settings.BLOB_STORAGE_ACCOUNT)
+    print_setting("Using async inspection uploading", settings.UPLOAD_INSPECTIONS_ASYNC)
+    print_setting("Plant code", settings.PLANT_CODE)
+    print_setting("Plant name", settings.PLANT_NAME)
+    print_setting("Plant shortname", settings.PLANT_SHORT_NAME)
+    print_setting("Robot capabilities", robot_settings.CAPABILITIES)
+
+
+def start() -> None:
+    injector: ApplicationContainer = get_injector()
+
+    setup_loggers()
+    setup_open_telemetry(app=injector.api().app)
+    logger: Logger = logging.getLogger("main")
+
+    print_startup_info()
+
+    state_machine: StateMachine = injector.state_machine()
+    uploader: Uploader = injector.uploader()
+    robot_interface: RobotInterface = injector.robot_interface()
+    events: Events = injector.events()
+    robot: Robot = injector.robot()
+
+    threads: List[Thread] = []
+
+    state_machine_thread: Thread = Thread(
+        target=main, name="ISAR State Machine", args=[state_machine], daemon=True
+    )
+    threads.append(state_machine_thread)
+
+    uploader_thread: Thread = Thread(
+        target=uploader.run, name="ISAR Uploader", daemon=True
+    )
+    threads.append(uploader_thread)
+
+    robot_service_thread: Thread = Thread(
+        target=robot.run, name="Robot service", daemon=True
+    )
+    threads.append(robot_service_thread)
+
+    if settings.UPLOAD_INSPECTIONS_ASYNC:
+
+        def inspections_callback(inspection: Inspection, mission: Mission):
+            message: Tuple[Inspection, Mission] = (
+                inspection,
+                mission,
+            )
+            state_machine.events.upload_queue.put(message)
+
+        robot.register_and_monitor_inspection_callback(inspections_callback)
+
+    if settings.MQTT_ENABLED:
+        mqtt_client: MqttClient = MqttClient(mqtt_queue=events.mqtt_queue)
+
+        mqtt_thread: Thread = Thread(
+            target=mqtt_client.run, name="ISAR MQTT Client", daemon=True
+        )
+        threads.append(mqtt_thread)
+
+        robot_info_publisher: RobotInfoPublisher = RobotInfoPublisher(
+            mqtt_queue=events.mqtt_queue
+        )
+        robot_info_thread: Thread = Thread(
+            target=robot_info_publisher.run,
+            name="ISAR Robot Info Publisher",
+            daemon=True,
+        )
+        threads.append(robot_info_thread)
+
+        robot_heartbeat_publisher: RobotHeartbeatPublisher = RobotHeartbeatPublisher(
+            mqtt_queue=events.mqtt_queue
+        )
+
+        robot_heartbeat_thread: Thread = Thread(
+            target=robot_heartbeat_publisher.run,
+            name="ISAR Robot Heartbeat Publisher",
+            daemon=True,
+        )
+        threads.append(robot_heartbeat_thread)
+
+        publishers: List[Thread] = robot_interface.get_telemetry_publishers(
+            queue=events.mqtt_queue,
+            robot_name=settings.ROBOT_NAME,
+            isar_id=settings.ISAR_ID,
+        )
+
+        if publishers:
+            threads.extend(publishers)
+
+    api: API = injector.api()
+    api_thread: Thread = Thread(target=api.server.run, name="ISAR API", daemon=True)
+    threads.append(api_thread)
+
+    for thread in threads:
+        thread.start()
+        logger.info("Started thread: %s", thread.name)
+
+    api.wait_for_api_server_ready()
+
+    while True:
+        for thread in threads:
+            if not thread.is_alive():
+                logger.critical("Thread '%s' failed - ISAR shutting down", thread.name)
+                sys.exit(1)
+        time.sleep(settings.FSM_SLEEP_TIME)

isar/services/service_connections/mqtt/mqtt_client.py

@@ -1,15 +1,24 @@
 import logging
 import os
+import time
 from queue import Empty, Queue
 
 import backoff
 from paho.mqtt import client as mqtt
 from paho.mqtt.client import Client
+from paho.mqtt.packettypes import PacketTypes
+from paho.mqtt.properties import Properties
 
 from isar.config.settings import settings
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 
 
+def props_expiry(seconds: int) -> Properties:
+    p = Properties(PacketTypes.PUBLISH)
+    p.MessageExpiryInterval = seconds
+    return p
+
+
 def _on_success(data: dict) -> None:
     logging.getLogger("mqtt_client").info("Connected to MQTT Broker")
     logging.getLogger("mqtt_client").debug(
@@ -53,7 +62,9 @@ class MqttClient(MqttClientInterface):
 
         self.port: int = settings.MQTT_PORT
 
-        self.client: Client = Client()
+        self.client: Client = Client(
+            protocol=mqtt.MQTTv5, callback_api_version=mqtt.CallbackAPIVersion.VERSION2
+        )
 
         self.client.enable_logger(logger=self.logger)
 
@@ -74,20 +85,36 @@ class MqttClient(MqttClientInterface):
 
         while True:
             if not self.client.is_connected():
+                time.sleep(0)  # avoid CPU spin
                 continue
             try:
-                topic, payload, qos, retain = self.mqtt_queue.get(timeout=1)
+                item = self.mqtt_queue.get(timeout=1)
+                if len(item) == 4:
+                    topic, payload, qos, retain = item
+                    properties = None
+                else:
+                    topic, payload, qos, retain, properties = item
             except Empty:
                 continue
 
-            self.publish(topic=topic, payload=payload, qos=qos, retain=retain)
+            self.publish(
+                topic=topic,
+                payload=payload,
+                qos=qos,
+                retain=retain,
+                properties=properties,
+            )
 
-    def on_connect(self, client, userdata, flags, rc):
-        self.logger.info("Connection returned result: " + mqtt.connack_string(rc))
+    def on_connect(self, client, userdata, flags, reason_code, properties):
+        self.logger.info(f"Connected: {reason_code}")
 
-    def on_disconnect(self, client, userdata, rc):
+    def on_disconnect(self, client, userdata, *args):
+        if not args:
+            return
+        reason_code = args[0] if len(args) < 3 else args[1]
+        rc = getattr(reason_code, "value", reason_code)
         if rc != 0:
-            self.logger.warning("Unexpected disconnection from MQTT Broker")
+            self.logger.warning(f"Unexpected disconnect: {reason_code}.")
 
     @backoff.on_exception(
         backoff.expo,
@@ -99,9 +126,18 @@ class MqttClient(MqttClientInterface):
     )
     def connect(self, host: str, port: int) -> None:
         self.logger.info("Attempting to connect to MQTT Broker")
-        self.logger.debug(f"Host: {host}, Port: {port}")
+        self.logger.info("Host: %s, Port: %s", host, port)
         self.client.connect(host=host, port=port)
 
-    def publish(self, topic: str, payload: str, qos: int = 0, retain: bool = False):
-        self.logger.debug(f"Publishing message to topic: {topic}")
-        self.client.publish(topic=topic, payload=payload, qos=qos, retain=retain)
+    def publish(
+        self,
+        topic: str,
+        payload: str,
+        qos: int = 0,
+        retain: bool = False,
+        properties=None,
+    ):
+        self.logger.debug("Publishing message to topic: %s", topic)
+        self.client.publish(
+            topic=topic, payload=payload, qos=qos, retain=retain, properties=properties
+        )

isar/services/service_connections/mqtt/robot_heartbeat_publisher.py

@@ -0,0 +1,32 @@
+import json
+import time
+from datetime import datetime, timezone
+from queue import Queue
+
+from isar.config.settings import settings
+from isar.services.service_connections.mqtt.mqtt_client import props_expiry
+from robot_interface.telemetry.mqtt_client import MqttPublisher
+from robot_interface.telemetry.payloads import RobotHeartbeatPayload
+from robot_interface.utilities.json_service import EnhancedJSONEncoder
+
+
+class RobotHeartbeatPublisher:
+    def __init__(self, mqtt_queue: Queue):
+        self.mqtt_publisher: MqttPublisher = MqttPublisher(mqtt_queue=mqtt_queue)
+
+    def run(self) -> None:
+        while True:
+            payload: RobotHeartbeatPayload = RobotHeartbeatPayload(
+                isar_id=settings.ISAR_ID,
+                robot_name=settings.ROBOT_NAME,
+                timestamp=datetime.now(timezone.utc),
+            )
+
+            self.mqtt_publisher.publish(
+                topic=settings.TOPIC_ISAR_ROBOT_HEARTBEAT,
+                payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+                retain=True,
+                properties=props_expiry(settings.MQTT_ROBOT_HEARTBEAT_EXPIRY),
+            )
+
+            time.sleep(settings.ROBOT_HEARTBEAT_PUBLISH_INTERVAL)

isar/services/service_connections/mqtt/robot_info_publisher.py

@@ -1,6 +1,6 @@
 import json
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from queue import Queue
 
 from isar.config.settings import robot_settings, settings
@@ -21,10 +21,11 @@ class RobotInfoPublisher:
                 robot_model=robot_settings.ROBOT_MODEL,  # type: ignore
                 robot_serial_number=settings.SERIAL_NUMBER,
                 robot_asset=settings.PLANT_SHORT_NAME,
-                video_streams=settings.VIDEO_STREAMS,
+                documentation=settings.DOCUMENTATION,
                 host=settings.API_HOST_VIEWED_EXTERNALLY,
                 port=settings.API_PORT,
-                timestamp=datetime.utcnow(),
+                capabilities=robot_settings.CAPABILITIES,
+                timestamp=datetime.now(timezone.utc),
             )
 
             self.mqtt_publisher.publish(

isar/services/service_connections/persistent_memory.py

@@ -0,0 +1,69 @@
+# This file uses SQLAlchemy to interface the persistent database storage.
+
+import sqlalchemy
+from sqlalchemy import Boolean, Integer, String
+from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class PersistentRobotState(Base):
+    __tablename__ = "persistent_robot_state"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    robot_id: Mapped[str] = mapped_column(String(64))
+    is_maintenance_mode: Mapped[bool] = mapped_column(Boolean, nullable=False)
+
+    def __repr__(self):
+        return f"PersistentRobotState(id={self.id!r}, robot_id={self.robot_id!r}, is_maintenance_mode={self.is_maintenance_mode!r})"
+
+
+class NoSuchRobotException(Exception):
+    pass
+
+
+def read_persistent_robot_state_is_maintenance_mode(
+    connection_string: str, robot_id: str
+):
+    engine = sqlalchemy.create_engine(connection_string)
+
+    with Session(engine) as session:
+        statement = sqlalchemy.select(PersistentRobotState).where(
+            PersistentRobotState.robot_id == robot_id
+        )
+        read_persistent_state = session.scalar(statement)
+
+        if read_persistent_state is None:
+            raise NoSuchRobotException(
+                f"No robot in persistent storage with id {robot_id}"
+            )
+
+        return read_persistent_state.is_maintenance_mode
+
+
+def change_persistent_robot_state_is_maintenance_mode(
+    connection_string: str, robot_id: str, value: bool
+):
+    engine = sqlalchemy.create_engine(connection_string)
+
+    with Session(engine) as session:
+        statement = sqlalchemy.select(PersistentRobotState).where(
+            PersistentRobotState.robot_id == robot_id
+        )
+        read_persistent_state = session.scalar(statement)
+
+        read_persistent_state.is_maintenance_mode = value
+        session.commit()
+
+
+def create_persistent_robot_state(connection_string: str, robot_id: str):
+    engine = sqlalchemy.create_engine(connection_string)
+
+    with Session(engine) as session:
+        persistent_state = PersistentRobotState(
+            robot_id=robot_id, is_maintenance_mode=True
+        )
+        session.add_all([persistent_state])
+        session.commit()

isar/services/utilities/mqtt_utilities.py

@@ -0,0 +1,93 @@
+import json
+from datetime import datetime, timezone
+from typing import Optional
+
+from isar.config.settings import settings
+from isar.models.status import IsarStatus
+from isar.services.service_connections.mqtt.mqtt_client import props_expiry
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.task import TASKS
+from robot_interface.telemetry.mqtt_client import MqttClientInterface
+from robot_interface.telemetry.payloads import (
+    IsarStatusPayload,
+    MissionPayload,
+    TaskPayload,
+)
+from robot_interface.utilities.json_service import EnhancedJSONEncoder
+
+
+def publish_task_status(
+    mqtt_publisher: MqttClientInterface, task: TASKS, mission: Optional[Mission]
+) -> None:
+    """Publishes the task status to the MQTT Broker"""
+
+    error_message: Optional[ErrorMessage] = None
+    if task:
+        if task.error_message:
+            error_message = task.error_message
+
+    payload: TaskPayload = TaskPayload(
+        isar_id=settings.ISAR_ID,
+        robot_name=settings.ROBOT_NAME,
+        mission_id=mission.id if mission else None,
+        task_id=task.id if task else None,
+        status=task.status if task else None,
+        task_type=task.type if task else None,
+        error_reason=error_message.error_reason if error_message else None,
+        error_description=(error_message.error_description if error_message else None),
+        timestamp=datetime.now(timezone.utc),
+    )
+
+    mqtt_publisher.publish(
+        topic=settings.TOPIC_ISAR_TASK + f"/{task.id}",
+        payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+        qos=1,
+        retain=True,
+        properties=props_expiry(settings.MQTT_MISSION_AND_TASK_EXPIRY),
+    )
+
+
+def publish_mission_status(
+    mqtt_publisher: MqttClientInterface, mission: Mission
+) -> None:
+    if not mqtt_publisher:
+        return
+
+    error_message = mission.error_message
+
+    payload: MissionPayload = MissionPayload(
+        isar_id=settings.ISAR_ID,
+        robot_name=settings.ROBOT_NAME,
+        mission_id=mission.id,
+        status=mission.status,
+        error_reason=error_message.error_reason if error_message else None,
+        error_description=(error_message.error_description if error_message else None),
+        timestamp=datetime.now(timezone.utc),
+    )
+
+    mqtt_publisher.publish(
+        topic=settings.TOPIC_ISAR_MISSION + f"/{mission.id}",
+        payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+        qos=1,
+        retain=True,
+        properties=props_expiry(settings.MQTT_MISSION_AND_TASK_EXPIRY),
+    )
+
+
+def publish_isar_status(
+    mqtt_publisher: MqttClientInterface, status: IsarStatus
+) -> None:
+    payload: IsarStatusPayload = IsarStatusPayload(
+        isar_id=settings.ISAR_ID,
+        robot_name=settings.ROBOT_NAME,
+        status=status,
+        timestamp=datetime.now(timezone.utc),
+    )
+
+    mqtt_publisher.publish(
+        topic=settings.TOPIC_ISAR_STATUS,
+        payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+        qos=1,
+        retain=True,
+    )

isar/services/utilities/robot_utilities.py

@@ -0,0 +1,20 @@
+import logging
+
+from robot_interface.models.robots.media import MediaConfig
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotUtilities:
+    """
+    Contains utility functions for getting robot information from the API.
+    """
+
+    def __init__(
+        self,
+        robot: RobotInterface,
+    ):
+        self.robot: RobotInterface = robot
+        self.logger = logging.getLogger("api")
+
+    def generate_media_config(self) -> MediaConfig:
+        return self.robot.generate_media_config()