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

pychemstation/__init__.py

@@ -1,3 +1,3 @@
 """
 .. include:: ../README.md
-"""
+"""

pychemstation/analysis/__init__.py

@@ -1,9 +1,4 @@
-from .base_spectrum import AbstractSpectrum
 from .process_report import CSVProcessor
 from .process_report import TXTProcessor
 
-__all__ = [
-    'AbstractSpectrum',
-    'CSVProcessor',
-    'TXTProcessor'
-]
+__all__ = ["CSVProcessor", "TXTProcessor"]

pychemstation/analysis/base_spectrum.py

@@ -197,10 +197,10 @@ class AbstractSpectrum(ABC):
             return (self.x.copy()[full_mask], self.y.copy()[full_mask])
 
     def show_spectrum(
-            self,
-            filename=None,
-            title=None,
-            label=None,
+        self,
+        filename=None,
+        title=None,
+        label=None,
     ):
         """Plots the spectral data using matplotlib.pyplot module.
 
@@ -249,7 +249,7 @@ class AbstractSpectrum(ABC):
             os.makedirs(path, exist_ok=True)
             fig.savefig(os.path.join(path, f"{filename}.png"), dpi=150)
 
-    def find_peaks(self, threshold=1, min_width=.1, min_dist=None, area=None):
+    def find_peaks(self, threshold=1, min_width=0.1, min_dist=None, area=None):
         """Finds all peaks above the threshold with at least min_width width.
 
         Args:
@@ -385,12 +385,12 @@ class AbstractSpectrum(ABC):
 
         if rule == "trapz":
             return integrate.trapz(
-                self.y[left_idx: right_idx + 1], self.x[left_idx: right_idx + 1]
+                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
             )
 
         elif rule == "simps":
             return integrate.simps(
-                self.y[left_idx: right_idx + 1], self.x[left_idx: right_idx + 1]
+                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
             )
 
         else:

pychemstation/{utils → analysis}/chromatogram.py

@@ -3,11 +3,13 @@
 import os
 import time
 from dataclasses import dataclass
+from typing import Dict
 
 import numpy as np
 
-from ..analysis import AbstractSpectrum
-from .parsing import CHFile
+
+from ..utils.parsing import CHFile
+from ..analysis.base_spectrum import AbstractSpectrum
 
 ACQUISITION_PARAMETERS = "acq.txt"
 
@@ -36,12 +38,11 @@ class AgilentHPLCChromatogram(AbstractSpectrum):
     }
 
     def __init__(self, path=None, autosaving=False):
-
         if path is not None:
             os.makedirs(path, exist_ok=True)
             self.path = path
         else:
-            self.path = os.path.join(".", "hplc_data")
+            self.path = os.path.join("../utils", "hplc_data")
             os.makedirs(self.path, exist_ok=True)
 
         super().__init__(path=path, autosaving=autosaving)
@@ -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,10 +17,11 @@ from aghplctools.ingestion.text import (
     _signal_table_re,
     chunk_string,
 )
+from pandas.errors import EmptyDataError
 from result import Err, Ok, Result
 
-from pychemstation.utils.chromatogram import AgilentHPLCChromatogram
-from pychemstation.utils.tray_types import FiftyFourVialPlate, Tray
+from ..analysis.chromatogram import AgilentHPLCChromatogram
+from ..utils.tray_types import FiftyFourVialPlate, Tray
 
 
 @dataclass
@@ -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,13 +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(labels, encoding="utf-16", header=None).to_dict()
-            vial_location = []
-            signals = {}
-            solvents = {}
-            for pos, val in df_labels[0].items():
+        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: 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:
@@ -91,18 +142,35 @@ 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) for w, s in signals.items()],
-                vial_location=FiftyFourVialPlate.from_int(int(vial_location)),
-                solvents=solvents
-            ))
+            return Ok(
+                AgilentReport(
+                    signals=[
+                        Signals(wavelength=w, peaks=s, data=None)
+                        for w, s in signals.items()
+                    ],
+                    vial_location=FiftyFourVialPlate.from_int(int(vial_location)),
+                    solvents=solvents,
+                )
+            )
 
         return Err("No report found")
 
@@ -111,34 +179,39 @@ class TXTProcessor(ReportProcessor):
     """
     Regex matches for column and unit combinations, courtesy of Veronica Lai.
     """
+
     _column_re_dictionary = {
-        'Peak': {  # peak index
-            '#': '[ ]+(?P<Peak>[\d]+)',  # number
+        "Peak": {  # peak index
+            "#": "[ ]+(?P<Peak>[\d]+)",  # number
         },
-        'RetTime': {  # retention time
-            '[min]': '(?P<RetTime>[\d]+.[\d]+)',  # minutes
+        "RetTime": {  # retention time
+            "[min]": "(?P<RetTime>[\d]+.[\d]+)",  # minutes
         },
-        'Type': {  # peak type
-            '': '(?P<Type>[A-Z]{1,3}(?: [A-Z]{1,2})*)',  # todo this is different from <4.8.8 aghplc tools
+        "Type": {  # peak type
+            "": "(?P<Type>[A-Z]{1,3}(?: [A-Z]{1,2})*)",  # todo this is different from <4.8.8 aghplc tools
         },
-        'Width': {  # peak width
-            '[min]': '(?P<Width>[\d]+.[\d]+[e+-]*[\d]+)',
+        "Width": {  # peak width
+            "[min]": "(?P<Width>[\d]+.[\d]+[e+-]*[\d]+)",
         },
-        'Area': {  # peak area
-            '[mAU*s]': '(?P<Area>[\d]+.[\d]+[e+-]*[\d]+)',  # area units
-            '%': '(?P<percent>[\d]+.[\d]+[e+-]*[\d]+)',  # percent
+        "Area": {  # peak area
+            "[mAU*s]": "(?P<Area>[\d]+.[\d]+[e+-]*[\d]+)",  # area units
+            "%": "(?P<percent>[\d]+.[\d]+[e+-]*[\d]+)",  # percent
         },
-        'Height': {  # peak height
-            '[mAU]': '(?P<Height>[\d]+.[\d]+[e+-]*[\d]+)',
+        "Height": {  # peak height
+            "[mAU]": "(?P<Height>[\d]+.[\d]+[e+-]*[\d]+)",
         },
-        'Name': {
-            '': '(?P<Name>[^\s]+(?:\s[^\s]+)*)',  # peak name
+        "Name": {
+            "": "(?P<Name>[^\s]+(?:\s[^\s]+)*)",  # peak name
         },
     }
 
-    def __init__(self, path: str, min_ret_time: int = 0,
-                 max_ret_time: int = 999,
-                 target_wavelength_range: List[int] = range(200, 300)):
+    def __init__(
+        self,
+        path: str,
+        min_ret_time: int = 0,
+        max_ret_time: int = 999,
+        target_wavelength_range=None,
+    ):
         """
         Class to process reports in CSV form.
 
@@ -147,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`.
@@ -162,34 +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))
-            parsed_signals.append(current_wavelength_signals)
-
-        return Ok(AgilentReport(vial_location=None,
-                                solvents=None,
-                                signals=parsed_signals))
+            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)
+
+            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:
         """
@@ -205,9 +294,9 @@ class TXTProcessor(ReportProcessor):
         should be able to use the `parse_area_report` method of aghplctools v4.8.8
         """
         if re.search(_no_peaks_re, report_text):  # There are no peaks in Report.txt
-            raise ValueError('No peaks found 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
@@ -218,65 +307,75 @@ class TXTProcessor(ReportProcessor):
                     si = _signal_info_re.match(table)
                     if si is not None:
                         # some error state (e.g. 'not found')
-                        if si.group('error') != '':
+                        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(
-                                f'The wavelength {float(si.group("wavelength"))} is already in the signals dictionary')
+                                f"The wavelength {float(si.group('wavelength'))} is already in the signals dictionary"
+                            )
                         signals[wavelength] = {}
                         # build peak regex
                         peak_re = self.build_peak_regex(table)
-                        if peak_re is None:  # if there are no columns (empty table), continue
+                        if (
+                            peak_re is None
+                        ):  # if there are no columns (empty table), continue
                             continue
-                        for line in table.split('\n'):
+                        for line in table.split("\n"):
                             peak = peak_re.match(line)
                             if peak is not None:
-                                signals[wavelength][float(peak.group('RetTime'))] = {}
-                                current = signals[wavelength][float(peak.group('RetTime'))]
+                                signals[wavelength][float(peak.group("RetTime"))] = {}
+                                current = signals[wavelength][
+                                    float(peak.group("RetTime"))
+                                ]
                                 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.
 
         :param signal_table: block of lines associated with an area table
         :return: peak line regex object (<=3.6 _sre.SRE_PATTERN, >=3.7 re.Pattern)
         """
-        split_table = signal_table.split('\n')
+        split_table = signal_table.split("\n")
         if len(split_table) <= 4:  # catch peak table with no values
             return None
         # todo verify that these indicies are always true
         column_line = split_table[2]  # table column line
         unit_line = split_table[3]  # column unit line
-        length_line = [len(val) + 1 for val in split_table[4].split('|')]  # length line
+        length_line = [len(val) + 1 for val in split_table[4].split("|")]  # length line
 
         # iterate over header values and units to build peak table regex
         peak_re_string = []
         for header, unit in zip(
-                chunk_string(column_line, length_line),
-                chunk_string(unit_line, length_line)
+            chunk_string(column_line, length_line), chunk_string(unit_line, length_line)
         ):
-            if header == '':  # todo create a better catch for an undefined header
+            if header == "":  # todo create a better catch for an undefined header
                 continue
             try:
                 peak_re_string.append(
-                    self._column_re_dictionary[header][unit]  # append the appropriate regex
+                    self._column_re_dictionary[header][
+                        unit
+                    ]  # append the appropriate regex
                 )
             except KeyError:  # catch for undefined regexes (need to be built)
-                raise KeyError(f'The header/unit combination "{header}" "{unit}" is not defined in the peak regex '
-                               f'dictionary. Let Lars know.')
+                raise KeyError(
+                    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)  # constructed string delimited by 1 or more spaces
-            + '[\s]*'  # and any remaining white space
+            "[ ]+".join(
+                peak_re_string
+            )  # constructed string delimited by 1 or more spaces
+            + "[\s]*"  # and any remaining white space
         )

pychemstation/control/__init__.py

@@ -1,8 +1,11 @@
 """
 .. include:: README.md
 """
+
 from .hplc import HPLCController
+from . import controllers
 
 __all__ = [
-    'HPLCController',
-]
+    "HPLCController",
+    "controllers",
+]

pychemstation/control/controllers/__init__.py

@@ -3,11 +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"]