pychemstation 0.10.5__py3-none-any.whl → 0.10.7__py3-none-any.whl

pychemstation/control/controllers/{tables → data_aq}/sequence.py

@@ -1,17 +1,15 @@
 import os
 import time
 import warnings
-from typing import Dict, List, Optional, Any
+from typing import Any, Dict, List, Optional, Union, Set
 
 from result import Err, Ok, Result
 from typing_extensions import override
 
 from pychemstation.analysis.chromatogram import (
-    SEQUENCE_TIME_FORMAT,
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
-from . import MethodController
 
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers.comm import CommunicationController
@@ -25,10 +23,11 @@ from ....utils.sequence_types import (
 )
 from ....utils.table_types import RegisterFlag, T, Table
 from ....utils.tray_types import FiftyFourVialPlate, TenVialColumn, Tray
-from .table import TableController
+from ..abc_tables.run import RunController
+from . import MethodController
 
 
-class SequenceController(TableController):
+class SequenceController(RunController):
     """
     Class containing sequence related logic
     """
@@ -92,6 +91,7 @@ class SequenceController(TableController):
     def get_row(self, row: int) -> SequenceEntry:
         sample_name = self.get_text(row, RegisterFlag.NAME)
         vial_location = self.try_int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
+        data_file = self.get_text(row, RegisterFlag.DATA_FILE)
         method = self.get_text(row, RegisterFlag.METHOD)
         num_inj = self.try_int(self.get_num(row, RegisterFlag.NUM_INJ))
         inj_vol = self.try_float(self.get_text(row, RegisterFlag.INJ_VOL))
@@ -106,6 +106,7 @@ class SequenceController(TableController):
             inj_vol=inj_vol,
             inj_source=inj_source,
             sample_type=sample_type,
+            data_file=data_file,
         )
 
     def check(self) -> str:
@@ -127,13 +128,17 @@ class SequenceController(TableController):
         self.send(f'_SeqPath$ = "{self.src}"')
         self.send(Command.SWITCH_SEQUENCE_CMD)
         time.sleep(2)
-        self.send(Command.GET_SEQUENCE_CMD)
-        time.sleep(2)
-        parsed_response = self.receive().ok_value.string_response
+        parsed_response = self.get_current_sequence_name()
 
         assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
         self.table_state = self.load()
 
+    def get_current_sequence_name(self):
+        self.send(Command.GET_SEQUENCE_CMD)
+        time.sleep(2)
+        parsed_response = self.receive().ok_value.string_response
+        return parsed_response
+
     def edit(self, sequence_table: SequenceTable):
         """
         Updates the currently loaded sequence table with the provided table. This method will delete the existing sequence table and remake it.
@@ -146,19 +151,18 @@ class SequenceController(TableController):
         if rows.is_ok():
             existing_row_num = rows.ok_value.num_response
             wanted_row_num = len(sequence_table.rows)
-            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))
+            for i in range(int(existing_row_num)):
+                self.delete_row(int(existing_row_num - i))
                 self.send(Command.SAVE_SEQUENCE_CMD)
-                existing_row_num = self.get_num_rows().ok_value.num_response
+            for i in range(int(wanted_row_num)):
+                self.add_row()
+                self.save()
             self.send(Command.SWITCH_SEQUENCE_CMD)
 
             for i, row in enumerate(sequence_table.rows):
                 self._edit_row(row=row, row_num=i + 1)
                 self.sleep(1)
-            self.send(Command.SAVE_SEQUENCE_CMD)
+            self.save()
             self.send(Command.SWITCH_SEQUENCE_CMD)
 
     def _edit_row(self, row: SequenceEntry, row_num: int):
@@ -172,56 +176,90 @@ class SequenceController(TableController):
         if num_rows.is_ok():
             while num_rows.ok_value.num_response < row_num:
                 self.add_row()
-                self.send(Command.SAVE_SEQUENCE_CMD)
+                self.save()
                 num_rows = self.get_num_rows()
         if row.vial_location:
-            loc = row.vial_location
-            loc_num = -1
-            if isinstance(loc, TenVialColumn):
-                loc_num = loc.value
-            elif isinstance(loc, FiftyFourVialPlate):
-                loc_num = loc.value()
-            self._edit_row_num(
-                row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
-            )
+            self.edit_vial_location(row.vial_location, row_num, save=False)
         if row.method:
-            method_dir = self.method_controller.src
-            possible_path = os.path.join(method_dir, row.method) + ".M\\"
-            method = row.method
-            if os.path.exists(possible_path):
-                method = os.path.join(method_dir, row.method)
-            self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
+            self.edit_method_name(row.method, row_num, save=False)
         if row.num_inj:
-            self._edit_row_num(
-                row=row_num, col_name=RegisterFlag.NUM_INJ, val=row.num_inj
-            )
+            self.edit_num_injections(row.num_inj, row_num, save=False)
         if row.inj_vol:
-            self._edit_row_text(
-                row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(row.inj_vol)
-            )
+            self.edit_injection_volume(row.inj_vol, row_num, save=False)
         if row.inj_source:
-            self._edit_row_text(
-                row=row_num, col_name=RegisterFlag.INJ_SOR, val=row.inj_source.value
-            )
+            self.edit_injection_source(row.inj_source, row_num, save=False)
         if row.sample_name:
-            self._edit_row_text(
-                row=row_num, col_name=RegisterFlag.NAME, val=row.sample_name
-            )
-            if row.data_file:
-                self._edit_row_text(
-                    row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.data_file
-                )
-            else:
-                self._edit_row_text(
-                    row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.sample_name
-                )
+            self.edit_sample_name(row.sample_name, row_num, save=False)
+        if row.data_file:
+            self.edit_data_file(row.data_file, row_num, save=False)
         if row.sample_type:
-            self._edit_row_num(
-                row=row_num,
-                col_name=RegisterFlag.SAMPLE_TYPE,
-                val=row.sample_type.value,
-            )
+            self.edit_sample_type(row.sample_type, row_num, save=False)
+        self.save()
+
+    def edit_sample_type(
+        self, sample_type: SampleType, row_num: int, save: bool = True
+    ):
+        self._edit_row_num(
+            row=row_num,
+            col_name=RegisterFlag.SAMPLE_TYPE,
+            val=sample_type.value,
+        )
+        if save:
+            self.save()
+
+    def edit_data_file(self, data_file: str, row_num: int, save: bool = True):
+        self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=data_file)
+        if save:
+            self.save()
+
+    def edit_sample_name(self, sample_name: str, row_num: int, save: bool = True):
+        self._edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=sample_name)
+        if save:
+            self.save()
 
+    def edit_injection_source(
+        self, inj_source: InjectionSource, row_num: int, save: bool = True
+    ):
+        self._edit_row_text(
+            row=row_num, col_name=RegisterFlag.INJ_SOR, val=inj_source.value
+        )
+        if save:
+            self.save()
+
+    def edit_injection_volume(
+        self, inj_vol: Union[int, float], row_num: int, save: bool = True
+    ):
+        self._edit_row_text(
+            row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(inj_vol)
+        )
+        if save:
+            self.save()
+
+    def edit_num_injections(self, num_inj: int, row_num: int, save: bool = True):
+        self._edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=num_inj)
+
+    def edit_method_name(self, method: str, row_num: int, save: bool = True):
+        method_dir = self.method_controller.src
+        possible_path = os.path.join(method_dir, method) + ".M\\"
+        if os.path.exists(possible_path):
+            method = os.path.join(method_dir, method)
+        self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
+        if save:
+            self.save()
+
+    def edit_vial_location(self, loc: Tray, row_num: int, save: bool = True):
+        loc_num = -1
+        if isinstance(loc, TenVialColumn):
+            loc_num = loc.value
+        elif isinstance(loc, FiftyFourVialPlate):
+            loc_num = loc.value()
+        self._edit_row_num(
+            row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
+        )
+        if save:
+            self.save()
+
+    def save(self):
         self.send(Command.SAVE_SEQUENCE_CMD)
 
     def run(self, stall_while_running: bool = True):
@@ -236,7 +274,8 @@ class SequenceController(TableController):
         else:
             raise ValueError("Controller is offline!")
 
-        if not self.table_state:
+        current_sequence_name = self.get_current_sequence_name()
+        if not self.table_state or self.table_state.name not in current_sequence_name:
             self.table_state = self.load()
 
         total_runtime = 0.0
@@ -258,16 +297,35 @@ class SequenceController(TableController):
                     curr_method_runtime = self.method_controller.get_total_runtime()
             total_runtime += curr_method_runtime
 
-        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
         self.send(Command.RUN_SEQUENCE_CMD.value)
         self.timeout = total_runtime * 60
 
-        if self.check_hplc_is_running():
-            folder_name = f"{self.table_state.name} {timestamp}"
-            data_file = SequenceDataFiles(
-                dir=folder_name, sequence_name=self.table_state.name
-            )
-            self.data_files.append(data_file)
+        tries = 10
+        hplc_running = False
+        for _ in range(tries):
+            hplc_running = self.check_hplc_is_running()
+            if hplc_running:
+                break
+
+        if hplc_running:
+            full_path_name, current_sample_file = None, None
+            for _ in range(5):
+                try:
+                    full_path_name, current_sample_file = (
+                        self.get_current_run_data_dir_file()
+                    )
+                    break
+                except ValueError:
+                    pass
+            if full_path_name and current_sample_file:
+                data_file = SequenceDataFiles(
+                    sequence_name=self.table_state.name,
+                    dir=full_path_name,
+                    _data_files=[r.data_file for r in self.table_state.rows],
+                )
+                self.data_files.append(data_file)
+            else:
+                raise ValueError("Data directory for sequence was not found.")
 
             if stall_while_running:
                 run_completed = self.check_hplc_done_running()
@@ -276,58 +334,43 @@ class SequenceController(TableController):
                 else:
                     warnings.warn("Run may have not completed.")
         else:
-            raise RuntimeError("Sequence run did not start.")
+            raise RuntimeError("Sequence run may not have started.")
 
     @override
     def fuzzy_match_most_recent_folder(
-        self, most_recent_folder: T
+        self, most_recent_folder: T, child_dirs: Optional[Set[str]]
     ) -> Result[SequenceDataFiles, str]:
         if isinstance(most_recent_folder, SequenceDataFiles):
-            if os.path.isdir(most_recent_folder.dir):
-                subdirs = [x[0] for x in os.walk(most_recent_folder.dir)]
-                potential_folders = sorted(
-                    list(filter(lambda d: most_recent_folder.dir in d, subdirs))
-                )
-                most_recent_folder.child_dirs = [
-                    f
-                    for f in potential_folders
-                    if most_recent_folder.dir in f and ".M" not in f and ".D" in f
-                ]
-                return Ok(most_recent_folder)
-
             try:
-                potential_folders = []
-                for d in self.data_dirs:
-                    subdirs = [x[0] for x in os.walk(d)]
-                    potential_folders = sorted(
-                        list(filter(lambda d: most_recent_folder.dir in d, subdirs))
-                    )
-                    if len(potential_folders) > 0:
-                        break
-                assert len(potential_folders) > 0
-                parent_dirs = []
-                for folder in potential_folders:
-                    path = os.path.normpath(folder)
-                    split_folder = path.split(os.sep)
-                    if most_recent_folder.dir in split_folder[-1]:
-                        parent_dirs.append(folder)
-                parent_dir = sorted(parent_dirs, reverse=True)[0]
-
-                potential_folders = []
-                for d in self.data_dirs:
-                    subdirs = [x[0] for x in os.walk(d)]
-                    potential_folders = sorted(
-                        list(filter(lambda d: parent_dir in d, subdirs))
-                    )
-                    if len(potential_folders) > 0:
-                        break
-                assert len(potential_folders) > 0
-                most_recent_folder.child_dirs = [
-                    f
-                    for f in potential_folders
-                    if parent_dir in f and ".M" not in f and ".D" in f
-                ]
-                return Ok(most_recent_folder)
+                if most_recent_folder.dir and os.path.isdir(most_recent_folder.dir):
+                    subdirs = [x[0] for x in os.walk(most_recent_folder.dir)]
+                    if (
+                        child_dirs
+                        and len(child_dirs) > 0
+                        and set(most_recent_folder._data_files) == child_dirs
+                    ):
+                        most_recent_folder.child_dirs = [
+                            os.path.join(most_recent_folder.dir, f) for f in child_dirs
+                        ]
+                    else:
+                        potential_folders: List[str] = sorted(
+                            list(
+                                filter(
+                                    lambda d: most_recent_folder.dir in d,
+                                    subdirs,
+                                )
+                            )
+                        )
+                        most_recent_folder.child_dirs = [
+                            f
+                            for f in potential_folders
+                            if most_recent_folder.dir in f
+                            and ".M" not in f
+                            and ".D" in f
+                        ]
+                    return Ok(most_recent_folder)
+                else:
+                    return Err("No sequence folder found, please give the full path.")
             except Exception as e:
                 error = f"Failed to get sequence folder: {e}"
                 return Err(error)
@@ -335,16 +378,20 @@ class SequenceController(TableController):
 
     def get_data_mult_uv(self, custom_path: Optional[str] = None):
         seq_data_dir = (
-            SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="")
+            SequenceDataFiles(dir=custom_path, sequence_name="")
             if custom_path
             else self.data_files[-1]
         )
         if len(seq_data_dir.child_dirs) == 0:
-            self.data_files[-1] = self.fuzzy_match_most_recent_folder(
-                seq_data_dir
-            ).ok_value
+            search_folder = self.fuzzy_match_most_recent_folder(
+                seq_data_dir, set(seq_data_dir.child_dirs)
+            )
+            if search_folder.is_ok():
+                seq_data_dir = search_folder.ok_value
+            else:
+                raise FileNotFoundError(search_folder.err_value)
         all_w_spectra: List[Dict[int, AgilentHPLCChromatogram]] = []
-        for row in self.data_files[-1].child_dirs:
+        for row in seq_data_dir.child_dirs:
             all_w_spectra.append(self.get_data_uv(custom_path=row))
         return all_w_spectra
 
@@ -362,13 +409,13 @@ class SequenceController(TableController):
         self, custom_path: Optional[str] = None
     ) -> List[AgilentChannelChromatogramData]:
         seq_file_dir = (
-            SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="")
+            SequenceDataFiles(dir=custom_path, sequence_name="")
             if custom_path
             else self.data_files[-1]
         )
         if len(seq_file_dir.child_dirs) == 0:
             self.data_files[-1] = self.fuzzy_match_most_recent_folder(
-                seq_file_dir
+                seq_file_dir, set(seq_file_dir.child_dirs)
             ).ok_value
         spectra: List[AgilentChannelChromatogramData] = []
         for row in self.data_files[-1].child_dirs:
@@ -385,8 +432,10 @@ class SequenceController(TableController):
             self.data_files.append(
                 self.fuzzy_match_most_recent_folder(
                     most_recent_folder=SequenceDataFiles(
-                        dir=custom_path, child_dirs=[], sequence_name="NA"
-                    )
+                        dir=custom_path,
+                        sequence_name="NA",
+                    ),
+                    child_dirs=None,
                 ).ok_value
             )
         parent_dir = self.data_files[-1]

pychemstation/control/controllers/devices/__init__.py

@@ -0,0 +1,3 @@
+from .injector import InjectorController
+
+__all__ = ["InjectorController"]

pychemstation/control/controllers/devices/injector.py

@@ -1,19 +1,23 @@
+from __future__ import annotations
+
+from ..abc_tables.device import DeviceController
 from ....control.controllers import CommunicationController
 from ....utils.injector_types import (
     Draw,
     Inject,
-    InjectorFunction,
     InjectorTable,
     Mode,
     Remote,
     RemoteCommand,
     SourceType,
     Wait,
+    DrawDefault,
+    DrawDefaultVolume,
+    DrawDefaultLocation,
 )
 from ....utils.macro import Response
 from ....utils.table_types import RegisterFlag, Table
-from ....utils.tray_types import Tray
-from .device import DeviceController
+from ....utils.tray_types import Tray, FiftyFourVialPlate, TenVialColumn, LocationPlus
 
 
 class InjectorController(DeviceController):
@@ -22,14 +26,32 @@ class InjectorController(DeviceController):
     ):
         super().__init__(controller, table, offline)
 
-    def get_row(self, row: int) -> InjectorFunction:
-        def return_tray_loc() -> Tray:
-            raise NotImplementedError
-            # unit = self.get_text(row, RegisterFlag.DRAW_LOCATION_UNIT)
-            # tray = self.get_text(row, RegisterFlag.DRAW_LOCATION_TRAY)
-            # x = self.get_text(row, RegisterFlag.DRAW_LOCATION_ROW)
-            # y = self.get_text(row, RegisterFlag.DRAW_LOCATION_COLUMN)
-            # return FiftyFourVialPlate.from_str("P1-A1")
+    def try_vial_location(self, val: str) -> Tray:
+        try:
+            return FiftyFourVialPlate.from_str(val)
+        except Exception:
+            try:
+                return TenVialColumn(int(val))
+            except Exception:
+                raise ValueError("Location could not be identified.")
+
+    def get_row(
+        self, row: int
+    ) -> (
+        Draw
+        | DrawDefaultVolume
+        | Inject
+        | Wait
+        | DrawDefault
+        | DrawDefaultLocation
+        | Remote
+    ):
+        def return_location_plus() -> Tray:
+            unit = self.get_num(row, RegisterFlag.DRAW_LOCATION_UNIT)
+            tray = self.get_num(row, RegisterFlag.DRAW_LOCATION_TRAY)
+            row_ = self.get_num(row, RegisterFlag.DRAW_LOCATION_ROW)
+            col = self.get_num(row, RegisterFlag.DRAW_LOCATION_COLUMN)
+            return LocationPlus(int(unit), int(tray), int(row_), int(col))
 
         function = self.get_text(row, RegisterFlag.FUNCTION)
         if function == "Wait":
@@ -37,20 +59,32 @@ class InjectorController(DeviceController):
         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)
-                )
+            if is_volume is not Mode.SET:
+                if is_source == SourceType.DEFAULT:
+                    return DrawDefault()
+                elif is_source is SourceType.SPECIFIC_LOCATION:
+                    return DrawDefaultVolume(location=return_location_plus())
+                elif is_source is SourceType.LOCATION:
+                    return DrawDefaultVolume(
+                        location=self.try_vial_location(
+                            self.get_text(row, RegisterFlag.DRAW_LOCATION)
+                        )
+                    )
+            else:
+                vol = self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE)
+                if is_source == SourceType.DEFAULT:
+                    return DrawDefaultLocation(amount=vol)
+                elif is_source is SourceType.SPECIFIC_LOCATION:
+                    return Draw(amount=vol, location=return_location_plus())
+                elif is_source is SourceType.LOCATION:
+                    return Draw(
+                        amount=vol,
+                        location=self.try_vial_location(
+                            self.get_text(row, RegisterFlag.DRAW_LOCATION)
+                        ),
+                    )
         elif function == "Remote":
             return Remote(
                 command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
@@ -58,16 +92,15 @@ class InjectorController(DeviceController):
             )
         raise ValueError("No valid function found.")
 
-    def load(self) -> InjectorTable:
+    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) for i in range(int(row_response.num_response))
+                        self.get_row(i + 1)
+                        for i in range(int(row_response.num_response))
                     ]
                 )
-        elif rows.is_err():
-            return InjectorTable(functions=[])
-        raise ValueError("Unexpected error")
+        raise ValueError("Couldn't read injector table rows.")

pychemstation/control/hplc.py

@@ -6,6 +6,7 @@ Authors: Lucy Hao
 
 from __future__ import annotations
 
+import os.path
 from typing import Dict, List, Optional, Tuple, Union
 
 from pychemstation.analysis.chromatogram import AgilentChannelChromatogramData
@@ -13,9 +14,10 @@ from pychemstation.analysis.chromatogram import (
     AgilentHPLCChromatogram,
 )
 from .controllers.devices.injector import InjectorController
-from .controllers.tables.sequence import SequenceController, MethodController
+from .controllers.data_aq.sequence import SequenceController, MethodController
 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
@@ -30,14 +32,16 @@ class HPLCController:
 
     INJECTOR_TABLE = Table(register="RCWLS1Pretreatment[1]", name="InstructionTable")
 
+    DAD_TABLE = Table(register="RCDAD1Method[1]", name="Timetable")
+
     MSD_TABLE = Table(register="MSACQINFO[1]", name="SprayChamber")
 
     def __init__(
         self,
         comm_dir: str,
-        method_dir: str,
-        sequence_dir: str,
-        data_dirs: List[str],
+        method_dir: Optional[str] = None,
+        sequence_dir: Optional[str] = None,
+        extra_data_dirs: Optional[List[str]] = None,
         offline: bool = False,
         debug: bool = False,
     ):
@@ -46,33 +50,42 @@ class HPLCController:
         double escaped: "C:\\my_folder\\"
 
         :param comm_dir: Name of directory for communication, where ChemStation will read and write from. Can be any existing directory.
-        :param data_dirs: Name of directories for storing data after method or sequence runs. Method data dir is default
         the first one in the list. In other words, the first dir in the list is highest prio. Must be "normal" strings and not r-strings.
-        :param method_dir: Name of directory where method files are stored.
-        :param sequence_dir: Name of directory where sequence files are stored.
         :raises FileNotFoundError: If either `data_dir`, `method_dir`, `sequence_dir`, `sequence_data_dir`or `comm_dir` is not a valid directory.
         """
         self.comm: CommunicationController = CommunicationController(
-            comm_dir=comm_dir, debug=debug
-        )
-        self.method_controller: MethodController = MethodController(
-            controller=self.comm,
-            src=method_dir,
-            data_dirs=data_dirs,
-            table=self.METHOD_TIMETABLE,
-            offline=offline,
-            injector_controller=InjectorController(
-                controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
-            ),
-        )
-        self.sequence_controller: SequenceController = SequenceController(
-            controller=self.comm,
-            src=sequence_dir,
-            data_dirs=data_dirs,
-            table=self.SEQUENCE_TABLE,
-            method_controller=self.method_controller,
-            offline=offline,
+            comm_dir=comm_dir, debug=debug, offline=offline
         )
+        data_dirs: List[str] = []
+        if not offline:
+            if not method_dir or not sequence_dir or not extra_data_dirs:
+                method_dir, sequence_dir, data_dirs = self.comm.get_chemstation_dirs()
+            if extra_data_dirs:
+                data_dirs.extend(extra_data_dirs)
+            data_dirs = list(set([os.path.normpath(p) for p in data_dirs]))
+        if method_dir and sequence_dir and data_dirs:
+            self.method_controller: MethodController = MethodController(
+                controller=self.comm,
+                src=method_dir,
+                data_dirs=data_dirs,
+                table=self.METHOD_TIMETABLE,
+                offline=offline,
+                injector_controller=InjectorController(
+                    controller=self.comm, table=self.INJECTOR_TABLE, offline=offline
+                ),
+            )
+            self.sequence_controller: SequenceController = SequenceController(
+                controller=self.comm,
+                src=sequence_dir,
+                data_dirs=data_dirs,
+                table=self.SEQUENCE_TABLE,
+                method_controller=self.method_controller,
+                offline=offline,
+            )
+        else:
+            raise ValueError(
+                "Expected a method dir, sequence dir and data dirs but they were None."
+            )
 
     def send(self, cmd: Union[Command, str]):
         """
@@ -278,6 +291,9 @@ class HPLCController:
         """Returns the currently loaded sequence."""
         return self.sequence_controller.load()
 
+    def load_injector_program(self) -> InjectorTable | None:
+        return self.method_controller.injector_controller.load()
+
     def standby(self):
         """Switches all modules in standby mode. All lamps and pumps are switched off."""
         self.send(Command.STANDBY_CMD)