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

pychemstation/analysis/process_report.py

@@ -83,7 +83,9 @@ class CSVProcessor(ReportProcessor):
                 if "00" in name and file_extension.lower() == "csv":
                     prefix, _, _ = name.partition("00")
                     return prefix
-        raise FileNotFoundError("Couldn't find the prefix for CSV")
+        raise FileNotFoundError(
+            "Couldn't find the prefix for CSV, please make sure the post-run settings generate a CSV."
+        )
 
     def report_contains(self, labels: List[str], want: List[str]):
         for label in labels:

pychemstation/control/controllers/comm.py

@@ -173,5 +173,5 @@ class CommunicationController(ABCCommunicationController):
                         data_dirs[i] = "C:" + data_dir
                 return method_dir, sequence_dir, data_dirs
         raise ValueError(
-                f"One of the method: {method_dir}, sequence: {sequence_dir} or data directories: {data_dirs} could not be found, please provide your own."
-            )
+            f"One of the method: {method_dir}, sequence: {sequence_dir} or data directories: {data_dirs} could not be found, please provide your own."
+        )

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, 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
 
 
@@ -50,9 +51,7 @@ class MethodController(RunController):
         )
 
     def get_current_method_name(self) -> str:
-        time.sleep(2)
-        self.send(Command.GET_METHOD_CMD)
-        time.sleep(2)
+        self.sleepy_send(Command.GET_METHOD_CMD)
         res = self.receive()
         if res.is_ok():
             return res.ok_value.string_response
@@ -77,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)]
@@ -195,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)
@@ -219,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:
@@ -229,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,
@@ -236,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,
@@ -255,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,
@@ -266,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],
@@ -326,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()
@@ -389,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,11 +573,11 @@ class MethodController(RunController):
             else:
                 warnings.warn(run_completed.err_value)
         else:
-            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], None)
-                i+=1
+                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:
@@ -453,11 +585,11 @@ class MethodController(RunController):
                 warnings.warn(warning)
 
     def _fuzzy_match_most_recent_folder(
-        self, most_recent_folder: T, child_dirs: Optional[Set[str]]
+        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)

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, 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()
 
@@ -255,11 +301,6 @@ class SequenceController(RunController):
         under the <data_dir>/<sequence table name> folder.
         Device must be ready.
         """
-        if self.controller:
-            self.controller.send(Command.SAVE_METHOD_CMD)
-            self.controller.send(Command.SAVE_SEQUENCE_CMD)
-        else:
-            raise ValueError("Controller is offline!")
 
         current_sequence_name = self.get_current_sequence_name()
         if not self.table_state or self.table_state.name not in current_sequence_name:
@@ -284,6 +325,11 @@ 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.SAVE_METHOD_CMD)
+        self.send(Command.SAVE_SEQUENCE_CMD)
         self.send(Command.RUN_SEQUENCE_CMD.value)
         self.timeout = total_runtime * 60
 
@@ -295,20 +341,11 @@ 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
+            full_path_name, current_sample_file = self.try_getting_run_info(folder_name)
             if full_path_name and current_sample_file:
                 data_file = SequenceDataFiles(
                     sequence_name=self.table_state.name,
                     dir=full_path_name,
-                    _data_files=[r.data_file for r in self.table_state.rows],
                     child_dirs=[os.path.join(full_path_name, current_sample_file)],
                 )
                 self.data_files.append(data_file)
@@ -324,38 +361,34 @@ 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 current_sample_file and full_path_name:
+                return full_path_name, current_sample_file
+            elif full_path_name:
+                return full_path_name, None
+        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]]
+        self, most_recent_folder: T
     ) -> Result[SequenceDataFiles, str]:
         if isinstance(most_recent_folder, SequenceDataFiles):
             try:
                 if most_recent_folder.dir and os.path.isdir(most_recent_folder.dir):
                     subdirs = [x[0] for x in os.walk(most_recent_folder.dir)]
-                    if (
-                        child_dirs
-                        and len(child_dirs) > 0
-                        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
-                        ]
-                    else:
-                        potential_folders: List[str] = sorted(
-                            list(
-                                filter(
-                                    lambda d: most_recent_folder.dir in d,
-                                    subdirs,
-                                )
-                            )
-                        )
-                        most_recent_folder.child_dirs = [
-                            f
-                            for f in potential_folders
-                            if most_recent_folder.dir in f
-                            and ".M" not in f
-                            and ".D" in f
-                        ]
+                    most_recent_folder.child_dirs = [
+                        f
+                        for f in subdirs
+                        if most_recent_folder.dir in f and ".D" in f and f[-1] == "D"
+                    ]
                     return Ok(most_recent_folder)
                 else:
                     return Err("No sequence folder found, please give the full path.")
@@ -370,14 +403,11 @@ class SequenceController(RunController):
             if custom_path
             else self.data_files[-1]
         )
-        if len(seq_data_dir.child_dirs) == 0:
-            search_folder = self._fuzzy_match_most_recent_folder(
-                seq_data_dir, set(seq_data_dir.child_dirs)
-            )
-            if search_folder.is_ok():
-                seq_data_dir = search_folder.ok_value
-            else:
-                raise FileNotFoundError(search_folder.err_value)
+        search_folder = self._fuzzy_match_most_recent_folder(seq_data_dir)
+        if search_folder.is_ok():
+            seq_data_dir = search_folder.ok_value
+        else:
+            raise FileNotFoundError(search_folder.err_value)
         all_w_spectra: List[Dict[int, AgilentHPLCChromatogram]] = []
         for row in seq_data_dir.child_dirs:
             all_w_spectra.append(self.get_data_uv(custom_path=row))
@@ -401,10 +431,9 @@ class SequenceController(RunController):
             if custom_path
             else self.data_files[-1]
         )
-        if len(seq_file_dir.child_dirs) == 0:
-            self.data_files[-1] = self._fuzzy_match_most_recent_folder(
-                seq_file_dir, set(seq_file_dir.child_dirs)
-            ).ok_value
+        self.data_files[-1] = self._fuzzy_match_most_recent_folder(
+            seq_file_dir
+        ).ok_value
         spectra: List[AgilentChannelChromatogramData] = []
         for row in self.data_files[-1].child_dirs:
             self.get_spectrum_at_channels(row)
@@ -423,10 +452,13 @@ class SequenceController(RunController):
                         dir=custom_path,
                         sequence_name="NA",
                     ),
-                    child_dirs=None,
                 ).ok_value
             )
         parent_dir = self.data_files[-1]
+        parent_dir = self._fuzzy_match_most_recent_folder(
+            most_recent_folder=parent_dir,
+        ).ok_value
+        assert len(parent_dir.child_dirs) != 0
         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,19 @@ 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],
+            )
+            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]:
@@ -89,15 +88,19 @@ class ABCCommunicationController(abc.ABC):
         :return: whether the HPLC machine is in a safe state to retrieve data back."""
         self.set_status()
         hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        time.sleep(5)
+        time.sleep(10)
         self.set_status()
         hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        return hplc_avail and hplc_actually_avail
+        time.sleep(10)
+        self.set_status()
+        hplc_final_check_avail = isinstance(
+            self._most_recent_hplc_status, HPLCAvailStatus
+        )
+        return hplc_avail and hplc_actually_avail and hplc_final_check_avail
 
     def sleepy_send(self, cmd: Union[Command, str]):
         self.send("Sleep 0.1")
         self.send(cmd)
-        self.send("Sleep 0.1")
 
     def send(self, cmd: Union[Command, str]):
         """Sends a command to Chemstation.

pychemstation/utils/abc_tables/run.py

@@ -94,9 +94,7 @@ class RunController(ABCTableController, abc.ABC):
         return object.__new__(cls)
 
     @abc.abstractmethod
-    def _fuzzy_match_most_recent_folder(
-        self, most_recent_folder: T, child_dirs: Set[str]
-    ) -> Result[T, str]:
+    def _fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         pass
 
     @abc.abstractmethod
@@ -192,9 +190,7 @@ class RunController(ABCTableController, abc.ABC):
         else:
             raise ValueError("Timeout value is None, no comparison can be made.")
 
-        check_folder = self._fuzzy_match_most_recent_folder(
-            self.data_files[-1], self.current_run_child_files
-        )
+        check_folder = self._fuzzy_match_most_recent_folder(self.data_files[-1])
         if check_folder.is_ok() and finished_run:
             return check_folder
         elif check_folder.is_ok():
@@ -255,9 +251,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/sequence_types.py

@@ -13,13 +13,11 @@ class SequenceDataFiles:
 
     :param sequence_name: the name of the sequence that is running
     :param dir: the complete path of the directory generated for the sequence
-    :param _data_files: the names of the files of the sequence runs, ends with ".D"
     :param child_dirs: the complete path of the files for sequence runs, contains the Chemstation data, `dir` and the sample run file.
     """
 
     sequence_name: str
     dir: str
-    _data_files: List[str] = field(default_factory=list)
     child_dirs: List[str] = field(default_factory=list)
 
 
@@ -78,10 +76,11 @@ class SequenceTable:
         for self_row, other_row in zip(self.rows, other.rows):
             equal &= self_row.vial_location == other_row.vial_location
             equal &= self_row.data_file == other_row.data_file
-            equal &= (
-                os.path.split(os.path.normpath(self_row.method))[-1]
-                == os.path.split(os.path.normpath(other_row.method))[-1]
-            )
+            if self_row.method and other_row.method:
+                equal &= (
+                    os.path.split(os.path.normpath(self_row.method))[-1]
+                    == os.path.split(os.path.normpath(other_row.method))[-1]
+                )
             equal &= self_row.num_inj == other_row.num_inj
             equal &= self_row.inj_vol == other_row.inj_vol
             equal &= self_row.inj_source == other_row.inj_source

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.7.dev1.dist-info → pychemstation-0.10.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.7.dev1
+Version: 0.10.8
 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.7.dev1.dist-info → pychemstation-0.10.8.dist-info}/RECORD

@@ -2,16 +2,16 @@ pychemstation/__init__.py,sha256=Sc4z8LRVFMwJUoc_DPVUriSXTZ6PO9MaJ80PhRbKyB8,34
 pychemstation/analysis/__init__.py,sha256=mPNnp0TmkoUxrTGcT6wNKMyCiOar5vC0cTPmFLrDU1Q,313
 pychemstation/analysis/base_spectrum.py,sha256=HjbTPoueR7XB1_puCcmx7zbQmeT5SH6_HVwHrYhNXhA,16537
 pychemstation/analysis/chromatogram.py,sha256=Jk6xOMHA6kSV597fJDZgrFRlvVorldvK4zerPASZrug,3969
-pychemstation/analysis/process_report.py,sha256=aTsW6u5-0iwsH3jQtkoKE9jbsy5NAUG6l7O-I49B8kY,14650
+pychemstation/analysis/process_report.py,sha256=GEazFm1asY1FZO87siiV9kWu2Wnbu7xwx86nlPeRexk,14728
 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=Nw5rJAOsmW1W6faq4jRuMJlEoGda91kD9GqkRX2jcgk,14210
 pychemstation/control/controllers/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
 pychemstation/control/controllers/__init__.py,sha256=q2TUEie3J-OLlxcGLkG7vIy8fazCEhHm61OGzJPbhD0,179
-pychemstation/control/controllers/comm.py,sha256=jdKl9Islwk5tq2h1esm_-8gR4r4xZre0Ma5fMBqRzW4,6660
+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=oxRT3kSjyrDzpS01HgtT9IvGkhq_wHQ_6_63maNhVio,18249
-pychemstation/control/controllers/data_aq/sequence.py,sha256=zhilGZXUEttqrux8OI2ieAWktINsrD98fm_b6guZKlo,17209
+pychemstation/control/controllers/data_aq/method.py,sha256=8ONU_FN9sLFAv7r_rO8gN3hL3HJoMaYMOItlKCVAIsk,24773
+pychemstation/control/controllers/data_aq/sequence.py,sha256=5JpXDWpS3JR2Cawn9RdUwOIYSipQPeB3OR7KW6muO6U,18623
 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=XBK9FCWgTstmquSL69sQHk4oKb5dimmB-RWvwxU3RV4,2655
+pychemstation/utils/sequence_types.py,sha256=H9htO2thyU9_KYOFBsGjlmA-4Nyd6aLd4D0MDLaXNCQ,2583
 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=svCQZelFcqfNZY_0hHOL8frVtw_06_PasGoQTNFWQ7g,5625
 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=uURDl66Mga8NAMffOUsG6prKhjpLo1-p2Y2PUTY1hY0,10052
+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.7.dev1.dist-info/METADATA,sha256=4q5zU2Ys8DnagN8Jqi-AFj8Updt1JxCDGAr-g3L9peQ,5757
-pychemstation-0.10.7.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pychemstation-0.10.7.dev1.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.10.7.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.dist-info/METADATA,sha256=MOopar8CgFbFX1BBqJAJmjB5Nao_0jO27TY9Y_pMEYc,5752
+pychemstation-0.10.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pychemstation-0.10.8.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.10.8.dist-info/RECORD,,