pychemstation 0.5.14.dev1__py3-none-any.whl → 0.6.0__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/injector.py

@@ -1,11 +1,117 @@
 from ....control.controllers import CommunicationController
 from .device import DeviceController
-from ....utils.table_types import Table
+from ....utils.injector_types import *
+from ....utils.macro import Command
+from ....utils.table_types import Table, RegisterFlag
 
 
 class InjectorController(DeviceController):
-    def get_row(self, row: int):
-        pass
 
     def __init__(self, controller: CommunicationController, table: Table):
         super().__init__(controller, table)
+
+    def get_row(self, row: int) -> InjectorFunction:
+        def return_tray_loc() -> Tray:
+            pass
+
+        function = self.get_text(row, RegisterFlag.FUNCTION)
+        if function == "Wait":
+            return Wait(duration=self.get_num(row, RegisterFlag.TIME))
+        elif function == "Inject":
+            return Inject()
+        elif function == "Draw":
+            # TODO: better error handling
+            is_source = SourceType(self.get_text(row, RegisterFlag.DRAW_SOURCE))
+            is_volume = Mode(self.get_text(row, RegisterFlag.DRAW_VOLUME))
+            vol = self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE) if is_volume == Mode.SET else None
+            if is_source is SourceType.SPECIFIC_LOCATION:
+                return Draw(amount=vol, source=return_tray_loc())
+            elif is_source is SourceType.LOCATION:
+                return Draw(amount=vol, location=self.get_text(row, RegisterFlag.DRAW_LOCATION))
+        elif function == "Remote":
+            return Remote(command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
+                          duration=self.get_num(row, RegisterFlag.REMOTE_DUR))
+
+    def load(self) -> InjectorTable:
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            return InjectorTable(functions=[self.get_row(i) for i in range(int(rows.ok_value.num_response))])
+
+    def edit(self, injector_table: InjectorTable):
+        columns_added = set()
+
+        def add_table_val(col_name: RegisterFlag, val: Union[str, int, float]):
+            nonlocal columns_added
+            if True:
+                if isinstance(val, str):
+                    self.edit_row_text(col_name=col_name, val=val)
+                else:
+                    self.edit_row_num(col_name=col_name, val=val)
+            else:
+                if isinstance(val, str):
+                    self.add_new_col_text(col_name=col_name, val=val)
+                else:
+                    self.add_new_col_num(col_name=col_name, val=val)
+                columns_added.add(col_name)
+
+        def add_inject(inject: Inject):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=inject.__class__.__name__)
+
+        def add_draw(draw: Draw):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=draw.__class__.__name__)
+            add_table_val(col_name=RegisterFlag.DRAW_SPEED, val=SourceType.DEFAULT.value)
+            add_table_val(col_name=RegisterFlag.DRAW_OFFSET, val=SourceType.DEFAULT.value)
+
+            if draw.amount:
+                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.SET.value)
+                add_table_val(col_name=RegisterFlag.DRAW_VOLUME_VALUE, val=draw.amount)
+            else:
+                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.DEFAULT.value)
+
+            if draw.location:
+                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.LOCATION.value)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION, val=draw.location)
+            elif draw.source:
+                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.SPECIFIC_LOCATION.value)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_UNIT, val=1)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_TRAY, val=1)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_ROW, val=1)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_COLUMN, val=1)
+            else:
+                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.DEFAULT.value)
+
+        def add_wait(wait: Wait):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=wait.__class__.__name__)
+            add_table_val(col_name=RegisterFlag.TIME, val=wait.duration)
+
+        def add_remote(remote: Remote):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=remote.__class__.__name__)
+            add_table_val(col_name=RegisterFlag.REMOTE, val=remote.command.value)
+            add_table_val(col_name=RegisterFlag.REMOTE_DUR, val=remote.duration)
+
+        self.send(Command.SAVE_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/controllers/tables/method.py

@@ -4,6 +4,7 @@ import time
 from xsdata.formats.dataclass.parsers import XmlParser
 
 from .table import TableController
+from ..devices.injector import InjectorController
 from ....control.controllers import CommunicationController
 from ....generated import PumpMethod, DadMethod, SolventElement
 from ....utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
@@ -17,7 +18,13 @@ class MethodController(TableController):
     Class containing method related logic
     """
 
-    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table, offline: bool):
+    def __init__(self, controller: CommunicationController,
+                 src: str,
+                 data_dir: str,
+                 table: Table,
+                 offline: bool,
+                 injector_controller: InjectorController):
+        self.injector_controller = injector_controller
         super().__init__(controller, src, data_dir, table, offline=offline)
 
     def check(self) -> str:
@@ -310,8 +317,6 @@ class MethodController(TableController):
 
         :param experiment_name: Name of the experiment
         """
-        if not self.table_state:
-            self.table_state = self.load()
 
         folder_name = ""
         hplc_is_running = False
@@ -331,13 +336,17 @@ class MethodController(TableController):
         self.data_files.append(os.path.join(self.data_dir, folder_name))
 
         if stall_while_running:
+
+            if not self.table_state:
+                self.table_state = self.load()
+
             run_completed = self.check_hplc_done_running(method=self.table_state)
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
                 raise RuntimeError("Run error has occurred.")
         else:
-            self.data_files[-1].dir = self.fuzzy_match_most_recent_folder(folder_name).ok_value
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(folder_name).ok_value
 
     def retrieve_recent_data_files(self) -> str:
         return self.data_files[-1]

pychemstation/control/controllers/tables/table.py

@@ -6,6 +6,7 @@ Authors: Lucy Hao
 
 import abc
 import os
+import warnings
 from dataclasses import dataclass
 from typing import Union, Optional
 
@@ -33,8 +34,8 @@ class ChromData:
 class TableController(abc.ABC):
 
     def __init__(self, controller: CommunicationController,
-                 src: str,
-                 data_dir: str,
+                 src: Optional[str],
+                 data_dir: Optional[str],
                  table: Table,
                  offline: bool = False):
         self.controller = controller
@@ -45,26 +46,27 @@ class TableController(abc.ABC):
             # Initialize row counter for table operations
             self.send('Local Rows')
 
-            if os.path.isdir(src):
+            if src and os.path.isdir(src):
                 self.src: str = src
             else:
-                raise FileNotFoundError(f"dir: {src} not found.")
+                warnings.warn(f"dir: {src} not found.")
 
-            if os.path.isdir(data_dir):
+            if data_dir and os.path.isdir(data_dir):
                 self.data_dir: str = data_dir
             else:
-                raise FileNotFoundError(f"dir: {data_dir} not found.")
-
-            self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
-            "A": AgilentHPLCChromatogram(self.data_dir),
-            "B": AgilentHPLCChromatogram(self.data_dir),
-            "C": AgilentHPLCChromatogram(self.data_dir),
-            "D": AgilentHPLCChromatogram(self.data_dir),
-            "E": AgilentHPLCChromatogram(self.data_dir),
-            "F": AgilentHPLCChromatogram(self.data_dir),
-            "G": AgilentHPLCChromatogram(self.data_dir),
-            "H": AgilentHPLCChromatogram(self.data_dir),
-        }
+                warnings.warn(f"dir: {data_dir} not found.")
+
+            if hasattr(self, "data_dir"):
+                self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
+                    "A": AgilentHPLCChromatogram(self.data_dir),
+                    "B": AgilentHPLCChromatogram(self.data_dir),
+                    "C": AgilentHPLCChromatogram(self.data_dir),
+                    "D": AgilentHPLCChromatogram(self.data_dir),
+                    "E": AgilentHPLCChromatogram(self.data_dir),
+                    "F": AgilentHPLCChromatogram(self.data_dir),
+                    "G": AgilentHPLCChromatogram(self.data_dir),
+                    "H": AgilentHPLCChromatogram(self.data_dir),
+                }
         else:
             self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
                 "A": AgilentHPLCChromatogram(),
@@ -80,8 +82,6 @@ class TableController(abc.ABC):
 
         self.uv = None
 
-
-
     def receive(self) -> Result[Response, str]:
         for _ in range(10):
             try:
@@ -107,7 +107,7 @@ class TableController(abc.ABC):
         """
         self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
 
-    def get_num(self, row: int, col_name: RegisterFlag) -> float:
+    def get_num(self, row: int, col_name: RegisterFlag) -> Union[int, float]:
         return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table.register,
                                                                                    table_name=self.table.name,
                                                                                    row=row,

pychemstation/control/hplc.py

@@ -6,8 +6,10 @@ Authors: Lucy Hao
 
 from typing import Union, Optional
 
+from .controllers.devices.injector import InjectorController
 from ..control.controllers import MethodController, SequenceController, CommunicationController
 from ..utils.chromatogram import AgilentChannelChromatogramData
+from ..utils.injector_types import InjectorTable
 from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
 from ..utils.method_types import MethodDetails
 from ..utils.sequence_types import SequenceTable, SequenceEntry
@@ -27,8 +29,13 @@ class HPLCController:
     )
 
     INJECTOR_TABLE = Table(
-        register="_LeoAlsMethod",
-        name="ProgTable"
+        register="RCWLS1Pretreatment[1]",
+        name="InstructionTable"
+    )
+
+    MSD_TABLE = Table(
+        register="MSACQINFO[1]",
+        name="SprayChamber"
     )
 
     def __init__(self,
@@ -48,7 +55,9 @@ class HPLCController:
                                                   src=method_dir,
                                                   data_dir=data_dir,
                                                   table=self.METHOD_TIMETABLE,
-                                                  offline=offline)
+                                                  offline=offline,
+                                                  injector_controller=InjectorController(controller=self.comm,
+                                                                                         table=self.INJECTOR_TABLE))
         self.sequence_controller = SequenceController(controller=self.comm,
                                                       src=sequence_dir,
                                                       data_dir=data_dir,
@@ -176,6 +185,9 @@ class HPLCController:
         """
         return self.method_controller.check()
 
+    def load_injector_program(self) -> InjectorTable:
+        return self.method_controller.injector_controller.load()
+
     def load_method(self) -> MethodDetails:
         """
         Returns all details of the currently loaded method, including its timetable.

pychemstation/utils/injector_types.py

@@ -1,20 +1,31 @@
 from dataclasses import dataclass
-from typing import Any
+from enum import Enum
+from typing import  Union, Optional
 
 from pychemstation.utils.tray_types import Tray
 
 
+class SourceType(Enum):
+    DEFAULT = "ActualPosition"
+    SPECIFIC_LOCATION = "ActualPositionPlusLocation"
+    LOCATION = "Location"
+
+
+class Mode(Enum):
+    DEFAULT = "Default"
+    SET = "Set"
+
+
 @dataclass
 class Draw:
-    amount: float
-    source: Tray
-    speed: Any
-    offset: Any
+    amount: Optional[float] = None
+    location: Optional[str] = None
+    source: Optional[Tray] = None
 
 
 @dataclass
 class Wait:
-    time: int
+    duration: int
 
 
 @dataclass
@@ -22,7 +33,18 @@ class Inject:
     pass
 
 
-InjectorFunction = [Draw, Wait, Inject]
+class RemoteCommand(Enum):
+    START = "START"
+    PREPARE = "PREPARE"
+
+
+@dataclass
+class Remote:
+    command: RemoteCommand
+    duration: int
+
+
+InjectorFunction = Union[Draw, Wait, Inject, Remote]
 
 
 @dataclass

pychemstation/utils/macro.py

@@ -37,7 +37,7 @@ class Command(Enum):
     # Method and Sequence Related
     GET_METHOD_CMD = "response$ = _MethFile$"
     GET_ROWS_CMD = 'response_num = TabHdrVal({register}, "{table_name}", "{col_name}")'
-    SWITCH_METHOD_CMD = 'LoadMethod "{method_dir}", "{method_name}.M"'
+    SWITCH_METHOD_CMD = 'LoadMethod _MethPath$, _MethFile$'
     START_METHOD_CMD = "StartMethod"
     RUN_METHOD_CMD = 'RunMethod "{data_dir}",, "{experiment_name}_{timestamp}"'
     STOP_METHOD_CMD = "StopMethod"

pychemstation/utils/method_types.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Union, Any, Optional
 
+from .injector_types import InjectorTable
 from .table_types import RegisterFlag
 from ..generated import Signal
 
@@ -36,7 +37,7 @@ class TimeTableEntry:
 
 @dataclass
 class MethodDetails:
-    """An Agilent Chemstation method, TODO is to add MS parameters
+    """An Agilent Chemstation method, TODO is to add MS parameters, injector parameters
 
     :attribute name: the name of the method, should be the same as the Chemstation method name.
     :attribute timetable: list of entries in the method timetable
@@ -49,6 +50,7 @@ class MethodDetails:
     name: str
     params: HPLCMethodParams
     timetable: list[TimeTableEntry]
+    injector_program: Optional[InjectorTable] = None
     stop_time: Optional[int] = None
     post_time: Optional[int] = None
     dad_wavelengthes: Optional[list[Signal]] = None

pychemstation/utils/table_types.py

@@ -65,6 +65,26 @@ class RegisterFlag(Enum):
     SAMPLE_TYPE = "SampleType"
     DATA_FILE = "DataFileName"
 
+    # for Injector Table
+    ## Draw
+    DRAW_SOURCE = "DrawSource"
+    DRAW_VOLUME = "DrawVolume_Mode"
+    DRAW_SPEED = "DrawSpeed_Mode"
+    DRAW_OFFSET = "DrawOffset_Mode"
+    # SetObjHdrVal RCWLS1Pretreatment[1], "DrawVolume_Value", 1
+    DRAW_VOLUME_VALUE = "DrawVolume_Value"
+    DRAW_LOCATION = "DrawLocation"
+    DRAW_LOCATION_TRAY = "DrawLocationPlus_Tray"
+    DRAW_LOCATION_UNIT = "DrawLocationPlus_Unit"
+    DRAW_LOCATION_ROW = "DrawLocationPlus_Row"
+    DRAW_LOCATION_COLUMN = "DrawLocationPlus_Column"
+    ## Inject
+    ## Wait
+    ## Remote
+    REMOTE = "RemoteLine"
+    REMOTE_DUR = "RemoteDuration"
+
+
 
 @dataclass
 class Table:

{pychemstation-0.5.14.dev1.dist-info → pychemstation-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.14.dev1
+Version: 0.6.0
 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.14.dev1.dist-info → pychemstation-0.6.0.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=UlafodQoFFow2UVo-INK1ZjxyJ5vrVvv1TjB5VyAsHo,9178
+pychemstation/control/hplc.py,sha256=LkNB_wKNaW3pU-OZlYfwFbXGWU2Iwmr1WD5c3dCWEbY,9742
 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,14 +14,15 @@ 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/dad.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/control/controllers/devices/device.py,sha256=SF1JK93FjmACnYrlKvldX3gEeA21qnXZegeNhc9QJGQ,738
-pychemstation/control/controllers/devices/injector.py,sha256=PfkSQlpE1zMzwyJ55Km1AdtPtdOS2RNyHDwAt_ZNa6M,349
+pychemstation/control/controllers/devices/injector.py,sha256=1iZgPQYw6AcV1VKw0RG-k94czE8lCRVWx5NCCubIOZA,5516
 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=Woni_nAEWRZ79wf2WixLnJWZONNdGgZGGV9GG7m0qCQ,16189
+pychemstation/control/controllers/tables/method.py,sha256=3GdAQ6Cwf20QL3v7eMkwNieWbJdtr9GN12USbSVl_iE,16426
 pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
 pychemstation/control/controllers/tables/sequence.py,sha256=vqwJeV38YWdFnaDXvZVOGYl-UCV9lmMbh8Fj5kQ3mqY,8815
-pychemstation/control/controllers/tables/table.py,sha256=pJCtMDGHweBhm_BEo0qhh2AjCjYAx1QyIY0AShs707A,12411
+pychemstation/control/controllers/tables/table.py,sha256=J-uNIFHVznPJqOKPmmqrJBXt70KlxmZlSdtEVM2pEKM,12576
 pychemstation/control/table/__init__.py,sha256=RgMN4uIWHdNUHpGRBWdzmzAbk7XEKl6Y-qtqWCxzSZU,124
 pychemstation/control/table/method.py,sha256=THVoGomSXff_CTU3eAYme0BYwkPzab5UgZKsiZ29QSk,12196
 pychemstation/control/table/sequence.py,sha256=Eri52AnbE3BGthfrRSvYKYciquUzvHKo0lYUTySYYE8,10542
@@ -30,23 +32,24 @@ pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCs
 pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/chromatogram.py,sha256=-q3_hL9GTyi4C95os7IwAiOrkTM4EXIiigm-nW9pFmM,3221
-pychemstation/utils/injector_types.py,sha256=xOkvlX_cH_QmuKbyXj8Lc2JEA_6g82az1zB4oTwcKN0,386
-pychemstation/utils/macro.py,sha256=OCQRRC-f46RlhenZfe7ldSgxBhzcZ5JlW3Ej-9OfeSI,2847
-pychemstation/utils/method_types.py,sha256=e7c2nWub6pT_S8ZF6sd7uXYm9ZBno0mARnzc1hnSHPY,1516
+pychemstation/utils/injector_types.py,sha256=SD452SwEHNx4Xs2p-mhg6X0pd99XewQ1Zbu-r9kPOJs,817
+pychemstation/utils/macro.py,sha256=o1dypIKhEMbDea34VFh4gKu-kWIjXZAFyqK4FYjCKjo,2836
+pychemstation/utils/method_types.py,sha256=3qxKeREl_97GnQ74qcA3kxibnvWI4ueb-6XZlxcV2Hg,1632
 pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
 pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
 pychemstation/utils/sequence_types.py,sha256=4cNpmRdPLN5oGN7ozHgT21E65aBO8vV3ZcRXMOQ3EA8,1084
-pychemstation/utils/table_types.py,sha256=mlbxPAiPvO_EBba5OSzuJcpCL0srrC7uUfm_lKsOsmA,2557
+pychemstation/utils/table_types.py,sha256=0kg7gZXFk7O5l0K1BEBaF4OFFdja3-hFUG9UbN5PBcs,3173
 pychemstation/utils/tray_types.py,sha256=MaHN36rhcEI5mAY95VU8hfP9HhAlngQvMYq-2oyC0hc,764
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=4FPJjW97yn6QiHNQVSlqjjJUE-Bh9SmyjIvgAeaGQBU,2450
-tests/test_comb.py,sha256=EDE1Ve0A_EK4qro9imZsrD0xXrQN8hAowiOWPFtw3dM,5515
-tests/test_comm.py,sha256=EYOpVXzEMQLGhhKYDPO-KaLcJdPSMPTD9Y4jSI0yVQY,2516
-tests/test_inj.py,sha256=yaPGZoHiOC3ZSgsmrtiqp8QtSo2bMxB9FJhaFlOpad0,1412
-tests/test_method.py,sha256=Up2EEysYwldPT9GJw27Mycs6qi_Y2W3opjhc7wnLU9U,3215
-tests/test_sequence.py,sha256=Nz2iqp1cJgw6kcQvnwSkfBmhxpOH62PoEu6o_5rO-PY,4929
-pychemstation-0.5.14.dev1.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.14.dev1.dist-info/METADATA,sha256=-kS4rtI8LDxt1GKutFyCSSMi2fx65plU2b7EgUb6m1c,4376
-pychemstation-0.5.14.dev1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.14.dev1.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.14.dev1.dist-info/RECORD,,
+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=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.6.0.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.6.0.dist-info/METADATA,sha256=mO3-TN1CbOOEDxaUfAdwfZvRE65V3IvlXecYdb0uQBE,4370
+pychemstation-0.6.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.6.0.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.6.0.dist-info/RECORD,,

tests/constants.py

@@ -4,7 +4,7 @@ from pychemstation.utils.method_types import *
 from pychemstation.utils.sequence_types import *
 
 DEFAULT_METHOD = "GENERAL-POROSHELL-OPT"
-DEFAULT_SEQUENCE = "LLETest"
+DEFAULT_SEQUENCE = "hplc_testing"
 
 # CONSTANTS: paths only work in Hein group HPLC machine in room 242
 DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"

tests/test_comb.py

@@ -10,7 +10,7 @@ run_too = True
 
 class TestCombinations(unittest.TestCase):
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(

tests/test_comm.py

@@ -10,7 +10,7 @@ from tests.constants import *
 class TestComm(unittest.TestCase):
 
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(

tests/test_inj.py

@@ -17,22 +17,17 @@ 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:
-            gp_mtd = self.hplc_controller.method_controller.load_from_disk(DEFAULT_METHOD)
-            self.assertTrue(gp_mtd.first_row.organic_modifier == 5)
+            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.method_controller.switch(DEFAULT_METHOD)
-        new_method = gen_rand_method()
-        try:
-            self.hplc_controller.edit_method(new_method)
-        except Exception as e:
-            self.fail(f"Should have not failed: {e}")
+
+
 
 if __name__ == '__main__':
     unittest.main()

tests/test_method.py

@@ -28,7 +28,25 @@ class TestMethod(unittest.TestCase):
 
     def test_edit_method(self):
         self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-        new_method = gen_rand_method()
+        new_method = MethodDetails(name=DEFAULT_METHOD,
+                                   timetable=[TimeTableEntry(start_time=1,
+                                                             organic_modifer=20,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2,
+                                                             organic_modifer=30,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2.5,
+                                                             organic_modifer=60,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3,
+                                                             organic_modifer=80,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3.5,
+                                                             organic_modifer=100,
+                                                             flow=0.65)],
+                                   stop_time=4,
+                                   post_time=1,
+                                   params=HPLCMethodParams(organic_modifier=5, flow=0.65))
         try:
             self.hplc_controller.edit_method(new_method)
         except Exception as e:

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()

tests/test_sequence.py

@@ -2,13 +2,12 @@ import os
 import unittest
 
 from pychemstation.control import HPLCController
-from pychemstation.utils.sequence_types import *
 from tests.constants import *
 
 
 class TestSequence(unittest.TestCase):
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(