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

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/storage/uploader.py

@@ -146,6 +146,9 @@ class Uploader:
                     )
             except Empty:
                 continue
+            except Exception as e:
+                self.logger.error(f"Unexpected error in uploader thread: {e}")
+                continue
 
     def _upload(self, item: BlobItem) -> StoragePaths:
         inspection_paths: StoragePaths

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.7
+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