pychemstation 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

pychemstation-0.5.4.dist-info/RECORD

@@ -0,0 +1,34 @@
+pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
+pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt420YMI4,44
+pychemstation/analysis/base_spectrum.py,sha256=FBvwzLtF9mdqW7f8ETY9G4cpfJ-SzbiSkZq9EtXcSXo,17045
+pychemstation/analysis/spec_utils.py,sha256=8NZMV0dtfxZLARjWzM5ks0tgEYQv_SKUiZzba2IoKgw,10505
+pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
+pychemstation/control/__init__.py,sha256=aH9cPf-ljrVeVhN0K3cyEcAavmPXCjhhOnpLNf8qLqE,106
+pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
+pychemstation/control/hplc.py,sha256=huEUl90Ylvzvy2TXWUjhyDU4PazrK7Z51M8spquHvVg,6719
+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
+pychemstation/control/table/table_controller.py,sha256=F5lv1DlPkEDcFmtwVT-E9Kq075jnWIN-iZIM3_mTt5E,8115
+pychemstation/generated/__init__.py,sha256=GAoZFAYbPVEJDkcOw3e1rgOqd7TCW0HyKNPM8OMehMg,1005
+pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCsHRFQ0rmM,8402
+pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
+pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/utils/chromatogram.py,sha256=35nvEh6prVsWO6lMHYgGuidUOFHv954_7MNf0Az3Fz4,3759
+pychemstation/utils/macro.py,sha256=BAIcE_dppNffwrSqGq8gh0ccE9YAJfQFQZHXJgA1WtA,2586
+pychemstation/utils/method_types.py,sha256=YngbyHg96JSFnvhm5Zd7wJvLTQPPQsLbvbyz3HlGLYY,862
+pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
+pychemstation/utils/sequence_types.py,sha256=3VqiUHsfFEdynAxfR-z8JIWBCo7PdnGwTvsk7sm7Ij8,1055
+pychemstation/utils/table_types.py,sha256=cN51Ry2pammDdk85cabVH3qkchjKKIzZfAH87Poty80,2350
+pychemstation/utils/tray_types.py,sha256=UUDED-IAf-8FmPVZezuWSiIQE_HgiZQMV2sTqu4oZw8,177
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/constants.py,sha256=lLwT_QaVriivL5llkul6RxXxPriwUp1E-Y3G9fejvbo,2092
+tests/test_comb.py,sha256=faF4764oJEZ2vhG9-zLmQxjATseipRKXrStehuDCXOI,5638
+tests/test_comm.py,sha256=1ZZd0UrIBOKe91wzA-XI-gSRgXmId9mLWYSMeche82Y,2973
+tests/test_method.py,sha256=uCPpZVYKPz1CNWwhmBo_8TH0ku2V0ZpDZJj3f8iINB4,2440
+tests/test_sequence.py,sha256=yIQGhUTehtHz6D1ai5W6AlP0zes2icF0VdQ0IGJ2CbQ,4901
+pychemstation-0.5.4.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.4.dist-info/METADATA,sha256=TN5NWM9_QmES6TmIm_pXGvQxlNTQsHJDiP1wd1dRktA,3992
+pychemstation-0.5.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.4.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.4.dist-info/RECORD,,

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 = "LLETest"
 
 # 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\\2024-12\\"
+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=round(random.random(), 2),
+            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,143 @@
+import os
+
+import unittest
+
+from pychemstation.control import HPLCController
+from tests.constants import *
+
+run_too = True
+
+
+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):
+        try:
+            self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+            rand_method = MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=5,
+                    flow=0.65,
+                    maximum_run_time=2),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=0.10,
+                        organic_modifer=5,
+                        flow=0.34),
+                    TimeTableEntry(
+                        start_time=1,
+                        organic_modifer=98,
+                        flow=0.55)])
+            self.hplc_controller.edit_method(rand_method, save=True)
+            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.append(SequenceEntry(
+                vial_location=TenColumn.ONE,
+                method=DEFAULT_METHOD,
+                num_inj=3,
+                inj_vol=4,
+                sample_name="Sampel1",
+                sample_type=SampleType.SAMPLE,
+            ))
+            seq_table.rows[0] = SequenceEntry(
+                vial_location=TenColumn.ONE,
+                method=DEFAULT_METHOD,
+                num_inj=3,
+                inj_vol=4,
+                sample_name="Sampel2",
+                sample_type=SampleType.SAMPLE)
+            self.hplc_controller.edit_sequence(seq_table)
+            if run_too:
+                self.hplc_controller.run_sequence()
+                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()
+                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 = MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=5,
+                    flow=0.65,
+                    maximum_run_time=2),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=0.50,
+                        organic_modifer=99,
+                        flow=0.34)])
+            self.hplc_controller.edit_method(rand_method, save=True)
+
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            seq_table = SequenceTable(
+                name=DEFAULT_SEQUENCE,
+                rows=[
+                    SequenceEntry(
+                        vial_location=8320,
+                        sample_name="WM-01-001_Cr-Org",
+                        method=DEFAULT_METHOD,
+                        inj_source=InjectionSource.HIP_ALS,
+                        inj_vol=2,
+                        num_inj=1,
+                        sample_type=SampleType.SAMPLE
+                    ),
+                    SequenceEntry(
+                        vial_location=8448,
+                        sample_name="WM-01-001_Cr-Aq",
+                        method=DEFAULT_METHOD,
+                        inj_source=InjectionSource.HIP_ALS,
+                        inj_vol=2,
+                        num_inj=1,
+                        sample_type=SampleType.SAMPLE
+                    ),
+                ]
+            )
+
+            self.hplc_controller.edit_sequence(seq_table)
+            if run_too:
+                self.hplc_controller.preprun()
+                self.hplc_controller.run_sequence()
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                self.assertTrue(len(chrom) == 2)
+        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) == 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,100 @@ 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
+                    ),
+                    SequenceEntry(
+                        vial_location=TenColumn.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=TenColumn.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_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=TenColumn.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=TenColumn.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_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}")