pychemstation 0.5.14.dev1__py3-none-any.whl → 0.5.15__py3-none-any.whl

pychemstation/control/controllers/devices/injector.py

@@ -1,11 +1,122 @@
 from ....control.controllers import CommunicationController
 from .device import DeviceController
-from ....utils.table_types import Table
+from ....utils.injector_types import *
+from ....utils.macro import Command
+from ....utils.table_types import Table, RegisterFlag
 
 
 class InjectorController(DeviceController):
-    def get_row(self, row: int):
-        pass
 
     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":
+            # TODO: better error handling
+            is_source = SourceType(self.get_text(row, RegisterFlag.DRAW_SOURCE))
+            is_volume = Mode(self.get_text(row, RegisterFlag.DRAW_VOLUME))
+            vol = self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE) if is_volume == Mode.SET else None
+            if is_source is SourceType.SPECIFIC_LOCATION:
+                return Draw(amount=vol, source=return_tray_loc())
+            elif is_source is SourceType.LOCATION:
+                return Draw(amount=vol, location=self.get_text(row, RegisterFlag.DRAW_LOCATION))
+        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(int(rows.ok_value.num_response))])
+
+    def edit(self, injector_table: InjectorTable):
+        rows = self.get_num_rows()
+        if rows.is_ok():
+            existing_row_num = rows.value.num_response
+            wanted_row_num = len(injector_table.functions)
+            while existing_row_num != wanted_row_num:
+                if wanted_row_num > existing_row_num:
+                    self.add_row()
+                elif wanted_row_num < existing_row_num:
+                    self.delete_row(int(existing_row_num))
+                self.send(Command.SAVE_METHOD_CMD)
+                existing_row_num = self.get_num_rows().ok_value.num_response
+            self.send(Command.SWITCH_METHOD_CMD)
+
+        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.location:
+                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.LOCATION.value)
+                add_table_val(col_name=RegisterFlag.DRAW_LOCATION, val=draw.location)
+            elif 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()
+        self.send(Command.SAVE_METHOD_CMD)
+        self.send(Command.SWITCH_METHOD_CMD)
+
+    def download(self):
+        self.send('Sleep 1')
+        self.sleepy_send("DownloadLWls 1")
+        self.send('Sleep 1')

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/table.py

@@ -6,6 +6,7 @@ Authors: Lucy Hao
 
 import abc
 import os
+import warnings
 from dataclasses import dataclass
 from typing import Union, Optional
 
@@ -33,8 +34,8 @@ class ChromData:
 class TableController(abc.ABC):
 
     def __init__(self, controller: CommunicationController,
-                 src: str,
-                 data_dir: str,
+                 src: Optional[str],
+                 data_dir: Optional[str],
                  table: Table,
                  offline: bool = False):
         self.controller = controller
@@ -45,26 +46,27 @@ class TableController(abc.ABC):
             # Initialize row counter for table operations
             self.send('Local Rows')
 
-            if os.path.isdir(src):
+            if src and os.path.isdir(src):
                 self.src: str = src
             else:
-                raise FileNotFoundError(f"dir: {src} not found.")
+                warnings.warn(f"dir: {src} not found.")
 
-            if os.path.isdir(data_dir):
+            if data_dir and os.path.isdir(data_dir):
                 self.data_dir: str = data_dir
             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),
-        }
+                warnings.warn(f"dir: {data_dir} not found.")
+
+            if hasattr(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(),
@@ -80,8 +82,6 @@ class TableController(abc.ABC):
 
         self.uv = None
 
-
-
     def receive(self) -> Result[Response, str]:
         for _ in range(10):
             try:
@@ -107,7 +107,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,

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,31 @@
 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"
+    LOCATION = "Location"
+
+
+class Mode(Enum):
+    DEFAULT = "Default"
+    SET = "Set"
+
+
 @dataclass
 class Draw:
-    amount: float
-    source: Tray
-    speed: Any
-    offset: Any
+    amount: Optional[float] = None
+    location: Optional[str] = None
+    source: Optional[Tray] = None
 
 
 @dataclass
 class Wait:
-    time: int
+    duration: int
 
 
 @dataclass
@@ -22,7 +33,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/macro.py

@@ -37,7 +37,7 @@ class Command(Enum):
     # Method and Sequence Related
     GET_METHOD_CMD = "response$ = _MethFile$"
     GET_ROWS_CMD = 'response_num = TabHdrVal({register}, "{table_name}", "{col_name}")'
-    SWITCH_METHOD_CMD = 'LoadMethod "{method_dir}", "{method_name}.M"'
+    SWITCH_METHOD_CMD = 'LoadMethod _MethPath$, _MethFile$'
     START_METHOD_CMD = "StartMethod"
     RUN_METHOD_CMD = 'RunMethod "{data_dir}",, "{experiment_name}_{timestamp}"'
     STOP_METHOD_CMD = "StopMethod"

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,26 @@ 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"
+    # SetObjHdrVal RCWLS1Pretreatment[1], "DrawVolume_Value", 1
+    DRAW_VOLUME_VALUE = "DrawVolume_Value"
+    DRAW_LOCATION = "DrawLocation"
+    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.14.dev1.dist-info → pychemstation-0.5.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.14.dev1
+Version: 0.5.15
 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.14.dev1.dist-info → pychemstation-0.5.15.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,13 +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=PfkSQlpE1zMzwyJ55Km1AdtPtdOS2RNyHDwAt_ZNa6M,349
+pychemstation/control/controllers/devices/injector.py,sha256=ul5q8quGcB7N3sNPBWbifIoqGdp95LJMXPAbcufHBng,5728
 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=pJCtMDGHweBhm_BEo0qhh2AjCjYAx1QyIY0AShs707A,12411
+pychemstation/control/controllers/tables/table.py,sha256=J-uNIFHVznPJqOKPmmqrJBXt70KlxmZlSdtEVM2pEKM,12576
 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
@@ -30,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/macro.py,sha256=OCQRRC-f46RlhenZfe7ldSgxBhzcZ5JlW3Ej-9OfeSI,2847
-pychemstation/utils/method_types.py,sha256=e7c2nWub6pT_S8ZF6sd7uXYm9ZBno0mARnzc1hnSHPY,1516
+pychemstation/utils/injector_types.py,sha256=SD452SwEHNx4Xs2p-mhg6X0pd99XewQ1Zbu-r9kPOJs,817
+pychemstation/utils/macro.py,sha256=o1dypIKhEMbDea34VFh4gKu-kWIjXZAFyqK4FYjCKjo,2836
+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=0kg7gZXFk7O5l0K1BEBaF4OFFdja3-hFUG9UbN5PBcs,3173
 pychemstation/utils/tray_types.py,sha256=MaHN36rhcEI5mAY95VU8hfP9HhAlngQvMYq-2oyC0hc,764
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=4FPJjW97yn6QiHNQVSlqjjJUE-Bh9SmyjIvgAeaGQBU,2450
-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=Up2EEysYwldPT9GJw27Mycs6qi_Y2W3opjhc7wnLU9U,3215
-tests/test_sequence.py,sha256=Nz2iqp1cJgw6kcQvnwSkfBmhxpOH62PoEu6o_5rO-PY,4929
-pychemstation-0.5.14.dev1.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.5.14.dev1.dist-info/METADATA,sha256=-kS4rtI8LDxt1GKutFyCSSMi2fx65plU2b7EgUb6m1c,4376
-pychemstation-0.5.14.dev1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.5.14.dev1.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.5.14.dev1.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=1ib-RwVouBLmWJO1KLQD8ghIqpD2xi1ePsrEw49mNIU,2045
+tests/test_method.py,sha256=KB7yAtVb4gZftnYzh-VfPb9LGVZOHUIW6OljEYRtbhA,4570
+tests/test_sequence.py,sha256=vs5-dqkItRds_tPM2-N6MNJ37FB0nLRFaDzBV8d42i8,4880
+pychemstation-0.5.15.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.5.15.dist-info/METADATA,sha256=aAdW7pVUfyidEcFiPaEMUFzGLl4DLormW-51LsCbaU0,4371
+pychemstation-0.5.15.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pychemstation-0.5.15.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.5.15.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\\"

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,6 +2,8 @@ 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 *
 
 
@@ -21,18 +23,33 @@ 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)
+            inj_table = self.hplc_controller.load_injector_program()
+            self.assertTrue(len(inj_table.functions) == 2)
         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:
-            self.hplc_controller.edit_method(new_method)
+            injector_program = InjectorTable(
+                functions=[
+                    Draw(amount=0.3, location="P1-A2"),
+                           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:
+            injector_program = InjectorTable(
+                functions=[Draw(location="P1-F2"), 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

@@ -28,7 +28,25 @@ class TestMethod(unittest.TestCase):
 
     def test_edit_method(self):
         self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
-        new_method = gen_rand_method()
+        new_method = MethodDetails(name=DEFAULT_METHOD,
+                                   timetable=[TimeTableEntry(start_time=1,
+                                                             organic_modifer=20,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2,
+                                                             organic_modifer=30,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=2.5,
+                                                             organic_modifer=60,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3,
+                                                             organic_modifer=80,
+                                                             flow=0.65),
+                                              TimeTableEntry(start_time=3.5,
+                                                             organic_modifer=100,
+                                                             flow=0.65)],
+                                   stop_time=4,
+                                   post_time=1,
+                                   params=HPLCMethodParams(organic_modifier=5, flow=0.65))
         try:
             self.hplc_controller.edit_method(new_method)
         except Exception as e:

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(