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

isar/state_machine/states/monitor.py

@@ -1,23 +1,17 @@
 import logging
 import time
 from copy import deepcopy
-from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Callable, Optional, Tuple
 
 from injector import inject
 from transitions import State
 
 from isar.config.settings import settings
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
+from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
-    RobotCommunicationException,
-    RobotCommunicationTimeoutException,
     RobotException,
     RobotRetrieveInspectionException,
-    RobotTaskStatusException,
 )
 from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
@@ -33,24 +27,19 @@ class Monitor(State):
     def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="monitor", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
-        self.request_status_failure_counter: int = 0
-        self.request_status_failure_counter_limit: int = (
-            settings.REQUEST_STATUS_FAILURE_COUNTER_LIMIT
-        )
 
         self.logger = logging.getLogger("state_machine")
-        self.task_status_thread: Optional[ThreadedRequest] = None
 
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
     def stop(self) -> None:
-        if self.task_status_thread:
-            self.task_status_thread.wait_for_thread()
-        self.task_status_thread = None
+        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():
@@ -61,50 +50,53 @@ class Monitor(State):
                 transition = self.state_machine.pause  # type: ignore
                 break
 
-            if not self.task_status_thread:
-                self._run_get_status_thread(
-                    status_function=self.state_machine.robot.task_status,
-                    function_argument=self.state_machine.current_task.id,
-                    thread_name="State Machine Monitor Get Task Status",
-                )
-            try:
-                status: TaskStatus = self.task_status_thread.get_output()
-                self.request_status_failure_counter = 0
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-            except (
-                RobotCommunicationTimeoutException,
-                RobotCommunicationException,
-            ) as e:
-                retry_limit_exceeded: bool = self._check_if_exceeded_retry_limit(e)
-                if retry_limit_exceeded:
-                    self.logger.error(
-                        f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
-                        f"because: {e.error_description}"
-                    )
-                    status = TaskStatus.Failed
+            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.REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY)
+                    time.sleep(settings.FSM_SLEEP_TIME)
                     continue
 
-            except RobotTaskStatusException as e:
-                self.state_machine.current_task.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
+            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.logger.error(
-                    f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
-                    f"because: {e.error_description}"
+                self.state_machine.current_mission.error_message = ErrorMessage(
+                    error_reason=mission_failed.error_reason,
+                    error_description=mission_failed.error_description,
                 )
-                status = TaskStatus.Failed
 
-            except RobotException as e:
-                self._set_error_message(e)
-                status = TaskStatus.Failed
+                transition = self.state_machine.mission_failed_to_start  # type: ignore
+                break
 
+            status: TaskStatus
+
+            task_failure: Optional[ErrorMessage] = (
+                self.state_machine.get_task_failure_event()
+            )
+            if task_failure is not None:
+                self.state_machine.current_task.error_message = task_failure
                 self.logger.error(
-                    f"Retrieving the status failed because: {e.error_description}"
+                    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(
@@ -148,17 +140,8 @@ class Monitor(State):
                     task=self.state_machine.current_task
                 )
 
-            self.task_status_thread = None
-            time.sleep(self.state_machine.sleep_time)
-
         transition()
 
-    def _run_get_status_thread(
-        self, status_function: Callable, function_argument: str, thread_name: str
-    ) -> None:
-        self.task_status_thread = ThreadedRequest(request_func=status_function)
-        self.task_status_thread.start_thread(function_argument, name=thread_name)
-
     def _queue_inspections_for_upload(
         self, mission: Mission, current_task: InspectionTask
     ) -> None:
@@ -218,33 +201,3 @@ class Monitor(State):
             error_reason=e.error_reason, error_description=e.error_description
         )
         self.state_machine.current_task.error_message = error_message
-
-    def _check_if_exceeded_retry_limit(
-        self, e: Union[RobotCommunicationTimeoutException, RobotCommunicationException]
-    ) -> bool:
-        self.state_machine.current_mission.error_message = ErrorMessage(
-            error_reason=e.error_reason, error_description=e.error_description
-        )
-        self.task_status_thread = None
-        self.request_status_failure_counter += 1
-        self.logger.warning(
-            f"Monitoring task {self.state_machine.current_task.id} failed #: "
-            f"{self.request_status_failure_counter} failed because: {e.error_description}"
-        )
-
-        if (
-            self.request_status_failure_counter
-            >= self.request_status_failure_counter_limit
-        ):
-            self.state_machine.current_task.error_message = ErrorMessage(
-                error_reason=e.error_reason,
-                error_description=e.error_description,
-            )
-            self.logger.error(
-                f"Task will be cancelled after failing to get task status "
-                f"{self.request_status_failure_counter} times because: "
-                f"{e.error_description}"
-            )
-            return True
-
-        return False

isar/state_machine/states/offline.py

@@ -1,15 +1,9 @@
 import logging
 import time
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from transitions import State
 
-from isar.config.settings import settings
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
-from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -21,43 +15,24 @@ 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.robot_status_thread: Optional[ThreadedRequest] = None
 
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
     def stop(self) -> None:
-        if self.robot_status_thread:
-            self.robot_status_thread.wait_for_thread()
-        self.robot_status_thread = None
+        return
 
     def _run(self) -> None:
         while True:
-            if not self.robot_status_thread:
-                self.robot_status_thread = ThreadedRequest(
-                    request_func=self.state_machine.robot.robot_status
-                )
-                self.robot_status_thread.start_thread(
-                    name="State Machine Offline Get Robot Status"
-                )
-
-            try:
-                robot_status: RobotStatus = self.robot_status_thread.get_output()
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except RobotException as e:
-                self.logger.error(
-                    f"Failed to get robot status because: {e.error_description}"
-                )
-
-            if robot_status != RobotStatus.Offline:
+            robot_status = self.state_machine.get_robot_status()
+            if robot_status == RobotStatus.BlockedProtectiveStop:
+                transition = self.state_machine.robot_protective_stop_engaged  # type: ignore
+                break
+            elif robot_status != RobotStatus.Offline:
                 transition = self.state_machine.robot_turned_online  # type: ignore
                 break
 
-            self.robot_status_thread = None
-            time.sleep(settings.ROBOT_API_STATUS_POLL_INTERVAL)
+            time.sleep(self.state_machine.sleep_time)
 
         transition()

isar/state_machine/states/paused.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable
 
 from transitions import State
 

isar/state_machine/states_enum.py

@@ -4,8 +4,6 @@ from enum import Enum
 class States(str, Enum):
     Off = "off"
     Idle = "idle"
-    Initiate = "initiate"
-    Initialize = "initialize"
     Monitor = "monitor"
     Paused = "paused"
     Stop = "stop"

isar/state_machine/transitions/fail_mission.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+
+def report_failed_mission_and_finalize(state_machine: "StateMachine") -> None:
+    state_machine.current_task.status = TaskStatus.Failed
+    state_machine.current_mission.status = MissionStatus.Failed
+    state_machine.publish_task_status(task=state_machine.current_task)
+    state_machine._finalize()

isar/state_machine/transitions/finish_mission.py

@@ -0,0 +1,39 @@
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+
+def finish_mission(state_machine: "StateMachine") -> bool:
+    fail_statuses: List[TaskStatus] = [
+        TaskStatus.Cancelled,
+        TaskStatus.Failed,
+    ]
+    partially_fail_statuses = fail_statuses + [TaskStatus.PartiallySuccessful]
+
+    if len(state_machine.current_mission.tasks) == 0:
+        state_machine.current_mission.status = MissionStatus.Successful
+    elif all(
+        task.status in fail_statuses for task in state_machine.current_mission.tasks
+    ):
+        state_machine.current_mission.error_message = ErrorMessage(
+            error_reason=None,
+            error_description="The mission failed because all tasks in the mission "
+            "failed",
+        )
+        state_machine.current_mission.status = MissionStatus.Failed
+    elif any(
+        task.status in partially_fail_statuses
+        for task in state_machine.current_mission.tasks
+    ):
+        state_machine.current_mission.status = MissionStatus.PartiallySuccessful
+    else:
+        state_machine.current_mission.status = MissionStatus.Successful
+    state_machine._finalize()
+
+    state_machine.current_task = None
+    state_machine.send_task_status()
+    return True

isar/state_machine/transitions/pause.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from isar.apis.models.models import ControlMissionResponse
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+
+def pause_mission(state_machine: "StateMachine") -> bool:
+    state_machine.logger.info(f"Pausing mission: {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.queues.api_pause_mission.output.put(paused_mission_response)
+
+    state_machine.publish_mission_status()
+    state_machine.publish_task_status(task=state_machine.current_task)
+
+    state_machine.robot.pause()
+    return True

isar/state_machine/transitions/resume.py

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from isar.apis.models.models import ControlMissionResponse
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+
+def resume_mission(state_machine: "StateMachine") -> bool:
+    state_machine.logger.info(f"Resuming mission: {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.queues.api_resume_mission.output.put(resume_mission_response)
+
+    state_machine.robot.resume()
+    return True

isar/state_machine/transitions/start_mission.py

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from robot_interface.models.exceptions.robot_exceptions import (
+    ErrorMessage,
+    RobotException,
+    RobotInitializeException,
+)
+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)
+    return True
+
+
+def initiate_mission(state_machine: "StateMachine") -> bool:
+    state_machine.logger.info(
+        f"Initialization successful. Starting new mission: "
+        f"{state_machine.current_mission.id}"
+    )
+    state_machine.log_mission_overview(mission=state_machine.current_mission)
+
+    state_machine.current_mission.status = MissionStatus.InProgress
+    state_machine.publish_mission_status()
+    state_machine.current_task = state_machine.task_selector.next_task()
+    state_machine.send_task_status()
+    if state_machine.current_task is None:
+        return False
+
+    state_machine.current_task.status = TaskStatus.InProgress
+    state_machine.publish_task_status(task=state_machine.current_task)
+    return True
+
+
+def initialize_robot(state_machine: "StateMachine") -> bool:
+    try:
+        state_machine.robot.initialize()
+    except (RobotInitializeException, RobotException) as e:
+        state_machine.current_task.error_message = ErrorMessage(
+            error_reason=e.error_reason, error_description=e.error_description
+        )
+        state_machine.logger.error(
+            f"Failed to initialize robot because: {e.error_description}"
+        )
+        _initialization_failed(state_machine)
+        return False
+    return True
+
+
+def set_mission_to_in_progress(state_machine: "StateMachine") -> bool:
+    state_machine.current_mission.status = MissionStatus.InProgress
+    state_machine.publish_task_status(task=state_machine.current_task)
+    state_machine.logger.info(
+        f"Successfully initiated "
+        f"{type(state_machine.current_task).__name__} "
+        f"task: {str(state_machine.current_task.id)[:8]}"
+    )
+    return True
+
+
+def trigger_start_mission_or_task_event(state_machine: "StateMachine") -> bool:
+    state_machine.queues.state_machine_start_mission.input.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._finalize()

isar/state_machine/transitions/stop.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+from isar.apis.models.models import ControlMissionResponse
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
+
+
+def stop_mission(state_machine: "StateMachine") -> bool:
+    if state_machine.current_mission is None:
+        state_machine._queue_empty_response()
+        state_machine.reset_state_machine()
+        return True
+
+    state_machine.current_mission.status = MissionStatus.Cancelled
+
+    for task in state_machine.current_mission.tasks:
+        if task.status in [
+            TaskStatus.NotStarted,
+            TaskStatus.InProgress,
+            TaskStatus.Paused,
+        ]:
+            task.status = TaskStatus.Cancelled
+
+    stopped_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.queues.api_stop_mission.output.put(stopped_mission_response)
+
+    state_machine.publish_task_status(task=state_machine.current_task)
+    state_machine._finalize()
+    return True

isar/state_machine/transitions/utils.py

@@ -0,0 +1,10 @@
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+def def_transition(
+    state_machine: "StateMachine", transition_function: Callable[["StateMachine"], bool]
+) -> Callable[[], bool]:
+    return lambda: transition_function(state_machine)

isar/storage/slimm_storage.py

@@ -100,7 +100,7 @@ class SlimmStorage(StorageInterface):
     @staticmethod
     def _construct_multiform_request_image(
         filename: str, inspection: Inspection, mission: Mission
-    ):
+    ) -> MultipartEncoder:
         array_of_orientation = (
             inspection.metadata.pose.orientation.to_quat_array().tolist()
         )
@@ -148,7 +148,7 @@ class SlimmStorage(StorageInterface):
         filename: str,
         inspection: Inspection,
         mission: Mission,
-    ):
+    ) -> MultipartEncoder:
         array_of_orientation = (
             inspection.metadata.pose.orientation.to_quat_array().tolist()
         )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: isar
-Version: 1.25.8
+Version: 1.26.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -127,6 +127,7 @@ Requires-Dist: transitions
 Requires-Dist: uvicorn
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pip-tools; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
@@ -350,8 +351,6 @@ In general the states
 
 ```
 States.Off,
-States.Initialize,
-States.Initiate,
 States.Stop,
 States.Monitor,
 States.Paused,