isar 1.30.5__py3-none-any.whl → 1.31.1__py3-none-any.whl

isar/robot/robot.py

@@ -1,27 +1,24 @@
 import logging
-from queue import Queue
-from threading import Event
+from threading import Event as ThreadEvent
 from typing import Optional
 
-from dependency_injector.wiring import inject
-
-from isar.models.communication.queues.events import (
+from isar.models.events import (
+    Event,
     Events,
     RobotServiceEvents,
     SharedState,
     StateMachineEvents,
 )
-from isar.models.communication.queues.queue_utils import check_for_event, trigger_event
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
 from isar.robot.robot_stop_mission import RobotStopMissionThread
 from isar.robot.robot_task_status import RobotTaskStatusThread
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
+from robot_interface.models.mission.mission import Mission
 from robot_interface.robot_interface import RobotInterface
 
 
 class Robot(object):
-    @inject
     def __init__(
         self, events: Events, robot: RobotInterface, shared_state: SharedState
     ) -> None:
@@ -34,7 +31,7 @@ class Robot(object):
         self.robot_status_thread: Optional[RobotStatusThread] = None
         self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
         self.stop_mission_thread: Optional[RobotStopMissionThread] = None
-        self.signal_thread_quitting: Event = Event()
+        self.signal_thread_quitting: ThreadEvent = ThreadEvent()
 
     def stop(self) -> None:
         self.signal_thread_quitting.set()
@@ -56,8 +53,8 @@ class Robot(object):
         self.robot_task_status_thread = None
         self.start_mission_thread = None
 
-    def _check_and_handle_start_mission(self, event: Queue) -> None:
-        start_mission = check_for_event(event)
+    def _start_mission_event_handler(self, event: Event[Mission]) -> None:
+        start_mission = event.consume_event()
         if start_mission is not None:
             if (
                 self.start_mission_thread is not None
@@ -75,8 +72,8 @@ class Robot(object):
             )
             self.start_mission_thread.start()
 
-    def _check_and_handle_task_status_request(self, event: Queue[str]) -> None:
-        task_id: str = check_for_event(event)
+    def _task_status_request_handler(self, event: Event[str]) -> None:
+        task_id: str = event.consume_event()
         if task_id:
             self.robot_task_status_thread = RobotTaskStatusThread(
                 self.robot_service_events,
@@ -86,8 +83,8 @@ class Robot(object):
             )
             self.robot_task_status_thread.start()
 
-    def _check_and_handle_stop_mission(self, event: Queue) -> None:
-        if check_for_event(event):
+    def _stop_mission_request_handler(self, event: Event[bool]) -> None:
+        if event.consume_event():
             if (
                 self.stop_mission_thread is not None
                 and self.stop_mission_thread.is_alive()
@@ -105,8 +102,8 @@ class Robot(object):
                     error_reason=ErrorReason.RobotStillStartingMissionException,
                     error_description=error_description,
                 )
-                trigger_event(
-                    self.robot_service_events.mission_failed_to_stop, error_message
+                self.robot_service_events.mission_failed_to_stop.trigger_event(
+                    error_message
                 )
                 return
             self.stop_mission_thread = RobotStopMissionThread(
@@ -121,14 +118,12 @@ class Robot(object):
         self.robot_status_thread.start()
 
         while not self.signal_thread_quitting.wait(0):
-            self._check_and_handle_start_mission(
-                self.state_machine_events.start_mission
-            )
+            self._start_mission_event_handler(self.state_machine_events.start_mission)
 
-            self._check_and_handle_task_status_request(
+            self._task_status_request_handler(
                 self.state_machine_events.task_status_request
             )
 
-            self._check_and_handle_stop_mission(self.state_machine_events.stop_mission)
+            self._stop_mission_request_handler(self.state_machine_events.stop_mission)
 
         self.logger.info("Exiting robot service main thread")

isar/robot/robot_start_mission.py

@@ -2,11 +2,7 @@ import logging
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import (
-    trigger_event,
-    trigger_event_without_data,
-)
+from isar.models.events import RobotServiceEvents
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotException,
@@ -44,13 +40,13 @@ class RobotStartMissionThread(Thread):
                     self.logger.error(
                         f"Mission is infeasible and cannot be scheduled because: {e.error_description}"
                     )
-                    trigger_event(
-                        self.robot_service_events.mission_failed,
+                    self.robot_service_events.mission_failed.trigger_event(
                         ErrorMessage(
                             error_reason=e.error_reason,
                             error_description=e.error_description,
-                        ),
+                        )
                     )
+
                     break
                 except RobotException as e:
                     retries += 1
@@ -66,12 +62,11 @@ class RobotStartMissionThread(Thread):
                             f"{e.error_description}"
                         )
 
-                        trigger_event(
-                            self.robot_service_events.mission_failed,
+                        self.robot_service_events.mission_failed.trigger_event(
                             ErrorMessage(
                                 error_reason=e.error_reason,
                                 error_description=e.error_description,
-                            ),
+                            )
                         )
                         break
 
@@ -79,12 +74,11 @@ class RobotStartMissionThread(Thread):
 
                 started_mission = True
         except RobotInfeasibleMissionException as e:
-            trigger_event(
-                self.robot_service_events.mission_failed,
+            self.robot_service_events.mission_failed.trigger_event(
                 ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
                 ),
             )
 
         if started_mission:
-            trigger_event_without_data(self.robot_service_events.mission_started)
+            self.robot_service_events.mission_started.trigger_event(True)

isar/robot/robot_status.py

@@ -3,8 +3,7 @@ import time
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import SharedState
-from isar.models.communication.queues.queue_utils import update_shared_state
+from isar.models.events import SharedState
 from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.robot_interface import RobotInterface
 
@@ -49,7 +48,7 @@ class RobotStatusThread(Thread):
                 self.last_robot_status_poll_time = time.time()
 
                 robot_status = self.robot.robot_status()
-                update_shared_state(self.shared_state.robot_status, robot_status)
+                self.shared_state.robot_status.update(robot_status)
             except RobotException as e:
                 self.logger.error(f"Failed to retrieve robot status: {e}")
                 continue

isar/robot/robot_stop_mission.py

@@ -4,11 +4,7 @@ from threading import Event, Thread
 from typing import Optional
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import (
-    trigger_event,
-    trigger_event_without_data,
-)
+from isar.models.events import RobotServiceEvents
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotActionException,
@@ -51,9 +47,7 @@ class RobotStopMissionThread(Thread):
                 time.sleep(settings.FSM_SLEEP_TIME)
                 continue
 
-            trigger_event_without_data(
-                self.robot_service_events.mission_successfully_stopped
-            )
+            self.robot_service_events.mission_successfully_stopped.trigger_event(True)
             return
 
         error_description = (
@@ -68,4 +62,4 @@ class RobotStopMissionThread(Thread):
             error_description=error_description,
         )
 
-        trigger_event(self.robot_service_events.mission_failed_to_stop, error_message)
+        self.robot_service_events.mission_failed_to_stop.trigger_event(error_message)

isar/robot/robot_task_status.py

@@ -4,8 +4,7 @@ from threading import Event, Thread
 from typing import Optional
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import trigger_event
+from isar.models.events import RobotServiceEvents
 from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
@@ -82,10 +81,7 @@ class RobotTaskStatusThread(Thread):
                 )
                 break
 
-            trigger_event(self.robot_service_events.task_status_updated, task_status)
+            self.robot_service_events.task_status_updated.trigger_event(task_status)
             return
 
-        trigger_event(
-            self.robot_service_events.task_status_failed,
-            failed_task_error,
-        )
+        self.robot_service_events.task_status_failed.trigger_event(failed_task_error)

isar/script.py

@@ -8,8 +8,9 @@ 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.communication.queues.events import Events
+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
@@ -68,6 +69,7 @@ def print_startup_info():
     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)
@@ -83,6 +85,7 @@ def start() -> None:
 
     keyvault = injector.keyvault()
     setup_loggers(keyvault=keyvault)
+    setup_open_telemetry(app=injector.api().app)
     logger: Logger = logging.getLogger("main")
 
     print_startup_info()

isar/services/utilities/robot_utilities.py

@@ -1,7 +1,5 @@
 import logging
 
-from dependency_injector.wiring import inject
-
 from robot_interface.models.robots.media import MediaConfig
 from robot_interface.robot_interface import RobotInterface
 
@@ -11,7 +9,6 @@ class RobotUtilities:
     Contains utility functions for getting robot information from the API.
     """
 
-    @inject
     def __init__(
         self,
         robot: RobotInterface,

isar/services/utilities/scheduling_utilities.py

@@ -1,10 +1,8 @@
 import logging
 from copy import deepcopy
 from http import HTTPStatus
-from queue import Empty
-from typing import Any, List
+from typing import List, TypeVar
 
-from dependency_injector.wiring import inject
 from fastapi import HTTPException
 from requests import HTTPError
 
@@ -15,15 +13,20 @@ from isar.mission_planner.mission_planner_interface import (
     MissionPlannerError,
     MissionPlannerInterface,
 )
-from isar.models.communication.message import StartMissionMessage
-from isar.models.communication.queues.events import APIRequests, Events, SharedState
-from isar.models.communication.queues.queue_io import QueueIO
-from isar.models.communication.queues.queue_timeout_error import QueueTimeoutError
-from isar.services.utilities.queue_utilities import QueueUtilities
+from isar.models.events import (
+    APIEvent,
+    APIRequests,
+    Events,
+    EventTimeoutError,
+    SharedState,
+)
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
 from robot_interface.models.mission.status import MissionStatus
 
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
 
 class SchedulingUtilities:
     """
@@ -31,7 +34,6 @@ class SchedulingUtilities:
     required thread communication through queues to the state machine.
     """
 
-    @inject
     def __init__(
         self,
         events: Events,
@@ -53,9 +55,8 @@ class SchedulingUtilities:
         HTTPException 500 Internal Server Error
             If the current state is not available on the queue
         """
-        try:
-            return self.shared_state.state.check()
-        except Empty:
+        current_state = self.shared_state.state.check()
+        if current_state is None:
             error_message: str = (
                 "Internal Server Error - Current state of the state machine is unknown"
             )
@@ -63,6 +64,7 @@ class SchedulingUtilities:
             raise HTTPException(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
             )
+        return current_state
 
     def get_mission(self, mission_id: str) -> Mission:
         """Get the mission with mission_id from the current mission planner
@@ -175,10 +177,10 @@ class SchedulingUtilities:
         """
         try:
             self._send_command(
-                StartMissionMessage(mission=deepcopy(mission)),
+                deepcopy(mission),
                 self.api_events.start_mission,
             )
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to start mission in ISAR"
             self.logger.error(error_message)
             raise HTTPException(
@@ -201,7 +203,7 @@ class SchedulingUtilities:
                 True,
                 self.api_events.return_home,
             )
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = (
                 "Internal Server Error - Failed to start return home mission in ISAR"
             )
@@ -220,15 +222,15 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.api_events.pause_mission)
-        except QueueTimeoutError:
+            response = self._send_command(True, self.api_events.pause_mission)
+            self.logger.info("OK - Mission successfully paused")
+            return response
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to pause mission"
             self.logger.error(error_message)
             raise HTTPException(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
             )
-        finally:
-            self.logger.info("OK - Mission successfully paused")
 
     def resume_mission(self) -> ControlMissionResponse:
         """Resume mission
@@ -239,21 +241,23 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.api_events.resume_mission)
-        except QueueTimeoutError:
+            response = self._send_command(True, self.api_events.resume_mission)
+            self.logger.info("OK - Mission successfully resumed")
+            return response
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to resume mission"
             self.logger.error(error_message)
             raise HTTPException(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
             )
-        finally:
-            self.logger.info("OK - Mission successfully resumed")
 
-    def stop_mission(self) -> ControlMissionResponse:
+    def stop_mission(self, mission_id: str = "") -> ControlMissionResponse:
         """Stop mission
 
         Raises
         ------
+        HTTPException 404 Not Found
+            If the mission_id was not known to Isar
         HTTPException 503 Service Unavailable
             The request was understood, but attempting to stop the mission failed
         HTTPException 408 Request timeout
@@ -261,15 +265,23 @@ class SchedulingUtilities:
         """
         try:
             stop_mission_response: ControlMissionResponse = self._send_command(
-                True, self.api_events.stop_mission
+                mission_id, self.api_events.stop_mission
             )
+
+            if stop_mission_response.mission_not_found:
+                error_message = f"Mission ID {stop_mission_response.mission_id} is not currently running"
+                self.logger.error(error_message)
+                raise HTTPException(
+                    status_code=HTTPStatus.NOT_FOUND, detail=error_message
+                )
+
             if stop_mission_response.mission_status != MissionStatus.Cancelled.value:
                 error_message = "Failed to stop mission"
                 self.logger.error(error_message)
                 raise HTTPException(
-                    status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail=error_message
+                    status_code=HTTPStatus.CONFLICT, detail=error_message
                 )
-        except QueueTimeoutError:
+        except EventTimeoutError:
             error_message = "Internal Server Error - Failed to stop mission"
             self.logger.error(error_message)
             raise HTTPException(
@@ -278,14 +290,12 @@ class SchedulingUtilities:
         self.logger.info("OK - Mission successfully stopped")
         return stop_mission_response
 
-    def _send_command(self, input: Any, queueio: QueueIO) -> Any:
-        queueio.input.put(input)
+    def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
+        api_event.input.trigger_event(input)
         try:
-            return QueueUtilities.check_queue(
-                queueio.output,
-                self.queue_timeout,
-            )
-        except QueueTimeoutError as e:
-            QueueUtilities.clear_queue(queueio.input)
+            return api_event.output.consume_event(timeout=self.queue_timeout)
+        except EventTimeoutError as e:
+            self.logger.error("Queue timed out")
+            api_event.input.clear_event()
             self.logger.error("No output received for command to state machine")
             raise e

isar/state_machine/state_machine.py

@@ -3,9 +3,8 @@ import logging
 from collections import deque
 from datetime import datetime, timezone
 from threading import Event
-from typing import Deque, List, Optional
+from typing import Deque, List, Optional, Tuple
 
-from dependency_injector.wiring import inject
 from transitions import Machine
 from transitions.core import State
 
@@ -15,8 +14,7 @@ from isar.mission_planner.task_selector_interface import (
     TaskSelectorInterface,
     TaskSelectorStop,
 )
-from isar.models.communication.queues.events import Events, SharedState
-from isar.models.communication.queues.queue_utils import update_shared_state
+from isar.models.events import Events, SharedState
 from isar.state_machine.states.await_next_mission import AwaitNextMission
 from isar.state_machine.states.blocked_protective_stop import BlockedProtectiveStop
 from isar.state_machine.states.home import Home
@@ -31,10 +29,15 @@ from isar.state_machine.states_enum import States
 from isar.state_machine.transitions.mission import get_mission_transitions
 from isar.state_machine.transitions.return_home import get_return_home_transitions
 from isar.state_machine.transitions.robot_status import get_robot_status_transitions
-from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+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.status import RobotStatus, TaskStatus
-from robot_interface.models.mission.task import TASKS
+from robot_interface.models.mission.task import TASKS, InspectionTask, Task
 from robot_interface.robot_interface import RobotInterface
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from robot_interface.telemetry.payloads import (
@@ -48,7 +51,6 @@ from robot_interface.utilities.json_service import EnhancedJSONEncoder
 class StateMachine(object):
     """Handles state transitions for supervisory robot control."""
 
-    @inject
     def __init__(
         self,
         events: Events,
@@ -142,6 +144,8 @@ class StateMachine(object):
 
         self.current_state: State = States(self.state)  # type: ignore
 
+        self.awaiting_task_status: bool = False
+
         self.transitions_log_length: int = transitions_log_length
         self.transitions_list: Deque[States] = deque([], self.transitions_log_length)
 
@@ -184,7 +188,7 @@ class StateMachine(object):
     def update_state(self):
         """Updates the current state of the state machine."""
         self.current_state = States(self.state)  # type: ignore
-        update_shared_state(self.shared_state.state, self.current_state)
+        self.shared_state.state.update(self.current_state)
         self._log_state_transition(self.current_state)
         self.logger.info("State: %s", self.current_state)
         self.publish_status()
@@ -203,9 +207,21 @@ class StateMachine(object):
         self.task_selector.initialize(tasks=self.current_mission.tasks)
 
     def send_task_status(self):
-        update_shared_state(
-            self.shared_state.state_machine_current_task, self.current_task
-        )
+        self.shared_state.state_machine_current_task.update(self.current_task)
+
+    def report_task_status(self, task: Task) -> None:
+        if task.status == TaskStatus.Failed:
+            self.logger.warning(
+                f"Task: {str(task.id)[:8]} was reported as failed by the robot"
+            )
+        elif task.status == TaskStatus.Successful:
+            self.logger.info(
+                f"{type(task).__name__} task: {str(task.id)[:8]} completed"
+            )
+        else:
+            self.logger.info(
+                f"Task: {str(task.id)[:8]} was reported as task.status by the robot"
+            )
 
     def publish_mission_status(self) -> None:
         if not self.mqtt_publisher:
@@ -336,6 +352,58 @@ class StateMachine(object):
             )
         )
 
+    def should_upload_inspections(self) -> bool:
+        if settings.UPLOAD_INSPECTIONS_ASYNC:
+            return False
+
+        return (
+            self.current_task.is_finished()
+            and self.current_task.status == TaskStatus.Successful
+            and isinstance(self.current_task, InspectionTask)
+        )
+
+    def queue_inspections_for_upload(
+        self, mission: Mission, current_task: InspectionTask, logger: logging.Logger
+    ) -> None:
+        try:
+            inspection: Inspection = self.robot.get_inspection(task=current_task)
+            if current_task.inspection_id != inspection.id:
+                logger.warning(
+                    f"The inspection_id of task ({current_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.current_task.error_message = error_message
+            logger.error(
+                f"Failed to retrieve inspections because: {e.error_description}"
+            )
+            return
+
+        except Exception as e:
+            logger.error(
+                f"Failed to retrieve inspections because of unexpected error: {e}"
+            )
+            return
+
+        if not inspection:
+            logger.warning(
+                f"No inspection result data retrieved for task {str(current_task.id)[:8]}"
+            )
+
+        inspection.metadata.tag_id = current_task.tag_id
+
+        message: Tuple[Inspection, Mission] = (
+            inspection,
+            mission,
+        )
+        self.events.upload_queue.put(message)
+        logger.info(f"Inspection result: {str(inspection.id)[:8]} queued for upload")
+
 
 def main(state_machine: StateMachine):
     """Starts a state machine instance."""

isar/state_machine/states/await_next_mission.py

@@ -1,20 +1,55 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
-from transitions import State
+from isar.config.settings import settings
+from isar.eventhandlers.eventhandler import (
+    EventHandlerBase,
+    EventHandlerMapping,
+    TimeoutHandlerMapping,
+)
+from isar.state_machine.utils.common_event_handlers import (
+    return_home_event_handler,
+    start_mission_event_handler,
+    stop_mission_event_handler,
+)
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
-from isar.state_machine.generic_states.idle import Idle, IdleStates
 
+class AwaitNextMission(EventHandlerBase):
 
-class AwaitNextMission(State, Idle):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        State.__init__(
-            self, name="await_next_mission", on_enter=self.start, on_exit=self.stop
-        )
-        Idle.__init__(
-            self,
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.input,
+                handler=lambda event: start_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="return_home_event",
+                event=events.api_requests.return_home.input,
+                handler=lambda event: return_home_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.return_home.input,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+        ]
+
+        timers: List[TimeoutHandlerMapping] = [
+            TimeoutHandlerMapping(
+                name="should_return_home_timer",
+                timeout_in_seconds=settings.RETURN_HOME_DELAY,
+                handler=lambda: state_machine.request_return_home,  # type: ignore
+            )
+        ]
+
+        super().__init__(
+            state_name="await_next_mission",
             state_machine=state_machine,
-            state=IdleStates.AwaitNextMission,
+            event_handler_mappings=event_handlers,
+            timers=timers,
         )