mxcubecore 1.329.0__tar.gz → 1.330.0__tar.gz

{mxcubecore-1.329.0 → mxcubecore-1.330.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mxcubecore
-Version: 1.329.0
+Version: 1.330.0
 Summary: Core libraries for the MXCuBE application
 License: LGPL-3.0-or-later
 Keywords: mxcube,mxcube3,mxcubecore

{mxcubecore-1.329.0 → mxcubecore-1.330.0}/mxcubecore/HardwareObjects/ESRF/ESRFXRFSpectrum.py

@@ -38,12 +38,13 @@ __copyright__ = """ Copyright © by the MXCuBE collaboration """
 __license__ = "LGPLv3+"
 
 import logging
-import os.path
 from ast import literal_eval
+from pathlib import Path
+from shutil import copy2
 from unittest.mock import MagicMock
 from warnings import warn
 
-import numpy
+import numpy as np
 from PyMca5.PyMca import (
     ClassMcaTheory,
     ConfigDict,
@@ -62,7 +63,7 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
     def __init__(self, name):
         super().__init__(name)
         self.cfgfile = None
-        self.config_fit = None
+        self.config = None
         self.ctrl_hwobj = None
         self.mcafit = None
         self.default_erange = None
@@ -73,15 +74,16 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
         super().init()
         self.ctrl_hwobj = self.get_object_by_role("controller")
         self.cfgfile = self.get_property(
-            "cfgfile", "/users/blissadm/local/beamline_configuration/misc/15keV.cfg"
+            "cfgfile",
+            "/users/blissadm/local/beamline_configuration/misc/15keV.cfg",
         )
-        self.config_fit = ConfigDict.ConfigDict()
+        self.config = ConfigDict.ConfigDict()
         self.mcafit = ClassMcaTheory.McaTheory(self.cfgfile)
         self.default_erange = literal_eval(
-            self.get_property("default_energy_range", "[2.0, 15.0]")
+            self.get_property("default_energy_range", "[2.0, 15.0]"),
         )
         self.cfg_energies = literal_eval(
-            self.get_property("cfg_energies", "[7, 9, 12, 15]")
+            self.get_property("cfg_energies", "[7, 9, 12, 15]"),
         )
 
     def _doSpectrum(self, ctime, filename):
@@ -92,14 +94,18 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
         )
         return self._execute_spectrum(ctime, filename)
 
-    def _execute_spectrum(self, integration_time=None, filename=None):
+    def _execute_spectrum(
+        self,
+        integration_time: float | None = None,
+        filename: str | None = None,
+    ) -> bool:
         """Local XRF spectrum sequence.
 
         Args:
-            integration_time (float): MCA integration time [s].
-            filename (str): Data file (full path).
+            integration_time: MCA integration time [s].
+            filename: Data file (full path).
         Returns:
-            (bool): Procedure executed correctly (True) or error (False)
+            Procedure executed correctly (True) or error (False)
         """
         filename = filename or self.spectrum_info_dict["filename"]
         integration_time = integration_time or self.default_integration_time
@@ -124,13 +130,13 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
 
     # Next methods are for fitting the data with pymca
 
-    def mcafit_configuration(self, config=None):
+    def mcafit_configuration(self, config: dict | None = None):
         """Configure the fitting parameters. The procedure is time consuming.
            It is only executed if the last configuration file is not the same.
 
         Args:
-            config(dict): Configuration dictionary, containing among others the
-                          configuration file name.
+            config: Configuration dictionary, containing among others the
+                    configuration file name.
         """
         change = False
         if not config or "file" not in config:
@@ -141,33 +147,36 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
         if self.cfgfile != cfgfile:
             self.cfgfile = cfgfile
             change = True
-        self.config_fit.read(self.cfgfile)
-        if "concentrations" not in self.config_fit:
-            self.config_fit["concentrations"] = {}
+        self.config.read(self.cfgfile)
+        if "concentrations" not in self.config:
+            self.config["concentrations"] = {}
             change = True
-        if "attenuators" not in self.config_fit:
-            self.config_fit["attenuators"] = {
-                "Matrix": [1, "Water", 1.0, 0.01, 45.0, 45.0]
-            }
+        if "attenuators" not in self.config:
+            self.config["attenuators"] = {"Matrix": [1, "Water", 1.0, 0.01, 45.0, 45.0]}
             change = True
         if "flux" in config:
-            self.config_fit["concentrations"]["flux"] = float(config["flux"])
+            self.config["concentrations"]["flux"] = float(config["flux"])
             change = True
         if "time" in config:
-            self.config_fit["concentrations"]["time"] = float(config["time"])
+            self.config["concentrations"]["time"] = float(config["time"])
             change = True
 
         if change:
-            self.mcafit.configure(self.config_fit)
-
-    def spectrum_analyse(self, data=None, calib=None, config=None):
+            self.mcafit.configure(self.config)
+
+    def spectrum_analyse(
+        self,
+        data: list | None = None,
+        calib: list | None = None,
+        config: dict | None = None,
+    ) -> bool:
         """Execute the fitting. Write the fitted data files to the archive
         directory.
 
         Args:
-            data (list): The raw data.
-            calib (list): The mca calibration.
-            config (dict): The configuration dictionary.
+            data: The raw data.
+            calib: The mca calibration.
+            config: The configuration dictionary.
         """
 
         if not config:
@@ -177,9 +186,9 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
                 "bsX": self.spectrum_info_dict["beamSizeHorizontal"],
                 "bsY": self.spectrum_info_dict["beamSizeVertical"],
                 "legend": self.spectrum_info_dict["annotatedPymcaXfeSpectrum"],
-                "htmldir": os.path.split(
-                    self.spectrum_info_dict["annotatedPymcaXfeSpectrum"]
-                )[0],
+                "htmldir": Path(
+                    self.spectrum_info_dict["annotatedPymcaXfeSpectrum"],
+                ).parent,
             }
 
         self.mcafit_configuration(config)
@@ -191,15 +200,15 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
 
         try:
             if data[0].size == 2:
-                xdata = numpy.array(data[:, 0]) * 1.0
-                ydata = numpy.array(data[:, 1])
+                xdata = np.array(data[:, 0]) * 1.0
+                ydata = np.array(data[:, 1])
             else:
                 xdata = data[0] * 1.0
                 ydata = data[1]
 
             try:
-                xmin = self.config_fit["fit"]["xmin"]
-                xmax = self.config_fit["fit"]["xmax"]
+                xmin = self.config["fit"]["xmin"]
+                xmax = self.config["fit"]["xmax"]
             except KeyError:
                 xmin = data[0][0]
                 xmax = data[0][-1]
@@ -211,19 +220,26 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
             if fitresult:
                 fitresult = {"fitresult": fitresult[0], "result": fitresult[1]}
 
-                # write the csv file to pyarch
+                # create the gallery directory
+                new_dir = Path(self.spectrum_info_dict["filename"]).parent / "gallery"
+                if not self.create_directory(new_dir):
+                    self.update_state(self.STATES.FAULT)
+                    return False
+
+                # write the csv file to pyarch and gallery
                 csvname = self.spectrum_info_dict["fittedDataFileFullPath"]
                 self._write_csv_file(fitresult["result"], csvname)
+                copy2(csvname, new_dir / Path(csvname).name)
 
                 # write html report to pyarch
-                fname = os.path.basename(self.spectrum_info_dict["filename"])
+                fname = Path(self.spectrum_info_dict["filename"]).name
                 outfile = fname.split(".")[0]
-                outdir = os.path.dirname(
-                    self.spectrum_info_dict["annotatedPymcaXfeSpectrum"]
-                )
+                outdir = Path(
+                    self.spectrum_info_dict["annotatedPymcaXfeSpectrum"],
+                ).parent
 
                 _kw = {
-                    "outdir": outdir,
+                    "outdir": str(outdir),
                     "outfile": outfile,
                     "fitresult": fitresult,
                     "plotdict": {"logy": False},
@@ -232,6 +248,13 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
                 report = QtMcaAdvancedFitReport.QtMcaAdvancedFitReport(**_kw)
                 text = report.getText()
                 report.writeReport(text=text)
+
+                # copy png file to galery
+                copy2(
+                    self.spectrum_info_dict["jpegScanFileFullPath"],
+                    new_dir,
+                )
+
                 return True
             return False
         except Exception as exp:
@@ -241,17 +264,17 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
             self.spectrum_command_failed()
             return False
 
-    def _write_csv_file(self, fitresult, fname=None):
+    def _write_csv_file(self, fitresult: dict, fname: str | None = None):
         """Write fitted data to a csv file.
 
         Args:
-            fitresult(dict): Data as dictionary.
+            fitresult: Data as dictionary.
         Kwargs:
-            fname (str): Filename to write to (full path).
+            fname: Filename to write to (full path).
         """
         fname = fname or self.spectrum_info_dict["fittedDataFileFullPath"]
-        if os.path.exists(fname):
-            os.remove(fname)
+        if Path(fname).exists():
+            Path(fname).unlink()
 
         # get the significant peaks
         peaks_dict = {}
@@ -283,7 +306,7 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
             header += delimiter + f'"{key}"'
 
         # logging.getLogger("user_level_log").info("Writing %s" % fname)
-        with open(fname, "w") as csv_fd:
+        with Path(fname).open("w") as csv_fd:
             csv_fd.write(header)
             csv_fd.write("\n")
             for i in range(fitresult["xdata"].size):
@@ -301,23 +324,21 @@ class ESRFXRFSpectrum(AbstractXRFSpectrum):
                         fitresult["continuum"][i],
                         delimiter,
                         fitresult["pileup"][i],
-                    )
+                    ),
                 )
                 for val in peaks_dict.values():
                     csv_fd.write(f"{delimiter}{val[i]:.7g}")
 
                 csv_fd.write("\n")
 
-    def _get_cfgfile(self, energy):
+    def _get_cfgfile(self, energy: float) -> str:
         """Get the correct configuration file.
 
         Args:
             energy(float): The energy to choose which configuration file.
         """
         self.cfg_energies.sort()
-
-        cfg_path = os.path.split(self.cfgfile)[0]
         for egy in self.cfg_energies:
             if egy > energy:
-                return os.path.join(cfg_path, f"{str(egy)}keV.cfg")
-        return self.cfgfile
+                return str(Path(self.cfgfile).parent / f"{egy}keV.cfg")
+        return str(self.cfgfile)

{mxcubecore-1.329.0 → mxcubecore-1.330.0}/mxcubecore/HardwareObjects/ESRFLIMS.py

@@ -24,7 +24,7 @@ class ESRFLIMS(AbstractLims):
         self.ispyb = self.get_object_by_role("ispyb")
 
         self.is_local_host = False
-        self.active_lims = self.drac.get_lims_name()
+        self.active_lims = self.drac.get_lims_name()[0]
 
     def get_lims_name(self) -> List[Lims]:
         return self.drac.get_lims_name() + self.ispyb.get_lims_name()
@@ -225,8 +225,8 @@ class ESRFLIMS(AbstractLims):
     def allow_session(self, session: Session):
         return self.drac.allow_session(session)
 
-    def get_session_by_id(self, id: str):
-        return self.drac.get_session_by_id(id)
+    def get_session_by_id(self, sid: str):
+        return self.drac.get_session_by_id(sid)
 
     def get_user_name(self):
         return self.drac.get_user_name()
@@ -252,11 +252,13 @@ class ESRFLIMS(AbstractLims):
 
     def store_energy_scan(self, energyscan_dict):
         energyscan_dict["sessionId"] = self.ispyb.get_session_id()
-        return self.ispyb.store_energy_scan(energyscan_dict)
+        self.drac.store_energy_scan(energyscan_dict)
+        return self.ispyb.store_energy_scan(self._clean_sample_id(energyscan_dict))
 
     def store_xfe_spectrum(self, xfespectrum_dict):
         xfespectrum_dict["sessionId"] = self.ispyb.get_session_id()
-        return self.ispyb.store_xfe_spectrum(xfespectrum_dict)
+        self.drac.store_xfe_spectrum(xfespectrum_dict)
+        return self.ispyb.store_xfe_spectrum(self._clean_sample_id(xfespectrum_dict))
 
     def store_workflow(self, *args, **kwargs):
         pass

{mxcubecore-1.329.0 → mxcubecore-1.330.0}/mxcubecore/HardwareObjects/ICATLIMS.py

@@ -1,9 +1,9 @@
 import json
 import logging
-import pathlib
 import shutil
 from collections import defaultdict
 from datetime import datetime, timedelta
+from pathlib import Path
 from typing import List, Optional
 from zoneinfo import ZoneInfo
 
@@ -82,7 +82,8 @@ class ICATLIMS(AbstractLims):
         sessions = self.to_sessions(self.__get_all_investigations())
 
         if len(sessions) == 0:
-            raise Exception("No sessions available for user %s" % (user_name))
+            msg = f"No sessions available for user {user_name}"
+            raise RuntimeError(msg)
 
         logger.debug("Successfully retrieved %s sessions" % (len(sessions)))
 
@@ -101,7 +102,7 @@ class ICATLIMS(AbstractLims):
                     break
 
             if not session_found:
-                raise Exception(
+                raise RuntimeError(
                     "Current session in-use (with id %s) not avaialble to user %s"
                     % (self.session_manager.active_session.session_id, user_name)
                 )
@@ -291,13 +292,13 @@ class ICATLIMS(AbstractLims):
         # id to the sample sheet declared in the user portal
         sample_sheet_id = tracking_sample.get("sampleId")
         # identifier that points to the sample tracking
-        trackingSampleId = tracking_sample.get("_id")
+        tracking_sample_id = tracking_sample.get("_id")
 
         logger.debug(
-            "[ICATClient] Sample ids sample_id=%s sample_sheet_id=%s trackingSampleId=%s",
+            "[ICATClient] Sample ids sample_id=%s sample_sheet_id=%s tracking_sample_id=%s",
             sample_id,
             sample_sheet_id,
-            trackingSampleId,
+            tracking_sample_id,
         )
 
         sample_location = tracking_sample.get("sampleContainerPosition")
@@ -352,7 +353,7 @@ class ICATLIMS(AbstractLims):
                                     processing_plan, downloads
                                 )
                             except RuntimeError:
-                                logger.error(
+                                logger.exception(
                                     "Failed __add_download_path_to_processing_plan"
                                 )
 
@@ -369,7 +370,7 @@ class ICATLIMS(AbstractLims):
             "sampleName": sample_name,
             "sampleId": sample_id,
             "sample_sheet_id": sample_sheet_id,
-            "trackingSampleId": trackingSampleId,
+            "trackingSampleId": tracking_sample_id,
             "proteinAcronym": protein_acronym,
             "sampleLocation": sample_location,
             "containerCode": puck_name,
@@ -410,11 +411,13 @@ class ICATLIMS(AbstractLims):
         pass
 
     @property
-    def only_staff_session_selection(self):
-        return bool(self.get_property("only_staff_session_selection", default=False))
+    def only_staff_session_selection(self) -> bool:
+        return bool(
+            self.get_property("only_staff_session_selection", default_value=False)
+        )
 
     def store_robot_action(self, proposal_id: str):
-        raise Exception("Not implemented")
+        raise NotImplementedError
 
     @property
     def filter(self):
@@ -452,11 +455,11 @@ class ICATLIMS(AbstractLims):
     def after_offset_days(self):
         return self.get_property("after_offset_days", "1")
 
-    def _string_to_format_date(self, date: str, format: str) -> str:
+    def _string_to_format_date(self, date: str, fmt: str) -> str:
         if date is not None:
             date_time = self._tz_aware_fromisoformat(date)
             if date_time is not None:
-                return date_time.strftime(format)
+                return date_time.strftime(fmt)
         return ""
 
     def _string_to_date(self, date: str) -> str:
@@ -468,7 +471,7 @@ class ICATLIMS(AbstractLims):
     def _tz_aware_fromisoformat(self, date: str) -> datetime:
         try:
             return datetime.fromisoformat(date).astimezone()
-        except Exception:
+        except (TypeError, ValueError):
             return None
 
     def set_active_session_by_id(self, session_id: str) -> Session:
@@ -483,7 +486,7 @@ class ICATLIMS(AbstractLims):
 
         if len(sessions) == 0:
             logger.warning("Session list is empty. No session candidates")
-            raise Exception("No sessions available")
+            raise RuntimeError("No sessions available")
 
         if len(sessions) == 1:
             self.session_manager.active_session = sessions[0]
@@ -495,7 +498,7 @@ class ICATLIMS(AbstractLims):
 
         session_list = [obj for obj in sessions if obj.session_id == session_id]
         if len(session_list) != 1:
-            raise Exception(
+            raise RuntimeError(
                 "Session not found in the local list of sessions. session_id="
                 + session_id
             )
@@ -507,19 +510,19 @@ class ICATLIMS(AbstractLims):
         logger.debug("allow_session investigationId=%s", session.session_id)
         self.icatClient.reschedule_investigation(session.session_id)
 
-    def get_session_by_id(self, id: str):
+    def get_session_by_id(self, sid: str):
         logger.debug(
             "get_session_by_id investigationId=%s investigations=%s",
-            id,
+            sid,
             str(len(self.investigations)),
         )
-        investigation_list = list(filter(lambda p: p["id"] == id, self.investigations))
+        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",
-            id,
+            sid,
             str(len(self.investigations)),
         )
         return None
@@ -802,11 +805,11 @@ class ICATLIMS(AbstractLims):
             try:
                 if cell is not None and puck is not None:
                     position = int(cell * 3) + int(puck)
-            except Exception as e:
-                logger.exception(e)
+            except Exception:
+                logger.exception()
             return position, sample_position
-        except Exception as e:
-            logger.exception(e)
+        except Exception:
+            logger.exception()
 
     def store_beamline_setup(self, session_id: str, bl_config_dict: dict):
         pass
@@ -817,8 +820,76 @@ class ICATLIMS(AbstractLims):
     def store_energy_scan(self, energyscan_dict: dict):
         pass
 
-    def store_xfe_spectrum(self, xfespectrum_dict: dict):
-        pass
+    def store_xfe_spectrum(self, collection_parameters: dict):
+        status = {"xfeFluorescenceSpectrumId": -1}
+        try:
+            try:
+                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",
+                )
+            _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(collection_parameters["filename"]).parent
+
+            msg = f"SampleId is: {collection_parameters.get('blSampleId')}"
+            logging.getLogger("HWR").debug(msg)
+            try:
+                sample = HWR.beamline.lims.find_sample_by_sample_id(
+                    collection_parameters.get("blSampleId")
+                )
+                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,
+            }
+
+            self.icatClient.store_dataset(
+                beamline=beamline,
+                proposal=proposal,
+                dataset=str(directory.name),
+                path=str(directory),
+                metadata=metadata,
+            )
+        except Exception:
+            logging.getLogger("ispyb_client").exception()
+
+        return status
 
     def store_workflow(self, workflow_dict: dict):
         pass
@@ -871,7 +942,7 @@ class ICATLIMS(AbstractLims):
             else:
                 logger.exception("HTTP error for sample %s", sample_id)
 
-        except requests.exceptions.RequestException as e:
+        except requests.exceptions.RequestException:
             logger.exception("Request error for sample %s", sample_id)
         return None
 
@@ -883,15 +954,15 @@ class ICATLIMS(AbstractLims):
 
         Parameters:
             sample (str): Sample identifier.
-            output_folder (str): Directory where files will be saved.
+            output_folder (str): Directory where storefiles will be saved.
 
         Returns:
             dict: A dictionary containing the paths of the downloaded files.
         """
         downloaded_files: List[Download] = []
         for resource in resources:
-            resource_folder = pathlib.Path(output_folder) / sample_name
-            resource_folder = pathlib.Path(resource_folder) / (
+            resource_folder = Path(output_folder) / sample_name
+            resource_folder = Path(resource_folder) / (
                 resource.groupName if resource.groupName else ""
             )
             resource_folder.mkdir(
@@ -931,7 +1002,7 @@ class ICATLIMS(AbstractLims):
 
         try:
             fileinfo = collection_parameters["fileinfo"]
-            directory = pathlib.Path(fileinfo["directory"])
+            directory = Path(fileinfo["directory"])
             dataset_name = directory.name
             # Determine the scan type
             if dataset_name.endswith("mesh"):
@@ -1086,7 +1157,7 @@ class ICATLIMS(AbstractLims):
             except RuntimeError:
                 logger.warning("Failed to get MX_axis_end")
 
-            icat_metadata_path = pathlib.Path(directory) / "metadata.json"
+            icat_metadata_path = Path(directory) / "metadata.json"
             with open(icat_metadata_path, "w") as f:
                 # We add the processing and experiment plan only in the metadata.json
                 # it will not work thought pyicat-plus
@@ -1107,7 +1178,7 @@ class ICATLIMS(AbstractLims):
                 for snapshot_index in range(1, 5):
                     key = f"xtalSnapshotFullPath{snapshot_index}"
                     if key in collection_parameters:
-                        snapshot_path = pathlib.Path(collection_parameters[key])
+                        snapshot_path = Path(collection_parameters[key])
                         if snapshot_path.exists():
                             logger.debug(
                                 f"Copying snapshot index {snapshot_index} to gallery"
@@ -1167,4 +1238,3 @@ class ICATLIMS(AbstractLims):
         :param sample_dict: A dictionary with the properties for the entry.
         :type sample_dict: dict
         """
-        pass