isar 1.30.4__py3-none-any.whl → 1.31.0__py3-none-any.whl

isar/apis/api.py

@@ -8,35 +8,23 @@ from typing import List, Union
 
 import click
 import uvicorn
-from dependency_injector.wiring import inject
-from fastapi import FastAPI, Request, Security
+from fastapi import FastAPI, Security
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.routing import APIRouter
-from opencensus.ext.azure.trace_exporter import AzureExporter
-from opencensus.trace.attributes_helper import COMMON_ATTRIBUTES
-from opencensus.trace.samplers import ProbabilitySampler
-from opencensus.trace.span import SpanKind
-from opencensus.trace.tracer import Tracer
 from pydantic import AnyHttpUrl
 
 from isar.apis.models.models import ControlMissionResponse, StartMissionResponse
 from isar.apis.robot_control.robot_controller import RobotController
 from isar.apis.schedule.scheduling_controller import SchedulingController
 from isar.apis.security.authentication import Authenticator
-from isar.config.configuration_error import ConfigurationError
-from isar.config.keyvault.keyvault_error import KeyvaultError
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from robot_interface.telemetry.payloads import StartUpMessagePayload
 from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
-HTTP_URL = COMMON_ATTRIBUTES["HTTP_URL"]
-HTTP_STATUS_CODE = COMMON_ATTRIBUTES["HTTP_STATUS_CODE"]
-
 
 class API:
-    @inject
     def __init__(
         self,
         authenticator: Authenticator,
@@ -45,7 +33,6 @@ class API:
         keyvault: Keyvault,
         mqtt_publisher: MqttClientInterface,
         port: int = settings.API_PORT,
-        azure_ai_logging_enabled: bool = settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED,
     ) -> None:
         self.authenticator: Authenticator = authenticator
         self.scheduling_controller: SchedulingController = scheduling_controller
@@ -53,7 +40,6 @@ class API:
         self.keyvault: Keyvault = keyvault
         self.host: str = "0.0.0.0"  # Locking uvicorn to use 0.0.0.0
         self.port: int = port
-        self.azure_ai_logging_enabled: bool = azure_ai_logging_enabled
         self.mqtt_publisher: MqttClientInterface = mqtt_publisher
 
         self.logger: Logger = logging.getLogger("api")
@@ -113,9 +99,6 @@ class API:
                 allow_headers=["*"],
             )
 
-        if self.azure_ai_logging_enabled:
-            self._add_request_logging_middleware(app)
-
         app.include_router(router=self._create_scheduler_router())
 
         app.include_router(router=self._create_info_router())
@@ -210,9 +193,15 @@ class API:
                     "description": "Mission succesfully stopped",
                     "model": ControlMissionResponse,
                 },
+                HTTPStatus.UNPROCESSABLE_ENTITY.value: {
+                    "description": "Invalid body - The JSON is incorrect",
+                },
                 HTTPStatus.CONFLICT.value: {
                     "description": "Conflict - Invalid command in the current state",
                 },
+                HTTPStatus.BAD_REQUEST.value: {
+                    "description": "Bad request - Robot does not have the capabilities to perform the mission",
+                },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
                     "description": "Internal Server Error - Current state of state machine unknown",
                 },
@@ -336,39 +325,6 @@ class API:
             extra={"color_message": color_message},
         )
 
-    def _add_request_logging_middleware(self, app: FastAPI) -> None:
-        connection_string: str
-        try:
-            connection_string = self.keyvault.get_secret(
-                "application-insights-connection-string"
-            ).value
-        except KeyvaultError:
-            message: str = (
-                "Missing connection string for Application Insights in key vault. "
-            )
-            self.logger.critical(message)
-            raise ConfigurationError(message)
-
-        @app.middleware("http")
-        async def middlewareOpencensus(request: Request, call_next):
-            tracer = Tracer(
-                exporter=AzureExporter(connection_string=connection_string),
-                sampler=ProbabilitySampler(1.0),
-            )
-            with tracer.span("main") as span:
-                span.span_kind = SpanKind.SERVER
-
-                response = await call_next(request)
-
-                tracer.add_attribute_to_current_span(
-                    attribute_key=HTTP_STATUS_CODE, attribute_value=response.status_code
-                )
-                tracer.add_attribute_to_current_span(
-                    attribute_key=HTTP_URL, attribute_value=str(request.url)
-                )
-
-            return response
-
     def _publish_startup_message(self) -> None:
         if not self.mqtt_publisher:
             return

isar/apis/models/models.py

@@ -19,10 +19,11 @@ class StartMissionResponse(BaseModel):
 
 
 class ControlMissionResponse(BaseModel):
-    mission_id: str
-    mission_status: str
-    task_id: str
-    task_status: str
+    mission_id: Optional[str]
+    mission_status: Optional[str]
+    mission_not_found: Optional[bool] = False
+    task_id: Optional[str]
+    task_status: Optional[str]
 
 
 class RobotInfoResponse(BaseModel):

isar/apis/models/start_mission_definition.py

@@ -58,6 +58,10 @@ class StartMissionDefinition(BaseModel):
     start_pose: Optional[InputPose] = None
 
 
+class StopMissionDefinition(BaseModel):
+    mission_id: Optional[str] = None
+
+
 def to_isar_mission(
     start_mission_definition: StartMissionDefinition,
 ) -> Mission:

isar/apis/robot_control/robot_controller.py

@@ -1,6 +1,5 @@
 import logging
 
-from dependency_injector.wiring import inject
 from fastapi import HTTPException
 
 from isar.apis.models.models import RobotInfoResponse
@@ -10,7 +9,6 @@ from robot_interface.models.robots.media import MediaConfig
 
 
 class RobotController:
-    @inject
     def __init__(
         self,
         robot_utilities: RobotUtilities,

isar/apis/schedule/scheduling_controller.py

@@ -2,7 +2,6 @@ import logging
 from http import HTTPStatus
 from threading import Lock
 
-from dependency_injector.wiring import inject
 from fastapi import Body, HTTPException, Path
 
 from isar.apis.models.models import (
@@ -12,6 +11,7 @@ from isar.apis.models.models import (
 )
 from isar.apis.models.start_mission_definition import (
     StartMissionDefinition,
+    StopMissionDefinition,
     to_isar_mission,
 )
 from isar.config.settings import robot_settings, settings
@@ -23,7 +23,6 @@ from robot_interface.models.mission.task import TASKS, InspectionTask, MoveArm
 
 
 class SchedulingController:
-    @inject
     def __init__(
         self,
         scheduling_utilities: SchedulingUtilities,
@@ -179,7 +178,16 @@ class SchedulingController:
         )
         return resume_mission_response
 
-    def stop_mission(self) -> ControlMissionResponse:
+    def stop_mission(
+        self,
+        mission_id: StopMissionDefinition = Body(
+            default=None,
+            embed=True,
+            title="Mission ID to stop",
+            description="The mission ID of the mission being stopped, in json format",
+        ),
+    ) -> ControlMissionResponse:
+
         self.logger.info("Received request to stop current mission")
 
         state: States = self.scheduling_utilities.get_state()
@@ -198,7 +206,7 @@ class SchedulingController:
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
 
         stop_mission_response: ControlMissionResponse = (
-            self.scheduling_utilities.stop_mission()
+            self.scheduling_utilities.stop_mission(mission_id.mission_id)
         )
         return stop_mission_response
 

isar/config/log.py

@@ -3,30 +3,21 @@ import logging.config
 from importlib.resources import as_file, files
 
 import yaml
-from opencensus.ext.azure.log_exporter import AzureLogHandler
 from uvicorn.logging import ColourizedFormatter
 
-from isar.config.configuration_error import ConfigurationError
-from isar.config.keyvault.keyvault_error import KeyvaultError
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 
 
 def setup_loggers(keyvault: Keyvault) -> None:
     log_levels: dict = settings.LOG_LEVELS
-    source = files("isar").joinpath("config").joinpath("logging.conf")
-    with as_file(source) as f:
-        log_config = yaml.safe_load(open(f))
+    log_config = load_log_config()
 
     logging.config.dictConfig(log_config)
 
     handlers = []
     if settings.LOG_HANDLER_LOCAL_ENABLED:
         handlers.append(configure_console_handler(log_config=log_config))
-    if settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
-        handlers.append(
-            configure_azure_handler(log_config=log_config, keyvault=keyvault)
-        )
 
     for log_handler in handlers:
         for loggers in log_config["loggers"].keys():
@@ -35,6 +26,13 @@ def setup_loggers(keyvault: Keyvault) -> None:
         logging.getLogger().addHandler(log_handler)
 
 
+def load_log_config():
+    source = files("isar").joinpath("config").joinpath("logging.conf")
+    with as_file(source) as f:
+        log_config = yaml.safe_load(open(f))
+    return log_config
+
+
 def configure_console_handler(log_config: dict) -> logging.Handler:
     handler = logging.StreamHandler()
     handler.setLevel(log_config["root"]["level"])
@@ -46,22 +44,3 @@ def configure_console_handler(log_config: dict) -> logging.Handler:
         )
     )
     return handler
-
-
-def configure_azure_handler(log_config: dict, keyvault: Keyvault) -> logging.Handler:
-    connection_string: str
-    try:
-        connection_string = keyvault.get_secret(
-            "application-insights-connection-string"
-        ).value
-    except KeyvaultError:
-        message: str = (
-            "CRITICAL ERROR: Missing connection string for"
-            f" Application Insights in key vault '{keyvault.name}'."
-        )
-        print(f"\n{message} \n")
-        raise ConfigurationError(message)
-
-    handler = AzureLogHandler(connection_string=connection_string)
-    handler.setLevel(log_config["root"]["level"])
-    return handler

isar/config/open_telemetry.py

@@ -0,0 +1,68 @@
+import logging
+
+from azure.identity import ManagedIdentityCredential
+from azure.monitor.opentelemetry.exporter import (
+    AzureMonitorLogExporter,
+    AzureMonitorTraceExporter,
+)
+from fastapi import FastAPI
+from opentelemetry import trace
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.resources import SERVICE_NAME, Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from isar.config.log import load_log_config
+from isar.config.settings import settings
+
+
+def setup_open_telemetry(app: FastAPI) -> None:
+    if not settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
+        return
+    trace_exporter, log_exporter = get_azure_monitor_exporters()
+
+    service_name = settings.OPEN_TELEMETRY_SERVICE_NAME
+    resource = Resource.create({SERVICE_NAME: service_name})
+
+    tracer_provider = TracerProvider(resource=resource)
+    tracer_provider.add_span_processor(BatchSpanProcessor(trace_exporter))
+    trace.set_tracer_provider(tracer_provider)
+
+    log_provider = LoggerProvider(resource=resource)
+    set_logger_provider(log_provider)
+    log_provider.add_log_record_processor(BatchLogRecordProcessor(log_exporter))
+
+    handler = LoggingHandler(logger_provider=log_provider)
+    attach_loggers_for_open_telemetry(handler)
+
+    FastAPIInstrumentor.instrument_app(app, tracer_provider=tracer_provider)
+
+
+def attach_loggers_for_open_telemetry(handler: LoggingHandler):
+    log_config = load_log_config()
+
+    for logger_name in log_config["loggers"].keys():
+        logger = logging.getLogger(logger_name)
+        logger.addHandler(handler)
+
+
+def get_azure_monitor_exporters() -> (
+    tuple[AzureMonitorTraceExporter, AzureMonitorLogExporter]
+):
+    """
+    If connection string is defined in environment variables, then use it to create Azure Monitor Exporters.
+    Else use Azure Managed Identity to create Azure Monitor Exporters.
+    """
+    connection_string = settings.APPLICATIONINSIGHTS_CONNECTION_STRING
+    if connection_string:
+        trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
+        log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
+    else:
+        credential = ManagedIdentityCredential()
+        trace_exporter = AzureMonitorTraceExporter(credential=credential)
+        log_exporter = AzureMonitorLogExporter(credential=credential)
+
+    return trace_exporter, log_exporter

isar/config/settings.py

@@ -12,6 +12,12 @@ from robot_interface.telemetry.payloads import DocumentInfo
 
 
 class Settings(BaseSettings):
+    # Name of the OpenTelemetry service
+    OPEN_TELEMETRY_SERVICE_NAME: str = Field(default="isar")
+    # Connection string for Azure Application Insights
+    # This is optional and it will use managed identity if not set
+    APPLICATIONINSIGHTS_CONNECTION_STRING: str = Field(default="")
+
     # Determines which robot package ISAR will attempt to import
     # Name must match with an installed python package in the local environment
     ROBOT_PACKAGE: str = Field(default="isar_robot")
@@ -52,6 +58,12 @@ class Settings(BaseSettings):
     # issues
     REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY: float = Field(default=10)
 
+    # Number of attempts for state transitions resume and pause if failed
+    STATE_TRANSITION_NUM_RETIRES: int = Field(default=10)
+
+    # Interval between attempt of state transition
+    STATE_TRANSITION_RETRY_INTERVAL_SEC: float = Field(default=1)
+
     # Number of attempts to stop the robot before giving up
     STOP_ROBOT_ATTEMPTS_LIMIT: int = Field(default=3)
 

isar/mission_planner/local_planner.py

@@ -2,8 +2,6 @@ import json
 import logging
 from pathlib import Path
 
-from dependency_injector.wiring import inject
-
 from isar.config.settings import settings
 from isar.mission_planner.mission_planner_interface import (
     MissionNotFoundError,
@@ -16,7 +14,6 @@ logger = logging.getLogger("api")
 
 
 class LocalPlanner(MissionPlannerInterface):
-    @inject
     def __init__(self):
         self.predefined_mission_folder = Path(settings.PREDEFINED_MISSIONS_FOLDER)
 

isar/models/communication/queues/events.py

@@ -35,7 +35,7 @@ class APIRequests:
 class StateMachineEvents:
     def __init__(self) -> None:
         self.start_mission: Queue[Mission] = Queue(maxsize=1)
-        self.stop_mission: Queue[bool] = Queue(maxsize=1)
+        self.stop_mission: Queue[str] = Queue(maxsize=1)
         self.pause_mission: Queue[bool] = Queue(maxsize=1)
         self.task_status_request: Queue[str] = Queue(maxsize=1)
 

isar/models/communication/queues/queue_utils.py

@@ -1,12 +1,12 @@
 from queue import Empty, Queue
-from typing import Optional, TypeVar
+from typing import Any, Optional, TypeVar
 
 from isar.models.communication.queues.status_queue import StatusQueue
 
 T = TypeVar("T")
 
 
-def trigger_event_without_data(queue: Queue[bool]) -> None:
+def trigger_event_without_data(queue: Queue[Any]) -> None:
     queue.put(True)
 
 

isar/robot/robot.py

@@ -3,8 +3,6 @@ from queue import Queue
 from threading import Event
 from typing import Optional
 
-from dependency_injector.wiring import inject
-
 from isar.models.communication.queues.events import (
     Events,
     RobotServiceEvents,
@@ -21,7 +19,6 @@ from robot_interface.robot_interface import RobotInterface
 
 
 class Robot(object):
-    @inject
     def __init__(
         self, events: Events, robot: RobotInterface, shared_state: SharedState
     ) -> None:

isar/script.py

@@ -8,6 +8,7 @@ from typing import Any, List, Tuple
 import isar
 from isar.apis.api import API
 from isar.config.log import setup_loggers
+from isar.config.open_telemetry import setup_open_telemetry
 from isar.config.settings import robot_settings, settings
 from isar.models.communication.queues.events import Events
 from isar.modules import ApplicationContainer, get_injector
@@ -83,6 +84,7 @@ def start() -> None:
 
     keyvault = injector.keyvault()
     setup_loggers(keyvault=keyvault)
+    setup_open_telemetry(app=injector.api().app)
     logger: Logger = logging.getLogger("main")
 
     print_startup_info()

isar/services/utilities/robot_utilities.py

@@ -1,7 +1,5 @@
 import logging
 
-from dependency_injector.wiring import inject
-
 from robot_interface.models.robots.media import MediaConfig
 from robot_interface.robot_interface import RobotInterface
 
@@ -11,7 +9,6 @@ class RobotUtilities:
     Contains utility functions for getting robot information from the API.
     """
 
-    @inject
     def __init__(
         self,
         robot: RobotInterface,

isar/services/utilities/scheduling_utilities.py

@@ -4,7 +4,6 @@ from http import HTTPStatus
 from queue import Empty
 from typing import Any, List
 
-from dependency_injector.wiring import inject
 from fastapi import HTTPException
 from requests import HTTPError
 
@@ -22,6 +21,7 @@ from isar.models.communication.queues.queue_timeout_error import QueueTimeoutErr
 from isar.services.utilities.queue_utilities import QueueUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import MissionStatus
 
 
 class SchedulingUtilities:
@@ -30,7 +30,6 @@ class SchedulingUtilities:
     required thread communication through queues to the state machine.
     """
 
-    @inject
     def __init__(
         self,
         events: Events,
@@ -219,15 +218,15 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.api_events.pause_mission)
+            response = self._send_command(True, self.api_events.pause_mission)
+            self.logger.info("OK - Mission successfully paused")
+            return response
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to pause mission"
             self.logger.error(error_message)
             raise HTTPException(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
             )
-        finally:
-            self.logger.info("OK - Mission successfully paused")
 
     def resume_mission(self) -> ControlMissionResponse:
         """Resume mission
@@ -238,28 +237,46 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            return self._send_command(True, self.api_events.resume_mission)
+            response = self._send_command(True, self.api_events.resume_mission)
+            self.logger.info("OK - Mission successfully resumed")
+            return response
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to resume mission"
             self.logger.error(error_message)
             raise HTTPException(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
             )
-        finally:
-            self.logger.info("OK - Mission successfully resumed")
 
-    def stop_mission(self) -> ControlMissionResponse:
+    def stop_mission(self, mission_id: str = "") -> ControlMissionResponse:
         """Stop mission
 
         Raises
         ------
-        HTTTPException 408 Request timeout
+        HTTPException 404 Not Found
+            If the mission_id was not known to Isar
+        HTTPException 503 Service Unavailable
+            The request was understood, but attempting to stop the mission failed
+        HTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
         """
         try:
             stop_mission_response: ControlMissionResponse = self._send_command(
-                True, self.api_events.stop_mission
+                mission_id, self.api_events.stop_mission
             )
+
+            if stop_mission_response.mission_not_found:
+                error_message = f"Mission ID {stop_mission_response.mission_id} is not currently running"
+                self.logger.error(error_message)
+                raise HTTPException(
+                    status_code=HTTPStatus.NOT_FOUND, detail=error_message
+                )
+
+            if stop_mission_response.mission_status != MissionStatus.Cancelled.value:
+                error_message = "Failed to stop mission"
+                self.logger.error(error_message)
+                raise HTTPException(
+                    status_code=HTTPStatus.CONFLICT, detail=error_message
+                )
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to stop mission"
             self.logger.error(error_message)

isar/state_machine/generic_states/idle.py

@@ -86,7 +86,7 @@ class Idle:
         return False
 
     def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
-        if check_for_event(event):
+        if check_for_event(event) is not None:
             self.state_machine.stop()  # type: ignore
             return True
         return False

isar/state_machine/generic_states/ongoing_mission.py

@@ -6,6 +6,7 @@ from queue import Queue
 from threading import Event
 from typing import TYPE_CHECKING, Optional, Tuple
 
+from isar.apis.models.models import ControlMissionResponse
 from isar.config.settings import settings
 from isar.models.communication.message import StartMissionMessage
 from isar.models.communication.queues.queue_utils import (
@@ -16,6 +17,7 @@ from isar.models.communication.queues.queue_utils import (
 from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
+    ErrorReason,
     RobotException,
     RobotRetrieveInspectionException,
 )
@@ -54,12 +56,24 @@ class OngoingMission:
         self._run()
 
     def stop(self) -> None:
-        self.state_machine.mission_ongoing = False
+        return
 
     def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
-        if check_for_event(event):
-            self.state_machine.stop()  # type: ignore
-            return True
+        mission_id: str = check_for_event(event)
+        if mission_id is not None:
+            if self.state_machine.current_mission.id == mission_id or mission_id == "":
+                self.state_machine.stop()  # type: ignore
+                return True
+            else:
+                self.events.api_requests.stop_mission.output.put(
+                    ControlMissionResponse(
+                        mission_id=mission_id,
+                        mission_status=self.state_machine.current_mission.status,
+                        mission_not_found=True,
+                        task_id=self.state_machine.current_task.id,
+                        task_status=self.state_machine.current_task.status,
+                    )
+                )
         return False
 
     def _check_and_handle_pause_mission_event(self, event: Queue) -> bool:
@@ -139,6 +153,10 @@ class OngoingMission:
 
             if self.state == OngoingMissionStates.ReturningHome:
                 if status != TaskStatus.Successful:
+                    self.state_machine.current_mission.error_message = ErrorMessage(
+                        error_reason=ErrorReason.RobotActionException,
+                        error_description="Return home failed.",
+                    )
                     self.state_machine.return_home_failed()  # type: ignore
                     return True
                 self.state_machine.returned_home()  # type: ignore
@@ -159,9 +177,6 @@ class OngoingMission:
                 self.state_machine.mission_finished()  # type: ignore
                 return True
 
-            # Report and update next task
-            self.state_machine.current_task.update_task_status()
-            self.state_machine.publish_task_status(task=self.state_machine.current_task)
         return False
 
     def _check_and_handle_start_mission_event(

isar/state_machine/state_machine.py

@@ -5,7 +5,6 @@ from datetime import datetime, timezone
 from threading import Event
 from typing import Deque, List, Optional
 
-from dependency_injector.wiring import inject
 from transitions import Machine
 from transitions.core import State
 
@@ -48,7 +47,6 @@ from robot_interface.utilities.json_service import EnhancedJSONEncoder
 class StateMachine(object):
     """Handles state transitions for supervisory robot control."""
 
-    @inject
     def __init__(
         self,
         events: Events,
@@ -194,6 +192,7 @@ class StateMachine(object):
         self.current_task = None
         self.send_task_status()
         self.current_mission = None
+        self.mission_ongoing = False
 
     def start_mission(self, mission: Mission):
         """Starts a scheduled mission."""
@@ -316,17 +315,13 @@ class StateMachine(object):
         self.logger.info("Mission overview:\n%s", log_statement)
 
     def _make_control_mission_response(self) -> ControlMissionResponse:
-        if self.current_mission is None:
-            raise ValueError("No current mission is set")
-
-        if self.current_task is None:
-            raise ValueError("No current task is set")
-
         return ControlMissionResponse(
-            mission_id=self.current_mission.id,
-            mission_status=self.current_mission.status,
-            task_id=self.current_task.id,
-            task_status=self.current_task.status,
+            mission_id=self.current_mission.id if self.current_mission else None,
+            mission_status=(
+                self.current_mission.status if self.current_mission else None
+            ),
+            task_id=self.current_task.id if self.current_task else None,
+            task_status=self.current_task.status if self.current_task else None,
         )
 
     def _queue_empty_response(self) -> None:

isar/state_machine/states/monitor.py

@@ -1,6 +1,5 @@
 from typing import TYPE_CHECKING
 
-from dependency_injector.wiring import inject
 from transitions import State
 
 from isar.state_machine.generic_states.ongoing_mission import (
@@ -13,7 +12,6 @@ if TYPE_CHECKING:
 
 
 class Monitor(State, OngoingMission):
-    @inject
     def __init__(self, state_machine: "StateMachine") -> None:
         State.__init__(self, name="monitor", on_enter=self.start, on_exit=self.stop)
 

isar/state_machine/states/stopping.py

@@ -39,9 +39,9 @@ class Stopping(State):
         if error_message is not None:
             self.logger.warning(error_message.error_description)
             if self.stopping_return_home_mission:
-                self.state_machine.return_home_mission_stopped()  # type: ignore
+                self.state_machine.return_home_mission_stopping_failed()  # type: ignore
             else:
-                self.state_machine.mission_stopped()  # type: ignore
+                self.state_machine.mission_stopping_failed()  # type: ignore
             return True
         return False
 

isar/state_machine/states/unknown_status.py

@@ -33,7 +33,7 @@ class UnknownStatus(State):
         return
 
     def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
-        if check_for_event(event):
+        if check_for_event(event) is not None:
             self.state_machine.stop()  # type: ignore
             return True
         return False

isar/state_machine/transitions/functions/pause.py

@@ -3,22 +3,51 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
+import time
+
 from isar.apis.models.models import ControlMissionResponse
+from isar.config.settings import settings
+from robot_interface.models.exceptions.robot_exceptions import (
+    RobotActionException,
+    RobotException,
+)
 from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def pause_mission(state_machine: "StateMachine") -> bool:
     state_machine.logger.info("Pausing mission: %s", state_machine.current_mission.id)
-    state_machine.current_mission.status = MissionStatus.Paused
-    state_machine.current_task.status = TaskStatus.Paused
 
-    paused_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
-    )
-    state_machine.events.api_requests.pause_mission.output.put(paused_mission_response)
+    max_retries = settings.STATE_TRANSITION_NUM_RETIRES
+    retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
+
+    for attempt in range(max_retries):
+        try:
+            state_machine.robot.pause()
+            state_machine.current_mission.status = MissionStatus.Paused
+            state_machine.current_task.status = TaskStatus.Paused
+
+            paused_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+            state_machine.events.api_requests.pause_mission.output.put(
+                paused_mission_response
+            )
+
+            state_machine.publish_mission_status()
+            state_machine.publish_task_status(task=state_machine.current_task)
 
-    state_machine.publish_mission_status()
-    state_machine.publish_task_status(task=state_machine.current_task)
+            state_machine.logger.info("Mission paused successfully.")
+            return True
+        except RobotActionException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause mission failed: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+        except RobotException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause mission raised a RobotException: {e.error_description}"
+            )
+            time.sleep(retry_interval)
 
-    state_machine.robot.pause()
-    return True
+    state_machine.logger.error("Failed to pause mission after multiple attempts.")
+    return False

isar/state_machine/transitions/functions/resume.py

@@ -3,25 +3,54 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
+import time
+
 from isar.apis.models.models import ControlMissionResponse
+from isar.config.settings import settings
+from robot_interface.models.exceptions.robot_exceptions import (
+    RobotActionException,
+    RobotException,
+)
 from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def resume_mission(state_machine: "StateMachine") -> bool:
     state_machine.logger.info("Resuming mission: %s", state_machine.current_mission.id)
-    state_machine.current_mission.status = MissionStatus.InProgress
-    state_machine.current_mission.error_message = None
-    state_machine.current_task.status = TaskStatus.InProgress
-
-    state_machine.mission_ongoing = True
-
-    state_machine.publish_mission_status()
-    state_machine.publish_task_status(task=state_machine.current_task)
-
-    resume_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
-    )
-    state_machine.events.api_requests.resume_mission.output.put(resume_mission_response)
 
-    state_machine.robot.resume()
-    return True
+    max_retries = settings.STATE_TRANSITION_NUM_RETIRES
+    retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
+
+    for attempt in range(max_retries):
+        try:
+            state_machine.robot.resume()
+            state_machine.current_mission.status = MissionStatus.InProgress
+            state_machine.current_mission.error_message = None
+            state_machine.current_task.status = TaskStatus.InProgress
+
+            state_machine.mission_ongoing = True
+
+            state_machine.publish_mission_status()
+            state_machine.publish_task_status(task=state_machine.current_task)
+
+            resume_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+            state_machine.events.api_requests.resume_mission.output.put(
+                resume_mission_response
+            )
+
+            state_machine.logger.info("Mission resumed successfully.")
+            return True
+        except RobotActionException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to resume mission failed: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+        except RobotException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to resume mission raised a RobotException: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+
+    state_machine.logger.error("Failed to resume mission after multiple attempts.")
+    return False

isar/state_machine/transitions/functions/stop.py

@@ -1,6 +1,9 @@
 from typing import TYPE_CHECKING
 
-from isar.models.communication.queues.queue_utils import trigger_event_without_data
+from isar.models.communication.queues.queue_utils import (
+    check_for_event_without_consumption,
+    trigger_event_without_data,
+)
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -39,11 +42,51 @@ def stop_mission_cleanup(state_machine: "StateMachine") -> bool:
     return True
 
 
+def stop_mission_failed(state_machine: "StateMachine") -> bool:
+    stopped_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.stop_mission.output.put(stopped_mission_response)
+    return True
+
+
 def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
     if state_machine.current_mission is None:
         state_machine._queue_empty_response()
         state_machine.reset_state_machine()
         return True
 
+    if not check_for_event_without_consumption(
+        state_machine.events.api_requests.start_mission.input
+    ):
+        state_machine.current_mission.status = MissionStatus.Cancelled
+
+        for task in state_machine.current_mission.tasks:
+            if task.status in [
+                TaskStatus.NotStarted,
+                TaskStatus.InProgress,
+                TaskStatus.Paused,
+            ]:
+                task.status = TaskStatus.Cancelled
+
+        stopped_mission_response: ControlMissionResponse = (
+            state_machine._make_control_mission_response()
+        )
+        state_machine.events.api_requests.stop_mission.output.put(
+            stopped_mission_response
+        )
+
     state_machine._finalize()
     return True
+
+
+def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
+    if check_for_event_without_consumption(
+        state_machine.events.api_requests.start_mission.input
+    ):
+        return True
+    stopped_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.stop_mission.output.put(stopped_mission_response)
+    return True

isar/state_machine/transitions/mission.py

@@ -15,7 +15,9 @@ from isar.state_machine.transitions.functions.start_mission import (
 )
 from isar.state_machine.transitions.functions.stop import (
     stop_mission_cleanup,
+    stop_mission_failed,
     stop_return_home_mission_cleanup,
+    stop_return_home_mission_failed,
     trigger_stop_mission_event,
 )
 from isar.state_machine.transitions.functions.utils import def_transition
@@ -30,13 +32,23 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "pause",
             "source": state_machine.monitor_state,
             "dest": state_machine.paused_state,
-            "before": def_transition(state_machine, pause_mission),
+            "conditions": def_transition(state_machine, pause_mission),
+        },
+        {
+            "trigger": "pause",
+            "source": state_machine.monitor_state,
+            "dest": state_machine.monitor_state,
         },
         {
             "trigger": "resume",
             "source": state_machine.paused_state,
             "dest": state_machine.monitor_state,
-            "before": def_transition(state_machine, resume_mission),
+            "conditions": def_transition(state_machine, resume_mission),
+        },
+        {
+            "trigger": "resume",
+            "source": state_machine.paused_state,
+            "dest": state_machine.paused_state,
         },
         {
             "trigger": "stop",
@@ -56,6 +68,18 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, stop_mission_cleanup),
         },
+        {
+            "trigger": "mission_stopping_failed",
+            "source": state_machine.stopping_state,
+            "dest": state_machine.monitor_state,
+            "before": def_transition(state_machine, stop_mission_failed),
+        },
+        {
+            "trigger": "return_home_mission_stopping_failed",
+            "source": state_machine.stopping_state,
+            "dest": state_machine.returning_home_state,
+            "before": def_transition(state_machine, stop_return_home_mission_failed),
+        },
         {
             "trigger": "return_home_mission_stopped",
             "source": state_machine.stopping_state,

isar/state_machine/transitions/return_home.py

@@ -63,7 +63,7 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "return_home_failed",
             "source": state_machine.returning_home_state,
             "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, return_home_finished),
+            "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
     ]
     return return_home_transitions

isar/storage/blob_storage.py

@@ -4,7 +4,6 @@ from typing import Union
 
 from azure.core.exceptions import ResourceExistsError
 from azure.storage.blob import BlobClient, BlobServiceClient, ContainerClient
-from dependency_injector.wiring import inject
 
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
@@ -15,7 +14,6 @@ from robot_interface.models.mission.mission import Mission
 
 
 class BlobStorage(StorageInterface):
-    @inject
     def __init__(
         self, keyvault: Keyvault, container_name: str = settings.BLOB_CONTAINER
     ) -> None:

isar/storage/uploader.py

@@ -6,8 +6,6 @@ from queue import Empty, Queue
 from threading import Event
 from typing import List, Union
 
-from dependency_injector.wiring import inject
-
 from isar.config.settings import settings
 from isar.models.communication.queues.events import Events
 from isar.storage.storage_interface import StorageException, StorageInterface
@@ -63,7 +61,6 @@ class BlobItem(UploaderQueueItem):
 
 
 class Uploader:
-    @inject
     def __init__(
         self,
         events: Events,

{isar-1.30.4.dist-info → isar-1.31.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.30.4
+Version: 1.31.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -113,9 +113,6 @@ Requires-Dist: fastapi-azure-auth
 Requires-Dist: fastapi
 Requires-Dist: dependency-injector
 Requires-Dist: numpy
-Requires-Dist: opencensus-ext-azure
-Requires-Dist: opencensus-ext-logging
-Requires-Dist: opencensus-ext-requests
 Requires-Dist: paho-mqtt
 Requires-Dist: pydantic_settings
 Requires-Dist: pydantic
@@ -126,6 +123,12 @@ Requires-Dist: requests-toolbelt
 Requires-Dist: requests
 Requires-Dist: transitions
 Requires-Dist: uvicorn
+Requires-Dist: opentelemetry-api
+Requires-Dist: opentelemetry-sdk
+Requires-Dist: opentelemetry-exporter-otlp
+Requires-Dist: opentelemetry-instrumentation-fastapi
+Requires-Dist: azure-monitor-opentelemetry
+Requires-Dist: azure-monitor-opentelemetry-exporter>=1.0.0b38
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: isort; extra == "dev"

{isar-1.30.4.dist-info → isar-1.31.0.dist-info}/RECORD

@@ -1,21 +1,22 @@
 isar/__init__.py,sha256=cH8p8bVveu3FUL6kBhldcSlLaoHgD82Kd0-SwSNfGXw,87
 isar/modules.py,sha256=QBB1pge1i17HVMLA5n-qd9K3APCrX9bFF2vlfjheOhU,4778
-isar/script.py,sha256=0oUUfytKDOsWrPv4iWemTWl5L3Ug66mQsbvqGqQrVWk,6050
+isar/script.py,sha256=OC0O3y5HO5OAstg7g-tLKgF7mulKfglkpztDRk9PvT0,6159
 isar/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/api.py,sha256=2hggLxcdsHqTYDAfVUMwMIBgpuB-0ba2HWMscHkRGzA,15072
+isar/apis/api.py,sha256=B0fVZPKtnvrxzk48xoazGPYsJVjjBH4IL6glDJ3PGWI,13328
 isar/apis/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/models/models.py,sha256=HzLaWhjAv0uJRBWipIgYg_F75eaQ5jl9Pi4UnYbDJ-M,1749
-isar/apis/models/start_mission_definition.py,sha256=S87i_vrgXTY1nTMTiXMJAnx_q5uVxuiRNcrQrAYWKeo,6152
-isar/apis/robot_control/robot_controller.py,sha256=7EVukShJDhYez12wYeGWZXH-BrfQ4Wu2so0-fSWN2Zo,1277
+isar/apis/models/models.py,sha256=GMOss2C8lBeRFV7E37mLwSOM6RhiyLQLcLBRzm_51d4,1835
+isar/apis/models/start_mission_definition.py,sha256=m9M5dZCmvRM1b4N8xYGquCSplSr4GDk376s2QoVL8F4,6231
+isar/apis/robot_control/robot_controller.py,sha256=0EHjMqOBdfJlMrCItGPz5X-4X2kc-2XlNnUU2LOcLfc,1219
 isar/apis/schedule/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/schedule/scheduling_controller.py,sha256=ggoWjYKxgMwJ5trs8gsU8SGj6CQlmb7Ee1SjRg7hSTw,9671
+isar/apis/schedule/scheduling_controller.py,sha256=yQM2HMgelBnbkzPR_tLHOY2EbThUcSO5jMA6Xtp5FQA,9915
 isar/apis/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/apis/security/authentication.py,sha256=Se2puhe2TUBmfio2RLma52-VSLRhqvWgu0Cd1bhdwMo,2000
 isar/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/config/configuration_error.py,sha256=rO6WOhafX6xvVib8WxV-eY483Z0PpN-9PxGsq5ATfKc,46
-isar/config/log.py,sha256=SzEWbzXU1DpN7YONIRT8k0zBOGm_qVkXlJuuZtb8STc,2300
+isar/config/log.py,sha256=_zeHrsI4XqoHc1Um50PLHFjlwGiClM_M5CzcXoqwZuY,1380
 isar/config/logging.conf,sha256=mYO1xf27gAopEMHhGzY7-mwyfN16rwRLkPNMvy3zn2g,1127
-isar/config/settings.py,sha256=dn9fEKX7GpzD9Y7q0TjQxW9Xf0iY-pCl3NV7bkxH1E8,12487
+isar/config/open_telemetry.py,sha256=7hO6lR4lgK3IRZVh0a4shxIuamyt9paLM6d_FwXw5OY,2661
+isar/config/settings.py,sha256=-fBxs0TUGmoCX4nF1Rwg0YMZ-WQ6qsqFZpWHxqwOrlk,13029
 isar/config/certs/ca-cert.pem,sha256=qoNljfad_qcMxhXJIUMLd7nT-Qwf_d4dYSdoOFEOE8I,2179
 isar/config/keyvault/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/config/keyvault/keyvault_error.py,sha256=zvPCsZLjboxsxthYkxpRERCTFxYV8R5WmACewAUQLwk,41
@@ -35,7 +36,7 @@ isar/config/predefined_missions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 isar/config/predefined_missions/default.json,sha256=NWo9y5noPmpjlNUxLnZK95Sz7DIEaUR-ISYlw3MP8i0,1251
 isar/config/predefined_missions/default_turtlebot.json,sha256=8Vk1_0P0BBsG0vwh4vwIYINiiWioErHZ0Ppjq3ctaPM,2143
 isar/mission_planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/mission_planner/local_planner.py,sha256=6JxAR_V2JB-pVzZ8xajRa1tlKO3d3x-5oe-5NodgkvU,2579
+isar/mission_planner/local_planner.py,sha256=Mkg3vvUBF1jImfQnaFvXLNpKVadR21X4mwDd_wHqJ2w,2520
 isar/mission_planner/mission_planner_interface.py,sha256=UgpPIM4FbrWOD7fGY3Ul64k3uYb8wo0FwSWGewYoVbc,485
 isar/mission_planner/sequential_task_selector.py,sha256=66agRPHuJnEa1vArPyty4muTasAZ50XPjjrSaTdY_Cc,643
 isar/mission_planner/task_selector_interface.py,sha256=pnLeaGPIuyXThcflZ_A7YL2b2xQjFT88hAZidkMomxU,707
@@ -43,13 +44,13 @@ isar/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/models/communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/models/communication/message.py,sha256=ge2EdUXRnYkiEu5TIAYJFQET_5w-N8MRgc2Y31vetno,155
 isar/models/communication/queues/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/models/communication/queues/events.py,sha256=o_oMos8Md6aTv91ymRNY0fNDWwj5QxWcBm6rxHQz5TY,2413
+isar/models/communication/queues/events.py,sha256=mZt1ZarqmyDW_y42w7aD1Iv-m7HLwrpUyOh3pM4w79Q,2412
 isar/models/communication/queues/queue_io.py,sha256=AnHWUCkZ0tunkxKKeBarq-OUkRM97IaMfA-a1pmf1cQ,394
 isar/models/communication/queues/queue_timeout_error.py,sha256=rF8TlNF7RHS_ueTZ5mp7aFkhLY1j0dcwMwH-Ba6lVpE,45
-isar/models/communication/queues/queue_utils.py,sha256=wg6bIR3NS35Ek9hnGR5eN8z6i0jd5tOwM-8l30h3uiA,868
+isar/models/communication/queues/queue_utils.py,sha256=3kw7LxMVxCUM7JF7DVQgxbiUzMBMtVa8nwfpr7xDSGc,872
 isar/models/communication/queues/status_queue.py,sha256=on8kvlNsG6MJjEVsyqtBswIpmOdOggQiKr7F5x0T3jw,514
 isar/models/mission_metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/robot/robot.py,sha256=h-Z_1xCACekHvaj-vPJAhdzixSlcW4zMpe9__ui0zv8,5490
+isar/robot/robot.py,sha256=MmdrJzC4U_dGK3NLA6vgGNi0awNQwFvsPDsr9030fso,5431
 isar/robot/robot_start_mission.py,sha256=vQKsKnrWQuY70jEK-qeeaZYpXxQH4vElorczYZheXTQ,3423
 isar/robot/robot_status.py,sha256=FpkTIAA-O5vKuyU7fnWn2YXtbstq5qbk9XSxbn_0MXU,2015
 isar/robot/robot_stop_mission.py,sha256=jUyfemvbyigxrlIp9aKPn-PvarhagJEgajQPS_LgJ7g,2442
@@ -66,47 +67,47 @@ isar/services/service_connections/mqtt/robot_info_publisher.py,sha256=AxokGk51hR
 isar/services/service_connections/stid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/utilities/queue_utilities.py,sha256=Pw3hehSwkXJNeDv-bDVDfs58VOwtt3i5hpiJ2ZpphuQ,1225
-isar/services/utilities/robot_utilities.py,sha256=J3miRs0t74HNBoMIzVMceMCibp5DozP9Ai1_i7B3kWI,573
-isar/services/utilities/scheduling_utilities.py,sha256=SVmpAuU7101FVUx6x4tcMDrxYaWBPhgOkntFxX_d6Zc,10179
+isar/services/utilities/robot_utilities.py,sha256=4zCigsLXfqDC8POHchktSq81zr1_pTaRve_LQsVr6Mk,514
+isar/services/utilities/scheduling_utilities.py,sha256=eXeTEe4JmP2mgVd77DC5SLGTPjpG6O9IhN330dAyh-4,11122
 isar/services/utilities/threaded_request.py,sha256=py4G-_RjnIdHljmKFAcQ6ddqMmp-ZYV39Ece-dqRqjs,1874
 isar/state_machine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/state_machine/state_machine.py,sha256=onPjxGqDGSSvjHxCosKxIyiTw0X01FLwJX9rJArqfXg,13152
+isar/state_machine/state_machine.py,sha256=6rksxhG4OLoZYfRSB5wfpqHXQUperbRjqwnY-6ue8Gk,13099
 isar/state_machine/states_enum.py,sha256=Z3dO6k6JmQAZ1lzcR58oVCxoCky_-ZS9MaL3RSaNbZ4,434
-isar/state_machine/generic_states/idle.py,sha256=T_LSadQ8Eu9egYPgL43WKDYv27MwFu-dqIxDazVE_KU,4359
-isar/state_machine/generic_states/ongoing_mission.py,sha256=NTYQIddTG0Nsq_ZjcWWBSe9KsQp_7zQcKH_0HYW18SQ,10850
+isar/state_machine/generic_states/idle.py,sha256=uXVHtKeX3jPZC7iVmic1sKD6nLtSOVynrHNiUCdTDcw,4371
+isar/state_machine/generic_states/ongoing_mission.py,sha256=ns6mbaSJvjM7JAbl1txPA9VdjxTv4iWKGbdYahtTtGc,11571
 isar/state_machine/generic_states/robot_unavailable.py,sha256=pHmed1uRPwCWAR4uBJmdnxi9WX8veTbGG9ephmROhm0,1851
 isar/state_machine/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/state_machine/states/await_next_mission.py,sha256=U0oGi-O05S-ZvdhpQRuirrY3ZBbblURo5U95PsscMlQ,573
 isar/state_machine/states/blocked_protective_stop.py,sha256=KDux2lm5kwEEarnDt9FG4MFrWbYUzs1_DX5hu2ILIlI,675
 isar/state_machine/states/home.py,sha256=2v7BFQn4QZ0npOrXpWLWCoHD5IpSyAJr-vQCS3MQWJs,514
-isar/state_machine/states/monitor.py,sha256=1PMirQaaQa_V-DEmbv-4dqlrB5q_XTg1Q1Gt--F1Bgw,655
+isar/state_machine/states/monitor.py,sha256=BVrfZb-EWIdNYTC75F8HCi_OOtjBYbphrwki98p1WdE,597
 isar/state_machine/states/offline.py,sha256=vZnBMVDnehZ-0gPsHNVRpZtb8OBBFkeEnq2olo_Ep6M,609
 isar/state_machine/states/paused.py,sha256=IgnWBM6WXj3wjFZMARAPWIpzWGyUSW35DVBvNHuiNP8,1460
 isar/state_machine/states/returning_home.py,sha256=BBQo3PoNP-THlvJa5gQr0fNBhInh_Ox1L2OeH8evUq8,638
 isar/state_machine/states/robot_standing_still.py,sha256=RbOZSiQz72tWAJID5ksgzcb4lND6OniiG35IE1wMUHk,579
-isar/state_machine/states/stopping.py,sha256=Y44kEw-xB9_63eP6utAMY0RegrIz_1nL5cSI3cfaXEg,2838
-isar/state_machine/states/unknown_status.py,sha256=tOwfHW_4bKKkUTpKD7qc5gIwGT_fTXaCNxXcogGw-wo,2416
-isar/state_machine/transitions/mission.py,sha256=Sb_D9i1orV_I_eCDI0c8ZvhCU89peUqTfHI5-G36d08,4905
-isar/state_machine/transitions/return_home.py,sha256=LeOMnckUUQYzBYRidD2ge6M0KdxGDTgo-ioXR7_9r8A,2714
+isar/state_machine/states/stopping.py,sha256=yJE7KT1aGo_qd1VTETfg1rTrlM-hKKQYKQp7xu4py_Y,2854
+isar/state_machine/states/unknown_status.py,sha256=qfIoL5f7Hj-aZKq5tCM1FctkuEI6SwgpQuixzKx11Zk,2428
+isar/state_machine/transitions/mission.py,sha256=Lsiee_hSn5wd7KWpmvIdaG-49f6HGdkCdiXAo5L0ciE,5803
+isar/state_machine/transitions/return_home.py,sha256=6aBpKpozT48RJ__w13gv-r7dSz-fEOCzkAuKq5Hwm6k,2728
 isar/state_machine/transitions/robot_status.py,sha256=c1ceyWRGCtx-KTDtxHXRD7oPbt8TQ2ej24A0wyim8vc,2720
 isar/state_machine/transitions/functions/fail_mission.py,sha256=_6HqBMALDinFZ4yh5GMpeqqgV5tw5i8OVMj5UDdqesg,495
 isar/state_machine/transitions/functions/finish_mission.py,sha256=TRQrk7HdllmAkwsp25HRZAFAk46Y1hLx3jmkIAKrHDI,1442
-isar/state_machine/transitions/functions/pause.py,sha256=aoDkq2nV6wBY0YQX3KbjvBR1ojP2o_SCRT_gfz0BulI,889
-isar/state_machine/transitions/functions/resume.py,sha256=9KQjH_6YBGyxFhb7G5dgDe3WH0xHawhEIw6yTVEm9os,998
+isar/state_machine/transitions/functions/pause.py,sha256=oaIFd4aZnbeaHb-EGQE9ozJctskqXKsRKkNc68M8sp0,1975
+isar/state_machine/transitions/functions/resume.py,sha256=HgAEn4jQOPkVPWWZCAh7dqnIerdF8nGcgFcZ1KsCNSQ,2104
 isar/state_machine/transitions/functions/return_home.py,sha256=UlniwYvpz74hxqgN0TyVv3LCmiMsqsosKEtEGLqkNj0,1139
 isar/state_machine/transitions/functions/robot_status.py,sha256=xhKZ5u_X8uDvnhvGnAIABuKaPXeVqFjkgj4H2Om-j_A,1013
 isar/state_machine/transitions/functions/start_mission.py,sha256=ricRfhLH1_lNpqWxneMZcm7ps2YfY6sQGHkiT0Glf6M,2564
-isar/state_machine/transitions/functions/stop.py,sha256=aIj3EPnpgNLdsJwOK1ehhI1TpenQa9JjBxZH0Nm6dLg,1649
+isar/state_machine/transitions/functions/stop.py,sha256=JK4hjGc3QtgSzvCWeOr1YG61SH1QOhmVNjw_jOnahQg,3123
 isar/state_machine/transitions/functions/utils.py,sha256=Wa72Ocq4QT1E6qkpEJZQ3h5o33pGvx7Tlkt2JZ2Grbk,314
 isar/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/storage/blob_storage.py,sha256=Qci6bO508nlTHKPuPtVU5QcvGA4T7mv8cFrKWRcfw4g,3226
+isar/storage/blob_storage.py,sha256=D67y3Z939iXoRxs8npOuKOhgs2o6dYz2ivTm5IXXhJE,3168
 isar/storage/local_storage.py,sha256=Bnmoi5gyN8r-oRh0aHrOdGqaH3JqRScFKMRXYojW5kY,1855
 isar/storage/storage_interface.py,sha256=DYDry4I7aZpDHJhsBF6s8zrgokFAc7fdKJKfA8AvL7o,828
-isar/storage/uploader.py,sha256=HAC3ssuPQCQ1xH4aTQfHIaq-ZoEzKwONWmsAOpNXOzw,9523
+isar/storage/uploader.py,sha256=1F4M34aVnD828WV62muTIE04vj3D52lrTOOh8r6SgwA,9464
 isar/storage/utilities.py,sha256=oLH0Rp7UtrQQdilfITnmXO1Z0ExdeDhBImYHid55vBA,3449
-isar-1.30.4.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
+isar-1.31.0.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
 robot_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/robot_interface.py,sha256=Miout0IRX7QniUNu_upyNzkB8KDUWin7GGCqIeMh83E,8195
+robot_interface/robot_interface.py,sha256=-jCAKkZ2eiyzUyHVQmOzw4hMgLWR7pE8MHj-WZo85ZY,7978
 robot_interface/test_robot_interface.py,sha256=FV1urn7SbsMyWBIcTKjsBwAG4IsXeZ6pLHE0mA9EGGs,692
 robot_interface/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -117,7 +118,7 @@ robot_interface/models/inspection/inspection.py,sha256=2T8czQcNt9J1M96tKGQA6P3s5
 robot_interface/models/mission/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/mission/mission.py,sha256=MQ9p5cuclLXexaZu9bkDh5-aN99eunvYC0vP-Z_kUwI,960
 robot_interface/models/mission/status.py,sha256=UOCARLfLxLFXJEjfIH7aXYXO7xajOKBJsxz-Wd6gZQ4,740
-robot_interface/models/mission/task.py,sha256=7g4Xu-2yn3A7JVqrqg-XHHIX1uwYuIrRB00GrOchjio,4820
+robot_interface/models/mission/task.py,sha256=YzaqJ_KIIm-3S2Y2-BG4Pdkc8sjFMzMx5jj8FtXSmFg,4744
 robot_interface/models/robots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/robots/battery_state.py,sha256=ktOtJ8ltdK0k_i7BoqYfhc5dbOzIG6Oo-uWC67fCWio,98
 robot_interface/models/robots/media.py,sha256=8A-CuuubfngzPprs6zWB9hSaqe3jzgsE8rcCzRX2Uto,227
@@ -128,8 +129,8 @@ robot_interface/telemetry/payloads.py,sha256=PpvmV7XeGgfhc_aRUYFOdwBTwV2x8TwTBIN
 robot_interface/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/utilities/json_service.py,sha256=qkzVkb60Gi_pto-b5n1vNzCrQze2yqgIJqSLNLYj1Fg,1034
 robot_interface/utilities/uuid_string_factory.py,sha256=_NQIbBQ56w0qqO0MUDP6aPpHbxW7ATRhK8HnQiBSLkc,76
-isar-1.30.4.dist-info/METADATA,sha256=SaISJES198lknEfIqlqwrZ1CZe4A0vzi_mKYuu1fZrU,31063
-isar-1.30.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isar-1.30.4.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.30.4.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.30.4.dist-info/RECORD,,
+isar-1.31.0.dist-info/METADATA,sha256=RZo3tvmuEPeEdu1CQeqgKAQyWysrlJExNPMVn8zjqPs,31217
+isar-1.31.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isar-1.31.0.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
+isar-1.31.0.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
+isar-1.31.0.dist-info/RECORD,,

robot_interface/models/mission/task.py

@@ -50,9 +50,6 @@ class Task(BaseModel):
             return True
         return False
 
-    def update_task_status(self) -> TaskStatus:
-        return self.status
-
 
 class InspectionTask(Task):
     """

robot_interface/robot_interface.py

@@ -221,10 +221,7 @@ class RobotInterface(metaclass=ABCMeta):
     @abstractmethod
     def robot_status(self) -> RobotStatus:
         """
-        Method which returns an enum indicating if the robot package is able to reach
-        the interface which is used to communicate with the robot. This is further used
-        by ISAR to indicate whether the ISAR instance is fully functional and may be
-        used by other systems.
+        Method which returns an enum indicating the status of the robot.
 
         Returns
         -------