pychemstation 0.5.3.dev1__tar.gz → 0.5.5__tar.gz

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.3.dev1
+Version: 0.5.5
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
-Home-page: https://gitlab.com/heingroup/pychemstation
+Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao
 Author-email: lhao03@student.ubc.ca
 Classifier: Programming Language :: Python :: 3
@@ -12,6 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: polling
 Requires-Dist: seabreeze
+Requires-Dist: xsdata
 
 # Agilent HPLC Macro Control
 
@@ -40,7 +41,7 @@ pip install pychemstation
    where you will put your
    MACRO file(s).
 3. Download the [
-   `hplc_talk.mac`](https://github.com/croningp/analyticallabware/blob/master/AnalyticalLabware/devices/Agilent/hplctalk.mac).
+   `hplc_talk.mac`](https://gitlab.com/heingroup/device-api/pychemstation/-/blob/main/tests/hplc_talk.mac).
     - On line 69, change the path name up to `\cmd` and `\reply`. For instance, you should have:
       `MonitorFile "[my path]\cmd", "[my path]\reply"`
     - and then add this file to the folder from the previous step.
@@ -77,13 +78,12 @@ hplc_controller = HPLCController(data_dir=DATA_DIR,
 hplc_controller.preprun()
 hplc_controller.switch_method(method_name=DEFAULT_METHOD)
 hplc_controller.run_method(experiment_name="Run 10")
-data_status_valid, chrom = hplc_controller.get_last_run_method_data()
+chrom = hplc_controller.get_last_run_method_data()
 
-if data_status_valid:
-    # afterwards, save, analyze or plot the data!
-    values = {"x": chrom.x, "y": chrom.y}
-    chromatogram_data = pd.DataFrame.from_dict(values)
-    chromatogram_data.to_csv("Run 10.csv", index=False) 
+# afterwards, save, analyze or plot the data!
+values = {"x": chrom.A.x, "y": chrom.A.y}
+chromatogram_data = pd.DataFrame.from_dict(values)
+chromatogram_data.to_csv("Run 10.csv", index=False) 
 ```
 
 ## Adding your own MACROs
@@ -102,3 +102,6 @@ Lucy Hao
 
 - Adapted from [**AnalyticalLabware**](https://github.com/croningp/analyticallabware), created by members in the Cronin
   Group. Copyright © Cronin Group, used under the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
+- Adapted from the [MACROS](https://github.com/Bourne-Group/HPLCMethodOptimisationGUI)
+  used in [**Operator-free HPLC automated method development guided by Bayesian optimization**](https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00062e),
+  created by members in the Bourne Group.  Copyright © Bourne Group, used under the [MIT](https://opensource.org/license/mit) license.

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/README.md

@@ -25,7 +25,7 @@ pip install pychemstation
    where you will put your
    MACRO file(s).
 3. Download the [
-   `hplc_talk.mac`](https://github.com/croningp/analyticallabware/blob/master/AnalyticalLabware/devices/Agilent/hplctalk.mac).
+   `hplc_talk.mac`](https://gitlab.com/heingroup/device-api/pychemstation/-/blob/main/tests/hplc_talk.mac).
     - On line 69, change the path name up to `\cmd` and `\reply`. For instance, you should have:
       `MonitorFile "[my path]\cmd", "[my path]\reply"`
     - and then add this file to the folder from the previous step.
@@ -62,13 +62,12 @@ hplc_controller = HPLCController(data_dir=DATA_DIR,
 hplc_controller.preprun()
 hplc_controller.switch_method(method_name=DEFAULT_METHOD)
 hplc_controller.run_method(experiment_name="Run 10")
-data_status_valid, chrom = hplc_controller.get_last_run_method_data()
+chrom = hplc_controller.get_last_run_method_data()
 
-if data_status_valid:
-    # afterwards, save, analyze or plot the data!
-    values = {"x": chrom.x, "y": chrom.y}
-    chromatogram_data = pd.DataFrame.from_dict(values)
-    chromatogram_data.to_csv("Run 10.csv", index=False) 
+# afterwards, save, analyze or plot the data!
+values = {"x": chrom.A.x, "y": chrom.A.y}
+chromatogram_data = pd.DataFrame.from_dict(values)
+chromatogram_data.to_csv("Run 10.csv", index=False) 
 ```
 
 ## Adding your own MACROs
@@ -86,4 +85,7 @@ our [GitLab](https://gitlab.com/heingroup/device-api/pychemstation)!
 Lucy Hao
 
 - Adapted from [**AnalyticalLabware**](https://github.com/croningp/analyticallabware), created by members in the Cronin
-  Group. Copyright © Cronin Group, used under the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
+  Group. Copyright © Cronin Group, used under the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
+- Adapted from the [MACROS](https://github.com/Bourne-Group/HPLCMethodOptimisationGUI)
+  used in [**Operator-free HPLC automated method development guided by Bayesian optimization**](https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00062e),
+  created by members in the Bourne Group.  Copyright © Bourne Group, used under the [MIT](https://opensource.org/license/mit) license.

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/pychemstation/control/__init__.py

@@ -1,5 +1,4 @@
 """
 .. include:: README.md
 """
-from .comm import CommunicationController
 from .hplc import HPLCController

{pychemstation-0.5.3.dev1/pychemstation/control/table → pychemstation-0.5.5/pychemstation/control/controllers}/__init__.py

@@ -1,3 +1,4 @@
 from .method import MethodController
 from .sequence import SequenceController
 from .table_controller import TableController
+from .comm import CommunicationController

{pychemstation-0.5.3.dev1/pychemstation/control → pychemstation-0.5.5/pychemstation/control/controllers}/comm.py

@@ -14,8 +14,8 @@ import os
 import time
 
 from result import Result, Ok, Err
-from ..utils.macro import *
-from ..utils.method_types import *
+
+from ...utils.macro import *
 
 
 class CommunicationController:
@@ -86,17 +86,18 @@ class CommunicationController:
 
     def set_status(self):
         """Updates current status of HPLC machine"""
-        self._most_recent_hplc_status = self.get_status()[0]
+        self._most_recent_hplc_status = self.get_status()
 
-    def check_if_running(self, data_path: str) -> bool:
+    def check_if_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()
-        file_exists = os.path.exists(data_path)
         hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        done_writing_data = hplc_avail and file_exists
-        return done_writing_data
+        time.sleep(30)
+        self.set_status()
+        hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
+        return hplc_avail and hplc_actually_avail
 
     def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
         """Low-level execution primitive. Sends a command string to HPLC.
@@ -170,6 +171,9 @@ 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()
 
     def receive(self) -> Result[Response, str]:
         """Returns messages received in reply file.

{pychemstation-0.5.3.dev1/pychemstation/control/table → pychemstation-0.5.5/pychemstation/control/controllers}/method.py

@@ -1,13 +1,13 @@
 import os
 import time
-from typing import Optional, Any
+from typing import Optional
 
 from xsdata.formats.dataclass.parsers import XmlParser
 
-from .. import CommunicationController
-from ...control.table.table_controller import TableController
+from ...control.controllers.table_controller import TableController
+from ...control.controllers.comm import CommunicationController
 from ...generated import PumpMethod, DadMethod, SolventElement
-from ...utils.chromatogram import TIME_FORMAT, AgilentHPLCChromatogram
+from ...utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
 from ...utils.macro import Command
 from ...utils.method_types import PType, TimeTableEntry, Param, MethodTimetable, HPLCMethodParams
 from ...utils.table_types import RegisterFlag, TableOperation, Table
@@ -269,6 +269,6 @@ class MethodController(TableController):
     def retrieve_recent_data_files(self) -> str:
         return self.data_files[-1]
 
-    def get_data(self) -> dict[str, AgilentHPLCChromatogram]:
+    def get_data(self) -> AgilentChannelChromatogramData:
         self.get_spectrum(self.data_files[-1])
-        return self.spectra
+        return AgilentChannelChromatogramData(**self.spectra)

{pychemstation-0.5.3.dev1/pychemstation/control/table → pychemstation-0.5.5/pychemstation/control/controllers}/sequence.py

@@ -1,17 +1,12 @@
-from typing import Any
-
-from copy import deepcopy
-
 import os
 import time
 
-from .table_controller import TableController
-from ...control import CommunicationController
-from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentHPLCChromatogram
+from ...control.controllers.table_controller import TableController
+from ...control.controllers.comm import CommunicationController
+from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogramData
 from ...utils.macro import Command
 from ...utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
 from ...utils.table_types import TableOperation, RegisterFlag, Table
-from ...utils.tray_types import TenColumn
 
 
 class SequenceController(TableController):
@@ -30,7 +25,7 @@ class SequenceController(TableController):
 
         if rows.is_ok() and seq_name.is_ok():
             return SequenceTable(
-                name=seq_name.ok_value.num_response,
+                name=seq_name.ok_value.string_response.partition(".S")[0],
                 rows=[self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))])
         raise RuntimeError(rows.err_value)
 
@@ -73,34 +68,25 @@ class SequenceController(TableController):
 
         :param sequence_table:
         """
-        self.send("Local Rows")
-        self.sleep(1)
-        self.delete_table()
-        self.sleep(1)
-        self.new_table()
-        self.sleep(1)
-        self.get_num_rows()
-
-        if True:
-            for _ in sequence_table.rows:
-                self.add_row()
-                self.sleep(1)
+
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            existing_row_num = rows.value.num_response
+            wanted_row_num = len(sequence_table.rows)
+            while existing_row_num != wanted_row_num:
+                if wanted_row_num > existing_row_num:
+                    self.add_row()
+                elif wanted_row_num < existing_row_num:
+                    self.delete_row(int(existing_row_num))
                 self.send(Command.SAVE_SEQUENCE_CMD)
-            self.get_num_rows()
-            self.send(Command.SAVE_SEQUENCE_CMD)
+                existing_row_num = self.get_num_rows().ok_value.num_response
+            self.send(Command.SWITCH_SEQUENCE_CMD)
+
             for i, row in enumerate(sequence_table.rows):
                 self.edit_row(row=row, row_num=i + 1)
                 self.sleep(1)
             self.send(Command.SAVE_SEQUENCE_CMD)
-        else:
-            for i, row in enumerate(sequence_table.rows):
-                self.add_row()
-                self.sleep(0.1)
-                self.edit_row(row=row, row_num=i + 1)
-                self.sleep(0.1)
-                rows = self.get_num_rows()
-                self.send(Command.SAVE_SEQUENCE_CMD)
-                self.send(Command.SWITCH_SEQUENCE_CMD)
+            self.send(Command.SWITCH_SEQUENCE_CMD)
 
     def edit_row(self, row: SequenceEntry, row_num: int):
         """
@@ -120,13 +106,16 @@ class SequenceController(TableController):
         table_name = self.table.name
 
         if row.vial_location:
+            loc = row.vial_location
+            if isinstance(row.vial_location, InjectionSource):
+                loc = row.vial_location.value
             self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
                                                                       table_name=table_name,
                                                                       row=row_num,
                                                                       col_name=RegisterFlag.VIAL_LOCATION,
-                                                                      val=row.vial_location.value))
+                                                                      val=loc))
         if row.method:
-            possible_path = os.path.join(self.method_dir, row.method)
+            possible_path = os.path.join(self.method_dir, row.method) + ".M\\"
             method = row.method
             if os.path.exists(possible_path):
                 method = os.path.join(self.method_dir, row.method)
@@ -177,23 +166,22 @@ class SequenceController(TableController):
 
         self.send(Command.SAVE_SEQUENCE_CMD)
 
-    def run(self, sequence_table: SequenceTable):
+    def run(self):
         """
         Starts the currently loaded sequence, storing data
         under the <data_dir>/<sequence table name> folder.
         Device must be ready.
-
-        :param sequence_table:
         """
         timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
+        seq_table = self.load()
         self.send(Command.RUN_SEQUENCE_CMD.value)
 
         if self.check_hplc_is_running():
-            folder_name = f"{sequence_table.name} {timestamp}"
+            folder_name = f"{seq_table.name} {timestamp}"
             self.data_files.append(SequenceDataFiles(dir=folder_name,
-                                                     sequence_name=sequence_table.name, ))
+                                                     sequence_name=seq_table.name))
 
-        run_completed = self.check_hplc_done_running()
+        run_completed = self.check_hplc_done_running(sequence=seq_table)
 
         if run_completed.is_ok():
             self.data_files[-1].dir = run_completed.value
@@ -202,16 +190,22 @@ class SequenceController(TableController):
 
     def retrieve_recent_data_files(self):
         sequence_data_files: SequenceDataFiles = self.data_files[-1]
-        return os.path.join(sequence_data_files.dir, sequence_data_files.child_dirs[-1])
+        return sequence_data_files.dir
 
-    def get_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
-        sequence_data_files: SequenceDataFiles = self.data_files[-1]
+    def get_data(self) -> list[AgilentChannelChromatogramData]:
+        parent_dir = self.data_files[-1].dir
         subdirs = [x[0] for x in os.walk(self.data_dir)]
-        potential_folders = sorted(list(filter(lambda d: sequence_data_files.dir in d, subdirs)))
-        self.data_files[-1].child_dirs = potential_folders
-        spectra: list[dict[str, AgilentHPLCChromatogram]] = []
-        for row in sequence_data_files.child_dirs:
-            data_path = os.path.join(sequence_data_files.dir, row)
-            self.get_spectrum(data_path)
-            spectra.append(deepcopy(self.spectra))
+        potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))
+        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[AgilentChannelChromatogramData] = []
+        for row in self.data_files[-1].child_dirs:
+            self.get_spectrum(row)
+            spectra.append(
+                AgilentChannelChromatogramData(
+                    A=self.spectra["A"],
+                    B=self.spectra["B"],
+                    C=self.spectra["C"],
+                    D=self.spectra["D"]))
         return spectra

{pychemstation-0.5.3.dev1/pychemstation/control/table → pychemstation-0.5.5/pychemstation/control/controllers}/table_controller.py

@@ -6,16 +6,17 @@ Authors: Lucy Hao
 
 import abc
 import os
+import time
 from typing import Union, Optional
 
 import polling
 from result import Result, Ok, Err
 
-from ...control import CommunicationController
-from ...utils.chromatogram import AgilentHPLCChromatogram
+from ...control.controllers.comm import CommunicationController
+from ...utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 from ...utils.macro import Command, HPLCRunningStatus, Response
 from ...utils.method_types import MethodTimetable
-from ...utils.sequence_types import SequenceDataFiles
+from ...utils.sequence_types import SequenceDataFiles, SequenceTable
 from ...utils.table_types import Table, TableOperation, RegisterFlag
 
 
@@ -82,6 +83,11 @@ class TableController(abc.ABC):
     def get_row(self, row: int):
         pass
 
+    def delete_row(self, row: int):
+        self.sleepy_send(TableOperation.DELETE_ROW.value.format(register=self.table.register,
+                                                                table_name=self.table.name,
+                                                                row=row))
+
     def add_row(self):
         """
         Adds a row to the provided table for currently loaded method or sequence.
@@ -124,7 +130,7 @@ class TableController(abc.ABC):
         res = self.controller.receive()
 
         if res.is_ok():
-            self.send("Sleep 1")
+            self.send("Sleep 0.1")
             self.send('Print Rows')
             return res
         else:
@@ -137,24 +143,42 @@ class TableController(abc.ABC):
             max_tries=10)
         return started_running
 
-    def check_hplc_done_running(self, method: Optional[MethodTimetable] = None) -> Result[str, str]:
+    def check_hplc_done_running(self,
+                                method: Optional[MethodTimetable] = None,
+                                sequence: Optional[SequenceTable] = None) -> Result[str, str]:
         """
         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
         :return: Return True if data can be read back, else False.
         """
-        timeout = 10 * 60 if method is None else (method.first_row.maximum_run_time + 2) * 60
+        timeout = 10 * 60
+        if method:
+            timeout = ((method.first_row.maximum_run_time + 2) * 60)
+        if sequence:
+            timeout *= len(sequence.rows)
+
         most_recent_folder = self.retrieve_recent_data_files()
         finished_run = polling.poll(
-            lambda: self.controller.check_if_running(most_recent_folder),
+            lambda: self.controller.check_if_running(),
             timeout=timeout,
-            step=30
+            step=60
         )
+
         if finished_run:
-            subdirs = [x[0] for x in os.walk(self.data_dir)]
-            potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
-            return Ok(potential_folders[0])
+            if os.path.exists(most_recent_folder):
+                return Ok(most_recent_folder)
+            else:
+                subdirs = [x[0] for x in os.walk(self.data_dir)]
+                potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
+                parent_dirs = []
+                for folder in potential_folders:
+                    path = os.path.normpath(folder)
+                    split_folder = path.split(os.sep)
+                    if most_recent_folder in split_folder[-1]:
+                        parent_dirs.append(folder)
+                parent_dir = sorted(parent_dirs, reverse=True)[0]
+                return Ok(parent_dir)
         else:
             return Err("Run did not complete as expected")
 
@@ -163,7 +187,7 @@ class TableController(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def get_data(self) -> tuple[bool,]:
+    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
         pass
 
     def get_spectrum(self, data_file: str):

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/pychemstation/control/hplc.py

@@ -6,9 +6,8 @@ Authors: Lucy Hao
 
 from typing import Union, Optional
 
-from ..control import CommunicationController
-from ..control.table import MethodController, SequenceController
-from ..utils.chromatogram import AgilentHPLCChromatogram
+from ..control.controllers import MethodController, SequenceController, CommunicationController
+from ..utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
 from ..utils.method_types import MethodTimetable
 from ..utils.sequence_types import SequenceTable, SequenceEntry
@@ -65,8 +64,8 @@ class HPLCController:
         only 'General-Poroshell' is needed.
 
         :param method_name: any available method in Chemstation method directory
-        :raise IndexError: Response did not have expected format. Try again.
-        :raise AssertionError: The desired method is not selected. Try again.
+        :raises  IndexError: Response did not have expected format. Try again.
+        :raises  AssertionError: The desired method is not selected. Try again.
         """
         self.method_controller.switch(method_name)
 
@@ -91,15 +90,15 @@ class HPLCController:
         """
         self.method_controller.run(experiment_name)
 
-    def run_sequence(self, sequence_table: SequenceTable):
+    def run_sequence(self):
         """
         Starts the currently loaded sequence, storing data
         under the <data_dir>/<sequence table name> folder.
         Device must be ready.
 
-        :param sequence_table:
+        :param sequence_name:
         """
-        self.sequence_controller.run(sequence_table)
+        self.sequence_controller.run()
 
     def edit_method(self, updated_method: MethodTimetable, save: bool = False):
         """Updated the currently loaded method in ChemStation with provided values.
@@ -114,7 +113,7 @@ class HPLCController:
         Updates the currently loaded sequence table with the provided table. This method will delete the existing sequence table and remake it.
         If you would only like to edit a single row of a sequence table, use `edit_sequence_row` instead.
 
-        :param sequence_table:
+        :param updated_sequence:
         """
         self.sequence_controller.edit(updated_sequence)
 
@@ -127,13 +126,13 @@ class HPLCController:
         """
         self.sequence_controller.edit_row(row, num)
 
-    def get_last_run_method_data(self) -> dict[str, AgilentHPLCChromatogram]:
+    def get_last_run_method_data(self) -> AgilentChannelChromatogramData:
         """
         Returns the last run method data.
         """
         return self.method_controller.get_data()
 
-    def get_last_run_sequence_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
+    def get_last_run_sequence_data(self) -> list[AgilentChannelChromatogramData]:
         """
         Returns data for all rows in the last run sequence data.
         """

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/pychemstation/utils/chromatogram.py

@@ -1,17 +1,14 @@
 """Module for HPLC chromatogram data loading and manipulating"""
 
 import os
-import logging
 import time
+from dataclasses import dataclass
 
 import numpy as np
 
 from .parsing import CHFile
 from ..analysis import AbstractSpectrum
 
-# Chemstation data path
-DATA_DIR = r"C:\Chem32\1\Data"
-
 # standard filenames for spectral data
 CHANNELS = {"A": "01", "B": "02", "C": "03", "D": "04"}
 
@@ -105,26 +102,10 @@ class AgilentHPLCChromatogram(AbstractSpectrum):
             np.savez_compressed(npz_file, times=data.times, values=data.values)
             return np.array(data.times), np.array(data.values)
 
-    def extract_peakarea(self, experiment_dir: str):
-        """
-        Reads processed data from Chemstation report files.
 
-        Args:
-            experiment_dir: .D directory with the report files
-        """
-        # filename = os.path.join(experiment_dir, f"REPORT{CHANNELS[channel]}.csv")
-        # TODO parse file properly
-        # data = np.genfromtxt(filename, delimiter=',')
-        # return data
-        pass
-
-    def default_processing(self):
-        """
-        Processes the chromatogram in place.
-        """
-        # trim first 5 min and last 3 min of run
-        self.trim(5, 25)
-        # parameters found to work best for chromatogram data
-        self.correct_baseline(lmbd=1e5, p=0.0001, n_iter=10)
-        # get all peaks in processed chromatogram
-        self.find_peaks()
+@dataclass
+class AgilentChannelChromatogramData:
+    A: AgilentHPLCChromatogram
+    B: AgilentHPLCChromatogram
+    C: AgilentHPLCChromatogram
+    D: AgilentHPLCChromatogram

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/pychemstation/utils/table_types.py

@@ -9,6 +9,7 @@ class TableOperation(Enum):
     DELETE_TABLE = 'DelTab {register}, "{table_name}"'
     CREATE_TABLE = 'NewTab {register}, "{table_name}"'
     NEW_ROW = 'InsTabRow {register}, "{table_name}"'
+    DELETE_ROW = 'DelTabRow {register}, "{table_name}", {row}'
     EDIT_ROW_VAL = 'SetTabVal "{register}", "{table_name}", {row}, "{col_name}", {val}'
     EDIT_ROW_TEXT = 'SetTabText "{register}", "{table_name}", {row}, "{col_name}", "{val}"'
     GET_ROW_VAL = 'TabVal("{register}", "{table_name}", {row}, "{col_name}")'

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/pychemstation.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.3.dev1
+Version: 0.5.5
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
-Home-page: https://gitlab.com/heingroup/pychemstation
+Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao
 Author-email: lhao03@student.ubc.ca
 Classifier: Programming Language :: Python :: 3
@@ -12,6 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: polling
 Requires-Dist: seabreeze
+Requires-Dist: xsdata
 
 # Agilent HPLC Macro Control
 
@@ -40,7 +41,7 @@ pip install pychemstation
    where you will put your
    MACRO file(s).
 3. Download the [
-   `hplc_talk.mac`](https://github.com/croningp/analyticallabware/blob/master/AnalyticalLabware/devices/Agilent/hplctalk.mac).
+   `hplc_talk.mac`](https://gitlab.com/heingroup/device-api/pychemstation/-/blob/main/tests/hplc_talk.mac).
     - On line 69, change the path name up to `\cmd` and `\reply`. For instance, you should have:
       `MonitorFile "[my path]\cmd", "[my path]\reply"`
     - and then add this file to the folder from the previous step.
@@ -77,13 +78,12 @@ hplc_controller = HPLCController(data_dir=DATA_DIR,
 hplc_controller.preprun()
 hplc_controller.switch_method(method_name=DEFAULT_METHOD)
 hplc_controller.run_method(experiment_name="Run 10")
-data_status_valid, chrom = hplc_controller.get_last_run_method_data()
+chrom = hplc_controller.get_last_run_method_data()
 
-if data_status_valid:
-    # afterwards, save, analyze or plot the data!
-    values = {"x": chrom.x, "y": chrom.y}
-    chromatogram_data = pd.DataFrame.from_dict(values)
-    chromatogram_data.to_csv("Run 10.csv", index=False) 
+# afterwards, save, analyze or plot the data!
+values = {"x": chrom.A.x, "y": chrom.A.y}
+chromatogram_data = pd.DataFrame.from_dict(values)
+chromatogram_data.to_csv("Run 10.csv", index=False) 
 ```
 
 ## Adding your own MACROs
@@ -102,3 +102,6 @@ Lucy Hao
 
 - Adapted from [**AnalyticalLabware**](https://github.com/croningp/analyticallabware), created by members in the Cronin
   Group. Copyright © Cronin Group, used under the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
+- Adapted from the [MACROS](https://github.com/Bourne-Group/HPLCMethodOptimisationGUI)
+  used in [**Operator-free HPLC automated method development guided by Bayesian optimization**](https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00062e),
+  created by members in the Bourne Group.  Copyright © Bourne Group, used under the [MIT](https://opensource.org/license/mit) license.

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/pychemstation.egg-info/SOURCES.txt

@@ -13,12 +13,12 @@ pychemstation/analysis/base_spectrum.py
 pychemstation/analysis/spec_utils.py
 pychemstation/analysis/utils.py
 pychemstation/control/__init__.py
-pychemstation/control/comm.py
 pychemstation/control/hplc.py
-pychemstation/control/table/__init__.py
-pychemstation/control/table/method.py
-pychemstation/control/table/sequence.py
-pychemstation/control/table/table_controller.py
+pychemstation/control/controllers/__init__.py
+pychemstation/control/controllers/comm.py
+pychemstation/control/controllers/method.py
+pychemstation/control/controllers/sequence.py
+pychemstation/control/controllers/table_controller.py
 pychemstation/generated/__init__.py
 pychemstation/generated/dad_method.py
 pychemstation/generated/pump_method.py

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/pychemstation.egg-info/requires.txt

@@ -1,2 +1,3 @@
 polling
 seabreeze
+xsdata

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/setup.py

@@ -5,21 +5,22 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="pychemstation",
-    version="0.5.3.dev1",
+    version="0.5.5",
     author="Lucy Hao",
     author_email="lhao03@student.ubc.ca",
     description="Library to interact with Chemstation software, primarily used in Hein lab",
     long_description=long_description,
     long_description_content_type="text/markdown",
-    url="https://gitlab.com/heingroup/pychemstation",
+    url="https://gitlab.com/heingroup/device-api/pychemstation",
     packages=setuptools.find_packages(),
     install_requires=[
-          'polling',
-          'seabreeze'
+        'polling',
+        'seabreeze',
+        'xsdata'
     ],
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
     ],
-)
+)

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/tests/constants.py

@@ -4,7 +4,7 @@ from pychemstation.utils.method_types import *
 from pychemstation.utils.sequence_types import *
 
 DEFAULT_METHOD = "GENERAL-POROSHELL-OPT"
-DEFAULT_SEQUENCE = "hplc_testing"
+DEFAULT_SEQUENCE = "LLETest"
 
 # CONSTANTS: paths only work in Hein group HPLC machine in room 242
 DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
@@ -20,8 +20,8 @@ HEIN_LAB_CONSTANTS = [DEFAULT_COMMAND_PATH,
 # 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"
-SEQUENCE_DIR_254 = "C:\\1\\Sequence"
+DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\2024-12\\"
+SEQUENCE_DIR_254 = "C:\\1\\Sequence\\"
 
 HEIN_LAB_CONSTANTS_254 = [DEFAULT_COMMAND_PATH_254,
                           DEFAULT_METHOD_DIR_254,
@@ -42,7 +42,7 @@ def gen_rand_method():
     return MethodTimetable(
         first_row=HPLCMethodParams(
             organic_modifier=org_modifier,
-            flow=random.random(),
+            flow=round(random.random(), 2),
             maximum_run_time=max_run_time),
         subsequent_rows=[
             TimeTableEntry(

pychemstation-0.5.5/tests/test_comb.py

@@ -0,0 +1,143 @@
+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(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_run_method_after_update(self):
+        try:
+            self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+            rand_method = MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=5,
+                    flow=0.65,
+                    maximum_run_time=2),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=0.10,
+                        organic_modifer=5,
+                        flow=0.34),
+                    TimeTableEntry(
+                        start_time=1,
+                        organic_modifer=98,
+                        flow=0.55)])
+            self.hplc_controller.edit_method(rand_method, save=True)
+            if run_too:
+                self.hplc_controller.run_method(experiment_name="changed_method")
+        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=TenColumn.ONE,
+                method=DEFAULT_METHOD,
+                num_inj=3,
+                inj_vol=4,
+                sample_name="Sampel1",
+                sample_type=SampleType.SAMPLE,
+            ))
+            seq_table.rows[0] = SequenceEntry(
+                vial_location=TenColumn.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 = MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=5,
+                    flow=0.65,
+                    maximum_run_time=2),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=0.50,
+                        organic_modifer=99,
+                        flow=0.34)])
+            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) == 2)
+        except Exception:
+            self.fail("Failed")

{pychemstation-0.5.3.dev1 → pychemstation-0.5.5}/tests/test_sequence.py

@@ -63,6 +63,54 @@ class TestSequence(unittest.TestCase):
                         sample_name="Sampel2",
                         sample_type=SampleType.SAMPLE,
                         inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=TenColumn.TEN,
+                        method=DEFAULT_METHOD,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=TenColumn.THREE,
+                        method=DEFAULT_METHOD,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    )
+                ]
+            )
+            self.hplc_controller.edit_sequence(seq_table)
+        except Exception:
+            self.fail("Should have not occured")
+
+    def test_edit_entire_table_less_rows(self):
+        self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+        try:
+            seq_table = SequenceTable(
+                name=DEFAULT_SEQUENCE,
+                rows=[
+                    SequenceEntry(
+                        vial_location=TenColumn.TEN,
+                        method=DEFAULT_METHOD,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
+                    ),
+                    SequenceEntry(
+                        vial_location=TenColumn.THREE,
+                        method=DEFAULT_METHOD,
+                        num_inj=3,
+                        inj_vol=4,
+                        sample_name="Sampel2",
+                        sample_type=SampleType.SAMPLE,
+                        inj_source=InjectionSource.HIP_ALS
                     )
                 ]
             )

pychemstation-0.5.3.dev1/tests/test_comb.py

@@ -1,129 +0,0 @@
-import os
-
-import unittest
-
-from pychemstation.control import HPLCController
-from tests.constants import *
-
-run_too = False
-
-
-
-
-class TestCombinations(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_run_method_after_update(self):
-        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-
-        try:
-            rand_method = gen_rand_method()
-            self.hplc_controller.edit_method(rand_method)
-            if run_too:
-                self.hplc_controller.run_method(experiment_name="changed_method")
-        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[0].vial_location = TenColumn.FIVE
-            seq_table.rows[1].vial_location = TenColumn.ONE
-            seq_table.rows[0].inj_source = InjectionSource.HIP_ALS
-            seq_table.rows[1].inj_source = InjectionSource.MANUAL
-            self.hplc_controller.edit_sequence(seq_table)
-            if run_too:
-                self.hplc_controller.run_sequence(seq_table)
-                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(seq_table)
-                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 = gen_rand_method()
-            self.hplc_controller.edit_method(rand_method, save=True)
-
-            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
-            seq_table = self.hplc_controller.load_sequence()
-            seq_table.rows[0].vial_location = TenColumn.ONE
-            seq_table.rows[0].inj_source = InjectionSource.HIP_ALS
-            seq_table.rows[1].vial_location = TenColumn.TWO
-            seq_table.rows[1].inj_source = InjectionSource.HIP_ALS
-            self.hplc_controller.edit_sequence(seq_table)
-
-            if run_too:
-                self.hplc_controller.run_sequence(seq_table)
-                chrom = self.hplc_controller.get_last_run_sequence_data()
-                self.assertTrue(len(chrom) == 2)
-        except Exception:
-            self.fail("Failed")
-
-    def test_update_table_then_row(self):
-        try:
-            self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
-            rand_method = gen_rand_method()
-            self.hplc_controller.edit_method(rand_method, save=True)
-
-            seq_table = self.hplc_controller.load_sequence()
-            seq_table.rows[0].vial_location = TenColumn.ONE
-            seq_table.rows[0].inj_source = InjectionSource.HIP_ALS
-            seq_table.rows[0].method = DEFAULT_METHOD
-            seq_table.rows[1].vial_location = TenColumn.TWO
-            seq_table.rows[1].inj_source = InjectionSource.HIP_ALS
-            seq_table.rows[1].method = DEFAULT_METHOD
-
-            self.hplc_controller.edit_sequence(seq_table)
-            self.hplc_controller.edit_sequence_row(
-                SequenceEntry(
-                    vial_location=TenColumn.ONE,
-                    method=DEFAULT_METHOD,
-                    num_inj=3,
-                    inj_vol=4,
-                    sample_name="Blank",
-                    sample_type=SampleType.BLANK,
-                )
-            )
-            if run_too:
-                self.hplc_controller.run_sequence(seq_table)
-                chrom = self.hplc_controller.get_last_run_sequence_data()
-                self.assertTrue(len(chrom) == 2)
-        except Exception:
-            self.fail("Failed")
-
-    def test_run_after_new_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, 3)
-            if run_too:
-                self.hplc_controller.run_sequence(seq_table)
-                chrom = self.hplc_controller.get_last_run_sequence_data()
-                self.assertTrue(len(chrom) == 2)
-        except Exception:
-            self.fail("Failed")