pychemstation 0.10.10__py3-none-any.whl → 0.10.12__py3-none-any.whl

pychemstation/control/controllers/comm.py

@@ -54,7 +54,7 @@ class CommunicationController(ABCCommunicationController):
         raise RuntimeError("Failed to get number.")
 
     def get_text_val(self, cmd: str) -> str:
-        tries = 10
+        tries = 5
         for _ in range(tries):
             self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
             res = self.receive()

pychemstation/control/controllers/data_aq/method.py

@@ -5,12 +5,16 @@ import time
 import warnings
 from typing import Dict, List, Optional, Union, Tuple
 
-from result import Err, Ok, Result
+from result import Err, Result, Ok
 
-from pychemstation.analysis.chromatogram import (
+from ..devices.column import ColumnController
+from ..devices.dad import DADController
+from ..devices.pump import PumpController
+from ..devices.sample_info import SampleInfo
+from ....analysis.chromatogram import (
     TIME_FORMAT,
-    AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
+    AgilentChannelChromatogramData,
 )
 
 from ....analysis.process_report import AgilentReport, ReportType
@@ -20,12 +24,13 @@ from ....utils.macro import Command
 from ....utils.method_types import (
     HPLCMethodParams,
     MethodDetails,
+    TimeTableEntry,
     Param,
     PType,
-    TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, T, Table, TableOperation
+from ....utils.table_types import RegisterFlag, T, Table
 from ..devices.injector import InjectorController
+from ....utils.tray_types import Tray
 
 
 class MethodController(RunController):
@@ -38,9 +43,17 @@ class MethodController(RunController):
         data_dirs: Optional[List[str]],
         table: Table,
         offline: bool,
-        injector_controller: InjectorController,
+        injector: InjectorController,
+        pump: PumpController,
+        dad: DADController,
+        column: ColumnController,
+        sample_info: SampleInfo,
     ):
-        self.injector_controller = injector_controller
+        self.injector = injector
+        self.pump = pump
+        self.dad = dad
+        self.column = column
+        self.sample_info = sample_info
         self.data_files: List[str] = []
         super().__init__(
             controller=controller,
@@ -50,6 +63,9 @@ class MethodController(RunController):
             offline=offline,
         )
 
+    def get_sample_location(self) -> Tray:
+        return self.sample_info.get_location()
+
     def get_current_method_name(self) -> str:
         self.sleepy_send(Command.GET_METHOD_CMD)
         res = self.receive()
@@ -60,18 +76,8 @@ class MethodController(RunController):
     def get_method_params(self) -> HPLCMethodParams:
         if self.controller:
             return HPLCMethodParams(
-                organic_modifier=self.controller.get_num_val(
-                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                        register=self.table_locator.register,
-                        register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
-                    )
-                ),
-                flow=self.controller.get_num_val(
-                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                        register=self.table_locator.register,
-                        register_flag=RegisterFlag.FLOW,
-                    )
-                ),
+                organic_modifier=self.get_om(),
+                flow=self.get_flow(),
             )
         raise ValueError("Communication controller is offline!")
 
@@ -114,23 +120,20 @@ class MethodController(RunController):
         return entries
 
     def load(self) -> MethodDetails:
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            method_name = self.get_method_name()
-            timetable_rows = self.get_timetable(int(rows.ok_value.num_response))
-            params = self.get_method_params()
-            stop_time = self.get_stop_time()
-            post_time = self.get_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)
+        rows = self.get_row_count_safely()
+        method_name = self.get_method_name()
+        timetable_rows = self.get_timetable(rows)
+        params = self.get_method_params()
+        stop_time = self.get_stop_time()
+        post_time = self.get_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
 
     def get_method_name(self):
         self.send(Command.GET_METHOD_CMD)
@@ -138,26 +141,6 @@ class MethodController(RunController):
         method_name = res.ok_value.string_response
         return method_name
 
-    def get_post_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.POST_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
-    def get_stop_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.MAX_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
     def get_total_runtime(self) -> Union[int, float]:
         """Returns total method runtime in minutes."""
         return self.get_post_time() + self.get_stop_time()
@@ -217,20 +200,14 @@ class MethodController(RunController):
         self.edit_method_timetable(updated_method.timetable)
 
         if save:
-            self.send(
-                Command.SAVE_METHOD_CMD.value.format(
-                    commit_msg=f"saved method at {str(time.time())}"
-                )
-            )
+            self.save_method()
 
-    def edit_initial_om(self, new_om: Union[int, float]):
-        self._validate_organic_modifier(new_om)
-        initial_organic_modifier: Param = Param(
-            val=new_om,
-            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-            ptype=PType.NUM,
+    def save_method(self):
+        self.send(
+            Command.SAVE_METHOD_CMD.value.format(
+                commit_msg=f"saved method at {str(time.time())}"
+            )
         )
-        self._update_param(initial_organic_modifier)
 
     def _validate_organic_modifier(self, new_om):
         if not (isinstance(new_om, int) or isinstance(new_om, float)):
@@ -240,13 +217,6 @@ class MethodController(RunController):
         if new_om > 100:
             raise ValueError("Organic modifer must be less than 100.")
 
-    def edit_flow(self, new_flow: Union[int, float]):
-        self._validate_flow(new_flow)
-        flow: Param = Param(
-            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
-        )
-        self._update_param(flow)
-
     def _validate_flow(self, new_flow):
         if not (isinstance(new_flow, int) or isinstance(new_flow, float)):
             raise ValueError("Flow must be int or float")
@@ -255,38 +225,12 @@ class MethodController(RunController):
         if new_flow >= 5.0:
             raise ValueError("Flow must be less than 5.0")
 
-    def edit_stop_time(self, new_stop_time: Union[int, float]):
-        self.validate_stop_time(new_stop_time)
-        stop_time: Param = Param(
-            val=new_stop_time,
-            chemstation_key=RegisterFlag.MAX_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(
-                val="Set", chemstation_key=RegisterFlag.STOPTIME_MODE, ptype=PType.STR
-            )
-        )
-        self._update_param(stop_time)
-
     def validate_stop_time(self, new_stop_time):
         if not (isinstance(new_stop_time, int) or isinstance(new_stop_time, float)):
             raise ValueError("Stop time must be int or float")
         if new_stop_time < 0:
             raise ValueError("Stop time must be positive")
 
-    def edit_post_time(self, new_post_time: Union[int, float]):
-        self.validate_post_time(new_post_time)
-        post_time: Param = Param(
-            val=new_post_time,
-            chemstation_key=RegisterFlag.POST_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(val="Set", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR)
-        )
-        self._update_param(post_time)
-
     def validate_post_time(self, new_post_time):
         if not (isinstance(new_post_time, int) or isinstance(new_post_time, float)):
             raise ValueError("Post time must be int or float")
@@ -301,59 +245,14 @@ class MethodController(RunController):
         new_post_time: Union[int, float] | None,
     ):
         self.delete_table()
-        self.edit_initial_om(new_initial_om)
+        self._validate_flow(new_flow)
+        self.validate_post_time(new_post_time)
+        self._validate_organic_modifier(new_initial_om)
+        self.validate_stop_time(new_stop_time)
         self.edit_flow(new_flow)
-        if new_stop_time:
-            self.edit_stop_time(new_stop_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.STOPTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-        if new_post_time:
-            self.edit_post_time(new_post_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.POSTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-
-    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_locator.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.sleepy_send(
-                    setting_command.value.format(
-                        register=register,
-                        register_flag=register_flag,
-                        val=method_param.val,
-                    )
-                )
-        else:
-            self.sleepy_send(
-                setting_command.value.format(
-                    register=register,
-                    register_flag=method_param.chemstation_key,
-                    val=method_param.val,
-                )
-            )
-        self.download()
+        self.edit_initial_om(new_initial_om)
+        self.edit_stop_time(new_stop_time)
+        self.edit_post_time(new_post_time)
 
     def download(self):
         self.sleepy_send("DownloadRCMethod PMP1")
@@ -443,62 +342,6 @@ class MethodController(RunController):
         self.download()
         return time_added, flow_added, om_added, function_added
 
-        # if first_row:
-        #     time_added = False
-        #     flow_row_method: Callable = (
-        #         self.add_new_col_text
-        #         if row.flow and not row.organic_modifer
-        #         else self._edit_row_text
-        #     )
-        #     if row.organic_modifer:
-        #         self.add_row()
-        #         self.add_new_col_text(
-        #             col_name=RegisterFlag.FUNCTION,
-        #             val=RegisterFlag.SOLVENT_COMPOSITION.value,
-        #         )
-        #         if not time_added:
-        #             time_added = True
-        #             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()
-        #         flow_row_method(
-        #             col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value
-        #         )
-        #         if not time_added:
-        #             time_added = True
-        #             self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
-        #         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 edit_method_timetable(self, timetable_rows: List[TimeTableEntry]):
         self.get_num_rows()
         self.delete_table()
@@ -508,8 +351,8 @@ class MethodController(RunController):
             res = self.get_num_rows()
 
         self.new_table()
-        num_rows = self.get_num_rows()
-        if num_rows.ok_value.num_response != 0:
+        num_rows = self.get_row_count_safely()
+        if num_rows != 0:
             raise ValueError("Should be zero rows!")
 
         time_added = False
@@ -644,3 +487,77 @@ class MethodController(RunController):
                     Row {i + 1} ({timetable[i].start_time}) has a smaller or equal starttime than row {i} ({start_time})"""
                 )
             self._validate_row(row)
+
+    def get_om(self):
+        return self._read_num_param(RegisterFlag.SOLVENT_B_COMPOSITION)
+
+    def get_flow(self):
+        return self._read_num_param(RegisterFlag.FLOW)
+
+    def get_post_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.POST_TIME)
+
+    def get_stop_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.MAX_TIME)
+
+    def edit_post_time(self, new_post_time: Optional[int | float]):
+        if new_post_time:
+            post_time: Param = Param(
+                val=new_post_time,
+                chemstation_key=RegisterFlag.POST_TIME,
+                ptype=PType.NUM,
+            )
+            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,
+                )
+            )
+
+    def edit_stop_time(self, new_stop_time: Optional[int | float]):
+        if new_stop_time:
+            stop_time: Param = Param(
+                val=new_stop_time,
+                chemstation_key=RegisterFlag.MAX_TIME,
+                ptype=PType.NUM,
+            )
+            self._update_param(
+                Param(
+                    val="Set",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+            self._update_param(stop_time)
+        else:
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+
+    def edit_flow(self, new_flow: Union[int, float]):
+        flow: Param = Param(
+            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
+        )
+        self._update_param(flow)
+
+    def edit_initial_om(self, new_om: Union[int, float]):
+        initial_organic_modifier: Param = Param(
+            val=new_om,
+            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+            ptype=PType.NUM,
+        )
+        self._update_param(initial_organic_modifier)

pychemstation/control/controllers/data_aq/sequence.py

@@ -55,19 +55,20 @@ class SequenceController(RunController):
         )
 
     def load(self) -> SequenceTable:
-        rows = self.get_num_rows()
+        rows = self.get_row_count_safely()
         self.send(Command.GET_SEQUENCE_CMD)
         seq_name = self.receive()
 
-        if rows.is_ok() and seq_name.is_ok():
+        if seq_name.is_ok():
             self.table_state: SequenceTable = 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))
-                ],
+                rows=[self.get_row(r + 1) for r in range(int(rows))],
             )
             return self.table_state
-        raise RuntimeError(rows.err_value)
+        else:
+            raise RuntimeError(
+                f"couldn't read rows or sequence name: {seq_name.err_value}"
+            )
 
     def try_int(self, val: Any) -> Optional[int]:
         try:
@@ -88,18 +89,17 @@ class SequenceController(RunController):
             raise ValueError("Expected vial location, is empty.")
 
     def get_row(self, row: int) -> SequenceEntry:
-        sample_name = self.get_text(row, RegisterFlag.NAME)
-        vial_location = self.try_int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
-        data_file = self.get_text(row, RegisterFlag.DATA_FILE)
-        method = self.get_text(row, RegisterFlag.METHOD)
-        num_inj = self.try_int(self.get_num(row, RegisterFlag.NUM_INJ))
-        inj_vol = self.try_float(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))
-        vial_enum = self.try_vial_location(vial_location)
+        sample_name = self.get_sample_name(row)
+        vial_location = self.get_vial_location(row)
+        data_file = self.get_data_file(row)
+        method = self.get_method(row)
+        num_inj = self.get_num_inj(row)
+        inj_vol = self.get_inj_vol(row)
+        inj_source = self.get_inj_source(row)
+        sample_type = self.get_sample_type(row)
         return SequenceEntry(
             sample_name=sample_name,
-            vial_location=vial_enum,
+            vial_location=vial_location,
             method=None if len(method) == 0 else method,
             num_inj=num_inj,
             inj_vol=inj_vol,
@@ -108,6 +108,32 @@ class SequenceController(RunController):
             data_file=data_file,
         )
 
+    def get_sample_type(self, row):
+        return SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
+
+    def get_inj_source(self, row):
+        return InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
+
+    def get_inj_vol(self, row):
+        return self.try_float(self.get_text(row, RegisterFlag.INJ_VOL))
+
+    def get_num_inj(self, row):
+        return self.try_int(self.get_num(row, RegisterFlag.NUM_INJ))
+
+    def get_method(self, row):
+        return self.get_text(row, RegisterFlag.METHOD)
+
+    def get_data_file(self, row):
+        return self.get_text(row, RegisterFlag.DATA_FILE)
+
+    def get_vial_location(self, row) -> Tray:
+        return self.try_vial_location(
+            self.try_int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
+        )
+
+    def get_sample_name(self, row):
+        return self.get_text(row, RegisterFlag.NAME)
+
     def switch(self, seq_name: str):
         """
         Switch to the specified sequence. The sequence name does not need the '.S' extension.
@@ -136,23 +162,21 @@ class SequenceController(RunController):
         :param sequence_table:
         """
         self.table_state = sequence_table
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            existing_row_num = rows.ok_value.num_response
-            wanted_row_num = len(sequence_table.rows)
-            for i in range(int(existing_row_num)):
-                self.delete_row(int(existing_row_num - i))
-                self.send(Command.SAVE_SEQUENCE_CMD)
-            for i in range(int(wanted_row_num)):
-                self.add_row()
-                self.save()
-            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.save()
-            self.send(Command.SWITCH_SEQUENCE_CMD)
+        rows = self.get_row_count_safely()
+        existing_row_num = rows
+        wanted_row_num = len(sequence_table.rows)
+        for i in range(int(existing_row_num)):
+            self.delete_row(int(existing_row_num - i))
+            self.send(Command.SAVE_SEQUENCE_CMD)
+        for i in range(int(wanted_row_num)):
+            self.add_row()
+            self.download()
+        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.download()
+        self.send(Command.SWITCH_SEQUENCE_CMD)
 
     def _edit_row(self, row: SequenceEntry, row_num: int):
         """
@@ -161,12 +185,11 @@ class SequenceController(RunController):
         :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.save()
-                num_rows = self.get_num_rows()
+        num_rows = self.get_row_count_safely()
+        while num_rows < row_num:
+            self.add_row()
+            self.download()
+            num_rows = self.get_row_count_safely()
         if row.vial_location:
             self.edit_vial_location(row.vial_location, row_num, save=False)
         if row.method:
@@ -183,7 +206,7 @@ class SequenceController(RunController):
             self.edit_data_file(row.data_file, row_num, save=False)
         if row.sample_type:
             self.edit_sample_type(row.sample_type, row_num, save=False)
-        self.save()
+        self.download()
 
     def edit_sample_type(
         self, sample_type: SampleType, row_num: int, save: bool = True
@@ -196,17 +219,17 @@ class SequenceController(RunController):
             val=sample_type.value,
         )
         if save:
-            self.save()
+            self.download()
 
     def edit_data_file(self, data_file: str, row_num: int, save: bool = True):
         self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=data_file)
         if save:
-            self.save()
+            self.download()
 
     def edit_sample_name(self, sample_name: str, row_num: int, save: bool = True):
         self._edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=sample_name)
         if save:
-            self.save()
+            self.download()
 
     def edit_injection_source(
         self, inj_source: InjectionSource, row_num: int, save: bool = True
@@ -217,7 +240,7 @@ class SequenceController(RunController):
             row=row_num, col_name=RegisterFlag.INJ_SOR, val=inj_source.value
         )
         if save:
-            self.save()
+            self.download()
 
     def edit_injection_volume(
         self, inj_vol: Union[int, float], row_num: int, save: bool = True
@@ -226,12 +249,12 @@ class SequenceController(RunController):
             row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(inj_vol)
         )
         if save:
-            self.save()
+            self.download()
 
     def edit_num_injections(self, num_inj: int, row_num: int, save: bool = True):
         self._edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=num_inj)
         if save:
-            self.save()
+            self.download()
 
     def edit_method_name(
         self, method: str, row_num: int, save: bool = True, override_check: bool = False
@@ -246,7 +269,7 @@ class SequenceController(RunController):
             )
         self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
         if save:
-            self.save()
+            self.download()
 
     def edit_vial_location(self, loc: Tray, row_num: int, save: bool = True):
         loc_num = -1
@@ -268,11 +291,11 @@ class SequenceController(RunController):
             elif isinstance(loc, VialBar) or isinstance(loc, FiftyFourVialPlate):
                 self.add_row()
                 previous_contents.vial_location = loc
-                num_rows = self.get_num_rows().ok_value.num_response
+                num_rows = self.get_row_count_safely()
                 self._edit_row(previous_contents, num_rows)
                 self.move_row(int(num_rows), row_num)
                 self.delete_row(row_num + 1)
-                self.save()
+                self.download()
             else:
                 raise ValueError(
                     "`loc` should be of type `VialBar`, `FiftyFourVialPlate`"
@@ -290,9 +313,9 @@ class SequenceController(RunController):
                 row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
             )
         if save:
-            self.save()
+            self.download()
 
-    def save(self):
+    def download(self):
         self.send(Command.SAVE_SEQUENCE_CMD)
 
     def run(self, stall_while_running: bool = True):