pychemstation 0.6.2__py3-none-any.whl → 0.6.5__py3-none-any.whl

pychemstation/analysis/process_report.py

@@ -1,18 +1,15 @@
-"""
-pip install pandas
-pip install aghplctools==4.8.6
-"""
-
 import os
 import re
 from dataclasses import dataclass
-from typing import List, AnyStr
+from typing import List, AnyStr, Dict
 
 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 pychemstation.utils.tray_types import Tray, FiftyFourVialPlate
+
 
 @dataclass
 class AgilentPeak:
@@ -25,6 +22,13 @@ class AgilentPeak:
     height_percent: float
 
 
+@dataclass
+class AgilentReport:
+    vial_location: Tray
+    signals: Dict[AnyStr, List[AgilentPeak]]
+    solvents: Dict[AnyStr, AnyStr]
+
+
 _column_re_dictionary = {  # regex matches for column and unit combinations
     'Peak': {  # peak index
         '#': '[ ]+(?P<Peak>[\d]+)',  # number
@@ -51,7 +55,7 @@ _column_re_dictionary = {  # regex matches for column and unit combinations
 }
 
 
-def build_peak_regex(signal_table: str):
+def build_peak_regex(signal_table: str) -> re.Pattern[AnyStr]:
     """
     Builds a peak regex from a signal table
 
@@ -211,9 +215,40 @@ def process_folder(folder_path, target_wavelengths=None, min_retention_time=0, m
     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))
+def process_csv_report(folder_path: str) -> Result[AgilentReport, AnyStr]:
+    labels = os.path.join(folder_path, f'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():
+            if val == "Location":
+                vial_location = df_labels[1][pos]
+            elif "Solvent" in val:
+                if val not in solvents.keys():
+                    solvents[val] = df_labels[2][pos]
+            elif val == "Number of Signals":
+                num_signals = int(df_labels[1][pos])
+                for s in range(1, num_signals + 1):
+                    peaks = process_peaks(os.path.join(folder_path, f'REPORT0{s}.CSV'))
+                    if peaks.is_ok():
+                        wavelength = df_labels[1][pos + s].partition(",4 Ref=off")[0][-3:]
+                        signals[wavelength] = peaks.ok_value
+                break
+
+        return Ok(AgilentReport(
+            signals=signals,
+            vial_location=FiftyFourVialPlate.from_int(vial_location),
+            solvents=solvents
+        ))
+
     return Err("No report found")
+
+
+def process_peaks(folder_path: str) -> Result[List[AgilentPeak], AnyStr]:
+    try:
+        df = pd.read_csv(folder_path, encoding="utf-16", header=None)
+        return Ok(df.apply(lambda row: AgilentPeak(*row), axis=1))
+    except Exception:
+        return Err("Trouble reading report")

pychemstation/control/controllers/tables/method.py

@@ -132,7 +132,7 @@ class MethodController(TableController):
         :raise IndexError: Response did not have expected format. Try again.
         :raise AssertionError: The desired method is not selected. Try again.
         """
-        self.send(Command.SWITCH_METHOD_CMD.value.format(method_dir=self.src,
+        self.send(Command.SWITCH_METHOD_CMD_SPECIFIC.value.format(method_dir=self.src,
                                                          method_name=method_name))
 
         time.sleep(2)

pychemstation/control/controllers/tables/sequence.py

@@ -41,8 +41,9 @@ class SequenceController(TableController):
         inj_vol = int(self.get_text(row, RegisterFlag.INJ_VOL))
         inj_source = InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
         sample_type = SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
+        vial_enum = TenVialColumn(vial_location) if vial_location <= 10 else FiftyFourVialPlate.from_int(num=vial_location)
         return SequenceEntry(sample_name=sample_name,
-                             vial_location=vial_location,
+                             vial_location=vial_enum,
                              method=None if len(method) == 0 else method,
                              num_inj=num_inj,
                              inj_vol=inj_vol,

pychemstation/control/controllers/tables/table.py

@@ -8,7 +8,7 @@ import abc
 import os
 import warnings
 from dataclasses import dataclass
-from typing import Union, Optional
+from typing import Union, Optional, AnyStr
 
 import numpy as np
 import polling
@@ -48,13 +48,13 @@ class TableController(abc.ABC):
 
             if src and os.path.isdir(src):
                 self.src: str = src
-            else:
-                warnings.warn(f"dir: {src} not found.")
+            elif isinstance(src, str):
+                raise FileNotFoundError(f"dir: {src} not found.")
 
             if data_dir and os.path.isdir(data_dir):
                 self.data_dir: str = data_dir
-            else:
-                warnings.warn(f"dir: {data_dir} not found.")
+            elif isinstance(data_dir, str):
+                raise FileNotFoundError(f"dir: {data_dir} not found.")
 
             if hasattr(self, "data_dir"):
                 self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {

pychemstation/control/hplc.py

@@ -43,6 +43,7 @@ class HPLCController:
                  data_dir: str,
                  method_dir: str,
                  sequence_dir: str,
+                 secondary_data_dir: Optional[str] = None,
                  offline: bool = False):
         """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
         `comm_dir` must match the file path in the macro file.
@@ -61,7 +62,7 @@ class HPLCController:
                                                                                          offline=offline))
         self.sequence_controller = SequenceController(controller=self.comm,
                                                       src=sequence_dir,
-                                                      data_dir=data_dir,
+                                                      data_dir=data_dir if not secondary_data_dir else secondary_data_dir,
                                                       table=self.SEQUENCE_TABLE,
                                                       method_dir=method_dir,
                                                       offline=offline)

pychemstation/utils/macro.py

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

pychemstation/utils/method_types.py

@@ -23,7 +23,7 @@ class Param:
 
 @dataclass
 class HPLCMethodParams:
-    organic_modifier: int
+    organic_modifier: float
     flow: float
     pressure: Optional[float] = None  # TODO: find this
 
@@ -51,6 +51,6 @@ class MethodDetails:
     params: HPLCMethodParams
     timetable: list[TimeTableEntry]
     injector_program: Optional[InjectorTable] = None
-    stop_time: Optional[int] = None
-    post_time: Optional[int] = None
+    stop_time: Optional[float] = None
+    post_time: Optional[float] = None
     dad_wavelengthes: Optional[list[Signal]] = None

pychemstation/utils/sequence_types.py

@@ -43,7 +43,7 @@ class SequenceEntry:
     data_file: Optional[str] = None
     method: Optional[str] = None
     num_inj: Optional[int] = 1
-    inj_vol: Optional[int] = 2
+    inj_vol: Optional[float] = 2
     inj_source: Optional[InjectionSource] = InjectionSource.HIP_ALS
     sample_type: Optional[SampleType] = SampleType.SAMPLE
 

pychemstation/utils/tray_types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 from dataclasses import dataclass
 from enum import Enum
 from typing import Union
@@ -16,18 +17,67 @@ class Num(Enum):
     EIGHT = 8
     NINE = 9
 
+    @classmethod
+    def from_num(cls, num: int) -> Num:
+        match num:
+            case 1:
+                return Num.ONE
+            case 2:
+                return Num.TWO
+            case 3:
+                return Num.THREE
+            case 4:
+                return Num.FOUR
+            case 5:
+                return Num.FIVE
+            case 6:
+                return Num.SIX
+            case 7:
+                return Num.SEVEN
+            case 8:
+                return Num.EIGHT
+            case 9:
+                return Num.NINE
+            case _:
+                raise ValueError("Num is one of 1 to 9")
+
 
 class Plate(Enum):
-    ONE = "1"
-    TWO = "2"
+    ONE = -96
+    TWO = 4000
+
+    @classmethod
+    def from_num(cls, plate: int) -> Plate:
+        if 1 <= plate <= 2:
+            return Plate.ONE if plate == 1 else Plate.TWO
+        raise ValueError("Plate is one or 1 or 2")
 
 
 class Letter(Enum):
-    A = 8191
-    B = 8255
-    C = 8319
-    D = 8383
-    F = 8447
+    A = 4191
+    B = 4255
+    C = 4319
+    D = 4383
+    E = 4447
+    F = 4511
+
+    @classmethod
+    def from_str(cls, let: str) -> Letter:
+        match let:
+            case "A":
+                return Letter.A
+            case "B":
+                return Letter.B
+            case "C":
+                return Letter.C
+            case "D":
+                return Letter.D
+            case "E":
+                return Letter.E
+            case "F":
+                return Letter.F
+            case _:
+                raise ValueError("Letter is one of A to F")
 
 
 @dataclass
@@ -37,7 +87,64 @@ class FiftyFourVialPlate:
     num: Num
 
     def value(self) -> int:
-        return self.letter.value + self.num.value
+        return self.plate.value + self.letter.value + self.num.value
+
+    @classmethod
+    def from_str(cls, loc: str):
+        if len(loc) != 5:
+            raise ValueError("Plate locations must be PX-LY, where X is either 1 or 2 and Y is 1 to 9")
+        try:
+            plate = int(loc[1])
+            letter = loc[3]
+            num = int(loc[4])
+            return FiftyFourVialPlate(plate=Plate.from_num(plate),
+                                      letter=Letter.from_str(letter),
+                                      num=Num.from_num(num))
+        except Exception as e:
+            raise ValueError("Plate locations must be PX-LY, where X is either 1 or 2 and Y is 1 to 9")
+
+    @classmethod
+    def from_int(cls, num: int) -> FiftyFourVialPlate:
+        row_starts = [
+            # plate 1
+            FiftyFourVialPlate.from_str('P1-F1'),
+            FiftyFourVialPlate.from_str('P1-E1'),
+            FiftyFourVialPlate.from_str('P1-D1'),
+            FiftyFourVialPlate.from_str('P1-C1'),
+            FiftyFourVialPlate.from_str('P1-B1'),
+            FiftyFourVialPlate.from_str('P1-A1'),
+            # plate 2
+            FiftyFourVialPlate.from_str('P2-F1'),
+            FiftyFourVialPlate.from_str('P2-E1'),
+            FiftyFourVialPlate.from_str('P2-D1'),
+            FiftyFourVialPlate.from_str('P2-C1'),
+            FiftyFourVialPlate.from_str('P2-B1'),
+            FiftyFourVialPlate.from_str('P2-A1'),
+        ]
+
+        # find which row
+        possible_row = None
+        for i in range(0, 6):
+            p1_val = row_starts[i].value()
+            p2_val = row_starts[6 + i].value()
+            if num >= p2_val:
+                possible_row = row_starts[6 + i]
+            elif p1_val <= num < row_starts[-1].value():
+                possible_row = row_starts[i]
+            if possible_row:
+                break
+
+        # determine which num
+        if possible_row:
+            starting_loc = possible_row
+            base_val = starting_loc.plate.value + starting_loc.letter.value
+            for i in range(1, 10):
+                if num - i == base_val:
+                    return FiftyFourVialPlate(
+                        plate=starting_loc.plate,
+                        letter=starting_loc.letter,
+                        num=Num.from_num(i))
+        raise ValueError("Number didn't match any location. " + str(num))
 
 
 class TenVialColumn(Enum):
@@ -53,4 +160,4 @@ class TenVialColumn(Enum):
     TEN = 10
 
 
-Tray = Union[FiftyFourVialPlate, TenVialColumn]
+Tray = Union[FiftyFourVialPlate, TenVialColumn]

{pychemstation-0.6.2.dist-info → pychemstation-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.6.2
+Version: 0.6.5
 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.6.2.dist-info → pychemstation-0.6.5.dist-info}/RECORD

@@ -1,12 +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/process_report.py,sha256=3NWBK1g9fwjmdHoIlMxlXBlbyU5oXyK-_roEE7ZcPXM,10412
 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=8vKdm5sTGY_VnBRqcAS3EMRJAQ2wbLRbFswaSi2CHHc,9848
+pychemstation/control/hplc.py,sha256=zUPALdS8TbmtbOwJo4o8x6Ceyxw9nEYOwyfTOWZj510,9957
 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
@@ -19,10 +19,10 @@ pychemstation/control/controllers/devices/device.py,sha256=QUFpUwmGxMzmG1CiRhNau
 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
+pychemstation/control/controllers/tables/method.py,sha256=Bzo0BHatMOFf_TmMBVuQbtLvZRTARaW5q1e2-WKJVHY,16435
 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=GjZ15aJhsCQ9Ps9imOh3Q5NgK97kzangrJcOGa8bjKA,12610
+pychemstation/control/controllers/tables/sequence.py,sha256=RvJEtOskHDAkQOmfZBxvCg2cPoy83zN4LudYmRfp5wg,8935
+pychemstation/control/controllers/tables/table.py,sha256=EqlCrx0wN48_JyzlW7YekgaBePoaD9liC0vomaJsswI,12685
 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
@@ -33,23 +33,26 @@ pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/chromatogram.py,sha256=-q3_hL9GTyi4C95os7IwAiOrkTM4EXIiigm-nW9pFmM,3221
 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/macro.py,sha256=PZ916baFfqCkPaSqpdjm2N5mhfg4V4H8KQl7N5l3rUw,2916
+pychemstation/utils/method_types.py,sha256=5FK7RThLhaQcLrzRi_qLnlPqZuGPtwwipP6eMoq0kpE,1638
 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/sequence_types.py,sha256=x2EClcq6ROdzeLZg63XcXXTknwl2aZ48Vuyru0xZjgA,1086
 pychemstation/utils/table_types.py,sha256=0kg7gZXFk7O5l0K1BEBaF4OFFdja3-hFUG9UbN5PBcs,3173
-pychemstation/utils/tray_types.py,sha256=MaHN36rhcEI5mAY95VU8hfP9HhAlngQvMYq-2oyC0hc,764
+pychemstation/utils/tray_types.py,sha256=3W0IE20SEqnRRa6pZ4Jv94Cn4-3-LGoP-hxUz5LCztc,4403
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=55DOLpylLt12mb_gSgzEo-EYynwTmI2uH7PcrTM6Iq0,2455
+tests/constants.py,sha256=7CpYly3S549ALNNezO_KVqEPzl6fIdmTuTfJVFwzZq8,3278
 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_inj.py,sha256=UakPA1Sd1GAbFvFepEredWcWPoW7PMLKotfqVZ1i4hE,1434
 tests/test_method.py,sha256=KB7yAtVb4gZftnYzh-VfPb9LGVZOHUIW6OljEYRtbhA,4570
-tests/test_proc_rep.py,sha256=WhUiFqDD1Aey_Nc6Hvbd2zo48K4MWjwDhfO9LiwEQ7M,703
+tests/test_nightly.py,sha256=WpLZfs-n9oPrwz-64gWJB5oxJGYz_ab4sLZ4E-xFBpY,2654
+tests/test_proc_rep.py,sha256=sxRiTBybVm6lyAqmgrri-T2EfZgs27oSgbYXSsN9CwU,1380
+tests/test_runs_stable.py,sha256=-u9lFUwn26ZsNJtV3yMR8irjdrVezMCjWwImbq6m0H0,3487
 tests/test_sequence.py,sha256=vs5-dqkItRds_tPM2-N6MNJ37FB0nLRFaDzBV8d42i8,4880
-pychemstation-0.6.2.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.6.2.dist-info/METADATA,sha256=aZ5H2wFid5vlvSpa7eGizZT4QHiKvm6rN0YL3WdvydY,4370
-pychemstation-0.6.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.6.2.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.6.2.dist-info/RECORD,,
+tests/test_stable.py,sha256=9JNSW5bl13KEJKTNRWR9nCwrGSCYbVClx1yKXAL50xA,11565
+pychemstation-0.6.5.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.6.5.dist-info/METADATA,sha256=UUe-F8F2oeDvQdXMSwgLOZcmZa_aLJdhtqpVAW9hVAU,4370
+pychemstation-0.6.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.6.5.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.6.5.dist-info/RECORD,,

tests/constants.py

@@ -1,5 +1,8 @@
+import os
 import random
 
+from pychemstation.control import HPLCController
+from pychemstation.utils.macro import Command
 from pychemstation.utils.method_types import *
 from pychemstation.utils.sequence_types import *
 
@@ -63,3 +66,19 @@ seq_entry = SequenceEntry(
     sample_name="Test",
     sample_type=SampleType(int(random.random() * 3)),
 )
+
+
+def set_up_utils(num: int) -> HPLCController:
+    path_constants = room(num)
+    for path in path_constants:
+        if not os.path.exists(path):
+            raise FileNotFoundError(
+                f"{path} does not exist on your system. If you would like to run tests, please change this path.")
+
+    controller = HPLCController(comm_dir=path_constants[0],
+                                method_dir=path_constants[1],
+                                data_dir=path_constants[2],
+                                sequence_dir=path_constants[3])
+    controller.send(Command.SAVE_METHOD_CMD.value.format(commit_msg="method saved by pychemstation"))
+    controller.send(Command.SAVE_SEQUENCE_CMD)
+    return controller

tests/test_inj.py

@@ -2,22 +2,27 @@ import os
 import unittest
 
 from pychemstation.control import HPLCController
+from pychemstation.utils.tray_types import FiftyFourVialPlate, Letter, Plate, Num
 from tests.constants import *
 
+offline = True
+
 
 class TestInj(unittest.TestCase):
     def setUp(self):
         path_constants = room(254)
         for path in path_constants:
-            if not os.path.exists(path):
+            if not offline and not os.path.exists(path):
                 self.fail(
                     f"{path} does not exist on your system. If you would like to run tests, please change this path.")
 
-        self.hplc_controller = HPLCController(comm_dir=path_constants[0],
+        self.hplc_controller = HPLCController(offline=offline,
+                                              comm_dir=path_constants[0],
                                               method_dir=path_constants[1],
                                               data_dir=path_constants[2],
                                               sequence_dir=path_constants[3])
-        # self.hplc_controller.switch_method(DEFAULT_METHOD)
+        if not offline:
+            self.hplc_controller.switch_method(DEFAULT_METHOD)
 
     def test_load_inj(self):
         try:
@@ -26,7 +31,8 @@ class TestInj(unittest.TestCase):
         except Exception as e:
             self.fail(f"Should have not failed, {e}")
 
-
+    def test_plate_number(self):
+        self.assertEqual(4096, FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.FOUR).value())
 
 
 if __name__ == '__main__':

tests/test_nightly.py

@@ -0,0 +1,80 @@
+import unittest
+
+from pluggy import Result
+
+from pychemstation.analysis.process_report import process_csv_report
+from pychemstation.utils.tray_types import FiftyFourVialPlate, Letter, Plate, Num
+from tests.constants import *
+
+offline = True
+
+
+class TestNightly(unittest.TestCase):
+    def setUp(self):
+        path_constants = room(254)
+        for path in path_constants:
+            if not offline and not os.path.exists(path):
+                self.fail(
+                    f"{path} does not exist on your system. If you would like to run tests, please change this path.")
+
+        self.hplc_controller = HPLCController(offline=offline,
+                                              comm_dir=path_constants[0],
+                                              method_dir=path_constants[1],
+                                              data_dir=path_constants[2],
+                                              sequence_dir=path_constants[3])
+        if not offline:
+            self.hplc_controller.switch_method(DEFAULT_METHOD)
+
+    def test_load_inj(self):
+        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_plate_number(self):
+        self.assertEqual(4096, FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.FOUR).value())
+
+    def test_build_peak_regex(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_parse_area_report(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_process_export_report(self):
+        try:
+            import pandas as pd
+
+            file_path = "/Users/lucyhao/Codes/pychemstation/tests/0_2025-03-15 19-14-35.D/Report00.CSV"
+            df = pd.read_csv(file_path, encoding="utf-16")
+
+            # Print the first column
+            print(df)
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_process_folder(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_report_csv(self):
+        try:
+            report: Result = process_csv_report(folder_path="0_2025-03-15 19-14-35.D")
+            print(report)
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_proc_rep.py

@@ -7,18 +7,43 @@ from pychemstation.analysis.process_report import process_csv_report
 
 class TestReport(unittest.TestCase):
 
-    def test_process_reporttxt(self):
+    def test_build_peak_regex(self):
         try:
             # TODO
             print('yes')
         except Exception as e:
             self.fail(f"Should have not failed, {e}")
 
-    def test_report_csv(self):
+    def test_parse_area_report(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)
+            # TODO
             print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_process_export_report(self):
+        try:
+            import pandas as pd
+
+            file_path = "/Users/lucyhao/Codes/pychemstation/tests/0_2025-03-15 19-14-35.D/Report00.CSV"
+            df = pd.read_csv(file_path, encoding="utf-16")
+
+            # Print the first column
+            print(df)
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_process_folder(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_report_csv(self):
+        try:
+            report: Result = process_csv_report(folder_path="0_2025-03-15 19-14-35.D")
+            print(report)
         except Exception as e:
             self.fail(f"Should have not failed: {e}")
 

tests/test_runs_stable.py

@@ -0,0 +1,88 @@
+
+import unittest
+
+from pychemstation.utils.tray_types import FiftyFourVialPlate, Plate, Letter, Num
+from tests.constants import *
+
+run_too = True
+
+
+class TestRunsStable(unittest.TestCase):
+    def setUp(self):
+        self.hplc_controller = set_up_utils(254)
+
+    def test_run_method(self):
+        try:
+            self.hplc_controller.run_method(experiment_name="test_experiment")
+            chrom = self.hplc_controller.get_last_run_method_data()
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_run_10_times(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+        rand_method = MethodDetails(
+            name=DEFAULT_METHOD,
+            params=HPLCMethodParams(
+                organic_modifier=5,
+                flow=0.65),
+            timetable=[TimeTableEntry(
+                start_time=0.50,
+                organic_modifer=99,
+                flow=0.65)],
+            stop_time=1,
+            post_time=0)
+        self.hplc_controller.edit_method(rand_method, save=True)
+        try:
+            for _ in range(10):
+                self.hplc_controller.run_method(experiment_name="limiting_testing")
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_update_method_update_seq_table_run(self):
+        try:
+            loc = FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.F, num=Num.TWO)
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            seq_table = SequenceTable(
+                name=DEFAULT_SEQUENCE,
+                rows=[SequenceEntry(
+                    vial_location=loc,
+                    sample_name="run seq with new method",
+                    method=DEFAULT_METHOD,
+                    inj_source=InjectionSource.HIP_ALS,
+                    inj_vol=0.5,
+                    num_inj=1,
+                    sample_type=SampleType.SAMPLE
+                )])
+            self.hplc_controller.edit_sequence(seq_table) # bug didnt delete all the rows, left an extra
+
+            self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+            rand_method = MethodDetails(
+                name=DEFAULT_METHOD,
+                params=HPLCMethodParams(
+                    organic_modifier=5,
+                    flow=0.65),
+                timetable=[TimeTableEntry(
+                    start_time=random.randint(1, 3) + 0.50,
+                    organic_modifer=100,
+                    flow=0.65)],
+                stop_time=random.randint(4, 6),
+                post_time=1)
+            self.hplc_controller.edit_method(rand_method, save=True)
+            if run_too:
+                self.hplc_controller.preprun()
+                self.hplc_controller.run_sequence()
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                # report = process_csv_report(self.hplc_controller.sequence_controller.data_files[-1].child_dirs[-1])
+                # self.assertEqual(loc, report.ok_value.vial_location)
+        except Exception:
+            self.fail("Failed")
+
+    def test_run_sequence(self):
+        try:
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            self.hplc_controller.preprun()
+            self.hplc_controller.run_sequence()
+            chrom = self.hplc_controller.get_last_run_sequence_data()
+            self.assertTrue(len(chrom) == 1)
+        except Exception:
+            self.fail("Failed")

tests/test_stable.py

@@ -0,0 +1,268 @@
+import unittest
+
+from pychemstation.utils.macro import *
+from pychemstation.utils.tray_types import *
+from tests.constants import *
+
+
+class TestStable(unittest.TestCase):
+
+    def setUp(self):
+        self.hplc_controller = set_up_utils(254)
+
+    def test_status_check_standby(self):
+        self.hplc_controller.standby()
+        self.assertTrue(self.hplc_controller.status() in [HPLCAvailStatus.STANDBY, HPLCRunningStatus.NOTREADY])
+
+    def test_status_check_preprun(self):
+        self.hplc_controller.preprun()
+        self.assertTrue(self.hplc_controller.status() in [HPLCAvailStatus.PRERUN, HPLCAvailStatus.STANDBY,
+                                                          HPLCRunningStatus.NOTREADY])
+
+    def test_send_command(self):
+        try:
+            self.hplc_controller.send(Command.GET_METHOD_CMD)
+        except Exception as e:
+            self.fail(f"Should not throw error: {e}")
+
+    def test_send_str(self):
+        try:
+            self.hplc_controller.send("Local TestNum")
+            self.hplc_controller.send("TestNum = 0")
+            self.hplc_controller.send("Print TestNum")
+            self.hplc_controller.send("response_num = TestNum")
+            self.hplc_controller.send("Print response_num")
+        except Exception as e:
+            self.fail(f"Should not throw error: {e}")
+
+    def test_get_num(self):
+        try:
+            self.hplc_controller.send("response_num = 10")
+            res = self.hplc_controller.receive().num_response
+            self.assertEqual(res, 10)
+        except Exception as e:
+            self.fail(f"Should not throw error: {e}")
+
+    def test_get_response(self):
+        try:
+            self.hplc_controller.switch_method(method_name=DEFAULT_METHOD)
+            self.hplc_controller.send(Command.GET_METHOD_CMD)
+            res = self.hplc_controller.receive()
+            self.assertTrue(DEFAULT_METHOD in res.string_response)
+        except Exception as e:
+            self.fail(f"Should not throw error: {e}")
+
+    def test_load_method_from_disk(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.params.organic_modifier == 5)
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_edit_method(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+        new_method = MethodDetails(name=DEFAULT_METHOD + ".M",
+                                   timetable=[TimeTableEntry(start_time=1.0,
+                                                             organic_modifer=20.0,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2.0,
+                                                             organic_modifer=30.0,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2.5,
+                                                             organic_modifer=60.0,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3.0,
+                                                             organic_modifer=80.0,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3.5,
+                                                             organic_modifer=100.0,
+                                                             flow=0.65)],
+                                   stop_time=4.0,
+                                   post_time=1.0,
+                                   params=HPLCMethodParams(organic_modifier=5.0, flow=0.65))
+        try:
+            self.hplc_controller.edit_method(new_method)
+            self.assertEqual(new_method, self.hplc_controller.load_method())
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_load_method(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+        new_method = gen_rand_method()
+        try:
+            self.hplc_controller.edit_method(new_method)
+            loaded_method = self.hplc_controller.load_method()
+            self.assertEqual(new_method.params.organic_modifier,
+                             loaded_method.params.organic_modifier)
+            self.assertEqual(new_method.timetable[0].organic_modifer,
+                             loaded_method.timetable[0].organic_modifer)
+            self.assertEqual(round(new_method.params.flow, 2),
+                             round(loaded_method.params.flow, 2))
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_switch(self):
+        try:
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+        except Exception as e:
+            self.fail(f"Should have not expected: {e}")
+
+    def test_read(self):
+        try:
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            table = self.hplc_controller.load_sequence()
+            self.assertTrue(table)
+        except Exception as e:
+            self.fail(f"Should have not expected: {e}")
+
+    def test_edit_entire_table(self):
+        self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+        seq_folder = self.hplc_controller.sequence_controller.src
+        meth_path = os.path.join(seq_folder, DEFAULT_METHOD)
+        try:
+            seq_table = SequenceTable(
+                name=DEFAULT_SEQUENCE,
+                rows=[
+                    SequenceEntry(
+                        vial_location=TenVialColumn.ONE,
+                        method=meth_path,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel1",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.ONE),
+                        method=meth_path,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.TWO),
+                        method=meth_path,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.THREE),
+                        method=meth_path,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    )
+                ]
+            )
+            self.hplc_controller.edit_sequence(seq_table)
+            self.assertEqual(seq_table,
+                             self.hplc_controller.load_sequence())
+        except Exception:
+            self.fail("Should have not occured")
+
+    def test_edit_entire_table_less_rows(self):
+        self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+        try:
+            seq_table = SequenceTable(
+                name=DEFAULT_SEQUENCE,
+                rows=[
+                    SequenceEntry(
+                        vial_location=TenVialColumn.TEN,
+                        method=DEFAULT_METHOD,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=TenVialColumn.THREE,
+                        method=DEFAULT_METHOD,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    )
+                ]
+            )
+            self.hplc_controller.edit_sequence(seq_table)
+        except Exception:
+            self.fail("Should have not occured")
+
+    def test_load(self):
+        try:
+            seq = self.hplc_controller.load_sequence()
+            self.assertTrue(len(seq.rows) > 0)
+        except Exception as e:
+            self.fail(f"Should have not expected: {e}")
+
+    def test_tray_nums(self):
+        vial_locations = [
+            FiftyFourVialPlate.from_str('P1-A7'),
+            FiftyFourVialPlate.from_str('P1-B4'),
+            FiftyFourVialPlate.from_str('P1-C2'),
+            FiftyFourVialPlate.from_str('P1-D8'),
+            FiftyFourVialPlate.from_str('P1-E3'),
+            FiftyFourVialPlate.from_str('P1-F5'),
+            # plate 2
+            FiftyFourVialPlate.from_str('P2-A7'),
+            FiftyFourVialPlate.from_str('P2-B2'),
+            FiftyFourVialPlate.from_str('P2-C1'),
+            FiftyFourVialPlate.from_str('P2-D8'),
+            FiftyFourVialPlate.from_str('P2-E3'),
+            FiftyFourVialPlate.from_str('P2-F6'),
+        ]
+        seq_table = SequenceTable(
+            name=DEFAULT_SEQUENCE,
+            rows=[
+                SequenceEntry(
+                    vial_location=v,
+                    method=DEFAULT_METHOD,
+                    num_inj=3,
+                    inj_vol=4,
+                    sample_name="Sampel2",
+                    sample_type=SampleType.SAMPLE,
+                    inj_source=InjectionSource.HIP_ALS
+                ) for v in vial_locations
+            ]
+        )
+        self.hplc_controller.edit_sequence(seq_table)
+        loaded_table = self.hplc_controller.load_sequence()
+        for i in range(len(vial_locations)):
+            self.assertTrue(vial_locations[i].value()
+                            == seq_table.rows[i].vial_location.value()
+                            == loaded_table.rows[i].vial_location.value())
+
+    def test_tray_nums_only(self):
+        vial_locations = [
+            # plate 2
+            FiftyFourVialPlate.from_str('P2-A7'),
+            FiftyFourVialPlate.from_str('P2-B2'),
+            FiftyFourVialPlate.from_str('P2-C1'),
+            FiftyFourVialPlate.from_str('P2-D8'),
+            FiftyFourVialPlate.from_str('P2-E3'),
+            FiftyFourVialPlate.from_str('P2-F6'),
+            # plate 1
+            FiftyFourVialPlate.from_str('P1-A7'),
+            FiftyFourVialPlate.from_str('P1-B4'),
+            FiftyFourVialPlate.from_str('P1-C2'),
+            FiftyFourVialPlate.from_str('P1-D8'),
+            FiftyFourVialPlate.from_str('P1-E3'),
+            FiftyFourVialPlate.from_str('P1-F5'),
+        ]
+
+        for i in range(len(vial_locations)):
+            self.assertEqual(vial_locations[i], FiftyFourVialPlate.from_int(vial_locations[i].value()))
+
+
+if __name__ == '__main__':
+    unittest.main()