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

pychemstation/control/controllers/__init__.py

@@ -3,7 +3,5 @@
 """
 
 from .comm import CommunicationController
-from .devices.pump import PumpController
-from .devices.column import ColumnController
 from .tables.method import MethodController
 from .tables.sequence import SequenceController

pychemstation/control/controllers/comm.py

@@ -9,7 +9,6 @@ been processed.
 
 Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
-import logging
 import os
 import time
 from typing import Optional
@@ -32,12 +31,15 @@ class CommunicationController:
             comm_dir: str,
             cmd_file: str = "cmd",
             reply_file: str = "reply",
+            debug: bool = False
     ):
         """
         :param comm_dir:
         :param cmd_file: Name of command file
         :param reply_file: Name of reply file
+        :param debug: whether to save log of sent commands
         """
+        self.debug = debug
         if os.path.isdir(comm_dir):
             self.cmd_file = os.path.join(comm_dir, cmd_file)
             self.reply_file = os.path.join(comm_dir, reply_file)
@@ -52,21 +54,26 @@ class CommunicationController:
 
         self.reset_cmd_counter()
 
-    def get_num_val(self, cmd: str) -> Union[int, float, Err]:
-        self.send(Command.GET_NUM_VAL_CMD.value.format(cmd=cmd))
-        res = self.receive()
-        if res.is_ok():
-            return res.ok_value.num_response
-        else:
-            raise RuntimeError("Failed to get number.")
+        # Initialize row counter for table operations
+        self.send('Local Rows')
+
+    def get_num_val(self, cmd: str) -> Union[int, float]:
+        tries = 5
+        for _ in range(tries):
+            self.send(Command.GET_NUM_VAL_CMD.value.format(cmd=cmd))
+            res = self.receive()
+            if res.is_ok():
+                return res.ok_value.num_response
+        raise RuntimeError("Failed to get number.")
 
     def get_text_val(self, cmd: str) -> str:
-        self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
-        res = self.receive()
-        if res.is_ok():
-            return res.ok_value.string_response
-        else:
-            raise RuntimeError("Failed to get string")
+        tries = 5
+        for _ in range(tries):
+            self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
+            res = self.receive()
+            if res.is_ok():
+                return res.ok_value.string_response
+        raise RuntimeError("Failed to get string")
 
     def get_status(self) -> Status:
         """Get device status(es).
@@ -89,16 +96,15 @@ class CommunicationController:
         """Updates current status of HPLC machine"""
         self._most_recent_hplc_status = self.get_status()
 
-    def check_if_running(self) -> bool:
+    def check_if_not_running(self) -> bool:
         """Checks if HPLC machine is in an available state, meaning a state that data is not being written.
 
         :return: whether the HPLC machine is in a safe state to retrieve data back."""
         self.set_status()
         hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        time.sleep(30)
+        time.sleep(5)
         self.set_status()
         hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        logging.info("Still running")
         return hplc_avail and hplc_actually_avail
 
     def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
@@ -173,9 +179,10 @@ class CommunicationController:
         cmd_to_send: str = cmd.value if isinstance(cmd, Command) else cmd
         self.cmd_no += 1
         self._send(cmd_to_send, self.cmd_no)
-        f = open("out.txt", "a")
-        f.write(cmd_to_send + "\n")
-        f.close()
+        if self.debug:
+            f = open("out.txt", "a")
+            f.write(cmd_to_send + "\n")
+            f.close()
 
     def receive(self) -> Result[Response, str]:
         """Returns messages received in reply file.

pychemstation/control/controllers/devices/device.py

@@ -1,16 +1,23 @@
 import abc
-from typing import Union
+from typing import Union, List
 
+from result import Result
+
+from ....analysis.process_report import ReportType, AgilentReport
 from ....control.controllers import CommunicationController
 from ....control.controllers.tables.table import TableController
 from ....utils.chromatogram import AgilentChannelChromatogramData
-from ....utils.table_types import Table
+from ....utils.table_types import Table, T
 
 
 class DeviceController(TableController, abc.ABC):
 
     def __init__(self, controller: CommunicationController, table: Table, offline: bool):
-        super().__init__(controller, None, None, table, offline)
+        super().__init__(controller=controller,
+                         src=None,
+                         data_dirs=[],
+                         table=table,
+                         offline=offline)
 
     @abc.abstractmethod
     def get_row(self, row: int):
@@ -19,5 +26,11 @@ class DeviceController(TableController, abc.ABC):
     def retrieve_recent_data_files(self):
         raise NotImplementedError
 
-    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def get_data(self) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        raise NotImplementedError
+
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+        raise NotImplementedError
+
+    def get_report(self, report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
         raise NotImplementedError

pychemstation/control/controllers/tables/method.py

@@ -2,13 +2,15 @@ import os
 import time
 from typing import List
 
+from result import Result, Ok, Err
 from xsdata.formats.dataclass.parsers import XmlParser
 
 from .table import TableController
 from ..devices.injector import InjectorController
+from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
 from ....generated import PumpMethod, DadMethod, SolventElement
-from ....utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
+from ....utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData, AgilentHPLCChromatogram
 from ....utils.macro import *
 from ....utils.method_types import *
 from ....utils.table_types import *
@@ -26,7 +28,8 @@ class MethodController(TableController):
                  offline: bool,
                  injector_controller: InjectorController):
         self.injector_controller = injector_controller
-        super().__init__(controller, src, data_dirs, table, offline=offline)
+        self.data_files: List[str] = []
+        super().__init__(controller=controller, src=src, data_dirs=data_dirs, table=table, offline=offline)
 
     def check(self) -> str:
         time.sleep(2)
@@ -40,13 +43,13 @@ class MethodController(TableController):
     def get_method_params(self) -> HPLCMethodParams:
         return HPLCMethodParams(organic_modifier=self.controller.get_num_val(
             cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                register=self.table.register,
+                register=self.table_locator.register,
                 register_flag=RegisterFlag.SOLVENT_B_COMPOSITION
             )
         ),
             flow=self.controller.get_num_val(
                 cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table.register,
+                    register=self.table_locator.register,
                     register_flag=RegisterFlag.FLOW
                 )
             ),
@@ -90,19 +93,11 @@ class MethodController(TableController):
     def load(self) -> MethodDetails:
         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
+            method_name = self.get_method_name()
             timetable_rows = self.get_timetable(int(rows.ok_value.num_response))
             params = self.get_method_params()
-            stop_time = self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table.register,
-                    register_flag=RegisterFlag.MAX_TIME))
-            post_time = self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table.register,
-                    register_flag=RegisterFlag.POST_TIME))
+            stop_time = self.get_stop_time()
+            post_time = self.get_post_time()
             self.table_state = MethodDetails(name=method_name,
                                              timetable=timetable_rows,
                                              stop_time=stop_time,
@@ -112,6 +107,24 @@ class MethodController(TableController):
         else:
             raise RuntimeError(rows.err_value)
 
+    def get_method_name(self):
+        self.send(Command.GET_METHOD_CMD)
+        res = self.receive()
+        method_name = res.ok_value.string_response
+        return method_name
+
+    def get_post_time(self) -> Union[int, float]:
+        return self.controller.get_num_val(
+            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                register=self.table_locator.register,
+                register_flag=RegisterFlag.POST_TIME))
+
+    def get_stop_time(self) -> Union[int, float]:
+        return self.controller.get_num_val(
+            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                register=self.table_locator.register,
+                register_flag=RegisterFlag.MAX_TIME))
+
     def current_method(self, method_name: str):
         """
         Checks if a given method is already loaded into Chemstation. Method name does not need the ".M" extension.
@@ -123,18 +136,19 @@ class MethodController(TableController):
         parsed_response = self.receive()
         return method_name in parsed_response
 
-    def switch(self, method_name: str):
+    def switch(self, method_name: str, alt_method_dir: Optional[str] = None):
         """
         Allows the user to switch between pre-programmed methods. No need to append '.M'
         to the end of the method name. For example. for the method named 'General-Poroshell.M',
         only 'General-Poroshell' is needed.
 
         :param method_name: any available method in Chemstation method directory
+        :param alt_method_dir: directory where the method resides
         :raise IndexError: Response did not have expected format. Try again.
         :raise AssertionError: The desired method is not selected. Try again.
         """
-        self.send(Command.SWITCH_METHOD_CMD_SPECIFIC.value.format(method_dir=self.src,
-                                                                  method_name=method_name))
+        method_dir = self.src if not alt_method_dir else alt_method_dir
+        self.send(Command.SWITCH_METHOD_CMD_SPECIFIC.value.format(method_dir=method_dir, method_name=method_name))
 
         time.sleep(2)
         self.send(Command.GET_METHOD_CMD)
@@ -239,7 +253,7 @@ class MethodController(TableController):
 
         :param method_param: a parameter to update for currently loaded method.
         """
-        register = self.table.register
+        register = self.table_locator.register
         setting_command = TableOperation.UPDATE_OBJ_HDR_VAL if method_param.ptype == PType.NUM else TableOperation.UPDATE_OBJ_HDR_TEXT
         if isinstance(method_param.chemstation_key, list):
             for register_flag in method_param.chemstation_key:
@@ -287,9 +301,8 @@ class MethodController(TableController):
                 self._edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
                 self.download()
 
-    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
+    def _update_method_timetable(self, timetable_rows: List[TimeTableEntry]):
         self.get_num_rows()
-
         self.delete_table()
         res = self.get_num_rows()
         while not res.is_err():
@@ -304,19 +317,15 @@ class MethodController(TableController):
 
     def stop(self):
         """
-        Stops the method run. A dialog window will pop up and manual intervention may be required.\
+        Stops the method run. A dialog window will pop up and manual intervention may be required.
         """
         self.send(Command.STOP_METHOD_CMD)
 
-    def run(self, experiment_name: str, stall_while_running: bool = True):
+    def run(self, experiment_name: str, add_timestamp: bool = True, stall_while_running: bool = True):
         """
-        This is the preferred method to trigger a run.
-        Starts the currently selected method, storing data
-        under the <data_dir>/<experiment_name>.D folder.
-        The <experiment_name> will be appended with a timestamp in the '%Y-%m-%d-%H-%M' format.
-        Device must be ready.
-
         :param experiment_name: Name of the experiment
+        :param stall_while_running: whether to stall or immediately return
+        :param add_timestamp: if should add timestamp to experiment name
         """
 
         folder_name = ""
@@ -325,9 +334,8 @@ class MethodController(TableController):
         while tries < 10 and not hplc_is_running:
             timestamp = time.strftime(TIME_FORMAT)
             self.send(Command.RUN_METHOD_CMD.value.format(data_dir=self.data_dirs[0],
-                                                          experiment_name=experiment_name,
-                                                          timestamp=timestamp))
-            folder_name = f"{experiment_name}_{timestamp}.D"
+                                                          experiment_name=f"{experiment_name}_{timestamp}" if add_timestamp else experiment_name))
+            folder_name = f"{experiment_name}_{timestamp}.D" if add_timestamp else f"{experiment_name}.D"
             hplc_is_running = self.check_hplc_is_running()
             tries += 1
 
@@ -337,11 +345,8 @@ class MethodController(TableController):
         self.data_files.append(os.path.join(self.data_dirs[0], folder_name))
 
         if stall_while_running:
-
-            if not self.table_state:
-                self.table_state = self.load()
-
-            run_completed = self.check_hplc_done_running(method=self.table_state)
+            self.timeout = (self.get_stop_time() + self.get_post_time()) * 60
+            run_completed = self.check_hplc_done_running()
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
@@ -349,8 +354,10 @@ class MethodController(TableController):
         else:
             self.data_files[-1] = self.fuzzy_match_most_recent_folder(folder_name).ok_value
 
-    def retrieve_recent_data_files(self) -> str:
-        return self.data_files[-1]
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+        if os.path.exists(most_recent_folder):
+            return Ok(most_recent_folder)
+        return Err("Folder not found!")
 
     def get_data(self, custom_path: Optional[str] = None,
                  read_uv: bool = False) -> AgilentChannelChromatogramData:
@@ -359,3 +366,14 @@ class MethodController(TableController):
         else:
             self.get_spectrum(custom_path, read_uv)
         return AgilentChannelChromatogramData(**self.spectra) if not read_uv else self.uv
+
+    def get_report(self, custom_path: Optional[str] = None,
+                   report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
+        metd_report = self.get_report_details(self.data_files[-1] if not custom_path else custom_path,
+                                              report_type)
+        chrom_data: List[AgilentHPLCChromatogram] = list(self.get_data(custom_path).__dict__.values())
+        for i, signal in enumerate(metd_report.signals):
+            possible_data = chrom_data[i]
+            if len(possible_data.x) > 0:
+                signal.data = possible_data
+        return [metd_report]

pychemstation/control/controllers/tables/sequence.py

@@ -1,10 +1,15 @@
 import os
 import time
-from typing import Optional, Union, List
+from typing import Optional, List, Dict
 
-from .table import TableController, ChromData
+from result import Result, Ok, Err
+from typing_extensions import override
+
+from .table import TableController
+from .. import MethodController
+from ....analysis.process_report import ReportType, AgilentReport
 from ....control.controllers.comm import CommunicationController
-from ....utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogramData
+from ....utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogramData, AgilentHPLCChromatogram
 from ....utils.macro import Command
 from ....utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
 from ....utils.table_types import RegisterFlag, Table
@@ -17,13 +22,14 @@ class SequenceController(TableController):
     """
 
     def __init__(self, controller: CommunicationController,
+                 method_controller: MethodController,
                  src: str,
                  data_dirs: List[str],
                  table: Table,
-                 method_dir: str,
                  offline: bool):
-        self.method_dir = method_dir
-        super().__init__(controller, src, data_dirs, table, offline=offline)
+        self.method_controller = method_controller
+        self.data_files: List[SequenceDataFiles] = []
+        super().__init__(controller=controller, src=src, data_dirs=data_dirs, table=table, offline=offline)
 
     def load(self) -> SequenceTable:
         rows = self.get_num_rows()
@@ -42,7 +48,7 @@ class SequenceController(TableController):
         vial_location = int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
         method = self.get_text(row, RegisterFlag.METHOD)
         num_inj = int(self.get_num(row, RegisterFlag.NUM_INJ))
-        inj_vol = int(self.get_text(row, RegisterFlag.INJ_VOL))
+        inj_vol = float(self.get_text(row, RegisterFlag.INJ_VOL))
         inj_source = InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
         sample_type = SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
         vial_enum = TenVialColumn(vial_location) if vial_location <= 10 else FiftyFourVialPlate.from_int(
@@ -131,10 +137,11 @@ class SequenceController(TableController):
             self._edit_row_num(row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc)
 
         if row.method:
-            possible_path = os.path.join(self.method_dir, row.method) + ".M\\"
+            method_dir = self.method_controller.src
+            possible_path = os.path.join(method_dir, row.method) + ".M\\"
             method = row.method
             if os.path.exists(possible_path):
-                method = os.path.join(self.method_dir, row.method)
+                method = os.path.join(method_dir, row.method)
             self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
 
         if row.num_inj:
@@ -165,11 +172,27 @@ class SequenceController(TableController):
         Device must be ready.
         """
         self.controller.send(Command.SAVE_METHOD_CMD)
+        self.controller.send(Command.SAVE_SEQUENCE_CMD)
+
         if not self.table_state:
             self.table_state = self.load()
 
+        total_runtime = 0
+        for entry in self.table_state.rows:
+            curr_method_runtime = self.method_controller.get_post_time() + self.method_controller.get_stop_time()
+            loaded_method = self.method_controller.get_method_name()[:-2]
+            method_path = entry.method.split(sep="\\")
+            method_name = method_path[-1]
+            if loaded_method != method_name:
+                method_dir = os.path.join(*method_path[:-1]) if len(method_path) > 1 else None
+                self.method_controller.switch(method_name=method_name,
+                                              alt_method_dir=method_dir)
+                curr_method_runtime = self.method_controller.get_post_time() + self.method_controller.get_stop_time()
+            total_runtime += curr_method_runtime
+
         timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
         self.send(Command.RUN_SEQUENCE_CMD.value)
+        self.timeout = total_runtime * 60
 
         if self.check_hplc_is_running():
             folder_name = f"{self.table_state.name} {timestamp}"
@@ -177,35 +200,82 @@ class SequenceController(TableController):
                                                      sequence_name=self.table_state.name))
 
             if stall_while_running:
-                run_completed = self.check_hplc_done_running(sequence=self.table_state)
+                run_completed = self.check_hplc_done_running()
                 if run_completed.is_ok():
-                    self.data_files[-1].dir = run_completed.value
+                    self.data_files[-1].dir = run_completed.ok_value
                 else:
                     raise RuntimeError("Run error has occurred.")
             else:
-                self.data_files[-1].dir = self.fuzzy_match_most_recent_folder(folder_name).ok_value
-
-    def retrieve_recent_data_files(self) -> str:
-        sequence_data_files: SequenceDataFiles = self.data_files[-1]
-        return sequence_data_files.dir
-
-    def get_data(self, custom_path: Optional[str] = None,
-                 read_uv: bool = False) -> list[AgilentChannelChromatogramData]:
-        parent_dir = self.data_files[-1].dir if not custom_path else custom_path
-
-        potential_folders = []
-        for d in self.data_dirs:
+                self.data_files[-1] = SequenceDataFiles(dir=folder_name,
+                                                        child_dirs=[],
+                                                        sequence_name=self.table_state.name)
+
+    @override
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: SequenceDataFiles) -> Result[SequenceDataFiles, str]:
+        if os.path.isdir(most_recent_folder.dir):
+            subdirs = [x[0] for x in os.walk(most_recent_folder.dir)]
+            potential_folders = sorted(list(filter(lambda d: most_recent_folder.dir in d, subdirs)))
+            most_recent_folder.child_dirs = [f for f in potential_folders if
+                                             most_recent_folder.dir in f and ".M" not in f and ".D" in f]
+            return Ok(most_recent_folder)
+
+        try:
+            potential_folders = []
+            for d in self.data_dirs:
+                subdirs = [x[0] for x in os.walk(d)]
+                potential_folders = sorted(list(filter(lambda d: most_recent_folder.dir in d, subdirs)))
+                if len(potential_folders) > 0:
+                    break
+            assert len(potential_folders) > 0
+            parent_dirs = []
+            for folder in potential_folders:
+                path = os.path.normpath(folder)
+                split_folder = path.split(os.sep)
+                if most_recent_folder.dir in split_folder[-1]:
+                    parent_dirs.append(folder)
+            parent_dir = sorted(parent_dirs, reverse=True)[0]
+
+            potential_folders = []
+            for d in self.data_dirs:
                 subdirs = [x[0] for x in os.walk(d)]
                 potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))
                 if len(potential_folders) > 0:
                     break
-        assert len(potential_folders) > 0
-        self.data_files[-1].child_dirs = [f for f in potential_folders if parent_dir in f and ".M" not in f and ".D" in f]
-        spectra: list[Union[AgilentChannelChromatogramData, ChromData]] = []
-        all_w_spectra: list[Union[AgilentChannelChromatogramData, ChromData]] = []
+            assert len(potential_folders) > 0
+            most_recent_folder.child_dirs = [f for f in potential_folders if
+                                             parent_dir in f and ".M" not in f and ".D" in f]
+            return Ok(most_recent_folder)
+        except Exception:
+            return Err("Failed to get sequence folder")
+
+    def get_data(self, custom_path: Optional[str] = None,
+                 read_uv: bool = False) -> List[AgilentChannelChromatogramData]:
+        if len(self.data_files[-1].child_dirs) == 0:
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(self.data_files[-1]).ok_value
+        spectra: list[AgilentChannelChromatogramData] = []
+        all_w_spectra: list[Dict[str, AgilentHPLCChromatogram]] = []
         for row in self.data_files[-1].child_dirs:
             self.get_spectrum(row, read_uv)
             spectra.append(AgilentChannelChromatogramData(**self.spectra))
             all_w_spectra.append(self.uv)
-
         return spectra if not read_uv else all_w_spectra
+
+    def get_report(self, custom_path: Optional[str] = None,
+                   report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
+        if custom_path:
+            self.data_files.append(
+                self.fuzzy_match_most_recent_folder(most_recent_folder=SequenceDataFiles(dir=custom_path,
+                                                                                         child_dirs=[],
+                                                                                         sequence_name="NA")).ok_value)
+        parent_dir = self.data_files[-1]
+        spectra = self.get_data(custom_path=custom_path)
+        reports = []
+        for i, child_dir in enumerate(parent_dir.child_dirs):
+            metd_report = self.get_report_details(child_dir, report_type)
+            child_spectra: List[AgilentHPLCChromatogram] = list(spectra[i].__dict__.values())
+            for j, signal in enumerate(metd_report.signals):
+                possible_data = child_spectra[j]
+                if len(possible_data.x) > 0:
+                    signal.data = possible_data
+            reports.append(metd_report)
+        return reports