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

pychemstation/analysis/chromatogram.py

@@ -3,6 +3,7 @@
 import os
 import time
 from dataclasses import dataclass
+from typing import Dict
 
 import numpy as np
 
@@ -114,3 +115,22 @@ class AgilentChannelChromatogramData:
     F: AgilentHPLCChromatogram
     G: AgilentHPLCChromatogram
     H: AgilentHPLCChromatogram
+
+    @classmethod
+    def from_dict(cls, chroms: Dict[str, AgilentHPLCChromatogram]):
+        keys = chroms.keys()
+        class_keys = vars(AgilentChannelChromatogramData)["__annotations__"].keys()
+        if set(class_keys) == set(keys):
+            return AgilentChannelChromatogramData(
+                A=chroms["A"],
+                B=chroms["B"],
+                C=chroms["C"],
+                D=chroms["D"],
+                E=chroms["E"],
+                F=chroms["F"],
+                G=chroms["G"],
+                H=chroms["H"],
+            )
+        else:
+            err = f"{keys} don't match {class_keys}"
+            raise KeyError(err)

pychemstation/analysis/process_report.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 import abc
 import os
 import re
 from abc import abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import AnyStr, Dict, List, Optional, Pattern
+from typing import AnyStr, Dict, List, Optional, Pattern, Union
 
 import pandas as pd
 from aghplctools.ingestion.text import (
@@ -15,6 +17,7 @@ from aghplctools.ingestion.text import (
     _signal_table_re,
     chunk_string,
 )
+from pandas.errors import EmptyDataError
 from result import Err, Ok, Result
 
 from ..analysis.chromatogram import AgilentHPLCChromatogram
@@ -43,7 +46,7 @@ class Signals:
 class AgilentReport:
     vial_location: Optional[Tray]
     signals: List[Signals]
-    solvents: Optional[Dict[AnyStr, AnyStr]]
+    solvents: Optional[Dict[str, str]]
 
 
 class ReportType(Enum):
@@ -69,6 +72,37 @@ class CSVProcessor(ReportProcessor):
         """
         super().__init__(path)
 
+    def find_csv_prefix(self) -> str:
+        files = [
+            f
+            for f in os.listdir(self.path)
+            if os.path.isfile(os.path.join(self.path, f))
+        ]
+        for file in files:
+            if "00" in file:
+                name, _, file_extension = file.partition(".")
+                if "00" in name and file_extension.lower() == "csv":
+                    prefix, _, _ = name.partition("00")
+                    return prefix
+        raise FileNotFoundError("Couldn't find the prefix for CSV")
+
+    def report_contains(self, labels: List[str], want: List[str]):
+        for label in labels:
+            if label in want:
+                want.remove(label)
+
+        all_labels_seen = False
+        if len(want) != 0:
+            for want_label in want:
+                label_seen = False
+                for label in labels:
+                    if want_label in label or want_label == label:
+                        label_seen = True
+                all_labels_seen = label_seen
+        else:
+            return True
+        return all_labels_seen
+
     def process_report(self) -> Result[AgilentReport, AnyStr]:
         """
         Method to parse details from CSV report.
@@ -76,15 +110,30 @@ class CSVProcessor(ReportProcessor):
         :return: subset of complete report details, specifically the sample location, solvents in pumps,
          and list of peaks at each wavelength channel.
         """
-        labels = os.path.join(self.path, "REPORT00.CSV")
-        if os.path.exists(labels):
-            df_labels: Dict[int, Dict[int:AnyStr]] = pd.read_csv(
+        prefix = self.find_csv_prefix()
+        labels = os.path.join(self.path, f"{prefix}00.CSV")
+        if not os.path.exists(labels):
+            raise ValueError(
+                "CSV reports do not exist, make sure to turn on the post run CSV report option!"
+            )
+        elif os.path.exists(labels):
+            LOCATION = "Location"
+            NUM_SIGNALS = "Number of Signals"
+            SOLVENT = "Solvent"
+            df_labels: Dict[int, Dict[int, str]] = pd.read_csv(
                 labels, encoding="utf-16", header=None
             ).to_dict()
-            vial_location = []
-            signals = {}
-            solvents = {}
-            for pos, val in df_labels[0].items():
+            vial_location: str = ""
+            signals: Dict[int, list[AgilentPeak]] = {}
+            solvents: Dict[str, str] = {}
+            report_labels: Dict[int, str] = df_labels[0]
+
+            if not self.report_contains(
+                list(report_labels.values()), [LOCATION, NUM_SIGNALS, SOLVENT]
+            ):
+                return Err(f"Missing one of: {LOCATION}, {NUM_SIGNALS}, {SOLVENT}")
+
+            for pos, val in report_labels.items():
                 if val == "Location":
                     vial_location = df_labels[1][pos]
                 elif "Solvent" in val:
@@ -93,22 +142,29 @@ class CSVProcessor(ReportProcessor):
                 elif val == "Number of Signals":
                     num_signals = int(df_labels[1][pos])
                     for s in range(1, num_signals + 1):
-                        df = pd.read_csv(
-                            os.path.join(self.path, f"REPORT0{s}.CSV"),
-                            encoding="utf-16",
-                            header=None,
-                        )
-                        peaks = df.apply(lambda row: AgilentPeak(*row), axis=1)
-                        wavelength = df_labels[1][pos + s].partition(",4 Ref=off")[0][
-                            -3:
-                        ]
-                        signals[wavelength] = list(peaks)
+                        try:
+                            df = pd.read_csv(
+                                os.path.join(self.path, f"{prefix}0{s}.CSV"),
+                                encoding="utf-16",
+                                header=None,
+                            )
+                            peaks = df.apply(lambda row: AgilentPeak(*row), axis=1)
+                        except EmptyDataError:
+                            peaks = []
+                        try:
+                            wavelength = df_labels[1][pos + s].partition(",4 Ref=off")[
+                                0
+                            ][-3:]
+                            signals[int(wavelength)] = list(peaks)
+                        except (IndexError, ValueError):
+                            # TODO: Ask about the MS signals
+                            pass
                     break
 
             return Ok(
                 AgilentReport(
                     signals=[
-                        Signals(wavelength=int(w), peaks=s, data=None)
+                        Signals(wavelength=w, peaks=s, data=None)
                         for w, s in signals.items()
                     ],
                     vial_location=FiftyFourVialPlate.from_int(int(vial_location)),
@@ -154,7 +210,7 @@ class TXTProcessor(ReportProcessor):
         path: str,
         min_ret_time: int = 0,
         max_ret_time: int = 999,
-        target_wavelength_range: List[int] = range(200, 300),
+        target_wavelength_range=None,
     ):
         """
         Class to process reports in CSV form.
@@ -164,12 +220,14 @@ class TXTProcessor(ReportProcessor):
         :param max_ret_time: peaks will only be returned up to this time (min)
         :param target_wavelength_range: range of wavelengths to return
         """
+        if target_wavelength_range is None:
+            target_wavelength_range = list(range(200, 300))
         self.target_wavelength_range = target_wavelength_range
         self.min_ret_time = min_ret_time
         self.max_ret_time = max_ret_time
         super().__init__(path)
 
-    def process_report(self) -> Result[AgilentReport, AnyStr]:
+    def process_report(self) -> Result[AgilentReport, Union[AnyStr, Exception]]:
         """
         Method to parse details from CSV report.
         If you want more functionality, use `aghplctools`.
@@ -179,44 +237,48 @@ class TXTProcessor(ReportProcessor):
         :return: subset of complete report details, specifically the sample location, solvents in pumps,
          and list of peaks at each wavelength channel.
         """
-
-        with open(
-            os.path.join(self.path, "REPORT.TXT"), "r", encoding="utf-16"
-        ) as openfile:
-            text = openfile.read()
-
         try:
-            signals = self.parse_area_report(text)
-        except ValueError as e:
-            return Err("No peaks found: " + str(e))
-
-        signals = {
-            key: signals[key] for key in self.target_wavelength_range if key in signals
-        }
-
-        parsed_signals = []
-        for wavelength, wavelength_dict in signals.items():
-            current_wavelength_signals = Signals(
-                wavelength=int(wavelength), peaks=[], data=None
-            )
-            for ret_time, ret_time_dict in wavelength_dict.items():
-                if self.min_ret_time <= ret_time <= self.max_ret_time:
-                    current_wavelength_signals.peaks.append(
-                        AgilentPeak(
-                            retention_time=ret_time,
-                            area=ret_time_dict["Area"],
-                            width=ret_time_dict["Width"],
-                            height=ret_time_dict["Height"],
-                            peak_number=None,
-                            peak_type=ret_time_dict["Type"],
-                            area_percent=None,
+            with open(
+                os.path.join(self.path, "REPORT.TXT"), "r", encoding="utf-16"
+            ) as openfile:
+                text = openfile.read()
+
+            try:
+                signals = self.parse_area_report(text)
+            except ValueError as e:
+                return Err("No peaks found: " + str(e))
+
+            signals = {
+                key: signals[key]
+                for key in self.target_wavelength_range
+                if key in signals
+            }
+
+            parsed_signals = []
+            for wavelength, wavelength_dict in signals.items():
+                current_wavelength_signals = Signals(
+                    wavelength=int(wavelength), peaks=[], data=None
+                )
+                for ret_time, ret_time_dict in wavelength_dict.items():
+                    if self.min_ret_time <= ret_time <= self.max_ret_time:
+                        current_wavelength_signals.peaks.append(
+                            AgilentPeak(
+                                retention_time=ret_time,
+                                area=ret_time_dict["Area"],
+                                width=ret_time_dict["Width"],
+                                height=ret_time_dict["Height"],
+                                peak_number=None,
+                                peak_type=ret_time_dict["Type"],
+                                area_percent=None,
+                            )
                         )
-                    )
-            parsed_signals.append(current_wavelength_signals)
+                parsed_signals.append(current_wavelength_signals)
 
-        return Ok(
-            AgilentReport(vial_location=None, solvents=None, signals=parsed_signals)
-        )
+            return Ok(
+                AgilentReport(vial_location=None, solvents=None, signals=parsed_signals)
+            )
+        except Exception as e:
+            return Err(e)
 
     def parse_area_report(self, report_text: str) -> Dict:
         """
@@ -234,7 +296,7 @@ class TXTProcessor(ReportProcessor):
         if re.search(_no_peaks_re, report_text):  # There are no peaks in Report.txt
             raise ValueError("No peaks found in Report.txt")
         blocks = _header_block_re.split(report_text)
-        signals = {}  # output dictionary
+        signals: Dict[int, dict] = {}  # output dictionary
         for ind, block in enumerate(blocks):
             # area report block
             if _area_report_re.match(block):  # match area report block
@@ -247,7 +309,7 @@ class TXTProcessor(ReportProcessor):
                         # some error state (e.g. 'not found')
                         if si.group("error") != "":
                             continue
-                        wavelength = float(si.group("wavelength"))
+                        wavelength = int(si.group("wavelength"))
                         if wavelength in signals:
                             # placeholder error raise just in case (this probably won't happen)
                             raise KeyError(
@@ -270,15 +332,14 @@ class TXTProcessor(ReportProcessor):
                                 for key in self._column_re_dictionary:
                                     if key in peak.re.groupindex:
                                         try:  # try float conversion, otherwise continue
-                                            value = float(peak.group(key))
+                                            current[key] = float(peak.group(key))
                                         except ValueError:
-                                            value = peak.group(key)
-                                        current[key] = value
+                                            current[key] = peak.group(key)
                                     else:  # ensures defined
                                         current[key] = None
         return signals
 
-    def build_peak_regex(self, signal_table: str) -> Pattern[AnyStr]:
+    def build_peak_regex(self, signal_table: str) -> Pattern[str] | None:
         """
         Builds a peak regex from a signal table. Courtesy of Veronica Lai.
 
@@ -311,6 +372,7 @@ class TXTProcessor(ReportProcessor):
                     f'The header/unit combination "{header}" "{unit}" is not defined in the peak regex '
                     f"dictionary. Let Lars know."
                 )
+
         return re.compile(
             "[ ]+".join(
                 peak_re_string

pychemstation/control/__init__.py

@@ -3,7 +3,9 @@
 """
 
 from .hplc import HPLCController
+from . import controllers
 
 __all__ = [
     "HPLCController",
+    "controllers",
 ]

pychemstation/control/controllers/__init__.py

@@ -3,7 +3,6 @@
 """
 
 from .comm import CommunicationController
-from .tables.method import MethodController
-from .tables.sequence import SequenceController
+from . import tables
 
-__all__ = ["CommunicationController", "MethodController", "SequenceController"]
+__all__ = ["CommunicationController", "tables"]

pychemstation/control/controllers/comm.py

@@ -39,6 +39,7 @@ class CommunicationController:
         comm_dir: str,
         cmd_file: str = "cmd",
         reply_file: str = "reply",
+        offline: bool = False,
         debug: bool = False,
     ):
         """
@@ -47,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()
@@ -75,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()
@@ -92,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:
@@ -145,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)
 
@@ -158,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
@@ -169,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")

pychemstation/control/controllers/devices/device.py

@@ -1,49 +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 pychemstation.analysis.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):
+class DeviceController(abc.ABC):
     def __init__(
         self, controller: CommunicationController, table: Table, offline: bool
     ):
-        super().__init__(
-            controller=controller, src=None, data_dirs=[], table=table, offline=offline
-        )
+        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

@@ -10,6 +10,7 @@ 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
@@ -23,7 +24,12 @@ class InjectorController(DeviceController):
 
     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":
@@ -48,14 +54,20 @@ class InjectorController(DeviceController):
         elif function == "Remote":
             return Remote(
                 command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
-                duration=self.get_num(row, RegisterFlag.REMOTE_DUR),
+                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"]