pychemstation 0.8.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

pychemstation/control/controllers/table_controller.py

@@ -0,0 +1,266 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+Authors: Lucy Hao
+"""
+
+import abc
+import os
+from typing import Union, Optional
+
+import polling
+from 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 MethodDetails
+from ...utils.sequence_types import SequenceDataFiles, SequenceTable
+from ...utils.table_types import Table, TableOperation, RegisterFlag
+
+TableType = Union[MethodDetails, 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
+
+        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, Optional[AgilentHPLCChromatogram]] = {
+            "A": AgilentHPLCChromatogram(self.data_dir),
+            "B": AgilentHPLCChromatogram(self.data_dir),
+            "C": AgilentHPLCChromatogram(self.data_dir),
+            "D": AgilentHPLCChromatogram(self.data_dir),
+            "E": AgilentHPLCChromatogram(self.data_dir),
+            "F": AgilentHPLCChromatogram(self.data_dir),
+            "G": AgilentHPLCChromatogram(self.data_dir),
+            "H": AgilentHPLCChromatogram(self.data_dir),
+        }
+
+        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:
+                return self.controller.receive()
+            except IndexError:
+                continue
+        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]):
+        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))
+
+    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
+
+    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[Response, 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=5,
+            max_tries=100)
+        return started_running
+
+    def check_hplc_done_running(self,
+                                method: Optional[MethodDetails] = 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
+        :param sequence: if you are running a sequence and want to read back data, the timeout period will be adjusted to be longer than the sequence's runtime
+        :return: Return True if data can be read back, else False.
+        """
+        timeout = 10 * 60
+        if method:
+            timeout = ((method.stop_time + method.post_time + 3) * 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=50)
+
+        check_folder = self.fuzzy_match_most_recent_folder(most_recent_folder)
+        if check_folder.is_ok() and finished_run:
+            return check_folder
+        elif check_folder.is_ok():
+            finished_run = polling.poll(
+                lambda: self.controller.check_if_running(),
+                timeout=timeout,
+                step=50)
+            if finished_run:
+                return check_folder
+            return check_folder
+        else:
+            return Err("Run did not complete as expected")
+
+    def fuzzy_match_most_recent_folder(self, most_recent_folder) -> Result[str, str]:
+        if os.path.exists(most_recent_folder):
+            return Ok(most_recent_folder)
+
+        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)
+
+    @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():
+            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/controllers/tables/method.py

@@ -1,6 +1,7 @@
 import os
 import time
-from typing import List
+import warnings
+from typing import Dict, List, Optional, Union
 
 from result import Err, Ok, Result
 from xsdata.formats.dataclass.parsers import XmlParser
@@ -13,9 +14,15 @@ from ....utils.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
-from ....utils.macro import *
-from ....utils.method_types import *
-from ....utils.table_types import *
+from ....utils.macro import Command
+from ....utils.method_types import (
+    HPLCMethodParams,
+    MethodDetails,
+    Param,
+    PType,
+    TimeTableEntry,
+)
+from ....utils.table_types import RegisterFlag, T, Table, TableOperation
 from ..devices.injector import InjectorController
 from .table import TableController
 
@@ -129,6 +136,10 @@ class MethodController(TableController):
                 register=self.table_locator.register,
                 register_flag=RegisterFlag.MAX_TIME))
 
+    def get_total_runtime(self) -> Union[int, float]:
+        """Returns total method runtime in minutes."""
+        return self.get_post_time() + self.get_stop_time()
+
     def current_method(self, method_name: str):
         """
         Checks if a given method is already loaded into Chemstation. Method name does not need the ".M" extension.
@@ -173,6 +184,7 @@ class MethodController(TableController):
         :raises FileNotFoundError: Method does not exist
         :return: method details
         """
+        warnings.warn("This method is not actively maintained.")
         method_folder = f"{method_name}.M"
         method_path = os.path.join(self.src, method_folder, "AgilentPumpDriver1.RapidControl.MethodXML.xml")
         dad_path = os.path.join(self.src, method_folder, "Agilent1200erDadDriver1.RapidControl.MethodXML.xml")
@@ -347,29 +359,39 @@ class MethodController(TableController):
             raise RuntimeError("Method failed to start.")
 
         self.data_files.append(os.path.join(self.data_dirs[0], folder_name))
+        self.timeout = (self.get_total_runtime()) * 60
 
         if stall_while_running:
-            self.timeout = (self.get_stop_time() + self.get_post_time()) * 60
             run_completed = self.check_hplc_done_running()
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
                 raise RuntimeError("Run error has occurred.")
         else:
-            self.data_files[-1] = self.fuzzy_match_most_recent_folder(folder_name).ok_value
+            folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+            while folder.is_err():
+                folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+            if folder.is_ok():
+                self.data_files[-1] = folder.ok_value
+            else:
+                warning = f"Data folder {self.data_files[-1]} may not exist, returning and will check again after run is done."
+                warnings.warn(warning)
+
 
     def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         if os.path.exists(most_recent_folder):
             return Ok(most_recent_folder)
         return Err("Folder not found!")
 
-    def get_data(self, custom_path: Optional[str] = None,
-                 read_uv: bool = False) -> AgilentChannelChromatogramData:
-        if not custom_path:
-            self.get_spectrum(self.data_files[-1], read_uv)
-        else:
-            self.get_spectrum(custom_path, read_uv)
-        return AgilentChannelChromatogramData(**self.spectra) if not read_uv else self.uv
+    def get_data(self, custom_path: Optional[str] = None) -> AgilentChannelChromatogramData:
+        custom_path = custom_path if custom_path else self.data_files[-1]
+        self.get_spectrum_at_channels(custom_path)
+        return AgilentChannelChromatogramData(**self.spectra)
+
+    def get_data_uv(self, custom_path: Optional[str] = None) -> Dict[str, AgilentHPLCChromatogram]:
+        custom_path = custom_path if custom_path else self.data_files[-1]
+        self.get_uv_spectrum(custom_path)
+        return self.uv
 
     def get_report(self, custom_path: Optional[str] = None,
                    report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:

pychemstation/control/controllers/tables/sequence.py

@@ -1,19 +1,29 @@
 import os
 import time
-from typing import Optional, List, Dict
+from typing import Dict, List, Optional
 
-from result import Result, Ok, Err
+from result import Err, Ok, Result
 from typing_extensions import override
 
-from .table import TableController
-from .. import MethodController
-from ....analysis.process_report import ReportType, AgilentReport
+from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers.comm import CommunicationController
-from ....utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogramData, AgilentHPLCChromatogram
+from ....utils.chromatogram import (
+    SEQUENCE_TIME_FORMAT,
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
 from ....utils.macro import Command
-from ....utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
+from ....utils.sequence_types import (
+    InjectionSource,
+    SampleType,
+    SequenceDataFiles,
+    SequenceEntry,
+    SequenceTable,
+)
 from ....utils.table_types import RegisterFlag, Table
-from ....utils.tray_types import TenVialColumn, FiftyFourVialPlate
+from ....utils.tray_types import FiftyFourVialPlate, TenVialColumn
+from .. import MethodController
+from .table import TableController
 
 
 class SequenceController(TableController):
@@ -82,7 +92,7 @@ class SequenceController(TableController):
         time.sleep(2)
         self.send(Command.GET_SEQUENCE_CMD)
         time.sleep(2)
-        parsed_response = self.receive().value.string_response
+        parsed_response = self.receive().ok_value.string_response
 
         assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
         self.table_state = None
@@ -97,7 +107,7 @@ class SequenceController(TableController):
         self.table_state = sequence_table
         rows = self.get_num_rows()
         if rows.is_ok():
-            existing_row_num = rows.value.num_response
+            existing_row_num = rows.ok_value.num_response
             wanted_row_num = len(sequence_table.rows)
             while existing_row_num != wanted_row_num:
                 if wanted_row_num > existing_row_num:
@@ -127,7 +137,6 @@ class SequenceController(TableController):
                 self.add_row()
                 self.send(Command.SAVE_SEQUENCE_CMD)
                 num_rows = self.get_num_rows()
-
         if row.vial_location:
             loc = row.vial_location
             if isinstance(loc, TenVialColumn):
@@ -135,7 +144,6 @@ class SequenceController(TableController):
             elif isinstance(loc, FiftyFourVialPlate):
                 loc = row.vial_location.value()
             self._edit_row_num(row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc)
-
         if row.method:
             method_dir = self.method_controller.src
             possible_path = os.path.join(method_dir, row.method) + ".M\\"
@@ -143,23 +151,18 @@ class SequenceController(TableController):
             if os.path.exists(possible_path):
                 method = os.path.join(method_dir, row.method)
             self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
-
         if row.num_inj:
             self._edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=row.num_inj)
-
         if row.inj_vol:
             self._edit_row_text(row=row_num, col_name=RegisterFlag.INJ_VOL, val=row.inj_vol)
-
         if row.inj_source:
             self._edit_row_text(row=row_num, col_name=RegisterFlag.INJ_SOR, val=row.inj_source.value)
-
         if row.sample_name:
             self._edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=row.sample_name)
             if row.data_file:
                 self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.data_file)
             else:
                 self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.sample_name)
-
         if row.sample_type:
             self._edit_row_num(row=row_num, col_name=RegisterFlag.SAMPLE_TYPE, val=row.sample_type.value)
 
@@ -179,15 +182,15 @@ class SequenceController(TableController):
 
         total_runtime = 0
         for entry in self.table_state.rows:
-            curr_method_runtime = self.method_controller.get_post_time() + self.method_controller.get_stop_time()
-            loaded_method = self.method_controller.get_method_name()[:-2]
+            curr_method_runtime = self.method_controller.get_total_runtime()
+            loaded_method = self.method_controller.get_method_name().removesuffix(".M")
             method_path = entry.method.split(sep="\\")
             method_name = method_path[-1]
             if loaded_method != method_name:
-                method_dir = os.path.join(*method_path[:-1]) if len(method_path) > 1 else None
+                method_dir = "\\".join(method_path[:-1])+"\\" if len(method_path) > 1 else None
                 self.method_controller.switch(method_name=method_name,
                                               alt_method_dir=method_dir)
-                curr_method_runtime = self.method_controller.get_post_time() + self.method_controller.get_stop_time()
+                curr_method_runtime = self.method_controller.get_total_runtime()
             total_runtime += curr_method_runtime
 
         timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
@@ -196,8 +199,8 @@ class SequenceController(TableController):
 
         if self.check_hplc_is_running():
             folder_name = f"{self.table_state.name} {timestamp}"
-            self.data_files.append(SequenceDataFiles(dir=folder_name,
-                                                     sequence_name=self.table_state.name))
+            data_file = SequenceDataFiles(dir=folder_name, sequence_name=self.table_state.name)
+            self.data_files.append(data_file)
 
             if stall_while_running:
                 run_completed = self.check_hplc_done_running()
@@ -205,10 +208,8 @@ class SequenceController(TableController):
                     self.data_files[-1] = run_completed.ok_value
                 else:
                     raise RuntimeError("Run error has occurred.")
-            else:
-                self.data_files[-1] = SequenceDataFiles(dir=folder_name,
-                                                        child_dirs=[],
-                                                        sequence_name=self.table_state.name)
+        else:
+            raise RuntimeError("Sequence run did not start.")
 
     @override
     def fuzzy_match_most_recent_folder(self, most_recent_folder: SequenceDataFiles) -> Result[SequenceDataFiles, str]:
@@ -248,17 +249,25 @@ class SequenceController(TableController):
         except Exception:
             return Err("Failed to get sequence folder")
 
-    def get_data(self, custom_path: Optional[str] = None,
-                 read_uv: bool = False) -> List[AgilentChannelChromatogramData]:
-        if len(self.data_files[-1].child_dirs) == 0:
-            self.data_files[-1] = self.fuzzy_match_most_recent_folder(self.data_files[-1]).ok_value
-        spectra: list[AgilentChannelChromatogramData] = []
-        all_w_spectra: list[Dict[str, AgilentHPLCChromatogram]] = []
+    def get_data_uv(self,custom_path: Optional[str] = None) -> List[Dict[str, AgilentHPLCChromatogram]]:
+        custom_path = SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="") if custom_path else self.data_files[-1]
+        if len(custom_path.child_dirs) == 0:
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(custom_path).ok_value
+        all_w_spectra: List[Dict[str, AgilentHPLCChromatogram]] = []
         for row in self.data_files[-1].child_dirs:
-            self.get_spectrum(row, read_uv)
-            spectra.append(AgilentChannelChromatogramData(**self.spectra))
+            self.get_uv_spectrum(row)
             all_w_spectra.append(self.uv)
-        return spectra if not read_uv else all_w_spectra
+        return all_w_spectra
+
+    def get_data(self, custom_path: Optional[str] = None) -> List[AgilentChannelChromatogramData]:
+        custom_path = SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="") if custom_path else self.data_files[-1]
+        if len(custom_path.child_dirs) == 0:
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(custom_path).ok_value
+        spectra: List[AgilentChannelChromatogramData] = []
+        for row in self.data_files[-1].child_dirs:
+            self.get_spectrum_at_channels(row)
+            spectra.append(AgilentChannelChromatogramData(**self.spectra))
+        return spectra
 
     def get_report(self, custom_path: Optional[str] = None,
                    report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
@@ -268,7 +277,7 @@ class SequenceController(TableController):
                                                                                          child_dirs=[],
                                                                                          sequence_name="NA")).ok_value)
         parent_dir = self.data_files[-1]
-        spectra = self.get_data(custom_path=custom_path)
+        spectra = self.get_data()
         reports = []
         for i, child_dir in enumerate(parent_dir.child_dirs):
             metd_report = self.get_report_details(child_dir, report_type)