pychemstation 0.8.4__py3-none-any.whl → 0.9.1__py3-none-any.whl

pychemstation/control/controllers/devices/device.py

@@ -1,23 +1,25 @@
 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 pychemstation.analysis.chromatogram import (
+    AgilentChannelChromatogramData,
+    AgilentHPLCChromatogram,
+)
+from ....utils.table_types import T, Table
 
 
 class DeviceController(TableController, abc.ABC):
-
-    def __init__(self, controller: CommunicationController, table: Table, offline: bool):
-        super().__init__(controller=controller,
-                         src=None,
-                         data_dirs=[],
-                         table=table,
-                         offline=offline)
+    def __init__(
+        self, controller: CommunicationController, table: Table, offline: bool
+    ):
+        super().__init__(
+            controller=controller, src=None, data_dirs=[], table=table, offline=offline
+        )
 
     @abc.abstractmethod
     def get_row(self, row: int):
@@ -26,11 +28,22 @@ class DeviceController(TableController, abc.ABC):
     def retrieve_recent_data_files(self):
         raise NotImplementedError
 
-    def get_data(self) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
+    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
         raise NotImplementedError
 
-    def fuzzy_match_most_recent_folder(self, most_recent_folder: T) -> Result[T, str]:
+    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_report(self, report_type: ReportType = ReportType.TXT) -> List[AgilentReport]:
+    def get_data(
+        self, custom_path: Optional[str] = None
+    ) -> Union[List[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
         raise NotImplementedError

pychemstation/control/controllers/devices/injector.py

@@ -1,13 +1,24 @@
 from ....control.controllers import CommunicationController
+from ....utils.injector_types import (
+    Draw,
+    Inject,
+    InjectorFunction,
+    InjectorTable,
+    Mode,
+    Remote,
+    RemoteCommand,
+    SourceType,
+    Wait,
+)
+from ....utils.table_types import RegisterFlag, Table
+from ....utils.tray_types import Tray
 from .device import DeviceController
-from ....utils.injector_types import *
-from ....utils.macro import Command
-from ....utils.table_types import Table, RegisterFlag
 
 
 class InjectorController(DeviceController):
-
-    def __init__(self, controller: CommunicationController, table: Table, offline: bool):
+    def __init__(
+        self, controller: CommunicationController, table: Table, offline: bool
+    ):
         super().__init__(controller, table, offline)
 
     def get_row(self, row: int) -> InjectorFunction:
@@ -23,95 +34,28 @@ class InjectorController(DeviceController):
             # TODO: better error handling
             is_source = SourceType(self.get_text(row, RegisterFlag.DRAW_SOURCE))
             is_volume = Mode(self.get_text(row, RegisterFlag.DRAW_VOLUME))
-            vol = self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE) if is_volume == Mode.SET else None
+            vol = (
+                self.get_num(row, RegisterFlag.DRAW_VOLUME_VALUE)
+                if is_volume == Mode.SET
+                else None
+            )
             if is_source is SourceType.SPECIFIC_LOCATION:
                 return Draw(amount=vol, source=return_tray_loc())
             elif is_source is SourceType.LOCATION:
-                return Draw(amount=vol, location=self.get_text(row, RegisterFlag.DRAW_LOCATION))
+                return Draw(
+                    amount=vol, location=self.get_text(row, RegisterFlag.DRAW_LOCATION)
+                )
         elif function == "Remote":
-            return Remote(command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
-                          duration=self.get_num(row, RegisterFlag.REMOTE_DUR))
+            return Remote(
+                command=RemoteCommand(self.get_text(row, RegisterFlag.REMOTE)),
+                duration=self.get_num(row, RegisterFlag.REMOTE_DUR),
+            )
 
     def load(self) -> InjectorTable:
         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')
+            return InjectorTable(
+                functions=[
+                    self.get_row(i) for i in range(int(rows.ok_value.num_response))
+                ]
+            )