pychemstation 0.10.2__py3-none-any.whl → 0.10.4__py3-none-any.whl

pychemstation/control/hplc.py

@@ -3,57 +3,48 @@ Module to provide API for higher-level HPLC actions.
 
 Authors: Lucy Hao
 """
+
 from __future__ import annotations
 
 from typing import Dict, List, Optional, Tuple, Union
 
-from pychemstation.utils.chromatogram import (
+from pychemstation.analysis.chromatogram import (
     AgilentHPLCChromatogram,
 )
-from .controllers.devices.injector import InjectorController
+
 from ..analysis.process_report import AgilentReport, ReportType
 from ..control.controllers import (
     CommunicationController,
     MethodController,
     SequenceController,
 )
-from ..utils.chromatogram import AgilentChannelChromatogramData
-from ..utils.injector_types import InjectorTable
+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,
-                 debug: 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\\"
@@ -65,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, 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)
+        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]):
         """
@@ -89,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):
@@ -135,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
@@ -146,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."""
@@ -168,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()
 
@@ -176,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()
 
@@ -197,19 +206,25 @@ 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,
-                                 custom_path: Optional[str] = None) -> Dict[str, AgilentHPLCChromatogram] | 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.
 
@@ -221,20 +236,27 @@ class HPLCController:
         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]:
+    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,
-                                   custom_path: Optional[str] = None) -> List[Dict[str, AgilentHPLCChromatogram]] | \
-                                                                         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.
 
@@ -254,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()
@@ -271,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/pump_method.py

@@ -313,25 +313,21 @@ class SolventElement:
             "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,
-            },
-        )
+    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,
+        },
     )
 
 

pychemstation/utils/macro.py

@@ -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) -> Type[HPLCRunningStatus[Any] | HPLCErrorStatus[Any] | HPLCAvailStatus[Any]]:
+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

@@ -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/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

@@ -27,7 +27,6 @@ UINT32 = ENDIAN + "I"
 
 
 def fread(fid, nelements, dtype):
-
     """Equivalent to Matlab fread function"""
 
     if dtype is str:
@@ -42,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
@@ -53,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.
@@ -73,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
@@ -122,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_:
@@ -130,7 +125,6 @@ class CHFile(object):
             self.values = self._parse_data(file_)
 
     def _parse_header(self, file_):
-
         """Parse the header"""
 
         # Parse and check version
@@ -154,7 +148,6 @@ class CHFile(object):
                 ]
 
     def _parse_header_status(self):
-
         """Print known and unknown parts of the header"""
 
         file_ = open(self.filepath, "rb")
@@ -234,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"""
 
@@ -252,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]
 
@@ -260,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:
@@ -279,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,9 +1,8 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from enum import Enum
 from typing import Optional, List
-
+from dataclasses import dataclass, field
 from pychemstation.utils.tray_types import Tray
 
 
@@ -11,7 +10,7 @@ from pychemstation.utils.tray_types import Tray
 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/utils/spec_utils.py

@@ -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,
@@ -156,14 +155,14 @@ def filter_noisy_regions(y_data, peaks_regions):
     # compute the actual regions data points
     y_data_regions = []
     for region in peaks_regions:
-        y_data_regions.append(y_data[region[0]: region[-1]])
+        y_data_regions.append(y_data[region[0] : region[-1]])
 
     # compute noise data regions, i.e. in between peak regions
     noise_data_regions = []
     for row, _ in enumerate(peaks_regions):
         try:
             noise_data_regions.append(
-                y_data[peaks_regions[row][1]: peaks_regions[row + 1][0]]
+                y_data[peaks_regions[row][1] : peaks_regions[row + 1][0]]
             )
         except IndexError:
             # exception for the last row -> discard

pychemstation/utils/table_types.py

@@ -7,28 +7,30 @@ from typing import TypeVar
 
 class TableOperation(Enum):
     def __str__(self):
-        return '%s' % self.value
+        return "%s" % self.value
 
     DELETE_TABLE = 'DelTab {register}, "{table_name}"'
     CREATE_TABLE = 'NewTab {register}, "{table_name}"'
     NEW_ROW = 'InsTabRow {register}, "{table_name}"'
     DELETE_ROW = 'DelTabRow {register}, "{table_name}", {row}'
     EDIT_ROW_VAL = 'SetTabVal "{register}", "{table_name}", {row}, "{col_name}", {val}'
-    EDIT_ROW_TEXT = 'SetTabText "{register}", "{table_name}", {row}, "{col_name}", "{val}"'
+    EDIT_ROW_TEXT = (
+        'SetTabText "{register}", "{table_name}", {row}, "{col_name}", "{val}"'
+    )
     GET_ROW_VAL = 'TabVal("{register}", "{table_name}", {row}, "{col_name}")'
     GET_ROW_TEXT = 'TabText$("{register}", "{table_name}", {row}, "{col_name}")'
     GET_NUM_ROWS = 'Rows = TabHdrVal({register}, "{table_name}", "{col_name}")'
     GET_OBJ_HDR_VAL = 'ObjHdrVal("{register}", "{register_flag}")'
     GET_OBJ_HDR_TEXT = 'ObjHdrText$("{register}", "{register_flag}")'
-    UPDATE_OBJ_HDR_VAL = 'SetObjHdrVal {register}, {register_flag}, {val}'
-    UPDATE_OBJ_HDR_TEXT = 'SetObjHdrText {register}, {register_flag}, {val}'
+    UPDATE_OBJ_HDR_VAL = "SetObjHdrVal {register}, {register_flag}, {val}"
+    UPDATE_OBJ_HDR_TEXT = "SetObjHdrText {register}, {register_flag}, {val}"
     NEW_COL_TEXT = 'NewColText {register}, "{table_name}", "{col_name}", "{val}"'
     NEW_COL_VAL = 'NewColVal {register}, "{table_name}", "{col_name}", {val}'
 
 
 class RegisterFlag(Enum):
     def __str__(self):
-        return '%s' % self.value
+        return "%s" % self.value
 
     # for table
     NUM_ROWS = "NumberOfRows"
@@ -40,7 +42,7 @@ class RegisterFlag(Enum):
     SOLVENT_D_COMPOSITION = "PumpChannel4_CompositionPercentage"
     FLOW = "Flow"
     MAX_TIME = "StopTime_Time"
-    POST_TIME = "PostTime_Time" #TODO: check
+    POST_TIME = "PostTime_Time"  # TODO: check
     COLUMN_OVEN_TEMP1 = "TemperatureControl_Temperature"
     COLUMN_OVEN_TEMP2 = "TemperatureControl2_Temperature"
     STOPTIME_MODE = "StopTime_Mode"
@@ -55,7 +57,6 @@ class RegisterFlag(Enum):
     EXTERNAL_CONTACT = "ExternalContact"
     FUNCTION = "Function"
 
-
     # for Sequence
     VIAL_LOCATION = "Vial"
     NAME = "SampleName"
@@ -86,10 +87,10 @@ class RegisterFlag(Enum):
     REMOTE_DUR = "RemoteDuration"
 
 
-
 @dataclass
 class Table:
     register: str
     name: str
 
-T = TypeVar('T')
+
+T = TypeVar("T")