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

pychemstation/control/controllers/devices/column.py

@@ -0,0 +1,61 @@
+from typing import List, Dict
+
+from ....control.controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
+from ....utils.macro import Command
+from ....utils.method_types import Param, PType
+from ....utils.table_types import Device, Table, RegisterFlag
+
+
+class ColumnController(DeviceController):
+    def __init__(
+        self, controller: CommunicationController, table: Table | Device, offline: bool
+    ):
+        super().__init__(controller, table, offline)
+        if not self.offline:
+            self.display_to_internal: Dict[str, str] = {
+                display_name: real_name
+                for display_name, real_name in zip(
+                    self.check_available_column_positions(),
+                    self._internal_column_positions(),
+                )
+            }
+            self.internal_to_display: Dict[str, str] = dict(
+                map(reversed, self.display_to_internal.items())  # type: ignore
+            )
+
+    def check_column_position(self):
+        return self.internal_to_display[
+            self._read_str_param(register_flag=RegisterFlag.COLUMN_POSITION)
+        ]
+
+    def _internal_column_positions(self) -> List[str]:
+        return self._read_str_param(
+            register_flag=RegisterFlag.AVAIL_COLUMN_POSITIONS
+        ).split("|")
+
+    def check_available_column_positions(self) -> List[str]:
+        return self._read_str_param(
+            register_flag=RegisterFlag.AVAIL_COLUMN_DISPLAY_VALUES
+        ).split("|")
+
+    def change_column_position(self, column: str):
+        if column not in self.display_to_internal.keys():
+            raise ValueError(f"Please use one of: {self.display_to_internal.keys()}")
+        self._update_param(
+            Param(
+                ptype=PType.STR,
+                chemstation_key=RegisterFlag.COLUMN_POSITION,
+                val=self.display_to_internal[column],
+            ),
+        )
+
+    def turn_off(self):
+        self.sleepy_send(Command.COLUMN_OFF_CMD)
+        pass
+
+    def turn_on(self):
+        self.sleepy_send(Command.COLUMN_ON_CMD)
+
+    def download(self):
+        self.sleepy_send("DownloadRCMethod THM1")

pychemstation/control/controllers/devices/dad.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import warnings
+
+from ...controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
+from ....utils.device_types import DADChannels, DADChannel
+from ....utils.macro import Command
+from ....utils.method_types import Param, PType
+from ....utils.table_types import RegisterFlag, Table, Device
+
+
+class DADController(DeviceController):
+    def __init__(
+        self, controller: CommunicationController, table: Table | Device, offline: bool
+    ):
+        super().__init__(controller, table, offline)
+
+    def download(self):
+        self.sleepy_send("DownloadRCMethod DAD1")
+
+    def turn_off(self):
+        self.send(Command.LAMP_OFF_CMD)
+
+    def turn_on(self):
+        self.send(Command.LAMP_ON_CMD)
+
+    def load_wavelengths(self) -> DADChannels:
+        return DADChannels(
+            A=self._read_num_param(RegisterFlag.SIGNAL_A),
+            A_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_A_USED)),
+            B=self._read_num_param(RegisterFlag.SIGNAL_B),
+            B_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_B_USED)),
+            C=self._read_num_param(RegisterFlag.SIGNAL_C),
+            C_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_C_USED)),
+            D=self._read_num_param(RegisterFlag.SIGNAL_D),
+            D_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_D_USED)),
+            E=self._read_num_param(RegisterFlag.SIGNAL_E),
+            E_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_E_USED)),
+        )
+
+    def edit_wavelength(self, signal: int, wavelength: DADChannel):
+        warnings.warn("You may need to check that the wavelength is calibrated.")
+        register = RegisterFlag.SIGNAL_A
+        match wavelength:
+            case DADChannel.A:
+                register = RegisterFlag.SIGNAL_A
+            case DADChannel.B:
+                register = RegisterFlag.SIGNAL_B
+            case DADChannel.C:
+                register = RegisterFlag.SIGNAL_C
+            case DADChannel.D:
+                register = RegisterFlag.SIGNAL_D
+            case DADChannel.E:
+                register = RegisterFlag.SIGNAL_E
+        self._update_param(
+            Param(
+                ptype=PType.NUM,
+                val=signal,
+                chemstation_key=register,
+            )
+        )
+        self.download()
+
+    def set_wavelength_usage(self, wavelength: DADChannel, on: bool):
+        register = RegisterFlag.SIGNAL_A_USED
+        match wavelength:
+            case DADChannel.A:
+                register = RegisterFlag.SIGNAL_A_USED
+            case DADChannel.B:
+                register = RegisterFlag.SIGNAL_B_USED
+            case DADChannel.C:
+                register = RegisterFlag.SIGNAL_C_USED
+            case DADChannel.D:
+                register = RegisterFlag.SIGNAL_D_USED
+            case DADChannel.E:
+                register = RegisterFlag.SIGNAL_E_USED
+        self._update_param(
+            Param(
+                ptype=PType.NUM,
+                val=int(on),
+                chemstation_key=register,
+            )
+        )
+        self.download()

pychemstation/control/controllers/devices/injector.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import warnings
+
 from ....control.controllers import CommunicationController
 from ....utils.abc_tables.device import DeviceController
 from ....utils.injector_types import (
@@ -15,7 +17,7 @@ from ....utils.injector_types import (
     DrawDefaultVolume,
     DrawDefaultLocation,
 )
-from ....utils.macro import Response
+from ....utils.method_types import Param, PType
 from ....utils.table_types import RegisterFlag, Table
 from ....utils.tray_types import Tray, FiftyFourVialPlate, VialBar, LocationPlus
 
@@ -26,6 +28,21 @@ class InjectorController(DeviceController):
     ):
         super().__init__(controller, table, offline)
 
+    def turn_off(self):
+        warnings.warn("Injector has no on/off state.")
+
+    def turn_on(self):
+        warnings.warn("Injector has no on/off state.")
+
+    def change_injection_volume(self, new_injection_volume: float):
+        self._update_param(
+            param=Param(
+                ptype=PType.NUM,
+                val=new_injection_volume,
+                chemstation_key=RegisterFlag.INJECTION_VOLUME,
+            )
+        )
+
     def try_vial_location(self, val: str) -> Tray:
         try:
             return FiftyFourVialPlate.from_str(val)
@@ -93,14 +110,5 @@ class InjectorController(DeviceController):
         raise ValueError("No valid function found.")
 
     def load(self) -> InjectorTable | None:
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            row_response = rows.value
-            if isinstance(row_response, Response):
-                return InjectorTable(
-                    functions=[
-                        self.get_row(i + 1)
-                        for i in range(int(row_response.num_response))
-                    ]
-                )
-        raise ValueError("Couldn't read injector table rows.")
+        rows = self.get_row_count_safely()
+        return InjectorTable(functions=[self.get_row(i + 1) for i in range(rows)])

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