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

isar/apis/api.py

@@ -112,29 +112,6 @@ class API:
 
         authentication_dependency: Security = Security(self.authenticator.get_scheme())
 
-        router.add_api_route(
-            path="/schedule/start-mission/{id}",
-            endpoint=self.scheduling_controller.start_mission_by_id,
-            methods=["POST"],
-            deprecated=True,
-            dependencies=[authentication_dependency],
-            summary="Start a mission with id='id' from the current mission planner",
-            responses={
-                HTTPStatus.OK.value: {
-                    "description": "Mission succesfully started",
-                    "model": StartMissionResponse,
-                },
-                HTTPStatus.NOT_FOUND.value: {
-                    "description": "Not found - Mission not found",
-                },
-                HTTPStatus.CONFLICT.value: {
-                    "description": "Conflict - Invalid command in the current state",
-                },
-                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
-                    "description": "Internal Server Error - Current state of state machine unknown",
-                },
-            },
-        )
         router.add_api_route(
             path="/schedule/start-mission",
             endpoint=self.scheduling_controller.start_mission,

isar/apis/models/start_mission_definition.py

@@ -6,7 +6,6 @@ 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.task import (
     TASKS,
@@ -63,6 +62,10 @@ class StopMissionDefinition(BaseModel):
     mission_id: Optional[str] = None
 
 
+class MissionFormatError(Exception):
+    pass
+
+
 def to_isar_mission(
     start_mission_definition: StartMissionDefinition,
 ) -> Mission:
@@ -73,7 +76,7 @@ def to_isar_mission(
         isar_tasks.append(task)
 
     if not isar_tasks:
-        raise MissionPlannerError("Mission does not contain any valid tasks")
+        raise MissionFormatError("Mission does not contain any valid tasks")
 
     isar_mission_name: str = (
         start_mission_definition.name
@@ -101,7 +104,7 @@ def to_isar_task(task_definition: StartMissionTaskDefinition) -> TASKS:
     elif task_definition.type == TaskType.ReturnToHome:
         return ReturnToHome()
     else:
-        raise MissionPlannerError(
+        raise MissionFormatError(
             f"Failed to create task: '{task_definition.type}' is not a valid"
         )
 

isar/apis/schedule/scheduling_controller.py

@@ -1,7 +1,7 @@
 import logging
 from http import HTTPStatus
 
-from fastapi import Body, HTTPException, Path
+from fastapi import Body, HTTPException
 from opentelemetry import trace
 
 from isar.apis.models.models import (
@@ -10,12 +10,12 @@ from isar.apis.models.models import (
     TaskResponse,
 )
 from isar.apis.models.start_mission_definition import (
+    MissionFormatError,
     StartMissionDefinition,
     StopMissionDefinition,
     to_isar_mission,
 )
 from isar.config.settings import robot_settings
-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
@@ -32,32 +32,6 @@ class SchedulingController:
         self.scheduling_utilities: SchedulingUtilities = scheduling_utilities
         self.logger = logging.getLogger("api")
 
-    @tracer.start_as_current_span("start_mission_by_id")
-    def start_mission_by_id(
-        self,
-        mission_id: str = Path(
-            alias="id",
-            title="Mission ID",
-            description="ID-number for predefined mission",
-        ),
-    ) -> StartMissionResponse:
-        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)
-
-        self.scheduling_utilities.verify_robot_capable_of_mission(
-            mission=mission, robot_capabilities=robot_settings.CAPABILITIES
-        )
-
-        self.logger.info("Starting mission with ISAR Mission ID: '%s'", mission.id)
-
-        self.scheduling_utilities.start_mission(mission=mission)
-
-        return self._api_response(mission)
-
     @tracer.start_as_current_span("start_mission")
     def start_mission(
         self,
@@ -87,7 +61,7 @@ class SchedulingController:
             mission: Mission = to_isar_mission(
                 start_mission_definition=mission_definition
             )
-        except MissionPlannerError as e:
+        except MissionFormatError as e:
             error_message = f"Bad Request - Cannot create ISAR mission: {e}"
             self.logger.warning(error_message)
             raise HTTPException(

isar/config/keyvault/keyvault_service.py

@@ -9,7 +9,9 @@ from azure.core.exceptions import (
 from azure.identity import ClientSecretCredential, DefaultAzureCredential
 from azure.keyvault.secrets import KeyVaultSecret, SecretClient
 
-from isar.config.keyvault.keyvault_error import KeyvaultError
+
+class KeyvaultError(Exception):
+    pass
 
 
 class Keyvault:

isar/config/settings.py

@@ -6,7 +6,6 @@ from dotenv import load_dotenv
 from pydantic import Field, ValidationInfo, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from isar.config import predefined_missions
 from robot_interface.models.robots.robot_model import RobotModel
 from robot_interface.telemetry.payloads import DocumentInfo
 
@@ -36,10 +35,6 @@ class Settings(BaseSettings):
     # The sleep is used to throttle the system on every iteration in the loop
     FSM_SLEEP_TIME: float = Field(default=0.1)
 
-    # Location of JSON files containing predefined missions for the Local Planner to use
-    path: str = os.path.dirname(predefined_missions.__file__)
-    PREDEFINED_MISSIONS_FOLDER: str = Field(default=path + "/")
-
     # Name of default map transformation
     DEFAULT_MAP: str = Field(default="default_map")
 
@@ -93,9 +88,6 @@ class Settings(BaseSettings):
     # Sets how many times the robot should try to return home if a return home fails
     RETURN_HOME_RETRY_LIMIT: int = Field(default=5)
 
-    # Determines which mission planner module is used by ISAR
-    MISSION_PLANNER: str = Field(default="local")
-
     # Determines which storage modules are used by ISAR
     # Multiple storage modules can be chosen
     # Each module will be called when storing results from inspections

isar/models/status.py

@@ -16,3 +16,7 @@ class IsarStatus(Enum):
     GoingToLockdown = "goingtolockdown"
     GoingToRecharging = "goingtorecharging"
     Maintenance = "maintenance"
+    Pausing = "pausing"
+    PausingReturnHome = "pausingreturnhome"
+    Stopping = "stopping"
+    StoppingReturnHome = "stoppingreturnhome"

isar/modules.py

@@ -9,7 +9,6 @@ from isar.apis.schedule.scheduling_controller import SchedulingController
 from isar.apis.security.authentication import Authenticator
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
-from isar.mission_planner.local_planner import LocalPlanner
 from isar.models.events import Events, SharedState
 from isar.robot.robot import Robot
 from isar.services.utilities.robot_utilities import RobotUtilities
@@ -59,7 +58,6 @@ class ApplicationContainer(containers.DeclarativeContainer):
         SchedulingUtilities,
         events=events,
         shared_state=shared_state,
-        mission_planner=providers.Singleton(LocalPlanner),
     )
     scheduling_controller = providers.Singleton(
         SchedulingController, scheduling_utilities=scheduling_utilities

isar/robot/robot.py

@@ -142,17 +142,23 @@ class Robot(object):
         ):
             self.stop_mission_thread.join()
             error_message = self.stop_mission_thread.error_message
-            self.stop_mission_thread = None
 
             if error_message:
                 self.robot_service_events.mission_failed_to_stop.trigger_event(
                     error_message
                 )
+                self.stop_mission_thread = None
             else:
-                self.signal_mission_stopped.set()
                 if self.monitor_mission_thread is not None:
+                    if self.monitor_mission_thread.is_alive():
+                        self.signal_mission_stopped.set()
+                        return
                     self.monitor_mission_thread.join()
                     self.monitor_mission_thread = None
+
+                self.stop_mission_thread = None
+                # The mission status will already be reported on MQTT, the state machine does not need the event
+                self.robot_service_events.mission_status_updated.clear_event()
                 self.robot_service_events.mission_successfully_stopped.trigger_event(
                     True
                 )

isar/script.py

@@ -58,10 +58,10 @@ def print_startup_info():
     )
 
     print_setting("ISAR settings")
+    print_setting("ISAR ID", settings.ISAR_ID)
     print_setting("Robot package", settings.ROBOT_PACKAGE)
     print_setting("Robot name", settings.ROBOT_NAME)
     print_setting("Running on port", settings.API_PORT)
-    print_setting("Mission planner", settings.MISSION_PLANNER)
     print_setting("Using local storage", settings.STORAGE_LOCAL_ENABLED)
     print_setting("Using blob storage", settings.STORAGE_BLOB_ENABLED)
     print_setting("Blob storage account", settings.BLOB_STORAGE_ACCOUNT)

isar/services/utilities/scheduling_utilities.py

@@ -4,15 +4,9 @@ from http import HTTPStatus
 from typing import List, TypeVar
 
 from fastapi import HTTPException
-from requests import HTTPError
 
 from isar.apis.models.models import ControlMissionResponse, MaintenanceResponse
 from isar.config.settings import settings
-from isar.mission_planner.mission_planner_interface import (
-    MissionNotFoundError,
-    MissionPlannerError,
-    MissionPlannerInterface,
-)
 from isar.models.events import (
     APIEvent,
     APIRequests,
@@ -41,12 +35,10 @@ class SchedulingUtilities:
         self,
         events: Events,
         shared_state: SharedState,
-        mission_planner: MissionPlannerInterface,
         queue_timeout: int = settings.QUEUE_TIMEOUT,
     ):
         self.api_events: APIRequests = events.api_requests
         self.shared_state: SharedState = shared_state
-        self.mission_planner: MissionPlannerInterface = mission_planner
         self.queue_timeout: int = queue_timeout
         self.logger = logging.getLogger("api")
 
@@ -69,40 +61,6 @@ class SchedulingUtilities:
             )
         return current_state
 
-    def get_mission(self, mission_id: str) -> Mission:
-        """Get the mission with mission_id from the current mission planner
-
-        Raises
-        ------
-        HTTPException 404 Not Found
-            If requested mission with mission_id is not found
-        HTTPException 500 Internal Server Error
-            If for some reason the mission can not be returned
-        """
-        try:
-            return self.mission_planner.get_mission(mission_id)
-        except HTTPError as e:
-            self.logger.error(e)
-            raise HTTPException(status_code=e.response.status_code)
-        except MissionNotFoundError as e:
-            self.logger.error(e)
-            raise HTTPException(
-                status_code=HTTPStatus.NOT_FOUND,
-                detail=f"Mission with id '{mission_id}' not found",
-            )
-        except MissionPlannerError as e:
-            self.logger.error(e)
-            raise HTTPException(
-                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                detail="Could not plan mission",
-            )
-        except Exception as e:
-            self.logger.error(e)
-            raise HTTPException(
-                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                detail="Could not return mission",
-            )
-
     def verify_robot_capable_of_mission(
         self, mission: Mission, robot_capabilities: List[str]
     ) -> bool:

isar/state_machine/state_machine.py

@@ -41,6 +41,10 @@ from isar.state_machine.states.stopping_due_to_maintenance import (
 )
 from isar.state_machine.states.stopping_go_to_lockdown import StoppingGoToLockdown
 from isar.state_machine.states.stopping_go_to_recharge import StoppingGoToRecharge
+from isar.state_machine.states.stopping_paused_mission import StoppingPausedMission
+from isar.state_machine.states.stopping_paused_return_home import (
+    StoppingPausedReturnHome,
+)
 from isar.state_machine.states.stopping_return_home import StoppingReturnHome
 from isar.state_machine.states.unknown_status import UnknownStatus
 from isar.state_machine.states_enum import States
@@ -106,6 +110,8 @@ class StateMachine(object):
         self.going_to_lockdown_state: State = GoingToLockdown(self)
         self.going_to_recharging_state: State = GoingToRecharging(self)
         self.stopping_due_to_maintenance_state: State = StoppingDueToMaintenance(self)
+        self.stopping_paused_mission_state: State = StoppingPausedMission(self)
+        self.stopping_paused_return_home_state: State = StoppingPausedReturnHome(self)
 
         # States Waiting for mission
         self.await_next_mission_state: State = AwaitNextMission(self)
@@ -147,6 +153,8 @@ class StateMachine(object):
             self.stopping_go_to_recharge_state,
             self.stopping_due_to_maintenance_state,
             self.maintenance_state,
+            self.stopping_paused_mission_state,
+            self.stopping_paused_return_home_state,
         ]
 
         if settings.PERSISTENT_STORAGE_CONNECTION_STRING == "":
@@ -237,9 +245,8 @@ class StateMachine(object):
 
         if self.shared_state.mission_id.check() is None:
             self.logger.warning(
-                "Could not publish mission aborted message. No ongoing mission."
+                "Publishing mission aborted message with no ongoing mission."
             )
-            return
 
         payload: MissionAbortedPayload = MissionAbortedPayload(
             isar_id=settings.ISAR_ID,
@@ -309,6 +316,21 @@ class StateMachine(object):
             return IsarStatus.GoingToRecharging
         elif self.current_state == States.Maintenance:
             return IsarStatus.Maintenance
+        elif self.current_state == States.Pausing:
+            return IsarStatus.Pausing
+        elif self.current_state == States.PausingReturnHome:
+            return IsarStatus.PausingReturnHome
+        elif self.current_state in [
+            States.Stopping,
+            States.StoppingDueToMaintenance,
+            States.StoppingGoToLockdown,
+            States.StoppingGoToRecharge,
+            States.StoppingPausedMission,
+            States.StoppingPausedReturnHome,
+        ]:
+            return IsarStatus.Stopping
+        elif self.current_state == States.StoppingReturnHome:
+            return IsarStatus.StoppingReturnHome
         else:
             return IsarStatus.Busy
 

isar/state_machine/states/maintenance.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, List
 
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
 from isar.models.events import Event
+from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -18,7 +19,13 @@ class Maintenance(EventHandlerBase):
                 events.api_requests.release_from_maintenance_mode.response.trigger_event(
                     True
                 )
-                return state_machine.release_from_maintenance  # type: ignore
+
+                robot_status = state_machine.shared_state.robot_status.check()
+                if robot_status == RobotStatus.Home:
+                    return state_machine.goto_home  # type: ignore
+                else:
+                    return state_machine.goto_intervention_needed  # type: ignore
+
             return None
 
         event_handlers: List[EventHandlerMapping] = [

isar/state_machine/states/stopping.py

@@ -36,6 +36,14 @@ class Stopping(EventHandlerBase):
             state_machine.events.api_requests.stop_mission.response.trigger_event(
                 ControlMissionResponse(success=True)
             )
+
+            if state_machine.shared_state.mission_id.check() is None:
+                reason: str = (
+                    "Robot was busy and mission stopped but no ongoing mission found in shared state."
+                )
+                state_machine.logger.warning(reason)
+                state_machine.publish_mission_aborted(reason, False)
+
             state_machine.print_transitions()
             if not state_machine.battery_level_is_above_mission_start_threshold():
                 state_machine.start_return_home_mission()

isar/state_machine/states/stopping_paused_mission.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING, List
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.state_machine.utils.common_event_handlers import (
+    failed_stop_event_handler,
+    successful_stop_event_handler,
+)
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingPausedMission(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=lambda event: failed_stop_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=lambda event: successful_stop_event_handler(
+                    state_machine, event
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_paused_mission",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/stopping_paused_return_home.py

@@ -0,0 +1,59 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from isar.apis.models.models import MissionStartResponse
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.state_machine.utils.common_event_handlers import (
+    failed_stop_return_home_event_handler,
+    successful_stop_return_home_event_handler,
+)
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingPausedReturnHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        self.mission: Optional[Mission] = None
+
+        def _respond_to_start_mission_request():
+            self.mission = (
+                state_machine.events.api_requests.start_mission.request.consume_event()
+            )
+            if not self.mission:
+                state_machine.logger.error(
+                    "Reached stopping paused return home without a mission request"
+                )
+            else:
+                response = MissionStartResponse(
+                    mission_id=self.mission.id,
+                    mission_started=True,
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    response
+                )
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=lambda event: failed_stop_return_home_event_handler(
+                    state_machine, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=lambda event: successful_stop_return_home_event_handler(
+                    state_machine, event, self.mission
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_paused_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+            on_entry=_respond_to_start_mission_request,
+        )

isar/state_machine/states/stopping_return_home.py

@@ -1,10 +1,11 @@
-import logging
-from typing import TYPE_CHECKING, Callable, List, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from isar.apis.models.models import MissionStartResponse
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
-from isar.models.events import Event
-from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from isar.state_machine.utils.common_event_handlers import (
+    failed_stop_return_home_event_handler,
+    successful_stop_return_home_event_handler,
+)
 from robot_interface.models.mission.mission import Mission
 
 if TYPE_CHECKING:
@@ -14,64 +15,45 @@ if TYPE_CHECKING:
 class StoppingReturnHome(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
-        logger = logging.getLogger("state_machine")
         events = state_machine.events
+        self.mission: Optional[Mission] = None
 
-        def _failed_stop_event_handler(
-            event: Event[ErrorMessage],
-        ) -> Optional[Callable]:
-            error_message: Optional[ErrorMessage] = event.consume_event()
-            if error_message is None:
-                return None
-
-            logger.warning(error_message.error_description)
-            mission: Mission = (
+        def _respond_to_start_mission_request():
+            self.mission = (
                 state_machine.events.api_requests.start_mission.request.consume_event()
             )
-            state_machine.events.api_requests.start_mission.response.trigger_event(
-                MissionStartResponse(
-                    mission_id=mission.id,
-                    mission_started=False,
-                    mission_not_started_reason="Failed to cancel return home mission",
+            if not self.mission:
+                state_machine.logger.error(
+                    "Reached stopping return home without a mission request"
+                )
+            else:
+                response = MissionStartResponse(
+                    mission_id=self.mission.id,
+                    mission_started=True,
                 )
-            )
-            return state_machine.return_home_mission_stopping_failed  # type: ignore
-
-        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if not event.consume_event():
-                return None
-
-            mission: Mission = (
-                state_machine.events.api_requests.start_mission.request.consume_event()
-            )
-
-            if mission:
-                state_machine.start_mission(mission=mission)
                 state_machine.events.api_requests.start_mission.response.trigger_event(
-                    MissionStartResponse(mission_started=True)
+                    response
                 )
-                return state_machine.start_mission_monitoring  # type: ignore
-
-            state_machine.logger.error(
-                "Stopped return home without a new mission to start"
-            )
-            state_machine.start_return_home_mission()
-            return state_machine.start_return_home_monitoring  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="failed_stop_event",
                 event=events.robot_service_events.mission_failed_to_stop,
-                handler=_failed_stop_event_handler,
+                handler=lambda event: failed_stop_return_home_event_handler(
+                    state_machine, event
+                ),
             ),
             EventHandlerMapping(
                 name="successful_stop_event",
                 event=events.robot_service_events.mission_successfully_stopped,
-                handler=_successful_stop_event_handler,
+                handler=lambda event: successful_stop_return_home_event_handler(
+                    state_machine, event, self.mission
+                ),
             ),
         ]
         super().__init__(
             state_name="stopping_return_home",
             state_machine=state_machine,
             event_handler_mappings=event_handlers,
+            on_entry=_respond_to_start_mission_request,
         )

isar/state_machine/states/unknown_status.py

@@ -41,6 +41,8 @@ class UnknownStatus(EventHandlerBase):
                 return state_machine.robot_status_offline  # type: ignore
             elif robot_status == RobotStatus.BlockedProtectiveStop:
                 return state_machine.robot_status_blocked_protective_stop  # type: ignore
+            elif robot_status == RobotStatus.Busy:
+                return state_machine.robot_status_busy  # type: ignore
             return None
 
         def _reset_status_check():

isar/state_machine/states_enum.py

@@ -26,6 +26,8 @@ class States(str, Enum):
     StoppingGoToRecharge = "stopping_go_to_recharge"
     Maintenance = "maintenance"
     StoppingDueToMaintenance = "stopping_due_to_maintenance"
+    StoppingPausedMission = "stopping_paused_mission"
+    StoppingPausedReturnHome = "stopping_paused_return_home"
 
     def __repr__(self):
         return self.value