Create and mount application level data direcory rather than just a scan directory

src/openflexure_microscope_server/things/__init__.py

@@ -3,3 +3,59 @@
 The microscope can be extended to be used with other hardware by creating a package
 with other Things and including them in the LabThings-FastAPI config file.
 """
+
+import posixpath
+from typing import Optional, Self
+
+from starlette.routing import Mount
+from starlette.staticfiles import StaticFiles
+
+import labthings_fastapi as lt
+
+
+class OFMThing(lt.Thing):
+    """A custom LabThings Thing class for the OpenFlexure Microscope."""
+
+    _data_dir: Optional[str] = None
+
+    def __enter__(self) -> Self:
+        """Set the data directory when the Thing is entered."""
+        self._data_dir = get_data_directory_from_server(self)
+        return self
+
+    @property
+    def data_dir(self) -> str:
+        """The data directory for this thing."""
+        if self._data_dir is None:
+            raise RuntimeError(
+                "No data directory set. Has the LabThings server been started?"
+            )
+        return self._data_dir
+
+
+def get_data_directory_from_server(thing: lt.Thing) -> str:
+    """Get the data directory from the server.
+
+    :param thing: The Thing to get the data directory for.
+
+    :return: The data directory as a string:
+    :raise RuntimeError: If not able to get the data directory for any reason.
+    """
+    server = thing._thing_server_interface._server()
+    if server is None:
+        raise RuntimeError("No server found to communicate with.")
+    routes = server.app.routes
+    try:
+        route_paths = [route.path if hasattr(route, "path") else "" for route in routes]
+        data_index = route_paths.index("/data")
+    except ValueError as e:
+        raise RuntimeError("Could not find data directory") from e
+    mount = routes[data_index]
+    if not isinstance(mount, Mount):
+        raise RuntimeError("Data directory isn't a starlette.routing.Mount.")
+    if not isinstance(mount.app, StaticFiles):
+        raise RuntimeError("Data is not mounted as static files.")
+    app_data_dir = mount.app.directory
+    if app_data_dir is None:
+        raise RuntimeError("Data directory is not set.")
+    return posixpath.join(str(app_data_dir), thing.path.strip("/"))

src/openflexure_microscope_server/things/smart_scan.py

@@ -32,6 +32,7 @@ from pydantic import BaseModel, PlainSerializer
 import labthings_fastapi as lt
 
 from openflexure_microscope_server import scan_directories, stitching
+from openflexure_microscope_server.things import OFMThing
 from openflexure_microscope_server.utilities import coerce_thing_selector
 
 # Things
@@ -120,7 +121,7 @@ def _scan_running(
     return scan_running_wrapper
 
 
-class SmartScanThing(lt.Thing):
+class SmartScanThing(OFMThing):
     """A Thing for scanning samples and interacting with past scans.
 
     SmartScanThing exposes all functionality for automatically scanning samples,
@@ -135,23 +136,22 @@ class SmartScanThing(lt.Thing):
     def __init__(
         self,
         thing_server_interface: lt.ThingServerInterface,
-        scans_folder: str,
         default_workflow: str,
     ) -> None:
         """Initialise a SmartScanThing saving to and loading from the input directory.
 
-        :param scans_folder: This is the path to the directory where all scans will be
-            saved. Any scans already in this directory will be accessible through the
-            HTTP interface.
+        :param default_workflow: The default workflows that smart scan uses if nothing
+            is set in settings.
         """
         super().__init__(thing_server_interface)
-        self._scan_dir_manager = scan_directories.ScanDirectoryManager(scans_folder)
         self._scan_lock = threading.Lock()
         self._default_workflow = default_workflow
         self._workflow_name = default_workflow
 
     def __enter__(self) -> Self:
         """Open hardware connection when the Thing context manager is opened."""
+        super().__enter__()
+        self._scan_dir_manager = scan_directories.ScanDirectoryManager(self.data_dir)
         valid_name = coerce_thing_selector(
             thing_mapping=self._all_workflows,
             selected=self.workflow_name,