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

ag_hplc_macro/utils/hplc_param_types.py

@@ -1,185 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import Union, Any, Optional
-
-from pychemstation.generated import SolventElement, Signal
-
-
-# Commands sent to the Chemstation Macro
-# See https://www.agilent.com/cs/library/usermanuals/Public/MACROS.PDF
-class Command(Enum):
-    def __str__(self):
-        return '%s' % self.value
-
-    RESET_COUNTER_CMD = "last_cmd_no = 0"
-    GET_STATUS_CMD = "response$ = AcqStatus$"
-    SLEEP_CMD = "Sleep {seconds}"
-    STANDBY_CMD = "Standby"
-    STOP_MACRO_CMD = "Stop"
-    PREPRUN_CMD = "PrepRun"
-    LAMP_ON_CMD = "LampAll ON"
-    LAMP_OFF_CMD = "LampAll OFF"
-    PUMP_ON_CMD = "PumpAll ON"
-    PUMP_OFF_CMD = "PumpAll OFF"
-    GET_METHOD_CMD = "response$ = _MethFile$"
-    SWITCH_METHOD_CMD = 'LoadMethod "{method_dir}", "{method_name}.M"'
-    START_METHOD_CMD = "StartMethod"
-    RUN_METHOD_CMD = 'RunMethod "{data_dir}",, "{experiment_name}_{timestamp}"'
-    STOP_METHOD_CMD = "StopMethod"
-    UPDATE_METHOD_CMD = 'UpdateMethod'
-    SWITCH_SEQUENCE_CMD = 'LoadSequence _SeqPath$, _SeqFile$'
-    SAVE_SEQUENCE_CMD = 'SaveSequence _SeqPath$, _SeqFile$'
-    GET_SEQUENCE_CMD = 'response$ = _SeqFile$'
-    RUN_SEQUENCE_CMD = 'RunSequence "{data_dir}",, "{experiment_name}_{timestamp}"'
-
-
-class RegisterFlag(Enum):
-    def __str__(self):
-        return '%s' % self.value
-
-    # for table
-    NUM_ROWS = "NumberOfRows"
-
-    # for Method
-    SOLVENT_A_COMPOSITION = "PumpChannel_CompositionPercentage"
-    SOLVENT_B_COMPOSITION = "PumpChannel2_CompositionPercentage"
-    SOLVENT_C_COMPOSITION = "PumpChannel3_CompositionPercentage"
-    SOLVENT_D_COMPOSITION = "PumpChannel4_CompositionPercentage"
-    FLOW = "Flow"
-    MAX_TIME = "StopTime_Time"
-    COLUMN_OVEN_TEMP1 = "TemperatureControl_Temperature"
-    COLUMN_OVEN_TEMP2 = "TemperatureControl2_Temperature"
-    STOPTIME_MODE = "StopTime_Mode"
-    POSTIME_MODE = "PostTime_Mode"
-
-    # for Method Timetable
-    SOLVENT_COMPOSITION = "SolventComposition"
-
-    # for Sequence
-    VIAL_LOCATION = "Vial"
-    NAME = ""
-    METHOD = ""
-    INJ_VOL = ""
-
-
-class TableOperation(Enum):
-    def __str__(self):
-        return '%s' % self.value
-
-    DELETE_TABLE = 'DelTab {register}, "{table_name}"'
-    CREATE_TABLE = 'NewTab {register}, "{table_name}"'
-    NEW_ROW = 'InsTabRow {register}, "{table_name}"'
-    EDIT_ROW_VAL = 'SetTabVal "{register}", "{table_name}", {row}, "{col_name}", {val}'
-    EDIT_ROW_TEXT = 'SetTabText "{register}", "{table_name}", {row}, "{col_name}", "{val}"'
-    GET_ROW_VAL = 'TabVal ("{register}", "{table_name}", {row}, "{col_name}")'
-    GET_ROW_TEXT = 'TabText ("{register}", "{table_name}", {row}, "{col_name}")'
-    GET_OBJ_HDR_VAL = '{internal_val} = TabHdrVal({register}, "{table_name}", "{col_name}")'
-    GET_OBJ_HDR_TEXT = ''
-    UPDATE_OBJ_HDR_VAL = 'SetObjHdrVal {register}, {register_flag}, {val}'
-    UPDATE_OBJ_HDR_TEXT = 'SetObjHdrText {register}, {register_flag}, {val}'
-    NEW_COL_TEXT = 'NewColText {register}, "{table_name}", "{col_name}", "{val}"'
-    NEW_COL_VAL = 'NewColVal {register}, "{table_name}", "{col_name}", {val}'
-
-
-class PType(Enum):
-    STR = "str"
-    NUM = "num"
-
-
-@dataclass
-class Param:
-    ptype: PType
-    val: Union[float, int, str, Any]
-    chemstation_key: Union[RegisterFlag, list[RegisterFlag]]
-
-
-@dataclass
-class HPLCMethodParams:
-    organic_modifier: Param
-    flow: Param
-    temperature: Param
-    inj_vol: Param
-    equ_time: Param
-    maximum_run_time: Param
-
-
-@dataclass
-class Entry:
-    start_time: float
-    organic_modifer: float
-    flow: float
-
-
-@dataclass
-class SequenceEntry:
-    vial_location: Optional[int] = None
-    method: Optional[str] = None
-    inj_vol: Optional[int] = None
-    name: Optional[str] = None
-
-
-@dataclass
-class SequenceTable:
-    rows: list[SequenceEntry]
-
-
-@dataclass
-class MethodTimetable:
-    first_row: HPLCMethodParams
-    subsequent_rows: list[Entry]
-    dad_wavelengthes: Optional[list[Signal]] = None
-    organic_modifier: Optional[SolventElement] = None
-    modifier_a: Optional[SolventElement] = None
-
-
-class HPLCRunningStatus(Enum):
-    @classmethod
-    def has_member_key(cls, key):
-        return key in cls.__members__
-
-    INJECTING = "INJECTING"
-    PREPARING = "PREPARING"
-    RUN = "RUN"
-    NOTREADY = "NOTREADY"
-    POSTRUN = "POSTRUN"
-    RAWDATA = "RAWDATA"
-    INITIALIZING = "INITIALIZING"
-    NOMODULE = "NOMODULE"
-
-
-class HPLCAvailStatus(Enum):
-    @classmethod
-    def has_member_key(cls, key):
-        return key in cls.__members__
-
-    PRERUN = "PRERUN"
-    OFFLINE = "OFFLINE"
-    STANDBY = "STANDBY"
-
-
-class HPLCErrorStatus(Enum):
-
-    @classmethod
-    def has_member_key(cls, key):
-        return key in cls.__members__
-
-    ERROR = "ERROR"
-    BREAK = "BREAK"
-    NORESPONSE = "NORESPONSE"
-    MALFORMED = "MALFORMED"
-
-
-@dataclass
-class Table:
-    register: str
-    name: str
-
-
-def str_to_status(status: str) -> Union[HPLCAvailStatus, HPLCErrorStatus, HPLCRunningStatus]:
-    if HPLCErrorStatus.has_member_key(status):
-        return HPLCErrorStatus[status]
-    if HPLCRunningStatus.has_member_key(status):
-        return HPLCRunningStatus[status]
-    if HPLCAvailStatus.has_member_key(status):
-        return HPLCAvailStatus[status]
-    raise KeyError(status)

hein-analytical-control/__init__.py

@@ -1,3 +0,0 @@
-"""
-.. include:: ../README.md
-"""

hein-analytical-control/analysis/__init__.py

@@ -1 +0,0 @@
-from .base_spectrum import AbstractSpectrum

hein-analytical-control/analysis/base_spectrum.py

@@ -1,509 +0,0 @@
-import pickle
-import os
-import logging
-
-from abc import ABC, abstractmethod
-
-import numpy as np
-import matplotlib.pyplot as plt
-
-from scipy import (
-    sparse,
-    signal,
-    interpolate,
-    integrate,
-)
-
-from .utils import interpolate_to_index, find_nearest_value_index
-
-
-class AbstractSpectrum(ABC):
-    """General class for handling spectroscopic data
-
-    Contains methods for data manipulation (load/save) and basic processing
-    features, such as baseline correction, smoothing, peak picking and
-    integration.
-
-    All data processing happens in place!
-    """
-
-    # for plotting
-    AXIS_MAPPING = {
-        "x": "x_data",
-        "y": "y_data",
-    }
-
-    # list of properties to be saved
-    PUBLIC_PROPERTIES = {
-        "x",
-        "y",
-        "peaks",
-        "timestamp",
-    }
-
-    # list of internal properties to be dumped during new data loading
-    INTERNAL_PROPERTIES = {
-        "baseline",
-    }
-
-    def __init__(self, path=None, autosaving=True):
-        """Default constructor, loads properties into instance namespace.
-
-        Can be redefined in ancestor classes.
-
-        Args:
-            path (Union[str, bool], optional): Valid path to save data to.
-                If omitted, uses ".//spectrum". If False - no folder created.
-            autosaving (bool, optional): If the True (default) will save the
-                spectrum when the new one is loaded. Will drop otherwise.
-        """
-
-        self.autosaving = autosaving
-
-        # loading public properties
-        for prop in self.PUBLIC_PROPERTIES:
-            setattr(self, prop, None)
-
-        # loading internal properties
-        for prop in self.INTERNAL_PROPERTIES:
-            setattr(self, prop, None)
-
-        # creating data path
-        if path is None:
-            self.path = os.path.join(".", "spectrum")
-            os.makedirs(self.path, exist_ok=True)
-        else:
-            try:
-                os.makedirs(path, exist_ok=True)
-                self.path = path
-            except TypeError:  # type(path) -> bool
-                self.path = "."
-
-        # creating logger
-        if not hasattr(self, "logger"):
-            self.logger = logging.getLogger(self.__class__.__name__)
-
-    def _dump(self):
-        """Dummy method to dump all spectral data. Used before loading new data."""
-
-        self.__init__(path=self.path, autosaving=self.autosaving)
-
-    @abstractmethod
-    def load_spectrum(self, x, y, timestamp):
-        """Loads the spectral data.
-
-        This method must be redefined in ancestor classes.
-
-        Args:
-            x (:obj: np.array): An array with data to be plotted as "x" axis.
-            y (:obj: np.array): An array with data to be plotted as "y" axis.
-            timestamp (float): Timestamp to the corresponding spectrum.
-        """
-
-        try:
-            assert x.shape == y.shape
-        except AssertionError:
-            raise ValueError("X and Y data must have same dimension.") from None
-
-        if self.x is not None:
-            if self.autosaving:
-                self.save_data()
-            self._dump()
-
-        self.x = x
-        self.y = y
-        self.timestamp = timestamp
-
-    def save_data(self, filename=None, verbose=False):
-        """Saves the data to given path using python pickle module.
-
-        Args:
-            filename (str, optional): Filename for the current spectrum. If
-                omitted, using current timestamp.
-            verbose (bool, optional): If all processed data needs to be saved as
-                well. Default: False.
-        """
-        if filename is None:
-            filename = f"{self.timestamp}.pickle"
-        else:
-            # file extension used from python 3. documentation
-            filename += ".pickle"
-
-        path = os.path.join(self.path, filename)
-
-        data = {
-            prop: self.__dict__[prop]
-            for prop in self.PUBLIC_PROPERTIES
-            if self.__dict__[prop] is not None
-        }
-
-        if verbose:
-            data.update(
-                {
-                    prop: self.__dict__[prop]
-                    for prop in self.INTERNAL_PROPERTIES
-                    if self.__dict__[prop] is not None
-                }
-            )
-
-        with open(path, "wb") as f:
-            pickle.dump(data, f)
-
-        self.logger.info("Saved in %s", path)
-
-    def load_data(self, path):
-        """Loads the data from saved pickle file.
-
-        Data is loaded in place, so instance attributes are overwritten.
-
-        Args:
-            path (str): Valid path to pickle file.
-        """
-
-        if self.x is not None:
-            self._dump()
-
-        # TODO add exception handling
-        with open(path, "rb") as f:
-            data = pickle.load(f)
-
-        self.__dict__.update(data)
-
-    def trim(self, xmin, xmax, in_place=True):
-        """Trims the spectrum data within specific X region
-
-        Args:
-            xmin (int): Minimum position on the X axis to start from.
-            xmax (int): Maximum position on the X axis to end to.
-            in_place (bool): If trimming happens in place, else returns new
-                array as trimmed copy.
-
-        Returns:
-            (bool): True if trimmed in place.
-            (Tuple[np.array, np.array]): Trimmed copy of the original array as
-                tuple with X and Y points respectively.
-        """
-
-        # Creating the mask to map arrays
-        above_ind = self.x > xmin
-        below_ind = self.x < xmax
-        full_mask = np.logical_and(above_ind, below_ind)
-
-        # Mapping arrays if they are supplied
-        if in_place:
-            self.y = self.y[full_mask]
-            self.x = self.x[full_mask]
-            if self.baseline is not None and self.baseline.shape == full_mask.shape:
-                self.baseline = self.baseline[full_mask]
-            return True
-        else:
-            return (self.x.copy()[full_mask], self.y.copy()[full_mask])
-
-    def show_spectrum(
-        self,
-        filename=None,
-        title=None,
-        label=None,
-    ):
-        """Plots the spectral data using matplotlib.pyplot module.
-
-        Args:
-            filename (str, optional): Filename for the current plot. If omitted,
-                file is not saved.
-            title (str, optional): Title for the spectrum plot. If omitted, no
-                title is set.
-            label (str, optional): Label for the spectrum plot. If omitted, uses
-                the spectrum timestamp.
-        """
-        if label is None:
-            label = f"{self.timestamp}"
-
-        fig, ax = plt.subplots(figsize=(12, 8))
-
-        ax.plot(
-            self.x,
-            self.y,
-            color="xkcd:navy blue",
-            label=label,
-        )
-
-        ax.set_xlabel(self.AXIS_MAPPING["x"])
-        ax.set_ylabel(self.AXIS_MAPPING["y"])
-
-        if title is not None:
-            ax.set_title(title)
-
-        # plotting peaks if found
-        if self.peaks is not None:
-            plt.scatter(
-                self.peaks[:, 1],
-                self.peaks[:, 2],
-                label="found peaks",
-                color="xkcd:tangerine",
-            )
-
-        ax.legend()
-
-        if filename is None:
-            fig.show()
-
-        else:
-            path = os.path.join(self.path, "images")
-            os.makedirs(path, exist_ok=True)
-            fig.savefig(os.path.join(path, f"{filename}.png"), dpi=150)
-
-    def find_peaks(self, threshold=1, min_width=.1, min_dist=None, area=None):
-        """Finds all peaks above the threshold with at least min_width width.
-
-        Args:
-            threshold (float, optional): Relative peak height with respect to
-                the highest peak.
-            min_width (int, optional): Minimum peak width.
-            min_dist (int, optional): Minimum distance between peaks.
-            area (Tuple(int, int), optional): Area to search peaks in. Supplied
-                as min, max X values tuple.
-
-        Return:
-            (:obj: np.array): An array of peaks ids as rounded peak_x coordinate
-                value. If searching within specified area, full peak information
-                matrix is returned, see below for details.
-
-        Also updates the self.peaks attrbiute (if "area" is omitted) as:
-            (:obj: np.array): An (n_peaks x 5) array with peak data as columns:
-                peak_id (float): Rounded peak_x coordinate value.
-                peak_x (float): X-coordinate for the peak.
-                peak_y (float): Y-coordinate for the peak.
-                peak_left_x (float): X-coordinate for the left peak border.
-                peak_right_x (float): X-coordinate for the right peak border.
-
-        Peak data is accessed with indexing, e.g.:
-            self.peaks[n] will give all data for n's peak
-            self.peaks[:, 2] will give Y coordinate for all found peaks
-        """
-
-        # only dumping if area is omitted
-        if self.peaks is not None and not area:
-            self.peaks = None
-
-        # trimming
-        if area is not None:
-            spec_y = self.trim(area[0], area[1], False)[1]
-        else:
-            spec_y = self.y.copy()
-
-        threshold *= self.y.max() - self.y.min()
-        peaks, _ = signal.find_peaks(
-            spec_y, height=threshold, width=min_width, distance=min_dist
-        )
-
-        # obtaining width for full peak height
-        # TODO deal with intersecting peaks!
-        # TODO deal with incorrect peak width
-        pw = signal.peak_widths(spec_y, peaks, rel_height=0.95)
-
-        # converting all to column vectors by adding extra dimension along 2nd
-        # axis. Check documentation on np.newaxis for details
-        peak_xs = self.x.copy()[peaks][:, np.newaxis]
-        peak_ys = self.y.copy()[peaks][:, np.newaxis]
-        peaks_ids = np.around(peak_xs)
-        peaks_left_ids = interpolate_to_index(self.x, pw[2])[:, np.newaxis]
-        peaks_right_ids = interpolate_to_index(self.x, pw[3])[:, np.newaxis]
-
-        if area is None:
-            # updating only if area is not specified
-            self.peaks = np.hstack(
-                (
-                    peaks_ids,
-                    peak_xs,
-                    peak_ys,
-                    peaks_left_ids,
-                    peaks_right_ids,
-                )
-            )
-            return peaks_ids
-
-        return np.hstack(
-            (
-                peaks_ids,
-                peak_xs,
-                peak_ys,
-                peaks_left_ids,
-                peaks_right_ids,
-            )
-        )
-
-    def correct_baseline(self, lmbd=1e3, p=0.01, n_iter=10):
-        """Generates and subtracts the baseline for the given spectrum.
-
-        Based on Eilers, P; Boelens, H. (2005): Baseline Correction with
-            Asymmetric Least Squares Smoothing.
-
-        Default values chosen arbitrary based on processing Raman spectra.
-
-        Args:
-            lmbd (float): Arbitrary parameter to define the smoothness of the
-                baseline the larger lmbd is, the smoother baseline will be,
-                recommended value between 1e2 and 1e5.
-            p (float): An asymmetric least squares parameter to compute the
-                weights of the residuals, chosen arbitrary, recommended values
-                between 0.1 and 0.001.
-            n_iter (int, optional): Number of iterations to perform the fit,
-                recommended value between 5 and 10.
-        """
-
-        # generating the baseline first
-        L = len(self.y)
-        D = sparse.csc_matrix(np.diff(np.eye(L), 2))
-        w = np.ones(L)
-        for _ in range(n_iter):
-            W = sparse.spdiags(w, 0, L, L)
-            Z = W + lmbd * D.dot(D.transpose())
-            z = sparse.linalg.spsolve(Z, w * self.y)
-            w = p * (self.y > z) + (1 - p) * (self.y < z)
-
-        # updating attribute for future use
-        self.baseline = z
-
-        # subtracting the baseline
-        # TODO update peak coordinates if peaks were present
-        self.y -= z
-        self.logger.info("Baseline corrected")
-
-    def integrate_area(self, area, rule="trapz"):
-        """Integrate the spectrum within given area
-
-        Args:
-            area (Tuple[float, float]): Tuple with left and right border (X axis
-                obviously) for the desired area.
-            rule (str): Method for integration, "trapz" - trapezoidal
-                rule (default), "simps" - Simpson's rule.
-        Returns:
-            float: Definite integral within given area as approximated by given
-                method.
-        """
-
-        # closest value in experimental data and its index in data array
-        _, left_idx = find_nearest_value_index(self.x, area[0])
-        _, right_idx = find_nearest_value_index(self.x, area[1])
-
-        if rule == "trapz":
-            return integrate.trapz(
-                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
-            )
-
-        elif rule == "simps":
-            return integrate.simps(
-                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
-            )
-
-        else:
-            raise ValueError(
-                'Only trapezoidal "trapz" or Simpson\'s "simps" \
-rules are supported!'
-            )
-
-    def integrate_peak(self, peak, rule="trapz"):
-        """Calculate an area for a given peak
-
-        Args:
-            peak (float): (rounded) peak Y coordinate. If precise peak position
-                was not found, closest is picked.
-            rule (str): Method for integration, "trapz" - trapezoidal
-                rule (default), "simps" - Simpson's rule.
-        Returns:
-            float: Definite integral within given area as approximated by given
-                method.
-        """
-
-        if self.peaks is None:
-            self.find_peaks()
-
-        true_peak, idx = find_nearest_value_index(self.peaks[:, 0], peak)
-        _, _, _, left, right = self.peaks[idx]
-
-        self.logger.debug(
-            "Integrating peak found at %s, borders %.02f-%.02f", true_peak, left, right
-        )
-
-        return self.integrate_area((left, right), rule=rule)
-
-    def smooth_spectrum(self, window_length=15, polyorder=7, in_place=True):
-        """Smoothes the spectrum using Savitsky-Golay filter.
-
-        For details see scipy.signal.savgol_filter.
-
-        Default values for window length and polynomial order were chosen
-        arbitrary based on Raman spectra.
-
-        Args:
-            window_length (int): The length of the filter window (i.e. the
-                number of coefficients). window_length must be a positive odd
-                integer.
-            polyorder (int): The order of the polynomial used to fit the
-                samples. polyorder must be less than window_length.
-            in_place (bool, optional): If smoothing happens in place, returns
-                smoothed spectrum if True.
-        """
-
-        if in_place:
-            self.y = signal.savgol_filter(
-                self.y, window_length=window_length, polyorder=polyorder
-            )
-            return True
-
-        return signal.savgol_filter(
-            self.y,
-            window_length=window_length,
-            polyorder=polyorder,
-        )
-
-    def default_processing(self):
-        """Dummy method to return spectral data.
-
-        Normally redefined in ancestor classes to include basic processing for
-            specific spectrum type.
-
-        Returns:
-            Tuple[np.array, np.array, float]: Spectral data as X and Y
-                coordinates and a timestamp.
-        """
-
-        return self.x, self.y, self.timestamp
-
-    @classmethod
-    def from_data(cls, data):
-        """Class method to instantiate the class from the saved data file.
-
-        Args:
-            data (str): Path to spectral data file (as pickle).
-
-        Returns:
-            New instance with all data inside.
-        """
-
-        if "pickle" not in data:
-            raise AttributeError("Only .pickle files are supported")
-
-        path = os.path.abspath(os.path.dirname(data))
-
-        spec = cls(path)
-        spec.load_data(data)
-
-        return spec
-
-    def copy(self):
-        """Dummy class to return a new instance with the same data as the
-        current.
-
-        Returns:
-            (:obj:SpinsolveNMRSpectrum): New object with the same data.
-        """
-
-        # creating new instance
-        spec = self.__class__(self.path, self.autosaving)
-
-        # loading attributes
-        for prop in self.PUBLIC_PROPERTIES.union(self.INTERNAL_PROPERTIES):
-            setattr(spec, prop, getattr(self, prop))
-
-        return spec