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

pychemstation/control/comm.py

@@ -1,206 +0,0 @@
-"""
-Module to provide API for the communication with Agilent HPLC systems.
-
-HPLCController sends commands to Chemstation software via a command file.
-Answers are received via reply file. On the Chemstation side, a custom
-Macro monitors the command file, executes commands and writes to the reply file.
-Each command is given a number (cmd_no) to keep track of which commands have
-been processed.
-
-Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
-"""
-
-import os
-import time
-
-from result import Result, Ok, Err
-from ..utils.macro import *
-from ..utils.method_types import *
-
-
-class CommunicationController:
-    """
-    Class that communicates with Agilent using Macros
-    """
-
-    # maximum command number
-    MAX_CMD_NO = 255
-
-    def __init__(
-            self,
-            comm_dir: str,
-            cmd_file: str = "cmd",
-            reply_file: str = "reply",
-    ):
-        """
-        :param comm_dir:
-        :param cmd_file: Name of command file
-        :param reply_file: Name of reply file
-        """
-        if os.path.isdir(comm_dir):
-            self.cmd_file = os.path.join(comm_dir, cmd_file)
-            self.reply_file = os.path.join(comm_dir, reply_file)
-            self.cmd_no = 0
-        else:
-            raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
-        self._most_recent_hplc_status = None
-
-        # Create files for Chemstation to communicate with Python
-        open(self.cmd_file, "a").close()
-        open(self.reply_file, "a").close()
-
-        self.reset_cmd_counter()
-
-    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
-        """
-        self.send(Command.GET_STATUS_CMD)
-        time.sleep(1)
-
-        try:
-            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
-        except IndexError:
-            return HPLCErrorStatus.MALFORMED
-
-    def set_status(self):
-        """Updates current status of HPLC machine"""
-        self._most_recent_hplc_status = self.get_status()
-
-    def check_if_running(self) -> 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."""
-        self.set_status()
-        hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        time.sleep(30)
-        self.set_status()
-        hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        return hplc_avail and hplc_actually_avail
-
-    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
-        """Low-level execution primitive. Sends a command string to HPLC.
-
-        :param cmd: string to be sent to HPLC
-        :param cmd_no: Command number
-        :param num_attempts: Number of attempts to send the command before raising exception.
-        :raises IOError: Could not write to command file.
-        """
-        err = None
-        for _ in range(num_attempts):
-            time.sleep(1)
-            try:
-                with open(self.cmd_file, "w", encoding="utf8") as cmd_file:
-                    cmd_file.write(f"{cmd_no} {cmd}")
-            except IOError as e:
-                err = e
-                continue
-            else:
-                return
-        else:
-            raise IOError(f"Failed to send command #{cmd_no}: {cmd}.") from err
-
-    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: Potential ChemStation response
-        """
-        err = None
-        for _ in range(num_attempts):
-            time.sleep(1)
-
-            try:
-                with open(self.reply_file, "r", encoding="utf_16") as reply_file:
-                    response = reply_file.read()
-            except OSError as e:
-                err = e
-                continue
-
-            try:
-                first_line = response.splitlines()[0]
-                response_no = int(first_line.split()[0])
-            except IndexError as e:
-                err = e
-                continue
-
-            # check that response corresponds to sent command
-            if response_no == cmd_no:
-                return Ok(response)
-            else:
-                continue
-        else:
-            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")
-        self.send(cmd)
-        self.send("Sleep 0.1")
-
-    def send(self, cmd: Union[Command, str]):
-        """Sends a command to Chemstation.
-
-        :param cmd: Command to be sent to HPLC
-        """
-        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)
-        f = open("out.txt", "a")
-        f.write(cmd_to_send + "\n")
-        f.close()
-
-    def receive(self) -> Result[Response, str]:
-        """Returns messages received in reply file.
-
-        :return: ChemStation response 
-        """
-        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=self.MAX_CMD_NO + 1)
-        self._receive(cmd_no=self.MAX_CMD_NO + 1)
-        self.cmd_no = 0
-
-    def stop_macro(self):
-        """Stops Macro execution. Connection will be lost."""
-        self.send(Command.STOP_MACRO_CMD)

pychemstation/control/controllers/devices/column.py

@@ -1,12 +0,0 @@
-from ....control.controllers import CommunicationController
-from .device import DeviceController
-from ....utils.table_types import Table
-
-
-class ColumnController(DeviceController):
-
-    def __init__(self, controller: CommunicationController, table: Table):
-        super().__init__(controller, table)
-
-    def get_row(self, row: int):
-        pass

pychemstation/control/controllers/devices/pump.py

@@ -1,43 +0,0 @@
-from ....control.controllers import CommunicationController
-from .device import DeviceController
-from ....utils.pump_types import Pump
-from ....utils.table_types import Table
-
-
-class PumpController(DeviceController):
-
-    def __init__(self, controller: CommunicationController, table: Table):
-        super().__init__(controller, table)
-        self.A1 = Pump(in_use=True, solvent="A1")
-        self.B1 = Pump(in_use=True, solvent="B1")
-        self.A2 = Pump(in_use=False, solvent="A2")
-        self.B2 = Pump(in_use=False, solvent="B2")
-
-    def validate_pumps(self):
-        invalid_A_pump_usage = self.A1.in_use and self.A2.in_use
-        invalid_B_pump_usage = self.B1.in_use and self.B2.in_use
-        if invalid_A_pump_usage or invalid_B_pump_usage:
-            raise AttributeError
-
-    def switch_pump(self, num: int, pump: str):
-        if pump == "A":
-            if num == 1:
-                self.A1.in_use = True
-                self.A2.in_use = False
-            elif num == 2:
-                self.A1.in_use = False
-                self.A2.in_use = True
-        elif pump == "B":
-            if num == 1:
-                self.B1.in_use = True
-                self.B2.in_use = False
-            elif num == 2:
-                self.B1.in_use = False
-                self.B2.in_use = True
-        self.purge()
-
-    def purge(self):
-        pass
-
-    def get_row(self, row: int):
-        pass

pychemstation/control/controllers/method.py

@@ -1,338 +0,0 @@
-import os
-import time
-from typing import Optional, Union
-
-from xsdata.formats.dataclass.parsers import XmlParser
-
-from ...control.controllers.table_controller import TableController
-from ...control.controllers.comm import CommunicationController
-from ...generated import PumpMethod, DadMethod, SolventElement
-from ...utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
-from ...utils.macro import Command
-from ...utils.method_types import PType, TimeTableEntry, Param, MethodDetails, 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 check(self) -> str:
-        time.sleep(2)
-        self.send(Command.GET_METHOD_CMD)
-        time.sleep(2)
-        res = self.receive()
-        if res.is_ok():
-            return res.ok_value.string_response
-        return "ERROR"
-
-    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
-                )
-            ),
-        )
-
-    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=self.get_num(row, RegisterFlag.TIMETABLE_FLOW))
-
-    def get_timetable(self, rows: int):
-        uncoalesced_timetable_rows = [self.get_row(r + 1) for r in range(rows)]
-        timetable_rows = {}
-        for row in uncoalesced_timetable_rows:
-            time_key = str(row.start_time)
-            if time_key not in timetable_rows.keys():
-                timetable_rows[time_key] = TimeTableEntry(start_time=row.start_time,
-                                                          flow=row.flow,
-                                                          organic_modifer=row.organic_modifer)
-            else:
-                if row.flow:
-                    timetable_rows[time_key].flow = row.flow
-                if row.organic_modifer:
-                    timetable_rows[time_key].organic_modifer = row.organic_modifer
-        entries = list(timetable_rows.values())
-        entries.sort(key=lambda e: e.start_time)
-        return entries
-
-    def load(self) -> MethodDetails:
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            self.send(Command.GET_METHOD_CMD)
-            res = self.receive()
-            method_name = res.ok_value.string_response
-            timetable_rows = self.get_timetable(int(rows.ok_value.num_response))
-            params = self.get_method_params()
-            stop_time = self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table.register,
-                    register_flag=RegisterFlag.MAX_TIME))
-            post_time = self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table.register,
-                    register_flag=RegisterFlag.POST_TIME))
-            self.table_state = MethodDetails(
-                name=method_name,
-                timetable=timetable_rows,
-                stop_time=stop_time,
-                post_time=post_time,
-                params=params)
-            return self.table_state
-        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."
-        self.table_state = None
-
-    def load_from_disk(self, method_name: str) -> MethodDetails:
-        """
-        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
-
-            self.table_state = MethodDetails(
-                name=method_name,
-                params=HPLCMethodParams(organic_modifier=organic_modifier.percentage,
-                                        flow=method.flow),
-                stop_time=method.stop_time.stop_time_value,
-                post_time=method.post_time.post_time_value,
-                timetable=[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)
-            return self.table_state
-        else:
-            raise FileNotFoundError
-
-    def edit(self, updated_method: MethodDetails, 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.
-        :param save: if false only modifies the method, otherwise saves to disk
-        """
-        self.table_state = updated_method
-        initial_organic_modifier: Param = Param(val=updated_method.params.organic_modifier,
-                                                chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-                                                ptype=PType.NUM)
-        max_time: Param = Param(val=updated_method.stop_time,
-                                chemstation_key=RegisterFlag.MAX_TIME,
-                                ptype=PType.NUM)
-        post_time: Param = Param(val=updated_method.post_time,
-                                 chemstation_key=RegisterFlag.POST_TIME,
-                                 ptype=PType.NUM)  # TODO check postime works
-        flow: Param = Param(val=updated_method.params.flow,
-                            chemstation_key=RegisterFlag.FLOW,
-                            ptype=PType.NUM)
-
-        # Method settings required for all runs
-        self.update_method_params(flow, initial_organic_modifier, max_time, post_time)
-        self._update_method_timetable(updated_method.timetable)
-
-        if save:
-            self.send(Command.SAVE_METHOD_CMD.value.format(
-                commit_msg=f"saved method at {str(time.time())}"
-            ))
-
-    def update_method_params(self, flow, initial_organic_modifier, max_time, post_time):
-        self.delete_table()
-        self._update_param(initial_organic_modifier)
-        self._update_param(flow)
-        if self.table_state.stop_time:
-            self._update_param(Param(val="Set",
-                                     chemstation_key=RegisterFlag.STOPTIME_MODE,
-                                     ptype=PType.STR))
-            self._update_param(max_time)
-        else:
-            self._update_param(Param(val="Off",
-                                     chemstation_key=RegisterFlag.STOPTIME_MODE,
-                                     ptype=PType.STR))
-        if self.table_state.post_time:
-            self._update_param(Param(val="Set",
-                                     chemstation_key=RegisterFlag.POSTIME_MODE,
-                                     ptype=PType.STR))
-            self._update_param(post_time)
-        self.download()
-
-    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 download(self):
-        self.send('Sleep 1')
-        self.sleepy_send("DownloadRCMethod PMP1")
-        self.send('Sleep 1')
-
-    def edit_row(self, row: TimeTableEntry, first_row: bool = False):
-        if first_row:
-            self.add_row()
-            self.add_new_col_text(col_name=RegisterFlag.FUNCTION,
-                                  val=RegisterFlag.SOLVENT_COMPOSITION.value)
-            self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
-            self.add_new_col_num(col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
-                                 val=row.organic_modifer)
-            self.add_row()
-            self.get_num_rows()
-            self.edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
-            self.add_new_col_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
-            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
-            self.download()
-        else:
-            self.add_row()
-            self.get_num_rows()
-            self.edit_row_text(col_name=RegisterFlag.FUNCTION,
-                               val=RegisterFlag.SOLVENT_COMPOSITION.value)
-            self.edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
-            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
-                              val=row.organic_modifer)
-            self.download()
-
-            self.add_row()
-            self.get_num_rows()
-            self.edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
-            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
-            self.edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
-            self.download()
-
-    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
-        self.get_num_rows()
-
-        self.delete_table()
-        res = self.get_num_rows()
-        while not res.is_err():
-            self.delete_table()
-            res = self.get_num_rows()
-
-        self.new_table()
-        self.get_num_rows()
-
-        for i, row in enumerate(timetable_rows):
-            self.edit_row(row=row, first_row=i == 0)
-
-    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, stall_while_running: bool = True):
-        """
-        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
-        """
-        if not self.table_state:
-            self.table_state = self.load()
-
-        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))
-
-            if stall_while_running:
-                run_completed = self.check_hplc_done_running(method=self.table_state)
-                if run_completed.is_ok():
-                    self.data_files[-1] = run_completed.value
-                else:
-                    raise RuntimeError("Run error has occurred.")
-            else:
-                self.data_files[-1].dir = self.fuzzy_match_most_recent_folder(folder_name).ok_value
-
-    def retrieve_recent_data_files(self) -> str:
-        return self.data_files[-1]
-
-    def get_data(self, custom_path: Optional[str] = None) -> AgilentChannelChromatogramData:
-        if not custom_path:
-            self.get_spectrum(self.data_files[-1])
-        else:
-            self.get_spectrum(custom_path)
-        return AgilentChannelChromatogramData(**self.spectra)