pychemstation 0.5.2__py3-none-any.whl → 0.5.3.dev1__py3-none-any.whl

pychemstation/control/comm.py

@@ -13,7 +13,7 @@ Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 import os
 import time
 
-from ..utils.constants import MAX_CMD_NO
+from result import Result, Ok, Err
 from ..utils.macro import *
 from ..utils.method_types import *
 
@@ -23,6 +23,9 @@ class CommunicationController:
     Class that communicates with Agilent using Macros
     """
 
+    # maximum command number
+    MAX_CMD_NO = 255
+
     def __init__(
             self,
             comm_dir: str,
@@ -48,7 +51,23 @@ class CommunicationController:
 
         self.reset_cmd_counter()
 
-    def get_status(self) -> list[Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]]:
+    def get_num_val(self, cmd: str) -> Union[int, float, Err]:
+        self.send(Command.GET_NUM_VAL_CMD.value.format(cmd=cmd))
+        res = self.receive()
+        if res.is_ok():
+            return res.ok_value.num_response
+        else:
+            raise RuntimeError("Failed to get number.")
+
+    def get_text_val(self, cmd: str) -> str:
+        self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
+        res = self.receive()
+        if res.is_ok():
+            return res.ok_value.string_response
+        else:
+            raise RuntimeError("Failed to get string")
+
+    def get_status(self) -> Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]:
         """Get device status(es).
 
         :return: list of ChemStation's current status
@@ -57,33 +76,28 @@ class CommunicationController:
         time.sleep(1)
 
         try:
-            parsed_response = self.receive().splitlines()[1].split()[1:]
-            recieved_status = [str_to_status(res) for res in parsed_response]
-            self._most_recent_hplc_status = recieved_status[0]
-            return recieved_status
+            parsed_response = self.receive().value.string_response
+            self._most_recent_hplc_status = str_to_status(parsed_response)
+            return self._most_recent_hplc_status
         except IOError:
-            return [HPLCErrorStatus.NORESPONSE]
+            return HPLCErrorStatus.NORESPONSE
         except IndexError:
-            return [HPLCErrorStatus.MALFORMED]
+            return HPLCErrorStatus.MALFORMED
 
     def set_status(self):
         """Updates current status of HPLC machine"""
         self._most_recent_hplc_status = self.get_status()[0]
 
-    def _check_data_status(self, data_path: str) -> bool:
+    def check_if_running(self, data_path: str) -> bool:
         """Checks if HPLC machine is in an available state, meaning a state that data is not being written.
 
         :return: whether the HPLC machine is in a safe state to retrieve data back."""
-        old_status = self._most_recent_hplc_status
         self.set_status()
         file_exists = os.path.exists(data_path)
-        done_writing_data = isinstance(self._most_recent_hplc_status,
-                                       HPLCAvailStatus) and old_status != self._most_recent_hplc_status and file_exists
+        hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
+        done_writing_data = hplc_avail and file_exists
         return done_writing_data
 
-    def check_data(self, data_path: str) -> bool:
-        return self._check_data_status(data_path)
-
     def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
         """Low-level execution primitive. Sends a command string to HPLC.
 
@@ -106,13 +120,13 @@ class CommunicationController:
         else:
             raise IOError(f"Failed to send command #{cmd_no}: {cmd}.") from err
 
-    def _receive(self, cmd_no: int, num_attempts=100) -> str:
+    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
         """Low-level execution primitive. Recives a response from HPLC.
 
         :param cmd_no: Command number
         :param num_attempts: Number of retries to open reply file
         :raises IOError: Could not read reply file.
-        :return: ChemStation response 
+        :return: Potential ChemStation response
         """
         err = None
         for _ in range(num_attempts):
@@ -134,11 +148,11 @@ class CommunicationController:
 
             # check that response corresponds to sent command
             if response_no == cmd_no:
-                return response
+                return Ok(response)
             else:
                 continue
         else:
-            raise IOError(f"Failed to receive reply to command #{cmd_no}.") from err
+            return Err(f"Failed to receive reply to command #{cmd_no} due to {err}.")
 
     def sleepy_send(self, cmd: Union[Command, str]):
         self.send("Sleep 0.1")
@@ -150,24 +164,37 @@ class CommunicationController:
 
         :param cmd: Command to be sent to HPLC
         """
-        if self.cmd_no == MAX_CMD_NO:
+        if self.cmd_no == self.MAX_CMD_NO:
             self.reset_cmd_counter()
 
         cmd_to_send: str = cmd.value if isinstance(cmd, Command) else cmd
         self.cmd_no += 1
         self._send(cmd_to_send, self.cmd_no)
 
-    def receive(self) -> str:
+    def receive(self) -> Result[Response, str]:
         """Returns messages received in reply file.
 
         :return: ChemStation response 
         """
-        return self._receive(self.cmd_no)
+        num_response_prefix = "Numerical Responses:"
+        str_response_prefix = "String Responses:"
+        possible_response = self._receive(self.cmd_no)
+        if Ok(possible_response):
+            lines = possible_response.value.splitlines()
+            for line in lines:
+                if str_response_prefix in line and num_response_prefix in line:
+                    string_responses_dirty, _, numerical_responses = line.partition(num_response_prefix)
+                    _, _, string_responses = string_responses_dirty.partition(str_response_prefix)
+                    return Ok(Response(string_response=string_responses.strip(),
+                                       num_response=float(numerical_responses.strip())))
+            return Err(f"Could not retrieve HPLC response")
+        else:
+            return Err(f"Could not establish response to HPLC: {possible_response}")
 
     def reset_cmd_counter(self):
         """Resets the command counter."""
-        self._send(Command.RESET_COUNTER_CMD.value, cmd_no=MAX_CMD_NO + 1)
-        self._receive(cmd_no=MAX_CMD_NO + 1)
+        self._send(Command.RESET_COUNTER_CMD.value, cmd_no=self.MAX_CMD_NO + 1)
+        self._receive(cmd_no=self.MAX_CMD_NO + 1)
         self.cmd_no = 0
 
     def stop_macro(self):

pychemstation/control/hplc.py

@@ -9,12 +9,24 @@ from typing import Union, Optional
 from ..control import CommunicationController
 from ..control.table import MethodController, SequenceController
 from ..utils.chromatogram import AgilentHPLCChromatogram
-from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus
+from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
 from ..utils.method_types import MethodTimetable
 from ..utils.sequence_types import SequenceTable, SequenceEntry
+from ..utils.table_types import Table
 
 
 class HPLCController:
+    # tables
+    METHOD_TIMETABLE = Table(
+        register="RCPMP1Method[1]",
+        name="Timetable"
+    )
+
+    SEQUENCE_TABLE = Table(
+        register="_sequence[1]",
+        name="SeqTable1"
+    )
+
     def __init__(self,
                  comm_dir: str,
                  data_dir: str,
@@ -27,16 +39,23 @@ class HPLCController:
         :raises FileNotFoundError: If either `data_dir`, `method_dir` or `comm_dir` is not a valid directory.
         """
         self.comm = CommunicationController(comm_dir=comm_dir)
-        self.method_controller = MethodController(controller=self.comm, src=method_dir, data_dir=data_dir)
-        self.sequence_controller = SequenceController(controller=self.comm, src=sequence_dir, data_dir=data_dir)
+        self.method_controller = MethodController(controller=self.comm,
+                                                  src=method_dir,
+                                                  data_dir=data_dir,
+                                                  table=self.METHOD_TIMETABLE)
+        self.sequence_controller = SequenceController(controller=self.comm,
+                                                      src=sequence_dir,
+                                                      data_dir=data_dir,
+                                                      table=self.SEQUENCE_TABLE,
+                                                      method_dir=method_dir)
 
     def send(self, cmd: Union[Command, str]):
         self.comm.send(cmd)
 
-    def receive(self) -> str:
-        return self.comm.receive()
+    def receive(self) -> Response:
+        return self.comm.receive().value
 
-    def status(self) -> list[HPLCRunningStatus | HPLCAvailStatus | HPLCErrorStatus]:
+    def status(self) -> Union[HPLCRunningStatus | HPLCAvailStatus | HPLCErrorStatus]:
         return self.comm.get_status()
 
     def switch_method(self, method_name: str):
@@ -56,7 +75,7 @@ class HPLCController:
          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 seq_name: The name of the sequence file
+        :param sequence_name: The name of the sequence file
         """
         self.sequence_controller.switch(sequence_name)
 
@@ -82,12 +101,13 @@ class HPLCController:
         """
         self.sequence_controller.run(sequence_table)
 
-    def edit_method(self, updated_method: MethodTimetable):
+    def edit_method(self, updated_method: MethodTimetable, save: bool = False):
         """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:
         """
-        self.method_controller.edit(updated_method)
+        self.method_controller.edit(updated_method, save)
 
     def edit_sequence(self, updated_sequence: SequenceTable):
         """
@@ -107,23 +127,29 @@ class HPLCController:
         """
         self.sequence_controller.edit_row(row, num)
 
-    def get_last_run_method_data(self) -> Optional[dict[str, AgilentHPLCChromatogram]]:
+    def get_last_run_method_data(self) -> dict[str, AgilentHPLCChromatogram]:
         """
         Returns the last run method data.
         """
-        data_valid, data = self.method_controller.get_data()
-        if data_valid:
-            return data
-        return None
+        return self.method_controller.get_data()
 
-    def get_last_run_sequence_data(self) -> Optional[list[dict[str, AgilentHPLCChromatogram]]]:
+    def get_last_run_sequence_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
         """
         Returns data for all rows in the last run sequence data.
         """
-        data_valid, data = self.sequence_controller.get_data()
-        if data_valid:
-            return data
-        return None
+        return self.sequence_controller.get_data()
+
+    def load_method(self) -> MethodTimetable:
+        """
+        Returns the currently loaded method, including its timetable.
+        """
+        return self.method_controller.load()
+
+    def load_sequence(self) -> SequenceTable:
+        """
+        Returns the currently loaded sequence.
+        """
+        return self.sequence_controller.load()
 
     def standby(self):
         """Switches all modules in standby mode. All lamps and pumps are switched off."""

pychemstation/control/table/method.py

@@ -7,11 +7,10 @@ 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
-from ...utils.constants import METHOD_TIMETABLE
+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
+from ...utils.table_types import RegisterFlag, TableOperation, Table
 
 
 class MethodController(TableController):
@@ -19,10 +18,46 @@ class MethodController(TableController):
     Class containing method related logic
     """
 
-    def __init__(self, controller: CommunicationController, src: str, data_dir: str):
-        super().__init__(controller, src, data_dir)
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
+        super().__init__(controller, src, data_dir, table)
 
-    def is_loaded(self, method_name: str):
+    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.
 
@@ -30,7 +65,7 @@ class MethodController(TableController):
         :return: True if method is already loaded
         """
         self.send(Command.GET_METHOD_CMD)
-        parsed_response = self.receive().splitlines()[1].split()[1:][0]
+        parsed_response = self.receive()
         return method_name in parsed_response
 
     def switch(self, method_name: str):
@@ -49,18 +84,12 @@ class MethodController(TableController):
         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."
 
-        # check that method switched
-        for _ in range(10):
-            try:
-                parsed_response = self.receive().splitlines()[1].split()[1:][0]
-                break
-            except IndexError:
-                continue
-
-        assert parsed_response == f"{method_name}.M", "Switching Methods failed."
-
-    def load(self, method_name: str):
+    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
@@ -91,25 +120,10 @@ class MethodController(TableController):
 
             return MethodTimetable(
                 first_row=HPLCMethodParams(
-                    organic_modifier=Param(val=organic_modifier.percentage,
-                                           chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-                                           ptype=PType.NUM),
-                    flow=Param(val=method.flow,
-                               chemstation_key=RegisterFlag.FLOW,
-                               ptype=PType.NUM),
-                    maximum_run_time=Param(val=method.stop_time,
-                                           chemstation_key=RegisterFlag.MAX_TIME,
-                                           ptype=PType.NUM),
-                    temperature=Param(val=None,
-                                      chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
-                                                       RegisterFlag.COLUMN_OVEN_TEMP2],
-                                      ptype=PType.NUM),
-                    inj_vol=Param(val=None,
-                                  chemstation_key=None,
-                                  ptype=PType.NUM),
-                    equ_time=Param(val=None,
-                                   chemstation_key=None,
-                                   ptype=PType.NUM)),
+                    organic_modifier=organic_modifier.percentage,
+                    flow=method.flow,
+                    maximum_run_time=method.stop_time,
+                    temperature=-1),
                 subsequent_rows=[
                     TimeTableEntry(
                         start_time=tte.time,
@@ -124,7 +138,7 @@ class MethodController(TableController):
         else:
             raise FileNotFoundError
 
-    def edit(self, updated_method: MethodTimetable):
+    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.
@@ -138,13 +152,9 @@ class MethodController(TableController):
         flow: Param = Param(val=updated_method.first_row.flow,
                             chemstation_key=RegisterFlag.FLOW,
                             ptype=PType.NUM)
-        temperature: Param = Param(val=updated_method.first_row.temperature,
-                                   chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
-                                                   RegisterFlag.COLUMN_OVEN_TEMP2],
-                                   ptype=PType.NUM)
 
         # Method settings required for all runs
-        self.delete_table(METHOD_TIMETABLE)
+        self.delete_table()
         self._update_param(initial_organic_modifier)
         self._update_param(flow)
         self._update_param(Param(val="Set",
@@ -159,18 +169,23 @@ class MethodController(TableController):
 
         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_table_rows(METHOD_TIMETABLE)
+        self.get_num_rows()
 
         self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
-        res = self._get_table_rows(METHOD_TIMETABLE)
-        while "ERROR" not in res:
+        res = self.get_num_rows()
+        while not res.is_err():
             self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
-            res = self._get_table_rows(METHOD_TIMETABLE)
+            res = self.get_num_rows()
 
         self.sleepy_send('NewTab RCPMP1Method[1], "Timetable"')
-        self._get_table_rows(METHOD_TIMETABLE)
+        self.get_num_rows()
 
         for i, row in enumerate(timetable_rows):
             if i == 0:
@@ -188,7 +203,7 @@ class MethodController(TableController):
                 self.send('Sleep 1')
             else:
                 self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
-                self._get_table_rows(METHOD_TIMETABLE)
+                self.get_num_rows()
 
                 self.sleepy_send(
                     f'SetTabText RCPMP1Method[1], "Timetable", Rows, "Function", "SolventComposition"')
@@ -200,7 +215,7 @@ class MethodController(TableController):
                 self.send("Sleep 1")
                 self.sleepy_send("DownloadRCMethod PMP1")
                 self.send("Sleep 1")
-                self._get_table_rows(METHOD_TIMETABLE)
+                self.get_num_rows()
 
     def _update_param(self, method_param: Param):
         """Change a method parameter, changes what is visibly seen in Chemstation GUI.
@@ -208,7 +223,7 @@ class MethodController(TableController):
 
         :param method_param: a parameter to update for currently loaded method.
         """
-        register = METHOD_TIMETABLE.register
+        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:
@@ -238,21 +253,22 @@ class MethodController(TableController):
         :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))
 
-        folder_name = f"{experiment_name}_{timestamp}.D"
-        self.data_files.append(os.path.join(self.data_dir, folder_name))
+        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) -> tuple[bool, Any]:
-        data_ready = self.data_ready()
-        if data_ready:
-            self.get_spectrum(self.data_files[-1])
-            return data_ready, self.spectra
-        else:
-            return False, None
+    def get_data(self) -> dict[str, AgilentHPLCChromatogram]:
+        self.get_spectrum(self.data_files[-1])
+        return self.spectra