isar 1.33.8__py3-none-any.whl → 1.33.9__py3-none-any.whl

isar/config/settings.py

@@ -168,7 +168,7 @@ class Settings(BaseSettings):
     UPLOAD_INSPECTIONS_ASYNC: bool = Field(default=False)
 
     # URL to storage account for Azure Blob Storage
-    BLOB_STORAGE_ACCOUNT: str = Field(default="eqrobotdevstorage")
+    BLOB_STORAGE_ACCOUNT: str = Field(default="")
 
     # Name of blob container in Azure Blob Storage [slimm test]
     BLOB_CONTAINER: str = Field(default="test")

isar/state_machine/states/await_next_mission.py

@@ -27,12 +27,13 @@ class AwaitNextMission(EventHandlerBase):
             event: Event[bool],
         ) -> Optional[Callable]:
             should_lockdown: bool = event.consume_event()
-            if should_lockdown:
-                events.api_requests.send_to_lockdown.response.trigger_event(
-                    LockdownResponse(lockdown_started=True)
-                )
-                return state_machine.request_lockdown_mission  # type: ignore
-            return None
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.request_lockdown_mission  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/going_to_lockdown.py

@@ -32,18 +32,19 @@ class GoingToLockdown(EventHandlerBase):
             event: Event[Optional[ErrorMessage]],
         ) -> Optional[Callable]:
             mission_failed: Optional[ErrorMessage] = event.consume_event()
-            if mission_failed is not None:
-                state_machine.logger.warning(
-                    f"Failed to initiate mission "
-                    f"{str(state_machine.current_mission.id)[:8]} because: "
-                    f"{mission_failed.error_description}"
-                )
-                state_machine.current_mission.error_message = ErrorMessage(
-                    error_reason=mission_failed.error_reason,
-                    error_description=mission_failed.error_description,
-                )
-                return state_machine.lockdown_mission_failed  # type: ignore
-            return None
+            if mission_failed is None:
+                return None
+
+            state_machine.logger.warning(
+                f"Failed to initiate mission "
+                f"{str(state_machine.current_mission.id)[:8]} because: "
+                f"{mission_failed.error_description}"
+            )
+            state_machine.current_mission.error_message = ErrorMessage(
+                error_reason=mission_failed.error_reason,
+                error_description=mission_failed.error_description,
+            )
+            return state_machine.lockdown_mission_failed  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/home.py

@@ -22,12 +22,13 @@ class Home(EventHandlerBase):
 
         def _send_to_lockdown_event_handler(event: Event[bool]):
             should_send_robot_home: bool = event.consume_event()
-            if should_send_robot_home:
-                events.api_requests.send_to_lockdown.response.trigger_event(
-                    LockdownResponse(lockdown_started=True)
-                )
-                return state_machine.reached_lockdown  # type: ignore
-            return None
+            if not should_send_robot_home:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.reached_lockdown  # type: ignore
 
         def _robot_status_event_handler(
             state_machine: "StateMachine",

isar/state_machine/states/intervention_needed.py

@@ -17,12 +17,13 @@ class InterventionNeeded(EventHandlerBase):
         def release_intervention_needed_handler(
             event: Event[bool],
         ) -> Optional[Callable]:
-            if event.consume_event():
-                state_machine.events.api_requests.release_intervention_needed.response.trigger_event(
-                    True
-                )
-                return state_machine.release_intervention_needed  # type: ignore
-            return None
+            if not event.consume_event():
+                return None
+
+            state_machine.events.api_requests.release_intervention_needed.response.trigger_event(
+                True
+            )
+            return state_machine.release_intervention_needed  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/lockdown.py

@@ -14,13 +14,14 @@ class Lockdown(EventHandlerBase):
 
         def _release_from_lockdown_handler(event: Event[bool]):
             should_release_from_lockdown: bool = event.consume_event()
-            if should_release_from_lockdown:
-                events.api_requests.release_from_lockdown.response.trigger_event(True)
-                if state_machine.battery_level_is_above_mission_start_threshold():
-                    return state_machine.release_from_lockdown  # type: ignore
-                else:
-                    return state_machine.starting_recharging  # type: ignore
-            return None
+            if not should_release_from_lockdown:
+                return None
+
+            events.api_requests.release_from_lockdown.response.trigger_event(True)
+            if state_machine.battery_level_is_above_mission_start_threshold():
+                return state_machine.release_from_lockdown  # type: ignore
+            else:
+                return state_machine.starting_recharging  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/monitor.py

@@ -27,9 +27,10 @@ class Monitor(EventHandlerBase):
         shared_state = state_machine.shared_state
 
         def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
-                return state_machine.pause  # type: ignore
-            return None
+            if not event.consume_event():
+                return None
+
+            return state_machine.pause  # type: ignore
 
         def _handle_task_completed(task_status: TaskStatus):
             if state_machine.should_upload_inspections():
@@ -44,35 +45,38 @@ class Monitor(EventHandlerBase):
                 )
 
             state_machine.iterate_current_task()
-            if state_machine.current_task is None:
-                return state_machine.mission_finished  # type: ignore
-            return None
+            if state_machine.current_task is not None:
+                return None
+
+            return state_machine.mission_finished  # type: ignore
 
         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
+            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                return None
+
+            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
 
         def _send_to_lockdown_event_handler(
             event: Event[bool],
         ) -> Optional[Callable]:
             should_lockdown: bool = event.consume_event()
-            if should_lockdown:
-                state_machine.logger.warning(
-                    "Cancelling current mission due to robot going to lockdown"
-                )
-                return state_machine.stop_go_to_lockdown  # type: ignore
-            return None
+            if not should_lockdown:
+                return None
+
+            state_machine.logger.warning(
+                "Cancelling current mission due to robot going to lockdown"
+            )
+            return state_machine.stop_go_to_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/paused.py

@@ -19,28 +19,30 @@ class Paused(EventHandlerBase):
             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
+            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                return None
+
+            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
 
         def _send_to_lockdown_event_handler(
             event: Event[bool],
         ) -> Optional[Callable]:
             should_lockdown: bool = event.consume_event()
-            if should_lockdown:
-                state_machine._finalize()
-                state_machine.logger.warning(
-                    "Cancelling current mission due to robot going to lockdown"
-                )
-                return state_machine.stop_go_to_lockdown  # type: ignore
-            return None
+            if not should_lockdown:
+                return None
+
+            state_machine._finalize()
+            state_machine.logger.warning(
+                "Cancelling current mission due to robot going to lockdown"
+            )
+            return state_machine.stop_go_to_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/pausing.py

@@ -31,29 +31,30 @@ class Pausing(EventHandlerBase):
             state_machine.publish_mission_status()
             state_machine.send_task_status()
 
-            if error_message is not None:
-                return state_machine.mission_pausing_failed  # type: ignore
-            return None
+            if error_message is None:
+                return None
+
+            return state_machine.mission_pausing_failed  # type: ignore
 
         def _successful_pause_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
+            if not event.consume_event():
+                return None
 
-                state_machine.current_mission.status = MissionStatus.Paused
-                state_machine.current_task.status = TaskStatus.Paused
+            state_machine.current_mission.status = MissionStatus.Paused
+            state_machine.current_task.status = TaskStatus.Paused
 
-                paused_mission_response: ControlMissionResponse = (
-                    state_machine._make_control_mission_response()
-                )
+            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.events.api_requests.pause_mission.response.trigger_event(
+                paused_mission_response
+            )
 
-                state_machine.publish_mission_status()
-                state_machine.send_task_status()
+            state_machine.publish_mission_status()
+            state_machine.send_task_status()
 
-                return state_machine.mission_paused  # type:ignore
-            return None
+            return state_machine.mission_paused  # type:ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/pausing_return_home.py

@@ -31,29 +31,30 @@ class PausingReturnHome(EventHandlerBase):
             state_machine.publish_mission_status()
             state_machine.send_task_status()
 
-            if error_message is not None:
-                return state_machine.return_home_mission_pausing_failed  # type: ignore
-            return None
+            if error_message is None:
+                return None
+
+            return state_machine.return_home_mission_pausing_failed  # type: ignore
 
         def _successful_pause_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
+            if not event.consume_event():
+                return None
 
-                state_machine.current_mission.status = MissionStatus.Paused
-                state_machine.current_task.status = TaskStatus.Paused
+            state_machine.current_mission.status = MissionStatus.Paused
+            state_machine.current_task.status = TaskStatus.Paused
 
-                paused_mission_response: ControlMissionResponse = (
-                    state_machine._make_control_mission_response()
-                )
+            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.events.api_requests.pause_mission.response.trigger_event(
+                paused_mission_response
+            )
 
-                state_machine.publish_mission_status()
-                state_machine.send_task_status()
+            state_machine.publish_mission_status()
+            state_machine.send_task_status()
 
-                return state_machine.return_home_mission_paused  # type: ignore
-            return None
+            return state_machine.return_home_mission_paused  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/recharging.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Optional
 
 from isar.apis.models.models import LockdownResponse
 from isar.config.settings import settings
@@ -18,23 +18,29 @@ class Recharging(EventHandlerBase):
 
         def robot_battery_level_updated_handler(event: Event[float]):
             battery_level: float = event.check()
-            if battery_level >= settings.ROBOT_BATTERY_RECHARGE_THRESHOLD:
-                return state_machine.robot_recharged  # type: ignore
-            return None
+            if battery_level < settings.ROBOT_BATTERY_RECHARGE_THRESHOLD:
+                return None
+
+            return state_machine.robot_recharged  # type: ignore
 
         def robot_offline_handler(event: Event[RobotStatus]):
-            robot_status: RobotStatus = event.check()
+            robot_status: Optional[RobotStatus] = event.check()
+
+            if robot_status is None:
+                return None
+
             if robot_status == RobotStatus.Offline:
                 return state_machine.robot_went_offline  # type: ignore
 
         def _send_to_lockdown_event_handler(event: Event[bool]):
             should_lockdown: bool = event.consume_event()
-            if should_lockdown:
-                events.api_requests.send_to_lockdown.response.trigger_event(
-                    LockdownResponse(lockdown_started=True)
-                )
-                return state_machine.reached_lockdown  # type: ignore
-            return None
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.reached_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/return_home_paused.py

@@ -20,38 +20,42 @@ class ReturnHomePaused(EventHandlerBase):
             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
+
+            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                return None
+
+            return state_machine.resume  # type: ignore
 
         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
+            if not event.has_event():
+                return None
+
+            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
 
         def _send_to_lockdown_event_handler(
             event: Event[bool],
         ) -> Optional[Callable]:
             should_lockdown: bool = event.consume_event()
-            if should_lockdown:
-                events.api_requests.send_to_lockdown.response.trigger_event(
-                    LockdownResponse(lockdown_started=True)
-                )
-                return state_machine.resume_lockdown  # type: ignore
-            return None
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.resume_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/returning_home.py

@@ -24,9 +24,10 @@ class ReturningHome(EventHandlerBase):
         events = state_machine.events
 
         def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
-                return state_machine.pause_return_home  # type: ignore
-            return None
+            if not event.consume_event():
+                return None
+
+            return state_machine.pause_return_home  # type: ignore
 
         def _handle_task_completed(status: TaskStatus):
             if status != TaskStatus.Successful:
@@ -45,31 +46,34 @@ class ReturningHome(EventHandlerBase):
         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
+            if not event.has_event():
+                return None
+
+            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
 
         def _send_to_lockdown_event_handler(
             event: Event[bool],
         ) -> Optional[Callable]:
             should_lockdown: bool = event.consume_event()
-            if should_lockdown:
-                events.api_requests.send_to_lockdown.response.trigger_event(
-                    LockdownResponse(lockdown_started=True)
-                )
-                return state_machine.go_to_lockdown  # type: ignore
-            return None
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.go_to_lockdown  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/stopping.py

@@ -45,17 +45,19 @@ class Stopping(EventHandlerBase):
             event: Event[ErrorMessage],
         ) -> Optional[Callable]:
             error_message: Optional[ErrorMessage] = event.consume_event()
-            if error_message is not None:
-                return state_machine.mission_stopping_failed  # type: ignore
-            return None
+            if error_message is None:
+                return None
+
+            return state_machine.mission_stopping_failed  # type: ignore
 
         def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
-                _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
+            if not event.consume_event():
+                return None
+
+            _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
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/stopping_go_to_lockdown.py

@@ -38,27 +38,27 @@ class StoppingGoToLockdown(EventHandlerBase):
             event: Event[ErrorMessage],
         ) -> Optional[Callable]:
             error_message: Optional[ErrorMessage] = event.consume_event()
-            if error_message is not None:
-                events.api_requests.send_to_lockdown.response.trigger_event(
-                    LockdownResponse(
-                        lockdown_started=False,
-                        failure_reason="Failed to stop ongoing mission",
-                    )
+            if error_message is None:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(
+                    lockdown_started=False,
+                    failure_reason="Failed to stop ongoing mission",
                 )
-                return state_machine.mission_stopping_failed  # type: ignore
-            return None
+            )
+            return state_machine.mission_stopping_failed  # type: ignore
 
         def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
-            if event.consume_event():
-                state_machine.publish_mission_aborted(
-                    "Robot being sent to lockdown", True
-                )
-                _stop_mission_cleanup()
-                events.api_requests.send_to_lockdown.response.trigger_event(
-                    LockdownResponse(lockdown_started=True)
-                )
-                return state_machine.request_lockdown_mission  # type: ignore
-            return None
+            if not event.consume_event():
+                return None
+
+            state_machine.publish_mission_aborted("Robot being sent to lockdown", True)
+            _stop_mission_cleanup()
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.request_lockdown_mission  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/stopping_return_home.py

@@ -21,38 +21,40 @@ class StoppingReturnHome(EventHandlerBase):
             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",
-                    )
+            if error_message is None:
+                return 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
+            )
+            return state_machine.return_home_mission_stopping_failed  # type: ignore
 
         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()
-                )
+            if not event.consume_event():
+                return None
 
-                state_machine.reset_state_machine()
+            mission: Mission = (
+                state_machine.events.api_requests.start_mission.request.consume_event()
+            )
 
-                if mission:
-                    state_machine.start_mission(mission=mission)
-                    return state_machine.request_mission_start  # type: ignore
+            state_machine.reset_state_machine()
 
-                state_machine.logger.error(
-                    "Stopped return home without a new mission to start"
-                )
-                return state_machine.request_return_home  # type: ignore
-            return None
+            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
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/states/unknown_status.py

@@ -18,15 +18,18 @@ class UnknownStatus(EventHandlerBase):
         def _robot_status_event_handler(
             event: Event[RobotStatus],
         ) -> Optional[Callable]:
-            robot_status: RobotStatus = event.check()
-            if (
+            robot_status: Optional[RobotStatus] = event.check()
+            if robot_status is None:
+                return None
+            if not (
                 robot_status == RobotStatus.Home
                 or robot_status == RobotStatus.Offline
                 or robot_status == RobotStatus.BlockedProtectiveStop
                 or robot_status == RobotStatus.Available
             ):
-                return state_machine.robot_status_changed  # type: ignore
-            return None
+                return None
+
+            return state_machine.robot_status_changed  # type: ignore
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(

isar/state_machine/utils/common_event_handlers.py

@@ -16,28 +16,30 @@ def start_mission_event_handler(
     response: Event[MissionStartResponse],
 ) -> Optional[Callable]:
     mission: Optional[Mission] = event.consume_event()
-    if mission:
-        if not state_machine.battery_level_is_above_mission_start_threshold():
-            response.trigger_event(
-                MissionStartResponse(
-                    mission_id=mission.id,
-                    mission_started=False,
-                    mission_not_started_reason="Robot battery too low",
-                )
+    if not mission:
+        return None
+
+    if not state_machine.battery_level_is_above_mission_start_threshold():
+        response.trigger_event(
+            MissionStartResponse(
+                mission_id=mission.id,
+                mission_started=False,
+                mission_not_started_reason="Robot battery too low",
             )
-            return None
-        state_machine.start_mission(mission=mission)
-        return state_machine.request_mission_start  # type: ignore
-    return None
+        )
+        return None
+    state_machine.start_mission(mission=mission)
+    return state_machine.request_mission_start  # type: ignore
 
 
 def return_home_event_handler(
     state_machine: "StateMachine", event: Event[bool]
 ) -> Optional[Callable]:
-    if event.consume_event():
-        state_machine.events.api_requests.return_home.response.trigger_event(True)
-        return state_machine.request_return_home  # type: ignore
-    return None
+    if not event.consume_event():
+        return None
+
+    state_machine.events.api_requests.return_home.response.trigger_event(True)
+    return state_machine.request_return_home  # type: ignore
 
 
 def robot_status_event_handler(
@@ -48,6 +50,7 @@ def robot_status_event_handler(
 ) -> Optional[Callable]:
     if not status_changed_event.consume_event():
         return None
+
     robot_status: Optional[RobotStatus] = status_event.check()
     if robot_status != expected_status:
         return state_machine.robot_status_changed  # type: ignore
@@ -58,29 +61,33 @@ def stop_mission_event_handler(
     state_machine: "StateMachine", event: Event[str]
 ) -> Optional[Callable]:
     mission_id: str = event.consume_event()
-    if mission_id is not None:
-        if state_machine.current_mission.id == mission_id or mission_id == "":
-            return state_machine.stop  # type: ignore
-        else:
-            state_machine.events.api_requests.stop_mission.response.trigger_event(
-                ControlMissionResponse(
-                    mission_id=mission_id,
-                    mission_status=state_machine.current_mission.status,
-                    mission_not_found=True,
-                    task_id=state_machine.current_task.id,
-                    task_status=state_machine.current_task.status,
-                )
+    if mission_id is None:
+        return None
+
+    if state_machine.current_mission.id == mission_id or mission_id == "":
+        return state_machine.stop  # type: ignore
+    else:
+        state_machine.events.api_requests.stop_mission.response.trigger_event(
+            ControlMissionResponse(
+                mission_id=mission_id,
+                mission_status=state_machine.current_mission.status,
+                mission_not_found=True,
+                task_id=state_machine.current_task.id,
+                task_status=state_machine.current_task.status,
             )
-    return None
+        )
+        return None
 
 
 def mission_started_event_handler(
     state_machine: "StateMachine",
     event: Event[bool],
 ) -> Optional[Callable]:
-    if event.consume_event():
-        state_machine.logger.info("Received confirmation that mission has started")
-        state_machine.mission_ongoing = True
+    if not event.consume_event():
+        return None
+
+    state_machine.logger.info("Received confirmation that mission has started")
+    state_machine.mission_ongoing = True
     return None
 
 
@@ -89,18 +96,19 @@ def mission_failed_event_handler(
     event: Event[Optional[ErrorMessage]],
 ) -> Optional[Callable]:
     mission_failed: Optional[ErrorMessage] = event.consume_event()
-    if mission_failed is not None:
-        state_machine.logger.warning(
-            f"Failed to initiate mission "
-            f"{str(state_machine.current_mission.id)[:8]} because: "
-            f"{mission_failed.error_description}"
-        )
-        state_machine.current_mission.error_message = ErrorMessage(
-            error_reason=mission_failed.error_reason,
-            error_description=mission_failed.error_description,
-        )
-        return state_machine.mission_failed_to_start  # type: ignore
-    return None
+    if mission_failed is None:
+        return None
+
+    state_machine.logger.warning(
+        f"Failed to initiate mission "
+        f"{str(state_machine.current_mission.id)[:8]} because: "
+        f"{mission_failed.error_description}"
+    )
+    state_machine.current_mission.error_message = ErrorMessage(
+        error_reason=mission_failed.error_reason,
+        error_description=mission_failed.error_description,
+    )
+    return state_machine.mission_failed_to_start  # type: ignore
 
 
 def task_status_failed_event_handler(
@@ -173,9 +181,10 @@ def _handle_new_task_status(
 
     state_machine.current_task.status = status
 
-    if state_machine.current_task.is_finished():
-        state_machine.report_task_status(state_machine.current_task)
-        state_machine.publish_task_status(task=state_machine.current_task)
+    if not state_machine.current_task.is_finished():
+        return None
 
-        return handle_task_completed(status)
-    return None
+    state_machine.report_task_status(state_machine.current_task)
+    state_machine.publish_task_status(task=state_machine.current_task)
+
+    return handle_task_completed(status)

{isar-1.33.8.dist-info → isar-1.33.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.8
+Version: 1.33.9
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -480,6 +480,7 @@ Enabling API authentication also requires the same environment variables. The re
 AZURE_CLIENT_ID
 AZURE_TENANT_ID
 AZURE_CLIENT_SECRET
+ISAR_BLOB_STORAGE_ACCOUNT
 ```
 
 ## MQTT communication

{isar-1.33.8.dist-info → isar-1.33.9.dist-info}/RECORD

@@ -16,7 +16,7 @@ isar/config/configuration_error.py,sha256=rO6WOhafX6xvVib8WxV-eY483Z0PpN-9PxGsq5
 isar/config/log.py,sha256=f_mLLz5RSa0kZkdpi1m0iMdwwDc4RQp12mnT6gu2exE,1303
 isar/config/logging.conf,sha256=a7ZBvZkrMDaPU3eRGAjL_eZz6hZsa6BaRJOfx8mbnnM,629
 isar/config/open_telemetry.py,sha256=Lgu0lbRQA-zz6ZDoBKKk0whQex5w18jl1wjqWzHUGdg,3634
-isar/config/settings.py,sha256=XMPU4d1V6FspjvMmto5TFmC8Slt8Nrpmn9n_tsyPTYk,14423
+isar/config/settings.py,sha256=Bw1OUDo4DJLKk2rt2sP7okw3fW56CHrmWN9w1Hd0t9o,14406
 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
@@ -68,24 +68,24 @@ isar/state_machine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 isar/state_machine/state_machine.py,sha256=lF25XC6vpNO8Mj3DWnmfPBKjS1atl7GdtGbBs2TkaUs,19887
 isar/state_machine/states_enum.py,sha256=EzqLHsNbR7KBMIY5Fa_CDaHm9v6g8UFzq9DJs4x0OU8,746
 isar/state_machine/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/state_machine/states/await_next_mission.py,sha256=3_KrK7nWu1Dm-VA3Rt1gwVsUbn9WuB7MoqLCfobGJSM,2749
+isar/state_machine/states/await_next_mission.py,sha256=H1QN62S6iUYzLgyzK8UVG-0PEWGiCDdsIOjWC7BWD_Q,2742
 isar/state_machine/states/blocked_protective_stop.py,sha256=HJr_jH8OdHMuX8zhjlF5jtNAfMCxkA1X7nOGmkAz-RY,1263
-isar/state_machine/states/going_to_lockdown.py,sha256=RLMOH2lXiT3hQhfUtbBVAUfwKUd33yxbjq4uZDZ_Tkc,3388
-isar/state_machine/states/home.py,sha256=mCwXSb9LygNpY4qaKEkEYC3nP-6HdsSGmEyjsENumgM,3396
-isar/state_machine/states/intervention_needed.py,sha256=A0QYz1vD1tDKAealihXDuoGuMLtXrRfn_AwFoaUhT_Q,1640
-isar/state_machine/states/lockdown.py,sha256=mWjhjtky5GbW6BLjsi2TsS0LXI-yq7l29FaqZ2TbTek,1375
-isar/state_machine/states/monitor.py,sha256=wmiJrbKntnNw9ExS6-VdJJuW2Q3Jzl9DozmZmEXJ0Cw,5285
+isar/state_machine/states/going_to_lockdown.py,sha256=q5C5MCRZxfSRJad2sntwIhvx_jsjm47Q6_4uN4kRQNI,3349
+isar/state_machine/states/home.py,sha256=pAAQrVHjbtOsVz0R_Z2CBQewearLoqGoCkGz2R62pT0,3389
+isar/state_machine/states/intervention_needed.py,sha256=nv7054e9gBJQ4-Mshs8cczqnD0IN-N-_5qvUR-cNcUM,1633
+isar/state_machine/states/lockdown.py,sha256=ZFw9XMDENECuH3lh89RKeU_3CTzW0ZBvqCKptFJG5xo,1364
+isar/state_machine/states/monitor.py,sha256=AbH6C_YJWlUvXVDtAgk3qQQkuuxga33-HD5hYpktQS0,5262
 isar/state_machine/states/offline.py,sha256=k1UdcRWLd6lJiL5cnpHKBkvMY4xZMt_x7XIauy-Rgww,1219
-isar/state_machine/states/paused.py,sha256=1ADoTJ3b137k7dmZYxeyGVhyrRF8qotxoV1NaWCbBUk,2870
-isar/state_machine/states/pausing.py,sha256=r0GywI1-JDOJLZEnxhnq_yFKza37eL45qHP0ir8SBsY,2762
-isar/state_machine/states/pausing_return_home.py,sha256=USyBLWpJqrsJ2hsdyW6i-gvEsog2l7OMJLdgIj-hq0Y,2808
-isar/state_machine/states/recharging.py,sha256=6zRppneGXetMaZVvhqCPcSoQyz08tftNhWHYxLCRGc8,2367
-isar/state_machine/states/return_home_paused.py,sha256=eBBFFbkLVfY_5yP2kPZnHHwxcwOcHKAxjkQTMat55HU,3398
-isar/state_machine/states/returning_home.py,sha256=47M760nPt1dh1P0C0PmfVLrjsZaWz_pGizuBbWZ0OeI,5211
-isar/state_machine/states/stopping.py,sha256=h0x94hVoIUJyml3WMrbJlbxG2dzMCeOL1rJoNCQfzGQ,3057
-isar/state_machine/states/stopping_go_to_lockdown.py,sha256=npbz0aFbbCpsEbmBYc8wE9DZXztkLkRB-OD7tslbE0c,3166
-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/states/paused.py,sha256=T1R66rcVPevDQSzYAHnAicSSJ0LvPuGWz8fD-mX_jzo,2833
+isar/state_machine/states/pausing.py,sha256=uO6SpV8A2Rrx3P4r8TvBOH1Z9RxA8FvP5RBdEFXKybI,2723
+isar/state_machine/states/pausing_return_home.py,sha256=6sKpLswUQl64bZGl3wX_A0d6z9MYsF511AUSDyWpkho,2769
+isar/state_machine/states/recharging.py,sha256=TSCZuWhDKBW47peeP73k7aBD4_SEMOOdD1GgOdAq6lk,2447
+isar/state_machine/states/return_home_paused.py,sha256=rr5iy8u6zaTMZAGtlf1HlroVShjytxKjE6t-wGym8nU,3355
+isar/state_machine/states/returning_home.py,sha256=8TaEgOHWbxZKJ0XJhQVP5ljrAJ3hinVpHAEunsRi2vU,5171
+isar/state_machine/states/stopping.py,sha256=6ahiz1LowqOJFCamcdFEwVvd2vnDZe60nwVoiV8Lnx0,3047
+isar/state_machine/states/stopping_go_to_lockdown.py,sha256=Xuow75GFwXOH15CUQIsBrJj01bxX3YQq7xQh0zfpClo,3086
+isar/state_machine/states/stopping_return_home.py,sha256=YtLa-XE7J_bU-GOj_GjWek7e2fKKn2JDQHoxjDx9nGo,2903
+isar/state_machine/states/unknown_status.py,sha256=Vu07Sk90zFVInf3XdzFl5IaYrdrYaGO7Na7qAOGwjIk,1871
 isar/state_machine/transitions/mission.py,sha256=lwXdC5Jn19gO-wrSaZp3_77mLnvj-CaBYZk61U-qgoo,8211
 isar/state_machine/transitions/return_home.py,sha256=ho4Nae-C5BaxVFciFL546EuoMSDIWLqT58E8bNraW4o,6749
 isar/state_machine/transitions/robot_status.py,sha256=qJMurCpuficOiXs9us4lZJ5p_kOFSwKxJigiXfB1OS8,2430
@@ -98,14 +98,14 @@ isar/state_machine/transitions/functions/robot_status.py,sha256=bA8G5WtY7TA88MKp
 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
-isar/state_machine/utils/common_event_handlers.py,sha256=LqXPB4qojzz0LqKF14g4pUd0HYBqZiCV83I4UMgy9DY,6450
+isar/state_machine/utils/common_event_handlers.py,sha256=Wbka89VCkRjLkeO_lM-tduPF9JQ1Pf8ItrYSEa-0Shg,6365
 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=0BBrxyZGGRkNxGeZeoREucegs4yKUow2523oLEie07o,10841
 isar/storage/utilities.py,sha256=oLH0Rp7UtrQQdilfITnmXO1Z0ExdeDhBImYHid55vBA,3449
-isar-1.33.8.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
+isar-1.33.9.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
@@ -129,8 +129,8 @@ robot_interface/telemetry/payloads.py,sha256=A0SWiG609k6o6-Y3vhDWE6an2-_m7D_ND85
 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.8.dist-info/METADATA,sha256=0a9aP_euTxYn_zJaBBvt1LXK8w92gQU2GOLmDr0PJ-Y,31190
-isar-1.33.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isar-1.33.8.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.33.8.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.33.8.dist-info/RECORD,,
+isar-1.33.9.dist-info/METADATA,sha256=uu6Ab1WekJ79wzhxEhXbiaD62BVjAwHIzY1QlrKBC2o,31216
+isar-1.33.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isar-1.33.9.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
+isar-1.33.9.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
+isar-1.33.9.dist-info/RECORD,,