isar 1.11.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

isar/config/predefined_missions/default.json

@@ -1,92 +1,92 @@
 {
-  "id": 1,
-  "tasks": [
-    {
-      "steps": [
+    "id": 1,
+    "tasks": [
         {
-          "type": "drive_to_pose",
-          "pose": {
-            "position": {
-              "x": -2,
-              "y": -2,
-              "z": 0,
-              "frame": "asset"
-            },
-            "orientation": {
-              "x": 0,
-              "y": 0,
-              "z": 0.4794255,
-              "w": 0.8775826,
-              "frame": "asset"
-            },
-            "frame": "asset"
-          }
+            "steps": [
+                {
+                    "type": "drive_to_pose",
+                    "pose": {
+                        "position": {
+                            "x": -2,
+                            "y": -2,
+                            "z": 0,
+                            "frame": "asset"
+                        },
+                        "orientation": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0.4794255,
+                            "w": 0.8775826,
+                            "frame": "asset"
+                        },
+                        "frame": "asset"
+                    }
+                },
+                {
+                    "type": "take_image",
+                    "target": {
+                        "x": 2,
+                        "y": 2,
+                        "z": 0,
+                        "frame": "robot"
+                    }
+                }
+            ]
         },
         {
-          "type": "take_image",
-          "target": {
-            "x": 2,
-            "y": 2,
-            "z": 0,
-            "frame": "robot"
-          }
-        }
-      ]
-    },
-    {
-      "steps": [
-        {
-          "type": "drive_to_pose",
-          "pose": {
-            "position": {
-              "x": -2,
-              "y": 2,
-              "z": 0,
-              "frame": "asset"
-            },
-            "orientation": {
-              "x": 0,
-              "y": 0,
-              "z": 0.4794255,
-              "w": 0.8775826,
-              "frame": "asset"
-            },
-            "frame": "asset"
-          }
+            "steps": [
+                {
+                    "type": "drive_to_pose",
+                    "pose": {
+                        "position": {
+                            "x": -2,
+                            "y": 2,
+                            "z": 0,
+                            "frame": "asset"
+                        },
+                        "orientation": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0.4794255,
+                            "w": 0.8775826,
+                            "frame": "asset"
+                        },
+                        "frame": "asset"
+                    }
+                },
+                {
+                    "type": "take_thermal_image",
+                    "target": {
+                        "x": 2,
+                        "y": 2,
+                        "z": 0,
+                        "frame": "robot"
+                    }
+                }
+            ]
         },
         {
-          "type": "take_thermal_image",
-          "target": {
-            "x": 2,
-            "y": 2,
-            "z": 0,
-            "frame": "robot"
-          }
-        }
-      ]
-    },
-    {
-      "steps": [
-        {
-          "type": "drive_to_pose",
-          "pose": {
-            "position": {
-              "x": 2,
-              "y": 2,
-              "z": 0,
-              "frame": "asset"
-            },
-            "orientation": {
-              "x": 0,
-              "y": 0,
-              "z": 0.4794255,
-              "w": 0.8775826,
-              "frame": "asset"
-            },
-            "frame": "asset"
-          }
+            "steps": [
+                {
+                    "type": "drive_to_pose",
+                    "pose": {
+                        "position": {
+                            "x": 2,
+                            "y": 2,
+                            "z": 0,
+                            "frame": "asset"
+                        },
+                        "orientation": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0.4794255,
+                            "w": 0.8775826,
+                            "frame": "asset"
+                        },
+                        "frame": "asset"
+                    }
+                }
+            ]
         }
-      ]
-    }
-  ]
+    ]
 }

isar/config/settings.env

@@ -6,6 +6,9 @@ ISAR_STORAGE_LOCAL_ENABLED = true
 ISAR_STORAGE_BLOB_ENABLED = false
 ISAR_STORAGE_SLIMM_ENABLED = false
 
+ISAR_LOG_HANDLER_LOCAL_ENABLED = true
+ISAR_LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED = false
+
 ISAR_MQTT_ENABLED = true
 ISAR_MQTT_SSL_ENABLED = true
 
@@ -19,3 +22,5 @@ ISAR_API_HOST_VIEWED_EXTERNALLY = 0.0.0.0
 ISAR_MQTT_USERNAME = isar
 ISAR_MQTT_HOST = localhost
 ISAR_MQTT_PORT = 1883
+
+ISAR_KEYVAULT_NAME = IsarDevKv

isar/config/settings.py

@@ -119,7 +119,7 @@ class Settings(BaseSettings):
     MQTT_PORT: int = Field(default=1883)
 
     # Keyvault name
-    KEYVAULT: str = Field(default="EqRobotKeyVault")
+    KEYVAULT_NAME: str = Field(default="IsarDevKv")
 
     # URL to storage account for Azure Blob Storage
     BLOB_STORAGE_ACCOUNT_URL: str = Field(
@@ -151,14 +151,14 @@ class Settings(BaseSettings):
     ECHO_API_URL: str = Field(default="https://echohubapi.equinor.com/api")
 
     # Client ID for SLIMM App Registration
-    SLIMM_CLIENT_ID: str = Field(default="94c048cc-58e9-4570-85c0-4028c50ab6f3")
+    SLIMM_CLIENT_ID: str = Field(default="c630ca4d-d8d6-45ab-8cc6-68a363d0de9e")
 
     # Scope for access to SLIMM Ingestion API
     SLIMM_APP_SCOPE: str = Field(default=".default")
 
     # URL for SLIMM endpoint
     SLIMM_API_URL: str = Field(
-        default="https://slimmingestapitest.azurewebsites.net/SpatialIngest"
+        default="https://scinspectioningestapitest.azurewebsites.net/Ingest"
     )
 
     # Whether the results should be copied directly into the SLIMM datalake or only the
@@ -236,6 +236,18 @@ class Settings(BaseSettings):
     TOPIC_ISAR_ROBOT_STATUS: str = Field(default="robot_status")
     TOPIC_ISAR_ROBOT_INFO: str = Field(default="robot_info")
 
+    # Logging
+
+    #   Log handlers
+    # Determines which log handlers are used by ISAR
+    # Multiple log handlers can be chosen
+    # Each handler will be called when logging
+    # Selecting a different log handler than local may require certain access rights:
+    #    - The Azure AI logger requires the 'APPLICATIONINSIGHTS_CONNECTION_STRING' to be set as an environment variable.
+    LOG_HANDLER_LOCAL_ENABLED: bool = Field(default=True)
+    LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED: bool = Field(default=False)
+
+    #   Log levels
     API_LOG_LEVEL: str = Field(default="INFO")
     MAIN_LOG_LEVEL: str = Field(default="INFO")
     MQTT_LOG_LEVEL: str = Field(default="INFO")

isar/mission_planner/echo_planner.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, List, Optional, Union
+from typing import List, Optional, Union
 
 from alitra import Frame, Pose, Position
 from azure.identity import DefaultAzureCredential

isar/models/mission/status.py

@@ -3,19 +3,19 @@ from enum import Enum
 
 class MissionStatus(str, Enum):
     NotStarted: str = "not_started"
-    Started: str = "started"
     InProgress: str = "in_progress"
+    Paused: str = "paused"
     Failed: str = "failed"
     Cancelled: str = "cancelled"
-    Completed: str = "completed"
-    Paused: str = "paused"
+    Successful: str = "successful"
+    PartiallySuccessful: str = "partially_successful"
 
 
 class TaskStatus(str, Enum):
     NotStarted: str = "not_started"
     InProgress: str = "in_progress"
-    PartiallySuccessful: str = "partially_successful"
+    Paused: str = "paused"
     Failed: str = "failed"
     Cancelled: str = "cancelled"
     Successful: str = "successful"
-    Paused: str = "paused"
+    PartiallySuccessful: str = "partially_successful"

isar/models/mission_metadata/mission_metadata.py

@@ -17,8 +17,10 @@ class MissionMetadata:
     source_url: Optional[str] = None
     plant_code: str = settings.PLANT_CODE
     plant_name: str = settings.PLANT_NAME
+    plant_short_name: str = settings.PLANT_SHORT_NAME
     media_orientation_reference_system: str = (
         settings.MEDIA_ORIENTATION_REFERENCE_SYSTEM
     )
     robot_id: str = settings.ROBOT_ID
+    robot_model: str = settings.ROBOT_TYPE
     mission_date: date = datetime.utcnow().date()

isar/modules.py

@@ -36,8 +36,9 @@ class APIModule(Module):
         self,
         authenticator: Authenticator,
         scheduling_controller: SchedulingController,
+        keyvault: Keyvault,
     ) -> API:
-        return API(authenticator, scheduling_controller)
+        return API(authenticator, scheduling_controller, keyvault)
 
     @provider
     @singleton
@@ -153,7 +154,7 @@ class ServiceModule(Module):
     @provider
     @singleton
     def provide_keyvault(self) -> Keyvault:
-        return Keyvault(keyvault_name=settings.KEYVAULT)
+        return Keyvault(keyvault_name=settings.KEYVAULT_NAME)
 
     @provider
     @singleton

isar/services/service_connections/request_handler.py

@@ -51,7 +51,7 @@ class RequestHandler:
             response.raise_for_status()
         except HTTPError:
             self.logger.exception(
-                f"Http error. Http status code= {response.status_code}"
+                f"Http error. Http status code= {response.status_code}, Content: {response.content}"
             )
             raise
         return response

isar/state_machine/state_machine.py

@@ -262,7 +262,15 @@ class StateMachine(object):
         self.update_current_step()
 
     def _mission_finished(self) -> None:
-        self.current_mission.status = MissionStatus.Completed
+        fail_statuses: List[TaskStatus] = [
+            TaskStatus.Cancelled,
+            TaskStatus.Failed,
+            TaskStatus.PartiallySuccessful,
+        ]
+        if any(task.status in fail_statuses for task in self.current_mission.tasks):
+            self.current_mission.status = MissionStatus.PartiallySuccessful
+        else:
+            self.current_mission.status = MissionStatus.Successful
         self._finalize()
 
     def _mission_started(self) -> None:

isar/storage/slimm_storage.py

@@ -1,3 +1,4 @@
+import json
 import logging
 
 from azure.identity import DefaultAzureCredential
@@ -10,8 +11,8 @@ from isar.models.mission_metadata.mission_metadata import MissionMetadata
 from isar.services.auth.azure_credentials import AzureCredentials
 from isar.services.service_connections.request_handler import RequestHandler
 from isar.storage.storage_interface import StorageException, StorageInterface
-from isar.storage.utilities import get_filename, get_inspection_type
-from robot_interface.models.inspection.inspection import Inspection
+from isar.storage.utilities import get_filename
+from robot_interface.models.inspection.inspection import Inspection, ThermalVideo, Video
 
 
 class SlimmStorage(StorageInterface):
@@ -30,41 +31,61 @@ class SlimmStorage(StorageInterface):
 
         self.url: str = settings.SLIMM_API_URL
 
-    def store(self, inspection: Inspection, metadata: MissionMetadata) -> None:
-        token: str = self.credentials.get_token(self.request_scope).token
-
-        request_url: str = f"{self.url}/UploadSingleFile"
-
-        inspection_type: str = get_inspection_type(inspection=inspection)
+    def store(self, inspection: Inspection, metadata: MissionMetadata):
         filename: str = get_filename(
             mission_id=metadata.mission_id,
-            inspection_type=inspection_type,
+            inspection_type=type(inspection).__name__,
             inspection_id=inspection.id,
         )
-        filename_with_ending: str = f"{filename}.{inspection.metadata.file_type}"
+        filename = f"{filename}.{inspection.metadata.file_type}"
+        if type(inspection) in [Video, ThermalVideo]:
+            self._store_video(filename, inspection, metadata)
+        else:
+            self._store_image(filename, inspection, metadata)
 
-        multiform_body: MultipartEncoder = self._construct_multiform_request(
-            filename=filename_with_ending, inspection=inspection, metadata=metadata
+    def _store_image(
+        self, filename: str, inspection: Inspection, metadata: MissionMetadata
+    ):
+        multiform_body: MultipartEncoder = self._construct_multiform_request_image(
+            filename=filename, inspection=inspection, metadata=metadata
+        )
+        request_url: str = f"{self.url}/UploadSingleImage"
+        self._ingest(
+            inspection=inspection,
+            multiform_body=multiform_body,
+            request_url=request_url,
         )
+        return
 
+    def _store_video(
+        self, filename: str, inspection: Inspection, metadata: MissionMetadata
+    ):
+        multiform_body: MultipartEncoder = self._construct_multiform_request_video(
+            filename=filename, inspection=inspection, metadata=metadata
+        )
+        request_url = f"{self.url}/UploadSingleVideo"
         self._ingest(
             inspection=inspection,
             multiform_body=multiform_body,
             request_url=request_url,
-            token=token,
         )
+        return
 
-    def _ingest(self, inspection, multiform_body, request_url, token) -> None:
+    def _ingest(
+        self, inspection: Inspection, multiform_body: MultipartEncoder, request_url: str
+    ):
+        token: str = self.credentials.get_token(self.request_scope).token
         try:
-            self.request_handler.post(
+            response = self.request_handler.post(
                 url=request_url,
-                params={"DataType": "still"},
                 data=multiform_body,
                 headers={
                     "Authorization": f"Bearer {token}",
                     "Content-Type": multiform_body.content_type,
                 },
             )
+            guid = json.loads(response.text)["guid"]
+            self.logger.info(f"SLIMM upload GUID: {guid}")
         except (RequestException, HTTPError) as e:
             self.logger.warning(
                 f"Failed to upload inspection: {inspection.id} to SLIMM due to a "
@@ -73,50 +94,93 @@ class SlimmStorage(StorageInterface):
             raise StorageException from e
 
     @staticmethod
-    def _construct_multiform_request(
-        filename, inspection, metadata
-    ) -> MultipartEncoder:
+    def _construct_multiform_request_image(
+        filename: str, inspection: Inspection, metadata: MissionMetadata
+    ):
         array_of_orientation = (
             inspection.metadata.time_indexed_pose.pose.orientation.to_quat_array().tolist()
         )
         multiform_body: MultipartEncoder = MultipartEncoder(
             fields={
-                "SchemaMetadata.Mission.MissionId": metadata.mission_id,
-                "SchemaMetadata.Mission.StartDate": metadata.mission_date.isoformat(),
-                "SchemaMetadata.Mission.EndDate": metadata.mission_date.isoformat(),
-                "SchemaMetadata.Geodetic.CoordinateReferenceSystemCode": metadata.coordinate_reference_system,  # noqa: E501
-                "SchemaMetadata.Geodetic.VerticalCoordinateReferenceSystemCode": metadata.vertical_reference_system,  # noqa: E501
-                "SchemaMetadata.Geodetic.OrientationReferenceSystem": metadata.media_orientation_reference_system,  # noqa: E501
-                "SchemaMetadata.SensorCarrier.Id": metadata.robot_id,
-                "SchemaMetadata.InternalClassification": metadata.data_classification,
-                "SchemaMetadata.PlantFacilitySAPCode": metadata.plant_code,
-                "SchemaMetadata.Mission.Client": "Equinor",
-                "SchemaMetadata.IsoCountryCode": "NO",
-                "AttachedFileMetadata.X": str(
+                "PlantFacilitySAPCode": metadata.plant_code,
+                "InstCode": metadata.plant_short_name,
+                "InternalClassification": metadata.data_classification,
+                "IsoCountryCode": "NO",
+                "Geodetic.CoordinateReferenceSystemCode": metadata.coordinate_reference_system,  # noqa: E501
+                "Geodetic.VerticalCoordinateReferenceSystemCode": metadata.vertical_reference_system,  # noqa: E501
+                "Geodetic.OrientationReferenceSystem": metadata.media_orientation_reference_system,  # noqa: E501
+                "SensorCarrier.SensorCarrierId": metadata.robot_id,
+                "SensorCarrier.ModelName": metadata.robot_model,
+                "Mission.MissionId": metadata.mission_id,
+                "Mission.Client": "Equinor",
+                "ImageMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
+                "ImageMetadata.X": str(
                     inspection.metadata.time_indexed_pose.pose.position.x
                 ),
-                "AttachedFileMetadata.Y": str(
+                "ImageMetadata.Y": str(
                     inspection.metadata.time_indexed_pose.pose.position.y
                 ),
-                "AttachedFileMetadata.Z": str(
+                "ImageMetadata.Y": str(
                     inspection.metadata.time_indexed_pose.pose.position.z
                 ),
-                "AttachedFileMetadata.CameraOrientation[0]": str(
-                    array_of_orientation[0]
-                ),
-                "AttachedFileMetadata.CameraOrientation[1]": str(
-                    array_of_orientation[1]
+                "ImageMetadata.CameraOrientation1": str(array_of_orientation[0]),
+                "ImageMetadata.CameraOrientation2": str(array_of_orientation[1]),
+                "ImageMetadata.CameraOrientation3": str(array_of_orientation[2]),
+                "ImageMetadata.CameraOrientation4": str(array_of_orientation[3]),
+                "ImageMetadata.AnalysisMethods": str(inspection.metadata.analysis),
+                "ImageMetadata.Description": str(inspection.metadata.additional),
+                "ImageMetadata.FunctionalLocation": inspection.metadata.tag_id  # noqa: E501
+                if inspection.metadata.tag_id
+                else "NA",
+                "Filename": filename,
+                "AttachedFile": (filename, inspection.data),
+            }
+        )
+        return multiform_body
+
+    @staticmethod
+    def _construct_multiform_request_video(
+        filename: str,
+        inspection: Inspection,
+        metadata: MissionMetadata,
+    ):
+        array_of_orientation = (
+            inspection.metadata.time_indexed_pose.pose.orientation.to_quat_array().tolist()
+        )
+        multiform_body: MultipartEncoder = MultipartEncoder(
+            fields={
+                "PlantFacilitySAPCode": metadata.plant_code,
+                "InstCode": metadata.plant_short_name,
+                "InternalClassification": metadata.data_classification,
+                "IsoCountryCode": "NO",
+                "Geodetic.CoordinateReferenceSystemCode": metadata.coordinate_reference_system,  # noqa: E501
+                "Geodetic.VerticalCoordinateReferenceSystemCode": metadata.vertical_reference_system,  # noqa: E501
+                "Geodetic.OrientationReferenceSystem": metadata.media_orientation_reference_system,  # noqa: E501
+                "SensorCarrier.SensorCarrierId": metadata.robot_id,
+                "SensorCarrier.ModelName": metadata.robot_model,
+                "Mission.MissionId": metadata.mission_id,
+                "Mission.Client": "Equinor",
+                "VideoMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
+                "VideoMetadata.Duration": str(inspection.metadata.duration),  # type: ignore
+                "VideoMetadata.X": str(
+                    inspection.metadata.time_indexed_pose.pose.position.x
                 ),
-                "AttachedFileMetadata.CameraOrientation[2]": str(
-                    array_of_orientation[2]
+                "VideoMetadata.Y": str(
+                    inspection.metadata.time_indexed_pose.pose.position.y
                 ),
-                "AttachedFileMetadata.CameraOrientation[3]": str(
-                    array_of_orientation[3]
+                "VideoMetadata.Y": str(
+                    inspection.metadata.time_indexed_pose.pose.position.z
                 ),
-                "AttachedFileMetadata.FunctionalLocation": inspection.metadata.tag_id  # noqa: E501
+                "VideoMetadata.CameraOrientation1": str(array_of_orientation[0]),
+                "VideoMetadata.CameraOrientation2": str(array_of_orientation[1]),
+                "VideoMetadata.CameraOrientation3": str(array_of_orientation[2]),
+                "VideoMetadata.CameraOrientation4": str(array_of_orientation[3]),
+                "VideoMetadata.AnalysisMethods": str(inspection.metadata.analysis),
+                "VideoMetadata.Description": str(inspection.metadata.additional),
+                "VideoMetadata.FunctionalLocation": inspection.metadata.tag_id  # noqa: E501
                 if inspection.metadata.tag_id
                 else "NA",
-                "AttachedFileMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
+                "Filename": filename,
                 "AttachedFile": (filename, inspection.data),
             }
         )

isar/storage/utilities.py

@@ -14,12 +14,10 @@ from robot_interface.utilities.json_service import EnhancedJSONEncoder
 def construct_local_paths(
     inspection: Inspection, metadata: MissionMetadata
 ) -> Tuple[Path, Path]:
-    inspection_type: str = get_inspection_type(inspection=inspection)
-
     folder: Path = Path(str(metadata.mission_id))
     filename: str = get_filename(
         mission_id=metadata.mission_id,
-        inspection_type=inspection_type,
+        inspection_type=type(inspection).__name__,
         inspection_id=inspection.id,
     )
 
@@ -77,23 +75,3 @@ def get_filename(
     inspection_id: UUID,
 ) -> str:
     return f"{mission_id}_{inspection_type}_{inspection_id}"
-
-
-def get_inspection_type(inspection: Inspection) -> str:
-    if isinstance(inspection, Image):
-        return "image"
-    elif isinstance(inspection, ThermalImage):
-        return "thermal"
-    elif isinstance(inspection, Video):
-        return "video"
-    elif isinstance(inspection, ThermalVideo):
-        return "thermal_video"
-    else:
-        logging.getLogger("uploader").warning(
-            f"Failed to upload inspection with ID: {inspection.id}\n "
-            f"This was due to an inspection type ({type(inspection)}) "
-            f"which is not supported by the uploader"
-        )
-        raise StorageException(
-            f"Inspection type not supported by the uploader. Got {type(inspection)}"
-        )

{isar-1.11.0.dist-info → isar-1.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.11.0
+Version: 1.12.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Home-page: https://github.com/equinor/isar
 Author: Equinor ASA
@@ -25,6 +25,9 @@ Requires-Dist: dacite
 Requires-Dist: fastapi-azure-auth
 Requires-Dist: fastapi
 Requires-Dist: injector
+Requires-Dist: opencensus-ext-logging
+Requires-Dist: opencensus-ext-requests
+Requires-Dist: opencensus-ext-azure
 Requires-Dist: numpy
 Requires-Dist: paho-mqtt
 Requires-Dist: pydantic