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

isar/apis/models/start_mission_definition.py

@@ -1,167 +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
 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,
-    DriveToPose,
+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 = "inspection"
+    ReturnToHome = "return_to_home"
 
 
 class StartMissionInspectionDefinition(BaseModel):
     type: InspectionTypes = Field(default=InspectionTypes.image)
     inspection_target: InputPosition
-    analysis_types: Optional[str]
-    duration: Optional[float]
-    metadata: Optional[dict]
-    id: Optional[str]
+    inspection_description: Optional[str] = None
+    duration: Optional[float] = None
 
 
 class StartMissionTaskDefinition(BaseModel):
+    id: Optional[str] = None
+    type: TaskType = Field(default=TaskType.Inspection)
     pose: InputPose
-    inspections: List[StartMissionInspectionDefinition]
-    tag: Optional[str]
-    id: Optional[str]
+    inspection: Optional[StartMissionInspectionDefinition] = None
+    tag: Optional[str] = None
+    zoom: Optional[ZoomDescription] = None
 
 
 class StartMissionDefinition(BaseModel):
+    id: Optional[str] = None
     tasks: List[StartMissionTaskDefinition]
-    id: Optional[str]
-    name: Optional[str]
-
-
-def to_isar_mission(mission_definition: StartMissionDefinition) -> Mission:
-    isar_tasks: List[Task] = []
-    all_inspection_steps: List[STEPS] = []
-    duplicate_ids: List[str] = []
-
-    for task in mission_definition.tasks:
-        try:
-            tag_id: Optional[str] = task.tag
-            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=tag_id,
-                    analysis=inspection.analysis_types,
-                    metadata=inspection.metadata,
-                    id=inspection.id,
-                )
-                for inspection in task.inspections
-            ]
-        except ValueError as e:
-            raise MissionPlannerError(f"Failed to create task: {str(e)}")
-
-        duplicate_ids = get_duplicate_ids(items=inspection_steps)
-        if len(duplicate_ids) > 0:
-            raise MissionPlannerError(
-                f"Failed to create task: Duplicate step IDs are not allowed ({duplicate_ids})"
-            )
-        all_inspection_steps.extend(inspection_steps)
-
-        isar_task: Task = Task(steps=[drive_step, *inspection_steps], tag_id=tag_id)
-        if task.id:
-            isar_task.id = task.id
-        isar_tasks.append(isar_task)
+    name: Optional[str] = None
+    start_pose: Optional[InputPose] = None
+
+
+class StopMissionDefinition(BaseModel):
+    mission_id: Optional[str] = None
+
+
+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")
 
-    duplicate_ids = get_duplicate_ids(items=isar_tasks)
-    if len(duplicate_ids) > 0:
-        raise MissionPlannerError(
-            f"Failed to create mission: Duplicate task IDs are not allowed ({duplicate_ids})"
-        )
+    isar_mission_name: str = (
+        start_mission_definition.name
+        if start_mission_definition.name
+        else _build_mission_name()
+    )
+
+    start_pose = None
+    if start_mission_definition.start_pose:
+        start_pose = start_mission_definition.start_pose.to_alitra_pose()
+
+    id = start_mission_definition.id if start_mission_definition.id else uuid4_string()
+
+    return Mission(
+        id=id,
+        tasks=isar_tasks,
+        name=isar_mission_name,
+        start_pose=start_pose,
+    )
 
-    duplicate_ids = get_duplicate_ids(items=all_inspection_steps)
-    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 task: Duplicate step IDs are not allowed ({duplicate_ids})"
+            f"Failed to create task: '{task_definition.type}' is not a valid"
         )
 
-    isar_mission: Mission = Mission(tasks=isar_tasks)
 
-    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
-
-    return isar_mission
-
-
-def create_inspection_step(
-    inspection_type: InspectionTypes,
-    duration: float,
-    target: Position,
-    analysis: Optional[str],
-    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")
+def to_inspection_task(task_definition: StartMissionTaskDefinition) -> TASKS:
+    inspection_definition = task_definition.inspection
+
+    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 analysis:
-        inspection_step.analysis = analysis
-    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,
+        )