isar 1.30.4__tar.gz → 1.30.5__tar.gz

{isar-1.30.4 → isar-1.30.5}/.gitignore

@@ -137,3 +137,6 @@ dmypy.json
 # Temporary result folders
 results
 temp_results
+
+# MacOs file system
+.DS_Store

{isar-1.30.4 → isar-1.30.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.30.4
+Version: 1.30.5
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.30.4 → isar-1.30.5}/src/isar/apis/models/models.py

@@ -19,10 +19,10 @@ class StartMissionResponse(BaseModel):
 
 
 class ControlMissionResponse(BaseModel):
-    mission_id: str
-    mission_status: str
-    task_id: str
-    task_status: str
+    mission_id: Optional[str]
+    mission_status: Optional[str]
+    task_id: Optional[str]
+    task_status: Optional[str]
 
 
 class RobotInfoResponse(BaseModel):

{isar-1.30.4 → isar-1.30.5}/src/isar/services/utilities/scheduling_utilities.py

@@ -22,6 +22,7 @@ from isar.models.communication.queues.queue_timeout_error import QueueTimeoutErr
 from isar.services.utilities.queue_utilities import QueueUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import MissionStatus
 
 
 class SchedulingUtilities:
@@ -253,13 +254,21 @@ class SchedulingUtilities:
 
         Raises
         ------
-        HTTTPException 408 Request timeout
+        HTTPException 503 Service Unavailable
+            The request was understood, but attempting to stop the mission failed
+        HTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
         """
         try:
             stop_mission_response: ControlMissionResponse = self._send_command(
                 True, self.api_events.stop_mission
             )
+            if stop_mission_response.mission_status != MissionStatus.Cancelled.value:
+                error_message = "Failed to stop mission"
+                self.logger.error(error_message)
+                raise HTTPException(
+                    status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail=error_message
+                )
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to stop mission"
             self.logger.error(error_message)

{isar-1.30.4 → isar-1.30.5}/src/isar/state_machine/generic_states/ongoing_mission.py

@@ -54,7 +54,7 @@ class OngoingMission:
         self._run()
 
     def stop(self) -> None:
-        self.state_machine.mission_ongoing = False
+        return
 
     def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
         if check_for_event(event):

{isar-1.30.4 → isar-1.30.5}/src/isar/state_machine/state_machine.py

@@ -194,6 +194,7 @@ class StateMachine(object):
         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."""
@@ -316,17 +317,13 @@ class StateMachine(object):
         self.logger.info("Mission overview:\n%s", log_statement)
 
     def _make_control_mission_response(self) -> ControlMissionResponse:
-        if self.current_mission is None:
-            raise ValueError("No current mission is set")
-
-        if self.current_task is None:
-            raise ValueError("No current task is set")
-
         return ControlMissionResponse(
-            mission_id=self.current_mission.id,
-            mission_status=self.current_mission.status,
-            task_id=self.current_task.id,
-            task_status=self.current_task.status,
+            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:

{isar-1.30.4 → isar-1.30.5}/src/isar/state_machine/states/stopping.py

@@ -39,9 +39,9 @@ class Stopping(State):
         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_stopped()  # type: ignore
+                self.state_machine.return_home_mission_stopping_failed()  # type: ignore
             else:
-                self.state_machine.mission_stopped()  # type: ignore
+                self.state_machine.mission_stopping_failed()  # type: ignore
             return True
         return False
 

{isar-1.30.4 → isar-1.30.5}/src/isar/state_machine/transitions/functions/stop.py

@@ -1,6 +1,9 @@
 from typing import TYPE_CHECKING
 
-from isar.models.communication.queues.queue_utils import trigger_event_without_data
+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
@@ -39,11 +42,51 @@ def stop_mission_cleanup(state_machine: "StateMachine") -> bool:
     return True
 
 
+def stop_mission_failed(state_machine: "StateMachine") -> bool:
+    stopped_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.stop_mission.output.put(stopped_mission_response)
+    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 check_for_event_without_consumption(
+        state_machine.events.api_requests.start_mission.input
+    ):
+        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.output.put(
+            stopped_mission_response
+        )
+
     state_machine._finalize()
     return True
+
+
+def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
+    if check_for_event_without_consumption(
+        state_machine.events.api_requests.start_mission.input
+    ):
+        return True
+    stopped_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.stop_mission.output.put(stopped_mission_response)
+    return True

{isar-1.30.4 → isar-1.30.5}/src/isar/state_machine/transitions/mission.py

@@ -15,7 +15,9 @@ from isar.state_machine.transitions.functions.start_mission import (
 )
 from isar.state_machine.transitions.functions.stop import (
     stop_mission_cleanup,
+    stop_mission_failed,
     stop_return_home_mission_cleanup,
+    stop_return_home_mission_failed,
     trigger_stop_mission_event,
 )
 from isar.state_machine.transitions.functions.utils import def_transition
@@ -56,6 +58,18 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, stop_mission_cleanup),
         },
+        {
+            "trigger": "mission_stopping_failed",
+            "source": state_machine.stopping_state,
+            "dest": state_machine.monitor_state,
+            "before": def_transition(state_machine, stop_mission_failed),
+        },
+        {
+            "trigger": "return_home_mission_stopping_failed",
+            "source": state_machine.stopping_state,
+            "dest": state_machine.returning_home_state,
+            "before": def_transition(state_machine, stop_return_home_mission_failed),
+        },
         {
             "trigger": "return_home_mission_stopped",
             "source": state_machine.stopping_state,

{isar-1.30.4 → isar-1.30.5}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.30.4
+Version: 1.30.5
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.30.4 → isar-1.30.5}/tests/isar/apis/scheduler/test_scheduler_router.py

@@ -16,6 +16,7 @@ from isar.state_machine.states_enum import States
 from tests.test_double.mission_definition import DummyMissionDefinition
 
 dummy_mission = DummyMissionDefinition.default_mission
+dummy_mission_stopped = DummyMissionDefinition.stopped_mission
 
 mock_return_unknown_status = mock.Mock(return_value=States.UnknownStatus)
 mock_return_robot_standing_still = mock.Mock(return_value=States.RobotStandingStill)
@@ -34,9 +35,18 @@ dummy_control_mission_response = ControlMissionResponse(
     task_id=dummy_task.id,
     task_status=dummy_task.status,
 )
+dummy_stopped_control_mission_response = ControlMissionResponse(
+    mission_id=dummy_mission_stopped.id,
+    mission_status=dummy_mission_stopped.status,
+    task_id=dummy_mission_stopped.tasks[0].id,
+    task_status=dummy_mission_stopped.tasks[0].status,
+)
 mock_return_control_mission_response = mock.Mock(
     return_value=dummy_control_mission_response
 )
+mock_return_stopped_control_mission_response = mock.Mock(
+    return_value=dummy_stopped_control_mission_response
+)
 mock_queue_timeout_error = mock.Mock(side_effect=QueueTimeoutError)
 mock_mission_planner_error = mock.Mock(side_effect=MissionPlannerError)
 
@@ -255,7 +265,9 @@ class TestStopMission:
 
     @pytest.mark.parametrize("state", valid_states)
     @mock.patch.object(
-        SchedulingUtilities, "_send_command", mock_return_control_mission_response
+        SchedulingUtilities,
+        "_send_command",
+        mock_return_stopped_control_mission_response,
     )
     def test_stop_mission(
         self, client: TestClient, state: States, mocker: MockerFixture
@@ -263,7 +275,9 @@ class TestStopMission:
         mocker.patch.object(SchedulingUtilities, "get_state", return_value=state)
         response = client.post(url=self.schedule_stop_mission_path)
         assert response.status_code == HTTPStatus.OK
-        assert response.json() == jsonable_encoder(dummy_control_mission_response)
+        assert response.json() == jsonable_encoder(
+            dummy_stopped_control_mission_response
+        )
 
     @mock.patch.object(SchedulingUtilities, "get_state", mock_return_unknown_status)
     @mock.patch.object(

{isar-1.30.4 → isar-1.30.5}/tests/isar/state_machine/test_state_machine.py

@@ -1,11 +1,16 @@
 import time
 from collections import deque
+from http import HTTPStatus
 from threading import Thread
 from typing import List
 
 import pytest
+from fastapi import HTTPException
 from pytest_mock import MockerFixture
 
+from isar.models.communication.queues.queue_utils import (
+    check_for_event_without_consumption,
+)
 from isar.modules import ApplicationContainer
 from isar.robot.robot import Robot
 from isar.robot.robot_status import RobotStatusThread
@@ -122,7 +127,6 @@ def test_state_machine_failed_dependency(
     robot_service_thread: RobotServiceThreadMock,
     mocker,
 ) -> None:
-
     state_machine_thread.state_machine.await_next_mission_state.return_home_delay = 0.1
 
     mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.Failed)
@@ -250,7 +254,6 @@ def test_state_machine_with_successful_mission_stop(
     uploader_thread: UploaderThreadMock,
     mocker,
 ) -> None:
-
     mocker.patch.object(StubRobot, "robot_status", return_value=RobotStatus.Home)
     mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
 
@@ -303,19 +306,19 @@ def test_state_machine_with_unsuccessful_mission_stop(
 
     state_machine_thread.state_machine.sleep_time = 0
 
-    state_machine_thread.state_machine.await_next_mission_state.return_home_delay = 10  # Return home delay is set to 10 seconds to avoid the state machine triggering return home within the test duration
     state_machine_thread.start()
     robot_service_thread.start()
 
     scheduling_utilities.start_mission(mission=mission)
     time.sleep(1)
-    scheduling_utilities.stop_mission()
-    time.sleep(3)
+    with pytest.raises(HTTPException) as exception_details:
+        scheduling_utilities.stop_mission()
 
     expected_log = (
         "Be aware that the robot may still be "
         "moving even though a stop has been attempted"
     )
+    assert exception_details.value.status_code == HTTPStatus.SERVICE_UNAVAILABLE.value
     assert expected_log in caplog.text
     assert state_machine_thread.state_machine.transitions_list == deque(
         [
@@ -323,11 +326,114 @@ def test_state_machine_with_unsuccessful_mission_stop(
             States.RobotStandingStill,
             States.Monitor,
             States.Stopping,
-            States.AwaitNextMission,
+            States.Monitor,
+        ]
+    )
+
+
+def test_state_machine_with_unsuccessful_return_home_stop(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    caplog: pytest.LogCaptureFixture,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
+    mocker.patch.object(
+        StubRobot, "stop", side_effect=_mock_robot_exception_with_message
+    )
+
+    state_machine_thread.state_machine.sleep_time = 0
+
+    state_machine_thread.start()
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(1)
+    with pytest.raises(HTTPException) as exception_details:
+        scheduling_utilities.stop_mission()
+
+    expected_log = (
+        "Be aware that the robot may still be "
+        "moving even though a stop has been attempted"
+    )
+    assert exception_details.value.status_code == HTTPStatus.SERVICE_UNAVAILABLE.value
+    assert expected_log in caplog.text
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.Stopping,
+            States.ReturningHome,
+        ]
+    )
+
+
+def test_state_machine_with_successful_return_home_stop(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
+
+    state_machine_thread.state_machine.sleep_time = 0
+
+    state_machine_thread.start()
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(1)
+    scheduling_utilities.stop_mission()
+
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.Stopping,
+            States.RobotStandingStill,
         ]
     )
 
 
+def test_state_machine_with_mission_start_during_return_home_without_queueing_stop_response(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    mission: Mission = Mission(name="Dummy misson", tasks=[StubTask.take_image()])
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
+
+    state_machine_thread.state_machine.sleep_time = 0
+
+    state_machine_thread.start()
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(1)
+    scheduling_utilities.start_mission(mission=mission)
+
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.Stopping,
+            States.RobotStandingStill,
+            States.Monitor,
+        ]
+    )
+    assert not check_for_event_without_consumption(
+        state_machine_thread.state_machine.events.api_requests.start_mission.input
+    )
+
+
 def test_state_machine_offline_to_robot_standing_still(
     state_machine_thread, robot_service_thread, mocker
 ) -> None:

{isar-1.30.4 → isar-1.30.5}/tests/test_double/mission_definition.py

@@ -12,6 +12,7 @@ from isar.apis.models.start_mission_definition import (
     StartMissionTaskDefinition,
 )
 from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
 from tests.test_double.task import StubTask
 
 
@@ -32,6 +33,15 @@ class DummyMissionDefinition:
             dummy_task_take_image,
         ],
     )
+    dummy_task_take_image_cancelled = StubTask.take_image(status=TaskStatus.Cancelled)
+    stopped_mission = Mission(
+        id="default_mission",
+        name="Dummy misson",
+        tasks=[
+            dummy_task_take_image_cancelled,
+        ],
+        status=MissionStatus.Cancelled,
+    )
     dummy_start_mission_inspection_definition = StartMissionInspectionDefinition(
         type=InspectionTypes.image,
         inspection_target=dummy_input_target_position,

{isar-1.30.4 → isar-1.30.5}/tests/test_double/task.py

@@ -1,15 +1,16 @@
 from alitra import Frame, Orientation, Pose, Position
 
+from robot_interface.models.mission.status import TaskStatus
 from robot_interface.models.mission.task import TakeImage
 
 
 class StubTask:
     @staticmethod
-    def take_image() -> TakeImage:
+    def take_image(status: TaskStatus = TaskStatus.NotStarted) -> TakeImage:
         target_pose = Position(x=1, y=1, z=1, frame=Frame("robot"))
         robot_pose = Pose(
             position=Position(x=0, y=0, z=1, frame=Frame("robot")),
             orientation=Orientation(x=0, y=0, z=0, w=1, frame=Frame("robot")),
             frame=Frame("robot"),
         )
-        return TakeImage(target=target_pose, robot_pose=robot_pose)
+        return TakeImage(target=target_pose, robot_pose=robot_pose, status=status)