pychemstation 0.5.6__py3-none-any.whl → 0.5.7__py3-none-any.whl

pychemstation/control/controllers/method.py

@@ -21,6 +21,15 @@ class MethodController(TableController):
     def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
         super().__init__(controller, src, data_dir, table)
 
+    def check(self) -> str:
+        time.sleep(2)
+        self.send(Command.GET_METHOD_CMD)
+        time.sleep(2)
+        res = self.receive()
+        if res.is_ok():
+            return res.ok_value.string_response
+        return "ERROR"
+
     def get_method_params(self) -> HPLCMethodParams:
         return HPLCMethodParams(organic_modifier=self.controller.get_num_val(
             cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
@@ -50,8 +59,12 @@ class MethodController(TableController):
     def load(self) -> MethodTimetable:
         rows = self.get_num_rows()
         if rows.is_ok():
+            self.send(Command.GET_METHOD_CMD)
+            res = self.receive()
+            method_name = res.ok_value.string_response
             timetable_rows = [self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))]
             self.table_state = MethodTimetable(
+                name=method_name,
                 first_row=self.get_method_params(),
                 subsequent_rows=timetable_rows)
             return self.table_state
@@ -124,8 +137,7 @@ class MethodController(TableController):
                 first_row=HPLCMethodParams(
                     organic_modifier=organic_modifier.percentage,
                     flow=method.flow,
-                    maximum_run_time=method.stop_time,
-                    temperature=-1),
+                    maximum_run_time=method.stop_time.stop_time_value),
                 subsequent_rows=[
                     TimeTableEntry(
                         start_time=tte.time,

pychemstation/control/controllers/sequence.py

@@ -49,6 +49,15 @@ class SequenceController(TableController):
                              inj_source=inj_source,
                              sample_type=sample_type, )
 
+    def check(self) -> str:
+        time.sleep(2)
+        self.send(Command.GET_SEQUENCE_CMD)
+        time.sleep(2)
+        res = self.receive()
+        if res.is_ok():
+            return res.ok_value.string_response
+        return "ERROR"
+
     def switch(self, seq_name: str):
         """
         Switch to the specified sequence. The sequence name does not need the '.S' extension.
@@ -197,7 +206,7 @@ class SequenceController(TableController):
             else:
                 self.data_files[-1].dir = self.fuzzy_match_most_recent_folder(folder_name).ok_value
 
-    def retrieve_recent_data_files(self):
+    def retrieve_recent_data_files(self) -> str:
         sequence_data_files: SequenceDataFiles = self.data_files[-1]
         return sequence_data_files.dir
 

pychemstation/control/controllers/table_controller.py

@@ -19,12 +19,14 @@ from ...utils.sequence_types import SequenceDataFiles, SequenceTable
 from ...utils.table_types import Table, TableOperation, RegisterFlag
 
 
+TableType = Union[MethodTimetable, SequenceTable]
+
 class TableController(abc.ABC):
 
     def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
         self.controller = controller
         self.table = table
-        self.table_state : Optional[TableController] = None
+        self.table_state : Optional[TableType] = None
 
         if os.path.isdir(src):
             self.src: str = src
@@ -154,6 +156,7 @@ class TableController(abc.ABC):
         Checks if ChemStation has finished running and can read data back
 
         :param method: if you are running a method and want to read back data, the timeout period will be adjusted to be longer than the method's runtime
+        :param sequence: if you are running a sequence and want to read back data, the timeout period will be adjusted to be longer than the sequence's runtime
         :return: Return True if data can be read back, else False.
         """
         timeout = 10 * 60

pychemstation/control/hplc.py

@@ -7,7 +7,7 @@ Authors: Lucy Hao
 from typing import Union, Optional
 
 from ..control.controllers import MethodController, SequenceController, CommunicationController
-from ..utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
+from ..utils.chromatogram import AgilentChannelChromatogramData
 from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
 from ..utils.method_types import MethodTimetable
 from ..utils.sequence_types import SequenceTable, SequenceEntry
@@ -30,31 +30,38 @@ class HPLCController:
                  comm_dir: str,
                  data_dir: str,
                  method_dir: str,
-                 sequence_dir: str):
+                 sequence_dir: str,
+                 offline: bool = False):
         """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
         `comm_dir` must match the file path in the macro file.
 
         :param comm_dir: Name of directory for communication, where ChemStation will read and write from. Can be any existing directory.
         :raises FileNotFoundError: If either `data_dir`, `method_dir` or `comm_dir` is not a valid directory.
         """
-        self.comm = CommunicationController(comm_dir=comm_dir)
+        self.comm = CommunicationController(comm_dir=comm_dir) if not offline else None
         self.method_controller = MethodController(controller=self.comm,
                                                   src=method_dir,
                                                   data_dir=data_dir,
-                                                  table=self.METHOD_TIMETABLE)
+                                                  table=self.METHOD_TIMETABLE) if not offline else None
         self.sequence_controller = SequenceController(controller=self.comm,
                                                       src=sequence_dir,
                                                       data_dir=data_dir,
                                                       table=self.SEQUENCE_TABLE,
-                                                      method_dir=method_dir)
+                                                      method_dir=method_dir) if not offline else None
 
     def send(self, cmd: Union[Command, str]):
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.comm.send(cmd)
 
     def receive(self) -> Response:
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.comm.receive().value
 
     def status(self) -> Union[HPLCRunningStatus | HPLCAvailStatus | HPLCErrorStatus]:
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.comm.get_status()
 
     def switch_method(self, method_name: str):
@@ -67,6 +74,8 @@ class HPLCController:
         :raises  IndexError: Response did not have expected format. Try again.
         :raises  AssertionError: The desired method is not selected. Try again.
         """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.method_controller.switch(method_name)
 
     def switch_sequence(self, sequence_name: str):
@@ -76,9 +85,11 @@ class HPLCController:
 
         :param sequence_name: The name of the sequence file
         """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.sequence_controller.switch(sequence_name)
 
-    def run_method(self, experiment_name: str):
+    def run_method(self, experiment_name: str, stall_while_running: bool = True):
         """
         This is the preferred method to trigger a run.
         Starts the currently selected method, storing data
@@ -87,18 +98,23 @@ class HPLCController:
         Device must be ready.
 
         :param experiment_name: Name of the experiment
+        :param stall_while_running: whether this method should return or stall while HPLC runs.
         """
-        self.method_controller.run(experiment_name)
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
+        self.method_controller.run(experiment_name, stall_while_running)
 
-    def run_sequence(self):
+    def run_sequence(self, stall_while_running: bool = True):
         """
         Starts the currently loaded sequence, storing data
         under the <data_dir>/<sequence table name> folder.
         Device must be ready.
 
-        :param sequence_name:
+        :param stall_while_running: whether this method should return or stall while HPLC runs.
         """
-        self.sequence_controller.run()
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
+        self.sequence_controller.run(stall_while_running=stall_while_running)
 
     def edit_method(self, updated_method: MethodTimetable, save: bool = False):
         """Updated the currently loaded method in ChemStation with provided values.
@@ -106,6 +122,8 @@ class HPLCController:
         :param updated_method: the method with updated values, to be sent to Chemstation to modify the currently loaded method.
         :param save:
         """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.method_controller.edit(updated_method, save)
 
     def edit_sequence(self, updated_sequence: SequenceTable):
@@ -115,6 +133,8 @@ class HPLCController:
 
         :param updated_sequence:
         """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.sequence_controller.edit(updated_sequence)
 
     def edit_sequence_row(self, row: SequenceEntry, num: int):
@@ -124,52 +144,86 @@ class HPLCController:
         :param row: sequence row entry with updated information
         :param row_num: the row to edit, based on -1-based indexing
         """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.sequence_controller.edit_row(row, num)
 
-    def get_last_run_method_data(self) -> AgilentChannelChromatogramData:
+    def get_last_run_method_data(self, data: Optional[str] = None) -> AgilentChannelChromatogramData:
         """
         Returns the last run method data.
         """
-        return self.method_controller.get_data()
+        return self.method_controller.get_data(custom_path=data)
 
-    def get_last_run_sequence_data(self) -> list[AgilentChannelChromatogramData]:
+    def get_last_run_sequence_data(self, data: Optional[str] = None) -> list[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
         """
-        return self.sequence_controller.get_data()
+        return self.sequence_controller.get_data(custom_path=data)
+
+    def check_loaded_sequence(self) -> str:
+        """
+        Returns the name of the currently loaded sequence.
+        """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
+        return self.sequence_controller.check()
+
+    def check_loaded_method(self) -> str:
+        """
+        Returns the name of the currently loaded method.
+        """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
+        return self.method_controller.check()
 
     def load_method(self) -> MethodTimetable:
         """
-        Returns the currently loaded method, including its timetable.
+        Returns all details of the currently loaded method, including its timetable.
         """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.method_controller.load()
 
     def load_sequence(self) -> SequenceTable:
         """
         Returns the currently loaded sequence.
         """
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         return self.sequence_controller.load()
 
     def standby(self):
         """Switches all modules in standby mode. All lamps and pumps are switched off."""
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.STANDBY_CMD)
 
     def preprun(self):
         """ Prepares all modules for run. All lamps and pumps are switched on."""
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.PREPRUN_CMD)
 
     def lamp_on(self):
         """Turns the UV lamp on."""
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.LAMP_ON_CMD)
 
     def lamp_off(self):
         """Turns the UV lamp off."""
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.LAMP_OFF_CMD)
 
     def pump_on(self):
         """Turns on the pump on."""
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.PUMP_ON_CMD)
 
     def pump_off(self):
         """Turns the pump off."""
+        if not self.comm:
+            raise RuntimeError("Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.send(Command.PUMP_OFF_CMD)

pychemstation/utils/macro.py

@@ -86,3 +86,6 @@ def str_to_status(status: str) -> Union[HPLCAvailStatus, HPLCErrorStatus, HPLCRu
     if HPLCAvailStatus.has_member_key(status):
         return HPLCAvailStatus[status]
     raise KeyError(status)
+
+
+Status = Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]

pychemstation/utils/method_types.py

@@ -6,6 +6,7 @@ from .table_types import RegisterFlag
 from ..generated import Signal, SolventElement
 
 
+
 class PType(Enum):
     STR = "str"
     NUM = "num"
@@ -34,6 +35,7 @@ class TimeTableEntry:
 
 @dataclass
 class MethodTimetable:
+    name: str
     first_row: HPLCMethodParams
     subsequent_rows: list[TimeTableEntry]
     dad_wavelengthes: Optional[list[Signal]] = None

pychemstation/utils/table_types.py

@@ -46,6 +46,9 @@ class RegisterFlag(Enum):
 
     # for Method Timetable
     SOLVENT_COMPOSITION = "SolventComposition"
+    PRESSURE = "Pressure"
+    EXTERNAL_CONTACT = "ExternalContact"
+
 
     # for Sequence
     VIAL_LOCATION = "Vial"

{pychemstation-0.5.6.dist-info → pychemstation-0.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.6
+Version: 0.5.7
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao

{pychemstation-0.5.6.dist-info → pychemstation-0.5.7.dist-info}/RECORD

@@ -1,16 +1,16 @@
 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/base_spectrum.py,sha256=XPf9eJ72uz0CnxCY5uFOyu1MbVX-OTTXeN1tLzIMok4,16536
+pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-GKjiDi8,10201
 pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
 pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
 pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
-pychemstation/control/hplc.py,sha256=L1-cBQ7-thuITx1Mqq3lYXo832nEQtRJEX7nlLvRYrg,6732
+pychemstation/control/hplc.py,sha256=77VPB2lvjwddR-0N7YJBRCBsydfmCkAXZh1NyMicyLE,10801
 pychemstation/control/controllers/__init__.py,sha256=di3ytLIK-35XC_THw4IjNaOtCUTe7GuEOFb-obmREw4,166
-pychemstation/control/controllers/comm.py,sha256=-fJqPcis30fbWS07Tiv68lRFk7ALKC8OitcEBQ_xDTE,7409
-pychemstation/control/controllers/method.py,sha256=XaF45hN4FhQ77y3m0cNiNjeC_WN_CBSlWlbsqe9AZiw,12935
-pychemstation/control/controllers/sequence.py,sha256=Oi74EhVSgbDVQBxPvITvK5Eo52Ugtz_xCHFYCIq_4Oo,11070
-pychemstation/control/controllers/table_controller.py,sha256=U7oa_mwIKsySASMVWx-heD6C6tVkf5Yb26ksu9x5lQQ,8876
+pychemstation/control/controllers/comm.py,sha256=IU4I_Q42VNCNUlVi93MxCmw2EBY9hiBDkU9FxubKg3c,7441
+pychemstation/control/controllers/method.py,sha256=Z_nLu_zXyXhpixDq7xTOljMWVBn9ioFvmSLXhTHXw-Y,13322
+pychemstation/control/controllers/sequence.py,sha256=ME9F5nWt-GqL5Qonhe8uNRU0K9oRwGPkPpb_YgqbziI,11318
+pychemstation/control/controllers/table_controller.py,sha256=RARvXS2UIfVdinoVOD5aBFQFhEtu95K57bcNgwOKCME,9081
 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
@@ -20,20 +20,20 @@ pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCs
 pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/chromatogram.py,sha256=-q3_hL9GTyi4C95os7IwAiOrkTM4EXIiigm-nW9pFmM,3221
-pychemstation/utils/macro.py,sha256=BAIcE_dppNffwrSqGq8gh0ccE9YAJfQFQZHXJgA1WtA,2586
-pychemstation/utils/method_types.py,sha256=YngbyHg96JSFnvhm5Zd7wJvLTQPPQsLbvbyz3HlGLYY,862
+pychemstation/utils/macro.py,sha256=9rSdup9HucmVfT9ZnhwMUpH3vjxDsILXnBCGXQGVdYU,2656
+pychemstation/utils/method_types.py,sha256=Hyd_Kxf-ygKW7LlOtEhGG-uujwFPE1w-orqyxcDz17E,877
 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/table_types.py,sha256=H67-7I96X8Zkm2HygHYttYwG_XuNDmV2AKZW10yZbiA,2418
 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=pfPpw2wKuF7_v39SOmT4tbbarqBa7NfcRTUVdLLsvWw,5769
+tests/test_comb.py,sha256=Ef5PD_uEVszCMmpurbzlweSAXzGH6o1rblFqYhGC9r0,5680
 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.6.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.6.dist-info/METADATA,sha256=t3DKxxw4mHJeiVNSt9VSVTJav5Yc2Ze7DU33CHQcnJs,4307
-pychemstation-0.5.6.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.6.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.6.dist-info/RECORD,,
+pychemstation-0.5.7.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.7.dist-info/METADATA,sha256=9l3HlOYCQUlEjdnK65JeZzNXWvGOglMwngbhGiR50FI,4307
+pychemstation-0.5.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.7.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.7.dist-info/RECORD,,

tests/test_comb.py

@@ -28,16 +28,13 @@ class TestCombinations(unittest.TestCase):
                 first_row=HPLCMethodParams(
                     organic_modifier=5,
                     flow=0.65,
-                    maximum_run_time=1),
+                    maximum_run_time=4),
                 subsequent_rows=[
                     TimeTableEntry(
-                        start_time=0.10,
-                        organic_modifer=5,
-                        flow=0.34),
-                    TimeTableEntry(
-                        start_time=0.5,
-                        organic_modifer=98,
-                        flow=0.55)])
+                        start_time=3.5,
+                        organic_modifer=100,
+                        flow=0.65)],
+            name=DEFAULT_METHOD)
             self.hplc_controller.edit_method(rand_method, save=True)
             if run_too:
                 self.hplc_controller.run_method(experiment_name="changed_method")
@@ -97,7 +94,8 @@ class TestCombinations(unittest.TestCase):
                     TimeTableEntry(
                         start_time=0.50,
                         organic_modifer=99,
-                        flow=0.34)])
+                        flow=0.34)],
+            name=DEFAULT_METHOD)
             self.hplc_controller.edit_method(rand_method, save=True)
 
             self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)