pychemstation 0.5.9__tar.gz → 0.5.10__tar.gz

{pychemstation-0.5.9 → pychemstation-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.5.9
+Version: 0.5.10
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao

{pychemstation-0.5.9 → pychemstation-0.5.10}/pychemstation/control/controllers/method.py

@@ -1,6 +1,6 @@
 import os
 import time
-from typing import Optional
+from typing import Optional, Union
 
 from xsdata.formats.dataclass.parsers import XmlParser
 
@@ -9,7 +9,7 @@ from ...control.controllers.comm import CommunicationController
 from ...generated import PumpMethod, DadMethod, SolventElement
 from ...utils.chromatogram import TIME_FORMAT, AgilentChannelChromatogramData
 from ...utils.macro import Command
-from ...utils.method_types import PType, TimeTableEntry, Param, MethodTimetable, HPLCMethodParams
+from ...utils.method_types import PType, TimeTableEntry, Param, MethodDetails, HPLCMethodParams
 from ...utils.table_types import RegisterFlag, TableOperation, Table
 
 
@@ -43,30 +43,53 @@ class MethodController(TableController):
                     register_flag=RegisterFlag.FLOW
                 )
             ),
-            maximum_run_time=self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table.register,
-                    register_flag=RegisterFlag.MAX_TIME
-                )
-            ),
         )
 
     def get_row(self, row: int) -> TimeTableEntry:
         return TimeTableEntry(start_time=self.get_num(row, RegisterFlag.TIME),
                               organic_modifer=self.get_num(row, RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION),
-                              flow=None)
-
-    def load(self) -> MethodTimetable:
+                              flow=self.get_num(row, RegisterFlag.TIMETABLE_FLOW))
+
+    def get_timetable(self, rows: int):
+        uncoalesced_timetable_rows = [self.get_row(r + 1) for r in range(rows)]
+        timetable_rows = {}
+        for row in uncoalesced_timetable_rows:
+            time_key = str(row.start_time)
+            if time_key not in timetable_rows.keys():
+                timetable_rows[time_key] = TimeTableEntry(start_time=row.start_time,
+                                                          flow=row.flow,
+                                                          organic_modifer=row.organic_modifer)
+            else:
+                if row.flow:
+                    timetable_rows[time_key].flow = row.flow
+                if row.organic_modifer:
+                    timetable_rows[time_key].organic_modifer = row.organic_modifer
+        entries = list(timetable_rows.values())
+        entries.sort(key=lambda e: e.start_time)
+        return entries
+
+    def load(self) -> MethodDetails:
         rows = self.get_num_rows()
         if rows.is_ok():
             self.send(Command.GET_METHOD_CMD)
             res = self.receive()
             method_name = res.ok_value.string_response
-            timetable_rows = [self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))]
-            self.table_state = MethodTimetable(
+            timetable_rows = self.get_timetable(int(rows.ok_value.num_response))
+            params = self.get_method_params()
+            stop_time = self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table.register,
+                    register_flag=RegisterFlag.MAX_TIME))
+            post_time = self.controller.get_num_val(
+                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
+                    register=self.table.register,
+                    register_flag=RegisterFlag.POST_TIME))
+            self.table_state = MethodDetails(
                 name=method_name,
-                first_row=self.get_method_params(),
-                subsequent_rows=timetable_rows)
+                timetable=timetable_rows,
+                stop_time=stop_time,
+                post_time=post_time,
+                params=params)
             return self.table_state
         else:
             raise RuntimeError(rows.err_value)
@@ -104,7 +127,7 @@ 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) -> MethodTimetable:
+    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
@@ -133,120 +156,69 @@ class MethodController(TableController):
                     elif solvent.channel == "Channel_B":
                         organic_modifier = solvent
 
-            self.table_state = MethodTimetable(
-                first_row=HPLCMethodParams(
-                    organic_modifier=organic_modifier.percentage,
-                    flow=method.flow,
-                    maximum_run_time=method.stop_time.stop_time_value),
-                subsequent_rows=[
-                    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,
-                organic_modifier=organic_modifier,
-                modifier_a=aq_modifier
-            )
+            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: MethodTimetable, save: bool):
+    def edit(self, updated_method: MethodDetails, save: bool):
         """Updated the currently loaded method in ChemStation with provided values.
 
         :param updated_method: the method with updated values, to be sent to Chemstation to modify the currently loaded method.
+        :param save: if false only modifies the method, otherwise saves to disk
         """
         self.table_state = updated_method
-        initial_organic_modifier: Param = Param(val=updated_method.first_row.organic_modifier,
+        initial_organic_modifier: Param = Param(val=updated_method.params.organic_modifier,
                                                 chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
                                                 ptype=PType.NUM)
-        max_time: Param = Param(val=updated_method.first_row.maximum_run_time,
+        max_time: Param = Param(val=updated_method.stop_time,
                                 chemstation_key=RegisterFlag.MAX_TIME,
                                 ptype=PType.NUM)
-        flow: Param = Param(val=updated_method.first_row.flow,
+        post_time: Param = Param(val=updated_method.post_time,
+                                 chemstation_key=RegisterFlag.POST_TIME,
+                                 ptype=PType.NUM)  # TODO check postime works
+        flow: Param = Param(val=updated_method.params.flow,
                             chemstation_key=RegisterFlag.FLOW,
                             ptype=PType.NUM)
 
         # Method settings required for all runs
-        self.delete_table()
-        self._update_param(initial_organic_modifier)
-        self._update_param(flow)
-        self._update_param(Param(val="Set",
-                                 chemstation_key=RegisterFlag.STOPTIME_MODE,
-                                 ptype=PType.STR))
-        self._update_param(max_time)
-        self._update_param(Param(val="Off",
-                                 chemstation_key=RegisterFlag.POSTIME_MODE,
-                                 ptype=PType.STR))
-
-        self.send("DownloadRCMethod PMP1")
-
-        self._update_method_timetable(updated_method.subsequent_rows)
+        self.update_method_params(flow, initial_organic_modifier, max_time, post_time)
+        self._update_method_timetable(updated_method.timetable)
 
         if save:
             self.send(Command.SAVE_METHOD_CMD.value.format(
                 commit_msg=f"saved method at {str(time.time())}"
             ))
 
-    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
-        self.sleepy_send('Local Rows')
-        self.get_num_rows()
-
-        self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
-        res = self.get_num_rows()
-        while not res.is_err():
-            self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
-            res = self.get_num_rows()
-
-        self.sleepy_send('NewTab RCPMP1Method[1], "Timetable"')
-        self.get_num_rows()
-
-        for i, row in enumerate(timetable_rows):
-            if i == 0:
-                self.send('Sleep 1')
-                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
-                self.send('Sleep 1')
-
-                self.sleepy_send('NewColText RCPMP1Method[1], "Timetable", "Function", "SolventComposition"')
-                self.sleepy_send(f'NewColVal RCPMP1Method[1], "Timetable", "Time", {row.start_time}')
-                self.sleepy_send(
-                    f'NewColVal RCPMP1Method[1], "Timetable", "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
-
-                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
-                self.sleepy_send('SetTabText RCPMP1Method[1], "Timetable", 2, "Function", "Flow"')
-                self.sleepy_send(f'NewColVal RCPMP1Method[1], "Timetable", "FlowFlow", {row.flow}')
-                self.sleepy_send(f'SetTabVal RCPMP1Method[1], "Timetable", 2, "FlowFlow", {row.flow})')
-
-                self.send('Sleep 1')
-                self.sleepy_send("DownloadRCMethod PMP1")
-                self.send('Sleep 1')
-            else:
-                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
-                self.get_num_rows()
-
-                self.sleepy_send(
-                    f'SetTabText RCPMP1Method[1], "Timetable", Rows, "Function", "SolventComposition"')
-                self.sleepy_send(
-                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "Time", {row.start_time}')
-                self.sleepy_send(
-                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
-
-                self.send("Sleep 1")
-                self.sleepy_send("DownloadRCMethod PMP1")
-                self.send("Sleep 1")
-
-                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
-                self.get_num_rows()
-
-                self.sleepy_send('SetTabText RCPMP1Method[1], "Timetable", Rows , "Function", "Flow"')
-                self.sleepy_send(f'SetTabVal RCPMP1Method[1], "Timetable", Rows , "FlowFlow", {row.flow}')
-                self.sleepy_send(f'SetTabVal RCPMP1Method[1], "Timetable", Rows , "Time", {row.start_time}')
-
-                self.send("Sleep 1")
-                self.sleepy_send("DownloadRCMethod PMP1")
-                self.send("Sleep 1")
+    def update_method_params(self, flow, initial_organic_modifier, max_time, post_time):
+        self.delete_table()
+        self._update_param(initial_organic_modifier)
+        self._update_param(flow)
+        if self.table_state.stop_time:
+            self._update_param(Param(val="Set",
+                                     chemstation_key=RegisterFlag.STOPTIME_MODE,
+                                     ptype=PType.STR))
+            self._update_param(max_time)
+        else:
+            self._update_param(Param(val="Off",
+                                     chemstation_key=RegisterFlag.STOPTIME_MODE,
+                                     ptype=PType.STR))
+        if self.table_state.post_time:
+            self._update_param(Param(val="Set",
+                                     chemstation_key=RegisterFlag.POSTIME_MODE,
+                                     ptype=PType.STR))
+            self._update_param(post_time)
+        self.download()
 
     def _update_param(self, method_param: Param):
         """Change a method parameter, changes what is visibly seen in Chemstation GUI.
@@ -267,6 +239,57 @@ class MethodController(TableController):
                                                    val=method_param.val))
         time.sleep(2)
 
+    def download(self):
+        self.send('Sleep 1')
+        self.sleepy_send("DownloadRCMethod PMP1")
+        self.send('Sleep 1')
+
+    def edit_row(self, row: TimeTableEntry, first_row: bool = False):
+        if first_row:
+            self.add_row()
+            self.add_new_col_text(col_name=RegisterFlag.FUNCTION,
+                                  val=RegisterFlag.SOLVENT_COMPOSITION.value)
+            self.add_new_col_num(col_name=RegisterFlag.TIME, val=row.start_time)
+            self.add_new_col_num(col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
+                                 val=row.organic_modifer)
+            self.add_row()
+            self.get_num_rows()
+            self.edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
+            self.add_new_col_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
+            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
+            self.download()
+        else:
+            self.add_row()
+            self.get_num_rows()
+            self.edit_row_text(col_name=RegisterFlag.FUNCTION,
+                               val=RegisterFlag.SOLVENT_COMPOSITION.value)
+            self.edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
+            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_SOLVENT_B_COMPOSITION,
+                              val=row.organic_modifer)
+            self.download()
+
+            self.add_row()
+            self.get_num_rows()
+            self.edit_row_text(col_name=RegisterFlag.FUNCTION, val=RegisterFlag.FLOW.value)
+            self.edit_row_num(col_name=RegisterFlag.TIMETABLE_FLOW, val=row.flow)
+            self.edit_row_num(col_name=RegisterFlag.TIME, val=row.start_time)
+            self.download()
+
+    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
+        self.get_num_rows()
+
+        self.delete_table()
+        res = self.get_num_rows()
+        while not res.is_err():
+            self.delete_table()
+            res = self.get_num_rows()
+
+        self.new_table()
+        self.get_num_rows()
+
+        for i, row in enumerate(timetable_rows):
+            self.edit_row(row=row, first_row=i == 0)
+
     def stop(self):
         """
         Stops the method run. A dialog window will pop up and manual intervention may be required.\

{pychemstation-0.5.9 → pychemstation-0.5.10}/pychemstation/control/controllers/sequence.py

@@ -1,5 +1,4 @@
-from typing import  Optional
-
+from typing import Optional
 
 import os
 import time
@@ -10,6 +9,7 @@ from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentChannelChromatogr
 from ...utils.macro import Command
 from ...utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
 from ...utils.table_types import TableOperation, RegisterFlag, Table
+from ...utils.tray_types import TenColumn
 
 
 class SequenceController(TableController):
@@ -47,7 +47,7 @@ class SequenceController(TableController):
                              num_inj=num_inj,
                              inj_vol=inj_vol,
                              inj_source=inj_source,
-                             sample_type=sample_type, )
+                             sample_type=sample_type)
 
     def check(self) -> str:
         time.sleep(2)
@@ -116,67 +116,34 @@ class SequenceController(TableController):
                 self.send(Command.SAVE_SEQUENCE_CMD)
                 num_rows = self.get_num_rows()
 
-        table_register = self.table.register
-        table_name = self.table.name
-
         if row.vial_location:
             loc = row.vial_location
-            if isinstance(row.vial_location, InjectionSource):
+            if isinstance(row.vial_location, TenColumn):
                 loc = row.vial_location.value
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
-                                                                      table_name=table_name,
-                                                                      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:
             possible_path = os.path.join(self.method_dir, row.method) + ".M\\"
             method = row.method
             if os.path.exists(possible_path):
                 method = os.path.join(self.method_dir, row.method)
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.METHOD,
-                                                                       val=method))
+            self.edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
 
         if row.num_inj:
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
-                                                                      table_name=table_name,
-                                                                      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.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       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.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       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.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.NAME,
-                                                                       val=row.sample_name))
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.DATA_FILE,
-                                                                       val=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.DATA_FILE, val=row.sample_name)
+
         if row.sample_type:
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
-                                                                      table_name=table_name,
-                                                                      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)
 
@@ -210,7 +177,7 @@ class SequenceController(TableController):
         sequence_data_files: SequenceDataFiles = self.data_files[-1]
         return sequence_data_files.dir
 
-    def get_data(self, custom_path:Optional[str] = None ) -> list[AgilentChannelChromatogramData]:
+    def get_data(self, custom_path: Optional[str] = None) -> list[AgilentChannelChromatogramData]:
         parent_dir = self.data_files[-1].dir if not custom_path else custom_path
         subdirs = [x[0] for x in os.walk(self.data_dir)]
         potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))

{pychemstation-0.5.9 → pychemstation-0.5.10}/pychemstation/control/controllers/table_controller.py

@@ -14,19 +14,19 @@ from result import Result, Ok, Err
 from ...control.controllers.comm import CommunicationController
 from ...utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
 from ...utils.macro import Command, HPLCRunningStatus, Response
-from ...utils.method_types import MethodTimetable
+from ...utils.method_types import MethodDetails
 from ...utils.sequence_types import SequenceDataFiles, SequenceTable
 from ...utils.table_types import Table, TableOperation, RegisterFlag
 
+TableType = Union[MethodDetails, SequenceTable]
 
-TableType = Union[MethodTimetable, SequenceTable]
 
 class TableController(abc.ABC):
 
     def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
         self.controller = controller
         self.table = table
-        self.table_state : Optional[TableType] = None
+        self.table_state: Optional[TableType] = None
 
         if os.path.isdir(src):
             self.src: str = src
@@ -38,7 +38,7 @@ class TableController(abc.ABC):
         else:
             raise FileNotFoundError(f"dir: {data_dir} not found.")
 
-        self.spectra: dict[str, AgilentHPLCChromatogram] = {
+        self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {
             "A": AgilentHPLCChromatogram(self.data_dir),
             "B": AgilentHPLCChromatogram(self.data_dir),
             "C": AgilentHPLCChromatogram(self.data_dir),
@@ -51,6 +51,9 @@ class TableController(abc.ABC):
 
         self.data_files: Union[list[SequenceDataFiles], list[str]] = []
 
+        # Initialize row counter for table operations
+        self.send('Local Rows')
+
     def receive(self) -> Result[Response, str]:
         for _ in range(10):
             try:
@@ -60,6 +63,9 @@ class TableController(abc.ABC):
         return Err("Could not parse response")
 
     def send(self, cmd: Union[Command, str]):
+        if not self.controller:
+            raise RuntimeError(
+                "Communication controller must be initialized before sending command. It is currently in offline mode.")
         self.controller.send(cmd)
 
     def sleepy_send(self, cmd: Union[Command, str]):
@@ -85,6 +91,46 @@ class TableController(abc.ABC):
                                                                                      row=row,
                                                                                      col_name=col_name.value))
 
+    def add_new_col_num(self,
+                        col_name: RegisterFlag,
+                        val: Union[int, float]):
+        self.sleepy_send(TableOperation.NEW_COL_VAL.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            col_name=col_name,
+            val=val))
+
+    def add_new_col_text(self,
+                         col_name: RegisterFlag,
+                         val: str):
+        self.sleepy_send(TableOperation.NEW_COL_TEXT.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            col_name=col_name,
+            val=val))
+
+    def edit_row_num(self,
+                     col_name: RegisterFlag,
+                     val: Union[int, float],
+                     row: Optional[int] = None):
+        self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            row=row if row is not None else 'Rows',
+            col_name=col_name,
+            val=val))
+
+    def edit_row_text(self,
+                      col_name: RegisterFlag,
+                      val: str,
+                      row: Optional[int] = None):
+        self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(
+            register=self.table.register,
+            table_name=self.table.name,
+            row=row if row is not None else 'Rows',
+            col_name=col_name,
+            val=val))
+
     @abc.abstractmethod
     def get_row(self, row: int):
         pass
@@ -150,7 +196,7 @@ class TableController(abc.ABC):
         return started_running
 
     def check_hplc_done_running(self,
-                                method: Optional[MethodTimetable] = None,
+                                method: Optional[MethodDetails] = None,
                                 sequence: Optional[SequenceTable] = None) -> Result[str, str]:
         """
         Checks if ChemStation has finished running and can read data back
@@ -213,4 +259,8 @@ class TableController(abc.ABC):
         Load chromatogram for any channel in spectra dictionary.
         """
         for channel, spec in self.spectra.items():
-            spec.load_spectrum(data_path=data_file, channel=channel)
+            try:
+                spec.load_spectrum(data_path=data_file, channel=channel)
+            except FileNotFoundError:
+                self.spectra[channel] = None
+                print(f"No data at channel: {channel}")