isar 1.32.1__tar.gz → 1.32.3__tar.gz

{isar-1.32.1 → isar-1.32.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.32.1
+Version: 1.32.3
 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.32.1 → isar-1.32.3}/src/isar/config/settings.py

@@ -89,6 +89,9 @@ class Settings(BaseSettings):
     # Determines how long delay time should be allowed before returning home
     RETURN_HOME_DELAY: int = Field(default=10)
 
+    # Sets how many times the robot should try to return home if a return home fails
+    RETURN_HOME_RETRY_LIMIT: int = Field(default=5)
+
     # Determines which mission planner module is used by ISAR
     MISSION_PLANNER: str = Field(default="local")
 

{isar-1.32.1 → isar-1.32.3}/src/isar/state_machine/states/returning_home.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
 class ReturningHome(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
+        self.failed_return_home_attemps: int = 0
         events = state_machine.events
 
         def _handle_task_completed(status: TaskStatus):
@@ -28,7 +29,9 @@ class ReturningHome(EventHandlerBase):
                     error_reason=ErrorReason.RobotActionException,
                     error_description="Return home failed.",
                 )
+                self.failed_return_home_attemps += 1
                 return state_machine.return_home_failed  # type: ignore
+
             return state_machine.returned_home  # type: ignore
 
         def _start_mission_event_handler(

{isar-1.32.1 → isar-1.32.3}/src/isar/state_machine/transitions/functions/return_home.py

@@ -5,8 +5,9 @@ if TYPE_CHECKING:
 
 from typing import TYPE_CHECKING
 
+from isar.config.settings import settings
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
+from robot_interface.models.mission.status import MissionStatus, RobotStatus, TaskStatus
 from robot_interface.models.mission.task import ReturnToHome
 
 if TYPE_CHECKING:
@@ -23,6 +24,21 @@ def start_return_home_mission(state_machine: "StateMachine") -> bool:
     return True
 
 
+def should_retry_return_home(state_machine: "StateMachine") -> bool:
+    if state_machine.shared_state.robot_status.check() != RobotStatus.Available:
+        return False
+
+    return (
+        state_machine.returning_home_state.failed_return_home_attemps
+        < settings.RETURN_HOME_RETRY_LIMIT
+    )
+
+
+def reset_return_home_failure_counter(state_machine: "StateMachine") -> bool:
+    state_machine.returning_home_state.failed_return_home_attemps = 0
+    return True
+
+
 def set_return_home_status(state_machine: "StateMachine") -> bool:
     state_machine.log_mission_overview(mission=state_machine.current_mission)
     state_machine.current_mission.status = MissionStatus.InProgress

{isar-1.32.1 → isar-1.32.3}/src/isar/state_machine/transitions/return_home.py

@@ -5,8 +5,10 @@ from isar.state_machine.transitions.functions.fail_mission import (
     report_failed_return_home_and_intervention_needed,
 )
 from isar.state_machine.transitions.functions.return_home import (
+    reset_return_home_failure_counter,
     return_home_finished,
     set_return_home_status,
+    should_retry_return_home,
     start_return_home_mission,
 )
 from isar.state_machine.transitions.functions.start_mission import (
@@ -34,6 +36,7 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
                 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),
         },
@@ -59,7 +62,25 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "returned_home",
             "source": state_machine.returning_home_state,
             "dest": state_machine.home_state,
-            "before": def_transition(state_machine, return_home_finished),
+            "before": [
+                def_transition(state_machine, reset_return_home_failure_counter),
+                def_transition(state_machine, return_home_finished),
+            ],
+        },
+        {
+            "trigger": "return_home_failed",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.returning_home_state,
+            "conditions": [
+                def_transition(state_machine, should_retry_return_home),
+            ],
+            "before": [
+                def_transition(state_machine, report_failed_mission_and_finalize),
+                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, trigger_start_mission_event),
+            ],
         },
         {
             "trigger": "return_home_failed",
@@ -69,6 +90,7 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
                 def_transition(
                     state_machine, report_failed_return_home_and_intervention_needed
                 ),
+                def_transition(state_machine, reset_return_home_failure_counter),
                 def_transition(state_machine, report_failed_mission_and_finalize),
             ],
         },

{isar-1.32.1 → isar-1.32.3}/src/isar/storage/blob_storage.py

@@ -3,34 +3,49 @@ from pathlib import Path
 from typing import Union
 
 from azure.core.exceptions import ResourceExistsError
-from azure.storage.blob import BlobClient, BlobServiceClient, ContainerClient
+from azure.storage.blob import BlobServiceClient
 
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 from isar.storage.storage_interface import StorageException, StorageInterface
 from isar.storage.utilities import construct_metadata_file, construct_paths
-from robot_interface.models.inspection.inspection import Inspection
+from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
 
 
 class BlobStorage(StorageInterface):
-    def __init__(
-        self, keyvault: Keyvault, container_name: str = settings.BLOB_CONTAINER
-    ) -> None:
-        self.keyvault = keyvault
-        self.storage_connection_string = self.keyvault.get_secret(
+    def __init__(self, keyvault: Keyvault) -> None:
+        self.logger = logging.getLogger("uploader")
+
+        storage_connection_string = keyvault.get_secret(
             "AZURE-STORAGE-CONNECTION-STRING"
         ).value
-        self.container_name = container_name
 
-        self.blob_service_client = self._get_blob_service_client()
-        self.container_client = self._get_container_client(
-            blob_service_client=self.blob_service_client
+        if storage_connection_string is None:
+            raise RuntimeError("AZURE-STORAGE-CONNECTION-STRING from keyvault is None")
+
+        try:
+            blob_service_client = BlobServiceClient.from_connection_string(
+                storage_connection_string
+            )
+        except Exception as e:
+            self.logger.error("Unable to retrieve blob service client. Error: %s", e)
+            raise e
+
+        self.container_client = blob_service_client.get_container_client(
+            settings.BLOB_CONTAINER
         )
 
-        self.logger = logging.getLogger("uploader")
+        if not self.container_client.exists():
+            raise RuntimeError(
+                "The configured blob container %s does not exist",
+                settings.BLOB_CONTAINER,
+            )
+
+    def store(self, inspection: InspectionBlob, mission: Mission) -> Union[str, dict]:
+        if inspection.data is None:
+            raise StorageException("Nothing to store. The inspection data is empty")
 
-    def store(self, inspection: Inspection, mission: Mission) -> Union[str, dict]:
         data_path, metadata_path = construct_paths(
             inspection=inspection, mission=mission
         )
@@ -43,7 +58,7 @@ class BlobStorage(StorageInterface):
         return self._upload_file(path=data_path, data=inspection.data)
 
     def _upload_file(self, path: Path, data: bytes) -> Union[str, dict]:
-        blob_client = self._get_blob_client(path)
+        blob_client = self.container_client.get_blob_client(path.as_posix())
         try:
             blob_client.upload_blob(data=data)
         except ResourceExistsError as e:
@@ -62,20 +77,3 @@ class BlobStorage(StorageInterface):
             "blob_name": blob_client.blob_name,
         }
         return absolute_inspection_path
-
-    def _get_blob_service_client(self) -> BlobServiceClient:
-        try:
-            return BlobServiceClient.from_connection_string(
-                self.storage_connection_string
-            )
-        except Exception as e:
-            self.logger.error("Unable to retrieve blob service client. Error: %s", e)
-            raise e
-
-    def _get_container_client(
-        self, blob_service_client: BlobServiceClient
-    ) -> ContainerClient:
-        return blob_service_client.get_container_client(self.container_name)
-
-    def _get_blob_client(self, path_to_blob: Path) -> BlobClient:
-        return self.container_client.get_blob_client(path_to_blob.as_posix())

{isar-1.32.1 → isar-1.32.3}/src/isar/storage/local_storage.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from isar.config.settings import settings
 from isar.storage.storage_interface import StorageException, StorageInterface
 from isar.storage.utilities import construct_metadata_file, construct_paths
-from robot_interface.models.inspection.inspection import Inspection
+from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
 
 
@@ -13,7 +13,10 @@ class LocalStorage(StorageInterface):
         self.root_folder: Path = Path(settings.LOCAL_STORAGE_PATH)
         self.logger = logging.getLogger("uploader")
 
-    def store(self, inspection: Inspection, mission: Mission) -> str:
+    def store(self, inspection: InspectionBlob, mission: Mission) -> str:
+        if inspection.data is None:
+            raise StorageException("Nothing to store. The inspection data is empty")
+
         local_path, local_metadata_path = construct_paths(
             inspection=inspection, mission=mission
         )

{isar-1.32.1 → isar-1.32.3}/src/isar/storage/storage_interface.py

@@ -1,19 +1,19 @@
 from abc import ABCMeta, abstractmethod
 from typing import Union
 
-from robot_interface.models.inspection.inspection import Inspection
+from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
 
 
 class StorageInterface(metaclass=ABCMeta):
     @abstractmethod
-    def store(self, inspection: Inspection, mission: Mission) -> Union[str, dict]:
+    def store(self, inspection: InspectionBlob, mission: Mission) -> Union[str, dict]:
         """
         Parameters
         ----------
         mission : Mission
             Mission the inspection is a part of.
-        inspection : Inspection
+        inspection : InspectionBlob
             The inspection object to be stored.
 
         Returns

{isar-1.32.1 → isar-1.32.3}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.32.1
+Version: 1.32.3
 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.32.1 → isar-1.32.3}/tests/isar/state_machine/test_state_machine.py

@@ -157,6 +157,10 @@ def test_state_machine_failed_dependency(
             States.Monitor,
             States.AwaitNextMission,
             States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
             States.InterventionNeeded,
         ]
     )
@@ -478,6 +482,81 @@ def test_state_machine_with_mission_start_during_return_home_without_queueing_st
     )
 
 
+def test_state_machine_with_return_home_failure_successful_retries(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    state_machine_thread.state_machine.await_next_mission_state.timers[
+        0
+    ].timeout_in_seconds = 0.01
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    state_machine_thread.start()
+    mocker.patch.object(StubRobot, "robot_status", return_value=RobotStatus.Available)
+    mocker.patch.object(
+        StubRobot, "task_status", side_effect=[TaskStatus.Failed, TaskStatus.Successful]
+    )
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(3)  # Allow enough time to run mission and return home
+
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.Home,
+            States.RobotStandingStill,
+        ]
+    )
+
+
+def test_state_machine_with_return_home_failure_unsuccessful_retries_twice(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    state_machine_thread.state_machine.await_next_mission_state.timers[
+        0
+    ].timeout_in_seconds = 0.01
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    state_machine_thread.start()
+    mocker.patch.object(StubRobot, "robot_status", return_value=RobotStatus.Available)
+    mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.Failed)
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(3)  # Allow enough time to run mission and return home
+    scheduling_utilities.release_intervention_needed()
+    scheduling_utilities.return_home()
+    time.sleep(3)  # Allow enough time to run mission and return home
+
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.InterventionNeeded,
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.ReturningHome,
+            States.InterventionNeeded,
+        ]
+    )
+
+
 def test_state_machine_offline_to_robot_standing_still(
     state_machine_thread, robot_service_thread, mocker
 ) -> None: