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

isar/state_machine/states/stopping.py

@@ -0,0 +1,69 @@
+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)
+            )
+
+            if state_machine.shared_state.mission_id.check() is None:
+                reason: str = (
+                    "Robot was busy and mission stopped but no ongoing mission found in shared state."
+                )
+                state_machine.logger.warning(reason)
+                state_machine.publish_mission_aborted(reason, False)
+
+            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,
+        )

isar/state_machine/states/stopping_go_to_lockdown.py

@@ -0,0 +1,60 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import LockdownResponse
+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 StoppingGoToLockdown(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
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(
+                    lockdown_started=False,
+                    failure_reason="Failed to stop ongoing mission",
+                )
+            )
+            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.publish_mission_aborted("Robot being sent to lockdown", True)
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            state_machine.start_return_home_mission()
+            return state_machine.start_lockdown_mission_monitoring  # 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_go_to_lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/stopping_go_to_recharge.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+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 StoppingGoToRecharge(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
+
+            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.publish_mission_aborted(
+                "Robot battery too low to continue mission", True
+            )
+            state_machine.start_return_home_mission()
+            return state_machine.start_recharging_mission_monitoring  # 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_go_to_recharge",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/stopping_paused_mission.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING, List
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.state_machine.utils.common_event_handlers import (
+    failed_stop_event_handler,
+    successful_stop_event_handler,
+)
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingPausedMission(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=lambda event: failed_stop_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=lambda event: successful_stop_event_handler(
+                    state_machine, event
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_paused_mission",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/stopping_paused_return_home.py

@@ -0,0 +1,59 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from isar.apis.models.models import MissionStartResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.state_machine.utils.common_event_handlers import (
+    failed_stop_return_home_event_handler,
+    successful_stop_return_home_event_handler,
+)
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingPausedReturnHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        self.mission: Optional[Mission] = None
+
+        def _respond_to_start_mission_request():
+            self.mission = (
+                state_machine.events.api_requests.start_mission.request.consume_event()
+            )
+            if not self.mission:
+                state_machine.logger.error(
+                    "Reached stopping paused return home without a mission request"
+                )
+            else:
+                response = MissionStartResponse(
+                    mission_id=self.mission.id,
+                    mission_started=True,
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    response
+                )
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=lambda event: failed_stop_return_home_event_handler(
+                    state_machine, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=lambda event: successful_stop_return_home_event_handler(
+                    state_machine, event, self.mission
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_paused_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+            on_entry=_respond_to_start_mission_request,
+        )

isar/state_machine/states/stopping_return_home.py

@@ -0,0 +1,59 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from isar.apis.models.models import MissionStartResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.state_machine.utils.common_event_handlers import (
+    failed_stop_return_home_event_handler,
+    successful_stop_return_home_event_handler,
+)
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingReturnHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        self.mission: Optional[Mission] = None
+
+        def _respond_to_start_mission_request():
+            self.mission = (
+                state_machine.events.api_requests.start_mission.request.consume_event()
+            )
+            if not self.mission:
+                state_machine.logger.error(
+                    "Reached stopping return home without a mission request"
+                )
+            else:
+                response = MissionStartResponse(
+                    mission_id=self.mission.id,
+                    mission_started=True,
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    response
+                )
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=lambda event: failed_stop_return_home_event_handler(
+                    state_machine, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=lambda event: successful_stop_return_home_event_handler(
+                    state_machine, event, self.mission
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+            on_entry=_respond_to_start_mission_request,
+        )

isar/state_machine/states/unknown_status.py

@@ -0,0 +1,74 @@
+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 isar.state_machine.utils.common_event_handlers import stop_mission_event_handler
+from robot_interface.models.mission.status import RobotStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class UnknownStatus(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        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
+
+        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.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.Offline:
+                return state_machine.robot_status_offline  # type: ignore
+            elif robot_status == RobotStatus.BlockedProtectiveStop:
+                return state_machine.robot_status_blocked_protective_stop  # type: ignore
+            elif robot_status == RobotStatus.Busy:
+                return state_machine.robot_status_busy  # type: ignore
+            return None
+
+        def _reset_status_check():
+            # Ensures that we will check the status immediately instead of waiting for it to change
+            self.events.robot_service_events.robot_status_changed.trigger_event(True)
+
+        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="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="unknown_status",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+            on_entry=_reset_status_check,
+        )

isar/state_machine/states_enum.py

@@ -2,14 +2,32 @@ from enum import Enum
 
 
 class States(str, Enum):
-    Off = "off"
-    Idle = "idle"
-    Initiate = "initiate"
-    Initialize = "initialize"
     Monitor = "monitor"
+    ReturningHome = "returning_home"
+    Stopping = "stopping"
+    StoppingReturnHome = "stopping_return_home"
     Paused = "paused"
-    Stop = "stop"
+    Pausing = "pausing"
+    Resuming = "resuming"
+    PausingReturnHome = "pausing_return_home"
+    ResumingReturnHome = "resuming_return_home"
+    ReturnHomePaused = "return_home_paused"
+    AwaitNextMission = "await_next_mission"
+    Home = "home"
     Offline = "offline"
+    BlockedProtectiveStop = "blocked_protective_stop"
+    UnknownStatus = "unknown_status"
+    InterventionNeeded = "intervention_needed"
+    Recharging = "recharging"
+    StoppingGoToLockdown = "stopping_go_to_lockdown"
+    GoingToLockdown = "going_to_lockdown"
+    Lockdown = "lockdown"
+    GoingToRecharging = "going_to_recharging"
+    StoppingGoToRecharge = "stopping_go_to_recharge"
+    Maintenance = "maintenance"
+    StoppingDueToMaintenance = "stopping_due_to_maintenance"
+    StoppingPausedMission = "stopping_paused_mission"
+    StoppingPausedReturnHome = "stopping_paused_return_home"
 
     def __repr__(self):
         return self.value