isar 1.31.0__py3-none-any.whl → 1.32.0__py3-none-any.whl

isar/state_machine/states/offline.py

@@ -1,22 +1,34 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
-from transitions import State
-
-from isar.state_machine.generic_states.robot_unavailable import (
-    RobotUnavailable,
-    RobotUnavailableStates,
-)
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class Offline(State, RobotUnavailable):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        State.__init__(self, name="offline", on_enter=self.start, on_exit=self.stop)
+class Offline(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+
+        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
 
-        RobotUnavailable.__init__(
-            self,
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=shared_state.robot_status,
+                handler=_robot_status_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="offline",
             state_machine=state_machine,
-            state=RobotUnavailableStates.Offline,
+            event_handler_mappings=event_handlers,
         )

isar/state_machine/states/paused.py

@@ -1,44 +1,30 @@
-import logging
-import time
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, List
 
-from transitions import State
-
-from isar.models.communication.queues.queue_utils import check_for_event
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class Paused(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="paused", on_enter=self.start)
-        self.state_machine: "StateMachine" = state_machine
-        self.logger = logging.getLogger("state_machine")
-        self.events = self.state_machine.events
-        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
-
-    def _run(self) -> None:
-        transition: Callable
-        while True:
-            if self.signal_state_machine_to_stop.is_set():
-                self.logger.info(
-                    "Stopping state machine from %s state", self.__class__.__name__
-                )
-                break
-
-            if check_for_event(self.events.api_requests.stop_mission.input):
-                transition = self.state_machine.stop  # type: ignore
-                break
-
-            if check_for_event(self.events.api_requests.resume_mission.input):
-                transition = self.state_machine.resume  # type: ignore
-                break
-
-            time.sleep(self.state_machine.sleep_time)
-
-        transition()
+class Paused(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.stop_mission.input,
+                handler=lambda event: state_machine.stop if event.consume_event() else None,  # type: ignore
+            ),
+            EventHandlerMapping(
+                name="resume_mission_event",
+                event=events.api_requests.resume_mission.input,
+                handler=lambda event: state_machine.resume if event.consume_event() else None,  # type: ignore
+            ),
+        ]
+        super().__init__(
+            state_name="paused",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/returning_home.py

@@ -1,24 +1,85 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional
 
-from transitions import State
-
-from isar.state_machine.generic_states.ongoing_mission import (
-    OngoingMission,
-    OngoingMissionStates,
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import (
+    mission_failed_event_handler,
+    mission_started_event_handler,
+    stop_mission_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.mission import Mission
+from robot_interface.models.mission.status import TaskStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class ReturningHome(State, OngoingMission):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        State.__init__(
-            self, name="returning_home", on_enter=self.start, on_exit=self.stop
-        )
+class ReturningHome(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="Return home failed.",
+                )
+                return state_machine.return_home_failed  # type: ignore
+            return state_machine.returned_home  # type: ignore
+
+        def _start_mission_event_handler(
+            event: Event[Mission],
+        ) -> Optional[Callable]:
+            if event.has_event():
+                return state_machine.stop  # type: ignore
+            return None
 
-        OngoingMission.__init__(
-            self,
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.stop_mission.input,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            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=lambda event: mission_failed_event_handler(
+                    state_machine, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.input,
+                handler=_start_mission_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="returning_home",
             state_machine=state_machine,
-            state=OngoingMissionStates.ReturningHome,
+            event_handler_mappings=event_handlers,
         )

isar/state_machine/states/robot_standing_still.py

@@ -1,20 +1,50 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
-from transitions import State
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.state_machine.utils.common_event_handlers import (
+    return_home_event_handler,
+    robot_status_event_handler,
+    start_mission_event_handler,
+    stop_mission_event_handler,
+)
+from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
-from isar.state_machine.generic_states.idle import Idle, IdleStates
 
+class RobotStandingStill(EventHandlerBase):
 
-class RobotStandingStill(State, Idle):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        State.__init__(
-            self, name="robot_standing_still", on_enter=self.start, on_exit=self.stop
-        )
-        Idle.__init__(
-            self,
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.input,
+                handler=lambda event: start_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="return_home_event",
+                event=events.api_requests.return_home.input,
+                handler=lambda event: return_home_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.return_home.input,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=shared_state.robot_status,
+                handler=lambda event: robot_status_event_handler(
+                    state_machine, RobotStatus.Available, event
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="robot_standing_still",
             state_machine=state_machine,
-            state=IdleStates.RobotStandingStill,
+            event_handler_mappings=event_handlers,
         )

isar/state_machine/states/stopping.py

@@ -1,75 +1,60 @@
 import logging
-import time
-from queue import Queue
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Callable, List, Optional
 
-from transitions import State
-
-from isar.models.communication.queues.queue_utils import check_for_event
+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(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="stopping", on_enter=self.start, on_exit=self.stop)
-        self.state_machine: "StateMachine" = state_machine
-        self.logger = logging.getLogger("state_machine")
-        self.events = self.state_machine.events
-        self._count_number_retries: int = 0
-        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
-        self.stopping_return_home_mission: bool = False
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        if self.state_machine.current_mission is not None:
-            self.stopping_return_home_mission = (
-                self.state_machine.current_mission._is_return_to_home_mission()
-            )
-        self._run()
-
-    def stop(self) -> None:
-        self._count_number_retries = 0
-        self.stopping_return_home_mission = False
-
-    def _check_and_handle_failed_stop(self, event: Queue[ErrorMessage]) -> bool:
-        error_message: Optional[ErrorMessage] = check_for_event(event)
-        if error_message is not None:
-            self.logger.warning(error_message.error_description)
-            if self.stopping_return_home_mission:
-                self.state_machine.return_home_mission_stopping_failed()  # type: ignore
-            else:
-                self.state_machine.mission_stopping_failed()  # type: ignore
-            return True
-        return False
-
-    def _check_and_handle_successful_stop(self, event: Queue[bool]) -> bool:
-        if check_for_event(event):
-            if self.stopping_return_home_mission:
-                self.state_machine.return_home_mission_stopped()  # type: ignore
-            else:
-                self.state_machine.mission_stopped()  # type: ignore
-            return True
-        return False
-
-    def _run(self) -> None:
-        while True:
-            if self.signal_state_machine_to_stop.is_set():
-                self.logger.info(
-                    "Stopping state machine from %s state", self.__class__.__name__
-                )
-                break
-
-            if self._check_and_handle_failed_stop(
-                self.events.robot_service_events.mission_failed_to_stop
-            ):
-                break
-
-            if self._check_and_handle_successful_stop(
-                self.events.robot_service_events.mission_successfully_stopped
-            ):
-                break
-
-            time.sleep(self.state_machine.sleep_time)
+class Stopping(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 not None:
+                logger.warning(error_message.error_description)
+                if (
+                    state_machine.current_mission is not None
+                    and state_machine.current_mission._is_return_to_home_mission()
+                ):
+                    return state_machine.return_home_mission_stopping_failed  # type: ignore
+                else:
+                    return state_machine.mission_stopping_failed  # type: ignore
+            return None
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+                if (
+                    state_machine.current_mission is not None
+                    and state_machine.current_mission._is_return_to_home_mission()
+                ):
+                    return state_machine.return_home_mission_stopped  # type: ignore
+                else:
+                    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",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/unknown_status.py

@@ -1,74 +1,47 @@
-import logging
-import time
-from queue import Queue
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional
 
-from transitions import State
-
-from isar.models.communication.queues.queue_utils import (
-    check_for_event,
-    check_shared_state,
-)
-from isar.models.communication.queues.status_queue import StatusQueue
+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(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="unknown_status", on_enter=self.start, on_exit=self.stop)
-        self.state_machine: "StateMachine" = state_machine
-        self.logger = logging.getLogger("state_machine")
-        self.events = self.state_machine.events
-        self.shared_state = self.state_machine.shared_state
-        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
-
-    def stop(self) -> None:
-        return
-
-    def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
-        if check_for_event(event) is not None:
-            self.state_machine.stop()  # type: ignore
-            return True
-        return False
-
-    def _check_and_handle_robot_status_event(
-        self, event: StatusQueue[RobotStatus]
-    ) -> bool:
-        robot_status: RobotStatus = check_shared_state(event)
-        if (
-            robot_status == RobotStatus.Home
-            or robot_status == RobotStatus.Offline
-            or robot_status == RobotStatus.BlockedProtectiveStop
-            or robot_status == RobotStatus.Available
-        ):
-            self.state_machine.robot_status_changed()  # type: ignore
-            return True
+class UnknownStatus(EventHandlerBase):
 
-        return False
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
 
-    def _run(self) -> None:
-        while True:
-            if self.signal_state_machine_to_stop.is_set():
-                self.logger.info(
-                    "Stopping state machine from %s state", self.__class__.__name__
-                )
-                break
-
-            if self._check_and_handle_stop_mission_event(
-                self.events.api_requests.stop_mission.input
-            ):
-                break
-
-            if self._check_and_handle_robot_status_event(
-                self.shared_state.robot_status
+        def _robot_status_event_handler(
+            event: Event[RobotStatus],
+        ) -> Optional[Callable]:
+            robot_status: RobotStatus = event.check()
+            if (
+                robot_status == RobotStatus.Home
+                or robot_status == RobotStatus.Offline
+                or robot_status == RobotStatus.BlockedProtectiveStop
+                or robot_status == RobotStatus.Available
             ):
-                break
-
-            time.sleep(self.state_machine.sleep_time)
+                return state_machine.robot_status_changed  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.stop_mission.input,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=shared_state.robot_status,
+                handler=_robot_status_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="unknown_status",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states_enum.py

@@ -12,6 +12,7 @@ class States(str, Enum):
     Offline = "offline"
     BlockedProtectiveStop = "blocked_protective_stop"
     UnknownStatus = "unknown_status"
+    InterventionNeeded = "intervention_needed"
 
     def __repr__(self):
         return self.value

isar/state_machine/transitions/functions/fail_mission.py

@@ -11,3 +11,10 @@ def report_failed_mission_and_finalize(state_machine: "StateMachine") -> None:
     state_machine.current_mission.status = MissionStatus.Failed
     state_machine.publish_task_status(task=state_machine.current_task)
     state_machine._finalize()
+
+
+def report_failed_return_home_and_intervention_needed(
+    state_machine: "StateMachine",
+) -> None:
+    error_message: str = "Return home failed."
+    state_machine.publish_intervention_needed(error_message=error_message)

isar/state_machine/transitions/functions/robot_status.py

@@ -1,6 +1,5 @@
 from typing import TYPE_CHECKING
 
-from isar.models.communication.queues.queue_utils import check_shared_state
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -8,20 +7,20 @@ if TYPE_CHECKING:
 
 
 def is_offline(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.Offline
 
 
 def is_available(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.Available
 
 
 def is_home(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.Home
 
 
 def is_blocked_protective_stop(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.BlockedProtectiveStop

isar/state_machine/transitions/functions/stop.py

@@ -1,10 +1,5 @@
 from typing import TYPE_CHECKING
 
-from isar.models.communication.queues.queue_utils import (
-    check_for_event_without_consumption,
-    trigger_event_without_data,
-)
-
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
@@ -13,7 +8,7 @@ from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def trigger_stop_mission_event(state_machine: "StateMachine") -> bool:
-    trigger_event_without_data(state_machine.events.state_machine_events.stop_mission)
+    state_machine.events.state_machine_events.stop_mission.trigger_event(True)
     return True
 
 
@@ -56,9 +51,7 @@ def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
         state_machine.reset_state_machine()
         return True
 
-    if not check_for_event_without_consumption(
-        state_machine.events.api_requests.start_mission.input
-    ):
+    if not state_machine.events.api_requests.start_mission.input.has_event():
         state_machine.current_mission.status = MissionStatus.Cancelled
 
         for task in state_machine.current_mission.tasks:
@@ -81,9 +74,7 @@ def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
 
 
 def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
-    if check_for_event_without_consumption(
-        state_machine.events.api_requests.start_mission.input
-    ):
+    if state_machine.events.api_requests.start_mission.input.has_event():
         return True
     stopped_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()

isar/state_machine/transitions/mission.py

@@ -122,12 +122,6 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.home_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
-        {
-            "trigger": "request_mission_start",
-            "source": state_machine.returning_home_state,
-            "dest": state_machine.returning_home_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
-        },
         {
             "trigger": "mission_failed_to_start",
             "source": [state_machine.monitor_state, state_machine.returning_home_state],