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

pychemstation/control/controllers/tables/method.py

@@ -1,15 +1,15 @@
+from __future__ import annotations
+
 import os
 import time
 import warnings
-from typing import Dict, List, Optional, Union
+from typing import List, Optional, Union, Dict
 
 from result import Err, Ok, Result
-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,
@@ -22,7 +22,7 @@ from ....utils.method_types import (
     PType,
     TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, T, Table, TableOperation
+from ....utils.table_types import RegisterFlag, Table, TableOperation, T
 from ..devices.injector import InjectorController
 from .table import TableController
 
@@ -32,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)
@@ -52,19 +61,22 @@ 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
+        if self.controller:
+            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,
+                    )
+                ),
             )
-        ),
-            flow=self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.FLOW
-                )
-            ),
-        )
+        raise ValueError("Communication controller is offline!")
 
     def get_row(self, row: int) -> TimeTableEntry:
         flow = None
@@ -79,19 +91,26 @@ class MethodController(TableController):
         except RuntimeError:
             pass
 
-        return TimeTableEntry(start_time=self.get_num(row, RegisterFlag.TIME),
-                              organic_modifer=om,
-                              flow=flow)
+        if om is None and flow is None:
+            raise ValueError("Both flow and organic modifier is None")
+
+        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)]
-        timetable_rows = {}
+        timetable_rows: Dict[str, TimeTableEntry] = {}
         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
@@ -109,11 +128,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)
@@ -125,16 +146,24 @@ class MethodController(TableController):
         return method_name
 
     def get_post_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.POST_TIME))
+        if self.controller:
+            return self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=RegisterFlag.POST_TIME,
+                )
+            )
+        raise ValueError("Communication controller is not online!")
 
     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))
+        if self.controller:
+            return self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=RegisterFlag.MAX_TIME,
+                )
+            )
+        raise ValueError("Communication controller is not online!")
 
     def get_total_runtime(self) -> Union[int, float]:
         """Returns total method runtime in minutes."""
@@ -163,7 +192,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)
@@ -174,50 +207,6 @@ class MethodController(TableController):
             assert parsed_response == f"{method_name}.M", "Switching Methods failed."
         self.table_state = None
 
-    def load_from_disk(self, method_name: str) -> MethodDetails:
-        """
-        Retrieve method details of an existing method. Don't need to append ".M" to the end. This assumes the
-        organic modifier is in Channel B and that Channel A contains the aq layer. Additionally, assumes
-         only two solvents are being used.
-
-        :param method_name: name of method to load details of
-        :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")
-
-        if os.path.exists(os.path.join(self.src, f"{method_name}.M")):
-            parser = XmlParser()
-            method = parser.parse(method_path, PumpMethod)
-            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":
-                        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)
-            return self.table_state
-        else:
-            raise FileNotFoundError
-
     def edit(self, updated_method: MethodDetails, save: bool):
         """Updated the currently loaded method in ChemStation with provided values.
 
@@ -225,43 +214,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)
-        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)
+
+    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] | None,
+        new_post_time: Union[int, float] | None,
+    ):
+        self.delete_table()
+        self.edit_initial_om(new_initial_om)
+        self.edit_flow(new_flow)
+        if new_stop_time:
+            self.edit_stop_time(new_stop_time)
         else:
-            self._update_param(Param(val="Off", chemstation_key=RegisterFlag.STOPTIME_MODE, ptype=PType.STR))
-        if self.table_state.post_time:
-            self._update_param(Param(val="Set", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR))
-            self._update_param(post_time)
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+        if new_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.
@@ -270,34 +306,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()
@@ -305,19 +362,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()
@@ -329,7 +394,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):
         """
@@ -337,7 +402,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
@@ -349,9 +419,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
 
@@ -377,27 +457,37 @@ class MethodController(TableController):
                 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[str, str]:
+        if isinstance(most_recent_folder, str) or isinstance(most_recent_folder, bytes):
+            if os.path.exists(most_recent_folder):
+                return Ok(most_recent_folder)
+            return Err("Folder not found!")
+        raise ValueError("Folder is not a str or byte type.")
 
-    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) -> AgilentChannelChromatogramData:
+    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)
+        return AgilentChannelChromatogramData.from_dict(self.spectra)
 
-    def get_data_uv(self, custom_path: Optional[str] = None) -> Dict[str, AgilentHPLCChromatogram]:
+    def get_data_uv(
+        self, custom_path: Optional[str] = None
+    ) -> dict[int, 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]:
+    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: