pychemstation 0.10.5__py3-none-any.whl → 0.10.6__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/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/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/control/controllers/{tables/table.py → 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/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/control/controllers/comm.py

@@ -10,7 +10,6 @@ been processed.
 Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
 
-import os
 import time
 from typing import Optional, Union
 
@@ -18,22 +17,18 @@ from result import Err, Ok, Result
 
 from ...utils.macro import (
     str_to_status,
-    HPLCAvailStatus,
     HPLCErrorStatus,
     Command,
     Status,
-    Response,
 )
+from ...utils.mocking.abc_comm import ABCCommunicationController
 
 
-class CommunicationController:
+class CommunicationController(ABCCommunicationController):
     """
     Class that communicates with Agilent using Macros
     """
 
-    # maximum command number
-    MAX_CMD_NO = 255
-
     def __init__(
         self,
         comm_dir: str,
@@ -48,24 +43,7 @@ class CommunicationController:
         :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()
-
-            # Initialize row counter for table operations
-            self._most_recent_hplc_status: Status = self.get_status()
-            self.send("Local Rows")
+        super().__init__(comm_dir, cmd_file, reply_file, offline, debug)
 
     def get_num_val(self, cmd: str) -> Union[int, float]:
         tries = 10
@@ -108,21 +86,6 @@ class CommunicationController:
         except IndexError:
             return HPLCErrorStatus.MALFORMED
 
-    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 _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
         """Low-level execution primitive. Sends a command string to HPLC.
 
@@ -185,62 +148,3 @@ class CommunicationController:
             return Err(
                 f"Failed to receive reply to command #{cmd_no} due to {err} caused by {err_msg}."
             )
-
-    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/{tables → data_aq}/method.py

@@ -7,6 +7,7 @@ from typing import List, Optional, Union, Dict
 
 from result import Err, Ok, Result
 
+from ..abc_tables.run import RunController
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
 from pychemstation.analysis.chromatogram import (
@@ -24,10 +25,9 @@ from ....utils.method_types import (
 )
 from ....utils.table_types import RegisterFlag, Table, TableOperation, T
 from ..devices.injector import InjectorController
-from .table import TableController
 
 
-class MethodController(TableController):
+class MethodController(RunController):
     """
     Class containing method related logic
     """