isar 1.26.0__py3-none-any.whl → 1.26.1__py3-none-any.whl

isar/script.py

@@ -12,7 +12,7 @@ from isar.apis.api import API
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.log import setup_loggers
 from isar.config.settings import robot_settings, settings
-from isar.models.communication.queues.queues import Queues
+from isar.models.communication.queues.events import Events
 from isar.modules import get_injector
 from isar.robot.robot import Robot
 from isar.services.service_connections.mqtt.mqtt_client import MqttClient
@@ -94,7 +94,7 @@ def start() -> None:
     state_machine: StateMachine = injector.get(StateMachine)
     uploader: Uploader = injector.get(Uploader)
     robot: RobotInterface = injector.get(RobotInterface)
-    queues: Queues = injector.get(Queues)
+    events: Events = injector.get(Events)
     robot_service: Robot = injector.get(Robot)
 
     threads: List[Thread] = []
@@ -121,12 +121,12 @@ def start() -> None:
                 inspection,
                 mission,
             )
-            state_machine.queues.upload_queue.put(message)
+            state_machine.events.upload_queue.put(message)
 
         robot.register_inspection_callback(inspections_callback)
 
     if settings.MQTT_ENABLED:
-        mqtt_client: MqttClient = MqttClient(mqtt_queue=queues.mqtt_queue)
+        mqtt_client: MqttClient = MqttClient(mqtt_queue=events.mqtt_queue)
 
         mqtt_thread: Thread = Thread(
             target=mqtt_client.run, name="ISAR MQTT Client", daemon=True
@@ -134,7 +134,7 @@ def start() -> None:
         threads.append(mqtt_thread)
 
         robot_info_publisher: RobotInfoPublisher = RobotInfoPublisher(
-            mqtt_queue=queues.mqtt_queue
+            mqtt_queue=events.mqtt_queue
         )
         robot_info_thread: Thread = Thread(
             target=robot_info_publisher.run,
@@ -144,7 +144,7 @@ def start() -> None:
         threads.append(robot_info_thread)
 
         robot_heartbeat_publisher: RobotHeartbeatPublisher = RobotHeartbeatPublisher(
-            mqtt_queue=queues.mqtt_queue
+            mqtt_queue=events.mqtt_queue
         )
 
         robot_heartbeat_thread: Thread = Thread(
@@ -155,7 +155,7 @@ def start() -> None:
         threads.append(robot_heartbeat_thread)
 
         publishers: List[Thread] = robot.get_telemetry_publishers(
-            queue=queues.mqtt_queue,
+            queue=events.mqtt_queue,
             robot_name=settings.ROBOT_NAME,
             isar_id=settings.ISAR_ID,
         )

isar/services/utilities/scheduling_utilities.py

@@ -16,9 +16,9 @@ from isar.mission_planner.mission_planner_interface import (
     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.models.communication.queues.queues import Queues
 from isar.services.utilities.queue_utilities import QueueUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
@@ -33,11 +33,13 @@ class SchedulingUtilities:
     @inject
     def __init__(
         self,
-        queues: Queues,
+        events: Events,
+        shared_state: SharedState,
         mission_planner: MissionPlannerInterface,
         queue_timeout: int = settings.QUEUE_TIMEOUT,
     ):
-        self.queues: Queues = queues
+        self.api_events: APIRequests = events.api_requests
+        self.shared_state: SharedState = shared_state
         self.mission_planner: MissionPlannerInterface = mission_planner
         self.queue_timeout: int = queue_timeout
         self.logger = logging.getLogger("api")
@@ -51,7 +53,7 @@ class SchedulingUtilities:
             If the current state is not available on the queue
         """
         try:
-            return self.queues.state.check()
+            return self.shared_state.state.check()
         except Empty:
             error_message: str = (
                 "Internal Server Error - Current state of the state machine is unknown"
@@ -145,7 +147,7 @@ class SchedulingUtilities:
         try:
             self._send_command(
                 StartMissionMessage(mission=deepcopy(mission)),
-                self.queues.api_start_mission,
+                self.api_events.start_mission,
             )
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to start mission in ISAR"
@@ -164,7 +166,7 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.queues.api_pause_mission)
+            return self._send_command(True, self.api_events.pause_mission)
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to pause mission"
             self.logger.error(error_message)
@@ -183,7 +185,7 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.queues.api_resume_mission)
+            return self._send_command(True, self.api_events.resume_mission)
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to resume mission"
             self.logger.error(error_message)
@@ -203,7 +205,7 @@ class SchedulingUtilities:
         """
         try:
             stop_mission_response: ControlMissionResponse = self._send_command(
-                True, self.queues.api_stop_mission
+                True, self.api_events.stop_mission
             )
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to stop mission"

isar/state_machine/state_machine.py

@@ -1,6 +1,5 @@
 import json
 import logging
-import queue
 from collections import deque
 from datetime import datetime, timezone
 from typing import Deque, List, Optional
@@ -15,8 +14,8 @@ from isar.mission_planner.task_selector_interface import (
     TaskSelectorInterface,
     TaskSelectorStop,
 )
-from isar.models.communication.message import StartMissionMessage
-from isar.models.communication.queues.queues import Queues
+from isar.models.communication.queues.events import Events, SharedState
+from isar.models.communication.queues.queue_utils import update_shared_state
 from isar.state_machine.states.blocked_protective_stop import BlockedProtectiveStop
 from isar.state_machine.states.idle import Idle
 from isar.state_machine.states.monitor import Monitor
@@ -38,7 +37,10 @@ from isar.state_machine.transitions.start_mission import (
     set_mission_to_in_progress,
     trigger_start_mission_or_task_event,
 )
-from isar.state_machine.transitions.stop import stop_mission
+from isar.state_machine.transitions.stop import (
+    stop_mission_cleanup,
+    trigger_stop_mission_event,
+)
 from isar.state_machine.transitions.utils import def_transition
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.mission.mission import Mission
@@ -60,7 +62,8 @@ class StateMachine(object):
     @inject
     def __init__(
         self,
-        queues: Queues,
+        events: Events,
+        shared_state: SharedState,
         robot: RobotInterface,
         mqtt_publisher: MqttClientInterface,
         task_selector: TaskSelectorInterface,
@@ -72,8 +75,8 @@ class StateMachine(object):
 
         Parameters
         ----------
-        queues : Queues
-            Queues used for API communication.
+        events : Events
+            Events used for API and robot service communication.
         robot : RobotInterface
             Instance of robot interface.
         mqtt_publisher : MqttClientInterface
@@ -88,7 +91,8 @@ class StateMachine(object):
         """
         self.logger = logging.getLogger("state_machine")
 
-        self.queues: Queues = queues
+        self.events: Events = events
+        self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.mqtt_publisher: Optional[MqttClientInterface] = mqtt_publisher
         self.task_selector: TaskSelectorInterface = task_selector
@@ -134,6 +138,7 @@ class StateMachine(object):
                         self.paused_state,
                     ],
                     "dest": self.stop_state,
+                    "before": def_transition(self, trigger_stop_mission_event),
                 },
                 {
                     "trigger": "request_mission_start",
@@ -176,7 +181,7 @@ class StateMachine(object):
                     "trigger": "mission_stopped",
                     "source": self.stop_state,
                     "dest": self.idle_state,
-                    "before": def_transition(self, stop_mission),
+                    "before": def_transition(self, stop_mission_cleanup),
                 },
                 {
                     "trigger": "robot_turned_offline",
@@ -246,7 +251,7 @@ class StateMachine(object):
     def update_state(self):
         """Updates the current state of the state machine."""
         self.current_state = States(self.state)  # type: ignore
-        self.send_state_status()
+        update_shared_state(self.shared_state.state, self.current_state)
         self._log_state_transition(self.current_state)
         self.logger.info(f"State: {self.current_state}")
         self.publish_status()
@@ -263,68 +268,10 @@ class StateMachine(object):
 
         self.task_selector.initialize(tasks=self.current_mission.tasks)
 
-    def should_start_mission(self) -> Optional[StartMissionMessage]:
-        try:
-            return self.queues.api_start_mission.input.get(block=False)
-        except queue.Empty:
-            return None
-
-    def should_stop_mission(self) -> bool:
-        try:
-            return self.queues.api_stop_mission.input.get(block=False)
-        except queue.Empty:
-            return False
-
-    def should_pause_mission(self) -> bool:
-        try:
-            return self.queues.api_pause_mission.input.get(block=False)
-        except queue.Empty:
-            return False
-
-    def get_task_status_event(self) -> Optional[TaskStatus]:
-        try:
-            return self.queues.robot_task_status.input.get(block=False)
-        except queue.Empty:
-            return None
-
-    def request_task_status(self, task_id: str) -> None:
-        self.queues.state_machine_task_status_request.input.put(task_id)
-
-    def get_mission_started_event(self) -> bool:
-        try:
-            return self.queues.robot_mission_started.input.get(block=False)
-        except queue.Empty:
-            return False
-
-    def get_mission_failed_event(self) -> Optional[ErrorMessage]:
-        try:
-            return self.queues.robot_mission_failed.input.get(block=False)
-        except queue.Empty:
-            return None
-
-    def get_task_failure_event(self) -> Optional[ErrorMessage]:
-        try:
-            return self.queues.robot_task_status_failed.input.get(block=False)
-        except queue.Empty:
-            return None
-
-    def should_resume_mission(self) -> bool:
-        try:
-            return self.queues.api_resume_mission.input.get(block=False)
-        except queue.Empty:
-            return False
-
-    def get_robot_status(self) -> bool:
-        try:
-            return self.queues.robot_status.check()
-        except queue.Empty:
-            return False
-
-    def send_state_status(self) -> None:
-        self.queues.state.update(self.current_state)
-
     def send_task_status(self):
-        self.queues.state_machine_current_task.update(self.current_task)
+        update_shared_state(
+            self.shared_state.state_machine_current_task, self.current_task
+        )
 
     def publish_mission_status(self) -> None:
         if not self.mqtt_publisher:
@@ -437,7 +384,7 @@ class StateMachine(object):
         )
 
     def _queue_empty_response(self) -> None:
-        self.queues.api_stop_mission.output.put(
+        self.events.api_requests.stop_mission.output.put(
             ControlMissionResponse(
                 mission_id="None",
                 mission_status="None",

isar/state_machine/states/blocked_protective_stop.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Optional
 
 from transitions import State
 
+from isar.models.communication.queues.queue_utils import check_shared_state
 from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.mission.status import RobotStatus
 
@@ -19,27 +20,18 @@ class BlockedProtectiveStop(State):
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
         self.robot_status_thread: Optional[ThreadedRequest] = None
+        self.shared_state = self.state_machine.shared_state
 
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
     def stop(self) -> None:
-        if self.robot_status_thread:
-            self.robot_status_thread.wait_for_thread()
-        self.robot_status_thread = None
+        return
 
     def _run(self) -> None:
         while True:
-            if not self.robot_status_thread:
-                self.robot_status_thread = ThreadedRequest(
-                    request_func=self.state_machine.robot.robot_status
-                )
-                self.robot_status_thread.start_thread(
-                    name="State Machine BlockedProtectiveStop Get Robot Status"
-                )
-
-            robot_status = self.state_machine.get_robot_status()
+            robot_status = check_shared_state(self.shared_state.robot_status)
 
             if robot_status == RobotStatus.Offline:
                 transition = self.state_machine.robot_turned_offline  # type: ignore

isar/state_machine/states/idle.py

@@ -1,11 +1,16 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Callable, Optional
+from queue import Queue
+from typing import TYPE_CHECKING, Optional
 
 from transitions import State
 
-from isar.config.settings import settings
 from isar.models.communication.message import StartMissionMessage
+from isar.models.communication.queues.queue_utils import (
+    check_for_event,
+    check_shared_state,
+)
+from isar.models.communication.queues.status_queue import StatusQueue
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -18,6 +23,8 @@ class Idle(State):
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
         self.last_robot_status_poll_time: float = time.time()
+        self.events = self.state_machine.events
+        self.shared_state = self.state_machine.shared_state
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -26,36 +33,49 @@ class Idle(State):
     def stop(self) -> None:
         return
 
-    def _is_ready_to_poll_for_status(self) -> bool:
-        time_since_last_robot_status_poll = (
-            time.time() - self.last_robot_status_poll_time
-        )
-        return (
-            time_since_last_robot_status_poll > settings.ROBOT_API_STATUS_POLL_INTERVAL
-        )
+    def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
+        if check_for_event(event):
+            self.state_machine.stop()  # type: ignore
+            return True
+        return False
+
+    def _check_and_handle_start_mission_event(
+        self, event: Queue[StartMissionMessage]
+    ) -> bool:
+        start_mission: Optional[StartMissionMessage] = check_for_event(event)
+        if start_mission:
+            self.state_machine.start_mission(mission=start_mission.mission)
+            self.state_machine.request_mission_start()  # type: ignore
+            return True
+        return False
+
+    def _check_and_handle_robot_status_event(
+        self, event: StatusQueue[RobotStatus]
+    ) -> bool:
+        robot_status: RobotStatus = check_shared_state(event)
+        if robot_status == RobotStatus.Offline:
+            self.state_machine.robot_turned_offline()  # type: ignore
+            return True
+        elif robot_status == RobotStatus.BlockedProtectiveStop:
+            self.state_machine.robot_protective_stop_engaged()  # type: ignore
+            return True
+        return False
 
     def _run(self) -> None:
-        transition: Callable
         while True:
-            if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop  # type: ignore
+            if self._check_and_handle_stop_mission_event(
+                self.events.api_requests.stop_mission.input
+            ):
                 break
 
-            start_mission: Optional[StartMissionMessage] = (
-                self.state_machine.should_start_mission()
-            )
-            if start_mission:
-                self.state_machine.start_mission(mission=start_mission.mission)
-                transition = self.state_machine.request_mission_start  # type: ignore
+            if self._check_and_handle_start_mission_event(
+                self.events.api_requests.start_mission.input
+            ):
                 break
 
-            robot_status = self.state_machine.get_robot_status()
-            if robot_status == RobotStatus.Offline:
-                transition = self.state_machine.robot_turned_offline  # type: ignore
-                break
-            elif robot_status == RobotStatus.BlockedProtectiveStop:
-                transition = self.state_machine.robot_protective_stop_engaged  # type: ignore
+            if self._check_and_handle_robot_status_event(
+                self.shared_state.robot_status
+            ):
                 break
 
             time.sleep(self.state_machine.sleep_time)
-        transition()