isar 1.33.9__tar.gz → 1.34.0__tar.gz

{isar-1.33.9 → isar-1.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.9
+Version: 1.34.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -402,68 +402,6 @@ You can create your own storage module by implementing the [storage interface](.
 and adding your storage module to the selection [here](./src/isar/modules.py). Note that you must add your module as an
 option in the dictionary.
 
-## Task selection
-
-The tasks of a mission are selected based on a task selector module, defined by the `TASK_SELECTOR` configuration variable. The default task selector is `sequential`. When using the default module, tasks are executed in sequential order defined by the current input mission.
-
-### Implement you own task selector module
-
-Custom task selector modules may be added by implementing additional versions of the [task selector interface](./src/isar/mission_planner/task_selector_interface.py).
-
-For every custom module, the interface function `next_task()` must be implemented. All interface implementations by default have access to the list of tasks in the current mission through the member `self.tasks`, however additional variables may be supplied by adding arguments to `next_task()`. To comply with the interface definition, the function should return the next task upon every call, and raise the `TaskSelectorStop` exception when all tasks in the current mission have been completed:
-
-```python
-class CustomTaskSelector(TaskSelectorInterface):
-    ...
-    def next_task(...) -> Task:
-
-        # Add code here
-        ...
-
-        # Raise `TaskSelectorStop` when all tasks have been completed
-        ...
-```
-
-Optionally, the `initialize()` function may be extended by supplementing the parameter list or function body:
-
-```python
-class CustomTaskSelector(TaskSelectorInterface):
-    ...
-    def initialize(self, tasks: List[Task], ...) -> None:
-        super.initialize(tasks=tasks)
-
-        # Add supplementary code here
-        ...
-```
-
-A custom task selector may be made available during [module selection](./src/isar/modules.py) by adding it to the series of options in the dictionary of injector modules. It can then be activated by overriding the task selector configuration variable:
-
-```python
-# Add custom task selector module to `modules.py`
-
-class CustomTaskSelectorModule(Module):
-    @provider
-    @singleton
-    def provide_task_selector(self) -> TaskSelectorInterface:
-        return CustomTaskSelector()
-
-...
-
-# Make it available to select during injector instantiation
-
-modules: dict[str, tuple[Module, Union[str, bool]]] = {
-    ...
-    "task_selector": (
-        {
-            "sequential": SequentialTaskSelectorModule,
-            "custom": CustomTaskSelectorModule
-        }
-        ...
-    )
-    ...
-}
-```
-
 ## API authentication
 
 The API has an option to include user authentication. This can be enabled by setting the environment variable

{isar-1.33.9 → isar-1.34.0}/README.md

@@ -258,68 +258,6 @@ You can create your own storage module by implementing the [storage interface](.
 and adding your storage module to the selection [here](./src/isar/modules.py). Note that you must add your module as an
 option in the dictionary.
 
-## Task selection
-
-The tasks of a mission are selected based on a task selector module, defined by the `TASK_SELECTOR` configuration variable. The default task selector is `sequential`. When using the default module, tasks are executed in sequential order defined by the current input mission.
-
-### Implement you own task selector module
-
-Custom task selector modules may be added by implementing additional versions of the [task selector interface](./src/isar/mission_planner/task_selector_interface.py).
-
-For every custom module, the interface function `next_task()` must be implemented. All interface implementations by default have access to the list of tasks in the current mission through the member `self.tasks`, however additional variables may be supplied by adding arguments to `next_task()`. To comply with the interface definition, the function should return the next task upon every call, and raise the `TaskSelectorStop` exception when all tasks in the current mission have been completed:
-
-```python
-class CustomTaskSelector(TaskSelectorInterface):
-    ...
-    def next_task(...) -> Task:
-
-        # Add code here
-        ...
-
-        # Raise `TaskSelectorStop` when all tasks have been completed
-        ...
-```
-
-Optionally, the `initialize()` function may be extended by supplementing the parameter list or function body:
-
-```python
-class CustomTaskSelector(TaskSelectorInterface):
-    ...
-    def initialize(self, tasks: List[Task], ...) -> None:
-        super.initialize(tasks=tasks)
-
-        # Add supplementary code here
-        ...
-```
-
-A custom task selector may be made available during [module selection](./src/isar/modules.py) by adding it to the series of options in the dictionary of injector modules. It can then be activated by overriding the task selector configuration variable:
-
-```python
-# Add custom task selector module to `modules.py`
-
-class CustomTaskSelectorModule(Module):
-    @provider
-    @singleton
-    def provide_task_selector(self) -> TaskSelectorInterface:
-        return CustomTaskSelector()
-
-...
-
-# Make it available to select during injector instantiation
-
-modules: dict[str, tuple[Module, Union[str, bool]]] = {
-    ...
-    "task_selector": (
-        {
-            "sequential": SequentialTaskSelectorModule,
-            "custom": CustomTaskSelectorModule
-        }
-        ...
-    )
-    ...
-}
-```
-
 ## API authentication
 
 The API has an option to include user authentication. This can be enabled by setting the environment variable

{isar-1.33.9 → isar-1.34.0}/src/isar/apis/models/models.py

@@ -19,11 +19,8 @@ class StartMissionResponse(BaseModel):
 
 
 class ControlMissionResponse(BaseModel):
-    mission_id: Optional[str]
-    mission_status: Optional[str]
-    mission_not_found: Optional[bool] = False
-    task_id: Optional[str]
-    task_status: Optional[str]
+    success: bool
+    failure_reason: Optional[str] = None
 
 
 class MissionStartResponse(BaseModel):

{isar-1.33.9 → isar-1.34.0}/src/isar/config/settings.py

@@ -59,9 +59,6 @@ class Settings(BaseSettings):
     # issues
     REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY: float = Field(default=10)
 
-    # Time allowed to clear the robot status before giving up
-    CLEAR_ROBOT_STATUS_TIMEOUT: int = Field(default=3)
-
     # Number of attempts for state transitions resume and pause if failed
     STATE_TRANSITION_NUM_RETIRES: int = Field(default=10)
 
@@ -109,10 +106,6 @@ class Settings(BaseSettings):
     # Determines which mission planner module is used by ISAR
     MISSION_PLANNER: str = Field(default="local")
 
-    # Determines which task selector module is used by ISAR
-    # Options: [sequential]
-    TASK_SELECTOR: str = Field(default="sequential")
-
     # Determines which storage modules are used by ISAR
     # Multiple storage modules can be chosen
     # Each module will be called when storing results from inspections

{isar-1.33.9 → isar-1.34.0}/src/isar/models/events.py

@@ -1,6 +1,6 @@
 from collections import deque
 from queue import Empty, Queue
-from typing import Generic, Optional, TypeVar
+from typing import Generic, Optional, Tuple, TypeVar
 
 from transitions import State
 
@@ -12,7 +12,7 @@ from isar.apis.models.models import (
 from isar.config.settings import settings
 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
+from robot_interface.models.mission.status import MissionStatus, RobotStatus
 from robot_interface.models.mission.task import TASKS
 
 T = TypeVar("T")
@@ -126,18 +126,16 @@ class StateMachineEvents:
         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")
-        self.clear_robot_status: Event[bool] = Event("clear_robot_status")
 
 
 class RobotServiceEvents:
     def __init__(self) -> None:
-        self.task_status_updated: Event[TaskStatus] = Event("task_status_updated")
-        self.task_status_failed: Event[ErrorMessage] = Event("task_status_failed")
+        self.mission_status_updated: Event[MissionStatus] = Event(
+            "mission_status_updated"
+        )
         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.robot_status_cleared: Event[bool] = Event("robot_status_cleared")
         self.mission_failed_to_stop: Event[ErrorMessage] = Event(
             "mission_failed_to_stop"
         )
@@ -150,16 +148,17 @@ class RobotServiceEvents:
         self.mission_successfully_paused: Event[bool] = Event(
             "mission_successfully_paused"
         )
+        self.request_inspection_upload: Event[Tuple[TASKS, Mission]] = Event(
+            "request_inspection_upload"
+        )
 
 
 class SharedState:
     def __init__(self) -> None:
         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")
+        self.mission_id: Event[Optional[str]] = Event("mission_id")
 
 
 class EventTimeoutError(Exception):

{isar-1.33.9 → isar-1.34.0}/src/isar/modules.py

@@ -10,8 +10,6 @@ from isar.apis.security.authentication import Authenticator
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 from isar.mission_planner.local_planner import LocalPlanner
-from isar.mission_planner.sequential_task_selector import SequentialTaskSelector
-from isar.mission_planner.task_selector_interface import TaskSelectorInterface
 from isar.models.events import Events, SharedState
 from isar.robot.robot import Robot
 from isar.services.utilities.robot_utilities import RobotUtilities
@@ -89,24 +87,21 @@ class ApplicationContainer(containers.DeclarativeContainer):
     storage_handlers = providers.List(*storage_handlers_temp)
 
     # State machine
-    task_selector = providers.Singleton(
-        SequentialTaskSelector
-        if settings.TASK_SELECTOR == "sequential"
-        else TaskSelectorInterface
-    )
-
     state_machine = providers.Singleton(
         StateMachine,
         events=events,
         shared_state=shared_state,
         robot=robot_interface,
         mqtt_publisher=mqtt_client,
-        task_selector=task_selector,
     )
 
     # Robot
     robot = providers.Singleton(
-        Robot, events=events, robot=robot_interface, shared_state=shared_state
+        Robot,
+        events=events,
+        robot=robot_interface,
+        shared_state=shared_state,
+        mqtt_publisher=mqtt_client,
     )
 
     # Uploader
@@ -126,7 +121,6 @@ def get_injector() -> ApplicationContainer:
         {
             "KEYVAULT_NAME": settings.KEYVAULT_NAME,
             "MQTT_ENABLED": settings.MQTT_ENABLED,
-            "TASK_SELECTOR": settings.TASK_SELECTOR,
         }
     )
 

{isar-1.33.9 → isar-1.34.0}/src/isar/robot/robot.py

@@ -1,6 +1,7 @@
 import logging
+from queue import Queue
 from threading import Event as ThreadEvent
-from typing import Optional
+from typing import List, Optional, Tuple
 
 from isar.models.events import (
     Event,
@@ -10,32 +11,43 @@ from isar.models.events import (
     StateMachineEvents,
 )
 from isar.robot.robot_battery import RobotBatteryThread
+from isar.robot.robot_monitor_mission import RobotMonitorMissionThread
 from isar.robot.robot_pause_mission import RobotPauseMissionThread
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
 from isar.robot.robot_stop_mission import RobotStopMissionThread
-from isar.robot.robot_task_status import RobotTaskStatusThread
+from isar.robot.robot_upload_inspection import RobotUploadInspectionThread
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
 from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.task import TASKS
 from robot_interface.robot_interface import RobotInterface
+from robot_interface.telemetry.mqtt_client import MqttClientInterface
 
 
 class Robot(object):
     def __init__(
-        self, events: Events, robot: RobotInterface, shared_state: SharedState
+        self,
+        events: Events,
+        robot: RobotInterface,
+        shared_state: SharedState,
+        mqtt_publisher: MqttClientInterface,
     ) -> None:
         self.logger = logging.getLogger("robot")
         self.state_machine_events: StateMachineEvents = events.state_machine_events
         self.robot_service_events: RobotServiceEvents = events.robot_service_events
+        self.mqtt_publisher: MqttClientInterface = mqtt_publisher
+        self.upload_queue: Queue = events.upload_queue
         self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.start_mission_thread: Optional[RobotStartMissionThread] = None
         self.robot_battery_thread: Optional[RobotBatteryThread] = None
         self.robot_status_thread: Optional[RobotStatusThread] = None
-        self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
+        self.monitor_mission_thread: Optional[RobotMonitorMissionThread] = None
         self.stop_mission_thread: Optional[RobotStopMissionThread] = None
         self.pause_mission_thread: Optional[RobotPauseMissionThread] = None
+        self.upload_inspection_threads: List[RobotUploadInspectionThread] = []
         self.signal_thread_quitting: ThreadEvent = ThreadEvent()
+        self.signal_mission_stopped: ThreadEvent = ThreadEvent()
 
     def stop(self) -> None:
         self.signal_thread_quitting.set()
@@ -47,10 +59,10 @@ class Robot(object):
         ):
             self.robot_battery_thread.join()
         if (
-            self.robot_task_status_thread is not None
-            and self.robot_task_status_thread.is_alive()
+            self.monitor_mission_thread is not None
+            and self.monitor_mission_thread.is_alive()
         ):
-            self.robot_task_status_thread.join()
+            self.monitor_mission_thread.join()
         if (
             self.start_mission_thread is not None
             and self.start_mission_thread.is_alive()
@@ -60,8 +72,64 @@ class Robot(object):
             self.stop_mission_thread.join()
         self.robot_status_thread = None
         self.robot_battery_thread = None
-        self.robot_task_status_thread = None
         self.start_mission_thread = None
+        self.monitor_mission_thread = None
+
+    def _start_mission_done_handler(self) -> None:
+        if (
+            self.start_mission_thread is not None
+            and not self.start_mission_thread.is_alive()
+        ):
+            self.start_mission_thread.join()
+            mission = self.start_mission_thread.mission
+            self.start_mission_thread = None
+
+            if (
+                self.monitor_mission_thread is not None
+                and self.monitor_mission_thread.is_alive()
+            ):
+                self.logger.warning(
+                    "Attempted to start mission while monitoring an old mission."
+                )
+                self.monitor_mission_thread.join()
+
+            self.signal_mission_stopped.clear()
+            self.monitor_mission_thread = RobotMonitorMissionThread(
+                self.robot_service_events,
+                self.shared_state,
+                self.robot,
+                self.mqtt_publisher,
+                self.signal_thread_quitting,
+                self.signal_mission_stopped,
+                mission,
+            )
+            self.monitor_mission_thread.start()
+
+    def _stop_mission_done_handler(self) -> None:
+        if (
+            self.stop_mission_thread is not None
+            and not self.stop_mission_thread.is_alive()
+            and (
+                not self.monitor_mission_thread
+                or not self.monitor_mission_thread.is_alive()
+            )
+        ):
+            self.stop_mission_thread.join()
+            error_message = self.stop_mission_thread.error_message
+            self.stop_mission_thread = None
+
+            if self.monitor_mission_thread is not None:
+                self.monitor_mission_thread.join()
+                self.monitor_mission_thread = None
+
+            if error_message:
+                self.robot_service_events.mission_failed_to_stop.trigger_event(
+                    error_message
+                )
+            else:
+                self.robot_service_events.mission_successfully_stopped.trigger_event(
+                    True
+                )
 
     def _start_mission_event_handler(self, event: Event[Mission]) -> None:
         start_mission = event.consume_event()
@@ -74,6 +142,7 @@ class Robot(object):
                     "Attempted to start mission while another mission was starting."
                 )
                 self.start_mission_thread.join()
+
             self.start_mission_thread = RobotStartMissionThread(
                 self.robot_service_events,
                 self.robot,
@@ -82,17 +151,6 @@ class Robot(object):
             )
             self.start_mission_thread.start()
 
-    def _task_status_request_handler(self, event: Event[str]) -> None:
-        task_id: str = event.consume_event()
-        if task_id:
-            self.robot_task_status_thread = RobotTaskStatusThread(
-                self.robot_service_events,
-                self.robot,
-                self.signal_thread_quitting,
-                task_id,
-            )
-            self.robot_task_status_thread.start()
-
     def _stop_mission_request_handler(self, event: Event[bool]) -> None:
         if event.consume_event():
             if (
@@ -117,9 +175,10 @@ class Robot(object):
                 )
                 return
             self.stop_mission_thread = RobotStopMissionThread(
-                self.robot_service_events, self.robot, self.signal_thread_quitting
+                self.robot, self.signal_thread_quitting
             )
             self.stop_mission_thread.start()
+            self.signal_mission_stopped.set()
 
     def _pause_mission_request_handler(self, event: Event[bool]) -> None:
         if event.consume_event():
@@ -149,6 +208,28 @@ class Robot(object):
             )
             self.pause_mission_thread.start()
 
+    def _upload_inspection_event_handler(
+        self, event: Event[Tuple[TASKS, Mission]]
+    ) -> None:
+        upload_request = event.consume_event()
+        if upload_request:
+
+            upload_inspection_thread = RobotUploadInspectionThread(
+                self.upload_queue, self.robot, upload_request[0], upload_request[1]
+            )
+            self.upload_inspection_threads.append(upload_inspection_thread)
+            upload_inspection_thread.start()
+
+        def _join_threads(thread: RobotUploadInspectionThread) -> bool:
+            if thread.is_done():
+                thread.join()
+                return True
+            return False
+
+        self.upload_inspection_threads[:] = [
+            thread for thread in self.upload_inspection_threads if _join_threads(thread)
+        ]
+
     def run(self) -> None:
         self.robot_status_thread = RobotStatusThread(
             robot=self.robot,
@@ -167,12 +248,16 @@ class Robot(object):
         while not self.signal_thread_quitting.wait(0):
             self._start_mission_event_handler(self.state_machine_events.start_mission)
 
-            self._task_status_request_handler(
-                self.state_machine_events.task_status_request
-            )
-
             self._pause_mission_request_handler(self.state_machine_events.pause_mission)
 
             self._stop_mission_request_handler(self.state_machine_events.stop_mission)
 
+            self._upload_inspection_event_handler(
+                self.robot_service_events.request_inspection_upload
+            )
+
+            self._start_mission_done_handler()
+
+            self._stop_mission_done_handler()
+
         self.logger.info("Exiting robot service main thread")