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

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,91 +110,106 @@ 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
     ):
         if not (isinstance(val, int) or isinstance(val, float)):
             raise ValueError(f"{val} must be an int or float.")
-        num_rows = self.get_num_rows()
-        if row:
-            if num_rows.is_ok():
-                if num_rows.ok_value.num_response < row:
-                    raise ValueError("Not enough rows to edit!")
+        num_rows = self.get_row_count_safely()
+        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
     ):
         if not isinstance(val, str):
             raise ValueError(f"{val} must be a str.")
-        num_rows = self.get_num_rows()
-        if row:
-            if num_rows.is_ok():
-                if num_rows.ok_value.num_response < row:
-                    raise ValueError("Not enough rows to edit!")
+        num_rows = self.get_row_count_safely()
+        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()
+        tries = 10
+        i = 0
+        while row_count.is_err() and i < tries:
+            row_count = self.get_num_rows()
+            i += 1
+        if row_count.is_ok():
+            return int(row_count.ok_value.num_response)
+        else:
+            raise ValueError("couldn't read row count, table might not exist")
 
     def add_row(self):
         """Adds a row to the provided table for currently loaded method or sequence."""
-        previous_row_count = self.get_num_rows().ok_value.num_response
+        previous_row_count = self.get_row_count_safely()
         self.sleepy_send(
             TableOperation.NEW_ROW.value.format(
                 register=self.table_locator.register, table_name=self.table_locator.name
             )
         )
-        new_row_count = self.get_num_rows().ok_value.num_response
+        new_row_count = self.get_row_count_safely()
         if previous_row_count + 1 != new_row_count:
             raise ValueError("Row could not be added.")
 
@@ -205,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"'
 

pychemstation/utils/table_types.py

@@ -28,8 +28,8 @@ class TableOperation(Enum):
     GET_NUM_ROWS = 'Rows = TabHdrVal({register}, "{table_name}", "{col_name}")'
     GET_OBJ_HDR_VAL = 'ObjHdrVal("{register}", "{register_flag}")'
     GET_OBJ_HDR_TEXT = 'ObjHdrText$("{register}", "{register_flag}")'
-    UPDATE_OBJ_HDR_VAL = "SetObjHdrVal {register}, {register_flag}, {val}"
-    UPDATE_OBJ_HDR_TEXT = "SetObjHdrText {register}, {register_flag}, {val}"
+    UPDATE_OBJ_HDR_VAL = 'SetObjHdrVal "{register}", "{register_flag}", {val}'
+    UPDATE_OBJ_HDR_TEXT = 'SetObjHdrText "{register}", "{register_flag}", "{val}"'
     NEW_COL_TEXT = 'NewColText {register}, "{table_name}", "{col_name}", "{val}"'
     NEW_COL_VAL = 'NewColVal {register}, "{table_name}", "{col_name}", {val}'
 
@@ -42,6 +42,9 @@ class RegisterFlag(Enum):
     def __str__(self):
         return "%s" % self.value
 
+    # sample info
+    VIAL_NUMBER = "VialNumber"
+
     # for table
     NUM_ROWS = "NumberOfRows"
 
@@ -53,12 +56,6 @@ class RegisterFlag(Enum):
     FLOW = "Flow"
     MAX_TIME = "StopTime_Time"
     POST_TIME = "PostTime_Time"
-    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"
@@ -100,6 +97,57 @@ class RegisterFlag(Enum):
     ## Remote
     REMOTE = "RemoteLine"
     REMOTE_DUR = "RemoteDuration"
+    # Injection Volume
+    INJECTION_VOLUME = "Injection_Volume"
+
+    ## For Pump
+    ### Volume Status
+    BOTTLE_A1_ABSOLUTE_FILLING = "BottleFilling_CurrentAbsolute"
+    BOTTLE_A1_PERCENT_FILLING = "BottleFilling_CurrentPercent"
+    BOTTLE_A1_MAX = "BottleFilling_MaximumAbsolute"
+
+    BOTTLE_A2_ABSOLUTE_FILLING = "BottleFilling2_CurrentAbsolute"
+    BOTTLE_A2_PERCENT_FILLING = "BottleFilling2_CurrentPercent"
+    BOTTLE_A2_MAX = "BottleFilling2_MaximumAbsolute"
+
+    BOTTLE_B1_ABSOLUTE_FILLING = "BottleFilling3_CurrentAbsolute"
+    BOTTLE_B1_PERCENT_FILLING = "BottleFilling3_CurrentPercent"
+    BOTTLE_B1_MAX = "BottleFilling3_MaximumAbsolute"
+
+    BOTTLE_B2_ABSOLUTE_FILLING = "BottleFilling4_CurrentAbsolute"
+    BOTTLE_B2_PERCENT_FILLING = "BottleFilling4_CurrentPercent"
+    BOTTLE_B2_MAX = "BottleFilling4_MaximumAbsolute"
+
+    WASTE_BOTTLE_ABSOLUTE = "WasteBottleFilling_CurrentAbsolute"
+    WASTE_BOTTLE_PERCENT = "WasteBottleFilling_CurrentPercent"
+    WASTE_BOTTLE_MAX = "WasteBottleFilling_MaximumPercent"
+
+    ### Switching Solvent Bottles
+    PUMPCHANNEL_USED = "PumpChannel_IsUsed"
+    PUMPCHANNEL_SELECTION = "PumpChannel_SolventSelectionValvePosition"
+    BOTTLE_A1_USER_NAME = "PumpChannel_Position1_UserName"
+    BOTTLE_A2_USER_NAME = "PumpChannel_Position2_UserName"
+    PUMPCHANNEL2_USED = "PumpChannel_IsUsed"
+    PUMPCHANNEL2_SELECTION = "PumpChannel2_SolventSelectionValvePosition"
+    BOTTLE_B1_USER_NAME = "PumpChannel2_Position1_UserName"
+    BOTTLE_B2_USER_NAME = "PumpChannel2_Position2_UserName"
+
+    # For Column
+    AVAIL_COLUMN_DISPLAY_VALUES = "ColumnSwitchingValve_PositionDisplayValues"
+    AVAIL_COLUMN_POSITIONS = "ColumnSwitchingValve_PositionValues"
+    COLUMN_POSITION = "ColumnSwitchingValve_Position"
+
+    # For DAD
+    SIGNAL_A = "Signal_Wavelength"
+    SIGNAL_B = "Signal2_Wavelength"
+    SIGNAL_C = "Signal3_Wavelength"
+    SIGNAL_D = "Signal4_Wavelength"
+    SIGNAL_E = "Signal5_Wavelength"
+    SIGNAL_A_USED = "Signal_IsUsed"
+    SIGNAL_B_USED = "Signal2_IsUsed"
+    SIGNAL_C_USED = "Signal3_IsUsed"
+    SIGNAL_D_USED = "Signal4_IsUsed"
+    SIGNAL_E_USED = "Signal5_IsUsed"
 
 
 @dataclass
@@ -112,4 +160,13 @@ class Table:
     name: str
 
 
+@dataclass
+class Device:
+    """
+    Class for storing the keys needed to access certain devices
+    """
+
+    register: str
+
+
 T = TypeVar("T")

{pychemstation-0.10.10.dist-info → pychemstation-0.10.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.10
+Version: 0.10.12
 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
@@ -23,7 +23,7 @@ Requires-Dist: scipy>=1.10.1
 Requires-Dist: xsdata>=24.9
 Description-Content-Type: text/markdown
 
-# Agilent HPLC Macro Control
+# pychemstation: A Python package for automated control of Chemstation using MACROs
 
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/pychemstation)
 

{pychemstation-0.10.10.dist-info → pychemstation-0.10.12.dist-info}/RECORD

@@ -5,38 +5,42 @@ pychemstation/analysis/chromatogram.py,sha256=Jk6xOMHA6kSV597fJDZgrFRlvVorldvK4z
 pychemstation/analysis/process_report.py,sha256=GEazFm1asY1FZO87siiV9kWu2Wnbu7xwx86nlPeRexk,14728
 pychemstation/control/README.md,sha256=ohPn3xhgjFyPraQqR4x9aZhurQVAOYuYHv-E8sj0eK4,3124
 pychemstation/control/__init__.py,sha256=7lSkY7Qa7Ikdz82-2FESc_oqktv7JndsjltCkiMqnMI,147
-pychemstation/control/hplc.py,sha256=Nw5rJAOsmW1W6faq4jRuMJlEoGda91kD9GqkRX2jcgk,14210
+pychemstation/control/hplc.py,sha256=v0apEXVtTusvcVdgzY0Id4UJczKihFf-fjuFIJjAPEc,15213
 pychemstation/control/controllers/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
 pychemstation/control/controllers/__init__.py,sha256=q2TUEie3J-OLlxcGLkG7vIy8fazCEhHm61OGzJPbhD0,179
-pychemstation/control/controllers/comm.py,sha256=ySjgMBIfJ11sygXiZSPp9Rf6ABM4t6JhZRONRj1u2Cc,6652
+pychemstation/control/controllers/comm.py,sha256=ldM9mPIiT8txTJL_OzXsEQwQXQL-Q-9CWY4aEFeDUDQ,6651
 pychemstation/control/controllers/data_aq/__init__.py,sha256=w-Zgbit10niOQfz780ZmRHjUFxV1hMkdui7fOMPqeLA,132
-pychemstation/control/controllers/data_aq/method.py,sha256=sWtMjmBV-oY8dCxQbnksKvTVUtiH7rcq9cF1t-yoAKY,24787
-pychemstation/control/controllers/data_aq/sequence.py,sha256=yRlDlp0xzAERBbM_UAYGOErvcdTu0EC9HV4b_vyZLaI,18699
+pychemstation/control/controllers/data_aq/method.py,sha256=K9dMJG8DtsaM1q8kmyBLuilKD9RAd5FOBB91QnC3wr0,20709
+pychemstation/control/controllers/data_aq/sequence.py,sha256=Jwt-qrWdsxAbxmDhR11CSlNS95rDfp5eeg_joOr5g2w,19215
 pychemstation/control/controllers/devices/__init__.py,sha256=QpgGnLXyWiB96KIB98wMccEi8oOUUaLxvBCyevJzcOg,75
-pychemstation/control/controllers/devices/injector.py,sha256=LyubM-fqf5ruseGx32deTDK-yevmaTOvdo6YKg2PF7I,4029
+pychemstation/control/controllers/devices/column.py,sha256=RLGPQm2bzM5TVGDTrXGBiWY_epvy_bprKN2cG_DdrUI,2165
+pychemstation/control/controllers/devices/dad.py,sha256=TEm4C01qdWlulwQ_uu0q7FmfHdJTXfzmvldc9LsKELk,3105
+pychemstation/control/controllers/devices/injector.py,sha256=fRUBdnI6imZKz7VXP6x8nWPmZLQ97Nlk1a7GEfAnpug,4189
+pychemstation/control/controllers/devices/pump.py,sha256=2YKuWJ2NRWttefZ2IbU6o5SqUVbaFNcAL7y4WWMlPkA,4977
+pychemstation/control/controllers/devices/sample_info.py,sha256=-CJa425Hf_YgWoxqEmWXzjsrRArz6H7IyWF8PIMK5Hc,922
 pychemstation/generated/__init__.py,sha256=xnEs0QTjeuGYO3tVUIy8GDo95GqTV1peEjosGckpOu0,977
 pychemstation/generated/dad_method.py,sha256=xTUiSCvkXcxBUhjVm1YZKu-tHs16k23pF-0xYrQSwWA,8408
 pychemstation/generated/pump_method.py,sha256=s3MckKDw2-nZUC5lHrJVvXYdneWP8-9UvblNuGryPHY,12092
 pychemstation/utils/__init__.py,sha256=GZJyDzkhzrlMguxZTUpgthq72pA3YV23DJIR2Q63PCk,449
-pychemstation/utils/device_types.py,sha256=X8LFRdZpOK3bmdLgKKpsi8N9T27bI0Tg6_qEG9QJEBs,98
+pychemstation/utils/device_types.py,sha256=sjWofM20HKEFZHLILux5CIccXYapXyGCS0zxT9zsPR0,1321
 pychemstation/utils/injector_types.py,sha256=z2iWwTklGm0GRDCL9pnPCovQrwyRwxv8w5w5Xh7Pj3U,1152
-pychemstation/utils/macro.py,sha256=VGOU380ruJSKQhXJFI1g--qg4Xgx-e0D8z5FDPGe0cA,3433
+pychemstation/utils/macro.py,sha256=XCHQM-C_5UR48SZPSS4vp6QWSxF-nnQVN5evpNiqXl0,3505
 pychemstation/utils/method_types.py,sha256=ck8I4dRGhHXCUfBf3AT1OU1eCcSSZPgnlhvlLTfezEM,1562
 pychemstation/utils/num_utils.py,sha256=OpqZwMPoxTYkpjpinA1CcoQAXDY_0sie6d-hTU547uo,2087
 pychemstation/utils/parsing.py,sha256=mzdpxrH5ux4-_i4CwZvnIYnIwAnRnOptKb3fZyYJcx0,9307
 pychemstation/utils/sequence_types.py,sha256=H9htO2thyU9_KYOFBsGjlmA-4Nyd6aLd4D0MDLaXNCQ,2583
 pychemstation/utils/spec_utils.py,sha256=BtXgQndZy4kVKsrgEDxwNd0HctypnAt5upB9SOk1D9w,9700
-pychemstation/utils/table_types.py,sha256=ZmV52Vl1cYG_C1PEmVGB02mC3Dhfi7QMkUZwe0ujzAg,3748
+pychemstation/utils/table_types.py,sha256=r8hGb2Ey0_sheGqqMAC96vlEFDc6eQ72SInqdZ3trj8,5846
 pychemstation/utils/tray_types.py,sha256=UeHM0hUYaNc9giT96ZiGpyWBPQwG-SyLA0rVGzDDAJk,6618
 pychemstation/utils/abc_tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/abc_tables/abc_comm.py,sha256=7ywcufQZ7UWfNQdEEsfHqkA2CpRkt6ZlKYuLt9MXjvs,5656
-pychemstation/utils/abc_tables/device.py,sha256=v8MNFvymbKe4hWsqzO6Z_qsVvju_rISYtnPgaftecyE,919
+pychemstation/utils/abc_tables/device.py,sha256=5cAYoU5u0_7yN3lrzPe9xiSoT6qALu2lTU4iBGnqcpM,1194
 pychemstation/utils/abc_tables/run.py,sha256=uURDl66Mga8NAMffOUsG6prKhjpLo1-p2Y2PUTY1hY0,10052
-pychemstation/utils/abc_tables/table.py,sha256=AbuitDcBHODV-KpxjL7ZPoE-TSa6gyG2uqXXY90Mv2o,7992
+pychemstation/utils/abc_tables/table.py,sha256=lIumyZ2qCaF9j7A2OF-FbQfK0NhpFACP_cjSGnXg7kU,12041
 pychemstation/utils/mocking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/mocking/mock_comm.py,sha256=vZeYBXaKBZOlJmhn4TSbkov62gqlkfztqf3MSFU9kLE,800
 pychemstation/utils/mocking/mock_hplc.py,sha256=esVIlU4oqEsYLPOQs0AeVnKv9l52xBGT6UY862l9RQE,1163
-pychemstation-0.10.10.dist-info/METADATA,sha256=rfbKQndkcM2bkXWnjzer9OwynZMZlZ6ru_OaMzAr68w,5849
-pychemstation-0.10.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pychemstation-0.10.10.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.10.10.dist-info/RECORD,,
+pychemstation-0.10.12.dist-info/METADATA,sha256=rmxsCsOBdkgMV6McmhLT1HmepJF_04cD0x47RUcfKds,5904
+pychemstation-0.10.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pychemstation-0.10.12.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.10.12.dist-info/RECORD,,