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

isar/state_machine/states/recharging.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from isar.apis.models.models import LockdownResponse, MaintenanceResponse
+from isar.config.settings import settings
+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 Recharging(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        shared_state = state_machine.shared_state
+        events = state_machine.events
+
+        def robot_battery_level_updated_handler(event: Event[float]):
+            battery_level: float = event.check()
+            if battery_level < settings.ROBOT_BATTERY_RECHARGE_THRESHOLD:
+                return None
+
+            return state_machine.robot_recharged  # type: ignore
+
+        def robot_offline_handler(event: Event[RobotStatus]):
+            robot_status: Optional[RobotStatus] = event.check()
+
+            if robot_status is None:
+                return None
+
+            if robot_status == RobotStatus.Offline:
+                return state_machine.robot_status_offline  # type: ignore
+
+        def _send_to_lockdown_event_handler(event: Event[bool]):
+            should_lockdown: bool = event.consume_event()
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.reached_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:
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(is_maintenance_mode=True)
+                )
+                return state_machine.set_maintenance_mode  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="robot_offline_event",
+                event=shared_state.robot_status,
+                handler=robot_offline_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="recharging",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/resuming.py

@@ -0,0 +1,57 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import ControlMissionResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Resuming(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _failed_resume_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+
+            if error_message is None:
+                return None
+
+            state_machine.events.api_requests.resume_mission.response.trigger_event(
+                ControlMissionResponse(success=False)
+            )
+
+            return state_machine.mission_resuming_failed  # type: ignore
+
+        def _successful_resume_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
+
+            state_machine.events.api_requests.resume_mission.response.trigger_event(
+                ControlMissionResponse(success=True)
+            )
+
+            return state_machine.mission_resumed  # type:ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_resume_event",
+                event=events.robot_service_events.mission_failed_to_resume,
+                handler=_failed_resume_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_resume_event",
+                event=events.robot_service_events.mission_successfully_resumed,
+                handler=_successful_resume_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="resuming",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/resuming_return_home.py

@@ -0,0 +1,64 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import ControlMissionResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class ResumingReturnHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _failed_resume_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+
+            if error_message is None:
+                return None
+
+            state_machine.events.api_requests.resume_mission.response.trigger_event(
+                ControlMissionResponse(
+                    success=False,
+                    failure_reason=(
+                        getattr(error_message, "error_reason", str(error_message))
+                        if hasattr(error_message, "error_reason")
+                        else str(error_message)
+                    ),
+                )
+            )
+
+            return state_machine.return_home_mission_resuming_failed  # type: ignore
+
+        def _successful_resume_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
+
+            state_machine.events.api_requests.resume_mission.response.trigger_event(
+                ControlMissionResponse(success=True)
+            )
+
+            return state_machine.return_home_mission_resumed  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_resume_event",
+                event=events.robot_service_events.mission_failed_to_resume,
+                handler=_failed_resume_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_resume_event",
+                event=events.robot_service_events.mission_successfully_resumed,
+                handler=_successful_resume_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="resuming_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/return_home_paused.py

@@ -0,0 +1,109 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import LockdownResponse, MissionStartResponse
+from isar.config.settings import settings
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class ReturnHomePaused(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        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.events.state_machine_events.resume_mission.trigger_event(True)
+            return state_machine.resume  # type: ignore
+
+        def _start_mission_event_handler(
+            event: Event[Mission],
+        ) -> Optional[Callable]:
+            if not event.has_event():
+                return None
+
+            if not state_machine.battery_level_is_above_mission_start_threshold():
+                state_machine.events.api_requests.start_mission.request.consume_event()
+                response = MissionStartResponse(
+                    mission_id=None,
+                    mission_started=False,
+                    mission_not_started_reason="Robot battery too low",
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    response
+                )
+                return None
+            state_machine.events.state_machine_events.stop_mission.trigger_event(True)
+            return state_machine.stop_return_home  # 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
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            state_machine.events.state_machine_events.resume_mission.trigger_event(True)
+            return state_machine.resume_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
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="resume_return_home_event",
+                event=events.api_requests.resume_mission.request,
+                handler=lambda event: state_machine.resume if event.consume_event() else None,  # type: ignore
+            ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.request,
+                handler=_start_mission_event_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="return_home_paused",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/returning_home.py

@@ -0,0 +1,217 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import (
+    ControlMissionResponse,
+    LockdownResponse,
+    MissionStartResponse,
+)
+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 mission_started_event_handler
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import MissionStatus
+from robot_interface.models.mission.task import ReturnToHome
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class ReturningHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        self.failed_return_home_attempts: int = 0
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
+
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
+                ControlMissionResponse(success=True)
+            )
+            state_machine.events.state_machine_events.pause_mission.trigger_event(True)
+            return state_machine.pause_return_home  # type: ignore
+
+        def _start_mission_event_handler(
+            event: Event[Mission],
+        ) -> Optional[Callable]:
+            if not event.has_event():
+                return None
+
+            if not state_machine.battery_level_is_above_mission_start_threshold():
+                state_machine.events.api_requests.start_mission.request.consume_event()
+                response = MissionStartResponse(
+                    mission_id=None,
+                    mission_started=False,
+                    mission_not_started_reason="Robot battery too low",
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    response
+                )
+                return None
+
+            state_machine.events.state_machine_events.stop_mission.trigger_event(True)
+            return state_machine.stop_return_home  # type: ignore
+
+        def _mission_status_event_handler(
+            event: Event[MissionStatus],
+        ) -> Optional[Callable]:
+            mission_status: Optional[MissionStatus] = event.consume_event()
+
+            if mission_status and mission_status not in [
+                MissionStatus.InProgress,
+                MissionStatus.NotStarted,
+                MissionStatus.Paused,
+            ]:
+                if mission_status != MissionStatus.Successful:
+                    self.failed_return_home_attempts += 1
+                    if (
+                        self.failed_return_home_attempts
+                        >= settings.RETURN_HOME_RETRY_LIMIT
+                    ):
+                        state_machine.logger.warning(
+                            f"Failed to return home after {self.failed_return_home_attempts} attempts."
+                        )
+                        state_machine.publish_intervention_needed(
+                            error_message=f"Return home failed after {self.failed_return_home_attempts} attempts."
+                        )
+                        state_machine.print_transitions()
+                        return state_machine.return_home_failed  # type: ignore
+                    else:
+                        state_machine.start_mission(
+                            Mission(
+                                tasks=[ReturnToHome()],
+                                name="Return Home",
+                            )
+                        )
+                        return None
+
+                # This clears the current robot status value, so we don't read an outdated value
+                state_machine.events.robot_service_events.robot_status_changed.clear_event()
+                return state_machine.returned_home  # type: ignore
+            return None
+
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.go_to_lockdown  # type: ignore
+
+        def _mission_failed_event_handler(
+            event: Event[Optional[ErrorMessage]],
+        ) -> Optional[Callable]:
+            mission_failed: Optional[ErrorMessage] = event.consume_event()
+            if mission_failed is not None:
+                state_machine.logger.warning(
+                    f"Failed to initiate return home because: "
+                    f"{mission_failed.error_description}"
+                )
+                state_machine.publish_intervention_needed(
+                    error_message="Return home failed to initiate."
+                )
+                state_machine.print_transitions()
+                return state_machine.return_home_failed  # 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 _robot_already_home_event_handler(event: Event[bool]):
+            already_home: bool = event.consume_event()
+            if already_home:
+                state_machine.logger.info(
+                    "Robot reported that it is already home. "
+                    "Assuming return home mission successful without running."
+                )
+                return state_machine.returned_home  # type: ignore
+            return None
+
+        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
+
+            return state_machine.go_to_recharging  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            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="start_mission_event",
+                event=events.api_requests.start_mission.request,
+                handler=_start_mission_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,
+            ),
+            EventHandlerMapping(
+                name="robot_already_home",
+                event=events.robot_service_events.robot_already_home,
+                handler=_robot_already_home_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="returning_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+            on_transition=self._reset_failure_counter,
+            on_entry=self._reset_failure_counter,
+        )
+
+    def _reset_failure_counter(self):
+        self.failed_return_home_attempts = 0

isar/state_machine/states/stopping.py

@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import ControlMissionResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Stopping(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _failed_stop_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+            if error_message is None:
+                return None
+
+            stopped_mission_response: ControlMissionResponse = ControlMissionResponse(
+                success=False, failure_reason="ISAR failed to stop mission"
+            )
+            state_machine.events.api_requests.stop_mission.response.trigger_event(
+                stopped_mission_response
+            )
+            return state_machine.mission_stopping_failed  # type: ignore
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
+
+            state_machine.events.api_requests.stop_mission.response.trigger_event(
+                ControlMissionResponse(success=True)
+            )
+            state_machine.print_transitions()
+            if not state_machine.battery_level_is_above_mission_start_threshold():
+                state_machine.start_return_home_mission()
+                return state_machine.start_return_home_monitoring  # type: ignore
+            return state_machine.mission_stopped  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=_failed_stop_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=_successful_stop_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="stopping",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/stopping_due_to_maintenance.py

@@ -0,0 +1,61 @@
+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.exceptions.robot_exceptions import ErrorMessage
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingDueToMaintenance(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _failed_stop_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+            if error_message is not None:
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(
+                        is_maintenance_mode=False,
+                        failure_reason="Failed to stop ongoing mission",
+                    )
+                )
+                state_machine.logger.error(
+                    f"Failed to stop mission in StoppingDueToMaintenance. Message: {error_message.error_description}"
+                )
+                return state_machine.mission_stopping_failed  # type: ignore
+            return None
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+                state_machine.publish_mission_aborted(
+                    "Mission aborted, robot being sent to maintenance", True
+                )
+                events.api_requests.set_maintenance_mode.response.trigger_event(
+                    MaintenanceResponse(is_maintenance_mode=True)
+                )
+                return state_machine.mission_stopped  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=_failed_stop_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=_successful_stop_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_due_to_maintenance",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )