isar 1.30.5__py3-none-any.whl → 1.31.1__py3-none-any.whl

isar/apis/api.py

@@ -8,35 +8,23 @@ from typing import List, Union
 
 import click
 import uvicorn
-from dependency_injector.wiring import inject
-from fastapi import FastAPI, Request, Security
+from fastapi import FastAPI, Security
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.routing import APIRouter
-from opencensus.ext.azure.trace_exporter import AzureExporter
-from opencensus.trace.attributes_helper import COMMON_ATTRIBUTES
-from opencensus.trace.samplers import ProbabilitySampler
-from opencensus.trace.span import SpanKind
-from opencensus.trace.tracer import Tracer
 from pydantic import AnyHttpUrl
 
 from isar.apis.models.models import ControlMissionResponse, StartMissionResponse
 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.configuration_error import ConfigurationError
-from isar.config.keyvault.keyvault_error import KeyvaultError
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from robot_interface.telemetry.payloads import StartUpMessagePayload
 from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
-HTTP_URL = COMMON_ATTRIBUTES["HTTP_URL"]
-HTTP_STATUS_CODE = COMMON_ATTRIBUTES["HTTP_STATUS_CODE"]
-
 
 class API:
-    @inject
     def __init__(
         self,
         authenticator: Authenticator,
@@ -45,7 +33,6 @@ class API:
         keyvault: Keyvault,
         mqtt_publisher: MqttClientInterface,
         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
@@ -53,7 +40,6 @@ class API:
         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
         self.mqtt_publisher: MqttClientInterface = mqtt_publisher
 
         self.logger: Logger = logging.getLogger("api")
@@ -113,9 +99,6 @@ class API:
                 allow_headers=["*"],
             )
 
-        if self.azure_ai_logging_enabled:
-            self._add_request_logging_middleware(app)
-
         app.include_router(router=self._create_scheduler_router())
 
         app.include_router(router=self._create_info_router())
@@ -210,9 +193,15 @@ class API:
                     "description": "Mission succesfully stopped",
                     "model": ControlMissionResponse,
                 },
+                HTTPStatus.UNPROCESSABLE_ENTITY.value: {
+                    "description": "Invalid body - The JSON is incorrect",
+                },
                 HTTPStatus.CONFLICT.value: {
                     "description": "Conflict - Invalid command in the current state",
                 },
+                HTTPStatus.BAD_REQUEST.value: {
+                    "description": "Bad request - Robot does not have the capabilities to perform the mission",
+                },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
                     "description": "Internal Server Error - Current state of state machine unknown",
                 },
@@ -336,39 +325,6 @@ class API:
             extra={"color_message": color_message},
         )
 
-    def _add_request_logging_middleware(self, app: FastAPI) -> None:
-        connection_string: str
-        try:
-            connection_string = self.keyvault.get_secret(
-                "application-insights-connection-string"
-            ).value
-        except KeyvaultError:
-            message: str = (
-                "Missing connection string for Application Insights in key vault. "
-            )
-            self.logger.critical(message)
-            raise ConfigurationError(message)
-
-        @app.middleware("http")
-        async def middlewareOpencensus(request: Request, call_next):
-            tracer = Tracer(
-                exporter=AzureExporter(connection_string=connection_string),
-                sampler=ProbabilitySampler(1.0),
-            )
-            with tracer.span("main") as span:
-                span.span_kind = SpanKind.SERVER
-
-                response = await call_next(request)
-
-                tracer.add_attribute_to_current_span(
-                    attribute_key=HTTP_STATUS_CODE, attribute_value=response.status_code
-                )
-                tracer.add_attribute_to_current_span(
-                    attribute_key=HTTP_URL, attribute_value=str(request.url)
-                )
-
-            return response
-
     def _publish_startup_message(self) -> None:
         if not self.mqtt_publisher:
             return

isar/apis/models/models.py

@@ -21,6 +21,7 @@ class StartMissionResponse(BaseModel):
 class ControlMissionResponse(BaseModel):
     mission_id: Optional[str]
     mission_status: Optional[str]
+    mission_not_found: Optional[bool] = False
     task_id: Optional[str]
     task_status: Optional[str]
 

isar/apis/models/start_mission_definition.py

@@ -58,6 +58,10 @@ class StartMissionDefinition(BaseModel):
     start_pose: Optional[InputPose] = None
 
 
+class StopMissionDefinition(BaseModel):
+    mission_id: Optional[str] = None
+
+
 def to_isar_mission(
     start_mission_definition: StartMissionDefinition,
 ) -> Mission:

isar/apis/robot_control/robot_controller.py

@@ -1,6 +1,5 @@
 import logging
 
-from dependency_injector.wiring import inject
 from fastapi import HTTPException
 
 from isar.apis.models.models import RobotInfoResponse
@@ -10,7 +9,6 @@ from robot_interface.models.robots.media import MediaConfig
 
 
 class RobotController:
-    @inject
     def __init__(
         self,
         robot_utilities: RobotUtilities,

isar/apis/schedule/scheduling_controller.py

@@ -2,7 +2,6 @@ import logging
 from http import HTTPStatus
 from threading import Lock
 
-from dependency_injector.wiring import inject
 from fastapi import Body, HTTPException, Path
 
 from isar.apis.models.models import (
@@ -12,6 +11,7 @@ from isar.apis.models.models import (
 )
 from isar.apis.models.start_mission_definition import (
     StartMissionDefinition,
+    StopMissionDefinition,
     to_isar_mission,
 )
 from isar.config.settings import robot_settings, settings
@@ -23,7 +23,6 @@ from robot_interface.models.mission.task import TASKS, InspectionTask, MoveArm
 
 
 class SchedulingController:
-    @inject
     def __init__(
         self,
         scheduling_utilities: SchedulingUtilities,
@@ -179,7 +178,16 @@ class SchedulingController:
         )
         return resume_mission_response
 
-    def stop_mission(self) -> ControlMissionResponse:
+    def stop_mission(
+        self,
+        mission_id: StopMissionDefinition = Body(
+            default=None,
+            embed=True,
+            title="Mission ID to stop",
+            description="The mission ID of the mission being stopped, in json format",
+        ),
+    ) -> ControlMissionResponse:
+
         self.logger.info("Received request to stop current mission")
 
         state: States = self.scheduling_utilities.get_state()
@@ -198,7 +206,7 @@ class SchedulingController:
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
 
         stop_mission_response: ControlMissionResponse = (
-            self.scheduling_utilities.stop_mission()
+            self.scheduling_utilities.stop_mission(mission_id.mission_id)
         )
         return stop_mission_response
 

isar/config/log.py

@@ -3,30 +3,21 @@ import logging.config
 from importlib.resources import as_file, files
 
 import yaml
-from opencensus.ext.azure.log_exporter import AzureLogHandler
 from uvicorn.logging import ColourizedFormatter
 
-from isar.config.configuration_error import ConfigurationError
-from isar.config.keyvault.keyvault_error import KeyvaultError
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 
 
 def setup_loggers(keyvault: Keyvault) -> None:
     log_levels: dict = settings.LOG_LEVELS
-    source = files("isar").joinpath("config").joinpath("logging.conf")
-    with as_file(source) as f:
-        log_config = yaml.safe_load(open(f))
+    log_config = load_log_config()
 
     logging.config.dictConfig(log_config)
 
     handlers = []
     if settings.LOG_HANDLER_LOCAL_ENABLED:
         handlers.append(configure_console_handler(log_config=log_config))
-    if settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
-        handlers.append(
-            configure_azure_handler(log_config=log_config, keyvault=keyvault)
-        )
 
     for log_handler in handlers:
         for loggers in log_config["loggers"].keys():
@@ -35,6 +26,13 @@ def setup_loggers(keyvault: Keyvault) -> None:
         logging.getLogger().addHandler(log_handler)
 
 
+def load_log_config():
+    source = files("isar").joinpath("config").joinpath("logging.conf")
+    with as_file(source) as f:
+        log_config = yaml.safe_load(open(f))
+    return log_config
+
+
 def configure_console_handler(log_config: dict) -> logging.Handler:
     handler = logging.StreamHandler()
     handler.setLevel(log_config["root"]["level"])
@@ -46,22 +44,3 @@ def configure_console_handler(log_config: dict) -> logging.Handler:
         )
     )
     return handler
-
-
-def configure_azure_handler(log_config: dict, keyvault: Keyvault) -> logging.Handler:
-    connection_string: str
-    try:
-        connection_string = keyvault.get_secret(
-            "application-insights-connection-string"
-        ).value
-    except KeyvaultError:
-        message: str = (
-            "CRITICAL ERROR: Missing connection string for"
-            f" Application Insights in key vault '{keyvault.name}'."
-        )
-        print(f"\n{message} \n")
-        raise ConfigurationError(message)
-
-    handler = AzureLogHandler(connection_string=connection_string)
-    handler.setLevel(log_config["root"]["level"])
-    return handler

isar/config/open_telemetry.py

@@ -0,0 +1,62 @@
+import logging
+
+from azure.monitor.opentelemetry.exporter import (
+    AzureMonitorLogExporter,
+    AzureMonitorTraceExporter,
+)
+from fastapi import FastAPI
+from opentelemetry import trace
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.resources import SERVICE_NAME, Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from isar.config.log import load_log_config
+from isar.config.settings import settings
+
+
+def setup_open_telemetry(app: FastAPI) -> None:
+    if not settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
+        return
+    trace_exporter, log_exporter = get_azure_monitor_exporters()
+
+    service_name = settings.OPEN_TELEMETRY_SERVICE_NAME
+    resource = Resource.create({SERVICE_NAME: service_name})
+
+    tracer_provider = TracerProvider(resource=resource)
+    tracer_provider.add_span_processor(BatchSpanProcessor(trace_exporter))
+    trace.set_tracer_provider(tracer_provider)
+
+    log_provider = LoggerProvider(resource=resource)
+    set_logger_provider(log_provider)
+    log_provider.add_log_record_processor(BatchLogRecordProcessor(log_exporter))
+
+    handler = LoggingHandler(logger_provider=log_provider)
+    attach_loggers_for_open_telemetry(handler)
+
+    FastAPIInstrumentor.instrument_app(app, tracer_provider=tracer_provider)
+
+
+def attach_loggers_for_open_telemetry(handler: LoggingHandler):
+    log_config = load_log_config()
+
+    for logger_name in log_config["loggers"].keys():
+        logger = logging.getLogger(logger_name)
+        logger.addHandler(handler)
+
+
+def get_azure_monitor_exporters() -> (
+    tuple[AzureMonitorTraceExporter, AzureMonitorLogExporter]
+):
+    """
+    If connection string is defined in environment variables, then use it to create Azure Monitor Exporters.
+    Else use Azure Managed Identity to create Azure Monitor Exporters.
+    """
+    connection_string = settings.APPLICATIONINSIGHTS_CONNECTION_STRING
+    trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
+    log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
+
+    return trace_exporter, log_exporter

isar/config/settings.py

@@ -12,6 +12,12 @@ from robot_interface.telemetry.payloads import DocumentInfo
 
 
 class Settings(BaseSettings):
+    # Name of the OpenTelemetry service
+    OPEN_TELEMETRY_SERVICE_NAME: str = Field(default="isar")
+    # Connection string for Azure Application Insights
+    # This is optional and it will use managed identity if not set
+    APPLICATIONINSIGHTS_CONNECTION_STRING: str = Field(default="")
+
     # Determines which robot package ISAR will attempt to import
     # Name must match with an installed python package in the local environment
     ROBOT_PACKAGE: str = Field(default="isar_robot")
@@ -52,6 +58,12 @@ class Settings(BaseSettings):
     # issues
     REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY: float = Field(default=10)
 
+    # Number of attempts for state transitions resume and pause if failed
+    STATE_TRANSITION_NUM_RETIRES: int = Field(default=10)
+
+    # Interval between attempt of state transition
+    STATE_TRANSITION_RETRY_INTERVAL_SEC: float = Field(default=1)
+
     # Number of attempts to stop the robot before giving up
     STOP_ROBOT_ATTEMPTS_LIMIT: int = Field(default=3)
 

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/mission_planner/local_planner.py

@@ -2,8 +2,6 @@ import json
 import logging
 from pathlib import Path
 
-from dependency_injector.wiring import inject
-
 from isar.config.settings import settings
 from isar.mission_planner.mission_planner_interface import (
     MissionNotFoundError,
@@ -16,7 +14,6 @@ logger = logging.getLogger("api")
 
 
 class LocalPlanner(MissionPlannerInterface):
-    @inject
     def __init__(self):
         self.predefined_mission_folder = Path(settings.PREDEFINED_MISSIONS_FOLDER)
 

isar/models/events.py

@@ -0,0 +1,118 @@
+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()
+
+
+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