pychemstation 0.5.15__py3-none-any.whl → 0.6.1__py3-none-any.whl

pychemstation/analysis/process_report.py

@@ -0,0 +1,219 @@
+"""
+pip install pandas
+pip install aghplctools==4.8.6
+"""
+
+import os
+import re
+from dataclasses import dataclass
+from typing import List, AnyStr
+
+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
+
+
+@dataclass
+class AgilentPeak:
+    peak_number: int
+    retention_time: float
+    peak_type: str
+    width: float
+    area: float
+    height: float
+    height_percent: float
+
+
+_column_re_dictionary = {  # regex matches for column and unit combinations
+    'Peak': {  # peak index
+        '#': '[ ]+(?P<Peak>[\d]+)',  # number
+    },
+    '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
+    },
+    '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
+    },
+    'Height': {  # peak height
+        '[mAU]': '(?P<Height>[\d]+.[\d]+[e+-]*[\d]+)',
+    },
+    'Name': {
+        '': '(?P<Name>[^\s]+(?:\s[^\s]+)*)',  # peak name
+    },
+}
+
+
+def build_peak_regex(signal_table: str):
+    """
+    Builds a peak regex from a signal table
+
+    :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')
+    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
+
+    # 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)
+    ):
+        if header == '':  # todo create a better catch for an undefined header
+            continue
+        try:
+            peak_re_string.append(
+                _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.')
+    return re.compile(
+        '[ ]+'.join(peak_re_string)  # constructed string delimited by 1 or more spaces
+        + '[\s]*'  # and any remaining white space
+    )
+
+
+# todo should be able to use the parse_area_report method of aghplctools v4.8.8
+
+def parse_area_report(report_text: str) -> dict:
+    """
+    Interprets report text and parses the area report section, converting it to dictionary.
+
+    :param report_text: plain text version of the report.
+    :raises ValueError: if there are no peaks defined in the report text file
+    :return: dictionary of signals in the form
+        dict[wavelength][retention time (float)][Width/Area/Height/etc.]
+    """
+    if re.search(_no_peaks_re, report_text):  # There are no peaks in Report.txt
+        raise ValueError(f'No peaks found in Report.txt')
+    blocks = _header_block_re.split(report_text)
+    signals = {}  # output dictionary
+    for ind, block in enumerate(blocks):
+        # area report block
+        if _area_report_re.match(block):  # match area report block
+            # break into signal blocks
+            signal_blocks = _signal_table_re.split(blocks[ind + 1])
+            # iterate over signal blocks
+            for table in signal_blocks:
+                si = _signal_info_re.match(table)
+                if si is not None:
+                    # some error state (e.g. 'not found')
+                    if si.group('error') != '':
+                        continue
+                    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')
+                    signals[wavelength] = {}
+                    # build peak regex
+                    peak_re = build_peak_regex(table)
+                    if peak_re is None:  # if there are no columns (empty table), continue
+                        continue
+                    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'))]
+                            for key in _column_re_dictionary:
+                                if key in peak.re.groupindex:
+                                    try:  # try float conversion, otherwise continue
+                                        value = float(peak.group(key))
+                                    except ValueError:
+                                        value = peak.group(key)
+                                    current[key] = value
+                                else:  # ensures defined
+                                    current[key] = None
+    return signals
+
+
+def process_export_report(file_path, target_wavelengths=None, min_retention_time=0, max_retention_time=999):
+    # # Pull signals from the file
+    # from aghplctools.ingestion.text import pull_hplc_area_from_txt
+    # signals = pull_hplc_area_from_txt(file_path)
+
+    with open(file_path, 'r', encoding='utf-16') as openfile:
+        text = openfile.read()
+
+    try:
+        signals = parse_area_report(text)
+    except ValueError as e:
+        # value error thrown if there are no peaks found in the report
+        print(e)
+        return [], [], []
+
+    # filter wavelengths by the ones to keep
+    if target_wavelengths is not None:
+        signals = {key: signals[key] for key in target_wavelengths if key in signals}
+
+    wavelengths = []
+    retention_times = []
+    areas = []
+
+    for wavelength, wavelength_dict in signals.items():
+        for ret_time, ret_time_dict in wavelength_dict.items():
+            if min_retention_time <= ret_time <= max_retention_time:
+                wavelengths.append(wavelength)
+                retention_times.append(ret_time)
+                areas.append(ret_time_dict['Area'])
+
+    return wavelengths, retention_times, areas
+
+
+def process_folder(folder_path, target_wavelengths=None, min_retention_time=0, max_retention_time=999):
+    # folder path is the path to the overall folder, and inside there should be subfolders for each LC sample
+    # each subfolder should have a Report.TXT file
+    # sample_names = []
+    wavelengths = []
+    retention_times = []
+    peak_areas = []
+
+    # Get a list of all items (files and directories) in the folder
+    items = [os.path.join(folder_path, item) for item in os.listdir(folder_path)]
+
+    # Filter only directories from the list
+    # folders = [item for item in items if os.path.isdir(item)]
+
+    # # Sort the folders by creation date
+    # sorted_folders = sorted(folders, key=lambda f: os.stat(f).st_ctime)
+
+    for filename in items:
+        if filename.endswith('Report.TXT'):
+            # file_path = os.path.join(subfolder, filename)
+            file_wavelengths, file_retention_times, file_peak_areas = process_export_report(filename,
+                                                                                            target_wavelengths,
+                                                                                            min_retention_time,
+                                                                                            max_retention_time)
+            wavelengths.extend(file_wavelengths)
+            retention_times.extend(file_retention_times)
+            peak_areas.extend(file_peak_areas)
+
+    results_df = pd.DataFrame({'Wavelengths': wavelengths, 'Retention Times': retention_times, 'Areas': peak_areas})
+
+    # Save the results to a CSV file
+    # results_csv_path = os.path.join(folder_path, 'all_sample_data.csv')  # Specify the desired file path
+    # results_df.to_csv(results_csv_path, index=False)
+    # print(f"Results saved to {results_csv_path}")
+    return results_df
+
+
+def process_csv_report(folder_path: str, num: int) -> Result[List[AgilentPeak], AnyStr]:
+    potential_report = os.path.join(folder_path, f'REPORT0{num}.CSV')
+    if os.path.exists(potential_report):
+        df = pd.read_csv(potential_report, encoding="utf-16", header=None)
+        return Ok(df.apply(lambda row: AgilentPeak(*row), axis=1))
+    return Err("No report found")

pychemstation/control/controllers/devices/device.py

@@ -9,8 +9,8 @@ from ....utils.table_types import Table
 
 class DeviceController(TableController, abc.ABC):
 
-    def __init__(self, controller: CommunicationController, table: Table):
-        super().__init__(controller, None, None, table)
+    def __init__(self, controller: CommunicationController, table: Table, offline: bool):
+        super().__init__(controller, None, None, table, offline)
 
     @abc.abstractmethod
     def get_row(self, row: int):

pychemstation/control/controllers/devices/injector.py

@@ -7,8 +7,8 @@ from ....utils.table_types import Table, RegisterFlag
 
 class InjectorController(DeviceController):
 
-    def __init__(self, controller: CommunicationController, table: Table):
-        super().__init__(controller, table)
+    def __init__(self, controller: CommunicationController, table: Table, offline: bool):
+        super().__init__(controller, table, offline)
 
     def get_row(self, row: int) -> InjectorFunction:
         def return_tray_loc() -> Tray:
@@ -35,27 +35,14 @@ class InjectorController(DeviceController):
     def load(self) -> InjectorTable:
         rows = self.get_num_rows()
         if rows.is_ok():
-            return InjectorTable(functions=[self.get_row(i + 1) for i in range(int(rows.ok_value.num_response))])
+            return InjectorTable(functions=[self.get_row(i) for i in range(int(rows.ok_value.num_response))])
 
     def edit(self, injector_table: InjectorTable):
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            existing_row_num = rows.value.num_response
-            wanted_row_num = len(injector_table.functions)
-            while existing_row_num != wanted_row_num:
-                if wanted_row_num > existing_row_num:
-                    self.add_row()
-                elif wanted_row_num < existing_row_num:
-                    self.delete_row(int(existing_row_num))
-                self.send(Command.SAVE_METHOD_CMD)
-                existing_row_num = self.get_num_rows().ok_value.num_response
-            self.send(Command.SWITCH_METHOD_CMD)
-
         columns_added = set()
 
         def add_table_val(col_name: RegisterFlag, val: Union[str, int, float]):
             nonlocal columns_added
-            if col_name in columns_added:
+            if True:
                 if isinstance(val, str):
                     self.edit_row_text(col_name=col_name, val=val)
                 else:
@@ -102,21 +89,29 @@ class InjectorController(DeviceController):
             add_table_val(col_name=RegisterFlag.REMOTE, val=remote.command.value)
             add_table_val(col_name=RegisterFlag.REMOTE_DUR, val=remote.duration)
 
-        for i, function in enumerate(injector_table.functions):
-            self.add_row()
-            if isinstance(function, Inject):
-                add_inject(function)
-            elif isinstance(function, Draw):
-                add_draw(function)
-            elif isinstance(function, Wait):
-                add_wait(function)
-            elif isinstance(function, Remote):
-                add_remote(function)
-            self.download()
         self.send(Command.SAVE_METHOD_CMD)
-        self.send(Command.SWITCH_METHOD_CMD)
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            existing_row_num = rows.value.num_response
+            for i, function in enumerate(injector_table.functions):
+                if (i+1) > existing_row_num:
+                    self.add_row()
+                if isinstance(function, Inject):
+                    add_inject(function)
+                elif isinstance(function, Draw):
+                    add_draw(function)
+                elif isinstance(function, Wait):
+                    add_wait(function)
+                elif isinstance(function, Remote):
+                    add_remote(function)
+                self.download()
+                self.send(Command.SAVE_METHOD_CMD)
+                self.send(Command.SWITCH_METHOD_CMD)
+                existing_row_num = self.get_num_rows().ok_value.num_response
 
     def download(self):
+        self.send('Sleep 1')
+        self.sleepy_send("DownloadRCMethod WLS1")
         self.send('Sleep 1')
         self.sleepy_send("DownloadLWls 1")
         self.send('Sleep 1')

pychemstation/control/hplc.py

@@ -57,7 +57,8 @@ class HPLCController:
                                                   table=self.METHOD_TIMETABLE,
                                                   offline=offline,
                                                   injector_controller=InjectorController(controller=self.comm,
-                                                                                         table=self.INJECTOR_TABLE))
+                                                                                         table=self.INJECTOR_TABLE,
+                                                                                         offline=offline))
         self.sequence_controller = SequenceController(controller=self.comm,
                                                       src=sequence_dir,
                                                       data_dir=data_dir,
@@ -127,9 +128,6 @@ class HPLCController:
         """
         self.sequence_controller.run(stall_while_running=stall_while_running)
 
-    def edit_injector_program(self, injector_table: InjectorTable):
-        self.method_controller.injector_controller.edit(injector_table=injector_table)
-
     def edit_method(self, updated_method: MethodDetails, save: bool = False):
         """Updated the currently loaded method in ChemStation with provided values.
 

{pychemstation-0.5.15.dist-info → pychemstation-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.15
+Version: 0.6.1
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao

{pychemstation-0.5.15.dist-info → pychemstation-0.6.1.dist-info}/RECORD

@@ -1,11 +1,12 @@
 pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
 pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt420YMI4,44
 pychemstation/analysis/base_spectrum.py,sha256=XPf9eJ72uz0CnxCY5uFOyu1MbVX-OTTXeN1tLzIMok4,16536
+pychemstation/analysis/process_report.py,sha256=d290KgPY-cMlQg4yHaspLFxgso_yu9qNxXG6SF2qpuo,9054
 pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-GKjiDi8,10201
 pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
 pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
 pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
-pychemstation/control/hplc.py,sha256=IdHH4Yho5cJDDBLcc6k0XKDFDecghaY8NaA4dIU7KB8,9898
+pychemstation/control/hplc.py,sha256=8vKdm5sTGY_VnBRqcAS3EMRJAQ2wbLRbFswaSi2CHHc,9848
 pychemstation/control/controllers/__init__.py,sha256=EM6LBNSTJqYVatmnvPq0P-S3q0POA88c-y64zL79I_I,252
 pychemstation/control/controllers/comm.py,sha256=IU4I_Q42VNCNUlVi93MxCmw2EBY9hiBDkU9FxubKg3c,7441
 pychemstation/control/controllers/method.py,sha256=XUclB7lQ_SIkquR58MBmmi9drHIPEq9AR8VprTLenvI,15503
@@ -13,8 +14,9 @@ pychemstation/control/controllers/sequence.py,sha256=kYNxxck2I-q9mZDEZwG8bJ_99Ff
 pychemstation/control/controllers/table_controller.py,sha256=70ovnIjLKkJborS1ztk445Mv42TtUM9jUniaQmZuyWQ,11031
 pychemstation/control/controllers/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/control/controllers/devices/column.py,sha256=SCpCnVFZFUM9LM51MbWkVcBRayN3WFxy7lz9gs2PYeY,348
-pychemstation/control/controllers/devices/device.py,sha256=SF1JK93FjmACnYrlKvldX3gEeA21qnXZegeNhc9QJGQ,738
-pychemstation/control/controllers/devices/injector.py,sha256=ul5q8quGcB7N3sNPBWbifIoqGdp95LJMXPAbcufHBng,5728
+pychemstation/control/controllers/devices/dad.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/control/controllers/devices/device.py,sha256=QUFpUwmGxMzmG1CiRhNauV5cVZEJyRXyQDNQuW8Qfxk,762
+pychemstation/control/controllers/devices/injector.py,sha256=Kxf4NjxPUt2xjOmJ9Pea1b9YzWyGcpW8VdOlx9Jo-Nw,5540
 pychemstation/control/controllers/devices/pump.py,sha256=DJQh4lNXEraeC1CWrsKmsITOjuYlRI3tih_XRB3F1hg,1404
 pychemstation/control/controllers/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/control/controllers/tables/method.py,sha256=3GdAQ6Cwf20QL3v7eMkwNieWbJdtr9GN12USbSVl_iE,16426
@@ -42,11 +44,12 @@ tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/constants.py,sha256=55DOLpylLt12mb_gSgzEo-EYynwTmI2uH7PcrTM6Iq0,2455
 tests/test_comb.py,sha256=TS-CbtiPbntL4u6E1gSZ6xquNp6cQxIFdJqUr2ak7PA,5515
 tests/test_comm.py,sha256=iwl-Ey-xoytXmlNrjG84pDm82Ry_QUX6wY4gmVh4NDc,2516
-tests/test_inj.py,sha256=1ib-RwVouBLmWJO1KLQD8ghIqpD2xi1ePsrEw49mNIU,2045
+tests/test_inj.py,sha256=Blpk-z9PQuqo4xQ7AUi0CS2czMiYm-pqZe75OFTXru4,1092
 tests/test_method.py,sha256=KB7yAtVb4gZftnYzh-VfPb9LGVZOHUIW6OljEYRtbhA,4570
+tests/test_proc_rep.py,sha256=WhUiFqDD1Aey_Nc6Hvbd2zo48K4MWjwDhfO9LiwEQ7M,703
 tests/test_sequence.py,sha256=vs5-dqkItRds_tPM2-N6MNJ37FB0nLRFaDzBV8d42i8,4880
-pychemstation-0.5.15.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.15.dist-info/METADATA,sha256=aAdW7pVUfyidEcFiPaEMUFzGLl4DLormW-51LsCbaU0,4371
-pychemstation-0.5.15.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.15.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.15.dist-info/RECORD,,
+pychemstation-0.6.1.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.6.1.dist-info/METADATA,sha256=oGTCg13YoFF8G2T3aPXss0aKXNveIK9n_UMLpdYQVxM,4370
+pychemstation-0.6.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.6.1.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.6.1.dist-info/RECORD,,

tests/test_inj.py

@@ -2,8 +2,6 @@ import os
 import unittest
 
 from pychemstation.control import HPLCController
-from pychemstation.utils.injector_types import *
-from pychemstation.utils.tray_types import FiftyFourVialPlate, Plate, Letter, Num
 from tests.constants import *
 
 
@@ -19,36 +17,16 @@ class TestInj(unittest.TestCase):
                                               method_dir=path_constants[1],
                                               data_dir=path_constants[2],
                                               sequence_dir=path_constants[3])
+        # self.hplc_controller.switch_method(DEFAULT_METHOD)
 
     def test_load_inj(self):
-        self.hplc_controller.switch_method(DEFAULT_METHOD)
         try:
             inj_table = self.hplc_controller.load_injector_program()
             self.assertTrue(len(inj_table.functions) == 2)
         except Exception as e:
             self.fail(f"Should have not failed, {e}")
 
-    def test_edit_inj(self):
-        self.hplc_controller.switch_method(DEFAULT_METHOD)
-        try:
-            injector_program = InjectorTable(
-                functions=[
-                    Draw(amount=0.3, location="P1-A2"),
-                           Inject()]
-            )
-            self.hplc_controller.edit_injector_program(injector_program)
-        except Exception as e:
-            self.fail(f"Should have not failed: {e}")
 
-    def test_edit_inj_def(self):
-        self.hplc_controller.switch_method(DEFAULT_METHOD)
-        try:
-            injector_program = InjectorTable(
-                functions=[Draw(location="P1-F2"), Inject()]
-            )
-            self.hplc_controller.edit_injector_program(injector_program)
-        except Exception as e:
-            self.fail(f"Should have not failed: {e}")
 
 
 if __name__ == '__main__':

tests/test_proc_rep.py

@@ -0,0 +1,27 @@
+import unittest
+
+from result import Result
+
+from pychemstation.analysis.process_report import process_csv_report
+
+
+class TestReport(unittest.TestCase):
+
+    def test_process_reporttxt(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_report_csv(self):
+        try:
+            possible_peaks: Result = process_csv_report(folder_path="0_2025-03-15 19-14-35.D", num=1)
+            self.assertTrue(len(possible_peaks.ok_value) == 16)
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+
+if __name__ == '__main__':
+    unittest.main()