Major rewrite of the '_analyse' function:

* Disentangled the processing logic for the 4 SPA- and Tomography-related contexts
* Replaced matching Contexts using 'str(self._context)' with 'self._context.name'
* Replaced giant if-else blocks with match-case logic
* Use explicit returns

Author: tieneupin

src/murfey/client/analyser.py

@@ -14,7 +14,7 @@
 import threading
 from importlib.metadata import entry_points
 from pathlib import Path
-from typing import OrderedDict, Type
+from typing import Type
 
 from murfey.client.context import Context
 from murfey.client.destinations import find_longest_data_directory
@@ -78,10 +78,10 @@ def __init__(
 
         # SPA & Tomo-specific attributes
         self._extension: str = ""
-        self._unseen_xml: list = []
-        self._batch_store: dict = {}
-        self._force_mdoc_metadata = force_mdoc_metadata
-        self._mdoc_for_reading: Path | None = None
+        self._processing_params_found: bool = (
+            False  # Have the processing parameters been collected from the metadata?
+        )
+        # self._force_mdoc_metadata = force_mdoc_metadata  # Seems deprecated
         self._serialem = serialem
         self.parameters_model: (
             Type[ProcessingParametersSPA] | Type[ProcessingParametersTomo] | None
@@ -94,10 +94,6 @@ def _find_extension(self, file_path: Path) -> bool:
         """
         Identifies the file extension and stores that information in the class.
         """
-        if "atlas" in file_path.parts:
-            self._extension = file_path.suffix
-            return True
-
         if (
             required_substrings := self._murfey_config.get(
                 "data_required_substrings", {}
@@ -125,14 +121,6 @@ def _find_extension(self, file_path: Path) -> bool:
             if subframe_path := mdoc_data_block.get("SubFramePath"):
                 self._extension = Path(subframe_path).suffix
                 return True
-        # Check for LIF files and TXRM files separately
-        elif (
-            file_path.suffix == ".lif"
-            or file_path.suffix == ".txrm"
-            or file_path.suffix == ".xrm"
-        ):
-            self._extension = file_path.suffix
-            return True
         return False
 
     def _find_context(self, file_path: Path) -> bool:
@@ -337,6 +325,11 @@ def post_transfer(self, transferred_file: Path):
             )
 
     def _analyse_in_thread(self):
+        """
+        Class function that will be executed by the '_thread' attribute. It will
+        execute a while-loop in which is takes files of the queue and feeds them
+        into the '_analyse' class function until '_halt_thread' is set to True.
+        """
         logger.info("Analyser thread started")
         while not self._halt_thread:
             transferred_file = self.queue.get()
@@ -354,13 +347,18 @@ def _analyse_in_thread(self):
         self.notify(final=True)
 
     def _analyse(self, transferred_file: Path):
+        """
+        Class function that is called by '_analyse_in_thread'. It will identify
+        the Context class to use based on the files inspected, then run different
+        processing logic based on the context that was established.
+        """
         if self._limited:
             if (
                 "Metadata" in transferred_file.parts
                 or transferred_file.name == "EpuSession.dm"
             ) and not self._context:
                 if not (context := _get_context("SPAMetadataContext")):
-                    return
+                    return None
                 self._context = context.load()(
                     "epu",
                     self._basepath,
@@ -373,7 +371,7 @@ def _analyse(self, transferred_file: Path):
                 or transferred_file.name == "Session.dm"
             ) and not self._context:
                 if not (context := _get_context("TomographyMetadataContext")):
-                    return
+                    return None
                 self._context = context.load()(
                     "tomo",
                     self._basepath,
@@ -382,114 +380,110 @@ def _analyse(self, transferred_file: Path):
                 )
             self.post_transfer(transferred_file)
         else:
-            # Logic that doesn't require context determination
-            if not self._serialem and (
-                self._force_mdoc_metadata and transferred_file.suffix == ".mdoc"
-            ):
-                self._mdoc_for_reading = transferred_file
-
             # Try and determine context, and notify once when context is found
             if self._context is None:
                 # Exit early if the file can't be used to determine the context
                 if not self._find_context(transferred_file):
                     logger.debug(f"Couldn't find context for {str(transferred_file)!r}")
-                    return
+                    return None
                 else:
                     logger.info(f"Context found successfully using {transferred_file}")
 
-            # Trigger processing or metadata parsing according to the context
-            # Go through the straightforward ones first
-            if "CLEMContext" in str(self._context):
-                logger.debug(f"File {transferred_file.name!r} is part of CLEM workflow")
-                self.post_transfer(transferred_file)
-            elif "FIBContext" in str(self._context):
-                logger.debug(
-                    f"File {transferred_file.name!r} is part of the FIB workflow"
-                )
-                self.post_transfer(transferred_file)
-            elif "SXTContext" in str(self._context):
-                logger.debug(f"File {transferred_file.name!r} is an SXT file")
-                self.post_transfer(transferred_file)
-            elif "AtlasContext" in str(self._context):
-                logger.debug(f"File {transferred_file.name!r} is part of the atlas")
-                self.post_transfer(transferred_file)
-
-            # Handle files with tomography and SPA context differently
-            elif (
-                any(
-                    context in str(self._context)
-                    for context in (
-                        "SPAContext",
-                        "SPAMetadataContext",
-                        "TomographyContext",
-                        "TomographyMetadataContext",
-                    )
-                )
-                and self._context is not None
-            ):
-                context = str(self._context).split(" ")[0].split(".")[-1]
-
-                dc_metadata: OrderedDict | None = None
-                if not self._serialem and (
-                    self._force_mdoc_metadata
-                    and transferred_file.suffix == ".mdoc"
-                    or self._mdoc_for_reading
+            # Extra if-block for MyPy to verify that the context is set by this point
+            if self._context is None:
+                logger.error("Failed to set context even after finding context")
+                return None
+
+            # Trigger processing and metadata parsing according to the context
+            match self._context.name:
+                case (
+                    "CLEMContext"
+                    | "FIBContext"
+                    | "SPAMetadataContext"
+                    | "SXTContext"
+                    | "TomographyMetadataContext"
                 ):
-                    try:
-                        dc_metadata = self._context.gather_metadata(
-                            self._mdoc_for_reading or transferred_file,
-                            environment=self._environment,
-                        )
-                    except KeyError as e:
-                        logger.error(
-                            f"Metadata gathering failed with a key error for key: "
-                            f"{e.args[0]}"
-                        )
-                        raise e
-                    # Set the mdoc field to None if no metadata was found
-                    if not dc_metadata:
-                        self._mdoc_for_reading = None
-
-                if not self._extension or self._unseen_xml:
-                    # Early return if no extension was found
-                    if not self._find_extension(transferred_file):
-                        logger.warning(f"No extension found for {transferred_file}")
-                        return
-                    else:
+                    logger.debug(
+                        f"File {transferred_file.name!r} transferred with context {self._context.name}"
+                    )
+                    self.post_transfer(transferred_file)
+                case "SPAContext":
+                    logger.debug(f"File {transferred_file.name!r} is part of the atlas")
+                    self.post_transfer(transferred_file)
+
+                    # Find extension
+                    if not self._extension:
+                        if not self._find_extension(transferred_file):
+                            logger.warning(f"No extension found for {transferred_file}")
+                            return None
                         logger.info(
                             f"Extension found successfully for {transferred_file}"
                         )
-
-                logger.debug(
-                    f"Transferring file {str(transferred_file)} with context {context!r}"
-                )
-                self.post_transfer(transferred_file)
-
-                if not dc_metadata and transferred_file.suffix != ".mdoc":
-                    try:
-                        dc_metadata = self._context.gather_metadata(
-                            self._mdoc_for_reading or self._xml_file(transferred_file),
-                            environment=self._environment,
-                        )
-                    except KeyError as e:
-                        logger.error(
-                            f"Metadata gathering failed with a key error for key: {e.args[0]}"
+                    if not self._processing_params_found:
+                        # Try and gather the metadata from each file passing through
+                        # Once gathered, set the attribute to True and don't repeat again
+                        try:
+                            dc_metadata = self._context.gather_metadata(
+                                self._xml_file(transferred_file),
+                                environment=self._environment,
+                            )
+                        except (KeyError, ValueError) as e:
+                            logger.error(
+                                f"Metadata gathering failed with the following error: {e}"
+                            )
+                            dc_metadata = None
+                        if dc_metadata:
+                            self._processing_params_found = True
+                            if dc_metadata.get("file_extension"):
+                                self._extension = dc_metadata["file_extension"]
+                            else:
+                                dc_metadata["file_extension"] = self._extension
+                            dc_metadata["acquisition_software"] = (
+                                self._context._acquisition_software
+                            )
+                            self.notify(dc_metadata)
+
+                case "TomographyContext":
+                    logger.debug(f"File {transferred_file.name!r} is part of the atlas")
+                    self.post_transfer(transferred_file)
+
+                    # Find extension
+                    if not self._extension:
+                        if not self._find_extension(transferred_file):
+                            logger.warning(f"No extension found for {transferred_file}")
+                            return None
+                        logger.info(
+                            f"Extension found successfully for {transferred_file}"
                         )
-                        raise e
-                if not dc_metadata or not self._force_mdoc_metadata:
-                    self._mdoc_for_reading = None
-                    self._unseen_xml.append(transferred_file)
-                if dc_metadata:
-                    self._unseen_xml = []
-                    if dc_metadata.get("file_extension"):
-                        self._extension = dc_metadata["file_extension"]
-                    else:
-                        dc_metadata["file_extension"] = self._extension
-                    dc_metadata["acquisition_software"] = (
-                        self._context._acquisition_software
-                    )
-                    self.notify(dc_metadata)
-        return
+                    if (
+                        not self._processing_params_found
+                        and transferred_file.suffix == ".mdoc"
+                    ):
+                        # Try and gather the metadata from a passing .mdoc file
+                        # When gathered, set the attribute to True and don't repeat again
+                        try:
+                            dc_metadata = self._context.gather_metadata(
+                                transferred_file,
+                                environment=self._environment,
+                            )
+                        except (KeyError, ValueError) as e:
+                            logger.error(
+                                f"Metadata gathering failed with the following error: {e}"
+                            )
+                            dc_metadata = None
+                        if dc_metadata:
+                            self._processing_params_found = True
+                            if dc_metadata.get("file_extension"):
+                                self._extension = dc_metadata["file_extension"]
+                            else:
+                                dc_metadata["file_extension"] = self._extension
+                            dc_metadata["acquisition_software"] = (
+                                self._context._acquisition_software
+                            )
+                            self.notify(dc_metadata)
+                case _:
+                    logger.warning(f"Unknown context provided: {str(self._context)}")
+        return None
 
     def _xml_file(self, data_file: Path) -> Path:
         if not self._environment: