isar 1.30.5__py3-none-any.whl → 1.31.1__py3-none-any.whl

isar/state_machine/states/unknown_status.py

@@ -1,74 +1,47 @@
-import logging
-import time
-from queue import Queue
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional
 
-from transitions import State
-
-from isar.models.communication.queues.queue_utils import (
-    check_for_event,
-    check_shared_state,
-)
-from isar.models.communication.queues.status_queue import StatusQueue
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import stop_mission_event_handler
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
 
-class UnknownStatus(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="unknown_status", 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.shared_state = self.state_machine.shared_state
-        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        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_robot_status_event(
-        self, event: StatusQueue[RobotStatus]
-    ) -> bool:
-        robot_status: RobotStatus = check_shared_state(event)
-        if (
-            robot_status == RobotStatus.Home
-            or robot_status == RobotStatus.Offline
-            or robot_status == RobotStatus.BlockedProtectiveStop
-            or robot_status == RobotStatus.Available
-        ):
-            self.state_machine.robot_status_changed()  # type: ignore
-            return True
+class UnknownStatus(EventHandlerBase):
 
-        return False
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
 
-    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__
-                )
-                break
-
-            if self._check_and_handle_stop_mission_event(
-                self.events.api_requests.stop_mission.input
-            ):
-                break
-
-            if self._check_and_handle_robot_status_event(
-                self.shared_state.robot_status
+        def _robot_status_event_handler(
+            event: Event[RobotStatus],
+        ) -> Optional[Callable]:
+            robot_status: RobotStatus = event.check()
+            if (
+                robot_status == RobotStatus.Home
+                or robot_status == RobotStatus.Offline
+                or robot_status == RobotStatus.BlockedProtectiveStop
+                or robot_status == RobotStatus.Available
             ):
-                break
-
-            time.sleep(self.state_machine.sleep_time)
+                return state_machine.robot_status_changed  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="stop_mission_event",
+                event=events.api_requests.stop_mission.input,
+                handler=lambda event: stop_mission_event_handler(state_machine, event),
+            ),
+            EventHandlerMapping(
+                name="robot_status_event",
+                event=shared_state.robot_status,
+                handler=_robot_status_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="unknown_status",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/transitions/functions/pause.py

@@ -3,22 +3,51 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
+import time
+
 from isar.apis.models.models import ControlMissionResponse
+from isar.config.settings import settings
+from robot_interface.models.exceptions.robot_exceptions import (
+    RobotActionException,
+    RobotException,
+)
 from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def pause_mission(state_machine: "StateMachine") -> bool:
     state_machine.logger.info("Pausing mission: %s", state_machine.current_mission.id)
-    state_machine.current_mission.status = MissionStatus.Paused
-    state_machine.current_task.status = TaskStatus.Paused
 
-    paused_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
-    )
-    state_machine.events.api_requests.pause_mission.output.put(paused_mission_response)
+    max_retries = settings.STATE_TRANSITION_NUM_RETIRES
+    retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
+
+    for attempt in range(max_retries):
+        try:
+            state_machine.robot.pause()
+            state_machine.current_mission.status = MissionStatus.Paused
+            state_machine.current_task.status = TaskStatus.Paused
+
+            paused_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+            state_machine.events.api_requests.pause_mission.output.put(
+                paused_mission_response
+            )
+
+            state_machine.publish_mission_status()
+            state_machine.publish_task_status(task=state_machine.current_task)
 
-    state_machine.publish_mission_status()
-    state_machine.publish_task_status(task=state_machine.current_task)
+            state_machine.logger.info("Mission paused successfully.")
+            return True
+        except RobotActionException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause mission failed: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+        except RobotException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause mission raised a RobotException: {e.error_description}"
+            )
+            time.sleep(retry_interval)
 
-    state_machine.robot.pause()
-    return True
+    state_machine.logger.error("Failed to pause mission after multiple attempts.")
+    return False

isar/state_machine/transitions/functions/resume.py

@@ -3,25 +3,54 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
+import time
+
 from isar.apis.models.models import ControlMissionResponse
+from isar.config.settings import settings
+from robot_interface.models.exceptions.robot_exceptions import (
+    RobotActionException,
+    RobotException,
+)
 from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def resume_mission(state_machine: "StateMachine") -> bool:
     state_machine.logger.info("Resuming mission: %s", state_machine.current_mission.id)
-    state_machine.current_mission.status = MissionStatus.InProgress
-    state_machine.current_mission.error_message = None
-    state_machine.current_task.status = TaskStatus.InProgress
-
-    state_machine.mission_ongoing = True
-
-    state_machine.publish_mission_status()
-    state_machine.publish_task_status(task=state_machine.current_task)
-
-    resume_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
-    )
-    state_machine.events.api_requests.resume_mission.output.put(resume_mission_response)
 
-    state_machine.robot.resume()
-    return True
+    max_retries = settings.STATE_TRANSITION_NUM_RETIRES
+    retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
+
+    for attempt in range(max_retries):
+        try:
+            state_machine.robot.resume()
+            state_machine.current_mission.status = MissionStatus.InProgress
+            state_machine.current_mission.error_message = None
+            state_machine.current_task.status = TaskStatus.InProgress
+
+            state_machine.mission_ongoing = True
+
+            state_machine.publish_mission_status()
+            state_machine.publish_task_status(task=state_machine.current_task)
+
+            resume_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+            state_machine.events.api_requests.resume_mission.output.put(
+                resume_mission_response
+            )
+
+            state_machine.logger.info("Mission resumed successfully.")
+            return True
+        except RobotActionException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to resume mission failed: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+        except RobotException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to resume mission raised a RobotException: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+
+    state_machine.logger.error("Failed to resume mission after multiple attempts.")
+    return False

isar/state_machine/transitions/functions/robot_status.py

@@ -1,6 +1,5 @@
 from typing import TYPE_CHECKING
 
-from isar.models.communication.queues.queue_utils import check_shared_state
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -8,20 +7,20 @@ if TYPE_CHECKING:
 
 
 def is_offline(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.Offline
 
 
 def is_available(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.Available
 
 
 def is_home(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.Home
 
 
 def is_blocked_protective_stop(state_machine: "StateMachine") -> bool:
-    robot_status = check_shared_state(state_machine.shared_state.robot_status)
+    robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.BlockedProtectiveStop

isar/state_machine/transitions/functions/stop.py

@@ -1,10 +1,5 @@
 from typing import TYPE_CHECKING
 
-from isar.models.communication.queues.queue_utils import (
-    check_for_event_without_consumption,
-    trigger_event_without_data,
-)
-
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
 
@@ -13,7 +8,7 @@ from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def trigger_stop_mission_event(state_machine: "StateMachine") -> bool:
-    trigger_event_without_data(state_machine.events.state_machine_events.stop_mission)
+    state_machine.events.state_machine_events.stop_mission.trigger_event(True)
     return True
 
 
@@ -56,9 +51,7 @@ def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
         state_machine.reset_state_machine()
         return True
 
-    if not check_for_event_without_consumption(
-        state_machine.events.api_requests.start_mission.input
-    ):
+    if not state_machine.events.api_requests.start_mission.input.has_event():
         state_machine.current_mission.status = MissionStatus.Cancelled
 
         for task in state_machine.current_mission.tasks:
@@ -81,9 +74,7 @@ def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
 
 
 def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
-    if check_for_event_without_consumption(
-        state_machine.events.api_requests.start_mission.input
-    ):
+    if state_machine.events.api_requests.start_mission.input.has_event():
         return True
     stopped_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()

isar/state_machine/transitions/mission.py

@@ -32,13 +32,23 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "pause",
             "source": state_machine.monitor_state,
             "dest": state_machine.paused_state,
-            "before": def_transition(state_machine, pause_mission),
+            "conditions": def_transition(state_machine, pause_mission),
+        },
+        {
+            "trigger": "pause",
+            "source": state_machine.monitor_state,
+            "dest": state_machine.monitor_state,
         },
         {
             "trigger": "resume",
             "source": state_machine.paused_state,
             "dest": state_machine.monitor_state,
-            "before": def_transition(state_machine, resume_mission),
+            "conditions": def_transition(state_machine, resume_mission),
+        },
+        {
+            "trigger": "resume",
+            "source": state_machine.paused_state,
+            "dest": state_machine.paused_state,
         },
         {
             "trigger": "stop",

isar/state_machine/transitions/return_home.py

@@ -63,7 +63,7 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "return_home_failed",
             "source": state_machine.returning_home_state,
             "dest": state_machine.robot_standing_still_state,
-            "before": def_transition(state_machine, return_home_finished),
+            "before": def_transition(state_machine, report_failed_mission_and_finalize),
         },
     ]
     return return_home_transitions

isar/state_machine/utils/common_event_handlers.py

@@ -0,0 +1,166 @@
+from typing import TYPE_CHECKING, Callable, Optional
+
+from isar.apis.models.models import ControlMissionResponse
+from isar.models.events import Event
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import RobotStatus, TaskStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+def start_mission_event_handler(
+    state_machine: "StateMachine", event: Event[Mission]
+) -> Optional[Callable]:
+    mission: Optional[Mission] = event.consume_event()
+    if mission:
+        state_machine.start_mission(mission=mission)
+        return state_machine.request_mission_start  # type: ignore
+    return None
+
+
+def return_home_event_handler(
+    state_machine: "StateMachine", event: Event[bool]
+) -> Optional[Callable]:
+    if event.consume_event():
+        state_machine.events.api_requests.return_home.output.put(True)
+        return state_machine.request_return_home  # type: ignore
+    return None
+
+
+def robot_status_event_handler(
+    state_machine: "StateMachine",
+    expected_status: RobotStatus,
+    event: Event[RobotStatus],
+) -> Optional[Callable]:
+    robot_status: RobotStatus = event.check()
+    if robot_status != expected_status:
+        return state_machine.robot_status_changed  # type: ignore
+    return None
+
+
+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.output.put(
+                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
+
+
+def mission_started_event_handler(
+    state_machine: "StateMachine",
+    event: Event[bool],
+) -> Optional[Callable]:
+    if event.consume_event():
+        state_machine.mission_ongoing = True
+    return None
+
+
+def mission_failed_event_handler(
+    state_machine: "StateMachine",
+    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
+
+
+def task_status_failed_event_handler(
+    state_machine: "StateMachine",
+    handle_task_completed: Callable[[TaskStatus], Callable],
+    event: Event[Optional[ErrorMessage]],
+) -> Optional[Callable]:
+    if not state_machine.mission_ongoing:
+        return None
+
+    task_failure: Optional[ErrorMessage] = event.consume_event()
+    if task_failure is not None:
+        if state_machine.current_task is None:
+            state_machine.logger.warning(
+                "Received task status failed event when no task was running"
+            )
+            return None
+        state_machine.awaiting_task_status = False
+        state_machine.current_task.error_message = task_failure
+        state_machine.logger.error(
+            f"Monitoring task {state_machine.current_task.id[:8]} failed "
+            f"because: {task_failure.error_description}"
+        )
+        return _handle_new_task_status(
+            state_machine, handle_task_completed, TaskStatus.Failed
+        )
+
+    elif (
+        not state_machine.awaiting_task_status
+        and state_machine.current_task is not None
+    ):
+        state_machine.events.state_machine_events.task_status_request.trigger_event(
+            state_machine.current_task.id,
+        )
+        state_machine.awaiting_task_status = True
+    return None
+
+
+def task_status_event_handler(
+    state_machine: "StateMachine",
+    handle_task_completed: Callable[[TaskStatus], Callable],
+    event: Event[Optional[TaskStatus]],
+) -> Optional[Callable]:
+    if not state_machine.mission_ongoing:
+        return None
+
+    status: Optional[TaskStatus] = event.consume_event()
+    if status is not None:
+        state_machine.awaiting_task_status = False
+        return _handle_new_task_status(state_machine, handle_task_completed, status)
+
+    elif (
+        not state_machine.awaiting_task_status
+        and state_machine.current_task is not None
+    ):
+        state_machine.events.state_machine_events.task_status_request.trigger_event(
+            state_machine.current_task.id,
+        )
+        state_machine.awaiting_task_status = True
+    return None
+
+
+def _handle_new_task_status(
+    state_machine: "StateMachine",
+    handle_task_completed: Callable[[TaskStatus], Callable],
+    status: TaskStatus,
+) -> Optional[Callable]:
+    if state_machine.current_task is None:
+        state_machine.iterate_current_task()
+
+    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)
+
+        return handle_task_completed(status)
+    return None

isar/storage/blob_storage.py

@@ -4,7 +4,6 @@ from typing import Union
 
 from azure.core.exceptions import ResourceExistsError
 from azure.storage.blob import BlobClient, BlobServiceClient, ContainerClient
-from dependency_injector.wiring import inject
 
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
@@ -15,7 +14,6 @@ from robot_interface.models.mission.mission import Mission
 
 
 class BlobStorage(StorageInterface):
-    @inject
     def __init__(
         self, keyvault: Keyvault, container_name: str = settings.BLOB_CONTAINER
     ) -> None:

isar/storage/uploader.py

@@ -6,10 +6,8 @@ from queue import Empty, Queue
 from threading import Event
 from typing import List, Union
 
-from dependency_injector.wiring import inject
-
 from isar.config.settings import settings
-from isar.models.communication.queues.events import Events
+from isar.models.events import Events
 from isar.storage.storage_interface import StorageException, StorageInterface
 from robot_interface.models.inspection.inspection import (
     Inspection,
@@ -63,7 +61,6 @@ class BlobItem(UploaderQueueItem):
 
 
 class Uploader:
-    @inject
     def __init__(
         self,
         events: Events,

{isar-1.30.5.dist-info → isar-1.31.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.30.5
+Version: 1.31.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
@@ -113,9 +113,6 @@ Requires-Dist: fastapi-azure-auth
 Requires-Dist: fastapi
 Requires-Dist: dependency-injector
 Requires-Dist: numpy
-Requires-Dist: opencensus-ext-azure
-Requires-Dist: opencensus-ext-logging
-Requires-Dist: opencensus-ext-requests
 Requires-Dist: paho-mqtt
 Requires-Dist: pydantic_settings
 Requires-Dist: pydantic
@@ -126,6 +123,12 @@ Requires-Dist: requests-toolbelt
 Requires-Dist: requests
 Requires-Dist: transitions
 Requires-Dist: uvicorn
+Requires-Dist: opentelemetry-api
+Requires-Dist: opentelemetry-sdk
+Requires-Dist: opentelemetry-exporter-otlp
+Requires-Dist: opentelemetry-instrumentation-fastapi
+Requires-Dist: azure-monitor-opentelemetry
+Requires-Dist: azure-monitor-opentelemetry-exporter>=1.0.0b38
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: isort; extra == "dev"