isar 1.33.1__py3-none-any.whl → 1.33.3__py3-none-any.whl

isar/state_machine/transitions/mission.py

@@ -4,8 +4,15 @@ from isar.state_machine.transitions.functions.fail_mission import (
     report_failed_mission_and_finalize,
 )
 from isar.state_machine.transitions.functions.finish_mission import finish_mission
-from isar.state_machine.transitions.functions.pause import pause_mission
+from isar.state_machine.transitions.functions.pause import (
+    pause_mission,
+    pause_return_home_mission,
+)
 from isar.state_machine.transitions.functions.resume import resume_mission
+from isar.state_machine.transitions.functions.return_home import (
+    reset_return_home_failure_counter,
+    return_home_finished,
+)
 from isar.state_machine.transitions.functions.start_mission import (
     acknowledge_mission,
     initialize_robot,
@@ -15,7 +22,6 @@ from isar.state_machine.transitions.functions.start_mission import (
 )
 from isar.state_machine.transitions.functions.stop import (
     stop_mission_failed,
-    stop_return_home_mission_cleanup,
     stop_return_home_mission_failed,
     trigger_stop_mission_event,
 )
@@ -38,6 +44,17 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "source": state_machine.monitor_state,
             "dest": state_machine.monitor_state,
         },
+        {
+            "trigger": "pause",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.return_home_paused_state,
+            "conditions": def_transition(state_machine, pause_return_home_mission),
+        },
+        {
+            "trigger": "pause",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.returning_home_state,
+        },
         {
             "trigger": "resume",
             "source": state_machine.paused_state,
@@ -49,18 +66,40 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "source": state_machine.paused_state,
             "dest": state_machine.paused_state,
         },
+        {
+            "trigger": "resume",
+            "source": state_machine.return_home_paused_state,
+            "dest": state_machine.returning_home_state,
+            "conditions": def_transition(state_machine, resume_mission),
+        },
+        {
+            "trigger": "resume",
+            "source": state_machine.return_home_paused_state,
+            "dest": state_machine.return_home_paused_state,
+        },
         {
             "trigger": "stop",
             "source": [
                 state_machine.await_next_mission_state,
-                state_machine.robot_standing_still_state,
                 state_machine.monitor_state,
-                state_machine.returning_home_state,
                 state_machine.paused_state,
             ],
             "dest": state_machine.stopping_state,
             "before": def_transition(state_machine, trigger_stop_mission_event),
         },
+        {
+            "trigger": "stop_return_home",
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.return_home_paused_state,
+            ],
+            "dest": state_machine.stopping_return_home_state,
+            "before": [
+                def_transition(state_machine, trigger_stop_mission_event),
+                def_transition(state_machine, reset_return_home_failure_counter),
+                def_transition(state_machine, return_home_finished),
+            ],
+        },
         {
             "trigger": "mission_stopped",
             "source": state_machine.stopping_state,
@@ -74,22 +113,16 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
         },
         {
             "trigger": "return_home_mission_stopping_failed",
-            "source": state_machine.stopping_state,
+            "source": state_machine.stopping_return_home_state,
             "dest": state_machine.returning_home_state,
             "before": def_transition(state_machine, stop_return_home_mission_failed),
         },
-        {
-            "trigger": "return_home_mission_stopped",
-            "source": state_machine.stopping_state,
-            "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, stop_return_home_mission_cleanup),
-        },
         {
             "trigger": "request_mission_start",
             "source": [
                 state_machine.await_next_mission_state,
                 state_machine.home_state,
-                state_machine.robot_standing_still_state,
+                state_machine.stopping_return_home_state,
             ],
             "dest": state_machine.monitor_state,
             "prepare": def_transition(state_machine, acknowledge_mission),
@@ -108,12 +141,6 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
-        {
-            "trigger": "request_mission_start",
-            "source": state_machine.robot_standing_still_state,
-            "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
-        },
         {
             "trigger": "request_mission_start",
             "source": state_machine.home_state,
@@ -123,7 +150,7 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "mission_failed_to_start",
             "source": [state_machine.monitor_state, state_machine.returning_home_state],
-            "dest": state_machine.robot_standing_still_state,
+            "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
         {

isar/state_machine/transitions/return_home.py

@@ -28,10 +28,10 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "source": [
                 state_machine.await_next_mission_state,
                 state_machine.home_state,
-                state_machine.robot_standing_still_state,
                 state_machine.intervention_needed_state,
                 state_machine.monitor_state,
                 state_machine.stopping_state,
+                state_machine.stopping_return_home_state,
             ],
             "dest": state_machine.returning_home_state,
             "conditions": [
@@ -53,12 +53,6 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.home_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
-        {
-            "trigger": "request_return_home",
-            "source": state_machine.robot_standing_still_state,
-            "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
-        },
         {
             "trigger": "returned_home",
             "source": state_machine.returning_home_state,

isar/state_machine/transitions/robot_status.py

@@ -1,9 +1,8 @@
 from typing import TYPE_CHECKING, List
 
 from isar.state_machine.transitions.functions.robot_status import (
-    is_available,
+    is_available_or_home,
     is_blocked_protective_stop,
-    is_home,
     is_offline,
 )
 from isar.state_machine.transitions.functions.utils import def_transition
@@ -22,24 +21,12 @@ def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
                 state_machine.offline_state,
                 state_machine.unknown_status_state,
             ],
-            "dest": state_machine.robot_standing_still_state,
-            "conditions": def_transition(state_machine, is_available),
-        },
-        {
-            "trigger": "robot_status_changed",
-            "source": [
-                state_machine.robot_standing_still_state,
-                state_machine.blocked_protective_stopping_state,
-                state_machine.offline_state,
-                state_machine.unknown_status_state,
-            ],
             "dest": state_machine.home_state,
-            "conditions": def_transition(state_machine, is_home),
+            "conditions": def_transition(state_machine, is_available_or_home),
         },
         {
             "trigger": "robot_status_changed",
             "source": [
-                state_machine.robot_standing_still_state,
                 state_machine.home_state,
                 state_machine.offline_state,
                 state_machine.unknown_status_state,
@@ -50,7 +37,6 @@ def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "robot_status_changed",
             "source": [
-                state_machine.robot_standing_still_state,
                 state_machine.home_state,
                 state_machine.blocked_protective_stopping_state,
                 state_machine.unknown_status_state,
@@ -61,7 +47,6 @@ def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "robot_status_changed",
             "source": [
-                state_machine.robot_standing_still_state,
                 state_machine.home_state,
                 state_machine.blocked_protective_stopping_state,
                 state_machine.offline_state,

isar/storage/blob_storage.py

@@ -1,13 +1,17 @@
 import logging
 from pathlib import Path
-from typing import Union
 
 from azure.core.exceptions import ResourceExistsError
-from azure.storage.blob import BlobServiceClient
+from azure.storage.blob import BlobServiceClient, ContainerClient
 
 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.storage_interface import (
+    BlobStoragePath,
+    StorageException,
+    StorageInterface,
+    StoragePaths,
+)
 from isar.storage.utilities import construct_metadata_file, construct_paths
 from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
@@ -17,12 +21,18 @@ class BlobStorage(StorageInterface):
     def __init__(self, keyvault: Keyvault) -> None:
         self.logger = logging.getLogger("uploader")
 
-        storage_connection_string = keyvault.get_secret(
-            "AZURE-STORAGE-CONNECTION-STRING"
-        ).value
+        self.container_client_data = self._get_container_client(
+            keyvault, "AZURE-STORAGE-CONNECTION-STRING-DATA"
+        )
+        self.container_client_metadata = self._get_container_client(
+            keyvault, "AZURE-STORAGE-CONNECTION-STRING-METADATA"
+        )
+
+    def _get_container_client(self, keyvault: Keyvault, secret_name: str):
+        storage_connection_string = keyvault.get_secret(secret_name).value
 
         if storage_connection_string is None:
-            raise RuntimeError("AZURE-STORAGE-CONNECTION-STRING from keyvault is None")
+            raise RuntimeError(f"{secret_name} from keyvault is None")
 
         try:
             blob_service_client = BlobServiceClient.from_connection_string(
@@ -32,48 +42,60 @@ class BlobStorage(StorageInterface):
             self.logger.error("Unable to retrieve blob service client. Error: %s", e)
             raise e
 
-        self.container_client = blob_service_client.get_container_client(
+        container_client = blob_service_client.get_container_client(
             settings.BLOB_CONTAINER
         )
 
-        if not self.container_client.exists():
+        if not container_client.exists():
             raise RuntimeError(
                 "The configured blob container %s does not exist",
                 settings.BLOB_CONTAINER,
             )
+        return container_client
 
-    def store(self, inspection: InspectionBlob, mission: Mission) -> Union[str, dict]:
+    def store(
+        self, inspection: InspectionBlob, mission: Mission
+    ) -> StoragePaths[BlobStoragePath]:
         if inspection.data is None:
             raise StorageException("Nothing to store. The inspection data is empty")
 
-        data_path, metadata_path = construct_paths(
+        data_filename, metadata_filename = construct_paths(
             inspection=inspection, mission=mission
         )
 
         metadata_bytes: bytes = construct_metadata_file(
-            inspection=inspection, mission=mission, filename=data_path.name
+            inspection=inspection, mission=mission, filename=data_filename.name
         )
 
-        self._upload_file(path=metadata_path, data=metadata_bytes)
-        return self._upload_file(path=data_path, data=inspection.data)
+        data_path = self._upload_file(
+            filename=data_filename,
+            data=inspection.data,
+            container_client=self.container_client_data,
+        )
+        metadata_path = self._upload_file(
+            filename=metadata_filename,
+            data=metadata_bytes,
+            container_client=self.container_client_metadata,
+        )
+        return StoragePaths(data_path=data_path, metadata_path=metadata_path)
 
-    def _upload_file(self, path: Path, data: bytes) -> Union[str, dict]:
-        blob_client = self.container_client.get_blob_client(path.as_posix())
+    def _upload_file(
+        self, filename: Path, data: bytes, container_client: ContainerClient
+    ) -> BlobStoragePath:
+        blob_client = container_client.get_blob_client(filename.as_posix())
         try:
             blob_client.upload_blob(data=data)
         except ResourceExistsError as e:
             self.logger.error(
-                f"Blob {path.as_posix()} already exists in container. Error: {e}"
+                "Blob %s already exists in container. Error: %s", filename.as_posix(), e
             )
             raise StorageException from e
         except Exception as e:
             self.logger.error("An unexpected error occurred while uploading blob")
             raise StorageException from e
 
-        absolute_inspection_path = {
-            "source": "blob",
-            "storage_account": settings.BLOB_STORAGE_ACCOUNT,
-            "blob_container": settings.BLOB_CONTAINER,
-            "blob_name": blob_client.blob_name,
-        }
-        return absolute_inspection_path
+        return BlobStoragePath(
+            storage_account=settings.BLOB_STORAGE_ACCOUNT,
+            blob_container=settings.BLOB_CONTAINER,
+            blob_name=blob_client.blob_name,
+        )

isar/storage/local_storage.py

@@ -2,7 +2,12 @@ import logging
 from pathlib import Path
 
 from isar.config.settings import settings
-from isar.storage.storage_interface import StorageException, StorageInterface
+from isar.storage.storage_interface import (
+    LocalStoragePath,
+    StorageException,
+    StorageInterface,
+    StoragePaths,
+)
 from isar.storage.utilities import construct_metadata_file, construct_paths
 from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
@@ -13,33 +18,35 @@ class LocalStorage(StorageInterface):
         self.root_folder: Path = Path(settings.LOCAL_STORAGE_PATH)
         self.logger = logging.getLogger("uploader")
 
-    def store(self, inspection: InspectionBlob, mission: Mission) -> str:
+    def store(
+        self, inspection: InspectionBlob, mission: Mission
+    ) -> StoragePaths[LocalStoragePath]:
         if inspection.data is None:
             raise StorageException("Nothing to store. The inspection data is empty")
 
-        local_path, local_metadata_path = construct_paths(
+        local_filename, local_metadata_filename = construct_paths(
             inspection=inspection, mission=mission
         )
 
-        absolute_path: Path = self.root_folder.joinpath(local_path)
-        absolute_metadata_path: Path = self.root_folder.joinpath(local_metadata_path)
+        data_path: Path = self.root_folder.joinpath(local_filename)
+        metadata_path: Path = self.root_folder.joinpath(local_metadata_filename)
 
-        absolute_path.parent.mkdir(parents=True, exist_ok=True)
+        data_path.parent.mkdir(parents=True, exist_ok=True)
 
         metadata_bytes: bytes = construct_metadata_file(
-            inspection=inspection, mission=mission, filename=local_path.name
+            inspection=inspection, mission=mission, filename=local_filename.name
         )
         try:
             with (
-                open(absolute_path, "wb") as file,
-                open(absolute_metadata_path, "wb") as metadata_file,
+                open(data_path, "wb") as file,
+                open(metadata_path, "wb") as metadata_file,
             ):
                 file.write(inspection.data)
                 metadata_file.write(metadata_bytes)
         except IOError as e:
             self.logger.warning(
                 f"Failed open/write for one of the following files: \n"
-                f"{absolute_path}\n{absolute_metadata_path}"
+                f"{data_path}\n{metadata_path}"
             )
             raise StorageException from e
         except Exception as e:
@@ -47,4 +54,7 @@ class LocalStorage(StorageInterface):
                 "An unexpected error occurred while writing to local storage"
             )
             raise StorageException from e
-        return str(absolute_path)
+        return StoragePaths(
+            data_path=LocalStoragePath(file_path=data_path),
+            metadata_path=LocalStoragePath(file_path=metadata_path),
+        )

isar/storage/storage_interface.py

@@ -1,25 +1,46 @@
 from abc import ABCMeta, abstractmethod
-from typing import Union
+from pathlib import Path
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
 
 from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
 
 
+class BlobStoragePath(BaseModel):
+    storage_account: str
+    blob_container: str
+    blob_name: str
+
+
+class LocalStoragePath(BaseModel):
+    file_path: Path
+
+
+TPath = TypeVar("TPath", BlobStoragePath, LocalStoragePath)
+
+
+class StoragePaths(BaseModel, Generic[TPath]):
+    data_path: TPath
+    metadata_path: TPath
+
+
 class StorageInterface(metaclass=ABCMeta):
     @abstractmethod
-    def store(self, inspection: InspectionBlob, mission: Mission) -> Union[str, dict]:
+    def store(self, inspection: InspectionBlob, mission: Mission) -> StoragePaths:
         """
         Parameters
         ----------
-        mission : Mission
-            Mission the inspection is a part of.
         inspection : InspectionBlob
             The inspection object to be stored.
+        mission : Mission
+            Mission the inspection is a part of.
 
         Returns
         ----------
-        String
-            Path of the saved inspection
+        StoragePaths
+            Paths to the data and metadata
 
         Raises
         ----------

isar/storage/uploader.py

@@ -4,11 +4,17 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from queue import Empty, Queue
 from threading import Event
-from typing import List, Union
+from typing import List
 
 from isar.config.settings import settings
 from isar.models.events import Events
-from isar.storage.storage_interface import StorageException, StorageInterface
+from isar.storage.storage_interface import (
+    BlobStoragePath,
+    LocalStoragePath,
+    StorageException,
+    StorageInterface,
+    StoragePaths,
+)
 from robot_interface.models.inspection.inspection import (
     Inspection,
     InspectionBlob,
@@ -133,10 +139,10 @@ class Uploader:
             except Empty:
                 continue
 
-    def _upload(self, item: BlobItem) -> Union[str, dict]:
-        inspection_path: Union[str, dict] = ""
+    def _upload(self, item: BlobItem) -> StoragePaths:
+        inspection_paths: StoragePaths
         try:
-            inspection_path = item.storage_handler.store(
+            inspection_paths = item.storage_handler.store(
                 inspection=item.inspection, mission=item.mission
             )
             self.logger.info(
@@ -144,7 +150,7 @@ class Uploader:
                 f"uploaded inspection {str(item.inspection.id)[:8]}"
             )
             self._internal_upload_queue.remove(item)
-        except StorageException:
+        except StorageException as e:
             if item.get_retry_count() < self.max_retry_attempts:
                 item.increment_retry(self.max_wait_time)
                 self.logger.warning(
@@ -160,7 +166,8 @@ class Uploader:
                     f"{str(item.inspection.id)[:8]}. Aborting upload."
                 )
                 self._internal_upload_queue.remove(item)
-        return inspection_path
+            raise e
+        return inspection_paths
 
     def _process_upload_queue(self) -> None:
         def should_upload(_item):
@@ -181,10 +188,17 @@ class Uploader:
                 )
                 self._internal_upload_queue.remove(item)
             elif isinstance(item, BlobItem):
-                inspection_path = self._upload(item)
-                self._publish_inspection_result(
-                    inspection=item.inspection, inspection_path=inspection_path
-                )
+                try:
+                    inspection_paths = self._upload(item)
+                    if isinstance(inspection_paths.data_path, LocalStoragePath):
+                        self.logger.info("Skipping publishing when using local storage")
+                    else:
+                        self._publish_inspection_result(
+                            inspection=item.inspection,
+                            inspection_paths=inspection_paths,
+                        )
+                except StorageException:
+                    pass
             else:
                 self.logger.warning(
                     f"Unable to process upload item as its type {type(item).__name__} is not supported"
@@ -223,7 +237,9 @@ class Uploader:
         )
 
     def _publish_inspection_result(
-        self, inspection: InspectionBlob, inspection_path: Union[str, dict]
+        self,
+        inspection: InspectionBlob,
+        inspection_paths: StoragePaths[BlobStoragePath],
     ) -> None:
         """Publishes the reference of the inspection result to the MQTT Broker
         along with the analysis type
@@ -235,7 +251,8 @@ class Uploader:
             isar_id=settings.ISAR_ID,
             robot_name=settings.ROBOT_NAME,
             inspection_id=inspection.id,
-            inspection_path=inspection_path,
+            blob_storage_data_path=inspection_paths.data_path,
+            blob_storage_metadata_path=inspection_paths.metadata_path,
             installation_code=settings.PLANT_SHORT_NAME,
             tag_id=inspection.metadata.tag_id,
             inspection_type=type(inspection).__name__,

{isar-1.33.1.dist-info → isar-1.33.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.1
+Version: 1.33.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
@@ -369,7 +369,7 @@ States.Paused,
 indicates that the state machine is already running. For running a mission the state machine need to be in the states
 
 ```
-States.Home, States.RobotStandingStill, States.AwaitNextMission or States.ReturningHome
+States.Home, States.AwaitNextMission or States.ReturningHome
 ```
 
 ### FastAPI