Add application configuration that propagates to Things

Author: julianstirling

src/labthings_fastapi/server/__init__.py

@@ -7,7 +7,7 @@
 """
 
 from __future__ import annotations
-from typing import AsyncGenerator, Optional, TypeVar
+from typing import Any, AsyncGenerator, Optional, TypeVar
 from typing_extensions import Self
 import os
 
@@ -65,6 +65,7 @@ def __init__(
         self,
         things: ThingsConfig,
         settings_folder: Optional[str] = None,
+        application_config: Optional[Mapping[str, Any]] = None,
     ) -> None:
         r"""Initialise a LabThings server.
 
@@ -84,7 +85,11 @@ def __init__(
         """
         self.startup_failure: dict | None = None
         configure_thing_logger()  # Note: this is safe to call multiple times.
-        self._config = ThingServerConfig(things=things, settings_folder=settings_folder)
+        self._config = ThingServerConfig(
+            things=things,
+            settings_folder=settings_folder,
+            application_config=application_config,
+        )
         self.app = FastAPI(lifespan=self.lifespan)
         self._set_cors_middleware()
         self._set_url_for_middleware()
@@ -148,6 +153,15 @@ def things(self) -> Mapping[str, Thing]:
         """
         return MappingProxyType(self._things)
 
+    @property
+    def application_config(self) -> Mapping[str, Any] | None:
+        """Return the application configuration from the config file.
+
+        :return: The custom configuration as specified in the configuration
+            file.
+        """
+        return self._config.application_config
+
     ThingInstance = TypeVar("ThingInstance", bound=Thing)
 
     def things_by_class(self, cls: type[ThingInstance]) -> Sequence[ThingInstance]:

src/labthings_fastapi/server/config_model.py

@@ -180,6 +180,18 @@ def thing_configs(self) -> Mapping[ThingName, ThingConfig]:
         description="The location of the settings folder.",
     )
 
+    application_config: dict[str, Any] | None = Field(
+        default=None,
+        description=(
+            """Any custom settings required by the application.
+
+            These settings will be available to any Things within the application via
+            their ``application_config`` property. Any validation of the dictionary is
+            the responsibility of application code.
+            """
+        ),
+    )
+
 
 def normalise_things_config(things: ThingsConfig) -> Mapping[ThingName, ThingConfig]:
     r"""Ensure every Thing is defined by a `.ThingConfig` object.

src/labthings_fastapi/testing.py

@@ -121,6 +121,14 @@ def _action_manager(self) -> ActionManager:
         """
         raise NotImplementedError("MockThingServerInterface has no ActionManager.")
 
+    @property
+    def application_config(self) -> None:
+        """Return an empty application configuration when mocking.
+
+        :return: None
+        """
+        return None
+
 
 ThingSubclass = TypeVar("ThingSubclass", bound="Thing")
 

src/labthings_fastapi/thing.py

@@ -9,6 +9,7 @@
 from typing import TYPE_CHECKING, Any, Optional
 from typing_extensions import Self
 from collections.abc import Mapping
+from copy import deepcopy
 import logging
 import os
 import json
@@ -82,6 +83,8 @@ class Thing:
     _thing_server_interface: ThingServerInterface
     """Provide access to features of the server that this `.Thing` is attached to."""
 
+    application_config: Mapping[str, Any] | None
+
     def __init__(self, thing_server_interface: ThingServerInterface) -> None:
         """Initialise a Thing.
 
@@ -98,6 +101,9 @@ def __init__(self, thing_server_interface: ThingServerInterface) -> None:
             `.create_thing_without_server` which generates a mock interface.
         """
         self._thing_server_interface = thing_server_interface
+        # Create a deepcopy of the configuration so if one Thing mutates the config
+        # it cannot propagate.
+        self.application_config = deepcopy(thing_server_interface.application_config)
         self._disable_saving_settings: bool = False
 
     @property

src/labthings_fastapi/thing_server_interface.py

@@ -156,6 +156,11 @@ def path(self) -> str:
         """
         return self._get_server().path_for_thing(self.name)
 
+    @property
+    def application_config(self) -> Mapping[str, Any] | None:
+        """The custom application configuration options from configuration."""
+        return self._get_server().application_config
+
     def get_thing_states(self) -> Mapping[str, Any]:
         """Retrieve metadata from all Things on the server.
 

tests/test_thing.py

@@ -13,3 +13,22 @@ def test_add_thing():
     """Check that thing can be added to the server"""
     server = ThingServer({"thing": MyThing})
     assert isinstance(server.things["thing"], MyThing)
+
+
+def test_thing_can_access_application_config():
+    """Check that a thing can access its application config."""
+    conf = {
+        "things": {"thing1": MyThing, "thing2": MyThing},
+        "application_config": {"foo": "bar", "mock": True},
+    }
+
+    server = ThingServer.from_config(conf)
+    thing1 = server.things["thing1"]
+    thing2 = server.things["thing2"]
+
+    # Check both Things can access the application config
+    assert thing1.application_config == {"foo": "bar", "mock": True}
+    assert thing1.application_config == thing2.application_config
+    # But that they are not the same dictionary, preventing mutations affecting
+    # behaviour of another thing.
+    assert thing1.application_config is not thing2.application_config