Have settings dictionary generated on the fly for saving by a Thing method

Author: julianstirling

src/labthings_fastapi/decorators/__init__.py

@@ -37,6 +37,7 @@
 from ..descriptors import (
     ActionDescriptor,
     PropertyDescriptor,
+    SettingDescriptor,
     EndpointDescriptor,
     HTTPMethod,
 )
@@ -91,25 +92,24 @@ def __get__(self, obj, objtype=None):
         getter=func,
     )
 
-def persistent_thing_property(func: Callable) -> PropertyDescriptor:
-    """Mark a method of a Thing as a Property
+def thing_setting(func: Callable) -> SettingDescriptor:
+    """Mark a method of a Thing as a Setting.
 
-    We replace the function with a `Descriptor` that's a
-    subclass of `PropertyDescriptor`
+    A setting is a property that persists between runs
 
-    TODO: try https://stackoverflow.com/questions/54413434/type-hinting-with-descriptors
+    We replace the function with a `Descriptor` that's a
+    subclass of `SettingDescriptor`
     """
 
-    class PropertyDescriptorSubclass(PropertyDescriptor):
+    class SettingDescriptorSubclass(SettingDescriptor):
         def __get__(self, obj, objtype=None):
             return super().__get__(obj, objtype)
 
-    return PropertyDescriptorSubclass(
+    return SettingDescriptorSubclass(
         return_type(func),
         readonly=True,
         observable=False,
         getter=func,
-        persistent=True,
     )
 
 

src/labthings_fastapi/descriptors/__init__.py

@@ -1,4 +1,5 @@
 from .action import ActionDescriptor as ActionDescriptor
 from .property import PropertyDescriptor as PropertyDescriptor
+from .property import SettingDescriptor as SettingDescriptor
 from .endpoint import EndpointDescriptor as EndpointDescriptor
 from .endpoint import HTTPMethod as HTTPMethod

src/labthings_fastapi/descriptors/property.py

@@ -39,7 +39,6 @@ def __init__(
         title: Optional[str] = None,
         getter: Optional[Callable] = None,
         setter: Optional[Callable] = None,
-        persistent: bool = False,
     ):
         if getter and initial_value is not None:
             raise ValueError("getter and an initial value are mutually exclusive.")
@@ -54,7 +53,6 @@ def __init__(
         # The lines below allow _getter and _setter to be specified by subclasses
         self._setter = setter or getattr(self, "_setter", None)
         self._getter = getter or getattr(self, "_getter", None)
-        self.persistent = persistent
         self.save_location = None
         # Try to generate a DataSchema, so that we can raise an error that's easy to
         # link to the offending PropertyDescriptor
@@ -110,8 +108,6 @@ def __set__(self, obj, value):
         obj.__dict__[self.name] = value
         if self._setter:
             self._setter(obj, value)
-        if self.persistent:
-            logging.warning(f'This should save {self.name} to {self.save_location}')
         self.emit_changed_event(obj, value)
 
     def _observers_set(self, obj):
@@ -227,3 +223,15 @@ def setter(self, func: Callable) -> Self:
         self._setter = func
         self.readonly = False
         return self
+
+
+class SettingDescriptor(PropertyDescriptor):
+
+    @property
+    def persistent(self):
+        return True
+
+    def __set__(self, obj, value):
+        """Set the property's value"""
+        super().__set__(obj, value)
+        obj.save_settings()

src/labthings_fastapi/server/__init__.py

@@ -18,7 +18,6 @@
 from ..thing_description.model import ThingDescription
 from ..dependencies.thing_server import _thing_servers
 from ..outputs.blob import BlobDataManager
-from ..utilities import class_attributes
 
 
 class ThingServer:
@@ -86,11 +85,7 @@ def add_thing(self, thing: Thing, path: str):
         thing._labthings_thing_settings = ThingSettings(
             os.path.join(settings_folder, "settings.json")
         )
-        for name, attribute in class_attributes(thing):
-            if hasattr(attribute, "property_affordance"):
-                if attribute.persistent:
-                    attribute.save_location = os.path.join(settings_folder, "settings.json")
-        thing.attach_to_server(self, path)
+        thing.attach_to_server(self, path, os.path.join(settings_folder, "settings.json"))
 
     @asynccontextmanager
     async def lifespan(self, app: FastAPI):

src/labthings_fastapi/thing.py

@@ -10,11 +10,15 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING, Optional
 from collections.abc import Mapping
+import logging
 from fastapi.encoders import jsonable_encoder
 from fastapi import Request
 from anyio.abc import ObjectSendStream
 from anyio.from_thread import BlockingPortal
 from anyio.to_thread import run_sync
+
+from pydantic import BaseModel
+
 from .descriptors import PropertyDescriptor, ActionDescriptor
 from .thing_description.model import ThingDescription, NoSecurityScheme
 from .utilities import class_attributes
@@ -35,9 +39,6 @@ class Thing:
     a particular function - it will correspond to a path on the server, and a Thing
     Description document.
 
-    Your Thing should be a subclass of Thing - note that we don't define `__init__` so
-    you are free to initialise as you like and don't need to call `super().__init__`.
-
     ## Subclassing Notes
 
     * `__init__`: You should accept any arguments you need to configure the Thing
@@ -85,10 +86,11 @@ async def __aexit__(self, exc_t, exc_v, exc_tb):
         if hasattr(self, "__exit__"):
             return await run_sync(self.__exit__, exc_t, exc_v, exc_tb)
 
-    def attach_to_server(self, server: ThingServer, path: str):
+    def attach_to_server(self, server: ThingServer, path: str, setting_storage_path: str):
         """Add HTTP handlers to an app for all Interaction Affordances"""
         self.path = path
         self.action_manager: ActionManager = server.action_manager
+        self._setting_storage_path = setting_storage_path
 
         for _name, item in class_attributes(self):
             try:
@@ -113,6 +115,30 @@ def thing_description(request: Request) -> ThingDescription:
         async def websocket(ws: WebSocket):
             await websocket_endpoint(self, ws)
 
+
+    _settings: Optional[list[str]] = None
+
+    @property
+    def settings(self):
+        if self._settings is None:
+            self._settings = []
+            for name, attribute in class_attributes(self):
+                if hasattr(attribute, "property_affordance") and hasattr(attribute, "persistent"):
+                    self._settings.append(name)
+        return self._settings
+
+    _setting_storage_path: Optional[str] = None
+
+    @property
+    def setting_storage_path(self) -> ThingSettings:
+        """The storage path for settings. This is set at runtime."""
+        return self._setting_storage_path
+
+    def save_settings(self):
+        if self.settings is not None:
+            setting_dict = {name: self.__dict__[name] for name in self.settings}
+            logging.warning(f'This should save {setting_dict} to {self._setting_storage_path}')
+
     _labthings_thing_settings: Optional[ThingSettings] = None
 
     @property