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

isar/config/predefined_mission_definition/default_turtlebot.json

@@ -1,117 +0,0 @@
-{
-    "mission_definition": {
-        "tasks": [
-            {
-                "pose": {
-                    "position": {
-                        "x": -3.6,
-                        "y": 4,
-                        "z": 0,
-                        "frame": "asset"
-                    },
-                    "orientation": {
-                        "x": 0,
-                        "y": 0,
-                        "z": -0.7286672256879113,
-                        "w": -0.6848660759820616,
-                        "frame": "asset"
-                    },
-                    "frame_name": "asset"
-                },
-                "tag": "1-A",
-                "inspections": [
-                    {
-                        "type": "Image",
-                        "inspection_target": {
-                            "x": -4.7,
-                            "y": 4.9,
-                            "z": 0,
-                            "frame": "robot"
-                        },
-                        "metadata": {
-                            "zoom": "2x"
-                        }
-                    },
-                    {
-                        "type": "ThermalImage",
-                        "inspection_target": {
-                            "x": -4.7,
-                            "y": 4.9,
-                            "z": 0,
-                            "frame": "robot"
-                        }
-                    }
-                ]
-            },
-            {
-                "pose": {
-                    "position": {
-                        "x": 4.7,
-                        "y": 3,
-                        "z": 0,
-                        "frame": "asset"
-                    },
-                    "orientation": {
-                        "x": 0,
-                        "y": 0,
-                        "z": 0.5769585,
-                        "w": 0.8167734,
-                        "frame": "asset"
-                    },
-                    "frame_name": "asset"
-                },
-                "tag": "2-B",
-                "inspections": [
-                    {
-                        "type": "Image",
-                        "inspection_target": {
-                            "x": 5.6,
-                            "y": 5.2,
-                            "z": 0,
-                            "frame": "robot"
-                        }
-                    }
-                ]
-            },
-            {
-                "pose": {
-                    "position": {
-                        "x": 0.95,
-                        "y": 2.6,
-                        "z": 0,
-                        "frame": "asset"
-                    },
-                    "orientation": {
-                        "x": 0,
-                        "y": 0,
-                        "z": -0.6992469,
-                        "w": 0.7148802,
-                        "frame": "asset"
-                    },
-                    "frame_name": "asset"
-                },
-                "tag": "3-C",
-                "inspections": [
-                    {
-                        "type": "Image",
-                        "inspection_target": {
-                            "x": 5.6,
-                            "y": 5.2,
-                            "z": 0,
-                            "frame": "robot"
-                        }
-                    },
-                    {
-                        "type": "ThermalImage",
-                        "inspection_target": {
-                            "x": 1.9,
-                            "y": 1.9,
-                            "z": 0,
-                            "frame": "robot"
-                        }
-                    }
-                ]
-            }
-        ]
-    }
-}

isar/config/predefined_missions/default.json

@@ -1,72 +0,0 @@
-{
-  "id": "1",
-  "name": "Default mission",
-  "tasks": [
-    {
-      "type": "take_image",
-      "robot_pose": {
-        "position": {
-          "x": -2,
-          "y": -2,
-          "z": 0,
-          "frame": {
-            "name": "asset"
-          }
-        },
-        "orientation": {
-          "x": 0,
-          "y": 0,
-          "z": 0.4794255,
-          "w": 0.8775826,
-          "frame": {
-            "name": "asset"
-          }
-        },
-        "frame": {
-          "name": "asset"
-        }
-      },
-      "target": {
-        "x": 2,
-        "y": 2,
-        "z": 0,
-        "frame": {
-          "name": "asset"
-        }
-      }
-    },
-    {
-      "type": "take_image",
-      "robot_pose": {
-        "position": {
-          "x": -2,
-          "y": 2,
-          "z": 0,
-          "frame": {
-            "name": "asset"
-          }
-        },
-        "orientation": {
-          "x": 0,
-          "y": 0,
-          "z": 0.4794255,
-          "w": 0.8775826,
-          "frame": {
-            "name": "asset"
-          }
-        },
-        "frame": {
-          "name": "asset"
-        }
-      },
-      "target": {
-        "x": 2,
-        "y": 2,
-        "z": 0,
-        "frame": {
-          "name": "asset"
-        }
-      }
-    }
-  ]
-}

isar/config/predefined_missions/default_extra_capabilities.json

@@ -1,107 +0,0 @@
-{
-  "id": "2",
-  "name": "Default mission with extra capabilities",
-  "tasks": [
-    {
-      "type": "take_image",
-      "robot_pose": {
-        "position": {
-          "x": -3.6,
-          "y": 4,
-          "z": 0,
-          "frame": {"name": "asset"}
-        },
-        "orientation": {
-          "x": 0,
-          "y": 0,
-          "z": -0.7286672256879113,
-          "w": -0.6848660759820616,
-          "frame": {"name": "asset"}
-        },
-        "frame": {"name": "asset"}
-      },
-      "target": {
-        "x": -4.7,
-        "y": 4.9,
-        "z": 0,
-        "frame": {"name": "asset"}
-      }
-    },
-
-    {
-      "type": "take_image",
-      "robot_pose": {
-        "position": {
-          "x": 4.7,
-          "y": 3,
-          "z": 0,
-          "frame": {"name": "asset"}
-        },
-        "orientation": {
-          "x": 0,
-          "y": 0,
-          "z": 0.5769585,
-          "w": 0.8167734,
-          "frame": {"name": "asset"}
-        },
-        "frame": {"name": "asset"}
-      },
-      "target": {
-        "x": 5.6,
-        "y": 5.2,
-        "z": 0,
-        "frame": {"name": "asset"}
-      }
-    },
-    {
-      "type": "take_thermal_image",
-      "robot_pose": {
-        "position": {
-          "x": 4.7,
-          "y": 3,
-          "z": 0,
-          "frame": {"name": "asset"}
-        },
-        "orientation": {
-          "x": 0,
-          "y": 0,
-          "z": 0.5769585,
-          "w": 0.8167734,
-          "frame": {"name": "asset"}
-        },
-        "frame": {"name": "asset"}
-      },
-      "target": {
-        "x": 3.1,
-        "y": 5.2,
-        "z": 0,
-        "frame": {"name": "asset"}
-      }
-    },
-    {
-      "type": "take_thermal_image",
-      "robot_pose": {
-        "position": {
-          "x": 0.95,
-          "y": 2.6,
-          "z": 0,
-          "frame": {"name": "asset"}
-        },
-        "orientation": {
-          "x": 0,
-          "y": 0,
-          "z": -0.6992469,
-          "w": 0.7148802,
-          "frame": {"name": "asset"}
-        },
-        "frame": {"name": "asset"}
-      },
-      "target": {
-        "x": 1.9,
-        "y": 1.9,
-        "z": 0,
-        "frame": {"name": "asset"}
-      }
-    }
-  ]
-}

isar/mission_planner/local_planner.py

@@ -1,68 +0,0 @@
-import json
-import logging
-from pathlib import Path
-
-from isar.config.settings import settings
-from isar.mission_planner.mission_planner_interface import (
-    MissionNotFoundError,
-    MissionPlannerError,
-    MissionPlannerInterface,
-)
-from robot_interface.models.mission.mission import Mission
-
-logger = logging.getLogger("api")
-
-
-class LocalPlanner(MissionPlannerInterface):
-    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:
-        with open(mission_path) as json_file:
-            mission_dict = json.load(json_file)
-
-        return Mission(**mission_dict)
-
-    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)
-
-            mission: Mission = self.read_mission_from_file(path_to_file)
-            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 : str
-
-        Returns
-        -------
-        mission : Mission
-        """
-        pass
-
-
-class MissionPlannerError(Exception):
-    pass
-
-
-class MissionNotFoundError(Exception):
-    pass

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/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/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