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

isar/state_machine/states/await_next_mission.py

@@ -1,11 +1,13 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List, Optional
 
+from isar.apis.models.models import LockdownResponse
 from isar.config.settings import settings
 from isar.eventhandlers.eventhandler import (
     EventHandlerBase,
     EventHandlerMapping,
     TimeoutHandlerMapping,
 )
+from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     return_home_event_handler,
     start_mission_event_handler,
@@ -21,6 +23,17 @@ class AwaitNextMission(EventHandlerBase):
     def __init__(self, state_machine: "StateMachine"):
         events = state_machine.events
 
+        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.request_lockdown_mission  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -39,6 +52,11 @@ class AwaitNextMission(EventHandlerBase):
                 event=events.api_requests.return_home.request,
                 handler=lambda event: stop_mission_event_handler(state_machine, event),
             ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
         ]
 
         timers: List[TimeoutHandlerMapping] = [

isar/state_machine/states/blocked_protective_stop.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, List
 
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
-from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import robot_status_event_handler
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -11,19 +11,19 @@ if TYPE_CHECKING:
 class BlockedProtectiveStop(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
         shared_state = state_machine.shared_state
 
-        def _robot_status_event_handler(event: Event[RobotStatus]):
-            robot_status: RobotStatus = event.check()
-            if robot_status != RobotStatus.BlockedProtectiveStop:
-                return state_machine.robot_status_changed  # type: ignore
-            return None
-
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="robot_status_event",
-                event=shared_state.robot_status,
-                handler=_robot_status_event_handler,
+                event=events.robot_service_events.robot_status_changed,
+                handler=lambda event: robot_status_event_handler(
+                    state_machine=state_machine,
+                    expected_status=RobotStatus.BlockedProtectiveStop,
+                    status_changed_event=event,
+                    status_event=shared_state.robot_status,
+                ),
             ),
         ]
         super().__init__(

isar/state_machine/states/going_to_lockdown.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+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,
+    task_status_event_handler,
+    task_status_failed_event_handler,
+)
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
+from robot_interface.models.mission.status import TaskStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class GoingToLockdown(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _handle_task_completed(status: TaskStatus):
+            if status != TaskStatus.Successful:
+                state_machine.current_mission.error_message = ErrorMessage(
+                    error_reason=ErrorReason.RobotActionException,
+                    error_description="Lock down mission failed.",
+                )
+                return state_machine.lockdown_mission_failed  # type: ignore
+            return state_machine.reached_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 mission "
+                    f"{str(state_machine.current_mission.id)[:8]} because: "
+                    f"{mission_failed.error_description}"
+                )
+                state_machine.current_mission.error_message = ErrorMessage(
+                    error_reason=mission_failed.error_reason,
+                    error_description=mission_failed.error_description,
+                )
+                return state_machine.lockdown_mission_failed  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            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="task_status_failed_event",
+                event=events.robot_service_events.task_status_failed,
+                handler=lambda event: task_status_failed_event_handler(
+                    state_machine, _handle_task_completed, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="task_status_event",
+                event=events.robot_service_events.task_status_updated,
+                handler=lambda event: task_status_event_handler(
+                    state_machine, _handle_task_completed, event
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="going_to_lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/home.py

@@ -1,5 +1,6 @@
 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 isar.state_machine.utils.common_event_handlers import (
@@ -19,10 +20,23 @@ class Home(EventHandlerBase):
         events = state_machine.events
         shared_state = state_machine.shared_state
 
+        def _send_to_lockdown_event_handler(event: Event[bool]):
+            should_send_robot_home: bool = event.consume_event()
+            if should_send_robot_home:
+                events.api_requests.send_to_lockdown.response.trigger_event(
+                    LockdownResponse(lockdown_started=True)
+                )
+                return state_machine.reached_lockdown  # type: ignore
+            return None
+
         def _robot_status_event_handler(
-            event: Event[RobotStatus],
+            state_machine: "StateMachine",
+            status_changed_event: Event[bool],
+            status_event: Event[RobotStatus],
         ) -> Optional[Callable]:
-            robot_status: RobotStatus = event.check()
+            if not status_changed_event.consume_event():
+                return None
+            robot_status: Optional[RobotStatus] = status_event.check()
             if not (
                 robot_status == RobotStatus.Available
                 or robot_status == RobotStatus.Home
@@ -50,8 +64,17 @@ class Home(EventHandlerBase):
             ),
             EventHandlerMapping(
                 name="robot_status_event",
-                event=shared_state.robot_status,
-                handler=_robot_status_event_handler,
+                event=events.robot_service_events.robot_status_changed,
+                handler=lambda event: _robot_status_event_handler(
+                    state_machine=state_machine,
+                    status_changed_event=event,
+                    status_event=shared_state.robot_status,
+                ),
+            ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
             ),
         ]
         super().__init__(

isar/state_machine/states/lockdown.py

@@ -0,0 +1,37 @@
+from typing import TYPE_CHECKING, List
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Lockdown(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _release_from_lockdown_handler(event: Event[bool]):
+            should_release_from_lockdown: bool = event.consume_event()
+            if should_release_from_lockdown:
+                events.api_requests.release_from_lockdown.response.trigger_event(True)
+                if state_machine.battery_level_is_above_mission_start_threshold():
+                    return state_machine.release_from_lockdown  # type: ignore
+                else:
+                    return state_machine.starting_recharging  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="release_from_lockdown",
+                event=events.api_requests.release_from_lockdown.request,
+                handler=_release_from_lockdown_handler,
+            ),
+        ]
+
+        super().__init__(
+            state_name="lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/monitor.py

@@ -63,6 +63,17 @@ class Monitor(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.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",
@@ -107,6 +118,11 @@ class Monitor(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="monitor",

isar/state_machine/states/offline.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, List
 
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
-from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import robot_status_event_handler
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -11,20 +11,19 @@ if TYPE_CHECKING:
 class Offline(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
-
+        events = state_machine.events
         shared_state = state_machine.shared_state
 
-        def _robot_status_event_handler(event: Event[RobotStatus]):
-            robot_status: RobotStatus = event.check()
-            if robot_status != RobotStatus.Offline:
-                return state_machine.robot_status_changed  # type: ignore
-            return None
-
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="robot_status_event",
-                event=shared_state.robot_status,
-                handler=_robot_status_event_handler,
+                event=events.robot_service_events.robot_status_changed,
+                handler=lambda event: robot_status_event_handler(
+                    state_machine=state_machine,
+                    expected_status=RobotStatus.Offline,
+                    status_changed_event=event,
+                    status_event=shared_state.robot_status,
+                ),
             ),
         ]
         super().__init__(

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",