isar 1.33.9__py3-none-any.whl → 1.34.1__py3-none-any.whl

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
@@ -29,20 +24,6 @@ class ReturningHome(EventHandlerBase):
 
             return state_machine.pause_return_home  # type: ignore
 
-        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 state_machine.battery_level_is_above_mission_start_threshold():
-                return state_machine.starting_recharging  # type: ignore
-            else:
-                return state_machine.returned_home  # type: ignore
-
         def _start_mission_event_handler(
             event: Event[Mission],
         ) -> Optional[Callable]:
@@ -63,6 +44,27 @@ class ReturningHome(EventHandlerBase):
 
             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():
+                    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]:
@@ -75,6 +77,18 @@ class ReturningHome(EventHandlerBase):
             )
             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.return_home_failed  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="pause_mission_event",
@@ -91,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",
@@ -101,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,29 +15,10 @@ 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(

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,25 +14,6 @@ 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]:
@@ -54,7 +34,7 @@ class StoppingGoToLockdown(EventHandlerBase):
                 return None
 
             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)
             )

isar/state_machine/states/stopping_return_home.py

@@ -45,8 +45,6 @@ class StoppingReturnHome(EventHandlerBase):
                 state_machine.events.api_requests.start_mission.request.consume_event()
             )
 
-            state_machine.reset_state_machine()
-
             if mission:
                 state_machine.start_mission(mission=mission)
                 return state_machine.request_mission_start  # type: ignore

isar/state_machine/transitions/functions/fail_mission.py

@@ -3,21 +3,13 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
-
-
-def report_failed_mission_and_finalize(state_machine: "StateMachine") -> None:
-    state_machine.current_task.status = TaskStatus.Failed
-    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)
+    state_machine.print_transitions()
 
 
 def report_failed_lockdown_and_intervention_needed(

isar/state_machine/transitions/functions/finish_mission.py

@@ -1,39 +1,9 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
-from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
-
 
 def finish_mission(state_machine: "StateMachine") -> bool:
-    fail_statuses: List[TaskStatus] = [
-        TaskStatus.Cancelled,
-        TaskStatus.Failed,
-    ]
-    partially_fail_statuses = fail_statuses + [TaskStatus.PartiallySuccessful]
-
-    if len(state_machine.current_mission.tasks) == 0:
-        state_machine.current_mission.status = MissionStatus.Successful
-    elif all(
-        task.status in fail_statuses for task in state_machine.current_mission.tasks
-    ):
-        state_machine.current_mission.error_message = ErrorMessage(
-            error_reason=None,
-            error_description="The mission failed because all tasks in the mission "
-            "failed",
-        )
-        state_machine.current_mission.status = MissionStatus.Failed
-    elif any(
-        task.status in partially_fail_statuses
-        for task in state_machine.current_mission.tasks
-    ):
-        state_machine.current_mission.status = MissionStatus.PartiallySuccessful
-    else:
-        state_machine.current_mission.status = MissionStatus.Successful
-    state_machine._finalize()
-
-    state_machine.current_task = None
-    state_machine.send_task_status()
+    state_machine.print_transitions()
     return True

isar/state_machine/transitions/functions/pause.py

@@ -12,18 +12,19 @@ def trigger_pause_mission_event(state_machine: "StateMachine") -> bool:
 
 
 def pause_mission_failed(state_machine: "StateMachine") -> bool:
-    paused_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
-    )
     state_machine.events.api_requests.pause_mission.response.trigger_event(
-        paused_mission_response
+        ControlMissionResponse(
+            success=False, failure_reason="Failed to pause mission in ISAR"
+        )
     )
     return True
 
 
-def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
-    paused_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
+def pause_return_home_mission_failed(state_machine: "StateMachine") -> bool:
+    if state_machine.events.api_requests.start_mission.request.has_event():
+        return True
+    paused_mission_response: ControlMissionResponse = ControlMissionResponse(
+        success=False, failure_reason="ISAR failed to pause return home"
     )
     state_machine.events.api_requests.pause_mission.response.trigger_event(
         paused_mission_response

isar/state_machine/transitions/functions/resume.py

@@ -11,11 +11,10 @@ from robot_interface.models.exceptions.robot_exceptions import (
     RobotActionException,
     RobotException,
 )
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def resume_mission(state_machine: "StateMachine") -> bool:
-    state_machine.logger.info("Resuming mission: %s", state_machine.current_mission.id)
+    state_machine.logger.info("Resuming mission")
 
     max_retries = settings.STATE_TRANSITION_NUM_RETIRES
     retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
@@ -23,17 +22,9 @@ def resume_mission(state_machine: "StateMachine") -> bool:
     for attempt in range(max_retries):
         try:
             state_machine.robot.resume()
-            state_machine.current_mission.status = MissionStatus.InProgress
-            state_machine.current_mission.error_message = None
-            state_machine.current_task.status = TaskStatus.InProgress
 
-            state_machine.mission_ongoing = True
-
-            state_machine.publish_mission_status()
-            state_machine.publish_task_status(task=state_machine.current_task)
-
-            resume_mission_response: ControlMissionResponse = (
-                state_machine._make_control_mission_response()
+            resume_mission_response: ControlMissionResponse = ControlMissionResponse(
+                success=True
             )
             state_machine.events.api_requests.resume_mission.response.trigger_event(
                 resume_mission_response

isar/state_machine/transitions/functions/return_home.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 from isar.config.settings import settings
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import MissionStatus, RobotStatus, TaskStatus
+from robot_interface.models.mission.status import RobotStatus
 from robot_interface.models.mission.task import ReturnToHome
 
 if TYPE_CHECKING:
@@ -37,18 +37,3 @@ def should_retry_return_home(state_machine: "StateMachine") -> bool:
 def reset_return_home_failure_counter(state_machine: "StateMachine") -> bool:
     state_machine.returning_home_state.failed_return_home_attemps = 0
     return True
-
-
-def set_return_home_status(state_machine: "StateMachine") -> bool:
-    state_machine.log_mission_overview(mission=state_machine.current_mission)
-    state_machine.current_mission.status = MissionStatus.InProgress
-
-    state_machine.current_task = state_machine.task_selector.next_task()
-    state_machine.current_task.status = TaskStatus.InProgress
-
-    return True
-
-
-def return_home_finished(state_machine: "StateMachine") -> bool:
-    state_machine.reset_state_machine()
-    return True

isar/state_machine/transitions/functions/robot_status.py

@@ -1,7 +1,5 @@
-import time
 from typing import TYPE_CHECKING
 
-from isar.config.settings import settings
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -13,6 +11,11 @@ def is_offline(state_machine: "StateMachine") -> bool:
     return robot_status == RobotStatus.Offline
 
 
+def is_available(state_machine: "StateMachine") -> bool:
+    robot_status = state_machine.shared_state.robot_status.check()
+    return robot_status == RobotStatus.Available
+
+
 def is_available_or_home(state_machine: "StateMachine") -> bool:
     robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.Available or robot_status == RobotStatus.Home
@@ -24,13 +27,5 @@ def is_blocked_protective_stop(state_machine: "StateMachine") -> bool:
 
 
 def clear_robot_status(state_machine: "StateMachine") -> bool:
-    state_machine.events.state_machine_events.clear_robot_status.trigger_event(True)
-    start_time: float = time.time()
-    while time.time() - start_time < settings.CLEAR_ROBOT_STATUS_TIMEOUT:
-        if (
-            state_machine.events.robot_service_events.robot_status_cleared.consume_event()
-        ):
-            return True
-        time.sleep(settings.FSM_SLEEP_TIME)
-    state_machine.logger.error("Timed out waiting for robot status to be cleared")
-    return False
+    state_machine.events.robot_service_events.robot_status_changed.clear_event()
+    return True

isar/state_machine/transitions/functions/start_mission.py

@@ -5,11 +5,9 @@ if TYPE_CHECKING:
 
 from isar.apis.models.models import MissionStartResponse
 from robot_interface.models.exceptions.robot_exceptions import (
-    ErrorMessage,
     RobotException,
     RobotInitializeException,
 )
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def acknowledge_mission(state_machine: "StateMachine") -> bool:
@@ -19,59 +17,19 @@ def acknowledge_mission(state_machine: "StateMachine") -> bool:
     return True
 
 
-def prepare_state_machine_before_mission(state_machine: "StateMachine") -> bool:
-    state_machine.logger.info(
-        "Initiating mission:\n"
-        f"  Mission ID: {state_machine.current_mission.id}\n"
-        f"  Mission Name: {state_machine.current_mission.name}\n"
-        f"  Number of Tasks: {len(state_machine.current_mission.tasks)}"
-    )
-
-    state_machine.current_mission.status = MissionStatus.InProgress
-    state_machine.publish_mission_status()
-    state_machine.current_task = state_machine.task_selector.next_task()
-    state_machine.send_task_status()
-    if state_machine.current_task is None:
-        return False
-
-    state_machine.current_task.status = TaskStatus.InProgress
-    state_machine.publish_task_status(task=state_machine.current_task)
-    return True
-
-
 def initialize_robot(state_machine: "StateMachine") -> bool:
     try:
         state_machine.robot.initialize()
     except (RobotInitializeException, RobotException) as e:
-        state_machine.current_task.error_message = ErrorMessage(
-            error_reason=e.error_reason, error_description=e.error_description
-        )
         state_machine.logger.error(
             f"Failed to initialize robot because: {e.error_description}"
         )
         _initialization_failed(state_machine)
+        state_machine.print_transitions()
         return False
     return True
 
 
-def set_mission_to_in_progress(state_machine: "StateMachine") -> bool:
-    state_machine.current_mission.status = MissionStatus.InProgress
-    state_machine.publish_task_status(task=state_machine.current_task)
-    state_machine.logger.info(
-        f"Successfully initiated "
-        f"{type(state_machine.current_task).__name__} "
-        f"task: {str(state_machine.current_task.id)[:8]}"
-    )
-    return True
-
-
-def trigger_start_mission_event(state_machine: "StateMachine") -> bool:
-    state_machine.events.state_machine_events.start_mission.trigger_event(
-        state_machine.current_mission
-    )
-    return True
-
-
 def _initialization_failed(state_machine: "StateMachine") -> None:
     state_machine.events.api_requests.start_mission.response.trigger_event(
         MissionStartResponse(
@@ -79,4 +37,4 @@ def _initialization_failed(state_machine: "StateMachine") -> None:
             mission_not_started_reason="Failed to initialize robot",
         )
     )
-    state_machine._finalize()
+    state_machine.print_transitions()

isar/state_machine/transitions/functions/stop.py

@@ -4,7 +4,6 @@ if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 from isar.apis.models.models import ControlMissionResponse
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def trigger_stop_mission_event(state_machine: "StateMachine") -> bool:
@@ -13,8 +12,8 @@ def trigger_stop_mission_event(state_machine: "StateMachine") -> bool:
 
 
 def stop_mission_failed(state_machine: "StateMachine") -> bool:
-    stopped_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
+    stopped_mission_response: ControlMissionResponse = ControlMissionResponse(
+        success=False, failure_reason="ISAR failed to stop mission"
     )
     state_machine.events.api_requests.stop_mission.response.trigger_event(
         stopped_mission_response
@@ -22,39 +21,11 @@ def stop_mission_failed(state_machine: "StateMachine") -> bool:
     return True
 
 
-def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
-    if state_machine.current_mission is None:
-        state_machine._queue_empty_response()
-        state_machine.reset_state_machine()
-        return True
-
-    if not state_machine.events.api_requests.start_mission.request.has_event():
-        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
-        )
-
-    state_machine._finalize()
-    return True
-
-
 def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
     if state_machine.events.api_requests.start_mission.request.has_event():
         return True
-    stopped_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
+    stopped_mission_response: ControlMissionResponse = ControlMissionResponse(
+        success=False, failure_reason="ISAR failed to stop return home"
     )
     state_machine.events.api_requests.stop_mission.response.trigger_event(
         stopped_mission_response

isar/state_machine/transitions/mission.py

@@ -1,24 +1,18 @@
 from typing import TYPE_CHECKING, List
 
-from isar.state_machine.transitions.functions.fail_mission import (
-    report_failed_mission_and_finalize,
-)
 from isar.state_machine.transitions.functions.finish_mission import finish_mission
 from isar.state_machine.transitions.functions.pause import (
     pause_mission_failed,
+    pause_return_home_mission_failed,
     trigger_pause_mission_event,
 )
 from isar.state_machine.transitions.functions.resume import resume_mission
 from isar.state_machine.transitions.functions.return_home import (
     reset_return_home_failure_counter,
-    return_home_finished,
 )
 from isar.state_machine.transitions.functions.start_mission import (
     acknowledge_mission,
     initialize_robot,
-    prepare_state_machine_before_mission,
-    set_mission_to_in_progress,
-    trigger_start_mission_event,
 )
 from isar.state_machine.transitions.functions.stop import (
     stop_mission_failed,
@@ -63,7 +57,7 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "return_home_mission_pausing_failed",
             "source": state_machine.pausing_return_home_state,
             "dest": state_machine.returning_home_state,
-            "before": def_transition(state_machine, stop_return_home_mission_failed),
+            "before": def_transition(state_machine, pause_return_home_mission_failed),
         },
         {
             "trigger": "return_home_mission_paused",
@@ -126,7 +120,6 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "before": [
                 def_transition(state_machine, trigger_stop_mission_event),
                 def_transition(state_machine, reset_return_home_failure_counter),
-                def_transition(state_machine, return_home_finished),
             ],
         },
         {
@@ -166,31 +159,23 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.monitor_state,
             "prepare": def_transition(state_machine, acknowledge_mission),
             "conditions": [
-                def_transition(state_machine, prepare_state_machine_before_mission),
                 def_transition(state_machine, initialize_robot),
             ],
-            "before": [
-                def_transition(state_machine, set_mission_to_in_progress),
-                def_transition(state_machine, trigger_start_mission_event),
-            ],
         },
         {
             "trigger": "request_mission_start",
             "source": state_machine.await_next_mission_state,
             "dest": state_machine.await_next_mission_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
         {
             "trigger": "request_mission_start",
             "source": state_machine.home_state,
             "dest": state_machine.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],
             "dest": state_machine.await_next_mission_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
         {
             "trigger": "mission_finished",