isar 1.22.3__py3-none-any.whl → 1.23.0__py3-none-any.whl

robot_interface/models/mission/task.py

@@ -1,130 +1,197 @@
 from dataclasses import dataclass, field
-from typing import Iterator, List, Optional
+from enum import Enum
+from typing import Iterator, Literal, Optional, Type, Union
+
+from alitra import Pose, Position
 
 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 import (
+    Audio,
+    Image,
+    Inspection,
+    ThermalImage,
+    ThermalVideo,
+    Video,
 )
+from robot_interface.models.mission.status import TaskStatus
 from robot_interface.utilities.uuid_string_factory import uuid4_string
 
 
+class TaskTypes(str, Enum):
+    ReturnToHome = "return_to_home"
+    Localize = "localize"
+    MoveArm = "move_arm"
+    TakeImage = "take_image"
+    TakeThermalImage = "take_thermal_image"
+    TakeVideo = "take_video"
+    TakeThermalVideo = "take_thermal_video"
+    RecordAudio = "record_audio"
+    DockingProcedure = "docking_procedure"
+
+
 @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) -> Optional[Step]:
-        try:
-            step: Step = next(self._iterator)
-            while step.status != StepStatus.NotStarted:
-                step = next(self._iterator)
-            return step
-        except StopIteration:
-            return None
 
     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)
+        if (
+            self.status == TaskStatus.Successful
+            or self.status == TaskStatus.PartiallySuccessful
+            or self.status == TaskStatus.Cancelled
+            or self.status == TaskStatus.Failed
+        ):
+            return True
+        return False
+
+    def update_task_status(self) -> TaskStatus:
+        return self.status
+
+
+@dataclass
+class InspectionTask(Task):
+    """
+    Base class for all inspection tasks which produce results to be uploaded.
+    """
+
+    inspection: Inspection = field(default=None, init=True)
+    robot_pose: Pose = field(default=None, init=True)
+    metadata: Optional[dict] = field(default_factory=dict, init=True)
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Inspection
+
+
+@dataclass
+class DockingProcedure(Task):
+    """
+    Task which causes the robot to dock or undock
+    """
+
+    behavior: Literal["dock", "undock"] = field(default=None, init=True)
+    type: Literal[TaskTypes.DockingProcedure] = TaskTypes.DockingProcedure
+
+
+@dataclass
+class ReturnToHome(Task):
+    """
+    Task which cases the robot to return home
+    """
+
+    pose: Pose = field(default=None, init=True)
+    type: Literal[TaskTypes.ReturnToHome] = TaskTypes.ReturnToHome
+
+
+@dataclass
+class Localize(Task):
+    """
+    Task which causes the robot to localize
+    """
+
+    localization_pose: Pose = field(default=None, init=True)
+    type: Literal[TaskTypes.Localize] = TaskTypes.Localize
+
+
+@dataclass
+class MoveArm(Task):
+    """
+    Task which causes the robot to move its arm
+    """
+
+    arm_pose: str = field(default=None, init=True)
+    type: Literal[TaskTypes.MoveArm] = TaskTypes.MoveArm
+
+
+@dataclass
+class TakeImage(InspectionTask):
+    """
+    Task which causes the robot to take an image towards the given coordinate.
+    """
+
+    target: Position = field(default=None, init=True)
+    type: Literal[TaskTypes.TakeImage] = TaskTypes.TakeImage
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Image
+
+
+@dataclass
+class TakeThermalImage(InspectionTask):
+    """
+    Task which causes the robot to take a thermal image towards the given coordinate.
+    """
+
+    target: Position = field(default=None, init=True)
+    type: Literal[TaskTypes.TakeThermalImage] = TaskTypes.TakeThermalImage
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return ThermalImage
+
+
+@dataclass
+class TakeVideo(InspectionTask):
+    """
+    Task which causes the robot to take a video towards the given coordinate.
+
+    Duration of video is given in seconds.
+    """
+
+    target: Position = field(default=None, init=True)
+    duration: float = field(default=None, init=True)
+    type: Literal[TaskTypes.TakeVideo] = TaskTypes.TakeVideo
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Video
+
+
+@dataclass
+class TakeThermalVideo(InspectionTask):
+    """
+    Task which causes the robot to record thermal video towards the given coordinate
+
+    Duration of video is given in seconds.
+    """
+
+    target: Position = field(default=None, init=True)
+    duration: float = field(default=None, init=True)
+    type: Literal[TaskTypes.TakeThermalVideo] = TaskTypes.TakeThermalVideo
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return ThermalVideo
+
+
+@dataclass
+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, init=True)
+    duration: float = field(default=None, init=True)
+    type: Literal[TaskTypes.RecordAudio] = TaskTypes.RecordAudio
+
+    @staticmethod
+    def get_inspection_type() -> Type[Inspection]:
+        return Audio
+
+
+TASKS = Union[
+    ReturnToHome,
+    Localize,
+    MoveArm,
+    TakeImage,
+    TakeThermalImage,
+    TakeVideo,
+    TakeThermalVideo,
+    RecordAudio,
+    DockingProcedure,
+]

robot_interface/robot_interface.py

@@ -1,13 +1,13 @@
 from abc import ABCMeta, abstractmethod
 from queue import Queue
 from threading import Thread
-from typing import List, Sequence
+from typing import List
 
 from robot_interface.models.initialize import InitializeParams
 from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import MissionStatus, RobotStatus, StepStatus
-from robot_interface.models.mission.step import InspectionStep, Step
+from robot_interface.models.mission.status import RobotStatus, TaskStatus
+from robot_interface.models.mission.task import InspectionTask, Task
 
 
 class RobotInterface(metaclass=ABCMeta):
@@ -18,7 +18,7 @@ class RobotInterface(metaclass=ABCMeta):
         """Send a mission to the robot and initiate execution of the mission
 
         This function should be used in combination with the mission_status function
-        if the robot is designed to run full missions and not in a stepwise
+        if the robot is designed to run full missions and not in a taskwise
         configuration.
 
         Parameters
@@ -38,48 +38,23 @@ class RobotInterface(metaclass=ABCMeta):
             Will catch all RobotExceptions not previously listed and retry scheduling of
             the mission until the number of allowed retries is exceeded
         NotImplementedError
-            If the robot is designed for stepwise mission execution
+            If the robot is designed for taskwise mission execution
 
         """
         raise NotImplementedError
 
-    def mission_status(self) -> MissionStatus:
-        """Gets the status of the currently active mission on the robot
-
-        This function should be used in combination with the initiate_mission function
-        if the robot is designed to run full missions and not in a stepwise
-        configuration.
-
-        Returns
-        -------
-        MissionStatus
-            Status of the executing mission on the robot.
-
-        Raises
-        ------
-        RobotMissionStatusException
-            If the mission status could not be collected this will lead to the mission
-            being marked as failed
-        RobotException
-            An uncaught RobotException in the robot package while retrieving the status
-            will cause the mission to be marked as failed
-        NotImplementedError
-            If the robot is designed for stepwise mission execution
-
-        """
-
     @abstractmethod
-    def initiate_step(self, step: Step) -> None:
-        """Send a step to the robot and initiate the execution of the step
+    def initiate_task(self, task: Task) -> None:
+        """Send a task to the robot and initiate the execution of the task
 
-        This function should be used in combination with the step_status function
-        if the robot is designed to run stepwise missions and not in a full mission
+        This function should be used in combination with the task_status function
+        if the robot is designed to run taskwise missions and not in a full mission
         configuration.
 
         Parameters
         ----------
-        step : Step
-            The step that should be initiated on the robot.
+        task : Task
+            The task that should be initiated on the robot.
 
         Returns
         -------
@@ -87,12 +62,12 @@ class RobotInterface(metaclass=ABCMeta):
 
         Raises
         ------
-        RobotInfeasibleStepException
-            If the step input is infeasible and the step fails to be scheduled in
+        RobotInfeasibleTaskException
+            If the task input is infeasible and the task fails to be scheduled in
             a way that means attempting to schedule again is not necessary
         RobotException
             Will catch all RobotExceptions not previously listed and retry scheduling
-            of the step until the number of allowed retries is exceeded before the step
+            of the task until the number of allowed retries is exceeded before the task
             will be marked as failed and the mission cancelled
         NotImplementedError
             If the robot is designed for full mission execution.
@@ -101,22 +76,22 @@ class RobotInterface(metaclass=ABCMeta):
         raise NotImplementedError
 
     @abstractmethod
-    def step_status(self) -> StepStatus:
-        """Gets the status of the currently active step on robot.
+    def task_status(self, task_id: str) -> TaskStatus:
+        """Gets the status of the currently active task on robot.
 
-        This function should be used in combination with the initiate_step function
-        if the robot is designed to run stepwise missions and not in a full mission
+        This function should be used in combination with the initiate_task function
+        if the robot is designed to run taskwise missions and not in a full mission
         configuration.
 
         Returns
         -------
-        StepStatus
-            Status of the execution of current step.
+        TaskStatus
+            Status of the execution of current task.
 
         Raises
         ------
         RobotException
-            If the step status could not be retrieved.
+            If the task status could not be retrieved.
         NotImplementedError
             If the robot is designed for full mission execution.
 
@@ -125,7 +100,7 @@ class RobotInterface(metaclass=ABCMeta):
 
     @abstractmethod
     def stop(self) -> None:
-        """Stops the execution of the current step and stops the movement of the robot.
+        """Stops the execution of the current task and stops the movement of the robot.
 
         Returns
         -------
@@ -144,7 +119,7 @@ class RobotInterface(metaclass=ABCMeta):
 
     @abstractmethod
     def pause(self) -> None:
-        """Pauses the execution of the current step and stops the movement of the robot.
+        """Pauses the execution of the current task and stops the movement of the robot.
 
         Returns
         -------
@@ -163,7 +138,7 @@ class RobotInterface(metaclass=ABCMeta):
 
     @abstractmethod
     def resume(self) -> None:
-        """Resumes the execution of the current step and continues the rest of the mission.
+        """Resumes the execution of the current task and continues the rest of the mission.
 
         Returns
         -------
@@ -181,23 +156,23 @@ class RobotInterface(metaclass=ABCMeta):
         raise NotImplementedError
 
     @abstractmethod
-    def get_inspections(self, step: InspectionStep) -> Sequence[Inspection]:
-        """Return the inspections connected to the given step.
+    def get_inspection(self, task: InspectionTask) -> Inspection:
+        """Return the inspection connected to the given task.
 
         Parameters
         ----------
-        step : Step
+        task : InspectionTask
 
         Returns
         -------
         Sequence[InspectionResult]
-            List containing all the inspection results connected to the given step
+            List containing all the inspection results connected to the given task
 
         Raises
         ------
         RobotRetrieveInspectionException
             If the robot package is unable to retrieve the inspections for the relevant
-            mission or step an error message is logged and the state machine continues
+            mission or task an error message is logged and the state machine continues
         RobotException
             Catches other RobotExceptions that lead to the same result as a
             RobotRetrieveInspectionException