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

pychemstation/control/controllers/comm.py

@@ -9,6 +9,7 @@ been processed.
 
 Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
+
 import os
 import time
 from typing import Optional, Union
@@ -34,11 +35,12 @@ class CommunicationController:
     MAX_CMD_NO = 255
 
     def __init__(
-            self,
-            comm_dir: str,
-            cmd_file: str = "cmd",
-            reply_file: str = "reply",
-            debug: bool = False
+        self,
+        comm_dir: str,
+        cmd_file: str = "cmd",
+        reply_file: str = "reply",
+        offline: bool = False,
+        debug: bool = False,
     ):
         """
         :param comm_dir:
@@ -46,26 +48,27 @@ 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
+        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()
+            # 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.reset_cmd_counter()
 
-        # Initialize row counter for table operations
-        self.send('Local Rows')
+            # Initialize row counter for table operations
+            self._most_recent_hplc_status: Status = self.get_status()
+            self.send("Local Rows")
 
     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()
@@ -74,7 +77,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()
@@ -91,9 +94,15 @@ 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:
@@ -144,7 +153,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)
 
@@ -157,7 +167,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
@@ -168,7 +182,9 @@ class CommunicationController:
             else:
                 continue
         else:
-            return Err(f"Failed to receive reply to command #{cmd_no} due to {err}.")
+            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")
@@ -194,7 +210,7 @@ class CommunicationController:
     def receive(self) -> Result[Response, str]:
         """Returns messages received in reply file.
 
-        :return: ChemStation response 
+        :return: ChemStation response
         """
         num_response_prefix = "Numerical Responses:"
         str_response_prefix = "String Responses:"
@@ -203,10 +219,18 @@ class CommunicationController:
             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())))
+                    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}")

pychemstation/control/controllers/devices/device.py

@@ -1,39 +1,74 @@
+from __future__ import annotations
+
 import abc
-from typing import List, Union, Dict, Optional
+from typing import Union
 
-from result import Result
+from result import Err, Ok
 
-from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
-from ....control.controllers.tables.table import TableController
-from ....utils.chromatogram import AgilentChannelChromatogramData, AgilentHPLCChromatogram
-from ....utils.table_types import T, Table
-
+from ....utils.macro import Command, Response
+from ....utils.table_types import RegisterFlag, Table, TableOperation
 
-class DeviceController(TableController, abc.ABC):
 
-    def __init__(self, controller: CommunicationController, table: Table, offline: bool):
-        super().__init__(controller=controller,
-                         src=None,
-                         data_dirs=[],
-                         table=table,
-                         offline=offline)
+class DeviceController(abc.ABC):
+    def __init__(
+        self, controller: CommunicationController, table: Table, offline: bool
+    ):
+        self.table_locator = table
+        self.controller = controller
+        self.offline = offline
 
     @abc.abstractmethod
     def get_row(self, row: int):
         pass
 
-    def retrieve_recent_data_files(self):
-        raise NotImplementedError
+    def get_text(self, row: int, col_name: RegisterFlag) -> str:
+        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,
+            )
+        )
 
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
-        raise NotImplementedError
+    def get_num(self, row: int, col_name: RegisterFlag) -> Union[int, float]:
+        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,
+            )
+        )
 
-    def get_report(self, report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
-        raise NotImplementedError
+    def get_num_rows(self) -> Ok[Response] | Err[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,
+            )
+        )
+        res = self.controller.receive()
 
-    def get_data_uv(self) -> Union[List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]]:
-        raise NotImplementedError
+        if res.is_ok():
+            self.send("Sleep 0.1")
+            self.send("Print Rows")
+            return res
+        else:
+            return Err("No rows could be read.")
 
-    def get_data(self, custom_path: Optional[str] = None) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
-        raise NotImplementedError
+    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)

pychemstation/control/controllers/devices/injector.py

@@ -1,4 +1,3 @@
-
 from ....control.controllers import CommunicationController
 from ....utils.injector_types import (
     Draw,
@@ -11,19 +10,26 @@ from ....utils.injector_types import (
     SourceType,
     Wait,
 )
+from ....utils.macro import Response
 from ....utils.table_types import RegisterFlag, Table
 from ....utils.tray_types import Tray
 from .device import DeviceController
 
 
 class InjectorController(DeviceController):
-
-    def __init__(self, controller: CommunicationController, table: Table, offline: bool):
+    def __init__(
+        self, controller: CommunicationController, table: Table, offline: bool
+    ):
         super().__init__(controller, table, offline)
 
     def get_row(self, row: int) -> InjectorFunction:
         def return_tray_loc() -> Tray:
-            pass
+            raise NotImplementedError
+            # unit = self.get_text(row, RegisterFlag.DRAW_LOCATION_UNIT)
+            # tray = self.get_text(row, RegisterFlag.DRAW_LOCATION_TRAY)
+            # x = self.get_text(row, RegisterFlag.DRAW_LOCATION_ROW)
+            # y = self.get_text(row, RegisterFlag.DRAW_LOCATION_COLUMN)
+            # return FiftyFourVialPlate.from_str("P1-A1")
 
         function = self.get_text(row, RegisterFlag.FUNCTION)
         if function == "Wait":
@@ -34,17 +40,34 @@ class InjectorController(DeviceController):
             # TODO: better error handling
             is_source = SourceType(self.get_text(row, RegisterFlag.DRAW_SOURCE))
             is_volume = Mode(self.get_text(row, RegisterFlag.DRAW_VOLUME))
-            vol = self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE) if is_volume == Mode.SET else None
+            vol = (
+                self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE)
+                if is_volume == Mode.SET
+                else None
+            )
             if is_source is SourceType.SPECIFIC_LOCATION:
                 return Draw(amount=vol, source=return_tray_loc())
             elif is_source is SourceType.LOCATION:
-                return Draw(amount=vol, location=self.get_text(row, RegisterFlag.DRAW_LOCATION))
+                return Draw(
+                    amount=vol, location=self.get_text(row, RegisterFlag.DRAW_LOCATION)
+                )
         elif function == "Remote":
-            return Remote(command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
-                          duration=self.get_num(row, RegisterFlag.REMOTE_DUR))
+            return Remote(
+                command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
+                duration=int(self.get_num(row, RegisterFlag.REMOTE_DUR)),
+            )
+        raise ValueError("No valid function found.")
 
     def load(self) -> InjectorTable:
         rows = self.get_num_rows()
         if rows.is_ok():
-            return InjectorTable(functions=[self.get_row(i) for i in range(int(rows.ok_value.num_response))])
-
+            row_response = rows.value
+            if isinstance(row_response, Response):
+                return InjectorTable(
+                    functions=[
+                        self.get_row(i) for i in range(int(row_response.num_response))
+                    ]
+                )
+        elif rows.is_err():
+            return InjectorTable(functions=[])
+        raise ValueError("Unexpected error")

pychemstation/control/controllers/tables/__init__.py

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