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

pychemstation/control/controllers/sequence.py

@@ -0,0 +1,211 @@
+import os
+import time
+
+from ...control.controllers.table_controller import TableController
+from ...control.controllers.comm import CommunicationController
+from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogramData
+from ...utils.macro import Command
+from ...utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
+from ...utils.table_types import TableOperation, RegisterFlag, Table
+
+
+class SequenceController(TableController):
+    """
+    Class containing sequence related logic
+    """
+
+    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.string_response.partition(".S")[0],
+                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):
+        """
+        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)
+        parsed_response = self.receive().value.string_response
+
+        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:
+        """
+
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            existing_row_num = rows.value.num_response
+            wanted_row_num = len(sequence_table.rows)
+            while existing_row_num != wanted_row_num:
+                if wanted_row_num > existing_row_num:
+                    self.add_row()
+                elif wanted_row_num < existing_row_num:
+                    self.delete_row(int(existing_row_num))
+                self.send(Command.SAVE_SEQUENCE_CMD)
+                existing_row_num = self.get_num_rows().ok_value.num_response
+            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)
+            self.send(Command.SWITCH_SEQUENCE_CMD)
+
+    def edit_row(self, row: SequenceEntry, row_num: int):
+        """
+        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
+        """
+        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:
+            loc = row.vial_location
+            if isinstance(row.vial_location, InjectionSource):
+                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))
+        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))
+
+        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))
+
+        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))
+
+        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))
+
+        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))
+        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.send(Command.SAVE_SEQUENCE_CMD)
+
+    def run(self):
+        """
+        Starts the currently loaded sequence, storing data
+        under the <data_dir>/<sequence table name> folder.
+        Device must be ready.
+        """
+        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
+        seq_table = self.load()
+        self.send(Command.RUN_SEQUENCE_CMD.value)
+
+        if self.check_hplc_is_running():
+            folder_name = f"{seq_table.name} {timestamp}"
+            self.data_files.append(SequenceDataFiles(dir=folder_name,
+                                                     sequence_name=seq_table.name))
+
+        run_completed = self.check_hplc_done_running(sequence=seq_table)
+
+        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 sequence_data_files.dir
+
+    def get_data(self) -> list[AgilentChannelChromatogramData]:
+        parent_dir = self.data_files[-1].dir
+        subdirs = [x[0] for x in os.walk(self.data_dir)]
+        potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))
+        self.data_files[-1].child_dirs = [f for f in potential_folders if
+                                          parent_dir in f and ".M" not in f and ".D" in f]
+
+        spectra: list[AgilentChannelChromatogramData] = []
+        for row in self.data_files[-1].child_dirs:
+            self.get_spectrum(row)
+            spectra.append(
+                AgilentChannelChromatogramData(
+                    A=self.spectra["A"],
+                    B=self.spectra["B"],
+                    C=self.spectra["C"],
+                    D=self.spectra["D"]))
+        return spectra

pychemstation/control/controllers/table_controller.py

@@ -0,0 +1,198 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+Authors: Lucy Hao
+"""
+
+import abc
+import os
+import time
+from typing import Union, Optional
+
+import polling
+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.sequence_types import SequenceDataFiles, SequenceTable
+from ...utils.table_types import Table, TableOperation, RegisterFlag
+
+
+class TableController(abc.ABC):
+
+    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:
+            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: dict[str, AgilentHPLCChromatogram] = {
+            "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) -> 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)
+
+    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 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 delete_row(self, row: int):
+        self.sleepy_send(TableOperation.DELETE_ROW.value.format(register=self.table.register,
+                                                                table_name=self.table.name,
+                                                                row=row))
+
+    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.
+        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=self.table.register,
+                                                             table_name=self.table.name))
+
+    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.
+        You can also provide your own table.
+
+        :param table: the table to delete
+        """
+        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=self.table.register,
+                                                                  table_name=self.table.name))
+
+    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=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()
+
+        if res.is_ok():
+            self.send("Sleep 0.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,
+                                sequence: Optional[SequenceTable] = None) -> Result[str, str]:
+        """
+        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.
+        """
+        timeout = 10 * 60
+        if method:
+            timeout = ((method.first_row.maximum_run_time + 2) * 60)
+        if sequence:
+            timeout *= len(sequence.rows)
+
+        most_recent_folder = self.retrieve_recent_data_files()
+        finished_run = polling.poll(
+            lambda: self.controller.check_if_running(),
+            timeout=timeout,
+            step=60
+        )
+
+        if finished_run:
+            if os.path.exists(most_recent_folder):
+                return Ok(most_recent_folder)
+            else:
+                subdirs = [x[0] for x in os.walk(self.data_dir)]
+                potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
+                parent_dirs = []
+                for folder in potential_folders:
+                    path = os.path.normpath(folder)
+                    split_folder = path.split(os.sep)
+                    if most_recent_folder in split_folder[-1]:
+                        parent_dirs.append(folder)
+                parent_dir = sorted(parent_dirs, reverse=True)[0]
+                return Ok(parent_dir)
+        else:
+            return Err("Run did not complete as expected")
+
+    @abc.abstractmethod
+    def retrieve_recent_data_files(self):
+        pass
+
+    @abc.abstractmethod
+    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        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)

pychemstation/control/hplc.py

@@ -6,9 +6,8 @@ Authors: Lucy Hao
 
 from typing import Union, Optional
 
-from ..control import CommunicationController
-from ..control.table import MethodController, SequenceController
-from ..utils.chromatogram import AgilentHPLCChromatogram
+from ..control.controllers import MethodController, SequenceController, CommunicationController
+from ..utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
 from ..utils.method_types import MethodTimetable
 from ..utils.sequence_types import SequenceTable, SequenceEntry
@@ -65,8 +64,8 @@ class HPLCController:
         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.
+        :raises  IndexError: Response did not have expected format. Try again.
+        :raises  AssertionError: The desired method is not selected. Try again.
         """
         self.method_controller.switch(method_name)
 
@@ -91,15 +90,15 @@ class HPLCController:
         """
         self.method_controller.run(experiment_name)
 
-    def run_sequence(self, sequence_table: SequenceTable):
+    def run_sequence(self):
         """
         Starts the currently loaded sequence, storing data
         under the <data_dir>/<sequence table name> folder.
         Device must be ready.
 
-        :param sequence_table:
+        :param sequence_name:
         """
-        self.sequence_controller.run(sequence_table)
+        self.sequence_controller.run()
 
     def edit_method(self, updated_method: MethodTimetable, save: bool = False):
         """Updated the currently loaded method in ChemStation with provided values.
@@ -114,7 +113,7 @@ class HPLCController:
         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_row` instead.
 
-        :param sequence_table:
+        :param updated_sequence:
         """
         self.sequence_controller.edit(updated_sequence)
 
@@ -127,13 +126,13 @@ class HPLCController:
         """
         self.sequence_controller.edit_row(row, num)
 
-    def get_last_run_method_data(self) -> dict[str, AgilentHPLCChromatogram]:
+    def get_last_run_method_data(self) -> AgilentChannelChromatogramData:
         """
         Returns the last run method data.
         """
         return self.method_controller.get_data()
 
-    def get_last_run_sequence_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
+    def get_last_run_sequence_data(self) -> list[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
         """

pychemstation/control/table/sequence.py

@@ -30,7 +30,7 @@ class SequenceController(TableController):
 
         if rows.is_ok() and seq_name.is_ok():
             return SequenceTable(
-                name=seq_name.ok_value.num_response,
+                name=seq_name.ok_value.string_response.partition(".S")[0],
                 rows=[self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))])
         raise RuntimeError(rows.err_value)
 
@@ -73,34 +73,25 @@ class SequenceController(TableController):
 
         :param sequence_table:
         """
-        self.send("Local Rows")
-        self.sleep(1)
-        self.delete_table()
-        self.sleep(1)
-        self.new_table()
-        self.sleep(1)
-        self.get_num_rows()
-
-        if True:
-            for _ in sequence_table.rows:
-                self.add_row()
-                self.sleep(1)
+
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            existing_row_num = rows.value.num_response
+            wanted_row_num = len(sequence_table.rows)
+            while existing_row_num != wanted_row_num:
+                if wanted_row_num > existing_row_num:
+                    self.add_row()
+                elif wanted_row_num < existing_row_num:
+                    self.delete_row(int(existing_row_num))
                 self.send(Command.SAVE_SEQUENCE_CMD)
-            self.get_num_rows()
-            self.send(Command.SAVE_SEQUENCE_CMD)
+                existing_row_num = self.get_num_rows().ok_value.num_response
+            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)
-        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)
+            self.send(Command.SWITCH_SEQUENCE_CMD)
 
     def edit_row(self, row: SequenceEntry, row_num: int):
         """
@@ -120,13 +111,16 @@ class SequenceController(TableController):
         table_name = self.table.name
 
         if row.vial_location:
+            loc = row.vial_location
+            if isinstance(row.vial_location, InjectionSource):
+                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=row.vial_location.value))
+                                                                      val=loc))
         if row.method:
-            possible_path = os.path.join(self.method_dir, 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)
@@ -177,23 +171,22 @@ class SequenceController(TableController):
 
         self.send(Command.SAVE_SEQUENCE_CMD)
 
-    def run(self, sequence_table: SequenceTable):
+    def run(self):
         """
         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)
+        seq_table = self.load()
         self.send(Command.RUN_SEQUENCE_CMD.value)
 
         if self.check_hplc_is_running():
-            folder_name = f"{sequence_table.name} {timestamp}"
+            folder_name = f"{seq_table.name} {timestamp}"
             self.data_files.append(SequenceDataFiles(dir=folder_name,
-                                                     sequence_name=sequence_table.name, ))
+                                                     sequence_name=seq_table.name))
 
-        run_completed = self.check_hplc_done_running()
+        run_completed = self.check_hplc_done_running(sequence=seq_table)
 
         if run_completed.is_ok():
             self.data_files[-1].dir = run_completed.value
@@ -202,16 +195,16 @@ class SequenceController(TableController):
 
     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])
+        return sequence_data_files.dir
 
     def get_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
-        sequence_data_files: SequenceDataFiles = self.data_files[-1]
+        parent_dir = self.data_files[-1].dir
         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
+        potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))
+        self.data_files[-1].child_dirs = [f for f in potential_folders if parent_dir in f and ".M" not in f and ".D" in f]
+
         spectra: list[dict[str, AgilentHPLCChromatogram]] = []
-        for row in sequence_data_files.child_dirs:
-            data_path = os.path.join(sequence_data_files.dir, row)
-            self.get_spectrum(data_path)
+        for row in self.data_files[-1].child_dirs:
+            self.get_spectrum(row)
             spectra.append(deepcopy(self.spectra))
         return spectra