pychemstation 0.10.5__py3-none-any.whl → 0.10.6__py3-none-any.whl

pychemstation/control/controllers/{tables → data_aq}/sequence.py

@@ -1,7 +1,7 @@
 import os
 import time
 import warnings
-from typing import Dict, List, Optional, Any
+from typing import Any, Dict, List, Optional, Union
 
 from result import Err, Ok, Result
 from typing_extensions import override
@@ -11,7 +11,6 @@ from pychemstation.analysis.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
-from . import MethodController
 
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers.comm import CommunicationController
@@ -25,10 +24,11 @@ from ....utils.sequence_types import (
 )
 from ....utils.table_types import RegisterFlag, T, Table
 from ....utils.tray_types import FiftyFourVialPlate, TenVialColumn, Tray
-from .table import TableController
+from ..abc_tables.run import RunController
+from . import MethodController
 
 
-class SequenceController(TableController):
+class SequenceController(RunController):
     """
     Class containing sequence related logic
     """
@@ -146,13 +146,12 @@ class SequenceController(TableController):
         if rows.is_ok():
             existing_row_num = rows.ok_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))
+            for i in range(int(existing_row_num)):
+                self.delete_row(int(existing_row_num - i))
+                self.send(Command.SAVE_SEQUENCE_CMD)
+            for i in range(int(wanted_row_num)):
+                self.add_row()
                 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):
@@ -175,55 +174,68 @@ class SequenceController(TableController):
                 self.send(Command.SAVE_SEQUENCE_CMD)
                 num_rows = self.get_num_rows()
         if row.vial_location:
-            loc = row.vial_location
-            loc_num = -1
-            if isinstance(loc, TenVialColumn):
-                loc_num = loc.value
-            elif isinstance(loc, FiftyFourVialPlate):
-                loc_num = loc.value()
-            self._edit_row_num(
-                row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
-            )
+            self.edit_vial_location(row.vial_location, row_num)
         if row.method:
-            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(method_dir, row.method)
-            self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
+            self.edit_method_name(row.method, row_num)
         if row.num_inj:
-            self._edit_row_num(
-                row=row_num, col_name=RegisterFlag.NUM_INJ, val=row.num_inj
-            )
+            self.edit_num_injections(row.num_inj, row_num)
         if row.inj_vol:
-            self._edit_row_text(
-                row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(row.inj_vol)
-            )
+            self.edit_injection_volume(row.inj_vol, row_num)
         if row.inj_source:
-            self._edit_row_text(
-                row=row_num, col_name=RegisterFlag.INJ_SOR, val=row.inj_source.value
-            )
+            self.edit_injection_source(row.inj_source, row_num)
         if row.sample_name:
-            self._edit_row_text(
-                row=row_num, col_name=RegisterFlag.NAME, val=row.sample_name
-            )
-            if row.data_file:
-                self._edit_row_text(
-                    row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.data_file
-                )
-            else:
-                self._edit_row_text(
-                    row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.sample_name
-                )
+            self.edit_sample_name(row.sample_name, row_num)
+        if row.data_file:
+            self.edit_data_file(row.data_file, row_num)
+        elif row.sample_name and not row.data_file:
+            self.edit_data_file(row.sample_name, row_num)
         if row.sample_type:
-            self._edit_row_num(
-                row=row_num,
-                col_name=RegisterFlag.SAMPLE_TYPE,
-                val=row.sample_type.value,
-            )
-
+            self.edit_sample_type(row.sample_type, row_num)
         self.send(Command.SAVE_SEQUENCE_CMD)
 
+    def edit_sample_type(self, sample_type: SampleType, row_num: int):
+        self._edit_row_num(
+            row=row_num,
+            col_name=RegisterFlag.SAMPLE_TYPE,
+            val=sample_type.value,
+        )
+
+    def edit_data_file(self, data_file: str, row_num: int):
+        self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=data_file)
+
+    def edit_sample_name(self, sample_name: str, row_num: int):
+        self._edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=sample_name)
+
+    def edit_injection_source(self, inj_source: InjectionSource, row_num: int):
+        self._edit_row_text(
+            row=row_num, col_name=RegisterFlag.INJ_SOR, val=inj_source.value
+        )
+
+    def edit_injection_volume(self, inj_vol: Union[int, float], row_num: int):
+        self._edit_row_text(
+            row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(inj_vol)
+        )
+
+    def edit_num_injections(self, num_inj: int, row_num: int):
+        self._edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=num_inj)
+
+    def edit_method_name(self, method: str, row_num: int):
+        method_dir = self.method_controller.src
+        possible_path = os.path.join(method_dir, method) + ".M\\"
+        if os.path.exists(possible_path):
+            method = os.path.join(method_dir, method)
+        self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
+
+    def edit_vial_location(self, loc: Tray, row_num: int):
+        loc_num = -1
+        if isinstance(loc, TenVialColumn):
+            loc_num = loc.value
+        elif isinstance(loc, FiftyFourVialPlate):
+            loc_num = loc.value()
+        self._edit_row_num(
+            row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
+        )
+
     def run(self, stall_while_running: bool = True):
         """
         Starts the currently loaded sequence, storing data
@@ -262,7 +274,14 @@ class SequenceController(TableController):
         self.send(Command.RUN_SEQUENCE_CMD.value)
         self.timeout = total_runtime * 60
 
-        if self.check_hplc_is_running():
+        tries = 10
+        hplc_running = False
+        for _ in range(tries):
+            hplc_running = self.check_hplc_is_running()
+            if hplc_running:
+                break
+
+        if hplc_running:
             folder_name = f"{self.table_state.name} {timestamp}"
             data_file = SequenceDataFiles(
                 dir=folder_name, sequence_name=self.table_state.name
@@ -276,7 +295,7 @@ class SequenceController(TableController):
                 else:
                     warnings.warn("Run may have not completed.")
         else:
-            raise RuntimeError("Sequence run did not start.")
+            raise RuntimeError("Sequence run may not have started.")
 
     @override
     def fuzzy_match_most_recent_folder(

pychemstation/control/controllers/devices/__init__.py

@@ -0,0 +1,3 @@
+from .injector import InjectorController
+
+__all__ = ["InjectorController"]

pychemstation/control/controllers/devices/injector.py

@@ -1,19 +1,21 @@
+from ..abc_tables.device import DeviceController
 from ....control.controllers import CommunicationController
 from ....utils.injector_types import (
     Draw,
     Inject,
-    InjectorFunction,
     InjectorTable,
     Mode,
     Remote,
     RemoteCommand,
     SourceType,
     Wait,
+    DrawDefault,
+    DrawDefaultVolume,
+    DrawDefaultLocation,
 )
 from ....utils.macro import Response
 from ....utils.table_types import RegisterFlag, Table
-from ....utils.tray_types import Tray
-from .device import DeviceController
+from ....utils.tray_types import Tray, FiftyFourVialPlate, TenVialColumn, LocationPlus
 
 
 class InjectorController(DeviceController):
@@ -22,14 +24,32 @@ class InjectorController(DeviceController):
     ):
         super().__init__(controller, table, offline)
 
-    def get_row(self, row: int) -> InjectorFunction:
-        def return_tray_loc() -> Tray:
-            raise NotImplementedError
-            # unit = self.get_text(row, RegisterFlag.DRAW_LOCATION_UNIT)
-            # tray = self.get_text(row, RegisterFlag.DRAW_LOCATION_TRAY)
-            # x = self.get_text(row, RegisterFlag.DRAW_LOCATION_ROW)
-            # y = self.get_text(row, RegisterFlag.DRAW_LOCATION_COLUMN)
-            # return FiftyFourVialPlate.from_str("P1-A1")
+    def try_vial_location(self, val: str) -> Tray:
+        try:
+            return FiftyFourVialPlate.from_str(val)
+        except Exception:
+            try:
+                return TenVialColumn(int(val))
+            except Exception:
+                raise ValueError("Location could not be identified.")
+
+    def get_row(
+        self, row: int
+    ) -> (
+        Draw
+        | DrawDefaultVolume
+        | Inject
+        | Wait
+        | DrawDefault
+        | DrawDefaultLocation
+        | Remote
+    ):
+        def return_location_plus() -> Tray:
+            unit = self.get_num(row, RegisterFlag.DRAW_LOCATION_UNIT)
+            tray = self.get_num(row, RegisterFlag.DRAW_LOCATION_TRAY)
+            row_ = self.get_num(row, RegisterFlag.DRAW_LOCATION_ROW)
+            col = self.get_num(row, RegisterFlag.DRAW_LOCATION_COLUMN)
+            return LocationPlus(int(unit), int(tray), int(row_), int(col))
 
         function = self.get_text(row, RegisterFlag.FUNCTION)
         if function == "Wait":
@@ -37,20 +57,32 @@ class InjectorController(DeviceController):
         elif function == "Inject":
             return Inject()
         elif function == "Draw":
-            # TODO: better error handling
             is_source = SourceType(self.get_text(row, RegisterFlag.DRAW_SOURCE))
             is_volume = Mode(self.get_text(row, RegisterFlag.DRAW_VOLUME))
-            vol = (
-                self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE)
-                if is_volume == Mode.SET
-                else None
-            )
-            if is_source is SourceType.SPECIFIC_LOCATION:
-                return Draw(amount=vol, source=return_tray_loc())
-            elif is_source is SourceType.LOCATION:
-                return Draw(
-                    amount=vol, location=self.get_text(row, RegisterFlag.DRAW_LOCATION)
-                )
+            if is_volume is not Mode.SET:
+                if is_source == SourceType.DEFAULT:
+                    return DrawDefault()
+                elif is_source is SourceType.SPECIFIC_LOCATION:
+                    return DrawDefaultVolume(location=return_location_plus())
+                elif is_source is SourceType.LOCATION:
+                    return DrawDefaultVolume(
+                        location=self.try_vial_location(
+                            self.get_text(row, RegisterFlag.DRAW_LOCATION)
+                        )
+                    )
+            else:
+                vol = self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE)
+                if is_source == SourceType.DEFAULT:
+                    return DrawDefaultLocation(amount=vol)
+                elif is_source is SourceType.SPECIFIC_LOCATION:
+                    return Draw(amount=vol, location=return_location_plus())
+                elif is_source is SourceType.LOCATION:
+                    return Draw(
+                        amount=vol,
+                        location=self.try_vial_location(
+                            self.get_text(row, RegisterFlag.DRAW_LOCATION)
+                        ),
+                    )
         elif function == "Remote":
             return Remote(
                 command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
@@ -65,7 +97,8 @@ class InjectorController(DeviceController):
             if isinstance(row_response, Response):
                 return InjectorTable(
                     functions=[
-                        self.get_row(i) for i in range(int(row_response.num_response))
+                        self.get_row(i + 1)
+                        for i in range(int(row_response.num_response))
                     ]
                 )
         elif rows.is_err():

pychemstation/control/hplc.py

@@ -13,9 +13,10 @@ from pychemstation.analysis.chromatogram import (
     AgilentHPLCChromatogram,
 )
 from .controllers.devices.injector import InjectorController
-from .controllers.tables.sequence import SequenceController, MethodController
+from .controllers.data_aq.sequence import SequenceController, MethodController
 from ..analysis.process_report import AgilentReport, ReportType
 from ..control.controllers import CommunicationController
+from ..utils.injector_types import InjectorTable
 from ..utils.macro import Command, Response, Status
 from ..utils.method_types import MethodDetails
 from ..utils.sequence_types import SequenceTable
@@ -278,6 +279,9 @@ class HPLCController:
         """Returns the currently loaded sequence."""
         return self.sequence_controller.load()
 
+    def load_injector_program(self) -> InjectorTable:
+        return self.method_controller.injector_controller.load()
+
     def standby(self):
         """Switches all modules in standby mode. All lamps and pumps are switched off."""
         self.send(Command.STANDBY_CMD)

pychemstation/utils/injector_types.py

@@ -19,10 +19,25 @@ class Mode(Enum):
 @dataclass
 class Draw:
     amount: Optional[float] = None
-    location: Optional[str] = None
+    location: Optional[Tray] = None
     source: Optional[Tray] = None
 
 
+@dataclass
+class DrawDefaultVolume:
+    location: Optional[Tray] = None
+
+
+@dataclass
+class DrawDefaultLocation:
+    amount: Optional[float] = None
+
+
+@dataclass
+class DrawDefault:
+    pass
+
+
 @dataclass
 class Wait:
     duration: Union[int, float]
@@ -35,6 +50,9 @@ class Inject:
 
 class RemoteCommand(Enum):
     START = "START"
+    NOT_READY = "NOT_READY"
+    STOP = "STOP"
+    READY = "READY"
     PREPARE = "PREPARE"
 
 
@@ -44,7 +62,9 @@ class Remote:
     duration: int
 
 
-InjectorFunction = Union[Draw, Wait, Inject, Remote]
+InjectorFunction = Union[
+    Draw, DrawDefault, DrawDefaultVolume, DrawDefaultLocation, Wait, Inject, Remote
+]
 
 
 @dataclass

pychemstation/utils/mocking/abc_comm.py

@@ -0,0 +1,160 @@
+"""
+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 abc
+import os
+import time
+from abc import abstractmethod
+from typing import Union
+
+from result import Err, Ok, Result
+
+from ...utils.macro import (
+    HPLCAvailStatus,
+    Command,
+    Status,
+    Response,
+)
+
+
+class ABCCommunicationController(abc.ABC):
+    """
+    Abstract class representing the communication controller.
+    """
+
+    # maximum command number
+    MAX_CMD_NO = 255
+
+    def __init__(
+        self,
+        comm_dir: str,
+        cmd_file: str = "cmd",
+        reply_file: str = "reply",
+        offline: bool = False,
+        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
+        """
+        if not offline:
+            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)
+                self.cmd_no = 0
+            else:
+                raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
+
+            # Create files for Chemstation to communicate with Python
+            open(self.cmd_file, "a").close()
+            open(self.reply_file, "a").close()
+
+            self.reset_cmd_counter()
+            self._most_recent_hplc_status: Status = self.get_status()
+            self.send("Local Rows")
+
+    @abstractmethod
+    def get_num_val(self, cmd: str) -> Union[int, float]:
+        pass
+
+    @abstractmethod
+    def get_text_val(self, cmd: str) -> str:
+        pass
+
+    @abstractmethod
+    def get_status(self) -> Status:
+        pass
+
+    @abstractmethod
+    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
+        pass
+
+    @abstractmethod
+    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
+        pass
+
+    def set_status(self):
+        """Updates current status of HPLC machine"""
+        self._most_recent_hplc_status = self.get_status()
+
+    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(5)
+        self.set_status()
+        hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
+        return hplc_avail and hplc_actually_avail
+
+    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)
+        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.
+
+        :return: ChemStation response
+        """
+        num_response_prefix = "Numerical Responses:"
+        str_response_prefix = "String Responses:"
+        possible_response = self._receive(self.cmd_no)
+        if possible_response.is_ok():
+            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("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/utils/mocking/mock_comm.py

@@ -0,0 +1,5 @@
+from pychemstation.utils.mocking.abc_comm import ABCCommunicationController
+
+
+class MockCommunicationController(ABCCommunicationController):
+    pass

pychemstation/utils/mocking/mock_hplc.py

@@ -0,0 +1,2 @@
+class MockHPLC:
+    pass

pychemstation/utils/sequence_types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os.path
 from enum import Enum
 from typing import Optional, List
 from dataclasses import dataclass, field
@@ -51,3 +52,21 @@ class SequenceEntry:
 class SequenceTable:
     name: str
     rows: list[SequenceEntry]
+
+    def __eq__(self, other):
+        equal = False
+        if not isinstance(other, SequenceTable):
+            return False
+
+        for self_row, other_row in zip(self.rows, other.rows):
+            equal |= self_row.vial_location == other_row.vial_location
+            equal |= self_row.data_file == other_row.data_file
+            equal |= (
+                os.path.split(os.path.normpath(self_row.method))[-1]
+                == os.path.split(os.path.normpath(other_row.method))[-1]
+            )
+            equal |= self_row.num_inj == other_row.num_inj
+            equal |= self_row.inj_vol == other_row.inj_vol
+            equal |= self_row.inj_source == other_row.inj_source
+            equal |= self_row.sample_name == other_row.sample_name
+            equal |= self_row.sample_type == other_row.sample_type

pychemstation/utils/table_types.py

@@ -43,6 +43,12 @@ class RegisterFlag(Enum):
     FLOW = "Flow"
     MAX_TIME = "StopTime_Time"
     POST_TIME = "PostTime_Time"  # TODO: check
+    SIGNAL_A = "Signal_Wavelength"
+    SIGNAL_B = "Signal2_Wavelength"
+    SIGNAL_C = "Signal3_Wavelength"
+    SIGNAL_D = "Signal4_Wavelength"
+    SIGNAL_E = "Signal5_Wavelength"
+    SIGNAL_A_USED = "Signal1_IsUsed"
     COLUMN_OVEN_TEMP1 = "TemperatureControl_Temperature"
     COLUMN_OVEN_TEMP2 = "TemperatureControl2_Temperature"
     STOPTIME_MODE = "StopTime_Mode"

pychemstation/utils/tray_types.py

@@ -71,6 +71,22 @@ class Letter(Enum):
         else:
             raise ValueError("Letter must be one of A to F")
 
+    @classmethod
+    def from_int(cls, num: int) -> Letter:
+        letter_mapping = {
+            "A": Letter.A,
+            "B": Letter.B,
+            "C": Letter.C,
+            "D": Letter.D,
+            "E": Letter.E,
+            "F": Letter.F,
+        }
+
+        if num <= len(letter_mapping):
+            return list(letter_mapping.values())[num]
+        else:
+            raise ValueError("Letter must be one of A to F")
+
 
 @dataclass
 class FiftyFourVialPlate:
@@ -91,6 +107,17 @@ class FiftyFourVialPlate:
     def value(self) -> int:
         return self.plate.value + self.letter.value + self.num.value
 
+    @classmethod
+    def from_tray_row_col(cls, tray: int, row: int, col: int):
+        try:
+            return FiftyFourVialPlate(
+                plate=Plate.from_num(tray),
+                letter=Letter.from_int(row),
+                num=Num.from_num(col),
+            )
+        except Exception:
+            raise ValueError("Could not parse tray location.")
+
     @classmethod
     def from_str(cls, loc: str):
         """
@@ -190,4 +217,12 @@ class TenVialColumn(Enum):
     TEN = 10
 
 
-Tray = Union[FiftyFourVialPlate, TenVialColumn]
+@dataclass
+class LocationPlus:
+    unit: int
+    tray: int
+    row: int
+    col: int
+
+
+Tray = Union[FiftyFourVialPlate, TenVialColumn, LocationPlus]

{pychemstation-0.10.5.dist-info → pychemstation-0.10.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.5
+Version: 0.10.6
 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