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

isar/mission_planner/local_planner.py

@@ -1,82 +0,0 @@
-import logging
-from pathlib import Path
-
-from alitra import Frame
-from injector import inject
-
-from isar.config.settings import settings
-from isar.mission_planner.mission_planner_interface import (
-    MissionNotFoundError,
-    MissionPlannerError,
-    MissionPlannerInterface,
-)
-from isar.services.readers.base_reader import BaseReader, BaseReaderError
-from robot_interface.models.mission.mission import Mission
-
-logger = logging.getLogger("api")
-
-
-class LocalPlanner(MissionPlannerInterface):
-    @inject
-    def __init__(self):
-        self.predefined_mission_folder = Path(settings.PREDEFINED_MISSIONS_FOLDER)
-
-    def get_mission(self, mission_id) -> Mission:
-        missions: dict = self.get_predefined_missions()
-        if missions is None:
-            raise MissionPlannerError("There were no predefined missions")
-        try:
-            mission: Mission = missions[mission_id]["mission"]
-            return mission
-        except KeyError as e:
-            raise MissionNotFoundError(
-                f"Could not get mission : {mission_id} - does not exist {e}"
-            ) from e
-        except Exception as e:
-            raise MissionPlannerError(f"Could not get mission : {mission_id}") from e
-
-    @staticmethod
-    def read_mission_from_file(mission_path: Path) -> Mission:
-        mission_dict: dict = BaseReader.read_json(location=mission_path)
-        mission: Mission = BaseReader.dict_to_dataclass(
-            dataclass_dict=mission_dict,
-            target_dataclass=Mission,
-            cast_config=[Frame],
-            strict_config=True,
-        )
-
-        return mission
-
-    def get_predefined_missions(self) -> dict:
-        missions: dict = {}
-        invalid_mission_ids: list = []
-        json_files = self.predefined_mission_folder.glob("*.json")
-        for file in json_files:
-            mission_name = file.stem
-            path_to_file = self.predefined_mission_folder.joinpath(file.name)
-            try:
-                mission: Mission = self.read_mission_from_file(path_to_file)
-            except BaseReaderError as e:
-                logger.warning(
-                    f"Failed to read predefined mission {path_to_file} \n {e}"
-                )
-                continue
-            if mission.id in invalid_mission_ids:
-                logger.warning(
-                    f"Duplicate mission id {mission.id} : {path_to_file.as_posix()}"
-                )
-            elif mission.id in missions:
-                conflicting_file_path = missions[mission.id]["file"]
-                logger.warning(
-                    f"Duplicate mission id {mission.id} : {path_to_file.as_posix()}"
-                    + f" and {conflicting_file_path}"
-                )
-                invalid_mission_ids.append(mission.id)
-                missions.pop(mission.id)
-            else:
-                missions[mission.id] = {
-                    "name": mission_name,
-                    "file": path_to_file.as_posix(),
-                    "mission": mission,
-                }
-        return missions

isar/mission_planner/mission_planner_interface.py

@@ -1,26 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-from robot_interface.models.mission.mission import Mission
-
-
-class MissionPlannerInterface(metaclass=ABCMeta):
-    @abstractmethod
-    def get_mission(self, mission_id: str) -> Mission:
-        """
-        Parameters
-        ----------
-        mission_id : int
-
-        Returns
-        -------
-        mission : Mission
-        """
-        pass
-
-
-class MissionPlannerError(Exception):
-    pass
-
-
-class MissionNotFoundError(Exception):
-    pass

isar/mission_planner/sequential_task_selector.py

@@ -1,23 +0,0 @@
-from typing import Iterator, List
-
-from isar.mission_planner.task_selector_interface import (
-    TaskSelectorInterface,
-    TaskSelectorStop,
-)
-from robot_interface.models.mission.task import Task
-
-
-class SequentialTaskSelector(TaskSelectorInterface):
-    def __init__(self) -> None:
-        super().__init__()
-        self._iterator: Iterator = None
-
-    def initialize(self, tasks: List[Task]) -> None:
-        super().initialize(tasks=tasks)
-        self._iterator = iter(self.tasks)
-
-    def next_task(self) -> Task:
-        try:
-            return next(self._iterator)
-        except StopIteration:
-            raise TaskSelectorStop

isar/mission_planner/task_selector_interface.py

@@ -1,31 +0,0 @@
-from abc import ABCMeta, abstractmethod
-from typing import List
-
-from robot_interface.models.mission.task import Task
-
-
-class TaskSelectorInterface(metaclass=ABCMeta):
-    def __init__(self) -> None:
-        self.tasks: List[Task] = None
-
-    def initialize(self, tasks: List[Task]) -> None:
-        self.tasks = tasks
-
-    @abstractmethod
-    def next_task(self) -> Task:
-        """
-        Returns
-        -------
-        Task
-            Returns the next task from the list of tasks
-
-        Raises
-        ------
-        TaskSelectorStop
-            If all tasks have been selected, and the task selection process is complete.
-        """
-        pass
-
-
-class TaskSelectorStop(Exception):
-    pass

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/auth/azure_credentials.py

@@ -1,14 +0,0 @@
-import logging
-
-from azure.core.exceptions import ClientAuthenticationError
-from azure.identity import DefaultAzureCredential
-
-
-class AzureCredentials:
-    @staticmethod
-    def get_azure_credentials():
-        try:
-            return DefaultAzureCredential()
-        except ClientAuthenticationError as e:
-            logging.error(e.message)
-            raise e

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/service_connections/request_handler.py

@@ -1,153 +0,0 @@
-import logging
-from typing import Any, Optional
-
-import requests
-from requests.exceptions import ConnectionError, HTTPError, RequestException, Timeout
-from requests.models import Response
-
-from isar.config.settings import settings
-
-
-class RequestHandler:
-    def __init__(self):
-        self.logger = logging.getLogger("request_handler")
-
-    def base_request(
-        self,
-        url: str,
-        method: str,
-        json_body: Any,
-        timeout: float,
-        auth: tuple,
-        headers: Optional[dict] = None,
-        data: Optional[dict] = None,
-        params: Optional[dict] = None,
-        **kwargs,
-    ) -> Response:
-        try:
-            response = requests.request(
-                url=url,
-                method=method,
-                auth=auth,
-                headers=headers,
-                timeout=timeout,
-                json=json_body,
-                data=data,
-                params=params,
-                **kwargs,
-            )
-        except Timeout as e:
-            self.logger.exception("Timeout exception")
-            raise RequestException from e
-        except ConnectionError as e:
-            self.logger.exception("Connection error")
-            raise RequestException from e
-        except RequestException as e:
-            raise RequestException from e
-        except Exception as e:
-            self.logger.exception("An unhandled exception occurred during a request")
-            raise RequestException from e
-        try:
-            response.raise_for_status()
-        except HTTPError:
-            self.logger.exception(
-                f"Http error. Http status code= {response.status_code}, Content: {response.content}"
-            )
-            raise
-        return response
-
-    def get(
-        self,
-        url: str,
-        json_body=None,
-        request_timeout: float = settings.REQUEST_TIMEOUT,
-        auth: Optional[tuple] = None,
-        headers: Optional[dict] = None,
-        data: Optional[dict] = None,
-        params: Optional[dict] = None,
-        **kwargs,
-    ) -> Response:
-        response = self.base_request(
-            url=url,
-            method="GET",
-            auth=auth,
-            headers=headers,
-            timeout=request_timeout,
-            json_body=json_body,
-            data=data,
-            params=params,
-            **kwargs,
-        )
-        return response
-
-    def post(
-        self,
-        url: str,
-        json_body=None,
-        request_timeout: float = settings.REQUEST_TIMEOUT,
-        auth: Optional[tuple] = None,
-        headers: Optional[dict] = None,
-        data: Optional[dict] = None,
-        params: Optional[dict] = None,
-        **kwargs,
-    ) -> Response:
-        response = self.base_request(
-            url=url,
-            method="POST",
-            auth=auth,
-            headers=headers,
-            timeout=request_timeout,
-            json_body=json_body,
-            data=data,
-            params=params,
-            **kwargs,
-        )
-        return response
-
-    def delete(
-        self,
-        url: str,
-        json_body=None,
-        request_timeout: float = settings.REQUEST_TIMEOUT,
-        auth: Optional[tuple] = None,
-        headers: Optional[dict] = None,
-        data: Optional[dict] = None,
-        params: Optional[dict] = None,
-        **kwargs,
-    ) -> Response:
-        response = self.base_request(
-            url=url,
-            method="DELETE",
-            auth=auth,
-            headers=headers,
-            timeout=request_timeout,
-            json_body=json_body,
-            data=data,
-            params=params,
-            **kwargs,
-        )
-        return response
-
-    def put(
-        self,
-        url: str,
-        json_body=None,
-        request_timeout: float = settings.REQUEST_TIMEOUT,
-        auth: Optional[tuple] = None,
-        headers: Optional[dict] = None,
-        data: Optional[dict] = None,
-        params: Optional[dict] = None,
-        **kwargs,
-    ) -> Response:
-        response = self.base_request(
-            url=url,
-            method="PUT",
-            auth=auth,
-            headers=headers,
-            timeout=request_timeout,
-            json_body=json_body,
-            data=data,
-            params=params,
-            **kwargs,
-        )
-        return response

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/services/utilities/threaded_request.py

@@ -1,68 +0,0 @@
-from threading import Lock, Thread
-from typing import Any, Optional
-
-
-class ThreadedRequest:
-    def __init__(self, request_func: Any):
-        self._thread: Optional[Thread] = None
-        self._request_func: Any = request_func
-        self._output: Optional[Any] = None
-        self._output_lock: Lock = Lock()
-        self._exception: Optional[Exception] = None
-        self._exception_lock: Lock = Lock()
-
-    def start_thread(self, *request_args, **kwargs) -> bool:
-        if self._is_thread_alive():
-            return False
-        self._output = None
-        self._thread = Thread(target=self._thread_func, args=request_args, **kwargs)
-        self._thread.start()
-        return True
-
-    def get_output(self) -> Any:
-        if self._is_thread_alive():
-            raise ThreadedRequestNotFinishedError
-
-        self._exception_lock.acquire()
-        exception = self._exception
-        self._exception_lock.release()
-
-        if exception:
-            raise exception
-
-        self._output_lock.acquire()
-        output = self._output
-        self._output_lock.release()
-
-        return output
-
-    def wait_for_thread(self) -> None:
-        if not self._thread:
-            return
-        self._thread.join()
-
-    def _is_thread_alive(self) -> bool:
-        if not self._thread:
-            return False
-        return self._thread.is_alive()
-
-    def _thread_func(self, *args) -> None:
-        try:
-            request_output: Any = self._request_func(*args)
-        except Exception as e:
-            self._exception_lock.acquire()
-            self._exception = e
-            self._exception_lock.release()
-            return
-
-        self._output_lock.acquire()
-        self._output = request_output
-        self._output_lock.release()
-
-
-class ThreadedRequestError(Exception):
-    pass
-
-
-class ThreadedRequestNotFinishedError(ThreadedRequestError):
-    pass

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()