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

pychemstation/control/hplc.py

@@ -32,8 +32,6 @@ class HPLCController:
 
     INJECTOR_TABLE = Table(register="RCWLS1Pretreatment[1]", name="InstructionTable")
 
-    DAD_TABLE = Table(register="RCDAD1Method[1]", name="Timetable")
-
     MSD_TABLE = Table(register="MSACQINFO[1]", name="SprayChamber")
 
     def __init__(
@@ -63,7 +61,7 @@ class HPLCController:
             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:
+        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,
@@ -82,14 +80,15 @@ class HPLCController:
                 method_controller=self.method_controller,
                 offline=offline,
             )
-        else:
+        elif not offline and (not method_dir or not sequence_dir or not data_dirs):
             raise ValueError(
-                "Expected a method dir, sequence dir and data dirs but they were None."
+                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
         """
@@ -100,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(
@@ -112,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`
         """
@@ -124,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.
 
@@ -136,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
@@ -150,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.
@@ -171,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.
 
@@ -181,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.
@@ -206,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.
         """
@@ -218,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
@@ -232,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
@@ -248,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
@@ -264,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
@@ -277,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."""

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/{control/controllers → utils}/abc_tables/abc_comm.py

@@ -18,12 +18,17 @@ from typing import Union
 
 from result import Err, Ok, Result
 
-from ....utils.macro import Status, HPLCAvailStatus, Command, 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
@@ -37,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/{control/controllers → utils}/abc_tables/device.py

@@ -2,12 +2,19 @@ from __future__ import annotations
 
 from abc import ABC
 
-from ....control.controllers import CommunicationController
-from ....utils.table_types import Table
 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
     ):

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

@@ -17,33 +17,42 @@ import polling
 import rainbow as rb
 from result import Err, Ok, Result
 
-from pychemstation.analysis.chromatogram import (
+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 ....analysis.process_report import (
+from .table import ABCTableController
+from ...analysis.process_report import (
+    ReportType,
     AgilentReport,
     CSVProcessor,
-    ReportType,
     TXTProcessor,
 )
-from ....control.controllers.comm import CommunicationController
-from ....utils.macro import Command, HPLCRunningStatus
-from ....utils.method_types import MethodDetails
-from ....utils.sequence_types import SequenceTable
-from ....utils.table_types import T, Table
-from .table import ABCTableController
+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,
     ):
@@ -56,14 +65,15 @@ class RunController(ABCTableController, abc.ABC):
         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(),
@@ -84,8 +94,8 @@ class RunController(ABCTableController, abc.ABC):
         return object.__new__(cls)
 
     @abc.abstractmethod
-    def fuzzy_match_most_recent_folder(
-        self, most_recent_folder: T, child_files: Set[str]
+    def _fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_dirs: Set[str]
     ) -> Result[T, str]:
         pass
 
@@ -148,8 +158,7 @@ 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.
         """
@@ -183,7 +192,7 @@ 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(
+        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:
@@ -198,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"))
@@ -227,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)

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

@@ -11,16 +11,21 @@ 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],
@@ -60,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
         """
@@ -173,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
@@ -183,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
@@ -193,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

pychemstation/utils/macro.py

@@ -7,6 +7,8 @@ from typing import Union
 
 @dataclass
 class Response:
+    """Class representing a response from Chemstation"""
+
     string_response: str
     num_response: Union[int, float]
 

pychemstation/utils/method_types.py

@@ -4,8 +4,6 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Optional, Union
 
-from ..generated import Signal
-from .injector_types import InjectorTable
 from .table_types import RegisterFlag
 
 
@@ -23,6 +21,8 @@ class Param:
 
 @dataclass
 class HPLCMethodParams:
+    """The starting conditions of a run that are displayed in the Chemstation GUI for the pump."""
+
     organic_modifier: float
     flow: float
     pressure: Optional[float] = None  # TODO: find this
@@ -30,6 +30,8 @@ class HPLCMethodParams:
 
 @dataclass
 class TimeTableEntry:
+    """Row in a method timetable."""
+
     start_time: float
     organic_modifer: Optional[float]
     flow: Optional[float] = None
@@ -37,21 +39,18 @@ class TimeTableEntry:
 
 @dataclass
 class MethodDetails:
-    """An Agilent Chemstation method, TODO is to add MS parameters, injector parameters
-
-    :attribute name: the name of the method, should be the same as the Chemstation method name.
-    :attribute timetable: list of entries in the method timetable
-    :attribute stop_time: the time the method stops running after the last timetable entry.
-    :attribute post_time: the amount of time after the stoptime that the pumps keep running,
-        based on settings in the first row of the timetable.
-    :attribute params: the organic modifier (pump B) and flow rate displayed for the method (the time 0 settings)
-    :attribute dad_wavelengthes:
+    """An Agilent Chemstation method
+
+    :param name: the name of the method, should be the same as the Chemstation method name.
+    :param timetable: list of entries in the method timetable
+    :param stop_time: the time the method stops running after the last timetable entry. If `None`, won't be set.
+    :param post_time: the amount of time after the stoptime that the pumps keep running,
+        based on settings in the first row of the timetable. If `None`, won't be set.
+    :param params: the organic modifier (pump B) and flow rate displayed for the method (the time 0 settings)
     """
 
     name: str
     params: HPLCMethodParams
     timetable: list[TimeTableEntry]
-    injector_program: Optional[InjectorTable] = None
     stop_time: Optional[float] = None
     post_time: Optional[float] = None
-    dad_wavelengthes: Optional[list[Signal]] = None

pychemstation/utils/num_utils.py

@@ -18,7 +18,7 @@ def find_nearest_value_index(array, value) -> Tuple[float, int]:
     return array[index_], index_
 
 
-def interpolate_to_index(array, ids, precision: int = 100) -> np.array:
+def interpolate_to_index(array, ids, precision: int = 100) -> np.ndarray:
     """Find value in between arrays elements.
 
     Constructs linspace of size "precision" between index+1 and index to
@@ -37,8 +37,8 @@ def interpolate_to_index(array, ids, precision: int = 100) -> np.array:
     :return: New array with interpolated values according to provided indexes "ids".
 
     Example:
-        >>> interpolate_to_index(np.array([1.5]), np.array([1,2,3], 100))
-            array([2.50505051])
+        >>> interpolate_to_index(np.array([1.5]), np.array([1, 2, 3], 100))
+            ... array([2.50505051])
     """
 
     # breaking ids into fractional and integral parts

pychemstation/utils/sequence_types.py

@@ -9,6 +9,14 @@ from pychemstation.utils.tray_types import Tray
 
 @dataclass
 class SequenceDataFiles:
+    """Class to represent files generated during a sequence.
+
+    :param sequence_name: the name of the sequence that is running
+    :param dir: the complete path of the directory generated for the sequence
+    :param _data_files: the names of the files of the sequence runs, ends with ".D"
+    :param child_dirs: the complete path of the files for sequence runs, contains the Chemstation data, `dir` and the sample run file.
+    """
+
     sequence_name: str
     dir: str
     _data_files: List[str] = field(default_factory=list)
@@ -39,6 +47,8 @@ class InjectionSource(Enum):
 
 @dataclass
 class SequenceEntry:
+    """Class to represent each row of a sequence file, maps one to one to Chemstation."""
+
     data_file: str
     vial_location: Tray
     sample_name: Optional[str] = None
@@ -51,23 +61,30 @@ class SequenceEntry:
 
 @dataclass
 class SequenceTable:
+    """Class to represent a sequence file.
+
+    :param name: name of the sequence
+    :param rows: the entries
+    """
+
     name: str
     rows: list[SequenceEntry]
 
-    def __eq__(self, other):
-        equal = False
+    def __eq__(self, other) -> bool:
         if not isinstance(other, SequenceTable):
             return False
 
+        equal = True
         for self_row, other_row in zip(self.rows, other.rows):
-            equal |= self_row.vial_location == other_row.vial_location
-            equal |= self_row.data_file == other_row.data_file
-            equal |= (
+            equal &= self_row.vial_location == other_row.vial_location
+            equal &= self_row.data_file == other_row.data_file
+            equal &= (
                 os.path.split(os.path.normpath(self_row.method))[-1]
                 == os.path.split(os.path.normpath(other_row.method))[-1]
             )
-            equal |= self_row.num_inj == other_row.num_inj
-            equal |= self_row.inj_vol == other_row.inj_vol
-            equal |= self_row.inj_source == other_row.inj_source
-            equal |= self_row.sample_name == other_row.sample_name
-            equal |= self_row.sample_type == other_row.sample_type
+            equal &= self_row.num_inj == other_row.num_inj
+            equal &= self_row.inj_vol == other_row.inj_vol
+            equal &= self_row.inj_source == other_row.inj_source
+            equal &= self_row.sample_name == other_row.sample_name
+            equal &= self_row.sample_type == other_row.sample_type
+        return equal