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

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):
@@ -58,7 +57,6 @@ class ABCCommunicationController(abc.ABC):
 
             self.reset_cmd_counter()
             self._most_recent_hplc_status: Status = self.get_status()
-            self.send("Local Rows")
 
     @abstractmethod
     def get_num_val(self, cmd: str) -> Union[int, float]:
@@ -90,15 +88,19 @@ class ABCCommunicationController(abc.ABC):
         :return: whether the HPLC machine is in a safe state to retrieve data back."""
         self.set_status()
         hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        time.sleep(5)
+        time.sleep(10)
         self.set_status()
         hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        return hplc_avail and hplc_actually_avail
+        time.sleep(10)
+        self.set_status()
+        hplc_final_check_avail = isinstance(
+            self._most_recent_hplc_status, HPLCAvailStatus
+        )
+        return hplc_avail and hplc_actually_avail and hplc_final_check_avail
 
     def sleepy_send(self, cmd: Union[Command, str]):
         self.send("Sleep 0.1")
         self.send(cmd)
-        self.send("Sleep 0.1")
 
     def send(self, cmd: Union[Command, str]):
         """Sends a command to Chemstation.

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,9 +94,7 @@ 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]
-    ) -> Result[T, str]:
+    def _fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         pass
 
     @abc.abstractmethod
@@ -148,8 +156,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,9 +190,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(
-            self.data_files[-1], self.current_run_child_files
-        )
+        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():
@@ -198,7 +203,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 +232,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)
@@ -248,9 +251,14 @@ class RunController(ABCTableController, abc.ABC):
         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.")
+            if os.path.isdir(full_path_name.ok_value.string_response) and os.path.isdir(
+                os.path.join(
+                    full_path_name.ok_value.string_response,
+                    current_sample_file.ok_value.string_response,
+                )
+            ):
+                return (
+                    full_path_name.ok_value.string_response,
+                    current_sample_file.ok_value.string_response,
+                )
+        raise ValueError("Couldn't read data dir and file or doesn't exist yet.")

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
         """
@@ -122,8 +126,8 @@ class ABCTableController(abc.ABC):
     ):
         if not (isinstance(val, int) or isinstance(val, float)):
             raise ValueError(f"{val} must be an int or float.")
+        num_rows = self.get_num_rows()
         if row:
-            num_rows = self.get_num_rows()
             if num_rows.is_ok():
                 if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
@@ -132,7 +136,7 @@ class ABCTableController(abc.ABC):
             TableOperation.EDIT_ROW_VAL.value.format(
                 register=self.table_locator.register,
                 table_name=self.table_locator.name,
-                row=row if row is not None else "Rows",
+                row=row if row is not None else "response_num",
                 col_name=col_name,
                 val=val,
             )
@@ -143,8 +147,8 @@ class ABCTableController(abc.ABC):
     ):
         if not isinstance(val, str):
             raise ValueError(f"{val} must be a str.")
+        num_rows = self.get_num_rows()
         if row:
-            num_rows = self.get_num_rows()
             if num_rows.is_ok():
                 if num_rows.ok_value.num_response < row:
                     raise ValueError("Not enough rows to edit!")
@@ -153,7 +157,7 @@ class ABCTableController(abc.ABC):
             TableOperation.EDIT_ROW_TEXT.value.format(
                 register=self.table_locator.register,
                 table_name=self.table_locator.name,
-                row=row if row is not None else "Rows",
+                row=row if row is not None else "response_num",
                 col_name=col_name,
                 val=val,
             )
@@ -173,19 +177,19 @@ 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."""
+        previous_row_count = self.get_num_rows().ok_value.num_response
         self.sleepy_send(
             TableOperation.NEW_ROW.value.format(
                 register=self.table_locator.register, table_name=self.table_locator.name
             )
         )
+        new_row_count = self.get_num_rows().ok_value.num_response
+        if previous_row_count + 1 != new_row_count:
+            raise ValueError("Row could not be added.")
 
     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 +197,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
@@ -203,13 +205,6 @@ class ABCTableController(abc.ABC):
         )
 
     def get_num_rows(self) -> Result[Response, str]:
-        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_locator.register,
@@ -223,8 +218,16 @@ class ABCTableController(abc.ABC):
             raise ValueError("Controller is offline")
 
         if res.is_ok():
-            self.send("Sleep 0.1")
-            self.send("Print Rows")
             return res
         else:
             return Err("No rows could be read.")
+
+    def move_row(self, from_row: int, to_row: int):
+        self.send(
+            TableOperation.MOVE_ROW.value.format(
+                register=self.table_locator.register,
+                table_name=self.table_locator.name,
+                from_row=from_row,
+                to_row=to_row,
+            )
+        )

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]
 
@@ -53,12 +55,15 @@ class Command(Enum):
     # Get directories
     GET_METHOD_DIR = "response$ = _METHPATH$"
     GET_SEQUENCE_DIR = "response$ = _SEQUENCEPATHS$"
+    CONFIG_MET_PATH = "_CONFIGMETPATH"
+    CONFIG_SEQ_PATH = "_CONFIGSEQPATH"
+    GET_RUNNING_SEQUENCE_DIR = "response$ = _SEQPATHS$"
     GET_DATA_DIRS = "response$ = _DATAPATHS$"
     GET_CURRENT_RUN_DATA_DIR = "response$ = _DATAPath$"
     GET_CURRENT_RUN_DATA_FILE = "response$ = _DATAFILE1$"
 
-    # Debuggng
-    ERROR = "response$ = _ERROR$"
+    # Errors
+    ERROR = "response$ = _ERRMSG$"
 
 
 class HPLCRunningStatus(Enum):

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,28 +30,27 @@ class HPLCMethodParams:
 
 @dataclass
 class TimeTableEntry:
+    """Row in a method timetable."""
+
     start_time: float
-    organic_modifer: Optional[float]
+    organic_modifer: Optional[float] = None
     flow: Optional[float] = None
 
 
 @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/mocking/mock_comm.py

@@ -1,5 +1,28 @@
-from ...control.controllers.abc_tables.abc_comm import ABCCommunicationController
+from typing import Union
+
+from result import Result
+
+from .mock_hplc import MockHPLC
+from ..abc_tables.abc_comm import ABCCommunicationController
+from ..macro import Status
 
 
 class MockCommunicationController(ABCCommunicationController):
-    pass
+    def __init__(self, comm_dir: str):
+        super().__init__(comm_dir)
+        self.hplc = MockHPLC()
+
+    def get_num_val(self, cmd: str) -> Union[int, float]:
+        raise NotImplementedError
+
+    def get_text_val(self, cmd: str) -> str:
+        raise NotImplementedError
+
+    def get_status(self) -> Status:
+        raise NotImplementedError
+
+    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
+        raise NotImplementedError
+
+    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
+        raise NotImplementedError

pychemstation/utils/mocking/mock_hplc.py

@@ -1,2 +1,30 @@
+from ..macro import HPLCAvailStatus, Status
+from ..method_types import MethodDetails, HPLCMethodParams, TimeTableEntry
+from ..sequence_types import SequenceTable, SequenceEntry, InjectionSource
+from ..tray_types import FiftyFourVialPlate
+
+
 class MockHPLC:
-    pass
+    def __init__(self):
+        self.current_method: MethodDetails = MethodDetails(
+            name="General-Poroshell",
+            params=HPLCMethodParams(organic_modifier=5, flow=0.65),
+            timetable=[TimeTableEntry(start_time=3, organic_modifer=99, flow=0.65)],
+            stop_time=5,
+            post_time=2,
+        )
+        self.current_sequence: SequenceTable = SequenceTable(
+            name="hplc_testing",
+            rows=[
+                SequenceEntry(
+                    vial_location=FiftyFourVialPlate.from_str("P1-A2"),
+                    sample_name="sample1",
+                    data_file="sample1",
+                    method="General-Poroshell",
+                    num_inj=1,
+                    inj_vol=1,
+                    inj_source=InjectionSource.HIP_ALS,
+                )
+            ],
+        )
+        self.current_status: Status = HPLCAvailStatus.STANDBY

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,9 +9,15 @@ 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 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)
     child_dirs: List[str] = field(default_factory=list)
 
 
@@ -39,6 +45,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 +59,31 @@ 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 |= (
-                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.vial_location == other_row.vial_location
+            equal &= self_row.data_file == other_row.data_file
+            if self_row.method and other_row.method:
+                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
+        return equal