isar 1.25.5__tar.gz → 1.25.7__tar.gz

{isar-1.25.5 → isar-1.25.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: isar
-Version: 1.25.5
+Version: 1.25.7
 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.25.5 → isar-1.25.7}/src/isar/apis/api.py

@@ -301,6 +301,14 @@ class API:
             methods=["GET"],
             dependencies=[authentication_dependency],
             summary="Generates a media stream connection config",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Media stream was successfully generated",
+                },
+                HTTPStatus.NO_CONTENT.value: {
+                    "description": "Robot has no media config",
+                },
+            },
         )
 
         return router

{isar-1.25.5 → isar-1.25.7}/src/isar/apis/models/start_mission_definition.py

@@ -18,6 +18,7 @@ from robot_interface.models.mission.task import (
     TakeThermalImage,
     TakeThermalVideo,
     TakeVideo,
+    TakeGasMeasurement,
     ZoomDescription,
 )
 
@@ -28,6 +29,7 @@ class InspectionTypes(str, Enum):
     video = "Video"
     thermal_video = "ThermalVideo"
     audio = "Audio"
+    gas_measurement = "GasMeasurement"
 
 
 class TaskType(str, Enum):
@@ -200,7 +202,6 @@ def to_inspection_task(task_definition: StartMissionTaskDefinition) -> TASKS:
                 target=task_definition.inspection.inspection_target.to_alitra_position(),
                 duration=inspection_definition.duration,
                 metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
             )
         else:
             return RecordAudio(
@@ -209,7 +210,20 @@ def to_inspection_task(task_definition: StartMissionTaskDefinition) -> TASKS:
                 target=task_definition.inspection.inspection_target.to_alitra_position(),
                 duration=inspection_definition.duration,
                 metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
+            )
+    elif inspection_definition.type == InspectionTypes.gas_measurement:
+        if task_definition.id:
+            return TakeGasMeasurement(
+                id=task_definition.id,
+                robot_pose=task_definition.pose.to_alitra_pose(),
+                tag_id=task_definition.tag,
+                metadata=task_definition.inspection.metadata,
+            )
+        else:
+            return TakeGasMeasurement(
+                robot_pose=task_definition.pose.to_alitra_pose(),
+                tag_id=task_definition.tag,
+                metadata=task_definition.inspection.metadata,
             )
     else:
         raise ValueError(

{isar-1.25.5 → isar-1.25.7}/src/isar/apis/robot_control/robot_controller.py

@@ -5,6 +5,7 @@ from injector import inject
 from isar.apis.models.models import RobotInfoResponse
 from isar.config.settings import robot_settings, settings
 from isar.services.utilities.robot_utilities import RobotUtilities
+from fastapi import HTTPException
 
 
 class RobotController:
@@ -17,7 +18,13 @@ class RobotController:
         self.logger = logging.getLogger("api")
 
     def generate_media_config(self):
-        return self.robot_utilities.generate_media_config()
+        media_config = self.robot_utilities.generate_media_config()
+        if media_config is None:
+            raise HTTPException(
+                status_code=204,
+                detail="Robot has no media config",
+            )
+        return media_config
 
     def get_info(self):
         return RobotInfoResponse(

{isar-1.25.5 → isar-1.25.7}/src/isar/config/settings.py

@@ -25,9 +25,6 @@ class Settings(BaseSettings):
     # Name must match with an installed python package in the local environment
     ROBOT_PACKAGE: str = Field(default="isar_robot")
 
-    # The run mode of the robot (stepwise or full mission)
-    RUN_MISSION_BY_TASK: bool = Field(default=True)
-
     # Determines the local path in which results from missions are stored
     LOCAL_STORAGE_PATH: str = Field(default="./results")
 
@@ -331,7 +328,3 @@ class RobotSettings(BaseSettings):
 
 
 robot_settings = RobotSettings()
-
-if not settings.RUN_MISSION_BY_TASK:  # If mission-wise, do not run localize missions
-    if "localize" in robot_settings.CAPABILITIES:
-        robot_settings.CAPABILITIES.remove("localize")

{isar-1.25.5 → isar-1.25.7}/src/isar/script.py

@@ -66,7 +66,6 @@ def print_startup_info():
     print_setting(fillchar="-")
     print_setting("Robot package", settings.ROBOT_PACKAGE)
     print_setting("Robot name", settings.ROBOT_NAME)
-    print_setting("Run mission taskwise", settings.RUN_MISSION_BY_TASK)
     print_setting("Running on port", settings.API_PORT)
     print_setting("Mission planner", settings.MISSION_PLANNER)
     print_setting("Using local storage", settings.STORAGE_LOCAL_ENABLED)

{isar-1.25.5 → isar-1.25.7}/src/isar/state_machine/state_machine.py

@@ -54,7 +54,6 @@ class StateMachine(object):
         mqtt_publisher: MqttClientInterface,
         task_selector: TaskSelectorInterface,
         sleep_time: float = settings.FSM_SLEEP_TIME,
-        run_mission_by_task: bool = settings.RUN_MISSION_BY_TASK,
         stop_robot_attempts_limit: int = settings.STOP_ROBOT_ATTEMPTS_LIMIT,
         transitions_log_length: int = settings.STATE_TRANSITIONS_LOG_LENGTH,
     ):
@@ -82,7 +81,6 @@ class StateMachine(object):
         self.robot: RobotInterface = robot
         self.mqtt_publisher: Optional[MqttClientInterface] = mqtt_publisher
         self.task_selector: TaskSelectorInterface = task_selector
-        self.run_mission_by_task: bool = run_mission_by_task
 
         # List of states
         self.stop_state: State = Stop(self)
@@ -114,7 +112,6 @@ class StateMachine(object):
                     "trigger": "start_machine",
                     "source": self.off_state,
                     "dest": self.idle_state,
-                    "before": self._off,
                 },
                 {
                     "trigger": "initiated",
@@ -123,32 +120,24 @@ class StateMachine(object):
                     "before": self._initiated,
                 },
                 {
-                    "trigger": "pause_full_mission",
-                    "source": [self.initiate_state, self.monitor_state],
+                    "trigger": "pause",
+                    "source": self.monitor_state,
                     "dest": self.paused_state,
                     "before": self._mission_paused,
                 },
-                {
-                    "trigger": "pause",
-                    "source": [self.initiate_state, self.monitor_state],
-                    "dest": self.stop_state,
-                    "before": self._pause,
-                },
                 {
                     "trigger": "stop",
                     "source": [
+                        self.idle_state,
                         self.initiate_state,
                         self.monitor_state,
-                        self.idle_state,
+                        self.paused_state,
                     ],
                     "dest": self.stop_state,
-                    "before": self._stop,
                 },
                 {
                     "trigger": "mission_finished",
-                    "source": [
-                        self.initiate_state,
-                    ],
+                    "source": self.monitor_state,
                     "dest": self.idle_state,
                     "before": self._mission_finished,
                 },
@@ -173,39 +162,9 @@ class StateMachine(object):
                 {
                     "trigger": "resume",
                     "source": self.paused_state,
-                    "dest": self.initiate_state,
-                    "before": self._resume,
-                },
-                {
-                    "trigger": "resume_full_mission",
-                    "source": self.paused_state,
                     "dest": self.monitor_state,
                     "before": self._resume,
                 },
-                {
-                    "trigger": "task_finished",
-                    "source": self.monitor_state,
-                    "dest": self.initiate_state,
-                    "before": self._task_finished,
-                },
-                {
-                    "trigger": "full_mission_finished",
-                    "source": self.monitor_state,
-                    "dest": self.initiate_state,
-                    "before": self._full_mission_finished,
-                },
-                {
-                    "trigger": "mission_paused",
-                    "source": self.stop_state,
-                    "dest": self.paused_state,
-                    "before": self._mission_paused,
-                },
-                {
-                    "trigger": "initiate_infeasible",
-                    "source": self.initiate_state,
-                    "dest": self.initiate_state,
-                    "before": self._initiate_infeasible,
-                },
                 {
                     "trigger": "initiate_failed",
                     "source": self.initiate_state,
@@ -214,33 +173,29 @@ class StateMachine(object):
                 },
                 {
                     "trigger": "mission_stopped",
-                    "source": [self.stop_state, self.paused_state],
+                    "source": self.stop_state,
                     "dest": self.idle_state,
                     "before": self._mission_stopped,
                 },
                 {
                     "trigger": "robot_turned_offline",
-                    "source": [self.idle_state],
+                    "source": self.idle_state,
                     "dest": self.offline_state,
-                    "before": self._offline,
                 },
                 {
                     "trigger": "robot_turned_online",
                     "source": self.offline_state,
                     "dest": self.idle_state,
-                    "before": self._online,
                 },
                 {
                     "trigger": "robot_protective_stop_engaged",
-                    "source": [self.idle_state],
+                    "source": self.idle_state,
                     "dest": self.blocked_protective_stop,
-                    "before": self._protective_stop_engaged,
                 },
                 {
                     "trigger": "robot_protective_stop_disengaged",
                     "source": self.blocked_protective_stop,
                     "dest": self.idle_state,
-                    "before": self._protective_stop_disengaged,
                 },
             ]
         )
@@ -248,7 +203,6 @@ class StateMachine(object):
         self.stop_robot_attempts_limit: int = stop_robot_attempts_limit
         self.sleep_time: float = sleep_time
 
-        self.stopped: bool = False
         self.current_mission: Optional[Mission] = None
         self.current_task: Optional[TASKS] = None
         self.initial_pose: Optional[Pose] = None
@@ -268,8 +222,6 @@ class StateMachine(object):
         self._finalize()
 
     def _initiated(self) -> None:
-        if self.run_mission_by_task:
-            self.current_task.status = TaskStatus.InProgress
         self.current_mission.status = MissionStatus.InProgress
         self.publish_task_status(task=self.current_task)
         self.logger.info(
@@ -278,24 +230,6 @@ class StateMachine(object):
             f"task: {str(self.current_task.id)[:8]}"
         )
 
-    def _pause(self) -> None:
-        return
-
-    def _off(self) -> None:
-        return
-
-    def _offline(self) -> None:
-        return
-
-    def _online(self) -> None:
-        return
-
-    def _protective_stop_engaged(self) -> None:
-        return
-
-    def _protective_stop_disengaged(self) -> None:
-        return
-
     def _resume(self) -> None:
         self.logger.info(f"Resuming mission: {self.current_mission.id}")
         self.current_mission.status = MissionStatus.InProgress
@@ -354,11 +288,6 @@ class StateMachine(object):
             self.current_task.status = TaskStatus.InProgress
             self.publish_task_status(task=self.current_task)
 
-    def _task_finished(self) -> None:
-        self.publish_task_status(task=self.current_task)
-        self.current_task.update_task_status()
-        self.iterate_current_task()
-
     def _full_mission_finished(self) -> None:
         self.current_task = None
 
@@ -377,21 +306,12 @@ class StateMachine(object):
 
         self.robot.pause()
 
-    def _stop(self) -> None:
-        self.stopped = True
-
     def _initiate_failed(self) -> None:
         self.current_task.status = TaskStatus.Failed
         self.current_mission.status = MissionStatus.Failed
         self.publish_task_status(task=self.current_task)
         self._finalize()
 
-    def _initiate_infeasible(self) -> None:
-        if self.run_mission_by_task:
-            self.current_task.status = TaskStatus.Failed
-            self.publish_task_status(task=self.current_task)
-            self.iterate_current_task()
-
     def _mission_stopped(self) -> None:
         if self.current_mission is None:
             self._queue_empty_response()
@@ -458,7 +378,6 @@ class StateMachine(object):
 
     def reset_state_machine(self) -> None:
         self.logger.info("Resetting state machine")
-        self.stopped = False
         self.current_task = None
         self.current_mission = None
         self.initial_pose = None

{isar-1.25.5 → isar-1.25.7}/src/isar/state_machine/states/initiate.py

@@ -13,7 +13,6 @@ from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotException,
     RobotInfeasibleMissionException,
-    RobotInfeasibleTaskException,
 )
 
 if TYPE_CHECKING:
@@ -49,30 +48,12 @@ class Initiate(State):
                 transition = self.state_machine.stop  # type: ignore
                 break
 
-            if self.state_machine.should_pause_mission():
-                transition = self.state_machine.pause  # type: ignore
-                break
-
-            if not self.state_machine.current_task:
-                self.logger.info(
-                    f"Completed mission: {self.state_machine.current_mission.id}"
-                )
-                transition = self.state_machine.mission_finished  # type: ignore
-                break
-
             if not self.initiate_thread:
-                if self.state_machine.run_mission_by_task:
-                    self._run_initiate_thread(
-                        initiate_function=self.state_machine.robot.initiate_task,
-                        function_argument=self.state_machine.current_task,
-                        thread_name="State Machine Initiate Task",
-                    )
-                else:
-                    self._run_initiate_thread(
-                        initiate_function=self.state_machine.robot.initiate_mission,
-                        function_argument=self.state_machine.current_mission,
-                        thread_name="State Machine Initiate Mission",
-                    )
+                self._run_initiate_thread(
+                    initiate_function=self.state_machine.robot.initiate_mission,
+                    function_argument=self.state_machine.current_mission,
+                    thread_name="State Machine Initiate Mission",
+                )
 
             try:
                 self.initiate_thread.get_output()
@@ -81,18 +62,6 @@ class Initiate(State):
             except ThreadedRequestNotFinishedError:
                 time.sleep(self.state_machine.sleep_time)
                 continue
-            except RobotInfeasibleTaskException as e:
-                self.state_machine.current_task.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                )
-                self.logger.warning(
-                    f"Failed to initiate task "
-                    f"{str(self.state_machine.current_task.id)[:8]} after retrying "
-                    f"{self.initiate_failure_counter} times because: "
-                    f"{e.error_description}"
-                )
-                transition = self.state_machine.initiate_infeasible  # type: ignore
-                break
 
             except RobotInfeasibleMissionException as e:
                 self.state_machine.current_mission.error_message = ErrorMessage(

{isar-1.25.5 → isar-1.25.7}/src/isar/state_machine/states/monitor.py

@@ -58,10 +58,7 @@ class Monitor(State):
                 break
 
             if self.state_machine.should_pause_mission():
-                if self.state_machine.run_mission_by_task:
-                    transition = self.state_machine.pause  # type: ignore
-                else:
-                    transition = self.state_machine.pause_full_mission  # type: ignore
+                transition = self.state_machine.pause  # type: ignore
                 break
 
             if not self.task_status_thread:
@@ -72,6 +69,7 @@ class Monitor(State):
                 )
             try:
                 status: TaskStatus = self.task_status_thread.get_output()
+                self.request_status_failure_counter = 0
             except ThreadedRequestNotFinishedError:
                 time.sleep(self.state_machine.sleep_time)
                 continue
@@ -133,28 +131,22 @@ class Monitor(State):
                     name="State Machine Get Inspections",
                 )
 
-            if self.state_machine.run_mission_by_task:
-                if self.state_machine.current_task.is_finished():
-                    self._report_task_status(self.state_machine.current_task)
-                    transition = self.state_machine.task_finished  # type: ignore
-                    break
-            else:
-                if self.state_machine.current_task.is_finished():
-                    self._report_task_status(self.state_machine.current_task)
-                    self.state_machine.publish_task_status(
-                        task=self.state_machine.current_task
-                    )
+            if self.state_machine.current_task.is_finished():
+                self._report_task_status(self.state_machine.current_task)
+                self.state_machine.publish_task_status(
+                    task=self.state_machine.current_task
+                )
 
-                    self.state_machine.iterate_current_task()
-                    if self.state_machine.current_task is None:
-                        transition = self.state_machine.full_mission_finished  # type: ignore
-                        break
+                self.state_machine.iterate_current_task()
+                if self.state_machine.current_task is None:
+                    transition = self.state_machine.mission_finished  # type: ignore
+                    break
 
-                    # Report and update next task
-                    self.state_machine.current_task.update_task_status()
-                    self.state_machine.publish_task_status(
-                        task=self.state_machine.current_task
-                    )
+                # Report and update next task
+                self.state_machine.current_task.update_task_status()
+                self.state_machine.publish_task_status(
+                    task=self.state_machine.current_task
+                )
 
             self.task_status_thread = None
             time.sleep(self.state_machine.sleep_time)
@@ -174,7 +166,7 @@ class Monitor(State):
             inspection: Inspection = self.state_machine.robot.get_inspection(
                 task=current_task
             )
-            if current_task.inspection_id == inspection.id:
+            if current_task.inspection_id != inspection.id:
                 self.logger.warning(
                     f"The inspection_id of task ({current_task.inspection_id}) "
                     f"and result ({inspection.id}) is not matching. "
@@ -205,7 +197,6 @@ class Monitor(State):
         )
 
     def _report_task_status(self, task: Task) -> None:
-        self.request_status_failure_counter = 0
         if task.status == TaskStatus.Failed:
             self.logger.warning(
                 f"Task: {str(task.id)[:8]} was reported as failed by the robot"

{isar-1.25.5 → isar-1.25.7}/src/isar/state_machine/states/paused.py

@@ -22,14 +22,11 @@ class Paused(State):
         transition: Callable
         while True:
             if self.state_machine.should_stop_mission():
-                transition = self.state_machine.mission_stopped  # type: ignore
+                transition = self.state_machine.stop  # type: ignore
                 break
 
             if self.state_machine.should_resume_mission():
-                if self.state_machine.run_mission_by_task:
-                    transition = self.state_machine.resume  # type: ignore
-                else:
-                    transition = self.state_machine.resume_full_mission  # type: ignore
+                transition = self.state_machine.resume  # type: ignore
                 break
 
             time.sleep(self.state_machine.sleep_time)

{isar-1.25.5 → isar-1.25.7}/src/isar/state_machine/states/stop.py

@@ -43,9 +43,6 @@ class Stop(State):
                 self.stop_thread = ThreadedRequest(self.state_machine.robot.stop)
                 self.stop_thread.start_thread(name="State Machine Stop Robot")
 
-            if self.state_machine.should_stop_mission():
-                self.state_machine.stopped = True
-
             try:
                 self.stop_thread.get_output()
             except ThreadedRequestNotFinishedError:
@@ -70,10 +67,9 @@ class Stop(State):
 
                 self.stop_thread = None
                 continue
-            if self.state_machine.stopped:
-                transition = self.state_machine.mission_stopped  # type: ignore
-            else:
-                transition = self.state_machine.mission_paused  # type: ignore
+
+            transition = self.state_machine.mission_stopped  # type: ignore
+
             break
 
         transition()

{isar-1.25.5 → isar-1.25.7}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: isar
-Version: 1.25.5
+Version: 1.25.7
 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.25.5 → isar-1.25.7}/src/robot_interface/models/inspection/inspection.py

@@ -42,6 +42,11 @@ class AudioMetadata(InspectionMetadata):
     duration: Optional[float] = field(default=None)
 
 
+@dataclass
+class GasMeasurementMetadata(InspectionMetadata):
+    pass
+
+
 class Inspection(BaseModel):
     metadata: InspectionMetadata
     id: str = Field(frozen=True)
@@ -90,3 +95,11 @@ class Audio(Inspection):
     @staticmethod
     def get_metadata_type() -> Type[InspectionMetadata]:
         return AudioMetadata
+
+
+class GasMeasurement(Inspection):
+    metadata: GasMeasurementMetadata
+
+    @staticmethod
+    def get_metadata_type() -> Type[InspectionMetadata]:
+        return GasMeasurementMetadata

{isar-1.25.5 → isar-1.25.7}/src/robot_interface/models/mission/task.py

@@ -11,6 +11,7 @@ from robot_interface.models.inspection.inspection import (
     Inspection,
     ThermalImage,
     ThermalVideo,
+    GasMeasurement,
     Video,
 )
 from robot_interface.models.mission.status import TaskStatus
@@ -25,6 +26,7 @@ class TaskTypes(str, Enum):
     TakeThermalImage = "take_thermal_image"
     TakeVideo = "take_video"
     TakeThermalVideo = "take_thermal_video"
+    TakeGasMeasurement = "take_gas_measurement"
     RecordAudio = "record_audio"
     DockingProcedure = "docking_procedure"
 
@@ -179,6 +181,20 @@ class RecordAudio(InspectionTask):
         return Audio
 
 
+class TakeGasMeasurement(InspectionTask):
+    """
+    Task which causes the robot to take a CO2 measurement at its position.
+
+    Duration of audio is given in seconds.
+    """
+
+    type: Literal[TaskTypes.TakeGasMeasurement] = TaskTypes.TakeGasMeasurement
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return GasMeasurement
+
+
 TASKS = Union[
     ReturnToHome,
     Localize,
@@ -187,6 +203,7 @@ TASKS = Union[
     TakeThermalImage,
     TakeVideo,
     TakeThermalVideo,
+    TakeGasMeasurement,
     RecordAudio,
     DockingProcedure,
 ]

{isar-1.25.5 → isar-1.25.7}/src/robot_interface/robot_interface.py

@@ -18,10 +18,6 @@ class RobotInterface(metaclass=ABCMeta):
     def initiate_mission(self, mission: Mission) -> None:
         """Send a mission to the robot and initiate execution of the mission
 
-        This function should be used in combination with the mission_status function
-        if the robot is designed to run full missions and not in a taskwise
-        configuration.
-
         Parameters
         ----------
         mission: Mission
@@ -38,8 +34,6 @@ class RobotInterface(metaclass=ABCMeta):
         RobotException
             Will catch all RobotExceptions not previously listed and retry scheduling of
             the mission until the number of allowed retries is exceeded
-        NotImplementedError
-            If the robot is designed for taskwise mission execution
 
         """
         raise NotImplementedError
@@ -48,10 +42,6 @@ class RobotInterface(metaclass=ABCMeta):
     def initiate_task(self, task: Task) -> None:
         """Send a task to the robot and initiate the execution of the task
 
-        This function should be used in combination with the task_status function
-        if the robot is designed to run taskwise missions and not in a full mission
-        configuration.
-
         Parameters
         ----------
         task : Task
@@ -71,7 +61,7 @@ class RobotInterface(metaclass=ABCMeta):
             of the task until the number of allowed retries is exceeded before the task
             will be marked as failed and the mission cancelled
         NotImplementedError
-            If the robot is designed for full mission execution.
+            If there is a mismatch between the implemented tasks and listed capabilities
 
         """
         raise NotImplementedError
@@ -80,10 +70,6 @@ class RobotInterface(metaclass=ABCMeta):
     def task_status(self, task_id: str) -> TaskStatus:
         """Gets the status of the currently active task on robot.
 
-        This function should be used in combination with the initiate_task function
-        if the robot is designed to run taskwise missions and not in a full mission
-        configuration.
-
         Returns
         -------
         TaskStatus
@@ -93,8 +79,6 @@ class RobotInterface(metaclass=ABCMeta):
         ------
         RobotException
             If the task status could not be retrieved.
-        NotImplementedError
-            If the robot is designed for full mission execution.
 
         """
         raise NotImplementedError