pychemstation 0.10.10__tar.gz → 0.10.12__tar.gz

pychemstation-0.10.12/.git

@@ -0,0 +1 @@
+gitdir: /Users/lucyhao/Codes/hein-lab/pychemstation-worktree/pychemstation/.git/worktrees/v0.10.x

{pychemstation-0.10.10 → pychemstation-0.10.12}/.pre-commit-config.yaml

@@ -11,4 +11,10 @@ repos:
 - repo: https://github.com/pre-commit/mirrors-mypy
   rev: v1.15.0
   hooks:
-    - id: mypy
+    - id: mypy
+- repo: local
+  hooks:
+    - id: delete-debug-files
+      name: delete-debug-files
+      entry: bash -c 'find . -name "out.txt" -type f -delete'
+      language: system

{pychemstation-0.10.10 → pychemstation-0.10.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.10
+Version: 0.10.12
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Project-URL: Documentation, https://pychemstation-e5a086.gitlab.io/pychemstation.html
 Project-URL: Repository, https://gitlab.com/heingroup/device-api/pychemstation
@@ -23,7 +23,7 @@ Requires-Dist: scipy>=1.10.1
 Requires-Dist: xsdata>=24.9
 Description-Content-Type: text/markdown
 
-# Agilent HPLC Macro Control
+# pychemstation: A Python package for automated control of Chemstation using MACROs
 
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/pychemstation)
 

{pychemstation-0.10.10 → pychemstation-0.10.12}/README.md

@@ -1,4 +1,4 @@
-# Agilent HPLC Macro Control
+# pychemstation: A Python package for automated control of Chemstation using MACROs
 
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/pychemstation)
 

{pychemstation-0.10.10 → pychemstation-0.10.12}/pychemstation/control/controllers/comm.py

@@ -54,7 +54,7 @@ class CommunicationController(ABCCommunicationController):
         raise RuntimeError("Failed to get number.")
 
     def get_text_val(self, cmd: str) -> str:
-        tries = 10
+        tries = 5
         for _ in range(tries):
             self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
             res = self.receive()

{pychemstation-0.10.10 → pychemstation-0.10.12}/pychemstation/control/controllers/data_aq/method.py

@@ -5,12 +5,16 @@ import time
 import warnings
 from typing import Dict, List, Optional, Union, Tuple
 
-from result import Err, Ok, Result
+from result import Err, Result, Ok
 
-from pychemstation.analysis.chromatogram import (
+from ..devices.column import ColumnController
+from ..devices.dad import DADController
+from ..devices.pump import PumpController
+from ..devices.sample_info import SampleInfo
+from ....analysis.chromatogram import (
     TIME_FORMAT,
-    AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
+    AgilentChannelChromatogramData,
 )
 
 from ....analysis.process_report import AgilentReport, ReportType
@@ -20,12 +24,13 @@ from ....utils.macro import Command
 from ....utils.method_types import (
     HPLCMethodParams,
     MethodDetails,
+    TimeTableEntry,
     Param,
     PType,
-    TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, T, Table, TableOperation
+from ....utils.table_types import RegisterFlag, T, Table
 from ..devices.injector import InjectorController
+from ....utils.tray_types import Tray
 
 
 class MethodController(RunController):
@@ -38,9 +43,17 @@ class MethodController(RunController):
         data_dirs: Optional[List[str]],
         table: Table,
         offline: bool,
-        injector_controller: InjectorController,
+        injector: InjectorController,
+        pump: PumpController,
+        dad: DADController,
+        column: ColumnController,
+        sample_info: SampleInfo,
     ):
-        self.injector_controller = injector_controller
+        self.injector = injector
+        self.pump = pump
+        self.dad = dad
+        self.column = column
+        self.sample_info = sample_info
         self.data_files: List[str] = []
         super().__init__(
             controller=controller,
@@ -50,6 +63,9 @@ class MethodController(RunController):
             offline=offline,
         )
 
+    def get_sample_location(self) -> Tray:
+        return self.sample_info.get_location()
+
     def get_current_method_name(self) -> str:
         self.sleepy_send(Command.GET_METHOD_CMD)
         res = self.receive()
@@ -60,18 +76,8 @@ class MethodController(RunController):
     def get_method_params(self) -> HPLCMethodParams:
         if self.controller:
             return HPLCMethodParams(
-                organic_modifier=self.controller.get_num_val(
-                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                        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_locator.register,
-                        register_flag=RegisterFlag.FLOW,
-                    )
-                ),
+                organic_modifier=self.get_om(),
+                flow=self.get_flow(),
             )
         raise ValueError("Communication controller is offline!")
 
@@ -114,23 +120,20 @@ class MethodController(RunController):
         return entries
 
     def load(self) -> MethodDetails:
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            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.get_stop_time()
-            post_time = self.get_post_time()
-            self.table_state = MethodDetails(
-                name=method_name,
-                timetable=timetable_rows,
-                stop_time=stop_time,
-                post_time=post_time,
-                params=params,
-            )
-            return self.table_state
-        else:
-            raise RuntimeError(rows.err_value)
+        rows = self.get_row_count_safely()
+        method_name = self.get_method_name()
+        timetable_rows = self.get_timetable(rows)
+        params = self.get_method_params()
+        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,
+            post_time=post_time,
+            params=params,
+        )
+        return self.table_state
 
     def get_method_name(self):
         self.send(Command.GET_METHOD_CMD)
@@ -138,26 +141,6 @@ class MethodController(RunController):
         method_name = res.ok_value.string_response
         return method_name
 
-    def get_post_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.POST_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
-    def get_stop_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.MAX_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
     def get_total_runtime(self) -> Union[int, float]:
         """Returns total method runtime in minutes."""
         return self.get_post_time() + self.get_stop_time()
@@ -217,20 +200,14 @@ class MethodController(RunController):
         self.edit_method_timetable(updated_method.timetable)
 
         if save:
-            self.send(
-                Command.SAVE_METHOD_CMD.value.format(
-                    commit_msg=f"saved method at {str(time.time())}"
-                )
-            )
+            self.save_method()
 
-    def edit_initial_om(self, new_om: Union[int, float]):
-        self._validate_organic_modifier(new_om)
-        initial_organic_modifier: Param = Param(
-            val=new_om,
-            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-            ptype=PType.NUM,
+    def save_method(self):
+        self.send(
+            Command.SAVE_METHOD_CMD.value.format(
+                commit_msg=f"saved method at {str(time.time())}"
+            )
         )
-        self._update_param(initial_organic_modifier)
 
     def _validate_organic_modifier(self, new_om):
         if not (isinstance(new_om, int) or isinstance(new_om, float)):
@@ -240,13 +217,6 @@ class MethodController(RunController):
         if new_om > 100:
             raise ValueError("Organic modifer must be less than 100.")
 
-    def edit_flow(self, new_flow: Union[int, float]):
-        self._validate_flow(new_flow)
-        flow: Param = Param(
-            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
-        )
-        self._update_param(flow)
-
     def _validate_flow(self, new_flow):
         if not (isinstance(new_flow, int) or isinstance(new_flow, float)):
             raise ValueError("Flow must be int or float")
@@ -255,38 +225,12 @@ class MethodController(RunController):
         if new_flow >= 5.0:
             raise ValueError("Flow must be less than 5.0")
 
-    def edit_stop_time(self, new_stop_time: Union[int, float]):
-        self.validate_stop_time(new_stop_time)
-        stop_time: Param = Param(
-            val=new_stop_time,
-            chemstation_key=RegisterFlag.MAX_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(
-                val="Set", chemstation_key=RegisterFlag.STOPTIME_MODE, ptype=PType.STR
-            )
-        )
-        self._update_param(stop_time)
-
     def validate_stop_time(self, new_stop_time):
         if not (isinstance(new_stop_time, int) or isinstance(new_stop_time, float)):
             raise ValueError("Stop time must be int or float")
         if new_stop_time < 0:
             raise ValueError("Stop time must be positive")
 
-    def edit_post_time(self, new_post_time: Union[int, float]):
-        self.validate_post_time(new_post_time)
-        post_time: Param = Param(
-            val=new_post_time,
-            chemstation_key=RegisterFlag.POST_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(val="Set", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR)
-        )
-        self._update_param(post_time)
-
     def validate_post_time(self, new_post_time):
         if not (isinstance(new_post_time, int) or isinstance(new_post_time, float)):
             raise ValueError("Post time must be int or float")
@@ -301,59 +245,14 @@ class MethodController(RunController):
         new_post_time: Union[int, float] | None,
     ):
         self.delete_table()
-        self.edit_initial_om(new_initial_om)
+        self._validate_flow(new_flow)
+        self.validate_post_time(new_post_time)
+        self._validate_organic_modifier(new_initial_om)
+        self.validate_stop_time(new_stop_time)
         self.edit_flow(new_flow)
-        if new_stop_time:
-            self.edit_stop_time(new_stop_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.STOPTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-        if new_post_time:
-            self.edit_post_time(new_post_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.POSTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-
-    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)
-
-        :param method_param: a parameter to update for currently loaded method.
-        """
-        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:
-                self.sleepy_send(
-                    setting_command.value.format(
-                        register=register,
-                        register_flag=register_flag,
-                        val=method_param.val,
-                    )
-                )
-        else:
-            self.sleepy_send(
-                setting_command.value.format(
-                    register=register,
-                    register_flag=method_param.chemstation_key,
-                    val=method_param.val,
-                )
-            )
-        self.download()
+        self.edit_initial_om(new_initial_om)
+        self.edit_stop_time(new_stop_time)
+        self.edit_post_time(new_post_time)
 
     def download(self):
         self.sleepy_send("DownloadRCMethod PMP1")
@@ -443,62 +342,6 @@ class MethodController(RunController):
         self.download()
         return time_added, flow_added, om_added, function_added
 
-        # if first_row:
-        #     time_added = False
-        #     flow_row_method: Callable = (
-        #         self.add_new_col_text
-        #         if row.flow and not row.organic_modifer
-        #         else self._edit_row_text
-        #     )
-        #     if row.organic_modifer:
-        #         self.add_row()
-        #         self.add_new_col_text(
-        #             col_name=RegisterFlag.FUNCTION,
-        #             val=RegisterFlag.SOLVENT_COMPOSITION.value,
-        #         )
-        #         if not time_added:
-        #             time_added = True
-        #             self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
-        #         self.add_new_col_num(
-        #             col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
-        #             val=row.organic_modifer,
-        #         )
-        #     if row.flow:
-        #         self.add_row()
-        #         self.get_num_rows()
-        #         flow_row_method(
-        #             col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value
-        #         )
-        #         if not time_added:
-        #             time_added = True
-        #             self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
-        #         self.add_new_col_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
-        #         self._edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
-        #     self.download()
-        # else:
-        #     if row.organic_modifer:
-        #         self.add_row()
-        #         self.get_num_rows()
-        #         self._edit_row_text(
-        #             col_name=RegisterFlag.FUNCTION,
-        #             val=RegisterFlag.SOLVENT_COMPOSITION.value,
-        #         )
-        #         self._edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
-        #         self._edit_row_num(
-        #             col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
-        #             val=row.organic_modifer,
-        #         )
-        #         self.download()
-        #     if row.flow:
-        #         self.add_row()
-        #         self.get_num_rows()
-        #         self._edit_row_text(
-        #             col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value
-        #         )
-        #         self._edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
-        #         self._edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
-        #         self.download()
-
     def edit_method_timetable(self, timetable_rows: List[TimeTableEntry]):
         self.get_num_rows()
         self.delete_table()
@@ -508,8 +351,8 @@ class MethodController(RunController):
             res = self.get_num_rows()
 
         self.new_table()
-        num_rows = self.get_num_rows()
-        if num_rows.ok_value.num_response != 0:
+        num_rows = self.get_row_count_safely()
+        if num_rows != 0:
             raise ValueError("Should be zero rows!")
 
         time_added = False
@@ -644,3 +487,77 @@ class MethodController(RunController):
                     Row {i + 1} ({timetable[i].start_time}) has a smaller or equal starttime than row {i} ({start_time})"""
                 )
             self._validate_row(row)
+
+    def get_om(self):
+        return self._read_num_param(RegisterFlag.SOLVENT_B_COMPOSITION)
+
+    def get_flow(self):
+        return self._read_num_param(RegisterFlag.FLOW)
+
+    def get_post_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.POST_TIME)
+
+    def get_stop_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.MAX_TIME)
+
+    def edit_post_time(self, new_post_time: Optional[int | float]):
+        if new_post_time:
+            post_time: Param = Param(
+                val=new_post_time,
+                chemstation_key=RegisterFlag.POST_TIME,
+                ptype=PType.NUM,
+            )
+            self._update_param(
+                Param(
+                    val="Set",
+                    chemstation_key=RegisterFlag.POSTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+            self._update_param(post_time)
+        else:
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.POSTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+
+    def edit_stop_time(self, new_stop_time: Optional[int | float]):
+        if new_stop_time:
+            stop_time: Param = Param(
+                val=new_stop_time,
+                chemstation_key=RegisterFlag.MAX_TIME,
+                ptype=PType.NUM,
+            )
+            self._update_param(
+                Param(
+                    val="Set",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+            self._update_param(stop_time)
+        else:
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+
+    def edit_flow(self, new_flow: Union[int, float]):
+        flow: Param = Param(
+            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
+        )
+        self._update_param(flow)
+
+    def edit_initial_om(self, new_om: Union[int, float]):
+        initial_organic_modifier: Param = Param(
+            val=new_om,
+            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+            ptype=PType.NUM,
+        )
+        self._update_param(initial_organic_modifier)