isar 1.16.16__tar.gz → 1.16.18__tar.gz

{isar-1.16.16 → isar-1.16.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.16.16
+Version: 1.16.18
 Summary: Integration and Supervisory control of Autonomous Robots
 Home-page: https://github.com/equinor/isar
 Author: Equinor ASA

{isar-1.16.16 → isar-1.16.18}/src/isar/config/settings.env

@@ -14,7 +14,7 @@ ISAR_MQTT_SSL_ENABLED = true
 
 ISAR_AUTHENTICATION_ENABLED = false
 
-ISAR_PLANT_SHORT_NAME = KAA
+ISAR_PLANT_SHORT_NAME = HUA
 
 ISAR_API_HOST_VIEWED_EXTERNALLY = 0.0.0.0
 

{isar-1.16.16 → isar-1.16.18}/src/isar/config/settings.py

@@ -66,10 +66,10 @@ class Settings(BaseSettings):
     UPLOAD_FAILURE_MAX_WAIT: int = Field(default=60)
 
     # ISAR telemetry intervals
-    ROBOT_STATUS_PUBLISH_INTERVAL: int = Field(default=1)
-    ROBOT_HEARTBEAT_PUBLISH_INTERVAL: int = Field(default=1)
-    ROBOT_INFO_PUBLISH_INTERVAL: int = Field(default=5)
-    ROBOT_API_STATUS_POLL_INTERVAL: int = Field(default=5)
+    ROBOT_STATUS_PUBLISH_INTERVAL: float = Field(default=1)
+    ROBOT_HEARTBEAT_PUBLISH_INTERVAL: float = Field(default=1)
+    ROBOT_INFO_PUBLISH_INTERVAL: float = Field(default=5)
+    ROBOT_API_STATUS_POLL_INTERVAL: float = Field(default=5)
 
     # FastAPI host
     API_HOST_VIEWED_EXTERNALLY: str = Field(default="0.0.0.0")

{isar-1.16.16 → isar-1.16.18}/src/isar/services/service_connections/mqtt/robot_info_publisher.py

@@ -24,6 +24,7 @@ class RobotInfoPublisher:
                 video_streams=settings.VIDEO_STREAMS,
                 host=settings.API_HOST_VIEWED_EXTERNALLY,
                 port=settings.API_PORT,
+                capabilities=robot_settings.CAPABILITIES,
                 timestamp=datetime.utcnow(),
             )
 

{isar-1.16.16 → isar-1.16.18}/src/isar/state_machine/state_machine.py

@@ -1,7 +1,6 @@
 import json
 import logging
 import queue
-import time
 from collections import deque
 from datetime import datetime
 from typing import Deque, List, Optional
@@ -226,18 +225,13 @@ class StateMachine(object):
     def _initiated(self) -> None:
         if self.stepwise_mission:
             self.current_step.status = StepStatus.InProgress
-            self.publish_step_status(step=self.current_step)
-            self.logger.info(
-                f"Successfully initiated "
-                f"{type(self.current_step).__name__} "
-                f"step: {str(self.current_step.id)[:8]}"
-            )
-        else:
-            self.current_mission.status = MissionStatus.InProgress
-            self.logger.info(
-                f"Successfully initiated full mission with ID: "
-                f"{str(self.current_mission.id)[:8]}"
-            )
+        self.current_mission.status = MissionStatus.InProgress
+        self.publish_step_status(step=self.current_step)
+        self.logger.info(
+            f"Successfully initiated "
+            f"{type(self.current_step).__name__} "
+            f"step: {str(self.current_step.id)[:8]}"
+        )
 
     def _pause(self) -> None:
         return
@@ -269,7 +263,9 @@ class StateMachine(object):
         ]
         partially_fail_statuses = fail_statuses + [TaskStatus.PartiallySuccessful]
 
-        if all(task.status in fail_statuses for task in self.current_mission.tasks):
+        if len(self.current_mission.tasks) == 0:
+            self.current_mission.status = MissionStatus.Successful
+        elif all(task.status in fail_statuses for task in self.current_mission.tasks):
             self.current_mission.error_message = ErrorMessage(
                 error_reason=None,
                 error_description="The mission failed because all tasks in the mission "
@@ -296,9 +292,12 @@ class StateMachine(object):
         self.current_mission.status = MissionStatus.InProgress
         self.publish_mission_status()
         self.current_task = self.task_selector.next_task()
-        self.current_task.status = TaskStatus.InProgress
-        self.publish_task_status(task=self.current_task)
-        self.update_current_step()
+        if self.current_task == None:
+            self._mission_finished()
+        else:
+            self.current_task.status = TaskStatus.InProgress
+            self.publish_task_status(task=self.current_task)
+            self.update_current_step()
 
     def _step_finished(self) -> None:
         self.publish_step_status(step=self.current_step)
@@ -307,28 +306,6 @@ class StateMachine(object):
 
     def _full_mission_finished(self) -> None:
         self.current_task = None
-        step_status: StepStatus = StepStatus.Failed
-        task_status: TaskStatus = TaskStatus.Failed
-
-        if self.current_mission.status == MissionStatus.Failed:
-            step_status = StepStatus.Failed
-            task_status = TaskStatus.Failed
-        elif self.current_mission.status == MissionStatus.Cancelled:
-            step_status = StepStatus.Cancelled
-            task_status = TaskStatus.Cancelled
-        elif (
-            self.current_mission.status == MissionStatus.Successful
-            or self.current_mission.status == MissionStatus.PartiallySuccessful
-        ):
-            step_status = StepStatus.Successful
-            task_status = TaskStatus.Successful
-
-        for task in self.current_mission.tasks:
-            task.status = task_status
-            for step in task.steps:
-                step.status = step_status
-                self.publish_step_status(step=step)
-            self.publish_task_status(task=task)
 
     def _mission_paused(self) -> None:
         self.logger.info(f"Pausing mission: {self.current_mission.id}")
@@ -349,26 +326,12 @@ class StateMachine(object):
         self.stopped = True
 
     def _initiate_failed(self) -> None:
-        if self.stepwise_mission:
-            self.current_step.status = StepStatus.Failed
-            self.current_task.update_task_status()
-            self.current_mission.status = MissionStatus.Failed
-            self.publish_step_status(step=self.current_step)
-            self.publish_task_status(task=self.current_task)
-            self._finalize()
-
-        else:
-            self.current_task = None
-            step_status: StepStatus = StepStatus.Cancelled
-            task_status: TaskStatus = TaskStatus.Cancelled
-
-            for task in self.current_mission.tasks:
-                task.status = task_status
-                for step in task.steps:
-                    step.status = step_status
-                    self.publish_step_status(step=step)
-                self.publish_task_status(task=task)
-            self._finalize()
+        self.current_step.status = StepStatus.Failed
+        self.current_task.update_task_status()
+        self.current_mission.status = MissionStatus.Failed
+        self.publish_step_status(step=self.current_step)
+        self.publish_task_status(task=self.current_task)
+        self._finalize()
 
     def _initiate_infeasible(self) -> None:
         if self.stepwise_mission:
@@ -435,9 +398,19 @@ class StateMachine(object):
                 self.current_task = None
 
     def update_current_step(self):
-        if self.current_task:
+        if self.current_task != None:
             self.current_step = self.current_task.next_step()
 
+    def update_remaining_steps(self):
+        if self.current_task:
+            for step in self.current_task.steps:
+                if (
+                    step.status == StepStatus.InProgress
+                    or step.status == StepStatus.NotStarted
+                ):
+                    step.status = self.current_task.status
+                    self.publish_step_status(step=step)
+
     def update_state(self):
         """Updates the current state of the state machine."""
         self.current_state = States(self.state)

{isar-1.16.16 → isar-1.16.18}/src/isar/state_machine/states/monitor.py

@@ -6,6 +6,7 @@ from typing import Callable, Optional, Sequence, TYPE_CHECKING, Tuple, Union
 from injector import inject
 from transitions import State
 
+from isar.mission_planner.task_selector_interface import TaskSelectorStop
 from isar.services.utilities.threaded_request import (
     ThreadedRequest,
     ThreadedRequestNotFinishedError,
@@ -19,7 +20,7 @@ from robot_interface.models.exceptions.robot_exceptions import (
 )
 from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import MissionStatus
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
 from robot_interface.models.mission.step import InspectionStep, Step, StepStatus
 
 if TYPE_CHECKING:
@@ -56,16 +57,10 @@ class Monitor(State):
                 break
 
             if not self.step_status_thread:
-                if self.state_machine.stepwise_mission:
-                    self._run_get_status_thread(
-                        status_function=self.state_machine.robot.step_status,
-                        thread_name="State Machine Monitor Get Step Status",
-                    )
-                else:
-                    self._run_get_status_thread(
-                        status_function=self.state_machine.robot.mission_status,
-                        thread_name="State Machine Monitor Get Mission Status",
-                    )
+                self._run_get_status_thread(
+                    status_function=self.state_machine.robot.step_status,
+                    thread_name="State Machine Monitor Get Step Status",
+                )
 
             try:
                 status: Union[StepStatus, MissionStatus] = (
@@ -97,19 +92,19 @@ class Monitor(State):
 
             except RobotException as e:
                 self._set_error_message(e)
-                if self.state_machine.stepwise_mission:
-                    status = StepStatus.Failed
-                else:
-                    status = MissionStatus.Failed
+                status = StepStatus.Failed
 
                 self.logger.error(
                     f"Retrieving the status failed because: {e.error_description}"
                 )
 
-            if self.state_machine.stepwise_mission and isinstance(status, StepStatus):
+            if isinstance(status, StepStatus):
                 self.state_machine.current_step.status = status
             elif isinstance(status, MissionStatus):
                 self.state_machine.current_mission.status = status
+                self.logger.error(
+                    f"Received an invalid status update when monitoring mission. Only StepStatus is expected."
+                )
 
             if self._should_upload_inspections():
                 get_inspections_thread = ThreadedRequest(
@@ -126,7 +121,28 @@ class Monitor(State):
                     transition = self.state_machine.step_finished  # type: ignore
                     break
             else:
-                if self._mission_finished(self.state_machine.current_mission):
+                if isinstance(status, StepStatus):
+                    if self._step_finished(self.state_machine.current_step):
+                        self.state_machine.current_task.update_task_status()
+                    else:  # If not all steps are done
+                        self.state_machine.current_task.status = TaskStatus.InProgress
+
+                    self.state_machine.publish_task_status(
+                        self.state_machine.current_task
+                    )
+                    if self.state_machine.current_task.status == TaskStatus.Successful:
+                        self.state_machine.update_remaining_steps()
+                        try:
+                            self.state_machine.current_task = (
+                                self.state_machine.task_selector.next_task()
+                            )
+                        except TaskSelectorStop:
+                            # Indicates that all tasks are finished
+                            self.state_machine.current_task = None
+                            transition = self.state_machine.full_mission_finished  # type: ignore
+                            break
+                        self.state_machine.update_current_step()
+                elif self._mission_finished(self.state_machine.current_mission):
                     transition = self.state_machine.full_mission_finished  # type: ignore
                     break
 
@@ -196,28 +212,15 @@ class Monitor(State):
         return False
 
     def _should_upload_inspections(self) -> bool:
-        if self.state_machine.stepwise_mission:
-            step: Step = self.state_machine.current_step
-            return (
-                self._step_finished(step)
-                and step.status == StepStatus.Successful
-                and isinstance(step, InspectionStep)
-            )
-        else:
-            mission_status: MissionStatus = self.state_machine.current_mission.status
-            if (
-                mission_status == MissionStatus.Successful
-                or mission_status == MissionStatus.PartiallySuccessful
-            ):
-                return True
-            return False
+        step: Step = self.state_machine.current_step
+        return (
+            self._step_finished(step)
+            and step.status == StepStatus.Successful
+            and isinstance(step, InspectionStep)
+        )
 
     def _set_error_message(self, e: RobotException) -> None:
         error_message: ErrorMessage = ErrorMessage(
             error_reason=e.error_reason, error_description=e.error_description
         )
-        if self.state_machine.stepwise_mission:
-            self.state_machine.current_step.error_message = error_message
-        else:
-            if self.state_machine.current_mission:
-                self.state_machine.current_mission.error_message = error_message
+        self.state_machine.current_step.error_message = error_message

{isar-1.16.16 → isar-1.16.18}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.16.16
+Version: 1.16.18
 Summary: Integration and Supervisory control of Autonomous Robots
 Home-page: https://github.com/equinor/isar
 Author: Equinor ASA

{isar-1.16.16 → isar-1.16.18}/src/robot_interface/telemetry/mqtt_client.py

@@ -1,11 +1,15 @@
 import time
 from abc import ABCMeta, abstractmethod
 from queue import Queue
-from typing import Callable, Tuple
+from typing import Callable, Tuple, Type
+from datetime import datetime
+import json
 
 from robot_interface.models.exceptions.robot_exceptions import (
     RobotTelemetryException,
 )
+from robot_interface.telemetry.payloads import CloudHealthPayload
+from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
 
 class MqttClientInterface(metaclass=ABCMeta):
@@ -61,17 +65,23 @@ class MqttTelemetryPublisher(MqttClientInterface):
         self.retain: bool = retain
 
     def run(self, isar_id: str, robot_name: str) -> None:
+        self.cloud_healt_topic: str = f"isar/{isar_id}/cloud_health"
+        topic: str
+        payload: str
+
         while True:
             try:
-                payload: str = self.telemetry_method(
-                    isar_id=isar_id, robot_name=robot_name
-                )
+                payload = self.telemetry_method(isar_id=isar_id, robot_name=robot_name)
+                topic = self.topic
             except RobotTelemetryException:
-                continue
+                payload = json.dumps(
+                    CloudHealthPayload(isar_id, robot_name, datetime.utcnow()),
+                    cls=EnhancedJSONEncoder,
+                )
+                topic = self.cloud_healt_topic
+
+            self.publish(topic=topic, payload=payload, qos=self.qos, retain=self.retain)
 
-            self.publish(
-                topic=self.topic, payload=payload, qos=self.qos, retain=self.retain
-            )
             time.sleep(self.interval)
 
     def publish(

{isar-1.16.16 → isar-1.16.18}/src/robot_interface/telemetry/payloads.py

@@ -15,6 +15,13 @@ class TelemetryPayload:
     timestamp: datetime
 
 
+@dataclass
+class CloudHealthPayload:
+    isar_id: str
+    robot_name: str
+    timestamp: datetime
+
+
 @dataclass
 class TelemetryPosePayload(TelemetryPayload):
     pose: Pose
@@ -65,6 +72,7 @@ class RobotInfoPayload:
     video_streams: List[VideoStream]
     host: str
     port: int
+    capabilities: List[str]
     timestamp: datetime
 
 

{isar-1.16.16 → isar-1.16.18}/tests/isar/state_machine/states/test_monitor.py

@@ -2,7 +2,7 @@ import pytest
 
 from isar.state_machine.states.monitor import Monitor
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import StepStatus
+from robot_interface.models.mission.status import MissionStatus, StepStatus
 from robot_interface.models.mission.step import Step, TakeImage
 from robot_interface.models.mission.task import Task
 from tests.mocks.step import MockStep
@@ -27,19 +27,22 @@ def test_step_finished(monitor: Monitor, mock_status, expected_output):
 
 
 @pytest.mark.parametrize(
-    "mock_status, should_queue_upload",
+    "is_status_successful, should_queue_upload",
     [
-        (StepStatus.Successful, True),
-        (StepStatus.Failed, False),
+        (True, True),
+        (False, False),
     ],
 )
 def test_should_only_upload_if_status_is_completed(
-    monitor: Monitor, mock_status, should_queue_upload
+    monitor: Monitor, is_status_successful, should_queue_upload
 ):
     step: TakeImage = MockStep.take_image_in_coordinate_direction()
-    step.status = mock_status
+    step.status = StepStatus.Successful if is_status_successful else StepStatus.Failed
     task: Task = Task(steps=[step])
     mission: Mission = Mission(tasks=[task])
+    mission.status = (
+        MissionStatus.Successful if is_status_successful else MissionStatus.Failed
+    )
 
     monitor.state_machine.current_mission = mission
     monitor.state_machine.current_task = task

{isar-1.16.16 → isar-1.16.18}/tests/isar/state_machine/test_state_machine.py

@@ -90,27 +90,50 @@ def test_reset_state_machine(state_machine) -> None:
 empty_mission: Mission = Mission([], None)
 
 
-def test_state_machine_transitions(injector, state_machine_thread) -> None:
+@pytest.mark.parametrize(
+    "should_run_stepwise",
+    [
+        (True),
+        (False),
+    ],
+)
+def test_state_machine_transitions(
+    injector, state_machine_thread, should_run_stepwise
+) -> None:
     step_1: Step = DriveToPose(pose=MockPose.default_pose())
     step_2: Step = TakeImage(target=MockPose.default_pose().position)
     mission: Mission = Mission(tasks=[Task(steps=[step_1, step_2])])  # type: ignore
 
+    state_machine_thread.state_machine.stepwise_mission = should_run_stepwise
+
     scheduling_utilities: SchedulingUtilities = injector.get(SchedulingUtilities)
     scheduling_utilities.start_mission(mission=mission, initial_pose=None)
 
     time.sleep(3)
-    expected_transitions_list = deque(
-        [
-            States.Idle,
-            States.Initialize,
-            States.Initiate,
-            States.Monitor,
-            States.Initiate,
-            States.Monitor,
-            States.Initiate,
-            States.Idle,
-        ]
-    )
+    if should_run_stepwise:
+        expected_transitions_list = deque(
+            [
+                States.Idle,
+                States.Initialize,
+                States.Initiate,
+                States.Monitor,
+                States.Initiate,
+                States.Monitor,
+                States.Initiate,
+                States.Idle,
+            ]
+        )
+    else:
+        expected_transitions_list = deque(
+            [
+                States.Idle,
+                States.Initialize,
+                States.Initiate,
+                States.Monitor,
+                States.Initiate,
+                States.Idle,
+            ]
+        )
     assert (
         state_machine_thread.state_machine.transitions_list == expected_transitions_list
     )