pychemstation 0.10.4__py3-none-any.whl → 0.10.6__py3-none-any.whl

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,27 +17,24 @@ 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,
         cmd_file: str = "cmd",
         reply_file: str = "reply",
+        offline: bool = False,
         debug: bool = False,
     ):
         """
@@ -47,26 +43,10 @@ class CommunicationController:
         :param reply_file: Name of reply file
         :param debug: whether to save log of sent commands
         """
-        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.")
-        self._most_recent_hplc_status: Optional[Status] = None
-
-        # 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.send("Local Rows")
+        super().__init__(comm_dir, cmd_file, reply_file, offline, debug)
 
     def get_num_val(self, cmd: str) -> Union[int, float]:
-        tries = 5
+        tries = 10
         for _ in range(tries):
             self.send(Command.GET_NUM_VAL_CMD.value.format(cmd=cmd))
             res = self.receive()
@@ -75,7 +55,7 @@ class CommunicationController:
         raise RuntimeError("Failed to get number.")
 
     def get_text_val(self, cmd: str) -> str:
-        tries = 5
+        tries = 10
         for _ in range(tries):
             self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
             res = self.receive()
@@ -92,29 +72,20 @@ class CommunicationController:
         time.sleep(1)
 
         try:
-            parsed_response = self.receive().value.string_response
-            self._most_recent_hplc_status = str_to_status(parsed_response)
-            return self._most_recent_hplc_status
+            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 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.
 
@@ -145,7 +116,8 @@ class CommunicationController:
         :raises IOError: Could not read reply file.
         :return: Potential ChemStation response
         """
-        err: Optional[Union[OSError, IndexError]] = None
+        err: Optional[Union[OSError, IndexError, ValueError]] = None
+        err_msg = ""
         for _ in range(num_attempts):
             time.sleep(1)
 
@@ -158,7 +130,11 @@ class CommunicationController:
 
             try:
                 first_line = response.splitlines()[0]
-                response_no = int(first_line.split()[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
@@ -169,63 +145,6 @@ class CommunicationController:
             else:
                 continue
         else:
-            return Err(f"Failed to receive reply to command #{cmd_no} due to {err}.")
-
-    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)
+            return Err(
+                f"Failed to receive reply to command #{cmd_no} due to {err} caused by {err_msg}."
+            )

pychemstation/control/controllers/data_aq/__init__.py

@@ -0,0 +1,4 @@
+from .method import MethodController
+from .sequence import SequenceController
+
+__all__ = ["MethodController", "SequenceController"]

pychemstation/control/controllers/{tables → data_aq}/method.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
+
 import os
 import time
 import warnings
-from typing import Dict, List, Optional, Union
+from typing import List, Optional, Union, Dict
 
 from result import Err, Ok, Result
-from xsdata.formats.dataclass.parsers import XmlParser
 
+from ..abc_tables.run import RunController
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
-from ....generated import DadMethod, PumpMethod, SolventElement
 from pychemstation.analysis.chromatogram import (
     TIME_FORMAT,
     AgilentChannelChromatogramData,
@@ -22,12 +23,11 @@ from ....utils.method_types import (
     PType,
     TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, T, Table, TableOperation
+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
     """
@@ -61,20 +61,22 @@ class MethodController(TableController):
         return "ERROR"
 
     def get_method_params(self) -> HPLCMethodParams:
-        return HPLCMethodParams(
-            organic_modifier=self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
-                )
-            ),
-            flow=self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.FLOW,
-                )
-            ),
-        )
+        if self.controller:
+            return HPLCMethodParams(
+                organic_modifier=self.controller.get_num_val(
+                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                        register=self.table_locator.register,
+                        register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
+                    )
+                ),
+                flow=self.controller.get_num_val(
+                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                        register=self.table_locator.register,
+                        register_flag=RegisterFlag.FLOW,
+                    )
+                ),
+            )
+        raise ValueError("Communication controller is offline!")
 
     def get_row(self, row: int) -> TimeTableEntry:
         flow = None
@@ -89,6 +91,9 @@ class MethodController(TableController):
         except RuntimeError:
             pass
 
+        if om is None and flow is None:
+            raise ValueError("Both flow and organic modifier is None")
+
         return TimeTableEntry(
             start_time=self.get_num(row, RegisterFlag.TIME),
             organic_modifer=om,
@@ -97,7 +102,7 @@ class MethodController(TableController):
 
     def get_timetable(self, rows: int):
         uncoalesced_timetable_rows = [self.get_row(r + 1) for r in range(rows)]
-        timetable_rows = {}
+        timetable_rows: Dict[str, TimeTableEntry] = {}
         for row in uncoalesced_timetable_rows:
             time_key = str(row.start_time)
             if time_key not in timetable_rows.keys():
@@ -141,20 +146,24 @@ class MethodController(TableController):
         return method_name
 
     def get_post_time(self) -> Union[int, float]:
-        return self.controller.get_num_val(
-            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                register=self.table_locator.register,
-                register_flag=RegisterFlag.POST_TIME,
+        if self.controller:
+            return self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=RegisterFlag.POST_TIME,
+                )
             )
-        )
+        raise ValueError("Communication controller is not online!")
 
     def get_stop_time(self) -> Union[int, float]:
-        return self.controller.get_num_val(
-            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                register=self.table_locator.register,
-                register_flag=RegisterFlag.MAX_TIME,
+        if self.controller:
+            return self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=RegisterFlag.MAX_TIME,
+                )
             )
-        )
+        raise ValueError("Communication controller is not online!")
 
     def get_total_runtime(self) -> Union[int, float]:
         """Returns total method runtime in minutes."""
@@ -198,60 +207,6 @@ class MethodController(TableController):
             assert parsed_response == f"{method_name}.M", "Switching Methods failed."
         self.table_state = None
 
-    def load_from_disk(self, method_name: str) -> MethodDetails:
-        """
-        Retrieve method details of an existing method. Don't need to append ".M" to the end. This assumes the
-        organic modifier is in Channel B and that Channel A contains the aq layer. Additionally, assumes
-         only two solvents are being used.
-
-        :param method_name: name of method to load details of
-        :raises FileNotFoundError: Method does not exist
-        :return: method details
-        """
-        warnings.warn("This method is not actively maintained.")
-        method_folder = f"{method_name}.M"
-        method_path = os.path.join(
-            self.src, method_folder, "AgilentPumpDriver1.RapidControl.MethodXML.xml"
-        )
-        dad_path = os.path.join(
-            self.src,
-            method_folder,
-            "Agilent1200erDadDriver1.RapidControl.MethodXML.xml",
-        )
-
-        if os.path.exists(os.path.join(self.src, f"{method_name}.M")):
-            parser = XmlParser()
-            method = parser.parse(method_path, PumpMethod)
-            dad = parser.parse(dad_path, DadMethod)
-
-            organic_modifier: Optional[SolventElement] = None
-
-            if len(method.solvent_composition.solvent_element) == 2:
-                for solvent in method.solvent_composition.solvent_element:
-                    if solvent.channel == "Channel_B":
-                        organic_modifier = solvent
-
-            self.table_state = MethodDetails(
-                name=method_name,
-                params=HPLCMethodParams(
-                    organic_modifier=organic_modifier.percentage, flow=method.flow
-                ),
-                stop_time=method.stop_time.stop_time_value,
-                post_time=method.post_time.post_time_value,
-                timetable=[
-                    TimeTableEntry(
-                        start_time=tte.time,
-                        organic_modifer=tte.percent_b,
-                        flow=method.flow,
-                    )
-                    for tte in method.timetable.timetable_entry
-                ],
-                dad_wavelengthes=dad.signals.signal,
-            )
-            return self.table_state
-        else:
-            raise FileNotFoundError
-
     def edit(self, updated_method: MethodDetails, save: bool):
         """Updated the currently loaded method in ChemStation with provided values.
 
@@ -317,13 +272,13 @@ class MethodController(TableController):
         self,
         new_flow: Union[int, float],
         new_initial_om: Union[int, float],
-        new_stop_time: Union[int, float],
-        new_post_time: Union[int, float],
+        new_stop_time: Union[int, float] | None,
+        new_post_time: Union[int, float] | None,
     ):
         self.delete_table()
         self.edit_initial_om(new_initial_om)
         self.edit_flow(new_flow)
-        if self.table_state.stop_time:
+        if new_stop_time:
             self.edit_stop_time(new_stop_time)
         else:
             self._update_param(
@@ -333,7 +288,7 @@ class MethodController(TableController):
                     ptype=PType.STR,
                 )
             )
-        if self.table_state.post_time:
+        if new_post_time:
             self.edit_post_time(new_post_time)
         else:
             self._update_param(
@@ -502,21 +457,23 @@ class MethodController(TableController):
                 warning = f"Data folder {self.data_files[-1]} may not exist, returning and will check again after run is done."
                 warnings.warn(warning)
 
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
-        if os.path.exists(most_recent_folder):
-            return Ok(most_recent_folder)
-        return Err("Folder not found!")
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[str, str]:
+        if isinstance(most_recent_folder, str) or isinstance(most_recent_folder, bytes):
+            if os.path.exists(most_recent_folder):
+                return Ok(most_recent_folder)
+            return Err("Folder not found!")
+        raise ValueError("Folder is not a str or byte type.")
 
     def get_data(
         self, custom_path: Optional[str] = None
     ) -> AgilentChannelChromatogramData:
         custom_path = custom_path if custom_path else self.data_files[-1]
         self.get_spectrum_at_channels(custom_path)
-        return AgilentChannelChromatogramData(**self.spectra)
+        return AgilentChannelChromatogramData.from_dict(self.spectra)
 
     def get_data_uv(
         self, custom_path: Optional[str] = None
-    ) -> Dict[str, AgilentHPLCChromatogram]:
+    ) -> dict[int, AgilentHPLCChromatogram]:
         custom_path = custom_path if custom_path else self.data_files[-1]
         self.get_uv_spectrum(custom_path)
         return self.uv