pychemstation 0.8.3__py3-none-any.whl → 0.10.1__py3-none-any.whl

pychemstation/analysis/__init__.py

@@ -1 +1,5 @@
 from .base_spectrum import AbstractSpectrum
+
+__all__ = [
+    'AbstractSpectrum',
+]

pychemstation/analysis/base_spectrum.py

@@ -6,12 +6,12 @@ from abc import ABC, abstractmethod
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy import (
-    sparse,
-    signal,
     integrate,
+    signal,
+    sparse,
 )
 
-from .utils import interpolate_to_index, find_nearest_value_index
+from ..utils.num_utils import find_nearest_value_index, interpolate_to_index
 
 
 class AbstractSpectrum(ABC):
@@ -197,10 +197,10 @@ class AbstractSpectrum(ABC):
             return (self.x.copy()[full_mask], self.y.copy()[full_mask])
 
     def show_spectrum(
-        self,
-        filename=None,
-        title=None,
-        label=None,
+            self,
+            filename=None,
+            title=None,
+            label=None,
     ):
         """Plots the spectral data using matplotlib.pyplot module.
 
@@ -385,12 +385,12 @@ class AbstractSpectrum(ABC):
 
         if rule == "trapz":
             return integrate.trapz(
-                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
+                self.y[left_idx: right_idx + 1], self.x[left_idx: right_idx + 1]
             )
 
         elif rule == "simps":
             return integrate.simps(
-                self.y[left_idx : right_idx + 1], self.x[left_idx : right_idx + 1]
+                self.y[left_idx: right_idx + 1], self.x[left_idx: right_idx + 1]
             )
 
         else:

pychemstation/analysis/process_report.py

@@ -4,15 +4,21 @@ import re
 from abc import abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, AnyStr, Dict, Optional, Pattern
+from typing import AnyStr, Dict, List, Optional, Pattern
 
 import pandas as pd
-from aghplctools.ingestion.text import _no_peaks_re, _area_report_re, _header_block_re, _signal_info_re, \
-    _signal_table_re, chunk_string
-from result import Result, Err, Ok
+from aghplctools.ingestion.text import (
+    _area_report_re,
+    _header_block_re,
+    _no_peaks_re,
+    _signal_info_re,
+    _signal_table_re,
+    chunk_string,
+)
+from result import Err, Ok, Result
 
 from pychemstation.utils.chromatogram import AgilentHPLCChromatogram
-from pychemstation.utils.tray_types import Tray, FiftyFourVialPlate
+from pychemstation.utils.tray_types import FiftyFourVialPlate, Tray
 
 
 @dataclass
@@ -70,7 +76,7 @@ class CSVProcessor(ReportProcessor):
         :returns: subset of complete report details, specifically the sample location, solvents in pumps,
          and list of peaks at each wavelength channel.
         """
-        labels = os.path.join(self.path, f'REPORT00.CSV')
+        labels = os.path.join(self.path, 'REPORT00.CSV')
         if os.path.exists(labels):
             df_labels: Dict[int, Dict[int: AnyStr]] = pd.read_csv(labels, encoding="utf-16", header=None).to_dict()
             vial_location = []
@@ -200,7 +206,7 @@ class TXTProcessor(ReportProcessor):
         should be able to use the `parse_area_report` method of aghplctools v4.8.8
         """
         if re.search(_no_peaks_re, report_text):  # There are no peaks in Report.txt
-            raise ValueError(f'No peaks found in Report.txt')
+            raise ValueError('No peaks found in Report.txt')
         blocks = _header_block_re.split(report_text)
         signals = {}  # output dictionary
         for ind, block in enumerate(blocks):

pychemstation/control/README.md

@@ -1,6 +1,7 @@
-#  Examples of usecases
+# Examples of usecases
 
 ## Initialization
+
 ```python
 from pychemstation.control import HPLCController
 
@@ -16,6 +17,7 @@ hplc_controller = HPLCController(data_dir=DATA_DIR,
 ```
 
 ## Switching a method
+
 ```python
 hplc_controller.switch_method("General-Poroshell")
 ```
@@ -50,6 +52,7 @@ hplc_controller.edit_method(new_method)
 ```
 
 ## Running a method and get data from last run method
+
 ```python
 hplc_controller.run_method(experiment_name="test_experiment")
 chrom = hplc_controller.get_last_run_method_data()
@@ -57,10 +60,13 @@ channel_a_time = chrom.A.x
 ```
 
 ## Switching a sequence
+
 ```python
 hplc_controller.switch_sequence(sequence_name="hplc_testing")
 ```
+
 ## Editing a Sequence Row
+
 ```python
 from pychemstation.utils.sequence_types import *
 from pychemstation.utils.tray_types import *
@@ -77,6 +83,7 @@ hplc_controller.edit_sequence_row(SequenceEntry(
 ```
 
 ## Editing entire Sequence Table
+
 ```python
 from pychemstation.utils.tray_types import *
 from pychemstation.utils.sequence_types import *
@@ -117,6 +124,7 @@ hplc_controller.edit_sequence(seq_table)
 ```
 
 ## Running a sequence and get data from last run sequence
+
 ```python
 hplc_controller.run_sequence(seq_table)
 chroms = hplc_controller.get_last_run_sequence_data()

pychemstation/control/__init__.py

@@ -2,3 +2,7 @@
 .. include:: README.md
 """
 from .hplc import HPLCController
+
+__all__ = [
+    'HPLCController',
+]

pychemstation/control/controllers/__init__.py

@@ -5,3 +5,9 @@
 from .comm import CommunicationController
 from .tables.method import MethodController
 from .tables.sequence import SequenceController
+
+__all__ = [
+    'CommunicationController',
+    'MethodController',
+    'SequenceController'
+]

pychemstation/control/controllers/comm.py

@@ -11,11 +11,18 @@ Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
 """
 import os
 import time
-from typing import Optional
+from typing import Optional, Union
 
-from result import Result, Ok, Err
+from result import Err, Ok, Result
 
-from ...utils.macro import *
+from ...utils.macro import (
+    str_to_status,
+    HPLCAvailStatus,
+    HPLCErrorStatus,
+    Command,
+    Status,
+    Response,
+)
 
 
 class CommunicationController:
@@ -193,14 +200,14 @@ class CommunicationController:
         str_response_prefix = "String Responses:"
         possible_response = self._receive(self.cmd_no)
         if possible_response.is_ok():
-            lines = possible_response.value.splitlines()
+            lines = possible_response.ok_value.splitlines()
             for line in lines:
                 if str_response_prefix in line and num_response_prefix in line:
                     string_responses_dirty, _, numerical_responses = line.partition(num_response_prefix)
                     _, _, string_responses = string_responses_dirty.partition(str_response_prefix)
                     return Ok(Response(string_response=string_responses.strip(),
                                        num_response=float(numerical_responses.strip())))
-            return Err(f"Could not retrieve HPLC response")
+            return Err("Could not retrieve HPLC response")
         else:
             return Err(f"Could not establish response to HPLC: {possible_response}")
 

pychemstation/control/controllers/devices/device.py

@@ -1,13 +1,13 @@
 import abc
-from typing import Union, List
+from typing import List, Union, Dict, Optional
 
 from result import Result
 
-from ....analysis.process_report import ReportType, AgilentReport
+from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
 from ....control.controllers.tables.table import TableController
-from ....utils.chromatogram import AgilentChannelChromatogramData
-from ....utils.table_types import Table, T
+from ....utils.chromatogram import AgilentChannelChromatogramData, AgilentHPLCChromatogram
+from ....utils.table_types import T, Table
 
 
 class DeviceController(TableController, abc.ABC):
@@ -26,11 +26,14 @@ class DeviceController(TableController, abc.ABC):
     def retrieve_recent_data_files(self):
         raise NotImplementedError
 
-    def get_data(self) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
-        raise NotImplementedError
-
     def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         raise NotImplementedError
 
     def get_report(self, report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
         raise NotImplementedError
+
+    def get_data_uv(self) -> Union[List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]]:
+        raise NotImplementedError
+
+    def get_data(self, custom_path: Optional[str] = None) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        raise NotImplementedError

pychemstation/control/controllers/devices/injector.py

@@ -1,8 +1,19 @@
-from ....control.controllers import CommunicationController
+from __future__ import annotations
+
 from .device import DeviceController
-from ....utils.injector_types import *
-from ....utils.macro import Command
-from ....utils.table_types import Table, RegisterFlag
+from ....control.controllers import CommunicationController
+from ....utils.injector_types import (
+    Draw,
+    Inject,
+    InjectorTable,
+    Mode,
+    Remote,
+    RemoteCommand,
+    SourceType,
+    Wait,
+)
+from ....utils.table_types import RegisterFlag, Table
+from ....utils.tray_types import Tray
 
 
 class InjectorController(DeviceController):
@@ -10,7 +21,7 @@ class InjectorController(DeviceController):
     def __init__(self, controller: CommunicationController, table: Table, offline: bool):
         super().__init__(controller, table, offline)
 
-    def get_row(self, row: int) -> InjectorFunction:
+    def get_row(self, row: int) -> None | Remote | Draw | Wait | Inject:
         def return_tray_loc() -> Tray:
             pass
 
@@ -32,86 +43,9 @@ class InjectorController(DeviceController):
             return Remote(command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
                           duration=self.get_num(row, RegisterFlag.REMOTE_DUR))
 
-    def load(self) -> InjectorTable:
+    def load(self) -> InjectorTable | None:
         rows = self.get_num_rows()
         if rows.is_ok():
             return InjectorTable(functions=[self.get_row(i) for i in range(int(rows.ok_value.num_response))])
 
-    def edit(self, injector_table: InjectorTable):
-        columns_added = set()
-
-        def add_table_val(col_name: RegisterFlag, val: Union[str, int, float]):
-            nonlocal columns_added
-            if True:
-                if isinstance(val, str):
-                    self._edit_row_text(col_name=col_name, val=val)
-                else:
-                    self._edit_row_num(col_name=col_name, val=val)
-            else:
-                if isinstance(val, str):
-                    self.add_new_col_text(col_name=col_name, val=val)
-                else:
-                    self.add_new_col_num(col_name=col_name, val=val)
-                columns_added.add(col_name)
-
-        def add_inject(inject: Inject):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=inject.__class__.__name__)
-
-        def add_draw(draw: Draw):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=draw.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.DRAW_SPEED, val=SourceType.DEFAULT.value)
-            add_table_val(col_name=RegisterFlag.DRAW_OFFSET, val=SourceType.DEFAULT.value)
-
-            if draw.amount:
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.SET.value)
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME_VALUE, val=draw.amount)
-            else:
-                add_table_val(col_name=RegisterFlag.DRAW_VOLUME, val=Mode.DEFAULT.value)
-
-            if draw.location:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.LOCATION.value)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION, val=draw.location)
-            elif draw.source:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.SPECIFIC_LOCATION.value)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_UNIT, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_TRAY, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_ROW, val=1)
-                add_table_val(col_name=RegisterFlag.DRAW_LOCATION_COLUMN, val=1)
-            else:
-                add_table_val(col_name=RegisterFlag.DRAW_SOURCE, val=SourceType.DEFAULT.value)
-
-        def add_wait(wait: Wait):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=wait.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.TIME, val=wait.duration)
-
-        def add_remote(remote: Remote):
-            add_table_val(col_name=RegisterFlag.FUNCTION, val=remote.__class__.__name__)
-            add_table_val(col_name=RegisterFlag.REMOTE, val=remote.command.value)
-            add_table_val(col_name=RegisterFlag.REMOTE_DUR, val=remote.duration)
-
-        self.send(Command.SAVE_METHOD_CMD)
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            existing_row_num = rows.value.num_response
-            for i, function in enumerate(injector_table.functions):
-                if (i+1) > existing_row_num:
-                    self.add_row()
-                if isinstance(function, Inject):
-                    add_inject(function)
-                elif isinstance(function, Draw):
-                    add_draw(function)
-                elif isinstance(function, Wait):
-                    add_wait(function)
-                elif isinstance(function, Remote):
-                    add_remote(function)
-                self.download()
-                self.send(Command.SAVE_METHOD_CMD)
-                self.send(Command.SWITCH_METHOD_CMD)
-                existing_row_num = self.get_num_rows().ok_value.num_response
-
-    def download(self):
-        self.send('Sleep 1')
-        self.sleepy_send("DownloadRCMethod WLS1")
-        self.send('Sleep 1')
-        self.sleepy_send("DownloadLWls 1")
-        self.send('Sleep 1')
+   

pychemstation/control/controllers/tables/method.py

@@ -1,6 +1,7 @@
 import os
 import time
-from typing import List
+import warnings
+from typing import Dict, List, Optional, Union
 
 from result import Err, Ok, Result
 from xsdata.formats.dataclass.parsers import XmlParser
@@ -13,9 +14,15 @@ from ....utils.chromatogram import (
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
-from ....utils.macro import *
-from ....utils.method_types import *
-from ....utils.table_types import *
+from ....utils.macro import Command
+from ....utils.method_types import (
+    HPLCMethodParams,
+    MethodDetails,
+    Param,
+    PType,
+    TimeTableEntry,
+)
+from ....utils.table_types import RegisterFlag, T, Table, TableOperation
 from ..devices.injector import InjectorController
 from .table import TableController
 
@@ -129,6 +136,10 @@ class MethodController(TableController):
                 register=self.table_locator.register,
                 register_flag=RegisterFlag.MAX_TIME))
 
+    def get_total_runtime(self) -> Union[int, float]:
+        """Returns total method runtime in minutes."""
+        return self.get_post_time() + self.get_stop_time()
+
     def current_method(self, method_name: str):
         """
         Checks if a given method is already loaded into Chemstation. Method name does not need the ".M" extension.
@@ -173,6 +184,7 @@ class MethodController(TableController):
         :raises FileNotFoundError: Method does not exist
         :return: method details
         """
+        warnings.warn("This method is not actively maintained.")
         method_folder = f"{method_name}.M"
         method_path = os.path.join(self.src, method_folder, "AgilentPumpDriver1.RapidControl.MethodXML.xml")
         dad_path = os.path.join(self.src, method_folder, "Agilent1200erDadDriver1.RapidControl.MethodXML.xml")
@@ -347,29 +359,39 @@ class MethodController(TableController):
             raise RuntimeError("Method failed to start.")
 
         self.data_files.append(os.path.join(self.data_dirs[0], folder_name))
+        self.timeout = (self.get_total_runtime()) * 60
 
         if stall_while_running:
-            self.timeout = (self.get_stop_time() + self.get_post_time()) * 60
             run_completed = self.check_hplc_done_running()
             if run_completed.is_ok():
                 self.data_files[-1] = run_completed.ok_value
             else:
                 raise RuntimeError("Run error has occurred.")
         else:
-            self.data_files[-1] = self.fuzzy_match_most_recent_folder(folder_name).ok_value
+            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])
+            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[T, str]:
         if os.path.exists(most_recent_folder):
             return Ok(most_recent_folder)
         return Err("Folder not found!")
 
-    def get_data(self, custom_path: Optional[str] = None,
-                 read_uv: bool = False) -> AgilentChannelChromatogramData:
-        if not custom_path:
-            self.get_spectrum(self.data_files[-1], read_uv)
-        else:
-            self.get_spectrum(custom_path, read_uv)
-        return AgilentChannelChromatogramData(**self.spectra) if not read_uv else self.uv
+    def get_data(self, custom_path: Optional[str] = None) -> AgilentChannelChromatogramData:
+        custom_path = custom_path if custom_path else self.data_files[-1]
+        self.get_spectrum_at_channels(custom_path)
+        return AgilentChannelChromatogramData(**self.spectra)
+
+    def get_data_uv(self, custom_path: Optional[str] = None) -> Dict[str, AgilentHPLCChromatogram]:
+        custom_path = custom_path if custom_path else self.data_files[-1]
+        self.get_uv_spectrum(custom_path)
+        return self.uv
 
     def get_report(self, custom_path: Optional[str] = None,
                    report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:

pychemstation/control/controllers/tables/sequence.py

@@ -1,19 +1,29 @@
 import os
 import time
-from typing import Optional, List, Dict
+from typing import Dict, List, Optional
 
-from result import Result, Ok, Err
+from result import Err, Ok, Result
 from typing_extensions import override
 
-from .table import TableController
-from .. import MethodController
-from ....analysis.process_report import ReportType, AgilentReport
+from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers.comm import CommunicationController
-from ....utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogramData, AgilentHPLCChromatogram
+from ....utils.chromatogram import (
+    SEQUENCE_TIME_FORMAT,
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
 from ....utils.macro import Command
-from ....utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
+from ....utils.sequence_types import (
+    InjectionSource,
+    SampleType,
+    SequenceDataFiles,
+    SequenceEntry,
+    SequenceTable,
+)
 from ....utils.table_types import RegisterFlag, Table
-from ....utils.tray_types import TenVialColumn, FiftyFourVialPlate
+from ....utils.tray_types import FiftyFourVialPlate, TenVialColumn
+from .. import MethodController
+from .table import TableController
 
 
 class SequenceController(TableController):
@@ -82,7 +92,7 @@ class SequenceController(TableController):
         time.sleep(2)
         self.send(Command.GET_SEQUENCE_CMD)
         time.sleep(2)
-        parsed_response = self.receive().value.string_response
+        parsed_response = self.receive().ok_value.string_response
 
         assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
         self.table_state = None
@@ -97,7 +107,7 @@ class SequenceController(TableController):
         self.table_state = sequence_table
         rows = self.get_num_rows()
         if rows.is_ok():
-            existing_row_num = rows.value.num_response
+            existing_row_num = rows.ok_value.num_response
             wanted_row_num = len(sequence_table.rows)
             while existing_row_num != wanted_row_num:
                 if wanted_row_num > existing_row_num:
@@ -127,7 +137,6 @@ class SequenceController(TableController):
                 self.add_row()
                 self.send(Command.SAVE_SEQUENCE_CMD)
                 num_rows = self.get_num_rows()
-
         if row.vial_location:
             loc = row.vial_location
             if isinstance(loc, TenVialColumn):
@@ -135,7 +144,6 @@ class SequenceController(TableController):
             elif isinstance(loc, FiftyFourVialPlate):
                 loc = row.vial_location.value()
             self._edit_row_num(row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc)
-
         if row.method:
             method_dir = self.method_controller.src
             possible_path = os.path.join(method_dir, row.method) + ".M\\"
@@ -143,23 +151,18 @@ class SequenceController(TableController):
             if os.path.exists(possible_path):
                 method = os.path.join(method_dir, row.method)
             self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
-
         if row.num_inj:
             self._edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=row.num_inj)
-
         if row.inj_vol:
             self._edit_row_text(row=row_num, col_name=RegisterFlag.INJ_VOL, val=row.inj_vol)
-
         if row.inj_source:
             self._edit_row_text(row=row_num, col_name=RegisterFlag.INJ_SOR, val=row.inj_source.value)
-
         if row.sample_name:
             self._edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=row.sample_name)
             if row.data_file:
                 self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.data_file)
             else:
                 self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=row.sample_name)
-
         if row.sample_type:
             self._edit_row_num(row=row_num, col_name=RegisterFlag.SAMPLE_TYPE, val=row.sample_type.value)
 
@@ -179,15 +182,15 @@ class SequenceController(TableController):
 
         total_runtime = 0
         for entry in self.table_state.rows:
-            curr_method_runtime = self.method_controller.get_post_time() + self.method_controller.get_stop_time()
-            loaded_method = self.method_controller.get_method_name()[:-2]
+            curr_method_runtime = self.method_controller.get_total_runtime()
+            loaded_method = self.method_controller.get_method_name().removesuffix(".M")
             method_path = entry.method.split(sep="\\")
             method_name = method_path[-1]
             if loaded_method != method_name:
-                method_dir = os.path.join(*method_path[:-1]) if len(method_path) > 1 else None
+                method_dir = "\\".join(method_path[:-1])+"\\" if len(method_path) > 1 else None
                 self.method_controller.switch(method_name=method_name,
                                               alt_method_dir=method_dir)
-                curr_method_runtime = self.method_controller.get_post_time() + self.method_controller.get_stop_time()
+                curr_method_runtime = self.method_controller.get_total_runtime()
             total_runtime += curr_method_runtime
 
         timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
@@ -196,8 +199,8 @@ class SequenceController(TableController):
 
         if self.check_hplc_is_running():
             folder_name = f"{self.table_state.name} {timestamp}"
-            self.data_files.append(SequenceDataFiles(dir=folder_name,
-                                                     sequence_name=self.table_state.name))
+            data_file = SequenceDataFiles(dir=folder_name, sequence_name=self.table_state.name)
+            self.data_files.append(data_file)
 
             if stall_while_running:
                 run_completed = self.check_hplc_done_running()
@@ -205,10 +208,8 @@ class SequenceController(TableController):
                     self.data_files[-1] = run_completed.ok_value
                 else:
                     raise RuntimeError("Run error has occurred.")
-            else:
-                self.data_files[-1] = SequenceDataFiles(dir=folder_name,
-                                                        child_dirs=[],
-                                                        sequence_name=self.table_state.name)
+        else:
+            raise RuntimeError("Sequence run did not start.")
 
     @override
     def fuzzy_match_most_recent_folder(self, most_recent_folder: SequenceDataFiles) -> Result[SequenceDataFiles, str]:
@@ -248,17 +249,25 @@ class SequenceController(TableController):
         except Exception:
             return Err("Failed to get sequence folder")
 
-    def get_data(self, custom_path: Optional[str] = None,
-                 read_uv: bool = False) -> List[AgilentChannelChromatogramData]:
-        if len(self.data_files[-1].child_dirs) == 0:
-            self.data_files[-1] = self.fuzzy_match_most_recent_folder(self.data_files[-1]).ok_value
-        spectra: list[AgilentChannelChromatogramData] = []
-        all_w_spectra: list[Dict[str, AgilentHPLCChromatogram]] = []
+    def get_data_uv(self,custom_path: Optional[str] = None) -> List[Dict[str, AgilentHPLCChromatogram]]:
+        custom_path = SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="") if custom_path else self.data_files[-1]
+        if len(custom_path.child_dirs) == 0:
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(custom_path).ok_value
+        all_w_spectra: List[Dict[str, AgilentHPLCChromatogram]] = []
         for row in self.data_files[-1].child_dirs:
-            self.get_spectrum(row, read_uv)
-            spectra.append(AgilentChannelChromatogramData(**self.spectra))
+            self.get_uv_spectrum(row)
             all_w_spectra.append(self.uv)
-        return spectra if not read_uv else all_w_spectra
+        return all_w_spectra
+
+    def get_data(self, custom_path: Optional[str] = None) -> List[AgilentChannelChromatogramData]:
+        custom_path = SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="") if custom_path else self.data_files[-1]
+        if len(custom_path.child_dirs) == 0:
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(custom_path).ok_value
+        spectra: List[AgilentChannelChromatogramData] = []
+        for row in self.data_files[-1].child_dirs:
+            self.get_spectrum_at_channels(row)
+            spectra.append(AgilentChannelChromatogramData(**self.spectra))
+        return spectra
 
     def get_report(self, custom_path: Optional[str] = None,
                    report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
@@ -268,7 +277,7 @@ class SequenceController(TableController):
                                                                                          child_dirs=[],
                                                                                          sequence_name="NA")).ok_value)
         parent_dir = self.data_files[-1]
-        spectra = self.get_data(custom_path=custom_path)
+        spectra = self.get_data()
         reports = []
         for i, child_dir in enumerate(parent_dir.child_dirs):
             metd_report = self.get_report_details(child_dir, report_type)

pychemstation/control/controllers/tables/table.py

@@ -3,24 +3,34 @@ Abstract module containing shared logic for Method and Sequence tables.
 
 Authors: Lucy Hao
 """
+from __future__ import annotations
 
 import abc
 import math
 import os
 import time
-from typing import Union, Optional, List, Tuple, Dict
+import warnings
+from typing import Dict, List, Optional, Tuple, Union
 
 import polling
 import rainbow as rb
-from result import Result, Err
-
-from ....analysis.process_report import AgilentReport, ReportType, CSVProcessor, TXTProcessor
+from result import Err, Result, Ok
+
+from ....analysis.process_report import (
+    AgilentReport,
+    CSVProcessor,
+    ReportType,
+    TXTProcessor,
+)
 from ....control.controllers.comm import CommunicationController
-from ....utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
+from ....utils.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
 from ....utils.macro import Command, HPLCRunningStatus, Response
 from ....utils.method_types import MethodDetails
 from ....utils.sequence_types import SequenceDataFiles, SequenceTable
-from ....utils.table_types import Table, TableOperation, RegisterFlag, T
+from ....utils.table_types import RegisterFlag, T, Table, TableOperation
 
 TableType = Union[MethodDetails, SequenceTable]
 
@@ -200,21 +210,25 @@ class TableController(abc.ABC):
         return started_running
 
     def check_hplc_run_finished(self) -> Tuple[float, bool]:
-        time_passed = (time.time() - self.curr_run_starting_time)
-        if time_passed > self.timeout:
-            done_running = self.controller.check_if_not_running()
-            enough_time_passed = time_passed >= self.timeout
-            run_finished = enough_time_passed and done_running
-            if run_finished:
-                self._reset_time()
-                return 0, run_finished
-        return (time_passed / self.timeout), self.controller.check_if_not_running()
-
-    def check_hplc_done_running(self) -> Result[Union[SequenceDataFiles, str], str]:
+        done_running = self.controller.check_if_not_running()
+        if self.curr_run_starting_time and self.timeout:
+            time_passed = (time.time() - self.curr_run_starting_time)
+            if time_passed > self.timeout:
+                enough_time_passed = time_passed >= self.timeout
+                run_finished = enough_time_passed and done_running
+                if run_finished:
+                    self._reset_time()
+                    return 0, run_finished
+            else:
+                time_left = self.timeout - time_passed
+                return time_left, self.controller.check_if_not_running()
+        return 0, self.controller.check_if_not_running()
+
+    def check_hplc_done_running(self) -> Ok[T] | Err[str]:
         """
         Checks if ChemStation has finished running and can read data back
 
-        :return: Return True if data can be read back, else False.
+        :return: Data file object containing most recent run file information.
         """
         finished_run = False
         minutes = math.ceil(self.timeout / 60)
@@ -244,16 +258,18 @@ class TableController(abc.ABC):
             except Exception:
                 self._reset_time()
                 return check_folder
-
-        else:
-            return Err("Run did not complete as expected")
+        return Err("Run did not complete as expected")
 
     @abc.abstractmethod
     def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         pass
 
     @abc.abstractmethod
-    def get_data(self) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def get_data(self, custom_path: Optional[str] = None) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+        pass
+
+    @abc.abstractmethod
+    def get_data_uv(self) -> Union[List[Dict[str, AgilentHPLCChromatogram]], Dict[str, AgilentHPLCChromatogram]]:
         pass
 
     @abc.abstractmethod
@@ -263,11 +279,11 @@ class TableController(abc.ABC):
     def get_uv_spectrum(self, path: str):
         data_uv = rb.agilent.chemstation.parse_file(os.path.join(path, "DAD1.UV"))
         times = data_uv.xlabels
-        wavelengthes = data_uv.ylabels
-        data = data_uv.data.transpose()
-        for (i, w) in enumerate(wavelengthes):
+        wavelengths = data_uv.ylabels
+        absorbances = data_uv.data.transpose()
+        for (i, w) in enumerate(wavelengths):
             self.uv[w] = AgilentHPLCChromatogram()
-            self.uv[w].attach_spectrum(times, data[i])
+            self.uv[w].attach_spectrum(times, absorbances[i])
 
     def get_report_details(self, path: str,
                            report_type: ReportType = ReportType.TXT) -> AgilentReport:
@@ -281,18 +297,18 @@ class TableController(abc.ABC):
                 self.report = csv_report.ok_value
         return self.report
 
-    def get_spectrum(self, data_path: str, read_uv: bool = False):
+
+    def get_spectrum_at_channels(self, data_path: str):
         """
         Load chromatogram for any channel in spectra dictionary.
         """
-        if read_uv:
-            self.get_uv_spectrum(data_path)
         for channel, spec in self.spectra.items():
             try:
                 spec.load_spectrum(data_path=data_path, channel=channel)
             except FileNotFoundError:
                 self.spectra[channel] = AgilentHPLCChromatogram()
-                print(f"No data at channel: {channel}")
+                warning = f"No data at channel: {channel}"
+                warnings.warn(warning)
 
     def _reset_time(self):
         self.curr_run_starting_time = None

pychemstation/control/hplc.py

@@ -3,12 +3,20 @@ Module to provide API for higher-level HPLC actions.
 
 Authors: Lucy Hao
 """
+from __future__ import annotations
 
-from typing import Union, Optional, List, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
+from pychemstation.utils.chromatogram import (
+    AgilentHPLCChromatogram,
+)
 from .controllers.devices.injector import InjectorController
-from ..analysis.process_report import ReportType, AgilentReport
-from ..control.controllers import MethodController, SequenceController, CommunicationController
+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 ..utils.macro import Command, Response, Status
@@ -44,7 +52,8 @@ class HPLCController:
                  method_dir: str,
                  sequence_dir: str,
                  data_dirs: List[str],
-                 offline: bool = False):
+                 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,7 +65,7 @@ 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.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,
@@ -200,14 +209,17 @@ class HPLCController:
         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:
+                                 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)
+        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,
@@ -221,14 +233,18 @@ class HPLCController:
         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]:
+                                   custom_path: Optional[str] = None) -> List[Dict[str, 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."""

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
 
 

pychemstation/utils/chromatogram.py

@@ -6,16 +6,13 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from .parsing import CHFile
 from ..analysis import AbstractSpectrum
-
-# standard filenames for spectral data
-CHANNELS = {"A": "01", "B": "02", "C": "03", "D": "04"}
+from .parsing import CHFile
 
 ACQUISITION_PARAMETERS = "acq.txt"
 
 # format used in acquisition parameters
-TIME_FORMAT = "%Y-%m-%d-%H-%M-%S"
+TIME_FORMAT = "%Y-%m-%d %H-%M-%S"
 SEQUENCE_TIME_FORMAT = "%Y-%m-%d %H-%M"
 
 

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
@@ -87,7 +87,7 @@ 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):

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

pychemstation/utils/sequence_types.py

@@ -2,16 +2,16 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional, Union
+from typing import Optional, List
 
-from pychemstation.utils.tray_types import TenVialColumn, Tray
+from pychemstation.utils.tray_types import Tray
 
 
 @dataclass
 class SequenceDataFiles:
     sequence_name: str
     dir: str
-    child_dirs: Optional[list[str]] = None
+    child_dirs: Optional[List[str]] = None
 
 
 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):
@@ -156,14 +156,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-0.8.3.dist-info → pychemstation-0.10.1.dist-info}/METADATA

@@ -1,10 +1,17 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.8.3
-Summary: Library to interact with Chemstation software, primarily used in Hein lab.
+Version: 0.10.1
+Summary: Library to interact with Chemstation software, primarily used in Hein lagit branch -mb
+Project-URL: Documentation, https://pychemstation-e5a086.gitlab.io/pychemstation.html
+Project-URL: Repository, https://gitlab.com/heingroup/device-api/pychemstation
 Author-email: lucyhao <hao.lucyy@gmail.com>
 License-File: LICENSE
-Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
 Requires-Dist: aghplctools>=4.8.8
 Requires-Dist: coverage>=7.6.1
 Requires-Dist: matplotlib>=3.7.5
@@ -27,8 +34,12 @@ Description-Content-Type: text/markdown
 
 [![PyPI Latest Release](https://img.shields.io/pypi/v/pychemstation.svg)](https://pypi.org/project/pychemstation/)
 
+> **_NOTE:_** If you are running Python **3.8**, use versions 0.**8**.x. If you are running Python **>=3.10**, use
+> version 0.**10**.x. You are welcome to use newer pychemstation versions with older Python versions, but functionality
+> is not guaranteed!
+
 Unofficial Python package to control Agilent Chemstation; we are not affiliated with Agilent.
-Check out the [docs](https://hein-analytical-control-5e6e85.gitlab.io/) for usage instructions. This project is under
+Check out the [docs](https://pychemstation-e5a086.gitlab.io/pychemstation.html) for usage instructions. This project is under
 active development, and breaking changes may occur at any moment.
 
 ## Getting started
@@ -110,6 +121,8 @@ Lucy Hao, Maria Politi
 
 - Adapted from [**AnalyticalLabware**](https://github.com/croningp/analyticallabware), created by members in the Cronin
   Group. Copyright © Cronin Group, used under the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
-- Adapted from the [MACROS](https://github.com/Bourne-Group/HPLCMethodOptimisationGUI)
-  used in [**Operator-free HPLC automated method development guided by Bayesian optimization**](https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00062e),
-  created by members in the Bourne Group.  Copyright © Bourne Group, used under the [MIT](https://opensource.org/license/mit) license.
+- Adapted from the [MACROS](https://github.com/Bourne-Group/HPLCMethodOptimisationGUI) used in [**Operator-free HPLC
+  automated method development guided by Bayesian optimization
+  **](https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00062e),
+  created by members in the Bourne Group. Copyright © Bourne Group, used under
+  the [MIT](https://opensource.org/license/mit) license.

pychemstation-0.10.1.dist-info/RECORD

@@ -0,0 +1,37 @@
+pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
+pychemstation/analysis/__init__.py,sha256=Vi31PZ7fgIvyuIhkgCNvEYeV_jtUCa8FCrAGbpks7zc,83
+pychemstation/analysis/base_spectrum.py,sha256=9WkOLk2qTAYTF1ALNUenVPoosOtBiLRvy2ni8zlGU5w,16540
+pychemstation/analysis/process_report.py,sha256=ZOgcRUMGXdGMrMFcdzsSwdOk6OBp-PpcA83vSvnmVSg,11871
+pychemstation/control/README.md,sha256=y73F-qh4g3k9Z9vBeQATqqhbwMfKB5MvGqJi5GgSUJQ,3357
+pychemstation/control/__init__.py,sha256=Js79QczKZxDNZrzG1-4yl_whCoP2aw-yDAQJungiiic,100
+pychemstation/control/hplc.py,sha256=f7NHcCWtc_ApasjU5VMQtEvWQxoIboi_-RU9dkjORrs,13215
+pychemstation/control/controllers/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
+pychemstation/control/controllers/__init__.py,sha256=r7UU0u5zuJHO_KTqt-4Gy65BMlyXtxrdskiOhtO9Yw4,260
+pychemstation/control/controllers/comm.py,sha256=AN3A3ThvIsOKWY7Kmb_tnE5pRUqI7O2ID8M54z_w-uE,7831
+pychemstation/control/controllers/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/control/controllers/devices/device.py,sha256=JNBKVRka1I3LA1lElIeUO0j93BTK5IJufTPNq95OhNE,1473
+pychemstation/control/controllers/devices/injector.py,sha256=s40jFd0B_wJn4ID6SgAk_F8WhnGbbflpiti4uwIhaSs,1950
+pychemstation/control/controllers/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/control/controllers/tables/method.py,sha256=LHoNRSTsSrrktghqNnU5KTRXDczcuGgqdqKEs_3sUXI,18609
+pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
+pychemstation/control/controllers/tables/sequence.py,sha256=DwX0wi5GhHmk8wnl89X2MKvqTSojLycV4IEvNjdVdWg,13400
+pychemstation/control/controllers/tables/table.py,sha256=zMzsQgkLxM3LVe9w-OM8WjLZxTo9zrmBTNH182gAyh8,12750
+pychemstation/generated/__init__.py,sha256=GAoZFAYbPVEJDkcOw3e1rgOqd7TCW0HyKNPM8OMehMg,1005
+pychemstation/generated/dad_method.py,sha256=xTUiSCvkXcxBUhjVm1YZKu-tHs16k23pF-0xYrQSwWA,8408
+pychemstation/generated/pump_method.py,sha256=797RsSDI2-QPf_BX8isZQx0O3aRx84EGIXJXhXw3IS0,12180
+pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/utils/chromatogram.py,sha256=2Los_ix_wAi4yxG_9neGRnNYPre9_uC1mrne3Ygit5c,3242
+pychemstation/utils/injector_types.py,sha256=PXwJK1uXs8hlQ6dWIEbAGfk2BpQJQmN3SlUbL4ntZz0,822
+pychemstation/utils/macro.py,sha256=Lh8aGcwo9sC2Sfc19Wgms5d3VgBLV3VXdvspqNHYE18,2931
+pychemstation/utils/method_types.py,sha256=ZOFMJ7wpqWBRJNIvOux-7Ou4nJVSuyWRHrd37wMnPa0,1638
+pychemstation/utils/num_utils.py,sha256=rgpTJTrpsiBANbtsfys9xj0sqlTe__3J0OSeoygaQTM,2081
+pychemstation/utils/parsing.py,sha256=iFdnie-v0u5JI4cctJye_yhWQxHgy72_PWZ7w57Ltvg,9318
+pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
+pychemstation/utils/sequence_types.py,sha256=WyJWL18Q86TgoUpYH2_CevoTZuhcui0EnyHYdrp3Nmo,1070
+pychemstation/utils/spec_utils.py,sha256=MQZPDwCYZRfkEhNJQUt74huPexXBlJ3W4o7_230JWcE,10210
+pychemstation/utils/table_types.py,sha256=7txqW_oNpkh4venSkGEtreVe6UV9dzNB1DTrIeTkQHA,3217
+pychemstation/utils/tray_types.py,sha256=eOO-muUjadyvCM8JnYAZVyxJeyYBlENP1zXiFskAFbs,5049
+pychemstation-0.10.1.dist-info/METADATA,sha256=gWFw70cbvfeIPV1T3IJDLDktm4FjjXn1JvPfTDQZoDw,5274
+pychemstation-0.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pychemstation-0.10.1.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.10.1.dist-info/RECORD,,

pychemstation-0.8.3.dist-info/RECORD

@@ -1,37 +0,0 @@
-pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
-pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt420YMI4,44
-pychemstation/analysis/base_spectrum.py,sha256=dPULGlr-sMHNMDIdyzlvX8taw_nkBliKTb00lNI8cwk,16517
-pychemstation/analysis/process_report.py,sha256=wysKaA06UeK_9ba2SZc9maP4P-HQfZDMD9NNt21kWcY,11850
-pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-GKjiDi8,10201
-pychemstation/analysis/utils.py,sha256=rgpTJTrpsiBANbtsfys9xj0sqlTe__3J0OSeoygaQTM,2081
-pychemstation/control/README.md,sha256=7Q0rY014y7Qq8wfL7GSQG0l2P1PXfmgB0qZ2YkkE7n0,3350
-pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
-pychemstation/control/hplc.py,sha256=E_QFMOqUabiqCO6Pu4lZYTsiWhdQULw4AqyKPwiQx90,12628
-pychemstation/control/controllers/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
-pychemstation/control/controllers/__init__.py,sha256=LuFEsVGN5sXuHW_DG61DWBDJ_fU4dMls4bQJ5XNRaok,166
-pychemstation/control/controllers/comm.py,sha256=fRCFh3Ye-HnoGaur69NRdkLHNtdlMoJjIOTqeJe1tAk,7720
-pychemstation/control/controllers/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/control/controllers/devices/device.py,sha256=d9SwasjXTXplkRK5eH3asrNPo3BBZmAz6CKBYAuKSIc,1249
-pychemstation/control/controllers/devices/injector.py,sha256=ynPQtvMFt1iK0LQBf4ZEYdxJCyavmashXwyCQbmRjuw,5542
-pychemstation/control/controllers/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/control/controllers/tables/method.py,sha256=sX83sHlnaAm8Wop_d28RDAk4DBPvQWduH3Atodtmw4A,17714
-pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
-pychemstation/control/controllers/tables/sequence.py,sha256=1bZdoVK877KuAwKTjo-NWvOU8rHxx8cQBL4I71ZN4EM,13105
-pychemstation/control/controllers/tables/table.py,sha256=Adis9584LJqP4yjLj5XrIxqq1jzdBiDieOG4vc90EIU,12327
-pychemstation/generated/__init__.py,sha256=GAoZFAYbPVEJDkcOw3e1rgOqd7TCW0HyKNPM8OMehMg,1005
-pychemstation/generated/dad_method.py,sha256=zfS9op450CRSGPKkUr9qUyPBbND06b9N8SUU9j4cosM,8408
-pychemstation/generated/pump_method.py,sha256=c_FB14rgODZyH5eDb3kxZAI77xRj1HMpQkE2R6MypNA,12180
-pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/utils/chromatogram.py,sha256=s6mqru88E9YQGLbdr2Thm2plf8urCFoHHkMqW6_1Rz4,3338
-pychemstation/utils/injector_types.py,sha256=hTgC-4xnO-EXOLOsCZ0L6TX4KUsB14Q-5jU4_hCzmfM,822
-pychemstation/utils/macro.py,sha256=WgXGR8fgyR_QhRML9NUD3oZZBT4LLSI9uwuragHEe2k,2904
-pychemstation/utils/method_types.py,sha256=5FK7RThLhaQcLrzRi_qLnlPqZuGPtwwipP6eMoq0kpE,1638
-pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
-pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
-pychemstation/utils/sequence_types.py,sha256=x2EClcq6ROdzeLZg63XcXXTknwl2aZ48Vuyru0xZjgA,1086
-pychemstation/utils/table_types.py,sha256=7txqW_oNpkh4venSkGEtreVe6UV9dzNB1DTrIeTkQHA,3217
-pychemstation/utils/tray_types.py,sha256=eOO-muUjadyvCM8JnYAZVyxJeyYBlENP1zXiFskAFbs,5049
-pychemstation-0.8.3.dist-info/METADATA,sha256=vfeuRByzef7lYuAQgYyON587lphk76NR3cPOQZyhwfQ,4575
-pychemstation-0.8.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pychemstation-0.8.3.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.8.3.dist-info/RECORD,,