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

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,10 +11,12 @@ from typing_extensions import override
 from pychemstation.analysis.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
+    SEQUENCE_TIME_FORMAT,
 )
 
 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,
@@ -22,8 +26,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
 
 
@@ -36,8 +39,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,
     ):
@@ -80,11 +83,7 @@ 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.")
 
@@ -109,15 +108,6 @@ class SequenceController(RunController):
             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.
@@ -131,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)
@@ -199,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,
@@ -220,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
         )
@@ -237,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, TenVialColumn):
-            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()
 
@@ -268,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:
@@ -297,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
 
@@ -308,20 +341,12 @@ 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)
             else:
@@ -332,42 +357,38 @@ class SequenceController(RunController):
                 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.")
 
+    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]]
+    def _fuzzy_match_most_recent_folder(
+        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.")
@@ -382,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))
@@ -413,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)
@@ -430,15 +447,18 @@ 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,
                         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/controllers/devices/injector.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from ..abc_tables.device import DeviceController
 from ....control.controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
 from ....utils.injector_types import (
     Draw,
     Inject,
@@ -17,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):
@@ -31,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.")
 

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
 
 
@@ -32,8 +32,6 @@ 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__(
@@ -63,7 +61,7 @@ class HPLCController:
             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:
+        if (method_dir and sequence_dir and data_dirs and not offline) or offline:
             self.method_controller: MethodController = MethodController(
                 controller=self.comm,
                 src=method_dir,
@@ -82,14 +80,15 @@ class HPLCController:
                 method_controller=self.method_controller,
                 offline=offline,
             )
-        else:
+        elif not offline and (not method_dir or not sequence_dir or not data_dirs):
             raise ValueError(
-                "Expected a method dir, sequence dir and data dirs but they were None."
+                f"Expected a method dir: {method_dir}, sequence dir: {sequence_dir} and data dirs:{data_dirs} but one was None."
             )
+        else:
+            raise ValueError("Expected error occured, please try again.")
 
     def send(self, cmd: Union[Command, str]):
-        """
-        Sends any Command or string to Chemstation.
+        """Sends any Command or string to Chemstation.
 
         :param cmd: the macro to send to Chemstation
         """
@@ -100,20 +99,22 @@ class HPLCController:
         self.comm.send(cmd)
 
     def receive(self) -> None | Response | str:
-        """
-        Get the most recent response from Chemstation.
+        """Get the most recent response from Chemstation.
 
-        :return: most recent response from a macro that returned a response.
+        :return: most recent response from the most recently sent MACRO that returned a response.
         """
         if not self.comm:
             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.
+        """Get the current status of the HPLC machine.
 
         :return: current status of the HPLC machine; Status types can be found in `pychemstation.utils.macro`
         """
@@ -124,8 +125,7 @@ class HPLCController:
         return self.comm.get_status()
 
     def switch_method(self, method_name: str):
-        """
-        Allows the user to switch between pre-programmed methods. No need to append '.M'
+        """Allows the user to switch between pre-programmed methods. No need to append '.M'
         to the end of the method name. For example. for the method named 'General-Poroshell.M',
         only 'General-Poroshell' is needed.
 
@@ -136,8 +136,7 @@ class HPLCController:
         self.method_controller.switch(method_name)
 
     def switch_sequence(self, sequence_name: str):
-        """
-         Allows the user to switch between pre-programmed sequences. The sequence name does not need the '.S' extension.
+        """Allows the user to switch between pre-programmed sequences. The sequence name does not need the '.S' extension.
          For example: for the method named 'mySeq.S', only 'mySeq' is needed.
 
         :param sequence_name: The name of the sequence file
@@ -150,8 +149,7 @@ class HPLCController:
         add_timestamp: bool = True,
         stall_while_running: bool = True,
     ):
-        """
-        This is the preferred method to trigger a run.
+        """This is the preferred method to trigger a run.
         Starts the currently selected method, storing data
         under the <data_dir>/<experiment_name>.D folder.
         Device must be ready.
@@ -171,8 +169,7 @@ class HPLCController:
         self.method_controller.stop()
 
     def run_sequence(self, stall_while_running: bool = True):
-        """
-        Starts the currently loaded sequence, storing data
+        """Starts the currently loaded sequence, storing data
         under one of the data_dirs/<sequence table name> folder.
         Device must be ready.
 
@@ -181,24 +178,21 @@ class HPLCController:
         self.sequence_controller.run(stall_while_running=stall_while_running)
 
     def check_method_complete(self) -> Tuple[float, int]:
-        """
-        Check if the currently running method (if any) is done.
+        """Check if the currently running method (if any) is done.
 
-        :returns the percent of the method run completed, and whether the run is complete.
+        :returns: the percent of the method run completed, and whether the run is complete.
         """
         return self.method_controller.check_hplc_run_finished()
 
     def check_sequence_complete(self) -> Tuple[float, int]:
-        """
-        Check if the currently running sequence (if any) is done.
+        """Check if the currently running sequence (if any) is done.
 
         :return: the percent of the sequence run completed, and whether the run is complete.
         """
         return self.sequence_controller.check_hplc_run_finished()
 
     def edit_method(self, updated_method: MethodDetails, save: bool = False):
-        """
-        Updated the currently loaded method in ChemStation with provided values.
+        """Updated the currently loaded method in ChemStation with provided values.
 
         :param updated_method: the method with updated values, to be sent to Chemstation to modify the currently loaded method.
         :param save: whether this method should be saved to disk, or just modified.
@@ -206,20 +200,28 @@ class HPLCController:
         self.method_controller.edit(updated_method, save)
 
     def edit_sequence(self, updated_sequence: SequenceTable):
-        """
-        Updates the currently loaded sequence table with the provided table, and saves the sequence.
+        """Updates the currently loaded sequence table with the provided table, and saves the sequence.
 
         :param updated_sequence: The sequence table to be written to the currently loaded sequence table.
         """
         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,
         report_type: ReportType = ReportType.CSV,
     ) -> AgilentReport:
-        """
-        Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
+        """Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
 
         :param custom_path: path to sequence folder
         :param report_type: read either the TXT or CSV version
@@ -232,8 +234,7 @@ class HPLCController:
     def get_last_run_method_data(
         self, read_uv: bool = False, custom_path: Optional[str] = None
     ) -> Dict[int, AgilentHPLCChromatogram] | AgilentChannelChromatogramData:
-        """
-        Returns the last run method data.
+        """Returns the last run method data.
 
         :param custom_path: If you want to just load method data but from a file path. This file path must be the complete file path.
         :param read_uv: whether to also read the UV file
@@ -243,13 +244,25 @@ 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,
         report_type: ReportType = ReportType.CSV,
     ) -> List[AgilentReport]:
-        """
-        Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
+        """Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
 
         :param custom_path: path to sequence folder
         :param report_type: read either the TXT or CSV version
@@ -264,8 +277,7 @@ class HPLCController:
     ) -> (
         List[Dict[int, AgilentHPLCChromatogram]] | List[AgilentChannelChromatogramData]
     ):
-        """
-        Returns data for all rows in the last run sequence data.
+        """Returns data for all rows in the last run sequence data.
 
         :param custom_path: If you want to just load sequence data but from a file path. This file path must be the complete file path.
         :param read_uv: whether to also read the UV file
@@ -277,11 +289,11 @@ class HPLCController:
 
     def check_loaded_sequence(self) -> str:
         """Returns the name of the currently loaded sequence."""
-        return self.sequence_controller.check()
+        return self.sequence_controller.get_current_sequence_name()
 
     def check_loaded_method(self) -> str:
         """Returns the name of the currently loaded method."""
-        return self.method_controller.check()
+        return self.method_controller.get_current_method_name()
 
     def load_method(self) -> MethodDetails:
         """Returns details of the currently loaded method, such as its starting modifier conditions and timetable."""

pychemstation/utils/__init__.py

@@ -0,0 +1,23 @@
+from . import abc_tables
+from . import injector_types
+from . import macro
+from . import method_types
+from . import num_utils
+from . import parsing
+from . import sequence_types
+from . import spec_utils
+from . import table_types
+from . import tray_types
+
+__all__ = [
+    "abc_tables",
+    "injector_types",
+    "macro",
+    "method_types",
+    "num_utils",
+    "parsing",
+    "sequence_types",
+    "spec_utils",
+    "table_types",
+    "tray_types",
+]