mxcubecore 1.382.0__py3-none-any.whl → 1.383.0__py3-none-any.whl

mxcubecore/HardwareObjects/ICATLIMS.py

@@ -4,12 +4,14 @@ import shutil
 from collections import defaultdict
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import List, Optional
+from typing import TYPE_CHECKING, List, Optional
 from zoneinfo import ZoneInfo
 
 import requests
 from pyicat_plus.client.main import IcatClient
-from pyicat_plus.client.models.session import Session as ICATSession
+
+if TYPE_CHECKING:
+    from pyicat_plus.client.models.session import Session as ICATSession
 
 from mxcubecore import HardwareRepository as HWR
 from mxcubecore.BaseHardwareObjects import HardwareObject
@@ -43,6 +45,7 @@ class ICATLIMS(AbstractLims):
         self.url = self.get_property("ws_root")
         self.ingesters = self.get_property("queue_urls")
         self.investigations = []
+        self.samples = []
 
         # Initialize ICAT client
         self.icatClient = IcatClient(
@@ -62,21 +65,21 @@ class ICATLIMS(AbstractLims):
         password: str,
         session_manager: Optional[LimsSessionManager],
     ) -> LimsSessionManager:
-        logger.debug("authenticate %s" % (user_name))
+        msg = f"authenticate {user_name}"
+        logger.debug(msg)
 
         self.icat_session: ICATSession = self.icatClient.do_log_in(password)
 
         if self.icatClient is None or self.icatClient is None:
-            logger.exception(
-                "Error initializing icatClient. icatClient=%s" % (self.url)
-            )
+            msg = "Error initializing icatClient: "
+            msg += f"icatClient={self.url}"
+            logger.error(msg)
             raise RuntimeError("Could not initialize icatClient")
 
         # Connected to metadata icatClient
-        logger.debug(
-            "Connected succesfully to icatClient. fullName=%s url=%s"
-            % (self.icat_session["fullName"], self.url)
-        )
+        msg = "Connected succesfully to icatClient: "
+        msg += f"fullName={self.icat_session['fullName']}, url={self.url}"
+        logger.debug(msg)
 
         # Retrieving user's investigations
         sessions = self.to_sessions(self.__get_all_investigations())
@@ -85,7 +88,8 @@ class ICATLIMS(AbstractLims):
             msg = f"No sessions available for user {user_name}"
             raise RuntimeError(msg)
 
-        logger.debug("Successfully retrieved %s sessions" % (len(sessions)))
+        msg = f"Successfully retrieved {len(sessions)} sessions"
+        logger.debug(msg)
 
         # This is done because ICATLims can be used standalone or from ESRFLims
         if session_manager is not None:
@@ -95,39 +99,37 @@ class ICATLIMS(AbstractLims):
         # access to that session
         if self.session_manager.active_session:
             session_found = False
-
+            session_id = self.session_manager.active_session.session_id
             for session in sessions:
-                if session.session_id == self.session_manager.active_session.session_id:
+                if session.session_id == session_id:
                     session_found = True
                     break
 
             if not session_found:
-                raise RuntimeError(
-                    "Current session in-use (with id %s) not avaialble to user %s"
-                    % (self.session_manager.active_session.session_id, user_name)
-                )
+                msg = f"Current session in-use (with id {session_id}) "
+                msg += f"not avaialble for user {user_name}"
+                raise RuntimeError(msg)
+
         return self.session_manager, self.icat_session["name"], sessions
 
     def is_user_login_type(self) -> bool:
         return True
 
     def get_proposals_by_user(self, user_name):
-        logger.debug("get_proposals_by_user %s" % user_name)
+        msg = f"get_proposals_by_user {user_name}\n"
+        msg += f"[ICATCLient] Read {len(self.lims_rest.investigations)} investigations"
+        logger.debug(msg)
 
-        logger.debug(
-            "[ICATCLient] Read %s investigations" % len(self.lims_rest.investigations)
-        )
         return self.lims_rest.to_sessions(self.lims_rest.investigations)
 
-    def _get_loaded_pucks(self, parcels):
-        """
-        Retrieves all pucks from the parcels that have a defined 'sampleChangerLocation'.
-
-        A puck is considered "loaded" if it contains the key 'sampleChangerLocation'.
-        Iterates through all parcels and collects such pucks.
-
+    def _get_loaded_pucks(self, parcels) -> list:
+        """Retrieve all pucks from the parcels that have a defined
+            'sampleChangerLocation'.
+            A puck is considered "loaded" if it contains the key
+            'sampleChangerLocation'.
+            Iterates through all parcels and collects such pucks.
         Returns:
-            list: A list of pucks (dicts) that have 'sampleChangerLocation' defined.
+            A list of pucks (dicts) that have 'sampleChangerLocation' defined.
         """
         loaded_pucks = []
 
@@ -143,21 +145,20 @@ class ICATLIMS(AbstractLims):
 
         return loaded_pucks
 
-    def get_samples(self, lims_name):
-        """
-        Retrieves and processes sample information from LIMS based on the provided name.
-
-        This method:
-        - Retrieves parcel data (containers like UniPucks or SpinePucks).
-        - Retrieves sample sheet data.
-        - Identifies and processes only loaded pucks (those with a 'sampleChangerLocation').
-        - Converts each sample in the pucks into internal queue samples using `__to_sample`.
-
+    def get_samples(self, lims_name: str) -> list:
+        """Retrieve and process sample information from LIMS based on the
+            provided name:
+            - Retrieves parcel data (containers like UniPucks or SpinePucks).
+            - Retrieves sample sheet data.
+            - Identifies and processes only loaded pucks
+              (those with a 'sampleChangerLocation').
+            - Converts each sample in the pucks into internal queue samples
+              using `__to_sample`.
         Args:
-            lims_name (str): The LIMS name or identifier used to fetch sample-related data.
+            The LIMS name or identifier used to fetch sample-related data.
 
         Returns:
-            list: A list of processed sample objects ready for queuing.
+            A list of processed sample objects ready for queuing.
         """
 
         self.samples = []
@@ -181,37 +182,33 @@ class ICATLIMS(AbstractLims):
 
             # Filter for loaded pucks
             self.loaded_pucks = self._get_loaded_pucks(self.parcels)
-            logger.debug("[ICATClient] %d loaded pucks found", len(self.loaded_pucks))
+            msg = f"[ICATClient] {len(self.loaded_pucks)} loaded pucks found"
+            logger.debug(msg)
 
             # Extract and process samples from loaded pucks
             for puck in self.loaded_pucks:
                 tracking_samples = puck.get("content", [])
                 puck_name = puck.get("name", "Unnamed")
                 location = puck.get("sampleChangerLocation", "Unknown")
-
-                logger.debug(
-                    "[ICATClient] Found puck '%s' at position '%s' containing %d samples",
-                    puck_name,
-                    location,
-                    len(tracking_samples),
-                )
-
+                msg = f"[ICATClient] Found puck {puck_name} at position "
+                msg += f"{location}, containing {len(tracking_samples)} samples"
+                logger.debug(msg)
                 for tracking_sample in tracking_samples:
                     sample = self.__to_sample(tracking_sample, puck, self.sample_sheets)
                     self.samples.append(sample)
-            logger.debug("[ICATClient] Total %d samples read", len(self.samples))
-
-            return self.samples
         except RuntimeError:
             logger.exception("[ICATClient] Error retrieving samples: %s")
-
+        else:
+            msg = f"[ICATClient] Total {len(self.samples)} samples read"
+            logger.debug(msg)
+            return self.samples
         return []
 
     def get_sample_sheet_by_id(
         self, samples: List[SampleSheet], sample_id: int
     ) -> Optional[SampleSheet]:
         """
-        Retrieves a sample sheet by its unique ID.
+        Retrieve a sample sheet by its unique ID.
 
         Args:
             samples (List[SampleSheet]): A list of Sample objects.
@@ -240,22 +237,21 @@ class ICATLIMS(AbstractLims):
 
         # Enrich the processing_plan
         for item in processing_plan:
-            if item["key"] == "pipelines":
+            if item["key"] == "Advanced_processing":
                 for pipeline in item["value"]:
-                    # Match reference to filename
+                    # Update reference
                     ref = pipeline.get("reference")
                     if ref in file_path_lookup:
-                        pipeline["reference_path"] = file_path_lookup[ref]
-                    # Match search_models to groupName
-                    group = pipeline.get("search_models")
-                    if group in group_paths:
-                        pipeline["search_models_path"] = group_paths[group]
-        for item in processing_plan:
-            if item["key"] == "search_models":
-                # Match reference to filename
-                models = item.get("value")
-                for model in models:
-                    model["path"] = group_paths[model["pdb_group"]]
+                        pipeline["reference"] = {"filepath": file_path_lookup[ref]}
+
+                    # Update search_models
+                    if "search_models" in pipeline:
+                        models = json.loads(pipeline["search_models"])
+                        for model in models:
+                            group = model.get("pdb_group")
+                            if group in group_paths:
+                                model["file_paths"] = group_paths[group]
+                        pipeline["search_models"] = models
 
     def _safe_json_loads(self, json_str):
         try:
@@ -267,13 +263,12 @@ class ICATLIMS(AbstractLims):
         self, tracking_sample: dict, puck: dict, sample_sheets: List[SampleSheet]
     ) -> dict:
         """
-        Converts a tracking sample and associated metadata into the internal sample data structure.
-
-        This method:
+        Convert a tracking sample and associated metadata into the internal
+        sample data structure.
         - Extracts relevant sample metadata.
         - Resolves protein acronym from the sample sheet if available.
         - Maps experiment plan details into a diffraction plan dictionary.
-        - Assembles all relevant fields into a final structured sample dictionary.
+        - Assembles all relevant fields into a structured sample dictionary.
 
         Args:
             tracking_sample (dict): The raw sample data from tracking.
@@ -294,12 +289,10 @@ class ICATLIMS(AbstractLims):
         # identifier that points to the sample tracking
         tracking_sample_id = tracking_sample.get("_id")
 
-        logger.debug(
-            "[ICATClient] Sample ids sample_id=%s sample_sheet_id=%s tracking_sample_id=%s",
-            sample_id,
-            sample_sheet_id,
-            tracking_sample_id,
-        )
+        msg = f"[ICATClient] Sample ids sample_id={sample_id} "
+        msg += f"sample_sheet_id={sample_sheet_id} "
+        msg += f"tracking_sample_id={tracking_sample_id}"
+        logger.debug(msg)
 
         sample_location = tracking_sample.get("sampleContainerPosition")
         puck_location = str(puck.get("sampleChangerLocation", "Unknown"))
@@ -336,17 +329,18 @@ class ICATLIMS(AbstractLims):
                         destination_folder = HWR.beamline.session.get_full_path("", "")[
                             0
                         ]
-                        logger.debug(
-                            "Download restource. sample_sheet_id=%s destination_folder=%s"
-                            % (sample_sheet_id, destination_folder)
-                        )
+                        msg = "Download restource: "
+                        msg += f"sample_sheet_id={sample_sheet_id} "
+                        msg += f"destination_folder={destination_folder}"
+                        logger.debug(msg)
                         downloads = self._download_resources(
                             sample_sheet_id,
                             sample_information.resources,
                             destination_folder,
                             sample_name,
                         )
-                        logger.debug("downloaded %s resources" % len(downloads))
+                        msg = f"downloaded {len(downloads)} resources"
+                        logger.debug(msg)
                         if len(downloads) > 0:
                             try:
                                 self.__add_download_path_to_processing_plan(
@@ -362,7 +356,8 @@ class ICATLIMS(AbstractLims):
                 }
 
             except RuntimeError as e:
-                logger.warning("error getting sample information %s " % e)
+                msg = f"error getting sample information {e}"
+                logger.warning(msg)
 
         comments = tracking_sample.get("comments")
 
@@ -511,38 +506,32 @@ class ICATLIMS(AbstractLims):
         self.icatClient.reschedule_investigation(session.session_id)
 
     def get_session_by_id(self, sid: str):
-        logger.debug(
-            "get_session_by_id investigationId=%s investigations=%s",
-            sid,
-            str(len(self.investigations)),
-        )
+        msg = f"get_session_by_id investigationId={sid} "
+        msg += f"investigations={len(self.investigations)}"
+        logger.debug(msg)
+
         investigation_list = list(filter(lambda p: p["id"] == sid, self.investigations))
         if len(investigation_list) == 1:
             self.investigation = investigation_list[0]
             return self.__to_session(investigation_list[0])
-        logger.warn(
-            "No investigation found. get_session_by_id investigationId=%s investigations=%s",
-            sid,
-            str(len(self.investigations)),
-        )
+
+        logger.warning("No investigation found")
         return None
 
     def __get_all_investigations(self):
         """Returns all investigations by user. An investigation corresponds to
         one experimental session. It returns an empty array in case of error"""
+        self.investigations = []
         try:
-            self.investigations = []
-            logger.debug(
-                "__get_all_investigations before=%s after=%s beamline=%s isInstrumentScientist=%s isAdministrator=%s compatible_beamlines=%s"
-                % (
-                    self.before_offset_days,
-                    self.after_offset_days,
-                    self.override_beamline_name,
-                    self.icat_session["isInstrumentScientist"],
-                    self.icat_session["isAdministrator"],
-                    self.compatible_beamlines,
-                )
+            msg = f"__get_all_investigations before={self.before_offset_days} "
+            msg += f"after={self.after_offset_days} "
+            msg += f"beamline={self.override_beamline_name} "
+            msg += (
+                f"isInstrumentScientist={self.icat_session['isInstrumentScientist']} "
             )
+            msg += f"isAdministrator={self.icat_session['isAdministrator']} "
+            msg += f"compatible_beamlines={self.compatible_beamlines}"
+            logger.debug(msg)
 
             if self.icat_session is not None and (
                 self.icat_session["isAdministrator"]
@@ -558,7 +547,8 @@ class ICATLIMS(AbstractLims):
                 )
             elif self.only_staff_session_selection:
                 if self.session_manager.active_session is None:
-                    # If no session selected and only staff is allowed then print warning an return no investigations
+                    # print warning an return no investigations
+                    # if no session selected and only staff is allowed
                     logger.warning(
                         "No session selected. Only staff can select a session"
                     )
@@ -576,14 +566,14 @@ class ICATLIMS(AbstractLims):
                     end_date=datetime.today()
                     + timedelta(days=float(self.after_offset_days)),
                 )
-            logger.debug(
-                "__get_all_investigations retrieved %s investigations"
-                % len(self.investigations)
-            )
-            return self.investigations
         except Exception:
             self.investigations = []
             logger.exception("Failed on __get_all_investigations")
+        else:
+            msg = "__get_all_investigations retrieved "
+            msg += f"{len(self.investigations)} investigations"
+            logger.debug(msg)
+
         return self.investigations
 
     def __get_proposal_number_by_investigation(self, investigation):
@@ -690,9 +680,7 @@ class ICATLIMS(AbstractLims):
             data_portal_URL=self._get_data_portal_url(investigation),
             user_portal_URL=self._get_user_portal_url(investigation),
             logbook_URL=self._get_logbook_url(investigation),
-            is_rescheduled=(
-                True if "__actualEndDate" in investigation["parameters"] else False
-            ),
+            is_rescheduled=bool("__actualEndDate" in investigation["parameters"]),
             volume=self.__get_investigation_parameter_by_name(
                 investigation, "__volume"
             ),
@@ -716,34 +704,35 @@ class ICATLIMS(AbstractLims):
     def get_parcels(self):
         """Returns the parcels associated to an investigation"""
         try:
-            logger.debug(
-                "Retrieving parcels by investigation_id %s "
-                % (self.session_manager.active_session.session_id)
-            )
-            parcels = self.icatClient.get_parcels_by(
-                self.session_manager.active_session.session_id
-            )
-            logger.debug("Successfully retrieved %s parcels" % (len(parcels)))
-            return parcels
+            session_id = self.session_manager.active_session.session_id
+            msg = f"Retrieving parcels by investigation_id {session_id}"
+            logger.debug(msg)
+            parcels = self.icatClient.get_parcels_by(session_id)
         except Exception:
             logger.exception("Failed on get_parcels_by_investigation_id")
+        else:
+            msg = f"Successfully retrieved {len(parcels)} parcels"
+            logger.debug(msg)
+            return parcels
+
         return []
 
     def get_samples_sheets(self) -> List[SampleSheet]:
         """Returns the samples sheets associated to an investigation"""
         try:
-            logger.debug(
-                "Retrieving samples by investigation_id %s "
-                % (self.session_manager.active_session.session_id)
-            )
+            msg = "Retrieving samples by investigation_id "
+            msg += f"{self.session_manager.active_session.session_id}"
+            logger.debug(msg)
             samples = self.icatClient.get_samples_by(
                 self.session_manager.active_session.session_id
             )
-            logger.debug("Successfully retrieved %s samples" % (len(samples)))
-            # Convert to object
-            return [SampleSheet.parse_obj(sample) for sample in samples]
         except Exception:
             logger.exception("Failed on get_samples_by_investigation_id")
+        else:
+            msg = f"Successfully retrieved {len(samples)} samples"
+            logger.debug(msg)
+            # Convert to object
+            return [SampleSheet.parse_obj(sample) for sample in samples]
         return []
 
     def echo(self):
@@ -786,9 +775,9 @@ class ICATLIMS(AbstractLims):
             None,
         )
 
-    def _get_sample_position(self):
-        """
-        Returns the position of the puck in the samples changer and the position f the sample within the puck
+    def _get_sample_position(self) -> tuple:
+        """Return the position of the puck in the samples changer
+        and the position of the sample within the puck,
         """
         try:
             queue_entry = HWR.beamline.queue_manager.get_current_entry()
@@ -802,14 +791,11 @@ class ICATLIMS(AbstractLims):
                 (puck, sample_position) = location
 
             position = None
-            try:
-                if cell is not None and puck is not None:
-                    position = int(cell * 3) + int(puck)
-            except Exception:
-                logger.exception()
-            return position, sample_position
+            if None not in (cell, puck):
+                position = int(cell * 3) + int(puck)
         except Exception:
-            logger.exception()
+            logger.exception("Cannot retrieve sample position")
+        return position, sample_position
 
     def store_beamline_setup(self, session_id: str, bl_config_dict: dict):
         pass
@@ -817,12 +803,76 @@ class ICATLIMS(AbstractLims):
     def store_image(self, image_dict: dict):
         pass
 
-    def store_energy_scan(self, energyscan_dict: dict):
-        pass
+    def store_common_data(self, datacollection_dict: dict) -> dict:
+        """Fill in a dictionary with the common for all the
+           data collection tecjniques meta data.
+        Args:
+            datacollection_dict(dict): dictionarry from the data collection.
+        """
+        sample_id = datacollection_dict.get("blSampleId")
+        msg = f"SampleId is: {sample_id}"
+        logging.getLogger("HWR").debug(msg)
+        try:
+            sample = HWR.beamline.lims.find_sample_by_sample_id(sample_id)
+            sample_name = sample.get("sampleName")
+        except (AttributeError, TypeError):
+            sample_name = "unknown"
+            msg = f"Sample {sample_id} not found"
+            logging.getLogger("HWR").debug(msg)
+
+        start_time = datacollection_dict.get("startTime", "")
+        end_time = datacollection_dict.get("endTime", "")
 
-    def store_xfe_spectrum(self, collection_parameters: dict):
-        status = {"xfeFluorescenceSpectrumId": -1}
         try:
+            dt_aware = datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S").replace(
+                tzinfo=ZoneInfo("Europe/Paris")
+            )
+            dt_aware_end = datetime.strptime(end_time, "%Y-%m-%d %H:%M:%S").replace(
+                tzinfo=ZoneInfo("Europe/Paris")
+            )
+
+            start_time = dt_aware.isoformat(timespec="microseconds")
+            end_time = dt_aware_end.isoformat(timespec="microseconds")
+        except TypeError:
+            logging.getLogger("HWR").exception("Cannot parse start and end time")
+        bsx, bsy, shape, _ = HWR.beamline.beam.get_value()
+        flux_end = datacollection_dict.get("flux_end") or HWR.beamline.flux.get_value()
+
+        transmission = (
+            datacollection_dict.get("transmission")
+            or HWR.beamline.transmission.get_value()
+        )
+
+        energy = datacollection_dict.get("energy") or HWR.beamline.energy.get_value()
+        wavelength = (
+            datacollection_dict.get("wavelength")
+            or HWR.beamline.energy.get_wavelength()
+        )
+
+        machine_info = HWR.beamline.machine_info.get_value()
+
+        return {
+            "sampleId": sample_id,
+            "Sample_name": sample_name,
+            "startDate": start_time,
+            "endDate": end_time,
+            "MX_beamShape": shape.value,
+            "MX_beamSizeAtSampleX": bsx,
+            "MX_beamSizeAtSampleY": bsy,
+            "MX_xBeam": bsx,
+            "MX_yBeam": bsy,
+            "MX_flux": datacollection_dict.get("flux"),
+            "MX_fluxEnd": flux_end,
+            "MX_transmission": transmission,
+            "InstrumentMonochromator_wavelength": wavelength,
+            "InstrumentMonochromator_energy": energy,
+            "InstrumentSource_current": machine_info.get("current"),
+            "InstrumentSource_mode": machine_info.get("fill_mode"),
+        }
+
+    def store_energy_scan(self, energyscan_dict: dict):
+        try:
+            metadata = self.store_common_data(energyscan_dict)
             try:
                 beamline = self._get_scheduled_beamline()
                 msg = f"Dataset Beamline={beamline} "
@@ -835,49 +885,68 @@ class ICATLIMS(AbstractLims):
             _session = HWR.beamline.session
             proposal = f"{_session.proposal_code}{_session.proposal_number}"
 
-            try:
-                dt_aware = datetime.strptime(
-                    collection_parameters.get("startTime"),
-                    "%Y-%m-%d %H:%M:%S",
-                ).replace(tzinfo=ZoneInfo("Europe/Paris"))
-                dt_aware_end = datetime.strptime(
-                    collection_parameters.get("endTime"),
-                    "%Y-%m-%d %H:%M:%S",
-                ).replace(tzinfo=ZoneInfo("Europe/Paris"))
-
-                start_time = dt_aware.isoformat(timespec="microseconds")
-                end_time = dt_aware_end.isoformat(timespec="microseconds")
-            except TypeError:
-                logging.getLogger("HWR").exception("Failed to parse start and end time")
+            directory = Path(energyscan_dict["scanFileFullPath"]).parent
+
+            metadata.update(
+                {
+                    "scanType": "energy_scan",
+                    "MX_directory": str(directory),
+                    "MX_exposureTime": energyscan_dict.get("exposureTime"),
+                    "InstrumentDetector01_model": energyscan_dict.get(
+                        "fluorescenceDetector"
+                    ),
+                    "MX_element": energyscan_dict.get("element"),
+                    "MX_edgeEnergy": energyscan_dict.get("edgeEnergy"),
+                    "MX_startEnergy": energyscan_dict.get("startEnergy"),
+                    "MX_endEnergy": energyscan_dict.get("endEnergy"),
+                    "MX_peakEnergy": energyscan_dict.get("endEnergy"),
+                    "MX_inflectioEnergy": energyscan_dict.get("inflectioEnergy"),
+                    "MX_remoteEnergy": energyscan_dict.get("remoteEnergy"),
+                    "MX_peakFPrime": energyscan_dict.get("peakFPrime"),
+                    "MX_peakFDoublePrime": energyscan_dict.get("peakFDoublePrime"),
+                    "MX_inflectionFPrime": energyscan_dict.get("inflectionFPrime"),
+                    "MX_inflectionFDoublePrime": energyscan_dict.get(
+                        "inflectionFDoublePrime"
+                    ),
+                    "MX_comments": energyscan_dict.get("comments"),
+                }
+            )
 
-            directory = Path(collection_parameters["filename"]).parent
+            self.icatClient.store_dataset(
+                beamline=beamline,
+                proposal=proposal,
+                dataset=str(directory.name),
+                path=str(directory),
+                metadata=metadata,
+            )
+        except Exception:
+            logging.getLogger("ispyb_client").exception()
 
-            msg = f"SampleId is: {collection_parameters.get('blSampleId')}"
-            logging.getLogger("HWR").debug(msg)
+    def store_xfe_spectrum(self, xfespectrum_dict: dict):
+        status = {"xfeFluorescenceSpectrumId": -1}
+        try:
+            metadata = self.store_common_data(xfespectrum_dict)
             try:
-                sample = HWR.beamline.lims.find_sample_by_sample_id(
-                    collection_parameters.get("blSampleId")
+                beamline = self._get_scheduled_beamline()
+                msg = f"Dataset Beamline={beamline} "
+                msg += f"Current Beamline={HWR.beamline.session.beamline_name}"
+                logging.getLogger("HWR").info(msg)
+            except Exception:
+                logging.getLogger("HWR").exception(
+                    "Failed to get _get_scheduled_beamline",
                 )
-                sample_name = sample["sampleName"]
-            except (AttributeError, TypeError):
-                sample_name = "unknown"
-                msg = f"Sample not found {collection_parameters.get('blSampleId')}"
-                logging.getLogger("HWR").debug(msg)
-
-            metadata = {
-                "sampleId": collection_parameters.get("blSampleId"),
-                "MX_beamSizeAtSampleX": collection_parameters.get("beamSizeHorizontal"),
-                "MX_beamSizeAtSampleY": collection_parameters.get("beamSizeVertical"),
-                "MX_directory": str(directory),
-                "MX_exposureTime": collection_parameters.get("exposureTime"),
-                "MX_flux": collection_parameters.get("flux"),
-                "scanType": "xrf",
-                "MX_transmission": collection_parameters.get("beamTransmission"),
-                "Sample_name": sample_name,
-                "InstrumentMonochromator_energy": collection_parameters.get("energy"),
-                "startDate": start_time,
-                "endDate": end_time,
-            }
+            _session = HWR.beamline.session
+            proposal = f"{_session.proposal_code}{_session.proposal_number}"
+
+            directory = Path(xfespectrum_dict["filename"]).parent
+
+            metadata.update(
+                {
+                    "scanType": "xrf",
+                    "MX_directory": str(directory),
+                    "MX_exposureTime": xfespectrum_dict.get("exposureTime"),
+                }
+            )
 
             self.icatClient.store_dataset(
                 beamline=beamline,
@@ -894,12 +963,14 @@ class ICATLIMS(AbstractLims):
     def store_workflow(self, workflow_dict: dict):
         pass
 
-    def store_data_collection(self, mx_collection, bl_config=None):
-        # stores the dictionary with the information about the beamline to be sent when a dataset is produced
-        self.beamline_config = bl_config
+    def store_data_collection(self, datacollection_dict, beamline_config_dict=None):
+        """Store the dictionary with the information about the beamline
+        to be sent when a dataset is produced.
+        """
+        self.beamline_config = beamline_config_dict
 
-    def update_data_collection(self, mx_collection):
-        pass
+    def update_data_collection(self, datacollection_dict: dict):
+        """Update data collection."""
 
     def _get_oscillation_end(self, oscillation_sequence):
         return float(oscillation_sequence["start"]) + (
@@ -950,14 +1021,15 @@ class ICATLIMS(AbstractLims):
         self, sample_id, resources, output_folder: str, sample_name: str
     ) -> List[Download]:
         """
-        Downloads resources related to a given sample and saves them to the specified directory.
+        Download resources related to a given sample and save them to the
+        specified directory.
 
-        Parameters:
-            sample (str): Sample identifier.
+        Argss:
+            sample_id (str): Sample identifier.
             output_folder (str): Directory where storefiles will be saved.
 
         Returns:
-            dict: A dictionary containing the paths of the downloaded files.
+            List containing the paths of the downloaded files.
         """
         downloaded_files: List[Download] = []
         for resource in resources:
@@ -968,7 +1040,7 @@ class ICATLIMS(AbstractLims):
             resource_folder.mkdir(
                 parents=True,
                 exist_ok=True,
-            )  # Ensure the folder exists
+            )  # Make sure the folder exists
 
             try:
                 token = self.icat_session["sessionId"]
@@ -997,106 +1069,92 @@ class ICATLIMS(AbstractLims):
 
         return downloaded_files
 
-    def finalize_data_collection(self, collection_parameters):
+    def finalize_data_collection(self, datacollection_dict):
         logger.info("Storing datacollection in ICAT")
 
+        metadata = self.store_common_data(datacollection_dict)
+
         try:
-            fileinfo = collection_parameters["fileinfo"]
+            fileinfo = datacollection_dict["fileinfo"]
             directory = Path(fileinfo["directory"])
             dataset_name = directory.name
             # Determine the scan type
-            if dataset_name.endswith("mesh"):
-                scan_type = "mesh"
-            elif dataset_name.endswith("line"):
-                scan_type = "line"
-            elif dataset_name.endswith("characterisation"):
-                scan_type = "characterisation"
-            elif dataset_name.endswith("datacollection"):
-                scan_type = "datacollection"
-            else:
-                scan_type = collection_parameters["experiment_type"]
+            scan_types = ["mesh", "line", "characterisation", "datacollection"]
+            scan_type = datacollection_dict["experiment_type"]
+            for nam in scan_types:
+                if dataset_name.endswith(nam):
+                    scan_type = nam
 
-            workflow_params = collection_parameters.get("workflow_parameters", {})
+            workflow_params = datacollection_dict.get("workflow_parameters", {})
             workflow_type = workflow_params.get("workflow_type")
 
-            if workflow_type is None:
-                if not directory.name.startswith("run"):
-                    dataset_name = fileinfo["prefix"]
-
-            try:
-                dt_aware = datetime.strptime(
-                    collection_parameters.get("collection_start_time"),
-                    "%Y-%m-%d %H:%M:%S",
-                ).replace(tzinfo=ZoneInfo("Europe/Paris"))
-                start_time = dt_aware.isoformat(timespec="microseconds")
-                end_time = datetime.now(ZoneInfo("Europe/Paris")).isoformat()
-            except RuntimeError:
-                logger.warning("Failed to parse start and end time")
+            if workflow_type is None and not directory.name.startswith("run"):
+                dataset_name = fileinfo["prefix"]
 
-            if collection_parameters["sample_reference"]["acronym"]:
+            if datacollection_dict["sample_reference"]["acronym"]:
                 sample_name = (
-                    collection_parameters["sample_reference"]["acronym"]
+                    datacollection_dict["sample_reference"]["acronym"]
                     + "-"
-                    + collection_parameters["sample_reference"]["sample_name"]
+                    + datacollection_dict["sample_reference"]["sample_name"]
                 )
             else:
-                sample_name = collection_parameters["sample_reference"][
+                sample_name = datacollection_dict["sample_reference"][
                     "sample_name"
                 ].replace(":", "-")
 
             logger.info(f"LIMS sample name {sample_name}")
-            oscillation_sequence = collection_parameters["oscillation_sequence"][0]
+            oscillation_sequence = datacollection_dict["oscillation_sequence"][0]
 
             beamline = HWR.beamline.session.beamline_name.lower()
             distance = HWR.beamline.detector.distance.get_value()
-            proposal = f"{HWR.beamline.session.proposal_code}{HWR.beamline.session.proposal_number}"
-            metadata = {
-                "MX_beamShape": collection_parameters.get("beamShape"),
-                "sampleId": collection_parameters.get("blSampleId"),
-                "MX_beamSizeAtSampleX": collection_parameters.get("beamSizeAtSampleX"),
-                "MX_beamSizeAtSampleY": collection_parameters.get("beamSizeAtSampleY"),
-                "MX_dataCollectionId": collection_parameters.get("collection_id"),
-                "MX_detectorDistance": distance,
-                "MX_directory": str(directory),
-                "MX_exposureTime": oscillation_sequence["exposure_time"],
-                "MX_flux": collection_parameters.get("flux"),
-                "MX_fluxEnd": collection_parameters.get("flux_end"),
-                "MX_positionName": collection_parameters.get("position_name"),
-                "MX_numberOfImages": oscillation_sequence["number_of_images"],
-                "MX_oscillationRange": oscillation_sequence["range"],
-                "MX_axis_start": oscillation_sequence["start"],
-                "MX_oscillationOverlap": oscillation_sequence["overlap"],
-                "MX_resolution": collection_parameters.get("resolution"),
-                "MX_resolution_at_corner": collection_parameters.get(
-                    "resolutionAtCorner"
-                ),
-                "scanType": scan_type,
-                "MX_startImageNumber": oscillation_sequence["start_image_number"],
-                "MX_template": fileinfo["template"],
-                "MX_transmission": collection_parameters.get("transmission"),
-                "MX_xBeam": collection_parameters.get("xBeam"),
-                "MX_yBeam": collection_parameters.get("yBeam"),
-                "Sample_name": sample_name,
-                "InstrumentMonochromator_wavelength": collection_parameters.get(
-                    "wavelength"
-                ),
-                "InstrumentMonochromator_energy": collection_parameters.get("energy"),
-                "Workflow_name": workflow_params.get("workflow_name"),
-                "Workflow_type": workflow_params.get("workflow_type"),
-                "Workflow_id": workflow_params.get("workflow_uid"),
-                "MX_kappa_settings_id": workflow_params.get(
-                    "workflow_kappa_settings_id"
-                ),
-                "MX_characterisation_id": workflow_params.get(
-                    "workflow_characterisation_id"
-                ),
-                "MX_position_id": workflow_params.get("workflow_position_id"),
-                "group_by": workflow_params.get("workflow_group_by"),
-                "startDate": start_time,
-                "endDate": end_time,  # strftime("%Y-%m-%d %H:%M:%S"),
-            }
+            proposal = f"{HWR.beamline.session.proposal_code}"
+            proposal += f"{HWR.beamline.session.proposal_number}"
+
+            try:
+                dt_aware = datetime.strptime(
+                    datacollection_dict.get("collection_start_time"),
+                    "%Y-%m-%d %H:%M:%S",
+                ).replace(tzinfo=ZoneInfo("Europe/Paris"))
+                start_time = dt_aware.isoformat(timespec="microseconds")
+            except RuntimeError:
+                logger.warning("Failed to parse start and end time")
+
+            metadata.update(
+                {
+                    "MX_dataCollectionId": datacollection_dict.get("collection_id"),
+                    "MX_detectorDistance": distance,
+                    "MX_directory": str(directory),
+                    "MX_exposureTime": oscillation_sequence["exposure_time"],
+                    "MX_positionName": datacollection_dict.get("position_name"),
+                    "MX_numberOfImages": oscillation_sequence["number_of_images"],
+                    "MX_oscillationRange": oscillation_sequence["range"],
+                    "MX_axis_start": oscillation_sequence["start"],
+                    "MX_oscillationOverlap": oscillation_sequence["overlap"],
+                    "MX_resolution": datacollection_dict.get("resolution"),
+                    "MX_resolution_at_corner": datacollection_dict.get(
+                        "resolutionAtCorner"
+                    ),
+                    "scanType": scan_type,
+                    "MX_startImageNumber": oscillation_sequence["start_image_number"],
+                    "MX_template": fileinfo["template"],
+                    "Sample_name": sample_name,
+                    "Workflow_name": workflow_params.get("workflow_name"),
+                    "Workflow_type": workflow_params.get("workflow_type"),
+                    "Workflow_id": workflow_params.get("workflow_uid"),
+                    "MX_kappa_settings_id": workflow_params.get(
+                        "workflow_kappa_settings_id"
+                    ),
+                    "MX_characterisation_id": workflow_params.get(
+                        "workflow_characterisation_id"
+                    ),
+                    "MX_position_id": workflow_params.get("workflow_position_id"),
+                    "group_by": workflow_params.get("workflow_group_by"),
+                    "startDate": start_time,
+                }
+            )
 
-            # This forces the ingester to associate the dataset to the experiment by ID
+            # This forces the ingester to associate the dataset
+            # to the experiment by ID
             if self.session_manager.active_session.session_id:
                 metadata["investigationId"] = (
                     self.session_manager.active_session.session_id
@@ -1109,7 +1167,7 @@ class ICATLIMS(AbstractLims):
             metadata["SampleTrackingContainer_position"] = sample_position
             # Find sample by sampleId
             sample = HWR.beamline.lims.find_sample_by_sample_id(
-                collection_parameters.get("blSampleId")
+                datacollection_dict.get("blSampleId")
             )
 
             try:
@@ -1117,22 +1175,13 @@ class ICATLIMS(AbstractLims):
             except Exception:
                 logger.exception("Failed to read get_active_lims.")
 
-            try:
-                metadata["InstrumentSource_current"] = (
-                    HWR.beamline.machine_info.get_value().get("current")
-                )
-                metadata["InstrumentSource_mode"] = (
-                    HWR.beamline.machine_info.get_value().get("fill_mode")
-                )
-            except Exception as e:
-                logger.warning("Failed to read machine_info metadata.%s", e)
-
             try:
                 if sample is not None:
                     metadata["SampleProtein_acronym"] = sample.get("proteinAcronym")
                     metadata["SampleTrackingContainer_id"] = sample.get(
                         "containerCode"
-                    )  # containerCode instead of sampletrackingcontainer_id for ISPyB's compatiblity
+                    )  # containerCode instead of sampletrackingcontainer_id
+                    # for ISPyB's compatiblity
                     metadata["SampleTrackingParcel_id"] = sample.get(
                         "SampleTrackingParcel_id"
                     )
@@ -1164,7 +1213,7 @@ class ICATLIMS(AbstractLims):
                 logger.warning("Failed to get MX_axis_end")
 
             icat_metadata_path = Path(directory) / "metadata.json"
-            with open(icat_metadata_path, "w") as f:
+            with Path(icat_metadata_path).open("w") as f:
                 # We add the processing and experiment plan only in the metadata.json
                 # it will not work thought pyicat-plus
                 merged = metadata.copy()
@@ -1183,25 +1232,26 @@ class ICATLIMS(AbstractLims):
                 gallery_path.mkdir(mode=0o755, exist_ok=True)
                 for snapshot_index in range(1, 5):
                     key = f"xtalSnapshotFullPath{snapshot_index}"
-                    if key in collection_parameters:
-                        snapshot_path = Path(collection_parameters[key])
+                    if key in datacollection_dict:
+                        snapshot_path = Path(datacollection_dict[key])
                         if snapshot_path.exists():
-                            logger.debug(
-                                f"Copying snapshot index {snapshot_index} to gallery"
-                            )
+                            msg = f"Copying snapshot index {snapshot_index} to gallery"
+                            logger.debug(msg)
                             shutil.copy(snapshot_path, gallery_path)
             except RuntimeError as e:
                 logger.warning("Failed to create gallery. %s", e)
 
             try:
                 beamline = self._get_scheduled_beamline()
-                logger.info(
-                    f"Dataset Beamline={beamline} Current Beamline={HWR.beamline.session.beamline_name}"
-                )
-            except RuntimeError as e:
-                logger.warning("Failed to get _get_scheduled_beamline. %s", e)
+                msg = f"Dataset Beamline={beamline} "
+                msg += f"Current Beamline={HWR.beamline.session.beamline_name}"
+                logger.info(msg)
+            except RuntimeError as err:
+                msg = f"Failed to get _get_scheduled_beamline {err}"
+                logger.warning(msg)
 
-            # __actualInstrument is a dataset parameter that indicates where the dataset has been actually collected
+            # __actualInstrument is a dataset parameter that indicates
+            # where the dataset has been actually collected
             # only filled when it does not match the scheduled beamline
             try:
                 if (
@@ -1223,10 +1273,10 @@ class ICATLIMS(AbstractLims):
         except Exception as e:
             logger.warning("Failed uploading to ICAT. %s", e)
 
-    def _get_scheduled_beamline(self):
-        """
-        This returns the beamline where the session has been scheduled (in case of a different beamline)
-        otherwise it returns the name of the beamline as set in the properties
+    def _get_scheduled_beamline(self) -> str:
+        """Return the name of the beamline as set in the properties or the
+        name of the beamline where the session has been scheduled
+        (in case of a different beamline)
         """
         active_session = self.session_manager.active_session
 
@@ -1234,7 +1284,8 @@ class ICATLIMS(AbstractLims):
             return HWR.beamline.session.beamline_name.lower()
 
         beamline = str(active_session.beamline_name.lower())
-        logger.info(f"Session have been moved to another beamline: {beamline}")
+        msg = f"Session have been moved to another beamline: {beamline}"
+        logger.info(msg)
         return beamline
 
     def update_bl_sample(self, bl_sample: str):