pychemstation 0.8.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

pychemstation/analysis/__init__.py

@@ -1 +1,5 @@
 from .base_spectrum import AbstractSpectrum
+
+__all__ = [
+    'AbstractSpectrum',
+]

pychemstation/analysis/base_spectrum.py

@@ -6,12 +6,12 @@ from abc import ABC, abstractmethod
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy import (
-    sparse,
-    signal,
     integrate,
+    signal,
+    sparse,
 )
 
-from .utils import interpolate_to_index, find_nearest_value_index
+from ..utils.num_utils import find_nearest_value_index, interpolate_to_index
 
 
 class AbstractSpectrum(ABC):
@@ -197,10 +197,10 @@ class AbstractSpectrum(ABC):
             return (self.x.copy()[full_mask], self.y.copy()[full_mask])
 
     def show_spectrum(
-        self,
-        filename=None,
-        title=None,
-        label=None,
+            self,
+            filename=None,
+            title=None,
+            label=None,
     ):
         """Plots the spectral data using matplotlib.pyplot module.
 
@@ -385,12 +385,12 @@ class AbstractSpectrum(ABC):
 
         if rule == "trapz":
             return integrate.trapz(
-                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
+                self.y[left_idx: right_idx + 1], self.x[left_idx: right_idx + 1]
             )
 
         elif rule == "simps":
             return integrate.simps(
-                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
+                self.y[left_idx: right_idx + 1], self.x[left_idx: right_idx + 1]
             )
 
         else:

pychemstation/analysis/process_report.py

@@ -4,15 +4,21 @@ import re
 from abc import abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, AnyStr, Dict, Optional, Pattern
+from typing import AnyStr, Dict, List, Optional, Pattern
 
 import pandas as pd
-from aghplctools.ingestion.text import _no_peaks_re, _area_report_re, _header_block_re, _signal_info_re, \
-    _signal_table_re, chunk_string
-from result import Result, Err, Ok
+from aghplctools.ingestion.text import (
+    _area_report_re,
+    _header_block_re,
+    _no_peaks_re,
+    _signal_info_re,
+    _signal_table_re,
+    chunk_string,
+)
+from result import Err, Ok, Result
 
 from pychemstation.utils.chromatogram import AgilentHPLCChromatogram
-from pychemstation.utils.tray_types import Tray, FiftyFourVialPlate
+from pychemstation.utils.tray_types import FiftyFourVialPlate, Tray
 
 
 @dataclass
@@ -70,7 +76,7 @@ class CSVProcessor(ReportProcessor):
         :returns: subset of complete report details, specifically the sample location, solvents in pumps,
          and list of peaks at each wavelength channel.
         """
-        labels = os.path.join(self.path, f'REPORT00.CSV')
+        labels = os.path.join(self.path, 'REPORT00.CSV')
         if os.path.exists(labels):
             df_labels: Dict[int, Dict[int: AnyStr]] = pd.read_csv(labels, encoding="utf-16", header=None).to_dict()
             vial_location = []
@@ -200,7 +206,7 @@ class TXTProcessor(ReportProcessor):
         should be able to use the `parse_area_report` method of aghplctools v4.8.8
         """
         if re.search(_no_peaks_re, report_text):  # There are no peaks in Report.txt
-            raise ValueError(f'No peaks found in Report.txt')
+            raise ValueError('No peaks found in Report.txt')
         blocks = _header_block_re.split(report_text)
         signals = {}  # output dictionary
         for ind, block in enumerate(blocks):

pychemstation/analysis/utils.py

@@ -1,9 +1,7 @@
-from typing import Tuple
-
 import numpy as np
 
 
-def find_nearest_value_index(array, value) -> Tuple[float, int]:
+def find_nearest_value_index(array, value) -> tuple[float, int]:
     """Returns closest value and its index in a given array.
 
     :param array: An array to search in.

pychemstation/control/__init__.py

@@ -2,3 +2,7 @@
 .. include:: README.md
 """
 from .hplc import HPLCController
+
+__all__ = [
+    'HPLCController',
+]

pychemstation/control/comm.py

@@ -0,0 +1,206 @@
+"""
+Module to provide API for the communication with Agilent HPLC systems.
+
+HPLCController sends commands to Chemstation software via a command file.
+Answers are received via reply file. On the Chemstation side, a custom
+Macro monitors the command file, executes commands and writes to the reply file.
+Each command is given a number (cmd_no) to keep track of which commands have
+been processed.
+
+Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
+"""
+
+import os
+import time
+
+from result import Result, Ok, Err
+from ..utils.macro import *
+from ..utils.method_types import *
+
+
+class CommunicationController:
+    """
+    Class that communicates with Agilent using Macros
+    """
+
+    # maximum command number
+    MAX_CMD_NO = 255
+
+    def __init__(
+            self,
+            comm_dir: str,
+            cmd_file: str = "cmd",
+            reply_file: str = "reply",
+    ):
+        """
+        :param comm_dir:
+        :param cmd_file: Name of command file
+        :param reply_file: Name of reply file
+        """
+        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)
+            self.cmd_no = 0
+        else:
+            raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
+        self._most_recent_hplc_status = None
+
+        # Create files for Chemstation to communicate with Python
+        open(self.cmd_file, "a").close()
+        open(self.reply_file, "a").close()
+
+        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.")
+
+    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")
+
+    def get_status(self) -> Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]:
+        """Get device status(es).
+
+        :return: list of ChemStation's current status
+        """
+        self.send(Command.GET_STATUS_CMD)
+        time.sleep(1)
+
+        try:
+            parsed_response = self.receive().value.string_response
+            self._most_recent_hplc_status = str_to_status(parsed_response)
+            return self._most_recent_hplc_status
+        except IOError:
+            return HPLCErrorStatus.NORESPONSE
+        except IndexError:
+            return HPLCErrorStatus.MALFORMED
+
+    def set_status(self):
+        """Updates current status of HPLC machine"""
+        self._most_recent_hplc_status = self.get_status()
+
+    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()
+        hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
+        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.
+
+        :param cmd: string to be sent to HPLC
+        :param cmd_no: Command number
+        :param num_attempts: Number of attempts to send the command before raising exception.
+        :raises IOError: Could not write to command file.
+        """
+        err = None
+        for _ in range(num_attempts):
+            time.sleep(1)
+            try:
+                with open(self.cmd_file, "w", encoding="utf8") as cmd_file:
+                    cmd_file.write(f"{cmd_no} {cmd}")
+            except IOError as e:
+                err = e
+                continue
+            else:
+                return
+        else:
+            raise IOError(f"Failed to send command #{cmd_no}: {cmd}.") from err
+
+    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
+        """Low-level execution primitive. Recives a response from HPLC.
+
+        :param cmd_no: Command number
+        :param num_attempts: Number of retries to open reply file
+        :raises IOError: Could not read reply file.
+        :return: Potential ChemStation response
+        """
+        err = None
+        for _ in range(num_attempts):
+            time.sleep(1)
+
+            try:
+                with open(self.reply_file, "r", encoding="utf_16") as reply_file:
+                    response = reply_file.read()
+            except OSError as e:
+                err = e
+                continue
+
+            try:
+                first_line = response.splitlines()[0]
+                response_no = int(first_line.split()[0])
+            except IndexError as e:
+                err = e
+                continue
+
+            # check that response corresponds to sent command
+            if response_no == cmd_no:
+                return Ok(response)
+            else:
+                continue
+        else:
+            return Err(f"Failed to receive reply to command #{cmd_no} due to {err}.")
+
+    def sleepy_send(self, cmd: Union[Command, str]):
+        self.send("Sleep 0.1")
+        self.send(cmd)
+        self.send("Sleep 0.1")
+
+    def send(self, cmd: Union[Command, str]):
+        """Sends a command to Chemstation.
+
+        :param cmd: Command to be sent to HPLC
+        """
+        if self.cmd_no == self.MAX_CMD_NO:
+            self.reset_cmd_counter()
+
+        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.
+
+        :return: ChemStation response 
+        """
+        num_response_prefix = "Numerical Responses:"
+        str_response_prefix = "String Responses:"
+        possible_response = self._receive(self.cmd_no)
+        if Ok(possible_response):
+            lines = possible_response.value.splitlines()
+            for line in lines:
+                if str_response_prefix in line and num_response_prefix in line:
+                    string_responses_dirty, _, numerical_responses = line.partition(num_response_prefix)
+                    _, _, string_responses = string_responses_dirty.partition(str_response_prefix)
+                    return Ok(Response(string_response=string_responses.strip(),
+                                       num_response=float(numerical_responses.strip())))
+            return Err(f"Could not retrieve HPLC response")
+        else:
+            return Err(f"Could not establish response to HPLC: {possible_response}")
+
+    def reset_cmd_counter(self):
+        """Resets the command counter."""
+        self._send(Command.RESET_COUNTER_CMD.value, cmd_no=self.MAX_CMD_NO + 1)
+        self._receive(cmd_no=self.MAX_CMD_NO + 1)
+        self.cmd_no = 0
+
+    def stop_macro(self):
+        """Stops Macro execution. Connection will be lost."""
+        self.send(Command.STOP_MACRO_CMD)

pychemstation/control/controllers/__init__.py

@@ -5,3 +5,9 @@
 from .comm import CommunicationController
 from .tables.method import MethodController
 from .tables.sequence import SequenceController
+
+__all__ = [
+    'CommunicationController',
+    'MethodController',
+    'SequenceController'
+]

pychemstation/control/controllers/comm.py

@@ -11,11 +11,18 @@ Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
 import os
 import time
-from typing import Optional
+from typing import Optional, Union
 
-from result import Result, Ok, Err
+from result import Err, Ok, Result
 
-from ...utils.macro import *
+from ...utils.macro import (
+    str_to_status,
+    HPLCAvailStatus,
+    HPLCErrorStatus,
+    Command,
+    Status,
+    Response,
+)
 
 
 class CommunicationController:
@@ -193,14 +200,14 @@ class CommunicationController:
         str_response_prefix = "String Responses:"
         possible_response = self._receive(self.cmd_no)
         if possible_response.is_ok():
-            lines = possible_response.value.splitlines()
+            lines = possible_response.ok_value.splitlines()
             for line in lines:
                 if str_response_prefix in line and num_response_prefix in line:
                     string_responses_dirty, _, numerical_responses = line.partition(num_response_prefix)
                     _, _, string_responses = string_responses_dirty.partition(str_response_prefix)
                     return Ok(Response(string_response=string_responses.strip(),
                                        num_response=float(numerical_responses.strip())))
-            return Err(f"Could not retrieve HPLC response")
+            return Err("Could not retrieve HPLC response")
         else:
             return Err(f"Could not establish response to HPLC: {possible_response}")
 

pychemstation/control/controllers/devices/column.py

@@ -0,0 +1,12 @@
+from ....control.controllers import CommunicationController
+from .device import DeviceController
+from ....utils.table_types import Table
+
+
+class ColumnController(DeviceController):
+
+    def __init__(self, controller: CommunicationController, table: Table):
+        super().__init__(controller, table)
+
+    def get_row(self, row: int):
+        pass

pychemstation/control/controllers/devices/device.py

@@ -1,13 +1,13 @@
 import abc
-from typing import Union, List
+from typing import List, Union, Dict, Optional
 
 from result import Result
 
-from ....analysis.process_report import ReportType, AgilentReport
+from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
 from ....control.controllers.tables.table import TableController
-from ....utils.chromatogram import AgilentChannelChromatogramData
-from ....utils.table_types import Table, T
+from ....utils.chromatogram import AgilentChannelChromatogramData, AgilentHPLCChromatogram
+from ....utils.table_types import T, Table
 
 
 class DeviceController(TableController, abc.ABC):
@@ -26,11 +26,14 @@ class DeviceController(TableController, abc.ABC):
     def retrieve_recent_data_files(self):
         raise NotImplementedError
 
-    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
+
+    def get_data_uv(self) -> Union[List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]]:
+        raise NotImplementedError
+
+    def get_data(self, custom_path: Optional[str] = None) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        raise NotImplementedError

pychemstation/control/controllers/devices/injector.py

@@ -1,8 +1,19 @@
-from ....control.controllers import CommunicationController
+from __future__ import annotations
+
 from .device import DeviceController
-from ....utils.injector_types import *
-from ....utils.macro import Command
-from ....utils.table_types import Table, RegisterFlag
+from ....control.controllers import CommunicationController
+from ....utils.injector_types import (
+    Draw,
+    Inject,
+    InjectorTable,
+    Mode,
+    Remote,
+    RemoteCommand,
+    SourceType,
+    Wait,
+)
+from ....utils.table_types import RegisterFlag, Table
+from ....utils.tray_types import Tray
 
 
 class InjectorController(DeviceController):
@@ -10,7 +21,7 @@ class InjectorController(DeviceController):
     def __init__(self, controller: CommunicationController, table: Table, offline: bool):
         super().__init__(controller, table, offline)
 
-    def get_row(self, row: int) -> InjectorFunction:
+    def get_row(self, row: int) -> None | Remote | Draw | Wait | Inject:
         def return_tray_loc() -> Tray:
             pass
 
@@ -32,86 +43,9 @@ class InjectorController(DeviceController):
             return Remote(command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
                           duration=self.get_num(row, RegisterFlag.REMOTE_DUR))
 
-    def load(self) -> InjectorTable:
+    def load(self) -> InjectorTable | None:
         rows = self.get_num_rows()
         if rows.is_ok():
             return InjectorTable(functions=[self.get_row(i) for i in range(int(rows.ok_value.num_response))])
 
-    def edit(self, injector_table: InjectorTable):
-        columns_added = set()
-
-        def add_table_val(col_name: RegisterFlag, val: Union[str, int, float]):
-            nonlocal columns_added
-            if True:
-                if isinstance(val, str):
-                    self._edit_row_text(col_name=col_name, val=val)
-                else:
-                    self._edit_row_num(col_name=col_name, val=val)
-            else:
-                if isinstance(val, str):
-                    self.add_new_col_text(col_name=col_name, val=val)
-                else:
-                    self.add_new_col_num(col_name=col_name, val=val)
-                columns_added.add(col_name)
-
-        def add_inject(inject: Inject):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=inject.__class__.__name__)
-
-        def add_draw(draw: Draw):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=draw.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.DRAW_SPEED, val=SourceType.DEFAULT.value)
-            add_table_val(col_name=RegisterFlag.DRAW_OFFSET, val=SourceType.DEFAULT.value)
-
-            if draw.amount:
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.SET.value)
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME_VALUE, val=draw.amount)
-            else:
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.DEFAULT.value)
-
-            if draw.location:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.LOCATION.value)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION, val=draw.location)
-            elif draw.source:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.SPECIFIC_LOCATION.value)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_UNIT, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_TRAY, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_ROW, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_COLUMN, val=1)
-            else:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.DEFAULT.value)
-
-        def add_wait(wait: Wait):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=wait.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.TIME, val=wait.duration)
-
-        def add_remote(remote: Remote):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=remote.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.REMOTE, val=remote.command.value)
-            add_table_val(col_name=RegisterFlag.REMOTE_DUR, val=remote.duration)
-
-        self.send(Command.SAVE_METHOD_CMD)
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            existing_row_num = rows.value.num_response
-            for i, function in enumerate(injector_table.functions):
-                if (i+1) > existing_row_num:
-                    self.add_row()
-                if isinstance(function, Inject):
-                    add_inject(function)
-                elif isinstance(function, Draw):
-                    add_draw(function)
-                elif isinstance(function, Wait):
-                    add_wait(function)
-                elif isinstance(function, Remote):
-                    add_remote(function)
-                self.download()
-                self.send(Command.SAVE_METHOD_CMD)
-                self.send(Command.SWITCH_METHOD_CMD)
-                existing_row_num = self.get_num_rows().ok_value.num_response
-
-    def download(self):
-        self.send('Sleep 1')
-        self.sleepy_send("DownloadRCMethod WLS1")
-        self.send('Sleep 1')
-        self.sleepy_send("DownloadLWls 1")
-        self.send('Sleep 1')
+   

pychemstation/control/controllers/devices/pump.py

@@ -0,0 +1,43 @@
+from ....control.controllers import CommunicationController
+from .device import DeviceController
+from ....utils.pump_types import Pump
+from ....utils.table_types import Table
+
+
+class PumpController(DeviceController):
+
+    def __init__(self, controller: CommunicationController, table: Table):
+        super().__init__(controller, table)
+        self.A1 = Pump(in_use=True, solvent="A1")
+        self.B1 = Pump(in_use=True, solvent="B1")
+        self.A2 = Pump(in_use=False, solvent="A2")
+        self.B2 = Pump(in_use=False, solvent="B2")
+
+    def validate_pumps(self):
+        invalid_A_pump_usage = self.A1.in_use and self.A2.in_use
+        invalid_B_pump_usage = self.B1.in_use and self.B2.in_use
+        if invalid_A_pump_usage or invalid_B_pump_usage:
+            raise AttributeError
+
+    def switch_pump(self, num: int, pump: str):
+        if pump == "A":
+            if num == 1:
+                self.A1.in_use = True
+                self.A2.in_use = False
+            elif num == 2:
+                self.A1.in_use = False
+                self.A2.in_use = True
+        elif pump == "B":
+            if num == 1:
+                self.B1.in_use = True
+                self.B2.in_use = False
+            elif num == 2:
+                self.B1.in_use = False
+                self.B2.in_use = True
+        self.purge()
+
+    def purge(self):
+        pass
+
+    def get_row(self, row: int):
+        pass