pychemstation 0.5.4__py3-none-any.whl → 0.5.6.dev1__py3-none-any.whl

pychemstation/control/__init__.py

@@ -1,5 +1,4 @@
 """
 .. include:: README.md
 """
-from .comm import CommunicationController
 from .hplc import HPLCController

pychemstation/control/controllers/__init__.py

@@ -0,0 +1,4 @@
+from .method import MethodController
+from .sequence import SequenceController
+from .table_controller import TableController
+from .comm import CommunicationController

pychemstation/control/controllers/comm.py

@@ -0,0 +1,206 @@
+"""
+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 *
+
+
+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/method.py

@@ -0,0 +1,284 @@
+import os
+import time
+from typing import Optional
+
+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, 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))]
+            self.table_state = MethodTimetable(
+                first_row=self.get_method_params(),
+                subsequent_rows=timetable_rows)
+            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) -> 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
+
+            self.table_state = 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
+            )
+            return self.table_state
+        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, 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
+        """
+        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)

pychemstation/control/controllers/sequence.py

@@ -0,0 +1,213 @@
+from typing import  Optional
+
+
+import os
+import time
+
+from ...control.controllers.table_controller import TableController
+from ...control.controllers.comm import CommunicationController
+from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogramData
+from ...utils.macro import Command
+from ...utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
+from ...utils.table_types import TableOperation, RegisterFlag, Table
+
+
+class SequenceController(TableController):
+    """
+    Class containing sequence related logic
+    """
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table, method_dir: str):
+        self.method_dir = method_dir
+        super().__init__(controller, src, data_dir, table)
+
+    def load(self) -> SequenceTable:
+        rows = self.get_num_rows()
+        self.send(Command.GET_SEQUENCE_CMD)
+        seq_name = self.receive()
+
+        if rows.is_ok() and seq_name.is_ok():
+            self.table_state = SequenceTable(
+                name=seq_name.ok_value.string_response.partition(".S")[0],
+                rows=[self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))])
+            return self.table_state
+        raise RuntimeError(rows.err_value)
+
+    def get_row(self, row: int) -> SequenceEntry:
+        sample_name = self.get_text(row, RegisterFlag.NAME)
+        vial_location = int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
+        method = self.get_text(row, RegisterFlag.METHOD)
+        num_inj = int(self.get_num(row, RegisterFlag.NUM_INJ))
+        inj_vol = int(self.get_text(row, RegisterFlag.INJ_VOL))
+        inj_source = InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
+        sample_type = SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
+        return SequenceEntry(sample_name=sample_name,
+                             vial_location=vial_location,
+                             method=None if len(method) == 0 else method,
+                             num_inj=num_inj,
+                             inj_vol=inj_vol,
+                             inj_source=inj_source,
+                             sample_type=sample_type, )
+
+    def switch(self, seq_name: str):
+        """
+        Switch to the specified sequence. The sequence name does not need the '.S' extension.
+
+        :param seq_name: The name of the sequence file
+        """
+        self.send(f'_SeqFile$ = "{seq_name}.S"')
+        self.send(f'_SeqPath$ = "{self.src}"')
+        self.send(Command.SWITCH_SEQUENCE_CMD)
+        time.sleep(2)
+        self.send(Command.GET_SEQUENCE_CMD)
+        time.sleep(2)
+        parsed_response = self.receive().value.string_response
+
+        assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
+        self.table_state = None
+
+    def edit(self, sequence_table: SequenceTable):
+        """
+        Updates the currently loaded sequence table with the provided table. This method will delete the existing sequence table and remake it.
+        If you would only like to edit a single row of a sequence table, use `edit_sequence_table_row` instead.
+
+        :param sequence_table:
+        """
+
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            existing_row_num = rows.value.num_response
+            wanted_row_num = len(sequence_table.rows)
+            while existing_row_num != wanted_row_num:
+                if wanted_row_num > existing_row_num:
+                    self.add_row()
+                elif wanted_row_num < existing_row_num:
+                    self.delete_row(int(existing_row_num))
+                self.send(Command.SAVE_SEQUENCE_CMD)
+                existing_row_num = self.get_num_rows().ok_value.num_response
+            self.send(Command.SWITCH_SEQUENCE_CMD)
+
+            for i, row in enumerate(sequence_table.rows):
+                self.edit_row(row=row, row_num=i + 1)
+                self.sleep(1)
+            self.send(Command.SAVE_SEQUENCE_CMD)
+            self.send(Command.SWITCH_SEQUENCE_CMD)
+
+    def edit_row(self, row: SequenceEntry, row_num: int):
+        """
+        Edits a row in the sequence table. If a row does NOT exist, a new one will be created.
+
+        :param row: sequence row entry with updated information
+        :param row_num: the row to edit, based on 1-based indexing
+        """
+        num_rows = self.get_num_rows()
+        if num_rows.is_ok():
+            while num_rows.ok_value.num_response < row_num:
+                self.add_row()
+                self.send(Command.SAVE_SEQUENCE_CMD)
+                num_rows = self.get_num_rows()
+
+        table_register = self.table.register
+        table_name = self.table.name
+
+        if row.vial_location:
+            loc = row.vial_location
+            if isinstance(row.vial_location, InjectionSource):
+                loc = row.vial_location.value
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
+                                                                      table_name=table_name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.VIAL_LOCATION,
+                                                                      val=loc))
+        if row.method:
+            possible_path = os.path.join(self.method_dir, row.method) + ".M\\"
+            method = row.method
+            if os.path.exists(possible_path):
+                method = os.path.join(self.method_dir, row.method)
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=table_name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.METHOD,
+                                                                       val=method))
+
+        if row.num_inj:
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
+                                                                      table_name=table_name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.NUM_INJ,
+                                                                      val=row.num_inj))
+
+        if row.inj_vol:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=table_name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.INJ_VOL,
+                                                                       val=row.inj_vol))
+
+        if row.inj_source:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=table_name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.INJ_SOR,
+                                                                       val=row.inj_source.value))
+
+        if row.sample_name:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=table_name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.NAME,
+                                                                       val=row.sample_name))
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
+                                                                       table_name=table_name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.DATA_FILE,
+                                                                       val=row.sample_name))
+        if row.sample_type:
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
+                                                                      table_name=table_name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.SAMPLE_TYPE,
+                                                                      val=row.sample_type.value))
+
+        self.send(Command.SAVE_SEQUENCE_CMD)
+
+    def run(self, stall_while_running: bool = True):
+        """
+        Starts the currently loaded sequence, storing data
+        under the <data_dir>/<sequence table name> folder.
+        Device must be ready.
+        """
+        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
+        seq_table = self.load()
+        self.send(Command.RUN_SEQUENCE_CMD.value)
+
+        if self.check_hplc_is_running():
+            folder_name = f"{seq_table.name} {timestamp}"
+            self.data_files.append(SequenceDataFiles(dir=folder_name,
+                                                     sequence_name=seq_table.name))
+
+            if stall_while_running:
+                run_completed = self.check_hplc_done_running(sequence=seq_table)
+                if run_completed.is_ok():
+                    self.data_files[-1].dir = 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):
+        sequence_data_files: SequenceDataFiles = self.data_files[-1]
+        return sequence_data_files.dir
+
+    def get_data(self, custom_path:Optional[str] = None ) -> list[AgilentChannelChromatogramData]:
+        parent_dir = self.data_files[-1].dir if not custom_path else custom_path
+        subdirs = [x[0] for x in os.walk(self.data_dir)]
+        potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))
+        self.data_files[-1].child_dirs = [f for f in potential_folders if
+                                          parent_dir in f and ".M" not in f and ".D" in f]
+
+        spectra: list[AgilentChannelChromatogramData] = []
+        for row in self.data_files[-1].child_dirs:
+            self.get_spectrum(row)
+            spectra.append(AgilentChannelChromatogramData(**self.spectra))
+        return spectra

pychemstation/control/controllers/table_controller.py

@@ -0,0 +1,208 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+Authors: Lucy Hao
+"""
+
+import abc
+import os
+from typing import Union, Optional
+
+import polling
+from result import Result, Ok, Err
+
+from ...control.controllers.comm import CommunicationController
+from ...utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
+from ...utils.macro import Command, HPLCRunningStatus, Response
+from ...utils.method_types import MethodTimetable
+from ...utils.sequence_types import SequenceDataFiles, SequenceTable
+from ...utils.table_types import Table, TableOperation, RegisterFlag
+
+
+class TableController(abc.ABC):
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
+        self.controller = controller
+        self.table = table
+        self.table_state : Optional[TableController] = None
+
+        if os.path.isdir(src):
+            self.src: str = src
+        else:
+            raise FileNotFoundError(f"dir: {src} not found.")
+
+        if os.path.isdir(data_dir):
+            self.data_dir: str = data_dir
+        else:
+            raise FileNotFoundError(f"dir: {data_dir} not found.")
+
+        self.spectra: dict[str, AgilentHPLCChromatogram] = {
+            "A": AgilentHPLCChromatogram(self.data_dir),
+            "B": AgilentHPLCChromatogram(self.data_dir),
+            "C": AgilentHPLCChromatogram(self.data_dir),
+            "D": AgilentHPLCChromatogram(self.data_dir),
+        }
+
+        self.data_files: Union[list[SequenceDataFiles], list[str]] = []
+
+    def receive(self) -> Result[Response, str]:
+        for _ in range(10):
+            try:
+                return self.controller.receive()
+            except IndexError:
+                continue
+        return Err("Could not parse response")
+
+    def send(self, cmd: Union[Command, str]):
+        self.controller.send(cmd)
+
+    def sleepy_send(self, cmd: Union[Command, str]):
+        self.controller.sleepy_send(cmd)
+
+    def sleep(self, seconds: int):
+        """
+        Tells the HPLC to wait for a specified number of seconds.
+
+        :param seconds: number of seconds to wait
+        """
+        self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
+
+    def get_num(self, row: int, col_name: RegisterFlag) -> float:
+        return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table.register,
+                                                                                   table_name=self.table.name,
+                                                                                   row=row,
+                                                                                   col_name=col_name.value))
+
+    def get_text(self, row: int, col_name: RegisterFlag) -> str:
+        return self.controller.get_text_val(TableOperation.GET_ROW_TEXT.value.format(register=self.table.register,
+                                                                                     table_name=self.table.name,
+                                                                                     row=row,
+                                                                                     col_name=col_name.value))
+
+    @abc.abstractmethod
+    def get_row(self, row: int):
+        pass
+
+    def delete_row(self, row: int):
+        self.sleepy_send(TableOperation.DELETE_ROW.value.format(register=self.table.register,
+                                                                table_name=self.table.name,
+                                                                row=row))
+
+    def add_row(self):
+        """
+        Adds a row to the provided table for currently loaded method or sequence.
+        Import either the SEQUENCE_TABLE or METHOD_TIMETABLE from hein_analytical_control.constants.
+        You can also provide your own table.
+
+        :param table: the table to add a new row to
+        """
+        self.sleepy_send(TableOperation.NEW_ROW.value.format(register=self.table.register,
+                                                             table_name=self.table.name))
+
+    def delete_table(self):
+        """
+        Deletes the table for the current loaded method or sequence.
+        Import either the SEQUENCE_TABLE or METHOD_TIMETABLE from hein_analytical_control.constants.
+        You can also provide your own table.
+
+        :param table: the table to delete
+        """
+        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=self.table.register,
+                                                                  table_name=self.table.name))
+
+    def new_table(self):
+        """
+        Creates the table for the currently loaded method or sequence. Import either the SEQUENCE_TABLE or
+        METHOD_TIMETABLE from hein_analytical_control.constants. You can also provide your own table.
+
+        :param table: the table to create
+        """
+        self.send(TableOperation.CREATE_TABLE.value.format(register=self.table.register,
+                                                           table_name=self.table.name))
+
+    def get_num_rows(self) -> Result[Response, str]:
+        self.send(TableOperation.GET_NUM_ROWS.value.format(register=self.table.register,
+                                                           table_name=self.table.name,
+                                                           col_name=RegisterFlag.NUM_ROWS))
+        self.send(Command.GET_ROWS_CMD.value.format(register=self.table.register,
+                                                    table_name=self.table.name,
+                                                    col_name=RegisterFlag.NUM_ROWS))
+        res = self.controller.receive()
+
+        if res.is_ok():
+            self.send("Sleep 0.1")
+            self.send('Print Rows')
+            return res
+        else:
+            return Err("No rows could be read.")
+
+    def check_hplc_is_running(self) -> bool:
+        started_running = polling.poll(
+            lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
+            step=5,
+            max_tries=100)
+        return started_running
+
+    def check_hplc_done_running(self,
+                                method: Optional[MethodTimetable] = None,
+                                sequence: Optional[SequenceTable] = None) -> Result[str, str]:
+        """
+        Checks if ChemStation has finished running and can read data back
+
+        :param method: if you are running a method and want to read back data, the timeout period will be adjusted to be longer than the method's runtime
+        :return: Return True if data can be read back, else False.
+        """
+        timeout = 10 * 60
+        if method:
+            timeout = ((method.first_row.maximum_run_time + 5) * 60)
+        if sequence:
+            timeout *= len(sequence.rows)
+
+        most_recent_folder = self.retrieve_recent_data_files()
+        finished_run = polling.poll(
+            lambda: self.controller.check_if_running(),
+            timeout=timeout,
+            step=18)
+
+        check_folder = self.fuzzy_match_most_recent_folder(most_recent_folder)
+        if check_folder.is_ok() and finished_run:
+            return check_folder
+        elif check_folder.is_ok():
+            finished_run = polling.poll(
+                lambda: self.controller.check_if_running(),
+                timeout=timeout,
+                step=12)
+            if finished_run:
+                return check_folder
+        else:
+            return Err("Run did not complete as expected")
+
+    def fuzzy_match_most_recent_folder(self, most_recent_folder) -> Result[str, str]:
+        if os.path.exists(most_recent_folder):
+            return Ok(most_recent_folder)
+
+        subdirs = [x[0] for x in os.walk(self.data_dir)]
+        potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
+        parent_dirs = []
+        for folder in potential_folders:
+            path = os.path.normpath(folder)
+            split_folder = path.split(os.sep)
+            if most_recent_folder in split_folder[-1]:
+                parent_dirs.append(folder)
+        parent_dir = sorted(parent_dirs, reverse=True)[0]
+        return Ok(parent_dir)
+
+    @abc.abstractmethod
+    def retrieve_recent_data_files(self):
+        pass
+
+    @abc.abstractmethod
+    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        pass
+
+    def get_spectrum(self, data_file: str):
+        """
+        Load chromatogram for any channel in spectra dictionary.
+        """
+        for channel, spec in self.spectra.items():
+            spec.load_spectrum(data_path=data_file, channel=channel)

pychemstation/control/hplc.py

@@ -6,9 +6,8 @@ Authors: Lucy Hao
 
 from typing import Union, Optional
 
-from ..control import CommunicationController
-from ..control.table import MethodController, SequenceController
-from ..utils.chromatogram import AgilentHPLCChromatogram
+from ..control.controllers import MethodController, SequenceController, CommunicationController
+from ..utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
 from ..utils.method_types import MethodTimetable
 from ..utils.sequence_types import SequenceTable, SequenceEntry
@@ -65,8 +64,8 @@ class HPLCController:
         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.
+        :raises  IndexError: Response did not have expected format. Try again.
+        :raises  AssertionError: The desired method is not selected. Try again.
         """
         self.method_controller.switch(method_name)
 
@@ -127,13 +126,13 @@ class HPLCController:
         """
         self.sequence_controller.edit_row(row, num)
 
-    def get_last_run_method_data(self) -> dict[str, AgilentHPLCChromatogram]:
+    def get_last_run_method_data(self) -> AgilentChannelChromatogramData:
         """
         Returns the last run method data.
         """
         return self.method_controller.get_data()
 
-    def get_last_run_sequence_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
+    def get_last_run_sequence_data(self) -> list[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
         """

pychemstation/control/table/table_controller.py

@@ -12,8 +12,8 @@ from typing import Union, Optional
 import polling
 from result import Result, Ok, Err
 
-from ...control import CommunicationController
-from ...utils.chromatogram import AgilentHPLCChromatogram
+from ...control.controllers.comm import CommunicationController
+from ...utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 from ...utils.macro import Command, HPLCRunningStatus, Response
 from ...utils.method_types import MethodTimetable
 from ...utils.sequence_types import SequenceDataFiles, SequenceTable
@@ -139,8 +139,8 @@ class TableController(abc.ABC):
     def check_hplc_is_running(self) -> bool:
         started_running = polling.poll(
             lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
-            step=30,
-            max_tries=10)
+            step=5,
+            max_tries=100)
         return started_running
 
     def check_hplc_done_running(self,
@@ -162,32 +162,35 @@ class TableController(abc.ABC):
         finished_run = polling.poll(
             lambda: self.controller.check_if_running(),
             timeout=timeout,
-            step=60
+            step=12
         )
 
         if finished_run:
             if os.path.exists(most_recent_folder):
                 return Ok(most_recent_folder)
             else:
-                subdirs = [x[0] for x in os.walk(self.data_dir)]
-                potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
-                parent_dirs = []
-                for folder in potential_folders:
-                    path = os.path.normpath(folder)
-                    split_folder = path.split(os.sep)
-                    if most_recent_folder in split_folder[-1]:
-                        parent_dirs.append(folder)
-                parent_dir = sorted(parent_dirs, reverse=True)[0]
-                return Ok(parent_dir)
+                return self.fuzzy_match_most_recent_folder(most_recent_folder)
         else:
             return Err("Run did not complete as expected")
 
+    def fuzzy_match_most_recent_folder(self, most_recent_folder) -> Result[str, str]:
+        subdirs = [x[0] for x in os.walk(self.data_dir)]
+        potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
+        parent_dirs = []
+        for folder in potential_folders:
+            path = os.path.normpath(folder)
+            split_folder = path.split(os.sep)
+            if most_recent_folder in split_folder[-1]:
+                parent_dirs.append(folder)
+        parent_dir = sorted(parent_dirs, reverse=True)[0]
+        return Ok(parent_dir)
+
     @abc.abstractmethod
     def retrieve_recent_data_files(self):
         pass
 
     @abc.abstractmethod
-    def get_data(self) -> tuple[bool,]:
+    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
         pass
 
     def get_spectrum(self, data_file: str):

pychemstation/utils/chromatogram.py

@@ -1,17 +1,14 @@
 """Module for HPLC chromatogram data loading and manipulating"""
 
 import os
-import logging
 import time
+from dataclasses import dataclass
 
 import numpy as np
 
 from .parsing import CHFile
 from ..analysis import AbstractSpectrum
 
-# Chemstation data path
-DATA_DIR = r"C:\Chem32\1\Data"
-
 # standard filenames for spectral data
 CHANNELS = {"A": "01", "B": "02", "C": "03", "D": "04"}
 
@@ -19,7 +16,7 @@ ACQUISITION_PARAMETERS = "acq.txt"
 
 # format used in acquisition parameters
 TIME_FORMAT = "%Y-%m-%d %H-%M-%S"
-SEQUENCE_TIME_FORMAT = "%Y-%m-%d %H"
+SEQUENCE_TIME_FORMAT = "%Y-%m-%d %H-%M"
 
 
 class AgilentHPLCChromatogram(AbstractSpectrum):
@@ -105,26 +102,10 @@ class AgilentHPLCChromatogram(AbstractSpectrum):
             np.savez_compressed(npz_file, times=data.times, values=data.values)
             return np.array(data.times), np.array(data.values)
 
-    def extract_peakarea(self, experiment_dir: str):
-        """
-        Reads processed data from Chemstation report files.
 
-        Args:
-            experiment_dir: .D directory with the report files
-        """
-        # filename = os.path.join(experiment_dir, f"REPORT{CHANNELS[channel]}.csv")
-        # TODO parse file properly
-        # data = np.genfromtxt(filename, delimiter=',')
-        # return data
-        pass
-
-    def default_processing(self):
-        """
-        Processes the chromatogram in place.
-        """
-        # trim first 5 min and last 3 min of run
-        self.trim(5, 25)
-        # parameters found to work best for chromatogram data
-        self.correct_baseline(lmbd=1e5, p=0.0001, n_iter=10)
-        # get all peaks in processed chromatogram
-        self.find_peaks()
+@dataclass
+class AgilentChannelChromatogramData:
+    A: AgilentHPLCChromatogram
+    B: AgilentHPLCChromatogram
+    C: AgilentHPLCChromatogram
+    D: AgilentHPLCChromatogram

{pychemstation-0.5.4.dist-info → pychemstation-0.5.6.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.4
+Version: 0.5.6.dev1
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao
@@ -41,7 +41,7 @@ pip install pychemstation
    where you will put your
    MACRO file(s).
 3. Download the [
-   `hplc_talk.mac`](https://github.com/croningp/analyticallabware/blob/master/AnalyticalLabware/devices/Agilent/hplctalk.mac).
+   `hplc_talk.mac`](https://gitlab.com/heingroup/device-api/pychemstation/-/blob/main/tests/hplc_talk.mac).
     - On line 69, change the path name up to `\cmd` and `\reply`. For instance, you should have:
       `MonitorFile "[my path]\cmd", "[my path]\reply"`
     - and then add this file to the folder from the previous step.
@@ -78,13 +78,12 @@ hplc_controller = HPLCController(data_dir=DATA_DIR,
 hplc_controller.preprun()
 hplc_controller.switch_method(method_name=DEFAULT_METHOD)
 hplc_controller.run_method(experiment_name="Run 10")
-data_status_valid, chrom = hplc_controller.get_last_run_method_data()
+chrom = hplc_controller.get_last_run_method_data()
 
-if data_status_valid:
-    # afterwards, save, analyze or plot the data!
-    values = {"x": chrom.x, "y": chrom.y}
-    chromatogram_data = pd.DataFrame.from_dict(values)
-    chromatogram_data.to_csv("Run 10.csv", index=False) 
+# afterwards, save, analyze or plot the data!
+values = {"x": chrom.A.x, "y": chrom.A.y}
+chromatogram_data = pd.DataFrame.from_dict(values)
+chromatogram_data.to_csv("Run 10.csv", index=False) 
 ```
 
 ## Adding your own MACROs
@@ -103,3 +102,6 @@ Lucy Hao
 
 - Adapted from [**AnalyticalLabware**](https://github.com/croningp/analyticallabware), created by members in the Cronin
   Group. Copyright © Cronin Group, used under the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
+- Adapted from the [MACROS](https://github.com/Bourne-Group/HPLCMethodOptimisationGUI)
+  used in [**Operator-free HPLC automated method development guided by Bayesian optimization**](https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00062e),
+  created by members in the Bourne Group.  Copyright © Bourne Group, used under the [MIT](https://opensource.org/license/mit) license.

{pychemstation-0.5.4.dist-info → pychemstation-0.5.6.dev1.dist-info}/RECORD

@@ -3,18 +3,23 @@ pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt42
 pychemstation/analysis/base_spectrum.py,sha256=FBvwzLtF9mdqW7f8ETY9G4cpfJ-SzbiSkZq9EtXcSXo,17045
 pychemstation/analysis/spec_utils.py,sha256=8NZMV0dtfxZLARjWzM5ks0tgEYQv_SKUiZzba2IoKgw,10505
 pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
-pychemstation/control/__init__.py,sha256=aH9cPf-ljrVeVhN0K3cyEcAavmPXCjhhOnpLNf8qLqE,106
+pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
 pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
-pychemstation/control/hplc.py,sha256=huEUl90Ylvzvy2TXWUjhyDU4PazrK7Z51M8spquHvVg,6719
+pychemstation/control/hplc.py,sha256=L1-cBQ7-thuITx1Mqq3lYXo832nEQtRJEX7nlLvRYrg,6732
+pychemstation/control/controllers/__init__.py,sha256=di3ytLIK-35XC_THw4IjNaOtCUTe7GuEOFb-obmREw4,166
+pychemstation/control/controllers/comm.py,sha256=iltKMNfdp_8INA5Vss9asI2LxJam_Ro3YWBHBQFr4t0,7353
+pychemstation/control/controllers/method.py,sha256=GNGvGUF9LUCcHAe37SIdnQQ_RzwgnU2ba1oWLXnOp8w,12816
+pychemstation/control/controllers/sequence.py,sha256=f4ZhzkM2hY8xk8dUyiCpmZ5fwU4ev2-CNSbyFeFVe_w,10963
+pychemstation/control/controllers/table_controller.py,sha256=DnusCG5ySR8gA-oe3K_EJfAPlYhmW33epiCi4YVUKJg,8648
 pychemstation/control/table/__init__.py,sha256=RgMN4uIWHdNUHpGRBWdzmzAbk7XEKl6Y-qtqWCxzSZU,124
 pychemstation/control/table/method.py,sha256=THVoGomSXff_CTU3eAYme0BYwkPzab5UgZKsiZ29QSk,12196
 pychemstation/control/table/sequence.py,sha256=Eri52AnbE3BGthfrRSvYKYciquUzvHKo0lYUTySYYE8,10542
-pychemstation/control/table/table_controller.py,sha256=F5lv1DlPkEDcFmtwVT-E9Kq075jnWIN-iZIM3_mTt5E,8115
+pychemstation/control/table/table_controller.py,sha256=HVNYUXqtyFTAvb67fa3RO5RHgmBTFMsYRHKpiXdYcfs,8313
 pychemstation/generated/__init__.py,sha256=GAoZFAYbPVEJDkcOw3e1rgOqd7TCW0HyKNPM8OMehMg,1005
 pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCsHRFQ0rmM,8402
 pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/utils/chromatogram.py,sha256=35nvEh6prVsWO6lMHYgGuidUOFHv954_7MNf0Az3Fz4,3759
+pychemstation/utils/chromatogram.py,sha256=RiKWQG2FIlDzddhgABV-WIJg_BsCTL_wPfyYGikyxoM,3097
 pychemstation/utils/macro.py,sha256=BAIcE_dppNffwrSqGq8gh0ccE9YAJfQFQZHXJgA1WtA,2586
 pychemstation/utils/method_types.py,sha256=YngbyHg96JSFnvhm5Zd7wJvLTQPPQsLbvbyz3HlGLYY,862
 pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
@@ -23,12 +28,12 @@ pychemstation/utils/table_types.py,sha256=cN51Ry2pammDdk85cabVH3qkchjKKIzZfAH87P
 pychemstation/utils/tray_types.py,sha256=UUDED-IAf-8FmPVZezuWSiIQE_HgiZQMV2sTqu4oZw8,177
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/constants.py,sha256=lLwT_QaVriivL5llkul6RxXxPriwUp1E-Y3G9fejvbo,2092
-tests/test_comb.py,sha256=faF4764oJEZ2vhG9-zLmQxjATseipRKXrStehuDCXOI,5638
+tests/test_comb.py,sha256=CF6nSxUMBJeUjA-IfgPcBGV5oIG4aH1-RA26oIATa-s,5640
 tests/test_comm.py,sha256=1ZZd0UrIBOKe91wzA-XI-gSRgXmId9mLWYSMeche82Y,2973
 tests/test_method.py,sha256=uCPpZVYKPz1CNWwhmBo_8TH0ku2V0ZpDZJj3f8iINB4,2440
 tests/test_sequence.py,sha256=yIQGhUTehtHz6D1ai5W6AlP0zes2icF0VdQ0IGJ2CbQ,4901
-pychemstation-0.5.4.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.4.dist-info/METADATA,sha256=TN5NWM9_QmES6TmIm_pXGvQxlNTQsHJDiP1wd1dRktA,3992
-pychemstation-0.5.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.4.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.4.dist-info/RECORD,,
+pychemstation-0.5.6.dev1.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.6.dev1.dist-info/METADATA,sha256=7Pj5MObTqRmX3B19nhA70BzBRyHSA7bDku7O1-D89lE,4312
+pychemstation-0.5.6.dev1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.6.dev1.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.6.dev1.dist-info/RECORD,,

tests/test_comb.py

@@ -28,14 +28,14 @@ class TestCombinations(unittest.TestCase):
                 first_row=HPLCMethodParams(
                     organic_modifier=5,
                     flow=0.65,
-                    maximum_run_time=2),
+                    maximum_run_time=1),
                 subsequent_rows=[
                     TimeTableEntry(
                         start_time=0.10,
                         organic_modifer=5,
                         flow=0.34),
                     TimeTableEntry(
-                        start_time=1,
+                        start_time=0.5,
                         organic_modifer=98,
                         flow=0.55)])
             self.hplc_controller.edit_method(rand_method, save=True)