isar 1.30.2__tar.gz → 1.30.3__tar.gz

{isar-1.30.2 → isar-1.30.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.30.2
+Version: 1.30.3
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.30.2 → isar-1.30.3}/requirements.txt

@@ -4,7 +4,7 @@
 #
 #    pip-compile --output-file=requirements.txt pyproject.toml
 #
-alitra==1.1.3
+alitra==1.1.5
     # via isar (pyproject.toml)
 annotated-types==0.7.0
     # via pydantic
@@ -12,7 +12,7 @@ anyio==4.9.0
     # via
     #   httpx
     #   starlette
-azure-core==1.34.0
+azure-core==1.35.0
     # via
     #   azure-identity
     #   azure-keyvault-secrets
@@ -43,7 +43,7 @@ click==8.2.1
     # via
     #   isar (pyproject.toml)
     #   uvicorn
-cryptography==45.0.4
+cryptography==45.0.5
     # via
     #   azure-identity
     #   azure-storage-blob
@@ -54,9 +54,9 @@ dacite==1.9.2
     # via
     #   alitra
     #   isar (pyproject.toml)
-dependency-injector==4.48.0
+dependency-injector==4.48.1
     # via isar (pyproject.toml)
-fastapi==0.115.13
+fastapi==0.115.14
     # via
     #   fastapi-azure-auth
     #   isar (pyproject.toml)
@@ -91,7 +91,7 @@ msal==1.32.3
     #   msal-extensions
 msal-extensions==1.3.1
     # via azure-identity
-numpy==2.3.0
+numpy==2.3.1
     # via
     #   alitra
     #   isar (pyproject.toml)
@@ -135,14 +135,14 @@ pydantic==2.11.7
     #   pydantic-settings
 pydantic-core==2.33.2
     # via pydantic
-pydantic-settings==2.9.1
+pydantic-settings==2.10.1
     # via isar (pyproject.toml)
 pyjwt[crypto]==2.10.1
     # via
     #   fastapi-azure-auth
     #   isar (pyproject.toml)
     #   msal
-python-dotenv==1.1.0
+python-dotenv==1.1.1
     # via
     #   isar (pyproject.toml)
     #   pydantic-settings
@@ -161,7 +161,7 @@ requests-toolbelt==1.0.0
     # via isar (pyproject.toml)
 rsa==4.9.1
     # via google-auth
-scipy==1.15.3
+scipy==1.16.0
     # via alitra
 six==1.17.0
     # via
@@ -172,7 +172,7 @@ sniffio==1.3.1
     # via anyio
 starlette==0.46.2
     # via fastapi
-transitions==0.9.2
+transitions==0.9.3
     # via isar (pyproject.toml)
 typing-extensions==4.14.0
     # via
@@ -188,9 +188,9 @@ typing-inspection==0.4.1
     # via
     #   pydantic
     #   pydantic-settings
-urllib3==2.4.0
+urllib3==2.5.0
     # via requests
-uvicorn==0.34.3
+uvicorn==0.35.0
     # via isar (pyproject.toml)
 wrapt==1.17.2
     # via opencensus-ext-requests

{isar-1.30.2 → isar-1.30.3}/src/isar/config/settings.py

@@ -66,6 +66,7 @@ class Settings(BaseSettings):
     ROBOT_HEARTBEAT_PUBLISH_INTERVAL: float = Field(default=1)
     ROBOT_INFO_PUBLISH_INTERVAL: float = Field(default=5)
     ROBOT_API_STATUS_POLL_INTERVAL: float = Field(default=5)
+    THREAD_CHECK_INTERVAL: float = Field(default=0.01)
 
     # FastAPI host
     API_HOST_VIEWED_EXTERNALLY: str = Field(default="0.0.0.0")

{isar-1.30.2 → isar-1.30.3}/src/isar/robot/robot_start_mission.py

@@ -40,6 +40,18 @@ class RobotStartMissionThread(Thread):
                     return
                 try:
                     self.robot.initiate_mission(self.mission)
+                except RobotInfeasibleMissionException as e:
+                    self.logger.error(
+                        f"Mission is infeasible and cannot be scheduled because: {e.error_description}"
+                    )
+                    trigger_event(
+                        self.robot_service_events.mission_failed,
+                        ErrorMessage(
+                            error_reason=e.error_reason,
+                            error_description=e.error_description,
+                        ),
+                    )
+                    break
                 except RobotException as e:
                     retries += 1
                     self.logger.warning(

{isar-1.30.2 → isar-1.30.3}/src/isar/robot/robot_status.py

@@ -40,14 +40,16 @@ class RobotStatusThread(Thread):
         if self.signal_thread_quitting.is_set():
             return
 
-        while not self.signal_thread_quitting.wait(0.001):
+        thread_check_interval = settings.THREAD_CHECK_INTERVAL
+
+        while not self.signal_thread_quitting.wait(thread_check_interval):
             if not self._is_ready_to_poll_for_status():
                 continue
             try:
-                robot_status = self.robot.robot_status()
+                self.last_robot_status_poll_time = time.time()
 
+                robot_status = self.robot.robot_status()
                 update_shared_state(self.shared_state.robot_status, robot_status)
-                self.last_robot_status_poll_time = time.time()
             except RobotException as e:
                 self.logger.error(f"Failed to retrieve robot status: {e}")
                 continue

isar-1.30.2/src/isar/state_machine/states/robot_standing_still.py → isar-1.30.3/src/isar/state_machine/generic_states/idle.py

@@ -1,10 +1,10 @@
 import logging
 import time
+from enum import Enum
 from queue import Queue
 from typing import TYPE_CHECKING, Optional
 
-from transitions import State
-
+from isar.config.settings import settings
 from isar.models.communication.message import StartMissionMessage
 from isar.models.communication.queues.queue_io import QueueIO
 from isar.models.communication.queues.queue_utils import (
@@ -18,30 +18,41 @@ if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class RobotStandingStill(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(
-            name="robot_standing_still", on_enter=self.start, on_exit=self.stop
-        )
+class IdleStates(str, Enum):
+    AwaitNextMission = "awaitNextMission"
+    Home = "home"
+    RobotStandingStill = "robotStandingStill"
+
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Idle:
+    def __init__(
+        self,
+        state_machine: "StateMachine",
+        state: IdleStates,
+    ) -> None:
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
-        self.events = self.state_machine.events
+        self.events = state_machine.events
         self.shared_state = self.state_machine.shared_state
         self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
+        self.state: IdleStates = state
+
+        # Only used for await_next_mission state
+        self.entered_time: float = time.time()
+        self.return_home_delay: float = settings.RETURN_HOME_DELAY
 
     def start(self) -> None:
         self.state_machine.update_state()
+        self.entered_time = time.time()
         self._run()
 
     def stop(self) -> None:
         return
 
-    def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
-        if check_for_event(event):
-            self.state_machine.stop()  # type: ignore
-            return True
-        return False
-
     def _check_and_handle_start_mission_event(
         self, event: Queue[StartMissionMessage]
     ) -> bool:
@@ -63,17 +74,32 @@ class RobotStandingStill(State):
         self, event: StatusQueue[RobotStatus]
     ) -> bool:
         robot_status: RobotStatus = check_shared_state(event)
-        if robot_status != RobotStatus.Available:
+
+        expected_robot_status = (
+            RobotStatus.Home if self.state == IdleStates.Home else RobotStatus.Available
+        )
+
+        if robot_status != expected_robot_status:
             self.state_machine.robot_status_changed()  # type: ignore
             return True
 
         return False
 
+    def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
+        if check_for_event(event):
+            self.state_machine.stop()  # type: ignore
+            return True
+        return False
+
+    def _should_return_home(self) -> bool:
+        time_since_entered = time.time() - self.entered_time
+        return time_since_entered > self.return_home_delay
+
     def _run(self) -> None:
         while True:
             if self.signal_state_machine_to_stop.is_set():
                 self.logger.info(
-                    "Stopping state machine from %s state", self.__class__.__name__
+                    "Stopping state machine from %s state", self.state.name
                 )
                 break
 
@@ -92,9 +118,16 @@ class RobotStandingStill(State):
             ):
                 break
 
-            if self._check_and_handle_robot_status_event(
-                self.shared_state.robot_status
+            if (
+                self.state != IdleStates.AwaitNextMission
+                and self._check_and_handle_robot_status_event(
+                    self.shared_state.robot_status
+                )
             ):
                 break
 
+            if self.state == IdleStates.AwaitNextMission and self._should_return_home():
+                self.state_machine.request_return_home()  # type: ignore
+                break
+
             time.sleep(self.state_machine.sleep_time)

isar-1.30.2/src/isar/state_machine/states/monitor.py → isar-1.30.3/src/isar/state_machine/generic_states/ongoing_mission.py

@@ -1,15 +1,18 @@
 import logging
 import time
 from copy import deepcopy
+from enum import Enum
 from queue import Queue
 from threading import Event
 from typing import TYPE_CHECKING, Optional, Tuple
 
-from dependency_injector.wiring import inject
-from transitions import State
-
 from isar.config.settings import settings
-from isar.models.communication.queues.queue_utils import check_for_event, trigger_event
+from isar.models.communication.message import StartMissionMessage
+from isar.models.communication.queues.queue_utils import (
+    check_for_event,
+    check_for_event_without_consumption,
+    trigger_event,
+)
 from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
@@ -21,24 +24,30 @@ from robot_interface.models.mission.mission import Mission
 from robot_interface.models.mission.status import TaskStatus
 from robot_interface.models.mission.task import InspectionTask, Task
 
+
+class OngoingMissionStates(str, Enum):
+    Monitor = "monitor"
+    ReturningHome = "returningHome"
+
+
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class Monitor(State):
-    @inject
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="monitor", on_enter=self.start, on_exit=self.stop)
+class OngoingMission:
+    def __init__(
+        self,
+        state_machine: "StateMachine",
+        state: OngoingMissionStates,
+    ) -> None:
         self.state_machine: "StateMachine" = state_machine
-
         self.logger = logging.getLogger("state_machine")
-        self.events = self.state_machine.events
-
+        self.events = state_machine.events
         self.awaiting_task_status: bool = False
-
         self.signal_state_machine_to_stop: Event = (
             state_machine.signal_state_machine_to_stop
         )
+        self.state: OngoingMissionStates = state
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -46,7 +55,6 @@ class Monitor(State):
 
     def stop(self) -> None:
         self.state_machine.mission_ongoing = False
-        return
 
     def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
         if check_for_event(event):
@@ -60,9 +68,11 @@ class Monitor(State):
             return True
         return False
 
-    def _check_and_handle_mission_started_event(self, event: Queue) -> None:
+    def _check_and_handle_mission_started_event(self, event: Queue) -> bool:
         if check_for_event(event):
             self.state_machine.mission_ongoing = True
+            return True
+        return False
 
     def _check_and_handle_mission_failed_event(self, event: Queue) -> bool:
         mission_failed: Optional[ErrorMessage] = check_for_event(event)
@@ -76,7 +86,6 @@ class Monitor(State):
                 error_reason=mission_failed.error_reason,
                 error_description=mission_failed.error_description,
             )
-
             self.state_machine.mission_failed_to_start()  # type: ignore
             return True
         return False
@@ -124,18 +133,27 @@ class Monitor(State):
 
         self.state_machine.current_task.status = status
 
-        if self._should_upload_inspections():
-            get_inspection_thread = ThreadedRequest(self._queue_inspections_for_upload)
-            get_inspection_thread.start_thread(
-                deepcopy(self.state_machine.current_mission),
-                deepcopy(self.state_machine.current_task),
-                name="State Machine Get Inspections",
-            )
-
         if self.state_machine.current_task.is_finished():
             self._report_task_status(self.state_machine.current_task)
             self.state_machine.publish_task_status(task=self.state_machine.current_task)
 
+            if self.state == OngoingMissionStates.ReturningHome:
+                if status != TaskStatus.Successful:
+                    self.state_machine.return_home_failed()  # type: ignore
+                    return True
+                self.state_machine.returned_home()  # type: ignore
+                return True
+
+            if self._should_upload_inspections():
+                get_inspection_thread = ThreadedRequest(
+                    self._queue_inspections_for_upload
+                )
+                get_inspection_thread.start_thread(
+                    deepcopy(self.state_machine.current_mission),
+                    deepcopy(self.state_machine.current_task),
+                    name="State Machine Get Inspections",
+                )
+
             self.state_machine.iterate_current_task()
             if self.state_machine.current_task is None:
                 self.state_machine.mission_finished()  # type: ignore
@@ -146,12 +164,21 @@ class Monitor(State):
             self.state_machine.publish_task_status(task=self.state_machine.current_task)
         return False
 
+    def _check_and_handle_start_mission_event(
+        self, event: Queue[StartMissionMessage]
+    ) -> bool:
+        if check_for_event_without_consumption(event):
+            self.state_machine.stop()  # type: ignore
+            return True
+
+        return False
+
     def _run(self) -> None:
         self.awaiting_task_status = False
         while True:
             if self.signal_state_machine_to_stop.is_set():
                 self.logger.info(
-                    "Stopping state machine from %s state", self.__class__.__name__
+                    "Stopping state machine from %s state", self.state.name
                 )
                 break
 
@@ -160,8 +187,11 @@ class Monitor(State):
             ):
                 break
 
-            if self._check_and_handle_pause_mission_event(
-                self.events.api_requests.pause_mission.input
+            if (
+                self.state == OngoingMissionStates.Monitor
+                and self._check_and_handle_pause_mission_event(
+                    self.events.api_requests.pause_mission.input
+                )
             ):
                 break
 
@@ -174,6 +204,14 @@ class Monitor(State):
             ):
                 break
 
+            if (
+                self.state == OngoingMissionStates.ReturningHome
+                and self._check_and_handle_start_mission_event(
+                    self.events.api_requests.start_mission.input
+                )
+            ):
+                break
+
             if self._check_and_handle_task_status_failed_event(
                 self.events.robot_service_events.task_status_failed
             ):

isar-1.30.2/src/isar/state_machine/states/offline.py → isar-1.30.3/src/isar/state_machine/generic_states/robot_unavailable.py

@@ -1,23 +1,32 @@
 import logging
 import time
+from enum import Enum
 from typing import TYPE_CHECKING
 
-from transitions import State
-
 from isar.models.communication.queues.queue_utils import check_shared_state
 from robot_interface.models.mission.status import RobotStatus
 
+
+class RobotUnavailableStates(str, Enum):
+    BlockedProtectiveStop = "blockedProtectiveStop"
+    Offline = "offline"
+
+
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class Offline(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="offline", on_enter=self.start, on_exit=self.stop)
+class RobotUnavailable:
+    def __init__(
+        self,
+        state_machine: "StateMachine",
+        state: RobotUnavailableStates,
+    ) -> None:
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
         self.shared_state = self.state_machine.shared_state
         self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
+        self.state: RobotUnavailableStates = state
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -30,7 +39,7 @@ class Offline(State):
         while True:
             if self.signal_state_machine_to_stop.is_set():
                 self.logger.info(
-                    "Stopping state machine from %s state", self.__class__.__name__
+                    "Stopping state machine from %s state", self.state.name
                 )
                 break
 
@@ -38,7 +47,12 @@ class Offline(State):
                 self.shared_state.robot_status
             )
 
-            if robot_status != RobotStatus.Offline:
+            expected_status = (
+                RobotStatus.BlockedProtectiveStop
+                if self.state == RobotUnavailableStates.BlockedProtectiveStop
+                else RobotStatus.Offline
+            )
+            if robot_status != expected_status:
                 transition = self.state_machine.robot_status_changed  # type: ignore
                 break
 

{isar-1.30.2 → isar-1.30.3}/src/isar/state_machine/state_machine.py

@@ -168,6 +168,9 @@ class StateMachine(object):
         self.signal_state_machine_to_stop.set()
 
     def iterate_current_task(self):
+        if self.current_task is None:
+            raise ValueError("No current task is set")
+
         if self.current_task.is_finished():
             try:
                 self.current_task = self.task_selector.next_task()
@@ -313,6 +316,12 @@ class StateMachine(object):
         self.logger.info("Mission overview:\n%s", log_statement)
 
     def _make_control_mission_response(self) -> ControlMissionResponse:
+        if self.current_mission is None:
+            raise ValueError("No current mission is set")
+
+        if self.current_task is None:
+            raise ValueError("No current task is set")
+
         return ControlMissionResponse(
             mission_id=self.current_mission.id,
             mission_status=self.current_mission.status,

isar-1.30.3/src/isar/state_machine/states/await_next_mission.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING
+
+from transitions import State
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from isar.state_machine.generic_states.idle import Idle, IdleStates
+
+
+class AwaitNextMission(State, Idle):
+    def __init__(self, state_machine: "StateMachine") -> None:
+        State.__init__(
+            self, name="await_next_mission", on_enter=self.start, on_exit=self.stop
+        )
+        Idle.__init__(
+            self,
+            state_machine=state_machine,
+            state=IdleStates.AwaitNextMission,
+        )

isar-1.30.3/src/isar/state_machine/states/blocked_protective_stop.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+
+from transitions import State
+
+from isar.state_machine.generic_states.robot_unavailable import (
+    RobotUnavailable,
+    RobotUnavailableStates,
+)
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class BlockedProtectiveStop(State, RobotUnavailable):
+    def __init__(self, state_machine: "StateMachine") -> None:
+        State.__init__(
+            self, name="blocked_protective_stop", on_enter=self.start, on_exit=self.stop
+        )
+
+        RobotUnavailable.__init__(
+            self,
+            state_machine=state_machine,
+            state=RobotUnavailableStates.BlockedProtectiveStop,
+        )

isar-1.30.3/src/isar/state_machine/states/home.py

@@ -0,0 +1,19 @@
+from typing import TYPE_CHECKING
+
+from transitions import State
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from isar.state_machine.generic_states.idle import Idle, IdleStates
+
+
+class Home(State, Idle):
+    def __init__(self, state_machine: "StateMachine") -> None:
+        State.__init__(self, name="home", on_enter=self.start, on_exit=self.stop)
+
+        Idle.__init__(
+            self,
+            state_machine=state_machine,
+            state=IdleStates.Home,
+        )

isar-1.30.3/src/isar/state_machine/states/monitor.py

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

isar-1.30.3/src/isar/state_machine/states/offline.py

@@ -0,0 +1,22 @@
+from typing import TYPE_CHECKING
+
+from transitions import State
+
+from isar.state_machine.generic_states.robot_unavailable import (
+    RobotUnavailable,
+    RobotUnavailableStates,
+)
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Offline(State, RobotUnavailable):
+    def __init__(self, state_machine: "StateMachine") -> None:
+        State.__init__(self, name="offline", on_enter=self.start, on_exit=self.stop)
+
+        RobotUnavailable.__init__(
+            self,
+            state_machine=state_machine,
+            state=RobotUnavailableStates.Offline,
+        )

{isar-1.30.2 → isar-1.30.3}/src/isar/state_machine/states/paused.py

@@ -31,7 +31,7 @@ class Paused(State):
                 )
                 break
 
-            if check_for_event(self.events.api_requests.pause_mission.input):
+            if check_for_event(self.events.api_requests.stop_mission.input):
                 transition = self.state_machine.stop  # type: ignore
                 break
 

isar-1.30.3/src/isar/state_machine/states/returning_home.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+
+from transitions import State
+
+from isar.state_machine.generic_states.ongoing_mission import (
+    OngoingMission,
+    OngoingMissionStates,
+)
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class ReturningHome(State, OngoingMission):
+    def __init__(self, state_machine: "StateMachine") -> None:
+        State.__init__(
+            self, name="returning_home", on_enter=self.start, on_exit=self.stop
+        )
+
+        OngoingMission.__init__(
+            self,
+            state_machine=state_machine,
+            state=OngoingMissionStates.ReturningHome,
+        )