pychemstation 0.4.7.dev1__py3-none-any.whl → 0.4.7.dev2__py3-none-any.whl

pychemstation/control/__init__.py

@@ -1,5 +1,6 @@
 """
 .. include:: README.md
 """
-from .hplc import HPLCController
-from .chromatogram import AgilentHPLCChromatogram
+from .comm import HPLCController
+from .method import MethodController
+from .sequence import SequenceController

hein-analytical-control/devices/Agilent/hplc.py → pychemstation/control/comm.py

@@ -13,18 +13,13 @@ Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 import logging
 import os
 import time
-from typing import Union
 
 import polling
-from xsdata.formats.dataclass.parsers import XmlParser
 
-from .chromatogram import AgilentHPLCChromatogram, TIME_FORMAT
-from .hplc_param_types import Command, HPLCAvailStatus, HPLCMethodParams, HPLCRunningStatus, HPLCErrorStatus, Param, \
-    str_to_status, PType, MethodTimetable, Entry, RegisterFlag
-from ...generated import PumpMethod, DadMethod
-
-# maximum command number
-MAX_CMD_NO = 255
+from ..utils.chromatogram import AgilentHPLCChromatogram
+from ..utils.constants import MAX_CMD_NO
+from ..utils.macro import *
+from ..utils.method_types import *
 
 
 class HPLCController:
@@ -36,7 +31,6 @@ class HPLCController:
             self,
             comm_dir: str,
             data_dir: str,
-            method_dir: str,
             cmd_file: str = "cmd",
             reply_file: str = "reply",
     ):
@@ -62,11 +56,6 @@ class HPLCController:
         else:
             raise FileNotFoundError(f"data_dir: {data_dir} not found.")
 
-        if os.path.isdir(method_dir):
-            self.method_dir = method_dir
-        else:
-            raise FileNotFoundError(f"method_dir: {method_dir} not found.")
-
         self.spectra = {
             "A": AgilentHPLCChromatogram(self.data_dir),
             "B": AgilentHPLCChromatogram(self.data_dir),
@@ -75,6 +64,7 @@ class HPLCController:
         }
 
         self.data_files: list[str] = []
+        self.internal_variables: list[dict[str, str]] = []
 
         # Create files for Chemstation to communicate with Python
         open(self.cmd_file, "a").close()
@@ -120,6 +110,17 @@ class HPLCController:
 
         return hplc_run_done
 
+    def get_spectrum(self):
+        """ Load last chromatogram for any channel in spectra dictionary."""
+        last_file = self.data_files[-1] if len(self.data_files) > 0 else None
+
+        if last_file is None:
+            raise IndexError
+
+        for channel, spec in self.controller.spectra.items():
+            spec.load_spectrum(data_path=last_file, channel=channel)
+            self.logger.info("%s chromatogram loaded.", channel)
+
     def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
         """Low-level execution primitive. Sends a command string to HPLC.
 
@@ -186,6 +187,11 @@ class HPLCController:
         else:
             raise IOError(f"Failed to receive reply to command #{cmd_no}.") from 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.
 
@@ -253,132 +259,6 @@ class HPLCController:
         """Stops Macro execution. Connection will be lost."""
         self.send(Command.STOP_MACRO_CMD)
 
-    def update_method(self):
-        pass
-
-    def edit_method_timetable(self):
-        pass
-
-    def _update_method_timetable(self):
-        pass
-
-    def _update_method_param(self, method_param: Param):
-        """Change a method parameter.
-
-        :param method_param: a parameter to update for currently loaded method
-        """
-
-        setting_command = "SetObjHdrVal" if method_param.ptype == PType.NUM else "SetObjHdrText"
-        if isinstance(method_param.chemstation_key, list):
-            for register in method_param.chemstation_key:
-                self.send(
-                    f'{setting_command} RCPMP1Method[1], {register}, {method_param.val}'
-                )
-        else:
-            self.send(
-                f'{setting_command} RCPMP1Method[1], {method_param.chemstation_key}, {method_param.val}'
-            )
-        time.sleep(2)
-
-    def desired_method_already_loaded(self, method_name: str) -> bool:
-        """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().splitlines()[1].split()[1:][0]
-        return method_name in parsed_response
-
-    def switch_method(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.method_dir, method_name=method_name)
-        )
-
-        time.sleep(2)
-        self.send(Command.GET_METHOD_CMD)
-        time.sleep(2)
-        # check that method switched
-        for _ in range(10):
-            try:
-                parsed_response = self.receive().splitlines()[1].split()[1:][0]
-                break
-            except IndexError:
-                self.logger.debug("Malformed response. Trying again.")
-                continue
-
-        assert parsed_response == f"{method_name}.M", "Switching Methods failed."
-
-    def load_method_details(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_path = os.path.join(self.method_dir, "AgilentPumpDriver1.RapidControl.MethodXML.xml")
-        dad_path = os.path.join(self.method_dir, "Agilent1200erDadDriver1.RapidControl.MethodXML.xml")
-
-        if os.path.exists(os.path.join(self.method_dir, f"{method_name}.M")):
-            parser = XmlParser()
-            method = parser.parse(method_path, PumpMethod)
-            dad = parser.parse(dad_path, DadMethod)
-
-            organic_modifier = None
-            aq_modifier = None
-
-            if len(method.solvent_composition.solvent_element) == 2:
-                for solvent in method.solvent_composition.solvent_element:
-                    if solvent.channel == "Channel_A":
-                        aq_modifier = solvent
-                    elif solvent.channel == "Channel_B":
-                        organic_modifier = solvent
-
-            return MethodTimetable(
-                first_row=HPLCMethodParams(
-                    organic_modifier=Param(val=organic_modifier.percentage,
-                                           chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-                                           ptype=PType.NUM),
-                    flow=Param(val=method.flow,
-                               chemstation_key=RegisterFlag.FLOW,
-                               ptype=PType.NUM),
-                    maximum_run_time=Param(val=method,
-                                           chemstation_key=RegisterFlag.MAX_TIME,
-                                           ptype=PType.NUM),
-                    temperature=Param(val=None,
-                                      chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
-                                                       RegisterFlag.COLUMN_OVEN_TEMP2],
-                                      ptype=PType.NUM),
-                    inj_vol=Param(val=None,
-                                  chemstation_key=None,
-                                  ptype=PType.NUM),
-                    equ_time=Param(val=None,
-                                   chemstation_key=None,
-                                   ptype=PType.NUM)),
-                subsequent_rows=[
-                    Entry(
-                        start_time=tte.time,
-                        organic_modifer=tte.percent_b,
-                        flow=method.flow
-                    ) for tte in method.timetable.timetable_entry
-                ],
-                dad_wavelengthes=dad.signals.signal,
-                organic_modifier=organic_modifier,
-                modifier_a=aq_modifier
-            )
-        else:
-            raise FileNotFoundError
-
     def lamp_on(self):
         """Turns the UV lamp on."""
         self.send(Command.LAMP_ON_CMD)
@@ -394,43 +274,3 @@ class HPLCController:
     def pump_off(self):
         """Turns the pump off."""
         self.send(Command.PUMP_OFF_CMD)
-
-    def start_method(self):
-        """Starts and executes currently loaded method to run according to Run Time Checklist. Device must be ready."""
-        self.send(Command.START_METHOD_CMD)
-
-    def run_method(self, experiment_name: str):
-        """This is the preferred method to trigger a run.
-        Starts the currently selected method, storing data
-        under the <data_dir>/<experiment_name>.D folder.
-        The should <experiment_name> end 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
-            )
-        )
-
-        folder_name = f"{experiment_name}_{timestamp}.D"
-        self.data_files.append(os.path.join(self.data_dir, folder_name))
-        self.logger.info("Started HPLC run:  %s.", folder_name)
-
-    def stop_method(self):
-        """Stops the run. A dialog window will pop up and manual intervention may be required."""
-        self.send(Command.STOP_METHOD_CMD)
-
-    def get_spectrum(self):
-        """ Load last chromatogram for any channel in spectra dictionary."""
-        last_file = self.data_files[-1] if len(self.data_files) > 0 else None
-
-        if last_file is None:
-            raise IndexError
-
-        for channel, spec in self.spectra.items():
-            spec.load_spectrum(data_path=last_file, channel=channel)
-            self.logger.info("%s chromatogram loaded.", channel)

pychemstation/control/method.py

@@ -0,0 +1,232 @@
+import os
+import time
+
+from xsdata.formats.dataclass.parsers import XmlParser
+
+from ..control.table_controller import TableController, HPLCController
+from ..generated import DadMethod, PumpMethod
+from ..utils.chromatogram import TIME_FORMAT
+from ..utils.constants import METHOD_TIMETABLE
+from ..utils.macro import Command
+from ..utils.method_types import MethodTimetable, HPLCMethodParams, Param, PType, TimeTableEntry
+from ..utils.table_types import RegisterFlag, TableOperation
+
+
+class MethodController(TableController):
+    """
+    Class containing method related logic
+    """
+
+    def __init__(self, controller: HPLCController, src: str):
+        super().__init__(controller, src)
+
+    def is_loaded(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().splitlines()[1].split()[1:][0]
+        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)
+
+        # check that method switched
+        for _ in range(10):
+            try:
+                parsed_response = self.receive().splitlines()[1].split()[1:][0]
+                break
+            except IndexError:
+                continue
+
+        assert parsed_response == f"{method_name}.M", "Switching Methods failed."
+
+    def run(self, experiment_name: str):
+        """This is the preferred method to trigger a run.
+        Starts the currently selected method, storing data
+        under the <data_dir>/<experiment_name>.D folder.
+        The <experiment_name> will be appended with a timestamp in the '%Y-%m-%d-%H-%M' format.
+        Device must be ready.
+
+        :param experiment_name: Name of the experiment
+        """
+        timestamp = time.strftime(TIME_FORMAT)
+
+        self.send(Command.RUN_METHOD_CMD.value.format(data_dir=self.src,
+                                                      experiment_name=experiment_name,
+                                                      timestamp=timestamp))
+
+        folder_name = f"{experiment_name}_{timestamp}.D"
+        self.controller.data_files.append(os.path.join(self.src, folder_name))
+
+    def load(self, method_name: str):
+        """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 = None
+            aq_modifier = None
+
+            if len(method.solvent_composition.solvent_element) == 2:
+                for solvent in method.solvent_composition.solvent_element:
+                    if solvent.channel == "Channel_A":
+                        aq_modifier = solvent
+                    elif solvent.channel == "Channel_B":
+                        organic_modifier = solvent
+
+            return MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=Param(val=organic_modifier.percentage,
+                                           chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+                                           ptype=PType.NUM),
+                    flow=Param(val=method.flow,
+                               chemstation_key=RegisterFlag.FLOW,
+                               ptype=PType.NUM),
+                    maximum_run_time=Param(val=method.stop_time,
+                                           chemstation_key=RegisterFlag.MAX_TIME,
+                                           ptype=PType.NUM),
+                    temperature=Param(val=None,
+                                      chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
+                                                       RegisterFlag.COLUMN_OVEN_TEMP2],
+                                      ptype=PType.NUM),
+                    inj_vol=Param(val=None,
+                                  chemstation_key=None,
+                                  ptype=PType.NUM),
+                    equ_time=Param(val=None,
+                                   chemstation_key=None,
+                                   ptype=PType.NUM)),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=tte.time,
+                        organic_modifer=tte.percent_b,
+                        flow=method.flow
+                    ) for tte in method.timetable.timetable_entry
+                ],
+                dad_wavelengthes=dad.signals.signal,
+                organic_modifier=organic_modifier,
+                modifier_a=aq_modifier
+            )
+        else:
+            raise FileNotFoundError
+
+    def edit(self, updated_method: MethodTimetable):
+        """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 = updated_method.first_row.organic_modifier
+        max_time: Param = updated_method.first_row.maximum_run_time
+        temp: Param = updated_method.first_row.temperature
+        injvol: Param = updated_method.first_row.inj_vol
+        equalib_time: Param = updated_method.first_row.equ_time
+        flow: Param = updated_method.first_row.flow
+
+        # Method settings required for all runs
+        self.send(TableOperation.DELETE_TABLE.value.format(register=METHOD_TIMETABLE.register,
+                                                           table_name=METHOD_TIMETABLE.name, ))
+        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)
+
+    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
+        self.sleepy_send('Local Rows')
+        self._get_table_rows(METHOD_TIMETABLE)
+
+        self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+        res = self._get_table_rows(METHOD_TIMETABLE)
+        while "ERROR" not in res:
+            self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+            res = self._get_table_rows(METHOD_TIMETABLE)
+
+        self.sleepy_send('NewTab RCPMP1Method[1], "Timetable"')
+        self._get_table_rows(METHOD_TIMETABLE)
+
+        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_table_rows(METHOD_TIMETABLE)
+
+                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_table_rows(METHOD_TIMETABLE)
+
+    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 = METHOD_TIMETABLE.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 run. A dialog window will pop up and manual intervention may be required."""
+        self.send(Command.STOP_METHOD_CMD)

pychemstation/control/sequence.py

@@ -0,0 +1,140 @@
+import os
+import time
+
+from ..control.table_controller import TableController, HPLCController
+from ..utils.chromatogram import SEQUENCE_TIME_FORMAT
+from ..utils.constants import SEQUENCE_TABLE
+from ..utils.macro import Command
+from ..utils.sequence_types import SequenceTable, SequenceEntry
+from ..utils.table_types import RegisterFlag, TableOperation
+
+
+class SequenceController(TableController):
+    """
+    Class containing sequence related logic
+    """
+
+    def __init__(self, controller: HPLCController, src: str):
+        super().__init__(controller, src)
+
+    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)
+        # check that method switched
+        for _ in range(10):
+            try:
+                parsed_response = self.receive().splitlines()[1].split()[1:][0]
+                break
+            except IndexError:
+                continue
+
+        assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
+
+    def run(self, sequence_table: SequenceTable):
+        """Starts the currently loaded sequence, storing data
+        under the <data_dir>/<sequence table name> folder.
+        The <sequence table name> will be appended with a timestamp in the "%Y %m %d %H %m %s" format.
+        Device must be ready.
+
+        :param sequence_table:
+        """
+        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
+        self.send(Command.RUN_SEQUENCE_CMD.value)
+        self.send(Command.RUN_SEQUENCE_CMD.value)
+        folder_name = f"{sequence_table.name} {timestamp}"
+        subdirs = [x[0] for x in os.walk(self.src)]
+        time.sleep(60)
+        potential_folders = sorted(list(filter(lambda d: folder_name in d, subdirs)))
+        self.controller.data_files.append(potential_folders[0])
+
+    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.send("Local Rows")
+        self.sleep(1)
+        self.delete_table(SEQUENCE_TABLE)
+        self.sleep(1)
+        self.new_table(SEQUENCE_TABLE)
+        self.sleep(1)
+        self._get_table_rows(SEQUENCE_TABLE)
+        for _ in sequence_table.rows:
+            self.add_table_row(SEQUENCE_TABLE)
+            self.sleep(1)
+            self.send(Command.SAVE_SEQUENCE_CMD)
+            self.sleep(1)
+        self._get_table_rows(SEQUENCE_TABLE)
+        self.send(Command.SWITCH_SEQUENCE_CMD)
+        for i, row in enumerate(sequence_table.rows):
+            self.edit(row=row, row_num=i + 0)
+            self.sleep(1)
+            self.send(Command.SAVE_SEQUENCE_CMD)
+            self.sleep(1)
+
+    def edit_row(self, row: SequenceEntry, row_num: int):
+        """Edits a row in the sequence table. Assumes the row already exists.
+
+        :param row: sequence row entry with updated information
+        :param row_num: the row to edit, based on -1-based indexing
+        """
+        if row.vial_location:
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=SEQUENCE_TABLE.register,
+                                                                      table_name=SEQUENCE_TABLE.name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.VIAL_LOCATION,
+                                                                      val=row.vial_location))
+        if row.method:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.METHOD,
+                                                                       val=row.method))
+
+        if row.num_inj:
+            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=SEQUENCE_TABLE.register,
+                                                                      table_name=SEQUENCE_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=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_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=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.INJ_SOR,
+                                                                       val=row.inj_source))
+
+        if row.sample_name:
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_TABLE.name,
+                                                                       row=row_num,
+                                                                       col_name=RegisterFlag.NAME,
+                                                                       val=row.sample_name))
+            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=SEQUENCE_TABLE.register,
+                                                                       table_name=SEQUENCE_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=SEQUENCE_TABLE.register,
+                                                                      table_name=SEQUENCE_TABLE.name,
+                                                                      row=row_num,
+                                                                      col_name=RegisterFlag.SAMPLE_TYPE,
+                                                                      val=row.sample_type))