pychemstation 0.4.7.dev1__py3-none-any.whl → 0.4.7.dev3__py3-none-any.whl

hein_analytical_control/devices/Magritek/Spinsolve/utils/parser.py

@@ -1,340 +0,0 @@
-"""
-Python module to parse the xml messages received from Spinsolve NMR.
-"""
-import logging
-
-import xml.etree.ElementTree as ET
-from xml.etree.ElementTree import ParseError
-
-from .exceptions import RequestError, HardwareError, ShimmingError, NMRError
-from .constants import (
-    CURRENT_SPINSOLVE_VERSION,
-    USER_DATA_TAG,
-)
-
-
-class ReplyParser:
-    """Parses usefull information from the xml reply"""
-
-    ### Response tags for easier handling ###
-    HARDWARE_RESPONSE_TAG = "HardwareResponse"
-    AVAILABLE_PROTOCOL_OPTIONS_RESPONSE_TAG = "AvailableProtocolOptionsResponse"
-    STATUS_TAG = "StatusNotification"
-    ESTIMATE_DURATION_RESPONSE_TAG = "EstimateDurationResponse"
-    CHECK_SHIM_RESPONSE_TAG = "CheckShimResponse"
-    QUICK_SHIM_RESPONSE_TAG = "QuickShimResponse"
-    POWER_SHIM_RESPONSE_TAG = "PowerShimResponse"
-    COMPLETED_NOTIFICATION_TAG = "CompletedNotificationType"
-    GET_RESPONSE_TAG = "GetResponse"
-
-    def __init__(self, device_ready_flag, data_folder_queue):
-        """
-        Args:
-            device_ready_flag (:obj: "threading.Event"): The threading event indicating
-                that the instrument is ready for the next commands
-            data_folder_queue (:obj: "queue.Queue"): A queue object to store the data folder information
-                for subsequent access with Spectrum class
-        """
-
-        self.device_ready_flag = device_ready_flag
-        self.data_folder_queue = data_folder_queue
-        self.connected_tag = None  # String to indicate if the instrument is connected, updated with HardwareRequest
-
-        self.logger = logging.getLogger("spinsolve.parser")
-
-        # For shimming validation
-        self.shimming_line_width_threshold = 1
-        self.shimming_base_width_threshold = 40
-
-    def parse(self, message):
-        """Parses the message into valuable XML element
-
-        Depending on the element tag, invokes various parsing methods
-
-        Args:
-            message (bytes): The message received from the instrument
-        """
-
-        self.logger.debug("Obtained the message: \n%s", message)
-
-        # Checking the obtained message
-        try:
-            msg_root = ET.fromstring(message)
-        except ParseError:
-            self.logger.error(
-                "ParseError: invalid XML message received, check the full message \n <%s>",
-                message.decode(),
-            )
-            raise ParseError(
-                "Invalid XML message received from the instrument, please check the log for the full message"
-            ) from None
-        if msg_root.tag != "Message" or len(msg_root) > 1:
-            self.logger.error(
-                "ParseError: incorrect message received, check the full message \n <%s>",
-                message.decode(),
-            )
-            raise ParseError(
-                "Incorrect message received from the instrument, please check the log for the full message"
-            )
-
-        # Main message element
-        msg_element = msg_root[0]
-
-        # Invoking specific methods for specific responds
-        if msg_element.tag == self.HARDWARE_RESPONSE_TAG:
-            return self.hardware_processing(msg_element)
-        elif msg_element.tag == self.AVAILABLE_PROTOCOL_OPTIONS_RESPONSE_TAG:
-            return message
-        elif msg_element.tag in [
-            self.CHECK_SHIM_RESPONSE_TAG,
-            self.QUICK_SHIM_RESPONSE_TAG,
-            self.POWER_SHIM_RESPONSE_TAG,
-        ]:
-            return self.shimming_processing(msg_element)
-        elif (
-            msg_element.tag == self.STATUS_TAG
-            or msg_element.tag == self.COMPLETED_NOTIFICATION_TAG
-        ):
-            return self.status_processing(msg_element)
-        elif msg_element.tag == self.ESTIMATE_DURATION_RESPONSE_TAG:
-            return self.estimate_duration_processing(msg_element)
-        elif msg_element.tag == self.GET_RESPONSE_TAG:
-            return self.data_response_processing(msg_element)
-        else:
-            self.logger.info(
-                "No specific parser requested, returning full decoded message"
-            )
-            return message.decode()
-
-    def hardware_processing(self, element):
-        """Process the message if the Hardware tag is present
-
-        Args:
-            element (:obj: xml.etree.ElementTree.Element): An element containing all
-                usefull information regarding Hardware response from the instrument
-
-        Returns:
-            dict: Dictionary with usefull hardware information
-
-        Raises:
-            HardwareError: In case the instrument is not connected
-        """
-
-        # Checking if the instrument is physically connected
-        self.logger.debug("Parsing message with <%s> tag", element.tag)
-        self.connected_tag = element.find(".//ConnectedToHardware").text
-        if self.connected_tag == "false":
-            raise HardwareError("The instrument is not connected!")
-
-        software_tag = element.find(".//SpinsolveSoftware").text
-
-        spinsolve_tag = element.find(".//SpinsolveType").text
-
-        self.logger.info(
-            "The %s NMR instrument is successfully connected \nRunning under %s Spinsolve software version",
-            spinsolve_tag,
-            software_tag,
-        )
-        if software_tag[:6] != CURRENT_SPINSOLVE_VERSION:
-            self.logger.warning(
-                "The current software version <%s> was not tested, please update or use at your own risk",
-                software_tag,
-            )
-
-        # If the instrument is connected, setting the ready flag
-        self.device_ready_flag.set()
-
-        usefull_information_dict = {
-            "Connected": f"{self.connected_tag}",
-            "SoftwareVersion": f"{software_tag}",
-            "InstrumentType": f"{spinsolve_tag}",
-        }
-
-        return usefull_information_dict
-
-    def data_response_processing(self, element):
-        """Process the message if the user parameters response is present.
-
-        Args:
-            element (:obj: xml.etree.ElementTree.Element): An element containing
-                all usefull information regarding Hardware response from the
-                instrument.
-
-        Returns:
-            Dict: Dictionary with user/experiment specific parameter, e.g.
-                userdata, solvent or sample.
-        """
-
-        self.logger.debug("Parsing message with <%s> tag", element.tag)
-        # messages with GetResponse have only one child
-        if len(element) > 1:
-            raise RequestError(
-                "Returned response for user data is incorrect, \
-check log files for details!"
-            )
-
-        chelement = element[0]
-
-        # special case for user data
-        if chelement.tag == USER_DATA_TAG:
-            return {
-                subel.attrib["key"]: subel.attrib["value"]
-                for subel in chelement  # iterating over subelements
-            }
-
-        return chelement.text
-
-    def shimming_processing(self, element):
-        """Process the message if the Shim tag is present
-
-        Args:
-            element (:obj: xml.etree.ElementTree.Element): An element containing all
-                usefull information regarding shimming response from the instrument
-
-        Returns:
-            True if shimming was successfull
-
-        Raises:
-            ShimmingError: If the shimming process failed
-        """
-
-        self.logger.debug("Parsing message with <%s> tag", element.tag)
-
-        self.device_ready_flag.set()
-
-        error_text = element.get("error")
-        if error_text:
-            self.logger.error(
-                "ShimmingError: check the error message below\
-\n%s",
-                error_text,
-            )
-            if (
-                self.shimming_base_width_threshold == 40
-                and self.shimming_line_width_threshold == 1
-            ):
-                # only raise error if default line widths were used as the
-                # reference point
-                raise ShimmingError(f"Shimming error: {error_text}")
-
-        for child in element:
-            self.logger.info("%s - %s", child.tag, child.text)
-
-        # Obtaining shimming parameters
-        line_width = round(float(element.find(".//LineWidth").text), 2)
-        base_width = round(float(element.find(".//BaseWidth").text), 2)
-        system_ready = element.find(".//SystemIsReady").text
-
-        # Checking shimming criteria
-        if line_width > self.shimming_line_width_threshold:
-            self.logger.critical(
-                "Shimming line width <%.2f> is above requested threshold <%.2f>, consider running another shimming method",
-                line_width,
-                self.shimming_line_width_threshold,
-            )
-        if base_width > self.shimming_base_width_threshold:
-            self.logger.critical(
-                "Shimming line width <%.2f> is above requested threshold <%.2f>, consider running another shimming method",
-                line_width,
-                self.shimming_line_width_threshold,
-            )
-        if system_ready != "true":
-            self.logger.critical(
-                "System is not ready after shimming, consider running another shimming method"
-            )
-            return False
-        else:
-            return True
-
-    def status_processing(self, element):
-        """Process the message if the Status tag is present
-
-        Logs the incoming messages and manages device_ready_flag
-
-        Args:
-            element (:obj: xml.etree.ElementTree.Element): An element containing all
-                usefull information regarding status response from the instrument
-
-        Returns:
-            str: String containing the path to the saved NMR data
-
-        Raises:
-            NMRError: in case of the protocol errors
-        """
-
-        self.logger.debug("Parsing message with <%s> tag", element.tag)
-
-        # Valuable data from the message
-        state_tag = element[0].tag
-        state_elem = element[0]
-        protocol_attrib = state_elem.get("protocol")
-
-        # Checking for errors first
-        error_attrib = state_elem.get("error")
-
-        # No error is actually raised, since the instrument
-        # Continues with protocol execution even if an error was returned
-        # TODO add an option to handle the error and stop the execution
-        if error_attrib:
-            self.logger.error(
-                "NMRError: <%s>, check the log for the full message", error_attrib
-            )
-            # raise NMRError(f"Error running the protocol <{protocol_attrib}>: {error_attrib}")
-
-        status_attrib = state_elem.get("status")
-        percentage_attrib = state_elem.get("percentage")
-        seconds_remaining_attrib = state_elem.get("secondsRemaining")
-
-        # Logging the data
-        if state_tag == "State":
-            # Resetting the event to False to block the incoming msg
-            if status_attrib == "Running":
-                self.logger.debug("Device in operation, blocking the incoming messages")
-            self.device_ready_flag.clear()
-            self.logger.info("%s the <%s> protocol", status_attrib, protocol_attrib)
-            if status_attrib == "Ready":
-                # When device is ready, setting the event to True for the next protocol to be executed
-                # Delay the flag setting for the SHIM protocol
-                if protocol_attrib != "SHIM":
-                    self.device_ready_flag.set()
-                data_folder = state_elem.get("dataFolder")
-                self.logger.info(
-                    "The protocol <%s> is complete, the NMR data is saved in <%s>",
-                    protocol_attrib,
-                    data_folder,
-                )
-                self.data_folder_queue.put(data_folder)
-                return data_folder
-
-        if state_tag == "Progress":
-            self.logger.info(
-                "The protocol <%s> is performing, %s%% completed, %s seconds remain",
-                protocol_attrib,
-                percentage_attrib,
-                seconds_remaining_attrib,
-            )
-
-    def estimate_duration_processing(self, element):
-        """Process the message if protocol duration was requested
-
-        Args:
-            element (:obj: xml.etree.ElementTree.Element): An element containing all
-                usefull information regarding duration estimation from the instrument
-
-        Returns:
-            int: Estimated duration for the requested protocol in seconds
-
-        Raises:
-            RequestError: In case the instrument returns an error attribute
-        """
-
-        self.logger.debug("Parsing message with <%s> tag", element.tag)
-
-        error_text = element.get("error")
-        if error_text:
-            self.logger.error("RequestError: check the log for the full message")
-            raise RequestError(f"Duration request error: {error_text}")
-
-        duration_in_seconds = element.get("durationInSeconds")
-
-        return int(duration_in_seconds)

hein_analytical_control/devices/Magritek/Spinsolve/utils/shimming.py

@@ -1,55 +0,0 @@
-"""
-Utility function to record last shimming results
-"""
-import time
-import os
-import json
-import queue
-from functools import wraps
-
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-SHIMMING_PARAMETERS = "shim.par"
-TIME_FORMAT = r"%Y-%m-%dT%H:%M:%S.%f"
-
-
-def shimming(f):
-    """Decorator to record shimming data."""
-
-    @wraps(f)
-    def wrapper(*args, **kwargs):
-        spinsolve_instance = args[0]
-
-        # performing shimming
-        result = f(*args, **kwargs)
-        params_path = os.path.join(result, SHIMMING_PARAMETERS)
-
-        # extracting and saving shimming parameters
-        spinsolve_instance.last_shimming_results = (
-            spinsolve_instance.spectrum.extract_parameters(params_path)
-        )
-
-        # appending path
-        spinsolve_instance.last_shimming_results.update(path=params_path)
-
-        # loading and saving timestamp
-        shimming_time = time.strptime(
-            spinsolve_instance.last_shimming_results["CurrentTime"], TIME_FORMAT
-        )
-        spinsolve_instance.last_shimming_results.update(
-            timestamp=time.mktime(shimming_time)
-        )
-
-        # emptying data folder queue, as shimming doesn't need processing
-        try:
-            spinsolve_instance.data_folder_queue.get_nowait()
-        except queue.Empty:
-            pass
-
-        # saving to json
-        with open(os.path.join(HERE, "shimming.json"), "w") as fobj:
-            json.dump(spinsolve_instance.last_shimming_results, fobj)
-
-        return result
-
-    return wrapper

hein_analytical_control/devices/Magritek/Spinsolve/utils/spinsolve_logging.py

@@ -1,43 +0,0 @@
-import logging
-from logging.handlers import RotatingFileHandler
-import os
-from datetime import datetime
-
-
-now = datetime.now().strftime("%d%m%y")
-
-LEVEL = logging.INFO
-HERE = os.path.abspath(".")
-LOG_PATH = os.path.join(HERE, "spinsolve_logs")
-NAME = "spinsolve"
-MAX_BYTES_SIZE = 3 * 1000 * 1000  # 2 MB is enough to store ~30 spectra records
-BACKUP_COUNT = 5  # will give in total logs for ~150 spectra records
-
-
-def get_logger():
-    """Returns logger object with predefined console and file handlers."""
-
-    logger = logging.getLogger(NAME)
-    logger.setLevel(logging.DEBUG)
-    logger.handlers = []  # resetting
-
-    ff = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-
-    # console handler
-    ch = logging.StreamHandler()
-    ch.setLevel(LEVEL)
-    ch.setFormatter(ff)
-
-    # file handler
-    os.makedirs(LOG_PATH, exist_ok=True)
-    file_path = os.path.join(LOG_PATH, f"{NAME}-{now}.log")
-    fh = RotatingFileHandler(
-        filename=file_path, mode="a", maxBytes=MAX_BYTES_SIZE, backupCount=BACKUP_COUNT
-    )
-    fh.setLevel(logging.DEBUG)
-    fh.setFormatter(ff)
-
-    logger.addHandler(ch)
-    logger.addHandler(fh)
-
-    return logger

hein_analytical_control/devices/OceanOptics/IR/NIRQuest512.py

@@ -1,90 +0,0 @@
-"""
-.. module:: NIRQuest512
-    :synopsis: Module representing the NIRQUest512 Near-IR spectrometer
-    :platforms: Unix, Windows
-
-.. moduleauthor:: Graham Keenan (Cronin Lab 2020)
-
-.. note:: Edit as needed. This is a skeletal implementation for minimal
-            functionality.
-
-"""
-
-import json
-from pathlib import Path
-from typing import Union, Dict
-from .ir_spectrum import IRSpectrum
-from ..oceanoptics import OceanOpticsSpectrometer
-
-
-class NoReferenceException(Exception):
-    """Exception for calling spectrum without a reference"""
-
-
-class NIRQuest512(OceanOpticsSpectrometer):
-    """Class representing the NIRQuest512 Near-IR spectrometer
-
-    Inherits:
-        OceanOpticsSpectrometer
-    """
-
-    def __init__(self):
-        super().__init__("IR", name="NIRQuest512 IR Spectrometer")
-        self.reference = {}
-        self.__ref_called = False
-
-    def load_reference(self, ref: Union[str, Dict]):
-        """Loads a pre-existing reference from disk or from dict.
-
-        Args:
-            ref (Union[str, Dict]): Reference as either a dictionary
-            or JSON filepath
-        """
-
-        # Filepath, load and set
-        if isinstance(ref, str) or isinstance(ref, Path):
-            with open(ref) as fd:
-                self.reference = json.load(fd)
-                self.__ref_called = True
-
-        # Dict, set
-        elif isinstance(ref, dict):
-            self.reference = ref
-            self.__ref_called = True
-
-        # Not supported
-        else:
-            self.logger.warning(f"Reference {ref} is unsupported. Not loading")
-
-    def obtain_reference_spectrum(self) -> IRSpectrum:
-        """Obtain a reference spectrum
-
-        Returns:
-            IRSpectrum: Reference IR spectrum
-        """
-
-        wavelength, intensities = self.scan()
-        self.reference["wavelength"] = wavelength
-        self.reference["intensities"] = intensities
-        self.__ref_called = True
-
-        return IRSpectrum(wavelength, intensities)
-
-    def obtain_spectrum(self) -> IRSpectrum:
-        """Obtain an IR spectrum of a sample.
-
-        Raises:
-            NoReferenceException: Attempting to measure a sample without#
-            reference data.
-
-        Returns:
-            IRSpectrum: Sample IR spectrum.
-        """
-
-        if not self.__ref_called:
-            raise NoReferenceException(
-                "Attempting to call a spectrum without a valid reference."
-            )
-
-        wavelength, intensities = self.scan()
-        return IRSpectrum(wavelength, intensities, ref=self.reference)