pychemstation 0.10.3__py3-none-any.whl → 0.10.4__py3-none-any.whl

pychemstation/control/controllers/tables/table.py

@@ -3,6 +3,7 @@ Abstract module containing shared logic for Method and Sequence tables.
 
 Authors: Lucy Hao
 """
+
 from __future__ import annotations
 
 import abc
@@ -23,25 +24,27 @@ from ....analysis.process_report import (
     TXTProcessor,
 )
 from ....control.controllers.comm import CommunicationController
-from ....utils.chromatogram import (
+from pychemstation.analysis.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
 from ....utils.macro import Command, HPLCRunningStatus, Response
 from ....utils.method_types import MethodDetails
-from ....utils.sequence_types import SequenceDataFiles, SequenceTable
+from ....utils.sequence_types import SequenceTable
 from ....utils.table_types import RegisterFlag, T, Table, TableOperation
 
 TableType = Union[MethodDetails, SequenceTable]
 
 
 class TableController(abc.ABC):
-
-    def __init__(self, controller: CommunicationController,
-                 src: Optional[str],
-                 data_dirs: Optional[List[str]],
-                 table: Table,
-                 offline: bool = False):
+    def __init__(
+        self,
+        controller: CommunicationController,
+        src: Optional[str],
+        data_dirs: Optional[List[str]],
+        table: Table,
+        offline: bool = False,
+    ):
         self.controller = controller
         self.table_locator = table
         self.table_state: Optional[TableType] = None
@@ -85,7 +88,8 @@ class TableController(abc.ABC):
     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.")
+                "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]):
@@ -100,108 +104,145 @@ class TableController(abc.ABC):
         self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
 
     def get_num(self, row: int, col_name: RegisterFlag) -> Union[int, float]:
-        return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table_locator.register,
-                                                                                   table_name=self.table_locator.name,
-                                                                                   row=row,
-                                                                                   col_name=col_name.value))
+        return self.controller.get_num_val(
+            TableOperation.GET_ROW_VAL.value.format(
+                register=self.table_locator.register,
+                table_name=self.table_locator.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_locator.register,
-                                                     table_name=self.table_locator.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_locator.register,
-            table_name=self.table_locator.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_locator.register,
-            table_name=self.table_locator.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_locator.register,
-            table_name=self.table_locator.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_locator.register,
-            table_name=self.table_locator.name,
-            row=row if row is not None else 'Rows',
-            col_name=col_name,
-            val=val))
+            TableOperation.GET_ROW_TEXT.value.format(
+                register=self.table_locator.register,
+                table_name=self.table_locator.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_locator.register,
+                table_name=self.table_locator.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_locator.register,
+                table_name=self.table_locator.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_locator.register,
+                table_name=self.table_locator.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_locator.register,
+                table_name=self.table_locator.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_locator.register,
-                                                                table_name=self.table_locator.name,
-                                                                row=row))
+        self.sleepy_send(
+            TableOperation.DELETE_ROW.value.format(
+                register=self.table_locator.register,
+                table_name=self.table_locator.name,
+                row=row,
+            )
+        )
 
     def add_row(self):
         """
         Adds a row to the provided table for currently loaded method or sequence.
         """
-        self.sleepy_send(TableOperation.NEW_ROW.value.format(register=self.table_locator.register,
-                                                             table_name=self.table_locator.name))
+        self.sleepy_send(
+            TableOperation.NEW_ROW.value.format(
+                register=self.table_locator.register, table_name=self.table_locator.name
+            )
+        )
 
     def delete_table(self):
         """
         Deletes the table for the current loaded method or sequence.
         """
-        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=self.table_locator.register,
-                                                                  table_name=self.table_locator.name))
+        self.sleepy_send(
+            TableOperation.DELETE_TABLE.value.format(
+                register=self.table_locator.register, table_name=self.table_locator.name
+            )
+        )
 
     def new_table(self):
         """
         Creates the table for the currently loaded method or sequence.
         """
-        self.send(TableOperation.CREATE_TABLE.value.format(register=self.table_locator.register,
-                                                           table_name=self.table_locator.name))
+        self.send(
+            TableOperation.CREATE_TABLE.value.format(
+                register=self.table_locator.register, table_name=self.table_locator.name
+            )
+        )
 
     def get_num_rows(self) -> Result[Response, str]:
-        self.send(TableOperation.GET_NUM_ROWS.value.format(register=self.table_locator.register,
-                                                           table_name=self.table_locator.name,
-                                                           col_name=RegisterFlag.NUM_ROWS))
-        self.send(Command.GET_ROWS_CMD.value.format(register=self.table_locator.register,
-                                                    table_name=self.table_locator.name,
-                                                    col_name=RegisterFlag.NUM_ROWS))
+        self.send(
+            TableOperation.GET_NUM_ROWS.value.format(
+                register=self.table_locator.register,
+                table_name=self.table_locator.name,
+                col_name=RegisterFlag.NUM_ROWS,
+            )
+        )
+        self.send(
+            Command.GET_ROWS_CMD.value.format(
+                register=self.table_locator.register,
+                table_name=self.table_locator.name,
+                col_name=RegisterFlag.NUM_ROWS,
+            )
+        )
         res = self.controller.receive()
 
         if res.is_ok():
             self.send("Sleep 0.1")
-            self.send('Print Rows')
+            self.send("Print Rows")
             return res
         else:
             return Err("No rows could be read.")
 
     def check_hplc_is_running(self) -> bool:
         try:
-            started_running = polling.poll(lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
-                                           step=1, max_tries=20)
+            started_running = polling.poll(
+                lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
+                step=1,
+                max_tries=20,
+            )
         except Exception as e:
             print(e)
             return False
@@ -212,7 +253,7 @@ class TableController(abc.ABC):
     def check_hplc_run_finished(self) -> Tuple[float, bool]:
         done_running = self.controller.check_if_not_running()
         if self.curr_run_starting_time and self.timeout:
-            time_passed = (time.time() - self.curr_run_starting_time)
+            time_passed = time.time() - self.curr_run_starting_time
             if time_passed > self.timeout:
                 enough_time_passed = time_passed >= self.timeout
                 run_finished = enough_time_passed and done_running
@@ -235,13 +276,25 @@ class TableController(abc.ABC):
         try:
             finished_run = not polling.poll(
                 lambda: self.check_hplc_run_finished()[1],
-                max_tries=minutes - 1, step=50)
-        except (polling.TimeoutException, polling.PollingException, polling.MaxCallException):
+                max_tries=minutes - 1,
+                step=50,
+            )
+        except (
+            polling.TimeoutException,
+            polling.PollingException,
+            polling.MaxCallException,
+        ):
             try:
                 finished_run = polling.poll(
                     lambda: self.check_hplc_run_finished()[1],
-                    timeout=self.timeout / 2, step=1)
-            except (polling.TimeoutException, polling.PollingException, polling.MaxCallException):
+                    timeout=self.timeout / 2,
+                    step=1,
+                )
+            except (
+                polling.TimeoutException,
+                polling.PollingException,
+                polling.MaxCallException,
+            ):
                 pass
 
         check_folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
@@ -250,14 +303,13 @@ class TableController(abc.ABC):
         elif check_folder.is_ok():
             try:
                 finished_run = polling.poll(
-                    lambda: self.check_hplc_run_finished()[1],
-                    max_tries=10,
-                    step=50)
+                    lambda: self.check_hplc_run_finished()[1], max_tries=10, step=50
+                )
                 if finished_run:
                     return check_folder
             except Exception:
                 self._reset_time()
-                return check_folder
+                return self.data_files[-1]
         return Err("Run did not complete as expected")
 
     @abc.abstractmethod
@@ -265,15 +317,23 @@ class TableController(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def get_data(self, custom_path: Optional[str] = None) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def get_data(
+        self, custom_path: Optional[str] = None
+    ) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
         pass
 
     @abc.abstractmethod
-    def get_data_uv(self) -> Union[List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]]:
+    def get_data_uv(
+        self,
+    ) -> Union[
+        List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]
+    ]:
         pass
 
     @abc.abstractmethod
-    def get_report(self, report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
+    def get_report(
+        self, report_type: ReportType = ReportType.TXT
+    ) -> List[AgilentReport]:
         pass
 
     def get_uv_spectrum(self, path: str):
@@ -281,12 +341,13 @@ class TableController(abc.ABC):
         times = data_uv.xlabels
         wavelengths = data_uv.ylabels
         absorbances = data_uv.data.transpose()
-        for (i, w) in enumerate(wavelengths):
+        for i, w in enumerate(wavelengths):
             self.uv[w] = AgilentHPLCChromatogram()
             self.uv[w].attach_spectrum(times, absorbances[i])
 
-    def get_report_details(self, path: str,
-                           report_type: ReportType = ReportType.TXT) -> AgilentReport:
+    def get_report_details(
+        self, path: str, report_type: ReportType = ReportType.TXT
+    ) -> AgilentReport:
         if report_type is ReportType.TXT:
             txt_report = TXTProcessor(path).process_report()
             if txt_report.is_ok():
@@ -297,7 +358,6 @@ class TableController(abc.ABC):
                 self.report = csv_report.ok_value
         return self.report
 
-
     def get_spectrum_at_channels(self, data_path: str):
         """
         Load chromatogram for any channel in spectra dictionary.

pychemstation/control/hplc.py

@@ -3,11 +3,12 @@ Module to provide API for higher-level HPLC actions.
 
 Authors: Lucy Hao
 """
+
 from __future__ import annotations
 
 from typing import Dict, List, Optional, Tuple, Union
 
-from pychemstation.utils.chromatogram import (
+from pychemstation.analysis.chromatogram import (
     AgilentHPLCChromatogram,
 )
 
@@ -17,7 +18,7 @@ from ..control.controllers import (
     MethodController,
     SequenceController,
 )
-from ..utils.chromatogram import AgilentChannelChromatogramData
+from pychemstation.analysis.chromatogram import AgilentChannelChromatogramData
 from ..utils.macro import Command, Response, Status
 from ..utils.method_types import MethodDetails
 from ..utils.sequence_types import SequenceTable
@@ -27,33 +28,23 @@ from .controllers.devices.injector import InjectorController
 
 class HPLCController:
     # tables
-    METHOD_TIMETABLE = Table(
-        register="RCPMP1Method[1]",
-        name="Timetable"
-    )
-
-    SEQUENCE_TABLE = Table(
-        register="_sequence[1]",
-        name="SeqTable1"
-    )
-
-    INJECTOR_TABLE = Table(
-        register="RCWLS1Pretreatment[1]",
-        name="InstructionTable"
-    )
-
-    MSD_TABLE = Table(
-        register="MSACQINFO[1]",
-        name="SprayChamber"
-    )
-
-    def __init__(self,
-                 comm_dir: str,
-                 method_dir: str,
-                 sequence_dir: str,
-                 data_dirs: List[str],
-                 offline: bool = False,
-                 debug: bool = False,):
+    METHOD_TIMETABLE = Table(register="RCPMP1Method[1]", name="Timetable")
+
+    SEQUENCE_TABLE = Table(register="_sequence[1]", name="SeqTable1")
+
+    INJECTOR_TABLE = Table(register="RCWLS1Pretreatment[1]", name="InstructionTable")
+
+    MSD_TABLE = Table(register="MSACQINFO[1]", name="SprayChamber")
+
+    def __init__(
+        self,
+        comm_dir: str,
+        method_dir: str,
+        sequence_dir: str,
+        data_dirs: List[str],
+        offline: bool = False,
+        debug: bool = False,
+    ):
         """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
         `comm_dir` must match the file path in the macro file. All file paths are normal strings, with the left slash
         double escaped: "C:\\my_folder\\"
@@ -65,21 +56,29 @@ class HPLCController:
         :param sequence_dir: Name of directory where sequence files are stored.
         :raises FileNotFoundError: If either `data_dir`, `method_dir`, `sequence_dir`, `sequence_data_dir`or `comm_dir` is not a valid directory.
         """
-        self.comm = CommunicationController(comm_dir=comm_dir, debug=debug) if not offline else None
-        self.method_controller = MethodController(controller=self.comm,
-                                                  src=method_dir,
-                                                  data_dirs=data_dirs,
-                                                  table=self.METHOD_TIMETABLE,
-                                                  offline=offline,
-                                                  injector_controller=InjectorController(controller=self.comm,
-                                                                                         table=self.INJECTOR_TABLE,
-                                                                                         offline=offline))
-        self.sequence_controller = SequenceController(controller=self.comm,
-                                                      src=sequence_dir,
-                                                      data_dirs=data_dirs,
-                                                      table=self.SEQUENCE_TABLE,
-                                                      method_controller=self.method_controller,
-                                                      offline=offline)
+        self.comm = (
+            CommunicationController(comm_dir=comm_dir, debug=debug)
+            if not offline
+            else None
+        )
+        self.method_controller = MethodController(
+            controller=self.comm,
+            src=method_dir,
+            data_dirs=data_dirs,
+            table=self.METHOD_TIMETABLE,
+            offline=offline,
+            injector_controller=InjectorController(
+                controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
+            ),
+        )
+        self.sequence_controller = SequenceController(
+            controller=self.comm,
+            src=sequence_dir,
+            data_dirs=data_dirs,
+            table=self.SEQUENCE_TABLE,
+            method_controller=self.method_controller,
+            offline=offline,
+        )
 
     def send(self, cmd: Union[Command, str]):
         """
@@ -89,7 +88,8 @@ class HPLCController:
         """
         if not self.comm:
             raise RuntimeError(
-                "Communication controller must be initialized before sending command. It is currently in offline mode.")
+                "Communication controller must be initialized before sending command. It is currently in offline mode."
+            )
         self.comm.send(cmd)
 
     def receive(self) -> Response:
@@ -100,7 +100,8 @@ class HPLCController:
         """
         if not self.comm:
             raise RuntimeError(
-                "Communication controller must be initialized before sending command. It is currently in offline mode.")
+                "Communication controller must be initialized before sending command. It is currently in offline mode."
+            )
         return self.comm.receive().value
 
     def status(self) -> Status:
@@ -111,7 +112,8 @@ class HPLCController:
         """
         if not self.comm:
             raise RuntimeError(
-                "Communication controller must be initialized before sending command. It is currently in offline mode.")
+                "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):
@@ -135,7 +137,12 @@ class HPLCController:
         """
         self.sequence_controller.switch(sequence_name)
 
-    def run_method(self, experiment_name: str, add_timestamp: bool = True, stall_while_running: bool = True):
+    def run_method(
+        self,
+        experiment_name: str,
+        add_timestamp: bool = True,
+        stall_while_running: bool = True,
+    ):
         """
         This is the preferred method to trigger a run.
         Starts the currently selected method, storing data
@@ -146,9 +153,11 @@ class HPLCController:
         :param stall_while_running: whether to return or stall while HPLC runs.
         :param add_timestamp: whether to append a timestamp in '%Y-%m-%d-%H-%M' format to end of experiment name.
         """
-        self.method_controller.run(experiment_name=experiment_name,
-                                   stall_while_running=stall_while_running,
-                                   add_timestamp=add_timestamp)
+        self.method_controller.run(
+            experiment_name=experiment_name,
+            stall_while_running=stall_while_running,
+            add_timestamp=add_timestamp,
+        )
 
     def stop_method(self):
         """Stops the current running method, manual intervention may be needed."""
@@ -197,9 +206,11 @@ class HPLCController:
         """
         self.sequence_controller.edit(updated_sequence)
 
-    def get_last_run_method_report(self,
-                                   custom_path: Optional[str] = None,
-                                   report_type: ReportType = ReportType.CSV) -> AgilentReport:
+    def get_last_run_method_report(
+        self,
+        custom_path: Optional[str] = None,
+        report_type: ReportType = ReportType.CSV,
+    ) -> AgilentReport:
         """
         Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
 
@@ -207,10 +218,13 @@ class HPLCController:
         :param report_type: read either the TXT or CSV version
         :return: report data for method
         """
-        return self.method_controller.get_report(custom_path=custom_path, report_type=report_type)[0]
+        return self.method_controller.get_report(
+            custom_path=custom_path, report_type=report_type
+        )[0]
 
-    def get_last_run_method_data(self, read_uv: bool = False,
-                                 custom_path: Optional[str] = None) -> Dict[str, AgilentHPLCChromatogram] | AgilentChannelChromatogramData:
+    def get_last_run_method_data(
+        self, read_uv: bool = False, custom_path: Optional[str] = None
+    ) -> Dict[str, AgilentHPLCChromatogram] | AgilentChannelChromatogramData:
         """
         Returns the last run method data.
 
@@ -222,9 +236,11 @@ class HPLCController:
         else:
             return self.method_controller.get_data(custom_path=custom_path)
 
-    def get_last_run_sequence_reports(self,
-                                      custom_path: Optional[str] = None,
-                                      report_type: ReportType = ReportType.CSV) -> List[AgilentReport]:
+    def get_last_run_sequence_reports(
+        self,
+        custom_path: Optional[str] = None,
+        report_type: ReportType = ReportType.CSV,
+    ) -> List[AgilentReport]:
         """
         Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
 
@@ -232,11 +248,15 @@ class HPLCController:
         :param report_type: read either the TXT or CSV version
         :return: list of reports for each row
         """
-        return self.sequence_controller.get_report(custom_path=custom_path, report_type=report_type)
-
-    def get_last_run_sequence_data(self, read_uv: bool = False,
-                                   custom_path: Optional[str] = None) -> List[Dict[int, AgilentHPLCChromatogram]] | \
-                                                                         List[AgilentChannelChromatogramData]:
+        return self.sequence_controller.get_report(
+            custom_path=custom_path, report_type=report_type
+        )
+
+    def get_last_run_sequence_data(
+        self, read_uv: bool = False, custom_path: Optional[str] = None
+    ) -> (
+        List[Dict[int, AgilentHPLCChromatogram]] | List[AgilentChannelChromatogramData]
+    ):
         """
         Returns data for all rows in the last run sequence data.
 
@@ -269,7 +289,7 @@ class HPLCController:
         self.send(Command.STANDBY_CMD)
 
     def preprun(self):
-        """ Prepares all modules for run. All lamps and pumps are switched on."""
+        """Prepares all modules for run. All lamps and pumps are switched on."""
         self.send(Command.PREPRUN_CMD)
 
     def lamp_on(self):

pychemstation/generated/__init__.py

@@ -19,13 +19,11 @@ from .dad_method import (
     AnalogOutput1,
     AnalogOutput2,
     DadMethod,
-    PostTime,
     PrepareAutomation,
     PrepareMode,
     Signal,
     Signals,
     SpectraAcquisition,
-    StopTime,
 )
 
 __all__ = [