pychemstation 0.10.8.dev1__py3-none-any.whl → 0.10.8.dev3__py3-none-any.whl

pychemstation/control/controllers/data_aq/method.py

@@ -3,17 +3,18 @@ from __future__ import annotations
 import os
 import time
 import warnings
-from typing import List, Optional, Union, Dict, Set
+from typing import Dict, List, Optional, Set, Union, Tuple
 
 from result import Err, Ok, Result
 
-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 (
@@ -23,7 +24,7 @@ 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
 
 
@@ -77,26 +78,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)]
@@ -219,6 +216,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:
@@ -229,6 +227,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,
@@ -236,13 +235,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,
@@ -255,7 +272,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,
@@ -266,6 +290,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],
@@ -334,51 +364,146 @@ class MethodController(RunController):
         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()
@@ -389,10 +514,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):
         """
@@ -490,3 +628,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)

pychemstation/control/controllers/data_aq/sequence.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import os
 import time
 import warnings
-from typing import Any, Dict, List, Optional, Union, Set
+from typing import Any, Dict, List, Optional, Union, Set, Tuple
 
 from result import Err, Ok, Result
 from typing_extensions import override
@@ -9,6 +11,7 @@ from typing_extensions import override
 from pychemstation.analysis.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
+    SEQUENCE_TIME_FORMAT,
 )
 
 from ....analysis.process_report import AgilentReport, ReportType
@@ -118,7 +121,6 @@ class SequenceController(RunController):
         parsed_response = self.get_current_sequence_name()
 
         assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
-        self.table_state = self.load()
 
     def get_current_sequence_name(self):
         self.send(Command.GET_SEQUENCE_CMD)
@@ -186,6 +188,8 @@ class SequenceController(RunController):
     def edit_sample_type(
         self, sample_type: SampleType, row_num: int, save: bool = True
     ):
+        if not isinstance(sample_type, SampleType):
+            raise ValueError("`sample_type` should be of type `SampleType`")
         self._edit_row_num(
             row=row_num,
             col_name=RegisterFlag.SAMPLE_TYPE,
@@ -207,6 +211,8 @@ class SequenceController(RunController):
     def edit_injection_source(
         self, inj_source: InjectionSource, row_num: int, save: bool = True
     ):
+        if not isinstance(inj_source, InjectionSource):
+            raise ValueError("`inj_source` should be of type `InjectionSource`")
         self._edit_row_text(
             row=row_num, col_name=RegisterFlag.INJ_SOR, val=inj_source.value
         )
@@ -224,25 +230,65 @@ class SequenceController(RunController):
 
     def edit_num_injections(self, num_inj: int, row_num: int, save: bool = True):
         self._edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=num_inj)
+        if save:
+            self.save()
 
-    def edit_method_name(self, method: str, row_num: int, save: bool = True):
+    def edit_method_name(
+        self, method: str, row_num: int, save: bool = True, override_check: bool = False
+    ):
         method_dir = self.method_controller.src
         possible_path = os.path.join(method_dir, method) + ".M\\"
         if os.path.exists(possible_path):
             method = os.path.join(method_dir, method)
+        elif not override_check:
+            raise ValueError(
+                "Method may not exist. If you would still like to use this method, set the `override_check` flag to `True`"
+            )
         self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
         if save:
             self.save()
 
     def edit_vial_location(self, loc: Tray, row_num: int, save: bool = True):
         loc_num = -1
-        if isinstance(loc, VialBar):
-            loc_num = loc.value
-        elif isinstance(loc, FiftyFourVialPlate):
-            loc_num = loc.value()
-        self._edit_row_num(
-            row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
-        )
+        try:
+            previous_contents = self.get_row(row_num)
+            if (
+                isinstance(loc, VialBar)
+                and isinstance(previous_contents.vial_location, VialBar)
+                or isinstance(loc, FiftyFourVialPlate)
+                and isinstance(previous_contents.vial_location, FiftyFourVialPlate)
+            ):
+                if isinstance(loc, VialBar):
+                    loc_num = loc.value
+                elif isinstance(loc, FiftyFourVialPlate):
+                    loc_num = loc.value()
+                self._edit_row_num(
+                    row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
+                )
+            elif isinstance(loc, VialBar) or isinstance(loc, FiftyFourVialPlate):
+                self.add_row()
+                previous_contents.vial_location = loc
+                num_rows = self.get_num_rows().ok_value.num_response
+                self._edit_row(previous_contents, num_rows)
+                self.move_row(int(num_rows), row_num)
+                self.delete_row(row_num + 1)
+                self.save()
+            else:
+                raise ValueError(
+                    "`loc` should be of type `VialBar`, `FiftyFourVialPlate`"
+                )
+        except Exception:
+            if not (isinstance(loc, VialBar) or isinstance(loc, FiftyFourVialPlate)):
+                raise ValueError(
+                    "`loc` should be of type `VialBar`, `FiftyFourVialPlate`"
+                )
+            if isinstance(loc, VialBar):
+                loc_num = loc.value
+            elif isinstance(loc, FiftyFourVialPlate):
+                loc_num = loc.value()
+            self._edit_row_num(
+                row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
+            )
         if save:
             self.save()
 
@@ -284,6 +330,9 @@ class SequenceController(RunController):
                     curr_method_runtime = self.method_controller.get_total_runtime()
             total_runtime += curr_method_runtime
 
+        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
+        folder_name = f"{self.table_state.name} {timestamp}"
+
         self.send(Command.RUN_SEQUENCE_CMD.value)
         self.timeout = total_runtime * 60
 
@@ -295,15 +344,7 @@ class SequenceController(RunController):
                 break
 
         if hplc_running:
-            full_path_name, current_sample_file = None, None
-            for _ in range(5):
-                try:
-                    full_path_name, current_sample_file = (
-                        self.get_current_run_data_dir_file()
-                    )
-                    break
-                except ValueError:
-                    pass
+            current_sample_file, full_path_name = self.try_getting_run_info(folder_name)
             if full_path_name and current_sample_file:
                 data_file = SequenceDataFiles(
                     sequence_name=self.table_state.name,
@@ -324,6 +365,36 @@ class SequenceController(RunController):
         else:
             raise RuntimeError("Sequence run may not have started.")
 
+    def try_getting_run_info(self, folder_name: str) -> Tuple[str, str | None]:
+        full_path_name, current_sample_file = None, None
+        for _ in range(5):
+            try:
+                full_path_name, current_sample_file = (
+                    self.get_current_run_data_dir_file()
+                )
+            except ValueError:
+                pass
+        if full_path_name and folder_name in full_path_name:
+            pass
+        else:
+            if self.controller:
+                self.controller.send(Command.GET_RUNNING_SEQUENCE_DIR)
+                res = self.controller.receive()
+                if res.is_ok():
+                    if os.path.isdir(res.ok_value.string_response):
+                        if folder_name in res.ok_value.string_response:
+                            full_path_name = res.ok_value.string_response
+                else:
+                    raise ValueError("Could not get sequence data folder.")
+            else:
+                raise ValueError("Controller is offline.")
+        if current_sample_file and full_path_name:
+            return full_path_name, current_sample_file
+        elif full_path_name:
+            return full_path_name, None
+        else:
+            raise ValueError("Could not get sequence data folder")
+
     @override
     def _fuzzy_match_most_recent_folder(
         self, most_recent_folder: T, child_dirs: Optional[Set[str]]
@@ -338,8 +409,13 @@ class SequenceController(RunController):
                         and set(most_recent_folder._data_files) == child_dirs
                     ):
                         most_recent_folder.child_dirs = [
-                            os.path.join(most_recent_folder.dir, f) for f in child_dirs
+                            os.path.join(most_recent_folder.dir, f)
+                            if not os.path.isdir(f)
+                            else f
+                            for f in child_dirs
                         ]
+                        for d in most_recent_folder.child_dirs:
+                            assert os.path.isdir(d)
                     else:
                         potential_folders: List[str] = sorted(
                             list(
@@ -427,6 +503,13 @@ class SequenceController(RunController):
                 ).ok_value
             )
         parent_dir = self.data_files[-1]
+        if (
+            len(parent_dir._data_files) != len(parent_dir.child_dirs)
+            or len(parent_dir.child_dirs) == 0
+        ):
+            parent_dir = self._fuzzy_match_most_recent_folder(
+                most_recent_folder=parent_dir, child_dirs=None
+            )
         spectra = self.get_data()
         reports = []
         for i, child_dir in enumerate(parent_dir.child_dirs):

pychemstation/control/hplc.py

@@ -20,7 +20,7 @@ from ..control.controllers import CommunicationController
 from ..utils.injector_types import InjectorTable
 from ..utils.macro import Command, Response, Status
 from ..utils.method_types import MethodDetails
-from ..utils.sequence_types import SequenceTable
+from ..utils.sequence_types import SequenceTable, SequenceDataFiles
 from ..utils.table_types import Table
 
 
@@ -107,7 +107,11 @@ class HPLCController:
             raise RuntimeError(
                 "Communication controller must be initialized before sending command. It is currently in offline mode."
             )
-        return self.comm.receive().value
+        res = self.comm.receive()
+        if res.is_ok():
+            return res.ok_value
+        else:
+            return res.err_value
 
     def status(self) -> Status:
         """Get the current status of the HPLC machine.
@@ -202,6 +206,16 @@ class HPLCController:
         """
         self.sequence_controller.edit(updated_sequence)
 
+    def get_last_run_method_file_path(self) -> str:
+        """Get the folder (ending with .D) for last run method.
+
+        :return: Complete path for method run.
+        """
+        if len(self.method_controller.data_files) > 0:
+            return self.method_controller.data_files[-1]
+        else:
+            raise UserWarning("No data yet!")
+
     def get_last_run_method_report(
         self,
         custom_path: Optional[str] = None,
@@ -230,6 +244,20 @@ class HPLCController:
         else:
             return self.method_controller.get_data(custom_path=custom_path)
 
+    def get_last_run_sequence_file_paths(self) -> SequenceDataFiles:
+        """Get the sequence folder and all run folders (ending with .D).
+
+        :return: `SequenceDataFiles` containing complete path locations for sequence folder and all runs.
+        """
+        if len(self.sequence_controller.data_files):
+            self.sequence_controller._fuzzy_match_most_recent_folder(
+                most_recent_folder=self.sequence_controller.data_files[-1],
+                child_dirs=set(),
+            )
+            return self.sequence_controller.data_files[-1]
+        else:
+            raise UserWarning("No data files yet!")
+
     def get_last_run_sequence_reports(
         self,
         custom_path: Optional[str] = None,

pychemstation/utils/abc_tables/abc_comm.py

@@ -57,7 +57,6 @@ class ABCCommunicationController(abc.ABC):
 
             self.reset_cmd_counter()
             self._most_recent_hplc_status: Status = self.get_status()
-            self.send("Local Rows")
 
     @abstractmethod
     def get_num_val(self, cmd: str) -> Union[int, float]:

pychemstation/utils/abc_tables/run.py

@@ -255,9 +255,14 @@ class RunController(ABCTableController, abc.ABC):
         self.send(Command.GET_CURRENT_RUN_DATA_FILE)
         current_sample_file = self.receive()
         if full_path_name.is_ok() and current_sample_file.is_ok():
-            return (
-                full_path_name.ok_value.string_response,
-                current_sample_file.ok_value.string_response,
-            )
-        else:
-            raise ValueError("Couldn't read data dir and file.")
+            if os.path.isdir(full_path_name.ok_value.string_response) and os.path.isdir(
+                os.path.join(
+                    full_path_name.ok_value.string_response,
+                    current_sample_file.ok_value.string_response,
+                )
+            ):
+                return (
+                    full_path_name.ok_value.string_response,
+                    current_sample_file.ok_value.string_response,
+                )
+        raise ValueError("Couldn't read data dir and file or doesn't exist yet.")

pychemstation/utils/abc_tables/table.py

@@ -126,8 +126,8 @@ class ABCTableController(abc.ABC):
     ):
         if not (isinstance(val, int) or isinstance(val, float)):
             raise ValueError(f"{val} must be an int or float.")
+        num_rows = self.get_num_rows()
         if row:
-            num_rows = self.get_num_rows()
             if num_rows.is_ok():
                 if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
@@ -136,7 +136,7 @@ class ABCTableController(abc.ABC):
             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",
+                row=row if row is not None else "response_num",
                 col_name=col_name,
                 val=val,
             )
@@ -147,8 +147,8 @@ class ABCTableController(abc.ABC):
     ):
         if not isinstance(val, str):
             raise ValueError(f"{val} must be a str.")
+        num_rows = self.get_num_rows()
         if row:
-            num_rows = self.get_num_rows()
             if num_rows.is_ok():
                 if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
@@ -157,7 +157,7 @@ class ABCTableController(abc.ABC):
             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",
+                row=row if row is not None else "response_num",
                 col_name=col_name,
                 val=val,
             )
@@ -178,11 +178,15 @@ class ABCTableController(abc.ABC):
 
     def add_row(self):
         """Adds a row to the provided table for currently loaded method or sequence."""
+        previous_row_count = self.get_num_rows().ok_value.num_response
         self.sleepy_send(
             TableOperation.NEW_ROW.value.format(
                 register=self.table_locator.register, table_name=self.table_locator.name
             )
         )
+        new_row_count = self.get_num_rows().ok_value.num_response
+        if previous_row_count + 1 != new_row_count:
+            raise ValueError("Row could not be added.")
 
     def delete_table(self):
         """Deletes the table."""
@@ -201,13 +205,6 @@ class ABCTableController(abc.ABC):
         )
 
     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,
@@ -221,8 +218,16 @@ class ABCTableController(abc.ABC):
             raise ValueError("Controller is offline")
 
         if res.is_ok():
-            self.send("Sleep 0.1")
-            self.send("Print Rows")
             return res
         else:
             return Err("No rows could be read.")
+
+    def move_row(self, from_row: int, to_row: int):
+        self.send(
+            TableOperation.MOVE_ROW.value.format(
+                register=self.table_locator.register,
+                table_name=self.table_locator.name,
+                from_row=from_row,
+                to_row=to_row,
+            )
+        )

pychemstation/utils/macro.py

@@ -55,12 +55,15 @@ class Command(Enum):
     # Get directories
     GET_METHOD_DIR = "response$ = _METHPATH$"
     GET_SEQUENCE_DIR = "response$ = _SEQUENCEPATHS$"
+    CONFIG_MET_PATH = "_CONFIGMETPATH"
+    CONFIG_SEQ_PATH = "_CONFIGSEQPATH"
+    GET_RUNNING_SEQUENCE_DIR = "response$ = _SEQPATHS$"
     GET_DATA_DIRS = "response$ = _DATAPATHS$"
     GET_CURRENT_RUN_DATA_DIR = "response$ = _DATAPath$"
     GET_CURRENT_RUN_DATA_FILE = "response$ = _DATAFILE1$"
 
-    # Debuggng
-    ERROR = "response$ = _ERROR$"
+    # Errors
+    ERROR = "response$ = _ERRMSG$"
 
 
 class HPLCRunningStatus(Enum):

pychemstation/utils/method_types.py

@@ -33,7 +33,7 @@ class TimeTableEntry:
     """Row in a method timetable."""
 
     start_time: float
-    organic_modifer: Optional[float]
+    organic_modifer: Optional[float] = None
     flow: Optional[float] = None
 
 

pychemstation/utils/mocking/mock_comm.py

@@ -1,5 +1,28 @@
-from ...control.controllers.abc_tables.abc_comm import ABCCommunicationController
+from typing import Union
+
+from result import Result
+
+from .mock_hplc import MockHPLC
+from ..abc_tables.abc_comm import ABCCommunicationController
+from ..macro import Status
 
 
 class MockCommunicationController(ABCCommunicationController):
-    pass
+    def __init__(self, comm_dir: str):
+        super().__init__(comm_dir)
+        self.hplc = MockHPLC()
+
+    def get_num_val(self, cmd: str) -> Union[int, float]:
+        raise NotImplementedError
+
+    def get_text_val(self, cmd: str) -> str:
+        raise NotImplementedError
+
+    def get_status(self) -> Status:
+        raise NotImplementedError
+
+    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
+        raise NotImplementedError
+
+    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
+        raise NotImplementedError

pychemstation/utils/mocking/mock_hplc.py

@@ -1,2 +1,30 @@
+from ..macro import HPLCAvailStatus, Status
+from ..method_types import MethodDetails, HPLCMethodParams, TimeTableEntry
+from ..sequence_types import SequenceTable, SequenceEntry, InjectionSource
+from ..tray_types import FiftyFourVialPlate
+
+
 class MockHPLC:
-    pass
+    def __init__(self):
+        self.current_method: MethodDetails = MethodDetails(
+            name="General-Poroshell",
+            params=HPLCMethodParams(organic_modifier=5, flow=0.65),
+            timetable=[TimeTableEntry(start_time=3, organic_modifer=99, flow=0.65)],
+            stop_time=5,
+            post_time=2,
+        )
+        self.current_sequence: SequenceTable = SequenceTable(
+            name="hplc_testing",
+            rows=[
+                SequenceEntry(
+                    vial_location=FiftyFourVialPlate.from_str("P1-A2"),
+                    sample_name="sample1",
+                    data_file="sample1",
+                    method="General-Poroshell",
+                    num_inj=1,
+                    inj_vol=1,
+                    inj_source=InjectionSource.HIP_ALS,
+                )
+            ],
+        )
+        self.current_status: Status = HPLCAvailStatus.STANDBY

pychemstation/utils/table_types.py

@@ -16,6 +16,8 @@ class TableOperation(Enum):
     DELETE_TABLE = 'DelTab {register}, "{table_name}"'
     CREATE_TABLE = 'NewTab {register}, "{table_name}"'
     NEW_ROW = 'InsTabRow {register}, "{table_name}"'
+    NEW_ROW_SPECIFIC = 'InsTabRow {register}, "{table_name}"'
+    MOVE_ROW = 'MoveTabRow {register}, "{table_name}", {from_row}, {to_row}'
     DELETE_ROW = 'DelTabRow {register}, "{table_name}", {row}'
     EDIT_ROW_VAL = 'SetTabVal "{register}", "{table_name}", {row}, "{col_name}", {val}'
     EDIT_ROW_TEXT = (

{pychemstation-0.10.8.dev1.dist-info → pychemstation-0.10.8.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.8.dev1
+Version: 0.10.8.dev3
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Project-URL: Documentation, https://pychemstation-e5a086.gitlab.io/pychemstation.html
 Project-URL: Repository, https://gitlab.com/heingroup/device-api/pychemstation

{pychemstation-0.10.8.dev1.dist-info → pychemstation-0.10.8.dev3.dist-info}/RECORD

@@ -5,13 +5,13 @@ pychemstation/analysis/chromatogram.py,sha256=Jk6xOMHA6kSV597fJDZgrFRlvVorldvK4z
 pychemstation/analysis/process_report.py,sha256=aTsW6u5-0iwsH3jQtkoKE9jbsy5NAUG6l7O-I49B8kY,14650
 pychemstation/control/README.md,sha256=ohPn3xhgjFyPraQqR4x9aZhurQVAOYuYHv-E8sj0eK4,3124
 pychemstation/control/__init__.py,sha256=7lSkY7Qa7Ikdz82-2FESc_oqktv7JndsjltCkiMqnMI,147
-pychemstation/control/hplc.py,sha256=Evmo_D6X2RDmPBFmo3vsKE9kxJzy36Ptz4MyF2IKNzA,13146
+pychemstation/control/hplc.py,sha256=JrfkQ5Jt9K9kf5l2X5wQzuYaQvPEnDa_aAkCVeMBk0o,14244
 pychemstation/control/controllers/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
 pychemstation/control/controllers/__init__.py,sha256=q2TUEie3J-OLlxcGLkG7vIy8fazCEhHm61OGzJPbhD0,179
 pychemstation/control/controllers/comm.py,sha256=ySjgMBIfJ11sygXiZSPp9Rf6ABM4t6JhZRONRj1u2Cc,6652
 pychemstation/control/controllers/data_aq/__init__.py,sha256=w-Zgbit10niOQfz780ZmRHjUFxV1hMkdui7fOMPqeLA,132
-pychemstation/control/controllers/data_aq/method.py,sha256=hfLU5bnlmqKc1DPnK-HNpe-S2DollXyNx89hiLwhKWI,18251
-pychemstation/control/controllers/data_aq/sequence.py,sha256=zhilGZXUEttqrux8OI2ieAWktINsrD98fm_b6guZKlo,17209
+pychemstation/control/controllers/data_aq/method.py,sha256=KFKL8yt3lHxpgND52z4gN6TeMvnNaAOVetpO2su1GlU,24935
+pychemstation/control/controllers/data_aq/sequence.py,sha256=CgNPc-IaPXCHkkWjhb2UrxhDmAltUz7rPCiZa4O6ATw,20967
 pychemstation/control/controllers/devices/__init__.py,sha256=QpgGnLXyWiB96KIB98wMccEi8oOUUaLxvBCyevJzcOg,75
 pychemstation/control/controllers/devices/injector.py,sha256=LyubM-fqf5ruseGx32deTDK-yevmaTOvdo6YKg2PF7I,4029
 pychemstation/generated/__init__.py,sha256=xnEs0QTjeuGYO3tVUIy8GDo95GqTV1peEjosGckpOu0,977
@@ -19,23 +19,23 @@ pychemstation/generated/dad_method.py,sha256=xTUiSCvkXcxBUhjVm1YZKu-tHs16k23pF-0
 pychemstation/generated/pump_method.py,sha256=s3MckKDw2-nZUC5lHrJVvXYdneWP8-9UvblNuGryPHY,12092
 pychemstation/utils/__init__.py,sha256=GZJyDzkhzrlMguxZTUpgthq72pA3YV23DJIR2Q63PCk,449
 pychemstation/utils/injector_types.py,sha256=z2iWwTklGm0GRDCL9pnPCovQrwyRwxv8w5w5Xh7Pj3U,1152
-pychemstation/utils/macro.py,sha256=n2CcvB7MY4fl8Ds909K41aqqH7_6DlKK5R4aemLhOdM,3300
-pychemstation/utils/method_types.py,sha256=pXfZWmIPnZu3kIdGPxSPJMhL4WSt-u00If1JDUaLaMQ,1555
+pychemstation/utils/macro.py,sha256=VGOU380ruJSKQhXJFI1g--qg4Xgx-e0D8z5FDPGe0cA,3433
+pychemstation/utils/method_types.py,sha256=ck8I4dRGhHXCUfBf3AT1OU1eCcSSZPgnlhvlLTfezEM,1562
 pychemstation/utils/num_utils.py,sha256=OpqZwMPoxTYkpjpinA1CcoQAXDY_0sie6d-hTU547uo,2087
 pychemstation/utils/parsing.py,sha256=mzdpxrH5ux4-_i4CwZvnIYnIwAnRnOptKb3fZyYJcx0,9307
 pychemstation/utils/sequence_types.py,sha256=JLGL7kCkPouHN7iBsnZfWe-nSjzF8XqFKzBPyF4SulE,2724
 pychemstation/utils/spec_utils.py,sha256=BtXgQndZy4kVKsrgEDxwNd0HctypnAt5upB9SOk1D9w,9700
-pychemstation/utils/table_types.py,sha256=obQrnwDNmy-7r1IDD3N6wY7gUPKfpcM6D9Ow0IN-T48,3609
+pychemstation/utils/table_types.py,sha256=ZmV52Vl1cYG_C1PEmVGB02mC3Dhfi7QMkUZwe0ujzAg,3748
 pychemstation/utils/tray_types.py,sha256=UeHM0hUYaNc9giT96ZiGpyWBPQwG-SyLA0rVGzDDAJk,6618
 pychemstation/utils/abc_tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/utils/abc_tables/abc_comm.py,sha256=rTrnfyTdqRSiBfBW1_460KsHER5vpfhv7JYwObBgBZc,5501
+pychemstation/utils/abc_tables/abc_comm.py,sha256=gLvCiD8hDHXlMsiUzZX__g2kgFCeNnUIK7_nsLwI7Hc,5465
 pychemstation/utils/abc_tables/device.py,sha256=v8MNFvymbKe4hWsqzO6Z_qsVvju_rISYtnPgaftecyE,919
-pychemstation/utils/abc_tables/run.py,sha256=FPwGuWIS4BLTS-aZqBLWoHvgev4qsAnUdPVjVPnFWVU,9842
-pychemstation/utils/abc_tables/table.py,sha256=4mfmegCdMppxgpxVDt7oULoxTBVia8_JTxYPjlWq8VE,7743
+pychemstation/utils/abc_tables/run.py,sha256=Sr6Iz_YrwJ78HTNHFv6fTA-Kca8gP3Dic_-7-AriyOw,10140
+pychemstation/utils/abc_tables/table.py,sha256=AbuitDcBHODV-KpxjL7ZPoE-TSa6gyG2uqXXY90Mv2o,7992
 pychemstation/utils/mocking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/utils/mocking/mock_comm.py,sha256=4DcKmUxp-LYNXjywT_za1_GpqKa4sFTj7F2V3r_qsA0,156
-pychemstation/utils/mocking/mock_hplc.py,sha256=Hx6127C7d3miYGCZYxbN-Q3PU8kpMgXYX2n6we2Twgw,25
-pychemstation-0.10.8.dev1.dist-info/METADATA,sha256=kACFfqsEpvT70MVDKx6KYzmgSjmPXe6pDcwhoj82ZIQ,5757
-pychemstation-0.10.8.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pychemstation-0.10.8.dev1.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.10.8.dev1.dist-info/RECORD,,
+pychemstation/utils/mocking/mock_comm.py,sha256=vZeYBXaKBZOlJmhn4TSbkov62gqlkfztqf3MSFU9kLE,800
+pychemstation/utils/mocking/mock_hplc.py,sha256=esVIlU4oqEsYLPOQs0AeVnKv9l52xBGT6UY862l9RQE,1163
+pychemstation-0.10.8.dev3.dist-info/METADATA,sha256=v0QV6RM1Zumdp8W0qD8rNuy-O-b_Uov8uFcDBsA1FK4,5757
+pychemstation-0.10.8.dev3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pychemstation-0.10.8.dev3.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.10.8.dev3.dist-info/RECORD,,