pychemstation 0.5.1__py3-none-any.whl → 0.5.3.dev1__py3-none-any.whl

tests/constants.py

@@ -1,12 +1,65 @@
+import random
+
+from pychemstation.utils.method_types import *
+from pychemstation.utils.sequence_types import *
+
+DEFAULT_METHOD = "GENERAL-POROSHELL-OPT"
+DEFAULT_SEQUENCE = "hplc_testing"
 
 # CONSTANTS: paths only work in Hein group HPLC machine in room 242
 DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
-DEFAULT_METHOD = "GENERAL-POROSHELL-OPT"
-DEFAULT_TESTING_METHOD = "GENERAL-POROSHELL-MIN"
 DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
 DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
 SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\3\\Sequence"
-DEFAULT_SEQUENCE = "hplc_testing"
-METHOD_EXAMPLE = "/Users/lucyhao/Codes/heinanalyticalcontrol/tests/methods/General-Poroshell.M"
 
-HEIN_LAB_CONSTANTS = [DEFAULT_COMMAND_PATH, DEFAULT_METHOD_DIR, DATA_DIR, SEQUENCE_DIR]
+HEIN_LAB_CONSTANTS = [DEFAULT_COMMAND_PATH,
+                      DEFAULT_METHOD_DIR,
+                      DATA_DIR,
+                      SEQUENCE_DIR]
+
+# these CONSTANTS work in rm 254
+DEFAULT_COMMAND_PATH_254 = "D:\\\git_repositories\\\hplc_comm\\"
+DEFAULT_METHOD_DIR_254 = "D:\\Chemstation\\1\\Methods\\"
+DATA_DIR_254 = "D:\\Chemstation\\1\\Data"
+SEQUENCE_DIR_254 = "C:\\1\\Sequence"
+
+HEIN_LAB_CONSTANTS_254 = [DEFAULT_COMMAND_PATH_254,
+                          DEFAULT_METHOD_DIR_254,
+                          DATA_DIR_254,
+                          SEQUENCE_DIR_254]
+
+
+def room(num: int):
+    if num == 242:
+        return HEIN_LAB_CONSTANTS
+    elif num == 254:
+        return HEIN_LAB_CONSTANTS_254
+
+
+def gen_rand_method():
+    org_modifier = int(random.random() * 10)
+    max_run_time = int(random.random() * 10)
+    return MethodTimetable(
+        first_row=HPLCMethodParams(
+            organic_modifier=org_modifier,
+            flow=random.random(),
+            maximum_run_time=max_run_time),
+        subsequent_rows=[
+            TimeTableEntry(
+                start_time=0.10,
+                organic_modifer=org_modifier,
+                flow=0.34),
+            TimeTableEntry(
+                start_time=1,
+                organic_modifer=100 - int(random.random() * 10),
+                flow=0.55)])
+
+
+seq_entry = SequenceEntry(
+    vial_location=TenColumn.ONE,
+    method=DEFAULT_METHOD,
+    num_inj=int(random.random() * 10),
+    inj_vol=int(random.random() * 10),
+    sample_name="Test",
+    sample_type=SampleType(int(random.random() * 3)),
+)

tests/test_comb.py

@@ -0,0 +1,129 @@
+import os
+
+import unittest
+
+from pychemstation.control import HPLCController
+from tests.constants import *
+
+run_too = False
+
+
+
+
+class TestCombinations(unittest.TestCase):
+    def setUp(self):
+        path_constants = room(254)
+        for path in path_constants:
+            if 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],
+                                              method_dir=path_constants[1],
+                                              data_dir=path_constants[2],
+                                              sequence_dir=path_constants[3])
+
+    def test_run_method_after_update(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+
+        try:
+            rand_method = gen_rand_method()
+            self.hplc_controller.edit_method(rand_method)
+            if run_too:
+                self.hplc_controller.run_method(experiment_name="changed_method")
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_run_after_table_edit(self):
+        try:
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            seq_table = self.hplc_controller.load_sequence()
+            seq_table.rows[0].vial_location = TenColumn.FIVE
+            seq_table.rows[1].vial_location = TenColumn.ONE
+            seq_table.rows[0].inj_source = InjectionSource.HIP_ALS
+            seq_table.rows[1].inj_source = InjectionSource.MANUAL
+            self.hplc_controller.edit_sequence(seq_table)
+            if run_too:
+                self.hplc_controller.run_sequence(seq_table)
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                self.assertTrue(len(chrom) == 2)
+        except Exception as e:
+            self.fail("Failed")
+
+    def test_run_after_existing_row_edit(self):
+        try:
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            seq_table = self.hplc_controller.load_sequence()
+            self.hplc_controller.edit_sequence_row(seq_entry, 1)
+            if run_too:
+                self.hplc_controller.run_sequence(seq_table)
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                self.assertTrue(len(chrom) == 2)
+        except Exception:
+            self.fail("Failed")
+
+    def test_update_method_update_seq_table_run(self):
+        try:
+            self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+            rand_method = gen_rand_method()
+            self.hplc_controller.edit_method(rand_method, save=True)
+
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            seq_table = self.hplc_controller.load_sequence()
+            seq_table.rows[0].vial_location = TenColumn.ONE
+            seq_table.rows[0].inj_source = InjectionSource.HIP_ALS
+            seq_table.rows[1].vial_location = TenColumn.TWO
+            seq_table.rows[1].inj_source = InjectionSource.HIP_ALS
+            self.hplc_controller.edit_sequence(seq_table)
+
+            if run_too:
+                self.hplc_controller.run_sequence(seq_table)
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                self.assertTrue(len(chrom) == 2)
+        except Exception:
+            self.fail("Failed")
+
+    def test_update_table_then_row(self):
+        try:
+            self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            rand_method = gen_rand_method()
+            self.hplc_controller.edit_method(rand_method, save=True)
+
+            seq_table = self.hplc_controller.load_sequence()
+            seq_table.rows[0].vial_location = TenColumn.ONE
+            seq_table.rows[0].inj_source = InjectionSource.HIP_ALS
+            seq_table.rows[0].method = DEFAULT_METHOD
+            seq_table.rows[1].vial_location = TenColumn.TWO
+            seq_table.rows[1].inj_source = InjectionSource.HIP_ALS
+            seq_table.rows[1].method = DEFAULT_METHOD
+
+            self.hplc_controller.edit_sequence(seq_table)
+            self.hplc_controller.edit_sequence_row(
+                SequenceEntry(
+                    vial_location=TenColumn.ONE,
+                    method=DEFAULT_METHOD,
+                    num_inj=3,
+                    inj_vol=4,
+                    sample_name="Blank",
+                    sample_type=SampleType.BLANK,
+                )
+            )
+            if run_too:
+                self.hplc_controller.run_sequence(seq_table)
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                self.assertTrue(len(chrom) == 2)
+        except Exception:
+            self.fail("Failed")
+
+    def test_run_after_new_row_edit(self):
+        try:
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            seq_table = self.hplc_controller.load_sequence()
+            self.hplc_controller.edit_sequence_row(seq_entry, 3)
+            if run_too:
+                self.hplc_controller.run_sequence(seq_table)
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                self.assertTrue(len(chrom) == 2)
+        except Exception:
+            self.fail("Failed")

tests/test_comm.py

@@ -10,24 +10,25 @@ from tests.constants import *
 class TestComm(unittest.TestCase):
 
     def setUp(self):
-        for path in HEIN_LAB_CONSTANTS:
+        path_constants = room(254)
+        for path in path_constants:
             if 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(data_dir=DATA_DIR,
-                                              comm_dir=DEFAULT_COMMAND_PATH,
-                                              method_dir=DEFAULT_METHOD_DIR,
-                                              sequence_dir=SEQUENCE_DIR)
+        self.hplc_controller = HPLCController(comm_dir=path_constants[0],
+                                              method_dir=path_constants[1],
+                                              data_dir=path_constants[2],
+                                              sequence_dir=path_constants[3])
 
     def test_status_check_standby(self):
         self.hplc_controller.standby()
-        self.assertTrue(self.hplc_controller.status()[0] in [HPLCAvailStatus.STANDBY, HPLCRunningStatus.NOTREADY])
+        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()[0] in [HPLCAvailStatus.PRERUN, HPLCAvailStatus.STANDBY,
-                                                             HPLCRunningStatus.NOTREADY])
+        self.assertTrue(self.hplc_controller.status() in [HPLCAvailStatus.PRERUN, HPLCAvailStatus.STANDBY,
+                                                          HPLCRunningStatus.NOTREADY])
 
     def test_send_command(self):
         try:
@@ -39,6 +40,17 @@ class TestComm(unittest.TestCase):
         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 num_response")
+        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}")
 
@@ -47,7 +59,7 @@ class TestComm(unittest.TestCase):
             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)
+            self.assertTrue(DEFAULT_METHOD in res.string_response)
         except Exception as e:
             self.fail(f"Should not throw error: {e}")
 

tests/test_method.py

@@ -2,51 +2,50 @@ import os
 import unittest
 
 from pychemstation.control import HPLCController
-from pychemstation.utils.method_types import *
 from tests.constants import *
 
 
 class TestMethod(unittest.TestCase):
     def setUp(self):
-        for path in HEIN_LAB_CONSTANTS:
+        path_constants = room(254)
+        for path in path_constants:
             if 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(data_dir=DATA_DIR,
-                                              comm_dir=DEFAULT_COMMAND_PATH,
-                                              method_dir=DEFAULT_METHOD_DIR,
-                                              sequence_dir=SEQUENCE_DIR)
+        self.hplc_controller = HPLCController(comm_dir=path_constants[0],
+                                              method_dir=path_constants[1],
+                                              data_dir=path_constants[2],
+                                              sequence_dir=path_constants[3])
 
-
-
-    def test_load_method_details(self):
+    def test_load_method_from_disk(self):
         self.hplc_controller.switch_method(DEFAULT_METHOD)
         try:
-            gp_mtd = self.hplc_controller.method_controller.load(DEFAULT_METHOD)
-            self.assertTrue(gp_mtd.first_row.organic_modifier.val == 5)
+            gp_mtd = self.hplc_controller.method_controller.load_from_disk(DEFAULT_METHOD)
+            self.assertTrue(gp_mtd.first_row.organic_modifier == 5)
         except Exception as e:
             self.fail(f"Should have not failed, {e}")
 
-    def test_method_update_timetable(self):
+    def test_edit_method(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}")
+
+    def test_load_method(self):
         self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-        new_method = MethodTimetable(
-            first_row=HPLCMethodParams(
-                organic_modifier=7,
-                flow=0.44,
-                maximum_run_time=2,
-                temperature=15),
-            subsequent_rows=[
-                TimeTableEntry(
-                    start_time=0.10,
-                    organic_modifer=7,
-                    flow=0.34),
-                TimeTableEntry(
-                    start_time=1,
-                    organic_modifer=99,
-                    flow=0.55)])
+        new_method = gen_rand_method()
         try:
             self.hplc_controller.edit_method(new_method)
+            loaded_method = self.hplc_controller.load_method()
+            self.assertEqual(new_method.first_row.organic_modifier,
+                             loaded_method.first_row.organic_modifier)
+            self.assertEqual(new_method.subsequent_rows,
+                             loaded_method.subsequent_rows)
+            self.assertEqual(new_method.first_row.flow,
+                             loaded_method.first_row.flow)
         except Exception as e:
             self.fail(f"Should have not failed: {e}")
 
@@ -58,7 +57,5 @@ class TestMethod(unittest.TestCase):
             self.fail(f"Should have not failed: {e}")
 
 
-
-
 if __name__ == '__main__':
     unittest.main()

tests/test_sequence.py

@@ -8,15 +8,16 @@ from tests.constants import *
 
 class TestSequence(unittest.TestCase):
     def setUp(self):
-        for path in HEIN_LAB_CONSTANTS:
+        path_constants = room(254)
+        for path in path_constants:
             if 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(data_dir=DATA_DIR,
-                                              comm_dir=DEFAULT_COMMAND_PATH,
-                                              method_dir=DEFAULT_METHOD_DIR,
-                                              sequence_dir=SEQUENCE_DIR)
+        self.hplc_controller = HPLCController(comm_dir=path_constants[0],
+                                              method_dir=path_constants[1],
+                                              data_dir=path_constants[2],
+                                              sequence_dir=path_constants[3])
 
     def test_switch(self):
         try:
@@ -26,77 +27,52 @@ class TestSequence(unittest.TestCase):
 
     def test_edit_row(self):
         self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
-        self.hplc_controller.edit_sequence_row(SequenceEntry(
-                    vial_location=10,
-                    method="C:\\ChemStation\\1\\Methods\\General-Poroshell",
-                    num_inj=3,
-                    inj_vol=4,
-                    sample_name="Blank",
-                    sample_type=SampleType.BLANK,
-                    inj_source=InjectionSource.HIP_ALS
-                ), 1)
+        try:
+            self.hplc_controller.edit_sequence_row(SequenceEntry(
+                vial_location=TenColumn.TEN,
+                method=DEFAULT_METHOD,
+                num_inj=3,
+                inj_vol=4,
+                sample_name="Blank",
+                sample_type=SampleType.BLANK,
+                inj_source=InjectionSource.HIP_ALS
+            ), 1)
+        except Exception:
+            self.fail("Should have not failed")
 
     def test_edit_entire_table(self):
         self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
-        seq_table = SequenceTable(
-            name=DEFAULT_SEQUENCE,
-            rows=[
-                SequenceEntry(
-                    vial_location=3,
-                    method="C:\\ChemStation\\1\\Methods\\General-Poroshell",
-                    num_inj=3,
-                    inj_vol=4,
-                    sample_name="Control",
-                    sample_type=SampleType.CONTROL,
-                    inj_source=InjectionSource.MANUAL
-                ),
-                SequenceEntry(
-                    vial_location=1,
-                    method="C:\\ChemStation\\1\\Methods\\General-Poroshell",
-                    num_inj=1,
-                    inj_vol=1,
-                    sample_name="Sample",
-                    sample_type=SampleType.SAMPLE,
-                    inj_source=InjectionSource.AS_METHOD
-                ),
-                SequenceEntry(
-                    vial_location=10,
-                    method="C:\\ChemStation\\1\\Methods\\General-Poroshell",
-                    num_inj=3,
-                    inj_vol=4,
-                    sample_name="Blank",
-                    sample_type=SampleType.BLANK,
-                    inj_source=InjectionSource.HIP_ALS
-                ),
-            ]
-        )
-        self.hplc_controller.edit_sequence(seq_table)
-
+        try:
+            seq_table = SequenceTable(
+                name=DEFAULT_SEQUENCE,
+                rows=[
+                    SequenceEntry(
+                        vial_location=TenColumn.ONE,
+                        method=DEFAULT_METHOD,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel1",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=TenColumn.TWO,
+                        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_run(self):
-        # self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
-        seq_table = SequenceTable(
-            name=DEFAULT_SEQUENCE,
-            rows=[
-                SequenceEntry(
-                    vial_location=1,
-                    method="C:\\ChemStation\\1\\Methods\\" + DEFAULT_METHOD,
-                    num_inj=1,
-                    inj_vol=1,
-                    sample_name="Test",
-                    sample_type=SampleType.BLANK
-                ),
-                SequenceEntry(
-                    vial_location=2,
-                    method="C:\\ChemStation\\1\\Methods\\" + DEFAULT_METHOD,
-                    num_inj=1,
-                    inj_vol=1,
-                    sample_name="Test2",
-                    sample_type=SampleType.BLANK
-                ),
-            ]
-        )
-        self.hplc_controller.edit_sequence(seq_table)
-        self.hplc_controller.run_sequence(seq_table)
-        chrom = self.hplc_controller.get_last_run_sequence_data()
-        self.assertTrue(len(chrom) == 2)
+    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}")

pychemstation/control/chromatogram.py

@@ -1,128 +0,0 @@
-"""Module for HPLC chromatogram data loading and manipulating"""
-
-import os
-import logging
-import time
-
-import numpy as np
-
-from ..analysis import AbstractSpectrum
-from ..utils.chemstation import CHFile
-
-# Chemstation data path
-DATA_DIR = r"C:\Chem32\1\Data"
-
-
-# standard filenames for spectral data
-CHANNELS = {"A": "01", "B": "02", "C": "03", "D": "04"}
-
-ACQUISITION_PARAMETERS = "acq.txt"
-
-# format used in acquisition parameters
-TIME_FORMAT = "%Y-%m-%d-%H-%M-%S"
-
-
-class AgilentHPLCChromatogram(AbstractSpectrum):
-    """Class for HPLC spectrum (chromatogram) loading and handling."""
-
-    AXIS_MAPPING = {"x": "min", "y": "mAu"}
-
-    INTERNAL_PROPERTIES = {
-        "baseline",
-        "parameters",
-        "data_path",
-    }
-
-    # set of properties to be saved
-    PUBLIC_PROPERTIES = {
-        "x",
-        "y",
-        "peaks",
-        "timestamp",
-    }
-
-    def __init__(self, path=None, autosaving=False):
-
-        if path is not None:
-            os.makedirs(path, exist_ok=True)
-            self.path = path
-        else:
-            self.path = os.path.join(".", "hplc_data")
-            os.makedirs(self.path, exist_ok=True)
-
-        self.logger = logging.getLogger("AgilentHPLCChromatogram")
-
-        super().__init__(path=path, autosaving=autosaving)
-
-    def load_spectrum(self, data_path, channel="A"):
-        """Loads the spectra from the given folder.
-
-        Args:
-            data_path (str): Path where HPLC data has been saved.
-        """
-
-        # to avoid dropping parameters when called in parent class
-        if self.x is not None:
-            if self.autosaving:
-                self.save_data(filename=f"{data_path}_{channel}")
-                self._dump()
-
-        # get raw data
-        x, y = self.extract_rawdata(data_path, channel)
-
-        # get timestamp
-        tstr = data_path.split(".")[0].split("_")[-1]
-        timestamp = time.mktime(time.strptime(tstr, TIME_FORMAT))
-
-        # loading all data
-        super().load_spectrum(x, y, timestamp)
-
-    ### PUBLIC METHODS TO LOAD RAW DATA ###
-
-    def extract_rawdata(self, experiment_dir: str, channel: str):
-        """
-        Reads raw data from Chemstation .CH files.
-
-        Args:
-            experiment_dir: .D directory with the .CH files
-
-        Returns:
-            np.array(times), np.array(values)   Raw chromatogram data
-        """
-        filename = os.path.join(experiment_dir, f"DAD1{channel}")
-        npz_file = filename + ".npz"
-
-        if os.path.exists(npz_file):
-            # already processed
-            data = np.load(npz_file)
-            return data["times"], data["values"]
-        else:
-            self.logger.debug("NPZ file not found. First time loading data.")
-            ch_file = filename + ".ch"
-            data = CHFile(ch_file)
-            np.savez_compressed(npz_file, times=data.times, values=data.values)
-            return np.array(data.times), np.array(data.values)
-
-    def extract_peakarea(self, experiment_dir: str):
-        """
-        Reads processed data from Chemstation report files.
-
-        Args:
-            experiment_dir: .D directory with the report files
-        """
-        # filename = os.path.join(experiment_dir, f"REPORT{CHANNELS[channel]}.csv")
-        # TODO parse file properly
-        # data = np.genfromtxt(filename, delimiter=',')
-        # return data
-        pass
-
-    def default_processing(self):
-        """
-        Processes the chromatogram in place.
-        """
-        # trim first 5 min and last 3 min of run
-        self.trim(5, 25)
-        # parameters found to work best for chromatogram data
-        self.correct_baseline(lmbd=1e5, p=0.0001, n_iter=10)
-        # get all peaks in processed chromatogram
-        self.find_peaks()