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

isar/state_machine/state_machine.py

@@ -3,20 +3,14 @@ import logging
 from collections import deque
 from datetime import datetime, timezone
 from threading import Event
-from typing import Deque, List, Optional, Tuple
+from typing import Deque, List, Optional
 
 from transitions import Machine
 from transitions.core import State
 
-from isar.apis.models.models import ControlMissionResponse
 from isar.config.settings import settings
-from isar.mission_planner.task_selector_interface import (
-    TaskSelectorInterface,
-    TaskSelectorStop,
-)
 from isar.models.events import Events, SharedState
 from isar.models.status import IsarStatus
-from isar.services.service_connections.mqtt.mqtt_client import props_expiry
 from isar.state_machine.states.await_next_mission import AwaitNextMission
 from isar.state_machine.states.blocked_protective_stop import BlockedProtectiveStop
 from isar.state_machine.states.going_to_lockdown import GoingToLockdown
@@ -39,23 +33,13 @@ from isar.state_machine.states_enum import States
 from isar.state_machine.transitions.mission import get_mission_transitions
 from isar.state_machine.transitions.return_home import get_return_home_transitions
 from isar.state_machine.transitions.robot_status import get_robot_status_transitions
-from robot_interface.models.exceptions.robot_exceptions import (
-    ErrorMessage,
-    RobotException,
-    RobotRetrieveInspectionException,
-)
-from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import TaskStatus
-from robot_interface.models.mission.task import TASKS, InspectionTask, Task
 from robot_interface.robot_interface import RobotInterface
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from robot_interface.telemetry.payloads import (
     InterventionNeededPayload,
     IsarStatusPayload,
     MissionAbortedPayload,
-    MissionPayload,
-    TaskPayload,
 )
 from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
@@ -69,7 +53,6 @@ class StateMachine(object):
         shared_state: SharedState,
         robot: RobotInterface,
         mqtt_publisher: MqttClientInterface,
-        task_selector: TaskSelectorInterface,
         sleep_time: float = settings.FSM_SLEEP_TIME,
         stop_robot_attempts_limit: int = settings.STOP_ROBOT_ATTEMPTS_LIMIT,
         transitions_log_length: int = settings.STATE_TRANSITIONS_LOG_LENGTH,
@@ -98,7 +81,6 @@ class StateMachine(object):
         self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.mqtt_publisher: Optional[MqttClientInterface] = mqtt_publisher
-        self.task_selector: TaskSelectorInterface = task_selector
 
         self.signal_state_machine_to_stop: Event = Event()
 
@@ -165,23 +147,14 @@ class StateMachine(object):
         self.stop_robot_attempts_limit: int = stop_robot_attempts_limit
         self.sleep_time: float = sleep_time
 
-        self.current_mission: Optional[Mission] = None
-        self.current_task: Optional[TASKS] = None
-
-        self.mission_ongoing: bool = False
-
         self.current_state: State = States(self.state)  # type: ignore
 
-        self.awaiting_task_status: bool = False
-
         self.transitions_log_length: int = transitions_log_length
         self.transitions_list: Deque[States] = deque([], self.transitions_log_length)
 
     #################################################################################
 
-    def _finalize(self) -> None:
-        self.publish_mission_status()
-        self.log_mission_overview(mission=self.current_mission)
+    def print_transitions(self) -> None:
         state_transitions: str = ", ".join(
             [
                 f"\n  {transition}" if (i + 1) % 10 == 0 else f"{transition}"
@@ -189,7 +162,7 @@ class StateMachine(object):
             ]
         )
         self.logger.info("State transitions:\n  %s", state_transitions)
-        self.reset_state_machine()
+        self.transitions = []
 
     def begin(self):
         """Starts the state machine. Transitions into unknown status state."""
@@ -199,20 +172,6 @@ class StateMachine(object):
         self.logger.info("Stopping state machine")
         self.signal_state_machine_to_stop.set()
 
-    def iterate_current_task(self):
-        if self.current_task is None:
-            raise ValueError("No current task is set")
-
-        if self.current_task.is_finished():
-            try:
-                self.current_task = self.task_selector.next_task()
-                self.current_task.status = TaskStatus.InProgress
-                self.publish_task_status(task=self.current_task)
-            except TaskSelectorStop:
-                # Indicates that all tasks are finished
-                self.current_task = None
-            self.send_task_status()
-
     def battery_level_is_above_mission_start_threshold(self):
         if not self.shared_state.robot_battery_level.check():
             self.logger.warning("Battery level is None")
@@ -226,45 +185,19 @@ class StateMachine(object):
         """Updates the current state of the state machine."""
         self.current_state = States(self.state)  # type: ignore
         self.shared_state.state.update(self.current_state)
-        self._log_state_transition(self.current_state)
+        self.transitions_list.append(self.current_state)
         self.logger.info("State: %s", self.current_state)
         self.publish_status()
 
-    def reset_state_machine(self) -> None:
-        self.logger.info("Resetting state machine")
-        self.current_task = None
-        self.send_task_status()
-        self.current_mission = None
-        self.mission_ongoing = False
-
     def start_mission(self, mission: Mission):
         """Starts a scheduled mission."""
-        self.current_mission = mission
-
-        self.task_selector.initialize(tasks=self.current_mission.tasks)
-
-    def send_task_status(self):
-        self.shared_state.state_machine_current_task.update(self.current_task)
-
-    def report_task_status(self, task: Task) -> None:
-        if task.status == TaskStatus.Failed:
-            self.logger.warning(
-                f"Task: {str(task.id)[:8]} was reported as failed by the robot"
-            )
-        elif task.status == TaskStatus.Successful:
-            self.logger.info(
-                f"{type(task).__name__} task: {str(task.id)[:8]} completed"
-            )
-        else:
-            self.logger.info(
-                f"Task: {str(task.id)[:8]} was reported as task.status by the robot"
-            )
+        self.events.state_machine_events.start_mission.trigger_event(mission)
 
     def publish_mission_aborted(self, reason: str, can_be_continued: bool) -> None:
         if not self.mqtt_publisher:
             return
 
-        if self.current_mission is None:
+        if self.shared_state.mission_id.check() is None:
             self.logger.warning(
                 "Could not publish mission aborted message. No ongoing mission."
             )
@@ -273,7 +206,7 @@ class StateMachine(object):
         payload: MissionAbortedPayload = MissionAbortedPayload(
             isar_id=settings.ISAR_ID,
             robot_name=settings.ROBOT_NAME,
-            mission_id=self.current_mission.id,
+            mission_id=self.shared_state.mission_id.check(),
             reason=reason,
             can_be_continued=can_be_continued,
             timestamp=datetime.now(timezone.utc),
@@ -286,68 +219,6 @@ class StateMachine(object):
             retain=True,
         )
 
-    def publish_mission_status(self) -> None:
-        if not self.mqtt_publisher:
-            return
-
-        error_message: Optional[ErrorMessage] = None
-        if self.current_mission:
-            if self.current_mission.error_message:
-                error_message = self.current_mission.error_message
-
-        payload: MissionPayload = MissionPayload(
-            isar_id=settings.ISAR_ID,
-            robot_name=settings.ROBOT_NAME,
-            mission_id=self.current_mission.id if self.current_mission else None,
-            status=self.current_mission.status if self.current_mission else None,
-            error_reason=error_message.error_reason if error_message else None,
-            error_description=(
-                error_message.error_description if error_message else None
-            ),
-            timestamp=datetime.now(timezone.utc),
-        )
-
-        if self.current_mission:
-            self.mqtt_publisher.publish(
-                topic=settings.TOPIC_ISAR_MISSION + f"/{self.current_mission.id}",
-                payload=json.dumps(payload, cls=EnhancedJSONEncoder),
-                qos=1,
-                retain=True,
-                properties=props_expiry(settings.MQTT_MISSION_AND_TASK_EXPIRY),
-            )
-
-    def publish_task_status(self, task: TASKS) -> None:
-        """Publishes the task status to the MQTT Broker"""
-        if not self.mqtt_publisher:
-            return
-
-        error_message: Optional[ErrorMessage] = None
-        if task:
-            if task.error_message:
-                error_message = task.error_message
-
-        payload: TaskPayload = TaskPayload(
-            isar_id=settings.ISAR_ID,
-            robot_name=settings.ROBOT_NAME,
-            mission_id=self.current_mission.id if self.current_mission else None,
-            task_id=task.id if task else None,
-            status=task.status if task else None,
-            task_type=task.type if task else None,
-            error_reason=error_message.error_reason if error_message else None,
-            error_description=(
-                error_message.error_description if error_message else None
-            ),
-            timestamp=datetime.now(timezone.utc),
-        )
-
-        self.mqtt_publisher.publish(
-            topic=settings.TOPIC_ISAR_TASK + f"/{task.id}",
-            payload=json.dumps(payload, cls=EnhancedJSONEncoder),
-            qos=1,
-            retain=True,
-            properties=props_expiry(settings.MQTT_MISSION_AND_TASK_EXPIRY),
-        )
-
     def publish_intervention_needed(self, error_message: str) -> None:
         """Publishes the intervention needed message to the MQTT Broker"""
         if not self.mqtt_publisher:
@@ -411,93 +282,6 @@ class StateMachine(object):
         else:
             return IsarStatus.Busy
 
-    def _log_state_transition(self, next_state) -> None:
-        """Logs all state transitions that are not self-transitions."""
-        self.transitions_list.append(next_state)
-
-    def log_mission_overview(self, mission: Mission) -> None:
-        """Log an overview of the tasks in a mission"""
-        log_statements: List[str] = []
-        for task in mission.tasks:
-            log_statements.append(
-                f"{type(task).__name__:<20} {str(task.id)[:8]:<32} -- {task.status}"
-            )
-        log_statement: str = "\n".join(log_statements)
-
-        self.logger.info("Mission overview:\n%s", log_statement)
-
-    def _make_control_mission_response(self) -> ControlMissionResponse:
-        return ControlMissionResponse(
-            mission_id=self.current_mission.id if self.current_mission else None,
-            mission_status=(
-                self.current_mission.status if self.current_mission else None
-            ),
-            task_id=self.current_task.id if self.current_task else None,
-            task_status=self.current_task.status if self.current_task else None,
-        )
-
-    def _queue_empty_response(self) -> None:
-        self.events.api_requests.stop_mission.response.trigger_event(
-            ControlMissionResponse(
-                mission_id="None",
-                mission_status="None",
-                task_id="None",
-                task_status="None",
-            )
-        )
-
-    def should_upload_inspections(self) -> bool:
-        if settings.UPLOAD_INSPECTIONS_ASYNC:
-            return False
-
-        return (
-            self.current_task.is_finished()
-            and self.current_task.status == TaskStatus.Successful
-            and isinstance(self.current_task, InspectionTask)
-        )
-
-    def queue_inspections_for_upload(
-        self, mission: Mission, current_task: InspectionTask, logger: logging.Logger
-    ) -> None:
-        try:
-            inspection: Inspection = self.robot.get_inspection(task=current_task)
-            if current_task.inspection_id != inspection.id:
-                logger.warning(
-                    f"The inspection_id of task ({current_task.inspection_id}) "
-                    f"and result ({inspection.id}) is not matching. "
-                    f"This may lead to confusions when accessing the inspection later"
-                )
-
-        except (RobotRetrieveInspectionException, RobotException) as e:
-            error_message: ErrorMessage = ErrorMessage(
-                error_reason=e.error_reason, error_description=e.error_description
-            )
-            self.current_task.error_message = error_message
-            logger.error(
-                f"Failed to retrieve inspections because: {e.error_description}"
-            )
-            return
-
-        except Exception as e:
-            logger.error(
-                f"Failed to retrieve inspections because of unexpected error: {e}"
-            )
-            return
-
-        if not inspection:
-            logger.warning(
-                f"No inspection result data retrieved for task {str(current_task.id)[:8]}"
-            )
-
-        inspection.metadata.tag_id = current_task.tag_id
-
-        message: Tuple[Inspection, Mission] = (
-            inspection,
-            mission,
-        )
-        self.events.upload_queue.put(message)
-        logger.info(f"Inspection result: {str(inspection.id)[:8]} queued for upload")
-
 
 def main(state_machine: StateMachine):
     """Starts a state machine instance."""

isar/state_machine/states/await_next_mission.py

@@ -27,12 +27,13 @@ class AwaitNextMission(EventHandlerBase):
             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
+            if not should_lockdown:
+                return None
+
+            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/going_to_lockdown.py

@@ -2,13 +2,9 @@ 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
+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.status import MissionStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -19,30 +15,33 @@ 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
+            if mission_failed is None:
+                return None
+
+            state_machine.logger.warning(
+                f"Failed to go to lockdown because: "
+                f"{mission_failed.error_description}"
+            )
+            return state_machine.lockdown_mission_failed  # 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:
+                    return state_machine.lockdown_mission_failed  # type: ignore
+
+                return state_machine.reached_lockdown  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [
@@ -59,18 +58,9 @@ class GoingToLockdown(EventHandlerBase):
                 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
-                ),
+                name="mission_status_event",
+                event=events.robot_service_events.mission_status_updated,
+                handler=_mission_status_event_handler,
             ),
         ]
         super().__init__(

isar/state_machine/states/home.py

@@ -22,21 +22,21 @@ class Home(EventHandlerBase):
 
         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
+            if not should_send_robot_home:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.reached_lockdown  # type: ignore
 
         def _robot_status_event_handler(
-            state_machine: "StateMachine",
             status_changed_event: Event[bool],
-            status_event: Event[RobotStatus],
         ) -> Optional[Callable]:
-            if not status_changed_event.consume_event():
+            has_changed = status_changed_event.consume_event()
+            if not has_changed:
                 return None
-            robot_status: Optional[RobotStatus] = status_event.check()
+            robot_status: Optional[RobotStatus] = shared_state.robot_status.check()
             if not (
                 robot_status == RobotStatus.Available
                 or robot_status == RobotStatus.Home
@@ -65,11 +65,7 @@ class Home(EventHandlerBase):
             EventHandlerMapping(
                 name="robot_status_event",
                 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,
-                ),
+                handler=_robot_status_event_handler,
             ),
             EventHandlerMapping(
                 name="send_to_lockdown_event",

isar/state_machine/states/intervention_needed.py

@@ -17,12 +17,13 @@ class InterventionNeeded(EventHandlerBase):
         def release_intervention_needed_handler(
             event: Event[bool],
         ) -> Optional[Callable]:
-            if event.consume_event():
-                state_machine.events.api_requests.release_intervention_needed.response.trigger_event(
-                    True
-                )
-                return state_machine.release_intervention_needed  # type: ignore
-            return None
+            if not event.consume_event():
+                return None
+
+            state_machine.events.api_requests.release_intervention_needed.response.trigger_event(
+                True
+            )
+            return state_machine.release_intervention_needed  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/lockdown.py

@@ -14,13 +14,14 @@ class Lockdown(EventHandlerBase):
 
         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
+            if not should_release_from_lockdown:
+                return None
+
+            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
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/monitor.py

@@ -1,19 +1,14 @@
-import logging
-from copy import deepcopy
 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.services.utilities.threaded_request import ThreadedRequest
 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.mission.status import TaskStatus
+from robot_interface.models.mission.status import MissionStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -22,56 +17,56 @@ if TYPE_CHECKING:
 class Monitor(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
-        logger = logging.getLogger("state_machine")
         events = state_machine.events
         shared_state = state_machine.shared_state
 
         def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
-                return state_machine.pause  # type: ignore
-            return None
-
-        def _handle_task_completed(task_status: TaskStatus):
-            if state_machine.should_upload_inspections():
-                get_inspection_thread = ThreadedRequest(
-                    state_machine.queue_inspections_for_upload
-                )
-                get_inspection_thread.start_thread(
-                    deepcopy(state_machine.current_mission),
-                    deepcopy(state_machine.current_task),
-                    logger,
-                    name="State Machine Get Inspections",
-                )
+            if not event.consume_event():
+                return None
 
-            state_machine.iterate_current_task()
-            if state_machine.current_task is None:
-                return state_machine.mission_finished  # type: ignore
-            return None
+            return state_machine.pause  # type: ignore
 
         def _robot_battery_level_updated_handler(
             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.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.logger.warning(
-                    "Cancelling current mission due to robot going to lockdown"
-                )
-                return state_machine.stop_go_to_lockdown  # type: ignore
+            if not should_lockdown:
+                return None
+
+            state_machine.logger.warning(
+                "Cancelling current mission due to robot going to lockdown"
+            )
+            return state_machine.stop_go_to_lockdown  # type: ignore
+
+        def _mission_status_event_handler(
+            event: Event[MissionStatus],
+        ) -> Optional[Callable]:
+            mission_status: Optional[MissionStatus] = event.consume_event()
+            if mission_status:
+                if mission_status not in [
+                    MissionStatus.InProgress,
+                    MissionStatus.NotStarted,
+                    MissionStatus.Paused,
+                ]:
+                    state_machine.logger.info(
+                        f"Mission completed with status {mission_status}"
+                    )
+                    return state_machine.mission_finished  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [
@@ -100,18 +95,9 @@ class Monitor(EventHandlerBase):
                 ),
             ),
             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="robot_battery_update_event",