isar 1.20.2__py3-none-any.whl → 1.34.9__py3-none-any.whl

isar/state_machine/transitions/robot_status.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
+    robot_status_transitions: List[dict] = [
+        {
+            "trigger": "initial_transition",
+            "source": state_machine.unknown_status_state,
+            "dest": state_machine.unknown_status_state,
+        },
+        {
+            "trigger": "initial_transition",
+            "source": state_machine.maintenance_state,
+            "dest": state_machine.maintenance_state,
+        },
+        {
+            "trigger": "robot_status_available",
+            "source": [
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.await_next_mission_state,
+        },
+        {
+            "trigger": "robot_status_available",
+            "source": [
+                state_machine.offline_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.home_state,
+            ],
+            "dest": state_machine.intervention_needed_state,
+        },
+        {
+            "trigger": "robot_status_home",
+            "source": [
+                state_machine.home_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.offline_state,
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.home_state,
+        },
+        {
+            "trigger": "robot_status_blocked_protective_stop",
+            "source": [
+                state_machine.home_state,
+                state_machine.offline_state,
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.blocked_protective_stopping_state,
+        },
+        {
+            "trigger": "robot_status_offline",
+            "source": [
+                state_machine.home_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.unknown_status_state,
+                state_machine.recharging_state,
+            ],
+            "dest": state_machine.offline_state,
+        },
+        {
+            "trigger": "robot_status_unknown",
+            "source": [
+                state_machine.home_state,
+                state_machine.blocked_protective_stopping_state,
+                state_machine.offline_state,
+                state_machine.unknown_status_state,
+            ],
+            "dest": state_machine.unknown_status_state,
+        },
+        {
+            "trigger": "robot_recharged",
+            "source": state_machine.recharging_state,
+            "dest": state_machine.home_state,
+        },
+    ]
+    return robot_status_transitions

isar/state_machine/utils/common_event_handlers.py

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING, Callable, Optional
+
+from isar.apis.models.models import ControlMissionResponse, MissionStartResponse
+from isar.models.events import Event
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+def start_mission_event_handler(
+    state_machine: "StateMachine",
+    event: Event[Mission],
+    response: Event[MissionStartResponse],
+) -> Optional[Callable]:
+    mission: Optional[Mission] = event.consume_event()
+    if not mission:
+        return None
+
+    if not state_machine.battery_level_is_above_mission_start_threshold():
+        response.trigger_event(
+            MissionStartResponse(
+                mission_id=mission.id,
+                mission_started=False,
+                mission_not_started_reason="Robot battery too low",
+            )
+        )
+        return None
+    state_machine.start_mission(mission=mission)
+    response.trigger_event(MissionStartResponse(mission_started=True))
+    return state_machine.start_mission_monitoring  # type: ignore
+
+
+def return_home_event_handler(
+    state_machine: "StateMachine", event: Event[bool]
+) -> Optional[Callable]:
+    if not event.consume_event():
+        return None
+
+    state_machine.events.api_requests.return_home.response.trigger_event(True)
+    state_machine.start_return_home_mission()
+    return state_machine.start_return_home_monitoring  # type: ignore
+
+
+def stop_mission_event_handler(
+    state_machine: "StateMachine", event: Event[str]
+) -> Optional[Callable]:
+    mission_id: str = event.consume_event()
+    if mission_id is None:
+        return None
+
+    if state_machine.shared_state.mission_id.check() == mission_id or mission_id == "":
+        state_machine.events.api_requests.stop_mission.response.trigger_event(
+            ControlMissionResponse(success=True)
+        )
+        state_machine.events.state_machine_events.stop_mission.trigger_event(True)
+        return state_machine.stop  # type: ignore
+    else:
+        state_machine.events.api_requests.stop_mission.response.trigger_event(
+            ControlMissionResponse(success=False, failure_reason="Mission not found")
+        )
+        return None
+
+
+def mission_started_event_handler(
+    state_machine: "StateMachine",
+    event: Event[bool],
+) -> Optional[Callable]:
+    if not event.consume_event():
+        return None
+
+    state_machine.logger.info("Received confirmation that mission has started")
+    return None

isar/storage/blob_storage.py

@@ -1,83 +1,101 @@
 import logging
 from pathlib import Path
-from typing import Union
 
 from azure.core.exceptions import ResourceExistsError
-from azure.storage.blob import BlobClient, BlobServiceClient, ContainerClient
-from injector import inject
+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 Inspection
+from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
 
 
 class BlobStorage(StorageInterface):
-    @inject
-    def __init__(
-        self, keyvault: Keyvault, container_name: str = settings.BLOB_CONTAINER
-    ):
-        self.keyvault = keyvault
-        self.storage_connection_string = self.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
+    def __init__(self, keyvault: Keyvault) -> None:
+        self.logger = logging.getLogger("uploader")
+
+        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"
         )
 
-        self.logger = logging.getLogger("uploader")
+    def _get_container_client(self, keyvault: Keyvault, secret_name: str):
+        storage_connection_string = keyvault.get_secret(secret_name).value
 
-    def store(self, inspection: Inspection, mission: Mission) -> Union[str, dict]:
-        data_path, metadata_path = construct_paths(
+        if storage_connection_string is None:
+            raise RuntimeError(f"{secret_name} 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
+
+        container_client = blob_service_client.get_container_client(
+            settings.BLOB_CONTAINER
+        )
+
+        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
+    ) -> StoragePaths[BlobStoragePath]:
+        if inspection.data is None:
+            raise StorageException("Nothing to store. The inspection data is empty")
+
+        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._get_blob_client(path)
+    def _upload_file(
+        self, filename: Path, data: bytes, container_client: ContainerClient
+    ) -> BlobStoragePath:
+        blob_client = container_client.get_blob_client(filename.as_posix())
         try:
-            blob_properties = blob_client.upload_blob(data=data)
+            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",
-            "blob_storage_account_url": settings.BLOB_STORAGE_ACCOUNT_URL,
-            "blob_container": settings.BLOB_CONTAINER,
-            "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(f"Unable to retrieve blob service client. Error: {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())
+        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,9 +2,14 @@ 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 Inspection
+from robot_interface.models.inspection.inspection import InspectionBlob
 from robot_interface.models.mission.mission import Mission
 
 
@@ -13,30 +18,35 @@ 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:
-        local_path, local_metadata_path = construct_paths(
+    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_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:
@@ -44,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 robot_interface.models.inspection.inspection import Inspection
+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: Inspection, mission: Mission) -> Union[str, dict]:
+    def store(self, inspection: InspectionBlob, mission: Mission) -> StoragePaths:
         """
         Parameters
         ----------
+        inspection : InspectionBlob
+            The inspection object to be stored.
         mission : Mission
             Mission the inspection is a part of.
-        inspection : Inspection
-            The inspection object to be stored.
 
         Returns
         ----------
-        String
-            Path of the saved inspection
+        StoragePaths
+            Paths to the data and metadata
 
         Raises
         ----------