pychemstation 0.5.1__py3-none-any.whl → 0.5.3.dev1__py3-none-any.whl

pychemstation/control/table/sequence.py

@@ -8,10 +8,10 @@ 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
+from ...utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
+from ...utils.table_types import TableOperation, RegisterFlag, Table
+from ...utils.tray_types import TenColumn
 
 
 class SequenceController(TableController):
@@ -19,8 +19,36 @@ 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 __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table, method_dir: str):
+        self.method_dir = method_dir
+        super().__init__(controller, src, data_dir, table)
+
+    def load(self) -> SequenceTable:
+        rows = self.get_num_rows()
+        self.send(Command.GET_SEQUENCE_CMD)
+        seq_name = self.receive()
+
+        if rows.is_ok() and seq_name.is_ok():
+            return SequenceTable(
+                name=seq_name.ok_value.num_response,
+                rows=[self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))])
+        raise RuntimeError(rows.err_value)
+
+    def get_row(self, row: int) -> SequenceEntry:
+        sample_name = self.get_text(row, RegisterFlag.NAME)
+        vial_location = int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
+        method = self.get_text(row, RegisterFlag.METHOD)
+        num_inj = int(self.get_num(row, RegisterFlag.NUM_INJ))
+        inj_vol = int(self.get_text(row, RegisterFlag.INJ_VOL))
+        inj_source = InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
+        sample_type = SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
+        return SequenceEntry(sample_name=sample_name,
+                             vial_location=vial_location,
+                             method=None if len(method) == 0 else method,
+                             num_inj=num_inj,
+                             inj_vol=inj_vol,
+                             inj_source=inj_source,
+                             sample_type=sample_type, )
 
     def switch(self, seq_name: str):
         """
@@ -34,13 +62,7 @@ class SequenceController(TableController):
         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
+        parsed_response = self.receive().value.string_response
 
         assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
 
@@ -53,85 +75,108 @@ class SequenceController(TableController):
         """
         self.send("Local Rows")
         self.sleep(1)
-        self.delete_table(SEQUENCE_TABLE)
+        self.delete_table()
         self.sleep(1)
-        self.new_table(SEQUENCE_TABLE)
+        self.new_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.get_num_rows()
+
+        if True:
+            for _ in sequence_table.rows:
+                self.add_row()
+                self.sleep(1)
+                self.send(Command.SAVE_SEQUENCE_CMD)
+            self.get_num_rows()
             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)
-
+            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)
+        else:
+            for i, row in enumerate(sequence_table.rows):
+                self.add_row()
+                self.sleep(0.1)
+                self.edit_row(row=row, row_num=i + 1)
+                self.sleep(0.1)
+                rows = self.get_num_rows()
+                self.send(Command.SAVE_SEQUENCE_CMD)
+                self.send(Command.SWITCH_SEQUENCE_CMD)
 
     def edit_row(self, row: SequenceEntry, row_num: int):
         """
-        Edits a row in the sequence table. Assumes the row already exists.
+        Edits a row in the sequence table. If a row does NOT exist, a new one will be created.
 
         :param row: sequence row entry with updated information
-        :param row_num: the row to edit, based on -1-based indexing
+        :param row_num: the row to edit, based on 1-based indexing
         """
+        num_rows = self.get_num_rows()
+        if num_rows.is_ok():
+            while num_rows.ok_value.num_response < row_num:
+                self.add_row()
+                self.send(Command.SAVE_SEQUENCE_CMD)
+                num_rows = self.get_num_rows()
+
+        table_register = self.table.register
+        table_name = self.table.name
+
         if row.vial_location:
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=SEQUENCE_TABLE.register,
-                                                                      table_name=SEQUENCE_TABLE.name,
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
+                                                                      table_name=table_name,
                                                                       row=row_num,
                                                                       col_name=RegisterFlag.VIAL_LOCATION,
-                                                                      val=row.vial_location))
+                                                                      val=row.vial_location.value))
         if row.method:
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
-                                                                       table_name=SEQUENCE_TABLE.name,
+            possible_path = os.path.join(self.method_dir, row.method)
+            method = row.method
+            if os.path.exists(possible_path):
+                method = os.path.join(self.method_dir, row.method)
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=table_name,
                                                                        row=row_num,
                                                                        col_name=RegisterFlag.METHOD,
-                                                                       val=row.method))
+                                                                       val=method))
 
         if row.num_inj:
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=SEQUENCE_TABLE.register,
-                                                                      table_name=SEQUENCE_TABLE.name,
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
+                                                                      table_name=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,
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=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,
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=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,
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=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,
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=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,
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
+                                                                      table_name=table_name,
                                                                       row=row_num,
                                                                       col_name=RegisterFlag.SAMPLE_TYPE,
                                                                       val=row.sample_type.value))
 
+        self.send(Command.SAVE_SEQUENCE_CMD)
+
     def run(self, sequence_table: SequenceTable):
         """
         Starts the currently loaded sequence, storing data
@@ -142,29 +187,31 @@ class SequenceController(TableController):
         """
         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(10)
-        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]))
+
+        if self.check_hplc_is_running():
+            folder_name = f"{sequence_table.name} {timestamp}"
+            self.data_files.append(SequenceDataFiles(dir=folder_name,
+                                                     sequence_name=sequence_table.name, ))
+
+        run_completed = self.check_hplc_done_running()
+
+        if run_completed.is_ok():
+            self.data_files[-1].dir = run_completed.value
+        else:
+            raise RuntimeError("Run error has occured.")
 
     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 = self.data_ready()
+    def get_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
         sequence_data_files: SequenceDataFiles = self.data_files[-1]
+        subdirs = [x[0] for x in os.walk(self.data_dir)]
+        potential_folders = sorted(list(filter(lambda d: sequence_data_files.dir in d, subdirs)))
+        self.data_files[-1].child_dirs = potential_folders
         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
+        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 spectra

pychemstation/control/table/table_controller.py

@@ -9,10 +9,11 @@ import os
 from typing import Union, Optional
 
 import polling
+from result import Result, Ok, Err
 
 from ...control import CommunicationController
 from ...utils.chromatogram import AgilentHPLCChromatogram
-from ...utils.macro import Command
+from ...utils.macro import Command, HPLCRunningStatus, Response
 from ...utils.method_types import MethodTimetable
 from ...utils.sequence_types import SequenceDataFiles
 from ...utils.table_types import Table, TableOperation, RegisterFlag
@@ -20,8 +21,10 @@ from ...utils.table_types import Table, TableOperation, RegisterFlag
 
 class TableController(abc.ABC):
 
-    def __init__(self, controller: CommunicationController, src: str, data_dir: str):
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
         self.controller = controller
+        self.table = table
+
         if os.path.isdir(src):
             self.src: str = src
         else:
@@ -32,7 +35,7 @@ class TableController(abc.ABC):
         else:
             raise FileNotFoundError(f"dir: {data_dir} not found.")
 
-        self.spectra = {
+        self.spectra: dict[str, AgilentHPLCChromatogram] = {
             "A": AgilentHPLCChromatogram(self.data_dir),
             "B": AgilentHPLCChromatogram(self.data_dir),
             "C": AgilentHPLCChromatogram(self.data_dir),
@@ -41,8 +44,13 @@ class TableController(abc.ABC):
 
         self.data_files: Union[list[SequenceDataFiles], list[str]] = []
 
-    def receive(self):
-        return self.controller.receive()
+    def receive(self) -> Result[Response, str]:
+        for _ in range(10):
+            try:
+                return self.controller.receive()
+            except IndexError:
+                continue
+        return Err("Could not parse response")
 
     def send(self, cmd: Union[Command, str]):
         self.controller.send(cmd)
@@ -58,7 +66,23 @@ class TableController(abc.ABC):
         """
         self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
 
-    def add_table_row(self, table: Table):
+    def get_num(self, row: int, col_name: RegisterFlag) -> float:
+        return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table.register,
+                                                                                   table_name=self.table.name,
+                                                                                   row=row,
+                                                                                   col_name=col_name.value))
+
+    def get_text(self, row: int, col_name: RegisterFlag) -> str:
+        return self.controller.get_text_val(TableOperation.GET_ROW_TEXT.value.format(register=self.table.register,
+                                                                                     table_name=self.table.name,
+                                                                                     row=row,
+                                                                                     col_name=col_name.value))
+
+    @abc.abstractmethod
+    def get_row(self, row: int):
+        pass
+
+    def add_row(self):
         """
         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.
@@ -66,10 +90,10 @@ class TableController(abc.ABC):
 
         :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))
+        self.sleepy_send(TableOperation.NEW_ROW.value.format(register=self.table.register,
+                                                             table_name=self.table.name))
 
-    def delete_table(self, table: Table):
+    def delete_table(self):
         """
         Deletes the table for the current loaded method or sequence.
         Import either the SEQUENCE_TABLE or METHOD_TIMETABLE from hein_analytical_control.constants.
@@ -77,46 +101,62 @@ class TableController(abc.ABC):
 
         :param table: the table to delete
         """
-        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=table.register,
-                                                                  table_name=table.name))
+        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=self.table.register,
+                                                                  table_name=self.table.name))
 
-    def new_table(self, table: Table):
+    def new_table(self):
         """
         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, ))
+        self.send(TableOperation.CREATE_TABLE.value.format(register=self.table.register,
+                                                           table_name=self.table.name))
+
+    def get_num_rows(self) -> Result[int, str]:
+        self.send(TableOperation.GET_NUM_ROWS.value.format(register=self.table.register,
+                                                           table_name=self.table.name,
+                                                           col_name=RegisterFlag.NUM_ROWS))
+        self.send(Command.GET_ROWS_CMD.value.format(register=self.table.register,
+                                                    table_name=self.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:
+        if res.is_ok():
+            self.send("Sleep 1")
+            self.send('Print Rows')
+            return res
+        else:
+            return Err("No rows could be read.")
+
+    def check_hplc_is_running(self) -> bool:
+        started_running = polling.poll(
+            lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
+            step=30,
+            max_tries=10)
+        return started_running
+
+    def check_hplc_done_running(self, method: Optional[MethodTimetable] = None) -> Result[str, str]:
         """
-        Checks if ChemStation has finished writing data and can be read back.
+        Checks if ChemStation has finished running and can read data 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 = 10 * 60 if method is None else (method.first_row.maximum_run_time + 2) * 60
+        most_recent_folder = self.retrieve_recent_data_files()
+        finished_run = polling.poll(
+            lambda: self.controller.check_if_running(most_recent_folder),
             timeout=timeout,
             step=30
         )
-
-        return hplc_run_done
+        if finished_run:
+            subdirs = [x[0] for x in os.walk(self.data_dir)]
+            potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
+            return Ok(potential_folders[0])
+        else:
+            return Err("Run did not complete as expected")
 
     @abc.abstractmethod
     def retrieve_recent_data_files(self):
@@ -132,6 +172,3 @@ class TableController(abc.ABC):
         """
         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/macro.py

@@ -1,5 +1,12 @@
 from enum import Enum
 from typing import Union
+from dataclasses import dataclass
+
+
+@dataclass
+class Response:
+    string_response: str
+    num_response: Union[int, float]
 
 
 # Commands sent to the Chemstation Macro
@@ -8,6 +15,8 @@ class Command(Enum):
     def __str__(self):
         return '%s' % self.value
 
+    GET_NUM_VAL_CMD = "response_num = {cmd}"
+    GET_TEXT_VAL_CMD = "response$ = {cmd}"
     RESET_COUNTER_CMD = "last_cmd_no = 0"
     GET_STATUS_CMD = "response$ = AcqStatus$"
     SLEEP_CMD = "Sleep {seconds}"
@@ -19,6 +28,7 @@ class Command(Enum):
     PUMP_ON_CMD = "PumpAll ON"
     PUMP_OFF_CMD = "PumpAll OFF"
     GET_METHOD_CMD = "response$ = _MethFile$"
+    GET_ROWS_CMD = 'response_num = TabHdrVal({register}, "{table_name}", "{col_name}")'
     SWITCH_METHOD_CMD = 'LoadMethod "{method_dir}", "{method_name}.M"'
     START_METHOD_CMD = "StartMethod"
     RUN_METHOD_CMD = 'RunMethod "{data_dir}",, "{experiment_name}_{timestamp}"'
@@ -26,7 +36,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}'
+    SAVE_METHOD_CMD = 'SaveMethod _MethPath$, _MethFile$, "{commit_msg}"'
     GET_SEQUENCE_CMD = 'response$ = _SeqFile$'
     RUN_SEQUENCE_CMD = 'RunSequence'
 

pychemstation/utils/method_types.py

@@ -22,7 +22,6 @@ class Param:
 class HPLCMethodParams:
     organic_modifier: int
     flow: float
-    temperature: float
     maximum_run_time: int
 
 
@@ -30,7 +29,7 @@ class HPLCMethodParams:
 class TimeTableEntry:
     start_time: float
     organic_modifer: float
-    flow: float
+    flow: Optional[float] = None
 
 
 @dataclass

pychemstation/utils/sequence_types.py

@@ -1,19 +1,17 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
-
+from typing import Optional, Union
 
-@dataclass
-class TrayLocation:
-    row: str
-    col: int
+from pychemstation.utils.tray_types import TenColumn
 
 
 @dataclass
 class SequenceDataFiles:
     sequence_name: str
     dir: str
-    child_dirs: list[str]
+    child_dirs: Optional[list[str]] = None
 
 
 class SampleType(Enum):
@@ -22,6 +20,10 @@ class SampleType(Enum):
     CALIBRATION = 3
     CONTROL = 4
 
+    @classmethod
+    def _missing_(cls, value):
+        return cls.SAMPLE
+
 
 class InjectionSource(Enum):
     AS_METHOD = "As Method"
@@ -29,11 +31,15 @@ class InjectionSource(Enum):
     MSD = "MSD"
     HIP_ALS = "HipAls"
 
+    @classmethod
+    def _missing_(cls, value):
+        return cls.HIP_ALS
+
 
 @dataclass
 class SequenceEntry:
     sample_name: str
-    vial_location: int
+    vial_location: Union[TenColumn, int]
     method: Optional[str] = None
     num_inj: Optional[int] = 1
     inj_vol: Optional[int] = 2

pychemstation/utils/table_types.py

@@ -11,10 +11,11 @@ class TableOperation(Enum):
     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 = ''
+    GET_ROW_VAL = 'TabVal("{register}", "{table_name}", {row}, "{col_name}")'
+    GET_ROW_TEXT = 'TabText$("{register}", "{table_name}", {row}, "{col_name}")'
+    GET_NUM_ROWS = 'Rows = TabHdrVal({register}, "{table_name}", "{col_name}")'
+    GET_OBJ_HDR_VAL = 'ObjHdrVal("{register}", "{register_flag}")'
+    GET_OBJ_HDR_TEXT = 'ObjHdrText$("{register}", "{register_flag}")'
     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}"'
@@ -39,6 +40,8 @@ class RegisterFlag(Enum):
     COLUMN_OVEN_TEMP2 = "TemperatureControl2_Temperature"
     STOPTIME_MODE = "StopTime_Mode"
     POSTIME_MODE = "PostTime_Mode"
+    TIME = "Time"
+    TIMETABLE_SOLVENT_B_COMPOSITION = "SolventCompositionPumpChannel2_Percentage"
 
     # for Method Timetable
     SOLVENT_COMPOSITION = "SolventComposition"

pychemstation/utils/tray_types.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class TenColumn(Enum):
+    ONE = 1
+    TWO = 2
+    THREE = 3
+    FOUR = 4
+    FIVE = 5
+    SIX = 6
+    SEVEN = 7
+    EIGHT = 8
+    NINE = 9
+    TEN = 10

{pychemstation-0.5.1.dist-info → pychemstation-0.5.3.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.1
+Version: 0.5.3.dev1
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/pychemstation
 Author: Lucy Hao

pychemstation-0.5.3.dev1.dist-info/RECORD

@@ -0,0 +1,34 @@
+pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
+pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt420YMI4,44
+pychemstation/analysis/base_spectrum.py,sha256=FBvwzLtF9mdqW7f8ETY9G4cpfJ-SzbiSkZq9EtXcSXo,17045
+pychemstation/analysis/spec_utils.py,sha256=8NZMV0dtfxZLARjWzM5ks0tgEYQv_SKUiZzba2IoKgw,10505
+pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
+pychemstation/control/__init__.py,sha256=aH9cPf-ljrVeVhN0K3cyEcAavmPXCjhhOnpLNf8qLqE,106
+pychemstation/control/comm.py,sha256=19RaKugJ7TbBfW-OM8fHxf90cfXCiDnNnZWPAOiWpGQ,7266
+pychemstation/control/hplc.py,sha256=r1N8kf5o1kAoY1taALvLJoIxNEbuOYsjwZ8eljrMZRM,6763
+pychemstation/control/table/__init__.py,sha256=RgMN4uIWHdNUHpGRBWdzmzAbk7XEKl6Y-qtqWCxzSZU,124
+pychemstation/control/table/method.py,sha256=THVoGomSXff_CTU3eAYme0BYwkPzab5UgZKsiZ29QSk,12196
+pychemstation/control/table/sequence.py,sha256=iTpk1oiGByut7MSFDHKpTlKUCYzXENOB6EMSKaWJWVY,10651
+pychemstation/control/table/table_controller.py,sha256=eq9P213Jslr1gJnjZEuvyQ4TpgrxdIXFXHwtQbJkrg0,7131
+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/chromatogram.py,sha256=35nvEh6prVsWO6lMHYgGuidUOFHv954_7MNf0Az3Fz4,3759
+pychemstation/utils/macro.py,sha256=BAIcE_dppNffwrSqGq8gh0ccE9YAJfQFQZHXJgA1WtA,2586
+pychemstation/utils/method_types.py,sha256=YngbyHg96JSFnvhm5Zd7wJvLTQPPQsLbvbyz3HlGLYY,862
+pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
+pychemstation/utils/sequence_types.py,sha256=3VqiUHsfFEdynAxfR-z8JIWBCo7PdnGwTvsk7sm7Ij8,1055
+pychemstation/utils/table_types.py,sha256=HAxAsqmyWsCqGwhg4LadGlX6ubacsd8tjXXz-6DL2nI,2287
+pychemstation/utils/tray_types.py,sha256=UUDED-IAf-8FmPVZezuWSiIQE_HgiZQMV2sTqu4oZw8,177
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/constants.py,sha256=CqahQtWK0NSGIpoCOY_uoN4BwR6TFtaX9wPAkPkG9BE,2074
+tests/test_comb.py,sha256=IrCqsGEBdrAqoGBQuKiJiaGRW9Ym9UNlVjPA9gc2UrA,5431
+tests/test_comm.py,sha256=1ZZd0UrIBOKe91wzA-XI-gSRgXmId9mLWYSMeche82Y,2973
+tests/test_method.py,sha256=uCPpZVYKPz1CNWwhmBo_8TH0ku2V0ZpDZJj3f8iINB4,2440
+tests/test_sequence.py,sha256=w_WQj97hlaZtcW1Zibzlrq0p179c-4-otM-ik_1EXME,2937
+pychemstation-0.5.3.dev1.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.3.dev1.dist-info/METADATA,sha256=YIbggvShXX-YxNtMFlMXfJIIB0LanjwtYBLz7O5Ttdw,3964
+pychemstation-0.5.3.dev1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.3.dev1.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.3.dev1.dist-info/RECORD,,