isar 1.33.0__tar.gz → 1.33.1__tar.gz

{isar-1.33.0 → isar-1.33.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.0
+Version: 1.33.1
 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.33.0 → isar-1.33.1}/src/isar/apis/schedule/scheduling_controller.py

@@ -1,6 +1,5 @@
 import logging
 from http import HTTPStatus
-from threading import Lock
 
 from fastapi import Body, HTTPException, Path
 
@@ -29,7 +28,6 @@ class SchedulingController:
     ):
         self.scheduling_utilities: SchedulingUtilities = scheduling_utilities
         self.logger = logging.getLogger("api")
-        self.start_mission_lock: Lock = Lock()
 
     def start_mission_by_id(
         self,
@@ -77,67 +75,38 @@ class SchedulingController:
                 detail=error_message_no_mission_definition,
             )
 
-        if not self.start_mission_lock.acquire(blocking=False):
-            error_message_another_mission_starting: str = (
-                "Conflict - Another mission is currently being started"
-            )
-            self.logger.warning(error_message_another_mission_starting)
-            raise HTTPException(
-                status_code=HTTPStatus.CONFLICT,
-                detail=error_message_another_mission_starting,
-            )
+        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         try:
-            state: States = self.scheduling_utilities.get_state()
-            self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(
-                state
+            mission: Mission = to_isar_mission(
+                start_mission_definition=mission_definition
             )
-
-            try:
-                mission: Mission = to_isar_mission(
-                    start_mission_definition=mission_definition
-                )
-            except MissionPlannerError as e:
-                error_message = f"Bad Request - Cannot create ISAR mission: {e}"
-                self.logger.warning(error_message)
-                raise HTTPException(
-                    status_code=HTTPStatus.BAD_REQUEST,
-                    detail=error_message,
-                )
-
-            self.scheduling_utilities.verify_robot_capable_of_mission(
-                mission=mission, robot_capabilities=robot_settings.CAPABILITIES
+        except MissionPlannerError as e:
+            error_message = f"Bad Request - Cannot create ISAR mission: {e}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST,
+                detail=error_message,
             )
 
-            self.logger.info("Starting mission: %s", mission.id)
-            self.scheduling_utilities.start_mission(mission=mission)
-            return self._api_response(mission)
+        self.scheduling_utilities.verify_robot_capable_of_mission(
+            mission=mission, robot_capabilities=robot_settings.CAPABILITIES
+        )
 
-        finally:
-            self.start_mission_lock.release()
+        self.logger.info("Starting mission: %s", mission.id)
+        self.scheduling_utilities.start_mission(mission=mission)
+        return self._api_response(mission)
 
     def return_home(self) -> None:
         self.logger.info("Received request to return home")
 
-        if not self.start_mission_lock.acquire(blocking=False):
-            error_message_another_mission_starting: str = (
-                "Conflict - Another mission is currently being started"
-            )
-            self.logger.warning(error_message_another_mission_starting)
-            raise HTTPException(
-                status_code=HTTPStatus.CONFLICT,
-                detail=error_message_another_mission_starting,
-            )
-
-        try:
-            state: States = self.scheduling_utilities.get_state()
-            self.scheduling_utilities.verify_state_machine_ready_to_receive_return_home_mission(
-                state
-            )
+        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.verify_state_machine_ready_to_receive_return_home_mission(
+            state
+        )
 
-            self.scheduling_utilities.return_home()
-        finally:
-            self.start_mission_lock.release()
+        self.scheduling_utilities.return_home()
 
     def pause_mission(self) -> ControlMissionResponse:
         self.logger.info("Received request to pause current mission")

{isar-1.33.0 → isar-1.33.1}/src/isar/models/events.py

@@ -17,12 +17,15 @@ T2 = TypeVar("T2")
 
 
 class Event(Queue[T]):
-    def __init__(self) -> None:
+    def __init__(self, name: str) -> None:
         super().__init__(maxsize=1)
+        self.name = name
 
     def trigger_event(self, data: T, timeout: int = None) -> None:
         try:
-            self.put(data, timeout=timeout)
+            # We always want a timeout when blocking for results, so that
+            # the thread will never get stuck waiting for a result
+            self.put(data, block=timeout is not None, timeout=timeout)
         except Exception:
             if timeout is not None:
                 raise EventTimeoutError
@@ -79,46 +82,62 @@ class APIEvent(Generic[T1, T2]):
     api to state machine while the response is from state machine to api.
     """
 
-    def __init__(self):
-        self.request: Event[T1] = Event()
-        self.response: Event[T2] = Event()
+    def __init__(self, name: str):
+        self.request: Event[T1] = Event("api-" + name + "-request")
+        self.response: Event[T2] = Event("api-" + name + "-request")
 
 
 class APIRequests:
     def __init__(self) -> None:
-        self.start_mission: APIEvent[Mission, MissionStartResponse] = APIEvent()
-        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent()
-        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
-        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
-        self.return_home: APIEvent[bool, bool] = APIEvent()
-        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent()
+        self.start_mission: APIEvent[Mission, MissionStartResponse] = APIEvent(
+            "start_mission"
+        )
+        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent(
+            "stop_mission"
+        )
+        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "pause_mission"
+        )
+        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "resume_mission"
+        )
+        self.return_home: APIEvent[bool, bool] = APIEvent("return_home")
+        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent(
+            "release_intervention_needed"
+        )
 
 
 class StateMachineEvents:
     def __init__(self) -> None:
-        self.start_mission: Event[Mission] = Event()
-        self.stop_mission: Event[bool] = Event()
-        self.pause_mission: Event[bool] = Event()
-        self.task_status_request: Event[str] = Event()
+        self.start_mission: Event[Mission] = Event("start_mission")
+        self.stop_mission: Event[bool] = Event("stop_mission")
+        self.pause_mission: Event[bool] = Event("pause_mission")
+        self.task_status_request: Event[str] = Event("task_status_request")
 
 
 class RobotServiceEvents:
     def __init__(self) -> None:
-        self.task_status_updated: Event[TaskStatus] = Event()
-        self.task_status_failed: Event[ErrorMessage] = Event()
-        self.mission_started: Event[bool] = Event()
-        self.mission_failed: Event[ErrorMessage] = Event()
-        self.robot_status_changed: Event[bool] = Event()
-        self.mission_failed_to_stop: Event[ErrorMessage] = Event()
-        self.mission_successfully_stopped: Event[bool] = Event()
+        self.task_status_updated: Event[TaskStatus] = Event("task_status_updated")
+        self.task_status_failed: Event[ErrorMessage] = Event("task_status_failed")
+        self.mission_started: Event[bool] = Event("mission_started")
+        self.mission_failed: Event[ErrorMessage] = Event("mission_failed")
+        self.robot_status_changed: Event[bool] = Event("robot_status_changed")
+        self.mission_failed_to_stop: Event[ErrorMessage] = Event(
+            "mission_failed_to_stop"
+        )
+        self.mission_successfully_stopped: Event[bool] = Event(
+            "mission_successfully_stopped"
+        )
 
 
 class SharedState:
     def __init__(self) -> None:
-        self.state: Event[State] = Event()
-        self.robot_status: Event[RobotStatus] = Event()
-        self.state_machine_current_task: Event[TASKS] = Event()
-        self.robot_battery_level: Event[float] = Event()
+        self.state: Event[State] = Event("state")
+        self.robot_status: Event[RobotStatus] = Event("robot_status")
+        self.state_machine_current_task: Event[TASKS] = Event(
+            "state_machine_current_task"
+        )
+        self.robot_battery_level: Event[float] = Event("robot_battery_level")
 
 
 class EventTimeoutError(Exception):

{isar-1.33.0 → isar-1.33.1}/src/isar/services/utilities/scheduling_utilities.py

@@ -347,3 +347,6 @@ class SchedulingUtilities:
             api_event.request.clear_event()
             self.logger.error("No output received for command to state machine")
             raise e
+        finally:
+            api_event.request.clear_event()
+            api_event.response.clear_event()

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/state_machine.py

@@ -406,7 +406,7 @@ class StateMachine(object):
         )
 
     def _queue_empty_response(self) -> None:
-        self.events.api_requests.stop_mission.response.put(
+        self.events.api_requests.stop_mission.response.trigger_event(
             ControlMissionResponse(
                 mission_id="None",
                 mission_status="None",

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/states/monitor.py

@@ -60,9 +60,7 @@ class Monitor(EventHandlerBase):
                 state_machine.logger.warning(
                     "Cancelling current mission due to low battery"
                 )
-                state_machine.current_mission = None
-                state_machine.current_task = None
-                return state_machine.request_return_home  # type: ignore
+                return state_machine.stop  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/states/returning_home.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.apis.models.models import MissionStartResponse
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
-from isar.models.events import Event, EventTimeoutError
+from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     mission_failed_event_handler,
     mission_started_event_handler,
@@ -43,17 +43,14 @@ class ReturningHome(EventHandlerBase):
         ) -> Optional[Callable]:
             if event.has_event():
                 if not state_machine.battery_level_is_above_mission_start_threshold():
-                    try:
-                        state_machine.events.api_requests.start_mission.response.trigger_event(
-                            MissionStartResponse(
-                                mission_id=None,
-                                mission_started=False,
-                                mission_not_started_reason="Robot battery too low",
-                            ),
-                            timeout=1,  # This conflict can happen if two API requests are received at the same time
-                        )
-                    except EventTimeoutError:
-                        pass
+                    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  # type: ignore
             return None

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/states/stopping.py

@@ -1,9 +1,11 @@
 import logging
 from typing import TYPE_CHECKING, Callable, List, Optional
 
+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
@@ -15,6 +17,32 @@ class Stopping(EventHandlerBase):
         logger = logging.getLogger("state_machine")
         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
+            )
+            state_machine.publish_task_status(task=state_machine.current_task)
+            state_machine._finalize()
+            return None
+
         def _failed_stop_event_handler(
             event: Event[ErrorMessage],
         ) -> Optional[Callable]:
@@ -38,6 +66,11 @@ class Stopping(EventHandlerBase):
                 ):
                     return state_machine.return_home_mission_stopped  # type: ignore
                 else:
+                    _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
 

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/transitions/functions/pause.py

@@ -29,7 +29,7 @@ def pause_mission(state_machine: "StateMachine") -> bool:
             paused_mission_response: ControlMissionResponse = (
                 state_machine._make_control_mission_response()
             )
-            state_machine.events.api_requests.pause_mission.response.put(
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
                 paused_mission_response
             )
 

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/transitions/functions/resume.py

@@ -35,7 +35,7 @@ def resume_mission(state_machine: "StateMachine") -> bool:
             resume_mission_response: ControlMissionResponse = (
                 state_machine._make_control_mission_response()
             )
-            state_machine.events.api_requests.resume_mission.response.put(
+            state_machine.events.api_requests.resume_mission.response.trigger_event(
                 resume_mission_response
             )
 

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/transitions/functions/start_mission.py

@@ -13,7 +13,7 @@ from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def acknowledge_mission(state_machine: "StateMachine") -> bool:
-    state_machine.events.api_requests.start_mission.response.put(
+    state_machine.events.api_requests.start_mission.response.trigger_event(
         MissionStartResponse(mission_started=True)
     )
     return True
@@ -66,14 +66,14 @@ def set_mission_to_in_progress(state_machine: "StateMachine") -> bool:
 
 
 def trigger_start_mission_event(state_machine: "StateMachine") -> bool:
-    state_machine.events.state_machine_events.start_mission.put(
+    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.put(
+    state_machine.events.api_requests.start_mission.response.trigger_event(
         MissionStartResponse(
             mission_started=False,
             mission_not_started_reason="Failed to initialize robot",

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/transitions/functions/stop.py

@@ -12,38 +12,11 @@ def trigger_stop_mission_event(state_machine: "StateMachine") -> bool:
     return True
 
 
-def stop_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
-
-    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.put(
-        stopped_mission_response
-    )
-    state_machine.publish_task_status(task=state_machine.current_task)
-    state_machine._finalize()
-    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.response.put(
+    state_machine.events.api_requests.stop_mission.response.trigger_event(
         stopped_mission_response
     )
     return True
@@ -69,7 +42,7 @@ def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
         stopped_mission_response: ControlMissionResponse = (
             state_machine._make_control_mission_response()
         )
-        state_machine.events.api_requests.stop_mission.response.put(
+        state_machine.events.api_requests.stop_mission.response.trigger_event(
             stopped_mission_response
         )
 
@@ -83,7 +56,7 @@ def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
     stopped_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()
     )
-    state_machine.events.api_requests.stop_mission.response.put(
+    state_machine.events.api_requests.stop_mission.response.trigger_event(
         stopped_mission_response
     )
     return True

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/transitions/mission.py

@@ -14,7 +14,6 @@ from isar.state_machine.transitions.functions.start_mission import (
     trigger_start_mission_event,
 )
 from isar.state_machine.transitions.functions.stop import (
-    stop_mission_cleanup,
     stop_mission_failed,
     stop_return_home_mission_cleanup,
     stop_return_home_mission_failed,
@@ -66,7 +65,6 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "mission_stopped",
             "source": state_machine.stopping_state,
             "dest": state_machine.await_next_mission_state,
-            "before": def_transition(state_machine, stop_mission_cleanup),
         },
         {
             "trigger": "mission_stopping_failed",

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/transitions/return_home.py

@@ -31,13 +31,13 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
                 state_machine.robot_standing_still_state,
                 state_machine.intervention_needed_state,
                 state_machine.monitor_state,
+                state_machine.stopping_state,
             ],
             "dest": state_machine.returning_home_state,
             "conditions": [
                 def_transition(state_machine, start_return_home_mission),
                 def_transition(state_machine, set_return_home_status),
                 def_transition(state_machine, initialize_robot),
-                def_transition(state_machine, initialize_robot),
             ],
             "before": def_transition(state_machine, trigger_start_mission_event),
         },

{isar-1.33.0 → isar-1.33.1}/src/isar/state_machine/utils/common_event_handlers.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Callable, Optional
 
 from isar.apis.models.models import ControlMissionResponse, MissionStartResponse
-from isar.models.events import Event, EventTimeoutError
+from isar.models.events import Event
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.mission.mission import Mission
 from robot_interface.models.mission.status import RobotStatus, TaskStatus
@@ -18,17 +18,13 @@ def start_mission_event_handler(
     mission: Optional[Mission] = event.consume_event()
     if mission:
         if not state_machine.battery_level_is_above_mission_start_threshold():
-            try:
-                response.trigger_event(
-                    MissionStartResponse(
-                        mission_id=mission.id,
-                        mission_started=False,
-                        mission_not_started_reason="Robot battery too low",
-                    ),
-                    timeout=1,  # This conflict can happen if two API requests are received at the same time
+            response.trigger_event(
+                MissionStartResponse(
+                    mission_id=mission.id,
+                    mission_started=False,
+                    mission_not_started_reason="Robot battery too low",
                 )
-            except EventTimeoutError:
-                pass
+            )
             return None
         state_machine.start_mission(mission=mission)
         return state_machine.request_mission_start  # type: ignore
@@ -39,7 +35,7 @@ def return_home_event_handler(
     state_machine: "StateMachine", event: Event[bool]
 ) -> Optional[Callable]:
     if event.consume_event():
-        state_machine.events.api_requests.return_home.response.put(True)
+        state_machine.events.api_requests.return_home.response.trigger_event(True)
         return state_machine.request_return_home  # type: ignore
     return None
 
@@ -63,7 +59,7 @@ def stop_mission_event_handler(
         if state_machine.current_mission.id == mission_id or mission_id == "":
             return state_machine.stop  # type: ignore
         else:
-            state_machine.events.api_requests.stop_mission.response.put(
+            state_machine.events.api_requests.stop_mission.response.trigger_event(
                 ControlMissionResponse(
                     mission_id=mission_id,
                     mission_status=state_machine.current_mission.status,
@@ -80,6 +76,7 @@ def mission_started_event_handler(
     event: Event[bool],
 ) -> Optional[Callable]:
     if event.consume_event():
+        state_machine.logger.info("Received confirmation that mission has started")
         state_machine.mission_ongoing = True
     return None
 

{isar-1.33.0 → isar-1.33.1}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.0
+Version: 1.33.1
 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.33.0 → isar-1.33.1}/tests/isar/models/communication/test_events.py

@@ -25,19 +25,19 @@ class TestEvents:
 
 
 def test_staus_queue_empty() -> None:
-    status_event: Event = Event()
+    status_event: Event = Event("test")
     assert status_event.check() is None
 
 
 def test_status_event_check() -> None:
-    status_event: Event = Event()
+    status_event: Event = Event("test")
     status_event.update("Test")
     assert status_event.check() == "Test"
     assert status_event._qsize() == 1
 
 
 def test_status_event_update() -> None:
-    status_event: Event = Event()
+    status_event: Event = Event("test")
     status_event.update("Test")
     status_event.update("New Test")
     assert status_event._qsize() == 1

{isar-1.33.0 → isar-1.33.1}/tests/isar/services/utilities/test_queue_utilities.py

@@ -18,7 +18,7 @@ class TestQueueUtilities:
     def test_check_queue_with_queue_size_one(
         self, message, queue_timeout, expected_message
     ) -> None:
-        test_event: Event = Event()
+        test_event: Event = Event("test")
         if message is not None:
             test_event.put(message)
             message = test_event.consume_event(timeout=queue_timeout)
@@ -28,7 +28,7 @@ class TestQueueUtilities:
                 test_event.consume_event(timeout=queue_timeout)
 
     def test_clear_queue(self) -> None:
-        test_event: Event = Event()
+        test_event: Event = Event("test")
         test_event.put(1)
         test_event.clear_event()
         assert test_event.empty()

{isar-1.33.0 → isar-1.33.1}/tests/isar/services/utilities/test_scheduling_utilities.py

@@ -15,7 +15,7 @@ def test_timeout_send_command(
     mocker: MockerFixture, scheduling_utilities: SchedulingUtilities
 ):
     mocker.patch.object(Event, "consume_event", side_effect=EventTimeoutError)
-    q: APIEvent = APIEvent()
+    q: APIEvent = APIEvent("test")
     with pytest.raises(EventTimeoutError):
         scheduling_utilities._send_command(True, q)
     assert q.request.empty()

{isar-1.33.0 → isar-1.33.1}/tests/isar/state_machine/test_state_machine.py

@@ -233,7 +233,7 @@ def test_monitor_goes_to_return_home_when_battery_low(
     event_handler.event.trigger_event(10.0, timeout=1)
     transition = event_handler.handler(event_handler.event)
 
-    assert transition is state_machine.request_return_home  # type: ignore
+    assert transition is state_machine.stop  # type: ignore
     assert not state_machine.events.mqtt_queue.empty()
 
     mqtt_message = state_machine.events.mqtt_queue.get(block=False)