pychemstation.utils.macro

  1from __future__ import annotations
  2
  3from dataclasses import dataclass
  4from enum import Enum
  5from typing import Union
  6
  7
  8@dataclass
  9class Response:
 10    """Class representing a response from Chemstation"""
 11
 12    string_response: str
 13    num_response: Union[int, float]
 14
 15
 16# Commands sent to the Chemstation Macro
 17# See https://www.agilent.com/cs/library/usermanuals/Public/MACROS.PDF
 18class Command(Enum):
 19    def __str__(self):
 20        return "%s" % self.value
 21
 22    GET_NUM_VAL_CMD = "response_num = {cmd}"
 23    GET_TEXT_VAL_CMD = "response$ = {cmd}"
 24    RESET_COUNTER_CMD = "last_cmd_no = 0"
 25    GET_STATUS_CMD = "response$ = AcqStatus$"
 26    SLEEP_CMD = "Sleep {seconds}"
 27    STANDBY_CMD = "Standby"
 28    STOP_MACRO_CMD = "Stop"
 29    PREPRUN_CMD = "PrepRun"
 30
 31    # Instrument Control
 32    LAMP_ON_CMD = "LampAll ON"
 33    LAMP_OFF_CMD = "LampAll OFF"
 34    PUMP_ON_CMD = "PumpAll ON"
 35    PUMP_OFF_CMD = "PumpAll OFF"
 36    COLUMN_ON_CMD = "ColumnAll ON"
 37    COLUMN_OFF_CMD = "ColumnAll OFF"
 38    INSTRUMENT_OFF = 'macro "SHUTDOWN.MAC" ,go'
 39    INSTRUMENT_ON = 'LIDoOperation "TURN_ON"'
 40
 41    # Method and Sequence Related
 42    GET_METHOD_CMD = "response$ = _MethFile$"
 43    GET_ROWS_CMD = 'response_num = TabHdrVal({register}, "{table_name}", "{col_name}")'
 44    SWITCH_METHOD_CMD = "LoadMethod _MethPath$, _MethFile$"
 45    SWITCH_METHOD_CMD_SPECIFIC = 'LoadMethod "{method_dir}", "{method_name}.M"'
 46    START_METHOD_CMD = "StartMethod"
 47    RUN_METHOD_CMD = 'RunMethod "{data_dir}",, "{experiment_name}"'
 48    STOP_METHOD_CMD = "StopMethod"
 49    UPDATE_METHOD_CMD = "UpdateMethod"
 50    SWITCH_SEQUENCE_CMD = "LoadSequence _SeqPath$, _SeqFile$"
 51    SAVE_SEQUENCE_CMD = "SaveSequence _SeqPath$, _SeqFile$"
 52    SAVE_METHOD_CMD = 'SaveMethod _MethPath$, _MethFile$, "{commit_msg}"'
 53    GET_SEQUENCE_CMD = "response$ = _SeqFile$"
 54    RUN_SEQUENCE_CMD = "RunSequence"
 55    CURRENT_RUNNING_SEQ_LINE = "response_num = _SEQCURRLINE1"
 56
 57    # Get directories
 58    GET_METHOD_DIR = "response$ = _METHPATH$"
 59    GET_SEQUENCE_DIR = "response$ = _SEQUENCEPATHS$"
 60    CONFIG_MET_PATH = "_CONFIGMETPATH"
 61    CONFIG_SEQ_PATH = "_CONFIGSEQPATH"
 62    GET_RUNNING_SEQUENCE_DIR = "response$ = _SEQPATHS$"
 63    GET_DATA_DIRS = "response$ = _DATAPATHS$"
 64    GET_CURRENT_RUN_DATA_DIR = "response$ = _DATAPath$"
 65    GET_CURRENT_RUN_DATA_FILE = "response$ = _DATAFILE1$"
 66
 67    # Errors
 68    ERROR = "response$ = _ERRMSG$"
 69
 70
 71class HPLCRunningStatus(Enum):
 72    @classmethod
 73    def has_member_key(cls, key):
 74        return key in cls.__members__
 75
 76    INJECTING = "INJECTING"
 77    PREPARING = "PREPARING"
 78    RUN = "RUN"
 79    NOTREADY = "NOTREADY"
 80    POSTRUN = "POSTRUN"
 81    RAWDATA = "RAWDATA"
 82    INITIALIZING = "INITIALIZING"
 83    NOMODULE = "NOMODULE"
 84
 85
 86class HPLCAvailStatus(Enum):
 87    @classmethod
 88    def has_member_key(cls, key):
 89        return key in cls.__members__
 90
 91    PRERUN = "PRERUN"
 92    OFFLINE = "OFFLINE"
 93    STANDBY = "STANDBY"
 94
 95
 96class HPLCErrorStatus(Enum):
 97    @classmethod
 98    def has_member_key(cls, key):
 99        return key in cls.__members__
100
101    ERROR = "ERROR"
102    BREAK = "BREAK"
103    NORESPONSE = "NORESPONSE"
104    MALFORMED = "MALFORMED"
105
106
107def str_to_status(
108    status: str,
109):
110    if HPLCErrorStatus.has_member_key(status):
111        return HPLCErrorStatus[status]
112    if HPLCRunningStatus.has_member_key(status):
113        return HPLCRunningStatus[status]
114    if HPLCAvailStatus.has_member_key(status):
115        return HPLCAvailStatus[status]
116    raise KeyError(status)
117
118
119Status = Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]
@dataclass
class Response:
 9@dataclass
10class Response:
11    """Class representing a response from Chemstation"""
12
13    string_response: str
14    num_response: Union[int, float]

Class representing a response from Chemstation

Response(string_response: str, num_response: Union[int, float])
string_response: str
num_response: Union[int, float]
class Command(enum.Enum):
19class Command(Enum):
20    def __str__(self):
21        return "%s" % self.value
22
23    GET_NUM_VAL_CMD = "response_num = {cmd}"
24    GET_TEXT_VAL_CMD = "response$ = {cmd}"
25    RESET_COUNTER_CMD = "last_cmd_no = 0"
26    GET_STATUS_CMD = "response$ = AcqStatus$"
27    SLEEP_CMD = "Sleep {seconds}"
28    STANDBY_CMD = "Standby"
29    STOP_MACRO_CMD = "Stop"
30    PREPRUN_CMD = "PrepRun"
31
32    # Instrument Control
33    LAMP_ON_CMD = "LampAll ON"
34    LAMP_OFF_CMD = "LampAll OFF"
35    PUMP_ON_CMD = "PumpAll ON"
36    PUMP_OFF_CMD = "PumpAll OFF"
37    COLUMN_ON_CMD = "ColumnAll ON"
38    COLUMN_OFF_CMD = "ColumnAll OFF"
39    INSTRUMENT_OFF = 'macro "SHUTDOWN.MAC" ,go'
40    INSTRUMENT_ON = 'LIDoOperation "TURN_ON"'
41
42    # Method and Sequence Related
43    GET_METHOD_CMD = "response$ = _MethFile$"
44    GET_ROWS_CMD = 'response_num = TabHdrVal({register}, "{table_name}", "{col_name}")'
45    SWITCH_METHOD_CMD = "LoadMethod _MethPath$, _MethFile$"
46    SWITCH_METHOD_CMD_SPECIFIC = 'LoadMethod "{method_dir}", "{method_name}.M"'
47    START_METHOD_CMD = "StartMethod"
48    RUN_METHOD_CMD = 'RunMethod "{data_dir}",, "{experiment_name}"'
49    STOP_METHOD_CMD = "StopMethod"
50    UPDATE_METHOD_CMD = "UpdateMethod"
51    SWITCH_SEQUENCE_CMD = "LoadSequence _SeqPath$, _SeqFile$"
52    SAVE_SEQUENCE_CMD = "SaveSequence _SeqPath$, _SeqFile$"
53    SAVE_METHOD_CMD = 'SaveMethod _MethPath$, _MethFile$, "{commit_msg}"'
54    GET_SEQUENCE_CMD = "response$ = _SeqFile$"
55    RUN_SEQUENCE_CMD = "RunSequence"
56    CURRENT_RUNNING_SEQ_LINE = "response_num = _SEQCURRLINE1"
57
58    # Get directories
59    GET_METHOD_DIR = "response$ = _METHPATH$"
60    GET_SEQUENCE_DIR = "response$ = _SEQUENCEPATHS$"
61    CONFIG_MET_PATH = "_CONFIGMETPATH"
62    CONFIG_SEQ_PATH = "_CONFIGSEQPATH"
63    GET_RUNNING_SEQUENCE_DIR = "response$ = _SEQPATHS$"
64    GET_DATA_DIRS = "response$ = _DATAPATHS$"
65    GET_CURRENT_RUN_DATA_DIR = "response$ = _DATAPath$"
66    GET_CURRENT_RUN_DATA_FILE = "response$ = _DATAFILE1$"
67
68    # Errors
69    ERROR = "response$ = _ERRMSG$"
GET_NUM_VAL_CMD = <Command.GET_NUM_VAL_CMD: 'response_num = {cmd}'>
GET_TEXT_VAL_CMD = <Command.GET_TEXT_VAL_CMD: 'response$ = {cmd}'>
RESET_COUNTER_CMD = <Command.RESET_COUNTER_CMD: 'last_cmd_no = 0'>
GET_STATUS_CMD = <Command.GET_STATUS_CMD: 'response$ = AcqStatus$'>
SLEEP_CMD = <Command.SLEEP_CMD: 'Sleep {seconds}'>
STANDBY_CMD = <Command.STANDBY_CMD: 'Standby'>
STOP_MACRO_CMD = <Command.STOP_MACRO_CMD: 'Stop'>
PREPRUN_CMD = <Command.PREPRUN_CMD: 'PrepRun'>
LAMP_ON_CMD = <Command.LAMP_ON_CMD: 'LampAll ON'>
LAMP_OFF_CMD = <Command.LAMP_OFF_CMD: 'LampAll OFF'>
PUMP_ON_CMD = <Command.PUMP_ON_CMD: 'PumpAll ON'>
PUMP_OFF_CMD = <Command.PUMP_OFF_CMD: 'PumpAll OFF'>
COLUMN_ON_CMD = <Command.COLUMN_ON_CMD: 'ColumnAll ON'>
COLUMN_OFF_CMD = <Command.COLUMN_OFF_CMD: 'ColumnAll OFF'>
INSTRUMENT_OFF = <Command.INSTRUMENT_OFF: 'macro "SHUTDOWN.MAC" ,go'>
INSTRUMENT_ON = <Command.INSTRUMENT_ON: 'LIDoOperation "TURN_ON"'>
GET_METHOD_CMD = <Command.GET_METHOD_CMD: 'response$ = _MethFile$'>
GET_ROWS_CMD = <Command.GET_ROWS_CMD: 'response_num = TabHdrVal({register}, "{table_name}", "{col_name}")'>
SWITCH_METHOD_CMD = <Command.SWITCH_METHOD_CMD: 'LoadMethod _MethPath$, _MethFile$'>
SWITCH_METHOD_CMD_SPECIFIC = <Command.SWITCH_METHOD_CMD_SPECIFIC: 'LoadMethod "{method_dir}", "{method_name}.M"'>
START_METHOD_CMD = <Command.START_METHOD_CMD: 'StartMethod'>
RUN_METHOD_CMD = <Command.RUN_METHOD_CMD: 'RunMethod "{data_dir}",, "{experiment_name}"'>
STOP_METHOD_CMD = <Command.STOP_METHOD_CMD: 'StopMethod'>
UPDATE_METHOD_CMD = <Command.UPDATE_METHOD_CMD: 'UpdateMethod'>
SWITCH_SEQUENCE_CMD = <Command.SWITCH_SEQUENCE_CMD: 'LoadSequence _SeqPath$, _SeqFile$'>
SAVE_SEQUENCE_CMD = <Command.SAVE_SEQUENCE_CMD: 'SaveSequence _SeqPath$, _SeqFile$'>
SAVE_METHOD_CMD = <Command.SAVE_METHOD_CMD: 'SaveMethod _MethPath$, _MethFile$, "{commit_msg}"'>
GET_SEQUENCE_CMD = <Command.GET_SEQUENCE_CMD: 'response$ = _SeqFile$'>
RUN_SEQUENCE_CMD = <Command.RUN_SEQUENCE_CMD: 'RunSequence'>
CURRENT_RUNNING_SEQ_LINE = <Command.CURRENT_RUNNING_SEQ_LINE: 'response_num = _SEQCURRLINE1'>
GET_METHOD_DIR = <Command.GET_METHOD_DIR: 'response$ = _METHPATH$'>
GET_SEQUENCE_DIR = <Command.GET_SEQUENCE_DIR: 'response$ = _SEQUENCEPATHS$'>
CONFIG_MET_PATH = <Command.CONFIG_MET_PATH: '_CONFIGMETPATH'>
CONFIG_SEQ_PATH = <Command.CONFIG_SEQ_PATH: '_CONFIGSEQPATH'>
GET_RUNNING_SEQUENCE_DIR = <Command.GET_RUNNING_SEQUENCE_DIR: 'response$ = _SEQPATHS$'>
GET_DATA_DIRS = <Command.GET_DATA_DIRS: 'response$ = _DATAPATHS$'>
GET_CURRENT_RUN_DATA_DIR = <Command.GET_CURRENT_RUN_DATA_DIR: 'response$ = _DATAPath$'>
GET_CURRENT_RUN_DATA_FILE = <Command.GET_CURRENT_RUN_DATA_FILE: 'response$ = _DATAFILE1$'>
ERROR = <Command.ERROR: 'response$ = _ERRMSG$'>
class HPLCRunningStatus(enum.Enum):
72class HPLCRunningStatus(Enum):
73    @classmethod
74    def has_member_key(cls, key):
75        return key in cls.__members__
76
77    INJECTING = "INJECTING"
78    PREPARING = "PREPARING"
79    RUN = "RUN"
80    NOTREADY = "NOTREADY"
81    POSTRUN = "POSTRUN"
82    RAWDATA = "RAWDATA"
83    INITIALIZING = "INITIALIZING"
84    NOMODULE = "NOMODULE"
@classmethod
def has_member_key(cls, key):
73    @classmethod
74    def has_member_key(cls, key):
75        return key in cls.__members__
INJECTING = <HPLCRunningStatus.INJECTING: 'INJECTING'>
PREPARING = <HPLCRunningStatus.PREPARING: 'PREPARING'>
RUN = <HPLCRunningStatus.RUN: 'RUN'>
NOTREADY = <HPLCRunningStatus.NOTREADY: 'NOTREADY'>
POSTRUN = <HPLCRunningStatus.POSTRUN: 'POSTRUN'>
RAWDATA = <HPLCRunningStatus.RAWDATA: 'RAWDATA'>
INITIALIZING = <HPLCRunningStatus.INITIALIZING: 'INITIALIZING'>
NOMODULE = <HPLCRunningStatus.NOMODULE: 'NOMODULE'>
class HPLCAvailStatus(enum.Enum):
87class HPLCAvailStatus(Enum):
88    @classmethod
89    def has_member_key(cls, key):
90        return key in cls.__members__
91
92    PRERUN = "PRERUN"
93    OFFLINE = "OFFLINE"
94    STANDBY = "STANDBY"
@classmethod
def has_member_key(cls, key):
88    @classmethod
89    def has_member_key(cls, key):
90        return key in cls.__members__
PRERUN = <HPLCAvailStatus.PRERUN: 'PRERUN'>
OFFLINE = <HPLCAvailStatus.OFFLINE: 'OFFLINE'>
STANDBY = <HPLCAvailStatus.STANDBY: 'STANDBY'>
class HPLCErrorStatus(enum.Enum):
 97class HPLCErrorStatus(Enum):
 98    @classmethod
 99    def has_member_key(cls, key):
100        return key in cls.__members__
101
102    ERROR = "ERROR"
103    BREAK = "BREAK"
104    NORESPONSE = "NORESPONSE"
105    MALFORMED = "MALFORMED"
@classmethod
def has_member_key(cls, key):
 98    @classmethod
 99    def has_member_key(cls, key):
100        return key in cls.__members__
ERROR = <HPLCErrorStatus.ERROR: 'ERROR'>
BREAK = <HPLCErrorStatus.BREAK: 'BREAK'>
NORESPONSE = <HPLCErrorStatus.NORESPONSE: 'NORESPONSE'>
MALFORMED = <HPLCErrorStatus.MALFORMED: 'MALFORMED'>
def str_to_status(status: str):
108def str_to_status(
109    status: str,
110):
111    if HPLCErrorStatus.has_member_key(status):
112        return HPLCErrorStatus[status]
113    if HPLCRunningStatus.has_member_key(status):
114        return HPLCRunningStatus[status]
115    if HPLCAvailStatus.has_member_key(status):
116        return HPLCAvailStatus[status]
117    raise KeyError(status)