pychemstation 0.10.6__py3-none-any.whl → 0.10.7.dev1__py3-none-any.whl

pychemstation/control/hplc.py

@@ -6,6 +6,7 @@ Authors: Lucy Hao
 
 from __future__ import annotations
 
+import os.path
 from typing import Dict, List, Optional, Tuple, Union
 
 from pychemstation.analysis.chromatogram import AgilentChannelChromatogramData
@@ -36,9 +37,9 @@ class HPLCController:
     def __init__(
         self,
         comm_dir: str,
-        method_dir: str,
-        sequence_dir: str,
-        data_dirs: List[str],
+        method_dir: Optional[str] = None,
+        sequence_dir: Optional[str] = None,
+        extra_data_dirs: Optional[List[str]] = None,
         offline: bool = False,
         debug: bool = False,
     ):
@@ -47,37 +48,47 @@ class HPLCController:
         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. 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.
         """
         self.comm: CommunicationController = CommunicationController(
-            comm_dir=comm_dir, debug=debug
-        )
-        self.method_controller: MethodController = MethodController(
-            controller=self.comm,
-            src=method_dir,
-            data_dirs=data_dirs,
-            table=self.METHOD_TIMETABLE,
-            offline=offline,
-            injector_controller=InjectorController(
-                controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
-            ),
-        )
-        self.sequence_controller: SequenceController = SequenceController(
-            controller=self.comm,
-            src=sequence_dir,
-            data_dirs=data_dirs,
-            table=self.SEQUENCE_TABLE,
-            method_controller=self.method_controller,
-            offline=offline,
+            comm_dir=comm_dir, debug=debug, offline=offline
         )
+        data_dirs: List[str] = []
+        if not offline:
+            if not method_dir or not sequence_dir or not extra_data_dirs:
+                method_dir, sequence_dir, data_dirs = self.comm.get_chemstation_dirs()
+            if extra_data_dirs:
+                data_dirs.extend(extra_data_dirs)
+            data_dirs = list(set([os.path.normpath(p) for p in data_dirs]))
+        if (method_dir and sequence_dir and data_dirs and not offline) or offline:
+            self.method_controller: MethodController = MethodController(
+                controller=self.comm,
+                src=method_dir,
+                data_dirs=data_dirs,
+                table=self.METHOD_TIMETABLE,
+                offline=offline,
+                injector_controller=InjectorController(
+                    controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
+                ),
+            )
+            self.sequence_controller: SequenceController = SequenceController(
+                controller=self.comm,
+                src=sequence_dir,
+                data_dirs=data_dirs,
+                table=self.SEQUENCE_TABLE,
+                method_controller=self.method_controller,
+                offline=offline,
+            )
+        elif not offline and (not method_dir or not sequence_dir or not data_dirs):
+            raise ValueError(
+                f"Expected a method dir: {method_dir}, sequence dir: {sequence_dir} and data dirs:{data_dirs} but one was None."
+            )
+        else:
+            raise ValueError("Expected error occured, please try again.")
 
     def send(self, cmd: Union[Command, str]):
-        """
-        Sends any Command or string to Chemstation.
+        """Sends any Command or string to Chemstation.
 
         :param cmd: the macro to send to Chemstation
         """
@@ -88,10 +99,9 @@ class HPLCController:
         self.comm.send(cmd)
 
     def receive(self) -> None | Response | str:
-        """
-        Get the most recent response from Chemstation.
+        """Get the most recent response from Chemstation.
 
-        :return: most recent response from a macro that returned a response.
+        :return: most recent response from the most recently sent MACRO that returned a response.
         """
         if not self.comm:
             raise RuntimeError(
@@ -100,8 +110,7 @@ class HPLCController:
         return self.comm.receive().value
 
     def status(self) -> Status:
-        """
-        Get the current status of the HPLC machine.
+        """Get the current status of the HPLC machine.
 
         :return: current status of the HPLC machine; Status types can be found in `pychemstation.utils.macro`
         """
@@ -112,8 +121,7 @@ class HPLCController:
         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'
+        """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.
 
@@ -124,8 +132,7 @@ class HPLCController:
         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.
+        """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 sequence_name: The name of the sequence file
@@ -138,8 +145,7 @@ class HPLCController:
         add_timestamp: bool = True,
         stall_while_running: bool = True,
     ):
-        """
-        This is the preferred method to trigger a run.
+        """This is the preferred method to trigger a run.
         Starts the currently selected method, storing data
         under the <data_dir>/<experiment_name>.D folder.
         Device must be ready.
@@ -159,8 +165,7 @@ class HPLCController:
         self.method_controller.stop()
 
     def run_sequence(self, stall_while_running: bool = True):
-        """
-        Starts the currently loaded sequence, storing data
+        """Starts the currently loaded sequence, storing data
         under one of the data_dirs/<sequence table name> folder.
         Device must be ready.
 
@@ -169,24 +174,21 @@ class HPLCController:
         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.
+        """Check if the currently running method (if any) is done.
 
-        :returns the percent of the method run completed, and whether the run is complete.
+        :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.
+        """Check if the currently running sequence (if any) is done.
 
         :return: 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 saved to disk, or just modified.
@@ -194,8 +196,7 @@ class HPLCController:
         self.method_controller.edit(updated_method, save)
 
     def edit_sequence(self, updated_sequence: SequenceTable):
-        """
-        Updates the currently loaded sequence table with the provided table, and saves the sequence.
+        """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.
         """
@@ -206,8 +207,7 @@ class HPLCController:
         custom_path: Optional[str] = None,
         report_type: ReportType = ReportType.CSV,
     ) -> AgilentReport:
-        """
-        Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
+        """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
@@ -220,8 +220,7 @@ class HPLCController:
     def get_last_run_method_data(
         self, read_uv: bool = False, custom_path: Optional[str] = None
     ) -> Dict[int, AgilentHPLCChromatogram] | AgilentChannelChromatogramData:
-        """
-        Returns the last run method data.
+        """Returns the last run method data.
 
         :param custom_path: If you want to just load method data but from a file path. This file path must be the complete file path.
         :param read_uv: whether to also read the UV file
@@ -236,8 +235,7 @@ class HPLCController:
         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.
+        """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
@@ -252,8 +250,7 @@ class HPLCController:
     ) -> (
         List[Dict[int, AgilentHPLCChromatogram]] | List[AgilentChannelChromatogramData]
     ):
-        """
-        Returns data for all rows in the last run sequence data.
+        """Returns data for all rows in the last run sequence data.
 
         :param custom_path: If you want to just load sequence data but from a file path. This file path must be the complete file path.
         :param read_uv: whether to also read the UV file
@@ -265,11 +262,11 @@ class HPLCController:
 
     def check_loaded_sequence(self) -> str:
         """Returns the name of the currently loaded sequence."""
-        return self.sequence_controller.check()
+        return self.sequence_controller.get_current_sequence_name()
 
     def check_loaded_method(self) -> str:
         """Returns the name of the currently loaded method."""
-        return self.method_controller.check()
+        return self.method_controller.get_current_method_name()
 
     def load_method(self) -> MethodDetails:
         """Returns details of the currently loaded method, such as its starting modifier conditions and timetable."""
@@ -279,7 +276,7 @@ class HPLCController:
         """Returns the currently loaded sequence."""
         return self.sequence_controller.load()
 
-    def load_injector_program(self) -> InjectorTable:
+    def load_injector_program(self) -> InjectorTable | None:
         return self.method_controller.injector_controller.load()
 
     def standby(self):

pychemstation/utils/__init__.py

@@ -0,0 +1,23 @@
+from . import abc_tables
+from . import injector_types
+from . import macro
+from . import method_types
+from . import num_utils
+from . import parsing
+from . import sequence_types
+from . import spec_utils
+from . import table_types
+from . import tray_types
+
+__all__ = [
+    "abc_tables",
+    "injector_types",
+    "macro",
+    "method_types",
+    "num_utils",
+    "parsing",
+    "sequence_types",
+    "spec_utils",
+    "table_types",
+    "tray_types",
+]

pychemstation/utils/{mocking → abc_tables}/abc_comm.py

@@ -18,17 +18,17 @@ from typing import Union
 
 from result import Err, Ok, Result
 
-from ...utils.macro import (
-    HPLCAvailStatus,
-    Command,
-    Status,
-    Response,
-)
+from ..macro import HPLCAvailStatus, Command, Response, Status
 
 
 class ABCCommunicationController(abc.ABC):
-    """
-    Abstract class representing the communication controller.
+    """Abstract class representing the communication controller.
+
+    :param comm_dir: the complete directory path that was used in the MACRO file, common file that pychemstation and Chemstation use to communicate.
+    :param cmd_file: name of the write file that pychemstation writes MACROs to, in `comm_dir`
+    :param reply_file: name of the read file that Chemstation replies to, in `comm_dir
+    :param offline: whether or not communication with Chemstation is to be established
+    :param debug: if True, prints all send MACROs to an out.txt file
     """
 
     # maximum command number
@@ -42,12 +42,6 @@ class ABCCommunicationController(abc.ABC):
         offline: bool = False,
         debug: bool = False,
     ):
-        """
-        :param comm_dir:
-        :param cmd_file: Name of command file
-        :param reply_file: Name of reply file
-        :param debug: whether to save log of sent commands
-        """
         if not offline:
             self.debug = debug
             if os.path.isdir(comm_dir):

pychemstation/utils/abc_tables/device.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from abc import ABC
+
+from .table import ABCTableController
+from ..table_types import Table
+from ...control.controllers import CommunicationController
+
+
+class DeviceController(ABCTableController, ABC):
+    """Abstract controller representing tables that contain device information.
+
+    :param controller: controller for sending MACROs
+    :param table: contains register keys for accessing table in Chemstation
+    :param offline: whether the communication controller is online.
+    """
+
+    def __init__(
+        self, controller: CommunicationController, table: Table, offline: bool
+    ):
+        super().__init__(controller=controller, table=table)
+        self.offline = offline
+
+    def __new__(cls, *args, **kwargs):
+        if cls is ABCTableController:
+            raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls)

pychemstation/{control/controllers → utils}/abc_tables/run.py

@@ -11,60 +11,69 @@ import math
 import os
 import time
 import warnings
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union, Set
 
 import polling
 import rainbow as rb
-from result import Err, Result, Ok
+from result import Err, Ok, Result
+
+from ..macro import HPLCRunningStatus, Command
+from ..method_types import MethodDetails
+from ..sequence_types import SequenceTable
+from ..table_types import Table, T
+from ...analysis.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
 
 from .table import ABCTableController
-from ....analysis.process_report import (
+from ...analysis.process_report import (
+    ReportType,
     AgilentReport,
     CSVProcessor,
-    ReportType,
     TXTProcessor,
 )
-from ....control.controllers.comm import CommunicationController
-from pychemstation.analysis.chromatogram import (
-    AgilentChannelChromatogramData,
-    AgilentHPLCChromatogram,
-)
-from ....utils.macro import HPLCRunningStatus
-from ....utils.method_types import MethodDetails
-from ....utils.sequence_types import SequenceTable
-from ....utils.table_types import Table, T
+from ...control.controllers import CommunicationController
 
 TableType = Union[MethodDetails, SequenceTable]
 
 
 class RunController(ABCTableController, abc.ABC):
+    """Abstract controller for all tables that can trigger runs on Chemstation.
+
+    :param controller: the controller for sending MACROs, must be initialized for a run to be triggered.
+    :param src: complete directory path where files containing run parameters are stored.
+    :param data_dirs: list of complete directories that Chemstation will write data to.
+    :param table: contains register keys for accessing table in Chemstation.
+    :param offline: whether the communication controller is online.
+    """
+
     def __init__(
         self,
         controller: Optional[CommunicationController],
-        src: str,
-        data_dirs: List[str],
+        src: Optional[str],
+        data_dirs: Optional[List[str]],
         table: Table,
         offline: bool = False,
     ):
         super().__init__(controller=controller, table=table)
-        warnings.warn(
-            "This abstract class is not meant to be initialized. Use MethodController or SequenceController."
-        )
         self.table_state: Optional[TableType] = None
         self.curr_run_starting_time: Optional[float] = None
         self.timeout: Optional[float] = None
+        self.current_run_child_files: Set[str] = set()
 
         if not offline:
             if src and not os.path.isdir(src):
                 raise FileNotFoundError(f"dir: {src} not found.")
-
-            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
+            if data_dirs:
+                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!")
+            if src and data_dirs:
+                self.src: str = src
+                self.data_dirs: List[str] = data_dirs
 
         self.spectra: dict[str, AgilentHPLCChromatogram] = {
             "A": AgilentHPLCChromatogram(),
@@ -79,8 +88,15 @@ class RunController(ABCTableController, abc.ABC):
         self.uv: Dict[int, AgilentHPLCChromatogram] = {}
         self.data_files: List = []
 
+    def __new__(cls, *args, **kwargs):
+        if cls is RunController:
+            raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls)
+
     @abc.abstractmethod
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+    def _fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_dirs: Set[str]
+    ) -> Result[T, str]:
         pass
 
     @abc.abstractmethod
@@ -120,6 +136,12 @@ class RunController(ABCTableController, abc.ABC):
 
     def check_hplc_run_finished(self) -> Tuple[float, bool]:
         if self.controller:
+            try:
+                _, current_run_file = self.get_current_run_data_dir_file()
+                sample_file, extension, _ = current_run_file.partition(".D")
+                self.current_run_child_files.add(sample_file)
+            except Exception:
+                pass
             done_running = self.controller.check_if_not_running()
             if self.curr_run_starting_time and self.timeout:
                 time_passed = time.time() - self.curr_run_starting_time
@@ -136,11 +158,11 @@ class RunController(ABCTableController, abc.ABC):
         raise ValueError("Controller is offline!")
 
     def check_hplc_done_running(self) -> Ok[T] | Err[str]:
-        """
-        Checks if ChemStation has finished running and can read data back
+        """Checks if ChemStation has finished running and can read data back
 
         :return: Data file object containing most recent run file information.
         """
+        self.current_run_child_files = set()
         if self.timeout is not None:
             finished_run = False
             minutes = math.ceil(self.timeout / 60)
@@ -170,7 +192,9 @@ class RunController(ABCTableController, abc.ABC):
         else:
             raise ValueError("Timeout value is None, no comparison can be made.")
 
-        check_folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+        check_folder = self._fuzzy_match_most_recent_folder(
+            self.data_files[-1], self.current_run_child_files
+        )
         if check_folder.is_ok() and finished_run:
             return check_folder
         elif check_folder.is_ok():
@@ -183,7 +207,7 @@ class RunController(ABCTableController, abc.ABC):
             except Exception:
                 self._reset_time()
                 return self.data_files[-1]
-        return Err("Run did not complete as expected")
+        return Err("Run not may not have completed.")
 
     def get_uv_spectrum(self, path: str):
         data_uv = rb.agilent.chemstation.parse_file(os.path.join(path, "DAD1.UV"))
@@ -212,9 +236,7 @@ class RunController(ABCTableController, abc.ABC):
         raise ValueError("Expected one of ReportType.TXT or ReportType.CSV")
 
     def get_spectrum_at_channels(self, data_path: str):
-        """
-        Load chromatogram for any channel in spectra dictionary.
-        """
+        """Load chromatogram for any channel in spectra dictionary."""
         for channel, spec in self.spectra.items():
             try:
                 spec.load_spectrum(data_path=data_path, channel=channel)
@@ -226,3 +248,16 @@ class RunController(ABCTableController, abc.ABC):
     def _reset_time(self):
         self.curr_run_starting_time = None
         self.timeout = None
+
+    def get_current_run_data_dir_file(self) -> Tuple[str, str]:
+        self.send(Command.GET_CURRENT_RUN_DATA_DIR)
+        full_path_name = self.receive()
+        self.send(Command.GET_CURRENT_RUN_DATA_FILE)
+        current_sample_file = self.receive()
+        if full_path_name.is_ok() and current_sample_file.is_ok():
+            return (
+                full_path_name.ok_value.string_response,
+                current_sample_file.ok_value.string_response,
+            )
+        else:
+            raise ValueError("Couldn't read data dir and file.")

pychemstation/{control/controllers → utils}/abc_tables/table.py

@@ -7,33 +7,39 @@ Authors: Lucy Hao
 from __future__ import annotations
 
 import abc
-import warnings
 from typing import Optional, Union
 
 from result import Err, Result
 
-from ....control.controllers.comm import CommunicationController
-from ....utils.macro import Command, Response
-from ....utils.method_types import MethodDetails
-from ....utils.sequence_types import SequenceTable
-from ....utils.table_types import RegisterFlag, Table, TableOperation
+from ..macro import Command, Response
+from ..method_types import MethodDetails
+from ..sequence_types import SequenceTable
+from ..table_types import Table, RegisterFlag, TableOperation
+from ...control.controllers import CommunicationController
 
 TableType = Union[MethodDetails, SequenceTable]
 
 
 class ABCTableController(abc.ABC):
+    """Abstract controller for all table-like objects in Chemstation.
+    :param controller: controller for sending MACROs to Chemstation
+    :param table: contains register keys needed for accessing table in Chemstation.
+    """
+
     def __init__(
         self,
         controller: Optional[CommunicationController],
         table: Table,
     ):
-        warnings.warn(
-            "This abstract class is not meant to be initialized. Use MethodController or SequenceController."
-        )
         self.controller = controller
         self.table_locator = table
         self.table_state: Optional[TableType] = None
 
+    def __new__(cls, *args, **kwargs):
+        if cls is ABCTableController:
+            raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls, *args, **kwargs)
+
     def receive(self) -> Result[Response, str]:
         if self.controller:
             for _ in range(10):
@@ -59,8 +65,7 @@ class ABCTableController(abc.ABC):
             raise ValueError("Controller is offline")
 
     def sleep(self, seconds: int):
-        """
-        Tells the HPLC to wait for a specified number of seconds.
+        """Tells the HPLC to wait for a specified number of seconds.
 
         :param seconds: number of seconds to wait
         """
@@ -93,6 +98,8 @@ class ABCTableController(abc.ABC):
             raise ValueError("Controller is offline")
 
     def add_new_col_num(self, col_name: RegisterFlag, val: Union[int, float]):
+        if not (isinstance(val, int) or isinstance(val, float)):
+            raise ValueError(f"{val} must be an int or float.")
         self.sleepy_send(
             TableOperation.NEW_COL_VAL.value.format(
                 register=self.table_locator.register,
@@ -103,6 +110,8 @@ class ABCTableController(abc.ABC):
         )
 
     def add_new_col_text(self, col_name: RegisterFlag, val: str):
+        if not isinstance(val, str):
+            raise ValueError(f"{val} must be a str.")
         self.sleepy_send(
             TableOperation.NEW_COL_TEXT.value.format(
                 register=self.table_locator.register,
@@ -115,10 +124,12 @@ class ABCTableController(abc.ABC):
     def _edit_row_num(
         self, col_name: RegisterFlag, val: Union[int, float], row: Optional[int] = None
     ):
+        if not (isinstance(val, int) or isinstance(val, float)):
+            raise ValueError(f"{val} must be an int or float.")
         if row:
             num_rows = self.get_num_rows()
             if num_rows.is_ok():
-                if num_rows.value.num_response < row:
+                if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
 
         self.sleepy_send(
@@ -134,10 +145,12 @@ class ABCTableController(abc.ABC):
     def _edit_row_text(
         self, col_name: RegisterFlag, val: str, row: Optional[int] = None
     ):
+        if not isinstance(val, str):
+            raise ValueError(f"{val} must be a str.")
         if row:
             num_rows = self.get_num_rows()
             if num_rows.is_ok():
-                if num_rows.value.num_response < row:
+                if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
 
         self.sleepy_send(
@@ -164,9 +177,7 @@ class ABCTableController(abc.ABC):
         )
 
     def add_row(self):
-        """
-        Adds a row to the provided table for currently loaded method or sequence.
-        """
+        """Adds a row to the provided table for currently loaded method or sequence."""
         self.sleepy_send(
             TableOperation.NEW_ROW.value.format(
                 register=self.table_locator.register, table_name=self.table_locator.name
@@ -174,9 +185,7 @@ class ABCTableController(abc.ABC):
         )
 
     def delete_table(self):
-        """
-        Deletes the table for the current loaded method or sequence.
-        """
+        """Deletes the table."""
         self.sleepy_send(
             TableOperation.DELETE_TABLE.value.format(
                 register=self.table_locator.register, table_name=self.table_locator.name
@@ -184,9 +193,7 @@ class ABCTableController(abc.ABC):
         )
 
     def new_table(self):
-        """
-        Creates the table for the currently loaded method or sequence.
-        """
+        """Creates the table."""
         self.send(
             TableOperation.CREATE_TABLE.value.format(
                 register=self.table_locator.register, table_name=self.table_locator.name