pychemstation 0.4.7.dev2__py3-none-any.whl → 0.5.0__py3-none-any.whl

pychemstation/control/table/__init__.py

@@ -0,0 +1,3 @@
+from .method import MethodController
+from .sequence import SequenceController
+from .table_controller import TableController

pychemstation/control/table/method.py

@@ -0,0 +1,258 @@
+import os
+import time
+from typing import Optional, Any
+
+from xsdata.formats.dataclass.parsers import XmlParser
+
+from .. import CommunicationController
+from ...control.table.table_controller import TableController
+from ...generated import PumpMethod, DadMethod, SolventElement
+from ...utils.chromatogram import TIME_FORMAT
+from ...utils.constants import METHOD_TIMETABLE
+from ...utils.macro import Command
+from ...utils.method_types import PType, TimeTableEntry, Param, MethodTimetable, HPLCMethodParams
+from ...utils.table_types import RegisterFlag, TableOperation
+
+
+class MethodController(TableController):
+    """
+    Class containing method related logic
+    """
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str):
+        super().__init__(controller, src, data_dir)
+
+    def is_loaded(self, method_name: str):
+        """
+        Checks if a given method is already loaded into Chemstation. Method name does not need the ".M" extension.
+
+        :param method_name: a Chemstation method
+        :return: True if method is already loaded
+        """
+        self.send(Command.GET_METHOD_CMD)
+        parsed_response = self.receive().splitlines()[1].split()[1:][0]
+        return method_name in parsed_response
+
+    def switch(self, method_name: str):
+        """
+        Allows the user to switch between pre-programmed methods. No need to append '.M'
+        to the end of the method name. For example. for the method named 'General-Poroshell.M',
+        only 'General-Poroshell' is needed.
+
+        :param method_name: any available method in Chemstation method directory
+        :raise IndexError: Response did not have expected format. Try again.
+        :raise AssertionError: The desired method is not selected. Try again.
+        """
+        self.send(Command.SWITCH_METHOD_CMD.value.format(method_dir=self.src,
+                                                         method_name=method_name))
+
+        time.sleep(2)
+        self.send(Command.GET_METHOD_CMD)
+        time.sleep(2)
+
+        # check that method switched
+        for _ in range(10):
+            try:
+                parsed_response = self.receive().splitlines()[1].split()[1:][0]
+                break
+            except IndexError:
+                continue
+
+        assert parsed_response == f"{method_name}.M", "Switching Methods failed."
+
+    def load(self, method_name: str):
+        """
+        Retrieve method details of an existing method. Don't need to append ".M" to the end. This assumes the
+        organic modifier is in Channel B and that Channel A contains the aq layer. Additionally, assumes
+         only two solvents are being used.
+
+        :param method_name: name of method to load details of
+        :raises FileNotFoundError: Method does not exist
+        :return: method details
+        """
+        method_folder = f"{method_name}.M"
+        method_path = os.path.join(self.src, method_folder, "AgilentPumpDriver1.RapidControl.MethodXML.xml")
+        dad_path = os.path.join(self.src, method_folder, "Agilent1200erDadDriver1.RapidControl.MethodXML.xml")
+
+        if os.path.exists(os.path.join(self.src, f"{method_name}.M")):
+            parser = XmlParser()
+            method = parser.parse(method_path, PumpMethod)
+            dad = parser.parse(dad_path, DadMethod)
+
+            organic_modifier: Optional[SolventElement] = None
+            aq_modifier: Optional[SolventElement] = None
+
+            if len(method.solvent_composition.solvent_element) == 2:
+                for solvent in method.solvent_composition.solvent_element:
+                    if solvent.channel == "Channel_A":
+                        aq_modifier = solvent
+                    elif solvent.channel == "Channel_B":
+                        organic_modifier = solvent
+
+            return MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=Param(val=organic_modifier.percentage,
+                                           chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+                                           ptype=PType.NUM),
+                    flow=Param(val=method.flow,
+                               chemstation_key=RegisterFlag.FLOW,
+                               ptype=PType.NUM),
+                    maximum_run_time=Param(val=method.stop_time,
+                                           chemstation_key=RegisterFlag.MAX_TIME,
+                                           ptype=PType.NUM),
+                    temperature=Param(val=None,
+                                      chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
+                                                       RegisterFlag.COLUMN_OVEN_TEMP2],
+                                      ptype=PType.NUM),
+                    inj_vol=Param(val=None,
+                                  chemstation_key=None,
+                                  ptype=PType.NUM),
+                    equ_time=Param(val=None,
+                                   chemstation_key=None,
+                                   ptype=PType.NUM)),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=tte.time,
+                        organic_modifer=tte.percent_b,
+                        flow=method.flow
+                    ) for tte in method.timetable.timetable_entry
+                ],
+                dad_wavelengthes=dad.signals.signal,
+                organic_modifier=organic_modifier,
+                modifier_a=aq_modifier
+            )
+        else:
+            raise FileNotFoundError
+
+    def edit(self, updated_method: MethodTimetable):
+        """Updated the currently loaded method in ChemStation with provided values.
+
+        :param updated_method: the method with updated values, to be sent to Chemstation to modify the currently loaded method.
+        """
+        initial_organic_modifier: Param = Param(val=updated_method.first_row.organic_modifier,
+                                                chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+                                                ptype=PType.NUM)
+        max_time: Param = Param(val=updated_method.first_row.maximum_run_time,
+                                chemstation_key=RegisterFlag.MAX_TIME,
+                                ptype=PType.NUM)
+        flow: Param = Param(val=updated_method.first_row.flow,
+                            chemstation_key=RegisterFlag.FLOW,
+                            ptype=PType.NUM)
+        temperature: Param = Param(val=updated_method.first_row.temperature,
+                                   chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
+                                                   RegisterFlag.COLUMN_OVEN_TEMP2],
+                                   ptype=PType.NUM)
+
+        # Method settings required for all runs
+        self.delete_table(METHOD_TIMETABLE)
+        self._update_param(initial_organic_modifier)
+        self._update_param(flow)
+        self._update_param(Param(val="Set",
+                                 chemstation_key=RegisterFlag.STOPTIME_MODE,
+                                 ptype=PType.STR))
+        self._update_param(max_time)
+        self._update_param(Param(val="Off",
+                                 chemstation_key=RegisterFlag.POSTIME_MODE,
+                                 ptype=PType.STR))
+
+        self.send("DownloadRCMethod PMP1")
+
+        self._update_method_timetable(updated_method.subsequent_rows)
+
+    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
+        self.sleepy_send('Local Rows')
+        self._get_table_rows(METHOD_TIMETABLE)
+
+        self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+        res = self._get_table_rows(METHOD_TIMETABLE)
+        while "ERROR" not in res:
+            self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+            res = self._get_table_rows(METHOD_TIMETABLE)
+
+        self.sleepy_send('NewTab RCPMP1Method[1], "Timetable"')
+        self._get_table_rows(METHOD_TIMETABLE)
+
+        for i, row in enumerate(timetable_rows):
+            if i == 0:
+                self.send('Sleep 1')
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
+                self.send('Sleep 1')
+
+                self.sleepy_send('NewColText RCPMP1Method[1], "Timetable", "Function", "SolventComposition"')
+                self.sleepy_send(f'NewColVal RCPMP1Method[1], "Timetable", "Time", {row.start_time}')
+                self.sleepy_send(
+                    f'NewColVal RCPMP1Method[1], "Timetable", "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
+
+                self.send('Sleep 1')
+                self.sleepy_send("DownloadRCMethod PMP1")
+                self.send('Sleep 1')
+            else:
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
+                self._get_table_rows(METHOD_TIMETABLE)
+
+                self.sleepy_send(
+                    f'SetTabText RCPMP1Method[1], "Timetable", Rows, "Function", "SolventComposition"')
+                self.sleepy_send(
+                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "Time", {row.start_time}')
+                self.sleepy_send(
+                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
+
+                self.send("Sleep 1")
+                self.sleepy_send("DownloadRCMethod PMP1")
+                self.send("Sleep 1")
+                self._get_table_rows(METHOD_TIMETABLE)
+
+    def _update_param(self, method_param: Param):
+        """Change a method parameter, changes what is visibly seen in Chemstation GUI.
+         (changes the first row in the timetable)
+
+        :param method_param: a parameter to update for currently loaded method.
+        """
+        register = METHOD_TIMETABLE.register
+        setting_command = TableOperation.UPDATE_OBJ_HDR_VAL if method_param.ptype == PType.NUM else TableOperation.UPDATE_OBJ_HDR_TEXT
+        if isinstance(method_param.chemstation_key, list):
+            for register_flag in method_param.chemstation_key:
+                self.send(setting_command.value.format(register=register,
+                                                       register_flag=register_flag,
+                                                       val=method_param.val))
+        else:
+            self.send(setting_command.value.format(register=register,
+                                                   register_flag=method_param.chemstation_key,
+                                                   val=method_param.val))
+        time.sleep(2)
+
+    def stop(self):
+        """
+        Stops the method run. A dialog window will pop up and manual intervention may be required.\
+        """
+        self.send(Command.STOP_METHOD_CMD)
+
+    def run(self, experiment_name: str):
+        """
+        This is the preferred method to trigger a run.
+        Starts the currently selected method, storing data
+        under the <data_dir>/<experiment_name>.D folder.
+        The <experiment_name> will be appended with a timestamp in the '%Y-%m-%d-%H-%M' format.
+        Device must be ready.
+
+        :param experiment_name: Name of the experiment
+        """
+        timestamp = time.strftime(TIME_FORMAT)
+
+        self.send(Command.RUN_METHOD_CMD.value.format(data_dir=self.data_dir,
+                                                      experiment_name=experiment_name,
+                                                      timestamp=timestamp))
+
+        folder_name = f"{experiment_name}_{timestamp}.D"
+        self.data_files.append(os.path.join(self.data_dir, folder_name))
+
+    def retrieve_recent_data_files(self) -> str:
+        return self.data_files[-1]
+
+    def get_data(self) -> tuple[bool, Any]:
+        data_ready = self.data_ready()
+        if data_ready:
+            self.get_spectrum(self.data_files[-1])
+            return data_ready, self.spectra
+        else:
+            return False, None

pychemstation/control/table/sequence.py

@@ -0,0 +1,170 @@
+from typing import Any
+
+from copy import deepcopy
+
+import os
+import time
+
+from .table_controller import TableController
+from ...control import CommunicationController
+from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentHPLCChromatogram
+from ...utils.constants import SEQUENCE_TABLE
+from ...utils.macro import Command
+from ...utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles
+from ...utils.table_types import TableOperation, RegisterFlag
+
+
+class SequenceController(TableController):
+    """
+    Class containing sequence related logic
+    """
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str):
+        super().__init__(controller, src, data_dir)
+
+    def switch(self, seq_name: str):
+        """
+        Switch to the specified sequence. The sequence name does not need the '.S' extension.
+
+        :param seq_name: The name of the sequence file
+        """
+        self.send(f'_SeqFile$ = "{seq_name}.S"')
+        self.send(f'_SeqPath$ = "{self.src}"')
+        self.send(Command.SWITCH_SEQUENCE_CMD)
+        time.sleep(2)
+        self.send(Command.GET_SEQUENCE_CMD)
+        time.sleep(2)
+        # check that method switched
+        for _ in range(10):
+            try:
+                parsed_response = self.receive().splitlines()[1].split()[1:][0]
+                break
+            except IndexError:
+                continue
+
+        assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
+
+    def edit(self, sequence_table: SequenceTable):
+        """
+        Updates the currently loaded sequence table with the provided table. This method will delete the existing sequence table and remake it.
+        If you would only like to edit a single row of a sequence table, use `edit_sequence_table_row` instead.
+
+        :param sequence_table:
+        """
+        self.send("Local Rows")
+        self.sleep(1)
+        self.delete_table(SEQUENCE_TABLE)
+        self.sleep(1)
+        self.new_table(SEQUENCE_TABLE)
+        self.sleep(1)
+        self._get_table_rows(SEQUENCE_TABLE)
+
+        for _ in sequence_table.rows:
+            self.add_table_row(SEQUENCE_TABLE)
+            self.sleep(1)
+            self.send(Command.SAVE_SEQUENCE_CMD)
+        self._get_table_rows(SEQUENCE_TABLE)
+        self.send(Command.SAVE_SEQUENCE_CMD)
+        self.send(Command.SWITCH_SEQUENCE_CMD)
+
+        for i, row in enumerate(sequence_table.rows):
+            self.edit_row(row=row, row_num=i + 1)
+            self.sleep(1)
+        self.send(Command.SAVE_SEQUENCE_CMD)
+
+
+    def edit_row(self, row: SequenceEntry, row_num: int):
+        """
+        Edits a row in the sequence table. Assumes the row already exists.
+
+        :param row: sequence row entry with updated information
+        :param row_num: the row to edit, based on -1-based indexing
+        """
+        if row.vial_location:
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=SEQUENCE_TABLE.register,
+                                                                      table_name=SEQUENCE_TABLE.name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.VIAL_LOCATION,
+                                                                      val=row.vial_location))
+        if row.method:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.METHOD,
+                                                                       val=row.method))
+
+        if row.num_inj:
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=SEQUENCE_TABLE.register,
+                                                                      table_name=SEQUENCE_TABLE.name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.NUM_INJ,
+                                                                      val=row.num_inj))
+
+        if row.inj_vol:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.INJ_VOL,
+                                                                       val=row.inj_vol))
+
+        if row.inj_source:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.INJ_SOR,
+                                                                       val=row.inj_source.value))
+
+        if row.sample_name:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.NAME,
+                                                                       val=row.sample_name))
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.DATA_FILE,
+                                                                       val=row.sample_name))
+        if row.sample_type:
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=SEQUENCE_TABLE.register,
+                                                                      table_name=SEQUENCE_TABLE.name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.SAMPLE_TYPE,
+                                                                      val=row.sample_type.value))
+
+    def run(self, sequence_table: SequenceTable):
+        """
+        Starts the currently loaded sequence, storing data
+        under the <data_dir>/<sequence table name> folder.
+        Device must be ready.
+
+        :param sequence_table:
+        """
+        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
+        # self.send(Command.RUN_SEQUENCE_CMD.value)
+        folder_name = f"{sequence_table.name} {timestamp}"
+        subdirs = [x[0] for x in os.walk(self.data_dir)]
+        # time.sleep(60)
+        potential_folders = sorted(list(filter(lambda d: folder_name in d, subdirs)))
+        parent_folder = potential_folders[0]
+        self.data_files.append(SequenceDataFiles(
+            sequence_name=sequence_table.name,
+            dir=parent_folder,
+            child_dirs=[r.sample_name + ".D" for r in sequence_table.rows]))
+
+    def retrieve_recent_data_files(self):
+        sequence_data_files: SequenceDataFiles = self.data_files[-1]
+        return os.path.join(sequence_data_files.dir, sequence_data_files.child_dirs[-1])
+
+    def get_data(self) -> tuple[bool, Any]:
+        data_ready = True # self.data_ready()
+        sequence_data_files: SequenceDataFiles = self.data_files[-1]
+        spectra: list[dict[str, AgilentHPLCChromatogram]] = []
+        if data_ready:
+            for row in sequence_data_files.child_dirs:
+                data_path = os.path.join(sequence_data_files.dir, row)
+                self.get_spectrum(data_path)
+                spectra.append(deepcopy(self.spectra))
+            return data_ready, spectra
+        else:
+            return False, None

pychemstation/control/table/table_controller.py

@@ -0,0 +1,137 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+Authors: Lucy Hao
+"""
+
+import abc
+import os
+from typing import Union, Optional
+
+import polling
+
+from ...control import CommunicationController
+from ...utils.chromatogram import AgilentHPLCChromatogram
+from ...utils.macro import Command
+from ...utils.method_types import MethodTimetable
+from ...utils.sequence_types import SequenceDataFiles
+from ...utils.table_types import Table, TableOperation, RegisterFlag
+
+
+class TableController(abc.ABC):
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str):
+        self.controller = controller
+        if os.path.isdir(src):
+            self.src: str = src
+        else:
+            raise FileNotFoundError(f"dir: {src} not found.")
+
+        if os.path.isdir(data_dir):
+            self.data_dir: str = data_dir
+        else:
+            raise FileNotFoundError(f"dir: {data_dir} not found.")
+
+        self.spectra = {
+            "A": AgilentHPLCChromatogram(self.data_dir),
+            "B": AgilentHPLCChromatogram(self.data_dir),
+            "C": AgilentHPLCChromatogram(self.data_dir),
+            "D": AgilentHPLCChromatogram(self.data_dir),
+        }
+
+        self.data_files: Union[list[SequenceDataFiles], list[str]] = []
+
+    def receive(self):
+        return self.controller.receive()
+
+    def send(self, cmd: Union[Command, str]):
+        self.controller.send(cmd)
+
+    def sleepy_send(self, cmd: Union[Command, str]):
+        self.controller.sleepy_send(cmd)
+
+    def sleep(self, seconds: int):
+        """
+        Tells the HPLC to wait for a specified number of seconds.
+
+        :param seconds: number of seconds to wait
+        """
+        self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
+
+    def add_table_row(self, table: Table):
+        """
+        Adds a row to the provided table for currently loaded method or sequence.
+        Import either the SEQUENCE_TABLE or METHOD_TIMETABLE from hein_analytical_control.constants.
+        You can also provide your own table.
+
+        :param table: the table to add a new row to
+        """
+        self.sleepy_send(TableOperation.NEW_ROW.value.format(register=table.register,
+                                                             table_name=table.name))
+
+    def delete_table(self, table: Table):
+        """
+        Deletes the table for the current loaded method or sequence.
+        Import either the SEQUENCE_TABLE or METHOD_TIMETABLE from hein_analytical_control.constants.
+        You can also provide your own table.
+
+        :param table: the table to delete
+        """
+        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=table.register,
+                                                                  table_name=table.name))
+
+    def new_table(self, table: Table):
+        """
+        Creates the table for the currently loaded method or sequence. Import either the SEQUENCE_TABLE or
+        METHOD_TIMETABLE from hein_analytical_control.constants. You can also provide your own table.
+
+        :param table: the table to create
+        """
+        self.send(TableOperation.CREATE_TABLE.value.format(register=table.register,
+                                                           table_name=table.name))
+
+    def _get_table_rows(self, table: Table) -> str:
+        self.send(TableOperation.GET_OBJ_HDR_VAL.value.format(internal_val="Rows",
+                                                              register=table.register,
+                                                              table_name=table.name,
+                                                              col_name=RegisterFlag.NUM_ROWS, ))
+        res = self.controller.receive()
+        self.send("Sleep 1")
+        self.send('Print Rows')
+        return res
+
+    def check_hplc_ready_with_data(self, method: Optional[MethodTimetable] = None) -> bool:
+        """
+        Checks if ChemStation has finished writing data and can be read back.
+
+        :param method: if you are running a method and want to read back data, the timeout period will be adjusted to be longer than the method's runtime
+        :return: Return True if data can be read back, else False.
+        """
+        self.controller.set_status()
+
+        timeout = 10 * 60
+        hplc_run_done = polling.poll(
+            lambda: self.controller.check_data(self.retrieve_recent_data_files()),
+            timeout=timeout,
+            step=30
+        )
+
+        return hplc_run_done
+
+    @abc.abstractmethod
+    def retrieve_recent_data_files(self):
+        pass
+
+    @abc.abstractmethod
+    def get_data(self) -> tuple[bool,]:
+        pass
+
+    def get_spectrum(self, data_file: str):
+        """
+        Load chromatogram for any channel in spectra dictionary.
+        """
+        for channel, spec in self.spectra.items():
+            spec.load_spectrum(data_path=data_file, channel=channel)
+
+    def data_ready(self) -> bool:
+        return self.check_hplc_ready_with_data()

pychemstation/utils/chromatogram.py

@@ -12,14 +12,13 @@ from ..analysis import AbstractSpectrum
 # Chemstation data path
 DATA_DIR = r"C:\Chem32\1\Data"
 
-
 # standard filenames for spectral data
 CHANNELS = {"A": "01", "B": "02", "C": "03", "D": "04"}
 
 ACQUISITION_PARAMETERS = "acq.txt"
 
 # format used in acquisition parameters
-TIME_FORMAT = "%Y-%m-%d-%H-%M-%S"
+TIME_FORMAT = "%Y-%m-%d %H-%M-%S"
 SEQUENCE_TIME_FORMAT = "%Y-%m-%d %H"
 
 
@@ -51,8 +50,6 @@ class AgilentHPLCChromatogram(AbstractSpectrum):
             self.path = os.path.join(".", "hplc_data")
             os.makedirs(self.path, exist_ok=True)
 
-        self.logger = logging.getLogger("AgilentHPLCChromatogram")
-
         super().__init__(path=path, autosaving=autosaving)
 
     def load_spectrum(self, data_path, channel="A"):
@@ -73,7 +70,11 @@ class AgilentHPLCChromatogram(AbstractSpectrum):
 
         # get timestamp
         tstr = data_path.split(".")[0].split("_")[-1]
-        timestamp = time.mktime(time.strptime(tstr, TIME_FORMAT))
+        timestamp = "NA"
+        try:
+            timestamp = time.mktime(time.strptime(tstr, TIME_FORMAT))
+        except ValueError:
+            pass
 
         # loading all data
         super().load_spectrum(x, y, timestamp)

pychemstation/utils/macro.py

@@ -26,6 +26,7 @@ class Command(Enum):
     UPDATE_METHOD_CMD = 'UpdateMethod'
     SWITCH_SEQUENCE_CMD = 'LoadSequence _SeqPath$, _SeqFile$'
     SAVE_SEQUENCE_CMD = 'SaveSequence _SeqPath$, _SeqFile$'
+    SAVE_METHOD_CMD = 'SaveMethod _MethPath$, _MethFile$, {commit_msg}'
     GET_SEQUENCE_CMD = 'response$ = _SeqFile$'
     RUN_SEQUENCE_CMD = 'RunSequence'
 

pychemstation/utils/method_types.py

@@ -20,12 +20,10 @@ class Param:
 
 @dataclass
 class HPLCMethodParams:
-    organic_modifier: Param
-    flow: Param
-    temperature: Param
-    inj_vol: Param
-    equ_time: Param
-    maximum_run_time: Param
+    organic_modifier: int
+    flow: float
+    temperature: float
+    maximum_run_time: int
 
 
 @dataclass

pychemstation/utils/sequence_types.py

@@ -3,27 +3,41 @@ from enum import Enum
 from typing import Optional
 
 
+@dataclass
+class TrayLocation:
+    row: str
+    col: int
+
+
+@dataclass
+class SequenceDataFiles:
+    sequence_name: str
+    dir: str
+    child_dirs: list[str]
+
+
 class SampleType(Enum):
     SAMPLE = 1
     BLANK = 2
-    CONTROL = 3
-    CALIBRATION = 4
+    CALIBRATION = 3
+    CONTROL = 4
 
 
 class InjectionSource(Enum):
-    AS_METHOD = "AsMethod"
+    AS_METHOD = "As Method"
     MANUAL = "Manual"
+    MSD = "MSD"
     HIP_ALS = "HipAls"
 
 
 @dataclass
 class SequenceEntry:
-    vial_location: Optional[int] = None
+    sample_name: str
+    vial_location: int
     method: Optional[str] = None
     num_inj: Optional[int] = 1
     inj_vol: Optional[int] = 2
     inj_source: Optional[InjectionSource] = InjectionSource.HIP_ALS
-    sample_name: Optional[str] = None
     sample_type: Optional[SampleType] = SampleType.SAMPLE