pychemstation 0.10.7__py3-none-any.whl → 0.10.8__py3-none-any.whl

pychemstation/control/controllers/data_aq/method.py

@@ -3,18 +3,19 @@ from __future__ import annotations
 import os
 import time
 import warnings
-from typing import List, Optional, Union, Dict, Set
+from typing import Dict, List, Optional, Union, Tuple
 
 from result import Err, Ok, Result
 
-from ..abc_tables.run import RunController
-from ....analysis.process_report import AgilentReport, ReportType
-from ....control.controllers import CommunicationController
 from pychemstation.analysis.chromatogram import (
     TIME_FORMAT,
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
+
+from ....analysis.process_report import AgilentReport, ReportType
+from ....control.controllers import CommunicationController
+from ....utils.abc_tables.run import RunController
 from ....utils.macro import Command
 from ....utils.method_types import (
     HPLCMethodParams,
@@ -23,20 +24,18 @@ from ....utils.method_types import (
     PType,
     TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, Table, TableOperation, T
+from ....utils.table_types import RegisterFlag, T, Table, TableOperation
 from ..devices.injector import InjectorController
 
 
 class MethodController(RunController):
-    """
-    Class containing method related logic
-    """
+    """Class containing method related logic."""
 
     def __init__(
         self,
-        controller: CommunicationController,
-        src: str,
-        data_dirs: List[str],
+        controller: Optional[CommunicationController],
+        src: Optional[str],
+        data_dirs: Optional[List[str]],
         table: Table,
         offline: bool,
         injector_controller: InjectorController,
@@ -51,10 +50,8 @@ class MethodController(RunController):
             offline=offline,
         )
 
-    def check(self) -> str:
-        time.sleep(2)
-        self.send(Command.GET_METHOD_CMD)
-        time.sleep(2)
+    def get_current_method_name(self) -> str:
+        self.sleepy_send(Command.GET_METHOD_CMD)
         res = self.receive()
         if res.is_ok():
             return res.ok_value.string_response
@@ -79,26 +76,22 @@ class MethodController(RunController):
         raise ValueError("Communication controller is offline!")
 
     def get_row(self, row: int) -> TimeTableEntry:
-        flow = None
-        om = None
-
-        try:
-            flow = self.get_num(row, RegisterFlag.TIMETABLE_FLOW)
-        except RuntimeError:
-            pass
-        try:
-            om = self.get_num(row, RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION)
-        except RuntimeError:
-            pass
-
-        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,
-        )
+        function = self.get_text(row, RegisterFlag.FUNCTION)
+        if function == RegisterFlag.FLOW.value:
+            return TimeTableEntry(
+                start_time=self.get_num(row, RegisterFlag.TIME),
+                organic_modifer=None,
+                flow=self.get_num(row, RegisterFlag.TIMETABLE_FLOW),
+            )
+        if function == RegisterFlag.SOLVENT_COMPOSITION.value:
+            return TimeTableEntry(
+                start_time=self.get_num(row, RegisterFlag.TIME),
+                organic_modifer=self.get_num(
+                    row, RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION
+                ),
+                flow=None,
+            )
+        raise ValueError("Both flow and organic modifier are empty")
 
     def get_timetable(self, rows: int):
         uncoalesced_timetable_rows = [self.get_row(r + 1) for r in range(rows)]
@@ -197,7 +190,6 @@ class MethodController(RunController):
                 method_dir=method_dir, method_name=method_name
             )
         )
-
         time.sleep(2)
         self.send(Command.GET_METHOD_CMD)
         time.sleep(2)
@@ -221,6 +213,7 @@ class MethodController(RunController):
             new_stop_time=updated_method.stop_time,
             new_post_time=updated_method.post_time,
         )
+        self.validate_timetable(updated_method.timetable)
         self.edit_method_timetable(updated_method.timetable)
 
         if save:
@@ -231,6 +224,7 @@ class MethodController(RunController):
             )
 
     def edit_initial_om(self, new_om: Union[int, float]):
+        self._validate_organic_modifier(new_om)
         initial_organic_modifier: Param = Param(
             val=new_om,
             chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
@@ -238,13 +232,31 @@ class MethodController(RunController):
         )
         self._update_param(initial_organic_modifier)
 
+    def _validate_organic_modifier(self, new_om):
+        if not (isinstance(new_om, int) or isinstance(new_om, float)):
+            raise ValueError("Organic modifier must be int or float")
+        if new_om < 0:
+            raise ValueError("Organic modifier must be positive")
+        if new_om > 100:
+            raise ValueError("Organic modifer must be less than 100.")
+
     def edit_flow(self, new_flow: Union[int, float]):
+        self._validate_flow(new_flow)
         flow: Param = Param(
             val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
         )
         self._update_param(flow)
 
+    def _validate_flow(self, new_flow):
+        if not (isinstance(new_flow, int) or isinstance(new_flow, float)):
+            raise ValueError("Flow must be int or float")
+        if new_flow < 0:
+            raise ValueError("Flow must be positive")
+        if new_flow >= 5.0:
+            raise ValueError("Flow must be less than 5.0")
+
     def edit_stop_time(self, new_stop_time: Union[int, float]):
+        self.validate_stop_time(new_stop_time)
         stop_time: Param = Param(
             val=new_stop_time,
             chemstation_key=RegisterFlag.MAX_TIME,
@@ -257,7 +269,14 @@ class MethodController(RunController):
         )
         self._update_param(stop_time)
 
+    def validate_stop_time(self, new_stop_time):
+        if not (isinstance(new_stop_time, int) or isinstance(new_stop_time, float)):
+            raise ValueError("Stop time must be int or float")
+        if new_stop_time < 0:
+            raise ValueError("Stop time must be positive")
+
     def edit_post_time(self, new_post_time: Union[int, float]):
+        self.validate_post_time(new_post_time)
         post_time: Param = Param(
             val=new_post_time,
             chemstation_key=RegisterFlag.POST_TIME,
@@ -268,6 +287,12 @@ class MethodController(RunController):
         )
         self._update_param(post_time)
 
+    def validate_post_time(self, new_post_time):
+        if not (isinstance(new_post_time, int) or isinstance(new_post_time, float)):
+            raise ValueError("Post time must be int or float")
+        if new_post_time < 0:
+            raise ValueError("Post time must be positive")
+
     def update_method_params(
         self,
         new_flow: Union[int, float],
@@ -328,59 +353,151 @@ class MethodController(RunController):
                     val=method_param.val,
                 )
             )
-        time.sleep(2)
         self.download()
 
     def download(self):
-        self.send("Sleep 1")
         self.sleepy_send("DownloadRCMethod PMP1")
-        self.send("Sleep 1")
 
-    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,
-                )
+    def _edit_row(
+        self,
+        row: TimeTableEntry,
+        first_row: bool,
+        time_added: bool,
+        flow_added: bool,
+        om_added: bool,
+        function_added: bool,
+    ) -> Tuple[bool, bool, bool, bool]:
+        def add_time():
+            nonlocal time_added
+            nonlocal first_row
+            if not time_added:
                 self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
+                time_added = True
+            elif not first_row:
+                self._edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
+
+        def add_flow():
+            nonlocal flow_added
+            nonlocal function_added
+            if not flow_added:
+                if not function_added:
+                    self.add_new_col_text(
+                        col_name=RegisterFlag.FUNCTION,
+                        val=RegisterFlag.FLOW.value,
+                    )
+                    function_added = True
+                else:
+                    self._edit_row_text(
+                        col_name=RegisterFlag.FUNCTION,
+                        val=RegisterFlag.FLOW.value,
+                    )
                 self.add_new_col_num(
-                    col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
-                    val=row.organic_modifer,
+                    col_name=RegisterFlag.TIMETABLE_FLOW,
+                    val=row.flow,
                 )
-            if row.flow:
-                self.add_row()
-                self.get_num_rows()
+                flow_added = True
+            else:
                 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()
-        else:
-            if row.organic_modifer:
-                self.add_row()
-                self.get_num_rows()
+
+        def add_om():
+            nonlocal om_added
+            nonlocal function_added
+            if not om_added:
+                if not function_added:
+                    self.add_new_col_text(
+                        col_name=RegisterFlag.FUNCTION,
+                        val=RegisterFlag.SOLVENT_COMPOSITION.value,
+                    )
+                    function_added = True
+                else:
+                    self._edit_row_text(
+                        col_name=RegisterFlag.FUNCTION,
+                        val=RegisterFlag.SOLVENT_COMPOSITION.value,
+                    )
+                self.add_new_col_num(
+                    col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
+                    val=row.organic_modifer,
+                )
+                om_added = True
+            else:
                 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.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_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
-                self._edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
-                self.download()
+
+        if row.organic_modifer:
+            self.add_row()
+            add_om()
+            add_time()
+        if row.flow:
+            self.add_row()
+            add_flow()
+            add_time()
+        self.download()
+        return time_added, flow_added, om_added, function_added
+
+        # if first_row:
+        #     time_added = False
+        #     flow_row_method: Callable = (
+        #         self.add_new_col_text
+        #         if row.flow and not row.organic_modifer
+        #         else self._edit_row_text
+        #     )
+        #     if row.organic_modifer:
+        #         self.add_row()
+        #         self.add_new_col_text(
+        #             col_name=RegisterFlag.FUNCTION,
+        #             val=RegisterFlag.SOLVENT_COMPOSITION.value,
+        #         )
+        #         if not time_added:
+        #             time_added = True
+        #             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,
+        #         )
+        #     if row.flow:
+        #         self.add_row()
+        #         self.get_num_rows()
+        #         flow_row_method(
+        #             col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value
+        #         )
+        #         if not time_added:
+        #             time_added = True
+        #             self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
+        #         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()
+        # else:
+        #     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_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.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_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
+        #         self._edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
+        #         self.download()
 
     def edit_method_timetable(self, timetable_rows: List[TimeTableEntry]):
         self.get_num_rows()
@@ -391,10 +508,23 @@ class MethodController(RunController):
             res = self.get_num_rows()
 
         self.new_table()
-        self.get_num_rows()
-
+        num_rows = self.get_num_rows()
+        if num_rows.ok_value.num_response != 0:
+            raise ValueError("Should be zero rows!")
+
+        time_added = False
+        flow_added = False
+        om_added = False
+        function_added = False
         for i, row in enumerate(timetable_rows):
-            self._edit_row(row=row, first_row=i == 0)
+            time_added, flow_added, om_added, function_added = self._edit_row(
+                row=row,
+                first_row=i == 0,
+                time_added=time_added,
+                flow_added=flow_added,
+                om_added=om_added,
+                function_added=function_added,
+            )
 
     def stop(self):
         """
@@ -441,23 +571,25 @@ class MethodController(RunController):
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
-                raise RuntimeError(f"Run error has occurred:{run_completed.err_value}.")
+                warnings.warn(run_completed.err_value)
         else:
-            folder = self.fuzzy_match_most_recent_folder(self.data_files[-1], None)
-            while folder.is_err():
-                folder = self.fuzzy_match_most_recent_folder(self.data_files[-1], None)
+            folder = self._fuzzy_match_most_recent_folder(self.data_files[-1])
+            i = 0
+            while folder.is_err() and i < 10:
+                folder = self._fuzzy_match_most_recent_folder(self.data_files[-1])
+                i += 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, child_dirs: Optional[Set[str]]
+    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 Ok(str(most_recent_folder))
             return Err("Folder not found!")
         raise ValueError("Folder is not a str or byte type.")
 
@@ -490,3 +622,25 @@ class MethodController(RunController):
             if len(possible_data.x) > 0:
                 signal.data = possible_data
         return [metd_report]
+
+    def _validate_row(self, row: TimeTableEntry):
+        if not (row.flow or row.organic_modifer):
+            raise ValueError(
+                "Require one of flow or organic modifier for the method timetable entry!"
+            )
+        if row.flow:
+            self._validate_flow(row.flow)
+        if row.organic_modifer:
+            self._validate_organic_modifier(row.organic_modifer)
+
+    def validate_timetable(self, timetable: List[TimeTableEntry]):
+        start_time = 0.0
+        for i, row in enumerate(timetable):
+            if row.start_time > start_time:
+                start_time = row.start_time
+            elif row.start_time <= start_time:
+                raise ValueError(
+                    f"""Every row's start time must be larger than the previous start time. 
+                    Row {i + 1} ({timetable[i].start_time}) has a smaller or equal starttime than row {i} ({start_time})"""
+                )
+            self._validate_row(row)