isar 1.26.2__py3-none-any.whl → 1.26.3__py3-none-any.whl

isar/apis/api.py

@@ -5,10 +5,10 @@ from typing import List, Union
 
 import click
 import uvicorn
+from dependency_injector.wiring import inject
 from fastapi import FastAPI, Request, Security
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.routing import APIRouter
-from injector import inject
 from opencensus.ext.azure.trace_exporter import AzureExporter
 from opencensus.trace.attributes_helper import COMMON_ATTRIBUTES
 from opencensus.trace.samplers import ProbabilitySampler
@@ -36,14 +36,14 @@ class API:
         authenticator: Authenticator,
         scheduling_controller: SchedulingController,
         robot_controller: RobotController,
-        keyvault_client: Keyvault,
+        keyvault: Keyvault,
         port: int = settings.API_PORT,
         azure_ai_logging_enabled: bool = settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED,
     ) -> None:
         self.authenticator: Authenticator = authenticator
         self.scheduling_controller: SchedulingController = scheduling_controller
         self.robot_controller: RobotController = robot_controller
-        self.keyvault_client: Keyvault = keyvault_client
+        self.keyvault: Keyvault = keyvault
         self.host: str = "0.0.0.0"  # Locking uvicorn to use 0.0.0.0
         self.port: int = port
         self.azure_ai_logging_enabled: bool = azure_ai_logging_enabled
@@ -295,7 +295,7 @@ class API:
     def _add_request_logging_middleware(self, app: FastAPI) -> None:
         connection_string: str
         try:
-            connection_string = self.keyvault_client.get_secret(
+            connection_string = self.keyvault.get_secret(
                 "application-insights-connection-string"
             ).value
         except KeyvaultError:

isar/apis/robot_control/robot_controller.py

@@ -1,7 +1,7 @@
 import logging
 
+from dependency_injector.wiring import inject
 from fastapi import HTTPException
-from injector import inject
 
 from isar.apis.models.models import RobotInfoResponse
 from isar.config.settings import robot_settings, settings

isar/apis/schedule/scheduling_controller.py

@@ -1,8 +1,8 @@
 import logging
 from http import HTTPStatus
 
+from dependency_injector.wiring import inject
 from fastapi import Body, HTTPException, Path
-from injector import inject
 
 from isar.apis.models.models import (
     ControlMissionResponse,

isar/apis/security/authentication.py

@@ -3,7 +3,7 @@ import logging
 from fastapi import Depends
 from fastapi.security.base import SecurityBase
 from fastapi_azure_auth import SingleTenantAzureAuthorizationCodeBearer
-from fastapi_azure_auth.exceptions import InvalidAuth
+from fastapi_azure_auth.exceptions import InvalidAuthHttp
 from fastapi_azure_auth.user import User
 from pydantic import BaseModel
 
@@ -35,7 +35,7 @@ async def validate_has_role(user: User = Depends(azure_scheme)) -> None:
     Raises a 403 authorization error if not.
     """
     if settings.REQUIRED_ROLE not in user.roles:
-        raise InvalidAuth(
+        raise InvalidAuthHttp(
             "Current user does not possess the required role for this endpoint"
         )
 

isar/config/log.py

@@ -56,7 +56,8 @@ def configure_azure_handler(log_config: dict, keyvault: Keyvault) -> logging.Han
         ).value
     except KeyvaultError:
         message: str = (
-            f"CRITICAL ERROR: Missing connection string for Application Insights in key vault '{keyvault.name}'."
+            "CRITICAL ERROR: Missing connection string for"
+            f" Application Insights in key vault '{keyvault.name}'."
         )
         print(f"\n{message} \n")
         raise ConfigurationError(message)

isar/mission_planner/local_planner.py

@@ -2,7 +2,7 @@ import json
 import logging
 from pathlib import Path
 
-from injector import inject
+from dependency_injector.wiring import inject
 
 from isar.config.settings import settings
 from isar.mission_planner.mission_planner_interface import (

isar/modules.py

@@ -1,10 +1,7 @@
-import logging
+import os
 from importlib import import_module
-from logging import Logger
-from types import ModuleType
-from typing import Dict, List, Tuple, Union
 
-from injector import Injector, Module, multiprovider, provider, singleton
+from dependency_injector import containers, providers
 
 from isar.apis.api import API
 from isar.apis.robot_control.robot_controller import RobotController
@@ -13,10 +10,10 @@ from isar.apis.security.authentication import Authenticator
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 from isar.mission_planner.local_planner import LocalPlanner
-from isar.mission_planner.mission_planner_interface import MissionPlannerInterface
 from isar.mission_planner.sequential_task_selector import SequentialTaskSelector
 from isar.mission_planner.task_selector_interface import TaskSelectorInterface
 from isar.models.communication.queues.events import Events, SharedState
+from isar.robot.robot import Robot
 from isar.services.service_connections.request_handler import RequestHandler
 from isar.services.utilities.robot_utilities import RobotUtilities
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities
@@ -24,224 +21,118 @@ from isar.state_machine.state_machine import StateMachine
 from isar.storage.blob_storage import BlobStorage
 from isar.storage.local_storage import LocalStorage
 from isar.storage.slimm_storage import SlimmStorage
-from isar.storage.storage_interface import StorageInterface
 from isar.storage.uploader import Uploader
-from robot_interface.robot_interface import RobotInterface
-from robot_interface.telemetry.mqtt_client import MqttClientInterface, MqttPublisher
-
-
-class APIModule(Module):
-    @provider
-    @singleton
-    def provide_api(
-        self,
-        authenticator: Authenticator,
-        scheduling_controller: SchedulingController,
-        robot_controller: RobotController,
-        keyvault: Keyvault,
-    ) -> API:
-        return API(authenticator, scheduling_controller, robot_controller, keyvault)
-
-    @provider
-    @singleton
-    def provide_scheduling_controller(
-        self,
-        scheduling_utilities: SchedulingUtilities,
-    ) -> SchedulingController:
-        return SchedulingController(scheduling_utilities)
-
-    @provider
-    @singleton
-    def provide_robot_controller(
-        self,
-        robot_utilities: RobotUtilities,
-    ) -> RobotController:
-        return RobotController(robot_utilities)
-
-
-class AuthenticationModule(Module):
-    @provider
-    @singleton
-    def provide_authenticator(self) -> Authenticator:
-        return Authenticator()
-
-
-class RobotModule(Module):
-    @provider
-    @singleton
-    def provide_robot_interface(self) -> RobotInterface:
-        robot_interface: ModuleType = import_module(
-            f"{settings.ROBOT_PACKAGE}.robotinterface"
+from robot_interface.telemetry.mqtt_client import MqttPublisher
+
+
+class ApplicationContainer(containers.DeclarativeContainer):
+    config = providers.Configuration(pydantic_settings=[settings])
+
+    # Core services
+    keyvault = providers.Singleton(
+        Keyvault,
+        keyvault_name=settings.KEYVAULT_NAME,
+        client_id=settings.AZURE_CLIENT_ID,
+        client_secret=os.environ.get("AZURE_CLIENT_SECRET"),
+        tenant_id=settings.AZURE_TENANT_ID,
+    )
+
+    # Events and shared state
+    events = providers.Singleton(Events)
+    shared_state = providers.Singleton(SharedState)
+
+    # Robot-related services
+    robot_interface = providers.Singleton(
+        lambda: import_module(f"{settings.ROBOT_PACKAGE}.robotinterface").Robot()
+    )
+    robot_utilities = providers.Singleton(RobotUtilities, robot=robot_interface)
+
+    # API and controllers
+    authenticator = providers.Singleton(Authenticator)
+    scheduling_utilities = providers.Singleton(
+        SchedulingUtilities,
+        events=events,
+        shared_state=shared_state,
+        mission_planner=providers.Singleton(LocalPlanner),
+    )
+    scheduling_controller = providers.Singleton(
+        SchedulingController, scheduling_utilities=scheduling_utilities
+    )
+    robot_controller = providers.Singleton(
+        RobotController, robot_utilities=robot_utilities
+    )
+    api = providers.Singleton(
+        API,
+        authenticator=authenticator,
+        scheduling_controller=scheduling_controller,
+        robot_controller=robot_controller,
+        keyvault=keyvault,
+    )
+
+    # Storage
+    local_storage = providers.Singleton(LocalStorage)
+    blob_storage = providers.Singleton(BlobStorage, keyvault=keyvault)
+    slimm_storage = providers.Singleton(
+        SlimmStorage, request_handler=providers.Singleton(RequestHandler)
+    )
+    storage_handlers = providers.List(local_storage, blob_storage, slimm_storage)
+
+    # Mqtt client
+    mqtt_client = (
+        providers.Singleton(
+            MqttPublisher,
+            mqtt_queue=providers.Callable(events.provided.mqtt_queue),
         )
-        return robot_interface.Robot()  # type: ignore
-
-
-class EventsModule(Module):
-    @provider
-    @singleton
-    def provide_events(self) -> Events:
-        return Events()
-
-
-class SharedStateModule(Module):
-    @provider
-    @singleton
-    def provide_shared_state(self) -> SharedState:
-        return SharedState()
-
-
-class RequestHandlerModule(Module):
-    @provider
-    @singleton
-    def provide_request_handler(self) -> RequestHandler:
-        return RequestHandler()
-
-
-class BlobStorageModule(Module):
-    @multiprovider
-    @singleton
-    def provide_blob_storage(self, keyvault: Keyvault) -> List[StorageInterface]:
-        return [BlobStorage(keyvault)]
-
-
-class LocalStorageModule(Module):
-    @multiprovider
-    @singleton
-    def provide_local_storage(self) -> List[StorageInterface]:
-        return [LocalStorage()]
-
-
-class SlimmStorageModule(Module):
-    @multiprovider
-    @singleton
-    def provide_slimm_storage(
-        self, request_handler: RequestHandler
-    ) -> List[StorageInterface]:
-        return [SlimmStorage(request_handler=request_handler)]
-
-
-class LocalPlannerModule(Module):
-    @provider
-    @singleton
-    def provide_local_planner(self) -> MissionPlannerInterface:
-        return LocalPlanner()
-
-
-class StateMachineModule(Module):
-    @provider
-    @singleton
-    def provide_state_machine(
-        self,
-        events: Events,
-        shared_state: SharedState,
-        robot: RobotInterface,
-        mqtt_client: MqttClientInterface,
-        task_selector: TaskSelectorInterface,
-    ) -> StateMachine:
-        return StateMachine(
-            events=events,
-            shared_state=shared_state,
-            robot=robot,
-            mqtt_publisher=mqtt_client,
-            task_selector=task_selector,
-        )
-
-
-class UploaderModule(Module):
-    @provider
-    @singleton
-    def provide_uploader(
-        self,
-        events: Events,
-        storage_handlers: List[StorageInterface],
-        mqtt_client: MqttClientInterface,
-    ) -> Uploader:
-        return Uploader(
-            events=events,
-            storage_handlers=storage_handlers,
-            mqtt_publisher=mqtt_client,
-        )
-
-
-class SchedulingUtilitiesModule(Module):
-    @provider
-    @singleton
-    def provide_scheduling_utilities(
-        self,
-        events: Events,
-        shared_state: SharedState,
-        mission_planner: MissionPlannerInterface,
-    ) -> SchedulingUtilities:
-        return SchedulingUtilities(events, shared_state, mission_planner)
-
-
-class RobotUtilitiesModule(Module):
-    @provider
-    @singleton
-    def provide_robot_utilities(self, robot: RobotInterface) -> RobotUtilities:
-        return RobotUtilities(robot)
-
-
-class ServiceModule(Module):
-    @provider
-    @singleton
-    def provide_keyvault(self) -> Keyvault:
-        return Keyvault(keyvault_name=settings.KEYVAULT_NAME)
-
-
-class MqttModule(Module):
-    @provider
-    @singleton
-    def provide_mqtt_client(self, events: Events) -> MqttClientInterface:
-        if settings.MQTT_ENABLED:
-            return MqttPublisher(mqtt_queue=events.mqtt_queue)
-        return None
-
-
-class SequentialTaskSelectorModule(Module):
-    @provider
-    @singleton
-    def provide_task_selector(self) -> TaskSelectorInterface:
-        return SequentialTaskSelector()
-
-
-modules: Dict[str, Tuple[Module, Union[str, bool]]] = {
-    "api": (APIModule, "required"),
-    "authentication": (AuthenticationModule, "required"),
-    "events": (EventsModule, "required"),
-    "shared_state": (SharedStateModule, "required"),
-    "request_handler": (RequestHandlerModule, "required"),
-    "robot_package": (RobotModule, settings.ROBOT_PACKAGE),
-    "isar_id": (RobotModule, settings.ISAR_ID),
-    "robot_name": (RobotModule, settings.ROBOT_NAME),
-    "mission_planner": (LocalPlannerModule, settings.MISSION_PLANNER),
-    "task_selector": (
-        {"sequential": SequentialTaskSelectorModule}[settings.TASK_SELECTOR],
-        settings.TASK_SELECTOR,
-    ),
-    "service": (ServiceModule, "required"),
-    "state_machine": (StateMachineModule, "required"),
-    "storage_local": (LocalStorageModule, settings.STORAGE_LOCAL_ENABLED),
-    "storage_blob": (BlobStorageModule, settings.STORAGE_BLOB_ENABLED),
-    "storage_slimm": (SlimmStorageModule, settings.STORAGE_SLIMM_ENABLED),
-    "mqtt": (MqttModule, "required"),
-    "utilities": (SchedulingUtilitiesModule, "required"),
-    "robot_utilities": (RobotUtilitiesModule, "required"),
-}
-
-
-def get_injector() -> Injector:
-    injector_modules: List[Module] = []
-    module_overview: str = ""
-
-    for category, (module, config_option) in modules.items():
-        if config_option:
-            injector_modules.append(module)
-        module_overview += (
-            f"\n    {category:<15} : {config_option:<20} ({module.__name__})"
-        )
-
-    logger: Logger = logging.getLogger("modules")
-    logger.info("Loaded the following module configurations: %s", module_overview)
-
-    return Injector(injector_modules)
+        if settings.MQTT_ENABLED
+        else None
+    )
+
+    # State machine
+    task_selector = providers.Singleton(
+        SequentialTaskSelector
+        if settings.TASK_SELECTOR == "sequential"
+        else TaskSelectorInterface
+    )
+
+    state_machine = providers.Singleton(
+        StateMachine,
+        events=events,
+        shared_state=shared_state,
+        robot=robot_interface,
+        mqtt_publisher=mqtt_client,
+        task_selector=task_selector,
+    )
+
+    # Robot
+    robot = providers.Singleton(
+        Robot, events=events, robot=robot_interface, shared_state=shared_state
+    )
+
+    # Uploader
+    uploader = providers.Singleton(
+        Uploader,
+        events=events,
+        storage_handlers=storage_handlers,
+        mqtt_publisher=mqtt_client,
+    )
+
+
+def get_injector() -> ApplicationContainer:
+    container = ApplicationContainer()
+    container.init_resources()
+    container.wire(modules=[__name__])
+    container.config.from_dict(
+        {
+            "KEYVAULT_NAME": settings.KEYVAULT_NAME,
+            "MQTT_ENABLED": settings.MQTT_ENABLED,
+            "TASK_SELECTOR": settings.TASK_SELECTOR,
+        }
+    )
+
+    print("Loaded the following module configurations:")
+    for provider_name, provider in container.providers.items():
+        provider_repr = repr(provider)
+        simplified_provider = provider_repr.split(".")[-1].split(">")[0]
+        print(f"    {provider_name:<20}: {simplified_provider}")
+
+    return container

isar/robot/robot.py

@@ -3,7 +3,7 @@ from queue import Queue
 from threading import Event
 from typing import Optional
 
-from injector import inject
+from dependency_injector.wiring import inject
 
 from isar.models.communication.queues.events import (
     Events,
@@ -20,11 +20,10 @@ from robot_interface.robot_interface import RobotInterface
 
 
 class Robot(object):
-
     @inject
     def __init__(
         self, events: Events, robot: RobotInterface, shared_state: SharedState
-    ):
+    ) -> None:
         self.logger = logging.getLogger("robot")
         self.state_machine_events: StateMachineEvents = events.state_machine_events
         self.robot_service_events: RobotServiceEvents = events.robot_service_events
@@ -107,10 +106,7 @@ class Robot(object):
         )
         self.robot_status_thread.start()
 
-        while True:
-            if self.signal_thread_quitting.is_set():
-                break
-
+        while not self.signal_thread_quitting.wait(0):
             self._check_and_handle_start_mission(
                 self.state_machine_events.start_mission
             )

isar/robot/robot_start_mission.py

@@ -17,7 +17,6 @@ from robot_interface.robot_interface import RobotInterface
 
 
 class RobotStartMissionThread(Thread):
-
     def __init__(
         self,
         robot_service_events: RobotServiceEvents,

isar/robot/robot_status.py

@@ -9,7 +9,6 @@ from robot_interface.robot_interface import RobotInterface
 
 
 class RobotStatusThread(Thread):
-
     def __init__(
         self,
         robot: RobotInterface,
@@ -21,7 +20,7 @@ class RobotStatusThread(Thread):
         self.robot: RobotInterface = robot
         self.signal_thread_quitting: Event = signal_thread_quitting
         self.last_robot_status_poll_time: float = time.time()
-        Thread.__init__(self, name="Robot status thread", daemon=True)
+        Thread.__init__(self, name="Robot status thread")
 
     def stop(self) -> None:
         return
@@ -35,10 +34,10 @@ class RobotStatusThread(Thread):
         )
 
     def run(self):
-        while True:
-            if self.signal_thread_quitting.is_set():
-                break
+        if self.signal_thread_quitting.is_set():
+            return
 
+        while not self.signal_thread_quitting.wait(0.001):
             if not self._is_ready_to_poll_for_status():
                 continue
 

isar/robot/robot_stop_mission.py

@@ -18,7 +18,6 @@ from robot_interface.robot_interface import RobotInterface
 
 
 class RobotStopMissionThread(Thread):
-
     def __init__(
         self,
         robot_service_events: RobotServiceEvents,

isar/robot/robot_task_status.py

@@ -19,7 +19,6 @@ from robot_interface.robot_interface import RobotInterface
 
 
 class RobotTaskStatusThread(Thread):
-
     def __init__(
         self,
         robot_service_events: RobotServiceEvents,

isar/script.py

@@ -5,15 +5,12 @@ from logging import Logger
 from threading import Thread
 from typing import Any, List, Tuple
 
-from injector import Injector
-
 import isar
 from isar.apis.api import API
-from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.log import setup_loggers
 from isar.config.settings import robot_settings, settings
 from isar.models.communication.queues.events import Events
-from isar.modules import get_injector
+from isar.modules import ApplicationContainer, get_injector
 from isar.robot.robot import Robot
 from isar.services.service_connections.mqtt.mqtt_client import MqttClient
 from isar.services.service_connections.mqtt.robot_heartbeat_publisher import (
@@ -83,19 +80,19 @@ def print_startup_info():
 
 
 def start() -> None:
-    injector: Injector = get_injector()
+    injector: ApplicationContainer = get_injector()
 
-    keyvault_client = injector.get(Keyvault)
-    setup_loggers(keyvault=keyvault_client)
+    keyvault = injector.keyvault()
+    setup_loggers(keyvault=keyvault)
     logger: Logger = logging.getLogger("main")
 
     print_startup_info()
 
-    state_machine: StateMachine = injector.get(StateMachine)
-    uploader: Uploader = injector.get(Uploader)
-    robot: RobotInterface = injector.get(RobotInterface)
-    events: Events = injector.get(Events)
-    robot_service: Robot = injector.get(Robot)
+    state_machine: StateMachine = injector.state_machine()
+    uploader: Uploader = injector.uploader()
+    robot_interface: RobotInterface = injector.robot_interface()
+    events: Events = injector.events()
+    robot: Robot = injector.robot()
 
     threads: List[Thread] = []
 
@@ -110,7 +107,7 @@ def start() -> None:
     threads.append(uploader_thread)
 
     robot_service_thread: Thread = Thread(
-        target=robot_service.run, name="Robot service", daemon=True
+        target=robot.run, name="Robot service", daemon=True
     )
     threads.append(robot_service_thread)
 
@@ -123,7 +120,7 @@ def start() -> None:
             )
             state_machine.events.upload_queue.put(message)
 
-        robot.register_inspection_callback(inspections_callback)
+        robot_interface.register_inspection_callback(inspections_callback)
 
     if settings.MQTT_ENABLED:
         mqtt_client: MqttClient = MqttClient(mqtt_queue=events.mqtt_queue)
@@ -154,7 +151,7 @@ def start() -> None:
         )
         threads.append(robot_heartbeat_thread)
 
-        publishers: List[Thread] = robot.get_telemetry_publishers(
+        publishers: List[Thread] = robot_interface.get_telemetry_publishers(
             queue=events.mqtt_queue,
             robot_name=settings.ROBOT_NAME,
             isar_id=settings.ISAR_ID,
@@ -163,7 +160,7 @@ def start() -> None:
         if publishers:
             threads.extend(publishers)
 
-    api: API = injector.get(API)
+    api: API = injector.api()
     api_thread: Thread = Thread(target=api.run_app, name="ISAR API", daemon=True)
     threads.append(api_thread)
 

isar/services/utilities/robot_utilities.py

@@ -1,6 +1,6 @@
 import logging
 
-from injector import inject
+from dependency_injector.wiring import inject
 
 from robot_interface.models.robots.media import MediaConfig
 from robot_interface.robot_interface import RobotInterface

isar/services/utilities/scheduling_utilities.py

@@ -4,8 +4,8 @@ from http import HTTPStatus
 from queue import Empty
 from typing import Any, List
 
+from dependency_injector.wiring import inject
 from fastapi import HTTPException
-from injector import inject
 from requests import HTTPError
 
 from isar.apis.models.models import ControlMissionResponse

isar/state_machine/state_machine.py

@@ -2,9 +2,10 @@ import json
 import logging
 from collections import deque
 from datetime import datetime, timezone
+from threading import Event
 from typing import Deque, List, Optional
 
-from injector import inject
+from dependency_injector.wiring import inject
 from transitions import Machine
 from transitions.core import State
 
@@ -97,6 +98,8 @@ class StateMachine(object):
         self.mqtt_publisher: Optional[MqttClientInterface] = mqtt_publisher
         self.task_selector: TaskSelectorInterface = task_selector
 
+        self.signal_state_machine_to_stop: Event = Event()
+
         # List of states
         self.stop_state: State = Stop(self)
         self.paused_state: State = Paused(self)
@@ -237,6 +240,10 @@ class StateMachine(object):
         """Starts the state machine. Transitions into idle state."""
         self.to_idle()  # type: ignore
 
+    def terminate(self):
+        self.logger.info("Stopping state machine")
+        self.signal_state_machine_to_stop.set()
+
     def iterate_current_task(self):
         if self.current_task.is_finished():
             try:

isar/state_machine/states/blocked_protective_stop.py

@@ -21,6 +21,7 @@ class BlockedProtectiveStop(State):
         self.logger = logging.getLogger("state_machine")
         self.robot_status_thread: Optional[ThreadedRequest] = None
         self.shared_state = self.state_machine.shared_state
+        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -31,8 +32,15 @@ class BlockedProtectiveStop(State):
 
     def _run(self) -> None:
         while True:
-            robot_status = check_shared_state(self.shared_state.robot_status)
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.__class__.__name__
+                )
+                break
 
+            robot_status: RobotStatus = check_shared_state(
+                self.shared_state.robot_status
+            )
             if robot_status == RobotStatus.Offline:
                 transition = self.state_machine.robot_turned_offline  # type: ignore
                 break

isar/state_machine/states/idle.py

@@ -25,6 +25,7 @@ class Idle(State):
         self.last_robot_status_poll_time: float = time.time()
         self.events = self.state_machine.events
         self.shared_state = self.state_machine.shared_state
+        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -63,6 +64,12 @@ class Idle(State):
 
     def _run(self) -> None:
         while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.__class__.__name__
+                )
+                break
+
             if self._check_and_handle_stop_mission_event(
                 self.events.api_requests.stop_mission.input
             ):

isar/state_machine/states/monitor.py

@@ -2,9 +2,10 @@ import logging
 import time
 from copy import deepcopy
 from queue import Queue
+from threading import Event
 from typing import TYPE_CHECKING, Optional, Tuple
 
-from injector import inject
+from dependency_injector.wiring import inject
 from transitions import State
 
 from isar.config.settings import settings
@@ -35,6 +36,10 @@ class Monitor(State):
 
         self.awaiting_task_status: bool = False
 
+        self.signal_state_machine_to_stop: Event = (
+            state_machine.signal_state_machine_to_stop
+        )
+
     def start(self) -> None:
         self.state_machine.update_state()
         self._run()
@@ -139,6 +144,12 @@ class Monitor(State):
     def _run(self) -> None:
         self.awaiting_task_status = False
         while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.__class__.__name__
+                )
+                break
+
             if self._check_and_handle_stop_mission_event(
                 self.events.api_requests.stop_mission.input
             ):

isar/state_machine/states/offline.py

@@ -17,6 +17,7 @@ class Offline(State):
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
         self.shared_state = self.state_machine.shared_state
+        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -27,6 +28,12 @@ class Offline(State):
 
     def _run(self) -> None:
         while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.__class__.__name__
+                )
+                break
+
             robot_status: RobotStatus = check_shared_state(
                 self.shared_state.robot_status
             )

isar/state_machine/states/paused.py

@@ -16,6 +16,7 @@ class Paused(State):
         self.state_machine: "StateMachine" = state_machine
         self.logger = logging.getLogger("state_machine")
         self.events = self.state_machine.events
+        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -24,6 +25,12 @@ class Paused(State):
     def _run(self) -> None:
         transition: Callable
         while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.__class__.__name__
+                )
+                break
+
             if check_for_event(self.events.api_requests.pause_mission.input):
                 transition = self.state_machine.stop  # type: ignore
                 break

isar/state_machine/states/stop.py

@@ -21,6 +21,7 @@ class Stop(State):
         self.events = self.state_machine.events
         self.stop_thread: Optional[ThreadedRequest] = None
         self._count_number_retries: int = 0
+        self.signal_state_machine_to_stop = state_machine.signal_state_machine_to_stop
 
     def start(self) -> None:
         self.state_machine.update_state()
@@ -48,6 +49,11 @@ class Stop(State):
 
     def _run(self) -> None:
         while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.__class__.__name__
+                )
+                break
 
             if self._check_and_handle_failed_stop(
                 self.events.robot_service_events.mission_failed_to_stop

isar/storage/blob_storage.py

@@ -4,7 +4,7 @@ from typing import Union
 
 from azure.core.exceptions import ResourceExistsError
 from azure.storage.blob import BlobClient, BlobServiceClient, ContainerClient
-from injector import inject
+from dependency_injector.wiring import inject
 
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings

isar/storage/slimm_storage.py

@@ -2,7 +2,7 @@ import json
 import logging
 
 from azure.identity import DefaultAzureCredential
-from injector import inject
+from dependency_injector.wiring import inject
 from requests import HTTPError, RequestException
 from requests_toolbelt import MultipartEncoder
 

isar/storage/uploader.py

@@ -3,9 +3,10 @@ import logging
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from queue import Empty, Queue
+from threading import Event
 from typing import List, Union
 
-from injector import inject
+from dependency_injector.wiring import inject
 
 from isar.config.settings import settings
 from isar.models.communication.queues.events import Events
@@ -75,11 +76,16 @@ class Uploader:
         self.max_retry_attempts = max_retry_attempts
         self._internal_upload_queue: List[UploaderQueueItem] = []
 
+        self.signal_thread_quitting: Event = Event()
+
         self.logger = logging.getLogger("uploader")
 
+    def stop(self) -> None:
+        self.signal_thread_quitting.set()
+
     def run(self) -> None:
         self.logger.info("Started uploader")
-        while True:
+        while not self.signal_thread_quitting.wait(0):
             inspection: Inspection
             mission: Mission
             try:

{isar-1.26.2.dist-info → isar-1.26.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.26.2
+Version: 1.26.3
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -111,7 +111,7 @@ Requires-Dist: click
 Requires-Dist: dacite
 Requires-Dist: fastapi-azure-auth
 Requires-Dist: fastapi
-Requires-Dist: injector
+Requires-Dist: dependency-injector
 Requires-Dist: numpy
 Requires-Dist: opencensus-ext-azure
 Requires-Dist: opencensus-ext-logging

{isar-1.26.2.dist-info → isar-1.26.3.dist-info}/RECORD

@@ -1,19 +1,19 @@
 isar/__init__.py,sha256=cH8p8bVveu3FUL6kBhldcSlLaoHgD82Kd0-SwSNfGXw,87
-isar/modules.py,sha256=PCHSJ8JSt4WeR_8UBPnu_OFHNNUr8ETidC-WfSRcMpo,7707
-isar/script.py,sha256=sOZINSPjv6JHfPfHLKunl5BpMfoz83r7ZpwuWclA_mg,6158
+isar/modules.py,sha256=shiuwpl3LCAZvl7a-8vE8L0ZxD1EW8wiZtvHbPOhMHk,4793
+isar/script.py,sha256=VOI4nSEObDj53cSAFfzVBFDMwbu20uOsUZLZYyDZfBE,6083
 isar/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/api.py,sha256=ARf7-GsjTSqWj9UOSiEJ1YnSF-fH7Tr0-mkkfL10MZ4,12620
+isar/apis/api.py,sha256=K0fYrLUo7dA1oD5oSkYinFPp3s4_DDnIJnY8BL3H1vQ,12610
 isar/apis/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/apis/models/models.py,sha256=HzLaWhjAv0uJRBWipIgYg_F75eaQ5jl9Pi4UnYbDJ-M,1749
 isar/apis/models/start_mission_definition.py,sha256=rGpdb51LIrGRE5RjBONWflumow4ev8oTbDTx5Ph2_Pc,6210
-isar/apis/robot_control/robot_controller.py,sha256=D8LVMU8TRLohn1nlw2NQXjOxYmzjsOwjm_kr6f-h2VY,1259
+isar/apis/robot_control/robot_controller.py,sha256=7EVukShJDhYez12wYeGWZXH-BrfQ4Wu2so0-fSWN2Zo,1277
 isar/apis/schedule/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/schedule/scheduling_controller.py,sha256=ky3Wk-WSLgtQz9b9cvt7as4uMJmEJOVJD2NxRxN5-9Q,7802
+isar/apis/schedule/scheduling_controller.py,sha256=zEeRo9ep5QHkWl-xbXmBxnRtH3FZfLgkEQ1TajOvIsM,7820
 isar/apis/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/apis/security/authentication.py,sha256=sBdknpvE_3qSd6L-Saq6Oza12vpAmCQiyyAS2rWgHtQ,1992
+isar/apis/security/authentication.py,sha256=Se2puhe2TUBmfio2RLma52-VSLRhqvWgu0Cd1bhdwMo,2000
 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/log.py,sha256=SzEWbzXU1DpN7YONIRT8k0zBOGm_qVkXlJuuZtb8STc,2300
 isar/config/logging.conf,sha256=mYO1xf27gAopEMHhGzY7-mwyfN16rwRLkPNMvy3zn2g,1127
 isar/config/settings.env,sha256=cLIlcXTM8x0N-6XjXmC0Qclx5dfDC6myqa25tvVwmRw,500
 isar/config/settings.py,sha256=cFKINb2VRBrLLCzSK0zmRny2fu7S3sGKbDCBv28DxHI,12859
@@ -36,7 +36,7 @@ isar/config/predefined_missions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 isar/config/predefined_missions/default.json,sha256=EDMfPQi2D_517jlfeU2BBFySkbvhYG7uEK6cbiK7DRM,1464
 isar/config/predefined_missions/default_turtlebot.json,sha256=8Vk1_0P0BBsG0vwh4vwIYINiiWioErHZ0Ppjq3ctaPM,2143
 isar/mission_planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/mission_planner/local_planner.py,sha256=45zVP3hzUHdZ5Ty4KWRL85_AUWiTmBhTtlsAruUDMD4,2561
+isar/mission_planner/local_planner.py,sha256=6JxAR_V2JB-pVzZ8xajRa1tlKO3d3x-5oe-5NodgkvU,2579
 isar/mission_planner/mission_planner_interface.py,sha256=UgpPIM4FbrWOD7fGY3Ul64k3uYb8wo0FwSWGewYoVbc,485
 isar/mission_planner/sequential_task_selector.py,sha256=66agRPHuJnEa1vArPyty4muTasAZ50XPjjrSaTdY_Cc,643
 isar/mission_planner/task_selector_interface.py,sha256=pnLeaGPIuyXThcflZ_A7YL2b2xQjFT88hAZidkMomxU,707
@@ -50,11 +50,11 @@ isar/models/communication/queues/queue_timeout_error.py,sha256=rF8TlNF7RHS_ueTZ5
 isar/models/communication/queues/queue_utils.py,sha256=BGydIndLOFbj_Hyd2RiAlwdm7rWrem9BzoAnXH-ulxo,684
 isar/models/communication/queues/status_queue.py,sha256=on8kvlNsG6MJjEVsyqtBswIpmOdOggQiKr7F5x0T3jw,514
 isar/models/mission_metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/robot/robot.py,sha256=t7spWRnZwMVkohs6trrnZjTCxarOH1cPU8iy9vaYTiM,4699
-isar/robot/robot_start_mission.py,sha256=pppndYWPmg-GxU69RglB-4L4MlgXdLcsd0S5gFtfM3o,2767
-isar/robot/robot_status.py,sha256=l7tS-Rl-Xj0f8TgdCuZrhvi4Ubckw92u1VfBOoAFbUM,1605
-isar/robot/robot_stop_mission.py,sha256=V7hSfjeoprqkCwbLoDEHeIELPLRR0HvYH7Uc-_Wa8dM,2443
-isar/robot/robot_task_status.py,sha256=iSSfxn8uu40-qouT0sgPwIcB8h-2Bm3m3_tlXTuLoKk,3306
+isar/robot/robot.py,sha256=RNuoE828lBOUBo9b2i5JiWhNsw7RqKpqEX4MlBPdLjI,4683
+isar/robot/robot_start_mission.py,sha256=0S5mzOENLtRvW75THr_PTlSDycI3NVMOptJuL9TV0v8,2766
+isar/robot/robot_status.py,sha256=3ysyLc639spTP4vuwruHirNTws0pct_pEtvPEaNtfwE,1623
+isar/robot/robot_stop_mission.py,sha256=jUyfemvbyigxrlIp9aKPn-PvarhagJEgajQPS_LgJ7g,2442
+isar/robot/robot_task_status.py,sha256=Rfmw5DUMZWsdjuLyPOegTbfkyAkNN3TW9EcHSoZ7fpo,3305
 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
@@ -67,20 +67,20 @@ isar/services/service_connections/mqtt/robot_info_publisher.py,sha256=AxokGk51hR
 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/robot_utilities.py,sha256=4-ob4kcIiRN_GXFDBMwBadfbwpYqKEkyzyC40wzvmko,555
-isar/services/utilities/scheduling_utilities.py,sha256=WaQXEK_cmPM9KNP3aBZGVnZCi97kR-M_rJWyWIGWZa4,8238
+isar/services/utilities/robot_utilities.py,sha256=J3miRs0t74HNBoMIzVMceMCibp5DozP9Ai1_i7B3kWI,573
+isar/services/utilities/scheduling_utilities.py,sha256=yYwNUCIasjVkH2-LVmHEdRCzUOOB3qr9xfVJdSpqlKY,8256
 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=1ZomEjZelMDFHalZpK8e3Xex2Am_FsqwPFUTrfLeX6o,15248
+isar/state_machine/state_machine.py,sha256=0A2VKmstY50hgC1gV-OdxmzCIGzkMZHOsdTAztn0gl0,15479
 isar/state_machine/states_enum.py,sha256=uqa3VD2Ig0PR5xG7s4-q5OLWiGdvEn-KYClv3KpRJ68,276
 isar/state_machine/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/state_machine/states/blocked_protective_stop.py,sha256=_InOhfCwCshrdUOquDy-js0cMrk8ddgPsHbHMLJzlNU,1540
-isar/state_machine/states/idle.py,sha256=0E9vFMXVJ7u2det3aN17KaNIBosA0zHr5mHIZqPL7dU,2771
-isar/state_machine/states/monitor.py,sha256=v-gPPjxmhNDpA2IKa7X1rm_xZC84pqHmgfSqCodz8PY,9153
+isar/state_machine/states/blocked_protective_stop.py,sha256=LVguaE3fPkZwBBkxp1xpdFCeKajMqzQTZTsHwxQRitQ,1887
+isar/state_machine/states/idle.py,sha256=ybi2q2Rg4vaLMg0CRZ8pauc5rYpIrE282lYkV6A-B_0,3076
+isar/state_machine/states/monitor.py,sha256=hLhS-Eq1iTcxtAbhwVaJbcIOhWy8KMhhEmh88TWIePA,9536
 isar/state_machine/states/off.py,sha256=4d2rMaXK19Xi9eE8PrRLXrDv_hri_B1B0mYsk5L5RHo,545
-isar/state_machine/states/offline.py,sha256=-4PgEm52rnOXqhFYy0phXfPaNq99xkeBm_ylla-jPeU,1380
-isar/state_machine/states/paused.py,sha256=r0jXxlTIwsVw8eR3vNRPMjz-rzKepyaCrzquKLd0E9o,1156
-isar/state_machine/states/stop.py,sha256=bGtukno8n_f6nHqW6Zow4e21TYA72Vvmhj8coUFBLYM,2147
+isar/state_machine/states/offline.py,sha256=ysXES4o3FLt6GMZ5v7SzxMDqsBMnePMOYBBhBk1Akfk,1685
+isar/state_machine/states/paused.py,sha256=NgEl48GjLvnqGfPipYZZ6Yj8vdTb-fFLAK2tUu8i9j8,1461
+isar/state_machine/states/stop.py,sha256=lF3uppwt_Qj66xWlRBeq26U1sUKo_DEu45V3cT-vmm4,2451
 isar/state_machine/transitions/fail_mission.py,sha256=_6HqBMALDinFZ4yh5GMpeqqgV5tw5i8OVMj5UDdqesg,495
 isar/state_machine/transitions/finish_mission.py,sha256=TRQrk7HdllmAkwsp25HRZAFAk46Y1hLx3jmkIAKrHDI,1442
 isar/state_machine/transitions/pause.py,sha256=aoDkq2nV6wBY0YQX3KbjvBR1ojP2o_SCRT_gfz0BulI,889
@@ -89,13 +89,13 @@ isar/state_machine/transitions/start_mission.py,sha256=BJdJvk0O5kq2DZkRHroVtkBzi
 isar/state_machine/transitions/stop.py,sha256=NzPvr6C1tmDqji5XJf5vw9up_Ow7ApuhjAzDVlJLZPw,1368
 isar/state_machine/transitions/utils.py,sha256=Wa72Ocq4QT1E6qkpEJZQ3h5o33pGvx7Tlkt2JZ2Grbk,314
 isar/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/storage/blob_storage.py,sha256=o4pdrG9P-rFAlmKg9Vuj2NckmIDgBvhKhpv1yOWH-F8,3208
+isar/storage/blob_storage.py,sha256=Qci6bO508nlTHKPuPtVU5QcvGA4T7mv8cFrKWRcfw4g,3226
 isar/storage/local_storage.py,sha256=Bnmoi5gyN8r-oRh0aHrOdGqaH3JqRScFKMRXYojW5kY,1855
-isar/storage/slimm_storage.py,sha256=945p97i1d974lLRl3bo9XYD8awc0x2FxiM6vnGA9T3w,9032
+isar/storage/slimm_storage.py,sha256=DJVvTce4cb8m0_b_r6yog41UuxO_9VKb1hYCZUTEhR0,9050
 isar/storage/storage_interface.py,sha256=DYDry4I7aZpDHJhsBF6s8zrgokFAc7fdKJKfA8AvL7o,828
-isar/storage/uploader.py,sha256=mJ-ax_6SvNpM2fG8WdyOUVKSB_J_nedJlCTJ_Xg2E4c,6543
+isar/storage/uploader.py,sha256=M7FEr0iLsrSil8SqP7vmB3hswIOA2HTrnakj6aOQbvg,6749
 isar/storage/utilities.py,sha256=fitsdQ1ox5gr9fk9VuSk_iTBiEAIS8NZAnHabUZORh0,3173
-isar-1.26.2.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
+isar-1.26.3.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
 robot_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/robot_interface.py,sha256=Bkk-joyIzRHxv8iZt7FLPFnlE8chlJad9vgjwc-fDkw,8786
 robot_interface/test_robot_interface.py,sha256=FV1urn7SbsMyWBIcTKjsBwAG4IsXeZ6pLHE0mA9EGGs,692
@@ -119,8 +119,8 @@ robot_interface/telemetry/payloads.py,sha256=m55aFrIczI-PDwQXvsFA6M7YNCTy83w7Ff-
 robot_interface/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/utilities/json_service.py,sha256=qkzVkb60Gi_pto-b5n1vNzCrQze2yqgIJqSLNLYj1Fg,1034
 robot_interface/utilities/uuid_string_factory.py,sha256=_NQIbBQ56w0qqO0MUDP6aPpHbxW7ATRhK8HnQiBSLkc,76
-isar-1.26.2.dist-info/METADATA,sha256=tYUxPEqRTzHxD7YpOR76LGsjXy5UfILPCvFJOIXKTQ8,30252
-isar-1.26.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-isar-1.26.2.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.26.2.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.26.2.dist-info/RECORD,,
+isar-1.26.3.dist-info/METADATA,sha256=WCaFk8atXbeG3TfFJCLLXAIw9wB6Lr1aX2sQgfKxESw,30263
+isar-1.26.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+isar-1.26.3.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
+isar-1.26.3.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
+isar-1.26.3.dist-info/RECORD,,

{isar-1.26.2.dist-info → isar-1.26.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any