Add endpoints for LIF to TIFF conversion

pyproject.toml

@@ -41,7 +41,7 @@ cicd = [
 ]
 clem = [
     # "matplotlib", # For visual statistical analysis of images
-    "readlif", # cryo-CLEM; open LIF files; part of bioio-lif
+    "readlif", # cryo-CLEM; open LIF files
     "tifffile", # cryo-CLEM; for saving to to TIFF files
 ]
 client = [

src/murfey/client/analyser.py

@@ -7,6 +7,7 @@
 from typing import Type
 
 from murfey.client.context import Context
+from murfey.client.contexts.clem import CLEMContext
 from murfey.client.contexts.spa import SPAContext, SPAModularContext
 from murfey.client.contexts.spa_metadata import SPAMetadataContext
 from murfey.client.contexts.tomo import TomographyContext
@@ -92,8 +93,14 @@ def _find_extension(self, file_path: Path):
         ):
             logger.info(f"File extension re-evaluated: {file_path.suffix}")
             self._extension = file_path.suffix
+        elif file_path.suffix == ".lif":
+            self._extension = file_path.suffix
 
     def _find_context(self, file_path: Path) -> bool:
+        if file_path.suffix == ".lif":
+            self._role = "detector"
+            self._context = CLEMContext("leica", self._basepath)
+            return True
         split_file_name = file_path.name.split("_")
         if split_file_name:
             if split_file_name[0].startswith("FoilHole"):
@@ -333,7 +340,12 @@ def _analyse(self):
                                 )
                 elif isinstance(
                     self._context,
-                    (TomographyContext, SPAModularContext, SPAMetadataContext),
+                    (
+                        TomographyContext,
+                        SPAModularContext,
+                        SPAMetadataContext,
+                        CLEMContext,
+                    ),
                 ):
                     self.post_transfer(transferred_file)
             self.queue.task_done()

src/murfey/client/contexts/clem.py

@@ -0,0 +1,107 @@
+"""
+Add a CLEM class context (refer to src/murfey/client/contexts/fib.py)
+
+Provide a post transfer function to pass on:
+- File path on the DLS file system
+- Session ID (src/murfey/client/instance_environment.py)
+"""
+
+# import requests
+import logging
+from pathlib import Path
+from typing import Optional
+
+from murfey.client.context import Context
+from murfey.client.instance_environment import MurfeyInstanceEnvironment
+from murfey.util import capture_post, get_machine_config
+
+# Create logger object
+logger = logging.getLogger("murfey.client.contexts.clem")
+
+
+def _file_transferred_to(
+    environment: MurfeyInstanceEnvironment, source: Path, file_path: Path
+) -> Optional[Path]:
+    machine_config = get_machine_config(
+        str(environment.url.geturl()), demo=environment.demo
+    )
+    if environment.visit in environment.default_destinations[source]:
+        return (
+            Path(machine_config.get("rsync_basepath", ""))
+            / Path(environment.default_destinations[source])
+            / file_path.relative_to(source)
+        )
+    return (
+        Path(machine_config.get("rsync_basepath", ""))
+        / Path(environment.default_destinations[source])
+        / environment.visit
+        / file_path.relative_to(source)
+    )
+
+
+def _get_source(
+    file_path: Path, environment: MurfeyInstanceEnvironment
+) -> Optional[Path]:
+    for s in environment.sources:
+        if file_path.is_relative_to(s):
+            return s
+    return None
+
+
+class CLEMContext(Context):
+    def __init__(self, acquisition_software: str, basepath: Path):
+        super().__init__("CLEM", acquisition_software)
+        self._basepath = basepath
+
+    def post_transfer(
+        self,
+        transferred_file: Path,
+        role: str = "",
+        environment: Optional[MurfeyInstanceEnvironment] = None,
+        **kwargs,
+    ) -> bool:
+        super().post_transfer(
+            transferred_file, role=role, environment=environment, **kwargs
+        )
+        # Check if file is a LIF file
+        if transferred_file.suffix == ".lif":
+            # Type checking to satisfy MyPy
+            if not environment:
+                logger.warning("No environment passed in")
+                return True
+
+            # Location of the file on the client PC
+            source = _get_source(transferred_file, environment)
+            # Type checking to satisfy MyPy
+            if not source:
+                logger.warning(f"No source found for file {transferred_file}")
+                return True
+
+            # Construct the URL for the Murfey server to communicate with
+            url = f"{str(environment.url.geturl())}/sessions/{environment.murfey_session}/lif_to_tiff"
+            # Type checking to satisfy MyPy
+            if not url:
+                logger.warning("No url found for the environment")
+                return True
+
+            # Get the Path on the DLS file system
+            file_path = _file_transferred_to(
+                environment=environment,
+                source=source,
+                file_path=transferred_file,
+            )
+
+            # Get the file size and timestamp from transferred_file
+            # Client PC cannot see file_path; that is for server PC
+
+            # Post the message and logs it if there's an error
+            capture_post(
+                url,
+                json={
+                    "name": str(file_path),
+                    "size": transferred_file.stat().st_size,
+                    "timestamp": transferred_file.stat().st_ctime,
+                    "description": "",
+                },
+            )
+        return True

src/murfey/server/clem/api.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from murfey.util.lif import convert_lif_to_tiff
+from murfey.util.models import LifFileInfo
+
+# Create APIRouter class object
+router = APIRouter()
+
+
+# Allow function to be seen as an endpoint by the router
+@router.post("/sessions/{session_id}/lif_to_tiff")
+def lif_to_tiff(
+    session_id: int,  # Used by the decorator
+    lif_info: LifFileInfo,
+):
+    convert_lif_to_tiff(file=lif_info.name)

src/murfey/server/main.py

@@ -12,6 +12,8 @@
 
 import murfey.server
 import murfey.server.bootstrap
+import murfey.server.clem.api
+import murfey.server.websocket
 import murfey.util.models
 from murfey.server import template_files
 
@@ -48,13 +50,14 @@ class Settings(BaseSettings):
 app.mount("/static", StaticFiles(directory=template_files / "static"), name="static")
 app.mount("/images", StaticFiles(directory=template_files / "images"), name="images")
 
+# Add router endpoints to the API
+app.include_router(router)
 app.include_router(murfey.server.bootstrap.bootstrap)
 app.include_router(murfey.server.bootstrap.cygwin)
 app.include_router(murfey.server.bootstrap.pypi)
 app.include_router(murfey.server.bootstrap.plugins)
+app.include_router(murfey.server.clem.api.router)
 app.include_router(murfey.server.websocket.ws)
 
-app.include_router(router)
-
 for r in importlib_metadata.entry_points(group="murfey.routers"):
     app.include_router(r.load())

src/murfey/util/lif.py

@@ -15,6 +15,8 @@
 from readlif.reader import LifFile
 from tifffile import imwrite
 
+from murfey.server.api import sanitise
+
 # Create logger object to output messages with
 logger = logging.getLogger("murfey.util.lif")
 
@@ -245,7 +247,7 @@ def convert_lif_to_tiff(file: Path):
             logger.info(f"{folder} already exists")
 
     # Load LIF file as a LifFile class
-    logger.info(f"Loading {file}")
+    logger.info(f"Loading {sanitise(file.name)}")
     lif_file = LifFile(str(file))  # Stack of scenes
     scene_list = list(lif_file.get_iter_image())  # List of scene names
 

src/murfey/util/models.py

@@ -83,6 +83,13 @@ class File(BaseModel):
     timestamp: float
 
 
+class LifFileInfo(BaseModel):
+    name: Path
+    size: int
+    timestamp: float
+    description: str = ""
+
+
 class SPAProcessingParameters(BaseModel):
     job_id: int