isar 1.20.2__py3-none-any.whl → 1.34.9__py3-none-any.whl

isar/models/communication/message.py

@@ -1,12 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from alitra import Pose
-
-from robot_interface.models.mission.mission import Mission
-
-
-@dataclass
-class StartMissionMessage:
-    mission: Mission
-    initial_pose: Optional[Pose]

isar/models/communication/queues/__init__.py

@@ -1,4 +0,0 @@
-from .queue_io import QueueIO
-from .queue_timeout_error import QueueTimeoutError
-from .queues import Queues
-from .status_queue import StatusQueue

isar/models/communication/queues/queue_io.py

@@ -1,12 +0,0 @@
-from queue import Queue
-
-
-class QueueIO:
-    """
-    Creates input and output queue. The queues are defined such that the input is from
-    api to state machine while the output is from state machine to api.
-    """
-
-    def __init__(self, input_size: int = 0, output_size: int = 0):
-        self.input: Queue = Queue(maxsize=input_size)
-        self.output: Queue = Queue(maxsize=output_size)

isar/models/communication/queues/queue_timeout_error.py

@@ -1,2 +0,0 @@
-class QueueTimeoutError(Exception):
-    pass

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/models/communication/queues/status_queue.py

@@ -1,20 +0,0 @@
-from collections import deque
-from queue import Empty, Queue
-from typing import Any
-
-
-class StatusQueue(Queue):
-    def __init__(self) -> None:
-        super().__init__()
-
-    def check(self) -> Any:
-        if not self._qsize():
-            raise Empty
-        with self.mutex:
-            l = list(self.queue)
-            return l.pop()
-
-    def update(self, item: Any):
-        with self.mutex:
-            self.queue = deque()
-            self.queue.append(item)

isar/services/readers/base_reader.py

@@ -1,37 +0,0 @@
-import json
-import logging
-from dataclasses import is_dataclass
-from logging import Logger
-from pathlib import Path
-from typing import Any, Optional
-
-from dacite import Config, from_dict
-
-logger: Logger = logging.getLogger("api")
-
-
-class BaseReader:
-    @staticmethod
-    def read_json(location: Path) -> dict:
-        with open(location) as json_file:
-            return json.load(json_file)
-
-    @staticmethod
-    def dict_to_dataclass(
-        dataclass_dict: dict,
-        target_dataclass: Any,
-        cast_config: list = [],
-        strict_config: bool = False,
-    ) -> Optional[Any]:
-        if not is_dataclass(target_dataclass):
-            raise BaseReaderError("{target_dataclass} is not a dataclass")
-        generated_dataclass = from_dict(
-            data_class=target_dataclass,
-            data=dataclass_dict,
-            config=Config(cast=cast_config, strict=strict_config),
-        )
-        return generated_dataclass
-
-
-class BaseReaderError(Exception):
-    pass

isar/services/utilities/queue_utilities.py

@@ -1,39 +0,0 @@
-import logging
-from queue import Empty, Queue
-from typing import Any
-
-from isar.models.communication.queues.queue_timeout_error import QueueTimeoutError
-
-logger = logging.getLogger("api")
-
-
-class QueueUtilities:
-    """
-    Contains utility functions for handling queue communication between threads.
-    """
-
-    @staticmethod
-    def check_queue(queue: Queue, queue_timeout: int = None) -> Any:
-        """
-        Checks if there is a message on a queue. If a timeout is specified the function
-        will raise a QueueTimeoutError if there is no message within the timeout. If
-        there is no timeout specified this function will block.
-        :param queue: The queue to be checked for a message
-        :param queue_timeout: Timeout in seconds
-        :return: Message found on queue
-        :raises QueueTimeoutError
-        """
-        try:
-            message: Any = queue.get(timeout=queue_timeout)
-        except Empty:
-            logger.error("Queue timed out")
-            raise QueueTimeoutError
-        return message
-
-    @staticmethod
-    def clear_queue(queue: Queue) -> None:
-        while True:
-            try:
-                queue.get(block=False)
-            except Empty:
-                break

isar/state_machine/states/idle.py

@@ -1,85 +0,0 @@
-import logging
-import time
-from typing import TYPE_CHECKING, Optional
-
-from transitions import State
-
-from isar.config.settings import settings
-from isar.models.communication.message import StartMissionMessage
-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:
-    from isar.state_machine.state_machine import StateMachine
-
-
-class Idle(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        super().__init__(name="idle", 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
-        self.last_robot_status_poll_time: float = time.time()
-
-    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
-
-    def _run(self) -> None:
-        while True:
-            start_mission: Optional[StartMissionMessage] = (
-                self.state_machine.should_start_mission()
-            )
-            if start_mission:
-                self.state_machine.start_mission(
-                    mission=start_mission.mission,
-                    initial_pose=start_mission.initial_pose,
-                )
-                transition = self.state_machine.mission_started  # type: ignore
-                break
-            time.sleep(self.state_machine.sleep_time)
-
-            time_from_last_robot_status_poll = (
-                time.time() - self.last_robot_status_poll_time
-            )
-            if (
-                time_from_last_robot_status_poll
-                < settings.ROBOT_API_STATUS_POLL_INTERVAL
-            ):
-                continue
-
-            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}"
-                )
-
-            self.last_robot_status_poll_time = time.time()
-
-            if robot_status == RobotStatus.Offline:
-                transition = self.state_machine.robot_turned_offline  # type: ignore
-                break
-
-        transition()

isar/state_machine/states/initialize.py

@@ -1,71 +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(
-                    self.state_machine.get_initialize_params(),
-                    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_step.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,142 +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,
-    RobotInfeasibleStepException,
-)
-
-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 self.state_machine.should_pause_mission():
-                transition = self.state_machine.pause  # type: ignore
-                break
-
-            if not self.state_machine.current_task:
-                self.logger.info(
-                    f"Completed mission: {self.state_machine.current_mission.id}"
-                )
-                transition = self.state_machine.mission_finished  # type: ignore
-                break
-
-            if not self.initiate_thread:
-                if self.state_machine.stepwise_mission:
-                    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",
-                    )
-                else:
-                    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 RobotInfeasibleStepException as e:
-                self.state_machine.current_step.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"{self.initiate_failure_counter} times because: "
-                    f"{e.error_description}"
-                )
-                transition = self.state_machine.initiate_infeasible  # type: ignore
-                break
-
-            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_step.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,
-        )

isar/state_machine/states/off.py

@@ -1,18 +0,0 @@
-import logging
-from typing import TYPE_CHECKING
-
-from transitions import State
-
-if TYPE_CHECKING:
-    from isar.state_machine.state_machine import StateMachine
-
-
-class Off(State):
-    def __init__(self, state_machine: "StateMachine"):
-        super().__init__(name="off", on_enter=self.start)
-        self.logger = logging.getLogger("state_machine")
-        self.state_machine: "StateMachine" = state_machine
-
-    def start(self):
-        self.state_machine.update_state()
-        self.logger.info(f"State: {self.state_machine.current_state}")

isar/state_machine/states/stop.py

@@ -1,95 +0,0 @@
-import logging
-import time
-from typing import TYPE_CHECKING, Callable, 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,
-)
-
-if TYPE_CHECKING:
-    from isar.state_machine.state_machine import StateMachine
-
-
-class Stop(State):
-    def __init__(self, state_machine: "StateMachine") -> None:
-        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.stop_thread: Optional[ThreadedRequest] = None
-        self._count_number_retries: int = 0
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
-
-    def stop(self) -> None:
-        if self.stop_thread:
-            self.stop_thread.wait_for_thread()
-        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")
-
-            if self.state_machine.should_stop_mission():
-                self.state_machine.stopped = True
-
-            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
-            if self.state_machine.stopped:
-                transition = self.state_machine.mission_stopped  # type: ignore
-            else:
-                transition = self.state_machine.mission_paused  # type: ignore
-            break
-
-        transition()
-
-    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.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"
-            )
-
-            return True
-        time.sleep(self.state_machine.sleep_time)
-        return False