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

robot_interface/telemetry/payloads.py

@@ -4,10 +4,10 @@ from typing import List, Optional, Union
 
 from alitra import Pose
 
-from robot_interface.models.robots.battery_state import BatteryState
-from robot_interface.models.mission.status import RobotStatus, MissionStatus, TaskStatus
-from robot_interface.models.mission.task import TaskTypes
 from robot_interface.models.exceptions.robot_exceptions import ErrorReason
+from robot_interface.models.mission.status import MissionStatus, RobotStatus, TaskStatus
+from robot_interface.models.mission.task import TaskTypes
+from robot_interface.models.robots.battery_state import BatteryState
 
 
 @dataclass

robot_interface/utilities/json_service.py

@@ -16,7 +16,7 @@ class EnhancedJSONEncoder(json.JSONEncoder):
 
     def default(self, o):
         if is_dataclass(o):
-            return asdict(o)
+            return asdict(o)  # type: ignore
         if isinstance(o, UUID):
             return str(o)
         if isinstance(o, Orientation):

isar/models/communication/queues/queues.py

@@ -1,19 +0,0 @@
-from queue import Queue
-
-from isar.config.settings import settings
-from isar.models.communication.queues.queue_io import QueueIO
-from isar.models.communication.queues.status_queue import StatusQueue
-
-
-class Queues:
-    def __init__(self) -> None:
-        self.start_mission: QueueIO = QueueIO(input_size=1, output_size=1)
-        self.stop_mission: QueueIO = QueueIO(input_size=1, output_size=1)
-        self.pause_mission: QueueIO = QueueIO(input_size=1, output_size=1)
-        self.resume_mission: QueueIO = QueueIO(input_size=1, output_size=1)
-        self.single_action: QueueIO = QueueIO(input_size=1, output_size=1)
-        self.upload_queue: Queue = Queue(maxsize=10)
-        self.state: StatusQueue = StatusQueue()
-
-        if settings.MQTT_ENABLED:
-            self.mqtt_queue: Queue = Queue()

isar/state_machine/states/initialize.py

@@ -1,70 +0,0 @@
-import logging
-import time
-from typing import TYPE_CHECKING, Callable, Optional
-
-from injector import inject
-from transitions import State
-
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
-from robot_interface.models.exceptions.robot_exceptions import (
-    ErrorMessage,
-    RobotException,
-    RobotInitializeException,
-)
-
-if TYPE_CHECKING:
-    from isar.state_machine.state_machine import StateMachine
-
-
-class Initialize(State):
-    @inject
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="initialize", on_enter=self.start, on_exit=self.stop)
-        self.state_machine: "StateMachine" = state_machine
-
-        self.logger = logging.getLogger("state_machine")
-        self.initialize_thread: Optional[ThreadedRequest] = None
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
-
-    def stop(self) -> None:
-        if self.initialize_thread:
-            self.initialize_thread.wait_for_thread()
-        self.initialize_thread = None
-
-    def _run(self) -> None:
-        transition: Callable
-        while True:
-            if not self.initialize_thread:
-                self.initialize_thread = ThreadedRequest(
-                    self.state_machine.robot.initialize
-                )
-                self.initialize_thread.start_thread(
-                    name="State Machine Initialize Robot"
-                )
-
-            try:
-                self.initialize_thread.get_output()
-
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except (RobotInitializeException, RobotException) as e:
-                self.state_machine.current_task.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                )
-                self.logger.error(
-                    f"Failed to initialize robot because: {e.error_description}"
-                )
-                transition = self.state_machine.initialization_failed  # type: ignore
-                break
-
-            transition = self.state_machine.initialization_successful  # type: ignore
-            break
-        transition()

isar/state_machine/states/initiate.py

@@ -1,111 +0,0 @@
-import logging
-import time
-from typing import TYPE_CHECKING, Any, Callable, Optional
-
-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 (
-    ErrorMessage,
-    RobotException,
-    RobotInfeasibleMissionException,
-)
-
-if TYPE_CHECKING:
-    from isar.state_machine.state_machine import StateMachine
-
-
-class Initiate(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="initiate", on_enter=self.start, on_exit=self.stop)
-        self.state_machine: "StateMachine" = state_machine
-        self.initiate_failure_counter: int = 0
-        self.initiate_failure_counter_limit: int = (
-            settings.INITIATE_FAILURE_COUNTER_LIMIT
-        )
-        self.logger = logging.getLogger("state_machine")
-
-        self.initiate_thread: Optional[ThreadedRequest] = None
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
-
-    def stop(self) -> None:
-        self.initiate_failure_counter = 0
-        if self.initiate_thread:
-            self.initiate_thread.wait_for_thread()
-        self.initiate_thread = None
-
-    def _run(self) -> None:
-        transition: Callable
-        while True:
-            if self.state_machine.should_stop_mission():
-                transition = self.state_machine.stop  # type: ignore
-                break
-
-            if not self.initiate_thread:
-                self._run_initiate_thread(
-                    initiate_function=self.state_machine.robot.initiate_mission,
-                    function_argument=self.state_machine.current_mission,
-                    thread_name="State Machine Initiate Mission",
-                )
-
-            try:
-                self.initiate_thread.get_output()
-                transition = self.state_machine.initiated  # type: ignore
-                break
-            except ThreadedRequestNotFinishedError:
-                time.sleep(self.state_machine.sleep_time)
-                continue
-
-            except RobotInfeasibleMissionException as e:
-                self.state_machine.current_mission.error_message = ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                )
-                self.logger.warning(
-                    f"Failed to initiate mission "
-                    f"{str(self.state_machine.current_mission.id)[:8]} because: "
-                    f"{e.error_description}"
-                )
-                transition = self.state_machine.initiate_failed  # type: ignore
-                break
-
-            except RobotException as e:
-                self.initiate_thread = None
-                self.initiate_failure_counter += 1
-                self.logger.warning(
-                    f"Initiating failed #: {str(self.initiate_failure_counter)} "
-                    f"because: {e.error_description}"
-                )
-
-                if self.initiate_failure_counter >= self.initiate_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"Mission will be cancelled after failing to initiate "
-                        f"{self.initiate_failure_counter_limit} times because: "
-                        f"{e.error_description}"
-                    )
-                    transition = self.state_machine.initiate_failed  # type: ignore
-                    break
-
-            time.sleep(self.state_machine.sleep_time)
-
-        transition()
-
-    def _run_initiate_thread(
-        self, initiate_function: Callable, function_argument: Any, thread_name: str
-    ) -> None:
-        self.initiate_thread = ThreadedRequest(request_func=initiate_function)
-
-        self.initiate_thread.start_thread(
-            function_argument,
-            name=thread_name,
-        )