pychemstation 0.10.5__tar.gz → 0.10.6__tar.gz

{pychemstation-0.10.5 → pychemstation-0.10.6}/.gitignore

@@ -6,4 +6,4 @@
 target
 .DS_Store
 env
-venv
+venv

{pychemstation-0.10.5 → pychemstation-0.10.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.5
+Version: 0.10.6
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Project-URL: Documentation, https://pychemstation-e5a086.gitlab.io/pychemstation.html
 Project-URL: Repository, https://gitlab.com/heingroup/device-api/pychemstation

pychemstation-0.10.6/pychemstation/analysis/__init__.py

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

{pychemstation-0.10.5 → pychemstation-0.10.6}/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-0.10.6/pychemstation/control/controllers/abc_tables/device.py

@@ -0,0 +1,15 @@
+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

pychemstation-0.10.5/pychemstation/control/controllers/tables/table.py → pychemstation-0.10.6/pychemstation/control/controllers/abc_tables/run.py

@@ -17,6 +17,7 @@ import polling
 import rainbow as rb
 from result import Err, Result, Ok
 
+from .table import ABCTableController
 from ....analysis.process_report import (
     AgilentReport,
     CSVProcessor,
@@ -28,15 +29,15 @@ from pychemstation.analysis.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
-from ....utils.macro import Command, HPLCRunningStatus, Response
+from ....utils.macro import 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 Table, T
 
 TableType = Union[MethodDetails, SequenceTable]
 
 
-class TableController(abc.ABC):
+class RunController(ABCTableController, abc.ABC):
     def __init__(
         self,
         controller: Optional[CommunicationController],
@@ -45,8 +46,10 @@ class TableController(abc.ABC):
         table: Table,
         offline: bool = False,
     ):
-        self.controller = controller
-        self.table_locator = table
+        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
@@ -76,179 +79,27 @@ 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,
-            )
-        )
-
     @abc.abstractmethod
-    def get_row(self, row: int):
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> 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:
@@ -334,28 +185,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

pychemstation-0.10.6/pychemstation/control/controllers/abc_tables/table.py

@@ -0,0 +1,221 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+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
+
+TableType = Union[MethodDetails, SequenceTable]
+
+
+class ABCTableController(abc.ABC):
+    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 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
+    ):
+        if row:
+            num_rows = self.get_num_rows()
+            if num_rows.is_ok():
+                if num_rows.value.num_response < row:
+                    raise ValueError("Not enough rows to edit!")
+
+        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
+    ):
+        if row:
+            num_rows = self.get_num_rows()
+            if num_rows.is_ok():
+                if num_rows.value.num_response < row:
+                    raise ValueError("Not enough rows to edit!")
+
+        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,
+            )
+        )
+
+    @abc.abstractmethod
+    def get_row(self, row: int):
+        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
+            )
+        )
+
+    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")
+
+        if res.is_ok():
+            self.send("Sleep 0.1")
+            self.send("Print Rows")
+            return res
+        else:
+            return Err("No rows could be read.")

pychemstation-0.10.6/pychemstation/control/controllers/comm.py

@@ -0,0 +1,150 @@
+"""
+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 time
+from typing import Optional, Union
+
+from result import Err, Ok, Result
+
+from ...utils.macro import (
+    str_to_status,
+    HPLCErrorStatus,
+    Command,
+    Status,
+)
+from ...utils.mocking.abc_comm import ABCCommunicationController
+
+
+class CommunicationController(ABCCommunicationController):
+    """
+    Class that communicates with Agilent using Macros
+    """
+
+    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
+        """
+        super().__init__(comm_dir, cmd_file, reply_file, offline, debug)
+
+    def get_num_val(self, cmd: str) -> Union[int, float]:
+        tries = 10
+        for _ in range(tries):
+            self.send(Command.GET_NUM_VAL_CMD.value.format(cmd=cmd))
+            res = self.receive()
+            if res.is_ok():
+                return res.ok_value.num_response
+        raise RuntimeError("Failed to get number.")
+
+    def get_text_val(self, cmd: str) -> str:
+        tries = 10
+        for _ in range(tries):
+            self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
+            res = self.receive()
+            if res.is_ok():
+                return res.ok_value.string_response
+        raise RuntimeError("Failed to get string")
+
+    def get_status(self) -> Status:
+        """Get device status(es).
+
+        :return: list of ChemStation's current status
+        """
+        self.send(Command.GET_STATUS_CMD)
+        time.sleep(1)
+
+        try:
+            res = self.receive()
+            if res.is_err():
+                return HPLCErrorStatus.NORESPONSE
+            if res.is_ok():
+                parsed_response = self.receive().value.string_response
+                self._most_recent_hplc_status = str_to_status(parsed_response)
+                return self._most_recent_hplc_status
+            else:
+                raise RuntimeError("Failed to get status")
+        except IOError:
+            return HPLCErrorStatus.NORESPONSE
+        except IndexError:
+            return HPLCErrorStatus.MALFORMED
+
+    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
+        """Low-level execution primitive. Sends a command string to HPLC.
+
+        :param cmd: string to be sent to HPLC
+        :param cmd_no: Command number
+        :param num_attempts: Number of attempts to send the command before raising exception.
+        :raises IOError: Could not write to command file.
+        """
+        err = None
+        for _ in range(num_attempts):
+            time.sleep(1)
+            try:
+                with open(self.cmd_file, "w", encoding="utf8") as cmd_file:
+                    cmd_file.write(f"{cmd_no} {cmd}")
+            except IOError as e:
+                err = e
+                continue
+            else:
+                return
+        else:
+            raise IOError(f"Failed to send command #{cmd_no}: {cmd}.") from err
+
+    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
+        """Low-level execution primitive. Recives a response from HPLC.
+
+        :param cmd_no: Command number
+        :param num_attempts: Number of retries to open reply file
+        :raises IOError: Could not read reply file.
+        :return: Potential ChemStation response
+        """
+        err: Optional[Union[OSError, IndexError, ValueError]] = None
+        err_msg = ""
+        for _ in range(num_attempts):
+            time.sleep(1)
+
+            try:
+                with open(self.reply_file, "r", encoding="utf_16") as reply_file:
+                    response = reply_file.read()
+            except OSError as e:
+                err = e
+                continue
+
+            try:
+                first_line = response.splitlines()[0]
+                try:
+                    response_no = int(first_line.split()[0])
+                except ValueError as e:
+                    err = e
+                    err_msg = f"Caused by {first_line}"
+            except IndexError as e:
+                err = e
+                continue
+
+            # check that response corresponds to sent command
+            if response_no == cmd_no:
+                return Ok(response)
+            else:
+                continue
+        else:
+            return Err(
+                f"Failed to receive reply to command #{cmd_no} due to {err} caused by {err_msg}."
+            )