pychemstation 0.7.0.dev2__py3-none-any.whl → 0.8.1__py3-none-any.whl

tests/test_comb.py

@@ -1,136 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,52 +0,0 @@
-import unittest
-
-from result import Result
-
-from pychemstation.analysis.process_report import process_csv_report
-
-
-class TestReport(unittest.TestCase):
-
-    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_runs_stable.py

@@ -1,125 +0,0 @@
-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(242)
-
-    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)  # nvm no bug??
-
-            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)
-            seq_table = SequenceTable(
-                name=DEFAULT_SEQUENCE,
-                rows=[SequenceEntry(vial_location=FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.ONE),
-                                    sample_name="P1-A1",
-                                    method=DEFAULT_METHOD,
-                                    inj_source=InjectionSource.HIP_ALS,
-                                    inj_vol=0.5,
-                                    num_inj=1,
-                                    sample_type=SampleType.SAMPLE),
-                      SequenceEntry(vial_location=FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.TWO),
-                                    sample_name="P1-A2",
-                                    method=DEFAULT_METHOD,
-                                    inj_source=InjectionSource.HIP_ALS,
-                                    inj_vol=0.5,
-                                    num_inj=1,
-                                    sample_type=SampleType.SAMPLE),
-                      SequenceEntry(vial_location=FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.THREE),
-                                    sample_name="P1-A3",
-                                    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)
-            self.hplc_controller.switch_method(method_name=DEFAULT_METHOD)
-            method = MethodDetails(
-                name=DEFAULT_METHOD,
-                params=HPLCMethodParams(
-                    organic_modifier=5,
-                    flow=0.65),
-                timetable=[TimeTableEntry(
-                    start_time=3.50,
-                    organic_modifer=100,
-                    flow=0.65)],
-                stop_time=5,
-                post_time=1)
-            self.hplc_controller.edit_method(method)
-            self.hplc_controller.preprun()
-            self.hplc_controller.run_sequence()
-            chroms = self.hplc_controller.get_last_run_sequence_data()
-            self.assertTrue(len(chroms) == 3)
-        except Exception:
-            self.fail("Failed")
-