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

tests/constants.py

@@ -1,134 +0,0 @@
-import os
-import random
-import shutil
-
-from pychemstation.control import HPLCController
-from pychemstation.utils.macro import Command
-from pychemstation.utils.method_types import (
-    HPLCMethodParams,
-    MethodDetails,
-    TimeTableEntry,
-)
-from pychemstation.utils.sequence_types import SampleType, SequenceEntry
-from pychemstation.utils.tray_types import FiftyFourVialPlate, TenVialColumn
-
-VIAL_PLATES = [
-    FiftyFourVialPlate.from_str('P1-A7'),
-    FiftyFourVialPlate.from_str('P1-B4'),
-    FiftyFourVialPlate.from_str('P1-C2'),
-    FiftyFourVialPlate.from_str('P1-D8'),
-    FiftyFourVialPlate.from_str('P1-E3'),
-    FiftyFourVialPlate.from_str('P1-F5'),
-    # plate 2
-    FiftyFourVialPlate.from_str('P2-A7'),
-    FiftyFourVialPlate.from_str('P2-B2'),
-    FiftyFourVialPlate.from_str('P2-C1'),
-    FiftyFourVialPlate.from_str('P2-D8'),
-    FiftyFourVialPlate.from_str('P2-E3'),
-    FiftyFourVialPlate.from_str('P2-F6'),
-]
-
-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\\hplc-method-optimization\\tests\\"
-DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
-DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data\\LC-BO\\"
-SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\3\\Sequence"
-SEQUENCE_DATA_DIR_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
-SEQUENCE_DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data\\"
-
-HEIN_LAB_CONSTANTS_242 = [DEFAULT_COMMAND_PATH,
-                          DEFAULT_METHOD_DIR,
-                          DATA_DIR,
-                          SEQUENCE_DIR,
-                          SEQUENCE_DATA_DIR_2,
-                          SEQUENCE_DATA_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\\LC BO\\"
-SEQUENCE_DIR_254 = "C:\\1\\Sequence\\"
-SEQUENCE_DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\"
-
-HEIN_LAB_CONSTANTS_254 = [DEFAULT_COMMAND_PATH_254,
-                          DEFAULT_METHOD_DIR_254,
-                          DATA_DIR_254,
-                          SEQUENCE_DIR_254,
-                          SEQUENCE_DATA_DIR_254]
-
-
-def room(num: int):
-    if num == 242:
-        return HEIN_LAB_CONSTANTS_242
-    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)
-    post_run_time = int(random.random() * 10)
-    flow = float(random.random() * 10) / 10
-    flow_1 = float(random.random() * 10) / 10
-    flow_2 = float(random.random() * 10) / 10
-    return MethodDetails(name=DEFAULT_METHOD,
-                         timetable=[TimeTableEntry(start_time=0.10,
-                                                   organic_modifer=org_modifier,
-                                                   flow=flow_1),
-                                    TimeTableEntry(start_time=1,
-                                                   organic_modifer=100 - int(random.random() * 10),
-                                                   flow=flow_2)],
-                         stop_time=max_run_time,
-                         post_time=post_run_time,
-                         params=HPLCMethodParams(organic_modifier=org_modifier, flow=flow))
-
-
-seq_entry = SequenceEntry(
-    vial_location=TenVialColumn.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)),
-)
-
-
-def set_up_utils(num: int, offline: bool = False, runs: bool = False) -> HPLCController:
-    path_constants = room(num)
-    if not offline:
-        for path in path_constants:
-            if not os.path.exists(path):
-                raise FileNotFoundError(
-                    f"{path} does not exist on your system. If you would like to run tests, please change this path.")
-
-    controller = HPLCController(offline=offline,
-                                comm_dir=path_constants[0],
-                                method_dir=path_constants[1],
-                                data_dirs=[path_constants[2], path_constants[4], path_constants[5]],
-                                sequence_dir=path_constants[3],
-                                debug=True)
-    if not offline:
-        controller.send(Command.SAVE_METHOD_CMD.value.format(commit_msg="method saved by pychemstation"))
-        controller.send(Command.SAVE_SEQUENCE_CMD)
-    if runs:
-        controller.instrument_on()
-        controller.preprun()
-    return controller
-
-
-
-def clean_up(hplc_controller: HPLCController):
-    if hasattr(hplc_controller.method_controller, "data_dirs") and hasattr(hplc_controller.sequence_controller, "data_dirs"):
-        files = hplc_controller.method_controller.data_files + [d.dir for d in hplc_controller.sequence_controller.data_files]
-        data_dirs = hplc_controller.method_controller.data_dirs
-        for folder in files:
-            if os.path.isdir(folder):
-                shutil.rmtree(folder)
-            else:
-                for data_dir in data_dirs:
-                    possible_path = os.path.join(data_dir, folder)
-                    if os.path.isdir(possible_path):
-                        shutil.rmtree(possible_path)

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_offline_stable.py

@@ -1,69 +0,0 @@
-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()