pychemstation 0.4.7.dev3__tar.gz → 0.5.1__tar.gz

{pychemstation-0.4.7.dev3 → pychemstation-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.4.7.dev3
+Version: 0.5.1
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/pychemstation
 Author: Lucy Hao
@@ -59,26 +59,27 @@ HPLCTalk_Run
 ## Example Usage
 
 ```python
-from pychemstation.control import HPLCController, MethodController, SequenceController
+from pychemstation.control import HPLCController
 import pandas as pd
 
 # these paths will be unique to your Chemstation setup
+DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
+DEFAULT_METHOD = "GENERAL-POROSHELL"
 DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
 DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
-DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\hplc-method-optimization\\tests"
+SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\2\\Sequence"
 
 hplc_controller = HPLCController(data_dir=DATA_DIR,
-                                 comm_dir=DEFAULT_COMMAND_PATH)
-method_controller = MethodController(controller=hplc_controller,
-                                     src=DEFAULT_METHOD_DIR)
+                                 comm_dir=DEFAULT_COMMAND_PATH,
+                                 sequence_dir=SEQUENCE_DIR,
+                                 method_dir=DEFAULT_METHOD_DIR)
 
 hplc_controller.preprun()
-method_controller.switch(method_name="General-Poroshell")
-method_controller.run(experiment_name="Run 10")
-data_ready = method_controller.data_ready()
+hplc_controller.switch_method(method_name=DEFAULT_METHOD)
+hplc_controller.run_method(experiment_name="Run 10")
+data_status_valid, chrom = hplc_controller.get_last_run_method_data()
 
-if data_ready:
-    chrom = method_controller.get_data()
+if data_status_valid:
     # afterwards, save, analyze or plot the data!
     values = {"x": chrom.x, "y": chrom.y}
     chromatogram_data = pd.DataFrame.from_dict(values)

{pychemstation-0.4.7.dev3 → pychemstation-0.5.1}/README.md

@@ -44,26 +44,27 @@ HPLCTalk_Run
 ## Example Usage
 
 ```python
-from pychemstation.control import HPLCController, MethodController, SequenceController
+from pychemstation.control import HPLCController
 import pandas as pd
 
 # these paths will be unique to your Chemstation setup
+DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
+DEFAULT_METHOD = "GENERAL-POROSHELL"
 DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
 DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
-DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\hplc-method-optimization\\tests"
+SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\2\\Sequence"
 
 hplc_controller = HPLCController(data_dir=DATA_DIR,
-                                 comm_dir=DEFAULT_COMMAND_PATH)
-method_controller = MethodController(controller=hplc_controller,
-                                     src=DEFAULT_METHOD_DIR)
+                                 comm_dir=DEFAULT_COMMAND_PATH,
+                                 sequence_dir=SEQUENCE_DIR,
+                                 method_dir=DEFAULT_METHOD_DIR)
 
 hplc_controller.preprun()
-method_controller.switch(method_name="General-Poroshell")
-method_controller.run(experiment_name="Run 10")
-data_ready = method_controller.data_ready()
+hplc_controller.switch_method(method_name=DEFAULT_METHOD)
+hplc_controller.run_method(experiment_name="Run 10")
+data_status_valid, chrom = hplc_controller.get_last_run_method_data()
 
-if data_ready:
-    chrom = method_controller.get_data()
+if data_status_valid:
     # afterwards, save, analyze or plot the data!
     values = {"x": chrom.x, "y": chrom.y}
     chromatogram_data = pd.DataFrame.from_dict(values)

pychemstation-0.5.1/pychemstation/control/__init__.py

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

{pychemstation-0.4.7.dev3 → pychemstation-0.5.1}/pychemstation/control/comm.py

@@ -1,5 +1,5 @@
 """
-Module to provide API for the remote control of the Agilent HPLC systems.
+Module to provide API for the communication with Agilent HPLC systems.
 
 HPLCController sends commands to Chemstation software via a command file.
 Answers are received via reply file. On the Chemstation side, a custom
@@ -10,38 +10,29 @@ been processed.
 Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
 
-import logging
 import os
 import time
 
-import polling
-
-from ..utils.chromatogram import AgilentHPLCChromatogram
 from ..utils.constants import MAX_CMD_NO
 from ..utils.macro import *
 from ..utils.method_types import *
 
 
-class HPLCController:
+class CommunicationController:
     """
-    Class to control Agilent HPLC systems via Chemstation Macros.
+    Class that communicates with Agilent using Macros
     """
 
     def __init__(
             self,
             comm_dir: str,
-            data_dir: str,
             cmd_file: str = "cmd",
             reply_file: str = "reply",
     ):
-        """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
-        `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.
-        :param data_dir: Name of directory that ChemStation saves run data. Must be accessible by ChemStation.
+        """
+        :param comm_dir:
         :param cmd_file: Name of command file
         :param reply_file: Name of reply file
-        :raises FileNotFoundError: If either `data_dir`, `method_dir` or `comm_dir` is not a valid directory.
         """
         if os.path.isdir(comm_dir):
             self.cmd_file = os.path.join(comm_dir, cmd_file)
@@ -51,75 +42,47 @@ class HPLCController:
             raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
         self._most_recent_hplc_status = None
 
-        if os.path.isdir(data_dir):
-            self.data_dir = data_dir
-        else:
-            raise FileNotFoundError(f"data_dir: {data_dir} not found.")
-
-        self.spectra = {
-            "A": AgilentHPLCChromatogram(self.data_dir),
-            "B": AgilentHPLCChromatogram(self.data_dir),
-            "C": AgilentHPLCChromatogram(self.data_dir),
-            "D": AgilentHPLCChromatogram(self.data_dir),
-        }
-
-        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()
         open(self.reply_file, "a").close()
 
-        self.logger = logging.getLogger("hplc_logger")
-        self.logger.addHandler(logging.NullHandler())
-
         self.reset_cmd_counter()
 
-        self.logger.info("HPLC Controller initialized.")
+    def get_status(self) -> list[Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]]:
+        """Get device status(es).
+
+        :return: list of ChemStation's current status
+        """
+        self.send(Command.GET_STATUS_CMD)
+        time.sleep(1)
+
+        try:
+            parsed_response = self.receive().splitlines()[1].split()[1:]
+            recieved_status = [str_to_status(res) for res in parsed_response]
+            self._most_recent_hplc_status = recieved_status[0]
+            return recieved_status
+        except IOError:
+            return [HPLCErrorStatus.NORESPONSE]
+        except IndexError:
+            return [HPLCErrorStatus.MALFORMED]
 
-    def _set_status(self):
+    def set_status(self):
         """Updates current status of HPLC machine"""
-        self._most_recent_hplc_status = self.status()[0]
+        self._most_recent_hplc_status = self.get_status()[0]
 
-    def _check_data_status(self) -> bool:
+    def _check_data_status(self, data_path: str) -> bool:
         """Checks if HPLC machine is in an available state, meaning a state that data is not being written.
 
         :return: whether the HPLC machine is in a safe state to retrieve data back."""
         old_status = self._most_recent_hplc_status
-        self._set_status()
-        file_exists = os.path.exists(self.data_files[-1]) if len(self.data_files) > 0 else False
+        self.set_status()
+        file_exists = os.path.exists(data_path)
         done_writing_data = isinstance(self._most_recent_hplc_status,
                                        HPLCAvailStatus) and old_status != self._most_recent_hplc_status and file_exists
         return done_writing_data
 
-    def check_hplc_ready_with_data(self) -> bool:
-        """Checks if ChemStation has finished writing data and can be read back.
-
-        :param method: if you are running a method and want to read back data, the timeout period will be adjusted to be longer than the method's runtime
-
-        :return: Return True if data can be read back, else False.
-        """
-        self._set_status()
-
-        timeout = 10 * 60
-        hplc_run_done = polling.poll(
-            lambda: self._check_data_status(),
-            timeout=timeout,
-            step=30
-        )
-
-        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 check_data(self, data_path: str) -> bool:
+        return self._check_data_status(data_path)
 
     def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
         """Low-level execution primitive. Sends a command string to HPLC.
@@ -137,10 +100,8 @@ class HPLCController:
                     cmd_file.write(f"{cmd_no} {cmd}")
             except IOError as e:
                 err = e
-                self.logger.warning("Failed to send command; trying again.")
                 continue
             else:
-                self.logger.info("Sent command #%d: %s.", cmd_no, cmd)
                 return
         else:
             raise IOError(f"Failed to send command #{cmd_no}: {cmd}.") from err
@@ -162,7 +123,6 @@ class HPLCController:
                     response = reply_file.read()
             except OSError as e:
                 err = e
-                self.logger.warning("Failed to read from reply file; trying again.")
                 continue
 
             try:
@@ -170,19 +130,12 @@ class HPLCController:
                 response_no = int(first_line.split()[0])
             except IndexError as e:
                 err = e
-                self.logger.warning("Malformed response %s; trying again.", response)
                 continue
 
             # check that response corresponds to sent command
             if response_no == cmd_no:
-                self.logger.info("Reply: \n%s", response)
                 return response
             else:
-                self.logger.warning(
-                    "Response #: %d != command #: %d; trying again.",
-                    response_no,
-                    cmd_no,
-                )
                 continue
         else:
             raise IOError(f"Failed to receive reply to command #{cmd_no}.") from err
@@ -217,60 +170,6 @@ class HPLCController:
         self._receive(cmd_no=MAX_CMD_NO + 1)
         self.cmd_no = 0
 
-        self.logger.debug("Reset command counter")
-
-    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))
-        self.logger.debug("Sleep command sent.")
-
-    def standby(self):
-        """Switches all modules in standby mode. All lamps and pumps are switched off."""
-        self.send(Command.STANDBY_CMD)
-        self.logger.debug("Standby command sent.")
-
-    def preprun(self):
-        """ Prepares all modules for run. All lamps and pumps are switched on."""
-        self.send(Command.PREPRUN_CMD)
-        self.logger.debug("PrepRun command sent.")
-
-    def status(self) -> list[Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]]:
-        """Get device status(es).
-
-        :return: list of ChemStation's current status
-        """
-        self.send(Command.GET_STATUS_CMD)
-        time.sleep(1)
-
-        try:
-            parsed_response = self.receive().splitlines()[1].split()[1:]
-        except IOError:
-            return [HPLCErrorStatus.NORESPONSE]
-        except IndexError:
-            return [HPLCErrorStatus.MALFORMED]
-        recieved_status = [str_to_status(res) for res in parsed_response]
-        self._most_recent_hplc_status = recieved_status[0]
-        return recieved_status
-
     def stop_macro(self):
         """Stops Macro execution. Connection will be lost."""
         self.send(Command.STOP_MACRO_CMD)
-
-    def lamp_on(self):
-        """Turns the UV lamp on."""
-        self.send(Command.LAMP_ON_CMD)
-
-    def lamp_off(self):
-        """Turns the UV lamp off."""
-        self.send(Command.LAMP_OFF_CMD)
-
-    def pump_on(self):
-        """Turns on the pump on."""
-        self.send(Command.PUMP_ON_CMD)
-
-    def pump_off(self):
-        """Turns the pump off."""
-        self.send(Command.PUMP_OFF_CMD)

pychemstation-0.5.1/pychemstation/control/hplc.py

@@ -0,0 +1,150 @@
+"""
+Module to provide API for higher-level HPLC actions.
+
+Authors: Lucy Hao
+"""
+
+from typing import Union, Optional
+
+from ..control import CommunicationController
+from ..control.table import MethodController, SequenceController
+from ..utils.chromatogram import AgilentHPLCChromatogram
+from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus
+from ..utils.method_types import MethodTimetable
+from ..utils.sequence_types import SequenceTable, SequenceEntry
+
+
+class HPLCController:
+    def __init__(self,
+                 comm_dir: str,
+                 data_dir: str,
+                 method_dir: str,
+                 sequence_dir: str):
+        """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
+        `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.
+        """
+        self.comm = CommunicationController(comm_dir=comm_dir)
+        self.method_controller = MethodController(controller=self.comm, src=method_dir, data_dir=data_dir)
+        self.sequence_controller = SequenceController(controller=self.comm, src=sequence_dir, data_dir=data_dir)
+
+    def send(self, cmd: Union[Command, str]):
+        self.comm.send(cmd)
+
+    def receive(self) -> str:
+        return self.comm.receive()
+
+    def status(self) -> list[HPLCRunningStatus | HPLCAvailStatus | HPLCErrorStatus]:
+        return self.comm.get_status()
+
+    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.method_controller.switch(method_name)
+
+    def switch_sequence(self, sequence_name: str):
+        """
+         Allows the user to switch between pre-programmed sequences. The sequence name does not need the '.S' extension.
+         For example. for the method named 'mySeq.S', only 'mySeq' is needed.
+
+        :param seq_name: The name of the sequence file
+        """
+        self.sequence_controller.switch(sequence_name)
+
+    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 <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
+        """
+        self.method_controller.run(experiment_name)
+
+    def run_sequence(self, sequence_table: SequenceTable):
+        """
+        Starts the currently loaded sequence, storing data
+        under the <data_dir>/<sequence table name> folder.
+        Device must be ready.
+
+        :param sequence_table:
+        """
+        self.sequence_controller.run(sequence_table)
+
+    def edit_method(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.
+        """
+        self.method_controller.edit(updated_method)
+
+    def edit_sequence(self, updated_sequence: 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_row` instead.
+
+        :param sequence_table:
+        """
+        self.sequence_controller.edit(updated_sequence)
+
+    def edit_sequence_row(self, row: SequenceEntry, 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
+        """
+        self.sequence_controller.edit_row(row, num)
+
+    def get_last_run_method_data(self) -> Optional[dict[str, AgilentHPLCChromatogram]]:
+        """
+        Returns the last run method data.
+        """
+        data_valid, data = self.method_controller.get_data()
+        if data_valid:
+            return data
+        return None
+
+    def get_last_run_sequence_data(self) -> Optional[list[dict[str, AgilentHPLCChromatogram]]]:
+        """
+        Returns data for all rows in the last run sequence data.
+        """
+        data_valid, data = self.sequence_controller.get_data()
+        if data_valid:
+            return data
+        return None
+
+    def standby(self):
+        """Switches all modules in standby mode. All lamps and pumps are switched off."""
+        self.send(Command.STANDBY_CMD)
+
+    def preprun(self):
+        """ Prepares all modules for run. All lamps and pumps are switched on."""
+        self.send(Command.PREPRUN_CMD)
+
+    def lamp_on(self):
+        """Turns the UV lamp on."""
+        self.send(Command.LAMP_ON_CMD)
+
+    def lamp_off(self):
+        """Turns the UV lamp off."""
+        self.send(Command.LAMP_OFF_CMD)
+
+    def pump_on(self):
+        """Turns on the pump on."""
+        self.send(Command.PUMP_ON_CMD)
+
+    def pump_off(self):
+        """Turns the pump off."""
+        self.send(Command.PUMP_OFF_CMD)

{pychemstation-0.4.7.dev3/pychemstation/control → pychemstation-0.5.1/pychemstation/control/table}/__init__.py

@@ -1,6 +1,3 @@
-"""
-.. include:: README.md
-"""
-from .comm import HPLCController
 from .method import MethodController
 from .sequence import SequenceController
+from .table_controller import TableController

{pychemstation-0.4.7.dev3/pychemstation/control → pychemstation-0.5.1/pychemstation/control/table}/method.py

@@ -1,15 +1,17 @@
 import os
 import time
+from typing import Optional, Any
 
 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
+from .. import CommunicationController
+from ...control.table.table_controller import TableController
+from ...generated import PumpMethod, DadMethod, SolventElement
+from ...utils.chromatogram import TIME_FORMAT
+from ...utils.constants import METHOD_TIMETABLE
+from ...utils.macro import Command
+from ...utils.method_types import PType, TimeTableEntry, Param, MethodTimetable, HPLCMethodParams
+from ...utils.table_types import RegisterFlag, TableOperation
 
 
 class MethodController(TableController):
@@ -17,11 +19,12 @@ class MethodController(TableController):
     Class containing method related logic
     """
 
-    def __init__(self, controller: HPLCController, src: str):
-        super().__init__(controller, src)
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str):
+        super().__init__(controller, src, data_dir)
 
     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.
+        """
+        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
@@ -31,7 +34,8 @@ class MethodController(TableController):
         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'
+        """
+        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.
 
@@ -56,26 +60,9 @@ class MethodController(TableController):
 
         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
+        """
+        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.
 
@@ -92,8 +79,8 @@ class MethodController(TableController):
             method = parser.parse(method_path, PumpMethod)
             dad = parser.parse(dad_path, DadMethod)
 
-            organic_modifier = None
-            aq_modifier = None
+            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:
@@ -142,16 +129,22 @@ class MethodController(TableController):
 
         :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
+        initial_organic_modifier: Param = Param(val=updated_method.first_row.organic_modifier,
+                                                chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+                                                ptype=PType.NUM)
+        max_time: Param = Param(val=updated_method.first_row.maximum_run_time,
+                                chemstation_key=RegisterFlag.MAX_TIME,
+                                ptype=PType.NUM)
+        flow: Param = Param(val=updated_method.first_row.flow,
+                            chemstation_key=RegisterFlag.FLOW,
+                            ptype=PType.NUM)
+        temperature: Param = Param(val=updated_method.first_row.temperature,
+                                   chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
+                                                   RegisterFlag.COLUMN_OVEN_TEMP2],
+                                   ptype=PType.NUM)
 
         # Method settings required for all runs
-        self.send(TableOperation.DELETE_TABLE.value.format(register=METHOD_TIMETABLE.register,
-                                                           table_name=METHOD_TIMETABLE.name, ))
+        self.delete_table(METHOD_TIMETABLE)
         self._update_param(initial_organic_modifier)
         self._update_param(flow)
         self._update_param(Param(val="Set",
@@ -210,7 +203,8 @@ class MethodController(TableController):
                 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)
+        """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.
         """
@@ -228,5 +222,37 @@ class MethodController(TableController):
         time.sleep(2)
 
     def stop(self):
-        """Stops the run. A dialog window will pop up and manual intervention may be required."""
+        """
+        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):
+        """
+        This is the preferred method to trigger a run.
+        Starts the currently selected method, storing data
+        under the <data_dir>/<experiment_name>.D folder.
+        The <experiment_name> will be appended with a timestamp in the '%Y-%m-%d-%H-%M' format.
+        Device must be ready.
+
+        :param experiment_name: Name of the experiment
+        """
+        timestamp = time.strftime(TIME_FORMAT)
+
+        self.send(Command.RUN_METHOD_CMD.value.format(data_dir=self.data_dir,
+                                                      experiment_name=experiment_name,
+                                                      timestamp=timestamp))
+
+        folder_name = f"{experiment_name}_{timestamp}.D"
+        self.data_files.append(os.path.join(self.data_dir, folder_name))
+
+    def retrieve_recent_data_files(self) -> str:
+        return self.data_files[-1]
+
+    def get_data(self) -> tuple[bool, Any]:
+        data_ready = self.data_ready()
+        if data_ready:
+            self.get_spectrum(self.data_files[-1])
+            return data_ready, self.spectra
+        else:
+            return False, None