pychemstation 0.10.11__py3-none-any.whl → 0.10.12__py3-none-any.whl

pychemstation/control/controllers/devices/pump.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import warnings
+
+from ....utils.macro import Command
+from ....control.controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
+from ....utils.device_types import (
+    SolventBottle,
+    MaybeBottle,
+    MaybePumpPosition,
+    PumpValve,
+    PumpPosition,
+)
+from ....utils.table_types import Table, RegisterFlag, Device
+
+
+class PumpController(DeviceController):
+    def __init__(
+        self, controller: CommunicationController, table: Table | Device, offline: bool
+    ):
+        super().__init__(controller, table, offline)
+        self.A_position: MaybePumpPosition = (
+            self.load_pump_position(PumpValve.A) if not offline else None
+        )
+        self.B_position: MaybePumpPosition = (
+            self.load_pump_position(PumpValve.B) if not offline else None
+        )
+        self.A1: MaybeBottle = None
+        self.A2: MaybeBottle = None
+        self.B1: MaybeBottle = None
+        self.B2: MaybeBottle = None
+        self.waste_bottle: MaybeBottle = None
+
+    def load_pump_position(self, pump_valve: PumpValve) -> PumpPosition:
+        match pump_valve:
+            case PumpValve.A:
+                return PumpPosition.from_str(
+                    self._read_str_param(RegisterFlag.PUMPCHANNEL_SELECTION)
+                )
+            case PumpValve.B:
+                return PumpPosition.from_str(
+                    self._read_str_param(RegisterFlag.PUMPCHANNEL2_SELECTION)
+                )
+            case _:
+                raise ValueError("Expected one of PumpValve.A or PumpValve.B")
+
+    def load_bottles(self):
+        self.A1 = self.get_solvent_bottle_a1()
+        self.A2 = self.get_solvent_bottle_a2()
+        self.B1 = self.get_solvent_bottle_b1()
+        self.B2 = self.get_solvent_bottle_b2()
+
+    @property
+    def rinse_method(self):
+        return self._rinse_method
+
+    @rinse_method.setter
+    def rinse_method(self, new_rinse_method: str):
+        self._rinse_method = new_rinse_method
+
+    def turn_off(self):
+        self.send(Command.PUMP_OFF_CMD)
+
+    def turn_on(self):
+        self.send(Command.PUMP_ON_CMD)
+
+    def get_solvent_bottle_a1(self) -> SolventBottle:
+        return SolventBottle(
+            absolute_filled=self._read_num_param(
+                RegisterFlag.BOTTLE_A1_ABSOLUTE_FILLING
+            ),
+            percent_filled=self._read_num_param(RegisterFlag.BOTTLE_A1_PERCENT_FILLING),
+            max_volume=self._read_num_param(RegisterFlag.BOTTLE_A1_MAX),
+            in_use=self.A_position == PumpPosition.ONE,
+            user_name=self._read_str_param(RegisterFlag.BOTTLE_A1_USER_NAME),
+            type=PumpValve.A,
+        )
+
+    def get_solvent_bottle_a2(self) -> SolventBottle:
+        return SolventBottle(
+            absolute_filled=self._read_num_param(
+                RegisterFlag.BOTTLE_A2_ABSOLUTE_FILLING
+            ),
+            percent_filled=self._read_num_param(RegisterFlag.BOTTLE_A2_PERCENT_FILLING),
+            max_volume=self._read_num_param(RegisterFlag.BOTTLE_A2_MAX),
+            in_use=self.A_position == PumpPosition.TWO,
+            user_name=self._read_str_param(RegisterFlag.BOTTLE_A2_USER_NAME),
+            type=PumpValve.A,
+        )
+
+    def get_solvent_bottle_b1(self) -> SolventBottle:
+        return SolventBottle(
+            absolute_filled=self._read_num_param(
+                RegisterFlag.BOTTLE_B1_ABSOLUTE_FILLING
+            ),
+            percent_filled=self._read_num_param(RegisterFlag.BOTTLE_B1_PERCENT_FILLING),
+            max_volume=self._read_num_param(RegisterFlag.BOTTLE_B1_MAX),
+            in_use=self.A_position == PumpPosition.ONE,
+            user_name=self._read_str_param(RegisterFlag.BOTTLE_B1_USER_NAME),
+            type=PumpValve.B,
+        )
+
+    def get_solvent_bottle_b2(self) -> SolventBottle:
+        return SolventBottle(
+            absolute_filled=self._read_num_param(
+                RegisterFlag.BOTTLE_B2_ABSOLUTE_FILLING
+            ),
+            percent_filled=self._read_num_param(RegisterFlag.BOTTLE_B2_PERCENT_FILLING),
+            max_volume=self._read_num_param(RegisterFlag.BOTTLE_B2_MAX),
+            in_use=self.A_position == PumpPosition.TWO,
+            user_name=self._read_str_param(RegisterFlag.BOTTLE_B2_USER_NAME),
+            type=PumpValve.B,
+        )
+
+    def get_waste_bottle_stats(self):
+        max_vol = None
+        try:
+            max_vol = self._read_num_param(RegisterFlag.WASTE_BOTTLE_MAX)
+        except RuntimeError:
+            warnings.warn(
+                "No maximum volume available! All other SolventBottle parameters may not be reliable."
+            )
+        self.waste_bottle = SolventBottle(
+            absolute_filled=self._read_num_param(RegisterFlag.WASTE_BOTTLE_PERCENT),
+            percent_filled=self._read_num_param(RegisterFlag.WASTE_BOTTLE_ABSOLUTE),
+            max_volume=max_vol,
+            in_use=True,
+            user_name="Waste Bottle",
+            type=None,
+        )

pychemstation/control/controllers/devices/sample_info.py

@@ -0,0 +1,27 @@
+from ....control.controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
+from ....utils.table_types import Table, Device, RegisterFlag
+from ....utils.tray_types import Tray, VialBar, FiftyFourVialPlate
+
+
+class SampleInfo(DeviceController):
+    def turn_off(self):
+        raise NotImplementedError
+
+    def turn_on(self):
+        raise NotImplementedError
+
+    def __init__(
+        self, controller: CommunicationController, table: Table | Device, offline: bool
+    ):
+        super().__init__(controller, table, offline)
+
+    def get_location(self) -> Tray:
+        location = self._read_str_param(RegisterFlag.VIAL_NUMBER)
+        try:
+            return FiftyFourVialPlate.from_int(location)
+        except ValueError:
+            try:
+                return VialBar(location)
+            except ValueError:
+                raise ValueError("Could not read vial location.")

pychemstation/control/hplc.py

@@ -9,19 +9,20 @@ from __future__ import annotations
 import os.path
 from typing import Dict, List, Optional, Tuple, Union
 
-from pychemstation.analysis.chromatogram import AgilentChannelChromatogramData
-from pychemstation.analysis.chromatogram import (
-    AgilentHPLCChromatogram,
-)
+from .controllers.devices.column import ColumnController
+from .controllers.devices.dad import DADController
 from .controllers.devices.injector import InjectorController
 from .controllers.data_aq.sequence import SequenceController, MethodController
+from .controllers.devices.pump import PumpController
+from .controllers.devices.sample_info import SampleInfo
+from ..analysis import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 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, SequenceDataFiles
-from ..utils.table_types import Table
+from ..utils.table_types import Table, Device
 
 
 class HPLCController:
@@ -32,7 +33,15 @@ class HPLCController:
 
     INJECTOR_TABLE = Table(register="RCWLS1Pretreatment[1]", name="InstructionTable")
 
-    MSD_TABLE = Table(register="MSACQINFO[1]", name="SprayChamber")
+    PUMP_DEVICE = Device(register="RCPMP1Status")
+
+    INJECTOR_DEVICE = Device(register="RCWLS1Method")
+
+    SAMPLE_INFO = Table(register="_CONFIG", name="SampleInfo")
+
+    COLUMN_TEMP_DEVICE = Device(register="RCTHM1Method")
+
+    DAD_DEVICE = Device(register="RCDAD1Method")
 
     def __init__(
         self,
@@ -68,9 +77,21 @@ class HPLCController:
                 data_dirs=data_dirs,
                 table=self.METHOD_TIMETABLE,
                 offline=offline,
-                injector_controller=InjectorController(
+                injector=InjectorController(
                     controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
                 ),
+                pump=PumpController(
+                    controller=self.comm, table=self.PUMP_DEVICE, offline=offline
+                ),
+                dad=DADController(
+                    controller=self.comm, table=self.DAD_DEVICE, offline=offline
+                ),
+                column=ColumnController(
+                    controller=self.comm, table=self.COLUMN_TEMP_DEVICE, offline=offline
+                ),
+                sample_info=SampleInfo(
+                    controller=self.comm, table=self.SAMPLE_INFO, offline=offline
+                ),
             )
             self.sequence_controller: SequenceController = SequenceController(
                 controller=self.comm,
@@ -304,7 +325,10 @@ class HPLCController:
         return self.sequence_controller.load()
 
     def load_injector_program(self) -> InjectorTable | None:
-        return self.method_controller.injector_controller.load()
+        return self.method_controller.injector.load()
+
+    def load_sample_location(self):
+        self.method_controller.get_location()
 
     def standby(self):
         """Switches all modules in standby mode. All lamps and pumps are switched off."""
@@ -316,19 +340,19 @@ class HPLCController:
 
     def lamp_on(self):
         """Turns the UV lamp on."""
-        self.send(Command.LAMP_ON_CMD)
+        self.method_controller.dad.turn_on()
 
     def lamp_off(self):
         """Turns the UV lamp off."""
-        self.send(Command.LAMP_OFF_CMD)
+        self.method_controller.dad.turn_off()
 
     def pump_on(self):
         """Turns on the pump on."""
-        self.send(Command.PUMP_ON_CMD)
+        self.method_controller.pump.turn_on()
 
     def pump_off(self):
         """Turns the pump off."""
-        self.send(Command.PUMP_OFF_CMD)
+        self.method_controller.pump.turn_off()
 
     def instrument_off(self):
         """Shuts the entire instrument off, including pumps, lamps, thermostat."""

pychemstation/utils/abc_tables/device.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from abc import ABC
+from abc import ABC, abstractmethod
 
 from .table import ABCTableController
-from ..table_types import Table
+from ..table_types import Table, Device
 from ...control.controllers import CommunicationController
 
 
@@ -15,8 +15,11 @@ class DeviceController(ABCTableController, ABC):
     :param offline: whether the communication controller is online.
     """
 
+    def get_row(self, row: int):
+        raise NotImplementedError
+
     def __init__(
-        self, controller: CommunicationController, table: Table, offline: bool
+        self, controller: CommunicationController, table: Table | Device, offline: bool
     ):
         super().__init__(controller=controller, table=table)
         self.offline = offline
@@ -25,3 +28,14 @@ class DeviceController(ABCTableController, ABC):
         if cls is ABCTableController:
             raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
         return object.__new__(cls)
+
+    def download(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def turn_off(self):
+        pass
+
+    @abstractmethod
+    def turn_on(self):
+        pass

pychemstation/utils/abc_tables/table.py

@@ -7,14 +7,16 @@ Authors: Lucy Hao
 from __future__ import annotations
 
 import abc
+from abc import abstractmethod
+from collections.abc import Callable
 from typing import Optional, Union
 
 from result import Err, Result
 
 from ..macro import Command, Response
-from ..method_types import MethodDetails
+from ..method_types import MethodDetails, PType, Param
 from ..sequence_types import SequenceTable
-from ..table_types import Table, RegisterFlag, TableOperation
+from ..table_types import Table, RegisterFlag, TableOperation, Device
 from ...control.controllers import CommunicationController
 
 TableType = Union[MethodDetails, SequenceTable]
@@ -29,7 +31,7 @@ class ABCTableController(abc.ABC):
     def __init__(
         self,
         controller: Optional[CommunicationController],
-        table: Table,
+        table: Table | Device,
     ):
         self.controller = controller
         self.table_locator = table
@@ -40,6 +42,14 @@ class ABCTableController(abc.ABC):
             raise TypeError(f"only children of '{cls.__name__}' may be instantiated")
         return object.__new__(cls, *args, **kwargs)
 
+    @abstractmethod
+    def download(self):
+        pass
+
+    @abc.abstractmethod
+    def get_row(self, row: int):
+        pass
+
     def receive(self) -> Result[Response, str]:
         if self.controller:
             for _ in range(10):
@@ -72,7 +82,7 @@ class ABCTableController(abc.ABC):
         self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
 
     def get_num(self, row: int, col_name: RegisterFlag) -> Union[int, float]:
-        if self.controller:
+        if isinstance(self.table_locator, Table) and self.controller:
             return self.controller.get_num_val(
                 TableOperation.GET_ROW_VAL.value.format(
                     register=self.table_locator.register,
@@ -85,7 +95,7 @@ class ABCTableController(abc.ABC):
             raise ValueError("Controller is offline")
 
     def get_text(self, row: int, col_name: RegisterFlag) -> str:
-        if self.controller:
+        if isinstance(self.table_locator, Table) and self.controller:
             return self.controller.get_text_val(
                 TableOperation.GET_ROW_TEXT.value.format(
                     register=self.table_locator.register,
@@ -100,26 +110,32 @@ class ABCTableController(abc.ABC):
     def add_new_col_num(self, col_name: RegisterFlag, val: Union[int, float]):
         if not (isinstance(val, int) or isinstance(val, float)):
             raise ValueError(f"{val} must be an int or float.")
-        self.sleepy_send(
-            TableOperation.NEW_COL_VAL.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                col_name=col_name,
-                val=val,
+        if isinstance(self.table_locator, Table) and self.controller:
+            self.sleepy_send(
+                TableOperation.NEW_COL_VAL.value.format(
+                    register=self.table_locator.register,
+                    table_name=self.table_locator.name,
+                    col_name=col_name,
+                    val=val,
+                )
             )
-        )
+        else:
+            raise ValueError("require table, not device")
 
     def add_new_col_text(self, col_name: RegisterFlag, val: str):
         if not isinstance(val, str):
             raise ValueError(f"{val} must be a str.")
-        self.sleepy_send(
-            TableOperation.NEW_COL_TEXT.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                col_name=col_name,
-                val=val,
+        if isinstance(self.table_locator, Table) and self.controller:
+            self.sleepy_send(
+                TableOperation.NEW_COL_TEXT.value.format(
+                    register=self.table_locator.register,
+                    table_name=self.table_locator.name,
+                    col_name=col_name,
+                    val=val,
+                )
             )
-        )
+        else:
+            raise ValueError("require table not device")
 
     def _edit_row_num(
         self, col_name: RegisterFlag, val: Union[int, float], row: Optional[int] = None
@@ -130,15 +146,16 @@ class ABCTableController(abc.ABC):
         if row and num_rows < row:
             raise ValueError("Not enough rows to edit!")
 
-        self.sleepy_send(
-            TableOperation.EDIT_ROW_VAL.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                row=row if row is not None else "response_num",
-                col_name=col_name,
-                val=val,
+        if isinstance(self.table_locator, Table) and self.controller:
+            self.sleepy_send(
+                TableOperation.EDIT_ROW_VAL.value.format(
+                    register=self.table_locator.register,
+                    table_name=self.table_locator.name,
+                    row=row if row is not None else "response_num",
+                    col_name=col_name,
+                    val=val,
+                )
             )
-        )
 
     def _edit_row_text(
         self, col_name: RegisterFlag, val: str, row: Optional[int] = None
@@ -149,28 +166,28 @@ class ABCTableController(abc.ABC):
         if row and num_rows < row:
             raise ValueError("Not enough rows to edit!")
 
-        self.sleepy_send(
-            TableOperation.EDIT_ROW_TEXT.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                row=row if row is not None else "response_num",
-                col_name=col_name,
-                val=val,
+        if isinstance(self.table_locator, Table) and self.controller:
+            self.sleepy_send(
+                TableOperation.EDIT_ROW_TEXT.value.format(
+                    register=self.table_locator.register,
+                    table_name=self.table_locator.name,
+                    row=row if row is not None else "response_num",
+                    col_name=col_name,
+                    val=val,
+                )
             )
-        )
-
-    @abc.abstractmethod
-    def get_row(self, row: int):
-        pass
 
     def delete_row(self, row: int):
-        self.sleepy_send(
-            TableOperation.DELETE_ROW.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                row=row,
+        if isinstance(self.table_locator, Table) and self.controller:
+            self.sleepy_send(
+                TableOperation.DELETE_ROW.value.format(
+                    register=self.table_locator.register,
+                    table_name=self.table_locator.name,
+                    row=row,
+                )
             )
-        )
+        else:
+            raise ValueError("controller is offline or given device, need table")
 
     def get_row_count_safely(self) -> int:
         row_count = self.get_num_rows()
@@ -213,29 +230,95 @@ class ABCTableController(abc.ABC):
         )
 
     def get_num_rows(self) -> Result[Response, str]:
-        self.send(
-            Command.GET_ROWS_CMD.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                col_name=RegisterFlag.NUM_ROWS,
+        if isinstance(self.table_locator, Table) and self.controller:
+            self.send(
+                Command.GET_ROWS_CMD.value.format(
+                    register=self.table_locator.register,
+                    table_name=self.table_locator.name,
+                    col_name=RegisterFlag.NUM_ROWS,
+                )
             )
-        )
-        if self.controller:
             res = self.controller.receive()
+            if res.is_ok():
+                return res
+            else:
+                return Err("No rows could be read.")
         else:
-            raise ValueError("Controller is offline")
+            raise ValueError(
+                "controller was offline or was given a device and not a table"
+            )
 
-        if res.is_ok():
-            return res
+    def move_row(self, from_row: int, to_row: int):
+        if isinstance(self.table_locator, Table) and self.controller:
+            self.send(
+                TableOperation.MOVE_ROW.value.format(
+                    register=self.table_locator.register,
+                    table_name=self.table_locator.name,
+                    from_row=from_row,
+                    to_row=to_row,
+                )
+            )
         else:
-            return Err("No rows could be read.")
+            raise ValueError("controller is offline or given device, need table")
 
-    def move_row(self, from_row: int, to_row: int):
-        self.send(
-            TableOperation.MOVE_ROW.value.format(
-                register=self.table_locator.register,
-                table_name=self.table_locator.name,
-                from_row=from_row,
-                to_row=to_row,
+    def _read_str_param(self, register_flag: RegisterFlag):
+        if self.controller:
+            try:
+                return self.controller.get_text_val(
+                    cmd=TableOperation.GET_OBJ_HDR_TEXT.value.format(
+                        register=self.table_locator.register,
+                        register_flag=register_flag,
+                    )
+                )
+            except RuntimeError:
+                return self.controller.get_text_val(
+                    cmd=TableOperation.GET_OBJ_HDR_TEXT.value.format(
+                        register=self.table_locator.register + "[2]",
+                        register_flag=register_flag,
+                    )
+                )
+        raise ValueError("Communication controller is not online!")
+
+    def _read_num_param(self, register_flag: RegisterFlag):
+        if self.controller:
+            return self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=register_flag,
+                )
             )
+        raise ValueError("Communication controller is not online!")
+
+    def _update_param(
+        self, param: Param, register_num: Optional[int] = None, sleep: bool = True
+    ):
+        register = self.table_locator.register
+        setting_command = (
+            TableOperation.UPDATE_OBJ_HDR_VAL
+            if param.ptype == PType.NUM
+            else TableOperation.UPDATE_OBJ_HDR_TEXT
         )
+        send_method: Callable = self.sleepy_send if sleep else self.send
+        if isinstance(param.chemstation_key, list):
+            for register_flag in param.chemstation_key:
+                send_method(
+                    setting_command.value.format(
+                        register=f"{register}[{str(register_num)}]"
+                        if register_num
+                        else register,
+                        register_flag=register_flag,
+                        val=param.val,
+                    )
+                )
+        else:
+            register_flag = param.chemstation_key
+            send_method(
+                setting_command.value.format(
+                    register=f"{register}[{str(register_num)}]"
+                    if register_num
+                    else register,
+                    register_flag=register_flag,
+                    val=param.val,
+                )
+            )
+        self.download()

pychemstation/utils/device_types.py

@@ -1,7 +1,73 @@
 from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
 
 
 @dataclass
+class DADChannels:
+    A: int
+    A_ON: bool
+    B: int
+    B_ON: bool
+    C: int
+    C_ON: bool
+    D: int
+    D_ON: bool
+    E: int
+    E_ON: bool
+
+
+class DADChannel(Enum):
+    A = "A"
+    B = "B"
+    C = "C"
+    D = "D"
+    E = "E"
+
+
+class PumpPosition(Enum):
+    ONE = 1
+    TWO = 2
+
+    @classmethod
+    def from_str(cls, pos):
+        match pos:
+            case "Position1":
+                return PumpPosition.ONE
+            case "Position2":
+                return PumpPosition.TWO
+            case _:
+                raise ValueError("Expected one of Position 1 or Position 2")
+
+    def to_str(self):
+        match self:
+            case PumpPosition.ONE:
+                return "Position1"
+            case PumpPosition.TWO:
+                return "Position2"
+            case _:
+                raise ValueError("Enum is one of ONE or TWO")
+
+
+class PumpValve(Enum):
+    A = "A"
+    B = "B"
+
+
+@dataclass
+class SolventBottle:
+    absolute_filled: float
+    percent_filled: float
+    type: Optional[PumpValve]
+    in_use: bool
+    user_name: str
+    max_volume: Optional[float]
+
+
+MaybeBottle = Optional[SolventBottle]
+MaybePumpPosition = Optional[PumpPosition]
+
+
 class SignalRead:
     on: bool
     wavelength: int

pychemstation/utils/macro.py

@@ -33,6 +33,8 @@ class Command(Enum):
     LAMP_OFF_CMD = "LampAll OFF"
     PUMP_ON_CMD = "PumpAll ON"
     PUMP_OFF_CMD = "PumpAll OFF"
+    COLUMN_ON_CMD = "ColumnAll ON"
+    COLUMN_OFF_CMD = "ColumnAll OFF"
     INSTRUMENT_OFF = 'macro "SHUTDOWN.MAC" ,go'
     INSTRUMENT_ON = 'LIDoOperation "TURN_ON"'