pychemstation 0.8.3__py3-none-any.whl → 0.8.6__py3-none-any.whl

pychemstation/__init__.py

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

pychemstation/analysis/__init__.py

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

pychemstation/analysis/base_spectrum.py

@@ -6,12 +6,12 @@ from abc import ABC, abstractmethod
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy import (
-    sparse,
-    signal,
     integrate,
+    signal,
+    sparse,
 )
 
-from .utils import interpolate_to_index, find_nearest_value_index
+from ..utils.num_utils import find_nearest_value_index, interpolate_to_index
 
 
 class AbstractSpectrum(ABC):
@@ -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:

pychemstation/{utils → analysis}/chromatogram.py

@@ -6,16 +6,14 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from .parsing import CHFile
-from ..analysis import AbstractSpectrum
 
-# standard filenames for spectral data
-CHANNELS = {"A": "01", "B": "02", "C": "03", "D": "04"}
+from ..utils.parsing import CHFile
+from ..analysis.base_spectrum import AbstractSpectrum
 
 ACQUISITION_PARAMETERS = "acq.txt"
 
 # format used in acquisition parameters
-TIME_FORMAT = "%Y-%m-%d-%H-%M-%S"
+TIME_FORMAT = "%Y-%m-%d %H-%M-%S"
 SEQUENCE_TIME_FORMAT = "%Y-%m-%d %H-%M"
 
 
@@ -39,12 +37,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)

pychemstation/analysis/process_report.py

@@ -4,26 +4,32 @@ import re
 from abc import abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, AnyStr, Dict, Optional, Pattern
+from typing import AnyStr, Dict, List, Optional, Pattern
 
 import pandas as pd
-from aghplctools.ingestion.text import _no_peaks_re, _area_report_re, _header_block_re, _signal_info_re, \
-    _signal_table_re, chunk_string
-from result import Result, Err, Ok
+from aghplctools.ingestion.text import (
+    _area_report_re,
+    _header_block_re,
+    _no_peaks_re,
+    _signal_info_re,
+    _signal_table_re,
+    chunk_string,
+)
+from result import Err, Ok, Result
 
-from pychemstation.utils.chromatogram import AgilentHPLCChromatogram
-from pychemstation.utils.tray_types import Tray, FiftyFourVialPlate
+from ..analysis.chromatogram import AgilentHPLCChromatogram
+from ..utils.tray_types import FiftyFourVialPlate, Tray
 
 
 @dataclass
 class AgilentPeak:
+    peak_number: Optional[int]
     retention_time: float
+    peak_type: Optional[str]
     width: float
     area: float
     height: float
-    peak_number: Optional[int]
-    peak_type: Optional[str]
-    height_percent: Optional[float]
+    area_percent: Optional[float]
 
 
 @dataclass
@@ -67,12 +73,14 @@ class CSVProcessor(ReportProcessor):
         """
         Method to parse details from CSV report.
 
-        :returns: subset of complete report details, specifically the sample location, solvents in pumps,
+        :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, f'REPORT00.CSV')
+        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()
+            df_labels: Dict[int, Dict[int:AnyStr]] = pd.read_csv(
+                labels, encoding="utf-16", header=None
+            ).to_dict()
             vial_location = []
             signals = {}
             solvents = {}
@@ -85,18 +93,33 @@ 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)
+                        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] = peaks
+                        try:
+                            wavelength = df_labels[1][pos + s].partition(",4 Ref=off")[
+                                0
+                            ][-3:]
+                            wavelength = int(wavelength)
+                            signals[wavelength] = list(peaks)
+                        except (IndexError, ValueError):
+                            # TODO: Ask about the MS signals
+                            pass
                     break
 
-            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 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")
 
@@ -105,34 +128,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: List[int] = range(200, 300),
+    ):
         """
         Class to process reports in CSV form.
 
@@ -149,16 +177,17 @@ class TXTProcessor(ReportProcessor):
     def process_report(self) -> Result[AgilentReport, AnyStr]:
         """
         Method to parse details from CSV report.
-
-        :returns: subset of complete report details, specifically the sample location, solvents in pumps,
-         and list of peaks at each wavelength channel.
-
         If you want more functionality, use `aghplctools`.
         `from aghplctools.ingestion.text import pull_hplc_area_from_txt`
         `signals = pull_hplc_area_from_txt(file_path)`
+
+        :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:
+        with open(
+            os.path.join(self.path, "REPORT.TXT"), "r", encoding="utf-16"
+        ) as openfile:
             text = openfile.read()
 
         try:
@@ -166,25 +195,33 @@ class TXTProcessor(ReportProcessor):
         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}
+        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=wavelength, peaks=[], data=None)
+            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'],
-                                                                        height_percent=None))
+                    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))
+        return Ok(
+            AgilentReport(vial_location=None, solvents=None, signals=parsed_signals)
+        )
 
     def parse_area_report(self, report_text: str) -> Dict:
         """
@@ -200,7 +237,7 @@ 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(f'No peaks found in Report.txt')
+            raise ValueError("No peaks found in Report.txt")
         blocks = _header_block_re.split(report_text)
         signals = {}  # output dictionary
         for ind, block in enumerate(blocks):
@@ -213,23 +250,28 @@ 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 = float(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
@@ -248,30 +290,35 @@ class TXTProcessor(ReportProcessor):
         :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/README.md

@@ -1,28 +1,24 @@
-#  Examples of usecases
+# Examples of usecases
 
-## Initialization
 ```python
 from pychemstation.control import HPLCController
 
 DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
-DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
 SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\3\\Sequence"
 DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
+DATA_DIR_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
+DATA_DIR_3 = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
 
-hplc_controller = HPLCController(data_dir=DATA_DIR,
+# Initialize HPLC Controller
+hplc_controller = HPLCController(data_dirs=[DATA_DIR_2, DATA_DIR_3],
                                  comm_dir=DEFAULT_COMMAND_PATH,
                                  method_dir=DEFAULT_METHOD_DIR,
                                  sequence_dir=SEQUENCE_DIR)
-```
 
-## Switching a method
-```python
+# Switching a method
 hplc_controller.switch_method("General-Poroshell")
-```
-
-## Editing a method
 
-```python
+# Editing a method
 from pychemstation.utils.method_types import *
 
 new_method = MethodDetails(
@@ -45,47 +41,27 @@ new_method = MethodDetails(
     stop_time=5,
     post_time=2
 )
-
 hplc_controller.edit_method(new_method)
-```
 
-## Running a method and get data from last run method
-```python
+# Run a method and get a report or data from last run method
 hplc_controller.run_method(experiment_name="test_experiment")
 chrom = hplc_controller.get_last_run_method_data()
 channel_a_time = chrom.A.x
-```
+report = hplc_controller.get_last_run_method_report()
+vial_location = report.vial_location
 
-## Switching a sequence
-```python
+# switch the currently loaded sequence
 hplc_controller.switch_sequence(sequence_name="hplc_testing")
-```
-## Editing a Sequence Row
-```python
-from pychemstation.utils.sequence_types import *
-from pychemstation.utils.tray_types import *
 
-hplc_controller.edit_sequence_row(SequenceEntry(
-    vial_location=FiftyFourVialPlate(plate=Plate.TWO, letter=Letter.A, num=Num.SEVEN).value(),
-    method="General-Poroshell",
-    num_inj=3,
-    inj_vol=4,
-    sample_name="Blank",
-    sample_type=SampleType.BLANK,
-    inj_source=InjectionSource.HIP_ALS
-), 1)
-```
-
-## Editing entire Sequence Table
-```python
+# edit the sequence table
 from pychemstation.utils.tray_types import *
 from pychemstation.utils.sequence_types import *
 
 seq_table = SequenceTable(
-    name=DEFAULT_SEQUENCE,
+    name="hplc_testing",
     rows=[
         SequenceEntry(
-            vial_location=FiftyFourVialPlate(plate=Plate.TWO, letter=Letter.A, num=Num.SEVEN).value(),
+            vial_location=FiftyFourVialPlate.from_str("P1-A1"),
             method="General-Poroshell",
             num_inj=3,
             inj_vol=4,
@@ -94,7 +70,7 @@ seq_table = SequenceTable(
             inj_source=InjectionSource.MANUAL
         ),
         SequenceEntry(
-            vial_location=TenVialColumn.ONE.value,
+            vial_location=TenVialColumn.ONE,
             method="General-Poroshell",
             num_inj=1,
             inj_vol=1,
@@ -103,7 +79,7 @@ seq_table = SequenceTable(
             inj_source=InjectionSource.AS_METHOD
         ),
         SequenceEntry(
-            vial_location=10,
+            vial_location=FiftyFourVialPlate.from_str("P2-B4"),
             method="General-Poroshell",
             num_inj=3,
             inj_vol=4,
@@ -114,11 +90,11 @@ seq_table = SequenceTable(
     ]
 )
 hplc_controller.edit_sequence(seq_table)
-```
 
-## Running a sequence and get data from last run sequence
-```python
-hplc_controller.run_sequence(seq_table)
-chroms = hplc_controller.get_last_run_sequence_data()
-channel_A_time = chroms[0].A.x
+# Run a sequence and get data or report from last run sequence
+hplc_controller.run_sequence()
+chroms = hplc_controller.get_last_run_sequence_data(read_uv=True)
+row_1_channel_A_abs = chroms[0][210].y
+report = hplc_controller.get_last_run_sequence_reports()
+vial_location_row_1 = report[0].vial_location
 ```

pychemstation/control/__init__.py

@@ -1,4 +1,9 @@
 """
 .. include:: README.md
 """
+
 from .hplc import HPLCController
+
+__all__ = [
+    "HPLCController",
+]

pychemstation/control/controllers/__init__.py

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

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}")