isar 1.15.0__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/service_connections/mqtt/robot_status_publisher.py

@@ -1,93 +0,0 @@
-import json
-import logging
-import time
-from datetime import datetime
-from logging import Logger
-from queue import Queue
-from threading import Thread
-
-from isar.config.settings import settings
-from isar.state_machine.state_machine import StateMachine
-from isar.state_machine.states_enum import States
-from robot_interface.models.exceptions import RobotCommunicationException
-from robot_interface.models.mission.status import RobotStatus
-from robot_interface.robot_interface import RobotInterface
-from robot_interface.telemetry.mqtt_client import MqttPublisher
-from robot_interface.telemetry.payloads import RobotStatusPayload
-from robot_interface.utilities.json_service import EnhancedJSONEncoder
-
-
-class RobotStatusPublisher:
-    def __init__(
-        self, mqtt_queue: Queue, robot: RobotInterface, state_machine: StateMachine
-    ):
-        self.mqtt_publisher: MqttPublisher = MqttPublisher(mqtt_queue=mqtt_queue)
-        self.robot: RobotInterface = robot
-        self.state_machine: StateMachine = state_machine
-
-    def _get_combined_robot_status(
-        self, robot_status: RobotStatus, current_state: States
-    ) -> RobotStatus:
-        if robot_status == RobotStatus.Offline:
-            return RobotStatus.Offline
-        elif current_state == States.Idle and robot_status == RobotStatus.Available:
-            return RobotStatus.Available
-        elif current_state != States.Idle or robot_status == RobotStatus.Busy:
-            return RobotStatus.Busy
-        return None
-
-    def run(self) -> None:
-        robot_status_monitor: RobotStatusMonitor = RobotStatusMonitor(robot=self.robot)
-        robot_status_thread: Thread = Thread(
-            target=robot_status_monitor.run,
-            name="Robot Status Monitor",
-            daemon=True,
-        )
-        robot_status_thread.start()
-
-        while True:
-            combined_status: RobotStatus = self._get_combined_robot_status(
-                robot_status=robot_status_monitor.robot_status,
-                current_state=self.state_machine.current_state,
-            )
-
-            payload: RobotStatusPayload = RobotStatusPayload(
-                isar_id=settings.ISAR_ID,
-                robot_name=settings.ROBOT_NAME,
-                robot_status=combined_status,
-                current_isar_state=self.state_machine.current_state,
-                current_mission_id=self.state_machine.current_mission.id
-                if self.state_machine.current_mission
-                else None,
-                current_task_id=self.state_machine.current_task.id
-                if self.state_machine.current_task
-                else None,
-                current_step_id=self.state_machine.current_step.id
-                if self.state_machine.current_step
-                else None,
-                timestamp=datetime.utcnow(),
-            )
-
-            self.mqtt_publisher.publish(
-                topic=settings.TOPIC_ISAR_ROBOT_STATUS,
-                payload=json.dumps(payload, cls=EnhancedJSONEncoder),
-            )
-
-            time.sleep(settings.ROBOT_STATUS_PUBLISH_INTERVAL)
-
-
-class RobotStatusMonitor:
-    def __init__(self, robot: RobotInterface):
-        self.robot: RobotInterface = robot
-        self.robot_status: RobotStatus = RobotStatus.Offline
-        self.logger: Logger = logging.getLogger("robot_status_monitor")
-
-    def run(self) -> None:
-        while True:
-            try:
-                self.robot_status = self.robot.robot_status()
-            except RobotCommunicationException:
-                self.logger.warning(
-                    "Failed to get robot status due to a communication exception"
-                )
-            time.sleep(settings.ROBOT_API_STATUS_POLL_INTERVAL)

isar/services/service_connections/stid/stid_service.py

@@ -1,45 +0,0 @@
-import logging
-from typing import Optional
-
-from alitra import Frame, Position
-from azure.identity import DefaultAzureCredential
-from injector import inject
-from requests import Response
-
-from isar.config.settings import settings
-from isar.services.auth.azure_credentials import AzureCredentials
-from isar.services.service_connections.request_handler import RequestHandler
-
-
-class StidService:
-    @inject
-    def __init__(self, request_handler: RequestHandler):
-        self.request_handler: RequestHandler = request_handler
-        self.credentials: DefaultAzureCredential = (
-            AzureCredentials.get_azure_credentials()
-        )
-        self.logger = logging.getLogger("api")
-
-    def tag_position(self, tag: str) -> Optional[Position]:
-        client_id: str = settings.STID_CLIENT_ID
-        scope: str = settings.STID_APP_SCOPE
-        request_scope: str = f"{client_id}/{scope}"
-
-        token: str = self.credentials.get_token(request_scope).token
-
-        stid_url: str = settings.STID_API_URL
-        plant_name: str = settings.STID_PLANT_NAME
-        request_url: str = f"{stid_url}/{plant_name}/tag"
-
-        response: Response = self.request_handler.get(
-            url=request_url,
-            params={"tagNo": tag},
-            headers={"Authorization": f"Bearer {token}"},
-        )
-        tag_metadata: dict = response.json()
-
-        x_coord: float = tag_metadata["xCoordinate"] / 1000
-        y_coord: float = tag_metadata["yCoordinate"] / 1000
-        z_coord: float = tag_metadata["zCoordinate"] / 1000
-
-        return Position(x=x_coord, y=y_coord, z=z_coord, frame=Frame("asset"))

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,40 +0,0 @@
-import logging
-import time
-from typing import Optional, TYPE_CHECKING
-
-from transitions import State
-
-from isar.models.communication.message import StartMissionMessage
-
-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")
-
-    def start(self) -> None:
-        self.state_machine.update_state()
-        self._run()
-
-    def stop(self) -> None:
-        pass
-
-    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)
-
-        transition()

isar/state_machine/states/initialize.py

@@ -1,60 +0,0 @@
-import logging
-import time
-from typing import Callable, Optional, TYPE_CHECKING
-
-from injector import inject
-from transitions import State
-
-from isar.services.utilities.threaded_request import (
-    ThreadedRequest,
-    ThreadedRequestNotFinishedError,
-)
-from robot_interface.models.exceptions import RobotException
-
-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 RobotException as e:
-                self.logger.error(f"Initialization of robot failed. Error: {e}")
-                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,129 +0,0 @@
-import logging
-import time
-from typing import Any, Callable, Optional, 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 import (
-    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:
-                self.logger.warning(
-                    f"Failed to initiate "
-                    f"{type(self.state_machine.current_step).__name__}"
-                    f"Invalid step: {str(self.state_machine.current_step.id)[:8]}"
-                )
-                transition = self.state_machine.initiate_infeasible  # type: ignore
-                break
-
-            except RobotInfeasibleMissionException:
-                self.logger.warning(
-                    f"Failed to initiate mission "
-                    f"{str(self.state_machine.current_mission.id)[:8]}"
-                )
-                transition = self.state_machine.initiate_infeasible  # type: ignore
-                break
-
-            except RobotException as e:
-                self.initiate_thread = None
-                self.initiate_failure_counter += 1
-                self.logger.warning(
-                    f"Initiating step failed #: {str(self.initiate_failure_counter)} "
-                    f"times. \n{e}"
-                )
-
-            if self.initiate_failure_counter >= self.initiate_failure_counter_limit:
-                self.logger.error(
-                    f"Mission will be cancelled as initiate failed after "
-                    f"{self.initiate_failure_counter_limit} attempts. "
-                    f"Cancelling mission."
-                )
-                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,78 +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 import 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 RobotException:
-                if self.handle_stop_fail(
-                    retry_limit=self.state_machine.stop_robot_attempts_limit
-                ):
-                    transition = self.state_machine.mission_stopped  # type: ignore
-                    break
-
-                self.logger.warning("Failed to stop robot. Retrying.")
-                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) -> bool:
-        self._count_number_retries += 1
-        if self._count_number_retries > retry_limit:
-            self.logger.warning(
-                "Could not communicate request: Reached limit for stop attempts. "
-                "Cancelled mission and transitioned to idle."
-            )
-            return True
-        time.sleep(self.state_machine.sleep_time)
-        return False