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

isar/config/settings.py

@@ -1,6 +1,6 @@
 import os
 from importlib.resources import as_file, files
-from typing import Any, List, Optional
+from typing import Any, List
 
 from dotenv import load_dotenv
 from pydantic import Field, ValidationInfo, field_validator
@@ -8,26 +8,21 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from isar.config import predefined_missions
 from robot_interface.models.robots.robot_model import RobotModel
-from robot_interface.telemetry.payloads import VideoStream
+from robot_interface.telemetry.payloads import DocumentInfo
 
 
 class Settings(BaseSettings):
-    def __init__(self) -> None:
-        try:
-            source = files("isar").joinpath("config").joinpath("settings.env")
-            with as_file(source) as eml:
-                env_file = eml
-        except ModuleNotFoundError:
-            env_file = None
-        super().__init__(_env_file=env_file)
+    # Endpoint open telemetry will export telemetry in the otlp protocol to
+    OPEN_TELEMETRY_OTLP_EXPORTER_ENDPOINT: str = Field(default="http://localhost:4318")
+
+    # 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")
 
-    # The run mode of the robot (stepwise or full mission)
-    RUN_MISSION_STEPWISE: bool = Field(default=True)
-
     # Determines the local path in which results from missions are stored
     LOCAL_STORAGE_PATH: str = Field(default="./results")
 
@@ -48,20 +43,21 @@ class Settings(BaseSettings):
     # Name of default map transformation
     DEFAULT_MAP: str = Field(default="default_map")
 
-    # Location of JSON files containing predefined maps
-    MAPS_FOLDER: str = Field(default="src/isar/config/maps/")
-
     # Determines the number of state transitions that are kept in the log
     STATE_TRANSITIONS_LOG_LENGTH: int = Field(default=20)
 
-    # Number of attempts to initiate a step or mission before cancelling
-    INITIATE_FAILURE_COUNTER_LIMIT: int = Field(default=10)
-
-    # Number of attempts to request a step status in monitor before cancelling
+    # Number of attempts to request a task status in monitor before cancelling
     REQUEST_STATUS_FAILURE_COUNTER_LIMIT: int = Field(default=3)
 
+    # Time allocated to reconnect when failing to retrieve status due to communication
+    # 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)
+
     # Number of attempts to stop the robot before giving up
-    STOP_ROBOT_ATTEMPTS_LIMIT: int = Field(default=10)
+    STOP_ROBOT_ATTEMPTS_LIMIT: int = Field(default=3)
 
     # Number of attempts to stop the robot before giving up
     UPLOAD_FAILURE_ATTEMPTS_LIMIT: int = Field(default=10)
@@ -70,10 +66,20 @@ class Settings(BaseSettings):
     UPLOAD_FAILURE_MAX_WAIT: int = Field(default=60)
 
     # ISAR telemetry intervals
-    ROBOT_STATUS_PUBLISH_INTERVAL: float = Field(default=1)
     ROBOT_HEARTBEAT_PUBLISH_INTERVAL: float = Field(default=1)
     ROBOT_INFO_PUBLISH_INTERVAL: float = Field(default=5)
+    ROBOT_API_BATTERY_POLL_INTERVAL: float = Field(default=5)
     ROBOT_API_STATUS_POLL_INTERVAL: float = Field(default=5)
+    THREAD_CHECK_INTERVAL: float = Field(default=0.01)
+
+    # Determines the minimum battery level the robot must have to start a mission
+    # If it drops below this level it will recharge to the value set by
+    # ROBOT_BATTERY_RECHARGE_THRESHOLD before starting new missions
+    ROBOT_MISSION_BATTERY_START_THRESHOLD: float = Field(default=25.0)
+
+    # Determines the minimum battery threshold to consider the robot recharged
+    # and ready for more missions, after having run low on charge
+    ROBOT_BATTERY_RECHARGE_THRESHOLD: float = Field(default=80.0)
 
     # FastAPI host
     API_HOST_VIEWED_EXTERNALLY: str = Field(default="0.0.0.0")
@@ -81,20 +87,21 @@ class Settings(BaseSettings):
     # FastAPI port
     API_PORT: int = Field(default=3000)
 
+    # Determines how long delay time should be allowed before returning home
+    RETURN_HOME_DELAY: int = Field(default=10)
+
+    # Sets how many times the robot should try to return home if a return home fails
+    RETURN_HOME_RETRY_LIMIT: int = Field(default=5)
+
     # Determines which mission planner module is used by ISAR
     MISSION_PLANNER: str = Field(default="local")
 
-    # Determines which task selector module is used by ISAR
-    # Options: [sequential]
-    TASK_SELECTOR: str = Field(default="sequential")
-
     # Determines which storage modules are used by ISAR
     # Multiple storage modules can be chosen
     # Each module will be called when storing results from inspections
     # Selecting a different storage module than local may require certain access rights
     STORAGE_LOCAL_ENABLED: bool = Field(default=True)
     STORAGE_BLOB_ENABLED: bool = Field(default=False)
-    STORAGE_SLIMM_ENABLED: bool = Field(default=False)
 
     # Determines whether the MQTT publishing module should be enabled or not
     # The publishing module will attempt to connect to the MQTT broker configured in
@@ -110,7 +117,7 @@ class Settings(BaseSettings):
     # Enabling this requires certain resources available for OAuth2 authentication
     # Currently supported authentication is Azure AD
     # (https://github.com/Intility/fastapi-azure-auth)
-    AUTHENTICATION_ENABLED: bool = Field(default=False)
+    AUTHENTICATION_ENABLED: bool = Field(default=True)
 
     # Tenant ID for the Azure tenant with your Azure Active Directory application
     AZURE_TENANT_ID: str = Field(default="3aa4a235-b6e2-48d5-9195-7fcf05b459b0")
@@ -140,46 +147,28 @@ class Settings(BaseSettings):
     # Keyvault name
     KEYVAULT_NAME: str = Field(default="IsarDevKv")
 
+    # Determines whether inspections are uploaded asynchronously or get_inspections in robotinterface
+    UPLOAD_INSPECTIONS_ASYNC: bool = Field(default=False)
+
     # URL to storage account for Azure Blob Storage
-    BLOB_STORAGE_ACCOUNT_URL: str = Field(
-        default="https://eqrobotdevstorage.blob.core.windows.net"
-    )
+    BLOB_STORAGE_ACCOUNT: str = Field(default="")
 
     # Name of blob container in Azure Blob Storage [slimm test]
     BLOB_CONTAINER: str = Field(default="test")
 
-    # Client ID for SLIMM App Registration
-    SLIMM_CLIENT_ID: str = Field(default="c630ca4d-d8d6-45ab-8cc6-68a363d0de9e")
-
-    # Scope for access to SLIMM Ingestion API
-    SLIMM_APP_SCOPE: str = Field(default=".default")
-
-    # URL for SLIMM endpoint
-    SLIMM_API_URL: str = Field(
-        default="https://scinspectioningestapitest.azurewebsites.net/Ingest"
-    )
-
-    # Whether the results should be copied directly into the SLIMM datalake or only the
-    # metadata
-    COPY_FILES_TO_SLIMM_DATALAKE: bool = Field(default=False)
+    PERSISTENT_STORAGE_CONNECTION_STRING: str = Field(default="")
 
     # The configuration of this section is tightly coupled with the metadata that is
     # submitted with the results once they have been uploaded.
 
     # Four digit code indicating facility
-    PLANT_CODE: str = Field(default="1320")
+    PLANT_CODE: str = Field(default="1210")
 
     # Name of the facility the robot is operating in
-    PLANT_NAME: str = Field(default="Kårstø")
+    PLANT_NAME: str = Field(default="Huldra")
 
     # Shortname of the facility the robot is operating in
-    PLANT_SHORT_NAME: str = Field(default="KAA")
-
-    # Country the robot is operating in
-    COUNTRY: str = Field(default="Norway")
-
-    # Type of robot ISAR is monitoring
-    ROBOT_TYPE: str = Field(default="robot")
+    PLANT_SHORT_NAME: str = Field(default="HUA")
 
     # Name of robot
     ROBOT_NAME: str = Field(default="Placebot")
@@ -190,25 +179,8 @@ class Settings(BaseSettings):
     # Serial number of the robot ISAR is connected to
     SERIAL_NUMBER: str = Field(default="0001")
 
-    # Endpoints to reach video streams for the robot
-    VIDEO_STREAMS: List[VideoStream] = Field(
-        default=[
-            VideoStream(
-                name="Front camera",
-                url="http://localhost:5000/videostream/front",
-                type="turtlebot",
-            ),
-            VideoStream(
-                name="Rear camera",
-                url="http://localhost:5000/videostream/rear",
-                type="turtlebot",
-            ),
-        ]
-    )
-
-    # Data scheme the robot should adhere to
-    # Options [DS0001]
-    DATA_SCHEME: str = Field(default="DS0001")
+    # Info about robot documentation
+    DOCUMENTATION: List[DocumentInfo] = Field(default=[])
 
     # Coordinate reference system of facility
     COORDINATE_REFERENCE_SYSTEM: str = Field(default="EQUINOR:4100001")
@@ -220,9 +192,6 @@ class Settings(BaseSettings):
     # Options [quaternion]
     MEDIA_ORIENTATION_REFERENCE_SYSTEM: str = Field(default="quaternion")
 
-    # Contractor who is responsible for robot missions
-    CONTRACTOR: str = Field(default="equinor")
-
     # Timezone
     TIMEZONE: str = Field(default="UTC+00:00")
 
@@ -232,15 +201,29 @@ class Settings(BaseSettings):
     # List of MQTT Topics
     TOPIC_ISAR_STATUS: str = Field(default="status", validate_default=True)
     TOPIC_ISAR_MISSION: str = Field(default="mission", validate_default=True)
+    TOPIC_ISAR_MISSION_ABORTED: str = Field(
+        default="aborted_mission", validate_default=True
+    )
     TOPIC_ISAR_TASK: str = Field(default="task", validate_default=True)
-    TOPIC_ISAR_STEP: str = Field(default="step", validate_default=True)
     TOPIC_ISAR_INSPECTION_RESULT: str = Field(
         default="inspection_result", validate_default=True
     )
+    TOPIC_ISAR_INSPECTION_VALUE: str = Field(
+        default="inspection_value", validate_default=True
+    )
     TOPIC_ISAR_ROBOT_INFO: str = Field(default="robot_info", validate_default=True)
     TOPIC_ISAR_ROBOT_HEARTBEAT: str = Field(
         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
+    )
+
+    # List of MQTT Topics Expiry
+    MQTT_ROBOT_HEARTBEAT_EXPIRY: int = Field(default=5)
+    MQTT_TELEMETRY_EXPIRY: int = Field(default=10)
+    MQTT_MISSION_AND_TASK_EXPIRY: int = Field(default=86400)
 
     # Logging
 
@@ -250,47 +233,29 @@ class Settings(BaseSettings):
     # Each handler will be called when logging
     # Selecting a different log handler than local may require certain access rights:
     #    - The Azure AI logger requires the 'APPLICATIONINSIGHTS_CONNECTION_STRING' to be set as an environment variable.
+    # In general logging is configured in logging.conf
     LOG_HANDLER_LOCAL_ENABLED: bool = Field(default=True)
     LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED: bool = Field(default=False)
 
-    #   Log levels
-    API_LOG_LEVEL: str = Field(default="INFO")
-    MAIN_LOG_LEVEL: str = Field(default="INFO")
-    MQTT_LOG_LEVEL: str = Field(default="INFO")
-    STATE_MACHINE_LOG_LEVEL: str = Field(default="INFO")
-    UPLOADER_LOG_LEVEL: str = Field(default="INFO")
-    CONSOLE_LOG_LEVEL: str = Field(default="INFO")
-    URLLIB3_LOG_LEVEL: str = Field(default="WARNING")
-    UVICORN_LOG_LEVEL: str = Field(default="WARNING")
-    AZURE_LOG_LEVEL: str = Field(default="WARNING")
+    DEBUG_LOG_FORMATTER: bool = Field(default=False)
 
-    LOG_LEVELS: dict = Field(default={})
+    # You can set logger levels from environment variables ending with _LOG_LEVEL
+    # For example, MQTT_LOG_LEVEL="DEBUG" will set the logger MQTT_LOGGER to DEBUG level
+    # Handeled in log.py and only work for loggers defined in logging.conf
 
     REQUIRED_ROLE: str = Field(default="Mission.Control")
 
-    @field_validator("LOG_LEVELS")
-    @classmethod
-    def set_log_levels(cls, v: Any, info: ValidationInfo) -> dict:
-        return {
-            "api": info.data["API_LOG_LEVEL"],
-            "main": info.data["MAIN_LOG_LEVEL"],
-            "mqtt": info.data["MQTT_LOG_LEVEL"],
-            "state_machine": info.data["STATE_MACHINE_LOG_LEVEL"],
-            "uploader": info.data["UPLOADER_LOG_LEVEL"],
-            "console": info.data["CONSOLE_LOG_LEVEL"],
-            "urllib3": info.data["URLLIB3_LOG_LEVEL"],
-            "uvicorn": info.data["UVICORN_LOG_LEVEL"],
-            "azure": info.data["AZURE_LOG_LEVEL"],
-        }
-
     @field_validator(
         "TOPIC_ISAR_STATUS",
         "TOPIC_ISAR_MISSION",
         "TOPIC_ISAR_TASK",
-        "TOPIC_ISAR_STEP",
         "TOPIC_ISAR_ROBOT_INFO",
         "TOPIC_ISAR_ROBOT_HEARTBEAT",
         "TOPIC_ISAR_INSPECTION_RESULT",
+        "TOPIC_ISAR_INSPECTION_VALUE",
+        "TOPIC_ISAR_STARTUP",
+        "TOPIC_ISAR_INTERVENTION_NEEDED",
+        "TOPIC_ISAR_MISSION_ABORTED",
     )
     @classmethod
     def prefix_isar_topics(cls, v: Any, info: ValidationInfo):
@@ -304,7 +269,12 @@ class Settings(BaseSettings):
     )
 
 
-load_dotenv()
+env = os.environ.get("ISAR_ENV")
+
+if env == "test":
+    load_dotenv(".env.test", override=True)
+else:
+    load_dotenv()
 settings = Settings()
 
 
@@ -324,17 +294,12 @@ class RobotSettings(BaseSettings):
 
     # ISAR steps the robot is capable of performing
     # This should be set in the robot package settings.env file
-    CAPABILITIES: List[str] = Field(default=["drive_to_pose", "take_image"])
+    CAPABILITIES: List[str] = Field(default=["take_image"])
 
     # Model of the robot which ISAR is connected to
     # This should be set in the robot package settings.env file
     ROBOT_MODEL: RobotModel = Field(default=RobotModel.Robot)  # type: ignore
 
-    # Valid arm poses that the robot may utilize
-    # This should be set in the robot package settings.env file
-    # Note that if the robot does not support moving an arm this will be None and
-    # the functionality will be unavailable
-    VALID_ARM_POSES: Optional[List[str]] = Field(default=None)
     model_config = SettingsConfigDict(
         env_file_encoding="utf-8", case_sensitive=True, extra="ignore"
     )

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

@@ -1,23 +1,19 @@
+import json
 import logging
 from pathlib import Path
 
-from alitra import Frame
-from injector import inject
-
 from isar.config.settings import settings
 from isar.mission_planner.mission_planner_interface import (
     MissionNotFoundError,
     MissionPlannerError,
     MissionPlannerInterface,
 )
-from isar.services.readers.base_reader import BaseReader, BaseReaderError
 from robot_interface.models.mission.mission import Mission
 
 logger = logging.getLogger("api")
 
 
 class LocalPlanner(MissionPlannerInterface):
-    @inject
     def __init__(self):
         self.predefined_mission_folder = Path(settings.PREDEFINED_MISSIONS_FOLDER)
 
@@ -37,15 +33,10 @@ class LocalPlanner(MissionPlannerInterface):
 
     @staticmethod
     def read_mission_from_file(mission_path: Path) -> Mission:
-        mission_dict: dict = BaseReader.read_json(location=mission_path)
-        mission: Mission = BaseReader.dict_to_dataclass(
-            dataclass_dict=mission_dict,
-            target_dataclass=Mission,
-            cast_config=[Frame],
-            strict_config=True,
-        )
+        with open(mission_path) as json_file:
+            mission_dict = json.load(json_file)
 
-        return mission
+        return Mission(**mission_dict)
 
     def get_predefined_missions(self) -> dict:
         missions: dict = {}
@@ -54,13 +45,8 @@ class LocalPlanner(MissionPlannerInterface):
         for file in json_files:
             mission_name = file.stem
             path_to_file = self.predefined_mission_folder.joinpath(file.name)
-            try:
-                mission: Mission = self.read_mission_from_file(path_to_file)
-            except BaseReaderError as e:
-                logger.warning(
-                    f"Failed to read predefined mission {path_to_file} \n {e}"
-                )
-                continue
+
+            mission: Mission = self.read_mission_from_file(path_to_file)
             if mission.id in invalid_mission_ids:
                 logger.warning(
                     f"Duplicate mission id {mission.id} : {path_to_file.as_posix()}"

isar/mission_planner/mission_planner_interface.py

@@ -9,7 +9,7 @@ class MissionPlannerInterface(metaclass=ABCMeta):
         """
         Parameters
         ----------
-        mission_id : int
+        mission_id : str
 
         Returns
         -------