isar 1.33.5__py3-none-any.whl → 1.33.6__py3-none-any.whl

isar/state_machine/states/paused.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Callable, List, Optional
 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
@@ -29,11 +30,23 @@ class Paused(EventHandlerBase):
                 return state_machine.stop  # type: ignore
             return None
 
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if should_lockdown:
+                state_machine._finalize()
+                state_machine.logger.warning(
+                    "Cancelling current mission due to robot going to lockdown"
+                )
+                return state_machine.stop_go_to_lockdown  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="stop_mission_event",
                 event=events.api_requests.stop_mission.request,
-                handler=lambda event: state_machine.stop if event.consume_event() else None,  # type: ignore
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
             ),
             EventHandlerMapping(
                 name="resume_mission_event",
@@ -45,6 +58,11 @@ class Paused(EventHandlerBase):
                 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,
+            ),
         ]
         super().__init__(
             state_name="paused",

isar/state_machine/states/pausing.py

@@ -0,0 +1,74 @@
+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
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Pausing(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _failed_pause_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+
+            paused_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
+                paused_mission_response
+            )
+
+            state_machine.publish_mission_status()
+            state_machine.send_task_status()
+
+            if error_message is not None:
+                return state_machine.mission_pausing_failed  # type: ignore
+            return None
+
+        def _successful_pause_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+
+                state_machine.current_mission.status = MissionStatus.Paused
+                state_machine.current_task.status = TaskStatus.Paused
+
+                paused_mission_response: ControlMissionResponse = (
+                    state_machine._make_control_mission_response()
+                )
+
+                state_machine.events.api_requests.pause_mission.response.trigger_event(
+                    paused_mission_response
+                )
+
+                state_machine.publish_mission_status()
+                state_machine.send_task_status()
+
+                return state_machine.mission_paused  # type:ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_pause_event",
+                event=events.robot_service_events.mission_failed_to_pause,
+                handler=_failed_pause_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_pause_event",
+                event=events.robot_service_events.mission_successfully_paused,
+                handler=_successful_pause_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="pausing",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/pausing_return_home.py

@@ -0,0 +1,74 @@
+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
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class PausingReturnHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _failed_pause_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+
+            paused_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
+                paused_mission_response
+            )
+
+            state_machine.publish_mission_status()
+            state_machine.send_task_status()
+
+            if error_message is not None:
+                return state_machine.return_home_mission_pausing_failed  # type: ignore
+            return None
+
+        def _successful_pause_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+
+                state_machine.current_mission.status = MissionStatus.Paused
+                state_machine.current_task.status = TaskStatus.Paused
+
+                paused_mission_response: ControlMissionResponse = (
+                    state_machine._make_control_mission_response()
+                )
+
+                state_machine.events.api_requests.pause_mission.response.trigger_event(
+                    paused_mission_response
+                )
+
+                state_machine.publish_mission_status()
+                state_machine.send_task_status()
+
+                return state_machine.return_home_mission_paused  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_pause_event",
+                event=events.robot_service_events.mission_failed_to_pause,
+                handler=_failed_pause_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_paused,
+                handler=_successful_pause_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="pausing_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/recharging.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, List
 
+from isar.apis.models.models import LockdownResponse
 from isar.config.settings import settings
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
 from isar.models.events import Event
@@ -13,6 +14,7 @@ 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()
@@ -25,6 +27,15 @@ class Recharging(EventHandlerBase):
             if robot_status == RobotStatus.Offline:
                 return state_machine.robot_went_offline  # type: ignore
 
+        def _send_to_lockdown_event_handler(event: Event[bool]):
+            should_lockdown: bool = event.consume_event()
+            if should_lockdown:
+                events.api_requests.send_to_lockdown.response.trigger_event(
+                    LockdownResponse(lockdown_started=True)
+                )
+                return state_machine.reached_lockdown  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="robot_battery_update_event",
@@ -36,6 +47,11 @@ class Recharging(EventHandlerBase):
                 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,
+            ),
         ]
         super().__init__(
             state_name="recharging",

isar/state_machine/states/return_home_paused.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Callable, List, Optional
 
-from isar.apis.models.models import MissionStartResponse
+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
@@ -42,6 +42,17 @@ class ReturnHomePaused(EventHandlerBase):
                 return state_machine.stop_return_home  # type: ignore
             return None
 
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if should_lockdown:
+                events.api_requests.send_to_lockdown.response.trigger_event(
+                    LockdownResponse(lockdown_started=True)
+                )
+                return state_machine.resume_lockdown  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="resume_return_home_event",
@@ -58,6 +69,11 @@ class ReturnHomePaused(EventHandlerBase):
                 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,
+            ),
         ]
         super().__init__(
             state_name="return_home_paused",

isar/state_machine/states/returning_home.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Callable, List, Optional
 
-from isar.apis.models.models import MissionStartResponse
+from isar.apis.models.models import LockdownResponse, MissionStartResponse
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
 from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
@@ -25,7 +25,7 @@ class ReturningHome(EventHandlerBase):
 
         def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
             if event.consume_event():
-                return state_machine.pause  # type: ignore
+                return state_machine.pause_return_home  # type: ignore
             return None
 
         def _handle_task_completed(status: TaskStatus):
@@ -60,6 +60,17 @@ class ReturningHome(EventHandlerBase):
                 return state_machine.stop_return_home  # type: ignore
             return None
 
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if should_lockdown:
+                events.api_requests.send_to_lockdown.response.trigger_event(
+                    LockdownResponse(lockdown_started=True)
+                )
+                return state_machine.go_to_lockdown  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="pause_mission_event",
@@ -99,6 +110,11 @@ class ReturningHome(EventHandlerBase):
                     state_machine, _handle_task_completed, event
                 ),
             ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
         ]
         super().__init__(
             state_name="returning_home",

isar/state_machine/states/stopping_go_to_lockdown.py

@@ -0,0 +1,79 @@
+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
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+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 _stop_mission_cleanup() -> None:
+            if state_machine.current_mission is None:
+                state_machine._queue_empty_response()
+                state_machine.reset_state_machine()
+                return None
+
+            state_machine.current_mission.status = MissionStatus.Cancelled
+
+            for task in state_machine.current_mission.tasks:
+                if task.status in [
+                    TaskStatus.NotStarted,
+                    TaskStatus.InProgress,
+                    TaskStatus.Paused,
+                ]:
+                    task.status = TaskStatus.Cancelled
+
+            state_machine.publish_task_status(task=state_machine.current_task)
+            return None
+
+        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.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
+            return None
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+                state_machine.publish_mission_aborted(
+                    "Robot being sent to lockdown", True
+                )
+                _stop_mission_cleanup()
+                events.api_requests.send_to_lockdown.response.trigger_event(
+                    LockdownResponse(lockdown_started=True)
+                )
+                return state_machine.request_lockdown_mission  # 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_go_to_lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states_enum.py

@@ -7,6 +7,8 @@ class States(str, Enum):
     Stopping = "stopping"
     StoppingReturnHome = "stopping_return_home"
     Paused = "paused"
+    Pausing = "pausing"
+    PausingReturnHome = "pausing_return_home"
     ReturnHomePaused = "return_home_paused"
     AwaitNextMission = "await_next_mission"
     Home = "home"
@@ -15,6 +17,9 @@ class States(str, Enum):
     UnknownStatus = "unknown_status"
     InterventionNeeded = "intervention_needed"
     Recharging = "recharging"
+    StoppingGoToLockdown = "stopping_go_to_lockdown"
+    GoingToLockdown = "going_to_lockdown"
+    Lockdown = "lockdown"
 
     def __repr__(self):
         return self.value

isar/state_machine/transitions/functions/fail_mission.py

@@ -18,3 +18,10 @@ def report_failed_return_home_and_intervention_needed(
 ) -> None:
     error_message: str = "Return home failed."
     state_machine.publish_intervention_needed(error_message=error_message)
+
+
+def report_failed_lockdown_and_intervention_needed(
+    state_machine: "StateMachine",
+) -> None:
+    error_message: str = "Lockdown mission failed."
+    state_machine.publish_intervention_needed(error_message=error_message)

isar/state_machine/transitions/functions/pause.py

@@ -1,91 +1,31 @@
 from typing import TYPE_CHECKING
 
-if TYPE_CHECKING:
-    from isar.state_machine.state_machine import StateMachine
-
-import time
-
 from isar.apis.models.models import ControlMissionResponse
-from isar.config.settings import settings
-from robot_interface.models.exceptions.robot_exceptions import (
-    RobotActionException,
-    RobotException,
-)
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
-
-
-def pause_mission(state_machine: "StateMachine") -> bool:
-    state_machine.logger.info("Pausing mission: %s", state_machine.current_mission.id)
-
-    max_retries = settings.STATE_TRANSITION_NUM_RETIRES
-    retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
-
-    for attempt in range(max_retries):
-        try:
-            state_machine.robot.pause()
-            state_machine.current_mission.status = MissionStatus.Paused
-            state_machine.current_task.status = TaskStatus.Paused
-
-            paused_mission_response: ControlMissionResponse = (
-                state_machine._make_control_mission_response()
-            )
-            state_machine.events.api_requests.pause_mission.response.trigger_event(
-                paused_mission_response
-            )
-
-            state_machine.publish_mission_status()
-            state_machine.publish_task_status(task=state_machine.current_task)
-
-            state_machine.logger.info("Mission paused successfully.")
-            return True
-        except RobotActionException as e:
-            state_machine.logger.warning(
-                f"Attempt {attempt + 1} to pause mission failed: {e.error_description}"
-            )
-            time.sleep(retry_interval)
-        except RobotException as e:
-            state_machine.logger.warning(
-                f"Attempt {attempt + 1} to pause mission raised a RobotException: {e.error_description}"
-            )
-            time.sleep(retry_interval)
-
-    state_machine.logger.error("Failed to pause mission after multiple attempts.")
-    return False
 
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
 
-def pause_return_home_mission(state_machine: "StateMachine") -> bool:
-    state_machine.logger.info("Pausing return home misson")
 
-    max_retries = settings.STATE_TRANSITION_NUM_RETIRES
-    retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
+def trigger_pause_mission_event(state_machine: "StateMachine") -> bool:
+    state_machine.events.state_machine_events.pause_mission.trigger_event(True)
+    return True
 
-    for attempt in range(max_retries):
-        try:
-            state_machine.robot.pause()
-            state_machine.current_mission.status = MissionStatus.Paused
-            state_machine.current_task.status = TaskStatus.Paused
 
-            paused_mission_response: ControlMissionResponse = (
-                state_machine._make_control_mission_response()
-            )
-            state_machine.events.api_requests.pause_mission.response.trigger_event(
-                paused_mission_response
-            )
+def pause_mission_failed(state_machine: "StateMachine") -> bool:
+    paused_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.pause_mission.response.trigger_event(
+        paused_mission_response
+    )
+    return True
 
-            state_machine.logger.info("Return home mission paused successfully.")
-            return True
-        except RobotActionException as e:
-            state_machine.logger.warning(
-                f"Attempt {attempt + 1} to pause return home mission failed: {e.error_description}"
-            )
-            time.sleep(retry_interval)
-        except RobotException as e:
-            state_machine.logger.warning(
-                f"Attempt {attempt + 1} to pause return home mission raised a RobotException: {e.error_description}"
-            )
-            time.sleep(retry_interval)
 
-    state_machine.logger.error(
-        "Failed to pause return home mission after multiple attempts."
+def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
+    paused_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.pause_mission.response.trigger_event(
+        paused_mission_response
     )
-    return False
+    return True

isar/state_machine/transitions/mission.py

@@ -5,8 +5,8 @@ from isar.state_machine.transitions.functions.fail_mission import (
 )
 from isar.state_machine.transitions.functions.finish_mission import finish_mission
 from isar.state_machine.transitions.functions.pause import (
-    pause_mission,
-    pause_return_home_mission,
+    pause_mission_failed,
+    trigger_pause_mission_event,
 )
 from isar.state_machine.transitions.functions.resume import resume_mission
 from isar.state_machine.transitions.functions.return_home import (
@@ -36,24 +36,39 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "pause",
             "source": state_machine.monitor_state,
+            "dest": state_machine.pausing_state,
+            "conditions": def_transition(state_machine, trigger_pause_mission_event),
+        },
+        {
+            "trigger": "mission_paused",
+            "source": state_machine.pausing_state,
             "dest": state_machine.paused_state,
-            "conditions": def_transition(state_machine, pause_mission),
         },
         {
-            "trigger": "pause",
-            "source": state_machine.monitor_state,
+            "trigger": "mission_pausing_failed",
+            "source": state_machine.pausing_state,
             "dest": state_machine.monitor_state,
+            "before": def_transition(state_machine, pause_mission_failed),
         },
         {
-            "trigger": "pause",
+            "trigger": "pause_return_home",
             "source": state_machine.returning_home_state,
-            "dest": state_machine.return_home_paused_state,
-            "conditions": def_transition(state_machine, pause_return_home_mission),
+            "dest": state_machine.pausing_return_home_state,
+            "before": [
+                def_transition(state_machine, trigger_pause_mission_event),
+                def_transition(state_machine, reset_return_home_failure_counter),
+            ],
         },
         {
-            "trigger": "pause",
-            "source": state_machine.returning_home_state,
+            "trigger": "return_home_mission_pausing_failed",
+            "source": state_machine.pausing_return_home_state,
             "dest": state_machine.returning_home_state,
+            "before": def_transition(state_machine, stop_return_home_mission_failed),
+        },
+        {
+            "trigger": "return_home_mission_paused",
+            "source": state_machine.pausing_return_home_state,
+            "dest": state_machine.return_home_paused_state,
         },
         {
             "trigger": "resume",
@@ -77,6 +92,12 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "source": state_machine.return_home_paused_state,
             "dest": state_machine.return_home_paused_state,
         },
+        {
+            "trigger": "resume_lockdown",
+            "source": state_machine.return_home_paused_state,
+            "dest": state_machine.going_to_lockdown_state,
+            "conditions": def_transition(state_machine, resume_mission),
+        },
         {
             "trigger": "stop",
             "source": [
@@ -87,6 +108,14 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.stopping_state,
             "before": def_transition(state_machine, trigger_stop_mission_event),
         },
+        {
+            "trigger": "stop_go_to_lockdown",
+            "source": [
+                state_machine.monitor_state,
+            ],
+            "dest": state_machine.stopping_go_to_lockdown_state,
+            "before": def_transition(state_machine, trigger_stop_mission_event),
+        },
         {
             "trigger": "stop_return_home",
             "source": [
@@ -105,12 +134,22 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "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_stopping_failed",
             "source": state_machine.stopping_state,
             "dest": state_machine.monitor_state,
             "before": def_transition(state_machine, stop_mission_failed),
         },
+        {
+            "trigger": "mission_stopping_failed",
+            "source": state_machine.stopping_go_to_lockdown_state,
+            "dest": state_machine.monitor_state,
+        },
         {
             "trigger": "return_home_mission_stopping_failed",
             "source": state_machine.stopping_return_home_state,
@@ -159,5 +198,11 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, finish_mission),
         },
+        {
+            "trigger": "lock_down_successful",
+            "source": state_machine.going_to_lockdown_state,
+            "dest": state_machine.lockdown_state,
+            "before": def_transition(state_machine, finish_mission),
+        },
     ]
     return mission_transitions