isar 1.26.0__py3-none-any.whl → 1.26.2__py3-none-any.whl

isar/apis/models/start_mission_definition.py

@@ -61,7 +61,6 @@ class StartMissionDefinition(BaseModel):
 
 def to_isar_mission(
     start_mission_definition: StartMissionDefinition,
-    return_pose: Optional[InputPose] = None,
 ) -> Mission:
     isar_tasks: List[TASKS] = []
 
@@ -69,9 +68,6 @@ def to_isar_mission(
         task: TASKS = to_isar_task(task_definition)
         isar_tasks.append(task)
 
-    if return_pose:
-        isar_tasks.append(ReturnToHome(pose=return_pose.to_alitra_pose()))
-
     if not isar_tasks:
         raise MissionPlannerError("Mission does not contain any valid tasks")
 

isar/apis/schedule/scheduling_controller.py

@@ -1,14 +1,11 @@
 import logging
 from http import HTTPStatus
-from typing import Optional
 
-from alitra import Pose
 from fastapi import Body, HTTPException, Path
 from injector import inject
 
 from isar.apis.models.models import (
     ControlMissionResponse,
-    InputPose,
     StartMissionResponse,
     TaskResponse,
 )
@@ -21,12 +18,7 @@ from isar.mission_planner.mission_planner_interface import MissionPlannerError
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.task import (
-    TASKS,
-    InspectionTask,
-    MoveArm,
-    ReturnToHome,
-)
+from robot_interface.models.mission.task import TASKS, InspectionTask, MoveArm
 
 
 class SchedulingController:
@@ -45,28 +37,19 @@ class SchedulingController:
             title="Mission ID",
             description="ID-number for predefined mission",
         ),
-        return_pose: Optional[InputPose] = Body(
-            default=None,
-            description="End pose of the mission. The robot return to the specified "
-            "pose after finishing all inspections",
-            embed=True,
-        ),
     ) -> StartMissionResponse:
-        self.logger.info(f"Received request to start mission with id {mission_id}")
+        self.logger.info("Received request to start mission with id %s", mission_id)
 
         state: States = self.scheduling_utilities.get_state()
         self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         mission: Mission = self.scheduling_utilities.get_mission(mission_id)
-        if return_pose:
-            pose: Pose = return_pose.to_alitra_pose()
-            mission.tasks.append(ReturnToHome(pose=pose))
 
         self.scheduling_utilities.verify_robot_capable_of_mission(
             mission=mission, robot_capabilities=robot_settings.CAPABILITIES
         )
 
-        self.logger.info(f"Starting mission with ISAR Mission ID: '{mission.id}'")
+        self.logger.info("Starting mission with ISAR Mission ID: '%s'", mission.id)
 
         self.scheduling_utilities.start_mission(mission=mission)
 
@@ -80,12 +63,6 @@ class SchedulingController:
             title="Mission Definition",
             description="Description of the mission in json format",
         ),
-        return_pose: Optional[InputPose] = Body(
-            default=None,
-            description="End pose of the mission. The robot return to the specified "
-            "pose after finishing all inspections",
-            embed=True,
-        ),
     ) -> StartMissionResponse:
         self.logger.info("Received request to start new mission")
 
@@ -103,7 +80,7 @@ class SchedulingController:
 
         try:
             mission: Mission = to_isar_mission(
-                start_mission_definition=mission_definition, return_pose=return_pose
+                start_mission_definition=mission_definition
             )
         except MissionPlannerError as e:
             error_message = f"Bad Request - Cannot create ISAR mission: {e}"
@@ -117,7 +94,7 @@ class SchedulingController:
             mission=mission, robot_capabilities=robot_settings.CAPABILITIES
         )
 
-        self.logger.info(f"Starting mission: {mission.id}")
+        self.logger.info("Starting mission: %s", mission.id)
         self.scheduling_utilities.start_mission(mission=mission)
         return self._api_response(mission)
 

isar/apis/security/authentication.py

@@ -48,7 +48,7 @@ class Authenticator:
         self.logger = logging.getLogger("api")
         self.authentication_enabled: bool = authentication_enabled
         enabled_string = "enabled" if self.authentication_enabled else "disabled"
-        self.logger.info(f"API authentication is {enabled_string}")
+        self.logger.info("API authentication is %s", enabled_string)
 
     def should_authenticate(self) -> bool:
         return self.authentication_enabled

isar/config/settings.py

@@ -51,7 +51,7 @@ class Settings(BaseSettings):
     # Determines the number of state transitions that are kept in the log
     STATE_TRANSITIONS_LOG_LENGTH: int = Field(default=20)
 
-    # Number of attempts to initiate a task or mission before cancelling
+    # Number of attempts to initiate a mission before cancelling
     INITIATE_FAILURE_COUNTER_LIMIT: int = Field(default=10)
 
     # Number of attempts to request a task status in monitor before cancelling

isar/models/communication/queues/events.py

@@ -0,0 +1,57 @@
+from queue import Queue
+
+from transitions import State
+
+from isar.config.settings import settings
+from isar.models.communication.queues.queue_io import QueueIO
+from isar.models.communication.queues.status_queue import StatusQueue
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import RobotStatus, TaskStatus
+from robot_interface.models.mission.task import TASKS
+
+
+class Events:
+    def __init__(self) -> None:
+        self.api_requests: APIRequests = APIRequests()
+        self.state_machine_events: StateMachineEvents = StateMachineEvents()
+        self.robot_service_events: RobotServiceEvents = RobotServiceEvents()
+
+        self.upload_queue: Queue = Queue(maxsize=10)
+
+        if settings.MQTT_ENABLED:
+            self.mqtt_queue: Queue = Queue()
+
+
+class APIRequests:
+    def __init__(self) -> None:
+        self.start_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.stop_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.pause_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.resume_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+
+
+class StateMachineEvents:
+    def __init__(self) -> None:
+        self.start_mission: Queue[Mission] = Queue(maxsize=1)
+        self.stop_mission: Queue[bool] = Queue(maxsize=1)
+        self.pause_mission: Queue[bool] = Queue(maxsize=1)
+        self.task_status_request: Queue[str] = Queue(maxsize=1)
+
+
+class RobotServiceEvents:
+    def __init__(self) -> None:
+        self.task_status_updated: Queue[TaskStatus] = Queue(maxsize=1)
+        self.task_status_failed: Queue[ErrorMessage] = Queue(maxsize=1)
+        self.mission_started: Queue[bool] = Queue(maxsize=1)
+        self.mission_failed: Queue[ErrorMessage] = Queue(maxsize=1)
+        self.robot_status_changed: Queue[bool] = Queue(maxsize=1)
+        self.mission_failed_to_stop: Queue[ErrorMessage] = Queue(maxsize=1)
+        self.mission_successfully_stopped: Queue[bool] = Queue(maxsize=1)
+
+
+class SharedState:
+    def __init__(self) -> None:
+        self.state: StatusQueue[State] = StatusQueue()
+        self.robot_status: StatusQueue[RobotStatus] = StatusQueue()
+        self.state_machine_current_task: StatusQueue[TASKS] = StatusQueue()

isar/models/communication/queues/queue_utils.py

@@ -1,27 +1,32 @@
-import queue
-from typing import Any
+from queue import Empty, Queue
+from typing import Optional, TypeVar
 
-from isar.models.communication.queues.queue_io import QueueIO
 from isar.models.communication.queues.status_queue import StatusQueue
 
+T = TypeVar("T")
 
-def trigger_event(queueio: QueueIO, data: Any = None) -> None:
-    queueio.input.put(data if data is not None else True)
 
+def trigger_event_without_data(queue: Queue[bool]) -> None:
+    queue.put(True)
 
-def check_shared_state(queueio: StatusQueue) -> Any:
+
+def trigger_event(queue: Queue[T], data: T) -> None:
+    queue.put(data)
+
+
+def check_shared_state(queue: StatusQueue[T]) -> Optional[T]:
     try:
-        return queueio.check()
-    except queue.Empty:
+        return queue.check()
+    except Empty:
         return None
 
 
-def update_shared_state(queueio: StatusQueue, data: Any = None) -> None:
-    queueio.update(data if data is not None else True)
+def update_shared_state(queue: StatusQueue[T], data: T) -> None:
+    queue.update(data)
 
 
-def check_for_event(queueio: QueueIO) -> Any:
+def check_for_event(queue: Queue[T]) -> Optional[T]:
     try:
-        return queueio.input.get(block=False)
-    except queue.Empty:
+        return queue.get(block=False)
+    except Empty:
         return None

isar/models/communication/queues/status_queue.py

@@ -1,20 +1,22 @@
 from collections import deque
 from queue import Empty, Queue
-from typing import Any
+from typing import TypeVar
 
+T = TypeVar("T")
 
-class StatusQueue(Queue):
+
+class StatusQueue(Queue[T]):
     def __init__(self) -> None:
         super().__init__()
 
-    def check(self) -> Any:
+    def check(self) -> T:
         if not self._qsize():
             raise Empty
         with self.mutex:
             queueList = list(self.queue)
             return queueList.pop()
 
-    def update(self, item: Any):
+    def update(self, item: T):
         with self.mutex:
-            self.queue = deque()
+            self.queue: deque[T] = deque()
             self.queue.append(item)

isar/modules.py

@@ -16,7 +16,7 @@ from isar.mission_planner.local_planner import LocalPlanner
 from isar.mission_planner.mission_planner_interface import MissionPlannerInterface
 from isar.mission_planner.sequential_task_selector import SequentialTaskSelector
 from isar.mission_planner.task_selector_interface import TaskSelectorInterface
-from isar.models.communication.queues.queues import Queues
+from isar.models.communication.queues.events import Events, SharedState
 from isar.services.service_connections.request_handler import RequestHandler
 from isar.services.utilities.robot_utilities import RobotUtilities
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities
@@ -76,11 +76,18 @@ class RobotModule(Module):
         return robot_interface.Robot()  # type: ignore
 
 
-class QueuesModule(Module):
+class EventsModule(Module):
     @provider
     @singleton
-    def provide_queues(self) -> Queues:
-        return Queues()
+    def provide_events(self) -> Events:
+        return Events()
+
+
+class SharedStateModule(Module):
+    @provider
+    @singleton
+    def provide_shared_state(self) -> SharedState:
+        return SharedState()
 
 
 class RequestHandlerModule(Module):
@@ -125,13 +132,15 @@ class StateMachineModule(Module):
     @singleton
     def provide_state_machine(
         self,
-        queues: Queues,
+        events: Events,
+        shared_state: SharedState,
         robot: RobotInterface,
         mqtt_client: MqttClientInterface,
         task_selector: TaskSelectorInterface,
     ) -> StateMachine:
         return StateMachine(
-            queues=queues,
+            events=events,
+            shared_state=shared_state,
             robot=robot,
             mqtt_publisher=mqtt_client,
             task_selector=task_selector,
@@ -143,12 +152,12 @@ class UploaderModule(Module):
     @singleton
     def provide_uploader(
         self,
-        queues: Queues,
+        events: Events,
         storage_handlers: List[StorageInterface],
         mqtt_client: MqttClientInterface,
     ) -> Uploader:
         return Uploader(
-            queues=queues,
+            events=events,
             storage_handlers=storage_handlers,
             mqtt_publisher=mqtt_client,
         )
@@ -158,9 +167,12 @@ class SchedulingUtilitiesModule(Module):
     @provider
     @singleton
     def provide_scheduling_utilities(
-        self, queues: Queues, mission_planner: MissionPlannerInterface
+        self,
+        events: Events,
+        shared_state: SharedState,
+        mission_planner: MissionPlannerInterface,
     ) -> SchedulingUtilities:
-        return SchedulingUtilities(queues, mission_planner)
+        return SchedulingUtilities(events, shared_state, mission_planner)
 
 
 class RobotUtilitiesModule(Module):
@@ -180,9 +192,9 @@ class ServiceModule(Module):
 class MqttModule(Module):
     @provider
     @singleton
-    def provide_mqtt_client(self, queues: Queues) -> MqttClientInterface:
+    def provide_mqtt_client(self, events: Events) -> MqttClientInterface:
         if settings.MQTT_ENABLED:
-            return MqttPublisher(mqtt_queue=queues.mqtt_queue)
+            return MqttPublisher(mqtt_queue=events.mqtt_queue)
         return None
 
 
@@ -196,7 +208,8 @@ class SequentialTaskSelectorModule(Module):
 modules: Dict[str, Tuple[Module, Union[str, bool]]] = {
     "api": (APIModule, "required"),
     "authentication": (AuthenticationModule, "required"),
-    "queues": (QueuesModule, "required"),
+    "events": (EventsModule, "required"),
+    "shared_state": (SharedStateModule, "required"),
     "request_handler": (RequestHandlerModule, "required"),
     "robot_package": (RobotModule, settings.ROBOT_PACKAGE),
     "isar_id": (RobotModule, settings.ISAR_ID),
@@ -229,6 +242,6 @@ def get_injector() -> Injector:
         )
 
     logger: Logger = logging.getLogger("modules")
-    logger.info(f"Loaded the following module configurations:{module_overview}")
+    logger.info("Loaded the following module configurations: %s", module_overview)
 
     return Injector(injector_modules)

isar/robot/robot.py

@@ -1,14 +1,20 @@
 import logging
+from queue import Queue
 from threading import Event
 from typing import Optional
 
 from injector import inject
 
-from isar.models.communication.queues.queue_io import QueueIO
+from isar.models.communication.queues.events import (
+    Events,
+    RobotServiceEvents,
+    SharedState,
+    StateMachineEvents,
+)
 from isar.models.communication.queues.queue_utils import check_for_event
-from isar.models.communication.queues.queues import Queues
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
+from isar.robot.robot_stop_mission import RobotStopMissionThread
 from isar.robot.robot_task_status import RobotTaskStatusThread
 from robot_interface.robot_interface import RobotInterface
 
@@ -16,13 +22,18 @@ from robot_interface.robot_interface import RobotInterface
 class Robot(object):
 
     @inject
-    def __init__(self, queues: Queues, robot: RobotInterface):
+    def __init__(
+        self, events: Events, robot: RobotInterface, shared_state: SharedState
+    ):
         self.logger = logging.getLogger("robot")
-        self.queues: Queues = queues
+        self.state_machine_events: StateMachineEvents = events.state_machine_events
+        self.robot_service_events: RobotServiceEvents = events.robot_service_events
+        self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.start_mission_thread: Optional[RobotStartMissionThread] = None
         self.robot_status_thread: Optional[RobotStatusThread] = None
         self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
+        self.stop_mission_thread_thread: Optional[RobotStopMissionThread] = None
         self.signal_thread_quitting: Event = Event()
 
     def stop(self) -> None:
@@ -39,12 +50,17 @@ class Robot(object):
             and self.robot_status_thread.is_alive()
         ):
             self.start_mission_thread.join()
+        if (
+            self.stop_mission_thread_thread is not None
+            and self.stop_mission_thread_thread.is_alive()
+        ):
+            self.stop_mission_thread_thread.join()
         self.robot_status_thread = None
         self.robot_task_status_thread = None
         self.start_mission_thread = None
 
-    def _check_and_handle_start_mission(self, queue: QueueIO) -> None:
-        start_mission = check_for_event(queue)
+    def _check_and_handle_start_mission(self, event: Queue) -> None:
+        start_mission = check_for_event(event)
         if start_mission is not None:
             if (
                 self.start_mission_thread is not None
@@ -55,24 +71,39 @@ class Robot(object):
                 )
                 self.start_mission_thread.join()
             self.start_mission_thread = RobotStartMissionThread(
-                self.queues,
+                self.robot_service_events,
                 self.robot,
                 self.signal_thread_quitting,
                 start_mission,
             )
             self.start_mission_thread.start()
 
-    def _check_and_handle_task_status_request(self, queue: QueueIO) -> None:
-        task_id = check_for_event(queue)
+    def _check_and_handle_task_status_request(self, event: Queue[str]) -> None:
+        task_id: str = check_for_event(event)
         if task_id:
             self.robot_task_status_thread = RobotTaskStatusThread(
-                self.queues, self.robot, self.signal_thread_quitting, task_id
+                self.robot_service_events,
+                self.robot,
+                self.signal_thread_quitting,
+                task_id,
             )
             self.robot_task_status_thread.start()
 
+    def _check_and_handle_stop_mission(self, event: Queue) -> None:
+        if check_for_event(event):
+            if (
+                self.stop_mission_thread_thread is not None
+                and self.start_mission_thread.is_alive()
+            ):
+                return
+            self.stop_mission_thread_thread = RobotStopMissionThread(
+                self.robot_service_events, self.robot, self.signal_thread_quitting
+            )
+            self.stop_mission_thread_thread.start()
+
     def run(self) -> None:
         self.robot_status_thread = RobotStatusThread(
-            self.queues, self.robot, self.signal_thread_quitting
+            self.robot, self.signal_thread_quitting, self.shared_state
         )
         self.robot_status_thread.start()
 
@@ -81,11 +112,13 @@ class Robot(object):
                 break
 
             self._check_and_handle_start_mission(
-                self.queues.state_machine_start_mission
+                self.state_machine_events.start_mission
             )
 
             self._check_and_handle_task_status_request(
-                self.queues.state_machine_task_status_request
+                self.state_machine_events.task_status_request
             )
 
+            self._check_and_handle_stop_mission(self.state_machine_events.stop_mission)
+
         self.logger.info("Exiting robot service main thread")

isar/robot/robot_start_mission.py

@@ -1,11 +1,12 @@
 import logging
 from threading import Event, Thread
-from typing import Optional
 
 from isar.config.settings import settings
-from isar.models.communication.queues.queue_utils import trigger_event
-from isar.models.communication.queues.queues import Queues
-from isar.services.utilities.threaded_request import ThreadedRequest
+from isar.models.communication.queues.events import RobotServiceEvents
+from isar.models.communication.queues.queue_utils import (
+    trigger_event,
+    trigger_event_without_data,
+)
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotException,
@@ -19,15 +20,14 @@ class RobotStartMissionThread(Thread):
 
     def __init__(
         self,
-        queues: Queues,
+        robot_service_events: RobotServiceEvents,
         robot: RobotInterface,
         signal_thread_quitting: Event,
         mission: Mission,
     ):
         self.logger = logging.getLogger("robot")
-        self.queues: Queues = queues
+        self.robot_service_events: RobotServiceEvents = robot_service_events
         self.robot: RobotInterface = robot
-        self.start_mission_thread: Optional[ThreadedRequest] = None
         self.signal_thread_quitting: Event = signal_thread_quitting
         self.mission = mission
         Thread.__init__(self, name="Robot start mission thread")
@@ -56,7 +56,7 @@ class RobotStartMissionThread(Thread):
                         )
 
                         trigger_event(
-                            self.queues.robot_mission_failed,
+                            self.robot_service_events.mission_failed,
                             ErrorMessage(
                                 error_reason=e.error_reason,
                                 error_description=error_description,
@@ -65,9 +65,9 @@ class RobotStartMissionThread(Thread):
                 started_mission = True
         except RobotInfeasibleMissionException as e:
             trigger_event(
-                self.queues.robot_mission_failed,
+                self.robot_service_events.mission_failed,
                 ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
                 ),
             )
-        trigger_event(self.queues.robot_mission_started)
+        trigger_event_without_data(self.robot_service_events.mission_started)

isar/robot/robot_status.py

@@ -3,18 +3,21 @@ import time
 from threading import Event, Thread
 
 from isar.config.settings import settings
+from isar.models.communication.queues.events import SharedState
 from isar.models.communication.queues.queue_utils import update_shared_state
-from isar.models.communication.queues.queues import Queues
 from robot_interface.robot_interface import RobotInterface
 
 
 class RobotStatusThread(Thread):
 
     def __init__(
-        self, queues: Queues, robot: RobotInterface, signal_thread_quitting: Event
+        self,
+        robot: RobotInterface,
+        signal_thread_quitting: Event,
+        shared_state: SharedState,
     ):
         self.logger = logging.getLogger("robot")
-        self.queues: Queues = queues
+        self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.signal_thread_quitting: Event = signal_thread_quitting
         self.last_robot_status_poll_time: float = time.time()
@@ -41,6 +44,6 @@ class RobotStatusThread(Thread):
 
             robot_status = self.robot.robot_status()
 
-            update_shared_state(self.queues.robot_status, robot_status)
+            update_shared_state(self.shared_state.robot_status, robot_status)
             self.last_robot_status_poll_time = time.time()
         self.logger.info("Exiting robot status thread")

isar/robot/robot_stop_mission.py

@@ -0,0 +1,72 @@
+import logging
+import time
+from threading import Event, Thread
+from typing import Optional
+
+from isar.config.settings import settings
+from isar.models.communication.queues.events import RobotServiceEvents
+from isar.models.communication.queues.queue_utils import (
+    trigger_event,
+    trigger_event_without_data,
+)
+from robot_interface.models.exceptions.robot_exceptions import (
+    ErrorMessage,
+    RobotActionException,
+    RobotException,
+)
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotStopMissionThread(Thread):
+
+    def __init__(
+        self,
+        robot_service_events: RobotServiceEvents,
+        robot: RobotInterface,
+        signal_thread_quitting: Event,
+    ):
+        self.logger = logging.getLogger("robot")
+        self.robot_service_events: RobotServiceEvents = robot_service_events
+        self.robot: RobotInterface = robot
+        self.signal_thread_quitting: Event = signal_thread_quitting
+        Thread.__init__(self, name="Robot start mission thread")
+
+    def run(self) -> None:
+        retries = 0
+        error: Optional[ErrorMessage] = None
+        while retries < settings.STOP_ROBOT_ATTEMPTS_LIMIT:
+            if self.signal_thread_quitting.wait(0):
+                return
+
+            try:
+                self.robot.stop()
+            except (RobotActionException, RobotException) as e:
+                self.logger.warning(
+                    f"\nFailed to stop robot because: {e.error_description}"
+                    f"\nAttempting to stop the robot again"
+                )
+                retries += 1
+                error = ErrorMessage(
+                    error_reason=e.error_reason, error_description=e.error_description
+                )
+                time.sleep(settings.FSM_SLEEP_TIME)
+                continue
+
+            trigger_event_without_data(
+                self.robot_service_events.mission_successfully_stopped
+            )
+            return
+
+        error_description = (
+            f"\nFailed to stop the robot after {retries} attempts because: "
+            f"{error.error_description}"
+            f"\nBe aware that the robot may still be moving even though a stop has "
+            "been attempted"
+        )
+
+        error_message = ErrorMessage(
+            error_reason=error.error_reason,
+            error_description=error_description,
+        )
+
+        trigger_event(self.robot_service_events.mission_failed_to_stop, error_message)