isar 1.31.0__py3-none-any.whl → 1.32.0__py3-none-any.whl

isar/apis/api.py

@@ -245,6 +245,24 @@ class API:
                 },
             },
         )
+        router.add_api_route(
+            path="/schedule/release-intervention-needed",
+            endpoint=self.scheduling_controller.release_intervention_needed,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Release the intervention needed state",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Robot released from intervention needed state"
+                },
+                HTTPStatus.CONFLICT.value: {
+                    "description": "Conflict - Invalid command in the current state"
+                },
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error - Current state of state machine unknown"
+                },
+            },
+        )
         router.add_api_route(
             path="/schedule/move_arm/{arm_pose_literal}",
             endpoint=self.scheduling_controller.start_move_arm_mission,

isar/apis/schedule/scheduling_controller.py

@@ -256,6 +256,22 @@ class SchedulingController:
         self.scheduling_utilities.start_mission(mission=mission)
         return self._api_response(mission)
 
+    def release_intervention_needed(self) -> None:
+        self.logger.info("Received request to release intervention needed state")
+
+        state: States = self.scheduling_utilities.get_state()
+
+        if state != States.InterventionNeeded:
+            error_message = f"Conflict - Release intervention needed command received in invalid state - State: {state}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
+            )
+
+        self.scheduling_utilities.release_intervention_needed()
+        self.logger.info("Released intervention needed state successfully")
+
     def _api_response(self, mission: Mission) -> StartMissionResponse:
         return StartMissionResponse(
             id=mission.id,

isar/config/log.py

@@ -5,11 +5,10 @@ from importlib.resources import as_file, files
 import yaml
 from uvicorn.logging import ColourizedFormatter
 
-from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 
 
-def setup_loggers(keyvault: Keyvault) -> None:
+def setup_loggers() -> None:
     log_levels: dict = settings.LOG_LEVELS
     log_config = load_log_config()
 

isar/config/logging.conf

@@ -5,50 +5,29 @@ formatters:
   colourized:
     style: "{"
     format: "{asctime} - {levelprefix:<8} - {name} - {message}"
-handlers:
-  api:
-    class: logging.FileHandler
-    formatter: simple
-    filename: api.log
-  main:
-    class: logging.FileHandler
-    formatter: simple
-    filename: main.log
-  mqtt:
-    class: logging.FileHandler
-    formatter: simple
-    filename: mqtt.log
-  state_machine:
-    class: logging.FileHandler
-    formatter: simple
-    filename: state_machine.log
-  uploader:
-    class: logging.FileHandler
-    formatter: simple
-    filename: uploader.log
 loggers:
   console:
     handlers: []
     propagate: no
   main:
-    handlers: [main]
+    handlers: []
     propagate: no
   api:
-    handlers: [api]
+    handlers: []
     propagate: no
   mqtt:
-    handlers: [mqtt]
-    propagate: False
+    handlers: []
+    propagate: no
   state_machine:
-    handlers: [state_machine]
-    propagate: False
+    handlers: []
+    propagate: no
   uploader:
-    handlers: [uploader]
-    propagate: False
+    handlers: []
+    propagate: no
   urllib3:
     handlers: []
   uvicorn:
-    handlers: [api]
+    handlers: []
     propagate: no
   azure:
     handlers: []

isar/config/open_telemetry.py

@@ -1,6 +1,5 @@
 import logging
 
-from azure.identity import ManagedIdentityCredential
 from azure.monitor.opentelemetry.exporter import (
     AzureMonitorLogExporter,
     AzureMonitorTraceExporter,
@@ -57,12 +56,7 @@ def get_azure_monitor_exporters() -> (
     Else use Azure Managed Identity to create Azure Monitor Exporters.
     """
     connection_string = settings.APPLICATIONINSIGHTS_CONNECTION_STRING
-    if connection_string:
-        trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
-        log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
-    else:
-        credential = ManagedIdentityCredential()
-        trace_exporter = AzureMonitorTraceExporter(credential=credential)
-        log_exporter = AzureMonitorLogExporter(credential=credential)
+    trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
+    log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
 
     return trace_exporter, log_exporter

isar/config/settings.py

@@ -224,6 +224,9 @@ class Settings(BaseSettings):
         default="robot_heartbeat", validate_default=True
     )
     TOPIC_ISAR_STARTUP: str = Field(default="startup", validate_default=True)
+    TOPIC_ISAR_INTERVENTION_NEEDED: str = Field(
+        default="intervention_needed", validate_default=True
+    )
 
     # Logging
 
@@ -275,6 +278,7 @@ class Settings(BaseSettings):
         "TOPIC_ISAR_INSPECTION_RESULT",
         "TOPIC_ISAR_INSPECTION_VALUE",
         "TOPIC_ISAR_STARTUP",
+        "TOPIC_ISAR_INTERVENTION_NEEDED",
     )
     @classmethod
     def prefix_isar_topics(cls, v: Any, info: ValidationInfo):

isar/eventhandlers/eventhandler.py

@@ -0,0 +1,93 @@
+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] = [],
+    ) -> 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
+
+    def start(self) -> None:
+        self.state_machine.update_state()
+        self._run()
+
+    def stop(self) -> None:
+        return
+
+    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)

isar/models/events.py

@@ -0,0 +1,119 @@
+from collections import deque
+from queue import Empty, Queue
+from typing import Generic, Optional, TypeVar
+
+from transitions import State
+
+from isar.apis.models.models import ControlMissionResponse
+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 RobotStatus, TaskStatus
+from robot_interface.models.mission.task import TASKS
+
+T = TypeVar("T")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+
+class Event(Queue[T]):
+    def __init__(self) -> None:
+        super().__init__(maxsize=1)
+
+    def trigger_event(self, data: T) -> None:
+        self.put(data)
+
+    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
+
+    def clear_event(self) -> None:
+        while True:
+            try:
+                self.get(block=False)
+            except Empty:
+                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 input and output event. The events are defined such that the input is from
+    api to state machine while the output is from state machine to api.
+    """
+
+    def __init__(self):
+        self.input: Event[T1] = Event()
+        self.output: Event[T2] = Event()
+
+
+class APIRequests:
+    def __init__(self) -> None:
+        self.start_mission: APIEvent[Mission, bool] = APIEvent()
+        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent()
+        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
+        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
+        self.return_home: APIEvent[bool, bool] = APIEvent()
+        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent()
+
+
+class StateMachineEvents:
+    def __init__(self) -> None:
+        self.start_mission: Event[Mission] = Event()
+        self.stop_mission: Event[bool] = Event()
+        self.pause_mission: Event[bool] = Event()
+        self.task_status_request: Event[str] = Event()
+
+
+class RobotServiceEvents:
+    def __init__(self) -> None:
+        self.task_status_updated: Event[TaskStatus] = Event()
+        self.task_status_failed: Event[ErrorMessage] = Event()
+        self.mission_started: Event[bool] = Event()
+        self.mission_failed: Event[ErrorMessage] = Event()
+        self.robot_status_changed: Event[bool] = Event()
+        self.mission_failed_to_stop: Event[ErrorMessage] = Event()
+        self.mission_successfully_stopped: Event[bool] = Event()
+
+
+class SharedState:
+    def __init__(self) -> None:
+        self.state: Event[State] = Event()
+        self.robot_status: Event[RobotStatus] = Event()
+        self.state_machine_current_task: Event[TASKS] = Event()
+
+
+class EventTimeoutError(Exception):
+    pass

isar/modules.py

@@ -12,7 +12,7 @@ from isar.config.settings import settings
 from isar.mission_planner.local_planner import LocalPlanner
 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.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

isar/robot/robot.py

@@ -1,20 +1,20 @@
 import logging
-from queue import Queue
-from threading import Event
+from threading import Event as ThreadEvent
 from typing import Optional
 
-from isar.models.communication.queues.events import (
+from isar.models.events import (
+    Event,
     Events,
     RobotServiceEvents,
     SharedState,
     StateMachineEvents,
 )
-from isar.models.communication.queues.queue_utils import check_for_event, trigger_event
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
 from isar.robot.robot_stop_mission import RobotStopMissionThread
 from isar.robot.robot_task_status import RobotTaskStatusThread
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
+from robot_interface.models.mission.mission import Mission
 from robot_interface.robot_interface import RobotInterface
 
 
@@ -31,7 +31,7 @@ class Robot(object):
         self.robot_status_thread: Optional[RobotStatusThread] = None
         self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
         self.stop_mission_thread: Optional[RobotStopMissionThread] = None
-        self.signal_thread_quitting: Event = Event()
+        self.signal_thread_quitting: ThreadEvent = ThreadEvent()
 
     def stop(self) -> None:
         self.signal_thread_quitting.set()
@@ -53,8 +53,8 @@ class Robot(object):
         self.robot_task_status_thread = None
         self.start_mission_thread = None
 
-    def _check_and_handle_start_mission(self, event: Queue) -> None:
-        start_mission = check_for_event(event)
+    def _start_mission_event_handler(self, event: Event[Mission]) -> None:
+        start_mission = event.consume_event()
         if start_mission is not None:
             if (
                 self.start_mission_thread is not None
@@ -72,8 +72,8 @@ class Robot(object):
             )
             self.start_mission_thread.start()
 
-    def _check_and_handle_task_status_request(self, event: Queue[str]) -> None:
-        task_id: str = check_for_event(event)
+    def _task_status_request_handler(self, event: Event[str]) -> None:
+        task_id: str = event.consume_event()
         if task_id:
             self.robot_task_status_thread = RobotTaskStatusThread(
                 self.robot_service_events,
@@ -83,8 +83,8 @@ class Robot(object):
             )
             self.robot_task_status_thread.start()
 
-    def _check_and_handle_stop_mission(self, event: Queue) -> None:
-        if check_for_event(event):
+    def _stop_mission_request_handler(self, event: Event[bool]) -> None:
+        if event.consume_event():
             if (
                 self.stop_mission_thread is not None
                 and self.stop_mission_thread.is_alive()
@@ -102,8 +102,8 @@ class Robot(object):
                     error_reason=ErrorReason.RobotStillStartingMissionException,
                     error_description=error_description,
                 )
-                trigger_event(
-                    self.robot_service_events.mission_failed_to_stop, error_message
+                self.robot_service_events.mission_failed_to_stop.trigger_event(
+                    error_message
                 )
                 return
             self.stop_mission_thread = RobotStopMissionThread(
@@ -118,14 +118,12 @@ class Robot(object):
         self.robot_status_thread.start()
 
         while not self.signal_thread_quitting.wait(0):
-            self._check_and_handle_start_mission(
-                self.state_machine_events.start_mission
-            )
+            self._start_mission_event_handler(self.state_machine_events.start_mission)
 
-            self._check_and_handle_task_status_request(
+            self._task_status_request_handler(
                 self.state_machine_events.task_status_request
             )
 
-            self._check_and_handle_stop_mission(self.state_machine_events.stop_mission)
+            self._stop_mission_request_handler(self.state_machine_events.stop_mission)
 
         self.logger.info("Exiting robot service main thread")

isar/robot/robot_start_mission.py

@@ -2,11 +2,7 @@ import logging
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import (
-    trigger_event,
-    trigger_event_without_data,
-)
+from isar.models.events import RobotServiceEvents
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotException,
@@ -44,13 +40,13 @@ class RobotStartMissionThread(Thread):
                     self.logger.error(
                         f"Mission is infeasible and cannot be scheduled because: {e.error_description}"
                     )
-                    trigger_event(
-                        self.robot_service_events.mission_failed,
+                    self.robot_service_events.mission_failed.trigger_event(
                         ErrorMessage(
                             error_reason=e.error_reason,
                             error_description=e.error_description,
-                        ),
+                        )
                     )
+
                     break
                 except RobotException as e:
                     retries += 1
@@ -66,12 +62,11 @@ class RobotStartMissionThread(Thread):
                             f"{e.error_description}"
                         )
 
-                        trigger_event(
-                            self.robot_service_events.mission_failed,
+                        self.robot_service_events.mission_failed.trigger_event(
                             ErrorMessage(
                                 error_reason=e.error_reason,
                                 error_description=e.error_description,
-                            ),
+                            )
                         )
                         break
 
@@ -79,12 +74,11 @@ class RobotStartMissionThread(Thread):
 
                 started_mission = True
         except RobotInfeasibleMissionException as e:
-            trigger_event(
-                self.robot_service_events.mission_failed,
+            self.robot_service_events.mission_failed.trigger_event(
                 ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
                 ),
             )
 
         if started_mission:
-            trigger_event_without_data(self.robot_service_events.mission_started)
+            self.robot_service_events.mission_started.trigger_event(True)

isar/robot/robot_status.py

@@ -3,8 +3,7 @@ import time
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import SharedState
-from isar.models.communication.queues.queue_utils import update_shared_state
+from isar.models.events import SharedState
 from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.robot_interface import RobotInterface
 
@@ -49,7 +48,7 @@ class RobotStatusThread(Thread):
                 self.last_robot_status_poll_time = time.time()
 
                 robot_status = self.robot.robot_status()
-                update_shared_state(self.shared_state.robot_status, robot_status)
+                self.shared_state.robot_status.update(robot_status)
             except RobotException as e:
                 self.logger.error(f"Failed to retrieve robot status: {e}")
                 continue

isar/robot/robot_stop_mission.py

@@ -4,11 +4,7 @@ from threading import Event, Thread
 from typing import Optional
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import (
-    trigger_event,
-    trigger_event_without_data,
-)
+from isar.models.events import RobotServiceEvents
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotActionException,
@@ -51,9 +47,7 @@ class RobotStopMissionThread(Thread):
                 time.sleep(settings.FSM_SLEEP_TIME)
                 continue
 
-            trigger_event_without_data(
-                self.robot_service_events.mission_successfully_stopped
-            )
+            self.robot_service_events.mission_successfully_stopped.trigger_event(True)
             return
 
         error_description = (
@@ -68,4 +62,4 @@ class RobotStopMissionThread(Thread):
             error_description=error_description,
         )
 
-        trigger_event(self.robot_service_events.mission_failed_to_stop, error_message)
+        self.robot_service_events.mission_failed_to_stop.trigger_event(error_message)

isar/robot/robot_task_status.py

@@ -4,8 +4,7 @@ from threading import Event, Thread
 from typing import Optional
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import trigger_event
+from isar.models.events import RobotServiceEvents
 from isar.services.utilities.threaded_request import ThreadedRequest
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
@@ -82,10 +81,7 @@ class RobotTaskStatusThread(Thread):
                 )
                 break
 
-            trigger_event(self.robot_service_events.task_status_updated, task_status)
+            self.robot_service_events.task_status_updated.trigger_event(task_status)
             return
 
-        trigger_event(
-            self.robot_service_events.task_status_failed,
-            failed_task_error,
-        )
+        self.robot_service_events.task_status_failed.trigger_event(failed_task_error)

isar/script.py

@@ -10,7 +10,7 @@ from isar.apis.api import API
 from isar.config.log import setup_loggers
 from isar.config.open_telemetry import setup_open_telemetry
 from isar.config.settings import robot_settings, settings
-from isar.models.communication.queues.events import Events
+from isar.models.events import Events
 from isar.modules import ApplicationContainer, get_injector
 from isar.robot.robot import Robot
 from isar.services.service_connections.mqtt.mqtt_client import MqttClient
@@ -36,7 +36,8 @@ def print_setting(
 
 
 def print_startup_info():
-    print(
+    logger: Logger = logging.getLogger("main")
+    logger.info(
         """
          __   ________   ___        ________
         / /  / ______/  /   |      / ____  /
@@ -48,42 +49,33 @@ def print_startup_info():
 """
     )
 
-    WIDTH = 48
-
     def print_setting(setting: str = "", value: Any = "", fillchar: str = " "):
         separator = ": " if value != "" else ""
-        text = setting.ljust(22, fillchar) + separator + str(value)
-        print("*", text.ljust(WIDTH - 4, fillchar), "*")
+        logger.info(setting + separator + str(value))
 
-    print("Integration and Supervisory control".center(WIDTH, " "))
-    print("of Autonomous Robots".center(WIDTH, " "))
-    print()
-    print(f"Version: {isar.__version__}\n".center(WIDTH, " "))
+    logger.info(
+        f"Integration and Supervisory control of Autonomous Robots - Version: {isar.__version__}\n"
+    )
 
-    print_setting(fillchar="*")
     print_setting("ISAR settings")
-    print_setting(fillchar="-")
     print_setting("Robot package", settings.ROBOT_PACKAGE)
     print_setting("Robot name", settings.ROBOT_NAME)
     print_setting("Running on port", settings.API_PORT)
     print_setting("Mission planner", settings.MISSION_PLANNER)
     print_setting("Using local storage", settings.STORAGE_LOCAL_ENABLED)
     print_setting("Using blob storage", settings.STORAGE_BLOB_ENABLED)
+    print_setting("Blob storage account", settings.BLOB_STORAGE_ACCOUNT)
     print_setting("Using async inspection uploading", settings.UPLOAD_INSPECTIONS_ASYNC)
     print_setting("Plant code", settings.PLANT_CODE)
     print_setting("Plant name", settings.PLANT_NAME)
     print_setting("Plant shortname", settings.PLANT_SHORT_NAME)
-    print_setting(fillchar="-")
     print_setting("Robot capabilities", robot_settings.CAPABILITIES)
-    print_setting(fillchar="*")
-    print()
 
 
 def start() -> None:
     injector: ApplicationContainer = get_injector()
 
-    keyvault = injector.keyvault()
-    setup_loggers(keyvault=keyvault)
+    setup_loggers()
     setup_open_telemetry(app=injector.api().app)
     logger: Logger = logging.getLogger("main")