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

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

isar/storage/slimm_storage.py

@@ -1,191 +0,0 @@
-import json
-import logging
-
-from azure.identity import DefaultAzureCredential
-from injector import inject
-from requests import HTTPError, RequestException
-from requests_toolbelt import MultipartEncoder
-
-from isar.config.settings import settings
-from isar.services.auth.azure_credentials import AzureCredentials
-from isar.services.service_connections.request_handler import RequestHandler
-from isar.storage.storage_interface import StorageException, StorageInterface
-from isar.storage.utilities import get_filename
-from robot_interface.models.inspection.inspection import Inspection, ThermalVideo, Video
-from robot_interface.models.mission.mission import Mission
-
-
-class SlimmStorage(StorageInterface):
-    @inject
-    def __init__(self, request_handler: RequestHandler) -> None:
-        self.request_handler: RequestHandler = request_handler
-        self.logger = logging.getLogger("uploader")
-
-        self.credentials: DefaultAzureCredential = (
-            AzureCredentials.get_azure_credentials()
-        )
-
-        client_id: str = settings.SLIMM_CLIENT_ID
-        scope: str = settings.SLIMM_APP_SCOPE
-        self.request_scope: str = f"{client_id}/{scope}"
-
-        self.url: str = settings.SLIMM_API_URL
-
-    def store(self, inspection: Inspection, mission: Mission) -> str:
-        filename: str = get_filename(
-            inspection=inspection,
-        )
-        filename = f"{filename}.{inspection.metadata.file_type}"
-        if type(inspection) in [Video, ThermalVideo]:
-            inspection_path = self._store_video(filename, inspection, mission)
-        else:
-            inspection_path = self._store_image(filename, inspection, mission)
-        return inspection_path
-
-    def _store_image(
-        self, filename: str, inspection: Inspection, mission: Mission
-    ) -> str:
-        multiform_body: MultipartEncoder = self._construct_multiform_request_image(
-            filename=filename, inspection=inspection, mission=mission
-        )
-        request_url: str = f"{self.url}/UploadSingleImage"
-        inspection_path = self._ingest(
-            inspection=inspection,
-            multiform_body=multiform_body,
-            request_url=request_url,
-        )
-        return inspection_path
-
-    def _store_video(
-        self, filename: str, inspection: Inspection, mission: Mission
-    ) -> str:
-        multiform_body: MultipartEncoder = self._construct_multiform_request_video(
-            filename=filename, inspection=inspection, mission=mission
-        )
-        request_url = f"{self.url}/UploadSingleVideo"
-        inspection_path = self._ingest(
-            inspection=inspection,
-            multiform_body=multiform_body,
-            request_url=request_url,
-        )
-        return inspection_path
-
-    def _ingest(
-        self, inspection: Inspection, multiform_body: MultipartEncoder, request_url: str
-    ) -> str:
-        token: str = self.credentials.get_token(self.request_scope).token
-        try:
-            response = self.request_handler.post(
-                url=request_url,
-                data=multiform_body,
-                headers={
-                    "Authorization": f"Bearer {token}",
-                    "Content-Type": multiform_body.content_type,
-                },
-            )
-            guid = json.loads(response.text)["guid"]
-            self.logger.info(f"SLIMM upload GUID: {guid}")
-        except (RequestException, HTTPError) as e:
-            self.logger.warning(
-                f"Failed to upload inspection: {inspection.id} to SLIMM due to a "
-                f"request exception"
-            )
-            raise StorageException from e
-        data = json.loads(response.content)
-        return data["guid"]
-
-    @staticmethod
-    def _construct_multiform_request_image(
-        filename: str, inspection: Inspection, mission: Mission
-    ):
-        array_of_orientation = (
-            inspection.metadata.pose.orientation.to_quat_array().tolist()
-        )
-        multiform_body: MultipartEncoder = MultipartEncoder(
-            fields={
-                "PlantFacilitySAPCode": settings.PLANT_CODE,
-                "InstCode": settings.PLANT_SHORT_NAME,
-                "InternalClassification": settings.DATA_CLASSIFICATION,
-                "IsoCountryCode": "NO",
-                "Geodetic.CoordinateReferenceSystemCode": settings.COORDINATE_REFERENCE_SYSTEM,  # noqa: E501
-                "Geodetic.VerticalCoordinateReferenceSystemCode": settings.VERTICAL_REFERENCE_SYSTEM,  # noqa: E501
-                "Geodetic.OrientationReferenceSystem": settings.MEDIA_ORIENTATION_REFERENCE_SYSTEM,  # noqa: E501
-                "SensorCarrier.SensorCarrierId": settings.ISAR_ID,
-                "SensorCarrier.ModelName": settings.ROBOT_TYPE,
-                "Mission.MissionId": mission.id,
-                "Mission.Client": "Equinor",
-                "ImageMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
-                "ImageMetadata.X": str(inspection.metadata.pose.position.x),
-                "ImageMetadata.Y": str(inspection.metadata.pose.position.y),
-                "ImageMetadata.Z": str(inspection.metadata.pose.position.z),
-                "ImageMetadata.CameraOrientation1": str(array_of_orientation[0]),
-                "ImageMetadata.CameraOrientation2": str(array_of_orientation[1]),
-                "ImageMetadata.CameraOrientation3": str(array_of_orientation[2]),
-                "ImageMetadata.CameraOrientation4": str(array_of_orientation[3]),
-                "ImageMetadata.AnalysisMethods": (
-                    inspection.metadata.additional["analysis_type"]
-                    if inspection.metadata.additional
-                    and inspection.metadata.additional["analysis_type"]
-                    else "N/A"
-                ),
-                "ImageMetadata.Description": str(inspection.metadata.additional),
-                "ImageMetadata.FunctionalLocation": (
-                    inspection.metadata.tag_id  # noqa: E501
-                    if inspection.metadata.tag_id
-                    else "N/A"
-                ),
-                "Filename": filename,
-                "AttachedFile": (filename, inspection.data),
-            }
-        )
-        return multiform_body
-
-    @staticmethod
-    def _construct_multiform_request_video(
-        filename: str,
-        inspection: Inspection,
-        mission: Mission,
-    ):
-        array_of_orientation = (
-            inspection.metadata.pose.orientation.to_quat_array().tolist()
-        )
-        multiform_body: MultipartEncoder = MultipartEncoder(
-            fields={
-                "PlantFacilitySAPCode": settings.PLANT_CODE,
-                "InstCode": settings.PLANT_SHORT_NAME,
-                "InternalClassification": settings.DATA_CLASSIFICATION,
-                "IsoCountryCode": "NO",
-                "Geodetic.CoordinateReferenceSystemCode": settings.COORDINATE_REFERENCE_SYSTEM,  # noqa: E501
-                "Geodetic.VerticalCoordinateReferenceSystemCode": settings.VERTICAL_REFERENCE_SYSTEM,  # noqa: E501
-                "Geodetic.OrientationReferenceSystem": settings.MEDIA_ORIENTATION_REFERENCE_SYSTEM,  # noqa: E501
-                "SensorCarrier.SensorCarrierId": settings.ISAR_ID,
-                "SensorCarrier.ModelName": settings.ROBOT_TYPE,
-                "Mission.MissionId": mission.id,
-                "Mission.Client": "Equinor",
-                "VideoMetadata.Timestamp": inspection.metadata.start_time.isoformat(),  # noqa: E501
-                # Converting to int because SLIMM expects an int, while we use floats in operations.
-                "VideoMetadata.Duration": str(int(inspection.metadata.duration)),  # type: ignore
-                "VideoMetadata.X": str(inspection.metadata.pose.position.x),
-                "VideoMetadata.Y": str(inspection.metadata.pose.position.y),
-                "VideoMetadata.Z": str(inspection.metadata.pose.position.z),
-                "VideoMetadata.CameraOrientation1": str(array_of_orientation[0]),
-                "VideoMetadata.CameraOrientation2": str(array_of_orientation[1]),
-                "VideoMetadata.CameraOrientation3": str(array_of_orientation[2]),
-                "VideoMetadata.CameraOrientation4": str(array_of_orientation[3]),
-                "VideoMetadata.AnalysisMethods": (
-                    inspection.metadata.additional["analysis_type"]
-                    if inspection.metadata.additional
-                    and inspection.metadata.additional["analysis_type"]
-                    else "N/A"
-                ),
-                "VideoMetadata.Description": str(inspection.metadata.additional),
-                "VideoMetadata.FunctionalLocation": (
-                    inspection.metadata.tag_id  # noqa: E501
-                    if inspection.metadata.tag_id
-                    else "N/A"
-                ),
-                "Filename": filename,
-                "AttachedFile": (filename, inspection.data),
-            }
-        )
-        return multiform_body

isar-1.20.2.dist-info/RECORD

@@ -1,116 +0,0 @@
-isar/__init__.py,sha256=cH8p8bVveu3FUL6kBhldcSlLaoHgD82Kd0-SwSNfGXw,87
-isar/modules.py,sha256=aO8bLSC4i_Qo4bOJ6aFfwAZRTJAw8o9SOOfkceUGCiU,6708
-isar/script.py,sha256=145KXMqKWkP5SjB2MyvO1HmIPJnFOQdwwWM3jy6s-9A,5260
-isar/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/api.py,sha256=vSXfkWR7iITWbh4BsDzjEDtQrz6KS-vi2S8AeaeDc3Q,13112
-isar/apis/models/__init__.py,sha256=NI1BYyN__Ogr00Qqe0XJ-9gEVPva2brXo2RJsbrS4tM,52
-isar/apis/models/models.py,sha256=BRm3Wl6TJHdHEKLRQ2SGDx6Y54qq8IesMbBuVO7RuxE,1757
-isar/apis/models/start_mission_definition.py,sha256=GuihnkVRXjzopMEiRQ4rOfeCGw98IFK9EYylB-5S0aI,7253
-isar/apis/schedule/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/schedule/scheduling_controller.py,sha256=w2F-6IKBgVN9HVopAOWBb3KUgPjhsnuPLQ3eqjDNfOg,11888
-isar/apis/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/security/authentication.py,sha256=TI8U9Y_L6ihHLMeM50ZONd5EPfuHdw_XMU_Q987W4AY,1975
-isar/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/config/configuration_error.py,sha256=rO6WOhafX6xvVib8WxV-eY483Z0PpN-9PxGsq5ATfKc,46
-isar/config/log.py,sha256=zHFLmGWQRn8TrcsxUS6KHpJt2JE86kYazU7b-bkcN9o,2285
-isar/config/logging.conf,sha256=mYO1xf27gAopEMHhGzY7-mwyfN16rwRLkPNMvy3zn2g,1127
-isar/config/settings.env,sha256=-kivj0osAAKlInnY81ugySTlcImhVABbnj9kUoBDLu8,535
-isar/config/settings.py,sha256=pZrZGe60WoMNl_SlCzJFavU3Qqil_ocCuaKcKfDn0KM,13175
-isar/config/certs/ca-cert.pem,sha256=gSBTyY0tKSFnssyvrvbFvHpQwii0kEkBryklVmevdtc,2029
-isar/config/keyvault/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/config/keyvault/keyvault_error.py,sha256=zvPCsZLjboxsxthYkxpRERCTFxYV8R5WmACewAUQLwk,41
-isar/config/keyvault/keyvault_service.py,sha256=b2EWNiNQmZ-FUWjZidNg5KXRcVH-U8CsiqcBf1devNw,3124
-isar/config/maps/JSP1_intermediate_deck.json,sha256=fdotzN6MVotyLbqpIjRSrbBYM84vogLkdS585NjBnL8,826
-isar/config/maps/JSP1_weather_deck.json,sha256=_dG3cSBI8q4_uHqHMOO5kSYqMXn85JL3_9PaH4uk1yQ,832
-isar/config/maps/default_map.json,sha256=3CdGMr0Qn3PrL4TfUK8I5a-hotMrS_n5DKfaEORJPT4,776
-isar/config/maps/klab_b.json,sha256=qXgWVUYPaTdVuomf6lQL-uRbV3Tsa6CftnzcbT3dY78,842
-isar/config/maps/klab_compressor.json,sha256=1Vrk5u_l4WXjrTtG4YfXlrCPbOoRs4TtYHOm0430u2A,803
-isar/config/maps/klab_turtlebot.json,sha256=HcB79XFEdY0Wm96EssIFO4TMyAWzc2KENoqN7TbTT0k,823
-isar/config/maps/turtleworld.json,sha256=EKLMpSK9Gu2lAN-E9l41XOaO3f9Su5n_I97mA6z7sWY,764
-isar/config/predefined_mission_definition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/config/predefined_mission_definition/default_exr.json,sha256=L3-kqjfgXoULDUgGsD3Zci7m3wdbwAuSrn4yaH4aPIA,1667
-isar/config/predefined_mission_definition/default_mission.json,sha256=nEk1ql17RAs2I5Ws2wA-0GJ6oqJco-Q0Q0vhf4k6ajc,2926
-isar/config/predefined_mission_definition/default_turtlebot.json,sha256=Ka379MLu8qiGIa6Fu-8p8A4OgHVccLkKYSX0RthUOeI,4060
-isar/config/predefined_missions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/config/predefined_missions/default.json,sha256=3J1KtQIFKxJsVoKlg0nKsj8asev-2dSz6IOrd4A57jY,2759
-isar/config/predefined_missions/default_turtlebot.json,sha256=gStYz_hCgQDBEeUW7W4bq_0R3OO55jRnwZt0CNYvHSM,3352
-isar/config/predefined_poses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/config/predefined_poses/predefined_poses.py,sha256=fhq8JF00feDLFKNBlyWeFoLfvfs5dVb__C7CmiVbwmQ,25779
-isar/mission_planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/mission_planner/local_planner.py,sha256=1Qcz7QntWXuYL1PcF6R9aZNCCdL-j_RJ2UGc1_rNZd8,3037
-isar/mission_planner/mission_planner_interface.py,sha256=51k6KKXqC8wZ4Mc8ZWo00Nwy8c6yNa81nEZNZelwJeo,485
-isar/mission_planner/sequential_task_selector.py,sha256=4OJ1Rvg6MaDQQxNcgAUtp2gvhHm3Srha5XJUu8X-Uzg,640
-isar/mission_planner/task_selector_interface.py,sha256=aXL2RXb_XmTNW-WXt6E7wFfJf_BjbownDa3zSqgQ4Ww,703
-isar/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/models/communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/models/communication/message.py,sha256=yN4SXYM-W_6u3Cf9yuAE3jy4e6mMrL3yUr-iVV4r55E,241
-isar/models/communication/queues/__init__.py,sha256=JqwWbdBQnBeIEhSTjBOkl-O3bYBVBSmjPcWUdscsobw,146
-isar/models/communication/queues/queue_io.py,sha256=AnHWUCkZ0tunkxKKeBarq-OUkRM97IaMfA-a1pmf1cQ,394
-isar/models/communication/queues/queue_timeout_error.py,sha256=rF8TlNF7RHS_ueTZ5mp7aFkhLY1j0dcwMwH-Ba6lVpE,45
-isar/models/communication/queues/queues.py,sha256=FzoqlT4AQ4Q5Jufh6yRPV2uq5iUZd1odrpjBl77yU5o,803
-isar/models/communication/queues/status_queue.py,sha256=K_i01uzCu1eciDt9QlDXLBINJnuRLqm6fzrM-PY6qD0,467
-isar/models/mission_metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/auth/azure_credentials.py,sha256=9PlwGe5FrPRbW2dp0go7LMp8_l_FRvL8xOXotXwzRDo,364
-isar/services/readers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/readers/base_reader.py,sha256=_fNd5fb5dFeMtOvfWzIAGO-KIgl3zT19iEuzSjeZNPc,987
-isar/services/service_connections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/service_connections/request_handler.py,sha256=0LxC0lu_HXeEf_xmJWjfEsh14oAUI97cpG1IWtBlcs4,4278
-isar/services/service_connections/mqtt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/service_connections/mqtt/mqtt_client.py,sha256=Aib0lqaddxW9aVXXYD7wGL9jIpr2USCCH91SQgFdIG4,3548
-isar/services/service_connections/mqtt/robot_heartbeat_publisher.py,sha256=0Qjo2wRZZoooXG-UE4z8YJc9QCCz6v-9YAqHRJgx-kE,1005
-isar/services/service_connections/mqtt/robot_info_publisher.py,sha256=f1vhBNPlx6p3Au8l7OsWIJXRM_xjA8qcLHvnkwCtRBM,1388
-isar/services/service_connections/stid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/services/utilities/queue_utilities.py,sha256=Pw3hehSwkXJNeDv-bDVDfs58VOwtt3i5hpiJ2ZpphuQ,1225
-isar/services/utilities/scheduling_utilities.py,sha256=LFimEmacML3J9q-FNLfKPhcAr-R3f2rkYkbsoro0Gyo,8434
-isar/services/utilities/threaded_request.py,sha256=py4G-_RjnIdHljmKFAcQ6ddqMmp-ZYV39Ece-dqRqjs,1874
-isar/state_machine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/state_machine/state_machine.py,sha256=-i7m2xVcgL3cW6AIMGAom97wzt433MXM8EQEGUykAJA,23653
-isar/state_machine/states_enum.py,sha256=BlrUcBWkM5K6D_UZXRwTaUgGpAagWmVZH6HhDBGzVU4,278
-isar/state_machine/states/__init__.py,sha256=kErbKPDTwNfCLijvdyN6_AuOqDwR23nu9F0Qovsnir4,218
-isar/state_machine/states/idle.py,sha256=_nrM17s4artaHezanl28_WcNyJod1_hkCyzAqZlPQiE,3034
-isar/state_machine/states/initialize.py,sha256=KUuyXVwzWK5bJNspA1JnYO_Xwu8fPPK6bnHK4mtwf5A,2359
-isar/state_machine/states/initiate.py,sha256=WqBROOGAh0DVB0f39RFkpqzkr0qrHMyrBGkh2svBbKw,5652
-isar/state_machine/states/monitor.py,sha256=t0wtRPrjnWnGQ8JXia7kLkSc8tyd33mBI7UDDAsJ6FM,10874
-isar/state_machine/states/off.py,sha256=jjqN_oJMpBtWuY7hP-c9f0w3p2CYCfe-NpmYHHPnmyI,544
-isar/state_machine/states/offline.py,sha256=wEMMIwM4JWfmDjI7pe9yKce_Mfz9aXqs6WEkxn8cx5I,2125
-isar/state_machine/states/paused.py,sha256=HqrvONw6r6AoYPUyFGGOy2ToT7Tid8JEw2pKp2ZhZ7Y,1004
-isar/state_machine/states/stop.py,sha256=zu7bVKR5zfkzU7iCrh8Pe2WRDHHzU2RBeFBxFK6Z-eA,3348
-isar/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/storage/blob_storage.py,sha256=oKdml1VVN8iTr-d_5H4Lz5E7zrhJRknCzOxHD-tO7m8,3230
-isar/storage/local_storage.py,sha256=Bnmoi5gyN8r-oRh0aHrOdGqaH3JqRScFKMRXYojW5kY,1855
-isar/storage/slimm_storage.py,sha256=Hp7ZIgZgIR4KAFjzxDKfgMZjPZwP2kmdc1gG8zVcsMk,8966
-isar/storage/storage_interface.py,sha256=DYDry4I7aZpDHJhsBF6s8zrgokFAc7fdKJKfA8AvL7o,828
-isar/storage/uploader.py,sha256=te3GyiSeu96MhbiqQ7ueIMUPLSKblx3UqYAshkxfVIE,6368
-isar/storage/utilities.py,sha256=eTyY56WCTda5YswE9znWNeNEoTbT3jokNbwcLVmmQjA,3113
-robot_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/robot_interface.py,sha256=i2qw1V9mLO-ljtS7LiRliQ7XNmmBJIwD4NG8mDfwMEI,8317
-robot_interface/test_robot_interface.py,sha256=FV1urn7SbsMyWBIcTKjsBwAG4IsXeZ6pLHE0mA9EGGs,692
-robot_interface/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/models/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/models/exceptions/robot_exceptions.py,sha256=l1h62gq7lfLzWoHh2ytdEWgn_4lS4M-GPxHkjgAXcP4,9036
-robot_interface/models/initialize/__init__.py,sha256=rz5neEDr59GDbzzI_FF0DId-C-I-50l113P-h-C_QBY,48
-robot_interface/models/initialize/initialize_params.py,sha256=2eG5Aq5bDKU6tVkaUMAoc46GERBgyaKkqv6yLupdRLc,164
-robot_interface/models/inspection/__init__.py,sha256=14wfuj4XZazrigKD7fL98khFKz-eckIpEgPcYRj40Kg,227
-robot_interface/models/inspection/inspection.py,sha256=TVqUl5o3d3fp8IravOMwJIuRoEU8y4BltFrF1IkwvTA,2176
-robot_interface/models/mission/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/models/mission/mission.py,sha256=xJ7i79TQkmO0Tv2IQeguhyliNP2J42ziS5iO-FyBpW0,839
-robot_interface/models/mission/status.py,sha256=R5jLmmn6M7oNX907QvbrhoAqAo4C1zB653Ed1PcxAtg,922
-robot_interface/models/mission/step.py,sha256=DEzU-LD-i3RTAaXBy5KwJZ6OnN5S0F3wwDaqX2DZ72M,5587
-robot_interface/models/mission/task.py,sha256=JJ062AIdwVoj3PUkWYmJDvRl5B7Tcu9S11J2F_0tfjE,4695
-robot_interface/models/robots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/models/robots/robot_model.py,sha256=pZQsqhn9hh6XE3EjMZhWMzYqg5oJ4CJ4CXeOASKvEf8,452
-robot_interface/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/telemetry/mqtt_client.py,sha256=AHBmOpVvoo6pY5uXwyBY7SooN_cnpuS0DMkfLUPwpl8,2743
-robot_interface/telemetry/payloads.py,sha256=eMK7mjZPsLY6yvu7AK-OcdvkeUpChzDrySDY7IjQ9RM,1464
-robot_interface/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/utilities/json_service.py,sha256=nU2Q_3P9Fq9hs6F_wtUjWtHfl_g1Siy-yDhXXSKwHwg,1018
-robot_interface/utilities/uuid_string_factory.py,sha256=_NQIbBQ56w0qqO0MUDP6aPpHbxW7ATRhK8HnQiBSLkc,76
-isar-1.20.2.dist-info/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
-isar-1.20.2.dist-info/METADATA,sha256=eGOpcvDhrvMdIocMCNNBxUQ_9q4Z_F_1aZOu9kNisiI,30574
-isar-1.20.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-isar-1.20.2.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.20.2.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.20.2.dist-info/RECORD,,

robot_interface/models/initialize/__init__.py

@@ -1 +0,0 @@
-from .initialize_params import InitializeParams

robot_interface/models/initialize/initialize_params.py

@@ -1,9 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from alitra import Pose
-
-
-@dataclass
-class InitializeParams:
-    initial_pose: Optional[Pose] = None