pychemstation 0.5.7.dev1__tar.gz → 0.5.9__tar.gz

{pychemstation-0.5.7.dev1 → pychemstation-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.7.dev1
+Version: 0.5.9
 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.7.dev1 → pychemstation-0.5.9}/pychemstation/control/controllers/comm.py

@@ -12,6 +12,7 @@ Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 import logging
 import os
 import time
+from typing import Optional
 
 from result import Result, Ok, Err
 
@@ -43,7 +44,7 @@ class CommunicationController:
             self.cmd_no = 0
         else:
             raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
-        self._most_recent_hplc_status = None
+        self._most_recent_hplc_status: Optional[Status] = None
 
         # Create files for Chemstation to communicate with Python
         open(self.cmd_file, "a").close()
@@ -67,7 +68,7 @@ class CommunicationController:
         else:
             raise RuntimeError("Failed to get string")
 
-    def get_status(self) -> Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]:
+    def get_status(self) -> Status:
         """Get device status(es).
 
         :return: list of ChemStation's current status
@@ -130,7 +131,7 @@ class CommunicationController:
         :raises IOError: Could not read reply file.
         :return: Potential ChemStation response
         """
-        err = None
+        err: Optional[Union[OSError, IndexError]] = None
         for _ in range(num_attempts):
             time.sleep(1)
 

{pychemstation-0.5.7.dev1 → pychemstation-0.5.9}/pychemstation/control/controllers/method.py

@@ -21,13 +21,14 @@ class MethodController(TableController):
     def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
         super().__init__(controller, src, data_dir, table)
 
-    def check_loaded_method(self):
+    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(
@@ -136,7 +137,7 @@ class MethodController(TableController):
                 first_row=HPLCMethodParams(
                     organic_modifier=organic_modifier.percentage,
                     flow=method.flow,
-                    maximum_run_time=method.stop_time),
+                    maximum_run_time=method.stop_time.stop_time_value),
                 subsequent_rows=[
                     TimeTableEntry(
                         start_time=tte.time,
@@ -213,6 +214,11 @@ class MethodController(TableController):
                 self.sleepy_send(
                     f'NewColVal RCPMP1Method[1], "Timetable", "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
 
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
+                self.sleepy_send('SetTabText RCPMP1Method[1], "Timetable", 2, "Function", "Flow"')
+                self.sleepy_send(f'NewColVal RCPMP1Method[1], "Timetable", "FlowFlow", {row.flow}')
+                self.sleepy_send(f'SetTabVal RCPMP1Method[1], "Timetable", 2, "FlowFlow", {row.flow})')
+
                 self.send('Sleep 1')
                 self.sleepy_send("DownloadRCMethod PMP1")
                 self.send('Sleep 1')
@@ -230,8 +236,18 @@ class MethodController(TableController):
                 self.send("Sleep 1")
                 self.sleepy_send("DownloadRCMethod PMP1")
                 self.send("Sleep 1")
+
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
                 self.get_num_rows()
 
+                self.sleepy_send('SetTabText RCPMP1Method[1], "Timetable", Rows , "Function", "Flow"')
+                self.sleepy_send(f'SetTabVal RCPMP1Method[1], "Timetable", Rows , "FlowFlow", {row.flow}')
+                self.sleepy_send(f'SetTabVal RCPMP1Method[1], "Timetable", Rows , "Time", {row.start_time}')
+
+                self.send("Sleep 1")
+                self.sleepy_send("DownloadRCMethod PMP1")
+                self.send("Sleep 1")
+
     def _update_param(self, method_param: Param):
         """Change a method parameter, changes what is visibly seen in Chemstation GUI.
          (changes the first row in the timetable)

{pychemstation-0.5.7.dev1 → pychemstation-0.5.9}/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-0.5.7.dev1 → pychemstation-0.5.9}/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
@@ -166,7 +169,7 @@ class TableController(abc.ABC):
         finished_run = polling.poll(
             lambda: self.controller.check_if_running(),
             timeout=timeout,
-            step=18)
+            step=50)
 
         check_folder = self.fuzzy_match_most_recent_folder(most_recent_folder)
         if check_folder.is_ok() and finished_run:
@@ -175,9 +178,10 @@ class TableController(abc.ABC):
             finished_run = polling.poll(
                 lambda: self.controller.check_if_running(),
                 timeout=timeout,
-                step=12)
+                step=50)
             if finished_run:
                 return check_folder
+            return check_folder
         else:
             return Err("Run did not complete as expected")
 

{pychemstation-0.5.7.dev1 → pychemstation-0.5.9}/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,14 +30,15 @@ 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,
@@ -49,12 +50,18 @@ class HPLCController:
                                                       method_dir=method_dir)
 
     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,55 +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:
-        return self.method_controller.check_loaded_method()
+        """
+        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-0.5.7.dev1 → pychemstation-0.5.9}/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-0.5.7.dev1 → pychemstation-0.5.9}/pychemstation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.7.dev1
+Version: 0.5.9
 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.7.dev1 → pychemstation-0.5.9}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="pychemstation",
-    version="0.5.7.dev1",
+    version="0.5.9",
     author="Lucy Hao",
     author_email="lhao03@student.ubc.ca",
     description="Library to interact with Chemstation software, primarily used in Hein lab",

{pychemstation-0.5.7.dev1 → pychemstation-0.5.9}/tests/constants.py

@@ -40,6 +40,7 @@ def gen_rand_method():
     org_modifier = int(random.random() * 10)
     max_run_time = int(random.random() * 10)
     return MethodTimetable(
+        name=DEFAULT_METHOD,
         first_row=HPLCMethodParams(
             organic_modifier=org_modifier,
             flow=round(random.random(), 2),

{pychemstation-0.5.7.dev1 → pychemstation-0.5.9}/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)