pychemstation 0.4.7.dev1__py3-none-any.whl

ag_hplc_macro/utils/chemstation.py

@@ -0,0 +1,290 @@
+#!/usr/bin/python
+# coding: utf-8
+
+"""
+File parser for Chemstation files (*.ch)
+Basically a port of the matlab script at:
+https://github.com/chemplexity/chromatography/blob/master/Development/File%20Conversion/ImportAgilentFID.m
+
+This file is a standalone file to parse the binary files created by Chemstation
+
+I use it for file with version 130, genereted by an Agilent LC.
+"""
+
+import struct
+from struct import unpack
+import numpy as np
+
+# Constants used for binary file parsing
+ENDIAN = ">"
+STRING = ENDIAN + "{}s"
+UINT8 = ENDIAN + "B"
+UINT16 = ENDIAN + "H"
+INT16 = ENDIAN + "h"
+INT32 = ENDIAN + "i"
+UINT32 = ENDIAN + "I"
+
+
+def fread(fid, nelements, dtype):
+
+    """Equivalent to Matlab fread function"""
+
+    if dtype is str:
+        dt = np.uint8  # WARNING: assuming 8-bit ASCII for np.str!
+    else:
+        dt = dtype
+
+    data_array = np.fromfile(fid, dt, nelements)
+    data_array.shape = (nelements, 1)
+
+    return data_array
+
+
+def parse_utf16_string(file_, encoding="UTF16"):
+
+    """Parse a pascal type UTF16 encoded string from a binary file object"""
+
+    # First read the expected number of CHARACTERS
+    string_length = unpack(UINT8, file_.read(1))[0]
+    # Then read and decode
+    parsed = unpack(STRING.format(2 * string_length), file_.read(2 * string_length))
+    return parsed[0].decode(encoding)
+
+
+class cached_property(object):
+
+    """A property that is only computed once per instance and then replaces
+    itself with an ordinary attribute. Deleting the attribute resets the
+    property.
+
+    https://github.com/bottlepy/bottle/commit/fa7733e075da0d790d809aa3d2f53071897e6f76
+    """
+
+    def __init__(self, func):
+        self.__doc__ = getattr(func, "__doc__")
+        self.func = func
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self
+        value = obj.__dict__[self.func.__name__] = self.func(obj)
+        return value
+
+
+class CHFile(object):
+
+    """Class that implementats the Agilent .ch file format version
+    130. Warning: Not all aspects of the file header is understood,
+    so there may and probably is information that is not parsed. See
+    _parse_header_status for an overview of which parts of the header
+    is understood.
+
+    Attributes:
+        values (numpy.array): The internsity values (y-value) or the
+        spectrum. The unit for the values is given in `metadata['units']`
+
+        metadata (dict): The extracted metadata
+
+        filepath (str): The filepath this object was loaded from
+    """
+
+    # Fields is a table of name, offset and type. Types 'x-time' and 'utf16'
+    # are specially handled, the rest are format arguments for struct unpack
+    fields = (
+        ("sequence_line_or_injection", 252, UINT16),
+        ("injection_or_sequence_line", 256, UINT16),
+        ("data_offset", 264, UINT32),
+        ("start_time", 282, "x-time"),
+        ("end_time", 286, "x-time"),
+        ("version_string", 326, "utf16"),
+        ("description", 347, "utf16"),
+        ("sample", 858, "utf16"),
+        ("operator", 1880, "utf16"),
+        ("date", 2391, "utf16"),
+        ("inlet", 2492, "utf16"),
+        ("instrument", 2533, "utf16"),
+        ("method", 2574, "utf16"),
+        ("software version", 3601, "utf16"),
+        ("software name", 3089, "utf16"),
+        ("software revision", 3802, "utf16"),
+        ("zero", 4110, INT32),
+        ("units", 4172, "utf16"),
+        ("detector", 4213, "utf16"),
+        ("yscaling", 4732, ENDIAN + "d"),
+    )
+
+    # The start position of the data
+    # Get it from metadata['data_offset'] * 512
+    data_start = 6144
+
+    # The versions of the file format supported by this implementation
+    supported_versions = {130}
+
+    def __init__(self, filepath):
+
+        self.filepath = filepath
+        self.metadata = {}
+        with open(self.filepath, "rb") as file_:
+            self._parse_header(file_)
+            self.values = self._parse_data(file_)
+
+    def _parse_header(self, file_):
+
+        """Parse the header"""
+
+        # Parse and check version
+        length = unpack(UINT8, file_.read(1))[0]
+        parsed = unpack(STRING.format(length), file_.read(length))
+        version = int(parsed[0])
+        if version not in self.supported_versions:
+            raise ValueError("Unsupported file version {}".format(version))
+        self.metadata["magic_number_version"] = version
+
+        # Parse all metadata fields
+        for name, offset, type_ in self.fields:
+            file_.seek(offset)
+            if type_ == "utf16":
+                self.metadata[name] = parse_utf16_string(file_)
+            elif type_ == "x-time":
+                self.metadata[name] = unpack(UINT32, file_.read(4))[0] / 60000
+            else:
+                self.metadata[name] = unpack(type_, file_.read(struct.calcsize(type_)))[
+                    0
+                ]
+
+    def _parse_header_status(self):
+
+        """Print known and unknown parts of the header"""
+
+        file_ = open(self.filepath, "rb")
+
+        print("Header parsing status")
+        # Map positions to fields for all the known fields
+        knowns = {item[1]: item for item in self.fields}
+        # A couple of places has a \x01 byte before a string, these we simply
+        # skip
+        skips = {325, 3600}
+        # Jump to after the magic number version
+        file_.seek(4)
+
+        # Initialize variables for unknown bytes
+        unknown_start = None
+        unknown_bytes = b""
+        # While we have not yet reached the data
+        while file_.tell() < self.data_start:
+            current_position = file_.tell()
+            # Just continue on skip bytes
+            if current_position in skips:
+                file_.read(1)
+                continue
+
+            # If we know about a data field that starts at this point
+            if current_position in knowns:
+                # If we have collected unknown bytes, print them out and reset
+                if unknown_bytes != b"":
+                    print(
+                        "Unknown at", unknown_start, repr(unknown_bytes.rstrip(b"\x00"))
+                    )
+                    unknown_bytes = b""
+                    unknown_start = None
+
+                # Print out the position, type, name and value of the known
+                # value
+                print("Known field at {: >4},".format(current_position), end=" ")
+                name, _, type_ = knowns[current_position]
+                if type_ == "x-time":
+                    print(
+                        'x-time, "{: <19}'.format(name + '"'),
+                        unpack(ENDIAN + "f", file_.read(4))[0] / 60000,
+                    )
+                elif type_ == "utf16":
+                    print(
+                        ' utf16, "{: <19}'.format(name + '"'), parse_utf16_string(file_)
+                    )
+                else:
+                    size = struct.calcsize(type_)
+                    print(
+                        '{: >6}, "{: <19}'.format(type_, name + '"'),
+                        unpack(type_, file_.read(size))[0],
+                    )
+
+            # We do not know about a data field at this position If we have
+            # already collected 4 zero bytes, assume that we are done with
+            # this unkonw field, print and reset
+            else:
+                if unknown_bytes[-4:] == b"\x00\x00\x00\x00":
+                    print(
+                        "Unknown at", unknown_start, repr(unknown_bytes.rstrip(b"\x00"))
+                    )
+                    unknown_bytes = b""
+                    unknown_start = None
+
+                # Read one byte and save it
+                one_byte = file_.read(1)
+                if unknown_bytes == b"":
+                    # Only start a new collection of unknown bytes, if this
+                    # byte is not a zero byte
+                    if one_byte != b"\x00":
+                        unknown_bytes = one_byte
+                        unknown_start = file_.tell() - 1
+                else:
+                    unknown_bytes += one_byte
+
+        file_.close()
+
+    def _parse_data(self, file_):
+
+        """Parse the data. Decompress the delta-encoded data, and scale them
+        with y-scaling"""
+
+        scaling = self.metadata["yscaling"]
+
+        # Go to the end of the file
+        file_.seek(0, 2)
+        stop = file_.tell()
+
+        # Go to the start point of the data
+        file_.seek(self.data_start)
+
+        signal = []
+
+        buff = [0, 0, 0, 0]
+
+        while file_.tell() < stop:
+
+            buff[0] = fread(file_, 1, INT16)[0][0]
+            buff[1] = buff[3]
+
+            if buff[0] << 12 == 0:
+                break
+
+            for i in range(buff[0] & 4095):
+
+                buff[2] = fread(file_, 1, INT16)[0][0]
+
+                if buff[2] != -32768:
+                    buff[1] = buff[1] + buff[2]
+                else:
+                    buff[1] = fread(file_, 1, INT32)[0][0]
+
+                signal.append(buff[1])
+
+            buff[3] = buff[1]
+
+        signal = np.array(signal)
+        signal = signal * scaling
+
+        return signal
+
+    @cached_property
+    def times(self):
+
+        """The time values (x-value) for the data set in minutes"""
+
+        return np.linspace(
+            self.metadata["start_time"], self.metadata["end_time"], len(self.values)
+        )
+
+
+if __name__ == "__main__":
+    CHFile("lcdiag.reg")

ag_hplc_macro/utils/constants.py

@@ -0,0 +1,15 @@
+from pychemstation.utils.hplc_param_types import Table
+
+# maximum command number
+MAX_CMD_NO = 255
+
+# tables
+METHOD_TIMETABLE = Table(
+    register="RCPMP1Method[1]",
+    name="Timetable"
+)
+
+SEQUENCE_TABLE = Table(
+    register="_sequence[1]",
+    name="SeqTable1"
+)

ag_hplc_macro/utils/hplc_param_types.py

@@ -0,0 +1,185 @@
+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

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

hein-analytical-control/analysis/__init__.py

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