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

pychemstation/control/controllers/abc_tables/table.py

@@ -0,0 +1,230 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+Authors: Lucy Hao
+"""
+
+from __future__ import annotations
+
+import abc
+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,
+    ):
+        self.controller = controller
+        self.table_locator = table
+        self.table_state: Optional[TableType] = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls is ABCTableController:
+            raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
+        return object.__new__(cls, *args, **kwargs)
+
+    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]):
+        if not (isinstance(val, int) or isinstance(val, float)):
+            raise ValueError(f"{val} must be an int or 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):
+        if not isinstance(val, str):
+            raise ValueError(f"{val} must be a 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 not (isinstance(val, int) or isinstance(val, float)):
+            raise ValueError(f"{val} must be an int or float.")
+        if row:
+            num_rows = self.get_num_rows()
+            if num_rows.is_ok():
+                if num_rows.ok_value.num_response < row:
+                    raise ValueError("Not enough rows to edit!")
+
+        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 not isinstance(val, str):
+            raise ValueError(f"{val} must be a str.")
+        if row:
+            num_rows = self.get_num_rows()
+            if num_rows.is_ok():
+                if num_rows.ok_value.num_response < row:
+                    raise ValueError("Not enough rows to edit!")
+
+        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,30 +10,25 @@ been processed.
 Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
 
-import os
 import time
-from typing import Optional, Union
+from typing import Optional, Union, Tuple, List
 
 from result import Err, Ok, Result
 
 from ...utils.macro import (
-    str_to_status,
-    HPLCAvailStatus,
-    HPLCErrorStatus,
     Command,
+    HPLCErrorStatus,
     Status,
-    Response,
+    str_to_status,
 )
+from .abc_tables.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
@@ -98,7 +76,7 @@ class CommunicationController:
             if res.is_err():
                 return HPLCErrorStatus.NORESPONSE
             if res.is_ok():
-                parsed_response = self.receive().value.string_response
+                parsed_response = self.receive().ok_value.string_response
                 self._most_recent_hplc_status = str_to_status(parsed_response)
                 return self._most_recent_hplc_status
             else:
@@ -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.
 
@@ -186,61 +149,23 @@ class CommunicationController:
                 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")
+    def get_chemstation_dirs(self) -> Tuple[str, str, List[str]]:
+        method_dir, sequence_dir, data_dirs = None, None, None
+        self.send(Command.GET_METHOD_DIR)
+        res = self.receive()
+        if res.is_ok():
+            method_dir = res.ok_value.string_response
+        self.send(Command.GET_SEQUENCE_DIR)
+        res = self.receive()
+        if res.is_ok():
+            sequence_dir = res.ok_value.string_response
+        self.send(Command.GET_DATA_DIRS)
+        res = self.receive()
+        if res.is_ok():
+            data_dirs = res.ok().string_response.split("|")
+        if method_dir and sequence_dir and data_dirs:
+            return method_dir, sequence_dir, data_dirs
         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)
+            raise ValueError(
+                "Please provide the method, sequence and data directories, could not be found."
+            )

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

@@ -3,10 +3,11 @@ from __future__ import annotations
 import os
 import time
 import warnings
-from typing import List, Optional, Union, Dict
+from typing import List, Optional, Union, Dict, Set
 
 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
     """
@@ -413,8 +413,6 @@ class MethodController(TableController):
         :param stall_while_running: whether to stall or immediately return
         :param add_timestamp: if should add timestamp to experiment name
         """
-
-        folder_name = ""
         hplc_is_running = False
         tries = 0
         while tries < 10 and not hplc_is_running:
@@ -427,18 +425,15 @@ class MethodController(TableController):
                     else experiment_name,
                 )
             )
-            folder_name = (
-                f"{experiment_name}_{timestamp}.D"
-                if add_timestamp
-                else f"{experiment_name}.D"
-            )
+
             hplc_is_running = self.check_hplc_is_running()
             tries += 1
 
+        data_dir, data_file = self.get_current_run_data_dir_file()
         if not hplc_is_running:
             raise RuntimeError("Method failed to start.")
 
-        self.data_files.append(os.path.join(self.data_dirs[0], folder_name))
+        self.data_files.append(os.path.join(os.path.normpath(data_dir), data_file))
         self.timeout = (self.get_total_runtime()) * 60
 
         if stall_while_running:
@@ -446,18 +441,20 @@ class MethodController(TableController):
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
-                raise RuntimeError("Run error has occurred.")
+                raise RuntimeError(f"Run error has occurred:{run_completed.err_value}.")
         else:
-            folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+            folder = self.fuzzy_match_most_recent_folder(self.data_files[-1], None)
             while folder.is_err():
-                folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+                folder = self.fuzzy_match_most_recent_folder(self.data_files[-1], None)
             if folder.is_ok():
                 self.data_files[-1] = folder.ok_value
             else:
                 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[str, str]:
+    def fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_dirs: Optional[Set[str]]
+    ) -> 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)