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

pychemstation/control/controllers/tables/sequence.py

@@ -1,5 +1,6 @@
 import os
 import time
+import warnings
 from typing import Dict, List, Optional
 
 from result import Err, Ok, Result
@@ -7,7 +8,7 @@ from typing_extensions import override
 
 from ....analysis.process_report import AgilentReport, ReportType
 from ....control.controllers.comm import CommunicationController
-from ....utils.chromatogram import (
+from pychemstation.analysis.chromatogram import (
     SEQUENCE_TIME_FORMAT,
     AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
@@ -31,15 +32,24 @@ class SequenceController(TableController):
     Class containing sequence related logic
     """
 
-    def __init__(self, controller: CommunicationController,
-                 method_controller: MethodController,
-                 src: str,
-                 data_dirs: List[str],
-                 table: Table,
-                 offline: bool):
+    def __init__(
+        self,
+        controller: CommunicationController,
+        method_controller: MethodController,
+        src: str,
+        data_dirs: List[str],
+        table: Table,
+        offline: bool,
+    ):
         self.method_controller = method_controller
         self.data_files: List[SequenceDataFiles] = []
-        super().__init__(controller=controller, src=src, data_dirs=data_dirs, table=table, offline=offline)
+        super().__init__(
+            controller=controller,
+            src=src,
+            data_dirs=data_dirs,
+            table=table,
+            offline=offline,
+        )
 
     def load(self) -> SequenceTable:
         rows = self.get_num_rows()
@@ -49,7 +59,10 @@ class SequenceController(TableController):
         if rows.is_ok() and seq_name.is_ok():
             self.table_state = 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))])
+                rows=[
+                    self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))
+                ],
+            )
             return self.table_state
         raise RuntimeError(rows.err_value)
 
@@ -61,15 +74,20 @@ class SequenceController(TableController):
         inj_vol = 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)
-        return SequenceEntry(sample_name=sample_name,
-                             vial_location=vial_enum,
-                             method=None if len(method) == 0 else method,
-                             num_inj=num_inj,
-                             inj_vol=inj_vol,
-                             inj_source=inj_source,
-                             sample_type=sample_type)
+        vial_enum = (
+            TenVialColumn(vial_location)
+            if vial_location <= 10
+            else FiftyFourVialPlate.from_int(num=vial_location)
+        )
+        return SequenceEntry(
+            sample_name=sample_name,
+            vial_location=vial_enum,
+            method=None if len(method) == 0 else method,
+            num_inj=num_inj,
+            inj_vol=inj_vol,
+            inj_source=inj_source,
+            sample_type=sample_type,
+        )
 
     def check(self) -> str:
         time.sleep(2)
@@ -143,7 +161,9 @@ class SequenceController(TableController):
                 loc = row.vial_location.value
             elif isinstance(loc, FiftyFourVialPlate):
                 loc = row.vial_location.value()
-            self._edit_row_num(row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc)
+            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\\"
@@ -152,19 +172,35 @@ class SequenceController(TableController):
                 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)
+            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)
+            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)
+            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)
+            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)
+                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)
+                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)
+            self._edit_row_num(
+                row=row_num,
+                col_name=RegisterFlag.SAMPLE_TYPE,
+                val=row.sample_type.value,
+            )
 
         self.send(Command.SAVE_SEQUENCE_CMD)
 
@@ -187,9 +223,12 @@ class SequenceController(TableController):
             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)
+                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
 
@@ -199,7 +238,9 @@ class SequenceController(TableController):
 
         if self.check_hplc_is_running():
             folder_name = f"{self.table_state.name} {timestamp}"
-            data_file = 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:
@@ -207,24 +248,33 @@ class SequenceController(TableController):
                 if run_completed.is_ok():
                     self.data_files[-1] = run_completed.ok_value
                 else:
-                    raise RuntimeError("Run error has occurred.")
+                    warnings.warn("Run may have not completed.")
         else:
             raise RuntimeError("Sequence run did not start.")
 
     @override
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: SequenceDataFiles) -> Result[SequenceDataFiles, str]:
+    def fuzzy_match_most_recent_folder(
+        self, most_recent_folder: SequenceDataFiles
+    ) -> 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]
+            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)]
-                potential_folders = sorted(list(filter(lambda d: most_recent_folder.dir in d, subdirs)))
+                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
@@ -239,49 +289,79 @@ class SequenceController(TableController):
             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)))
+                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]
+            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:
-            return Err("Failed to get sequence folder")
+        except Exception as e:
+            error = f"Failed to get sequence folder: {e}"
+            return Err(error)
 
-    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]
+    def get_data_uv(
+        self, custom_path: Optional[str] = None
+    ) -> List[Dict[int, 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]] = []
+            self.data_files[-1] = self.fuzzy_match_most_recent_folder(
+                custom_path
+            ).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)
         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]
+    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
+            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]:
+    def get_report(
+        self,
+        custom_path: Optional[str] = None,
+        report_type: ReportType = ReportType.TXT,
+    ) -> List[AgilentReport]:
         if custom_path:
             self.data_files.append(
-                self.fuzzy_match_most_recent_folder(most_recent_folder=SequenceDataFiles(dir=custom_path,
-                                                                                         child_dirs=[],
-                                                                                         sequence_name="NA")).ok_value)
+                self.fuzzy_match_most_recent_folder(
+                    most_recent_folder=SequenceDataFiles(
+                        dir=custom_path, child_dirs=[], sequence_name="NA"
+                    )
+                ).ok_value
+            )
         parent_dir = self.data_files[-1]
         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)
-            child_spectra: List[AgilentHPLCChromatogram] = list(spectra[i].__dict__.values())
+            child_spectra: List[AgilentHPLCChromatogram] = list(
+                spectra[i].__dict__.values()
+            )
             for j, signal in enumerate(metd_report.signals):
                 possible_data = child_spectra[j]
                 if len(possible_data.x) > 0: