pychemstation 0.10.6__py3-none-any.whl → 0.10.7.dev1__py3-none-any.whl

pychemstation/analysis/base_spectrum.py

@@ -2,6 +2,7 @@ import logging
 import os
 import pickle
 from abc import ABC, abstractmethod
+from typing import Optional, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -43,16 +44,15 @@ class AbstractSpectrum(ABC):
         "baseline",
     }
 
-    def __init__(self, path=None, autosaving=True):
+    def __init__(
+        self, path: Optional[Union[str, bool]] = None, autosaving: Optional[bool] = True
+    ):
         """Default constructor, loads properties into instance namespace.
 
         Can be redefined in ancestor classes.
 
-        Args:
-            path (Union[str, bool], optional): Valid path to save data to.
-                If omitted, uses ".//spectrum". If False - no folder created.
-            autosaving (bool, optional): If the True (default) will save the
-                spectrum when the new one is loaded. Will drop otherwise.
+        :param path: Valid path to save data to.  If omitted, uses ".//spectrum". If False - no folder created.
+        :param autosaving: If the True (default) will save the  spectrum when the new one is loaded. Will drop otherwise.
         """
 
         self.autosaving = autosaving
@@ -70,10 +70,10 @@ class AbstractSpectrum(ABC):
             self.path = os.path.join(".", "spectrum")
             os.makedirs(self.path, exist_ok=True)
         else:
-            try:
+            if isinstance(path, str):
                 os.makedirs(path, exist_ok=True)
                 self.path = path
-            except TypeError:  # type(path) -> bool
+            else:
                 self.path = "."
 
         # creating logger
@@ -86,15 +86,14 @@ class AbstractSpectrum(ABC):
         self.__init__(path=self.path, autosaving=self.autosaving)
 
     @abstractmethod
-    def load_spectrum(self, x, y, timestamp):
+    def load_spectrum(self, x: np.ndarray, y: np.ndarray, timestamp: float):
         """Loads the spectral data.
 
         This method must be redefined in ancestor classes.
 
-        Args:
-            x (:obj: np.array): An array with data to be plotted as "x" axis.
-            y (:obj: np.array): An array with data to be plotted as "y" axis.
-            timestamp (float): Timestamp to the corresponding spectrum.
+        :param x: An array with data to be plotted as "x" axis.
+        :param y: An array with data to be plotted as "y" axis.
+        :param timestamp: Timestamp to the corresponding spectrum.
         """
 
         try:
@@ -107,8 +106,8 @@ class AbstractSpectrum(ABC):
                 self.save_data()
             self._dump()
 
-        self.x = x
-        self.y = y
+        self.x: np.ndarray = x
+        self.y: np.ndarray = y
         self.timestamp = timestamp
 
     def save_data(self, filename=None, verbose=False):

pychemstation/analysis/chromatogram.py

@@ -3,7 +3,7 @@
 import os
 import time
 from dataclasses import dataclass
-from typing import Dict
+from typing import Dict, Tuple
 
 import numpy as np
 
@@ -80,15 +80,14 @@ class AgilentHPLCChromatogram(AbstractSpectrum):
 
     ### PUBLIC METHODS TO LOAD RAW DATA ###
 
-    def extract_rawdata(self, experiment_dir: str, channel: str):
-        """
-        Reads raw data from Chemstation .CH files.
+    def extract_rawdata(
+        self, experiment_dir: str, channel: str
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """Reads raw data from Chemstation .CH files.
 
-        Args:
-            experiment_dir: .D directory with the .CH files
+        :param experiment_dir: .D directory with the .CH files
 
-        Returns:
-            np.array(times), np.array(values)   Raw chromatogram data
+        :returns: np.array(times), np.array(values)   Raw chromatogram data
         """
         filename = os.path.join(experiment_dir, f"DAD1{channel}")
         npz_file = filename + ".npz"

pychemstation/analysis/process_report.py

@@ -65,8 +65,7 @@ class ReportProcessor(abc.ABC):
 
 class CSVProcessor(ReportProcessor):
     def __init__(self, path: str):
-        """
-        Class to process reports in CSV form.
+        """Class to process reports in CSV form.
 
         :param path: the parent folder that contains the CSV report(s) to parse.
         """
@@ -104,8 +103,7 @@ class CSVProcessor(ReportProcessor):
         return all_labels_seen
 
     def process_report(self) -> Result[AgilentReport, AnyStr]:
-        """
-        Method to parse details from CSV report.
+        """Method to parse details from CSV report.
 
         :return: subset of complete report details, specifically the sample location, solvents in pumps,
          and list of peaks at each wavelength channel.
@@ -176,9 +174,7 @@ class CSVProcessor(ReportProcessor):
 
 
 class TXTProcessor(ReportProcessor):
-    """
-    Regex matches for column and unit combinations, courtesy of Veronica Lai.
-    """
+    """Regex matches for column and unit combinations, courtesy of Veronica Lai."""
 
     _column_re_dictionary = {
         "Peak": {  # peak index
@@ -212,8 +208,7 @@ class TXTProcessor(ReportProcessor):
         max_ret_time: int = 999,
         target_wavelength_range=None,
     ):
-        """
-        Class to process reports in CSV form.
+        """Class to process reports in CSV form.
 
         :param path: the parent folder that contains the CSV report(s) to parse.
         :param min_ret_time: peaks after this value (min) will be returned
@@ -228,8 +223,7 @@ class TXTProcessor(ReportProcessor):
         super().__init__(path)
 
     def process_report(self) -> Result[AgilentReport, Union[AnyStr, Exception]]:
-        """
-        Method to parse details from CSV report.
+        """Method to parse details from CSV report.
         If you want more functionality, use `aghplctools`.
         `from aghplctools.ingestion.text import pull_hplc_area_from_txt`
         `signals = pull_hplc_area_from_txt(file_path)`
@@ -281,8 +275,7 @@ class TXTProcessor(ReportProcessor):
             return Err(e)
 
     def parse_area_report(self, report_text: str) -> Dict:
-        """
-        Interprets report text and parses the area report section, converting it to dictionary.
+        """Interprets report text and parses the area report section, converting it to dictionary.
         Courtesy of Veronica Lai.
 
         :param report_text: plain text version of the report.
@@ -340,8 +333,7 @@ class TXTProcessor(ReportProcessor):
         return signals
 
     def build_peak_regex(self, signal_table: str) -> Pattern[str] | None:
-        """
-        Builds a peak regex from a signal table. Courtesy of Veronica Lai.
+        """Builds a peak regex from a signal table. Courtesy of Veronica Lai.
 
         :param signal_table: block of lines associated with an area table
         :return: peak line regex object (<=3.6 _sre.SRE_PATTERN, >=3.7 re.Pattern)

pychemstation/control/README.md

@@ -10,7 +10,7 @@ DATA_DIR_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
 DATA_DIR_3 = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
 
 # Initialize HPLC Controller
-hplc_controller = HPLCController(data_dirs=[DATA_DIR_2, DATA_DIR_3],
+hplc_controller = HPLCController(extra_data_dirs=[DATA_DIR_2, DATA_DIR_3],
                                  comm_dir=DEFAULT_COMMAND_PATH,
                                  method_dir=DEFAULT_METHOD_DIR,
                                  sequence_dir=SEQUENCE_DIR)
@@ -70,7 +70,7 @@ seq_table = SequenceTable(
             inj_source=InjectionSource.MANUAL
         ),
         SequenceEntry(
-            vial_location=TenVialColumn.ONE,
+            vial_location=VialBar.ONE,
             method="General-Poroshell",
             num_inj=1,
             inj_vol=1,

pychemstation/control/controllers/__init__.py

@@ -4,5 +4,6 @@
 
 from .comm import CommunicationController
 from . import data_aq
+from . import devices
 
-__all__ = ["CommunicationController", "data_aq"]
+__all__ = ["CommunicationController", "data_aq", "devices"]

pychemstation/control/controllers/comm.py

@@ -11,22 +11,27 @@ Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
 
 import time
-from typing import Optional, Union
+from typing import Optional, Union, Tuple, List
 
 from result import Err, Ok, Result
 
+from ...utils.abc_tables.abc_comm import ABCCommunicationController
 from ...utils.macro import (
-    str_to_status,
-    HPLCErrorStatus,
     Command,
+    HPLCErrorStatus,
     Status,
+    str_to_status,
 )
-from ...utils.mocking.abc_comm import ABCCommunicationController
 
 
 class CommunicationController(ABCCommunicationController):
-    """
-    Class that communicates with Agilent using Macros
+    """Class that communicates with Agilent using Macros
+
+    :param comm_dir: the complete directory path that was used in the MACRO file, common file that pychemstation and Chemstation use to communicate.
+    :param cmd_file: name of the write file that pychemstation writes MACROs to, in `comm_dir`
+    :param reply_file: name of the read file that Chemstation replies to, in `comm_dir
+    :param offline: whether or not communication with Chemstation is to be established
+    :param debug: if True, prints all send MACROs to an out.txt file
     """
 
     def __init__(
@@ -37,12 +42,6 @@ class CommunicationController(ABCCommunicationController):
         offline: bool = False,
         debug: bool = False,
     ):
-        """
-        :param comm_dir:
-        :param cmd_file: Name of command file
-        :param reply_file: Name of reply file
-        :param debug: whether to save log of sent commands
-        """
         super().__init__(comm_dir, cmd_file, reply_file, offline, debug)
 
     def get_num_val(self, cmd: str) -> Union[int, float]:
@@ -76,7 +75,7 @@ class CommunicationController(ABCCommunicationController):
             if res.is_err():
                 return HPLCErrorStatus.NORESPONSE
             if res.is_ok():
-                parsed_response = self.receive().value.string_response
+                parsed_response = self.receive().ok_value.string_response
                 self._most_recent_hplc_status = str_to_status(parsed_response)
                 return self._most_recent_hplc_status
             else:
@@ -148,3 +147,31 @@ class CommunicationController(ABCCommunicationController):
             return Err(
                 f"Failed to receive reply to command #{cmd_no} due to {err} caused by {err_msg}."
             )
+
+    def get_chemstation_dirs(self) -> Tuple[str, str, List[str]]:
+        method_dir, sequence_dir, data_dirs = None, None, None
+        for _ in range(10):
+            self.send(Command.GET_METHOD_DIR)
+            res = self.receive()
+            if res.is_ok():
+                method_dir = res.ok_value.string_response
+            self.send(Command.GET_SEQUENCE_DIR)
+            res = self.receive()
+            if res.is_ok():
+                sequence_dir = res.ok_value.string_response
+            self.send(Command.GET_DATA_DIRS)
+            res = self.receive()
+            if res.is_ok():
+                data_dirs = res.ok().string_response.split("|")
+            if method_dir and sequence_dir and data_dirs:
+                if not sequence_dir[0].isalpha():
+                    sequence_dir = "C:" + sequence_dir
+                if not method_dir[0].isalpha():
+                    method_dir = "C:" + method_dir
+                for i, data_dir in enumerate(data_dirs):
+                    if not data_dir[0].isalpha():
+                        data_dirs[i] = "C:" + data_dir
+                return method_dir, sequence_dir, data_dirs
+        raise ValueError(
+                f"One of the method: {method_dir}, sequence: {sequence_dir} or data directories: {data_dirs} could not be found, please provide your own."
+            )

pychemstation/control/controllers/data_aq/method.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 import os
 import time
 import warnings
-from typing import List, Optional, Union, Dict
+from typing import List, Optional, Union, Dict, Set
 
 from result import Err, Ok, Result
 
-from ..abc_tables.run import RunController
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
 from pychemstation.analysis.chromatogram import (
@@ -15,6 +14,7 @@ from pychemstation.analysis.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
+from ....utils.abc_tables.run import RunController
 from ....utils.macro import Command
 from ....utils.method_types import (
     HPLCMethodParams,
@@ -28,15 +28,13 @@ from ..devices.injector import InjectorController
 
 
 class MethodController(RunController):
-    """
-    Class containing method related logic
-    """
+    """Class containing method related logic."""
 
     def __init__(
         self,
-        controller: CommunicationController,
-        src: str,
-        data_dirs: List[str],
+        controller: Optional[CommunicationController],
+        src: Optional[str],
+        data_dirs: Optional[List[str]],
         table: Table,
         offline: bool,
         injector_controller: InjectorController,
@@ -51,7 +49,7 @@ class MethodController(RunController):
             offline=offline,
         )
 
-    def check(self) -> str:
+    def get_current_method_name(self) -> str:
         time.sleep(2)
         self.send(Command.GET_METHOD_CMD)
         time.sleep(2)
@@ -413,8 +411,6 @@ class MethodController(RunController):
         :param stall_while_running: whether to stall or immediately return
         :param add_timestamp: if should add timestamp to experiment name
         """
-
-        folder_name = ""
         hplc_is_running = False
         tries = 0
         while tries < 10 and not hplc_is_running:
@@ -427,18 +423,15 @@ class MethodController(RunController):
                     else experiment_name,
                 )
             )
-            folder_name = (
-                f"{experiment_name}_{timestamp}.D"
-                if add_timestamp
-                else f"{experiment_name}.D"
-            )
+
             hplc_is_running = self.check_hplc_is_running()
             tries += 1
 
+        data_dir, data_file = self.get_current_run_data_dir_file()
         if not hplc_is_running:
             raise RuntimeError("Method failed to start.")
 
-        self.data_files.append(os.path.join(self.data_dirs[0], folder_name))
+        self.data_files.append(os.path.join(os.path.normpath(data_dir), data_file))
         self.timeout = (self.get_total_runtime()) * 60
 
         if stall_while_running:
@@ -446,18 +439,22 @@ class MethodController(RunController):
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
-                raise RuntimeError("Run error has occurred.")
+                warnings.warn(run_completed.err_value)
         else:
-            folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
-            while folder.is_err():
-                folder = self.fuzzy_match_most_recent_folder(self.data_files[-1])
+            folder = self._fuzzy_match_most_recent_folder(self.data_files[-1], None)
+            i = 0
+            while folder.is_err() and i < 10:
+                folder = self._fuzzy_match_most_recent_folder(self.data_files[-1], None)
+                i+=1
             if folder.is_ok():
                 self.data_files[-1] = folder.ok_value
             else:
                 warning = f"Data folder {self.data_files[-1]} may not exist, returning and will check again after run is done."
                 warnings.warn(warning)
 
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[str, str]:
+    def _fuzzy_match_most_recent_folder(
+        self, most_recent_folder: T, child_dirs: Optional[Set[str]]
+    ) -> Result[str, str]:
         if isinstance(most_recent_folder, str) or isinstance(most_recent_folder, bytes):
             if os.path.exists(most_recent_folder):
                 return Ok(most_recent_folder)