pychemstation 0.5.13.dev8__py3-none-any.whl → 0.5.14__py3-none-any.whl

pychemstation/control/controllers/devices/injector.py

@@ -0,0 +1,106 @@
+from ....control.controllers import CommunicationController
+from .device import DeviceController
+from ....utils.injector_types import *
+from ....utils.table_types import Table, RegisterFlag
+
+
+class InjectorController(DeviceController):
+
+    def __init__(self, controller: CommunicationController, table: Table):
+        super().__init__(controller, table)
+
+    def get_row(self, row: int) -> InjectorFunction:
+        def return_tray_loc() -> Tray:
+            pass
+
+        function = self.get_text(row, RegisterFlag.FUNCTION)
+        if function == "Wait":
+            return Wait(duration=self.get_num(row, RegisterFlag.TIME))
+        elif function == "Inject":
+            return Inject()
+        elif function == "Draw":
+            is_source = SourceType(self.get_text(row, RegisterFlag.DRAW_SOURCE))
+            is_volume = Mode(self.get_text(row, RegisterFlag.DRAW_VOLUME))
+            return Draw(amount=self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE) if is_volume == Mode.SET else None,
+                        source=return_tray_loc() if is_source == SourceType.SPECIFIC_LOCATION else None)
+        elif function == "Remote":
+            return Remote(command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
+                          duration=self.get_num(row, RegisterFlag.REMOTE_DUR))
+
+    def load(self) -> InjectorTable:
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            return InjectorTable(functions=[self.get_row(i + 1) for i in range(rows.ok_value.num_response)])
+
+    def edit(self, injector_table: InjectorTable):
+        self.delete_table()
+        res = self.get_num_rows()
+        while not res.is_err():
+            self.delete_table()
+            res = self.get_num_rows()
+
+        self.new_table()
+        self.get_num_rows()
+
+        columns_added = set()
+
+        def add_table_val(col_name: RegisterFlag, val: Union[str, int, float]):
+            nonlocal columns_added
+            if col_name in columns_added:
+                if isinstance(val, str):
+                    self.edit_row_text(col_name=col_name, val=val)
+                else:
+                    self.edit_row_num(col_name=col_name, val=val)
+            else:
+                if isinstance(val, str):
+                    self.add_new_col_text(col_name=col_name, val=val)
+                else:
+                    self.add_new_col_num(col_name=col_name, val=val)
+                columns_added.add(col_name)
+
+        def add_inject(inject: Inject):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=inject.__class__.__name__)
+
+        def add_draw(draw: Draw):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=draw.__class__.__name__)
+            add_table_val(col_name=RegisterFlag.DRAW_SPEED, val=SourceType.DEFAULT.value)
+            add_table_val(col_name=RegisterFlag.DRAW_OFFSET, val=SourceType.DEFAULT.value)
+
+            if draw.amount:
+                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.SET.value)
+                add_table_val(col_name=RegisterFlag.DRAW_VOLUME_VALUE, val=draw.amount)
+            else:
+                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.DEFAULT.value)
+
+            if draw.source:
+                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.SPECIFIC_LOCATION.value)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_UNIT, val=1)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_TRAY, val=1)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_ROW, val=1)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_COLUMN, val=1)
+            else:
+                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.DEFAULT.value)
+
+        def add_wait(wait: Wait):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=wait.__class__.__name__)
+            add_table_val(col_name=RegisterFlag.TIME, val=wait.duration)
+
+        def add_remote(remote: Remote):
+            add_table_val(col_name=RegisterFlag.FUNCTION, val=remote.__class__.__name__)
+            add_table_val(col_name=RegisterFlag.REMOTE, val=remote.command.value)
+            add_table_val(col_name=RegisterFlag.REMOTE_DUR, val=remote.duration)
+
+        for i, function in enumerate(injector_table.functions):
+            self.add_row()
+            if isinstance(function, Inject):
+                add_inject(function)
+            elif isinstance(function, Draw):
+                add_draw(function)
+            elif isinstance(function, Wait):
+                add_wait(function)
+            elif isinstance(function, Remote):
+                add_remote(function)
+            self.download()
+
+    def download(self):
+        pass

pychemstation/control/controllers/tables/method.py

@@ -4,6 +4,7 @@ import time
 from xsdata.formats.dataclass.parsers import XmlParser
 
 from .table import TableController
+from ..devices.injector import InjectorController
 from ....control.controllers import CommunicationController
 from ....generated import PumpMethod, DadMethod, SolventElement
 from ....utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
@@ -17,7 +18,13 @@ class MethodController(TableController):
     Class containing method related logic
     """
 
-    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table, offline: bool):
+    def __init__(self, controller: CommunicationController,
+                 src: str,
+                 data_dir: str,
+                 table: Table,
+                 offline: bool,
+                 injector_controller: InjectorController):
+        self.injector_controller = injector_controller
         super().__init__(controller, src, data_dir, table, offline=offline)
 
     def check(self) -> str:
@@ -310,8 +317,6 @@ class MethodController(TableController):
 
         :param experiment_name: Name of the experiment
         """
-        if not self.table_state:
-            self.table_state = self.load()
 
         folder_name = ""
         hplc_is_running = False
@@ -331,13 +336,17 @@ class MethodController(TableController):
         self.data_files.append(os.path.join(self.data_dir, folder_name))
 
         if stall_while_running:
+
+            if not self.table_state:
+                self.table_state = self.load()
+
             run_completed = self.check_hplc_done_running(method=self.table_state)
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
                 raise RuntimeError("Run error has occurred.")
         else:
-            self.data_files[-1].dir = self.fuzzy_match_most_recent_folder(folder_name).ok_value
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(folder_name).ok_value
 
     def retrieve_recent_data_files(self) -> str:
         return self.data_files[-1]

pychemstation/control/controllers/tables/ms.py

@@ -0,0 +1,21 @@
+from typing import Union
+
+from ....control.controllers import CommunicationController
+from ....control.controllers.tables.table import TableController
+from ....utils.chromatogram import AgilentChannelChromatogramData
+from ....utils.table_types import Table
+
+
+class MassSpecController(TableController):
+
+    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
+        super().__init__(controller, src, data_dir, table)
+
+    def get_row(self, row: int):
+        pass
+
+    def retrieve_recent_data_files(self):
+        pass
+
+    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        pass

pychemstation/control/controllers/tables/table.py

@@ -12,7 +12,6 @@ from typing import Union, Optional
 import numpy as np
 import polling
 import rainbow as rb
-from rainbow import DataFile
 from result import Result, Ok, Err
 
 from ....control.controllers.comm import CommunicationController
@@ -43,6 +42,9 @@ class TableController(abc.ABC):
         self.table_state: Optional[TableType] = None
 
         if not offline:
+            # Initialize row counter for table operations
+            self.send('Local Rows')
+
             if os.path.isdir(src):
                 self.src: str = src
             else:
@@ -53,24 +55,31 @@ class TableController(abc.ABC):
             else:
                 raise FileNotFoundError(f"dir: {data_dir} not found.")
 
-        self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
-            "A": AgilentHPLCChromatogram(self.data_dir),
-            "B": AgilentHPLCChromatogram(self.data_dir),
-            "C": AgilentHPLCChromatogram(self.data_dir),
-            "D": AgilentHPLCChromatogram(self.data_dir),
-            "E": AgilentHPLCChromatogram(self.data_dir),
-            "F": AgilentHPLCChromatogram(self.data_dir),
-            "G": AgilentHPLCChromatogram(self.data_dir),
-            "H": AgilentHPLCChromatogram(self.data_dir),
-        }
-
+            self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
+                "A": AgilentHPLCChromatogram(self.data_dir),
+                "B": AgilentHPLCChromatogram(self.data_dir),
+                "C": AgilentHPLCChromatogram(self.data_dir),
+                "D": AgilentHPLCChromatogram(self.data_dir),
+                "E": AgilentHPLCChromatogram(self.data_dir),
+                "F": AgilentHPLCChromatogram(self.data_dir),
+                "G": AgilentHPLCChromatogram(self.data_dir),
+                "H": AgilentHPLCChromatogram(self.data_dir),
+            }
+        else:
+            self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
+                "A": AgilentHPLCChromatogram(),
+                "B": AgilentHPLCChromatogram(),
+                "C": AgilentHPLCChromatogram(),
+                "D": AgilentHPLCChromatogram(),
+                "E": AgilentHPLCChromatogram(),
+                "F": AgilentHPLCChromatogram(),
+                "G": AgilentHPLCChromatogram(),
+                "H": AgilentHPLCChromatogram(),
+            }
         self.data_files: Union[list[SequenceDataFiles], list[str]] = []
 
         self.uv = None
 
-        # Initialize row counter for table operations
-        self.send('Local Rows')
-
     def receive(self) -> Result[Response, str]:
         for _ in range(10):
             try:
@@ -96,7 +105,7 @@ class TableController(abc.ABC):
         """
         self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
 
-    def get_num(self, row: int, col_name: RegisterFlag) -> float:
+    def get_num(self, row: int, col_name: RegisterFlag) -> Union[int, float]:
         return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table.register,
                                                                                    table_name=self.table.name,
                                                                                    row=row,
@@ -279,7 +288,7 @@ class TableController(abc.ABC):
         pass
 
     def get_uv_spectrum(self, path: str):
-        data_uv: DataFile = rb.agilent.chemstation.parse_file(os.path.join(path, "DAD1.UV"))
+        data_uv = rb.agilent.chemstation.parse_file(os.path.join(path, "DAD1.UV"))
         zipped_data = zip(data_uv.ylabels, data_uv.data)
         self.uv = {str(w_a[0]): ChromData(x=data_uv.xlabels, y=w_a[1]) for w_a in zipped_data}
 

pychemstation/control/hplc.py

@@ -6,8 +6,10 @@ Authors: Lucy Hao
 
 from typing import Union, Optional
 
+from .controllers.devices.injector import InjectorController
 from ..control.controllers import MethodController, SequenceController, CommunicationController
 from ..utils.chromatogram import AgilentChannelChromatogramData
+from ..utils.injector_types import InjectorTable
 from ..utils.macro import Command, HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus, Response
 from ..utils.method_types import MethodDetails
 from ..utils.sequence_types import SequenceTable, SequenceEntry
@@ -27,8 +29,13 @@ class HPLCController:
     )
 
     INJECTOR_TABLE = Table(
-        register="_LeoAlsMethod",
-        name="ProgTable"
+        register="RCWLS1Pretreatment[1]",
+        name="InstructionTable"
+    )
+
+    MSD_TABLE = Table(
+        register="MSACQINFO[1]",
+        name="SprayChamber"
     )
 
     def __init__(self,
@@ -48,7 +55,9 @@ class HPLCController:
                                                   src=method_dir,
                                                   data_dir=data_dir,
                                                   table=self.METHOD_TIMETABLE,
-                                                  offline=offline)
+                                                  offline=offline,
+                                                  injector_controller=InjectorController(controller=self.comm,
+                                                                                         table=self.INJECTOR_TABLE))
         self.sequence_controller = SequenceController(controller=self.comm,
                                                       src=sequence_dir,
                                                       data_dir=data_dir,
@@ -118,6 +127,9 @@ class HPLCController:
         """
         self.sequence_controller.run(stall_while_running=stall_while_running)
 
+    def edit_injector_program(self, injector_table: InjectorTable):
+        self.method_controller.injector_controller.edit(injector_table=injector_table)
+
     def edit_method(self, updated_method: MethodDetails, save: bool = False):
         """Updated the currently loaded method in ChemStation with provided values.
 
@@ -176,6 +188,9 @@ class HPLCController:
         """
         return self.method_controller.check()
 
+    def load_injector_program(self) -> InjectorTable:
+        return self.method_controller.injector_controller.load()
+
     def load_method(self) -> MethodDetails:
         """
         Returns all details of the currently loaded method, including its timetable.

pychemstation/utils/injector_types.py

@@ -1,20 +1,29 @@
 from dataclasses import dataclass
-from typing import Any
+from enum import Enum
+from typing import  Union, Optional
 
 from pychemstation.utils.tray_types import Tray
 
 
+class SourceType(Enum):
+    DEFAULT = "ActualPosition"
+    SPECIFIC_LOCATION = "ActualPositionPlusLocation"
+
+
+class Mode(Enum):
+    DEFAULT = "Default"
+    SET = "Set"
+
+
 @dataclass
 class Draw:
-    amount: float
-    source: Tray
-    speed: Any
-    offset: Any
+    amount: Optional[float] = None
+    source: Optional[Tray] = None
 
 
 @dataclass
 class Wait:
-    time: int
+    duration: int
 
 
 @dataclass
@@ -22,7 +31,18 @@ class Inject:
     pass
 
 
-InjectorFunction = [Draw, Wait, Inject]
+class RemoteCommand(Enum):
+    START = "START"
+    PREPARE = "PREPARE"
+
+
+@dataclass
+class Remote:
+    command: RemoteCommand
+    duration: int
+
+
+InjectorFunction = Union[Draw, Wait, Inject, Remote]
 
 
 @dataclass

pychemstation/utils/method_types.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Union, Any, Optional
 
+from .injector_types import InjectorTable
 from .table_types import RegisterFlag
 from ..generated import Signal
 
@@ -36,7 +37,7 @@ class TimeTableEntry:
 
 @dataclass
 class MethodDetails:
-    """An Agilent Chemstation method, TODO is to add MS parameters
+    """An Agilent Chemstation method, TODO is to add MS parameters, injector parameters
 
     :attribute name: the name of the method, should be the same as the Chemstation method name.
     :attribute timetable: list of entries in the method timetable
@@ -49,6 +50,7 @@ class MethodDetails:
     name: str
     params: HPLCMethodParams
     timetable: list[TimeTableEntry]
+    injector_program: Optional[InjectorTable] = None
     stop_time: Optional[int] = None
     post_time: Optional[int] = None
     dad_wavelengthes: Optional[list[Signal]] = None

pychemstation/utils/table_types.py

@@ -65,6 +65,24 @@ class RegisterFlag(Enum):
     SAMPLE_TYPE = "SampleType"
     DATA_FILE = "DataFileName"
 
+    # for Injector Table
+    ## Draw
+    DRAW_SOURCE = "DrawSource"
+    DRAW_VOLUME = "DrawVolume_Mode"
+    DRAW_SPEED = "DrawSpeed_Mode"
+    DRAW_OFFSET = "DrawOffset_Mode"
+    DRAW_VOLUME_VALUE = "DrawVolume_Value"
+    DRAW_LOCATION_TRAY = "DrawLocationPlus_Tray"
+    DRAW_LOCATION_UNIT = "DrawLocationPlus_Unit"
+    DRAW_LOCATION_ROW = "DrawLocationPlus_Row"
+    DRAW_LOCATION_COLUMN = "DrawLocationPlus_Column"
+    ## Inject
+    ## Wait
+    ## Remote
+    REMOTE = "RemoteLine"
+    REMOTE_DUR = "RemoteDuration"
+
+
 
 @dataclass
 class Table:

{pychemstation-0.5.13.dev8.dist-info → pychemstation-0.5.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.13.dev8
+Version: 0.5.14
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao

{pychemstation-0.5.13.dev8.dist-info → pychemstation-0.5.14.dist-info}/RECORD

@@ -5,7 +5,7 @@ pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-
 pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
 pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
 pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
-pychemstation/control/hplc.py,sha256=UlafodQoFFow2UVo-INK1ZjxyJ5vrVvv1TjB5VyAsHo,9178
+pychemstation/control/hplc.py,sha256=IdHH4Yho5cJDDBLcc6k0XKDFDecghaY8NaA4dIU7KB8,9898
 pychemstation/control/controllers/__init__.py,sha256=EM6LBNSTJqYVatmnvPq0P-S3q0POA88c-y64zL79I_I,252
 pychemstation/control/controllers/comm.py,sha256=IU4I_Q42VNCNUlVi93MxCmw2EBY9hiBDkU9FxubKg3c,7441
 pychemstation/control/controllers/method.py,sha256=XUclB7lQ_SIkquR58MBmmi9drHIPEq9AR8VprTLenvI,15503
@@ -14,11 +14,13 @@ pychemstation/control/controllers/table_controller.py,sha256=70ovnIjLKkJborS1ztk
 pychemstation/control/controllers/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/control/controllers/devices/column.py,sha256=SCpCnVFZFUM9LM51MbWkVcBRayN3WFxy7lz9gs2PYeY,348
 pychemstation/control/controllers/devices/device.py,sha256=SF1JK93FjmACnYrlKvldX3gEeA21qnXZegeNhc9QJGQ,738
+pychemstation/control/controllers/devices/injector.py,sha256=nm7fDu6HI3LHHpod8Bn6sCEnVnzojBxqhNhhzfaL-zk,4712
 pychemstation/control/controllers/devices/pump.py,sha256=DJQh4lNXEraeC1CWrsKmsITOjuYlRI3tih_XRB3F1hg,1404
 pychemstation/control/controllers/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/control/controllers/tables/method.py,sha256=Woni_nAEWRZ79wf2WixLnJWZONNdGgZGGV9GG7m0qCQ,16189
+pychemstation/control/controllers/tables/method.py,sha256=3GdAQ6Cwf20QL3v7eMkwNieWbJdtr9GN12USbSVl_iE,16426
+pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
 pychemstation/control/controllers/tables/sequence.py,sha256=vqwJeV38YWdFnaDXvZVOGYl-UCV9lmMbh8Fj5kQ3mqY,8815
-pychemstation/control/controllers/tables/table.py,sha256=9B6Su6G3NJnq6Z5zezQ51vB4dVTnUcetW97zWzWaD_Q,11950
+pychemstation/control/controllers/tables/table.py,sha256=ipscw8kimreJR95g4DLkC9dBB-23kuPstsWtb14P1bU,12457
 pychemstation/control/table/__init__.py,sha256=RgMN4uIWHdNUHpGRBWdzmzAbk7XEKl6Y-qtqWCxzSZU,124
 pychemstation/control/table/method.py,sha256=THVoGomSXff_CTU3eAYme0BYwkPzab5UgZKsiZ29QSk,12196
 pychemstation/control/table/sequence.py,sha256=Eri52AnbE3BGthfrRSvYKYciquUzvHKo0lYUTySYYE8,10542
@@ -28,23 +30,23 @@ pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCs
 pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
 pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pychemstation/utils/chromatogram.py,sha256=-q3_hL9GTyi4C95os7IwAiOrkTM4EXIiigm-nW9pFmM,3221
-pychemstation/utils/injector_types.py,sha256=xOkvlX_cH_QmuKbyXj8Lc2JEA_6g82az1zB4oTwcKN0,386
+pychemstation/utils/injector_types.py,sha256=DESgRec3FiMPE_h6yRAXyIF6VGJ_isFX9eFAjVZF-yI,756
 pychemstation/utils/macro.py,sha256=OCQRRC-f46RlhenZfe7ldSgxBhzcZ5JlW3Ej-9OfeSI,2847
-pychemstation/utils/method_types.py,sha256=e7c2nWub6pT_S8ZF6sd7uXYm9ZBno0mARnzc1hnSHPY,1516
+pychemstation/utils/method_types.py,sha256=3qxKeREl_97GnQ74qcA3kxibnvWI4ueb-6XZlxcV2Hg,1632
 pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
 pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
 pychemstation/utils/sequence_types.py,sha256=4cNpmRdPLN5oGN7ozHgT21E65aBO8vV3ZcRXMOQ3EA8,1084
-pychemstation/utils/table_types.py,sha256=mlbxPAiPvO_EBba5OSzuJcpCL0srrC7uUfm_lKsOsmA,2557
+pychemstation/utils/table_types.py,sha256=R9eNIItASX1yd6wrsRu-F_Q88m-es_2UIySEuNNmizs,3074
 pychemstation/utils/tray_types.py,sha256=MaHN36rhcEI5mAY95VU8hfP9HhAlngQvMYq-2oyC0hc,764
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=iU6knsNpQGnBfGcC8VAj5SrCDcHD3jBZLhQdF6UUwY4,2452
-tests/test_comb.py,sha256=EDE1Ve0A_EK4qro9imZsrD0xXrQN8hAowiOWPFtw3dM,5515
-tests/test_comm.py,sha256=EYOpVXzEMQLGhhKYDPO-KaLcJdPSMPTD9Y4jSI0yVQY,2516
-tests/test_inj.py,sha256=yaPGZoHiOC3ZSgsmrtiqp8QtSo2bMxB9FJhaFlOpad0,1412
-tests/test_method.py,sha256=r1Q1irqiVzs31QuTYLX3u_A0FpX8rIAQ1L4WOk9tLbk,2473
-tests/test_sequence.py,sha256=Nz2iqp1cJgw6kcQvnwSkfBmhxpOH62PoEu6o_5rO-PY,4929
-pychemstation-0.5.13.dev8.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.13.dev8.dist-info/METADATA,sha256=hQHPA2C0jWRoeCjh0LTagaJxkgYCvnCw4XOxTndnx4w,4376
-pychemstation-0.5.13.dev8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.13.dev8.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.13.dev8.dist-info/RECORD,,
+tests/constants.py,sha256=55DOLpylLt12mb_gSgzEo-EYynwTmI2uH7PcrTM6Iq0,2455
+tests/test_comb.py,sha256=TS-CbtiPbntL4u6E1gSZ6xquNp6cQxIFdJqUr2ak7PA,5515
+tests/test_comm.py,sha256=iwl-Ey-xoytXmlNrjG84pDm82Ry_QUX6wY4gmVh4NDc,2516
+tests/test_inj.py,sha256=5cV0LuLGUiV87u35uw41jinTA0W3rzLDS8mEqsX89kw,2710
+tests/test_method.py,sha256=hrxCsLKhC_3PPL0As-deEucbmXNBYsS6qVb89iC7brg,3215
+tests/test_sequence.py,sha256=vs5-dqkItRds_tPM2-N6MNJ37FB0nLRFaDzBV8d42i8,4880
+pychemstation-0.5.14.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.14.dist-info/METADATA,sha256=I1AWqOUHHQx1pkAHt07af7yabN9q8xANT-Sxdt3LxTI,4371
+pychemstation-0.5.14.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.14.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.14.dist-info/RECORD,,

tests/constants.py

@@ -4,7 +4,7 @@ from pychemstation.utils.method_types import *
 from pychemstation.utils.sequence_types import *
 
 DEFAULT_METHOD = "GENERAL-POROSHELL-OPT"
-DEFAULT_SEQUENCE = "LLETest"
+DEFAULT_SEQUENCE = "hplc_testing"
 
 # CONSTANTS: paths only work in Hein group HPLC machine in room 242
 DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
@@ -20,7 +20,7 @@ HEIN_LAB_CONSTANTS = [DEFAULT_COMMAND_PATH,
 # these CONSTANTS work in rm 254
 DEFAULT_COMMAND_PATH_254 = "D:\\\git_repositories\\\hplc_comm\\"
 DEFAULT_METHOD_DIR_254 = "D:\\Chemstation\\1\\Methods\\"
-DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\2024-12\\"
+DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\LC BO\\"
 SEQUENCE_DIR_254 = "C:\\1\\Sequence\\"
 
 HEIN_LAB_CONSTANTS_254 = [DEFAULT_COMMAND_PATH_254,

tests/test_comb.py

@@ -10,7 +10,7 @@ run_too = True
 
 class TestCombinations(unittest.TestCase):
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(

tests/test_comm.py

@@ -10,7 +10,7 @@ from tests.constants import *
 class TestComm(unittest.TestCase):
 
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(

tests/test_inj.py

@@ -2,12 +2,14 @@ import os
 import unittest
 
 from pychemstation.control import HPLCController
+from pychemstation.utils.injector_types import *
+from pychemstation.utils.tray_types import FiftyFourVialPlate, Plate, Letter, Num
 from tests.constants import *
 
 
 class TestInj(unittest.TestCase):
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(
@@ -21,18 +23,58 @@ class TestInj(unittest.TestCase):
     def test_load_inj(self):
         self.hplc_controller.switch_method(DEFAULT_METHOD)
         try:
-            gp_mtd = self.hplc_controller.method_controller.load_from_disk(DEFAULT_METHOD)
-            self.assertTrue(gp_mtd.first_row.organic_modifier == 5)
+            self.hplc_controller.load_injector_program()
         except Exception as e:
             self.fail(f"Should have not failed, {e}")
 
     def test_edit_inj(self):
-        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-        new_method = gen_rand_method()
+        self.hplc_controller.switch_method(DEFAULT_METHOD)
+        try:
+            injector_program = InjectorTable(
+                functions=[
+                    Draw(
+                        amount=0.3,
+                        source=FiftyFourVialPlate(
+                            plate=Plate.ONE,
+                            letter=Letter.A,
+                            num=Num.EIGHT)),
+                    Remote(
+                        command=RemoteCommand.PREPARE,
+                        duration=10,
+                    ),
+                    Wait(
+                        duration=2
+                    ),
+                    Inject(
+
+                    )
+                ]
+            )
+            self.hplc_controller.edit_injector_program(injector_program)
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_edit_inj_def(self):
+        self.hplc_controller.switch_method(DEFAULT_METHOD)
         try:
-            self.hplc_controller.edit_method(new_method)
+            injector_program = InjectorTable(
+                functions=[
+                    Draw(
+                        amount=0.3,
+                        source=FiftyFourVialPlate(
+                            plate=Plate.ONE,
+                            letter=Letter.A,
+                            num=Num.EIGHT)),
+                    Inject(
+
+                    )
+                ]
+            )
+
+            self.hplc_controller.edit_injector_program(injector_program)
         except Exception as e:
             self.fail(f"Should have not failed: {e}")
 
+
 if __name__ == '__main__':
     unittest.main()

tests/test_method.py

@@ -7,7 +7,7 @@ from tests.constants import *
 
 class TestMethod(unittest.TestCase):
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(
@@ -56,6 +56,26 @@ class TestMethod(unittest.TestCase):
         except Exception as e:
             self.fail(f"Should have not failed: {e}")
 
+    def test_run_10_times(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+        rand_method = MethodDetails(
+            name=DEFAULT_METHOD,
+            params=HPLCMethodParams(
+                organic_modifier=5,
+                flow=0.65),
+            timetable=[TimeTableEntry(
+                start_time=0.50,
+                organic_modifer=99,
+                flow=0.65)],
+            stop_time=1,
+            post_time=0)
+        self.hplc_controller.edit_method(rand_method, save=True)
+        try:
+            for _ in range(10):
+                self.hplc_controller.run_method(experiment_name="limiting_testing")
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

tests/test_sequence.py

@@ -2,13 +2,12 @@ import os
 import unittest
 
 from pychemstation.control import HPLCController
-from pychemstation.utils.sequence_types import *
 from tests.constants import *
 
 
 class TestSequence(unittest.TestCase):
     def setUp(self):
-        path_constants = room(254)
+        path_constants = room(242)
         for path in path_constants:
             if not os.path.exists(path):
                 self.fail(