isar 1.33.8__py3-none-any.whl → 1.34.0__py3-none-any.whl

isar/state_machine/states/paused.py

@@ -19,28 +19,30 @@ class Paused(EventHandlerBase):
             event: Event[float],
         ) -> Optional[Callable]:
             battery_level: float = event.check()
-            if battery_level < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
-                state_machine.publish_mission_aborted(
-                    "Robot battery too low to continue mission", True
-                )
-                state_machine._finalize()
-                state_machine.logger.warning(
-                    "Cancelling current mission due to low battery"
-                )
-                return state_machine.stop  # type: ignore
-            return None
+            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                return None
+
+            state_machine.publish_mission_aborted(
+                "Robot battery too low to continue mission", True
+            )
+            state_machine.print_transitions()
+            state_machine.logger.warning(
+                "Cancelling current mission due to low battery"
+            )
+            return state_machine.stop  # type: ignore
 
         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
+            if not should_lockdown:
+                return None
+
+            state_machine.print_transitions()
+            state_machine.logger.warning(
+                "Cancelling current mission due to robot going to lockdown"
+            )
+            return state_machine.stop_go_to_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/pausing.py

@@ -4,7 +4,6 @@ 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
@@ -20,40 +19,26 @@ class Pausing(EventHandlerBase):
         ) -> Optional[Callable]:
             error_message: Optional[ErrorMessage] = event.consume_event()
 
-            paused_mission_response: ControlMissionResponse = (
-                state_machine._make_control_mission_response()
-            )
+            if error_message is None:
+                return None
 
             state_machine.events.api_requests.pause_mission.response.trigger_event(
-                paused_mission_response
+                ControlMissionResponse(
+                    success=False, failure_reason=error_message.error_reason
+                )
             )
 
-            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
+            return state_machine.mission_pausing_failed  # type: ignore
 
         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
-                )
+            if not event.consume_event():
+                return None
 
-                state_machine.publish_mission_status()
-                state_machine.send_task_status()
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
+                ControlMissionResponse(success=True)
+            )
 
-                return state_machine.mission_paused  # type:ignore
-            return None
+            return state_machine.mission_paused  # type:ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/pausing_return_home.py

@@ -4,7 +4,6 @@ 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
@@ -20,40 +19,26 @@ class PausingReturnHome(EventHandlerBase):
         ) -> Optional[Callable]:
             error_message: Optional[ErrorMessage] = event.consume_event()
 
-            paused_mission_response: ControlMissionResponse = (
-                state_machine._make_control_mission_response()
-            )
+            if error_message is None:
+                return None
 
             state_machine.events.api_requests.pause_mission.response.trigger_event(
-                paused_mission_response
+                ControlMissionResponse(
+                    success=False, failure_reason=error_message.error_reason
+                )
             )
 
-            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
+            return state_machine.return_home_mission_pausing_failed  # type: ignore
 
         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
-                )
+            if not event.consume_event():
+                return None
 
-                state_machine.publish_mission_status()
-                state_machine.send_task_status()
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
+                ControlMissionResponse(success=True)
+            )
 
-                return state_machine.return_home_mission_paused  # type: ignore
-            return None
+            return state_machine.return_home_mission_paused  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/recharging.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Optional
 
 from isar.apis.models.models import LockdownResponse
 from isar.config.settings import settings
@@ -18,23 +18,29 @@ class Recharging(EventHandlerBase):
 
         def robot_battery_level_updated_handler(event: Event[float]):
             battery_level: float = event.check()
-            if battery_level >= settings.ROBOT_BATTERY_RECHARGE_THRESHOLD:
-                return state_machine.robot_recharged  # type: ignore
-            return None
+            if battery_level < settings.ROBOT_BATTERY_RECHARGE_THRESHOLD:
+                return None
+
+            return state_machine.robot_recharged  # type: ignore
 
         def robot_offline_handler(event: Event[RobotStatus]):
-            robot_status: RobotStatus = event.check()
+            robot_status: Optional[RobotStatus] = event.check()
+
+            if robot_status is None:
+                return None
+
             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
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.reached_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/return_home_paused.py

@@ -20,38 +20,42 @@ class ReturnHomePaused(EventHandlerBase):
             event: Event[float],
         ) -> Optional[Callable]:
             battery_level: float = event.check()
-            if battery_level < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
-                return state_machine.resume  # type: ignore
-            return None
+
+            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                return None
+
+            return state_machine.resume  # type: ignore
 
         def _start_mission_event_handler(
             event: Event[Mission],
         ) -> Optional[Callable]:
-            if event.has_event():
-                if not state_machine.battery_level_is_above_mission_start_threshold():
-                    state_machine.events.api_requests.start_mission.request.consume_event()
-                    response = MissionStartResponse(
-                        mission_id=None,
-                        mission_started=False,
-                        mission_not_started_reason="Robot battery too low",
-                    )
-                    state_machine.events.api_requests.start_mission.response.trigger_event(
-                        response
-                    )
-                    return None
-                return state_machine.stop_return_home  # type: ignore
-            return None
+            if not event.has_event():
+                return None
+
+            if not state_machine.battery_level_is_above_mission_start_threshold():
+                state_machine.events.api_requests.start_mission.request.consume_event()
+                response = MissionStartResponse(
+                    mission_id=None,
+                    mission_started=False,
+                    mission_not_started_reason="Robot battery too low",
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    response
+                )
+                return None
+            return state_machine.stop_return_home  # type: ignore
 
         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
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.resume_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/returning_home.py

@@ -3,15 +3,10 @@ from typing import TYPE_CHECKING, Callable, List, Optional
 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 (
-    mission_failed_event_handler,
-    mission_started_event_handler,
-    task_status_event_handler,
-    task_status_failed_event_handler,
-)
-from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
+from isar.state_machine.utils.common_event_handlers import mission_started_event_handler
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import TaskStatus
+from robot_interface.models.mission.status import MissionStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -24,51 +19,74 @@ class ReturningHome(EventHandlerBase):
         events = state_machine.events
 
         def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
-                return state_machine.pause_return_home  # type: ignore
-            return None
-
-        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.",
-                )
-                self.failed_return_home_attemps += 1
-                return state_machine.return_home_failed  # type: ignore
+            if not event.consume_event():
+                return None
 
-            if not state_machine.battery_level_is_above_mission_start_threshold():
-                return state_machine.starting_recharging  # type: ignore
-            else:
-                return state_machine.returned_home  # type: ignore
+            return state_machine.pause_return_home  # type: ignore
 
         def _start_mission_event_handler(
             event: Event[Mission],
         ) -> Optional[Callable]:
-            if event.has_event():
+            if not event.has_event():
+                return None
+
+            if not state_machine.battery_level_is_above_mission_start_threshold():
+                state_machine.events.api_requests.start_mission.request.consume_event()
+                response = MissionStartResponse(
+                    mission_id=None,
+                    mission_started=False,
+                    mission_not_started_reason="Robot battery too low",
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    response
+                )
+                return None
+
+            return state_machine.stop_return_home  # type: ignore
+
+        def _mission_status_event_handler(
+            event: Event[MissionStatus],
+        ) -> Optional[Callable]:
+            mission_status: Optional[MissionStatus] = event.consume_event()
+
+            if mission_status and mission_status not in [
+                MissionStatus.InProgress,
+                MissionStatus.NotStarted,
+                MissionStatus.Paused,
+            ]:
+                if mission_status != MissionStatus.Successful:
+                    self.failed_return_home_attemps += 1
+                    return state_machine.return_home_failed  # type: ignore
+
+                self.failed_return_home_attemps = 0
                 if not state_machine.battery_level_is_above_mission_start_threshold():
-                    state_machine.events.api_requests.start_mission.request.consume_event()
-                    response = MissionStartResponse(
-                        mission_id=None,
-                        mission_started=False,
-                        mission_not_started_reason="Robot battery too low",
-                    )
-                    state_machine.events.api_requests.start_mission.response.trigger_event(
-                        response
-                    )
-                    return None
-                return state_machine.stop_return_home  # type: ignore
+                    return state_machine.starting_recharging  # type: ignore
+                else:
+                    return state_machine.returned_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)
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.go_to_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 return home because: "
+                    f"{mission_failed.error_description}"
                 )
-                return state_machine.go_to_lockdown  # type: ignore
+                return state_machine.return_home_failed  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [
@@ -87,9 +105,7 @@ class ReturningHome(EventHandlerBase):
             EventHandlerMapping(
                 name="mission_failed_event",
                 event=events.robot_service_events.mission_failed,
-                handler=lambda event: mission_failed_event_handler(
-                    state_machine, event
-                ),
+                handler=_mission_failed_event_handler,
             ),
             EventHandlerMapping(
                 name="start_mission_event",
@@ -97,18 +113,9 @@ class ReturningHome(EventHandlerBase):
                 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
-                ),
+                name="mission_status_event",
+                event=events.robot_service_events.mission_status_updated,
+                handler=_mission_status_event_handler,
             ),
             EventHandlerMapping(
                 name="send_to_lockdown_event",

isar/state_machine/states/stopping.py

@@ -4,7 +4,6 @@ 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
@@ -16,46 +15,29 @@ class Stopping(EventHandlerBase):
         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
-
-            stopped_mission_response: ControlMissionResponse = (
-                state_machine._make_control_mission_response()
-            )
             state_machine.events.api_requests.stop_mission.response.trigger_event(
-                stopped_mission_response
+                ControlMissionResponse(success=True)
             )
-            state_machine.publish_task_status(task=state_machine.current_task)
-            state_machine._finalize()
+            state_machine.print_transitions()
             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:
-                return state_machine.mission_stopping_failed  # type: ignore
-            return None
+            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 event.consume_event():
-                _stop_mission_cleanup()
-                if not state_machine.battery_level_is_above_mission_start_threshold():
-                    return state_machine.request_return_home  # type: ignore
-                return state_machine.mission_stopped  # type: ignore
-            return None
+            if not event.consume_event():
+                return None
+
+            _stop_mission_cleanup()
+            if not state_machine.battery_level_is_above_mission_start_threshold():
+                return state_machine.request_return_home  # type: ignore
+            return state_machine.mission_stopped  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/stopping_go_to_lockdown.py

@@ -4,7 +4,6 @@ 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
@@ -15,50 +14,31 @@ 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",
-                    )
+            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
-            return None
+            )
+            return state_machine.mission_stopping_failed  # type: ignore
 
         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
+            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)
+            )
+            return state_machine.request_lockdown_mission  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/stopping_return_home.py

@@ -21,38 +21,38 @@ class StoppingReturnHome(EventHandlerBase):
             event: Event[ErrorMessage],
         ) -> Optional[Callable]:
             error_message: Optional[ErrorMessage] = event.consume_event()
-            if error_message is not 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",
-                    )
+            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
-            return None
+            )
+            return state_machine.return_home_mission_stopping_failed  # type: ignore
 
         def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
-                mission: Mission = (
-                    state_machine.events.api_requests.start_mission.request.consume_event()
-                )
+            if not event.consume_event():
+                return None
 
-                state_machine.reset_state_machine()
+            mission: Mission = (
+                state_machine.events.api_requests.start_mission.request.consume_event()
+            )
 
-                if mission:
-                    state_machine.start_mission(mission=mission)
-                    return state_machine.request_mission_start  # type: ignore
+            if mission:
+                state_machine.start_mission(mission=mission)
+                return state_machine.request_mission_start  # type: ignore
 
-                state_machine.logger.error(
-                    "Stopped return home without a new mission to start"
-                )
-                return state_machine.request_return_home  # type: ignore
-            return None
+            state_machine.logger.error(
+                "Stopped return home without a new mission to start"
+            )
+            return state_machine.request_return_home  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(