isar 1.22.4__py3-none-any.whl → 1.23.1__py3-none-any.whl

isar/state_machine/states/initiate.py

@@ -13,7 +13,7 @@ from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotException,
     RobotInfeasibleMissionException,
-    RobotInfeasibleStepException,
+    RobotInfeasibleTaskException,
 )
 
 if TYPE_CHECKING:
@@ -61,11 +61,11 @@ class Initiate(State):
                 break
 
             if not self.initiate_thread:
-                if self.state_machine.stepwise_mission:
+                if self.state_machine.run_mission_by_task:
                     self._run_initiate_thread(
-                        initiate_function=self.state_machine.robot.initiate_step,
-                        function_argument=self.state_machine.current_step,
-                        thread_name="State Machine Initiate Step",
+                        initiate_function=self.state_machine.robot.initiate_task,
+                        function_argument=self.state_machine.current_task,
+                        thread_name="State Machine Initiate Task",
                     )
                 else:
                     self._run_initiate_thread(
@@ -81,13 +81,13 @@ class Initiate(State):
             except ThreadedRequestNotFinishedError:
                 time.sleep(self.state_machine.sleep_time)
                 continue
-            except RobotInfeasibleStepException as e:
-                self.state_machine.current_step.error_message = ErrorMessage(
+            except RobotInfeasibleTaskException as e:
+                self.state_machine.current_task.error_message = ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
                 )
                 self.logger.warning(
-                    f"Failed to initiate step "
-                    f"{str(self.state_machine.current_step.id)[:8]} after retrying "
+                    f"Failed to initiate task "
+                    f"{str(self.state_machine.current_task.id)[:8]} after retrying "
                     f"{self.initiate_failure_counter} times because: "
                     f"{e.error_description}"
                 )
@@ -115,7 +115,7 @@ class Initiate(State):
                 )
 
                 if self.initiate_failure_counter >= self.initiate_failure_counter_limit:
-                    self.state_machine.current_step.error_message = ErrorMessage(
+                    self.state_machine.current_task.error_message = ErrorMessage(
                         error_reason=e.error_reason,
                         error_description=e.error_description,
                     )

isar/state_machine/states/monitor.py

@@ -7,7 +7,6 @@ from injector import inject
 from transitions import State
 
 from isar.config.settings import settings
-from isar.mission_planner.task_selector_interface import TaskSelectorStop
 from isar.services.utilities.threaded_request import (
     ThreadedRequest,
     ThreadedRequestNotFinishedError,
@@ -16,14 +15,13 @@ from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotCommunicationTimeoutException,
     RobotException,
-    RobotMissionStatusException,
     RobotRetrieveInspectionException,
-    RobotStepStatusException,
+    RobotTaskStatusException,
 )
 from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import MissionStatus, TaskStatus
-from robot_interface.models.mission.step import InspectionStep, Step, StepStatus
+from robot_interface.models.mission.status import TaskStatus
+from robot_interface.models.mission.task import InspectionTask, Task
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -40,16 +38,16 @@ class Monitor(State):
         )
 
         self.logger = logging.getLogger("state_machine")
-        self.step_status_thread: Optional[ThreadedRequest] = None
+        self.task_status_thread: Optional[ThreadedRequest] = None
 
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
 
     def stop(self) -> None:
-        if self.step_status_thread:
-            self.step_status_thread.wait_for_thread()
-        self.step_status_thread = None
+        if self.task_status_thread:
+            self.task_status_thread.wait_for_thread()
+        self.task_status_thread = None
 
     def _run(self) -> None:
         transition: Callable
@@ -59,121 +57,110 @@ class Monitor(State):
                 break
 
             if self.state_machine.should_pause_mission():
-                if self.state_machine.stepwise_mission:
+                if self.state_machine.run_mission_by_task:
                     transition = self.state_machine.pause  # type: ignore
                 else:
                     transition = self.state_machine.pause_full_mission  # type: ignore
                 break
 
-            if not self.step_status_thread:
+            if not self.task_status_thread:
                 self._run_get_status_thread(
-                    status_function=self.state_machine.robot.step_status,
+                    status_function=self.state_machine.robot.task_status,
+                    function_argument=self.state_machine.current_task.id,
                     thread_name="State Machine Monitor Get Step Status",
                 )
             try:
-                status: StepStatus = self.step_status_thread.get_output()
+                status: TaskStatus = self.task_status_thread.get_output()
             except ThreadedRequestNotFinishedError:
                 time.sleep(self.state_machine.sleep_time)
                 continue
 
             except RobotCommunicationTimeoutException as e:
-                step_failed: bool = self._handle_communication_timeout(e)
-                if step_failed:
-                    status = StepStatus.Failed
+                task_failed: bool = self._handle_communication_timeout(e)
+                if task_failed:
+                    status = TaskStatus.Failed
                 else:
                     continue
 
-            except RobotStepStatusException as e:
-                self.state_machine.current_step.error_message = ErrorMessage(
+            except RobotTaskStatusException as e:
+                self.state_machine.current_task.error_message = ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
                 )
                 self.logger.error(
-                    f"Monitoring step {self.state_machine.current_step.id[:8]} failed "
+                    f"Monitoring task {self.state_machine.current_task.id[:8]} failed "
                     f"because: {e.error_description}"
                 )
-                status = StepStatus.Failed
+                status = TaskStatus.Failed
 
             except RobotException as e:
                 self._set_error_message(e)
-                status = StepStatus.Failed
+                status = TaskStatus.Failed
 
                 self.logger.error(
                     f"Retrieving the status failed because: {e.error_description}"
                 )
 
-            if not isinstance(status, StepStatus):
+            if not isinstance(status, TaskStatus):
                 self.logger.error(
-                    f"Received an invalid status update when monitoring mission. Only StepStatus is expected."
+                    f"Received an invalid status update when monitoring mission. Only TaskStatus is expected."
                 )
                 break
 
             if self.state_machine.current_task == None:
                 self.state_machine.iterate_current_task()
-            if self.state_machine.current_step == None:
-                self.state_machine.iterate_current_step()
 
-            self.state_machine.current_step.status = status
+            self.state_machine.current_task.status = status
 
             if self._should_upload_inspections():
-                get_inspections_thread = ThreadedRequest(
+                get_inspection_thread = ThreadedRequest(
                     self._queue_inspections_for_upload
                 )
-                get_inspections_thread.start_thread(
+                get_inspection_thread.start_thread(
                     deepcopy(self.state_machine.current_mission),
-                    deepcopy(self.state_machine.current_step),
+                    deepcopy(self.state_machine.current_task),
                     name="State Machine Get Inspections",
                 )
 
-            if self.state_machine.stepwise_mission:
-                if self._is_step_finished(self.state_machine.current_step):
-                    self._report_step_status(self.state_machine.current_step)
-                    transition = self.state_machine.step_finished  # type: ignore
+            if self.state_machine.run_mission_by_task:
+                if self.state_machine.current_task.is_finished():
+                    self._report_task_status(self.state_machine.current_task)
+                    transition = self.state_machine.task_finished  # type: ignore
                     break
             else:
-                if self._is_step_finished(self.state_machine.current_step):
-                    self._report_step_status(self.state_machine.current_step)
-
-                    if self.state_machine.current_task.is_finished():
-                        # Report and update finished task
-                        self.state_machine.current_task.update_task_status()  # Uses the updated step status to set the task status
-                        self.state_machine.publish_task_status(
-                            task=self.state_machine.current_task
-                        )
-
-                        self.state_machine.iterate_current_task()
-
-                        if self.state_machine.current_task == None:
-                            transition = self.state_machine.full_mission_finished  # type: ignore
-                            break
-
-                        # 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
-                        )
-
-                    self.state_machine.iterate_current_step()
-
-                else:  # If not all steps are done
-                    self.state_machine.current_task.status = TaskStatus.InProgress
-
-            self.step_status_thread = None
+                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 == None:
+                        transition = self.state_machine.full_mission_finished  # type: ignore
+                        break
+
+                    # 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
+                    )
+
+            self.task_status_thread = None
             time.sleep(self.state_machine.sleep_time)
 
         transition()
 
     def _run_get_status_thread(
-        self, status_function: Callable, thread_name: str
+        self, status_function: Callable, function_argument: str, thread_name: str
     ) -> None:
-        self.step_status_thread = ThreadedRequest(request_func=status_function)
-        self.step_status_thread.start_thread(name=thread_name)
+        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_step: InspectionStep
+        self, mission: Mission, current_task: InspectionTask
     ) -> None:
         try:
-            inspections: Sequence[Inspection] = (
-                self.state_machine.robot.get_inspections(step=current_step)
+            inspection: Inspection = self.state_machine.robot.get_inspection(
+                task=current_task
             )
 
         except (RobotRetrieveInspectionException, RobotException) as e:
@@ -183,52 +170,42 @@ class Monitor(State):
             )
             return
 
-        if not inspections:
+        if not inspection:
             self.logger.warning(
-                f"No inspection data retrieved for step {str(current_step.id)[:8]}"
+                f"No inspection data retrieved for task {str(current_task.id)[:8]}"
             )
 
-        for inspection in inspections:
-            inspection.metadata.tag_id = current_step.tag_id
+        inspection.metadata.tag_id = current_task.tag_id
 
-            message: Tuple[Inspection, Mission] = (
-                inspection,
-                mission,
-            )
-            self.state_machine.queues.upload_queue.put(message)
-            self.logger.info(f"Inspection: {str(inspection.id)[:8]} queued for upload")
-
-    def _is_step_finished(self, step: Step) -> bool:
-        finished: bool = False
-        if step.status == StepStatus.Failed:
-            finished = True
-        elif step.status == StepStatus.Successful:
-            finished = True
-        return finished
-
-    def _report_step_status(self, step: Step) -> None:
-        if step.status == StepStatus.Failed:
+        message: Tuple[Inspection, Mission] = (
+            inspection,
+            mission,
+        )
+        self.state_machine.queues.upload_queue.put(message)
+        self.logger.info(f"Inspection: {str(inspection.id)[:8]} queued for upload")
+
+    def _report_task_status(self, task: Task) -> None:
+        if task.status == TaskStatus.Failed:
             self.logger.warning(
-                f"Step: {str(step.id)[:8]} was reported as failed by the robot"
+                f"Task: {str(task.id)[:8]} was reported as failed by the robot"
             )
-        elif step.status == StepStatus.Successful:
+        elif task.status == TaskStatus.Successful:
             self.logger.info(
-                f"{type(step).__name__} step: {str(step.id)[:8]} completed"
+                f"{type(task).__name__} task: {str(task.id)[:8]} completed"
             )
 
     def _should_upload_inspections(self) -> bool:
-        step: Step = self.state_machine.current_step
         return (
-            self._is_step_finished(step)
-            and step.status == StepStatus.Successful
-            and isinstance(step, InspectionStep)
+            self.state_machine.current_task.is_finished()
+            and self.state_machine.current_task.status == TaskStatus.Successful
+            and isinstance(self.state_machine.current_task, InspectionTask)
         )
 
     def _set_error_message(self, e: RobotException) -> None:
         error_message: ErrorMessage = ErrorMessage(
             error_reason=e.error_reason, error_description=e.error_description
         )
-        self.state_machine.current_step.error_message = error_message
+        self.state_machine.current_task.error_message = error_message
 
     def _handle_communication_timeout(
         self, e: RobotCommunicationTimeoutException
@@ -236,10 +213,10 @@ class Monitor(State):
         self.state_machine.current_mission.error_message = ErrorMessage(
             error_reason=e.error_reason, error_description=e.error_description
         )
-        self.step_status_thread = None
+        self.task_status_thread = None
         self.request_status_failure_counter += 1
         self.logger.warning(
-            f"Monitoring step {self.state_machine.current_step.id} failed #: "
+            f"Monitoring task {self.state_machine.current_task.id} failed #: "
             f"{self.request_status_failure_counter} failed because: {e.error_description}"
         )
 
@@ -247,12 +224,12 @@ class Monitor(State):
             self.request_status_failure_counter
             >= self.request_status_failure_counter_limit
         ):
-            self.state_machine.current_step.error_message = ErrorMessage(
+            self.state_machine.current_task.error_message = ErrorMessage(
                 error_reason=e.error_reason,
                 error_description=e.error_description,
             )
             self.logger.error(
-                f"Step will be cancelled after failing to get step status "
+                f"Step will be cancelled after failing to get task status "
                 f"{self.request_status_failure_counter} times because: "
                 f"{e.error_description}"
             )

isar/state_machine/states/paused.py

@@ -26,7 +26,7 @@ class Paused(State):
                 break
 
             if self.state_machine.should_resume_mission():
-                if self.state_machine.stepwise_mission:
+                if self.state_machine.run_mission_by_task:
                     transition = self.state_machine.resume  # type: ignore
                 else:
                     transition = self.state_machine.resume_full_mission  # type: ignore

isar/state_machine/states/stop.py

@@ -81,7 +81,7 @@ class Stop(State):
     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_step.error_message = error_message
+            self.state_machine.current_task.error_message = error_message
 
             self.logger.error(
                 f"\nFailed to stop the robot after {retry_limit} attempts because: "

{isar-1.22.4.dist-info → isar-1.23.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.22.4
+Version: 1.23.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

{isar-1.22.4.dist-info → isar-1.23.1.dist-info}/RECORD

@@ -1,21 +1,21 @@
 isar/__init__.py,sha256=cH8p8bVveu3FUL6kBhldcSlLaoHgD82Kd0-SwSNfGXw,87
 isar/modules.py,sha256=aO8bLSC4i_Qo4bOJ6aFfwAZRTJAw8o9SOOfkceUGCiU,6708
-isar/script.py,sha256=xhMMIuulPaaPTcP9-meF0xqNSPDQ7T1W_6yKK6K2RFg,5377
+isar/script.py,sha256=C6CTOZKjWu3JC-jOTN6QPd0Z6NxbydIcQcOM2tXMEXQ,5376
 isar/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/api.py,sha256=vSXfkWR7iITWbh4BsDzjEDtQrz6KS-vi2S8AeaeDc3Q,13112
+isar/apis/api.py,sha256=zrNdnMe5GS1xMtPLsF2Za0NKEyYNKMAVim4l027qQA4,13141
 isar/apis/models/__init__.py,sha256=NI1BYyN__Ogr00Qqe0XJ-9gEVPva2brXo2RJsbrS4tM,52
-isar/apis/models/models.py,sha256=BRm3Wl6TJHdHEKLRQ2SGDx6Y54qq8IesMbBuVO7RuxE,1757
-isar/apis/models/start_mission_definition.py,sha256=Ch8625e-ZDWQv5L-cVlpotTHm1b42ZrDBx2recvTIjM,7394
+isar/apis/models/models.py,sha256=6E8VhGBti6EKJefYTDNVERxRu_g_omg4J2MriPUPkaw,1709
+isar/apis/models/start_mission_definition.py,sha256=EFYkKMQL2o4hqumU1Dq-lKHAS4ZzxlC15XD1AZLpULs,8168
 isar/apis/schedule/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/schedule/scheduling_controller.py,sha256=w2F-6IKBgVN9HVopAOWBb3KUgPjhsnuPLQ3eqjDNfOg,11888
+isar/apis/schedule/scheduling_controller.py,sha256=GXjvkF4OPRJTWzQEvvxbKc79x2X2uzqbl1ZOv_-9Fpw,11508
 isar/apis/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/apis/security/authentication.py,sha256=TI8U9Y_L6ihHLMeM50ZONd5EPfuHdw_XMU_Q987W4AY,1975
 isar/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/config/configuration_error.py,sha256=rO6WOhafX6xvVib8WxV-eY483Z0PpN-9PxGsq5ATfKc,46
 isar/config/log.py,sha256=zHFLmGWQRn8TrcsxUS6KHpJt2JE86kYazU7b-bkcN9o,2285
 isar/config/logging.conf,sha256=mYO1xf27gAopEMHhGzY7-mwyfN16rwRLkPNMvy3zn2g,1127
-isar/config/settings.env,sha256=-kivj0osAAKlInnY81ugySTlcImhVABbnj9kUoBDLu8,535
-isar/config/settings.py,sha256=RUsQr4ZFhsMGQRmBQFYxYZkowsP82UG2EDisenLQXes,13478
+isar/config/settings.env,sha256=hJFfyl4S84nmcyf70Pz8nbGlPf4KTVx0UkgP3uf6T8E,534
+isar/config/settings.py,sha256=NgL3UegkJwsRRkV6rgbig6Xi5k4eYlHpzheaEFavFPs,13477
 isar/config/certs/ca-cert.pem,sha256=ijutWtGOAnKx3xPydNLOVoCLip3tGkNKUpr6pTPQfJA,2179
 isar/config/keyvault/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/config/keyvault/keyvault_error.py,sha256=zvPCsZLjboxsxthYkxpRERCTFxYV8R5WmACewAUQLwk,41
@@ -32,15 +32,15 @@ isar/config/predefined_mission_definition/default_exr.json,sha256=L3-kqjfgXoULDU
 isar/config/predefined_mission_definition/default_mission.json,sha256=nEk1ql17RAs2I5Ws2wA-0GJ6oqJco-Q0Q0vhf4k6ajc,2926
 isar/config/predefined_mission_definition/default_turtlebot.json,sha256=Ka379MLu8qiGIa6Fu-8p8A4OgHVccLkKYSX0RthUOeI,4060
 isar/config/predefined_missions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/config/predefined_missions/default.json,sha256=3J1KtQIFKxJsVoKlg0nKsj8asev-2dSz6IOrd4A57jY,2759
-isar/config/predefined_missions/default_turtlebot.json,sha256=gStYz_hCgQDBEeUW7W4bq_0R3OO55jRnwZt0CNYvHSM,3352
+isar/config/predefined_missions/default.json,sha256=27-_KSQvYnmhv7edn1eB9jXjtodad29-pvdpT1YRxr0,1325
+isar/config/predefined_missions/default_turtlebot.json,sha256=yjxr7-q0Yueq4aAyOG0Yw2x9NuxKTBOZDmjg5-BlYOM,1944
 isar/config/predefined_poses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/config/predefined_poses/predefined_poses.py,sha256=fhq8JF00feDLFKNBlyWeFoLfvfs5dVb__C7CmiVbwmQ,25779
 isar/mission_planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/mission_planner/local_planner.py,sha256=1Qcz7QntWXuYL1PcF6R9aZNCCdL-j_RJ2UGc1_rNZd8,3037
+isar/mission_planner/local_planner.py,sha256=gNEtln8e-f2mmyP9IM_8lbXo92HNF4rdMrrIxOPMoBY,3073
 isar/mission_planner/mission_planner_interface.py,sha256=51k6KKXqC8wZ4Mc8ZWo00Nwy8c6yNa81nEZNZelwJeo,485
-isar/mission_planner/sequential_task_selector.py,sha256=4OJ1Rvg6MaDQQxNcgAUtp2gvhHm3Srha5XJUu8X-Uzg,640
-isar/mission_planner/task_selector_interface.py,sha256=aXL2RXb_XmTNW-WXt6E7wFfJf_BjbownDa3zSqgQ4Ww,703
+isar/mission_planner/sequential_task_selector.py,sha256=lzBPV97wGBfqwpEh4l_7qhijx56yQtOmIM9DhIMOGFY,649
+isar/mission_planner/task_selector_interface.py,sha256=mzZEQfvU9BLCo_pu3fXXuYIjwjdjcr0vJ2pUCtFsr68,713
 isar/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/models/communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/models/communication/message.py,sha256=yN4SXYM-W_6u3Cf9yuAE3jy4e6mMrL3yUr-iVV4r55E,241
@@ -58,26 +58,26 @@ isar/services/readers/base_reader.py,sha256=_fNd5fb5dFeMtOvfWzIAGO-KIgl3zT19iEuz
 isar/services/service_connections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/service_connections/request_handler.py,sha256=0LxC0lu_HXeEf_xmJWjfEsh14oAUI97cpG1IWtBlcs4,4278
 isar/services/service_connections/mqtt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/service_connections/mqtt/mqtt_client.py,sha256=Aib0lqaddxW9aVXXYD7wGL9jIpr2USCCH91SQgFdIG4,3548
+isar/services/service_connections/mqtt/mqtt_client.py,sha256=N6o9U1PUmMJdHz-EDI8TA28gnMTVmNoxo_BKlfGyzeU,3547
 isar/services/service_connections/mqtt/robot_heartbeat_publisher.py,sha256=_bUOG7CfqBlCRvG4vh2XGoMXucBxsJarFIeXIKOH1aw,1019
 isar/services/service_connections/mqtt/robot_info_publisher.py,sha256=5G6ahslydhO2Z4Ug3abf5KVHeOiWdWBMxwraRbJZS_I,1456
 isar/services/service_connections/stid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/utilities/queue_utilities.py,sha256=Pw3hehSwkXJNeDv-bDVDfs58VOwtt3i5hpiJ2ZpphuQ,1225
-isar/services/utilities/scheduling_utilities.py,sha256=LFimEmacML3J9q-FNLfKPhcAr-R3f2rkYkbsoro0Gyo,8434
+isar/services/utilities/scheduling_utilities.py,sha256=cLnB97EkoZM0GN6kG5ezpzxLzACSoHU_Mv86ncyHdfM,8386
 isar/services/utilities/threaded_request.py,sha256=py4G-_RjnIdHljmKFAcQ6ddqMmp-ZYV39Ece-dqRqjs,1874
 isar/state_machine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/state_machine/state_machine.py,sha256=JrVwo3tU5lzWKlUE5oMpoE8aEte3HcVOHbjCGMIdv_c,24357
+isar/state_machine/state_machine.py,sha256=A7qAaXEnErmPQ7--sM7w9VabceS0qJOProlmwMb9iaU,21299
 isar/state_machine/states_enum.py,sha256=BlrUcBWkM5K6D_UZXRwTaUgGpAagWmVZH6HhDBGzVU4,278
 isar/state_machine/states/__init__.py,sha256=kErbKPDTwNfCLijvdyN6_AuOqDwR23nu9F0Qovsnir4,218
 isar/state_machine/states/idle.py,sha256=iAKESjETKUt9x3inE7TAPIohVM1iRsYyJjOoBeB3sVw,3079
-isar/state_machine/states/initialize.py,sha256=KUuyXVwzWK5bJNspA1JnYO_Xwu8fPPK6bnHK4mtwf5A,2359
-isar/state_machine/states/initiate.py,sha256=WqBROOGAh0DVB0f39RFkpqzkr0qrHMyrBGkh2svBbKw,5652
-isar/state_machine/states/monitor.py,sha256=Jc1ZZ4mOJQU-VI5-UQJLbKNQGqHMBruvurHeJOlGnD0,10277
+isar/state_machine/states/initialize.py,sha256=TVXV5Ps3N4_flM88j9pQiX88kZgLzLwzlJy_6hPbgcA,2359
+isar/state_machine/states/initiate.py,sha256=j1wvSC3zVODgRkKOVsQROiuWkjihSBtwCs5GsoivLvc,5655
+isar/state_machine/states/monitor.py,sha256=Nts7S9BuKYmOj73cRrkEZHHWXP5kh-2BKfSBH14MFYQ,9297
 isar/state_machine/states/off.py,sha256=jjqN_oJMpBtWuY7hP-c9f0w3p2CYCfe-NpmYHHPnmyI,544
 isar/state_machine/states/offline.py,sha256=ur5wDo4NWRLn7n-p5IUY6aSYcGApmqe_0IbRRywA6qA,2169
-isar/state_machine/states/paused.py,sha256=qFSauRwalyws8K5bDZ5wkcRDVYyevTDVRtbXkiF9rZc,1174
-isar/state_machine/states/stop.py,sha256=zu7bVKR5zfkzU7iCrh8Pe2WRDHHzU2RBeFBxFK6Z-eA,3348
+isar/state_machine/states/paused.py,sha256=TIg1iJvAxGUIfzE_qWp0wrq4Ka0a3zEf3GNwIWLIK0M,1177
+isar/state_machine/states/stop.py,sha256=WVyjhndHcccy7_P9bU7SXyZB3qphsGahdSymaghGc08,3348
 isar/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/storage/blob_storage.py,sha256=oKdml1VVN8iTr-d_5H4Lz5E7zrhJRknCzOxHD-tO7m8,3230
 isar/storage/local_storage.py,sha256=Bnmoi5gyN8r-oRh0aHrOdGqaH3JqRScFKMRXYojW5kY,1855
@@ -86,20 +86,19 @@ isar/storage/storage_interface.py,sha256=DYDry4I7aZpDHJhsBF6s8zrgokFAc7fdKJKfA8A
 isar/storage/uploader.py,sha256=_f-uIiL5ye6GLc7nYQxHrqDXrIquoL_t5tt9SSaYoDA,6440
 isar/storage/utilities.py,sha256=AGqOzhnyPXSStpJjBstqQ4QgUoHJioQB2DJ1NqeWn_w,3136
 robot_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/robot_interface.py,sha256=pY1Wuka0fTP-kCmkEndAcFytkS73cEE2zIHv-v5Fm1E,9466
+robot_interface/robot_interface.py,sha256=Jbfh1L7lPCjfHS6l3oQ_r0ACZw-KCazVc09PhxEIuao,8566
 robot_interface/test_robot_interface.py,sha256=FV1urn7SbsMyWBIcTKjsBwAG4IsXeZ6pLHE0mA9EGGs,692
 robot_interface/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/models/exceptions/robot_exceptions.py,sha256=DNlecQm2m4ld5mLLFQl1EkQ4b9XgX9H7g-b5c1EuUf4,9549
+robot_interface/models/exceptions/robot_exceptions.py,sha256=PnD5BvWHZfhxODv4abdmQ4PBLk41KcHcH-HYvOXUNNg,9549
 robot_interface/models/initialize/__init__.py,sha256=rz5neEDr59GDbzzI_FF0DId-C-I-50l113P-h-C_QBY,48
 robot_interface/models/initialize/initialize_params.py,sha256=2eG5Aq5bDKU6tVkaUMAoc46GERBgyaKkqv6yLupdRLc,164
 robot_interface/models/inspection/__init__.py,sha256=14wfuj4XZazrigKD7fL98khFKz-eckIpEgPcYRj40Kg,227
-robot_interface/models/inspection/inspection.py,sha256=TVqUl5o3d3fp8IravOMwJIuRoEU8y4BltFrF1IkwvTA,2176
+robot_interface/models/inspection/inspection.py,sha256=kFO3pDkZrggPrS1O5TxOsQYhGSuK-51NWnf4uM99sHs,2175
 robot_interface/models/mission/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/models/mission/mission.py,sha256=r_tYqhZeKASdJ_YIN0ZhCl6YdokuuDySI0o9IT2Qe7M,905
-robot_interface/models/mission/status.py,sha256=R5jLmmn6M7oNX907QvbrhoAqAo4C1zB653Ed1PcxAtg,922
-robot_interface/models/mission/step.py,sha256=DEzU-LD-i3RTAaXBy5KwJZ6OnN5S0F3wwDaqX2DZ72M,5587
-robot_interface/models/mission/task.py,sha256=Nup8e_M_KYhtEtGNeV4FzVzaRH4YpDWiKfMMkLJu0ms,4788
+robot_interface/models/mission/mission.py,sha256=FjrLagGqhk8x9y_fX7DwvApA_hdc7YJcdqT3vigB39g,907
+robot_interface/models/mission/status.py,sha256=C_viZWNTYOncWCdurx7Pko_D9d595QmHuJZBT8YMHUg,724
+robot_interface/models/mission/task.py,sha256=Qy2XmOmk8HChXMe1y8Dn9PvgA2W98Ypd1VqPPNK8ILM,5118
 robot_interface/models/robots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/robots/robot_model.py,sha256=pZQsqhn9hh6XE3EjMZhWMzYqg5oJ4CJ4CXeOASKvEf8,452
 robot_interface/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -109,9 +108,9 @@ robot_interface/telemetry/payloads.py,sha256=FafpIwsOvcTNtaBZqyOX7r5EjG7nZ2uLNhy
 robot_interface/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/utilities/json_service.py,sha256=nU2Q_3P9Fq9hs6F_wtUjWtHfl_g1Siy-yDhXXSKwHwg,1018
 robot_interface/utilities/uuid_string_factory.py,sha256=_NQIbBQ56w0qqO0MUDP6aPpHbxW7ATRhK8HnQiBSLkc,76
-isar-1.22.4.dist-info/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
-isar-1.22.4.dist-info/METADATA,sha256=VPlRvuOehH8dvjeIZ0zFrzoS4WiCKmHJ4_JteOg5nTM,30674
-isar-1.22.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-isar-1.22.4.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.22.4.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.22.4.dist-info/RECORD,,
+isar-1.23.1.dist-info/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
+isar-1.23.1.dist-info/METADATA,sha256=iXPUWr1_LQuzNQCRRch3MEfEvyK17NF-RMs8oIgxCaI,30674
+isar-1.23.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+isar-1.23.1.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
+isar-1.23.1.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
+isar-1.23.1.dist-info/RECORD,,

robot_interface/models/exceptions/robot_exceptions.py

@@ -6,7 +6,7 @@ from typing import Optional
 class ErrorReason(str, Enum):
     RobotCommunicationException: str = "robot_communication_exception"
     RobotCommunicationTimeoutException: str = "robot_communication_timeout_exception"
-    RobotInfeasibleStepException: str = "robot_infeasible_step_exception"
+    RobotInfeasibleTaskException: str = "robot_infeasible_step_exception"
     RobotInfeasibleMissionException: str = "robot_infeasible_mission_exception"
     RobotMissionStatusException: str = "robot_mission_status_exception"
     RobotStepStatusException: str = "robot_step_status_exception"
@@ -67,10 +67,10 @@ class RobotCommunicationTimeoutException(RobotException):
 
 # An exception which should be thrown by the robot package if it is unable to start the
 # current step.
-class RobotInfeasibleStepException(RobotException):
+class RobotInfeasibleTaskException(RobotException):
     def __init__(self, error_description: str) -> None:
         super().__init__(
-            error_reason=ErrorReason.RobotInfeasibleStepException,
+            error_reason=ErrorReason.RobotInfeasibleTaskException,
             error_description=error_description,
         )
 
@@ -103,7 +103,7 @@ class RobotMissionStatusException(RobotException):
 
 # An exception which should be thrown by the robot package if it is unable to collect
 # the status of the current step.
-class RobotStepStatusException(RobotException):
+class RobotTaskStatusException(RobotException):
     def __init__(self, error_description: str) -> None:
         super().__init__(
             error_reason=ErrorReason.RobotStepStatusException,

robot_interface/models/inspection/inspection.py

@@ -45,8 +45,8 @@ class AudioMetadata(InspectionMetadata):
 
 @dataclass
 class Inspection:
-    id: str = field(default_factory=uuid4_string, init=False)
     metadata: InspectionMetadata
+    id: str = field(default_factory=uuid4_string, init=True)
     data: Optional[bytes] = field(default=None, init=False)
 
     @staticmethod

robot_interface/models/mission/mission.py

@@ -5,13 +5,13 @@ from alitra import Pose
 
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.mission.status import MissionStatus
-from robot_interface.models.mission.task import Task
+from robot_interface.models.mission.task import TASKS
 from robot_interface.utilities.uuid_string_factory import uuid4_string
 
 
 @dataclass
 class Mission:
-    tasks: List[Task]
+    tasks: List[TASKS]
     id: str = field(default_factory=uuid4_string, init=True)
     name: str = ""
     start_pose: Optional[Pose] = None

robot_interface/models/mission/status.py

@@ -11,14 +11,6 @@ class MissionStatus(str, Enum):
     PartiallySuccessful: str = "partially_successful"
 
 
-class StepStatus(str, Enum):
-    NotStarted: str = "not_started"
-    Successful: str = "successful"
-    InProgress: str = "in_progress"
-    Failed: str = "failed"
-    Cancelled: str = "cancelled"
-
-
 class TaskStatus(str, Enum):
     NotStarted: str = "not_started"
     InProgress: str = "in_progress"