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

pychemstation/control/controllers/tables/method.py

@@ -1,14 +1,14 @@
+from __future__ import annotations
+
 import os
 import time
 import warnings
-from typing import Dict, List, Optional, Union
+from typing import List, Optional, Union, Dict
 
 from result import Err, Ok, Result
-from xsdata.formats.dataclass.parsers import XmlParser
 
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers import CommunicationController
-from ....generated import DadMethod, PumpMethod, SolventElement
 from pychemstation.analysis.chromatogram import (
     TIME_FORMAT,
     AgilentChannelChromatogramData,
@@ -22,7 +22,7 @@ from ....utils.method_types import (
     PType,
     TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, T, Table, TableOperation
+from ....utils.table_types import RegisterFlag, Table, TableOperation, T
 from ..devices.injector import InjectorController
 from .table import TableController
 
@@ -61,20 +61,22 @@ class MethodController(TableController):
         return "ERROR"
 
     def get_method_params(self) -> HPLCMethodParams:
-        return HPLCMethodParams(
-            organic_modifier=self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
-                )
-            ),
-            flow=self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.FLOW,
-                )
-            ),
-        )
+        if self.controller:
+            return HPLCMethodParams(
+                organic_modifier=self.controller.get_num_val(
+                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                        register=self.table_locator.register,
+                        register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
+                    )
+                ),
+                flow=self.controller.get_num_val(
+                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                        register=self.table_locator.register,
+                        register_flag=RegisterFlag.FLOW,
+                    )
+                ),
+            )
+        raise ValueError("Communication controller is offline!")
 
     def get_row(self, row: int) -> TimeTableEntry:
         flow = None
@@ -89,6 +91,9 @@ class MethodController(TableController):
         except RuntimeError:
             pass
 
+        if om is None and flow is None:
+            raise ValueError("Both flow and organic modifier is None")
+
         return TimeTableEntry(
             start_time=self.get_num(row, RegisterFlag.TIME),
             organic_modifer=om,
@@ -97,7 +102,7 @@ class MethodController(TableController):
 
     def get_timetable(self, rows: int):
         uncoalesced_timetable_rows = [self.get_row(r + 1) for r in range(rows)]
-        timetable_rows = {}
+        timetable_rows: Dict[str, TimeTableEntry] = {}
         for row in uncoalesced_timetable_rows:
             time_key = str(row.start_time)
             if time_key not in timetable_rows.keys():
@@ -141,20 +146,24 @@ class MethodController(TableController):
         return method_name
 
     def get_post_time(self) -> Union[int, float]:
-        return self.controller.get_num_val(
-            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                register=self.table_locator.register,
-                register_flag=RegisterFlag.POST_TIME,
+        if self.controller:
+            return self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=RegisterFlag.POST_TIME,
+                )
             )
-        )
+        raise ValueError("Communication controller is not online!")
 
     def get_stop_time(self) -> Union[int, float]:
-        return self.controller.get_num_val(
-            cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                register=self.table_locator.register,
-                register_flag=RegisterFlag.MAX_TIME,
+        if self.controller:
+            return self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table_locator.register,
+                    register_flag=RegisterFlag.MAX_TIME,
+                )
             )
-        )
+        raise ValueError("Communication controller is not online!")
 
     def get_total_runtime(self) -> Union[int, float]:
         """Returns total method runtime in minutes."""
@@ -198,60 +207,6 @@ class MethodController(TableController):
             assert parsed_response == f"{method_name}.M", "Switching Methods failed."
         self.table_state = None
 
-    def load_from_disk(self, method_name: str) -> MethodDetails:
-        """
-        Retrieve method details of an existing method. Don't need to append ".M" to the end. This assumes the
-        organic modifier is in Channel B and that Channel A contains the aq layer. Additionally, assumes
-         only two solvents are being used.
-
-        :param method_name: name of method to load details of
-        :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",
-        )
-
-        if os.path.exists(os.path.join(self.src, f"{method_name}.M")):
-            parser = XmlParser()
-            method = parser.parse(method_path, PumpMethod)
-            dad = parser.parse(dad_path, DadMethod)
-
-            organic_modifier: Optional[SolventElement] = None
-
-            if len(method.solvent_composition.solvent_element) == 2:
-                for solvent in method.solvent_composition.solvent_element:
-                    if solvent.channel == "Channel_B":
-                        organic_modifier = solvent
-
-            self.table_state = MethodDetails(
-                name=method_name,
-                params=HPLCMethodParams(
-                    organic_modifier=organic_modifier.percentage, flow=method.flow
-                ),
-                stop_time=method.stop_time.stop_time_value,
-                post_time=method.post_time.post_time_value,
-                timetable=[
-                    TimeTableEntry(
-                        start_time=tte.time,
-                        organic_modifer=tte.percent_b,
-                        flow=method.flow,
-                    )
-                    for tte in method.timetable.timetable_entry
-                ],
-                dad_wavelengthes=dad.signals.signal,
-            )
-            return self.table_state
-        else:
-            raise FileNotFoundError
-
     def edit(self, updated_method: MethodDetails, save: bool):
         """Updated the currently loaded method in ChemStation with provided values.
 
@@ -317,13 +272,13 @@ class MethodController(TableController):
         self,
         new_flow: Union[int, float],
         new_initial_om: Union[int, float],
-        new_stop_time: Union[int, float],
-        new_post_time: Union[int, float],
+        new_stop_time: Union[int, float] | None,
+        new_post_time: Union[int, float] | None,
     ):
         self.delete_table()
         self.edit_initial_om(new_initial_om)
         self.edit_flow(new_flow)
-        if self.table_state.stop_time:
+        if new_stop_time:
             self.edit_stop_time(new_stop_time)
         else:
             self._update_param(
@@ -333,7 +288,7 @@ class MethodController(TableController):
                     ptype=PType.STR,
                 )
             )
-        if self.table_state.post_time:
+        if new_post_time:
             self.edit_post_time(new_post_time)
         else:
             self._update_param(
@@ -502,21 +457,23 @@ class MethodController(TableController):
                 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 fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> 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)
+            return Err("Folder not found!")
+        raise ValueError("Folder is not a str or byte type.")
 
     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)
+        return AgilentChannelChromatogramData.from_dict(self.spectra)
 
     def get_data_uv(
         self, custom_path: Optional[str] = None
-    ) -> Dict[str, AgilentHPLCChromatogram]:
+    ) -> dict[int, AgilentHPLCChromatogram]:
         custom_path = custom_path if custom_path else self.data_files[-1]
         self.get_uv_spectrum(custom_path)
         return self.uv

pychemstation/control/controllers/tables/sequence.py

@@ -1,18 +1,20 @@
 import os
 import time
 import warnings
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Any
 
 from result import Err, Ok, Result
 from typing_extensions import override
 
-from ....analysis.process_report import AgilentReport, ReportType
-from ....control.controllers.comm import CommunicationController
 from pychemstation.analysis.chromatogram import (
     SEQUENCE_TIME_FORMAT,
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
 )
+from . import MethodController
+
+from ....analysis.process_report import AgilentReport, ReportType
+from ....control.controllers.comm import CommunicationController
 from ....utils.macro import Command
 from ....utils.sequence_types import (
     InjectionSource,
@@ -21,9 +23,8 @@ from ....utils.sequence_types import (
     SequenceEntry,
     SequenceTable,
 )
-from ....utils.table_types import RegisterFlag, Table
-from ....utils.tray_types import FiftyFourVialPlate, TenVialColumn
-from .. import MethodController
+from ....utils.table_types import RegisterFlag, T, Table
+from ....utils.tray_types import FiftyFourVialPlate, TenVialColumn, Tray
 from .table import TableController
 
 
@@ -34,7 +35,7 @@ class SequenceController(TableController):
 
     def __init__(
         self,
-        controller: CommunicationController,
+        controller: Optional[CommunicationController],
         method_controller: MethodController,
         src: str,
         data_dirs: List[str],
@@ -57,7 +58,7 @@ class SequenceController(TableController):
         seq_name = self.receive()
 
         if rows.is_ok() and seq_name.is_ok():
-            self.table_state = SequenceTable(
+            self.table_state: SequenceTable = SequenceTable(
                 name=seq_name.ok_value.string_response.partition(".S")[0],
                 rows=[
                     self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))
@@ -66,19 +67,37 @@ class SequenceController(TableController):
             return self.table_state
         raise RuntimeError(rows.err_value)
 
+    def try_int(self, val: Any) -> Optional[int]:
+        try:
+            return int(val)
+        except ValueError:
+            return None
+
+    def try_float(self, val: Any) -> Optional[float]:
+        try:
+            return float(val)
+        except ValueError:
+            return None
+
+    def try_vial_location(self, val: Any) -> Tray:
+        try:
+            return (
+                TenVialColumn(val)
+                if val <= 10
+                else FiftyFourVialPlate.from_int(num=val)
+            )
+        except ValueError:
+            raise ValueError("Expected vial location, is empty.")
+
     def get_row(self, row: int) -> SequenceEntry:
         sample_name = self.get_text(row, RegisterFlag.NAME)
-        vial_location = int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
+        vial_location = self.try_int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
         method = self.get_text(row, RegisterFlag.METHOD)
-        num_inj = int(self.get_num(row, RegisterFlag.NUM_INJ))
-        inj_vol = float(self.get_text(row, RegisterFlag.INJ_VOL))
+        num_inj = self.try_int(self.get_num(row, RegisterFlag.NUM_INJ))
+        inj_vol = self.try_float(self.get_text(row, RegisterFlag.INJ_VOL))
         inj_source = InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
         sample_type = SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
-        vial_enum = (
-            TenVialColumn(vial_location)
-            if vial_location <= 10
-            else FiftyFourVialPlate.from_int(num=vial_location)
-        )
+        vial_enum = self.try_vial_location(vial_location)
         return SequenceEntry(
             sample_name=sample_name,
             vial_location=vial_enum,
@@ -113,7 +132,7 @@ class SequenceController(TableController):
         parsed_response = self.receive().ok_value.string_response
 
         assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
-        self.table_state = None
+        self.table_state = self.load()
 
     def edit(self, sequence_table: SequenceTable):
         """
@@ -157,12 +176,13 @@ class SequenceController(TableController):
                 num_rows = self.get_num_rows()
         if row.vial_location:
             loc = row.vial_location
+            loc_num = -1
             if isinstance(loc, TenVialColumn):
-                loc = row.vial_location.value
+                loc_num = loc.value
             elif isinstance(loc, FiftyFourVialPlate):
-                loc = row.vial_location.value()
+                loc_num = loc.value()
             self._edit_row_num(
-                row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc
+                row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
             )
         if row.method:
             method_dir = self.method_controller.src
@@ -177,7 +197,7 @@ class SequenceController(TableController):
             )
         if row.inj_vol:
             self._edit_row_text(
-                row=row_num, col_name=RegisterFlag.INJ_VOL, val=row.inj_vol
+                row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(row.inj_vol)
             )
         if row.inj_source:
             self._edit_row_text(
@@ -210,26 +230,32 @@ class SequenceController(TableController):
         under the <data_dir>/<sequence table name> folder.
         Device must be ready.
         """
-        self.controller.send(Command.SAVE_METHOD_CMD)
-        self.controller.send(Command.SAVE_SEQUENCE_CMD)
+        if self.controller:
+            self.controller.send(Command.SAVE_METHOD_CMD)
+            self.controller.send(Command.SAVE_SEQUENCE_CMD)
+        else:
+            raise ValueError("Controller is offline!")
 
         if not self.table_state:
             self.table_state = self.load()
 
-        total_runtime = 0
+        total_runtime = 0.0
         for entry in self.table_state.rows:
             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 = (
-                    "\\".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_total_runtime()
+            if entry.method:
+                method_path = entry.method.split(sep="\\")
+                method_name = method_path[-1]
+                if loaded_method != method_name:
+                    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_total_runtime()
             total_runtime += curr_method_runtime
 
         timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
@@ -254,91 +280,100 @@ class SequenceController(TableController):
 
     @override
     def fuzzy_match_most_recent_folder(
-        self, most_recent_folder: SequenceDataFiles
+        self, most_recent_folder: T
     ) -> Result[SequenceDataFiles, str]:
-        if os.path.isdir(most_recent_folder.dir):
-            subdirs = [x[0] for x in os.walk(most_recent_folder.dir)]
-            potential_folders = sorted(
-                list(filter(lambda d: most_recent_folder.dir in d, subdirs))
-            )
-            most_recent_folder.child_dirs = [
-                f
-                for f in potential_folders
-                if most_recent_folder.dir in f and ".M" not in f and ".D" in f
-            ]
-            return Ok(most_recent_folder)
-
-        try:
-            potential_folders = []
-            for d in self.data_dirs:
-                subdirs = [x[0] for x in os.walk(d)]
+        if isinstance(most_recent_folder, SequenceDataFiles):
+            if os.path.isdir(most_recent_folder.dir):
+                subdirs = [x[0] for x in os.walk(most_recent_folder.dir)]
                 potential_folders = sorted(
                     list(filter(lambda d: most_recent_folder.dir in d, subdirs))
                 )
-                if len(potential_folders) > 0:
-                    break
-            assert len(potential_folders) > 0
-            parent_dirs = []
-            for folder in potential_folders:
-                path = os.path.normpath(folder)
-                split_folder = path.split(os.sep)
-                if most_recent_folder.dir in split_folder[-1]:
-                    parent_dirs.append(folder)
-            parent_dir = sorted(parent_dirs, reverse=True)[0]
-
-            potential_folders = []
-            for d in self.data_dirs:
-                subdirs = [x[0] for x in os.walk(d)]
-                potential_folders = sorted(
-                    list(filter(lambda d: parent_dir in d, subdirs))
-                )
-                if len(potential_folders) > 0:
-                    break
-            assert len(potential_folders) > 0
-            most_recent_folder.child_dirs = [
-                f
-                for f in potential_folders
-                if parent_dir in f and ".M" not in f and ".D" in f
-            ]
-            return Ok(most_recent_folder)
-        except Exception as e:
-            error = f"Failed to get sequence folder: {e}"
-            return Err(error)
+                most_recent_folder.child_dirs = [
+                    f
+                    for f in potential_folders
+                    if most_recent_folder.dir in f and ".M" not in f and ".D" in f
+                ]
+                return Ok(most_recent_folder)
 
-    def get_data_uv(
-        self, custom_path: Optional[str] = None
-    ) -> List[Dict[int, AgilentHPLCChromatogram]]:
-        custom_path = (
+            try:
+                potential_folders = []
+                for d in self.data_dirs:
+                    subdirs = [x[0] for x in os.walk(d)]
+                    potential_folders = sorted(
+                        list(filter(lambda d: most_recent_folder.dir in d, subdirs))
+                    )
+                    if len(potential_folders) > 0:
+                        break
+                assert len(potential_folders) > 0
+                parent_dirs = []
+                for folder in potential_folders:
+                    path = os.path.normpath(folder)
+                    split_folder = path.split(os.sep)
+                    if most_recent_folder.dir in split_folder[-1]:
+                        parent_dirs.append(folder)
+                parent_dir = sorted(parent_dirs, reverse=True)[0]
+
+                potential_folders = []
+                for d in self.data_dirs:
+                    subdirs = [x[0] for x in os.walk(d)]
+                    potential_folders = sorted(
+                        list(filter(lambda d: parent_dir in d, subdirs))
+                    )
+                    if len(potential_folders) > 0:
+                        break
+                assert len(potential_folders) > 0
+                most_recent_folder.child_dirs = [
+                    f
+                    for f in potential_folders
+                    if parent_dir in f and ".M" not in f and ".D" in f
+                ]
+                return Ok(most_recent_folder)
+            except Exception as e:
+                error = f"Failed to get sequence folder: {e}"
+                return Err(error)
+        return Err("Expected SequenceDataFile type.")
+
+    def get_data_mult_uv(self, custom_path: Optional[str] = None):
+        seq_data_dir = (
             SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="")
             if custom_path
             else self.data_files[-1]
         )
-        if len(custom_path.child_dirs) == 0:
+        if len(seq_data_dir.child_dirs) == 0:
             self.data_files[-1] = self.fuzzy_match_most_recent_folder(
-                custom_path
+                seq_data_dir
             ).ok_value
         all_w_spectra: List[Dict[int, AgilentHPLCChromatogram]] = []
         for row in self.data_files[-1].child_dirs:
-            self.get_uv_spectrum(row)
-            all_w_spectra.append(self.uv)
+            all_w_spectra.append(self.get_data_uv(custom_path=row))
         return all_w_spectra
 
+    def get_data_uv(
+        self, custom_path: Optional[str] = None
+    ) -> Dict[int, AgilentHPLCChromatogram]:
+        if isinstance(custom_path, str):
+            self.get_uv_spectrum(custom_path)
+            return self.uv
+        raise ValueError(
+            "Path should exist when calling from sequence. Provide a child path (contains the method)."
+        )
+
     def get_data(
         self, custom_path: Optional[str] = None
     ) -> List[AgilentChannelChromatogramData]:
-        custom_path = (
+        seq_file_dir = (
             SequenceDataFiles(dir=custom_path, child_dirs=[], sequence_name="")
             if custom_path
             else self.data_files[-1]
         )
-        if len(custom_path.child_dirs) == 0:
+        if len(seq_file_dir.child_dirs) == 0:
             self.data_files[-1] = self.fuzzy_match_most_recent_folder(
-                custom_path
+                seq_file_dir
             ).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))
+            spectra.append(AgilentChannelChromatogramData.from_dict(self.spectra))
         return spectra
 
     def get_report(
@@ -363,8 +398,12 @@ class SequenceController(TableController):
                 spectra[i].__dict__.values()
             )
             for j, signal in enumerate(metd_report.signals):
-                possible_data = child_spectra[j]
-                if len(possible_data.x) > 0:
-                    signal.data = possible_data
+                assert len(metd_report.signals) <= len(child_spectra)
+                try:
+                    possible_data = child_spectra[j]
+                    if len(possible_data.x) > 0:
+                        signal.data = possible_data
+                except IndexError:
+                    raise ValueError(j)
             reports.append(metd_report)
         return reports