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

pychemstation/control/controllers/data_aq/sequence.py

@@ -1,19 +1,19 @@
 import os
 import time
 import warnings
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, Set
 
 from result import Err, Ok, Result
 from typing_extensions import override
 
 from pychemstation.analysis.chromatogram import (
-    SEQUENCE_TIME_FORMAT,
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
 
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers.comm import CommunicationController
+from ....utils.abc_tables.run import RunController
 from ....utils.macro import Command
 from ....utils.sequence_types import (
     InjectionSource,
@@ -23,8 +23,7 @@ from ....utils.sequence_types import (
     SequenceTable,
 )
 from ....utils.table_types import RegisterFlag, T, Table
-from ....utils.tray_types import FiftyFourVialPlate, TenVialColumn, Tray
-from ..abc_tables.run import RunController
+from ....utils.tray_types import FiftyFourVialPlate, VialBar, Tray
 from . import MethodController
 
 
@@ -37,8 +36,8 @@ class SequenceController(RunController):
         self,
         controller: Optional[CommunicationController],
         method_controller: MethodController,
-        src: str,
-        data_dirs: List[str],
+        src: Optional[str],
+        data_dirs: Optional[List[str]],
         table: Table,
         offline: bool,
     ):
@@ -81,17 +80,14 @@ class SequenceController(RunController):
 
     def try_vial_location(self, val: Any) -> Tray:
         try:
-            return (
-                TenVialColumn(val)
-                if val <= 10
-                else FiftyFourVialPlate.from_int(num=val)
-            )
+            return VialBar(val) if val <= 10 else FiftyFourVialPlate.from_int(num=val)
         except ValueError:
             raise ValueError("Expected vial location, is empty.")
 
     def get_row(self, row: int) -> SequenceEntry:
         sample_name = self.get_text(row, RegisterFlag.NAME)
         vial_location = self.try_int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
+        data_file = self.get_text(row, RegisterFlag.DATA_FILE)
         method = self.get_text(row, RegisterFlag.METHOD)
         num_inj = self.try_int(self.get_num(row, RegisterFlag.NUM_INJ))
         inj_vol = self.try_float(self.get_text(row, RegisterFlag.INJ_VOL))
@@ -106,17 +102,9 @@ class SequenceController(RunController):
             inj_vol=inj_vol,
             inj_source=inj_source,
             sample_type=sample_type,
+            data_file=data_file,
         )
 
-    def check(self) -> str:
-        time.sleep(2)
-        self.send(Command.GET_SEQUENCE_CMD)
-        time.sleep(2)
-        res = self.receive()
-        if res.is_ok():
-            return res.ok_value.string_response
-        return "ERROR"
-
     def switch(self, seq_name: str):
         """
         Switch to the specified sequence. The sequence name does not need the '.S' extension.
@@ -127,13 +115,17 @@ class SequenceController(RunController):
         self.send(f'_SeqPath$ = "{self.src}"')
         self.send(Command.SWITCH_SEQUENCE_CMD)
         time.sleep(2)
-        self.send(Command.GET_SEQUENCE_CMD)
-        time.sleep(2)
-        parsed_response = self.receive().ok_value.string_response
+        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)
+        time.sleep(2)
+        parsed_response = self.receive().ok_value.string_response
+        return parsed_response
+
     def edit(self, sequence_table: SequenceTable):
         """
         Updates the currently loaded sequence table with the provided table. This method will delete the existing sequence table and remake it.
@@ -151,13 +143,13 @@ class SequenceController(RunController):
                 self.send(Command.SAVE_SEQUENCE_CMD)
             for i in range(int(wanted_row_num)):
                 self.add_row()
-                self.send(Command.SAVE_SEQUENCE_CMD)
+                self.save()
             self.send(Command.SWITCH_SEQUENCE_CMD)
 
             for i, row in enumerate(sequence_table.rows):
                 self._edit_row(row=row, row_num=i + 1)
                 self.sleep(1)
-            self.send(Command.SAVE_SEQUENCE_CMD)
+            self.save()
             self.send(Command.SWITCH_SEQUENCE_CMD)
 
     def _edit_row(self, row: SequenceEntry, row_num: int):
@@ -171,70 +163,91 @@ class SequenceController(RunController):
         if num_rows.is_ok():
             while num_rows.ok_value.num_response < row_num:
                 self.add_row()
-                self.send(Command.SAVE_SEQUENCE_CMD)
+                self.save()
                 num_rows = self.get_num_rows()
         if row.vial_location:
-            self.edit_vial_location(row.vial_location, row_num)
+            self.edit_vial_location(row.vial_location, row_num, save=False)
         if row.method:
-            self.edit_method_name(row.method, row_num)
+            self.edit_method_name(row.method, row_num, save=False)
         if row.num_inj:
-            self.edit_num_injections(row.num_inj, row_num)
+            self.edit_num_injections(row.num_inj, row_num, save=False)
         if row.inj_vol:
-            self.edit_injection_volume(row.inj_vol, row_num)
+            self.edit_injection_volume(row.inj_vol, row_num, save=False)
         if row.inj_source:
-            self.edit_injection_source(row.inj_source, row_num)
+            self.edit_injection_source(row.inj_source, row_num, save=False)
         if row.sample_name:
-            self.edit_sample_name(row.sample_name, row_num)
+            self.edit_sample_name(row.sample_name, row_num, save=False)
         if row.data_file:
-            self.edit_data_file(row.data_file, row_num)
-        elif row.sample_name and not row.data_file:
-            self.edit_data_file(row.sample_name, row_num)
+            self.edit_data_file(row.data_file, row_num, save=False)
         if row.sample_type:
-            self.edit_sample_type(row.sample_type, row_num)
-        self.send(Command.SAVE_SEQUENCE_CMD)
+            self.edit_sample_type(row.sample_type, row_num, save=False)
+        self.save()
 
-    def edit_sample_type(self, sample_type: SampleType, row_num: int):
+    def edit_sample_type(
+        self, sample_type: SampleType, row_num: int, save: bool = True
+    ):
         self._edit_row_num(
             row=row_num,
             col_name=RegisterFlag.SAMPLE_TYPE,
             val=sample_type.value,
         )
+        if save:
+            self.save()
 
-    def edit_data_file(self, data_file: str, row_num: int):
+    def edit_data_file(self, data_file: str, row_num: int, save: bool = True):
         self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=data_file)
+        if save:
+            self.save()
 
-    def edit_sample_name(self, sample_name: str, row_num: int):
+    def edit_sample_name(self, sample_name: str, row_num: int, save: bool = True):
         self._edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=sample_name)
+        if save:
+            self.save()
 
-    def edit_injection_source(self, inj_source: InjectionSource, row_num: int):
+    def edit_injection_source(
+        self, inj_source: InjectionSource, row_num: int, save: bool = True
+    ):
         self._edit_row_text(
             row=row_num, col_name=RegisterFlag.INJ_SOR, val=inj_source.value
         )
+        if save:
+            self.save()
 
-    def edit_injection_volume(self, inj_vol: Union[int, float], row_num: int):
+    def edit_injection_volume(
+        self, inj_vol: Union[int, float], row_num: int, save: bool = True
+    ):
         self._edit_row_text(
             row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(inj_vol)
         )
+        if save:
+            self.save()
 
-    def edit_num_injections(self, num_inj: int, row_num: int):
+    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)
 
-    def edit_method_name(self, method: str, row_num: int):
+    def edit_method_name(self, method: str, row_num: int, save: bool = True):
         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)
         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):
+    def edit_vial_location(self, loc: Tray, row_num: int, save: bool = True):
         loc_num = -1
-        if isinstance(loc, TenVialColumn):
+        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()
+
+    def save(self):
+        self.send(Command.SAVE_SEQUENCE_CMD)
 
     def run(self, stall_while_running: bool = True):
         """
@@ -248,7 +261,8 @@ class SequenceController(RunController):
         else:
             raise ValueError("Controller is offline!")
 
-        if not self.table_state:
+        current_sequence_name = self.get_current_sequence_name()
+        if not self.table_state or self.table_state.name not in current_sequence_name:
             self.table_state = self.load()
 
         total_runtime = 0.0
@@ -270,7 +284,6 @@ class SequenceController(RunController):
                     curr_method_runtime = self.method_controller.get_total_runtime()
             total_runtime += curr_method_runtime
 
-        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
         self.send(Command.RUN_SEQUENCE_CMD.value)
         self.timeout = total_runtime * 60
 
@@ -282,71 +295,70 @@ class SequenceController(RunController):
                 break
 
         if hplc_running:
-            folder_name = f"{self.table_state.name} {timestamp}"
-            data_file = SequenceDataFiles(
-                dir=folder_name, sequence_name=self.table_state.name
-            )
-            self.data_files.append(data_file)
+            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
+            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)
+            else:
+                raise ValueError("Data directory for sequence was not found.")
 
             if stall_while_running:
                 run_completed = self.check_hplc_done_running()
                 if run_completed.is_ok():
                     self.data_files[-1] = run_completed.ok_value
                 else:
-                    warnings.warn("Run may have not completed.")
+                    warnings.warn(run_completed.err_value)
         else:
             raise RuntimeError("Sequence run may not have started.")
 
     @override
-    def fuzzy_match_most_recent_folder(
-        self, most_recent_folder: T
+    def _fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_dirs: Optional[Set[str]]
     ) -> Result[SequenceDataFiles, str]:
         if isinstance(most_recent_folder, SequenceDataFiles):
-            if os.path.isdir(most_recent_folder.dir):
-                subdirs = [x[0] for x in os.walk(most_recent_folder.dir)]
-                potential_folders = 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
-                ]
-                return Ok(most_recent_folder)
-
             try:
-                potential_folders = []
-                for d in self.data_dirs:
-                    subdirs = [x[0] for x in os.walk(d)]
-                    potential_folders = sorted(
-                        list(filter(lambda d: most_recent_folder.dir in d, subdirs))
-                    )
-                    if len(potential_folders) > 0:
-                        break
-                assert len(potential_folders) > 0
-                parent_dirs = []
-                for folder in potential_folders:
-                    path = os.path.normpath(folder)
-                    split_folder = path.split(os.sep)
-                    if most_recent_folder.dir in split_folder[-1]:
-                        parent_dirs.append(folder)
-                parent_dir = sorted(parent_dirs, reverse=True)[0]
-
-                potential_folders = []
-                for d in self.data_dirs:
-                    subdirs = [x[0] for x in os.walk(d)]
-                    potential_folders = sorted(
-                        list(filter(lambda d: parent_dir in d, subdirs))
-                    )
-                    if len(potential_folders) > 0:
-                        break
-                assert len(potential_folders) > 0
-                most_recent_folder.child_dirs = [
-                    f
-                    for f in potential_folders
-                    if parent_dir in f and ".M" not in f and ".D" in f
-                ]
-                return Ok(most_recent_folder)
+                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
+                        ]
+                    return Ok(most_recent_folder)
+                else:
+                    return Err("No sequence folder found, please give the full path.")
             except Exception as e:
                 error = f"Failed to get sequence folder: {e}"
                 return Err(error)
@@ -354,16 +366,20 @@ class SequenceController(RunController):
 
     def get_data_mult_uv(self, custom_path: Optional[str] = None):
         seq_data_dir = (
-            SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="")
+            SequenceDataFiles(dir=custom_path, sequence_name="")
             if custom_path
             else self.data_files[-1]
         )
         if len(seq_data_dir.child_dirs) == 0:
-            self.data_files[-1] = self.fuzzy_match_most_recent_folder(
-                seq_data_dir
-            ).ok_value
+            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)
         all_w_spectra: List[Dict[int, AgilentHPLCChromatogram]] = []
-        for row in self.data_files[-1].child_dirs:
+        for row in seq_data_dir.child_dirs:
             all_w_spectra.append(self.get_data_uv(custom_path=row))
         return all_w_spectra
 
@@ -381,13 +397,13 @@ class SequenceController(RunController):
         self, custom_path: Optional[str] = None
     ) -> List[AgilentChannelChromatogramData]:
         seq_file_dir = (
-            SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="")
+            SequenceDataFiles(dir=custom_path, sequence_name="")
             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
+            self.data_files[-1] = self._fuzzy_match_most_recent_folder(
+                seq_file_dir, set(seq_file_dir.child_dirs)
             ).ok_value
         spectra: List[AgilentChannelChromatogramData] = []
         for row in self.data_files[-1].child_dirs:
@@ -402,10 +418,12 @@ class SequenceController(RunController):
     ) -> List[AgilentReport]:
         if custom_path:
             self.data_files.append(
-                self.fuzzy_match_most_recent_folder(
+                self._fuzzy_match_most_recent_folder(
                     most_recent_folder=SequenceDataFiles(
-                        dir=custom_path, child_dirs=[], sequence_name="NA"
-                    )
+                        dir=custom_path,
+                        sequence_name="NA",
+                    ),
+                    child_dirs=None,
                 ).ok_value
             )
         parent_dir = self.data_files[-1]

pychemstation/control/controllers/devices/injector.py

@@ -1,5 +1,7 @@
-from ..abc_tables.device import DeviceController
+from __future__ import annotations
+
 from ....control.controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
 from ....utils.injector_types import (
     Draw,
     Inject,
@@ -15,7 +17,7 @@ from ....utils.injector_types import (
 )
 from ....utils.macro import Response
 from ....utils.table_types import RegisterFlag, Table
-from ....utils.tray_types import Tray, FiftyFourVialPlate, TenVialColumn, LocationPlus
+from ....utils.tray_types import Tray, FiftyFourVialPlate, VialBar, LocationPlus
 
 
 class InjectorController(DeviceController):
@@ -29,7 +31,7 @@ class InjectorController(DeviceController):
             return FiftyFourVialPlate.from_str(val)
         except Exception:
             try:
-                return TenVialColumn(int(val))
+                return VialBar(int(val))
             except Exception:
                 raise ValueError("Location could not be identified.")
 
@@ -90,7 +92,7 @@ class InjectorController(DeviceController):
             )
         raise ValueError("No valid function found.")
 
-    def load(self) -> InjectorTable:
+    def load(self) -> InjectorTable | None:
         rows = self.get_num_rows()
         if rows.is_ok():
             row_response = rows.value
@@ -101,6 +103,4 @@ class InjectorController(DeviceController):
                         for i in range(int(row_response.num_response))
                     ]
                 )
-        elif rows.is_err():
-            return InjectorTable(functions=[])
-        raise ValueError("Unexpected error")
+        raise ValueError("Couldn't read injector table rows.")