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

isar/apis/models/start_mission_definition.py

@@ -1,230 +1,172 @@
 import time
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import List, Optional
 
-from alitra import Position, Pose, Orientation, Frame
 from pydantic import BaseModel, Field
 
 from isar.apis.models.models import InputPose, InputPosition
 from isar.config.settings import settings
 from isar.mission_planner.mission_planner_interface import MissionPlannerError
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.step import (
-    STEPS,
-    DockingProcedure,
-    DriveToPose,
-    Localize,
+from robot_interface.models.mission.task import (
+    TASKS,
     RecordAudio,
     ReturnToHome,
+    TakeCO2Measurement,
     TakeImage,
     TakeThermalImage,
     TakeThermalVideo,
     TakeVideo,
+    ZoomDescription,
 )
-from robot_interface.models.mission.task import Task
+from robot_interface.utilities.uuid_string_factory import uuid4_string
 
 
 class InspectionTypes(str, Enum):
-    image: str = "Image"
-    thermal_image: str = "ThermalImage"
-    video: str = "Video"
-    thermal_video: str = "ThermalVideo"
-    audio: str = "Audio"
+    image = "Image"
+    thermal_image = "ThermalImage"
+    video = "Video"
+    thermal_video = "ThermalVideo"
+    audio = "Audio"
+    co2_measurement = "CO2Measurement"
 
 
 class TaskType(str, Enum):
-    Inspection: str = "inspection"
-    DriveTo: str = "drive_to"
-    Localization: str = "localization"
-    ReturnToHome: str = "return_to_home"
-    Dock: str = "dock"
+    Inspection = "inspection"
+    ReturnToHome = "return_to_home"
 
 
 class StartMissionInspectionDefinition(BaseModel):
     type: InspectionTypes = Field(default=InspectionTypes.image)
     inspection_target: InputPosition
-    analysis_type: Optional[str] = None
+    inspection_description: Optional[str] = None
     duration: Optional[float] = None
-    metadata: Optional[dict] = None
-    id: Optional[str] = None
 
 
 class StartMissionTaskDefinition(BaseModel):
+    id: Optional[str] = None
     type: TaskType = Field(default=TaskType.Inspection)
     pose: InputPose
-    inspections: List[StartMissionInspectionDefinition]
+    inspection: Optional[StartMissionInspectionDefinition] = None
     tag: Optional[str] = None
-    id: Optional[str] = None
+    zoom: Optional[ZoomDescription] = None
 
 
 class StartMissionDefinition(BaseModel):
-    tasks: List[StartMissionTaskDefinition]
     id: Optional[str] = None
+    tasks: List[StartMissionTaskDefinition]
     name: Optional[str] = None
     start_pose: Optional[InputPose] = None
 
 
-def to_isar_mission(mission_definition: StartMissionDefinition) -> Mission:
-    isar_tasks: List[Task] = []
-    all_steps_in_mission: List[STEPS] = []
+class StopMissionDefinition(BaseModel):
+    mission_id: Optional[str] = None
 
-    for task in mission_definition.tasks:
-        steps: List[STEPS] = generate_steps(task)
-        all_steps_in_mission.extend(steps)
 
-        isar_task: Task = Task(steps=steps, tag_id=task.tag)
-        if task.id:
-            isar_task.id = task.id
-        isar_tasks.append(isar_task)
+def to_isar_mission(
+    start_mission_definition: StartMissionDefinition,
+) -> Mission:
+    isar_tasks: List[TASKS] = []
+
+    for task_definition in start_mission_definition.tasks:
+        task: TASKS = to_isar_task(task_definition)
+        isar_tasks.append(task)
 
     if not isar_tasks:
         raise MissionPlannerError("Mission does not contain any valid tasks")
 
-    check_for_duplicate_ids(isar_tasks)
-    check_for_duplicate_ids(all_steps_in_mission)
+    isar_mission_name: str = (
+        start_mission_definition.name
+        if start_mission_definition.name
+        else _build_mission_name()
+    )
 
-    isar_mission: Mission = Mission(tasks=isar_tasks)
+    start_pose = None
+    if start_mission_definition.start_pose:
+        start_pose = start_mission_definition.start_pose.to_alitra_pose()
 
-    if mission_definition.name:
-        isar_mission.name = mission_definition.name
-    else:
-        isar_mission.name = _build_mission_name()
-
-    if mission_definition.id:
-        isar_mission.id = mission_definition.id
-
-    if mission_definition.start_pose:
-        input_pose: InputPose = mission_definition.start_pose
-        input_frame: Frame = Frame(name=input_pose.frame_name)
-        input_position: Position = Position(
-            input_pose.position.x,
-            input_pose.position.y,
-            input_pose.position.z,
-            input_frame,
-        )
-        input_orientation: Orientation = Orientation(
-            input_pose.orientation.x,
-            input_pose.orientation.y,
-            input_pose.orientation.z,
-            input_pose.orientation.w,
-            input_frame,
-        )
-        isar_mission.start_pose = Pose(
-            position=input_position, orientation=input_orientation, frame=input_frame
-        )
+    id = start_mission_definition.id if start_mission_definition.id else uuid4_string()
 
-    return isar_mission
+    return Mission(
+        id=id,
+        tasks=isar_tasks,
+        name=isar_mission_name,
+        start_pose=start_pose,
+    )
 
 
-def check_for_duplicate_ids(items: Union[List[Task], List[STEPS]]):
-    duplicate_ids = get_duplicate_ids(items=items)
-    if len(duplicate_ids) > 0:
+def to_isar_task(task_definition: StartMissionTaskDefinition) -> TASKS:
+    if task_definition.type == TaskType.Inspection:
+        return to_inspection_task(task_definition)
+    elif task_definition.type == TaskType.ReturnToHome:
+        return ReturnToHome()
+    else:
         raise MissionPlannerError(
-            f"Failed to create as there were duplicate IDs which is not allowed "
-            f"({duplicate_ids})"
-        )
-
-
-def generate_steps(task) -> List[STEPS]:
-    steps: List[STEPS] = []
-    try:
-        match task.type:
-            case TaskType.Inspection:
-                steps.extend(generate_steps_for_inspection_task(task=task))
-            case TaskType.DriveTo:
-                steps.append(generate_steps_for_drive_to_task(task=task))
-            case TaskType.Localization:
-                steps.append(generate_steps_for_localization_task(task=task))
-            case TaskType.ReturnToHome:
-                steps.append(generate_steps_for_return_to_home_task(task=task))
-            case TaskType.Dock:
-                steps.append(generate_steps_for_dock_task())
-    except ValueError as e:
-        raise MissionPlannerError(f"Failed to create task: {str(e)}")
-
-    return steps
-
-
-def generate_steps_for_inspection_task(task: StartMissionTaskDefinition) -> List[STEPS]:
-    drive_step: DriveToPose = DriveToPose(pose=task.pose.to_alitra_pose())
-
-    inspection_steps: List[STEPS] = [
-        create_inspection_step(
-            inspection_type=inspection.type,
-            duration=inspection.duration,
-            target=inspection.inspection_target.to_alitra_position(),
-            tag_id=task.tag,
-            metadata=inspection.metadata,
-            id=inspection.id,
+            f"Failed to create task: '{task_definition.type}' is not a valid"
         )
-        for inspection in task.inspections
-    ]
-
-    return [drive_step, *inspection_steps]
-
-
-def generate_steps_for_drive_to_task(task: StartMissionTaskDefinition) -> DriveToPose:
-    return DriveToPose(pose=task.pose.to_alitra_pose())
-
 
-def generate_steps_for_localization_task(task: StartMissionTaskDefinition) -> Localize:
-    return Localize(localization_pose=task.pose.to_alitra_pose())
 
+def to_inspection_task(task_definition: StartMissionTaskDefinition) -> TASKS:
+    inspection_definition = task_definition.inspection
 
-def generate_steps_for_return_to_home_task(
-    task: StartMissionTaskDefinition,
-) -> ReturnToHome:
-    return ReturnToHome(pose=task.pose.to_alitra_pose())
-
-
-def generate_steps_for_dock_task() -> DockingProcedure:
-    return DockingProcedure(behavior="dock")
-
-
-def create_inspection_step(
-    inspection_type: InspectionTypes,
-    duration: float,
-    target: Position,
-    tag_id: Optional[str],
-    metadata: Optional[dict],
-    id: Optional[str],
-) -> STEPS:
-    inspection_step_dict: Dict[str, Any] = {
-        InspectionTypes.image.value: TakeImage(target=target),
-        InspectionTypes.video.value: TakeVideo(target=target, duration=duration),
-        InspectionTypes.thermal_image.value: TakeThermalImage(target=target),
-        InspectionTypes.thermal_video.value: TakeThermalVideo(
-            target=target, duration=duration
-        ),
-        InspectionTypes.audio.value: RecordAudio(target=target, duration=duration),
-    }
-
-    if inspection_type not in inspection_step_dict:
-        raise ValueError(f"Inspection type '{inspection_type}' not supported")
+    if inspection_definition.type == InspectionTypes.image:
+        return TakeImage(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            inspection_description=task_definition.inspection.inspection_description,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            zoom=task_definition.zoom,
+        )
+    elif inspection_definition.type == InspectionTypes.video:
+        return TakeVideo(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            inspection_description=task_definition.inspection.inspection_description,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=inspection_definition.duration,
+            zoom=task_definition.zoom,
+        )
+    elif inspection_definition.type == InspectionTypes.thermal_image:
+        return TakeThermalImage(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            inspection_description=task_definition.inspection.inspection_description,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            zoom=task_definition.zoom,
+        )
+    elif inspection_definition.type == InspectionTypes.thermal_video:
+        return TakeThermalVideo(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            inspection_description=task_definition.inspection.inspection_description,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=inspection_definition.duration,
+            zoom=task_definition.zoom,
+        )
+    elif inspection_definition.type == InspectionTypes.audio:
+        return RecordAudio(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            inspection_description=task_definition.inspection.inspection_description,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=inspection_definition.duration,
+        )
+    elif inspection_definition.type == InspectionTypes.co2_measurement:
+        return TakeCO2Measurement(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            inspection_description=task_definition.inspection.inspection_description,
+        )
     else:
-        inspection_step = inspection_step_dict[inspection_type]
-
-    if tag_id:
-        inspection_step.tag_id = tag_id
-    if metadata:
-        inspection_step.metadata = metadata
-    if id:
-        inspection_step.id = id
-
-    return inspection_step
-
-
-def get_duplicate_ids(items: Union[List[Task], List[STEPS]]) -> List[str]:
-    unique_ids: List[str] = []
-    duplicate_ids: List[str] = []
-    for item in items:
-        id: str = item.id
-        if id not in unique_ids:
-            unique_ids.append(id)
-        else:
-            duplicate_ids.append(id)
-
-    return duplicate_ids
+        raise ValueError(
+            f"Inspection type '{inspection_definition.type}' not supported"
+        )
 
 
 def _build_mission_name() -> str:

isar/apis/robot_control/robot_controller.py

@@ -0,0 +1,41 @@
+import logging
+
+from fastapi import HTTPException
+from opentelemetry import trace
+
+from isar.apis.models.models import RobotInfoResponse
+from isar.config.settings import robot_settings, settings
+from isar.services.utilities.robot_utilities import RobotUtilities
+from robot_interface.models.robots.media import MediaConfig
+
+tracer = trace.get_tracer(__name__)
+
+
+class RobotController:
+    def __init__(
+        self,
+        robot_utilities: RobotUtilities,
+    ):
+        self.robot_utilities: RobotUtilities = robot_utilities
+        self.logger = logging.getLogger("api")
+
+    @tracer.start_as_current_span("generate_media_config")
+    def generate_media_config(self) -> MediaConfig:
+        media_config: MediaConfig = self.robot_utilities.generate_media_config()
+        if media_config is None:
+            raise HTTPException(
+                status_code=204,
+                detail="Robot has no media config",
+            )
+        return media_config
+
+    @tracer.start_as_current_span("get_info")
+    def get_info(self) -> RobotInfoResponse:
+        return RobotInfoResponse(
+            robot_package=settings.ROBOT_PACKAGE,
+            isar_id=settings.ISAR_ID,
+            robot_name=settings.ROBOT_NAME,
+            robot_capabilities=robot_settings.CAPABILITIES,
+            robot_map_name=settings.DEFAULT_MAP,
+            plant_short_name=settings.PLANT_SHORT_NAME,
+        )