pychemstation 0.8.4__py3-none-any.whl → 0.8.7__py3-none-any.whl

pychemstation/control/controllers/comm.py

@@ -9,13 +9,21 @@ been processed.
 
 Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
+
 import os
 import time
-from typing import Optional
+from typing import Optional, Union
 
-from result import Result, Ok, Err
+from result import Err, Ok, Result
 
-from ...utils.macro import *
+from ...utils.macro import (
+    str_to_status,
+    HPLCAvailStatus,
+    HPLCErrorStatus,
+    Command,
+    Status,
+    Response,
+)
 
 
 class CommunicationController:
@@ -27,11 +35,11 @@ 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",
+        debug: bool = False,
     ):
         """
         :param comm_dir:
@@ -55,7 +63,7 @@ class CommunicationController:
         self.reset_cmd_counter()
 
         # Initialize row counter for table operations
-        self.send('Local Rows')
+        self.send("Local Rows")
 
     def get_num_val(self, cmd: str) -> Union[int, float]:
         tries = 5
@@ -138,6 +146,7 @@ class CommunicationController:
         :return: Potential ChemStation response
         """
         err: Optional[Union[OSError, IndexError]] = None
+        err_msg = ""
         for _ in range(num_attempts):
             time.sleep(1)
 
@@ -150,7 +159,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
@@ -161,7 +174,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")
@@ -187,20 +202,28 @@ 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:"
         possible_response = self._receive(self.cmd_no)
         if possible_response.is_ok():
-            lines = possible_response.value.splitlines()
+            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(f"Could not retrieve HPLC response")
+                    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,23 +1,25 @@
 import abc
-from typing import Union, List
+from typing import List, Union, Dict, Optional
 
 from result import Result
 
-from ....analysis.process_report import ReportType, AgilentReport
+from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
 from ....control.controllers.tables.table import TableController
-from ....utils.chromatogram import AgilentChannelChromatogramData
-from ....utils.table_types import Table, T
+from pychemstation.analysis.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
+from ....utils.table_types import T, Table
 
 
 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)
+    def __init__(
+        self, controller: CommunicationController, table: Table, offline: bool
+    ):
+        super().__init__(
+            controller=controller, src=None, data_dirs=[], table=table, offline=offline
+        )
 
     @abc.abstractmethod
     def get_row(self, row: int):
@@ -26,11 +28,22 @@ class DeviceController(TableController, abc.ABC):
     def retrieve_recent_data_files(self):
         raise NotImplementedError
 
-    def get_data(self) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         raise NotImplementedError
 
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+    def get_report(
+        self, report_type: ReportType = ReportType.TXT
+    ) -> List[AgilentReport]:
+        raise NotImplementedError
+
+    def get_data_uv(
+        self,
+    ) -> Union[
+        List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]
+    ]:
         raise NotImplementedError
 
-    def get_report(self, report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
+    def get_data(
+        self, custom_path: Optional[str] = None
+    ) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
         raise NotImplementedError

pychemstation/control/controllers/devices/injector.py

@@ -1,13 +1,24 @@
 from ....control.controllers import CommunicationController
+from ....utils.injector_types import (
+    Draw,
+    Inject,
+    InjectorFunction,
+    InjectorTable,
+    Mode,
+    Remote,
+    RemoteCommand,
+    SourceType,
+    Wait,
+)
+from ....utils.table_types import RegisterFlag, Table
+from ....utils.tray_types import Tray
 from .device import DeviceController
-from ....utils.injector_types import *
-from ....utils.macro import Command
-from ....utils.table_types import Table, RegisterFlag
 
 
 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:
@@ -23,95 +34,28 @@ 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=self.get_num(row, RegisterFlag.REMOTE_DUR),
+            )
 
     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))])
-
-    def edit(self, injector_table: InjectorTable):
-        columns_added = set()
-
-        def add_table_val(col_name: RegisterFlag, val: Union[str, int, float]):
-            nonlocal columns_added
-            if True:
-                if isinstance(val, str):
-                    self._edit_row_text(col_name=col_name, val=val)
-                else:
-                    self._edit_row_num(col_name=col_name, val=val)
-            else:
-                if isinstance(val, str):
-                    self.add_new_col_text(col_name=col_name, val=val)
-                else:
-                    self.add_new_col_num(col_name=col_name, val=val)
-                columns_added.add(col_name)
-
-        def add_inject(inject: Inject):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=inject.__class__.__name__)
-
-        def add_draw(draw: Draw):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=draw.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.DRAW_SPEED, val=SourceType.DEFAULT.value)
-            add_table_val(col_name=RegisterFlag.DRAW_OFFSET, val=SourceType.DEFAULT.value)
-
-            if draw.amount:
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.SET.value)
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME_VALUE, val=draw.amount)
-            else:
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.DEFAULT.value)
-
-            if draw.location:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.LOCATION.value)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION, val=draw.location)
-            elif draw.source:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.SPECIFIC_LOCATION.value)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_UNIT, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_TRAY, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_ROW, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_COLUMN, val=1)
-            else:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.DEFAULT.value)
-
-        def add_wait(wait: Wait):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=wait.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.TIME, val=wait.duration)
-
-        def add_remote(remote: Remote):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=remote.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.REMOTE, val=remote.command.value)
-            add_table_val(col_name=RegisterFlag.REMOTE_DUR, val=remote.duration)
-
-        self.send(Command.SAVE_METHOD_CMD)
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            existing_row_num = rows.value.num_response
-            for i, function in enumerate(injector_table.functions):
-                if (i+1) > existing_row_num:
-                    self.add_row()
-                if isinstance(function, Inject):
-                    add_inject(function)
-                elif isinstance(function, Draw):
-                    add_draw(function)
-                elif isinstance(function, Wait):
-                    add_wait(function)
-                elif isinstance(function, Remote):
-                    add_remote(function)
-                self.download()
-                self.send(Command.SAVE_METHOD_CMD)
-                self.send(Command.SWITCH_METHOD_CMD)
-                existing_row_num = self.get_num_rows().ok_value.num_response
-
-    def download(self):
-        self.send('Sleep 1')
-        self.sleepy_send("DownloadRCMethod WLS1")
-        self.send('Sleep 1')
-        self.sleepy_send("DownloadLWls 1")
-        self.send('Sleep 1')
+            return InjectorTable(
+                functions=[
+                    self.get_row(i) for i in range(int(rows.ok_value.num_response))
+                ]
+            )