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

pychemstation/control/README.md

@@ -10,7 +10,7 @@ DATA_DIR_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
 DATA_DIR_3 = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
 
 # Initialize HPLC Controller
-hplc_controller = HPLCController(data_dirs=[DATA_DIR_2, DATA_DIR_3],
+hplc_controller = HPLCController(extra_data_dirs=[DATA_DIR_2, DATA_DIR_3],
                                  comm_dir=DEFAULT_COMMAND_PATH,
                                  method_dir=DEFAULT_METHOD_DIR,
                                  sequence_dir=SEQUENCE_DIR)

pychemstation/{utils/mocking → control/controllers/abc_tables}/abc_comm.py

@@ -18,12 +18,7 @@ from typing import Union
 
 from result import Err, Ok, Result
 
-from ...utils.macro import (
-    HPLCAvailStatus,
-    Command,
-    Status,
-    Response,
-)
+from ....utils.macro import Status, HPLCAvailStatus, Command, Response
 
 
 class ABCCommunicationController(abc.ABC):

pychemstation/control/controllers/abc_tables/device.py

@@ -13,3 +13,8 @@ class DeviceController(ABCTableController, ABC):
     ):
         super().__init__(controller=controller, table=table)
         self.offline = offline
+
+    def __new__(cls, *args, **kwargs):
+        if cls is ABCTableController:
+            raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls)

pychemstation/control/controllers/abc_tables/run.py

@@ -11,13 +11,17 @@ import math
 import os
 import time
 import warnings
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union, Set
 
 import polling
 import rainbow as rb
-from result import Err, Result, Ok
+from result import Err, Ok, Result
+
+from pychemstation.analysis.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
 
-from .table import ABCTableController
 from ....analysis.process_report import (
     AgilentReport,
     CSVProcessor,
@@ -25,14 +29,11 @@ from ....analysis.process_report import (
     TXTProcessor,
 )
 from ....control.controllers.comm import CommunicationController
-from pychemstation.analysis.chromatogram import (
-    AgilentChannelChromatogramData,
-    AgilentHPLCChromatogram,
-)
-from ....utils.macro import HPLCRunningStatus
+from ....utils.macro import Command, HPLCRunningStatus
 from ....utils.method_types import MethodDetails
 from ....utils.sequence_types import SequenceTable
-from ....utils.table_types import Table, T
+from ....utils.table_types import T, Table
+from .table import ABCTableController
 
 TableType = Union[MethodDetails, SequenceTable]
 
@@ -47,12 +48,10 @@ class RunController(ABCTableController, abc.ABC):
         offline: bool = False,
     ):
         super().__init__(controller=controller, table=table)
-        warnings.warn(
-            "This abstract class is not meant to be initialized. Use MethodController or SequenceController."
-        )
         self.table_state: Optional[TableType] = None
         self.curr_run_starting_time: Optional[float] = None
         self.timeout: Optional[float] = None
+        self.current_run_child_files: Set[str] = set()
 
         if not offline:
             if src and not os.path.isdir(src):
@@ -79,8 +78,15 @@ class RunController(ABCTableController, abc.ABC):
         self.uv: Dict[int, AgilentHPLCChromatogram] = {}
         self.data_files: List = []
 
+    def __new__(cls, *args, **kwargs):
+        if cls is RunController:
+            raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls)
+
     @abc.abstractmethod
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+    def fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_files: Set[str]
+    ) -> Result[T, str]:
         pass
 
     @abc.abstractmethod
@@ -120,6 +126,12 @@ class RunController(ABCTableController, abc.ABC):
 
     def check_hplc_run_finished(self) -> Tuple[float, bool]:
         if self.controller:
+            try:
+                _, current_run_file = self.get_current_run_data_dir_file()
+                sample_file, extension, _ = current_run_file.partition(".D")
+                self.current_run_child_files.add(sample_file)
+            except Exception:
+                pass
             done_running = self.controller.check_if_not_running()
             if self.curr_run_starting_time and self.timeout:
                 time_passed = time.time() - self.curr_run_starting_time
@@ -141,6 +153,7 @@ class RunController(ABCTableController, abc.ABC):
 
         :return: Data file object containing most recent run file information.
         """
+        self.current_run_child_files = set()
         if self.timeout is not None:
             finished_run = False
             minutes = math.ceil(self.timeout / 60)
@@ -170,7 +183,9 @@ 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])
+        check_folder = self.fuzzy_match_most_recent_folder(
+            self.data_files[-1], self.current_run_child_files
+        )
         if check_folder.is_ok() and finished_run:
             return check_folder
         elif check_folder.is_ok():
@@ -226,3 +241,16 @@ class RunController(ABCTableController, abc.ABC):
     def _reset_time(self):
         self.curr_run_starting_time = None
         self.timeout = None
+
+    def get_current_run_data_dir_file(self) -> Tuple[str, str]:
+        self.send(Command.GET_CURRENT_RUN_DATA_DIR)
+        full_path_name = self.receive()
+        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.")

pychemstation/control/controllers/abc_tables/table.py

@@ -7,7 +7,6 @@ Authors: Lucy Hao
 from __future__ import annotations
 
 import abc
-import warnings
 from typing import Optional, Union
 
 from result import Err, Result
@@ -27,13 +26,15 @@ class ABCTableController(abc.ABC):
         controller: Optional[CommunicationController],
         table: Table,
     ):
-        warnings.warn(
-            "This abstract class is not meant to be initialized. Use MethodController or SequenceController."
-        )
         self.controller = controller
         self.table_locator = table
         self.table_state: Optional[TableType] = None
 
+    def __new__(cls, *args, **kwargs):
+        if cls is ABCTableController:
+            raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls, *args, **kwargs)
+
     def receive(self) -> Result[Response, str]:
         if self.controller:
             for _ in range(10):
@@ -93,6 +94,8 @@ class ABCTableController(abc.ABC):
             raise ValueError("Controller is offline")
 
     def add_new_col_num(self, col_name: RegisterFlag, val: Union[int, float]):
+        if not (isinstance(val, int) or isinstance(val, float)):
+            raise ValueError(f"{val} must be an int or float.")
         self.sleepy_send(
             TableOperation.NEW_COL_VAL.value.format(
                 register=self.table_locator.register,
@@ -103,6 +106,8 @@ class ABCTableController(abc.ABC):
         )
 
     def add_new_col_text(self, col_name: RegisterFlag, val: str):
+        if not isinstance(val, str):
+            raise ValueError(f"{val} must be a str.")
         self.sleepy_send(
             TableOperation.NEW_COL_TEXT.value.format(
                 register=self.table_locator.register,
@@ -115,10 +120,12 @@ class ABCTableController(abc.ABC):
     def _edit_row_num(
         self, col_name: RegisterFlag, val: Union[int, float], row: Optional[int] = None
     ):
+        if not (isinstance(val, int) or isinstance(val, float)):
+            raise ValueError(f"{val} must be an int or float.")
         if row:
             num_rows = self.get_num_rows()
             if num_rows.is_ok():
-                if num_rows.value.num_response < row:
+                if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
 
         self.sleepy_send(
@@ -134,10 +141,12 @@ class ABCTableController(abc.ABC):
     def _edit_row_text(
         self, col_name: RegisterFlag, val: str, row: Optional[int] = None
     ):
+        if not isinstance(val, str):
+            raise ValueError(f"{val} must be a str.")
         if row:
             num_rows = self.get_num_rows()
             if num_rows.is_ok():
-                if num_rows.value.num_response < row:
+                if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
 
         self.sleepy_send(

pychemstation/control/controllers/comm.py

@@ -11,17 +11,17 @@ Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
 
 import time
-from typing import Optional, Union
+from typing import Optional, Union, Tuple, List
 
 from result import Err, Ok, Result
 
 from ...utils.macro import (
-    str_to_status,
-    HPLCErrorStatus,
     Command,
+    HPLCErrorStatus,
     Status,
+    str_to_status,
 )
-from ...utils.mocking.abc_comm import ABCCommunicationController
+from .abc_tables.abc_comm import ABCCommunicationController
 
 
 class CommunicationController(ABCCommunicationController):
@@ -76,7 +76,7 @@ class CommunicationController(ABCCommunicationController):
             if res.is_err():
                 return HPLCErrorStatus.NORESPONSE
             if res.is_ok():
-                parsed_response = self.receive().value.string_response
+                parsed_response = self.receive().ok_value.string_response
                 self._most_recent_hplc_status = str_to_status(parsed_response)
                 return self._most_recent_hplc_status
             else:
@@ -148,3 +148,24 @@ class CommunicationController(ABCCommunicationController):
             return Err(
                 f"Failed to receive reply to command #{cmd_no} due to {err} caused by {err_msg}."
             )
+
+    def get_chemstation_dirs(self) -> Tuple[str, str, List[str]]:
+        method_dir, sequence_dir, data_dirs = None, None, None
+        self.send(Command.GET_METHOD_DIR)
+        res = self.receive()
+        if res.is_ok():
+            method_dir = res.ok_value.string_response
+        self.send(Command.GET_SEQUENCE_DIR)
+        res = self.receive()
+        if res.is_ok():
+            sequence_dir = res.ok_value.string_response
+        self.send(Command.GET_DATA_DIRS)
+        res = self.receive()
+        if res.is_ok():
+            data_dirs = res.ok().string_response.split("|")
+        if method_dir and sequence_dir and data_dirs:
+            return method_dir, sequence_dir, data_dirs
+        else:
+            raise ValueError(
+                "Please provide the method, sequence and data directories, could not be found."
+            )

pychemstation/control/controllers/data_aq/method.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import os
 import time
 import warnings
-from typing import List, Optional, Union, Dict
+from typing import List, Optional, Union, Dict, Set
 
 from result import Err, Ok, Result
 
@@ -413,8 +413,6 @@ class MethodController(RunController):
         :param stall_while_running: whether to stall or immediately return
         :param add_timestamp: if should add timestamp to experiment name
         """
-
-        folder_name = ""
         hplc_is_running = False
         tries = 0
         while tries < 10 and not hplc_is_running:
@@ -427,18 +425,15 @@ class MethodController(RunController):
                     else experiment_name,
                 )
             )
-            folder_name = (
-                f"{experiment_name}_{timestamp}.D"
-                if add_timestamp
-                else f"{experiment_name}.D"
-            )
+
             hplc_is_running = self.check_hplc_is_running()
             tries += 1
 
+        data_dir, data_file = self.get_current_run_data_dir_file()
         if not hplc_is_running:
             raise RuntimeError("Method failed to start.")
 
-        self.data_files.append(os.path.join(self.data_dirs[0], folder_name))
+        self.data_files.append(os.path.join(os.path.normpath(data_dir), data_file))
         self.timeout = (self.get_total_runtime()) * 60
 
         if stall_while_running:
@@ -446,18 +441,20 @@ class MethodController(RunController):
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
-                raise RuntimeError("Run error has occurred.")
+                raise RuntimeError(f"Run error has occurred:{run_completed.err_value}.")
         else:
-            folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+            folder = self.fuzzy_match_most_recent_folder(self.data_files[-1], None)
             while folder.is_err():
-                folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+                folder = self.fuzzy_match_most_recent_folder(self.data_files[-1], None)
             if folder.is_ok():
                 self.data_files[-1] = folder.ok_value
             else:
                 warning = f"Data folder {self.data_files[-1]} may not exist, returning and will check again after run is done."
                 warnings.warn(warning)
 
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[str, str]:
+    def fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_dirs: Optional[Set[str]]
+    ) -> 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)

pychemstation/control/controllers/data_aq/sequence.py

@@ -1,13 +1,12 @@
 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,
 )
@@ -92,6 +91,7 @@ class SequenceController(RunController):
     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,6 +106,7 @@ class SequenceController(RunController):
             inj_vol=inj_vol,
             inj_source=inj_source,
             sample_type=sample_type,
+            data_file=data_file,
         )
 
     def check(self) -> str:
@@ -127,13 +128,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 +156,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,62 +176,78 @@ 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):
             loc_num = loc.value
@@ -235,6 +256,11 @@ class SequenceController(RunController):
         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 +274,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 +297,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,11 +308,24 @@ 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],
+                )
+                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()
@@ -299,54 +338,39 @@ class SequenceController(RunController):
 
     @override
     def fuzzy_match_most_recent_folder(
-        self, most_recent_folder: T
+        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 +378,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 +409,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
+                seq_file_dir, set(seq_file_dir.child_dirs)
             ).ok_value
         spectra: List[AgilentChannelChromatogramData] = []
         for row in self.data_files[-1].child_dirs:
@@ -404,8 +432,10 @@ class SequenceController(RunController):
             self.data_files.append(
                 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,3 +1,5 @@
+from __future__ import annotations
+
 from ..abc_tables.device import DeviceController
 from ....control.controllers import CommunicationController
 from ....utils.injector_types import (
@@ -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.")

pychemstation/control/hplc.py

@@ -6,6 +6,7 @@ Authors: Lucy Hao
 
 from __future__ import annotations
 
+import os.path
 from typing import Dict, List, Optional, Tuple, Union
 
 from pychemstation.analysis.chromatogram import AgilentChannelChromatogramData
@@ -31,14 +32,16 @@ class HPLCController:
 
     INJECTOR_TABLE = Table(register="RCWLS1Pretreatment[1]", name="InstructionTable")
 
+    DAD_TABLE = Table(register="RCDAD1Method[1]", name="Timetable")
+
     MSD_TABLE = Table(register="MSACQINFO[1]", name="SprayChamber")
 
     def __init__(
         self,
         comm_dir: str,
-        method_dir: str,
-        sequence_dir: str,
-        data_dirs: List[str],
+        method_dir: Optional[str] = None,
+        sequence_dir: Optional[str] = None,
+        extra_data_dirs: Optional[List[str]] = None,
         offline: bool = False,
         debug: bool = False,
     ):
@@ -47,33 +50,42 @@ class HPLCController:
         double escaped: "C:\\my_folder\\"
 
         :param comm_dir: Name of directory for communication, where ChemStation will read and write from. Can be any existing directory.
-        :param data_dirs: Name of directories for storing data after method or sequence runs. Method data dir is default
         the first one in the list. In other words, the first dir in the list is highest prio. Must be "normal" strings and not r-strings.
-        :param method_dir: Name of directory where method files are stored.
-        :param sequence_dir: Name of directory where sequence files are stored.
         :raises FileNotFoundError: If either `data_dir`, `method_dir`, `sequence_dir`, `sequence_data_dir`or `comm_dir` is not a valid directory.
         """
         self.comm: CommunicationController = CommunicationController(
-            comm_dir=comm_dir, debug=debug
-        )
-        self.method_controller: MethodController = MethodController(
-            controller=self.comm,
-            src=method_dir,
-            data_dirs=data_dirs,
-            table=self.METHOD_TIMETABLE,
-            offline=offline,
-            injector_controller=InjectorController(
-                controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
-            ),
-        )
-        self.sequence_controller: SequenceController = SequenceController(
-            controller=self.comm,
-            src=sequence_dir,
-            data_dirs=data_dirs,
-            table=self.SEQUENCE_TABLE,
-            method_controller=self.method_controller,
-            offline=offline,
+            comm_dir=comm_dir, debug=debug, offline=offline
         )
+        data_dirs: List[str] = []
+        if not offline:
+            if not method_dir or not sequence_dir or not extra_data_dirs:
+                method_dir, sequence_dir, data_dirs = self.comm.get_chemstation_dirs()
+            if extra_data_dirs:
+                data_dirs.extend(extra_data_dirs)
+            data_dirs = list(set([os.path.normpath(p) for p in data_dirs]))
+        if method_dir and sequence_dir and data_dirs:
+            self.method_controller: MethodController = MethodController(
+                controller=self.comm,
+                src=method_dir,
+                data_dirs=data_dirs,
+                table=self.METHOD_TIMETABLE,
+                offline=offline,
+                injector_controller=InjectorController(
+                    controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
+                ),
+            )
+            self.sequence_controller: SequenceController = SequenceController(
+                controller=self.comm,
+                src=sequence_dir,
+                data_dirs=data_dirs,
+                table=self.SEQUENCE_TABLE,
+                method_controller=self.method_controller,
+                offline=offline,
+            )
+        else:
+            raise ValueError(
+                "Expected a method dir, sequence dir and data dirs but they were None."
+            )
 
     def send(self, cmd: Union[Command, str]):
         """
@@ -279,7 +291,7 @@ class HPLCController:
         """Returns the currently loaded sequence."""
         return self.sequence_controller.load()
 
-    def load_injector_program(self) -> InjectorTable:
+    def load_injector_program(self) -> InjectorTable | None:
         return self.method_controller.injector_controller.load()
 
     def standby(self):

pychemstation/utils/macro.py

@@ -48,6 +48,17 @@ class Command(Enum):
     SAVE_METHOD_CMD = 'SaveMethod _MethPath$, _MethFile$, "{commit_msg}"'
     GET_SEQUENCE_CMD = "response$ = _SeqFile$"
     RUN_SEQUENCE_CMD = "RunSequence"
+    CURRENT_RUNNING_SEQ_LINE = "response_num = _SEQCURRLINE1"
+
+    # Get directories
+    GET_METHOD_DIR = "response$ = _METHPATH$"
+    GET_SEQUENCE_DIR = "response$ = _SEQUENCEPATHS$"
+    GET_DATA_DIRS = "response$ = _DATAPATHS$"
+    GET_CURRENT_RUN_DATA_DIR = "response$ = _DATAPath$"
+    GET_CURRENT_RUN_DATA_FILE = "response$ = _DATAFILE1$"
+
+    # Debuggng
+    ERROR = "response$ = _ERROR$"
 
 
 class HPLCRunningStatus(Enum):

pychemstation/utils/mocking/mock_comm.py

@@ -1,4 +1,4 @@
-from pychemstation.utils.mocking.abc_comm import ABCCommunicationController
+from ...control.controllers.abc_tables.abc_comm import ABCCommunicationController
 
 
 class MockCommunicationController(ABCCommunicationController):

pychemstation/utils/sequence_types.py

@@ -11,6 +11,7 @@ from pychemstation.utils.tray_types import Tray
 class SequenceDataFiles:
     sequence_name: str
     dir: str
+    _data_files: List[str] = field(default_factory=list)
     child_dirs: List[str] = field(default_factory=list)
 
 
@@ -38,9 +39,9 @@ class InjectionSource(Enum):
 
 @dataclass
 class SequenceEntry:
-    sample_name: str
+    data_file: str
     vial_location: Tray
-    data_file: Optional[str] = None
+    sample_name: Optional[str] = None
     method: Optional[str] = None
     num_inj: Optional[int] = 1
     inj_vol: Optional[float] = 2

{pychemstation-0.10.6.dist-info → pychemstation-0.10.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.6
+Version: 0.10.7
 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
@@ -18,7 +18,7 @@ Requires-Dist: matplotlib>=3.7.5
 Requires-Dist: pandas>=2.0.3
 Requires-Dist: pdoc>=14.7.0
 Requires-Dist: polling>=0.3.2
-Requires-Dist: pre-commit>=4.2.0
+Requires-Dist: pre-commit>=3.5.0
 Requires-Dist: pytest>=7.3.5
 Requires-Dist: rainbow-api>=1.0.10
 Requires-Dist: result>=0.17.0
@@ -90,7 +90,7 @@ DATA_DIR_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
 DATA_DIR_3 = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
 
 # Initialize HPLC Controller
-hplc_controller = HPLCController(data_dirs=[DATA_DIR_2, DATA_DIR_3],
+hplc_controller = HPLCController(extra_data_dirs=[DATA_DIR_2, DATA_DIR_3],
                                  comm_dir=DEFAULT_COMMAND_PATH,
                                  method_dir=DEFAULT_METHOD_DIR,
                                  sequence_dir=SEQUENCE_DIR)

{pychemstation-0.10.6.dist-info → pychemstation-0.10.7.dist-info}/RECORD

@@ -3,40 +3,40 @@ pychemstation/analysis/__init__.py,sha256=mPNnp0TmkoUxrTGcT6wNKMyCiOar5vC0cTPmFL
 pychemstation/analysis/base_spectrum.py,sha256=t_VoxAtBph1V7S4fOsziERHiOBkYP0_nH7LTwbTEvcE,16529
 pychemstation/analysis/chromatogram.py,sha256=cHxPd5-miA6L3FjwN5cSFyq4xEeZoHWFFk8gU6tCgg4,3946
 pychemstation/analysis/process_report.py,sha256=xckcpqnYfzFTIo1nhgwP5A4GPJsW3PQ_qzuy5Z1KOuI,14714
-pychemstation/control/README.md,sha256=_7ITj4hD17YIwci6UY6xBebC9gPCBpzBFTB_Gx0eJBc,3124
+pychemstation/control/README.md,sha256=yVMhIOq3YL-8EzqZDWGXt36GzSjzqiI4fwkJ35bAzD0,3130
 pychemstation/control/__init__.py,sha256=7lSkY7Qa7Ikdz82-2FESc_oqktv7JndsjltCkiMqnMI,147
-pychemstation/control/hplc.py,sha256=C4cnjsSsjgK_VcySGhbG1OMGEVoY3pYSA69dnvqwEL0,12526
+pychemstation/control/hplc.py,sha256=PY6P_GTnVxL3rAwPHtJmiAm5iTw9X6xjYghyKpBpYFM,13063
 pychemstation/control/controllers/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
 pychemstation/control/controllers/__init__.py,sha256=EWvvITwY6RID5b1ilVsPowP85uzmIt3LYW0rvyN-3x0,146
-pychemstation/control/controllers/comm.py,sha256=saTyM86kUZ7mevWPpna7LoMC-Q0KR4Pq0cURhCoiW8k,5018
+pychemstation/control/controllers/comm.py,sha256=a3qp_u2vm_UO3VTDwKEEkJfHIWgF4Gxne0h03dQe0A8,5878
 pychemstation/control/controllers/abc_tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/control/controllers/abc_tables/device.py,sha256=HRea-dRwHf7u1aA1m2C9TmIBhhKKifmqVdPfZxmwoyk,442
-pychemstation/control/controllers/abc_tables/run.py,sha256=8RGvQ3NrXPidoGOilxyFoGHxaM1r1qn2d3TLLyOe4po,8202
-pychemstation/control/controllers/abc_tables/table.py,sha256=XriB53rn1YOAMCS4AGARKoniaXOQi5qUsBSNuLCn8ew,7196
+pychemstation/control/controllers/abc_tables/abc_comm.py,sha256=G2JSCNwLrLYPYBdcf_WuIl6dvJORmmQe5wih6TdvPiU,5226
+pychemstation/control/controllers/abc_tables/device.py,sha256=ZJQID_M53bUwVSleBL5MjFJFrExZO1xdYKRFn5VToug,641
+pychemstation/control/controllers/abc_tables/run.py,sha256=L958yy3vBxN0qxHVfMb7wgxxHAvSQq4zggWlon6vPs4,9294
+pychemstation/control/controllers/abc_tables/table.py,sha256=4c4W_9OzrY-SfH_oV6oBZkfn1Vp5XvNYbWUvbGY3G2s,7699
 pychemstation/control/controllers/data_aq/__init__.py,sha256=w-Zgbit10niOQfz780ZmRHjUFxV1hMkdui7fOMPqeLA,132
-pychemstation/control/controllers/data_aq/method.py,sha256=HnVMg-qwKSY7mTmw0AerMlVWHeu72YPfPBviTnzavA4,18214
-pychemstation/control/controllers/data_aq/sequence.py,sha256=Q77YkDTkIxUbsRYyN5OJt1a0HgD9TxHW-LiFRQDV8Kk,16516
+pychemstation/control/controllers/data_aq/method.py,sha256=BqAW2XdlJJQj08P282h_NPTJofdBKiNJgdis9j0c9lc,18183
+pychemstation/control/controllers/data_aq/sequence.py,sha256=here444uwwIH9m08ls8_wapA9088uvqX5DYCHFsarcU,17422
 pychemstation/control/controllers/devices/__init__.py,sha256=QpgGnLXyWiB96KIB98wMccEi8oOUUaLxvBCyevJzcOg,75
-pychemstation/control/controllers/devices/injector.py,sha256=NXJEKDGu-XJoQDbaJav6tD73S7UqFZqXJd5bcwdvwBQ,4047
+pychemstation/control/controllers/devices/injector.py,sha256=OxrF-SbV006bCh_j9o-clavc_d8Loh3myhFerbvjLg4,4033
 pychemstation/generated/__init__.py,sha256=xnEs0QTjeuGYO3tVUIy8GDo95GqTV1peEjosGckpOu0,977
 pychemstation/generated/dad_method.py,sha256=xTUiSCvkXcxBUhjVm1YZKu-tHs16k23pF-0xYrQSwWA,8408
 pychemstation/generated/pump_method.py,sha256=s3MckKDw2-nZUC5lHrJVvXYdneWP8-9UvblNuGryPHY,12092
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/injector_types.py,sha256=z2iWwTklGm0GRDCL9pnPCovQrwyRwxv8w5w5Xh7Pj3U,1152
-pychemstation/utils/macro.py,sha256=Y_0CwTHcDQKoxYrNHqdF14-ciwtx56Y65SzNtOFPhNk,2848
+pychemstation/utils/macro.py,sha256=4Tn__0EeoDT3exbzTKde5epd7Oj-rhUh-l9EkXTHn7c,3242
 pychemstation/utils/method_types.py,sha256=_2djFz_uWFc9aoZcyPMIjC5KYBs003WPoQGx7ZhMiOg,1649
 pychemstation/utils/num_utils.py,sha256=dDs8sLZ_SdtvDKhyhF3IkljiVf16IYqpMTO5tEk9vMk,2079
 pychemstation/utils/parsing.py,sha256=mzdpxrH5ux4-_i4CwZvnIYnIwAnRnOptKb3fZyYJcx0,9307
 pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
-pychemstation/utils/sequence_types.py,sha256=XVAi1MCQrNqwbmzrBrVbapjD_AQg6A-l0nwjNsNAbKs,1924
+pychemstation/utils/sequence_types.py,sha256=Bf_oGm-adRejDUmYrzV2GEx16NIO6jlH_ZMIYVKl8gg,1981
 pychemstation/utils/spec_utils.py,sha256=lS27Xi4mFNDWBfmBqOoxTcVchPAkLK2mSdoaWDOfaPI,10211
 pychemstation/utils/table_types.py,sha256=I5xy7tpmMWOMb6tFfWVE1r4wnSsgky5sZU9oNtHU9BE,3451
 pychemstation/utils/tray_types.py,sha256=FUjCUnozt5ZjCl5Vg9FioPHGTdKa43SQI1QPVkoBmV0,6078
 pychemstation/utils/mocking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/utils/mocking/abc_comm.py,sha256=zt1_6IBme6FiRjZ3zvUvlSdToBb85u3th8NKKGprn_Q,5246
-pychemstation/utils/mocking/mock_comm.py,sha256=nYSK2S85iDACIY73rX56yyqyaWo6Oaj3H7gvMsrkRJA,150
+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.6.dist-info/METADATA,sha256=yfxKdWhVOQkClZFBqiluL41D6PH3XkVZ9SoXxKQlY8Q,5933
-pychemstation-0.10.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pychemstation-0.10.6.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.10.6.dist-info/RECORD,,
+pychemstation-0.10.7.dist-info/METADATA,sha256=oDYpd4ohtIgRyHstF4Pdnn-EP5YSN0ozESFeAQLu_CE,5939
+pychemstation-0.10.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pychemstation-0.10.7.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.10.7.dist-info/RECORD,,