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

isar/config/log.py

@@ -1,66 +1,71 @@
 import logging
 import logging.config
+import os
 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
 
+from .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))
+
+def setup_loggers() -> None:
+    log_config = load_log_config()
 
     logging.config.dictConfig(log_config)
 
+    env_log_levels = {}
+    for env_var, value in os.environ.items():
+        if env_var.endswith("_LOG_LEVEL"):
+            log_name = env_var.split("_LOG_LEVEL")[0].lower()
+            env_log_levels[log_name] = value.upper()
+
     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)
+            configure_console_handler(log_config=log_config, settings=settings)
         )
 
     for log_handler in handlers:
-        for loggers in log_config["loggers"].keys():
-            logging.getLogger(loggers).addHandler(log_handler)
-            logging.getLogger(loggers).setLevel(log_levels[loggers])
-        logging.getLogger().addHandler(log_handler)
+        for logger_name, logger_config in log_config["loggers"].items():
+            logger = logging.getLogger(logger_name)
+            logger.addHandler(log_handler)
+            if "level" in logger_config:
+                logger.setLevel(logger_config["level"])
+            if logger_name in env_log_levels:
+                logger.setLevel(env_log_levels[logger_name])
+        root_logger = logging.getLogger()
+        root_logger.addHandler(log_handler)
+        if "level" in log_config.get("root", {}):
+            root_logger.setLevel(log_config["root"]["level"])
 
 
-def configure_console_handler(log_config: dict) -> logging.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, settings: Settings) -> logging.Handler:
     handler = logging.StreamHandler()
     handler.setLevel(log_config["root"]["level"])
-    handler.setFormatter(
-        ColourizedFormatter(
-            log_config["formatters"]["colourized"]["format"],
-            style="{",
-            use_colors=True,
+    if settings.DEBUG_LOG_FORMATTER:
+        handler.setFormatter(
+            ColourizedFormatter(
+                log_config["formatters"]["debug-formatter"]["format"],
+                style="{",
+                use_colors=True,
+            )
         )
-    )
-    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 = (
-            f"CRITICAL ERROR: Missing connection string for Application Insights in key vault '{keyvault.name}'."
+    else:
+        handler.setFormatter(
+            ColourizedFormatter(
+                log_config["formatters"]["colourized"]["format"],
+                style="{",
+                use_colors=True,
+            )
         )
-        print(f"\n{message} \n")
-        raise ConfigurationError(message)
-
-    handler = AzureLogHandler(connection_string=connection_string)
-    handler.setLevel(log_config["root"]["level"])
     return handler

isar/config/logging.conf

@@ -5,54 +5,39 @@ 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
+  debug-formatter:
+    style: "{"
+    format: "\x1b[2m{asctime}\x1b[22m - {levelprefix:<8} - \x1b[2m{filename}:{lineno:<4} - {funcName:<15} - {name}\x1b[22m\n{message}"
 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: []
+    level: WARNING
   uvicorn:
-    handlers: [api]
+    handlers: []
     propagate: no
+    level: WARNING
   azure:
     handlers: []
     propagate: no
+    level: WARNING
 root:
-  level: DEBUG
+  level: INFO
   handlers: []

isar/config/open_telemetry.py

@@ -0,0 +1,102 @@
+import logging
+from urllib.parse import urljoin
+
+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.exporter.otlp.proto.http._log_exporter import (
+    OTLPLogExporter as OTLPHttpLogExporter,
+)
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter as OTLPHttpSpanExporter,
+)
+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
+
+logging.getLogger("opentelemetry.sdk").setLevel(logging.CRITICAL)
+
+
+def setup_open_telemetry(app: FastAPI) -> None:
+
+    service_name = settings.ROBOT_NAME
+    resource = Resource.create({SERVICE_NAME: service_name})
+
+    tracer_provider = TracerProvider(resource=resource)
+    log_provider = LoggerProvider(resource=resource)
+
+    if settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
+        print("[OTEL] Azure Monitor exporters enabled")
+        azure_monitor_trace_exporter, azure_monitor_log_exporter = (
+            get_azure_monitor_exporters()
+        )
+
+        tracer_provider.add_span_processor(
+            BatchSpanProcessor(azure_monitor_trace_exporter)
+        )
+
+        log_provider.add_log_record_processor(
+            BatchLogRecordProcessor(azure_monitor_log_exporter)
+        )
+
+    otlp_exporter_endpoint = settings.OPEN_TELEMETRY_OTLP_EXPORTER_ENDPOINT
+    if otlp_exporter_endpoint:
+        print(f"[OTEL] OTLP exporters enabled, endpoint={otlp_exporter_endpoint}")
+        otlp_trace_exporter, otlp_log_exporter = get_otlp_exporters(
+            otlp_exporter_endpoint
+        )
+        tracer_provider.add_span_processor(BatchSpanProcessor(otlp_trace_exporter))
+
+        log_provider.add_log_record_processor(
+            BatchLogRecordProcessor(otlp_log_exporter)
+        )
+
+    set_logger_provider(log_provider)
+    trace.set_tracer_provider(tracer_provider)
+
+    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]
+):
+    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
+
+
+def get_otlp_exporters(
+    endpoint: str,
+) -> tuple[OTLPHttpSpanExporter, OTLPHttpLogExporter]:
+    base = endpoint.rstrip("/") + "/"
+    trace_ep = urljoin(base, "v1/traces")
+    log_ep = urljoin(base, "v1/logs")
+
+    print("[OTEL] Using HTTP/Protobuf protocol for OpenTelemetry export")
+    print(f"[OTEL]  traces → {trace_ep}")
+    print(f"[OTEL]  logs   → {log_ep}")
+
+    return OTLPHttpSpanExporter(endpoint=trace_ep), OTLPHttpLogExporter(endpoint=log_ep)

isar/config/settings.py

@@ -1,33 +1,27 @@
 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
 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")
 
@@ -41,27 +35,24 @@ class Settings(BaseSettings):
     # The sleep is used to throttle the system on every iteration in the loop
     FSM_SLEEP_TIME: float = Field(default=0.1)
 
-    # Location of JSON files containing predefined missions for the Local Planner to use
-    path: str = os.path.dirname(predefined_missions.__file__)
-    PREDEFINED_MISSIONS_FOLDER: str = Field(default=path + "/")
-
     # 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 +61,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,12 +82,11 @@ class Settings(BaseSettings):
     # FastAPI port
     API_PORT: int = Field(default=3000)
 
-    # Determines which mission planner module is used by ISAR
-    MISSION_PLANNER: str = Field(default="local")
+    # Determines how long delay time should be allowed before returning home
+    RETURN_HOME_DELAY: int = Field(default=10)
 
-    # Determines which task selector module is used by ISAR
-    # Options: [sequential]
-    TASK_SELECTOR: str = Field(default="sequential")
+    # 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 storage modules are used by ISAR
     # Multiple storage modules can be chosen
@@ -94,7 +94,6 @@ class Settings(BaseSettings):
     # 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 +109,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 +139,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 +171,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 +184,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 +193,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 +225,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 +261,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 +286,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"
     )