isar 1.26.0__py3-none-any.whl → 1.26.1__py3-none-any.whl

isar/state_machine/states/monitor.py

@@ -1,12 +1,14 @@
 import logging
 import time
 from copy import deepcopy
-from typing import TYPE_CHECKING, Callable, Optional, Tuple
+from queue import Queue
+from typing import TYPE_CHECKING, Optional, Tuple
 
 from injector 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.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
@@ -29,6 +31,9 @@ class Monitor(State):
         self.state_machine: "StateMachine" = state_machine
 
         self.logger = logging.getLogger("state_machine")
+        self.events = self.state_machine.events
+
+        self.awaiting_task_status: bool = False
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -38,109 +43,132 @@ class Monitor(State):
         self.state_machine.mission_ongoing = False
         return
 
-    def _run(self) -> None:
-        awaiting_task_status: bool = False
-        transition: Callable
-        while True:
-            if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop  # type: ignore
-                break
+    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_pause_mission_event(self, event: Queue) -> bool:
+        if check_for_event(event):
+            self.state_machine.pause()  # type: ignore
+            return True
+        return False
+
+    def _check_and_handle_mission_started_event(self, event: Queue) -> None:
+        if not self.state_machine.mission_ongoing:
+            if check_for_event(event):
+                self.state_machine.mission_ongoing = True
+
+    def _check_and_handle_mission_failed_event(self, event: Queue) -> bool:
+        mission_failed: Optional[ErrorMessage] = check_for_event(event)
+        if mission_failed is not None:
+            self.state_machine.logger.warning(
+                f"Failed to initiate mission "
+                f"{str(self.state_machine.current_mission.id)[:8]} because: "
+                f"{mission_failed.error_description}"
+            )
+            self.state_machine.current_mission.error_message = ErrorMessage(
+                error_reason=mission_failed.error_reason,
+                error_description=mission_failed.error_description,
+            )
 
-            if self.state_machine.should_pause_mission():
-                transition = self.state_machine.pause  # type: ignore
-                break
+            self.state_machine.mission_failed_to_start()  # type: ignore
+            return True
+        return False
 
-            if not self.state_machine.mission_ongoing:
-                if self.state_machine.get_mission_started_event():
-                    self.state_machine.mission_ongoing = True
-                else:
-                    time.sleep(settings.FSM_SLEEP_TIME)
-                    continue
-
-            mission_failed = self.state_machine.get_mission_failed_event()
-            if mission_failed is not None:
-                self.state_machine.logger.warning(
-                    f"Failed to initiate mission "
-                    f"{str(self.state_machine.current_mission.id)[:8]} because: "
-                    f"{mission_failed.error_description}"
-                )
-                self.state_machine.current_mission.error_message = ErrorMessage(
-                    error_reason=mission_failed.error_reason,
-                    error_description=mission_failed.error_description,
-                )
+    def _check_and_handle_task_status_failed_event(self, event: Queue) -> bool:
+        task_failure: Optional[ErrorMessage] = check_for_event(event)
+        if task_failure is not None:
+            self.awaiting_task_status = False
+            self.state_machine.current_task.error_message = task_failure
+            self.logger.error(
+                f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
+                f"because: {task_failure.error_description}"
+            )
+            return self._handle_new_task_status(TaskStatus.Failed)
+        elif not self.awaiting_task_status:
+            trigger_event(
+                self.events.state_machine_events.task_status_request,
+                self.state_machine.current_task.id,
+            )
+            self.awaiting_task_status = True
+        return False
+
+    def _check_and_handle_task_status_event(self, event: Queue) -> bool:
+        status: Optional[TaskStatus] = check_for_event(event)
+        if status is not None:
+            self.awaiting_task_status = False
+            return self._handle_new_task_status(status)
+        elif not self.awaiting_task_status:
+            trigger_event(
+                self.events.state_machine_events.task_status_request,
+                self.state_machine.current_task.id,
+            )
+            self.awaiting_task_status = True
+        return False
 
-                transition = self.state_machine.mission_failed_to_start  # type: ignore
-                break
+    def _handle_new_task_status(self, status: TaskStatus) -> bool:
+        if self.state_machine.current_task is None:
+            self.state_machine.iterate_current_task()
 
-            status: TaskStatus
+        self.state_machine.current_task.status = status
 
-            task_failure: Optional[ErrorMessage] = (
-                self.state_machine.get_task_failure_event()
+        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 task_failure is not None:
-                self.state_machine.current_task.error_message = task_failure
-                self.logger.error(
-                    f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
-                    f"because: {task_failure.error_description}"
-                )
-                status = TaskStatus.Failed
-            else:
-                status = self.state_machine.get_task_status_event()
-
-            if status is None:
-                if not awaiting_task_status:
-                    self.state_machine.request_task_status(
-                        self.state_machine.current_task
-                    )
-                    awaiting_task_status = True
-                time.sleep(settings.FSM_SLEEP_TIME)
-                continue
-            else:
-                awaiting_task_status = False
-
-            if not isinstance(status, TaskStatus):
-                self.logger.error(
-                    f"Received an invalid status update {status} when monitoring mission. "
-                    "Only TaskStatus is expected."
-                )
-                break
 
+        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)
+
+            self.state_machine.iterate_current_task()
             if self.state_machine.current_task is None:
-                self.state_machine.iterate_current_task()
+                self.state_machine.mission_finished()  # type: ignore
+                return True
 
-            self.state_machine.current_task.status = status
+            # Report and update next task
+            self.state_machine.current_task.update_task_status()
+            self.state_machine.publish_task_status(task=self.state_machine.current_task)
+        return False
 
-            if (
-                not settings.UPLOAD_INSPECTIONS_ASYNC
-                and self._should_upload_inspections()
+    def _run(self) -> None:
+        self.awaiting_task_status = False
+        while True:
+            if self._check_and_handle_stop_mission_event(
+                self.events.api_requests.stop_mission.input
             ):
-                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",
-                )
+                break
 
-            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._check_and_handle_pause_mission_event(
+                self.events.api_requests.pause_mission.input
+            ):
+                break
 
-                self.state_machine.iterate_current_task()
-                if self.state_machine.current_task is None:
-                    transition = self.state_machine.mission_finished  # type: ignore
-                    break
+            self._check_and_handle_mission_started_event(
+                self.events.robot_service_events.mission_started
+            )
 
-                # Report and update next task
-                self.state_machine.current_task.update_task_status()
-                self.state_machine.publish_task_status(
-                    task=self.state_machine.current_task
-                )
+            if self._check_and_handle_mission_failed_event(
+                self.events.robot_service_events.mission_failed
+            ):
+                break
+
+            if self._check_and_handle_task_status_failed_event(
+                self.events.robot_service_events.task_status_failed
+            ):
+                break
+
+            if self._check_and_handle_task_status_event(
+                self.events.robot_service_events.task_status_updated
+            ):
+                break
 
-        transition()
+            time.sleep(settings.FSM_SLEEP_TIME)
 
     def _queue_inspections_for_upload(
         self, mission: Mission, current_task: InspectionTask
@@ -163,6 +191,12 @@ class Monitor(State):
             )
             return
 
+        except Exception as e:
+            self.logger.error(
+                f"Failed to retrieve inspections because of unexpected error: {e}"
+            )
+            return
+
         if not inspection:
             self.logger.warning(
                 f"No inspection result data retrieved for task {str(current_task.id)[:8]}"
@@ -174,7 +208,7 @@ class Monitor(State):
             inspection,
             mission,
         )
-        self.state_machine.queues.upload_queue.put(message)
+        self.state_machine.events.upload_queue.put(message)
         self.logger.info(
             f"Inspection result: {str(inspection.id)[:8]} queued for upload"
         )
@@ -190,6 +224,9 @@ class Monitor(State):
             )
 
     def _should_upload_inspections(self) -> bool:
+        if settings.UPLOAD_INSPECTIONS_ASYNC:
+            return False
+
         return (
             self.state_machine.current_task.is_finished()
             and self.state_machine.current_task.status == TaskStatus.Successful

isar/state_machine/states/offline.py

@@ -4,6 +4,7 @@ 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
 
 if TYPE_CHECKING:
@@ -15,6 +16,7 @@ class Offline(State):
         super().__init__(name="offline", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
+        self.shared_state = self.state_machine.shared_state
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -25,7 +27,9 @@ class Offline(State):
 
     def _run(self) -> None:
         while True:
-            robot_status = self.state_machine.get_robot_status()
+            robot_status: RobotStatus = check_shared_state(
+                self.shared_state.robot_status
+            )
             if robot_status == RobotStatus.BlockedProtectiveStop:
                 transition = self.state_machine.robot_protective_stop_engaged  # type: ignore
                 break

isar/state_machine/states/paused.py

@@ -4,6 +4,8 @@ from typing import TYPE_CHECKING, Callable
 
 from transitions import State
 
+from isar.models.communication.queues.queue_utils import check_for_event
+
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
@@ -13,6 +15,7 @@ class Paused(State):
         super().__init__(name="paused", on_enter=self.start)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
+        self.events = self.state_machine.events
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -21,11 +24,11 @@ class Paused(State):
     def _run(self) -> None:
         transition: Callable
         while True:
-            if self.state_machine.should_stop_mission():
+            if check_for_event(self.events.api_requests.pause_mission.input):
                 transition = self.state_machine.stop  # type: ignore
                 break
 
-            if self.state_machine.should_resume_mission():
+            if check_for_event(self.events.api_requests.resume_mission.input):
                 transition = self.state_machine.resume  # type: ignore
                 break
 

isar/state_machine/states/stop.py

@@ -1,18 +1,13 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Callable, Optional
+from queue import Queue
+from typing import TYPE_CHECKING, Optional
 
 from transitions import State
 
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
-from robot_interface.models.exceptions.robot_exceptions import (
-    ErrorMessage,
-    RobotActionException,
-    RobotException,
-)
+from isar.models.communication.queues.queue_utils import check_for_event
+from isar.services.utilities.threaded_request import ThreadedRequest
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -23,6 +18,7 @@ class Stop(State):
         super().__init__(name="stop", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
+        self.events = self.state_machine.events
         self.stop_thread: Optional[ThreadedRequest] = None
         self._count_number_retries: int = 0
 
@@ -36,56 +32,31 @@ class Stop(State):
         self.stop_thread = None
         self._count_number_retries = 0
 
-    def _run(self) -> None:
-        transition: Callable
-        while True:
-            if not self.stop_thread:
-                self.stop_thread = ThreadedRequest(self.state_machine.robot.stop)
-                self.stop_thread.start_thread(name="State Machine Stop Robot")
-
-            try:
-                self.stop_thread.get_output()
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except (RobotActionException, RobotException) as e:
-                if self.handle_stop_fail(
-                    retry_limit=self.state_machine.stop_robot_attempts_limit,
-                    error_message=ErrorMessage(
-                        error_reason=e.error_reason,
-                        error_description=e.error_description,
-                    ),
-                ):
-                    transition = self.state_machine.mission_stopped  # type: ignore
-                    break
-
-                self.logger.warning(
-                    f"\nFailed to stop robot because: {e.error_description}"
-                    f"\nAttempting to stop the robot again"
-                )
-
-                self.stop_thread = None
-                continue
-
-            transition = self.state_machine.mission_stopped  # type: ignore
+    def _check_and_handle_failed_stop(self, event: Queue[ErrorMessage]) -> bool:
+        error_message: Optional[ErrorMessage] = check_for_event(event)
+        if error_message is not None:
+            self.logger.warning(error_message.error_description)
+            self.state_machine.mission_stopped()  # type: ignore
+            return True
+        return False
 
-            break
+    def _check_and_handle_successful_stop(self, event: Queue[bool]) -> bool:
+        if check_for_event(event):
+            self.state_machine.mission_stopped()  # type: ignore
+            return True
+        return False
 
-        transition()
+    def _run(self) -> None:
+        while True:
 
-    def handle_stop_fail(self, retry_limit: int, error_message: ErrorMessage) -> bool:
-        self._count_number_retries += 1
-        if self._count_number_retries > retry_limit:
-            self.state_machine.current_task.error_message = error_message
+            if self._check_and_handle_failed_stop(
+                self.events.robot_service_events.mission_failed_to_stop
+            ):
+                break
 
-            self.logger.error(
-                f"\nFailed to stop the robot after {retry_limit} attempts because: "
-                f"{error_message.error_description}"
-                f"\nBe aware that the robot may still be moving even though a stop has "
-                "been attempted"
-            )
+            if self._check_and_handle_successful_stop(
+                self.events.robot_service_events.mission_successfully_stopped
+            ):
+                break
 
-            return True
-        time.sleep(self.state_machine.sleep_time)
-        return False
+            time.sleep(self.state_machine.sleep_time)

isar/state_machine/transitions/pause.py

@@ -15,7 +15,7 @@ def pause_mission(state_machine: "StateMachine") -> bool:
     paused_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()
     )
-    state_machine.queues.api_pause_mission.output.put(paused_mission_response)
+    state_machine.events.api_requests.pause_mission.output.put(paused_mission_response)
 
     state_machine.publish_mission_status()
     state_machine.publish_task_status(task=state_machine.current_task)

isar/state_machine/transitions/resume.py

@@ -21,7 +21,7 @@ def resume_mission(state_machine: "StateMachine") -> bool:
     resume_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()
     )
-    state_machine.queues.api_resume_mission.output.put(resume_mission_response)
+    state_machine.events.api_requests.resume_mission.output.put(resume_mission_response)
 
     state_machine.robot.resume()
     return True

isar/state_machine/transitions/start_mission.py

@@ -12,7 +12,7 @@ from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def put_start_mission_on_queue(state_machine: "StateMachine") -> bool:
-    state_machine.queues.api_start_mission.output.put(True)
+    state_machine.events.api_requests.start_mission.output.put(True)
     return True
 
 
@@ -62,12 +62,12 @@ def set_mission_to_in_progress(state_machine: "StateMachine") -> bool:
 
 
 def trigger_start_mission_or_task_event(state_machine: "StateMachine") -> bool:
-    state_machine.queues.state_machine_start_mission.input.put(
+    state_machine.events.state_machine_events.start_mission.put(
         state_machine.current_mission
     )
     return True
 
 
 def _initialization_failed(state_machine: "StateMachine") -> None:
-    state_machine.queues.api_start_mission.output.put(False)
+    state_machine.events.api_requests.start_mission.output.put(False)
     state_machine._finalize()

isar/state_machine/transitions/stop.py

@@ -1,5 +1,7 @@
 from typing import TYPE_CHECKING
 
+from isar.models.communication.queues.queue_utils import trigger_event_without_data
+
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
@@ -7,7 +9,12 @@ from isar.apis.models.models import ControlMissionResponse
 from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
-def stop_mission(state_machine: "StateMachine") -> bool:
+def trigger_stop_mission_event(state_machine: "StateMachine") -> bool:
+    trigger_event_without_data(state_machine.events.state_machine_events.stop_mission)
+    return True
+
+
+def stop_mission_cleanup(state_machine: "StateMachine") -> bool:
     if state_machine.current_mission is None:
         state_machine._queue_empty_response()
         state_machine.reset_state_machine()
@@ -26,7 +33,7 @@ def stop_mission(state_machine: "StateMachine") -> bool:
     stopped_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()
     )
-    state_machine.queues.api_stop_mission.output.put(stopped_mission_response)
+    state_machine.events.api_requests.stop_mission.output.put(stopped_mission_response)
 
     state_machine.publish_task_status(task=state_machine.current_task)
     state_machine._finalize()

isar/storage/uploader.py

@@ -8,7 +8,7 @@ from typing import List, Union
 from injector import inject
 
 from isar.config.settings import settings
-from isar.models.communication.queues.queues import Queues
+from isar.models.communication.queues.events import Events
 from isar.storage.storage_interface import StorageException, StorageInterface
 from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
@@ -48,7 +48,7 @@ class Uploader:
     @inject
     def __init__(
         self,
-        queues: Queues,
+        events: Events,
         storage_handlers: List[StorageInterface],
         mqtt_publisher: MqttClientInterface,
         max_wait_time: int = settings.UPLOAD_FAILURE_MAX_WAIT,
@@ -58,8 +58,8 @@ class Uploader:
 
         Parameters
         ----------
-        queues : Queues
-            Queues used for cross-thread communication.
+        events : Events
+            Events used for cross-thread communication.
         storage_handlers : List[StorageInterface]
             List of handlers for different upload options
         max_wait_time : float
@@ -67,7 +67,7 @@ class Uploader:
         max_retry_attempts : int
             Maximum attempts to retry an upload when it fails
         """
-        self.upload_queue: Queue = queues.upload_queue
+        self.upload_queue: Queue = events.upload_queue
         self.storage_handlers: List[StorageInterface] = storage_handlers
         self.mqtt_publisher = mqtt_publisher
 

{isar-1.26.0.dist-info → isar-1.26.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: isar
-Version: 1.26.0
+Version: 1.26.1
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -95,6 +95,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Software Development :: Libraries
@@ -137,6 +138,7 @@ Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: requests-mock; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
 
 # ISAR
 
@@ -254,21 +256,6 @@ In [this](./src/isar/config/predefined_missions) folder there are predefined def
 corresponding to `mission_id=1`. A new mission may be added by adding a new json-file with a mission description. Note,
 the mission IDs must be unique.
 
-### Running with docker-compose
-
-ISAR may be started with an instance of the [isar-robot](https://github.com/equinor/isar-robot) package by
-
-```shell
-docker-compose up --build
-```
-
-Provided that the simulator from [isar-turtlebot](https://github.com/equinor/isar-turtlebot) is running ISAR may be
-started with the turtlebot by
-
-```shell
-docker-compose -f docker-compose-turtlebot.yml up --build
-```
-
 ### Configuration
 
 The system consists of many configuration variables which may alter the functionality. As an example, it is possible to