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

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
@@ -8,14 +9,20 @@ from xsdata.formats.dataclass.parsers import XmlParser
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
 from ....generated import DadMethod, PumpMethod, SolventElement
-from ....utils.chromatogram import (
+from pychemstation.analysis.chromatogram import (
     TIME_FORMAT,
     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
 
@@ -25,15 +32,24 @@ class MethodController(TableController):
     Class containing method related logic
     """
 
-    def __init__(self, controller: CommunicationController,
-                 src: str,
-                 data_dirs: List[str],
-                 table: Table,
-                 offline: bool,
-                 injector_controller: InjectorController):
+    def __init__(
+        self,
+        controller: CommunicationController,
+        src: str,
+        data_dirs: List[str],
+        table: Table,
+        offline: bool,
+        injector_controller: InjectorController,
+    ):
         self.injector_controller = injector_controller
         self.data_files: List[str] = []
-        super().__init__(controller=controller, src=src, data_dirs=data_dirs, table=table, offline=offline)
+        super().__init__(
+            controller=controller,
+            src=src,
+            data_dirs=data_dirs,
+            table=table,
+            offline=offline,
+        )
 
     def check(self) -> str:
         time.sleep(2)
@@ -45,16 +61,17 @@ class MethodController(TableController):
         return "ERROR"
 
     def get_method_params(self) -> HPLCMethodParams:
-        return HPLCMethodParams(organic_modifier=self.controller.get_num_val(
-            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                register=self.table_locator.register,
-                register_flag=RegisterFlag.SOLVENT_B_COMPOSITION
-            )
-        ),
+        return HPLCMethodParams(
+            organic_modifier=self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
+                )
+            ),
             flow=self.controller.get_num_val(
                 cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
                     register=self.table_locator.register,
-                    register_flag=RegisterFlag.FLOW
+                    register_flag=RegisterFlag.FLOW,
                 )
             ),
         )
@@ -72,9 +89,11 @@ class MethodController(TableController):
         except RuntimeError:
             pass
 
-        return TimeTableEntry(start_time=self.get_num(row, RegisterFlag.TIME),
-                              organic_modifer=om,
-                              flow=flow)
+        return TimeTableEntry(
+            start_time=self.get_num(row, RegisterFlag.TIME),
+            organic_modifer=om,
+            flow=flow,
+        )
 
     def get_timetable(self, rows: int):
         uncoalesced_timetable_rows = [self.get_row(r + 1) for r in range(rows)]
@@ -82,9 +101,11 @@ class MethodController(TableController):
         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)
+                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
@@ -102,11 +123,13 @@ class MethodController(TableController):
             params = self.get_method_params()
             stop_time = self.get_stop_time()
             post_time = self.get_post_time()
-            self.table_state = MethodDetails(name=method_name,
-                                             timetable=timetable_rows,
-                                             stop_time=stop_time,
-                                             post_time=post_time,
-                                             params=params)
+            self.table_state = MethodDetails(
+                name=method_name,
+                timetable=timetable_rows,
+                stop_time=stop_time,
+                post_time=post_time,
+                params=params,
+            )
             return self.table_state
         else:
             raise RuntimeError(rows.err_value)
@@ -121,13 +144,21 @@ class MethodController(TableController):
         return self.controller.get_num_val(
             cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
                 register=self.table_locator.register,
-                register_flag=RegisterFlag.POST_TIME))
+                register_flag=RegisterFlag.POST_TIME,
+            )
+        )
 
     def get_stop_time(self) -> Union[int, float]:
         return self.controller.get_num_val(
             cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
                 register=self.table_locator.register,
-                register_flag=RegisterFlag.MAX_TIME))
+                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):
         """
@@ -152,7 +183,11 @@ class MethodController(TableController):
         :raise AssertionError: The desired method is not selected. Try again.
         """
         method_dir = self.src if not alt_method_dir else alt_method_dir
-        self.send(Command.SWITCH_METHOD_CMD_SPECIFIC.value.format(method_dir=method_dir, method_name=method_name))
+        self.send(
+            Command.SWITCH_METHOD_CMD_SPECIFIC.value.format(
+                method_dir=method_dir, method_name=method_name
+            )
+        )
 
         time.sleep(2)
         self.send(Command.GET_METHOD_CMD)
@@ -173,9 +208,16 @@ 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")
+        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",
+        )
 
         if os.path.exists(os.path.join(self.src, f"{method_name}.M")):
             parser = XmlParser()
@@ -183,25 +225,29 @@ class MethodController(TableController):
             dad = parser.parse(dad_path, DadMethod)
 
             organic_modifier: Optional[SolventElement] = None
-            aq_modifier: Optional[SolventElement] = None
 
             if len(method.solvent_composition.solvent_element) == 2:
                 for solvent in method.solvent_composition.solvent_element:
-                    if solvent.channel == "Channel_A":
-                        aq_modifier = solvent
-                    elif solvent.channel == "Channel_B":
+                    if solvent.channel == "Channel_B":
                         organic_modifier = solvent
 
-            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)
+            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
@@ -213,43 +259,90 @@ class MethodController(TableController):
         :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.params.organic_modifier,
-                                                chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-                                                ptype=PType.NUM)
-        max_time: Param = Param(val=updated_method.stop_time,
-                                chemstation_key=RegisterFlag.MAX_TIME,
-                                ptype=PType.NUM)
-        post_time: Param = Param(val=updated_method.post_time,
-                                 chemstation_key=RegisterFlag.POST_TIME,
-                                 ptype=PType.NUM)
-        flow: Param = Param(val=updated_method.params.flow,
-                            chemstation_key=RegisterFlag.FLOW,
-                            ptype=PType.NUM)
-
         # Method settings required for all runs
-        self.update_method_params(flow, initial_organic_modifier, max_time, post_time)
-        self._update_method_timetable(updated_method.timetable)
+        self.update_method_params(
+            new_flow=updated_method.params.flow,
+            new_initial_om=updated_method.params.organic_modifier,
+            new_stop_time=updated_method.stop_time,
+            new_post_time=updated_method.post_time,
+        )
+        self.edit_method_timetable(updated_method.timetable)
 
         if save:
-            self.send(Command.SAVE_METHOD_CMD.value.format(
-                commit_msg=f"saved method at {str(time.time())}"
-            ))
+            self.send(
+                Command.SAVE_METHOD_CMD.value.format(
+                    commit_msg=f"saved method at {str(time.time())}"
+                )
+            )
 
-    def update_method_params(self, flow, initial_organic_modifier, max_time, post_time):
-        self.delete_table()
+    def edit_initial_om(self, new_om: Union[int, float]):
+        initial_organic_modifier: Param = Param(
+            val=new_om,
+            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+            ptype=PType.NUM,
+        )
         self._update_param(initial_organic_modifier)
+
+    def edit_flow(self, new_flow: Union[int, float]):
+        flow: Param = Param(
+            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
+        )
         self._update_param(flow)
+
+    def edit_stop_time(self, new_stop_time: Union[int, float]):
+        stop_time: Param = Param(
+            val=new_stop_time,
+            chemstation_key=RegisterFlag.MAX_TIME,
+            ptype=PType.NUM,
+        )
+        self._update_param(
+            Param(
+                val="Set", chemstation_key=RegisterFlag.STOPTIME_MODE, ptype=PType.STR
+            )
+        )
+        self._update_param(stop_time)
+
+    def edit_post_time(self, new_post_time: Union[int, float]):
+        post_time: Param = Param(
+            val=new_post_time,
+            chemstation_key=RegisterFlag.POST_TIME,
+            ptype=PType.NUM,
+        )
+        self._update_param(
+            Param(val="Set", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR)
+        )
+        self._update_param(post_time)
+
+    def update_method_params(
+        self,
+        new_flow: Union[int, float],
+        new_initial_om: Union[int, float],
+        new_stop_time: Union[int, float],
+        new_post_time: Union[int, float],
+    ):
+        self.delete_table()
+        self.edit_initial_om(new_initial_om)
+        self.edit_flow(new_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)
+            self.edit_stop_time(new_stop_time)
         else:
-            self._update_param(Param(val="Off", chemstation_key=RegisterFlag.STOPTIME_MODE, ptype=PType.STR))
+            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.edit_post_time(new_post_time)
         else:
-            self._update_param(Param(val="Off", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR))
-        self.download()
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.POSTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
 
     def _update_param(self, method_param: Param):
         """Change a method parameter, changes what is visibly seen in Chemstation GUI.
@@ -258,34 +351,55 @@ class MethodController(TableController):
         :param method_param: a parameter to update for currently loaded method.
         """
         register = self.table_locator.register
-        setting_command = TableOperation.UPDATE_OBJ_HDR_VAL if method_param.ptype == PType.NUM else TableOperation.UPDATE_OBJ_HDR_TEXT
+        setting_command = (
+            TableOperation.UPDATE_OBJ_HDR_VAL
+            if method_param.ptype == PType.NUM
+            else TableOperation.UPDATE_OBJ_HDR_TEXT
+        )
         if isinstance(method_param.chemstation_key, list):
             for register_flag in method_param.chemstation_key:
-                self.send(setting_command.value.format(register=register,
-                                                       register_flag=register_flag,
-                                                       val=method_param.val))
+                self.send(
+                    setting_command.value.format(
+                        register=register,
+                        register_flag=register_flag,
+                        val=method_param.val,
+                    )
+                )
         else:
-            self.send(setting_command.value.format(register=register,
-                                                   register_flag=method_param.chemstation_key,
-                                                   val=method_param.val))
+            self.send(
+                setting_command.value.format(
+                    register=register,
+                    register_flag=method_param.chemstation_key,
+                    val=method_param.val,
+                )
+            )
         time.sleep(2)
+        self.download()
 
     def download(self):
-        self.send('Sleep 1')
+        self.send("Sleep 1")
         self.sleepy_send("DownloadRCMethod PMP1")
-        self.send('Sleep 1')
+        self.send("Sleep 1")
 
-    def edit_row(self, row: TimeTableEntry, first_row: bool = False):
+    def _edit_row(self, row: TimeTableEntry, first_row: bool = False):
         if first_row:
             if row.organic_modifer:
                 self.add_row()
-                self.add_new_col_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.SOLVENT_COMPOSITION.value)
+                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_new_col_num(
+                    col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
+                    val=row.organic_modifer,
+                )
             if row.flow:
                 self.add_row()
                 self.get_num_rows()
-                self._edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
+                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()
@@ -293,19 +407,27 @@ class MethodController(TableController):
             if row.organic_modifer:
                 self.add_row()
                 self.get_num_rows()
-                self._edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.SOLVENT_COMPOSITION.value)
+                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._edit_row_num(
+                    col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
+                    val=row.organic_modifer,
+                )
                 self.download()
             if row.flow:
                 self.add_row()
                 self.get_num_rows()
-                self._edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
+                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]):
+    def edit_method_timetable(self, timetable_rows: List[TimeTableEntry]):
         self.get_num_rows()
         self.delete_table()
         res = self.get_num_rows()
@@ -317,7 +439,7 @@ class MethodController(TableController):
         self.get_num_rows()
 
         for i, row in enumerate(timetable_rows):
-            self.edit_row(row=row, first_row=i == 0)
+            self._edit_row(row=row, first_row=i == 0)
 
     def stop(self):
         """
@@ -325,7 +447,12 @@ class MethodController(TableController):
         """
         self.send(Command.STOP_METHOD_CMD)
 
-    def run(self, experiment_name: str, add_timestamp: bool = True, stall_while_running: bool = True):
+    def run(
+        self,
+        experiment_name: str,
+        add_timestamp: bool = True,
+        stall_while_running: bool = True,
+    ):
         """
         :param experiment_name: Name of the experiment
         :param stall_while_running: whether to stall or immediately return
@@ -337,9 +464,19 @@ class MethodController(TableController):
         tries = 0
         while tries < 10 and not hplc_is_running:
             timestamp = time.strftime(TIME_FORMAT)
-            self.send(Command.RUN_METHOD_CMD.value.format(data_dir=self.data_dirs[0],
-                                                          experiment_name=f"{experiment_name}_{timestamp}" if add_timestamp else experiment_name))
-            folder_name = f"{experiment_name}_{timestamp}.D" if add_timestamp else f"{experiment_name}.D"
+            self.send(
+                Command.RUN_METHOD_CMD.value.format(
+                    data_dir=self.data_dirs[0],
+                    experiment_name=f"{experiment_name}_{timestamp}"
+                    if add_timestamp
+                    else experiment_name,
+                )
+            )
+            folder_name = (
+                f"{experiment_name}_{timestamp}.D"
+                if add_timestamp
+                else f"{experiment_name}.D"
+            )
             hplc_is_running = self.check_hplc_is_running()
             tries += 1
 
@@ -347,35 +484,53 @@ 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_report(self, custom_path: Optional[str] = None,
-                   report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
+    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]:
         custom_path = self.data_files[-1] if not custom_path else custom_path
         metd_report = self.get_report_details(custom_path, report_type)
-        chrom_data: List[AgilentHPLCChromatogram] = list(self.get_data(custom_path).__dict__.values())
+        chrom_data: List[AgilentHPLCChromatogram] = list(
+            self.get_data(custom_path).__dict__.values()
+        )
         for i, signal in enumerate(metd_report.signals):
             possible_data = chrom_data[i]
             if len(possible_data.x) > 0:

pychemstation/control/controllers/tables/ms.py

@@ -2,13 +2,14 @@ from typing import Union
 
 from ....control.controllers import CommunicationController
 from ....control.controllers.tables.table import TableController
-from ....utils.chromatogram import AgilentChannelChromatogramData
+from pychemstation.analysis.chromatogram import AgilentChannelChromatogramData
 from ....utils.table_types import Table
 
 
 class MassSpecController(TableController):
-
-    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
+    def __init__(
+        self, controller: CommunicationController, src: str, data_dir: str, table: Table
+    ):
         super().__init__(controller, src, data_dir, table)
 
     def get_row(self, row: int):
@@ -17,5 +18,7 @@ class MassSpecController(TableController):
     def retrieve_recent_data_files(self):
         pass
 
-    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def get_data(
+        self,
+    ) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
         pass