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

robot_interface/models/exceptions/__init__.py

@@ -1,7 +0,0 @@
-from .robot_exceptions import (
-    RobotCommunicationException,
-    RobotException,
-    RobotInfeasibleMissionException,
-    RobotInfeasibleStepException,
-    RobotInvalidResponseException,
-)

robot_interface/models/exceptions/robot_exceptions.py

@@ -1,26 +1,296 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class ErrorReason(str, Enum):
+    RobotCommunicationException = "robot_communication_exception"
+    RobotCommunicationTimeoutException = "robot_communication_timeout_exception"
+    RobotInfeasibleTaskException = "robot_infeasible_task_exception"
+    RobotInfeasibleMissionException = "robot_infeasible_mission_exception"
+    RobotUnreliableDockingStatusException = "robot_unreliable_docking_status_exception"
+    RobotMissionStatusException = "robot_mission_status_exception"
+    RobotTaskStatusException = "robot_task_status_exception"
+    RobotAPIException = "robot_api_exception"
+    RobotActionException = "robot_action_exception"
+    RobotRetrieveDataException = "robot_retrieve_data_exception"
+    RobotRetrieveInspectionException = "robot_retrieve_inspection_exception"
+    RobotStillStartingMissionException = "robot_still_starting_mission_exception"
+    RobotTelemetryException = "robot_telemetry_exception"
+    RobotTelemetryNoUpdateException = "robot_telemetry_no_update_exception"
+    RobotTelemetryPoseException = "robot_telemetry_pose_exception"
+    RobotMapException = "robot_map_exception"
+    RobotTransformException = "robot_transform_exception"
+    RobotUnknownErrorException = "robot_unknown_error_exception"
+    RobotDisconnectedException = "robot_disconnected_exception"
+    RobotNoMissionRunningException = "robot_no_mission_running_exception"
+    RobotAlreadyHomeException = "robot_already_home_exception"
+
+
+@dataclass
+class ErrorMessage:
+    error_reason: Optional[ErrorReason]
+    error_description: str
+
+
+# This is the base exception class for exceptions that should be raised from the robot
+# package and handled in ISAR. Please peruse the different subclasses for information
+# on which exceptions to use where.
 class RobotException(Exception):
-    pass
+    def __init__(self, error_reason: ErrorReason, error_description: str):
+        self.error_reason: ErrorReason = error_reason
+        self.error_description: str = error_description
 
 
+# An exception which should be thrown by the robot package if it is unable to
+# communicate with the robot API. ISAR will retry the request.
 class RobotCommunicationException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotCommunicationException,
+            error_description=error_description,
+        )
+
     pass
 
 
-class RobotInfeasibleStepException(RobotException):
+# An exception which should be thrown by the robot package if it is unable to
+# complete a request as there is no ongoing mission.
+class RobotNoMissionRunningException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotNoMissionRunningException,
+            error_description=error_description,
+        )
+
     pass
 
 
+# An exception which should be thrown by the robot package if the communication has timed
+# out and ISAR should retry the request.
+class RobotCommunicationTimeoutException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotCommunicationTimeoutException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to start the
+# current task.
+class RobotInfeasibleTaskException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotInfeasibleTaskException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to start the
+# current mission.
 class RobotInfeasibleMissionException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotInfeasibleMissionException,
+            error_description=error_description,
+        )
+
     pass
 
 
-class RobotInvalidResponseException(RobotException):
+class RobotUnreliableDockingStatusException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotUnreliableDockingStatusException,
+            error_description=error_description,
+        )
+
     pass
 
 
+# An exception which should be thrown by the robot package if it is unable to collect
+# the status of the current mission.
+class RobotMissionStatusException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotMissionStatusException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to collect
+# the status of the current task.
+class RobotTaskStatusException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotTaskStatusException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is able to communicate
+# with the robot API but the result of the communication leads to an exception. An
+# example could be a KeyError while reading from the response dictionary.
+class RobotAPIException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotAPIException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to perform a
+# requested action. For example the package is unable to stop the robot.
+class RobotActionException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotActionException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to retrieve
+# data from the API like currently executing missions, status of the current mission
+# and similar.
+class RobotRetrieveDataException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotRetrieveDataException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to collect
+# the inspections that were generated for the currently executing task or mission.
+class RobotRetrieveInspectionException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotRetrieveInspectionException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is still starting the
+# mission when another action is requested. An example of this can be trying to stop
+# the robot while it is still starting the mission.
+class RobotStillStartingMissionException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotStillStartingMissionException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to retrieve
+# telemetry data. It should be used exclusively by the telemetry publishers and their
+# functions.
+class RobotTelemetryException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotTelemetryException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to retrieve
+# telemetry pose data. It should be used exclusively by the telemetry pose publisher.
+class RobotTelemetryPoseException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotTelemetryPoseException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if there is no new telemetry update.
+class RobotTelemetryNoUpdateException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotTelemetryNoUpdateException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to load the
+# configuration for maps and transformations. This could be caused by faulty
+# configuration and this exception will cause ISAR to crash as further execution is not
+# advised.
 class RobotMapException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotMapException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if it is unable to transform
+# the coordinates correctly between asset and robot frame.
+class RobotTransformException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotTransformException,
+            error_description=error_description,
+        )
+
     pass
 
 
-class RobotInvalidTelemetryException(RobotException):
+# An exception which should be thrown by the robot package if something occurred that
+# was unexpected and the error reason is unknown.
+class RobotUnknownErrorException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotUnknownErrorException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if the robot is not connected to the cloud
+class RobotDisconnectedException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotDisconnectedException,
+            error_description=error_description,
+        )
+
+    pass
+
+
+# An exception which should be thrown by the robot package if the robot receives a command
+# to go home and decide to ignore this request as it is already at home.
+class RobotAlreadyHomeException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotAlreadyHomeException,
+            error_description=error_description,
+        )
+
     pass

robot_interface/models/initialize/__init__.py

@@ -1 +0,0 @@
-from .initialize_params import InitializeParams

robot_interface/models/inspection/__init__.py

@@ -1,13 +0,0 @@
-from .inspection import (
-    Audio,
-    Image,
-    ImageMetadata,
-    Inspection,
-    InspectionMetadata,
-    ThermalImage,
-    ThermalImageMetadata,
-    ThermalVideo,
-    ThermalVideoMetadata,
-    Video,
-    VideoMetadata,
-)

robot_interface/models/inspection/inspection.py

@@ -1,61 +1,62 @@
-from abc import ABC
-from dataclasses import dataclass, field
 from datetime import datetime
-from typing import List, Optional, Type
+from typing import Optional, Type
 
-from alitra import Pose
+from alitra import Pose, Position
+from pydantic import BaseModel, Field
 
-from robot_interface.utilities.uuid_string_factory import uuid4_string
 
-
-@dataclass
-class InspectionMetadata(ABC):
+class InspectionMetadata(BaseModel):
     start_time: datetime
-    pose: Pose
+    robot_pose: Pose
+    target_position: Position
     file_type: str
-    analysis: Optional[str] = field(default=None, init=False)
-    tag_id: Optional[str] = field(default=None, init=False)
-    additional: Optional[dict] = field(default_factory=dict, init=False)
+    tag_id: Optional[str] = None
+    inspection_description: Optional[str] = None
 
 
-@dataclass
 class ImageMetadata(InspectionMetadata):
     pass
 
 
-@dataclass
 class ThermalImageMetadata(InspectionMetadata):
     pass
 
 
-@dataclass
 class VideoMetadata(InspectionMetadata):
-    duration: Optional[float] = field(default=None)
+    duration: float
 
 
-@dataclass
 class ThermalVideoMetadata(InspectionMetadata):
-    duration: Optional[float] = field(default=None)
+    duration: float
 
 
-@dataclass
 class AudioMetadata(InspectionMetadata):
-    duration: Optional[float] = field(default=None)
+    duration: float
+
+
+class GasMeasurementMetadata(InspectionMetadata):
+    pass
 
 
-@dataclass
-class Inspection:
-    id: str = field(default_factory=uuid4_string, init=False)
+class Inspection(BaseModel):
     metadata: InspectionMetadata
-    data: Optional[bytes] = field(default=None, init=False)
+    id: str = Field(frozen=True)
 
     @staticmethod
     def get_metadata_type() -> Type[InspectionMetadata]:
         return InspectionMetadata
 
 
-@dataclass
-class Image(Inspection):
+class InspectionValue(Inspection):
+    value: float = Field(frozen=True)
+    unit: str = Field(frozen=True)
+
+
+class InspectionBlob(Inspection):
+    data: Optional[bytes] = Field(default=None, frozen=True)
+
+
+class Image(InspectionBlob):
     metadata: ImageMetadata
 
     @staticmethod
@@ -63,8 +64,7 @@ class Image(Inspection):
         return ImageMetadata
 
 
-@dataclass
-class ThermalImage(Inspection):
+class ThermalImage(InspectionBlob):
     metadata: ThermalImageMetadata
 
     @staticmethod
@@ -72,8 +72,7 @@ class ThermalImage(Inspection):
         return ThermalImageMetadata
 
 
-@dataclass
-class Video(Inspection):
+class Video(InspectionBlob):
     metadata: VideoMetadata
 
     @staticmethod
@@ -81,8 +80,7 @@ class Video(Inspection):
         return VideoMetadata
 
 
-@dataclass
-class ThermalVideo(Inspection):
+class ThermalVideo(InspectionBlob):
     metadata: ThermalVideoMetadata
 
     @staticmethod
@@ -90,10 +88,21 @@ class ThermalVideo(Inspection):
         return ThermalVideoMetadata
 
 
-@dataclass
-class Audio(Inspection):
+class Audio(InspectionBlob):
     metadata: AudioMetadata
 
     @staticmethod
     def get_metadata_type() -> Type[InspectionMetadata]:
         return AudioMetadata
+
+
+class GasMeasurement(InspectionValue):
+    metadata: GasMeasurementMetadata
+
+    @staticmethod
+    def get_metadata_type() -> Type[InspectionMetadata]:
+        return GasMeasurementMetadata
+
+
+class CO2Measurement(GasMeasurement):
+    pass

robot_interface/models/mission/mission.py

@@ -1,21 +1,25 @@
-from dataclasses import dataclass, field
-from typing import List
+from typing import List, Optional
 
+from alitra import Pose
+from pydantic import BaseModel, Field
+
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.mission.status import MissionStatus
-from robot_interface.models.mission.task import Task
+from robot_interface.models.mission.task import TASKS, TaskTypes
 from robot_interface.utilities.uuid_string_factory import uuid4_string
 
 
-@dataclass
-class Mission:
-    tasks: List[Task]
-    id: str = field(default_factory=uuid4_string, init=True)
-    name: str = ""
+class Mission(BaseModel):
+    id: str = Field(default_factory=uuid4_string, frozen=True)
+    tasks: List[TASKS] = Field(default_factory=list, frozen=True)
+    name: str = Field(frozen=True)
+    start_pose: Optional[Pose] = Field(default=None, frozen=True)
     status: MissionStatus = MissionStatus.NotStarted
+    error_message: Optional[ErrorMessage] = Field(default=None)
 
-    def _set_unique_id(self) -> None:
-        self.id: str = uuid4_string()
-
-    def __post_init__(self) -> None:
-        if self.id is None:
-            self._set_unique_id()
+    def _is_return_to_home_mission(self) -> bool:
+        if len(self.tasks) != 1:
+            return False
+        if self.tasks[0].type != TaskTypes.ReturnToHome:
+            return False
+        return True

robot_interface/models/mission/status.py

@@ -2,34 +2,29 @@ from enum import Enum
 
 
 class MissionStatus(str, Enum):
-    NotStarted: str = "not_started"
-    InProgress: str = "in_progress"
-    Paused: str = "paused"
-    Failed: str = "failed"
-    Cancelled: str = "cancelled"
-    Successful: str = "successful"
-    PartiallySuccessful: str = "partially_successful"
-
-
-class StepStatus(str, Enum):
-    NotStarted: str = "not_started"
-    Successful: str = "successful"
-    InProgress: str = "in_progress"
-    Failed: str = "failed"
-    Cancelled: str = "cancelled"
+    NotStarted = "not_started"
+    InProgress = "in_progress"
+    Paused = "paused"
+    Failed = "failed"
+    Cancelled = "cancelled"
+    Successful = "successful"
+    PartiallySuccessful = "partially_successful"
 
 
 class TaskStatus(str, Enum):
-    NotStarted: str = "not_started"
-    InProgress: str = "in_progress"
-    Paused: str = "paused"
-    Failed: str = "failed"
-    Cancelled: str = "cancelled"
-    Successful: str = "successful"
-    PartiallySuccessful: str = "partially_successful"
+    NotStarted = "not_started"
+    InProgress = "in_progress"
+    Paused = "paused"
+    Failed = "failed"
+    Cancelled = "cancelled"
+    Successful = "successful"
+    PartiallySuccessful = "partially_successful"
 
 
 class RobotStatus(Enum):
-    Available: str = "available"
-    Busy: str = "busy"
-    Offline: str = "offline"
+    Available = "available"
+    Paused = "paused"
+    Busy = "busy"
+    Home = "home"
+    Offline = "offline"
+    BlockedProtectiveStop = "blockedprotectivestop"