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

isar/eventhandlers/eventhandler.py

@@ -0,0 +1,123 @@
+import logging
+import time
+from copy import deepcopy
+from dataclasses import dataclass
+from threading import Event as ThreadEvent
+from typing import TYPE_CHECKING, Callable, Generic, List, Optional, TypeVar
+
+from transitions import State
+
+from isar.config.settings import settings
+from isar.models.events import Event
+
+T = TypeVar("T")
+
+
+@dataclass
+class EventHandlerMapping(Generic[T]):
+    name: str
+    event: Event[T]
+    handler: Callable[[Event[T]], Optional[Callable]]
+
+
+@dataclass
+class TimeoutHandlerMapping:
+    name: str
+    timeout_in_seconds: float
+    handler: Callable[[], Optional[Callable]]
+
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class EventHandlerBase(State):
+    def __init__(
+        self,
+        state_machine: "StateMachine",
+        state_name: str,
+        event_handler_mappings: List[EventHandlerMapping],
+        timers: List[TimeoutHandlerMapping] = [],
+        on_entry: Optional[Callable[[], None]] = None,
+        on_transition: Optional[Callable[[], None]] = None,
+    ) -> None:
+
+        super().__init__(name=state_name, on_enter=self.start)
+        self.state_machine: "StateMachine" = state_machine
+        self.logger = logging.getLogger("state_machine")
+        self.events = state_machine.events
+        self.signal_state_machine_to_stop: ThreadEvent = (
+            state_machine.signal_state_machine_to_stop
+        )
+        self.event_handler_mappings = event_handler_mappings
+        self.state_name: str = state_name
+        self.timers = timers
+        self.on_entry = on_entry
+        self.on_transition = on_transition
+
+    def start(self) -> None:
+        self.state_machine.update_state()
+        if self.on_entry:
+            self.on_entry()
+        self._run()
+
+    def stop(self) -> None:
+        return
+
+    def get_event_handler_by_name(
+        self, event_handler_name: str
+    ) -> Optional[EventHandlerMapping]:
+        filtered_handlers = list(
+            filter(
+                lambda mapping: mapping.name == event_handler_name,
+                self.event_handler_mappings,
+            )
+        )
+        return filtered_handlers[0] if len(filtered_handlers) > 0 else None
+
+    def get_event_timer_by_name(
+        self, event_timer_name: str
+    ) -> Optional[TimeoutHandlerMapping]:
+        filtered_timers = list(
+            filter(
+                lambda mapping: mapping.name == event_timer_name,
+                self.timers,
+            )
+        )
+        return filtered_timers[0] if len(filtered_timers) > 0 else None
+
+    def _run(self) -> None:
+        should_exit_state: bool = False
+        timers = deepcopy(self.timers)
+        entered_time = time.time()
+        while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.state_name
+                )
+                break
+
+            for timer in timers:
+                if time.time() - entered_time > timer.timeout_in_seconds:
+                    transition_func = timer.handler()
+                    timers.remove(timer)
+                    if transition_func is not None:
+                        transition_func()
+                        should_exit_state = True
+                        break
+
+            if should_exit_state:
+                break
+
+            for handler_mapping in self.event_handler_mappings:
+                transition_func = handler_mapping.handler(handler_mapping.event)
+                if transition_func is not None:
+                    transition_func()
+                    should_exit_state = True
+                    break
+
+            if should_exit_state:
+                break
+            time.sleep(settings.FSM_SLEEP_TIME)
+        if self.on_transition:
+            self.on_transition()

isar/models/events.py

@@ -0,0 +1,184 @@
+from collections import deque
+from queue import Empty, Queue
+from typing import Generic, Optional, Tuple, TypeVar
+
+from transitions import State
+
+from isar.apis.models.models import (
+    ControlMissionResponse,
+    LockdownResponse,
+    MaintenanceResponse,
+    MissionStartResponse,
+)
+from isar.config.settings import settings
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import MissionStatus, RobotStatus
+from robot_interface.models.mission.task import TASKS
+
+T = TypeVar("T")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+
+class Event(Queue[T]):
+    def __init__(self, name: str) -> None:
+        super().__init__(maxsize=1)
+        self.name = name
+
+    def trigger_event(self, data: T, timeout: int = None) -> None:
+        try:
+            # We always want a timeout when blocking for results, so that
+            # the thread will never get stuck waiting for a result
+            self.put(data, block=timeout is not None, timeout=timeout)
+        except Exception:
+            if timeout is not None:
+                raise EventTimeoutError
+            return None
+
+    def consume_event(self, timeout: int = None) -> Optional[T]:
+        try:
+            return self.get(block=timeout is not None, timeout=timeout)
+        except Empty:
+            if timeout is not None:
+                raise EventTimeoutError
+            return None
+        except ValueError:
+            raise EventConflictError
+
+    def clear_event(self) -> None:
+        while True:
+            try:
+                self.get(block=False)
+            except Empty:
+                break
+            except ValueError:
+                break
+
+    def has_event(self) -> bool:
+        return (
+            self.qsize() != 0
+        )  # Queue size is not reliable, but should be sufficient for this case
+
+    def check(self) -> Optional[T]:
+        if not self._qsize():
+            return None
+        with self.mutex:
+            queueList = list(self.queue)
+            return queueList.pop()
+
+    def update(self, item: T):
+        with self.mutex:
+            self.queue: deque[T] = deque()
+            self.queue.append(item)
+
+
+class Events:
+    def __init__(self) -> None:
+        self.api_requests: APIRequests = APIRequests()
+        self.state_machine_events: StateMachineEvents = StateMachineEvents()
+        self.robot_service_events: RobotServiceEvents = RobotServiceEvents()
+
+        self.upload_queue: Queue = Queue(maxsize=10)
+
+        if settings.MQTT_ENABLED:
+            self.mqtt_queue: Queue = Queue()
+
+
+class APIEvent(Generic[T1, T2]):
+    """
+    Creates request and response event. The events are defined such that the request is from
+    api to state machine while the response is from state machine to api.
+    """
+
+    def __init__(self, name: str):
+        self.request: Event[T1] = Event("api-" + name + "-request")
+        self.response: Event[T2] = Event("api-" + name + "-request")
+
+
+class APIRequests:
+    def __init__(self) -> None:
+        self.start_mission: APIEvent[Mission, MissionStartResponse] = APIEvent(
+            "start_mission"
+        )
+        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent(
+            "stop_mission"
+        )
+        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "pause_mission"
+        )
+        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "resume_mission"
+        )
+        self.return_home: APIEvent[bool, bool] = APIEvent("return_home")
+        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent(
+            "release_intervention_needed"
+        )
+        self.send_to_lockdown: APIEvent[bool, LockdownResponse] = APIEvent(
+            "send_to_lockdown"
+        )
+        self.release_from_lockdown: APIEvent[bool, bool] = APIEvent(
+            "release_from_lockdown"
+        )
+        self.set_maintenance_mode: APIEvent[bool, MaintenanceResponse] = APIEvent(
+            "set_maintenance_mode"
+        )
+        self.release_from_maintenance_mode: APIEvent[bool, bool] = APIEvent(
+            "release_from_maintenance_mode"
+        )
+
+
+class StateMachineEvents:
+    def __init__(self) -> None:
+        self.start_mission: Event[Mission] = Event("start_mission")
+        self.stop_mission: Event[bool] = Event("stop_mission")
+        self.pause_mission: Event[bool] = Event("pause_mission")
+        self.resume_mission: Event[bool] = Event("resume_mission")
+
+
+class RobotServiceEvents:
+    def __init__(self) -> None:
+        self.mission_status_updated: Event[MissionStatus] = Event(
+            "mission_status_updated"
+        )
+        self.mission_started: Event[bool] = Event("mission_started")
+        self.mission_failed: Event[ErrorMessage] = Event("mission_failed")
+        self.robot_status_changed: Event[bool] = Event("robot_status_changed")
+        self.mission_failed_to_stop: Event[ErrorMessage] = Event(
+            "mission_failed_to_stop"
+        )
+        self.mission_successfully_stopped: Event[bool] = Event(
+            "mission_successfully_stopped"
+        )
+        self.mission_failed_to_pause: Event[ErrorMessage] = Event(
+            "mission_failed_to_pause"
+        )
+        self.mission_successfully_paused: Event[bool] = Event(
+            "mission_successfully_paused"
+        )
+        self.mission_failed_to_resume: Event[ErrorMessage] = Event(
+            "mission_failed_to_resume"
+        )
+        self.mission_successfully_resumed: Event[bool] = Event(
+            "mission_successfully_resumed"
+        )
+        self.request_inspection_upload: Event[Tuple[TASKS, Mission]] = Event(
+            "request_inspection_upload"
+        )
+        self.robot_already_home: Event[bool] = Event("robot_already_home")
+
+
+class SharedState:
+    def __init__(self) -> None:
+        self.state: Event[State] = Event("state")
+        self.robot_status: Event[RobotStatus] = Event("robot_status")
+        self.robot_battery_level: Event[float] = Event("robot_battery_level")
+        self.mission_id: Event[Optional[str]] = Event("mission_id")
+
+
+class EventTimeoutError(Exception):
+    pass
+
+
+class EventConflictError(Exception):
+    pass

isar/models/status.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+
+class IsarStatus(Enum):
+    Available = "available"
+    ReturnHomePaused = "returnhomepaused"
+    Paused = "paused"
+    Busy = "busy"
+    Home = "home"
+    Offline = "offline"
+    BlockedProtectiveStop = "blockedprotectivestop"
+    ReturningHome = "returninghome"
+    InterventionNeeded = "interventionneeded"
+    Recharging = "recharging"
+    Lockdown = "lockdown"
+    GoingToLockdown = "goingtolockdown"
+    GoingToRecharging = "goingtorecharging"
+    Maintenance = "maintenance"
+    Pausing = "pausing"
+    PausingReturnHome = "pausingreturnhome"
+    Stopping = "stopping"
+    StoppingReturnHome = "stoppingreturnhome"

isar/modules.py

@@ -1,214 +1,131 @@
-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
 from isar.apis.schedule.scheduling_controller import SchedulingController
 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.queues import Queues
-from isar.services.service_connections.request_handler import RequestHandler
+from isar.models.events import Events, SharedState
+from isar.robot.robot import Robot
+from isar.services.utilities.robot_utilities import RobotUtilities
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities
 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,
-        keyvault: Keyvault,
-    ) -> API:
-        return API(authenticator, scheduling_controller, keyvault)
-
-    @provider
-    @singleton
-    def provide_scheduling_controller(
-        self,
-        scheduling_utilities: SchedulingUtilities,
-    ) -> SchedulingController:
-        return SchedulingController(scheduling_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_package_name: str = settings.ROBOT_PACKAGE
-        robot: ModuleType = import_module(robot_package_name)
-        return robot.robotinterface.Robot()  # type: ignore
-
-
-class QueuesModule(Module):
-    @provider
-    @singleton
-    def provide_queues(self) -> Queues:
-        return Queues()
-
-
-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,
-        queues: Queues,
-        robot: RobotInterface,
-        mqtt_client: MqttClientInterface,
-        task_selector: TaskSelectorInterface,
-    ) -> StateMachine:
-        return StateMachine(
-            queues=queues,
-            robot=robot,
-            mqtt_publisher=mqtt_client,
-            task_selector=task_selector,
+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)
+
+    # Mqtt client
+    mqtt_client = (
+        providers.Singleton(
+            MqttPublisher,
+            mqtt_queue=providers.Callable(events.provided.mqtt_queue),
         )
-
-
-class UploaderModule(Module):
-    @provider
-    @singleton
-    def provide_uploader(
-        self,
-        queues: Queues,
-        storage_handlers: List[StorageInterface],
-        mqtt_client: MqttClientInterface,
-    ) -> Uploader:
-        return Uploader(
-            queues=queues,
-            storage_handlers=storage_handlers,
-            mqtt_publisher=mqtt_client,
-        )
-
-
-class UtilitiesModule(Module):
-    @provider
-    @singleton
-    def provide_scheduling_utilities(
-        self, queues: Queues, mission_planner: MissionPlannerInterface
-    ) -> SchedulingUtilities:
-        return SchedulingUtilities(queues, mission_planner)
-
-
-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, queues: Queues) -> MqttClientInterface:
-        if settings.MQTT_ENABLED:
-            return MqttPublisher(mqtt_queue=queues.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"),
-    "queues": (QueuesModule, "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": (UtilitiesModule, "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(f"Loaded the following module configurations:{module_overview}")
-
-    return Injector(injector_modules)
+        if settings.MQTT_ENABLED
+        else None
+    )
+
+    # API and controllers
+    authenticator = providers.Singleton(Authenticator)
+    scheduling_utilities = providers.Singleton(
+        SchedulingUtilities,
+        events=events,
+        shared_state=shared_state,
+    )
+    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,
+        mqtt_publisher=mqtt_client,
+    )
+
+    # Storage
+    storage_handlers_temp = []
+    if settings.STORAGE_LOCAL_ENABLED:
+        local_storage = providers.Singleton(LocalStorage)
+        storage_handlers_temp.append(local_storage)
+    if settings.STORAGE_BLOB_ENABLED:
+        blob_storage = providers.Singleton(BlobStorage, keyvault=keyvault)
+        storage_handlers_temp.append(blob_storage)
+    storage_handlers = providers.List(*storage_handlers_temp)
+
+    # State machine
+    state_machine = providers.Singleton(
+        StateMachine,
+        events=events,
+        shared_state=shared_state,
+        robot=robot_interface,
+        mqtt_publisher=mqtt_client,
+    )
+
+    # Robot
+    robot = providers.Singleton(
+        Robot,
+        events=events,
+        robot=robot_interface,
+        shared_state=shared_state,
+        mqtt_publisher=mqtt_client,
+    )
+
+    # 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,
+        }
+    )
+
+    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