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

pychemstation/analysis/__init__.py

@@ -1,4 +1,11 @@
 from .process_report import CSVProcessor
 from .process_report import TXTProcessor
+from .chromatogram import AgilentChannelChromatogramData
+from .chromatogram import AgilentHPLCChromatogram
 
-__all__ = ["CSVProcessor", "TXTProcessor"]
+__all__ = [
+    "CSVProcessor",
+    "TXTProcessor",
+    "AgilentChannelChromatogramData",
+    "AgilentHPLCChromatogram",
+]

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 data_aq
 
-__all__ = ["CommunicationController", "MethodController", "SequenceController"]
+__all__ = ["CommunicationController", "data_aq"]

pychemstation/control/controllers/abc_tables/device.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from abc import ABC
+
+from ....control.controllers import CommunicationController
+from ....utils.table_types import Table
+from .table import ABCTableController
+
+
+class DeviceController(ABCTableController, ABC):
+    def __init__(
+        self, controller: CommunicationController, table: Table, offline: bool
+    ):
+        super().__init__(controller=controller, table=table)
+        self.offline = offline

pychemstation/control/controllers/abc_tables/run.py

@@ -0,0 +1,228 @@
+"""
+Abstract module containing shared logic for Method and Sequence tables.
+
+Authors: Lucy Hao
+"""
+
+from __future__ import annotations
+
+import abc
+import math
+import os
+import time
+import warnings
+from typing import Dict, List, Optional, Tuple, Union
+
+import polling
+import rainbow as rb
+from result import Err, Result, Ok
+
+from .table import ABCTableController
+from ....analysis.process_report import (
+    AgilentReport,
+    CSVProcessor,
+    ReportType,
+    TXTProcessor,
+)
+from ....control.controllers.comm import CommunicationController
+from pychemstation.analysis.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
+from ....utils.macro import HPLCRunningStatus
+from ....utils.method_types import MethodDetails
+from ....utils.sequence_types import SequenceTable
+from ....utils.table_types import Table, T
+
+TableType = Union[MethodDetails, SequenceTable]
+
+
+class RunController(ABCTableController, abc.ABC):
+    def __init__(
+        self,
+        controller: Optional[CommunicationController],
+        src: str,
+        data_dirs: List[str],
+        table: Table,
+        offline: bool = False,
+    ):
+        super().__init__(controller=controller, table=table)
+        warnings.warn(
+            "This abstract class is not meant to be initialized. Use MethodController or SequenceController."
+        )
+        self.table_state: Optional[TableType] = None
+        self.curr_run_starting_time: Optional[float] = None
+        self.timeout: Optional[float] = None
+
+        if not offline:
+            if src and not os.path.isdir(src):
+                raise FileNotFoundError(f"dir: {src} not found.")
+
+            for d in data_dirs:
+                if not os.path.isdir(d):
+                    raise FileNotFoundError(f"dir: {d} not found.")
+                if r"\\" in d:
+                    raise ValueError("Data directories should not be raw strings!")
+            self.src: str = src
+            self.data_dirs: List[str] = data_dirs
+
+        self.spectra: dict[str, AgilentHPLCChromatogram] = {
+            "A": AgilentHPLCChromatogram(),
+            "B": AgilentHPLCChromatogram(),
+            "C": AgilentHPLCChromatogram(),
+            "D": AgilentHPLCChromatogram(),
+            "E": AgilentHPLCChromatogram(),
+            "F": AgilentHPLCChromatogram(),
+            "G": AgilentHPLCChromatogram(),
+            "H": AgilentHPLCChromatogram(),
+        }
+        self.uv: Dict[int, AgilentHPLCChromatogram] = {}
+        self.data_files: List = []
+
+    @abc.abstractmethod
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+        pass
+
+    @abc.abstractmethod
+    def get_data(
+        self, custom_path: Optional[str] = None
+    ) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        pass
+
+    @abc.abstractmethod
+    def get_data_uv(
+        self, custom_path: str | None = None
+    ) -> Dict[int, AgilentHPLCChromatogram]:
+        pass
+
+    @abc.abstractmethod
+    def get_report(
+        self, custom_path: str, report_type: ReportType = ReportType.TXT
+    ) -> List[AgilentReport]:
+        pass
+
+    def check_hplc_is_running(self) -> bool:
+        if self.controller:
+            try:
+                started_running = polling.poll(
+                    lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
+                    step=1,
+                    max_tries=20,
+                )
+            except Exception as e:
+                print(e)
+                return False
+            if started_running:
+                self.curr_run_starting_time = time.time()
+            return started_running
+        else:
+            raise ValueError("Controller is offline")
+
+    def check_hplc_run_finished(self) -> Tuple[float, bool]:
+        if self.controller:
+            done_running = self.controller.check_if_not_running()
+            if self.curr_run_starting_time and self.timeout:
+                time_passed = time.time() - self.curr_run_starting_time
+                if time_passed > self.timeout:
+                    enough_time_passed = time_passed >= self.timeout
+                    run_finished = enough_time_passed and done_running
+                    if run_finished:
+                        self._reset_time()
+                        return 0, run_finished
+                else:
+                    time_left = self.timeout - time_passed
+                    return time_left, self.controller.check_if_not_running()
+            return 0, self.controller.check_if_not_running()
+        raise ValueError("Controller is offline!")
+
+    def check_hplc_done_running(self) -> Ok[T] | Err[str]:
+        """
+        Checks if ChemStation has finished running and can read data back
+
+        :return: Data file object containing most recent run file information.
+        """
+        if self.timeout is not None:
+            finished_run = False
+            minutes = math.ceil(self.timeout / 60)
+            try:
+                finished_run = not polling.poll(
+                    lambda: self.check_hplc_run_finished()[1],
+                    max_tries=minutes - 1,
+                    step=50,
+                )
+            except (
+                polling.TimeoutException,
+                polling.PollingException,
+                polling.MaxCallException,
+            ):
+                try:
+                    finished_run = polling.poll(
+                        lambda: self.check_hplc_run_finished()[1],
+                        timeout=self.timeout / 2,
+                        step=1,
+                    )
+                except (
+                    polling.TimeoutException,
+                    polling.PollingException,
+                    polling.MaxCallException,
+                ):
+                    pass
+        else:
+            raise ValueError("Timeout value is None, no comparison can be made.")
+
+        check_folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+        if check_folder.is_ok() and finished_run:
+            return check_folder
+        elif check_folder.is_ok():
+            try:
+                finished_run = polling.poll(
+                    lambda: self.check_hplc_run_finished()[1], max_tries=10, step=50
+                )
+                if finished_run:
+                    return check_folder
+            except Exception:
+                self._reset_time()
+                return self.data_files[-1]
+        return Err("Run did not complete as expected")
+
+    def get_uv_spectrum(self, path: str):
+        data_uv = rb.agilent.chemstation.parse_file(os.path.join(path, "DAD1.UV"))
+        times = data_uv.xlabels
+        wavelengths = data_uv.ylabels
+        absorbances = data_uv.data.transpose()
+        for i, w in enumerate(wavelengths):
+            self.uv[w] = AgilentHPLCChromatogram()
+            self.uv[w].attach_spectrum(times, absorbances[i])
+
+    def get_report_details(
+        self, path: str, report_type: ReportType = ReportType.TXT
+    ) -> AgilentReport:
+        if report_type is ReportType.TXT:
+            txt_report = TXTProcessor(path).process_report()
+            if txt_report.is_ok():
+                return txt_report.ok_value
+            elif txt_report.is_err():
+                raise ValueError(txt_report.err_value)
+        if report_type is ReportType.CSV:
+            csv_report = CSVProcessor(path).process_report()
+            if csv_report.is_ok():
+                return csv_report.ok_value
+            elif csv_report.is_err():
+                raise ValueError(csv_report.err_value)
+        raise ValueError("Expected one of ReportType.TXT or ReportType.CSV")
+
+    def get_spectrum_at_channels(self, data_path: str):
+        """
+        Load chromatogram for any channel in spectra dictionary.
+        """
+        for channel, spec in self.spectra.items():
+            try:
+                spec.load_spectrum(data_path=data_path, channel=channel)
+            except FileNotFoundError:
+                self.spectra[channel] = AgilentHPLCChromatogram()
+                warning = f"No data at channel: {channel}"
+                warnings.warn(warning)
+
+    def _reset_time(self):
+        self.curr_run_starting_time = None
+        self.timeout = None