pychemstation 0.5.12__py3-none-any.whl → 0.5.13__py3-none-any.whl

pychemstation/control/controllers/__init__.py

@@ -1,4 +1,9 @@
-from .method import MethodController
-from .sequence import SequenceController
-from .table_controller import TableController
+"""
+.. include:: README.md
+"""
+
 from .comm import CommunicationController
+from .devices.pump import PumpController
+from .devices.column import ColumnController
+from .tables.method import MethodController
+from .tables.sequence import SequenceController

pychemstation/control/controllers/devices/column.py

@@ -0,0 +1,12 @@
+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/device.py

@@ -0,0 +1,23 @@
+import abc
+from typing import Union
+
+from ....control.controllers import CommunicationController
+from ....control.controllers.tables.table import TableController
+from ....utils.chromatogram import AgilentChannelChromatogramData
+from ....utils.table_types import Table
+
+
+class DeviceController(TableController, abc.ABC):
+
+    def __init__(self, controller: CommunicationController, table: Table):
+        super().__init__(controller, None, None, table)
+
+    @abc.abstractmethod
+    def get_row(self, row: int):
+        pass
+
+    def retrieve_recent_data_files(self):
+        raise NotImplementedError
+
+    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        raise NotImplementedError

pychemstation/control/controllers/devices/injector.py

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

pychemstation/control/controllers/devices/pump.py

@@ -0,0 +1,43 @@
+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/tables/method.py

@@ -0,0 +1,351 @@
+import os
+import time
+
+from xsdata.formats.dataclass.parsers import XmlParser
+
+from .table import TableController
+from ....control.controllers import CommunicationController
+from ....generated import PumpMethod, DadMethod, SolventElement
+from ....utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
+from ....utils.macro import *
+from ....utils.method_types import *
+from ....utils.table_types import *
+
+
+class MethodController(TableController):
+    """
+    Class containing method related logic
+    """
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table, offline: bool):
+        super().__init__(controller, src, data_dir, table, offline=offline)
+
+    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:
+        flow = None
+        om = None
+
+        try:
+            flow = self.get_num(row, RegisterFlag.TIMETABLE_FLOW)
+        except RuntimeError:
+            pass
+        try:
+            om = self.get_num(row, RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION)
+        except RuntimeError:
+            pass
+
+        return TimeTableEntry(start_time=self.get_num(row, RegisterFlag.TIME),
+                              organic_modifer=om,
+                              flow=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)
+        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)
+        else:
+            self._update_param(Param(val="Off", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR))
+        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:
+            if row.organic_modifer:
+                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)
+            if row.flow:
+                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:
+            if row.organic_modifer:
+                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()
+            if row.flow:
+                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()
+
+        folder_name = ""
+        hplc_is_running = False
+        tries = 0
+        while tries < 10 and not hplc_is_running:
+            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"
+            hplc_is_running = self.check_hplc_is_running()
+            tries += 1
+
+        if not hplc_is_running:
+            raise RuntimeError("Method failed to start.")
+
+        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.ok_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,
+                 read_uv: bool = False) -> AgilentChannelChromatogramData:
+        if not custom_path:
+            self.get_spectrum(self.data_files[-1], read_uv)
+        else:
+            self.get_spectrum(custom_path, read_uv)
+        return AgilentChannelChromatogramData(**self.spectra) if not read_uv else self.uv

pychemstation/control/controllers/tables/ms.py

@@ -0,0 +1,21 @@
+from typing import Union
+
+from ....control.controllers import CommunicationController
+from ....control.controllers.tables.table import TableController
+from ....utils.chromatogram import AgilentChannelChromatogramData
+from ....utils.table_types import Table
+
+
+class MassSpecController(TableController):
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
+        super().__init__(controller, src, data_dir, table)
+
+    def get_row(self, row: int):
+        pass
+
+    def retrieve_recent_data_files(self):
+        pass
+
+    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        pass

pychemstation/control/controllers/tables/sequence.py

@@ -0,0 +1,200 @@
+import os
+import time
+from typing import Optional, Union
+
+from .table import TableController, ChromData
+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 RegisterFlag, Table
+from ....utils.tray_types import TenVialColumn, FiftyFourVialPlate
+
+
+class SequenceController(TableController):
+    """
+    Class containing sequence related logic
+    """
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table, method_dir: str,
+                 offline: bool):
+        self.method_dir = method_dir
+        super().__init__(controller, src, data_dir, table, offline=offline)
+
+    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 check(self) -> str:
+        time.sleep(2)
+        self.send(Command.GET_SEQUENCE_CMD)
+        time.sleep(2)
+        res = self.receive()
+        if res.is_ok():
+            return res.ok_value.string_response
+        return "ERROR"
+
+    def switch(self, seq_name: str):
+        """
+        Switch to the specified sequence. The sequence name does not need the '.S' extension.
+
+        :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:
+        """
+        self.table_state = 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()
+
+        if row.vial_location:
+            loc = row.vial_location
+            if isinstance(loc, TenVialColumn):
+                loc = row.vial_location.value
+            elif isinstance(loc, FiftyFourVialPlate):
+                loc = row.vial_location.value()
+            self.edit_row_num(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.edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
+
+        if row.num_inj:
+            self.edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=row.num_inj)
+
+        if row.inj_vol:
+            self.edit_row_text(row=row_num, col_name=RegisterFlag.INJ_VOL, val=row.inj_vol)
+
+        if row.inj_source:
+            self.edit_row_text(row=row_num, col_name=RegisterFlag.INJ_SOR, val=row.inj_source.value)
+
+        if row.sample_name:
+            self.edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=row.sample_name)
+            if row.data_file:
+                self.edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.data_file)
+            else:
+                self.edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.sample_name)
+
+        if row.sample_type:
+            self.edit_row_num(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.
+        """
+        if not self.table_state:
+            self.table_state = self.load()
+
+        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
+        self.send(Command.RUN_SEQUENCE_CMD.value)
+
+        if self.check_hplc_is_running():
+            folder_name = f"{self.table_state.name} {timestamp}"
+            self.data_files.append(SequenceDataFiles(dir=folder_name,
+                                                     sequence_name=self.table_state.name))
+
+            if stall_while_running:
+                run_completed = self.check_hplc_done_running(sequence=self.table_state)
+                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) -> str:
+        sequence_data_files: SequenceDataFiles = self.data_files[-1]
+        return sequence_data_files.dir
+
+    def get_data(self, custom_path: Optional[str] = None,
+                 read_uv: bool = False) -> 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[Union[AgilentChannelChromatogramData, ChromData]] = []
+        all_w_spectra: list[Union[AgilentChannelChromatogramData, ChromData]] = []
+        for row in self.data_files[-1].child_dirs:
+            self.get_spectrum(row, read_uv)
+            spectra.append(AgilentChannelChromatogramData(**self.spectra))
+            all_w_spectra.append(self.uv)
+
+        return spectra if not read_uv else all_w_spectra

pychemstation/control/controllers/tables/table.py

@@ -0,0 +1,297 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+Authors: Lucy Hao
+"""
+
+import abc
+import os
+from dataclasses import dataclass
+from typing import Union, Optional
+
+import numpy as np
+import polling
+import rainbow as rb
+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 MethodDetails
+from ....utils.sequence_types import SequenceDataFiles, SequenceTable
+from ....utils.table_types import Table, TableOperation, RegisterFlag
+
+TableType = Union[MethodDetails, SequenceTable]
+
+
+@dataclass
+class ChromData:
+    x: np.array
+    y: np.array
+
+
+class TableController(abc.ABC):
+
+    def __init__(self, controller: CommunicationController,
+                 src: str,
+                 data_dir: str,
+                 table: Table,
+                 offline: bool = False):
+        self.controller = controller
+        self.table = table
+        self.table_state: Optional[TableType] = None
+
+        if not offline:
+            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, Optional[AgilentHPLCChromatogram]] = {
+            "A": AgilentHPLCChromatogram(self.data_dir),
+            "B": AgilentHPLCChromatogram(self.data_dir),
+            "C": AgilentHPLCChromatogram(self.data_dir),
+            "D": AgilentHPLCChromatogram(self.data_dir),
+            "E": AgilentHPLCChromatogram(self.data_dir),
+            "F": AgilentHPLCChromatogram(self.data_dir),
+            "G": AgilentHPLCChromatogram(self.data_dir),
+            "H": AgilentHPLCChromatogram(self.data_dir),
+        }
+
+        self.data_files: Union[list[SequenceDataFiles], list[str]] = []
+
+        self.uv = None
+
+        # Initialize row counter for table operations
+        self.send('Local Rows')
+
+    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]):
+        if not self.controller:
+            raise RuntimeError(
+                "Communication controller must be initialized before sending command. It is currently in offline mode.")
+        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))
+
+    def add_new_col_num(self,
+                        col_name: RegisterFlag,
+                        val: Union[int, float]):
+        self.sleepy_send(TableOperation.NEW_COL_VAL.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            col_name=col_name,
+            val=val))
+
+    def add_new_col_text(self,
+                         col_name: RegisterFlag,
+                         val: str):
+        self.sleepy_send(TableOperation.NEW_COL_TEXT.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            col_name=col_name,
+            val=val))
+
+    def edit_row_num(self,
+                     col_name: RegisterFlag,
+                     val: Union[int, float],
+                     row: Optional[int] = None):
+        self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            row=row if row is not None else 'Rows',
+            col_name=col_name,
+            val=val))
+
+    def edit_row_text(self,
+                      col_name: RegisterFlag,
+                      val: str,
+                      row: Optional[int] = None):
+        self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            row=row if row is not None else 'Rows',
+            col_name=col_name,
+            val=val))
+
+    @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:
+        try:
+            started_running = polling.poll(lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
+                                           step=3, max_tries=10)
+        except Exception as e:
+            print(e)
+            return False
+        return started_running
+
+    def check_hplc_done_running(self,
+                                method: Optional[MethodDetails] = 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
+        :param sequence: if you are running a sequence and want to read back data, the timeout period will be adjusted to be longer than the sequence's runtime
+        :return: Return True if data can be read back, else False.
+        """
+        timeout = 10 * 60
+        if method:
+            timeout = ((method.stop_time + method.post_time + 3) * 60)
+        if sequence:
+            timeout *= len(sequence.rows)
+
+        most_recent_folder = self.retrieve_recent_data_files()
+
+        finished_run = False
+        try:
+            finished_run = polling.poll(
+                lambda: self.controller.check_if_running(),
+                timeout=timeout,
+                step=50)
+        except Exception:
+            pass
+
+        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=50)
+            if finished_run:
+                return check_folder
+            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_uv_spectrum(self, path: str):
+        data_uv = rb.agilent.chemstation.parse_file(os.path.join(path, "DAD1.UV"))
+        zipped_data = zip(data_uv.ylabels, data_uv.data)
+        self.uv = {str(w_a[0]): ChromData(x=data_uv.xlabels, y=w_a[1]) for w_a in zipped_data}
+
+    def get_spectrum(self, data_path: str, read_uv: bool = False):
+        """
+        Load chromatogram for any channel in spectra dictionary.
+        """
+        if read_uv:
+            self.get_uv_spectrum(data_path)
+
+        for channel, spec in self.spectra.items():
+            try:
+                spec.load_spectrum(data_path=data_path, channel=channel)
+            except FileNotFoundError:
+                self.spectra[channel] = None
+                print(f"No data at channel: {channel}")

pychemstation/control/hplc.py

@@ -41,18 +41,20 @@ class HPLCController:
         `comm_dir` must match the file path in the macro file.
 
         :param comm_dir: Name of directory for communication, where ChemStation will read and write from. Can be any existing directory.
-        :raises FileNotFoundError: If either `data_dir`, `method_dir` or `comm_dir` is not a valid directory.
+        :raises FileNotFoundError: If either `data_dir`, `method_dir`, `sequence_dir`, or `comm_dir` is not a valid directory.
         """
         self.comm = CommunicationController(comm_dir=comm_dir) if not offline else None
         self.method_controller = MethodController(controller=self.comm,
                                                   src=method_dir,
                                                   data_dir=data_dir,
-                                                  table=self.METHOD_TIMETABLE)
+                                                  table=self.METHOD_TIMETABLE,
+                                                  offline=offline)
         self.sequence_controller = SequenceController(controller=self.comm,
                                                       src=sequence_dir,
                                                       data_dir=data_dir,
                                                       table=self.SEQUENCE_TABLE,
-                                                      method_dir=method_dir)
+                                                      method_dir=method_dir,
+                                                      offline=offline)
 
     def send(self, cmd: Union[Command, str]):
         if not self.comm:
@@ -142,21 +144,25 @@ class HPLCController:
         """
         self.sequence_controller.edit_row(row, num)
 
-    def get_last_run_method_data(self, data: Optional[str] = None) -> AgilentChannelChromatogramData:
+    def get_last_run_method_data(self, read_uv: bool = False,
+                                 data: Optional[str] = None) -> AgilentChannelChromatogramData:
         """
         Returns the last run method data.
 
         :param data: If you want to just load method data but from a file path. This file path must be the complete file path.
+        :param read_uv: whether to also read the UV file
         """
-        return self.method_controller.get_data(custom_path=data)
+        return self.method_controller.get_data(custom_path=data, read_uv=read_uv)
 
-    def get_last_run_sequence_data(self, data: Optional[str] = None) -> list[AgilentChannelChromatogramData]:
+    def get_last_run_sequence_data(self, read_uv: bool = False,
+                                   data: Optional[str] = None) -> list[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
 
         :param data: If you want to just load sequence data but from a file path. This file path must be the complete file path.
+        :param read_uv: whether to also read the UV file
         """
-        return self.sequence_controller.get_data(custom_path=data)
+        return self.sequence_controller.get_data(custom_path=data, read_uv=read_uv)
 
     def check_loaded_sequence(self) -> str:
         """

pychemstation/utils/injector_types.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Any
+
+from pychemstation.utils.tray_types import Tray
+
+
+@dataclass
+class Draw:
+    amount: float
+    source: Tray
+    speed: Any
+    offset: Any
+
+
+@dataclass
+class Wait:
+    time: int
+
+
+@dataclass
+class Inject:
+    pass
+
+
+InjectorFunction = [Draw, Wait, Inject]
+
+
+@dataclass
+class InjectorTable:
+    functions: list[InjectorFunction]

pychemstation/utils/macro.py

@@ -34,6 +34,7 @@ class Command(Enum):
     INSTRUMENT_OFF = 'macro "SHUTDOWN.MAC" ,go'
     INSTRUMENT_ON = 'LIDoOperation "TURN_ON"'
 
+    # Method and Sequence Related
     GET_METHOD_CMD = "response$ = _MethFile$"
     GET_ROWS_CMD = 'response_num = TabHdrVal({register}, "{table_name}", "{col_name}")'
     SWITCH_METHOD_CMD = 'LoadMethod "{method_dir}", "{method_name}.M"'

pychemstation/utils/pump_types.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Pump:
+    solvent: str
+    in_use: bool

pychemstation/utils/sequence_types.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Optional, Union
 
-from pychemstation.utils.tray_types import TenVialColumn
+from pychemstation.utils.tray_types import TenVialColumn, Tray
 
 
 @dataclass
@@ -39,7 +39,8 @@ class InjectionSource(Enum):
 @dataclass
 class SequenceEntry:
     sample_name: str
-    vial_location: Union[TenVialColumn, int]
+    vial_location: Tray
+    data_file: Optional[str] = None
     method: Optional[str] = None
     num_inj: Optional[int] = 1
     inj_vol: Optional[int] = 2

pychemstation/utils/tray_types.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum
+from typing import Union
 
 
 class Num(Enum):
@@ -50,3 +51,6 @@ class TenVialColumn(Enum):
     EIGHT = 8
     NINE = 9
     TEN = 10
+
+
+Tray = Union[FiftyFourVialPlate, TenVialColumn]

{pychemstation-0.5.12.dist-info → pychemstation-0.5.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.12
+Version: 0.5.13
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao
@@ -14,6 +14,7 @@ Requires-Dist: polling
 Requires-Dist: seabreeze
 Requires-Dist: xsdata
 Requires-Dist: result
+Requires-Dist: rainbow-api
 
 # Agilent HPLC Macro Control
 
@@ -99,7 +100,7 @@ our [GitLab](https://gitlab.com/heingroup/device-api/pychemstation)!
 
 ## Authors and Acknowledgements
 
-Lucy Hao
+Lucy Hao, Maria Politi
 
 - 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.

{pychemstation-0.5.12.dist-info → pychemstation-0.5.13.dist-info}/RECORD

@@ -5,12 +5,22 @@ pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-
 pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
 pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
 pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
-pychemstation/control/hplc.py,sha256=5xC5q-hrAn5hKdz-ZwT_Dlas9LWLV27jZvhCKj7Lzg4,8761
-pychemstation/control/controllers/__init__.py,sha256=di3ytLIK-35XC_THw4IjNaOtCUTe7GuEOFb-obmREw4,166
+pychemstation/control/hplc.py,sha256=UlafodQoFFow2UVo-INK1ZjxyJ5vrVvv1TjB5VyAsHo,9178
+pychemstation/control/controllers/__init__.py,sha256=EM6LBNSTJqYVatmnvPq0P-S3q0POA88c-y64zL79I_I,252
 pychemstation/control/controllers/comm.py,sha256=IU4I_Q42VNCNUlVi93MxCmw2EBY9hiBDkU9FxubKg3c,7441
 pychemstation/control/controllers/method.py,sha256=XUclB7lQ_SIkquR58MBmmi9drHIPEq9AR8VprTLenvI,15503
 pychemstation/control/controllers/sequence.py,sha256=kYNxxck2I-q9mZDEZwG8bJ_99FfLmunS13EAHOS65wU,8288
 pychemstation/control/controllers/table_controller.py,sha256=70ovnIjLKkJborS1ztk445Mv42TtUM9jUniaQmZuyWQ,11031
+pychemstation/control/controllers/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/control/controllers/devices/column.py,sha256=SCpCnVFZFUM9LM51MbWkVcBRayN3WFxy7lz9gs2PYeY,348
+pychemstation/control/controllers/devices/device.py,sha256=SF1JK93FjmACnYrlKvldX3gEeA21qnXZegeNhc9QJGQ,738
+pychemstation/control/controllers/devices/injector.py,sha256=PfkSQlpE1zMzwyJ55Km1AdtPtdOS2RNyHDwAt_ZNa6M,349
+pychemstation/control/controllers/devices/pump.py,sha256=DJQh4lNXEraeC1CWrsKmsITOjuYlRI3tih_XRB3F1hg,1404
+pychemstation/control/controllers/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/control/controllers/tables/method.py,sha256=Woni_nAEWRZ79wf2WixLnJWZONNdGgZGGV9GG7m0qCQ,16189
+pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
+pychemstation/control/controllers/tables/sequence.py,sha256=vqwJeV38YWdFnaDXvZVOGYl-UCV9lmMbh8Fj5kQ3mqY,8815
+pychemstation/control/controllers/tables/table.py,sha256=5AIzomkl9-iN4-WijzuGT_pkGndAsqqlm8Pv_h8Mg4k,11911
 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
@@ -20,20 +30,23 @@ pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCs
 pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/chromatogram.py,sha256=-q3_hL9GTyi4C95os7IwAiOrkTM4EXIiigm-nW9pFmM,3221
-pychemstation/utils/macro.py,sha256=3KOuhFfs95JGdrIXGlYtlmMEQvWtjhN0eRSio4kjslM,2813
+pychemstation/utils/injector_types.py,sha256=xOkvlX_cH_QmuKbyXj8Lc2JEA_6g82az1zB4oTwcKN0,386
+pychemstation/utils/macro.py,sha256=OCQRRC-f46RlhenZfe7ldSgxBhzcZ5JlW3Ej-9OfeSI,2847
 pychemstation/utils/method_types.py,sha256=e7c2nWub6pT_S8ZF6sd7uXYm9ZBno0mARnzc1hnSHPY,1516
 pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
-pychemstation/utils/sequence_types.py,sha256=OhbmBUS7XQOKHC8YLjgbEVdpjriEc1bORkwB5ZV43oA,1063
+pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
+pychemstation/utils/sequence_types.py,sha256=4cNpmRdPLN5oGN7ozHgT21E65aBO8vV3ZcRXMOQ3EA8,1084
 pychemstation/utils/table_types.py,sha256=mlbxPAiPvO_EBba5OSzuJcpCL0srrC7uUfm_lKsOsmA,2557
-pychemstation/utils/tray_types.py,sha256=Xe5UvDqGo_FL4roWGlrqoqH4_Kj1Hi60B9UaiNvBRAw,690
+pychemstation/utils/tray_types.py,sha256=MaHN36rhcEI5mAY95VU8hfP9HhAlngQvMYq-2oyC0hc,764
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=iU6knsNpQGnBfGcC8VAj5SrCDcHD3jBZLhQdF6UUwY4,2452
+tests/constants.py,sha256=4FPJjW97yn6QiHNQVSlqjjJUE-Bh9SmyjIvgAeaGQBU,2450
 tests/test_comb.py,sha256=EDE1Ve0A_EK4qro9imZsrD0xXrQN8hAowiOWPFtw3dM,5515
 tests/test_comm.py,sha256=EYOpVXzEMQLGhhKYDPO-KaLcJdPSMPTD9Y4jSI0yVQY,2516
-tests/test_method.py,sha256=r1Q1irqiVzs31QuTYLX3u_A0FpX8rIAQ1L4WOk9tLbk,2473
+tests/test_inj.py,sha256=yaPGZoHiOC3ZSgsmrtiqp8QtSo2bMxB9FJhaFlOpad0,1412
+tests/test_method.py,sha256=Up2EEysYwldPT9GJw27Mycs6qi_Y2W3opjhc7wnLU9U,3215
 tests/test_sequence.py,sha256=Nz2iqp1cJgw6kcQvnwSkfBmhxpOH62PoEu6o_5rO-PY,4929
-pychemstation-0.5.12.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.12.dist-info/METADATA,sha256=ewxWIstBLkHdJaC4sF2JwejgLAZRrQq_xzuXGwj-1ks,4330
-pychemstation-0.5.12.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.12.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.12.dist-info/RECORD,,
+pychemstation-0.5.13.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.13.dist-info/METADATA,sha256=Ni0HBLM4rqsJSKjDFCbZzo2xLPWWTHAMQJuSKvxBtXQ,4371
+pychemstation-0.5.13.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.13.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.13.dist-info/RECORD,,

tests/constants.py

@@ -20,7 +20,7 @@ HEIN_LAB_CONSTANTS = [DEFAULT_COMMAND_PATH,
 # these CONSTANTS work in rm 254
 DEFAULT_COMMAND_PATH_254 = "D:\\\git_repositories\\\hplc_comm\\"
 DEFAULT_METHOD_DIR_254 = "D:\\Chemstation\\1\\Methods\\"
-DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\2024-12\\"
+DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\LC BO\\"
 SEQUENCE_DIR_254 = "C:\\1\\Sequence\\"
 
 HEIN_LAB_CONSTANTS_254 = [DEFAULT_COMMAND_PATH_254,

tests/test_inj.py

@@ -0,0 +1,38 @@
+import os
+import unittest
+
+from pychemstation.control import HPLCController
+from tests.constants import *
+
+
+class TestInj(unittest.TestCase):
+    def setUp(self):
+        path_constants = room(254)
+        for path in path_constants:
+            if not os.path.exists(path):
+                self.fail(
+                    f"{path} does not exist on your system. If you would like to run tests, please change this path.")
+
+        self.hplc_controller = HPLCController(comm_dir=path_constants[0],
+                                              method_dir=path_constants[1],
+                                              data_dir=path_constants[2],
+                                              sequence_dir=path_constants[3])
+
+    def test_load_inj(self):
+        self.hplc_controller.switch_method(DEFAULT_METHOD)
+        try:
+            gp_mtd = self.hplc_controller.method_controller.load_from_disk(DEFAULT_METHOD)
+            self.assertTrue(gp_mtd.first_row.organic_modifier == 5)
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_edit_inj(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+        new_method = gen_rand_method()
+        try:
+            self.hplc_controller.edit_method(new_method)
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_method.py

@@ -56,6 +56,26 @@ class TestMethod(unittest.TestCase):
         except Exception as e:
             self.fail(f"Should have not failed: {e}")
 
+    def test_run_10_times(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+        rand_method = MethodDetails(
+            name=DEFAULT_METHOD,
+            params=HPLCMethodParams(
+                organic_modifier=5,
+                flow=0.65),
+            timetable=[TimeTableEntry(
+                start_time=0.50,
+                organic_modifer=99,
+                flow=0.65)],
+            stop_time=1,
+            post_time=0)
+        self.hplc_controller.edit_method(rand_method, save=True)
+        try:
+            for _ in range(10):
+                self.hplc_controller.run_method(experiment_name="limiting_testing")
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()