pychemstation 0.7.0.dev1__py3-none-any.whl → 0.8.0__py3-none-any.whl

pychemstation/control/controllers/tables/table.py

@@ -5,32 +5,26 @@ Authors: Lucy Hao
 """
 
 import abc
+import math
 import os
-import warnings
-from dataclasses import dataclass
-from typing import Union, Optional, AnyStr, List
+import time
+from typing import Union, Optional, List, Tuple, Dict
 
-import numpy as np
 import polling
 import rainbow as rb
-from result import Result, Ok, Err
+from result import Result, Err
 
+from ....analysis.process_report import AgilentReport, ReportType, CSVProcessor, TXTProcessor
 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
+from ....utils.table_types import Table, TableOperation, RegisterFlag, T
 
 TableType = Union[MethodDetails, SequenceTable]
 
 
-@dataclass
-class ChromData:
-    x: np.array
-    y: np.array
-
-
 class TableController(abc.ABC):
 
     def __init__(self, controller: CommunicationController,
@@ -39,36 +33,36 @@ class TableController(abc.ABC):
                  table: Table,
                  offline: bool = False):
         self.controller = controller
-        self.table = table
+        self.table_locator = table
         self.table_state: Optional[TableType] = None
+        self.curr_run_starting_time: Optional[float] = None
+        self.timeout: Optional[float] = None
 
         if not offline:
-            # Initialize row counter for table operations
-            self.send('Local Rows')
-
-            if src and os.path.isdir(src):
-                self.src: str = src
-            elif isinstance(src, str):
+            if src and not os.path.isdir(src):
                 raise FileNotFoundError(f"dir: {src} not found.")
 
-            if data_dirs:
-                for d in data_dirs:
-                    if not os.path.isdir(d):
-                        raise FileNotFoundError(f"dir: {d} not found.")
-                self.data_dirs: List[str] = data_dirs
-
-            self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
-                "A": AgilentHPLCChromatogram(),
-                "B": AgilentHPLCChromatogram(),
-                "C": AgilentHPLCChromatogram(),
-                "D": AgilentHPLCChromatogram(),
-                "E": AgilentHPLCChromatogram(),
-                "F": AgilentHPLCChromatogram(),
-                "G": AgilentHPLCChromatogram(),
-                "H": AgilentHPLCChromatogram(),
-            }
-        self.data_files: Union[list[SequenceDataFiles], list[str]] = []
-        self.uv = None
+            for d in data_dirs:
+                if not os.path.isdir(d):
+                    raise FileNotFoundError(f"dir: {d} not found.")
+                if r"\\" in d:
+                    raise ValueError("Data directories should not be raw strings!")
+            self.src: str = src
+            self.data_dirs: List[str] = data_dirs
+
+        self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
+            "A": AgilentHPLCChromatogram(),
+            "B": AgilentHPLCChromatogram(),
+            "C": AgilentHPLCChromatogram(),
+            "D": AgilentHPLCChromatogram(),
+            "E": AgilentHPLCChromatogram(),
+            "F": AgilentHPLCChromatogram(),
+            "G": AgilentHPLCChromatogram(),
+            "H": AgilentHPLCChromatogram(),
+        }
+        self.report: Optional[AgilentReport] = None
+        self.uv: Dict[str, AgilentHPLCChromatogram] = {}
+        self.data_files: List = []
 
     def receive(self) -> Result[Response, str]:
         for _ in range(10):
@@ -96,23 +90,24 @@ class TableController(abc.ABC):
         self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
 
     def get_num(self, row: int, col_name: RegisterFlag) -> Union[int, float]:
-        return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table.register,
-                                                                                   table_name=self.table.name,
+        return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table_locator.register,
+                                                                                   table_name=self.table_locator.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))
+        return self.controller.get_text_val(
+            TableOperation.GET_ROW_TEXT.value.format(register=self.table_locator.register,
+                                                     table_name=self.table_locator.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,
+            register=self.table_locator.register,
+            table_name=self.table_locator.name,
             col_name=col_name,
             val=val))
 
@@ -120,8 +115,8 @@ class TableController(abc.ABC):
                          col_name: RegisterFlag,
                          val: str):
         self.sleepy_send(TableOperation.NEW_COL_TEXT.value.format(
-            register=self.table.register,
-            table_name=self.table.name,
+            register=self.table_locator.register,
+            table_name=self.table_locator.name,
             col_name=col_name,
             val=val))
 
@@ -130,8 +125,8 @@ class TableController(abc.ABC):
                       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,
+            register=self.table_locator.register,
+            table_name=self.table_locator.name,
             row=row if row is not None else 'Rows',
             col_name=col_name,
             val=val))
@@ -141,8 +136,8 @@ class TableController(abc.ABC):
                        val: str,
                        row: Optional[int] = None):
         self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(
-            register=self.table.register,
-            table_name=self.table.name,
+            register=self.table_locator.register,
+            table_name=self.table_locator.name,
             row=row if row is not None else 'Rows',
             col_name=col_name,
             val=val))
@@ -152,48 +147,37 @@ class TableController(abc.ABC):
         pass
 
     def delete_row(self, row: int):
-        self.sleepy_send(TableOperation.DELETE_ROW.value.format(register=self.table.register,
-                                                                table_name=self.table.name,
+        self.sleepy_send(TableOperation.DELETE_ROW.value.format(register=self.table_locator.register,
+                                                                table_name=self.table_locator.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))
+        self.sleepy_send(TableOperation.NEW_ROW.value.format(register=self.table_locator.register,
+                                                             table_name=self.table_locator.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))
+        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=self.table_locator.register,
+                                                                  table_name=self.table_locator.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
+        Creates the table for the currently loaded method or sequence.
         """
-        self.send(TableOperation.CREATE_TABLE.value.format(register=self.table.register,
-                                                           table_name=self.table.name))
+        self.send(TableOperation.CREATE_TABLE.value.format(register=self.table_locator.register,
+                                                           table_name=self.table_locator.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,
+        self.send(TableOperation.GET_NUM_ROWS.value.format(register=self.table_locator.register,
+                                                           table_name=self.table_locator.name,
                                                            col_name=RegisterFlag.NUM_ROWS))
-        self.send(Command.GET_ROWS_CMD.value.format(register=self.table.register,
-                                                    table_name=self.table.name,
+        self.send(Command.GET_ROWS_CMD.value.format(register=self.table_locator.register,
+                                                    table_name=self.table_locator.name,
                                                     col_name=RegisterFlag.NUM_ROWS))
         res = self.controller.receive()
 
@@ -207,85 +191,93 @@ class TableController(abc.ABC):
     def check_hplc_is_running(self) -> bool:
         try:
             started_running = polling.poll(lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
-                                           step=3, max_tries=10)
+                                           step=1, max_tries=20)
         except Exception as e:
             print(e)
             return False
+        if started_running:
+            self.curr_run_starting_time = time.time()
         return started_running
 
-    def check_hplc_done_running(self,
-                                method: Optional[MethodDetails] = None,
-                                sequence: Optional[SequenceTable] = None) -> Result[str, str]:
+    def check_hplc_run_finished(self) -> Tuple[float, bool]:
+        time_passed = (time.time() - self.curr_run_starting_time)
+        if time_passed > self.timeout:
+            done_running = self.controller.check_if_not_running()
+            enough_time_passed = time_passed >= self.timeout
+            run_finished = enough_time_passed and done_running
+            if run_finished:
+                self._reset_time()
+                return 0, run_finished
+        return (time_passed / self.timeout), self.controller.check_if_not_running()
+
+    def check_hplc_done_running(self) -> Result[Union[SequenceDataFiles, 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
+        minutes = math.ceil(self.timeout / 60)
         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)
+            finished_run = not polling.poll(
+                lambda: self.check_hplc_run_finished()[1],
+                max_tries=minutes - 1, step=50)
+        except (polling.TimeoutException, polling.PollingException, polling.MaxCallException):
+            try:
+                finished_run = polling.poll(
+                    lambda: self.check_hplc_run_finished()[1],
+                    timeout=self.timeout / 2, step=1)
+            except (polling.TimeoutException, polling.PollingException, polling.MaxCallException):
+                pass
+
+        check_folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
         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:
+            try:
+                finished_run = polling.poll(
+                    lambda: self.check_hplc_run_finished()[1],
+                    max_tries=10,
+                    step=50)
+                if finished_run:
+                    return check_folder
+            except Exception:
+                self._reset_time()
                 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 = []
-        for d in self.data_dirs:
-            subdirs = [x[0] for x in os.walk(d)]
-            if len(subdirs) > 0:
-                break
-        assert len(subdirs) > 0
-        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 fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+        pass
 
     @abc.abstractmethod
-    def retrieve_recent_data_files(self):
+    def get_data(self) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
         pass
 
     @abc.abstractmethod
-    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def get_report(self, report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
         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}
+        for (wavelength, data) in zipped_data:
+            self.uv[wavelength] = AgilentHPLCChromatogram()
+            self.uv[wavelength].attach_spectrum(data_uv.xlabels, data)
+
+    def get_report_details(self, path: str,
+                           report_type: ReportType = ReportType.TXT) -> AgilentReport:
+        if report_type is ReportType.TXT:
+            txt_report = TXTProcessor(path).process_report()
+            if txt_report.is_ok():
+                self.report = txt_report.ok_value
+        if report_type is ReportType.CSV:
+            csv_report = CSVProcessor(path).process_report()
+            if csv_report.is_ok():
+                self.report = csv_report.ok_value
+        return self.report
 
     def get_spectrum(self, data_path: str, read_uv: bool = False):
         """
@@ -293,10 +285,13 @@ class TableController(abc.ABC):
         """
         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] = AgilentHPLCChromatogram()
                 print(f"No data at channel: {channel}")
+
+    def _reset_time(self):
+        self.curr_run_starting_time = None
+        self.timeout = None

pychemstation/control/hplc.py

@@ -4,15 +4,16 @@ Module to provide API for higher-level HPLC actions.
 Authors: Lucy Hao
 """
 
-from typing import Union, Optional, List
+from typing import Union, Optional, List, Tuple
 
 from .controllers.devices.injector import InjectorController
+from ..analysis.process_report import ReportType, AgilentReport
 from ..control.controllers import MethodController, SequenceController, CommunicationController
 from ..utils.chromatogram import AgilentChannelChromatogramData
 from ..utils.injector_types import InjectorTable
-from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
+from ..utils.macro import Command, Response, Status
 from ..utils.method_types import MethodDetails
-from ..utils.sequence_types import SequenceTable, SequenceEntry
+from ..utils.sequence_types import SequenceTable
 from ..utils.table_types import Table
 
 
@@ -45,11 +46,12 @@ class HPLCController:
                  data_dirs: List[str],
                  offline: bool = False):
         """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.
+        `comm_dir` must match the file path in the macro file. All file paths are normal strings, with the left slash
+        double escaped: "C:\\my_folder\\"
 
         :param comm_dir: Name of directory for communication, where ChemStation will read and write from. Can be any existing directory.
         :param data_dirs: Name of directories for storing data after method or sequence runs. Method data dir is default
-        the first one in the list. In other words, the first dir in the list is highest prio.
+        the first one in the list. In other words, the first dir in the list is highest prio. Must be "normal" strings and not r-strings.
         :param method_dir: Name of directory where method files are stored.
         :param sequence_dir: Name of directory where sequence files are stored.
         :raises FileNotFoundError: If either `data_dir`, `method_dir`, `sequence_dir`, `sequence_data_dir`or `comm_dir` is not a valid directory.
@@ -67,22 +69,37 @@ class HPLCController:
                                                       src=sequence_dir,
                                                       data_dirs=data_dirs,
                                                       table=self.SEQUENCE_TABLE,
-                                                      method_dir=method_dir,
+                                                      method_controller=self.method_controller,
                                                       offline=offline)
 
     def send(self, cmd: Union[Command, str]):
+        """
+        Sends any Command or string to Chemstation.
+
+        :param cmd: the macro to send to Chemstation
+        """
         if not self.comm:
             raise RuntimeError(
                 "Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.comm.send(cmd)
 
     def receive(self) -> Response:
+        """
+        Get the most recent response from Chemstation.
+
+        :returns: most recent response from a macro that returned a response.
+        """
         if not self.comm:
             raise RuntimeError(
                 "Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.comm.receive().value
 
-    def status(self) -> Union[HPLCRunningStatus | HPLCAvailStatus | HPLCErrorStatus]:
+    def status(self) -> Status:
+        """
+        Get the current status of the HPLC machine.
+
+        :returns: current status of the HPLC machine; Status types can be found in `pychemstation.utils.macro`
+        """
         if not self.comm:
             raise RuntimeError(
                 "Communication controller must be initialized before sending command. It is currently in offline mode.")
@@ -103,60 +120,84 @@ class HPLCController:
     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.
+         For example: for the method named 'mySeq.S', only 'mySeq' is needed.
 
         :param sequence_name: The name of the sequence file
         """
         self.sequence_controller.switch(sequence_name)
 
-    def run_method(self, experiment_name: str, stall_while_running: bool = True):
+    def run_method(self, experiment_name: str, add_timestamp: bool = True, 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
-        :param stall_while_running: whether this method should return or stall while HPLC runs.
+        :param stall_while_running: whether to return or stall while HPLC runs.
+        :param add_timestamp: whether to append a timestamp in '%Y-%m-%d-%H-%M' format to end of experiment name.
         """
-        self.method_controller.run(experiment_name, stall_while_running)
+        self.method_controller.run(experiment_name=experiment_name,
+                                   stall_while_running=stall_while_running,
+                                   add_timestamp=add_timestamp)
+
+    def stop_method(self):
+        """Stops the current running method, manual intervention may be needed."""
+        self.method_controller.stop()
 
     def run_sequence(self, stall_while_running: bool = True):
         """
         Starts the currently loaded sequence, storing data
-        under the <data_dir>/<sequence table name> folder.
+        under one of the data_dirs/<sequence table name> folder.
         Device must be ready.
 
-        :param stall_while_running: whether this method should return or stall while HPLC runs.
+        :param stall_while_running: whether to return or stall while HPLC runs.
         """
         self.sequence_controller.run(stall_while_running=stall_while_running)
 
+    def check_method_complete(self) -> Tuple[float, int]:
+        """
+        Check if the currently running method (if any) is done.
+
+        :returns: the percent of the method run completed, and whether the run is complete.
+        """
+        return self.method_controller.check_hplc_run_finished()
+
+    def check_sequence_complete(self) -> Tuple[float, int]:
+        """
+        Check if the currently running sequence (if any) is done.
+
+        :returns: the percent of the sequence run completed, and whether the run is complete.
+        """
+        return self.sequence_controller.check_hplc_run_finished()
+
     def edit_method(self, updated_method: MethodDetails, save: bool = False):
-        """Updated the currently loaded method in ChemStation with provided values.
+        """
+        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: whether this method should be to disk, or just modified.
+        :param save: whether this method should be saved to disk, or just modified.
         """
         self.method_controller.edit(updated_method, save)
 
     def edit_sequence(self, updated_sequence: SequenceTable):
         """
-        Updates the currently loaded sequence table with the provided table.
-        If you would only like to edit a single row of a sequence table, use `edit_sequence_row` instead.
+        Updates the currently loaded sequence table with the provided table, and saves the sequence.
 
         :param updated_sequence: The sequence table to be written to the currently loaded sequence table.
         """
         self.sequence_controller.edit(updated_sequence)
 
-    def edit_sequence_row(self, row: SequenceEntry, num: int):
+    def get_last_run_method_report(self,
+                                   custom_path: Optional[str] = None,
+                                   report_type: ReportType = ReportType.CSV) -> AgilentReport:
         """
-        Edits a row in the sequence table. Assumes the row already exists.
-
-        :param row: sequence row entry with updated information
-        :param num: the row to edit, based on 1-based indexing
+        Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
+        :param custom_path: path to sequence folder
+        :param report_type: read either the TXT or CSV version
+        :returns: report data for method
         """
-        self.sequence_controller._edit_row(row, num)
+        return self.method_controller.get_report(custom_path=custom_path, report_type=report_type)[0]
 
     def get_last_run_method_data(self, read_uv: bool = False,
                                  data: Optional[str] = None) -> AgilentChannelChromatogramData:
@@ -168,8 +209,19 @@ class HPLCController:
         """
         return self.method_controller.get_data(custom_path=data, read_uv=read_uv)
 
+    def get_last_run_sequence_reports(self,
+                                      custom_path: Optional[str] = None,
+                                      report_type: ReportType = ReportType.CSV) -> List[AgilentReport]:
+        """
+        Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
+        :param custom_path: path to sequence folder
+        :param report_type: read either the TXT or CSV version
+        :returns: list of reports for each row
+        """
+        return self.sequence_controller.get_report(custom_path=custom_path, report_type=report_type)
+
     def get_last_run_sequence_data(self, read_uv: bool = False,
-                                   data: Optional[str] = None) -> list[AgilentChannelChromatogramData]:
+                                   data: Optional[str] = None) -> List[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
 
@@ -179,30 +231,23 @@ class HPLCController:
         return self.sequence_controller.get_data(custom_path=data, read_uv=read_uv)
 
     def check_loaded_sequence(self) -> str:
-        """
-        Returns the name of the currently loaded sequence.
-        """
+        """Returns the name of the currently loaded sequence."""
         return self.sequence_controller.check()
 
     def check_loaded_method(self) -> str:
-        """
-        Returns the name of the currently loaded method.
-        """
+        """Returns the name of the currently loaded method."""
         return self.method_controller.check()
 
     def load_injector_program(self) -> InjectorTable:
+        """Returns all details of the injector program for the currently loaded method."""
         return self.method_controller.injector_controller.load()
 
     def load_method(self) -> MethodDetails:
-        """
-        Returns all details of the currently loaded method, including its timetable.
-        """
+        """Returns details of the currently loaded method, such as its starting modifier conditions and timetable."""
         return self.method_controller.load()
 
     def load_sequence(self) -> SequenceTable:
-        """
-        Returns the currently loaded sequence.
-        """
+        """Returns the currently loaded sequence."""
         return self.sequence_controller.load()
 
     def standby(self):

pychemstation/generated/dad_method.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Optional
+from typing import Optional, List
 
 
 @dataclass
@@ -202,8 +202,8 @@ class StopTime:
 
 @dataclass
 class Signals:
-    signal: list[Signal] = field(
-        default_factory=list,
+    signal: List[Signal] = field(
+        default_factory=List,
         metadata={
             "name": "Signal",
             "type": "Element",