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

isar/state_machine/states/monitor.py

@@ -1,263 +1,153 @@
-import logging
-import time
-from copy import deepcopy
-from typing import TYPE_CHECKING, Callable, Optional, Sequence, Tuple, Union
-
-from injector import inject
-from transitions import State
+from typing import TYPE_CHECKING, Callable, List, Optional
 
+from isar.apis.models.models import ControlMissionResponse
 from isar.config.settings import settings
-from isar.mission_planner.task_selector_interface import TaskSelectorStop
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
-from robot_interface.models.exceptions.robot_exceptions import (
-    ErrorMessage,
-    RobotCommunicationTimeoutException,
-    RobotException,
-    RobotMissionStatusException,
-    RobotRetrieveInspectionException,
-    RobotStepStatusException,
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import (
+    mission_started_event_handler,
+    stop_mission_event_handler,
 )
-from robot_interface.models.inspection.inspection import Inspection
-from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
-from robot_interface.models.mission.step import InspectionStep, Step, StepStatus
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.status import MissionStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class Monitor(State):
-    @inject
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="monitor", on_enter=self.start, on_exit=self.stop)
-        self.state_machine: "StateMachine" = state_machine
-        self.request_status_failure_counter: int = 0
-        self.request_status_failure_counter_limit: int = (
-            settings.REQUEST_STATUS_FAILURE_COUNTER_LIMIT
-        )
-
-        self.logger = logging.getLogger("state_machine")
-        self.step_status_thread: Optional[ThreadedRequest] = None
+class Monitor(EventHandlerBase):
 
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
 
-    def stop(self) -> None:
-        if self.step_status_thread:
-            self.step_status_thread.wait_for_thread()
-        self.step_status_thread = None
+        def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
 
-    def _run(self) -> None:
-        transition: Callable
-        while True:
-            if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop  # type: ignore
-                break
-
-            if self.state_machine.should_pause_mission():
-                transition = self.state_machine.pause  # type: ignore
-                break
-
-            if not self.step_status_thread:
-                self._run_get_status_thread(
-                    status_function=self.state_machine.robot.step_status,
-                    thread_name="State Machine Monitor Get Step Status",
-                )
-            try:
-                status: Union[StepStatus, MissionStatus] = (
-                    self.step_status_thread.get_output()
-                )
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except RobotCommunicationTimeoutException as e:
-                self.state_machine.current_mission.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                )
-                self.step_status_thread = None
-                self.request_status_failure_counter += 1
-                self.logger.warning(
-                    f"Monitoring step {self.state_machine.current_step.id} failed #: "
-                    f"{self.request_status_failure_counter} failed because: {e.error_description}"
-                )
-
-                if (
-                    self.request_status_failure_counter
-                    >= self.request_status_failure_counter_limit
-                ):
-                    self.state_machine.current_step.error_message = ErrorMessage(
-                        error_reason=e.error_reason,
-                        error_description=e.error_description,
-                    )
-                    self.logger.error(
-                        f"Step will be cancelled after failing to get step status "
-                        f"{self.request_status_failure_counter} times because: "
-                        f"{e.error_description}"
-                    )
-                    status = StepStatus.Failed
-                else:
-                    continue
-
-            except RobotStepStatusException as e:
-                self.state_machine.current_step.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                )
-                self.logger.error(
-                    f"Monitoring step {self.state_machine.current_step.id[:8]} failed "
-                    f"because: {e.error_description}"
-                )
-                status = StepStatus.Failed
-
-            except RobotMissionStatusException as e:
-                self.state_machine.current_mission.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                )
-                self.logger.error(
-                    f"Monitoring mission {self.state_machine.current_mission.id} "
-                    f"failed because: {e.error_description}"
-                )
-                status = MissionStatus.Failed
-
-            except RobotException as e:
-                self._set_error_message(e)
-                status = StepStatus.Failed
-
-                self.logger.error(
-                    f"Retrieving the status failed because: {e.error_description}"
-                )
-
-            if isinstance(status, StepStatus):
-                self.state_machine.current_step.status = status
-            elif isinstance(status, MissionStatus):
-                self.state_machine.current_mission.status = status
-                self.logger.error(
-                    f"Received an invalid status update when monitoring mission. Only StepStatus is expected."
-                )
-
-            if self._should_upload_inspections():
-                get_inspections_thread = ThreadedRequest(
-                    self._queue_inspections_for_upload
-                )
-                get_inspections_thread.start_thread(
-                    deepcopy(self.state_machine.current_mission),
-                    deepcopy(self.state_machine.current_step),
-                    name="State Machine Get Inspections",
-                )
-
-            if self.state_machine.stepwise_mission:
-                if self._step_finished(self.state_machine.current_step):
-                    transition = self.state_machine.step_finished  # type: ignore
-                    break
-            else:
-                if isinstance(status, StepStatus):
-                    if self._step_finished(self.state_machine.current_step):
-                        self.state_machine.update_current_task()
-                        if self.state_machine.current_task == None:
-                            transition = self.state_machine.full_mission_finished  # type: ignore
-                            break
-                        self.state_machine.update_current_step()
-                        self.state_machine.current_task.update_task_status()
-                    else:  # If not all steps are done
-                        self.state_machine.current_task.status = TaskStatus.InProgress
-
-                    self.state_machine.publish_task_status(
-                        self.state_machine.current_task
-                    )
-                    if self.state_machine.current_task.status == TaskStatus.Successful:
-                        try:
-                            self.state_machine.current_task = (
-                                self.state_machine.task_selector.next_task()
-                            )
-                        except TaskSelectorStop:
-                            # Indicates that all tasks are finished
-                            self.state_machine.current_task = None
-                            transition = self.state_machine.full_mission_finished  # type: ignore
-                            break
-                        self.state_machine.update_current_step()
-                elif self._mission_finished(self.state_machine.current_mission):
-                    transition = self.state_machine.full_mission_finished  # type: ignore
-                    break
-
-            self.step_status_thread = None
-            time.sleep(self.state_machine.sleep_time)
-
-        transition()
-
-    def _run_get_status_thread(
-        self, status_function: Callable, thread_name: str
-    ) -> None:
-        self.step_status_thread = ThreadedRequest(request_func=status_function)
-        self.step_status_thread.start_thread(name=thread_name)
-
-    def _queue_inspections_for_upload(
-        self, mission: Mission, current_step: InspectionStep
-    ) -> None:
-        try:
-            inspections: Sequence[Inspection] = (
-                self.state_machine.robot.get_inspections(step=current_step)
-            )
-
-        except (RobotRetrieveInspectionException, RobotException) as e:
-            self._set_error_message(e)
-            self.logger.error(
-                f"Failed to retrieve inspections because: {e.error_description}"
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
+                ControlMissionResponse(success=True)
             )
-            return
-
-        if not inspections:
-            self.logger.warning(
-                f"No inspection data retrieved for step {str(current_step.id)[:8]}"
-            )
-
-        for inspection in inspections:
-            inspection.metadata.tag_id = current_step.tag_id
-
-            message: Tuple[Inspection, Mission] = (
-                inspection,
-                mission,
+            state_machine.events.state_machine_events.pause_mission.trigger_event(True)
+            return state_machine.pause  # type: ignore
+
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
+                return None
+
+            state_machine.logger.warning(
+                "Cancelling current mission due to low battery"
             )
-            self.state_machine.queues.upload_queue.put(message)
-            self.logger.info(f"Inspection: {str(inspection.id)[:8]} queued for upload")
-
-    def _step_finished(self, step: Step) -> bool:
-        finished: bool = False
-        if step.status == StepStatus.Failed:
-            self.logger.warning(
-                f"Step: {str(step.id)[:8]} was reported as failed by the robot"
+            state_machine.events.state_machine_events.stop_mission.trigger_event(True)
+            return state_machine.stop_go_to_recharge  # type: ignore
+
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if not should_lockdown:
+                return None
+
+            state_machine.logger.warning(
+                "Cancelling current mission due to robot going to lockdown"
             )
-            finished = True
-        elif step.status == StepStatus.Successful:
-            self.logger.info(
-                f"{type(step).__name__} step: {str(step.id)[:8]} completed"
+            state_machine.events.state_machine_events.stop_mission.trigger_event(True)
+            return state_machine.stop_go_to_lockdown  # type: ignore
+
+        def _mission_status_event_handler(
+            event: Event[MissionStatus],
+        ) -> Optional[Callable]:
+            mission_status: Optional[MissionStatus] = event.consume_event()
+            if mission_status:
+                if mission_status not in [
+                    MissionStatus.InProgress,
+                    MissionStatus.NotStarted,
+                    MissionStatus.Paused,
+                ]:
+                    state_machine.logger.info(
+                        f"Mission completed with status {mission_status}"
+                    )
+                    state_machine.print_transitions()
+                    return state_machine.mission_finished  # type: ignore
+            return None
+
+        def _set_maintenance_mode_event_handler(event: Event[bool]):
+            should_set_maintenande_mode: bool = event.consume_event()
+            if should_set_maintenande_mode:
+                state_machine.logger.warning(
+                    "Cancelling current mission due to robot going to maintenance mode"
+                )
+                state_machine.events.state_machine_events.stop_mission.trigger_event(
+                    True
+                )
+                return state_machine.stop_due_to_maintenance  # type: ignore
+            return None
+
+        def _mission_failed_event_handler(
+            event: Event[Optional[ErrorMessage]],
+        ) -> Optional[Callable]:
+            mission_failed: Optional[ErrorMessage] = event.consume_event()
+            if mission_failed is None:
+                return None
+
+            state_machine.logger.warning(
+                f"Failed to initiate mission because: "
+                f"{mission_failed.error_description}"
             )
-            finished = True
-        return finished
-
-    @staticmethod
-    def _mission_finished(mission: Mission) -> bool:
-        if (
-            mission.status == MissionStatus.Successful
-            or mission.status == MissionStatus.PartiallySuccessful
-            or mission.status == MissionStatus.Failed
-        ):
-            return True
-        return False
-
-    def _should_upload_inspections(self) -> bool:
-        step: Step = self.state_machine.current_step
-        return (
-            self._step_finished(step)
-            and step.status == StepStatus.Successful
-            and isinstance(step, InspectionStep)
-        )
-
-    def _set_error_message(self, e: RobotException) -> None:
-        error_message: ErrorMessage = ErrorMessage(
-            error_reason=e.error_reason, error_description=e.error_description
+            return state_machine.mission_failed_to_start  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.stop_mission.request,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="pause_mission_event",
+                event=events.api_requests.pause_mission.request,
+                handler=_pause_mission_event_handler,
+            ),
+            EventHandlerMapping(
+                name="mission_started_event",
+                event=events.robot_service_events.mission_started,
+                handler=lambda event: mission_started_event_handler(
+                    state_machine, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="mission_failed_event",
+                event=events.robot_service_events.mission_failed,
+                handler=_mission_failed_event_handler,
+            ),
+            EventHandlerMapping(
+                name="mission_status_event",
+                event=events.robot_service_events.mission_status_updated,
+                handler=_mission_status_event_handler,
+            ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
+            EventHandlerMapping(
+                name="set_maintenance_mode",
+                event=events.api_requests.set_maintenance_mode.request,
+                handler=_set_maintenance_mode_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="monitor",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
         )
-        self.state_machine.current_step.error_message = error_message

isar/state_machine/states/offline.py

@@ -1,62 +1,60 @@
-import logging
-import time
-from typing import TYPE_CHECKING, Optional
-
-from transitions import State
-
-from isar.config.settings import settings
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
-from robot_interface.models.exceptions.robot_exceptions import RobotException
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import MaintenanceResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class Offline(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="offline", on_enter=self.start, on_exit=self.stop)
-        self.state_machine: "StateMachine" = state_machine
-        self.logger = logging.getLogger("state_machine")
-        self.robot_status_thread: Optional[ThreadedRequest] = None
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
+class Offline(EventHandlerBase):
 
-    def stop(self) -> None:
-        if self.robot_status_thread:
-            self.robot_status_thread.wait_for_thread()
-        self.robot_status_thread = None
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
 
-    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 Offline Get Robot Status"
+        def _set_maintenance_mode_event_handler(event: Event[bool]):
+            should_set_maintenande_mode: bool = event.consume_event()
+            if should_set_maintenande_mode:
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(is_maintenance_mode=True)
                 )
-
-            try:
-                robot_status: RobotStatus = self.robot_status_thread.get_output()
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except (RobotException,) as e:
-                self.logger.error(
-                    f"Failed to get robot status because: {e.error_description}"
-                )
-
-            if robot_status != RobotStatus.Offline:
-                transition = self.state_machine.robot_turned_online  # type: ignore
-                break
-
-            time.sleep(settings.ROBOT_API_STATUS_POLL_INTERVAL)
-
-        transition()
+                return state_machine.set_maintenance_mode  # type: ignore
+            return None
+
+        def _robot_status_event_handler(
+            status_changed_event: Event[bool],
+        ) -> Optional[Callable]:
+            has_changed = status_changed_event.consume_event()
+            if not has_changed:
+                return None
+            robot_status: Optional[RobotStatus] = shared_state.robot_status.check()
+            if robot_status == RobotStatus.Offline:
+                return None
+            elif robot_status == RobotStatus.Home:
+                return state_machine.robot_status_home  # type: ignore
+            elif robot_status == RobotStatus.Available:
+                return state_machine.robot_status_available  # type: ignore
+            elif robot_status == RobotStatus.BlockedProtectiveStop:
+                return state_machine.robot_status_blocked_protective_stop  # type: ignore
+            return state_machine.robot_status_unknown  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=events.robot_service_events.robot_status_changed,
+                handler=_robot_status_event_handler,
+            ),
+            EventHandlerMapping(
+                name="set_maintenance_mode",
+                event=events.api_requests.set_maintenance_mode.request,
+                handler=_set_maintenance_mode_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="offline",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/paused.py

@@ -1,34 +1,103 @@
-import logging
-import time
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Callable, List, Optional
 
-from transitions import State
+from isar.config.settings import settings
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import stop_mission_event_handler
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class Paused(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="paused", on_enter=self.start)
-        self.state_machine: "StateMachine" = state_machine
-        self.logger = logging.getLogger("state_machine")
+class Paused(EventHandlerBase):
 
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
 
-    def _run(self) -> None:
-        transition: Callable
-        while True:
-            if self.state_machine.should_stop_mission():
-                transition = self.state_machine.mission_stopped  # type: ignore
-                break
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
+                return None
 
-            if self.state_machine.should_resume_mission():
-                transition = self.state_machine.resume  # type: ignore
-                break
+            state_machine.publish_mission_aborted(
+                "Robot battery too low to continue mission", True
+            )
+            state_machine.print_transitions()
+            state_machine.logger.warning(
+                "Cancelling current mission due to low battery"
+            )
+            state_machine.events.state_machine_events.stop_mission.trigger_event(True)
+            return state_machine.stop  # type: ignore
 
-            time.sleep(self.state_machine.sleep_time)
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if not should_lockdown:
+                return None
 
-        transition()
+            state_machine.print_transitions()
+            state_machine.logger.warning(
+                "Cancelling current mission due to robot going to lockdown"
+            )
+            state_machine.events.state_machine_events.stop_mission.trigger_event(True)
+            return state_machine.stop_go_to_lockdown  # type: ignore
+
+        def _set_maintenance_mode_event_handler(event: Event[bool]):
+            should_set_maintenande_mode: bool = event.consume_event()
+            if should_set_maintenande_mode:
+                state_machine.logger.warning(
+                    "Cancelling current mission due to robot going to maintenance mode"
+                )
+                state_machine.events.state_machine_events.stop_mission.trigger_event(
+                    True
+                )
+                return state_machine.stop_due_to_maintenance  # type: ignore
+            return None
+
+        def _resume_misison_event_handler(event: Event[bool]):
+            if event.consume_event():
+                state_machine.events.state_machine_events.resume_mission.trigger_event(
+                    True
+                )
+                return state_machine.resume  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.stop_mission.request,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="resume_mission_event",
+                event=events.api_requests.resume_mission.request,
+                handler=_resume_misison_event_handler,
+            ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
+            EventHandlerMapping(
+                name="set_maintenance_mode",
+                event=events.api_requests.set_maintenance_mode.request,
+                handler=_set_maintenance_mode_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="paused",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )