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

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 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_type: 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,26 +1,25 @@
-from dataclasses import dataclass, field
 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 = ""
-    start_pose: Optional[Pose] = None
+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, init=False)
+    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,35 +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"
-    Blocked: str = "blocked"
+    Available = "available"
+    Paused = "paused"
+    Busy = "busy"
+    Home = "home"
+    Offline = "offline"
+    BlockedProtectiveStop = "blockedprotectivestop"

robot_interface/models/mission/task.py

@@ -1,127 +1,160 @@
-from dataclasses import dataclass, field
-from typing import Iterator, List, Optional
+from enum import Enum
+from typing import Literal, Optional, Type, Union
+
+from alitra import Pose, Position
+from pydantic import BaseModel, Field
 
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
-from robot_interface.models.mission.status import StepStatus, TaskStatus
-from robot_interface.models.mission.step import (
-    STEPS,
-    DriveToPose,
-    InspectionStep,
-    MotionStep,
-    Step,
+from robot_interface.models.inspection.inspection import (
+    Audio,
+    CO2Measurement,
+    Image,
+    Inspection,
+    ThermalImage,
+    ThermalVideo,
+    Video,
 )
+from robot_interface.models.mission.status import TaskStatus
 from robot_interface.utilities.uuid_string_factory import uuid4_string
 
 
-@dataclass
-class Task:
-    steps: List[STEPS]
-    status: TaskStatus = field(default=TaskStatus.NotStarted, init=False)
-    error_message: Optional[ErrorMessage] = field(default=None, init=False)
-    tag_id: Optional[str] = field(default=None)
-    id: str = field(default_factory=uuid4_string, init=True)
-    _iterator: Iterator = None
-
-    def next_step(self) -> Step:
-        step: Step = next(self._iterator)
-        while step.status != StepStatus.NotStarted:
-            step = next(self._iterator)
-        return step
-
-    def is_finished(self) -> bool:
-        for step in self.steps:
-            if step.status is StepStatus.Failed and isinstance(step, MotionStep):
-                # One motion step has failed meaning the task as a whole should be
-                # considered as failed
-                return True
-
-            elif (step.status is StepStatus.Failed) and isinstance(
-                step, InspectionStep
-            ):
-                # It should be possible to perform several inspections per task. If
-                # one out of many inspections fail the task is considered as
-                # partially successful.
-                continue
-
-            elif step.status is StepStatus.Successful:
-                # The task is complete once all steps are completed
-                continue
-            else:
-                # Not all steps have been completed yet
-                return False
-
-        return True
-
-    def update_task_status(self) -> None:
-        some_not_started: bool = False
-        for step in self.steps:
-            if step.status is StepStatus.Failed and isinstance(step, MotionStep):
-                self.error_message = ErrorMessage(
-                    error_reason=None,
-                    error_description=f"Inspection "
-                    f"{'of ' + self.tag_id if self.tag_id else ''}failed because the "
-                    f"robot could not navigate to the desired location",
-                )
-                self.status = TaskStatus.Failed
-                return
-
-            elif (step.status is StepStatus.Failed) and isinstance(
-                step, InspectionStep
-            ):
-                self.error_message = ErrorMessage(
-                    error_reason=None,
-                    error_description=f"Inspection "
-                    f"{'of ' + self.tag_id if self.tag_id else ''}was partially "
-                    f"successful because one or more inspection steps failed",
-                )
-                self.status = TaskStatus.PartiallySuccessful
-                continue
-
-            elif step.status is StepStatus.Successful:
-                continue
-
-            elif (step.status is StepStatus.NotStarted) and isinstance(
-                step, InspectionStep
-            ):
-                some_not_started = True
-
-        if self.status is not TaskStatus.PartiallySuccessful:
-            if some_not_started:
-                self.status = TaskStatus.InProgress  # TODO: handle all not_started
-            else:
-                self.status = TaskStatus.Successful
-
-        elif self._all_inspection_steps_failed():
-            self.error_message = ErrorMessage(
-                error_reason=None,
-                error_description=f"Inspection "
-                f"{'of ' + self.tag_id if self.tag_id else ''}failed as all inspection "
-                f"steps failed",
-            )
-            self.status = TaskStatus.Failed
-
-    def reset_task(self):
-        self.error_message = None
-        for step in self.steps:
-            step.error_message = None
-            if isinstance(step, DriveToPose):
-                step.status = StepStatus.NotStarted
-            elif (
-                isinstance(step, InspectionStep)
-                and step.status == StepStatus.InProgress
-            ):
-                step.status = StepStatus.NotStarted
-        self._iterator = iter(self.steps)
-
-    def _all_inspection_steps_failed(self) -> bool:
-        for step in self.steps:
-            if isinstance(step, MotionStep):
-                continue
-            elif step.status is not StepStatus.Failed:
-                return False
-
-        return True
-
-    def __post_init__(self) -> None:
-        if self._iterator is None:
-            self._iterator = iter(self.steps)
+class TaskTypes(str, Enum):
+    ReturnToHome = "return_to_home"
+    TakeImage = "take_image"
+    TakeThermalImage = "take_thermal_image"
+    TakeVideo = "take_video"
+    TakeThermalVideo = "take_thermal_video"
+    TakeCO2Measurement = "take_co2_measurement"
+    RecordAudio = "record_audio"
+
+
+class ZoomDescription(BaseModel):
+    objectWidth: float
+    objectHeight: float
+
+
+class Task(BaseModel):
+    status: TaskStatus = Field(default=TaskStatus.NotStarted)
+    error_message: Optional[ErrorMessage] = Field(default=None)
+    tag_id: Optional[str] = Field(default=None)
+    id: str = Field(default_factory=uuid4_string, frozen=True)
+
+
+class InspectionTask(Task):
+    """
+    Base class for all inspection tasks which produce results to be uploaded.
+    """
+
+    inspection_id: str = Field(default_factory=uuid4_string, frozen=True)
+    robot_pose: Pose = Field(default=None, init=True)
+    inspection_description: Optional[str] = Field(default=None)
+    zoom: Optional[ZoomDescription] = Field(default=None)
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Inspection
+
+
+class ReturnToHome(Task):
+    """
+    Task which cases the robot to return home
+    """
+
+    type: Literal[TaskTypes.ReturnToHome] = TaskTypes.ReturnToHome
+
+
+class TakeImage(InspectionTask):
+    """
+    Task which causes the robot to take an image towards the given target.
+    """
+
+    target: Position = Field(default=None)
+    type: Literal[TaskTypes.TakeImage] = TaskTypes.TakeImage
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Image
+
+
+class TakeThermalImage(InspectionTask):
+    """
+    Task which causes the robot to take a thermal image towards the given target.
+    """
+
+    target: Position = Field(default=None)
+    type: Literal[TaskTypes.TakeThermalImage] = TaskTypes.TakeThermalImage
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return ThermalImage
+
+
+class TakeVideo(InspectionTask):
+    """
+    Task which causes the robot to take a video towards the given target.
+
+    Duration of video is given in seconds.
+    """
+
+    target: Position = Field(default=None)
+    duration: float = Field(default=None)
+    type: Literal[TaskTypes.TakeVideo] = TaskTypes.TakeVideo
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Video
+
+
+class TakeThermalVideo(InspectionTask):
+    """
+    Task which causes the robot to record thermal video towards the given target
+
+    Duration of video is given in seconds.
+    """
+
+    target: Position = Field(default=None)
+    duration: float = Field(default=None)
+    type: Literal[TaskTypes.TakeThermalVideo] = TaskTypes.TakeThermalVideo
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return ThermalVideo
+
+
+class RecordAudio(InspectionTask):
+    """
+    Task which causes the robot to record a video at its position, facing the target.
+
+    Duration of audio is given in seconds.
+    """
+
+    target: Position = Field(default=None)
+    duration: float = Field(default=None)
+    type: Literal[TaskTypes.RecordAudio] = TaskTypes.RecordAudio
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Audio
+
+
+class TakeCO2Measurement(InspectionTask):
+    """
+    Task which causes the robot to take a CO2 measurement at its position.
+    """
+
+    type: Literal[TaskTypes.TakeCO2Measurement] = TaskTypes.TakeCO2Measurement
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return CO2Measurement
+
+
+TASKS = Union[
+    ReturnToHome,
+    TakeImage,
+    TakeThermalImage,
+    TakeVideo,
+    TakeThermalVideo,
+    TakeCO2Measurement,
+    RecordAudio,
+]

robot_interface/models/robots/battery_state.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class BatteryState(Enum):
+    Normal = "Normal"
+    Charging = "Charging"

robot_interface/models/robots/media.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class MediaConnectionType(str, Enum):
+    LiveKit = "LiveKit"
+
+
+@dataclass
+class MediaConfig:
+    url: str
+    token: str
+    media_connection_type: MediaConnectionType

robot_interface/models/robots/robot_model.py

@@ -4,10 +4,10 @@ from enum import Enum
 # Did you write your own isar-robot package and would like to have it included here?
 # Open a pull request to the ISAR repository!
 class RobotModel(Enum):
-    TaurobInspector: str = "TaurobInspector"
-    TaurobOperator: str = "TaurobOperator"
-    ExR2: str = "ExR2"
-    Robot: str = "Robot"  # This corresponds to the mock in isar_robot
-    Turtlebot: str = "Turtlebot"
-    AnymalX: str = "AnymalX"
-    AnymalD: str = "AnymalD"
+    TaurobInspector = "TaurobInspector"
+    TaurobOperator = "TaurobOperator"
+    ExR2 = "ExR2"
+    Robot = "Robot"  # This corresponds to the mock in isar_robot
+    Turtlebot = "Turtlebot"
+    AnymalX = "AnymalX"
+    AnymalD = "AnymalD"