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

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_return_home.py

@@ -0,0 +1,77 @@
+import logging
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import MissionStartResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+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"):
+        logger = logging.getLogger("state_machine")
+        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
+
+            logger.warning(error_message.error_description)
+            mission: Mission = (
+                state_machine.events.api_requests.start_mission.request.consume_event()
+            )
+            state_machine.events.api_requests.start_mission.response.trigger_event(
+                MissionStartResponse(
+                    mission_id=mission.id,
+                    mission_started=False,
+                    mission_not_started_reason="Failed to cancel return home mission",
+                )
+            )
+            return state_machine.return_home_mission_stopping_failed  # type: ignore
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
+
+            mission: Mission = (
+                state_machine.events.api_requests.start_mission.request.consume_event()
+            )
+
+            if mission:
+                state_machine.start_mission(mission=mission)
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    MissionStartResponse(mission_started=True)
+                )
+                return state_machine.start_mission_monitoring  # type: ignore
+
+            state_machine.logger.error(
+                "Stopped return home without a new mission to start"
+            )
+            state_machine.start_return_home_mission()
+            return state_machine.start_return_home_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_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/unknown_status.py

@@ -0,0 +1,72 @@
+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
+            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,13 +2,30 @@ 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"
 
     def __repr__(self):
         return self.value

isar/state_machine/transitions/mission.py

@@ -0,0 +1,192 @@
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
+    mission_transitions: List[dict] = [
+        {
+            "trigger": "pause",
+            "source": state_machine.monitor_state,
+            "dest": state_machine.pausing_state,
+        },
+        {
+            "trigger": "mission_paused",
+            "source": state_machine.pausing_state,
+            "dest": state_machine.paused_state,
+        },
+        {
+            "trigger": "mission_pausing_failed",
+            "source": state_machine.pausing_state,
+            "dest": state_machine.monitor_state,
+        },
+        {
+            "trigger": "pause_return_home",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.pausing_return_home_state,
+        },
+        {
+            "trigger": "return_home_mission_pausing_failed",
+            "source": state_machine.pausing_return_home_state,
+            "dest": state_machine.returning_home_state,
+        },
+        {
+            "trigger": "return_home_mission_paused",
+            "source": state_machine.pausing_return_home_state,
+            "dest": state_machine.return_home_paused_state,
+        },
+        {
+            "trigger": "resume",
+            "source": state_machine.paused_state,
+            "dest": state_machine.resuming_state,
+        },
+        {
+            "trigger": "mission_resumed",
+            "source": state_machine.resuming_state,
+            "dest": state_machine.monitor_state,
+        },
+        {
+            "trigger": "mission_resuming_failed",
+            "source": state_machine.resuming_state,
+            "dest": state_machine.await_next_mission_state,
+        },
+        {
+            "trigger": "resume",
+            "source": state_machine.return_home_paused_state,
+            "dest": state_machine.resuming_return_home_state,
+        },
+        {
+            "trigger": "return_home_mission_resumed",
+            "source": state_machine.resuming_return_home_state,
+            "dest": state_machine.returning_home_state,
+        },
+        {
+            "trigger": "return_home_mission_resuming_failed",
+            "source": state_machine.resuming_return_home_state,
+            "dest": state_machine.await_next_mission_state,
+        },
+        {
+            "trigger": "resume_lockdown",
+            "source": state_machine.return_home_paused_state,
+            "dest": state_machine.going_to_lockdown_state,
+        },
+        {
+            "trigger": "stop",
+            "source": [
+                state_machine.await_next_mission_state,
+                state_machine.monitor_state,
+                state_machine.paused_state,
+            ],
+            "dest": state_machine.stopping_state,
+        },
+        {
+            "trigger": "stop_go_to_lockdown",
+            "source": [
+                state_machine.monitor_state,
+                state_machine.paused_state,
+            ],
+            "dest": state_machine.stopping_go_to_lockdown_state,
+        },
+        {
+            "trigger": "stop_go_to_recharge",
+            "source": state_machine.monitor_state,
+            "dest": state_machine.stopping_go_to_recharge_state,
+        },
+        {
+            "trigger": "stop_due_to_maintenance",
+            "source": [
+                state_machine.monitor_state,
+                state_machine.paused_state,
+                # state_machine.pausing_return_home_state,  # Not neccessary since it will become paused and then the maintenance can trigger.
+                # state_machine.pausing_state,              # Not neccessary since it will become paused and then the maintenance can trigger.
+                state_machine.return_home_paused_state,
+                state_machine.returning_home_state,
+                # state_machine.stopping_return_home_state, # Not neccessary since it will become monitor and then the maintenance can trigger.
+                # state_machine.stopping_state,             # Not neccessary since it will become await next mission and then the maintenance can trigger.
+            ],
+            "dest": state_machine.stopping_due_to_maintenance_state,
+        },
+        {
+            "trigger": "stop_return_home",
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.return_home_paused_state,
+            ],
+            "dest": state_machine.stopping_return_home_state,
+        },
+        {
+            "trigger": "mission_stopped",
+            "source": state_machine.stopping_state,
+            "dest": state_machine.await_next_mission_state,
+        },
+        {
+            "trigger": "mission_stopped",
+            "source": state_machine.stopping_go_to_lockdown_state,
+            "dest": state_machine.going_to_lockdown_state,
+        },
+        {
+            "trigger": "mission_stopped",
+            "source": state_machine.stopping_due_to_maintenance_state,
+            "dest": state_machine.maintenance_state,
+        },
+        {
+            "trigger": "mission_stopping_failed",
+            "source": [
+                state_machine.stopping_go_to_lockdown_state,
+                state_machine.stopping_go_to_recharge_state,
+                state_machine.stopping_state,
+            ],
+            "dest": state_machine.monitor_state,
+        },
+        {
+            "trigger": "mission_stopping_failed",
+            "source": state_machine.stopping_due_to_maintenance_state,
+            "dest": state_machine.unknown_status_state,  # We do not know if we need to go to monitor or return_home state
+        },
+        {
+            "trigger": "return_home_mission_stopping_failed",
+            "source": state_machine.stopping_return_home_state,
+            "dest": state_machine.returning_home_state,
+        },
+        {
+            "trigger": "start_mission_monitoring",
+            "source": [
+                state_machine.await_next_mission_state,
+                state_machine.home_state,
+                state_machine.stopping_return_home_state,
+            ],
+            "dest": state_machine.monitor_state,
+        },
+        {
+            "trigger": "mission_failed_to_start",
+            "source": state_machine.monitor_state,
+            "dest": state_machine.await_next_mission_state,
+        },
+        {
+            "trigger": "mission_finished",
+            "source": state_machine.monitor_state,
+            "dest": state_machine.await_next_mission_state,
+        },
+        {
+            "trigger": "set_maintenance_mode",
+            "source": [
+                state_machine.await_next_mission_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.home_state,
+                state_machine.intervention_needed_state,
+                state_machine.offline_state,
+                state_machine.recharging_state,
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.maintenance_state,
+        },
+        {
+            "trigger": "release_from_maintenance",
+            "source": [
+                state_machine.maintenance_state,
+            ],
+            "dest": state_machine.home_state,
+        },
+    ]
+    return mission_transitions

isar/state_machine/transitions/return_home.py

@@ -0,0 +1,106 @@
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
+    return_home_transitions: List[dict] = [
+        {
+            "trigger": "start_return_home_monitoring",
+            "source": [
+                state_machine.await_next_mission_state,
+                state_machine.home_state,
+                state_machine.intervention_needed_state,
+                state_machine.monitor_state,
+                state_machine.stopping_state,
+                state_machine.stopping_return_home_state,
+            ],
+            "dest": state_machine.returning_home_state,
+        },
+        {
+            "trigger": "returned_home",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.home_state,
+        },
+        {
+            "trigger": "starting_recharging",
+            "source": [
+                state_machine.lockdown_state,
+                state_machine.home_state,
+                state_machine.going_to_recharging_state,
+            ],
+            "dest": state_machine.recharging_state,
+        },
+        {
+            "trigger": "return_home_failed",
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.going_to_recharging_state,
+            ],
+            "dest": state_machine.intervention_needed_state,
+        },
+        {
+            "trigger": "release_intervention_needed",
+            "source": state_machine.intervention_needed_state,
+            "dest": state_machine.unknown_status_state,
+        },
+        {
+            "trigger": "start_lockdown_mission_monitoring",
+            "source": [
+                state_machine.stopping_go_to_lockdown_state,
+                state_machine.await_next_mission_state,
+            ],
+            "dest": state_machine.going_to_lockdown_state,
+        },
+        {
+            "trigger": "start_recharging_mission_monitoring",
+            "source": [
+                state_machine.stopping_go_to_recharge_state,
+                state_machine.await_next_mission_state,
+            ],
+            "dest": state_machine.going_to_recharging_state,
+        },
+        {
+            "trigger": "go_to_lockdown",
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.going_to_recharging_state,
+            ],
+            "dest": state_machine.going_to_lockdown_state,
+        },
+        {
+            "trigger": "go_to_recharging",
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.return_home_paused_state,
+                state_machine.home_state,
+            ],
+            "dest": state_machine.going_to_recharging_state,
+        },
+        {
+            "trigger": "reached_lockdown",
+            "source": [
+                state_machine.home_state,
+                state_machine.going_to_lockdown_state,
+                state_machine.recharging_state,
+            ],
+            "dest": state_machine.lockdown_state,
+        },
+        {
+            "trigger": "lockdown_mission_failed",
+            "source": state_machine.going_to_lockdown_state,
+            "dest": state_machine.intervention_needed_state,
+        },
+        {
+            "trigger": "release_from_lockdown",
+            "source": state_machine.lockdown_state,
+            "dest": state_machine.home_state,
+        },
+        {
+            "trigger": "go_to_home",
+            "source": state_machine.intervention_needed_state,
+            "dest": state_machine.home_state,
+        },
+    ]
+    return return_home_transitions

isar/state_machine/transitions/robot_status.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
+    robot_status_transitions: List[dict] = [
+        {
+            "trigger": "initial_transition",
+            "source": state_machine.unknown_status_state,
+            "dest": state_machine.unknown_status_state,
+        },
+        {
+            "trigger": "initial_transition",
+            "source": state_machine.maintenance_state,
+            "dest": state_machine.maintenance_state,
+        },
+        {
+            "trigger": "robot_status_available",
+            "source": [
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.await_next_mission_state,
+        },
+        {
+            "trigger": "robot_status_available",
+            "source": [
+                state_machine.offline_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.home_state,
+            ],
+            "dest": state_machine.intervention_needed_state,
+        },
+        {
+            "trigger": "robot_status_home",
+            "source": [
+                state_machine.home_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.offline_state,
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.home_state,
+        },
+        {
+            "trigger": "robot_status_blocked_protective_stop",
+            "source": [
+                state_machine.home_state,
+                state_machine.offline_state,
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.blocked_protective_stopping_state,
+        },
+        {
+            "trigger": "robot_status_offline",
+            "source": [
+                state_machine.home_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.unknown_status_state,
+                state_machine.recharging_state,
+            ],
+            "dest": state_machine.offline_state,
+        },
+        {
+            "trigger": "robot_status_unknown",
+            "source": [
+                state_machine.home_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.offline_state,
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.unknown_status_state,
+        },
+        {
+            "trigger": "robot_recharged",
+            "source": state_machine.recharging_state,
+            "dest": state_machine.home_state,
+        },
+    ]
+    return robot_status_transitions