pychemstation 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

pychemstation/utils/chemstation.py

@@ -1,290 +0,0 @@
-#!/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")

pychemstation/utils/constants.py

@@ -1,15 +0,0 @@
-from ..utils.table_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"
-)

pychemstation/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)

pychemstation-0.5.2.dist-info/RECORD

@@ -1,40 +0,0 @@
-.DS_Store,sha256=1lFlJ5EFymdzGAUAaI30vcaaLHt3F1LwpG7xILf9jsM,6148
-pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
-pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt420YMI4,44
-pychemstation/analysis/base_spectrum.py,sha256=XPf9eJ72uz0CnxCY5uFOyu1MbVX-OTTXeN1tLzIMok4,16536
-pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-GKjiDi8,10201
-pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
-pychemstation/control/__init__.py,sha256=aH9cPf-ljrVeVhN0K3cyEcAavmPXCjhhOnpLNf8qLqE,106
-pychemstation/control/chromatogram.py,sha256=c4_RGconn4vYU9wyS0WX-GB5FlwnBf_sfVLh_GpeehE,3716
-pychemstation/control/comm.py,sha256=8hjzp-MWWDYyYsEOdlpaJeWd-8eDQw5Y84pyMToK8gE,6008
-pychemstation/control/hplc.py,sha256=xsfg0VWHSYy2f0YWxCAKxbyDla-POhp02zF5tgBPIVo,5829
-pychemstation/control/method.py,sha256=h9KcccDtqx0hQT7JaUc1TWCB8d21t0McOuzeBsEsh4c,10977
-pychemstation/control/sequence.py,sha256=ewc7l44VAtv3wHV2QgOILu5Ny3gmubHuEeHJN9N6OjQ,7511
-pychemstation/control/table_controller.py,sha256=83i1J2CvIrJ3NtAB_E46qhUe8MvXo1_GnDPmuiq-vSA,2957
-pychemstation/control/table/__init__.py,sha256=RgMN4uIWHdNUHpGRBWdzmzAbk7XEKl6Y-qtqWCxzSZU,124
-pychemstation/control/table/method.py,sha256=pywWVFXpdewA-5pXmcmvauX2WsjFQtrAiOSBFYCJfLE,11946
-pychemstation/control/table/sequence.py,sha256=mVay_KJNgL37GQBsVcxnQk9J7nPfRCzu5J17m6w8vMQ,8499
-pychemstation/control/table/table_controller.py,sha256=g8IPKIyLbPcXfJDN2DvKtPd9sImbUdoI44qTutQzPi8,4986
-pychemstation/generated/__init__.py,sha256=GAoZFAYbPVEJDkcOw3e1rgOqd7TCW0HyKNPM8OMehMg,1005
-pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCsHRFQ0rmM,8402
-pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
-pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/utils/chemstation.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
-pychemstation/utils/chromatogram.py,sha256=35nvEh6prVsWO6lMHYgGuidUOFHv954_7MNf0Az3Fz4,3759
-pychemstation/utils/constants.py,sha256=jLY-NixemSofukzSXJhAIU4aO2IJmBRAhAcq5066mFI,249
-pychemstation/utils/hplc_param_types.py,sha256=xvmsbYQp3iiS1-0-9eUy--5zk_wE1bkrlHEHSm0UC18,5206
-pychemstation/utils/macro.py,sha256=ngIhLfFCRXbFzfFu5y3LbWy16W1T2CErnx1374JjG0w,2284
-pychemstation/utils/method_types.py,sha256=tVpmWKa2BdkvpaEcvVIKOTjF76ZfHGryw168GXYoKDA,868
-pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
-pychemstation/utils/sequence_types.py,sha256=fvoEsJaw3M0ADMNnIFzkHl07-tzqYHylPFeeJ8AdwZ8,867
-pychemstation/utils/table_types.py,sha256=BBCRoz1R6zPV1i2u2Tdku7WwIp6EDv1rUuZVPVNgO1A,2090
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=TPwdBhG9M7VIZ5sxqEfspqC2pUS9ZSQM4z7ZKiKwzSo,625
-tests/test_comm.py,sha256=SvA9xuYnyXApMN2NniEW3rDRadknjCgKwlCV4WANyfk,2460
-tests/test_method.py,sha256=DGMDGj_O-YDc4-JYVEP152DxH81qsHP3E-5ZDlaKmTQ,2203
-tests/test_sequence.py,sha256=83Ii7GI7OlBqugxMXKcP1xrZLwed6jABMecQoEQp9ac,3930
-pychemstation-0.5.2.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.2.dist-info/METADATA,sha256=7b6fapSIzcB1xHFUvifLjXdJObdQPpdTbnOBYvV2Gmc,3959
-pychemstation-0.5.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.2.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.2.dist-info/RECORD,,