pychemstation 0.8.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

tests/test_comb.py

@@ -0,0 +1,136 @@
+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(242)
+        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 = MethodDetails(
+                params=HPLCMethodParams(organic_modifier=5,
+                                        flow=0.65),
+                timetable=[TimeTableEntry(start_time=3.5,
+                                          organic_modifer=100,
+                                          flow=0.65)],
+                name=DEFAULT_METHOD,
+                stop_time=10,
+                post_time=9)
+            self.hplc_controller.edit_method(rand_method, save=True)
+            if run_too:
+                self.hplc_controller.run_method(experiment_name="changed_method")
+                chrom = self.hplc_controller.get_last_run_method_data()
+                self.assertEqual(len(chrom.__dict__), 8)
+        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=TenVialColumn.ONE,
+                method=DEFAULT_METHOD,
+                num_inj=3,
+                inj_vol=4,
+                sample_name="Sampel1",
+                sample_type=SampleType.SAMPLE,
+            ))
+            seq_table.rows[0] = SequenceEntry(
+                vial_location=TenVialColumn.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 = MethodDetails(
+                name=DEFAULT_METHOD,
+                params=HPLCMethodParams(
+                    organic_modifier=5,
+                    flow=0.65),
+                timetable=[TimeTableEntry(
+                    start_time=0.50,
+                    organic_modifer=99,
+                    flow=0.34)],
+                stop_time=10,
+                post_time=5)
+            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) == 1)
+        except Exception:
+            self.fail("Failed")

tests/test_comm.py

@@ -0,0 +1,65 @@
+import os
+
+import unittest
+
+from pychemstation.control import HPLCController
+from pychemstation.utils.macro import *
+from tests.constants import *
+
+
+class TestComm(unittest.TestCase):
+
+    def setUp(self):
+        path_constants = room(242)
+        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_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}")
+

tests/test_inj.py

@@ -0,0 +1,39 @@
+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 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())
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_method.py

@@ -0,0 +1,99 @@
+import os
+import unittest
+
+from pychemstation.control import HPLCController
+from tests.constants import *
+
+
+class TestMethod(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_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.first_row.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,
+                                   timetable=[TimeTableEntry(start_time=1,
+                                                             organic_modifer=20,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2,
+                                                             organic_modifer=30,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2.5,
+                                                             organic_modifer=60,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3,
+                                                             organic_modifer=80,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3.5,
+                                                             organic_modifer=100,
+                                                             flow=0.65)],
+                                   stop_time=4,
+                                   post_time=1,
+                                   params=HPLCMethodParams(organic_modifier=5, flow=0.65))
+        try:
+            self.hplc_controller.edit_method(new_method)
+        except Exception as e:
+            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_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}")
+
+
+if __name__ == '__main__':
+    unittest.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_offline_stable.py

@@ -0,0 +1,69 @@
+import unittest
+
+from pychemstation.analysis.process_report import ReportType
+from pychemstation.utils.sequence_types import SequenceDataFiles
+from pychemstation.utils.tray_types import FiftyFourVialPlate
+from tests.constants import DEFAULT_SEQUENCE, VIAL_PLATES, clean_up, set_up_utils
+
+
+class TestStable(unittest.TestCase):
+    """
+    These tests should always work, while the controller is offline or online.
+    """
+
+    def setUp(self):
+        self.hplc_controller = set_up_utils(242, offline=True)
+
+    def tearDown(self):
+        clean_up(self.hplc_controller)
+
+    def test_tray_nums_only(self):
+        for i in range(len(VIAL_PLATES)):
+            self.assertEqual(VIAL_PLATES[i], FiftyFourVialPlate.from_int(VIAL_PLATES[i].value()))
+
+    def test_get_last_run_sequence(self):
+        path = "hplc_testing 2025-03-27 17-13-47"
+        self.hplc_controller.sequence_controller.data_files.append(SequenceDataFiles(dir=path,
+                                                                                     sequence_name=DEFAULT_SEQUENCE))
+        try:
+            most_recent_folder = self.hplc_controller.sequence_controller.data_files[-1]
+            check_folder = self.hplc_controller.sequence_controller.fuzzy_match_most_recent_folder(
+                most_recent_folder=most_recent_folder)
+            self.assertEqual(check_folder.ok_value.dir, path)
+            self.hplc_controller.sequence_controller.data_files[-1].dir = check_folder.ok_value
+            chrom = self.hplc_controller.get_last_run_sequence_data()
+            self.assertTrue(chrom)
+        except Exception:
+            self.fail()
+
+    def test_plate_number(self):
+        self.assertEqual(FiftyFourVialPlate.from_str("P1-A1").value(), 4096)
+        self.assertEqual(FiftyFourVialPlate.from_str("P1-A4").value(), 4099)
+
+    def test_get_method_report(self):
+        method_path = "0_2025-03-15 19-14-35.D"
+        report = self.hplc_controller.get_last_run_method_report(custom_path=method_path, report_type=ReportType.CSV)
+        self.assertEqual(report.vial_location, FiftyFourVialPlate.from_int(4096))
+
+    def test_get_seq_report(self):
+        seq_path = "hplc_testing 2025-03-27 17-13-47"
+        report = self.hplc_controller.get_last_run_sequence_reports(custom_path=seq_path, report_type=ReportType.TXT)
+        self.assertEqual(len(report[0].signals[0].peaks), 12)
+
+    def test_get_method_uv(self):
+        method_path = "0_2025-03-15 19-14-35.D"
+        try:
+            uv_data = self.hplc_controller.get_last_run_method_data(custom_path=method_path, read_uv=True)
+        except Exception:
+            pass
+
+    def test_get_seq_uv(self):
+        seq_path = "hplc_testing 2025-03-27 17-13-47"
+        try:
+            uv_datas = self.hplc_controller.get_last_run_sequence_data(custom_path=seq_path, read_uv=True)
+        except Exception:
+            pass
+
+
+if __name__ == '__main__':
+    unittest.main()