isar 1.33.2__py3-none-any.whl → 1.33.4__py3-none-any.whl

isar/apis/schedule/scheduling_controller.py

@@ -115,6 +115,7 @@ class SchedulingController:
 
         if state not in [
             States.Monitor,
+            States.ReturningHome,
         ]:
             error_message = (
                 f"Conflict - Pause command received in invalid state - State: {state}"
@@ -135,7 +136,7 @@ class SchedulingController:
 
         state: States = self.scheduling_utilities.get_state()
 
-        if state != States.Paused:
+        if state not in [States.Paused, States.ReturnHomePaused]:
             error_message = (
                 f"Conflict - Resume command received in invalid state - State: {state}"
             )
@@ -167,6 +168,7 @@ class SchedulingController:
             or state == States.BlockedProtectiveStop
             or state == States.Offline
             or state == States.Home
+            or state == States.ReturningHome
         ):
             error_message = (
                 f"Conflict - Stop command received in invalid state - State: {state}"

isar/services/service_connections/mqtt/mqtt_client.py

@@ -106,15 +106,15 @@ class MqttClient(MqttClientInterface):
             )
 
     def on_connect(self, client, userdata, flags, reason_code, properties):
-        self.logger.info(
-            "Connection returned result: " + mqtt.connack_string(reason_code)
-        )
-
-    def on_disconnect(self, client, userdata, reason_code, properties):
-        if reason_code != 0:
-            self.logger.warning(
-                f"Unexpected disconnection from MQTT Broker, {reason_code}"
-            )
+        self.logger.info(f"Connected: {reason_code}")
+
+    def on_disconnect(self, client, userdata, *args):
+        if not args:
+            return
+        reason_code = args[0] if len(args) < 3 else args[1]
+        rc = getattr(reason_code, "value", reason_code)
+        if rc != 0:
+            self.logger.warning(f"Unexpected disconnect: {reason_code}.")
 
     @backoff.on_exception(
         backoff.expo,

isar/services/utilities/scheduling_utilities.py

@@ -129,13 +129,13 @@ class SchedulingUtilities:
         ------
         HTTPException 409 Conflict
             If state machine is not home, robot standing still, awaiting next mission
-            or returning home and therefore cannot start a new mission
+            return home paused or returning home and therefore cannot start a new mission
         """
         if (
-            state == States.RobotStandingStill
-            or state == States.Home
+            state == States.Home
             or state == States.AwaitNextMission
             or state == States.ReturningHome
+            or state == States.ReturnHomePaused
         ):
             return True
 
@@ -154,11 +154,7 @@ class SchedulingUtilities:
             If state machine is not home, robot standing still or awaiting next mission
             and therefore cannot start a new return home mission
         """
-        if (
-            state == States.RobotStandingStill
-            or state == States.Home
-            or state == States.AwaitNextMission
-        ):
+        if state == States.Home or state == States.AwaitNextMission:
             return True
 
         error_message = f"Conflict - Robot is not home, robot standing still or awaiting next mission - State: {state}"
@@ -336,7 +332,7 @@ class SchedulingUtilities:
             )
 
     def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
-        if api_event.request.has_event() or api_event.response.has_event():
+        if api_event.request.has_event():
             raise EventConflictError("API event has already been sent")
 
         try:

isar/state_machine/state_machine.py

@@ -24,9 +24,10 @@ from isar.state_machine.states.monitor import Monitor
 from isar.state_machine.states.offline import Offline
 from isar.state_machine.states.paused import Paused
 from isar.state_machine.states.recharging import Recharging
+from isar.state_machine.states.return_home_paused import ReturnHomePaused
 from isar.state_machine.states.returning_home import ReturningHome
-from isar.state_machine.states.robot_standing_still import RobotStandingStill
 from isar.state_machine.states.stopping import Stopping
+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
 from isar.state_machine.transitions.mission import get_mission_transitions
@@ -101,11 +102,12 @@ class StateMachine(object):
         self.returning_home_state: State = ReturningHome(self)
         self.stopping_state: State = Stopping(self)
         self.paused_state: State = Paused(self)
+        self.return_home_paused_state: State = ReturnHomePaused(self)
+        self.stopping_return_home_state: State = StoppingReturnHome(self)
 
         # States Waiting for mission
         self.await_next_mission_state: State = AwaitNextMission(self)
         self.home_state: State = Home(self)
-        self.robot_standing_still_state: State = RobotStandingStill(self)
         self.intervention_needed_state: State = InterventionNeeded(self)
 
         # Status states
@@ -120,10 +122,11 @@ class StateMachine(object):
             self.monitor_state,
             self.returning_home_state,
             self.stopping_state,
+            self.stopping_return_home_state,
             self.paused_state,
+            self.return_home_paused_state,
             self.await_next_mission_state,
             self.home_state,
-            self.robot_standing_still_state,
             self.offline_state,
             self.blocked_protective_stopping_state,
             self.unknown_status_state,
@@ -363,11 +366,12 @@ class StateMachine(object):
         )
 
     def _current_status(self) -> RobotStatus:
-        if (
-            self.current_state == States.RobotStandingStill
-            or self.current_state == States.AwaitNextMission
-        ):
+        if self.current_state == States.AwaitNextMission:
             return RobotStatus.Available
+        elif self.current_state == States.ReturnHomePaused:
+            return RobotStatus.ReturnHomePaused
+        elif self.current_state == States.Paused:
+            return RobotStatus.Paused
         elif self.current_state == States.Home:
             return RobotStatus.Home
         elif self.current_state == States.ReturningHome:

isar/state_machine/states/home.py

@@ -1,9 +1,9 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     return_home_event_handler,
-    robot_status_event_handler,
     start_mission_event_handler,
     stop_mission_event_handler,
 )
@@ -19,6 +19,17 @@ class Home(EventHandlerBase):
         events = state_machine.events
         shared_state = state_machine.shared_state
 
+        def _robot_status_event_handler(
+            event: Event[RobotStatus],
+        ) -> Optional[Callable]:
+            robot_status: RobotStatus = event.check()
+            if not (
+                robot_status == RobotStatus.Available
+                or robot_status == RobotStatus.Home
+            ):
+                return state_machine.robot_status_changed  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -40,9 +51,7 @@ class Home(EventHandlerBase):
             EventHandlerMapping(
                 name="robot_status_event",
                 event=shared_state.robot_status,
-                handler=lambda event: robot_status_event_handler(
-                    state_machine, RobotStatus.Home, event
-                ),
+                handler=_robot_status_event_handler,
             ),
         ]
         super().__init__(

isar/state_machine/states/paused.py

@@ -1,6 +1,8 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List, Optional
 
+from isar.config.settings import settings
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -10,6 +12,22 @@ class Paused(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
         events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if battery_level < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                state_machine.publish_mission_aborted(
+                    "Robot battery too low to continue mission", True
+                )
+                state_machine._finalize()
+                state_machine.logger.warning(
+                    "Cancelling current mission due to low battery"
+                )
+                return state_machine.stop  # type: ignore
+            return None
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
@@ -22,6 +40,11 @@ class Paused(EventHandlerBase):
                 event=events.api_requests.resume_mission.request,
                 handler=lambda event: state_machine.resume if event.consume_event() else None,  # type: ignore
             ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
         ]
         super().__init__(
             state_name="paused",

isar/state_machine/states/return_home_paused.py

@@ -0,0 +1,66 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import MissionStartResponse
+from isar.config.settings import settings
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class ReturnHomePaused(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if battery_level < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                return state_machine.resume  # type: ignore
+            return None
+
+        def _start_mission_event_handler(
+            event: Event[Mission],
+        ) -> Optional[Callable]:
+            if event.has_event():
+                if not state_machine.battery_level_is_above_mission_start_threshold():
+                    state_machine.events.api_requests.start_mission.request.consume_event()
+                    response = MissionStartResponse(
+                        mission_id=None,
+                        mission_started=False,
+                        mission_not_started_reason="Robot battery too low",
+                    )
+                    state_machine.events.api_requests.start_mission.response.trigger_event(
+                        response
+                    )
+                    return None
+                return state_machine.stop_return_home  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="resume_return_home_event",
+                event=events.api_requests.resume_mission.request,
+                handler=lambda event: state_machine.resume if event.consume_event() else None,  # type: ignore
+            ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.request,
+                handler=_start_mission_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="return_home_paused",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/returning_home.py

@@ -6,7 +6,6 @@ from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     mission_failed_event_handler,
     mission_started_event_handler,
-    stop_mission_event_handler,
     task_status_event_handler,
     task_status_failed_event_handler,
 )
@@ -24,6 +23,11 @@ class ReturningHome(EventHandlerBase):
         self.failed_return_home_attemps: int = 0
         events = state_machine.events
 
+        def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+                return state_machine.pause  # type: ignore
+            return None
+
         def _handle_task_completed(status: TaskStatus):
             if status != TaskStatus.Successful:
                 state_machine.current_mission.error_message = ErrorMessage(
@@ -43,6 +47,7 @@ class ReturningHome(EventHandlerBase):
         ) -> Optional[Callable]:
             if event.has_event():
                 if not state_machine.battery_level_is_above_mission_start_threshold():
+                    state_machine.events.api_requests.start_mission.request.consume_event()
                     response = MissionStartResponse(
                         mission_id=None,
                         mission_started=False,
@@ -52,14 +57,14 @@ class ReturningHome(EventHandlerBase):
                         response
                     )
                     return None
-                return state_machine.stop  # type: ignore
+                return state_machine.stop_return_home  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
-                name="stop_mission_event",
-                event=events.api_requests.stop_mission.request,
-                handler=lambda event: stop_mission_event_handler(state_machine, event),
+                name="pause_mission_event",
+                event=events.api_requests.pause_mission.request,
+                handler=_pause_mission_event_handler,
             ),
             EventHandlerMapping(
                 name="mission_started_event",

isar/state_machine/states/stopping.py

@@ -1,4 +1,3 @@
-import logging
 from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.apis.models.models import ControlMissionResponse
@@ -14,7 +13,6 @@ if TYPE_CHECKING:
 class Stopping(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
-        logger = logging.getLogger("state_machine")
         events = state_machine.events
 
         def _stop_mission_cleanup() -> None:
@@ -48,30 +46,15 @@ class Stopping(EventHandlerBase):
         ) -> Optional[Callable]:
             error_message: Optional[ErrorMessage] = event.consume_event()
             if error_message is not None:
-                logger.warning(error_message.error_description)
-                if (
-                    state_machine.current_mission is not None
-                    and state_machine.current_mission._is_return_to_home_mission()
-                ):
-                    return state_machine.return_home_mission_stopping_failed  # type: ignore
-                else:
-                    return state_machine.mission_stopping_failed  # type: ignore
+                return state_machine.mission_stopping_failed  # type: ignore
             return None
 
         def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
             if event.consume_event():
-                if (
-                    state_machine.current_mission is not None
-                    and state_machine.current_mission._is_return_to_home_mission()
-                ):
-                    return state_machine.return_home_mission_stopped  # type: ignore
-                else:
-                    _stop_mission_cleanup()
-                    if (
-                        not state_machine.battery_level_is_above_mission_start_threshold()
-                    ):
-                        return state_machine.request_return_home  # type: ignore
-                    return state_machine.mission_stopped  # type: ignore
+                _stop_mission_cleanup()
+                if not state_machine.battery_level_is_above_mission_start_threshold():
+                    return state_machine.request_return_home  # type: ignore
+                return state_machine.mission_stopped  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [

isar/state_machine/states/stopping_return_home.py

@@ -0,0 +1,73 @@
+import logging
+from typing import TYPE_CHECKING, Callable, 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 robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingReturnHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        logger = logging.getLogger("state_machine")
+        events = state_machine.events
+
+        def _failed_stop_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+            if error_message is not None:
+                logger.warning(error_message.error_description)
+                mission: 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",
+                    )
+                )
+                return state_machine.return_home_mission_stopping_failed  # type: ignore
+            return None
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+                mission: Mission = (
+                    state_machine.events.api_requests.start_mission.request.consume_event()
+                )
+
+                state_machine.reset_state_machine()
+
+                if mission:
+                    state_machine.start_mission(mission=mission)
+                    return state_machine.request_mission_start  # type: ignore
+
+                state_machine.logger.error(
+                    "Stopped return home without a new mission to start"
+                )
+                return state_machine.request_return_home  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=_failed_stop_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=_successful_stop_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states_enum.py

@@ -5,10 +5,11 @@ class States(str, Enum):
     Monitor = "monitor"
     ReturningHome = "returning_home"
     Stopping = "stopping"
+    StoppingReturnHome = "stopping_return_home"
     Paused = "paused"
+    ReturnHomePaused = "return_home_paused"
     AwaitNextMission = "await_next_mission"
     Home = "home"
-    RobotStandingStill = "robot_standing_still"
     Offline = "offline"
     BlockedProtectiveStop = "blocked_protective_stop"
     UnknownStatus = "unknown_status"

isar/state_machine/transitions/functions/pause.py

@@ -51,3 +51,41 @@ def pause_mission(state_machine: "StateMachine") -> bool:
 
     state_machine.logger.error("Failed to pause mission after multiple attempts.")
     return False
+
+
+def pause_return_home_mission(state_machine: "StateMachine") -> bool:
+    state_machine.logger.info("Pausing return home misson")
+
+    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.response.trigger_event(
+                paused_mission_response
+            )
+
+            state_machine.logger.info("Return home mission paused successfully.")
+            return True
+        except RobotActionException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause return home mission failed: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+        except RobotException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause return home mission raised a RobotException: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+
+    state_machine.logger.error(
+        "Failed to pause return home mission after multiple attempts."
+    )
+    return False

isar/state_machine/transitions/functions/robot_status.py

@@ -11,14 +11,9 @@ def is_offline(state_machine: "StateMachine") -> bool:
     return robot_status == RobotStatus.Offline
 
 
-def is_available(state_machine: "StateMachine") -> bool:
+def is_available_or_home(state_machine: "StateMachine") -> bool:
     robot_status = state_machine.shared_state.robot_status.check()
-    return robot_status == RobotStatus.Available
-
-
-def is_home(state_machine: "StateMachine") -> bool:
-    robot_status = state_machine.shared_state.robot_status.check()
-    return robot_status == RobotStatus.Home
+    return robot_status == RobotStatus.Available or robot_status == RobotStatus.Home
 
 
 def is_blocked_protective_stop(state_machine: "StateMachine") -> bool:

isar/state_machine/transitions/mission.py

@@ -4,8 +4,15 @@ from isar.state_machine.transitions.functions.fail_mission import (
     report_failed_mission_and_finalize,
 )
 from isar.state_machine.transitions.functions.finish_mission import finish_mission
-from isar.state_machine.transitions.functions.pause import pause_mission
+from isar.state_machine.transitions.functions.pause import (
+    pause_mission,
+    pause_return_home_mission,
+)
 from isar.state_machine.transitions.functions.resume import resume_mission
+from isar.state_machine.transitions.functions.return_home import (
+    reset_return_home_failure_counter,
+    return_home_finished,
+)
 from isar.state_machine.transitions.functions.start_mission import (
     acknowledge_mission,
     initialize_robot,
@@ -15,7 +22,6 @@ from isar.state_machine.transitions.functions.start_mission import (
 )
 from isar.state_machine.transitions.functions.stop import (
     stop_mission_failed,
-    stop_return_home_mission_cleanup,
     stop_return_home_mission_failed,
     trigger_stop_mission_event,
 )
@@ -38,6 +44,17 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "source": state_machine.monitor_state,
             "dest": state_machine.monitor_state,
         },
+        {
+            "trigger": "pause",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.return_home_paused_state,
+            "conditions": def_transition(state_machine, pause_return_home_mission),
+        },
+        {
+            "trigger": "pause",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.returning_home_state,
+        },
         {
             "trigger": "resume",
             "source": state_machine.paused_state,
@@ -49,18 +66,40 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "source": state_machine.paused_state,
             "dest": state_machine.paused_state,
         },
+        {
+            "trigger": "resume",
+            "source": state_machine.return_home_paused_state,
+            "dest": state_machine.returning_home_state,
+            "conditions": def_transition(state_machine, resume_mission),
+        },
+        {
+            "trigger": "resume",
+            "source": state_machine.return_home_paused_state,
+            "dest": state_machine.return_home_paused_state,
+        },
         {
             "trigger": "stop",
             "source": [
                 state_machine.await_next_mission_state,
-                state_machine.robot_standing_still_state,
                 state_machine.monitor_state,
-                state_machine.returning_home_state,
                 state_machine.paused_state,
             ],
             "dest": state_machine.stopping_state,
             "before": def_transition(state_machine, trigger_stop_mission_event),
         },
+        {
+            "trigger": "stop_return_home",
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.return_home_paused_state,
+            ],
+            "dest": state_machine.stopping_return_home_state,
+            "before": [
+                def_transition(state_machine, trigger_stop_mission_event),
+                def_transition(state_machine, reset_return_home_failure_counter),
+                def_transition(state_machine, return_home_finished),
+            ],
+        },
         {
             "trigger": "mission_stopped",
             "source": state_machine.stopping_state,
@@ -74,22 +113,16 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
         },
         {
             "trigger": "return_home_mission_stopping_failed",
-            "source": state_machine.stopping_state,
+            "source": state_machine.stopping_return_home_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,
-            "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, stop_return_home_mission_cleanup),
-        },
         {
             "trigger": "request_mission_start",
             "source": [
                 state_machine.await_next_mission_state,
                 state_machine.home_state,
-                state_machine.robot_standing_still_state,
+                state_machine.stopping_return_home_state,
             ],
             "dest": state_machine.monitor_state,
             "prepare": def_transition(state_machine, acknowledge_mission),
@@ -108,12 +141,6 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
-        {
-            "trigger": "request_mission_start",
-            "source": state_machine.robot_standing_still_state,
-            "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
-        },
         {
             "trigger": "request_mission_start",
             "source": state_machine.home_state,
@@ -123,7 +150,7 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "mission_failed_to_start",
             "source": [state_machine.monitor_state, state_machine.returning_home_state],
-            "dest": state_machine.robot_standing_still_state,
+            "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
         {

isar/state_machine/transitions/return_home.py

@@ -28,10 +28,10 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "source": [
                 state_machine.await_next_mission_state,
                 state_machine.home_state,
-                state_machine.robot_standing_still_state,
                 state_machine.intervention_needed_state,
                 state_machine.monitor_state,
                 state_machine.stopping_state,
+                state_machine.stopping_return_home_state,
             ],
             "dest": state_machine.returning_home_state,
             "conditions": [
@@ -53,12 +53,6 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.home_state,
             "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
-        {
-            "trigger": "request_return_home",
-            "source": state_machine.robot_standing_still_state,
-            "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, report_failed_mission_and_finalize),
-        },
         {
             "trigger": "returned_home",
             "source": state_machine.returning_home_state,

isar/state_machine/transitions/robot_status.py

@@ -1,9 +1,8 @@
 from typing import TYPE_CHECKING, List
 
 from isar.state_machine.transitions.functions.robot_status import (
-    is_available,
+    is_available_or_home,
     is_blocked_protective_stop,
-    is_home,
     is_offline,
 )
 from isar.state_machine.transitions.functions.utils import def_transition
@@ -22,24 +21,12 @@ def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
                 state_machine.offline_state,
                 state_machine.unknown_status_state,
             ],
-            "dest": state_machine.robot_standing_still_state,
-            "conditions": def_transition(state_machine, is_available),
-        },
-        {
-            "trigger": "robot_status_changed",
-            "source": [
-                state_machine.robot_standing_still_state,
-                state_machine.blocked_protective_stopping_state,
-                state_machine.offline_state,
-                state_machine.unknown_status_state,
-            ],
             "dest": state_machine.home_state,
-            "conditions": def_transition(state_machine, is_home),
+            "conditions": def_transition(state_machine, is_available_or_home),
         },
         {
             "trigger": "robot_status_changed",
             "source": [
-                state_machine.robot_standing_still_state,
                 state_machine.home_state,
                 state_machine.offline_state,
                 state_machine.unknown_status_state,
@@ -50,7 +37,6 @@ def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "robot_status_changed",
             "source": [
-                state_machine.robot_standing_still_state,
                 state_machine.home_state,
                 state_machine.blocked_protective_stopping_state,
                 state_machine.unknown_status_state,
@@ -61,7 +47,6 @@ def get_robot_status_transitions(state_machine: "StateMachine") -> List[dict]:
         {
             "trigger": "robot_status_changed",
             "source": [
-                state_machine.robot_standing_still_state,
                 state_machine.home_state,
                 state_machine.blocked_protective_stopping_state,
                 state_machine.offline_state,

isar/storage/uploader.py

@@ -29,6 +29,14 @@ from robot_interface.telemetry.payloads import (
 from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
 
+def has_empty_blob_storage_path(storage_paths: StoragePaths):
+    for path in (storage_paths.data_path, storage_paths.metadata_path):
+        for value in (path.storage_account, path.blob_container, path.blob_name):
+            if not (value and value.strip()):
+                return True
+    return False
+
+
 @dataclass
 class UploaderQueueItem:
     inspection: Inspection
@@ -192,6 +200,13 @@ class Uploader:
                     inspection_paths = self._upload(item)
                     if isinstance(inspection_paths.data_path, LocalStoragePath):
                         self.logger.info("Skipping publishing when using local storage")
+                    elif isinstance(
+                        inspection_paths.data_path, BlobStoragePath
+                    ) and has_empty_blob_storage_path(inspection_paths):
+                        self.logger.warning(
+                            "Skipping publishing: Blob storage paths are empty for inspection %s",
+                            str(item.inspection.id)[:8],
+                        )
                     else:
                         self._publish_inspection_result(
                             inspection=item.inspection,

{isar-1.33.2.dist-info → isar-1.33.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.2
+Version: 1.33.4
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -369,7 +369,7 @@ States.Paused,
 indicates that the state machine is already running. For running a mission the state machine need to be in the states
 
 ```
-States.Home, States.RobotStandingStill, States.AwaitNextMission or States.ReturningHome
+States.Home, States.AwaitNextMission or States.ReturningHome
 ```
 
 ### FastAPI

{isar-1.33.2.dist-info → isar-1.33.4.dist-info}/RECORD

@@ -8,7 +8,7 @@ isar/apis/models/models.py,sha256=iRyqflpjGopm4KJjgRrOnC2swNEk3a-iwVynzw3Nm6c,19
 isar/apis/models/start_mission_definition.py,sha256=v-wt1XDd53Sw7DCdFAkxBBut-xd_uGJa7qMJnE3VI9k,6364
 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=xpKlxxxBQuHZ37WP1OU8SR198YIIrr2NdWWJeaZpuEc,9366
+isar/apis/schedule/scheduling_controller.py,sha256=RKtQmNtcepG0mgu5ihidc2J7ZJ9c1plIgUQCEBz_3SE,9476
 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
@@ -54,38 +54,39 @@ isar/services/auth/azure_credentials.py,sha256=9PlwGe5FrPRbW2dp0go7LMp8_l_FRvL8x
 isar/services/service_connections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/service_connections/request_handler.py,sha256=0LxC0lu_HXeEf_xmJWjfEsh14oAUI97cpG1IWtBlcs4,4278
 isar/services/service_connections/mqtt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/service_connections/mqtt/mqtt_client.py,sha256=ABJLJOckSq9ElkZYLKF64mOEUESgxjW1V6ySZX3de6M,4462
+isar/services/service_connections/mqtt/mqtt_client.py,sha256=8Dr65JNwPx5-kRY8UsRtZ_nrQ2gXXSUH6LWFOYlnluo,4482
 isar/services/service_connections/mqtt/robot_heartbeat_publisher.py,sha256=SKPvY2QwBxqnhL9aGuZQDGQ8F_NDqPtQI5bzRBIUxkQ,1203
 isar/services/service_connections/mqtt/robot_info_publisher.py,sha256=AxokGk51hRPTxxD2r0P9braPJCMrf1InaCxrUBKkF4g,1402
 isar/services/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/utilities/robot_utilities.py,sha256=4zCigsLXfqDC8POHchktSq81zr1_pTaRve_LQsVr6Mk,514
-isar/services/utilities/scheduling_utilities.py,sha256=3vFU7t7oEZTFQNJdAxfhaADScRJIxznWhDbagHyLKOQ,13605
+isar/services/utilities/scheduling_utilities.py,sha256=6t42uyHXRr8QtRU6qH_EzYKlvwXEAUCwe7U5IDUp4nc,13502
 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=PL-dImdaFsvoWQ_z8U9IImFXfSplUOQ5V7VBgePoW64,18314
-isar/state_machine/states_enum.py,sha256=4Kysag9JPi2JSyC2me2B1sLH3Sfo7qGJonc-Q_IiUug,511
+isar/state_machine/state_machine.py,sha256=W2RMBhSRtu5kH0LAuRHbPhxHxtFa0knWfBv7EMRuQcI,18610
+isar/state_machine/states_enum.py,sha256=hBbP87Aw9JiIBScfAkflWgQHYBrLA17ex0XXO4suRYY,555
 isar/state_machine/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/state_machine/states/await_next_mission.py,sha256=yg0aH4eukcnE1xRKiPVafRxqHt3WdvqD08EATzdEojk,1961
 isar/state_machine/states/blocked_protective_stop.py,sha256=GEOvxnHXjpCsrh3aa8Idtn1zMYv5HLQzj9qQAq8HvaU,1180
-isar/state_machine/states/home.py,sha256=TYv7WF5yX31Zw6Cn5MY2GHebUfypL5w510I92BEi_vE,1950
+isar/state_machine/states/home.py,sha256=718NFxbYQTM5VLKbL8e5ELlbXWYis1GfaZfl34EhfQo,2292
 isar/state_machine/states/intervention_needed.py,sha256=A0QYz1vD1tDKAealihXDuoGuMLtXrRfn_AwFoaUhT_Q,1640
 isar/state_machine/states/monitor.py,sha256=GiNGyPcskrv3QDxMfsOmHUe_MRCaNA-pYuk9p6kcKp0,4623
 isar/state_machine/states/offline.py,sha256=5wdNzC1wG0cWrpuT_r_mk8UNFHA4QSyg8ejXUTAg4Io,1137
-isar/state_machine/states/paused.py,sha256=osmLZhm0-2jcZmNRauveeidCBYayDZvLy-1TNYv6CgQ,1091
+isar/state_machine/states/paused.py,sha256=OruA2oPGWsVjnQ8xxVJJsGO3xKzXz2xF5uWsrvH27Ng,2101
 isar/state_machine/states/recharging.py,sha256=ni5WqFU0VDhdGC3ZfHcabSICm_5kwaS72wc3ecAB_os,1651
-isar/state_machine/states/returning_home.py,sha256=mPwsOFxMTO6On5PzeYKW8Roy6TaQIXsoWCsbtzcV7M8,4267
-isar/state_machine/states/robot_standing_still.py,sha256=EWG2_IPbxK6HFERHcmMFlWdN5PnXJXjwEfNlpsJnPkQ,1985
-isar/state_machine/states/stopping.py,sha256=ROKbQcJFS4A_U0Pd8lAViG7Dz8JqfBaR3vHmpvKC2oc,3848
+isar/state_machine/states/return_home_paused.py,sha256=nVfNqutEG251NCk18UqIerh0SdAgGsXMXBt5iT2oRK0,2711
+isar/state_machine/states/returning_home.py,sha256=75pfHNCjpV4jfhcmNAoabTwBzed1_-aFJE_KkTUTAnA,4513
+isar/state_machine/states/stopping.py,sha256=h0x94hVoIUJyml3WMrbJlbxG2dzMCeOL1rJoNCQfzGQ,3057
+isar/state_machine/states/stopping_return_home.py,sha256=ub952Ulas3a0lsV_dI4liBiInADo3zaPAGod2bPe_18,2985
 isar/state_machine/states/unknown_status.py,sha256=Y-g9cgme5zriyZ6YUzFRYhOvv9ZylCSwfaY8MJ7xEJ0,1791
-isar/state_machine/transitions/mission.py,sha256=oJiANT1lHd6YhEA_mQscDPDyfwMxwfosq7UcP0gfTNk,5456
-isar/state_machine/transitions/return_home.py,sha256=EIR14rnukV_mEYkwtz0J_D1Dp51oVna0wV71HSbqtuw,4630
-isar/state_machine/transitions/robot_status.py,sha256=sALt9BwZUnIFmVe35N1ptC-PyhfdHiTGu1R0GzpAQXk,3056
+isar/state_machine/transitions/mission.py,sha256=W56bs4jSFwH2K4yAwxzLWh7dDuLi8j-L4mVvmfeKjWw,6313
+isar/state_machine/transitions/return_home.py,sha256=9fXFVozsCZqtKjQwiPLLc3ExrgLj5zU9AD7a9IMe0Pw,4348
+isar/state_machine/transitions/robot_status.py,sha256=qJMurCpuficOiXs9us4lZJ5p_kOFSwKxJigiXfB1OS8,2430
 isar/state_machine/transitions/functions/fail_mission.py,sha256=jHHXhfQVYQEzCXgTEhv5e6uEK9p6iDPFFXqS9bzs_-A,720
 isar/state_machine/transitions/functions/finish_mission.py,sha256=TRQrk7HdllmAkwsp25HRZAFAk46Y1hLx3jmkIAKrHDI,1442
-isar/state_machine/transitions/functions/pause.py,sha256=Wa9XlhXVRNzxoYSsHc0w87ht4nQ5dGh50fjfA9lrAmI,1987
+isar/state_machine/transitions/functions/pause.py,sha256=R4Bbb-XcmcCwGiY3-lsYiK-WAz2KfVj4kM_pzE8OFyg,3472
 isar/state_machine/transitions/functions/resume.py,sha256=SAu4hWomPlrvO0lnpc6uM3rj79Bwq01acnaTEvNbO9U,2116
 isar/state_machine/transitions/functions/return_home.py,sha256=5WPO40MtuRKm9-NtyrS6m0IVEit14MXfMKjgZ2sCXRU,1666
-isar/state_machine/transitions/functions/robot_status.py,sha256=P1Cu8xVysbiKRKL4E8mSyoL2-72HfxrLvvOcdnBOlvw,889
+isar/state_machine/transitions/functions/robot_status.py,sha256=2P3EfP2c06GY-LUquyBTyHn1Ard31Hl3UeT-e-VaIWE,768
 isar/state_machine/transitions/functions/start_mission.py,sha256=tIpZzYXCoeC6ZWj18UB4DiZuICpxfzFUK23wfunad7Q,2864
 isar/state_machine/transitions/functions/stop.py,sha256=4idsNh7v6CRJivD36oKnVmdKlP7mSugTLCh9n12R1-U,2114
 isar/state_machine/transitions/functions/utils.py,sha256=Wa72Ocq4QT1E6qkpEJZQ3h5o33pGvx7Tlkt2JZ2Grbk,314
@@ -94,9 +95,9 @@ isar/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/storage/blob_storage.py,sha256=d44z3XpZDUbiKwN8Av2gytTJxnefMXrp5VhiGm4PWxU,3703
 isar/storage/local_storage.py,sha256=Rn-iiiz9DI7PzIhevOMshPIaqzJaqBXeVJMQRhVSl2M,2191
 isar/storage/storage_interface.py,sha256=x-imVeQTdL6dCaTaPTHpXwCR6N4e27WxK_Vpumg0x-Y,1230
-isar/storage/uploader.py,sha256=HurLZb4MbZYRRocsJimoUrP3UHrE7wiO0IfIpKBSHrw,9988
+isar/storage/uploader.py,sha256=oaGhHqYrtyvJoFUuD7ZyBgdPNkYaSgQokQZkAjmd4vI,10702
 isar/storage/utilities.py,sha256=oLH0Rp7UtrQQdilfITnmXO1Z0ExdeDhBImYHid55vBA,3449
-isar-1.33.2.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
+isar-1.33.4.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
 robot_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/robot_interface.py,sha256=A6t19lcNU_6AfkYKY5DaF0sheym_SZEAawbfaj36Kjk,8997
 robot_interface/test_robot_interface.py,sha256=FV1urn7SbsMyWBIcTKjsBwAG4IsXeZ6pLHE0mA9EGGs,692
@@ -108,7 +109,7 @@ robot_interface/models/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 robot_interface/models/inspection/inspection.py,sha256=cjAvekL8r82s7bgukWeXpYylHvJG_oRSCJNISPVCvZg,2238
 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=KC-79HBjM1-6xA0WmwAtZl8QC0pZu6u4wbYWb0IjGd8,816
+robot_interface/models/mission/status.py,sha256=e5Yr-GSV_CNSOV9MH2TQP4H_WbSG-z8Ty0JKkYFbZKA,856
 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
@@ -120,8 +121,8 @@ robot_interface/telemetry/payloads.py,sha256=RfLlm_te-bV_xcLtbBx27bgE8gkwPAhWBTF
 robot_interface/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/utilities/json_service.py,sha256=9N1zijW7K4d3WFR2autpaS8U9o1ibymiOX-6stTKCyk,1243
 robot_interface/utilities/uuid_string_factory.py,sha256=_NQIbBQ56w0qqO0MUDP6aPpHbxW7ATRhK8HnQiBSLkc,76
-isar-1.33.2.dist-info/METADATA,sha256=3Hzfh4ScmPbEXrX9zdzbcaC1I9cbGLpO23j_2Ihy61M,31217
-isar-1.33.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isar-1.33.2.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.33.2.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.33.2.dist-info/RECORD,,
+isar-1.33.4.dist-info/METADATA,sha256=kFWjErpSnEh4cucIUoioOsgWRnzcxU9BsI65g3hUKqI,31190
+isar-1.33.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isar-1.33.4.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
+isar-1.33.4.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
+isar-1.33.4.dist-info/RECORD,,

robot_interface/models/mission/status.py

@@ -23,10 +23,11 @@ class TaskStatus(str, Enum):
 
 class RobotStatus(Enum):
     Available = "available"
+    ReturnHomePaused = "returnhomepaused"
+    Paused = "paused"
     Busy = "busy"
     Home = "home"
     Offline = "offline"
-    Blocked = "blocked"
     BlockedProtectiveStop = "blockedprotectivestop"
     ReturningHome = "returninghome"
     InterventionNeeded = "interventionneeded"

isar/state_machine/states/robot_standing_still.py

@@ -1,52 +0,0 @@
-from typing import TYPE_CHECKING, List
-
-from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
-from isar.state_machine.utils.common_event_handlers import (
-    return_home_event_handler,
-    robot_status_event_handler,
-    start_mission_event_handler,
-    stop_mission_event_handler,
-)
-from robot_interface.models.mission.status import RobotStatus
-
-if TYPE_CHECKING:
-    from isar.state_machine.state_machine import StateMachine
-
-
-class RobotStandingStill(EventHandlerBase):
-
-    def __init__(self, state_machine: "StateMachine"):
-        events = state_machine.events
-        shared_state = state_machine.shared_state
-
-        event_handlers: List[EventHandlerMapping] = [
-            EventHandlerMapping(
-                name="start_mission_event",
-                event=events.api_requests.start_mission.request,
-                handler=lambda event: start_mission_event_handler(
-                    state_machine, event, events.api_requests.start_mission.response
-                ),
-            ),
-            EventHandlerMapping(
-                name="return_home_event",
-                event=events.api_requests.return_home.request,
-                handler=lambda event: return_home_event_handler(state_machine, event),
-            ),
-            EventHandlerMapping(
-                name="stop_mission_event",
-                event=events.api_requests.return_home.request,
-                handler=lambda event: stop_mission_event_handler(state_machine, event),
-            ),
-            EventHandlerMapping(
-                name="robot_status_event",
-                event=shared_state.robot_status,
-                handler=lambda event: robot_status_event_handler(
-                    state_machine, RobotStatus.Available, event
-                ),
-            ),
-        ]
-        super().__init__(
-            state_name="robot_standing_still",
-            state_machine=state_machine,
-            event_handler_mappings=event_handlers,
-        )