pychemstation 0.8.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

pychemstation/control/controllers/tables/table.py

@@ -3,24 +3,34 @@ Abstract module containing shared logic for Method and Sequence tables.
 
 Authors: Lucy Hao
 """
+from __future__ import annotations
 
 import abc
 import math
 import os
 import time
-from typing import Union, Optional, List, Tuple, Dict
+import warnings
+from typing import Dict, List, Optional, Tuple, Union
 
 import polling
 import rainbow as rb
-from result import Result, Err
-
-from ....analysis.process_report import AgilentReport, ReportType, CSVProcessor, TXTProcessor
+from result import Err, Result, Ok
+
+from ....analysis.process_report import (
+    AgilentReport,
+    CSVProcessor,
+    ReportType,
+    TXTProcessor,
+)
 from ....control.controllers.comm import CommunicationController
-from ....utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
+from ....utils.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
 from ....utils.macro import Command, HPLCRunningStatus, Response
 from ....utils.method_types import MethodDetails
 from ....utils.sequence_types import SequenceDataFiles, SequenceTable
-from ....utils.table_types import Table, TableOperation, RegisterFlag, T
+from ....utils.table_types import RegisterFlag, T, Table, TableOperation
 
 TableType = Union[MethodDetails, SequenceTable]
 
@@ -200,21 +210,25 @@ class TableController(abc.ABC):
         return started_running
 
     def check_hplc_run_finished(self) -> Tuple[float, bool]:
-        time_passed = (time.time() - self.curr_run_starting_time)
-        if time_passed > self.timeout:
-            done_running = self.controller.check_if_not_running()
-            enough_time_passed = time_passed >= self.timeout
-            run_finished = enough_time_passed and done_running
-            if run_finished:
-                self._reset_time()
-                return 0, run_finished
-        return (time_passed / self.timeout), self.controller.check_if_not_running()
-
-    def check_hplc_done_running(self) -> Result[Union[SequenceDataFiles, str], str]:
+        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)
+            if time_passed > self.timeout:
+                enough_time_passed = time_passed >= self.timeout
+                run_finished = enough_time_passed and done_running
+                if run_finished:
+                    self._reset_time()
+                    return 0, run_finished
+            else:
+                time_left = self.timeout - time_passed
+                return time_left, self.controller.check_if_not_running()
+        return 0, self.controller.check_if_not_running()
+
+    def check_hplc_done_running(self) -> Ok[T] | Err[str]:
         """
         Checks if ChemStation has finished running and can read data back
 
-        :return: Return True if data can be read back, else False.
+        :return: Data file object containing most recent run file information.
         """
         finished_run = False
         minutes = math.ceil(self.timeout / 60)
@@ -244,16 +258,18 @@ class TableController(abc.ABC):
             except Exception:
                 self._reset_time()
                 return check_folder
-
-        else:
-            return Err("Run did not complete as expected")
+        return Err("Run did not complete as expected")
 
     @abc.abstractmethod
     def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         pass
 
     @abc.abstractmethod
-    def get_data(self) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def get_data(self, custom_path: Optional[str] = None) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        pass
+
+    @abc.abstractmethod
+    def get_data_uv(self) -> Union[List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]]:
         pass
 
     @abc.abstractmethod
@@ -263,11 +279,11 @@ class TableController(abc.ABC):
     def get_uv_spectrum(self, path: str):
         data_uv = rb.agilent.chemstation.parse_file(os.path.join(path, "DAD1.UV"))
         times = data_uv.xlabels
-        wavelengthes = data_uv.ylabels
-        data = data_uv.data.transpose()
-        for (i, w) in enumerate(wavelengthes):
+        wavelengths = data_uv.ylabels
+        absorbances = data_uv.data.transpose()
+        for (i, w) in enumerate(wavelengths):
             self.uv[w] = AgilentHPLCChromatogram()
-            self.uv[w].attach_spectrum(times, data[i])
+            self.uv[w].attach_spectrum(times, absorbances[i])
 
     def get_report_details(self, path: str,
                            report_type: ReportType = ReportType.TXT) -> AgilentReport:
@@ -281,18 +297,18 @@ class TableController(abc.ABC):
                 self.report = csv_report.ok_value
         return self.report
 
-    def get_spectrum(self, data_path: str, read_uv: bool = False):
+
+    def get_spectrum_at_channels(self, data_path: str):
         """
         Load chromatogram for any channel in spectra dictionary.
         """
-        if read_uv:
-            self.get_uv_spectrum(data_path)
         for channel, spec in self.spectra.items():
             try:
                 spec.load_spectrum(data_path=data_path, channel=channel)
             except FileNotFoundError:
                 self.spectra[channel] = AgilentHPLCChromatogram()
-                print(f"No data at channel: {channel}")
+                warning = f"No data at channel: {channel}"
+                warnings.warn(warning)
 
     def _reset_time(self):
         self.curr_run_starting_time = None

pychemstation/control/hplc.py

@@ -3,12 +3,20 @@ Module to provide API for higher-level HPLC actions.
 
 Authors: Lucy Hao
 """
+from __future__ import annotations
 
-from typing import Union, Optional, List, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
+from pychemstation.utils.chromatogram import (
+    AgilentHPLCChromatogram,
+)
 from .controllers.devices.injector import InjectorController
-from ..analysis.process_report import ReportType, AgilentReport
-from ..control.controllers import MethodController, SequenceController, CommunicationController
+from ..analysis.process_report import AgilentReport, ReportType
+from ..control.controllers import (
+    CommunicationController,
+    MethodController,
+    SequenceController,
+)
 from ..utils.chromatogram import AgilentChannelChromatogramData
 from ..utils.injector_types import InjectorTable
 from ..utils.macro import Command, Response, Status
@@ -44,7 +52,8 @@ class HPLCController:
                  method_dir: str,
                  sequence_dir: str,
                  data_dirs: List[str],
-                 offline: bool = False):
+                 offline: bool = False,
+                 debug: bool = False,):
         """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
         `comm_dir` must match the file path in the macro file. All file paths are normal strings, with the left slash
         double escaped: "C:\\my_folder\\"
@@ -56,7 +65,7 @@ class HPLCController:
         :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(comm_dir=comm_dir) if not offline else None
+        self.comm = CommunicationController(comm_dir=comm_dir, debug=debug) if not offline else None
         self.method_controller = MethodController(controller=self.comm,
                                                   src=method_dir,
                                                   data_dirs=data_dirs,
@@ -200,14 +209,17 @@ class HPLCController:
         return self.method_controller.get_report(custom_path=custom_path, report_type=report_type)[0]
 
     def get_last_run_method_data(self, read_uv: bool = False,
-                                 data: Optional[str] = None) -> AgilentChannelChromatogramData:
+                                 custom_path: Optional[str] = None) -> Dict[str, AgilentHPLCChromatogram] | AgilentChannelChromatogramData:
         """
         Returns the last run method data.
 
-        :param data: If you want to just load method data but from a file path. This file path must be the complete file path.
+        :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
         """
-        return self.method_controller.get_data(custom_path=data, read_uv=read_uv)
+        if read_uv:
+            return self.method_controller.get_data_uv(custom_path=custom_path)
+        else:
+            return self.method_controller.get_data(custom_path=custom_path)
 
     def get_last_run_sequence_reports(self,
                                       custom_path: Optional[str] = None,
@@ -221,14 +233,18 @@ class HPLCController:
         return self.sequence_controller.get_report(custom_path=custom_path, report_type=report_type)
 
     def get_last_run_sequence_data(self, read_uv: bool = False,
-                                   data: Optional[str] = None) -> List[AgilentChannelChromatogramData]:
+                                   custom_path: Optional[str] = None) -> List[Dict[str, AgilentHPLCChromatogram]] | \
+                                                                         List[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
 
-        :param data: If you want to just load sequence data but from a file path. This file path must be the complete file path.
+        :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
         """
-        return self.sequence_controller.get_data(custom_path=data, read_uv=read_uv)
+        if read_uv:
+            return self.sequence_controller.get_data_uv(custom_path=custom_path)
+        else:
+            return self.sequence_controller.get_data(custom_path=custom_path)
 
     def check_loaded_sequence(self) -> str:
         """Returns the name of the currently loaded sequence."""

pychemstation/control/table/__init__.py

@@ -0,0 +1,3 @@
+from .method import MethodController
+from .sequence import SequenceController
+from .table_controller import TableController

pychemstation/control/table/method.py

@@ -0,0 +1,274 @@
+import os
+import time
+from typing import Optional, Any
+
+from xsdata.formats.dataclass.parsers import XmlParser
+
+from .. import CommunicationController
+from ...control.table.table_controller import TableController
+from ...generated import PumpMethod, DadMethod, SolventElement
+from ...utils.chromatogram import TIME_FORMAT, AgilentHPLCChromatogram
+from ...utils.macro import Command
+from ...utils.method_types import PType, TimeTableEntry, Param, MethodTimetable, HPLCMethodParams
+from ...utils.table_types import RegisterFlag, TableOperation, Table
+
+
+class MethodController(TableController):
+    """
+    Class containing method related logic
+    """
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
+        super().__init__(controller, src, data_dir, table)
+
+    def get_method_params(self) -> HPLCMethodParams:
+        return HPLCMethodParams(organic_modifier=self.controller.get_num_val(
+            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                register=self.table.register,
+                register_flag=RegisterFlag.SOLVENT_B_COMPOSITION
+            )
+        ),
+            flow=self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table.register,
+                    register_flag=RegisterFlag.FLOW
+                )
+            ),
+            maximum_run_time=self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table.register,
+                    register_flag=RegisterFlag.MAX_TIME
+                )
+            ),
+        )
+
+    def get_row(self, row: int) -> TimeTableEntry:
+        return TimeTableEntry(start_time=self.get_num(row, RegisterFlag.TIME),
+                              organic_modifer=self.get_num(row, RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION),
+                              flow=None)
+
+    def load(self) -> MethodTimetable:
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            timetable_rows = [self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))]
+            return MethodTimetable(
+                first_row=self.get_method_params(),
+                subsequent_rows=timetable_rows)
+        else:
+            raise RuntimeError(rows.err_value)
+
+    def current_method(self, method_name: str):
+        """
+        Checks if a given method is already loaded into Chemstation. Method name does not need the ".M" extension.
+
+        :param method_name: a Chemstation method
+        :return: True if method is already loaded
+        """
+        self.send(Command.GET_METHOD_CMD)
+        parsed_response = self.receive()
+        return method_name in parsed_response
+
+    def switch(self, method_name: str):
+        """
+        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.
+
+        :param method_name: any available method in Chemstation method directory
+        :raise IndexError: Response did not have expected format. Try again.
+        :raise AssertionError: The desired method is not selected. Try again.
+        """
+        self.send(Command.SWITCH_METHOD_CMD.value.format(method_dir=self.src,
+                                                         method_name=method_name))
+
+        time.sleep(2)
+        self.send(Command.GET_METHOD_CMD)
+        time.sleep(2)
+        res = self.receive()
+        if res.is_ok():
+            parsed_response = res.ok_value.string_response
+            assert parsed_response == f"{method_name}.M", "Switching Methods failed."
+
+    def load_from_disk(self, method_name: str) -> MethodTimetable:
+        """
+        Retrieve method details of an existing method. Don't need to append ".M" to the end. This assumes the
+        organic modifier is in Channel B and that Channel A contains the aq layer. Additionally, assumes
+         only two solvents are being used.
+
+        :param method_name: name of method to load details of
+        :raises FileNotFoundError: Method does not exist
+        :return: method details
+        """
+        method_folder = f"{method_name}.M"
+        method_path = os.path.join(self.src, method_folder, "AgilentPumpDriver1.RapidControl.MethodXML.xml")
+        dad_path = os.path.join(self.src, method_folder, "Agilent1200erDadDriver1.RapidControl.MethodXML.xml")
+
+        if os.path.exists(os.path.join(self.src, f"{method_name}.M")):
+            parser = XmlParser()
+            method = parser.parse(method_path, PumpMethod)
+            dad = parser.parse(dad_path, DadMethod)
+
+            organic_modifier: Optional[SolventElement] = None
+            aq_modifier: Optional[SolventElement] = None
+
+            if len(method.solvent_composition.solvent_element) == 2:
+                for solvent in method.solvent_composition.solvent_element:
+                    if solvent.channel == "Channel_A":
+                        aq_modifier = solvent
+                    elif solvent.channel == "Channel_B":
+                        organic_modifier = solvent
+
+            return MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=organic_modifier.percentage,
+                    flow=method.flow,
+                    maximum_run_time=method.stop_time,
+                    temperature=-1),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=tte.time,
+                        organic_modifer=tte.percent_b,
+                        flow=method.flow
+                    ) for tte in method.timetable.timetable_entry
+                ],
+                dad_wavelengthes=dad.signals.signal,
+                organic_modifier=organic_modifier,
+                modifier_a=aq_modifier
+            )
+        else:
+            raise FileNotFoundError
+
+    def edit(self, updated_method: MethodTimetable, save: bool):
+        """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.
+        """
+        initial_organic_modifier: Param = Param(val=updated_method.first_row.organic_modifier,
+                                                chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+                                                ptype=PType.NUM)
+        max_time: Param = Param(val=updated_method.first_row.maximum_run_time,
+                                chemstation_key=RegisterFlag.MAX_TIME,
+                                ptype=PType.NUM)
+        flow: Param = Param(val=updated_method.first_row.flow,
+                            chemstation_key=RegisterFlag.FLOW,
+                            ptype=PType.NUM)
+
+        # Method settings required for all runs
+        self.delete_table()
+        self._update_param(initial_organic_modifier)
+        self._update_param(flow)
+        self._update_param(Param(val="Set",
+                                 chemstation_key=RegisterFlag.STOPTIME_MODE,
+                                 ptype=PType.STR))
+        self._update_param(max_time)
+        self._update_param(Param(val="Off",
+                                 chemstation_key=RegisterFlag.POSTIME_MODE,
+                                 ptype=PType.STR))
+
+        self.send("DownloadRCMethod PMP1")
+
+        self._update_method_timetable(updated_method.subsequent_rows)
+
+        if save:
+            self.send(Command.SAVE_METHOD_CMD.value.format(
+                commit_msg=f"saved method at {str(time.time())}"
+            ))
+
+    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
+        self.sleepy_send('Local Rows')
+        self.get_num_rows()
+
+        self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+        res = self.get_num_rows()
+        while not res.is_err():
+            self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+            res = self.get_num_rows()
+
+        self.sleepy_send('NewTab RCPMP1Method[1], "Timetable"')
+        self.get_num_rows()
+
+        for i, row in enumerate(timetable_rows):
+            if i == 0:
+                self.send('Sleep 1')
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
+                self.send('Sleep 1')
+
+                self.sleepy_send('NewColText RCPMP1Method[1], "Timetable", "Function", "SolventComposition"')
+                self.sleepy_send(f'NewColVal RCPMP1Method[1], "Timetable", "Time", {row.start_time}')
+                self.sleepy_send(
+                    f'NewColVal RCPMP1Method[1], "Timetable", "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
+
+                self.send('Sleep 1')
+                self.sleepy_send("DownloadRCMethod PMP1")
+                self.send('Sleep 1')
+            else:
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
+                self.get_num_rows()
+
+                self.sleepy_send(
+                    f'SetTabText RCPMP1Method[1], "Timetable", Rows, "Function", "SolventComposition"')
+                self.sleepy_send(
+                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "Time", {row.start_time}')
+                self.sleepy_send(
+                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
+
+                self.send("Sleep 1")
+                self.sleepy_send("DownloadRCMethod PMP1")
+                self.send("Sleep 1")
+                self.get_num_rows()
+
+    def _update_param(self, method_param: Param):
+        """Change a method parameter, changes what is visibly seen in Chemstation GUI.
+         (changes the first row in the timetable)
+
+        :param method_param: a parameter to update for currently loaded method.
+        """
+        register = self.table.register
+        setting_command = TableOperation.UPDATE_OBJ_HDR_VAL if method_param.ptype == PType.NUM else TableOperation.UPDATE_OBJ_HDR_TEXT
+        if isinstance(method_param.chemstation_key, list):
+            for register_flag in method_param.chemstation_key:
+                self.send(setting_command.value.format(register=register,
+                                                       register_flag=register_flag,
+                                                       val=method_param.val))
+        else:
+            self.send(setting_command.value.format(register=register,
+                                                   register_flag=method_param.chemstation_key,
+                                                   val=method_param.val))
+        time.sleep(2)
+
+    def stop(self):
+        """
+        Stops the method run. A dialog window will pop up and manual intervention may be required.\
+        """
+        self.send(Command.STOP_METHOD_CMD)
+
+    def run(self, experiment_name: str):
+        """
+        This is the preferred method to trigger a run.
+        Starts the currently selected method, storing data
+        under the <data_dir>/<experiment_name>.D folder.
+        The <experiment_name> will be appended with a timestamp in the '%Y-%m-%d-%H-%M' format.
+        Device must be ready.
+
+        :param experiment_name: Name of the experiment
+        """
+        timestamp = time.strftime(TIME_FORMAT)
+        self.send(Command.RUN_METHOD_CMD.value.format(data_dir=self.data_dir,
+                                                      experiment_name=experiment_name,
+                                                      timestamp=timestamp))
+
+        if self.check_hplc_is_running():
+            folder_name = f"{experiment_name}_{timestamp}.D"
+            self.data_files.append(os.path.join(self.data_dir, folder_name))
+
+        run_completed = self.check_hplc_done_running()
+
+        if not run_completed.is_ok():
+            raise RuntimeError("Run did not complete as expected")
+
+    def retrieve_recent_data_files(self) -> str:
+        return self.data_files[-1]
+
+    def get_data(self) -> dict[str, AgilentHPLCChromatogram]:
+        self.get_spectrum(self.data_files[-1])
+        return self.spectra