pychemstation 0.8.4__py3-none-any.whl → 0.9.0__py3-none-any.whl

pychemstation/control/hplc.py

@@ -4,47 +4,47 @@ Module to provide API for higher-level HPLC actions.
 Authors: Lucy Hao
 """
 
-from typing import Union, Optional, List, Tuple
+from __future__ import annotations
 
-from .controllers.devices.injector import InjectorController
-from ..analysis.process_report import ReportType, AgilentReport
-from ..control.controllers import MethodController, SequenceController, CommunicationController
-from ..utils.chromatogram import AgilentChannelChromatogramData
-from ..utils.injector_types import InjectorTable
+from typing import Dict, List, Optional, Tuple, Union
+
+from pychemstation.analysis.chromatogram import (
+    AgilentHPLCChromatogram,
+)
+
+from ..analysis.process_report import AgilentReport, ReportType
+from ..control.controllers import (
+    CommunicationController,
+    MethodController,
+    SequenceController,
+)
+from pychemstation.analysis.chromatogram import AgilentChannelChromatogramData
 from ..utils.macro import Command, Response, Status
 from ..utils.method_types import MethodDetails
 from ..utils.sequence_types import SequenceTable
 from ..utils.table_types import Table
+from .controllers.devices.injector import InjectorController
 
 
 class HPLCController:
     # tables
-    METHOD_TIMETABLE = Table(
-        register="RCPMP1Method[1]",
-        name="Timetable"
-    )
-
-    SEQUENCE_TABLE = Table(
-        register="_sequence[1]",
-        name="SeqTable1"
-    )
-
-    INJECTOR_TABLE = Table(
-        register="RCWLS1Pretreatment[1]",
-        name="InstructionTable"
-    )
-
-    MSD_TABLE = Table(
-        register="MSACQINFO[1]",
-        name="SprayChamber"
-    )
-
-    def __init__(self,
-                 comm_dir: str,
-                 method_dir: str,
-                 sequence_dir: str,
-                 data_dirs: List[str],
-                 offline: bool = False):
+    METHOD_TIMETABLE = Table(register="RCPMP1Method[1]", name="Timetable")
+
+    SEQUENCE_TABLE = Table(register="_sequence[1]", name="SeqTable1")
+
+    INJECTOR_TABLE = Table(register="RCWLS1Pretreatment[1]", name="InstructionTable")
+
+    MSD_TABLE = Table(register="MSACQINFO[1]", name="SprayChamber")
+
+    def __init__(
+        self,
+        comm_dir: str,
+        method_dir: str,
+        sequence_dir: str,
+        data_dirs: List[str],
+        offline: bool = False,
+        debug: bool = False,
+    ):
         """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
         `comm_dir` must match the file path in the macro file. All file paths are normal strings, with the left slash
         double escaped: "C:\\my_folder\\"
@@ -56,21 +56,29 @@ class HPLCController:
         :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(comm_dir=comm_dir) if not offline else None
-        self.method_controller = 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(controller=self.comm,
-                                                      src=sequence_dir,
-                                                      data_dirs=data_dirs,
-                                                      table=self.SEQUENCE_TABLE,
-                                                      method_controller=self.method_controller,
-                                                      offline=offline)
+        self.comm = (
+            CommunicationController(comm_dir=comm_dir, debug=debug)
+            if not offline
+            else None
+        )
+        self.method_controller = 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(
+            controller=self.comm,
+            src=sequence_dir,
+            data_dirs=data_dirs,
+            table=self.SEQUENCE_TABLE,
+            method_controller=self.method_controller,
+            offline=offline,
+        )
 
     def send(self, cmd: Union[Command, str]):
         """
@@ -80,29 +88,32 @@ class HPLCController:
         """
         if not self.comm:
             raise RuntimeError(
-                "Communication controller must be initialized before sending command. It is currently in offline mode.")
+                "Communication controller must be initialized before sending command. It is currently in offline mode."
+            )
         self.comm.send(cmd)
 
     def receive(self) -> Response:
         """
         Get the most recent response from Chemstation.
 
-        :returns: most recent response from a macro that returned a response.
+        :return: most recent response from a macro that returned a response.
         """
         if not self.comm:
             raise RuntimeError(
-                "Communication controller must be initialized before sending command. It is currently in offline mode.")
+                "Communication controller must be initialized before sending command. It is currently in offline mode."
+            )
         return self.comm.receive().value
 
     def status(self) -> Status:
         """
         Get the current status of the HPLC machine.
 
-        :returns: current status of the HPLC machine; Status types can be found in `pychemstation.utils.macro`
+        :return: current status of the HPLC machine; Status types can be found in `pychemstation.utils.macro`
         """
         if not self.comm:
             raise RuntimeError(
-                "Communication controller must be initialized before sending command. It is currently in offline mode.")
+                "Communication controller must be initialized before sending command. It is currently in offline mode."
+            )
         return self.comm.get_status()
 
     def switch_method(self, method_name: str):
@@ -126,7 +137,12 @@ class HPLCController:
         """
         self.sequence_controller.switch(sequence_name)
 
-    def run_method(self, experiment_name: str, add_timestamp: bool = True, stall_while_running: bool = True):
+    def run_method(
+        self,
+        experiment_name: str,
+        add_timestamp: bool = True,
+        stall_while_running: bool = True,
+    ):
         """
         This is the preferred method to trigger a run.
         Starts the currently selected method, storing data
@@ -137,9 +153,11 @@ class HPLCController:
         :param stall_while_running: whether to return or stall while HPLC runs.
         :param add_timestamp: whether to append a timestamp in '%Y-%m-%d-%H-%M' format to end of experiment name.
         """
-        self.method_controller.run(experiment_name=experiment_name,
-                                   stall_while_running=stall_while_running,
-                                   add_timestamp=add_timestamp)
+        self.method_controller.run(
+            experiment_name=experiment_name,
+            stall_while_running=stall_while_running,
+            add_timestamp=add_timestamp,
+        )
 
     def stop_method(self):
         """Stops the current running method, manual intervention may be needed."""
@@ -159,7 +177,7 @@ class HPLCController:
         """
         Check if the currently running method (if any) is done.
 
-        :returns: the percent of the method run completed, and whether the run is complete.
+        :returns the percent of the method run completed, and whether the run is complete.
         """
         return self.method_controller.check_hplc_run_finished()
 
@@ -167,7 +185,7 @@ class HPLCController:
         """
         Check if the currently running sequence (if any) is done.
 
-        :returns: the percent of the sequence run completed, and whether the run is complete.
+        :return: the percent of the sequence run completed, and whether the run is complete.
         """
         return self.sequence_controller.check_hplc_run_finished()
 
@@ -188,47 +206,67 @@ class HPLCController:
         """
         self.sequence_controller.edit(updated_sequence)
 
-    def get_last_run_method_report(self,
-                                   custom_path: Optional[str] = None,
-                                   report_type: ReportType = ReportType.CSV) -> AgilentReport:
+    def get_last_run_method_report(
+        self,
+        custom_path: Optional[str] = None,
+        report_type: ReportType = ReportType.CSV,
+    ) -> AgilentReport:
         """
         Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
+
         :param custom_path: path to sequence folder
         :param report_type: read either the TXT or CSV version
-        :returns: report data for method
+        :return: report data for method
         """
-        return self.method_controller.get_report(custom_path=custom_path, report_type=report_type)[0]
+        return self.method_controller.get_report(
+            custom_path=custom_path, report_type=report_type
+        )[0]
 
-    def get_last_run_method_data(self, read_uv: bool = False,
-                                 data: Optional[str] = None) -> AgilentChannelChromatogramData:
+    def get_last_run_method_data(
+        self, read_uv: bool = False, custom_path: Optional[str] = None
+    ) -> Dict[str, AgilentHPLCChromatogram] | AgilentChannelChromatogramData:
         """
         Returns the last run method data.
 
-        :param data: If you want to just load method data but from a file path. This file path must be the complete file path.
+        :param custom_path: If you want to just load method data but from a file path. This file path must be the complete file path.
         :param read_uv: whether to also read the UV file
         """
-        return self.method_controller.get_data(custom_path=data, read_uv=read_uv)
-
-    def get_last_run_sequence_reports(self,
-                                      custom_path: Optional[str] = None,
-                                      report_type: ReportType = ReportType.CSV) -> List[AgilentReport]:
+        if read_uv:
+            return self.method_controller.get_data_uv(custom_path=custom_path)
+        else:
+            return self.method_controller.get_data(custom_path=custom_path)
+
+    def get_last_run_sequence_reports(
+        self,
+        custom_path: Optional[str] = None,
+        report_type: ReportType = ReportType.CSV,
+    ) -> List[AgilentReport]:
         """
         Return data contained in the REPORT files. Use `aghplctools` if you want more report processing utility.
+
         :param custom_path: path to sequence folder
         :param report_type: read either the TXT or CSV version
-        :returns: list of reports for each row
+        :return: list of reports for each row
         """
-        return self.sequence_controller.get_report(custom_path=custom_path, report_type=report_type)
-
-    def get_last_run_sequence_data(self, read_uv: bool = False,
-                                   data: Optional[str] = None) -> List[AgilentChannelChromatogramData]:
+        return self.sequence_controller.get_report(
+            custom_path=custom_path, report_type=report_type
+        )
+
+    def get_last_run_sequence_data(
+        self, read_uv: bool = False, custom_path: Optional[str] = None
+    ) -> (
+        List[Dict[int, AgilentHPLCChromatogram]] | List[AgilentChannelChromatogramData]
+    ):
         """
         Returns data for all rows in the last run sequence data.
 
-        :param data: If you want to just load sequence data but from a file path. This file path must be the complete file path.
+        :param custom_path: If you want to just load sequence data but from a file path. This file path must be the complete file path.
         :param read_uv: whether to also read the UV file
         """
-        return self.sequence_controller.get_data(custom_path=data, read_uv=read_uv)
+        if read_uv:
+            return self.sequence_controller.get_data_uv(custom_path=custom_path)
+        else:
+            return self.sequence_controller.get_data(custom_path=custom_path)
 
     def check_loaded_sequence(self) -> str:
         """Returns the name of the currently loaded sequence."""
@@ -238,10 +276,6 @@ class HPLCController:
         """Returns the name of the currently loaded method."""
         return self.method_controller.check()
 
-    def load_injector_program(self) -> InjectorTable:
-        """Returns all details of the injector program for the currently loaded method."""
-        return self.method_controller.injector_controller.load()
-
     def load_method(self) -> MethodDetails:
         """Returns details of the currently loaded method, such as its starting modifier conditions and timetable."""
         return self.method_controller.load()
@@ -255,7 +289,7 @@ class HPLCController:
         self.send(Command.STANDBY_CMD)
 
     def preprun(self):
-        """ Prepares all modules for run. All lamps and pumps are switched on."""
+        """Prepares all modules for run. All lamps and pumps are switched on."""
         self.send(Command.PREPRUN_CMD)
 
     def lamp_on(self):

pychemstation/generated/__init__.py

@@ -19,13 +19,11 @@ from .dad_method import (
     AnalogOutput1,
     AnalogOutput2,
     DadMethod,
-    PostTime,
     PrepareAutomation,
     PrepareMode,
     Signal,
     Signals,
     SpectraAcquisition,
-    StopTime,
 )
 
 __all__ = [

pychemstation/generated/dad_method.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Optional, List
+from typing import List, Optional
 
 
 @dataclass

pychemstation/generated/pump_method.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Optional, List
+from typing import List, Optional
 from xml.etree.ElementTree import QName
 
 
@@ -313,25 +313,21 @@ class SolventElement:
             "required": True,
         },
     )
-    channel1_extended_solvent_type: Optional[Channel1ExtendedSolventType] = (
-        field(
-            default=None,
-            metadata={
-                "name": "Channel1ExtendedSolventType",
-                "type": "Element",
-                "required": True,
-            },
-        )
+    channel1_extended_solvent_type: Optional[Channel1ExtendedSolventType] = field(
+        default=None,
+        metadata={
+            "name": "Channel1ExtendedSolventType",
+            "type": "Element",
+            "required": True,
+        },
     )
-    channel2_extended_solvent_type: Optional[Channel2ExtendedSolventType] = (
-        field(
-            default=None,
-            metadata={
-                "name": "Channel2ExtendedSolventType",
-                "type": "Element",
-                "required": True,
-            },
-        )
+    channel2_extended_solvent_type: Optional[Channel2ExtendedSolventType] = field(
+        default=None,
+        metadata={
+            "name": "Channel2ExtendedSolventType",
+            "type": "Element",
+            "required": True,
+        },
     )
 
 

pychemstation/utils/injector_types.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Union, Optional, List
+from typing import List, Optional, Union
 
 from pychemstation.utils.tray_types import Tray
 

pychemstation/utils/macro.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from enum import Enum
-from typing import Union
 from dataclasses import dataclass
+from enum import Enum
+from typing import Union, Any, Type
 
 
 @dataclass
@@ -15,7 +15,7 @@ class Response:
 # See https://www.agilent.com/cs/library/usermanuals/Public/MACROS.PDF
 class Command(Enum):
     def __str__(self):
-        return '%s' % self.value
+        return "%s" % self.value
 
     GET_NUM_VAL_CMD = "response_num = {cmd}"
     GET_TEXT_VAL_CMD = "response$ = {cmd}"
@@ -37,17 +37,17 @@ 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 _MethPath$, _MethFile$'
+    SWITCH_METHOD_CMD = "LoadMethod _MethPath$, _MethFile$"
     SWITCH_METHOD_CMD_SPECIFIC = 'LoadMethod "{method_dir}", "{method_name}.M"'
     START_METHOD_CMD = "StartMethod"
     RUN_METHOD_CMD = 'RunMethod "{data_dir}",, "{experiment_name}"'
     STOP_METHOD_CMD = "StopMethod"
-    UPDATE_METHOD_CMD = 'UpdateMethod'
-    SWITCH_SEQUENCE_CMD = 'LoadSequence _SeqPath$, _SeqFile$'
-    SAVE_SEQUENCE_CMD = 'SaveSequence _SeqPath$, _SeqFile$'
+    UPDATE_METHOD_CMD = "UpdateMethod"
+    SWITCH_SEQUENCE_CMD = "LoadSequence _SeqPath$, _SeqFile$"
+    SAVE_SEQUENCE_CMD = "SaveSequence _SeqPath$, _SeqFile$"
     SAVE_METHOD_CMD = 'SaveMethod _MethPath$, _MethFile$, "{commit_msg}"'
-    GET_SEQUENCE_CMD = 'response$ = _SeqFile$'
-    RUN_SEQUENCE_CMD = 'RunSequence'
+    GET_SEQUENCE_CMD = "response$ = _SeqFile$"
+    RUN_SEQUENCE_CMD = "RunSequence"
 
 
 class HPLCRunningStatus(Enum):
@@ -76,7 +76,6 @@ class HPLCAvailStatus(Enum):
 
 
 class HPLCErrorStatus(Enum):
-
     @classmethod
     def has_member_key(cls, key):
         return key in cls.__members__
@@ -87,7 +86,9 @@ class HPLCErrorStatus(Enum):
     MALFORMED = "MALFORMED"
 
 
-def str_to_status(status: str) -> Union[HPLCAvailStatus, HPLCErrorStatus, HPLCRunningStatus]:
+def str_to_status(
+    status: str,
+) -> Type[HPLCRunningStatus[Any] | HPLCErrorStatus[Any] | HPLCAvailStatus[Any]]:
     if HPLCErrorStatus.has_member_key(status):
         return HPLCErrorStatus[status]
     if HPLCRunningStatus.has_member_key(status):

pychemstation/utils/method_types.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Union, Any, Optional
+from typing import Any, Optional, Union
 
+from ..generated import Signal
 from .injector_types import InjectorTable
 from .table_types import RegisterFlag
-from ..generated import Signal
 
 
 class PType(Enum):
@@ -47,6 +47,7 @@ class MethodDetails:
     :attribute params: the organic modifier (pump B) and flow rate displayed for the method (the time 0 settings)
     :attribute dad_wavelengthes:
     """
+
     name: str
     params: HPLCMethodParams
     timetable: list[TimeTableEntry]

pychemstation/{analysis/utils.py → utils/num_utils.py}

@@ -11,7 +11,7 @@ def find_nearest_value_index(array, value) -> Tuple[float, int]:
     :param value: Target value.
     :type value: float
 
-    :returns: Nearest value in array and its index.
+    :return: Nearest value in array and its index.
     """
 
     index_ = np.argmin(np.abs(array - value))
@@ -34,7 +34,7 @@ def interpolate_to_index(array, ids, precision: int = 100) -> np.array:
     :type ids: np.array[float]
     :param precision: Desired presion.
 
-    :returns: New array with interpolated values according to provided indexes "ids".
+    :return: New array with interpolated values according to provided indexes "ids".
 
     Example:
         >>> interpolate_to_index(np.array([1.5]), np.array([1,2,3], 100))

pychemstation/utils/parsing.py

@@ -13,6 +13,7 @@ I use it for file with version 130, genereted by an Agilent LC.
 
 import struct
 from struct import unpack
+
 import numpy as np
 
 # Constants used for binary file parsing
@@ -26,7 +27,6 @@ UINT32 = ENDIAN + "I"
 
 
 def fread(fid, nelements, dtype):
-
     """Equivalent to Matlab fread function"""
 
     if dtype is str:
@@ -41,7 +41,6 @@ def fread(fid, nelements, dtype):
 
 
 def parse_utf16_string(file_, encoding="UTF16"):
-
     """Parse a pascal type UTF16 encoded string from a binary file object"""
 
     # First read the expected number of CHARACTERS
@@ -52,7 +51,6 @@ def parse_utf16_string(file_, encoding="UTF16"):
 
 
 class cached_property(object):
-
     """A property that is only computed once per instance and then replaces
     itself with an ordinary attribute. Deleting the attribute resets the
     property.
@@ -72,7 +70,6 @@ class cached_property(object):
 
 
 class CHFile(object):
-
     """Class that implementats the Agilent .ch file format version
     130. Warning: Not all aspects of the file header is understood,
     so there may and probably is information that is not parsed. See
@@ -121,7 +118,6 @@ class CHFile(object):
     supported_versions = {130}
 
     def __init__(self, filepath):
-
         self.filepath = filepath
         self.metadata = {}
         with open(self.filepath, "rb") as file_:
@@ -129,7 +125,6 @@ class CHFile(object):
             self.values = self._parse_data(file_)
 
     def _parse_header(self, file_):
-
         """Parse the header"""
 
         # Parse and check version
@@ -153,7 +148,6 @@ class CHFile(object):
                 ]
 
     def _parse_header_status(self):
-
         """Print known and unknown parts of the header"""
 
         file_ = open(self.filepath, "rb")
@@ -233,7 +227,6 @@ class CHFile(object):
         file_.close()
 
     def _parse_data(self, file_):
-
         """Parse the data. Decompress the delta-encoded data, and scale them
         with y-scaling"""
 
@@ -251,7 +244,6 @@ class CHFile(object):
         buff = [0, 0, 0, 0]
 
         while file_.tell() < stop:
-
             buff[0] = fread(file_, 1, INT16)[0][0]
             buff[1] = buff[3]
 
@@ -259,7 +251,6 @@ class CHFile(object):
                 break
 
             for i in range(buff[0] & 4095):
-
                 buff[2] = fread(file_, 1, INT16)[0][0]
 
                 if buff[2] != -32768:
@@ -278,7 +269,6 @@ class CHFile(object):
 
     @cached_property
     def times(self):
-
         """The time values (x-value) for the data set in minutes"""
 
         return np.linspace(

pychemstation/utils/sequence_types.py

@@ -1,17 +1,16 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from enum import Enum
-from typing import Optional, Union
-
-from pychemstation.utils.tray_types import TenVialColumn, Tray
+from typing import Optional, List
+from dataclasses import dataclass, field
+from pychemstation.utils.tray_types import Tray
 
 
 @dataclass
 class SequenceDataFiles:
     sequence_name: str
     dir: str
-    child_dirs: Optional[list[str]] = None
+    child_dirs: List[str] = field(default_factory=list)
 
 
 class SampleType(Enum):

pychemstation/{analysis → utils}/spec_utils.py

@@ -6,7 +6,7 @@ analysis.
 import numpy as np
 import scipy
 
-from .utils import find_nearest_value_index
+from ..utils.num_utils import find_nearest_value_index
 
 
 def create_binary_peak_map(data):
@@ -28,7 +28,6 @@ def create_binary_peak_map(data):
     peak_map = np.full_like(data_c, False, dtype=bool)
 
     for _ in range(100500):  # shouldn't take more iterations
-
         # looking for peaks
         peaks_found = np.logical_or(
             data_c > np.mean(data_c) + np.std(data_c) * 3,