pychemstation 0.10.11__tar.gz → 0.10.13__tar.gz

{pychemstation-0.10.11 → pychemstation-0.10.13}/.pre-commit-config.yaml

@@ -11,4 +11,10 @@ repos:
 - repo: https://github.com/pre-commit/mirrors-mypy
   rev: v1.15.0
   hooks:
-    - id: mypy
+    - id: mypy
+- repo: local
+  hooks:
+    - id: delete-debug-files
+      name: delete-debug-files
+      entry: bash -c 'find . -name "out.txt" -type f -delete'
+      language: system

pychemstation-0.10.13/.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+    "python.testing.unittestArgs": [
+        "-v",
+        "-s",
+        "./tests",
+        "-p",
+        "test_*.py"
+    ],
+    "python.testing.pytestEnabled": false,
+    "python.testing.unittestEnabled": true,
+    "python.analysis.typeCheckingMode": "standard"
+}

{pychemstation-0.10.11 → pychemstation-0.10.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.11
+Version: 0.10.13
 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.11 → pychemstation-0.10.13}/README.md

@@ -1,4 +1,4 @@
-# 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.13/cmd

@@ -0,0 +1 @@
+8 response$ = _METHPATH$

pychemstation-0.10.13/out.txt

@@ -0,0 +1,8 @@
+response$ = AcqStatus$
+response$ = _METHPATH$
+response$ = _SEQUENCEPATHS$
+response$ = _DATAPATHS$
+response$ = _METHPATH$
+response$ = _SEQUENCEPATHS$
+response$ = _DATAPATHS$
+response$ = _METHPATH$

pychemstation-0.10.13/paper.bib

@@ -0,0 +1,89 @@
+@misc{AccelerationConsortium,
+    title = {Acceleration {{Consortium}}},
+    urldate = {2025-04-16},
+    howpublished = {https://acceleration.utoronto.ca/events/acceleration-consortium-fall-research-symposium},
+    file = {/Users/lucyhao/Zotero/storage/KJJAD45E/acceleration-consortium-fall-research-symposium.html}
+}
+
+@misc{BourneGroupHPLCMethodOptimisationGUIHPLC,
+    title = {Bourne-{{Group}}/{{HPLCMethodOptimisationGUI}}: {{HPLC}} Method Optimisation Using Machine Learning},
+    urldate = {2025-04-16},
+    howpublished = {https://github.com/Bourne-Group/HPLCMethodOptimisationGUI}
+}
+
+@misc{ChromatographyMethodDevelopment,
+    title = {Chromatography {{Method Development}} - {{OpenLab ChemStation}} {\textbar} {{Agilent}}},
+    urldate = {2025-04-16},
+    howpublished = {https://www.agilent.com/en/product/software-informatics/analytical-software-suite/chromatography-data-systems/openlab-chemstation},
+    file = {/Users/lucyhao/Zotero/storage/KBK2IZV3/openlab-chemstation.html}
+}
+
+@misc{CroningpAnalyticallabware2025,
+    title = {Croningp/Analyticallabware},
+    year = {2025},
+    month = mar,
+    urldate = {2025-04-16},
+    howpublished = {croningp}
+}
+
+@article{dixonOperatorfreeHPLCAutomated2024a,
+    title = {Operator-Free {{HPLC}} Automated Method Development Guided by {{Bayesian}} Optimization},
+    author = {Dixon, Thomas M. and Williams, Jeanine and Besenhard, Maximilian and Howard, Roger M. and MacGregor, James and Peach, Philip and Clayton, Adam D. and Warren, Nicholas J. and Bourne, Richard A.},
+    year = {2024},
+    month = aug,
+    journal = {Digital Discovery},
+    volume = {3},
+    number = {8},
+    pages = {1591--1601},
+    publisher = {RSC},
+    issn = {2635-098X},
+    doi = {10.1039/D4DD00062E},
+    urldate = {2025-04-16},
+    abstract = {The need to efficiently develop high performance liquid chromatography (HPLC) methods, whilst adhering to quality by design principles is of paramount importance when it comes to impurity detection in the synthesis of active pharmaceutical ingredients. This study highlights a novel approach that fully automates HPLC method development using black-box single and multi-objective Bayesian optimization algorithms. Three continuous variables including the initial isocratic hold time, initial organic modifier concentration and the gradient time were adjusted to simultaneously optimize the number of peaks detected, the resolution between peaks and the method length. Two mixtures of analytes, one with seven compounds and one with eleven compounds, were investigated. The system explored the design space to find a global optimum in chromatogram quality without human assistance, and methods that gave baseline resolution were identified. Optimal operating conditions were typically reached within just 13 experiments. The single and multi-objective Bayesian optimization algorithms were compared to show that multi-objective optimization was more suitable for HPLC method development. This allowed for multiple chromatogram acceptance criteria to be selected without having to repeat the entire optimization, making it a useful tool for robustness testing. Work in this paper presents a fully ``operator-free'' and closed loop HPLC method optimization process that can find optimal methods quickly when compared to other modern HPLC optimization techniques such as design of experiments, linear solvent strength models or quantitative structure retention relationships.},
+    langid = {english},
+    file = {/Users/lucyhao/Zotero/storage/R6J4X3FX/Dixon et al. - 2024 - Operator-free HPLC automated method development guided by Bayesian optimization.pdf;/Users/lucyhao/Zotero/storage/U6VQC54Q/Dixon et al. - 2024 - Operator-free HPLC automated method development guided by Bayesian optimization.pdf}
+}
+
+@misc{DynamicSamplingAutonomous,
+    title = {Dynamic Sampling in Autonomous Process Optimization - {{Chemical Science}} ({{RSC Publishing}})},
+    urldate = {2025-04-16},
+    howpublished = {https://pubs.rsc.org/en/content/articlelanding/2024/sc/d3sc06884f\#!divAbstract},
+    file = {/Users/lucyhao/Zotero/storage/V9P3MB47/d3sc06884f.html}
+}
+
+@misc{HeinGroupHplcmethodoptimization2025,
+    title = {Hein {{Group}} / Hplc-Method-Optimization {$\cdot$} {{GitLab}}},
+    year = {2025},
+    month = apr,
+    journal = {GitLab},
+    urldate = {2025-04-16},
+    abstract = {GitLab.com},
+    howpublished = {https://gitlab.com/heingroup/hplc-method-optimization},
+    langid = {english}
+}
+
+@article{robertsAutomatingStochasticAntibody2025,
+    title = {Automating Stochastic Antibody--Drug Conjugation: A Self-Driving Lab Approach for Enhanced Therapeutic Development},
+    shorttitle = {Automating Stochastic Antibody--Drug Conjugation},
+    author = {Roberts, Liam and Reish, Matthew E. and Yang, Jerrica and Zhang, Wenyu and Derasp, Joshua S. and Hein, Jason E.},
+    year = {2025},
+    month = apr,
+    journal = {Digital Discovery},
+    volume = {4},
+    number = {4},
+    pages = {979--986},
+    publisher = {RSC},
+    issn = {2635-098X},
+    doi = {10.1039/D4DD00363B},
+    urldate = {2025-04-16},
+    abstract = {Antibody--drug conjugates (ADCs) have become a promising cancer treatment over the past two decades due to their on-target drug-release capabilities. However, labor-intensive manual conjugations currently limit the throughput of ADC synthesis. Herein, we introduce a Self-Driving Lab (SDL) for automated stochastic antibody--drug conjugation and characterization. The robotic platform performs conjugations and determines drug to antibody ratios from chromatography data, enabling the production of target ADCs iteratively in a closed loop. Our SDL establishes a robust foundation for increasing ADC production throughput and accelerating the development of cancer therapeutics.},
+    langid = {english},
+    file = {/Users/lucyhao/Zotero/storage/ENB4N88F/Roberts et al. - 2025 - Automating stochastic antibody–drug conjugation a self-driving lab approach for enhanced therapeuti.pdf;/Users/lucyhao/Zotero/storage/MQW4T3ZY/Roberts et al. - 2025 - Automating stochastic antibody–drug conjugation a self-driving lab approach for enhanced therapeuti.pdf}
+}
+
+@article{schneiderMacroProgrammingGuide,
+    title = {Macro {{Programming Guide}}},
+    author = {Schneider, J{\"u}rgen},
+    langid = {english},
+    file = {/Users/lucyhao/Zotero/storage/QKT883DB/Schneider - Macro Programming Guide.pdf}
+}

pychemstation-0.10.13/paper.md

@@ -0,0 +1,133 @@
+---
+title: 'pychemstation: A Python package for automated control of Chemstation using MACROs'
+tags:
+  - Python
+  - Self Driving Labs
+  - SDL
+  - HPLC
+  - Automation
+authors:
+  - name: Lucy Hao
+    email: lucyhao@chem.ubc.ca
+    orcid: 0000-0003-0296-3591
+    affiliation: 1
+  - name: Maria Politi
+    email: politim@chem.ubc.ca
+    orcid: 0000-0002-5815-3371
+    affiliation: "1, 3"
+  - name: Jason Hein
+    email: jhein@chem.ubc.ca
+    orcid: 0000-0002-4345-3005
+    affiliation: "1, 2, 3, 4"
+affiliations:
+  - name: Department of Chemistry, The University of British Columbia, Vancouver, Canada
+    index: 1
+  - name: Department of Chemistry, University of Bergen, Norway
+    index: 2
+  - name: Acceleration Consortium, University of Toronto, Toronto, ON, Canada
+    index: 3
+  - name: Telescope Innovations Corp., Vancouver, BC, Canada
+    index: 4
+date: 17 April 2025
+bibliography: paper.bib
+---
+
+# Summary
+
+`pychemstation` is a Python package that automates the use of high-performance liquid chromatography (HPLC) machines using
+Chemstation [@ChromatographyMethodDevelopment]. Python enables easy adoption by chemists and integrates smoothly with
+existing data analysis and robotics packages used in developing automated chemical workflows. The `pychemstation` API
+provides users with a simple class-based interface to automate common operations such as running analytical methods and
+sequences, modifying methods and sequences, and extracting chromatograms after runs. `pychemstation` provides this functionality by generating MACROs (a command
+protocol developed by Agilent) which are sent to ChemStation for execution. With HPLC being one of the most widely
+used analytical methods in research and industry, `pychemstation` opens the doors to using this powerful analytical technique in automated chemical workflows.
+
+# Statement of need
+
+Chemists run hundreds of analytical measurements to gain insight into chemical reactions. 
+This amounts to hours of manual labour to interact with graphical user interfaces (GUIs) to modify analytical methods,
+run the methods, and then extract data to gain scientific insight. Tasks such as these are amenable to automation, leading to a broader research
+goal to automate experiments through self-driving labs (SDLs) [@robertsAutomatingStochasticAntibody2025; @DynamicSamplingAutonomous].
+SDLs are robotic platforms that autonomously plan and execute hundreds of chemical reactions. Building an SDL requires
+every step a chemist would do by hand to be automated, one of them being the running of analytical equipment such as HPLC. 
+Building autonomous chemical requires the development of robust software tools that enable control and communication with analytical hardware.
+
+`pychemstation` was designed to be used by chemists to control Agilent-specific HPLC machines in their day-to-day
+operations or in developing SDLs. The development of `pychemstation` stemmed from the desire for a 
+robust strategy to interact with Chemstation, moving away from the fragile and cumbersome development of the “mouse and
+keyboard” interaction strategy with the GUI. Development began from the augmentation of an existing Python codebase for
+sending MACROs to Chemstation, with addition more MACROs through trial-and-error and previous published work 
+[@CroningpAnalyticallabware2025; @dixonOperatorfreeHPLCAutomated2024a; @BourneGroupHPLCMethodOptimisationGUIHPLCl; @schneiderMacroProgrammingGuide].
+`pychemstation` has already been used in several of the Hein group's projects, including SDLs for kinetics,
+liquid-liquid extraction and development of a Python based tool for autonomous data-driven HPLC method
+development [@AccelerationConsortium; @HeinGroupHplcmethodoptimization2025]. Built with robustness and ease-of-use in
+mind, `pychemstation` frees the chemist from repetitive tasks and gives SDL developers the ability to seamlessly interact with
+HPLC machines through an API, enhancing productivity and enabling more efficient software integration.
+
+# Description
+
+`pychemstation` controls the operation of Chemstation through a set of `Controller` classes which generate MACROs based
+on Python dataclasses. A schematic describing the package architecture is shown below in figure 1.
+
+![A class architecture diagram for `pychemstation`. The
+`CommunicationController` handles all communication between a user's Python program and a Chemstation instance. All other controllers extend an abstract
+`ABCTableController` which provides table loading and editing functionality all controllers require. The
+`RunController` is another abstract class including more functionality related to editing and triggering a run/runs.
+`RunController` also provides a polling functionality to let the user know when a run is complete, and returns the file paths containing the data from the run. The
+`DeviceController` load and edit details about hardware.](imgs/control.png)
+
+MACROs enabling functionality beyond method editing were discovered using a MACRO editor and Chemstation's built in
+MACRO help [@schneiderMacroProgrammingGuide; @ChromatographyMethodDevelopment].
+Python tests were written to ensure proper functionality of all the methods available in the `HPLCController` class that
+most users interact with, shown in figure 2. These tests include both unit (testing the individual controller
+classes) and integration tests (such as editing of methods and running them immediately after with retrieval of run
+data). Tests were run on two different HPLC machines in the Hein group.
+
+![All methods available for use in the `HPLCController` class](imgs/hplc.png)
+
+The `HPLCController` class contains a series of subclasses of `RunController` and `DeviceController`. 
+`RunController` subclasses, `MethodController` and `SequenceController`, generate MACROs related to runs, 
+such as triggering runs and returning data. The `DeviceController` subclasses are a new edition, allowing users to load 
+details about the injector, diode array detector, column/thermostat and pumps. The subclasses extending 
+`DeviceController` are in active development.
+
+The `RunController` subclasses provide `pychemstation`'s main functionality. The `MethodController` triggers method runs for one sample, while the `SequenceController` can trigger a runf o
+After a run is triggered, the `RunController` can either block until the HPLC is done the run or immediately return. If the user
+chooses to return before the HPLC is done a run, they choose to check how much time is remaining for the run. After the
+run, the `RunController` returns all the necessary file paths for further data processing. The UV chromatogram is returned per active channel, or for the entire
+scanned spectrum. There is limited data processing functionality for the auto-generated report in the `ReportProcessor`
+classes, thus other Python libraries are recommended for more in depth processing.
+
+The `MethodController` edits the pump timetable while the `SequenceController` edits the sequence table. An example is
+shown below. Various combinations of parameters and editing scenarios were tested to ensure the generated MACROs could
+handle different types of parameter updates.
+
+![An example of a Method pump timetable](imgs/method%20timetable.png)
+![An example of a Sequence table](imgs/img.png)
+
+A summary of available methods and functionality are shown in the tables below.
+
+| Run Controller | Features                                                                                                   |
+|----------------|------------------------------------------------------------------------------------------------------------|
+| Sequence       | Switch, Load sequence details, Edit sequence table entries, Run sequence, Retrieve sequence run data files |
+| Method         | Switch, Load method timetable, Edit method timetable, Run method, Retrieve method run data files           |
+
+| Device Controller    | Features                                                                            |
+|----------------------|-------------------------------------------------------------------------------------|
+| Pump                 | Edit parameters (flow, pressure, organic modifier), solvent and waste bottle status |
+| Diode Array Detector | Read and set active wavelengths                                                     |
+| Injector             | Change injection volume                                                             |
+| Columns              | Read active column, edit active column                                              |
+
+Thus, `pychemstation` provides both high-level and low-level control of an HPLC machine that uses Agilent's Chemstation
+software. More information and use case examples can be found in
+the [documentation](https://pychemstation-e5a086.gitlab.io/pychemstation.html).
+
+# Acknowledgements
+
+We acknowledge contributions from Wesley McNutt, Matthew Reish and Clark Zhang and funding support from AC, NSERC,
+Canada
+NRC,
+CFFI (?).
+
+# References

{pychemstation-0.10.11 → pychemstation-0.10.13}/pychemstation/control/controllers/comm.py

@@ -54,7 +54,7 @@ class CommunicationController(ABCCommunicationController):
         raise RuntimeError("Failed to get number.")
 
     def get_text_val(self, cmd: str) -> str:
-        tries = 10
+        tries = 5
         for _ in range(tries):
             self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
             res = self.receive()

{pychemstation-0.10.11 → pychemstation-0.10.13}/pychemstation/control/controllers/data_aq/method.py

@@ -5,12 +5,16 @@ import time
 import warnings
 from typing import Dict, List, Optional, Union, Tuple
 
-from result import Err, Ok, Result
+from result import Err, Result, Ok
 
-from pychemstation.analysis.chromatogram import (
+from ..devices.column import ColumnController
+from ..devices.dad import DADController
+from ..devices.pump import PumpController
+from ..devices.sample_info import SampleInfo
+from ....analysis.chromatogram import (
     TIME_FORMAT,
-    AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
+    AgilentChannelChromatogramData,
 )
 
 from ....analysis.process_report import AgilentReport, ReportType
@@ -20,12 +24,13 @@ from ....utils.macro import Command
 from ....utils.method_types import (
     HPLCMethodParams,
     MethodDetails,
+    TimeTableEntry,
     Param,
     PType,
-    TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, T, Table, TableOperation
+from ....utils.table_types import RegisterFlag, T, Table
 from ..devices.injector import InjectorController
+from ....utils.tray_types import Tray
 
 
 class MethodController(RunController):
@@ -38,9 +43,17 @@ class MethodController(RunController):
         data_dirs: Optional[List[str]],
         table: Table,
         offline: bool,
-        injector_controller: InjectorController,
+        injector: InjectorController,
+        pump: PumpController,
+        dad: DADController,
+        column: ColumnController,
+        sample_info: SampleInfo,
     ):
-        self.injector_controller = injector_controller
+        self.injector = injector
+        self.pump = pump
+        self.dad = dad
+        self.column = column
+        self.sample_info = sample_info
         self.data_files: List[str] = []
         super().__init__(
             controller=controller,
@@ -50,6 +63,9 @@ class MethodController(RunController):
             offline=offline,
         )
 
+    def get_sample_location(self) -> Tray:
+        return self.sample_info.get_location()
+
     def get_current_method_name(self) -> str:
         self.sleepy_send(Command.GET_METHOD_CMD)
         res = self.receive()
@@ -60,18 +76,8 @@ class MethodController(RunController):
     def get_method_params(self) -> HPLCMethodParams:
         if self.controller:
             return HPLCMethodParams(
-                organic_modifier=self.controller.get_num_val(
-                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                        register=self.table_locator.register,
-                        register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
-                    )
-                ),
-                flow=self.controller.get_num_val(
-                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                        register=self.table_locator.register,
-                        register_flag=RegisterFlag.FLOW,
-                    )
-                ),
+                organic_modifier=self.get_om(),
+                flow=self.get_flow(),
             )
         raise ValueError("Communication controller is offline!")
 
@@ -135,26 +141,6 @@ class MethodController(RunController):
         method_name = res.ok_value.string_response
         return method_name
 
-    def get_post_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.POST_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
-    def get_stop_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.MAX_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
     def get_total_runtime(self) -> Union[int, float]:
         """Returns total method runtime in minutes."""
         return self.get_post_time() + self.get_stop_time()
@@ -214,20 +200,14 @@ class MethodController(RunController):
         self.edit_method_timetable(updated_method.timetable)
 
         if save:
-            self.send(
-                Command.SAVE_METHOD_CMD.value.format(
-                    commit_msg=f"saved method at {str(time.time())}"
-                )
-            )
+            self.save_method()
 
-    def edit_initial_om(self, new_om: Union[int, float]):
-        self._validate_organic_modifier(new_om)
-        initial_organic_modifier: Param = Param(
-            val=new_om,
-            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-            ptype=PType.NUM,
+    def save_method(self):
+        self.send(
+            Command.SAVE_METHOD_CMD.value.format(
+                commit_msg=f"saved method at {str(time.time())}"
+            )
         )
-        self._update_param(initial_organic_modifier)
 
     def _validate_organic_modifier(self, new_om):
         if not (isinstance(new_om, int) or isinstance(new_om, float)):
@@ -237,13 +217,6 @@ class MethodController(RunController):
         if new_om > 100:
             raise ValueError("Organic modifer must be less than 100.")
 
-    def edit_flow(self, new_flow: Union[int, float]):
-        self._validate_flow(new_flow)
-        flow: Param = Param(
-            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
-        )
-        self._update_param(flow)
-
     def _validate_flow(self, new_flow):
         if not (isinstance(new_flow, int) or isinstance(new_flow, float)):
             raise ValueError("Flow must be int or float")
@@ -252,38 +225,12 @@ class MethodController(RunController):
         if new_flow >= 5.0:
             raise ValueError("Flow must be less than 5.0")
 
-    def edit_stop_time(self, new_stop_time: Union[int, float]):
-        self.validate_stop_time(new_stop_time)
-        stop_time: Param = Param(
-            val=new_stop_time,
-            chemstation_key=RegisterFlag.MAX_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(
-                val="Set", chemstation_key=RegisterFlag.STOPTIME_MODE, ptype=PType.STR
-            )
-        )
-        self._update_param(stop_time)
-
     def validate_stop_time(self, new_stop_time):
         if not (isinstance(new_stop_time, int) or isinstance(new_stop_time, float)):
             raise ValueError("Stop time must be int or float")
         if new_stop_time < 0:
             raise ValueError("Stop time must be positive")
 
-    def edit_post_time(self, new_post_time: Union[int, float]):
-        self.validate_post_time(new_post_time)
-        post_time: Param = Param(
-            val=new_post_time,
-            chemstation_key=RegisterFlag.POST_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(val="Set", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR)
-        )
-        self._update_param(post_time)
-
     def validate_post_time(self, new_post_time):
         if not (isinstance(new_post_time, int) or isinstance(new_post_time, float)):
             raise ValueError("Post time must be int or float")
@@ -298,59 +245,14 @@ class MethodController(RunController):
         new_post_time: Union[int, float] | None,
     ):
         self.delete_table()
-        self.edit_initial_om(new_initial_om)
+        self._validate_flow(new_flow)
+        self.validate_post_time(new_post_time)
+        self._validate_organic_modifier(new_initial_om)
+        self.validate_stop_time(new_stop_time)
         self.edit_flow(new_flow)
-        if new_stop_time:
-            self.edit_stop_time(new_stop_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.STOPTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-        if new_post_time:
-            self.edit_post_time(new_post_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.POSTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-
-    def _update_param(self, method_param: Param):
-        """Change a method parameter, changes what is visibly seen in Chemstation GUI.
-         (changes the first row in the timetable)
-
-        :param method_param: a parameter to update for currently loaded method.
-        """
-        register = self.table_locator.register
-        setting_command = (
-            TableOperation.UPDATE_OBJ_HDR_VAL
-            if method_param.ptype == PType.NUM
-            else TableOperation.UPDATE_OBJ_HDR_TEXT
-        )
-        if isinstance(method_param.chemstation_key, list):
-            for register_flag in method_param.chemstation_key:
-                self.sleepy_send(
-                    setting_command.value.format(
-                        register=register,
-                        register_flag=register_flag,
-                        val=method_param.val,
-                    )
-                )
-        else:
-            self.sleepy_send(
-                setting_command.value.format(
-                    register=register,
-                    register_flag=method_param.chemstation_key,
-                    val=method_param.val,
-                )
-            )
-        self.download()
+        self.edit_initial_om(new_initial_om)
+        self.edit_stop_time(new_stop_time)
+        self.edit_post_time(new_post_time)
 
     def download(self):
         self.sleepy_send("DownloadRCMethod PMP1")
@@ -585,3 +487,77 @@ class MethodController(RunController):
                     Row {i + 1} ({timetable[i].start_time}) has a smaller or equal starttime than row {i} ({start_time})"""
                 )
             self._validate_row(row)
+
+    def get_om(self):
+        return self._read_num_param(RegisterFlag.SOLVENT_B_COMPOSITION)
+
+    def get_flow(self):
+        return self._read_num_param(RegisterFlag.FLOW)
+
+    def get_post_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.POST_TIME)
+
+    def get_stop_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.MAX_TIME)
+
+    def edit_post_time(self, new_post_time: Optional[int | float]):
+        if new_post_time:
+            post_time: Param = Param(
+                val=new_post_time,
+                chemstation_key=RegisterFlag.POST_TIME,
+                ptype=PType.NUM,
+            )
+            self._update_param(
+                Param(
+                    val="Set",
+                    chemstation_key=RegisterFlag.POSTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+            self._update_param(post_time)
+        else:
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.POSTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+
+    def edit_stop_time(self, new_stop_time: Optional[int | float]):
+        if new_stop_time:
+            stop_time: Param = Param(
+                val=new_stop_time,
+                chemstation_key=RegisterFlag.MAX_TIME,
+                ptype=PType.NUM,
+            )
+            self._update_param(
+                Param(
+                    val="Set",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+            self._update_param(stop_time)
+        else:
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+
+    def edit_flow(self, new_flow: Union[int, float]):
+        flow: Param = Param(
+            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
+        )
+        self._update_param(flow)
+
+    def edit_initial_om(self, new_om: Union[int, float]):
+        initial_organic_modifier: Param = Param(
+            val=new_om,
+            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+            ptype=PType.NUM,
+        )
+        self._update_param(initial_organic_modifier)