pychemstation 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

pychemstation/control/controllers/method.py

@@ -1,6 +1,6 @@
 import os
 import time
-from typing import Optional
+from typing import Optional, Union
 
 from xsdata.formats.dataclass.parsers import XmlParser
 
@@ -9,7 +9,7 @@ from ...control.controllers.comm import CommunicationController
 from ...generated import PumpMethod, DadMethod, SolventElement
 from ...utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
 from ...utils.macro import Command
-from ...utils.method_types import PType, TimeTableEntry, Param, MethodTimetable, HPLCMethodParams
+from ...utils.method_types import PType, TimeTableEntry, Param, MethodDetails, HPLCMethodParams
 from ...utils.table_types import RegisterFlag, TableOperation, Table
 
 
@@ -43,30 +43,53 @@ class MethodController(TableController):
                     register_flag=RegisterFlag.FLOW
                 )
             ),
-            maximum_run_time=self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table.register,
-                    register_flag=RegisterFlag.MAX_TIME
-                )
-            ),
         )
 
     def get_row(self, row: int) -> TimeTableEntry:
         return TimeTableEntry(start_time=self.get_num(row, RegisterFlag.TIME),
                               organic_modifer=self.get_num(row, RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION),
-                              flow=None)
-
-    def load(self) -> MethodTimetable:
+                              flow=self.get_num(row, RegisterFlag.TIMETABLE_FLOW))
+
+    def get_timetable(self, rows: int):
+        uncoalesced_timetable_rows = [self.get_row(r + 1) for r in range(rows)]
+        timetable_rows = {}
+        for row in uncoalesced_timetable_rows:
+            time_key = str(row.start_time)
+            if time_key not in timetable_rows.keys():
+                timetable_rows[time_key] = TimeTableEntry(start_time=row.start_time,
+                                                          flow=row.flow,
+                                                          organic_modifer=row.organic_modifer)
+            else:
+                if row.flow:
+                    timetable_rows[time_key].flow = row.flow
+                if row.organic_modifer:
+                    timetable_rows[time_key].organic_modifer = row.organic_modifer
+        entries = list(timetable_rows.values())
+        entries.sort(key=lambda e: e.start_time)
+        return entries
+
+    def load(self) -> MethodDetails:
         rows = self.get_num_rows()
         if rows.is_ok():
             self.send(Command.GET_METHOD_CMD)
             res = self.receive()
             method_name = res.ok_value.string_response
-            timetable_rows = [self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))]
-            self.table_state = MethodTimetable(
+            timetable_rows = self.get_timetable(int(rows.ok_value.num_response))
+            params = self.get_method_params()
+            stop_time = self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table.register,
+                    register_flag=RegisterFlag.MAX_TIME))
+            post_time = self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table.register,
+                    register_flag=RegisterFlag.POST_TIME))
+            self.table_state = MethodDetails(
                 name=method_name,
-                first_row=self.get_method_params(),
-                subsequent_rows=timetable_rows)
+                timetable=timetable_rows,
+                stop_time=stop_time,
+                post_time=post_time,
+                params=params)
             return self.table_state
         else:
             raise RuntimeError(rows.err_value)
@@ -104,7 +127,7 @@ class MethodController(TableController):
             assert parsed_response == f"{method_name}.M", "Switching Methods failed."
         self.table_state = None
 
-    def load_from_disk(self, method_name: str) -> MethodTimetable:
+    def load_from_disk(self, method_name: str) -> MethodDetails:
         """
         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
@@ -133,105 +156,69 @@ class MethodController(TableController):
                     elif solvent.channel == "Channel_B":
                         organic_modifier = solvent
 
-            self.table_state = MethodTimetable(
-                first_row=HPLCMethodParams(
-                    organic_modifier=organic_modifier.percentage,
-                    flow=method.flow,
-                    maximum_run_time=method.stop_time.stop_time_value),
-                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
-            )
+            self.table_state = MethodDetails(
+                name=method_name,
+                params=HPLCMethodParams(organic_modifier=organic_modifier.percentage,
+                                        flow=method.flow),
+                stop_time=method.stop_time.stop_time_value,
+                post_time=method.post_time.post_time_value,
+                timetable=[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)
             return self.table_state
         else:
             raise FileNotFoundError
 
-    def edit(self, updated_method: MethodTimetable, save: bool):
+    def edit(self, updated_method: MethodDetails, save: bool):
         """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.
+        :param save: if false only modifies the method, otherwise saves to disk
         """
         self.table_state = updated_method
-        initial_organic_modifier: Param = Param(val=updated_method.first_row.organic_modifier,
+        initial_organic_modifier: Param = Param(val=updated_method.params.organic_modifier,
                                                 chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
                                                 ptype=PType.NUM)
-        max_time: Param = Param(val=updated_method.first_row.maximum_run_time,
+        max_time: Param = Param(val=updated_method.stop_time,
                                 chemstation_key=RegisterFlag.MAX_TIME,
                                 ptype=PType.NUM)
-        flow: Param = Param(val=updated_method.first_row.flow,
+        post_time: Param = Param(val=updated_method.post_time,
+                                 chemstation_key=RegisterFlag.POST_TIME,
+                                 ptype=PType.NUM)  # TODO check postime works
+        flow: Param = Param(val=updated_method.params.flow,
                             chemstation_key=RegisterFlag.FLOW,
                             ptype=PType.NUM)
 
         # Method settings required for all runs
-        self.delete_table()
-        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)
+        self.update_method_params(flow, initial_organic_modifier, max_time, post_time)
+        self._update_method_timetable(updated_method.timetable)
 
         if save:
             self.send(Command.SAVE_METHOD_CMD.value.format(
                 commit_msg=f"saved method at {str(time.time())}"
             ))
 
-    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
-        self.sleepy_send('Local Rows')
-        self.get_num_rows()
-
-        self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
-        res = self.get_num_rows()
-        while not res.is_err():
-            self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
-            res = self.get_num_rows()
-
-        self.sleepy_send('NewTab RCPMP1Method[1], "Timetable"')
-        self.get_num_rows()
-
-        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_num_rows()
-
-                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_num_rows()
+    def update_method_params(self, flow, initial_organic_modifier, max_time, post_time):
+        self.delete_table()
+        self._update_param(initial_organic_modifier)
+        self._update_param(flow)
+        if self.table_state.stop_time:
+            self._update_param(Param(val="Set",
+                                     chemstation_key=RegisterFlag.STOPTIME_MODE,
+                                     ptype=PType.STR))
+            self._update_param(max_time)
+        else:
+            self._update_param(Param(val="Off",
+                                     chemstation_key=RegisterFlag.STOPTIME_MODE,
+                                     ptype=PType.STR))
+        if self.table_state.post_time:
+            self._update_param(Param(val="Set",
+                                     chemstation_key=RegisterFlag.POSTIME_MODE,
+                                     ptype=PType.STR))
+            self._update_param(post_time)
+        self.download()
 
     def _update_param(self, method_param: Param):
         """Change a method parameter, changes what is visibly seen in Chemstation GUI.
@@ -252,6 +239,57 @@ class MethodController(TableController):
                                                    val=method_param.val))
         time.sleep(2)
 
+    def download(self):
+        self.send('Sleep 1')
+        self.sleepy_send("DownloadRCMethod PMP1")
+        self.send('Sleep 1')
+
+    def edit_row(self, row: TimeTableEntry, first_row: bool = False):
+        if first_row:
+            self.add_row()
+            self.add_new_col_text(col_name=RegisterFlag.FUNCTION,
+                                  val=RegisterFlag.SOLVENT_COMPOSITION.value)
+            self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
+            self.add_new_col_num(col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
+                                 val=row.organic_modifer)
+            self.add_row()
+            self.get_num_rows()
+            self.edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
+            self.add_new_col_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
+            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
+            self.download()
+        else:
+            self.add_row()
+            self.get_num_rows()
+            self.edit_row_text(col_name=RegisterFlag.FUNCTION,
+                               val=RegisterFlag.SOLVENT_COMPOSITION.value)
+            self.edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
+            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
+                              val=row.organic_modifer)
+            self.download()
+
+            self.add_row()
+            self.get_num_rows()
+            self.edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
+            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
+            self.edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
+            self.download()
+
+    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
+        self.get_num_rows()
+
+        self.delete_table()
+        res = self.get_num_rows()
+        while not res.is_err():
+            self.delete_table()
+            res = self.get_num_rows()
+
+        self.new_table()
+        self.get_num_rows()
+
+        for i, row in enumerate(timetable_rows):
+            self.edit_row(row=row, first_row=i == 0)
+
     def stop(self):
         """
         Stops the method run. A dialog window will pop up and manual intervention may be required.\

pychemstation/control/controllers/sequence.py

@@ -1,5 +1,4 @@
-from typing import  Optional
-
+from typing import Optional
 
 import os
 import time
@@ -10,6 +9,7 @@ from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogr
 from ...utils.macro import Command
 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):
@@ -47,7 +47,7 @@ class SequenceController(TableController):
                              num_inj=num_inj,
                              inj_vol=inj_vol,
                              inj_source=inj_source,
-                             sample_type=sample_type, )
+                             sample_type=sample_type)
 
     def check(self) -> str:
         time.sleep(2)
@@ -116,67 +116,34 @@ class SequenceController(TableController):
                 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:
             loc = row.vial_location
-            if isinstance(row.vial_location, InjectionSource):
+            if isinstance(row.vial_location, TenColumn):
                 loc = row.vial_location.value
-            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=loc))
+            self.edit_row_num(row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc)
+
         if row.method:
             possible_path = os.path.join(self.method_dir, row.method) + ".M\\"
             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=method))
+            self.edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
 
         if row.num_inj:
-            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))
+            self.edit_row_num(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=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.INJ_VOL,
-                                                                       val=row.inj_vol))
+            self.edit_row_text(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=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.INJ_SOR,
-                                                                       val=row.inj_source.value))
+            self.edit_row_text(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=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=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.DATA_FILE,
-                                                                       val=row.sample_name))
+            self.edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=row.sample_name)
+            self.edit_row_text(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=table_register,
-                                                                      table_name=table_name,
-                                                                      row=row_num,
-                                                                      col_name=RegisterFlag.SAMPLE_TYPE,
-                                                                      val=row.sample_type.value))
+            self.edit_row_num(row=row_num, col_name=RegisterFlag.SAMPLE_TYPE, val=row.sample_type.value)
 
         self.send(Command.SAVE_SEQUENCE_CMD)
 
@@ -210,7 +177,7 @@ class SequenceController(TableController):
         sequence_data_files: SequenceDataFiles = self.data_files[-1]
         return sequence_data_files.dir
 
-    def get_data(self, custom_path:Optional[str] = None ) -> list[AgilentChannelChromatogramData]:
+    def get_data(self, custom_path: Optional[str] = None) -> list[AgilentChannelChromatogramData]:
         parent_dir = self.data_files[-1].dir if not custom_path else custom_path
         subdirs = [x[0] for x in os.walk(self.data_dir)]
         potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))

pychemstation/control/controllers/table_controller.py

@@ -14,19 +14,19 @@ from result import Result, Ok, Err
 from ...control.controllers.comm import CommunicationController
 from ...utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 from ...utils.macro import Command, HPLCRunningStatus, Response
-from ...utils.method_types import MethodTimetable
+from ...utils.method_types import MethodDetails
 from ...utils.sequence_types import SequenceDataFiles, SequenceTable
 from ...utils.table_types import Table, TableOperation, RegisterFlag
 
+TableType = Union[MethodDetails, SequenceTable]
 
-TableType = Union[MethodTimetable, SequenceTable]
 
 class TableController(abc.ABC):
 
     def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
         self.controller = controller
         self.table = table
-        self.table_state : Optional[TableType] = None
+        self.table_state: Optional[TableType] = None
 
         if os.path.isdir(src):
             self.src: str = src
@@ -38,7 +38,7 @@ class TableController(abc.ABC):
         else:
             raise FileNotFoundError(f"dir: {data_dir} not found.")
 
-        self.spectra: dict[str, AgilentHPLCChromatogram] = {
+        self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
             "A": AgilentHPLCChromatogram(self.data_dir),
             "B": AgilentHPLCChromatogram(self.data_dir),
             "C": AgilentHPLCChromatogram(self.data_dir),
@@ -51,6 +51,9 @@ class TableController(abc.ABC):
 
         self.data_files: Union[list[SequenceDataFiles], list[str]] = []
 
+        # Initialize row counter for table operations
+        self.send('Local Rows')
+
     def receive(self) -> Result[Response, str]:
         for _ in range(10):
             try:
@@ -60,6 +63,9 @@ class TableController(abc.ABC):
         return Err("Could not parse response")
 
     def send(self, cmd: Union[Command, str]):
+        if not self.controller:
+            raise RuntimeError(
+                "Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.controller.send(cmd)
 
     def sleepy_send(self, cmd: Union[Command, str]):
@@ -85,6 +91,46 @@ class TableController(abc.ABC):
                                                                                      row=row,
                                                                                      col_name=col_name.value))
 
+    def add_new_col_num(self,
+                        col_name: RegisterFlag,
+                        val: Union[int, float]):
+        self.sleepy_send(TableOperation.NEW_COL_VAL.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            col_name=col_name,
+            val=val))
+
+    def add_new_col_text(self,
+                         col_name: RegisterFlag,
+                         val: str):
+        self.sleepy_send(TableOperation.NEW_COL_TEXT.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            col_name=col_name,
+            val=val))
+
+    def edit_row_num(self,
+                     col_name: RegisterFlag,
+                     val: Union[int, float],
+                     row: Optional[int] = None):
+        self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            row=row if row is not None else 'Rows',
+            col_name=col_name,
+            val=val))
+
+    def edit_row_text(self,
+                      col_name: RegisterFlag,
+                      val: str,
+                      row: Optional[int] = None):
+        self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            row=row if row is not None else 'Rows',
+            col_name=col_name,
+            val=val))
+
     @abc.abstractmethod
     def get_row(self, row: int):
         pass
@@ -150,7 +196,7 @@ class TableController(abc.ABC):
         return started_running
 
     def check_hplc_done_running(self,
-                                method: Optional[MethodTimetable] = None,
+                                method: Optional[MethodDetails] = None,
                                 sequence: Optional[SequenceTable] = None) -> Result[str, str]:
         """
         Checks if ChemStation has finished running and can read data back
@@ -169,7 +215,7 @@ class TableController(abc.ABC):
         finished_run = polling.poll(
             lambda: self.controller.check_if_running(),
             timeout=timeout,
-            step=18)
+            step=50)
 
         check_folder = self.fuzzy_match_most_recent_folder(most_recent_folder)
         if check_folder.is_ok() and finished_run:
@@ -178,9 +224,10 @@ class TableController(abc.ABC):
             finished_run = polling.poll(
                 lambda: self.controller.check_if_running(),
                 timeout=timeout,
-                step=12)
+                step=50)
             if finished_run:
                 return check_folder
+            return check_folder
         else:
             return Err("Run did not complete as expected")
 
@@ -212,4 +259,8 @@ class TableController(abc.ABC):
         Load chromatogram for any channel in spectra dictionary.
         """
         for channel, spec in self.spectra.items():
-            spec.load_spectrum(data_path=data_file, channel=channel)
+            try:
+                spec.load_spectrum(data_path=data_file, channel=channel)
+            except FileNotFoundError:
+                self.spectra[channel] = None
+                print(f"No data at channel: {channel}")

pychemstation/control/hplc.py

@@ -9,7 +9,7 @@ from typing import Union, Optional
 from ..control.controllers import MethodController, SequenceController, CommunicationController
 from ..utils.chromatogram import AgilentChannelChromatogramData
 from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
-from ..utils.method_types import MethodTimetable
+from ..utils.method_types import MethodDetails
 from ..utils.sequence_types import SequenceTable, SequenceEntry
 from ..utils.table_types import Table
 
@@ -26,6 +26,11 @@ class HPLCController:
         name="SeqTable1"
     )
 
+    INJECTOR_TABLE = Table(
+        register="_LeoAlsMethod",
+        name="ProgTable"
+    )
+
     def __init__(self,
                  comm_dir: str,
                  data_dir: str,
@@ -51,17 +56,20 @@ class HPLCController:
 
     def send(self, cmd: Union[Command, str]):
         if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
+            raise RuntimeError(
+                "Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.comm.send(cmd)
 
     def receive(self) -> Response:
         if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
+            raise RuntimeError(
+                "Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.comm.receive().value
 
     def status(self) -> Union[HPLCRunningStatus | HPLCAvailStatus | HPLCErrorStatus]:
         if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
+            raise RuntimeError(
+                "Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.comm.get_status()
 
     def switch_method(self, method_name: str):
@@ -74,8 +82,6 @@ class HPLCController:
         :raises  IndexError: Response did not have expected format. Try again.
         :raises  AssertionError: The desired method is not selected. Try again.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.method_controller.switch(method_name)
 
     def switch_sequence(self, sequence_name: str):
@@ -85,8 +91,6 @@ class HPLCController:
 
         :param sequence_name: The name of the sequence file
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.sequence_controller.switch(sequence_name)
 
     def run_method(self, experiment_name: str, stall_while_running: bool = True):
@@ -100,8 +104,6 @@ class HPLCController:
         :param experiment_name: Name of the experiment
         :param stall_while_running: whether this method should return or stall while HPLC runs.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.method_controller.run(experiment_name, stall_while_running)
 
     def run_sequence(self, stall_while_running: bool = True):
@@ -112,29 +114,23 @@ class HPLCController:
 
         :param stall_while_running: whether this method should return or stall while HPLC runs.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.sequence_controller.run(stall_while_running=stall_while_running)
 
-    def edit_method(self, updated_method: MethodTimetable, save: bool = False):
+    def edit_method(self, updated_method: MethodDetails, save: bool = False):
         """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.
-        :param save:
+        :param save: whether this method should be to disk, or just modified.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.method_controller.edit(updated_method, save)
 
     def edit_sequence(self, updated_sequence: SequenceTable):
         """
-        Updates the currently loaded sequence table with the provided table. This method will delete the existing sequence table and remake it.
+        Updates the currently loaded sequence table with the provided table.
         If you would only like to edit a single row of a sequence table, use `edit_sequence_row` instead.
 
-        :param updated_sequence:
+        :param updated_sequence: The sequence table to be written to the currently loaded sequence table.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.sequence_controller.edit(updated_sequence)
 
     def edit_sequence_row(self, row: SequenceEntry, num: int):
@@ -142,21 +138,23 @@ class HPLCController:
         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
+        :param num: the row to edit, based on 1-based indexing
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.sequence_controller.edit_row(row, num)
 
     def get_last_run_method_data(self, data: Optional[str] = None) -> AgilentChannelChromatogramData:
         """
         Returns the last run method data.
+
+        :param data: If you want to just load method data but from a file path. This file path must be the complete file path.
         """
         return self.method_controller.get_data(custom_path=data)
 
     def get_last_run_sequence_data(self, data: Optional[str] = None) -> list[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
+
+        :param data: If you want to just load sequence data but from a file path. This file path must be the complete file path.
         """
         return self.sequence_controller.get_data(custom_path=data)
 
@@ -164,66 +162,54 @@ class HPLCController:
         """
         Returns the name of the currently loaded sequence.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.sequence_controller.check()
 
     def check_loaded_method(self) -> str:
         """
         Returns the name of the currently loaded method.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.method_controller.check()
 
-    def load_method(self) -> MethodTimetable:
+    def load_method(self) -> MethodDetails:
         """
         Returns all details of the currently loaded method, including its timetable.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.method_controller.load()
 
     def load_sequence(self) -> SequenceTable:
         """
         Returns the currently loaded sequence.
         """
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.sequence_controller.load()
 
     def standby(self):
         """Switches all modules in standby mode. All lamps and pumps are switched off."""
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.STANDBY_CMD)
 
     def preprun(self):
         """ Prepares all modules for run. All lamps and pumps are switched on."""
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.PREPRUN_CMD)
 
     def lamp_on(self):
         """Turns the UV lamp on."""
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.LAMP_ON_CMD)
 
     def lamp_off(self):
         """Turns the UV lamp off."""
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.LAMP_OFF_CMD)
 
     def pump_on(self):
         """Turns on the pump on."""
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.PUMP_ON_CMD)
 
     def pump_off(self):
         """Turns the pump off."""
-        if not self.comm:
-            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.PUMP_OFF_CMD)
+
+    def instrument_off(self):
+        """Shuts the entire instrument off, including pumps, lamps, thermostat."""
+        self.send(Command.INSTRUMENT_OFF)
+
+    def instrument_on(self):
+        """Turns the entire instrument on, including pumps, lamps, thermostat."""
+        self.send(Command.INSTRUMENT_ON)

pychemstation/utils/macro.py

@@ -23,10 +23,16 @@ class Command(Enum):
     STANDBY_CMD = "Standby"
     STOP_MACRO_CMD = "Stop"
     PREPRUN_CMD = "PrepRun"
+
+    # Instrument Control
     LAMP_ON_CMD = "LampAll ON"
     LAMP_OFF_CMD = "LampAll OFF"
     PUMP_ON_CMD = "PumpAll ON"
     PUMP_OFF_CMD = "PumpAll OFF"
+    INSTRUMENT_OFF = 'macro "SHUTDOWN.MAC" ,go'
+    INSTRUMENT_ON = 'LIDoOperation "TURN_ON"'
+
+
     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"'

pychemstation/utils/method_types.py

@@ -3,8 +3,7 @@ from enum import Enum
 from typing import Union, Any, Optional
 
 from .table_types import RegisterFlag
-from ..generated import Signal, SolventElement
-
+from ..generated import Signal
 
 
 class PType(Enum):
@@ -23,7 +22,7 @@ class Param:
 class HPLCMethodParams:
     organic_modifier: int
     flow: float
-    maximum_run_time: int
+    pressure: Optional[float] = None #TODO: find this
 
 
 @dataclass
@@ -34,10 +33,20 @@ class TimeTableEntry:
 
 
 @dataclass
-class MethodTimetable:
+class MethodDetails:
+    """An Agilent Chemstation method, TODO is to add MS parameters
+
+    :attribute name: the name of the method, should be the same as the Chemstation method name.
+    :attribute timetable: list of entries in the method timetable
+    :attribute stop_time: the time the method stops running after the last timetable entry.
+    :attribute post_time: the amount of time after the stoptime that the pumps keep running,
+        based on settings in the first row of the timetable.
+    :attribute params: the organic modifier (pump B) and flow rate displayed for the method (the time 0 settings)
+    :attribute dad_wavelengthes:
+    """
     name: str
-    first_row: HPLCMethodParams
-    subsequent_rows: list[TimeTableEntry]
+    params: HPLCMethodParams
+    timetable: list[TimeTableEntry]
+    stop_time: Optional[int] = None
+    post_time: Optional[int] = None
     dad_wavelengthes: Optional[list[Signal]] = None
-    organic_modifier: Optional[SolventElement] = None
-    modifier_a: Optional[SolventElement] = None

pychemstation/utils/sequence_types.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Optional, Union
 
-from pychemstation.utils.tray_types import TenColumn
+from pychemstation.utils.tray_types import TenVialColumn
 
 
 @dataclass
@@ -39,7 +39,7 @@ class InjectionSource(Enum):
 @dataclass
 class SequenceEntry:
     sample_name: str
-    vial_location: Union[TenColumn, int]
+    vial_location: Union[TenVialColumn, int]
     method: Optional[str] = None
     num_inj: Optional[int] = 1
     inj_vol: Optional[int] = 2

pychemstation/utils/table_types.py

@@ -37,17 +37,20 @@ class RegisterFlag(Enum):
     SOLVENT_D_COMPOSITION = "PumpChannel4_CompositionPercentage"
     FLOW = "Flow"
     MAX_TIME = "StopTime_Time"
+    POST_TIME = "PostTime_Time" #TODO: check
     COLUMN_OVEN_TEMP1 = "TemperatureControl_Temperature"
     COLUMN_OVEN_TEMP2 = "TemperatureControl2_Temperature"
     STOPTIME_MODE = "StopTime_Mode"
     POSTIME_MODE = "PostTime_Mode"
     TIME = "Time"
     TIMETABLE_SOLVENT_B_COMPOSITION = "SolventCompositionPumpChannel2_Percentage"
+    TIMETABLE_FLOW = "FlowFlow"
 
     # for Method Timetable
     SOLVENT_COMPOSITION = "SolventComposition"
     PRESSURE = "Pressure"
     EXTERNAL_CONTACT = "ExternalContact"
+    FUNCTION = "Function"
 
 
     # for Sequence

pychemstation/utils/tray_types.py

@@ -1,7 +1,43 @@
+from dataclasses import dataclass
 from enum import Enum
 
 
-class TenColumn(Enum):
+class Num(Enum):
+    ONE = 1
+    TWO = 2
+    THREE = 3
+    FOUR = 4
+    FIVE = 5
+    SIX = 6
+    SEVEN = 7
+    EIGHT = 8
+    NINE = 9
+
+
+class Plate(Enum):
+    ONE = "1"
+    TWO = "2"
+
+
+class Letter(Enum):
+    A = 8191
+    B = 8255
+    C = 8319
+    D = 8383
+    F = 8447
+
+
+@dataclass
+class FiftyFourVialPlate:
+    plate: Plate
+    letter: Letter
+    num: Num
+
+    def value(self) -> int:
+        return self.letter.value + self.num.value
+
+
+class TenVialColumn(Enum):
     ONE = 1
     TWO = 2
     THREE = 3

{pychemstation-0.5.8.dist-info → pychemstation-0.5.10.dist-info}/METADATA

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

{pychemstation-0.5.8.dist-info → pychemstation-0.5.10.dist-info}/RECORD

@@ -5,12 +5,12 @@ pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-
 pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
 pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
 pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
-pychemstation/control/hplc.py,sha256=mIq7iN-BkWLSCNGCQPWc19Wjx82_mA_0X5Cy8TJoaUQ,10751
+pychemstation/control/hplc.py,sha256=5xC5q-hrAn5hKdz-ZwT_Dlas9LWLV27jZvhCKj7Lzg4,8761
 pychemstation/control/controllers/__init__.py,sha256=di3ytLIK-35XC_THw4IjNaOtCUTe7GuEOFb-obmREw4,166
 pychemstation/control/controllers/comm.py,sha256=IU4I_Q42VNCNUlVi93MxCmw2EBY9hiBDkU9FxubKg3c,7441
-pychemstation/control/controllers/method.py,sha256=Z_nLu_zXyXhpixDq7xTOljMWVBn9ioFvmSLXhTHXw-Y,13322
-pychemstation/control/controllers/sequence.py,sha256=ME9F5nWt-GqL5Qonhe8uNRU0K9oRwGPkPpb_YgqbziI,11318
-pychemstation/control/controllers/table_controller.py,sha256=RARvXS2UIfVdinoVOD5aBFQFhEtu95K57bcNgwOKCME,9081
+pychemstation/control/controllers/method.py,sha256=XUclB7lQ_SIkquR58MBmmi9drHIPEq9AR8VprTLenvI,15503
+pychemstation/control/controllers/sequence.py,sha256=XMaYvbMRBdaZPdEEL12oAl5uUIDi-_fbPJUU-Uxtk8I,8297
+pychemstation/control/controllers/table_controller.py,sha256=ItuNJ3aQqx73rviGVXs7vYaZKA9icPFreOUuUZupqB4,11029
 pychemstation/control/table/__init__.py,sha256=RgMN4uIWHdNUHpGRBWdzmzAbk7XEKl6Y-qtqWCxzSZU,124
 pychemstation/control/table/method.py,sha256=THVoGomSXff_CTU3eAYme0BYwkPzab5UgZKsiZ29QSk,12196
 pychemstation/control/table/sequence.py,sha256=Eri52AnbE3BGthfrRSvYKYciquUzvHKo0lYUTySYYE8,10542
@@ -20,20 +20,20 @@ pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCs
 pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/chromatogram.py,sha256=-q3_hL9GTyi4C95os7IwAiOrkTM4EXIiigm-nW9pFmM,3221
-pychemstation/utils/macro.py,sha256=9rSdup9HucmVfT9ZnhwMUpH3vjxDsILXnBCGXQGVdYU,2656
-pychemstation/utils/method_types.py,sha256=Hyd_Kxf-ygKW7LlOtEhGG-uujwFPE1w-orqyxcDz17E,877
+pychemstation/utils/macro.py,sha256=a6M6iK6c56Z75Opr2a-gsLKvMMpShu05DwcBYn5aTUs,2778
+pychemstation/utils/method_types.py,sha256=SRpr61Ca57NzfYoDiaooeI5tw1ESgVj_2-MctGyuN60,1478
 pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
-pychemstation/utils/sequence_types.py,sha256=3VqiUHsfFEdynAxfR-z8JIWBCo7PdnGwTvsk7sm7Ij8,1055
-pychemstation/utils/table_types.py,sha256=H67-7I96X8Zkm2HygHYttYwG_XuNDmV2AKZW10yZbiA,2418
-pychemstation/utils/tray_types.py,sha256=UUDED-IAf-8FmPVZezuWSiIQE_HgiZQMV2sTqu4oZw8,177
+pychemstation/utils/sequence_types.py,sha256=OhbmBUS7XQOKHC8YLjgbEVdpjriEc1bORkwB5ZV43oA,1063
+pychemstation/utils/table_types.py,sha256=HVE_tuM2TUED843iXvZqtONt8Eeolm6B5eciq60ZjR8,2521
+pychemstation/utils/tray_types.py,sha256=NzeH1IYI-k6u-2QrZshhx-lNlvOmGoOElbZ0fspT-38,654
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=lLwT_QaVriivL5llkul6RxXxPriwUp1E-Y3G9fejvbo,2092
-tests/test_comb.py,sha256=Ef5PD_uEVszCMmpurbzlweSAXzGH6o1rblFqYhGC9r0,5680
-tests/test_comm.py,sha256=1ZZd0UrIBOKe91wzA-XI-gSRgXmId9mLWYSMeche82Y,2973
-tests/test_method.py,sha256=uCPpZVYKPz1CNWwhmBo_8TH0ku2V0ZpDZJj3f8iINB4,2440
-tests/test_sequence.py,sha256=yIQGhUTehtHz6D1ai5W6AlP0zes2icF0VdQ0IGJ2CbQ,4901
-pychemstation-0.5.8.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.8.dist-info/METADATA,sha256=26690ZaxEouoE36tiXIBFH7DwfNr4DNTzABSddb3Rlw,4307
-pychemstation-0.5.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.8.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.8.dist-info/RECORD,,
+tests/constants.py,sha256=iU6knsNpQGnBfGcC8VAj5SrCDcHD3jBZLhQdF6UUwY4,2452
+tests/test_comb.py,sha256=EDE1Ve0A_EK4qro9imZsrD0xXrQN8hAowiOWPFtw3dM,5515
+tests/test_comm.py,sha256=EYOpVXzEMQLGhhKYDPO-KaLcJdPSMPTD9Y4jSI0yVQY,2516
+tests/test_method.py,sha256=r1Q1irqiVzs31QuTYLX3u_A0FpX8rIAQ1L4WOk9tLbk,2473
+tests/test_sequence.py,sha256=Nz2iqp1cJgw6kcQvnwSkfBmhxpOH62PoEu6o_5rO-PY,4929
+pychemstation-0.5.10.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.10.dist-info/METADATA,sha256=tcPTswg-NhMQlf7iDC1iYmUlKCta5QSSVFxoUVP8Wgc,4308
+pychemstation-0.5.10.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.10.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.10.dist-info/RECORD,,

tests/constants.py

@@ -39,24 +39,24 @@ def room(num: int):
 def gen_rand_method():
     org_modifier = int(random.random() * 10)
     max_run_time = int(random.random() * 10)
-    return MethodTimetable(
-        first_row=HPLCMethodParams(
-            organic_modifier=org_modifier,
-            flow=round(random.random(), 2),
-            maximum_run_time=max_run_time),
-        subsequent_rows=[
-            TimeTableEntry(
-                start_time=0.10,
-                organic_modifer=org_modifier,
-                flow=0.34),
-            TimeTableEntry(
-                start_time=1,
-                organic_modifer=100 - int(random.random() * 10),
-                flow=0.55)])
+    post_run_time = int(random.random() * 10)
+    flow = float(random.random() * 10) / 10
+    flow_1 = float(random.random() * 10) / 10
+    flow_2 = float(random.random() * 10) / 10
+    return MethodDetails(name=DEFAULT_METHOD,
+                         timetable=[TimeTableEntry(start_time=0.10,
+                                                   organic_modifer=org_modifier,
+                                                   flow=flow_1),
+                                    TimeTableEntry(start_time=1,
+                                                   organic_modifer=100 - int(random.random() * 10),
+                                                   flow=flow_2)],
+                         stop_time=max_run_time,
+                         post_time=post_run_time,
+                         params=HPLCMethodParams(organic_modifier=org_modifier, flow=flow))
 
 
 seq_entry = SequenceEntry(
-    vial_location=TenColumn.ONE,
+    vial_location=TenVialColumn.ONE,
     method=DEFAULT_METHOD,
     num_inj=int(random.random() * 10),
     inj_vol=int(random.random() * 10),

tests/test_comb.py

@@ -24,17 +24,15 @@ class TestCombinations(unittest.TestCase):
     def test_run_method_after_update(self):
         try:
             self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-            rand_method = MethodTimetable(
-                first_row=HPLCMethodParams(
-                    organic_modifier=5,
-                    flow=0.65,
-                    maximum_run_time=4),
-                subsequent_rows=[
-                    TimeTableEntry(
-                        start_time=3.5,
-                        organic_modifer=100,
-                        flow=0.65)],
-            name=DEFAULT_METHOD)
+            rand_method = MethodDetails(
+                params=HPLCMethodParams(organic_modifier=5,
+                                        flow=0.65),
+                timetable=[TimeTableEntry(start_time=3.5,
+                                          organic_modifer=100,
+                                          flow=0.65)],
+                name=DEFAULT_METHOD,
+                stop_time=10,
+                post_time=9)
             self.hplc_controller.edit_method(rand_method, save=True)
             if run_too:
                 self.hplc_controller.run_method(experiment_name="changed_method")
@@ -48,7 +46,7 @@ class TestCombinations(unittest.TestCase):
             self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
             seq_table = self.hplc_controller.load_sequence()
             seq_table.rows.append(SequenceEntry(
-                vial_location=TenColumn.ONE,
+                vial_location=TenVialColumn.ONE,
                 method=DEFAULT_METHOD,
                 num_inj=3,
                 inj_vol=4,
@@ -56,7 +54,7 @@ class TestCombinations(unittest.TestCase):
                 sample_type=SampleType.SAMPLE,
             ))
             seq_table.rows[0] = SequenceEntry(
-                vial_location=TenColumn.ONE,
+                vial_location=TenVialColumn.ONE,
                 method=DEFAULT_METHOD,
                 num_inj=3,
                 inj_vol=4,
@@ -85,43 +83,38 @@ class TestCombinations(unittest.TestCase):
     def test_update_method_update_seq_table_run(self):
         try:
             self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-            rand_method = MethodTimetable(
-                first_row=HPLCMethodParams(
+            rand_method = MethodDetails(
+                name=DEFAULT_METHOD,
+                params=HPLCMethodParams(
                     organic_modifier=5,
-                    flow=0.65,
-                    maximum_run_time=2),
-                subsequent_rows=[
-                    TimeTableEntry(
-                        start_time=0.50,
-                        organic_modifer=99,
-                        flow=0.34)],
-            name=DEFAULT_METHOD)
+                    flow=0.65),
+                timetable=[TimeTableEntry(
+                    start_time=0.50,
+                    organic_modifer=99,
+                    flow=0.34)],
+                stop_time=10,
+                post_time=5)
             self.hplc_controller.edit_method(rand_method, save=True)
 
             self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
             seq_table = SequenceTable(
                 name=DEFAULT_SEQUENCE,
-                rows=[
-                    SequenceEntry(
-                        vial_location=8320,
-                        sample_name="WM-01-001_Cr-Org",
-                        method=DEFAULT_METHOD,
-                        inj_source=InjectionSource.HIP_ALS,
-                        inj_vol=2,
-                        num_inj=1,
-                        sample_type=SampleType.SAMPLE
-                    ),
-                    SequenceEntry(
-                        vial_location=8448,
-                        sample_name="WM-01-001_Cr-Aq",
-                        method=DEFAULT_METHOD,
-                        inj_source=InjectionSource.HIP_ALS,
-                        inj_vol=2,
-                        num_inj=1,
-                        sample_type=SampleType.SAMPLE
-                    ),
-                ]
-            )
+                rows=[SequenceEntry(
+                    vial_location=8320,
+                    sample_name="WM-01-001_Cr-Org",
+                    method=DEFAULT_METHOD,
+                    inj_source=InjectionSource.HIP_ALS,
+                    inj_vol=2,
+                    num_inj=1,
+                    sample_type=SampleType.SAMPLE
+                ), SequenceEntry(
+                    vial_location=8448,
+                    sample_name="WM-01-001_Cr-Aq",
+                    method=DEFAULT_METHOD,
+                    inj_source=InjectionSource.HIP_ALS,
+                    inj_vol=2,
+                    num_inj=1,
+                    sample_type=SampleType.SAMPLE)])
 
             self.hplc_controller.edit_sequence(seq_table)
             if run_too:

tests/test_comm.py

@@ -42,7 +42,7 @@ class TestComm(unittest.TestCase):
             self.hplc_controller.send("TestNum = 0")
             self.hplc_controller.send("Print TestNum")
             self.hplc_controller.send("response_num = TestNum")
-            self.hplc_controller.send("Print num_response")
+            self.hplc_controller.send("Print response_num")
         except Exception as e:
             self.fail(f"Should not throw error: {e}")
 
@@ -63,16 +63,3 @@ class TestComm(unittest.TestCase):
         except Exception as e:
             self.fail(f"Should not throw error: {e}")
 
-    def test_pump_lamp(self):
-        pump_lamp = [
-            ("response", self.hplc_controller.lamp_on),
-            ("response", self.hplc_controller.lamp_off),
-            ("response", self.hplc_controller.pump_on),
-            ("response", self.hplc_controller.pump_off),
-        ]
-
-        for operation in pump_lamp:
-            try:
-                operation[1]()
-            except Exception as e:
-                self.fail(f"Failed due to: {e}")

tests/test_method.py

@@ -40,12 +40,12 @@ class TestMethod(unittest.TestCase):
         try:
             self.hplc_controller.edit_method(new_method)
             loaded_method = self.hplc_controller.load_method()
-            self.assertEqual(new_method.first_row.organic_modifier,
-                             loaded_method.first_row.organic_modifier)
-            self.assertEqual(new_method.subsequent_rows,
-                             loaded_method.subsequent_rows)
-            self.assertEqual(new_method.first_row.flow,
-                             loaded_method.first_row.flow)
+            self.assertEqual(new_method.params.organic_modifier,
+                             loaded_method.params.organic_modifier)
+            self.assertEqual(new_method.timetable[0].organic_modifer,
+                             loaded_method.timetable[0].organic_modifer)
+            self.assertEqual(round(new_method.params.flow, 2),
+                             round(loaded_method.params.flow, 2))
         except Exception as e:
             self.fail(f"Should have not failed: {e}")
 
@@ -58,4 +58,4 @@ class TestMethod(unittest.TestCase):
 
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

tests/test_sequence.py

@@ -29,7 +29,7 @@ class TestSequence(unittest.TestCase):
         self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
         try:
             self.hplc_controller.edit_sequence_row(SequenceEntry(
-                vial_location=TenColumn.TEN,
+                vial_location=TenVialColumn.TEN,
                 method=DEFAULT_METHOD,
                 num_inj=3,
                 inj_vol=4,
@@ -47,7 +47,7 @@ class TestSequence(unittest.TestCase):
                 name=DEFAULT_SEQUENCE,
                 rows=[
                     SequenceEntry(
-                        vial_location=TenColumn.ONE,
+                        vial_location=TenVialColumn.ONE,
                         method=DEFAULT_METHOD,
                         num_inj=3,
                         inj_vol=4,
@@ -56,7 +56,7 @@ class TestSequence(unittest.TestCase):
                         inj_source=InjectionSource.HIP_ALS
                     ),
                     SequenceEntry(
-                        vial_location=TenColumn.TWO,
+                        vial_location=TenVialColumn.TWO,
                         method=DEFAULT_METHOD,
                         num_inj=3,
                         inj_vol=4,
@@ -65,7 +65,7 @@ class TestSequence(unittest.TestCase):
                         inj_source=InjectionSource.HIP_ALS
                     ),
                     SequenceEntry(
-                        vial_location=TenColumn.TEN,
+                        vial_location=TenVialColumn.TEN,
                         method=DEFAULT_METHOD,
                         num_inj=3,
                         inj_vol=4,
@@ -74,7 +74,7 @@ class TestSequence(unittest.TestCase):
                         inj_source=InjectionSource.HIP_ALS
                     ),
                     SequenceEntry(
-                        vial_location=TenColumn.THREE,
+                        vial_location=TenVialColumn.THREE,
                         method=DEFAULT_METHOD,
                         num_inj=3,
                         inj_vol=4,
@@ -95,7 +95,7 @@ class TestSequence(unittest.TestCase):
                 name=DEFAULT_SEQUENCE,
                 rows=[
                     SequenceEntry(
-                        vial_location=TenColumn.TEN,
+                        vial_location=TenVialColumn.TEN,
                         method=DEFAULT_METHOD,
                         num_inj=3,
                         inj_vol=4,
@@ -104,7 +104,7 @@ class TestSequence(unittest.TestCase):
                         inj_source=InjectionSource.HIP_ALS
                     ),
                     SequenceEntry(
-                        vial_location=TenColumn.THREE,
+                        vial_location=TenVialColumn.THREE,
                         method=DEFAULT_METHOD,
                         num_inj=3,
                         inj_vol=4,