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

pychemstation/analysis/__init__.py

@@ -1,4 +1,11 @@
 from .process_report import CSVProcessor
 from .process_report import TXTProcessor
+from .chromatogram import AgilentChannelChromatogramData
+from .chromatogram import AgilentHPLCChromatogram
 
-__all__ = ["CSVProcessor", "TXTProcessor"]
+__all__ = [
+    "CSVProcessor",
+    "TXTProcessor",
+    "AgilentChannelChromatogramData",
+    "AgilentHPLCChromatogram",
+]

pychemstation/control/README.md

@@ -10,7 +10,7 @@ DATA_DIR_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
 DATA_DIR_3 = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
 
 # Initialize HPLC Controller
-hplc_controller = HPLCController(data_dirs=[DATA_DIR_2, DATA_DIR_3],
+hplc_controller = HPLCController(extra_data_dirs=[DATA_DIR_2, DATA_DIR_3],
                                  comm_dir=DEFAULT_COMMAND_PATH,
                                  method_dir=DEFAULT_METHOD_DIR,
                                  sequence_dir=SEQUENCE_DIR)

pychemstation/control/controllers/__init__.py

@@ -3,6 +3,6 @@
 """
 
 from .comm import CommunicationController
-from . import tables
+from . import data_aq
 
-__all__ = ["CommunicationController", "tables"]
+__all__ = ["CommunicationController", "data_aq"]

pychemstation/control/controllers/abc_tables/abc_comm.py

@@ -0,0 +1,155 @@
+"""
+Module to provide API for the communication with Agilent HPLC systems.
+
+HPLCController sends commands to Chemstation software via a command file.
+Answers are received via reply file. On the Chemstation side, a custom
+Macro monitors the command file, executes commands and writes to the reply file.
+Each command is given a number (cmd_no) to keep track of which commands have
+been processed.
+
+Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
+"""
+
+import abc
+import os
+import time
+from abc import abstractmethod
+from typing import Union
+
+from result import Err, Ok, Result
+
+from ....utils.macro import Status, HPLCAvailStatus, Command, Response
+
+
+class ABCCommunicationController(abc.ABC):
+    """
+    Abstract class representing the communication controller.
+    """
+
+    # maximum command number
+    MAX_CMD_NO = 255
+
+    def __init__(
+        self,
+        comm_dir: str,
+        cmd_file: str = "cmd",
+        reply_file: str = "reply",
+        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):
+                self.cmd_file = os.path.join(comm_dir, cmd_file)
+                self.reply_file = os.path.join(comm_dir, reply_file)
+                self.cmd_no = 0
+            else:
+                raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
+
+            # Create files for Chemstation to communicate with Python
+            open(self.cmd_file, "a").close()
+            open(self.reply_file, "a").close()
+
+            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]:
+        pass
+
+    @abstractmethod
+    def get_text_val(self, cmd: str) -> str:
+        pass
+
+    @abstractmethod
+    def get_status(self) -> Status:
+        pass
+
+    @abstractmethod
+    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
+        pass
+
+    @abstractmethod
+    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
+        pass
+
+    def set_status(self):
+        """Updates current status of HPLC machine"""
+        self._most_recent_hplc_status = self.get_status()
+
+    def check_if_not_running(self) -> bool:
+        """Checks if HPLC machine is in an available state, meaning a state that data is not being written.
+
+        :return: whether the HPLC machine is in a safe state to retrieve data back."""
+        self.set_status()
+        hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
+        time.sleep(5)
+        self.set_status()
+        hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
+        return hplc_avail and hplc_actually_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.
+
+        :param cmd: Command to be sent to HPLC
+        """
+        if self.cmd_no == self.MAX_CMD_NO:
+            self.reset_cmd_counter()
+
+        cmd_to_send: str = cmd.value if isinstance(cmd, Command) else cmd
+        self.cmd_no += 1
+        self._send(cmd_to_send, self.cmd_no)
+        if self.debug:
+            f = open("out.txt", "a")
+            f.write(cmd_to_send + "\n")
+            f.close()
+
+    def receive(self) -> Result[Response, str]:
+        """Returns messages received in reply file.
+
+        :return: ChemStation response
+        """
+        num_response_prefix = "Numerical Responses:"
+        str_response_prefix = "String Responses:"
+        possible_response = self._receive(self.cmd_no)
+        if possible_response.is_ok():
+            lines = possible_response.ok_value.splitlines()
+            for line in lines:
+                if str_response_prefix in line and num_response_prefix in line:
+                    string_responses_dirty, _, numerical_responses = line.partition(
+                        num_response_prefix
+                    )
+                    _, _, string_responses = string_responses_dirty.partition(
+                        str_response_prefix
+                    )
+                    return Ok(
+                        Response(
+                            string_response=string_responses.strip(),
+                            num_response=float(numerical_responses.strip()),
+                        )
+                    )
+            return Err("Could not retrieve HPLC response")
+        else:
+            return Err(f"Could not establish response to HPLC: {possible_response}")
+
+    def reset_cmd_counter(self):
+        """Resets the command counter."""
+        self._send(Command.RESET_COUNTER_CMD.value, cmd_no=self.MAX_CMD_NO + 1)
+        self._receive(cmd_no=self.MAX_CMD_NO + 1)
+        self.cmd_no = 0
+
+    def stop_macro(self):
+        """Stops Macro execution. Connection will be lost."""
+        self.send(Command.STOP_MACRO_CMD)

pychemstation/control/controllers/abc_tables/device.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from abc import ABC
+
+from ....control.controllers import CommunicationController
+from ....utils.table_types import Table
+from .table import ABCTableController
+
+
+class DeviceController(ABCTableController, ABC):
+    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/{tables/table.py → abc_tables/run.py}

@@ -11,11 +11,16 @@ 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 pychemstation.analysis.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
 
 from ....analysis.process_report import (
     AgilentReport,
@@ -24,19 +29,16 @@ from ....analysis.process_report import (
     TXTProcessor,
 )
 from ....control.controllers.comm import CommunicationController
-from pychemstation.analysis.chromatogram import (
-    AgilentChannelChromatogramData,
-    AgilentHPLCChromatogram,
-)
-from ....utils.macro import Command, HPLCRunningStatus, Response
+from ....utils.macro import Command, HPLCRunningStatus
 from ....utils.method_types import MethodDetails
 from ....utils.sequence_types import SequenceTable
-from ....utils.table_types import RegisterFlag, Table, TableOperation, T
+from ....utils.table_types import T, Table
+from .table import ABCTableController
 
 TableType = Union[MethodDetails, SequenceTable]
 
 
-class TableController(abc.ABC):
+class RunController(ABCTableController, abc.ABC):
     def __init__(
         self,
         controller: Optional[CommunicationController],
@@ -45,11 +47,11 @@ class TableController(abc.ABC):
         table: Table,
         offline: bool = False,
     ):
-        self.controller = controller
-        self.table_locator = table
+        super().__init__(controller=controller, table=table)
         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):
@@ -76,179 +78,34 @@ class TableController(abc.ABC):
         self.uv: Dict[int, AgilentHPLCChromatogram] = {}
         self.data_files: List = []
 
-    def receive(self) -> Result[Response, str]:
-        if self.controller:
-            for _ in range(10):
-                try:
-                    return self.controller.receive()
-                except IndexError:
-                    continue
-            return Err("Could not parse response")
-        else:
-            raise ValueError("Controller is offline!")
-
-    def send(self, cmd: Union[Command, str]):
-        if not self.controller:
-            raise RuntimeError(
-                "Communication controller must be initialized before sending command. It is currently in offline mode."
-            )
-        self.controller.send(cmd)
-
-    def sleepy_send(self, cmd: Union[Command, str]):
-        if self.controller:
-            self.controller.sleepy_send(cmd)
-        else:
-            raise ValueError("Controller is offline")
-
-    def sleep(self, seconds: int):
-        """
-        Tells the HPLC to wait for a specified number of seconds.
-
-        :param seconds: number of seconds to wait
-        """
-        self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
-
-    def get_num(self, row: int, col_name: RegisterFlag) -> Union[int, float]:
-        if self.controller:
-            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,
-                )
-            )
-        else:
-            raise ValueError("Controller is offline")
-
-    def get_text(self, row: int, col_name: RegisterFlag) -> str:
-        if self.controller:
-            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,
-                )
-            )
-        else:
-            raise ValueError("Controller is offline")
-
-    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_locator.register,
-                table_name=self.table_locator.name,
-                col_name=col_name,
-                val=val,
-            )
-        )
-
-    def add_new_col_text(self, col_name: RegisterFlag, val: str):
-        self.sleepy_send(
-            TableOperation.NEW_COL_TEXT.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                col_name=col_name,
-                val=val,
-            )
-        )
-
-    def _edit_row_num(
-        self, col_name: RegisterFlag, val: Union[int, float], row: Optional[int] = None
-    ):
-        self.sleepy_send(
-            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",
-                col_name=col_name,
-                val=val,
-            )
-        )
-
-    def _edit_row_text(
-        self, col_name: RegisterFlag, val: str, row: Optional[int] = None
-    ):
-        self.sleepy_send(
-            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",
-                col_name=col_name,
-                val=val,
-            )
-        )
+    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 get_row(self, row: int):
+    def fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_files: Set[str]
+    ) -> Result[T, str]:
         pass
 
-    def delete_row(self, row: int):
-        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.
-        """
-        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.
-        """
-        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.
-        """
-        self.send(
-            TableOperation.CREATE_TABLE.value.format(
-                register=self.table_locator.register, table_name=self.table_locator.name
-            )
-        )
+    @abc.abstractmethod
+    def get_data(
+        self, custom_path: Optional[str] = None
+    ) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        pass
 
-    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,
-                table_name=self.table_locator.name,
-                col_name=RegisterFlag.NUM_ROWS,
-            )
-        )
-        if self.controller:
-            res = self.controller.receive()
-        else:
-            raise ValueError("Controller is offline")
+    @abc.abstractmethod
+    def get_data_uv(
+        self, custom_path: str | None = None
+    ) -> Dict[int, AgilentHPLCChromatogram]:
+        pass
 
-        if res.is_ok():
-            self.send("Sleep 0.1")
-            self.send("Print Rows")
-            return res
-        else:
-            return Err("No rows could be read.")
+    @abc.abstractmethod
+    def get_report(
+        self, custom_path: str, report_type: ReportType = ReportType.TXT
+    ) -> List[AgilentReport]:
+        pass
 
     def check_hplc_is_running(self) -> bool:
         if self.controller:
@@ -269,6 +126,12 @@ class TableController(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
@@ -290,6 +153,7 @@ class TableController(abc.ABC):
 
         :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)
@@ -319,7 +183,9 @@ class TableController(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():
@@ -334,28 +200,6 @@ class TableController(abc.ABC):
                 return self.data_files[-1]
         return Err("Run did not complete as expected")
 
-    @abc.abstractmethod
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
-        pass
-
-    @abc.abstractmethod
-    def get_data(
-        self, custom_path: Optional[str] = None
-    ) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
-        pass
-
-    @abc.abstractmethod
-    def get_data_uv(
-        self, custom_path: str | None = None
-    ) -> Dict[int, AgilentHPLCChromatogram]:
-        pass
-
-    @abc.abstractmethod
-    def get_report(
-        self, custom_path: str, 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"))
         times = data_uv.xlabels
@@ -397,3 +241,16 @@ class TableController(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.")