nbs-livetable 0.1.1__py3-none-any.whl

nbs_livetable/QtKafkaTable.py

@@ -0,0 +1,176 @@
+from qtpy.QtWidgets import (
+    QWidget,
+    QLabel,
+    QApplication,
+    QVBoxLayout,
+    QMainWindow,
+    QCheckBox,
+    QHBoxLayout,
+)
+from qtpy.QtCore import QThread, Slot, Signal, QObject, Qt, QTimer
+from qtpy.QtGui import QFontInfo, QFont
+import argparse
+import queue
+import time
+from .kafka_table import qt_kafka_table
+
+# from bluesky_widgets.qt.run_engine_client import QtReConsoleMonitor
+
+from .simpleConsoleMonitor import QtReConsoleMonitor
+import sys
+
+
+class LiveTableModel(QWidget):
+    def __init__(
+        self,
+        beamline_acronym,
+        config_file,
+        topic_string="bluesky.runengine.documents",
+        parent=None,
+    ):
+        super().__init__(parent)
+        self.msg_queue = queue.Queue()
+        self.kafka_dispatcher, self.callback = qt_kafka_table(
+            beamline_acronym,
+            config_file,
+            topic_string,
+            self.newMsg,
+        )
+        self.kafka_dispatcher.setParent(self)
+        self.kafka_dispatcher.start()
+
+        label = QLabel("Test")
+        vbox = QVBoxLayout()
+        vbox.addWidget(label)
+        self.setLayout(vbox)
+        self.destroyed.connect(lambda: self.stop_console_output_monitoring)
+
+    def newMsg(self, msg):
+        self.msg_queue.put(msg)
+        # print(msg)
+
+    def start_console_output_monitoring(self):
+        print("Start Console Output Monitoring")
+        self._stop_console_monitor = False
+
+    def stop_console_output_monitoring(self):
+        print("Stop Console Monitoring")
+        self.kafka_dispatcher.stop()
+        self._stop_console_monitor = True
+
+    def continue_polling(self):
+        return not self._stop_console_monitor
+
+    # def console_monitoring_thread(self, *, callback):
+    def console_monitoring_thread(self):
+        # print("Monitoring")
+        for n in range(5):
+            try:
+                msg = self.msg_queue.get(timeout=0.2)
+                msg = msg.rstrip("\n") + "\n"
+                msgtime = time.time()
+                return msgtime, msg
+
+            except queue.Empty:
+                pass
+            except Exception as ex:
+                print(f"Exception occurred: {ex}")
+
+            if self._stop_console_monitor:
+                print("Stop monitoring!")
+        return None, None
+
+
+class QtKafkaTableTab(QWidget):
+    name = "Live Table"
+
+    def __init__(self, model, parent=None):
+        super().__init__(parent)
+        self.config = model.settings.gui_config
+        bl_acronym = self.config.get("kafka", {}).get("bl_acronym", "")
+        kafka_config = self.config.get("kafka", {}).get("config_file", "")
+        topic_string = self.config.get("kafka", {}).get(
+            "topic_string", "bluesky.runengine.documents"
+        )
+        self.kafkaTable = LiveTableModel(
+            bl_acronym, kafka_config, topic_string=topic_string
+        )
+        self.kafkaMonitor = QtReConsoleMonitor(self.kafkaTable, self)
+
+        # Set up monospace font
+        font = self.kafkaMonitor._text_edit.font()
+        font.setFamily("Monospace")
+        font.setStyleHint(QFont.Monospace)
+        self.kafkaMonitor._text_edit.setFont(font)
+
+        # Create baseline control
+        self.baselineCheck = QCheckBox("Show Baseline", self)
+        self.baselineCheck.setChecked(True)
+        self.baselineCheck.stateChanged.connect(self.toggleBaseline)
+
+        vbox = QVBoxLayout()
+        vbox.addWidget(QLabel("Kafka Table Monitor"))
+
+        # Add controls in a horizontal layout
+        controls = QHBoxLayout()
+        controls.addWidget(self.baselineCheck)
+        controls.addStretch()  # Push controls to the left
+        vbox.addLayout(controls)
+
+        vbox.addWidget(self.kafkaMonitor)
+        self.setLayout(vbox)
+
+        font = self.kafkaMonitor._text_edit.font()
+        actual_font = QFontInfo(font)
+        print(f"Font used: {actual_font.family()}, Font Desired: {font.family()}")
+
+    def toggleBaseline(self, state):
+        """Toggle baseline readings on/off."""
+        if hasattr(self.kafkaTable, "callback"):
+            self.kafkaTable.callback.baseline_enabled = bool(state)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Kafka LiveTable Monitor")
+    parser.add_argument(
+        "--bl", required=True, help="Beamline acronym used for kafka topic"
+    )
+    parser.add_argument(
+        "--config-file",
+        default="/etc/bluesky/kafka.yml",
+        help="kafka config file location",
+    )
+    parser.add_argument(
+        "--topic-string",
+        default="bluesky.runengine.documents",
+        help="string to be combined with acronym to create topic",
+    )
+
+    args = parser.parse_args()
+    app = QApplication([])
+
+    main_window = QMainWindow()
+    # model = LiveTableModel(args.bl, args.config_file, topic_string=args.topic_string)
+    # central_widget = LiveTableModel2(args.bl, args.config_file, topic_string=args.topic_string)
+    model = LiveTableModel(args.bl, args.config_file, topic_string=args.topic_string)
+    # central_widget = LiveTableModel3(args.bl, args.config_file, topic_string=args.topic_string)
+    central_widget = QtReConsoleMonitor(model, main_window)
+    # Ensure the font family is set to a monospace font that exists on the system
+    font = central_widget._text_edit.font()
+    font.setFamily("Monospace")
+    font.setStyleHint(QFont.Monospace)
+    central_widget._text_edit.setFont(font)
+    font = central_widget._text_edit.font()
+    actual_font = QFontInfo(font)
+    print(f"Font used: {actual_font.family()}, Font Desired: {font.family()}")
+    # model.setParent(central_widget)
+    # central_widget.start_console_output_monitoring()
+    main_window.setCentralWidget(central_widget)
+    central_widget.destroyed.connect(lambda: model.stop_console_output_monitoring)
+    main_window.show()
+    app_ref = app.exec_()
+    sys.exit(app_ref)
+
+
+if __name__ == "__main__":
+    main()

nbs_livetable/QtZmqTable.py

@@ -0,0 +1,151 @@
+from qtpy.QtWidgets import (
+    QWidget,
+    QLabel,
+    QApplication,
+    QVBoxLayout,
+    QMainWindow,
+    QCheckBox,
+    QHBoxLayout,
+)
+from qtpy.QtCore import QThread, Slot, Signal, QObject, Qt, QTimer
+from qtpy.QtGui import QFontInfo, QFont
+
+# import argparse
+import queue
+import time
+
+# from .kafka_table import qt_kafka_table
+from .zmq_table import qt_zmq_table
+
+# from bluesky_widgets.qt.run_engine_client import QtReConsoleMonitor
+
+from .simpleConsoleMonitor import QtReConsoleMonitor
+import sys
+
+
+class LiveTableModel(QWidget):
+    def __init__(
+        self,
+        parent=None,
+    ):
+        super().__init__(parent)
+        self.msg_queue = queue.Queue()
+        zmq_dispatcher, callback = qt_zmq_table(self.newMsg)
+        self.zmq_dispatcher = zmq_dispatcher
+        self.callback = callback
+        self.zmq_dispatcher.setParent(self)
+        self.zmq_dispatcher.start()
+
+        label = QLabel("Test")
+        vbox = QVBoxLayout()
+        vbox.addWidget(label)
+        self.setLayout(vbox)
+        self.destroyed.connect(lambda: self.stop_console_output_monitoring)
+
+    def newMsg(self, msg):
+        self.msg_queue.put(msg)
+        # print(msg)
+
+    def start_console_output_monitoring(self):
+        print("Start Console Output Monitoring")
+        self._stop_console_monitor = False
+
+    def stop_console_output_monitoring(self):
+        print("Stop Console Monitoring")
+        self.zmq_dispatcher.stop()
+        self._stop_console_monitor = True
+
+    def continue_polling(self):
+        return not self._stop_console_monitor
+
+    # def console_monitoring_thread(self, *, callback):
+    def console_monitoring_thread(self):
+        # print("Monitoring")
+        for n in range(5):
+            try:
+                msg = self.msg_queue.get(timeout=0.2)
+                msg = msg.rstrip("\n") + "\n"
+                msgtime = time.time()
+                return msgtime, msg
+
+            except queue.Empty:
+                pass
+            except Exception as ex:
+                print(f"Exception occurred: {ex}")
+
+            if self._stop_console_monitor:
+                print("Stop monitoring!")
+        return None, None
+
+
+class QtZMQTableTab(QWidget):
+    name = "Live Table"
+
+    def __init__(self, model, parent=None):
+        super().__init__(parent)
+        self.config = model.settings.gui_config
+        self.zmqTable = LiveTableModel(self)
+        self.zmqMonitor = QtReConsoleMonitor(self.zmqTable, self)
+
+        # Printing the font and font family used by self.zmqMonitor
+        font = self.zmqMonitor._text_edit.font()
+        font.setFamily("Monospace")
+        font.setStyleHint(QFont.Monospace)
+        self.zmqMonitor._text_edit.setFont(font)
+
+        # Create baseline control
+        self.baselineCheck = QCheckBox("Show Baseline", self)
+        self.baselineCheck.setChecked(True)
+        self.baselineCheck.stateChanged.connect(self.toggleBaseline)
+
+        vbox = QVBoxLayout()
+        vbox.addWidget(QLabel("ZMQ Table Monitor"))
+
+        # Add controls in a horizontal layout
+        controls = QHBoxLayout()
+        controls.addWidget(self.baselineCheck)
+        controls.addStretch()  # Push controls to the left
+        vbox.addLayout(controls)
+
+        vbox.addWidget(self.zmqMonitor)
+        self.setLayout(vbox)
+
+        font = self.zmqMonitor._text_edit.font()
+        actual_font = QFontInfo(font)
+        print(f"Font used: {actual_font.family()}, Font Desired: {font.family()}")
+
+    def toggleBaseline(self, state):
+        """Toggle baseline readings on/off."""
+        print("Toggle Baseline")
+        if hasattr(self.zmqTable, "callback"):
+            print("Baseline enabled: ", bool(state))
+            self.zmqTable.callback.baseline_enabled = bool(state)
+        else:
+            print("No callback found")
+
+
+def main():
+    app = QApplication([])
+
+    main_window = QMainWindow()
+    model = LiveTableModel()
+    central_widget = QtReConsoleMonitor(model, main_window)
+    # Ensure the font family is set to a monospace font that exists on the system
+    font = central_widget._text_edit.font()
+    font.setFamily("Monospace")
+    font.setStyleHint(QFont.Monospace)
+    central_widget._text_edit.setFont(font)
+    font = central_widget._text_edit.font()
+    actual_font = QFontInfo(font)
+    print(f"Font used: {actual_font.family()}, Font Desired: {font.family()}")
+    # model.setParent(central_widget)
+    # central_widget.start_console_output_monitoring()
+    main_window.setCentralWidget(central_widget)
+    central_widget.destroyed.connect(lambda: model.stop_console_output_monitoring)
+    main_window.show()
+    app_ref = app.exec_()
+    sys.exit(app_ref)
+
+
+if __name__ == "__main__":
+    main()

nbs_livetable/kafka_table.py

@@ -0,0 +1,87 @@
+import nslsii.kafka_utils
+from bluesky_kafka import RemoteDispatcher
+from bluesky_widgets.qt.kafka_dispatcher import QtRemoteDispatcher
+from bluesky.callbacks.best_effort import BestEffortCallback
+from .lessEffortCallback import LessEffortCallback
+import uuid
+import argparse
+
+
+def kafka_table(
+    beamline_acronym,
+    config_file,
+    topic_string="bluesky.documents",
+    out=print,
+    continue_polling=None,
+):
+    bec = LessEffortCallback(out=out)
+    # bec = BestEffortCallback()
+    kafka_config = nslsii.kafka_utils._read_bluesky_kafka_config_file(
+        config_file_path=config_file
+    )
+
+    # this consumer should not be in a group with other consumers
+    #   so generate a unique consumer group id for it
+    unique_group_id = f"echo-{beamline_acronym}-{str(uuid.uuid4())[:8]}"
+
+    kafka_dispatcher = RemoteDispatcher(
+        topics=[f"{beamline_acronym}.{topic_string}"],
+        bootstrap_servers=",".join(kafka_config["bootstrap_servers"]),
+        group_id=unique_group_id,
+        consumer_config=kafka_config["runengine_producer_config"],
+    )
+
+    kafka_dispatcher.subscribe(bec)
+    kafka_dispatcher.start(continue_polling=continue_polling)
+
+
+def qt_kafka_table(
+    beamline_acronym,
+    config_file,
+    topic_string="bluesky.documents",
+    out=print,
+):
+    bec = LessEffortCallback(out=out)
+    # bec = BestEffortCallback()
+    kafka_config = nslsii.kafka_utils._read_bluesky_kafka_config_file(
+        config_file_path=config_file
+    )
+
+    # this consumer should not be in a group with other consumers
+    #   so generate a unique consumer group id for it
+    unique_group_id = f"echo-{beamline_acronym}-{str(uuid.uuid4())[:8]}"
+
+    kafka_dispatcher = QtRemoteDispatcher(
+        topics=[f"{beamline_acronym}.{topic_string}"],
+        bootstrap_servers=",".join(kafka_config["bootstrap_servers"]),
+        group_id=unique_group_id,
+        consumer_config=kafka_config["runengine_producer_config"],
+    )
+
+    kafka_dispatcher.subscribe(bec)
+    return kafka_dispatcher, bec
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Kafka LiveTable Monitor")
+    parser.add_argument(
+        "--bl", required=True, help="Beamline acronym used for kafka topic"
+    )
+    parser.add_argument(
+        "--config-file",
+        default="/etc/bluesky/kafka.yml",
+        help="kafka config file location",
+    )
+    parser.add_argument(
+        "--topic-string",
+        default="bluesky.runengine.documents",
+        help="string to be combined with acronym to create topic",
+    )
+
+    args = parser.parse_args()
+
+    kafka_table(args.bl, args.config_file, args.topic_string)
+
+
+if __name__ == "__main__":
+    main()

nbs_livetable/lessEffortCallback.py

@@ -0,0 +1,258 @@
+"""
+Best Effort Callback.
+For instructions on how to test in a simulated environment please see:
+    tests/interactive/best_effort_cb.py
+"""
+
+import logging
+import sys
+import time
+from datetime import datetime
+from io import StringIO
+from warnings import warn
+
+
+from bluesky.callbacks.core import LiveTable, make_class_safe, CallbackBase
+
+logger = logging.getLogger(__name__)
+
+
+def hinted_fields(descriptor):
+    # Figure out which columns to put in the table.
+    obj_names = list(descriptor["object_keys"])
+    # We will see if these objects hint at whether
+    # a subset of their data keys ('fields') are interesting. If they
+    # did, we'll use those. If these didn't, we know that the RunEngine
+    # *always* records their complete list of fields, so we can use
+    # them all unselectively.
+    columns = []
+    for obj_name in obj_names:
+        try:
+            fields = descriptor.get("hints", {}).get(obj_name, {})["fields"]
+        except KeyError:
+            fields = descriptor["object_keys"][obj_name]
+        columns.extend(fields)
+    return columns
+
+
+@make_class_safe(logger=logger)
+class LessEffortCallback(CallbackBase):
+    def __init__(
+        self,
+        *,
+        fig_factory=None,
+        table_enabled=True,
+        out=print,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        # internal state
+        self._start_doc = None
+        self._descriptors = {}
+        self._table = None
+        self._heading_enabled = True
+        self._table_enabled = table_enabled
+        self._baseline_enabled = True
+        self._out = out
+        self._cleanup_motor_heuristic = False
+        self._stream_names_seen = set()
+        self._started = False
+
+        # hack to handle the bottom border of the table
+        self._buffer = StringIO()
+        self._baseline_toggle = True
+
+    @property
+    def baseline_enabled(self):
+        """Whether baseline readings are printed."""
+        return self._baseline_enabled
+
+    @baseline_enabled.setter
+    def baseline_enabled(self, enabled):
+        """Enable or disable baseline readings."""
+        self._baseline_enabled = bool(enabled)
+
+    def enable_heading(self):
+        "Print timestamp and IDs at the top of a run."
+        self._heading_enabled = True
+
+    def disable_heading(self):
+        "Opposite of enable_heading()"
+        self._heading_enabled = False
+
+    def enable_table(self):
+        "Print hinted readings from the 'primary' stream in a LiveTable."
+        self._table_enabled = True
+
+    def disable_table(self):
+        "Opposite of enable_table()"
+        self._table_enabled = False
+
+    def __call__(self, name, doc, *args, **kwargs):
+        if not (self._table_enabled or self._baseline_enabled):
+            return
+        super().__call__(name, doc, *args, **kwargs)
+
+    def start(self, doc):
+        self.clear()
+        print("Start Doc Received")
+        self._start_doc = doc
+        self.plan_hints = doc.get("hints", {})
+
+        # Prepare a guess about the dimensions (independent variables) in case
+        # we need it.
+        motors = self._start_doc.get("motors")
+        if motors is not None:
+            GUESS = [([motor], "primary") for motor in motors]
+        else:
+            GUESS = [(["time"], "primary")]
+
+        # Ues the guess if there is not hint about dimensions.
+        dimensions = self.plan_hints.get("dimensions")
+        if dimensions is None:
+            self._cleanup_motor_heuristic = True
+            dimensions = GUESS
+
+        # We can only cope with all the dimensions belonging to the same
+        # stream unless we resample. We are not doing to handle that yet.
+        if len(set(d[1] for d in dimensions)) != 1:  # noqa: C401
+            self._cleanup_motor_heuristic = True
+            dimensions = GUESS  # Fall back on our GUESS.
+            warn(
+                "We are ignoring the dimensions hinted because we cannot "
+                "combine streams."
+            )  # noqa: B028
+
+        # for each dimension, choose one field only
+        # the plan can supply a list of fields. It's assumed the first
+        # of the list is always the one plotted against
+        self.dim_fields = []
+        for fields, stream_name in dimensions:
+            try:
+                self.dim_fields.append(fields[0])
+            except:
+                continue
+
+        # make distinction between flattened fields and plotted fields
+        # motivation for this is that when plotting, we find dependent variable
+        # by finding elements that are not independent variables
+        self.all_dim_fields = [
+            field for fields, stream_name in dimensions for field in fields
+        ]
+
+        _, self.dim_stream = dimensions[0]
+
+        # Print heading.
+        tt = datetime.fromtimestamp(self._start_doc["time"]).utctimetuple()
+        if self._heading_enabled:
+            self._out(
+                "\n\nTransient Scan ID: {0}     Time: {1}".format(  # noqa: UP030
+                    self._start_doc.get("scan_id", ""),
+                    time.strftime("%Y-%m-%d %H:%M:%S", tt),
+                )
+            )
+            self._out(
+                "Persistent Unique Scan ID: '{0}'".format(self._start_doc["uid"])
+            )  # noqa: UP030
+        self._started = True
+
+    def descriptor(self, doc):
+        if not self._started:
+            return
+        self._descriptors[doc["uid"]] = doc
+        stream_name = doc.get("name", "primary")  # fall back for old docs
+
+        if stream_name not in self._stream_names_seen:
+            self._stream_names_seen.add(stream_name)
+            if self._table_enabled:
+                self._out(f"New stream: {stream_name!r}")
+
+        columns = hinted_fields(doc)
+
+        # ## This deals with old documents. ## #
+        if stream_name == "primary" and self._cleanup_motor_heuristic:
+            # We stashed object names in self.dim_fields, which we now need to
+            # look up the actual fields for.
+            self._cleanup_motor_heuristic = False
+            fixed_dim_fields = []
+            for obj_name in self.dim_fields:
+                # Special case: 'time' can be a dim_field, but it's not an
+                # object name. Just add it directly to the list of fields.
+                if obj_name == "time":
+                    fixed_dim_fields.append("time")
+                    continue
+                try:
+                    fields = doc.get("hints", {}).get(obj_name, {})["fields"]
+                except KeyError:
+                    fields = doc["object_keys"][obj_name]
+                fixed_dim_fields.extend(fields)
+            self.dim_fields = fixed_dim_fields
+
+        # Ensure that no independent variables ('dimensions') are
+        # duplicated here.
+        columns = [c for c in columns if c not in self.all_dim_fields]
+
+        # ## TABLE ## #
+        if stream_name == self.dim_stream:
+            if self._table_enabled:
+                # plot everything, independent or dependent variables
+                self._table = LiveTable(
+                    list(self.all_dim_fields) + columns,
+                    separator_lines=False,
+                    out=self._out,
+                )
+                self._table("start", self._start_doc)
+                self._table("descriptor", doc)
+
+    def event(self, doc):
+        if not self._started:
+            return
+        descriptor = self._descriptors[doc["descriptor"]]
+        if descriptor.get("name") == "primary":
+            if self._table is not None:
+                self._table("event", doc)
+
+        # Show the baseline readings.
+        if descriptor.get("name") == "baseline":
+            columns = hinted_fields(descriptor)
+            self._baseline_toggle = not self._baseline_toggle
+            if self._baseline_enabled:
+                border = "+" + "-" * 32 + "+" + "-" * 32 + "+"
+                if self._baseline_toggle:
+                    print("End-of-run baseline readings:", file=self._buffer)
+                    print(border, file=self._buffer)
+                else:
+                    self._out("Start-of-run baseline readings:")
+                    self._out(border)
+                for k, v in doc["data"].items():
+                    if k not in columns:
+                        continue
+                    if self._baseline_toggle:
+                        print(f"| {k:>30} | {v:<30} |", file=self._buffer)
+                    else:
+                        self._out(f"| {k:>30} | {v:<30} |")
+                if self._baseline_toggle:
+                    print(border, file=self._buffer)
+                else:
+                    self._out(border)
+
+    def stop(self, doc):
+        if not self._started:
+            return
+        if self._table is not None:
+            self._table("stop", doc)
+
+        if self._baseline_enabled:
+            # Print baseline below bottom border of table.
+            self._buffer.seek(0)
+            self._out(self._buffer.read())
+            self._out("\n")
+        self._started = False
+
+    def clear(self):
+        self._start_doc = None
+        self._descriptors.clear()
+        self._stream_names_seen.clear()
+        self._table = None
+        self._buffer = StringIO()
+        self._baseline_toggle = True

nbs_livetable/simpleConsoleMonitor.py

@@ -0,0 +1,174 @@
+from qtpy.QtCore import Qt, QTimer
+from qtpy.QtGui import (
+    QFont,
+    QFontMetrics,
+    QPalette,
+    QTextCursor,
+)
+from qtpy.QtWidgets import (
+    QPlainTextEdit,
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QCheckBox,
+    QPushButton,
+)
+from qtpy.QtGui import QIntValidator
+from bluesky_widgets.qt.threading import FunctionWorker
+
+
+class PushButtonMinimumWidth(QPushButton):
+    """
+    Push button minimum width necessary to fit the text
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        text = self.text()
+        font = self.font()
+
+        fm = QFontMetrics(font)
+        text_width = fm.width(text) + 6
+        self.setFixedWidth(text_width)
+
+
+class QtReConsoleMonitor(QWidget):
+    def __init__(self, model, parent=None):
+        super().__init__(parent)
+        # self.setAttribute(Qt.WA_DeleteOnClose)
+        print("New QtReConsoleMonitor with QPlainTextEdit")
+        self._max_lines = 1000
+
+        self._text_edit = QPlainTextEdit()
+        self._text_edit.setReadOnly(True)
+        self._text_edit.setMaximumBlockCount(self._max_lines)
+
+        p = self._text_edit.palette()
+        p.setColor(QPalette.Base, p.color(QPalette.Disabled, QPalette.Base))
+        self._text_edit.setPalette(p)
+
+        self._text_edit.setFont(QFont("Monospace"))
+
+        self._text_edit.verticalScrollBar().sliderPressed.connect(self._slider_pressed)
+        self._text_edit.verticalScrollBar().sliderReleased.connect(
+            self._slider_released
+        )
+        self._is_slider_pressed = False
+
+        self._pb_clear = PushButtonMinimumWidth("Clear")
+        self._pb_clear.clicked.connect(self._pb_clear_clicked)
+        self._lb_max_lines = QLabel("Max. Lines:")
+        self._le_max_lines = QLineEdit()
+        self._le_max_lines.setMaximumWidth(60)
+        self._le_max_lines.setAlignment(Qt.AlignHCenter)
+        self._le_max_lines.setText(f"{self._max_lines}")
+        self._le_max_lines.editingFinished.connect(self._le_max_lines_editing_finished)
+
+        self._le_max_lines_min = 10
+        self._le_max_lines_max = 10000
+        self._le_max_lines.setValidator(
+            QIntValidator(self._le_max_lines_min, self._le_max_lines_max)
+        )
+
+        self._autoscroll_enabled = True
+        self._cb_autoscroll = QCheckBox("Autoscroll")
+        self._cb_autoscroll.setChecked(True)
+        self._cb_autoscroll.stateChanged.connect(self._cb_autoscroll_state_changed)
+
+        vbox = QVBoxLayout()
+        hbox = QHBoxLayout()
+        hbox.addWidget(self._cb_autoscroll)
+        hbox.addStretch()
+        hbox.addWidget(self._lb_max_lines)
+        hbox.addWidget(self._le_max_lines)
+        hbox.addWidget(self._pb_clear)
+        vbox.addLayout(hbox)
+        vbox.addWidget(self._text_edit)
+        self.setLayout(vbox)
+
+        self.model = model
+        self.model.start_console_output_monitoring()
+        self._start_thread()
+        self._start_timer()
+        self._stop = False
+
+    def _process_new_console_output(self, result):
+        """
+        Process new console output and append to text edit.
+
+        Parameters
+        ----------
+        result : tuple
+            Tuple of (time, msg) where time is a timestamp and msg is the console output
+        """
+        time, msg = result
+
+        # Handle None or empty messages
+        if msg is None or not msg:
+            return
+
+        # Strip any trailing newlines to prevent doubles
+        msg = msg.rstrip("\n")
+
+        # Add the newline explicitly only if we're not at the start
+        if self._text_edit.document().isEmpty():
+            self._text_edit.insertPlainText(msg)
+        else:
+            self._text_edit.insertPlainText("\n" + msg)
+
+        if self._autoscroll_enabled and not self._is_slider_pressed:
+            self._text_edit.moveCursor(QTextCursor.End)
+
+    def _update_console_output(self):
+        """
+        Timer callback to update the display
+        """
+        if not self._stop:
+            self._start_timer()
+
+    def _start_timer(self):
+        """
+        Start the update timer
+        """
+        QTimer.singleShot(195, self._update_console_output)
+
+    def _slider_pressed(self):
+        self._is_slider_pressed = True
+
+    def _slider_released(self):
+        self._is_slider_pressed = False
+
+    def _is_slider_at_bottom(self):
+        sbar = self._text_edit.verticalScrollBar()
+        return sbar.value() == sbar.maximum() and self._autoscroll_enabled
+
+    def _pb_clear_clicked(self):
+        self._text_edit.clear()
+
+    def _le_max_lines_editing_finished(self):
+        v = int(self._le_max_lines.text())
+        v = max(min(v, self._le_max_lines_max), self._le_max_lines_min)
+        self._le_max_lines.setText(f"{v}")
+        self._max_lines = v
+        self._text_edit.setMaximumBlockCount(v)
+
+    def _cb_autoscroll_state_changed(self, state):
+        self._autoscroll_enabled = state == Qt.Checked
+
+    def _start_thread(self):
+        """
+        Start a new thread to monitor console output
+        """
+        self._thread = FunctionWorker(self.model.console_monitoring_thread)
+        self._thread.returned.connect(self._process_new_console_output)
+        self._thread.finished.connect(self._finished_receiving_console_output)
+        self._thread.start()
+
+    def _finished_receiving_console_output(self):
+        """
+        Callback when thread finishes - starts a new thread if not stopped
+        """
+        if not self._stop:
+            self._start_thread()

nbs_livetable/zmq_table.py

@@ -0,0 +1,35 @@
+from bluesky.callbacks.zmq import RemoteDispatcher
+from bluesky_widgets.qt.zmq_dispatcher import RemoteDispatcher as QtRemoteDispatcher
+from bluesky.callbacks.best_effort import BestEffortCallback
+from .lessEffortCallback import LessEffortCallback
+
+
+def zmq_table(out=print, continue_polling=None):
+    callback = LessEffortCallback(out=out)
+    # bec = BestEffortCallback()
+
+    zmq_dispatcher = RemoteDispatcher("localhost:5578")
+
+    zmq_dispatcher.subscribe(callback)
+    zmq_dispatcher.start()
+
+
+def qt_zmq_table(out=print):
+    callback = LessEffortCallback(out=out)
+    # bec = BestEffortCallback()
+
+    zmq_dispatcher = QtRemoteDispatcher("localhost:5578")
+
+    zmq_dispatcher.subscribe(callback)
+
+    return zmq_dispatcher, callback
+
+
+def main():
+
+    zmq_table()
+
+
+if __name__ == "__main__":
+
+    main()

nbs_livetable-0.1.1.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: nbs-livetable
+Version: 0.1.1
+Summary: An implementation of LiveTable running over Kafka or ZMQ
+Project-URL: homepage, https://github.com/xraygui/livetable
+Author-email: Charles Titus <ctitus@bnl.gov>
+Keywords: bluesky,gui,nsls-ii
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Public Domain
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: bluesky-kafka>=0.10.0
+Requires-Dist: bluesky-widgets>=0.0.16
+Requires-Dist: nslsii
+Requires-Dist: qtpy

nbs_livetable-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+nbs_livetable/QtKafkaTable.py,sha256=4sxkzq8H7ODyRlsCALotuR1UGZ-J3TE5zffgzxVJWMw,5834
+nbs_livetable/QtZmqTable.py,sha256=n6pfDXDHfMuIZEWEhxS9P5UL_rBpXSTwOMxpMkTPPDE,4675
+nbs_livetable/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nbs_livetable/kafka_table.py,sha256=w9ntYxTI3iwozFR97IM2q-q0ugNUX65sfyImghuuqiM,2657
+nbs_livetable/lessEffortCallback.py,sha256=PC75L3fj1gcdVa80lDHhuTryItIhP-2Vk8VbTRnP3rY,9211
+nbs_livetable/simpleConsoleMonitor.py,sha256=OcaaDsdRUE6vp_XzPW--_q2xHr19PHHqY3_As4putKg,5499
+nbs_livetable/zmq_table.py,sha256=ixI8jZ7gSBZn7CaB3oANzc9fqOVXiBzZFh779EfgDRU,814
+nbs_livetable-0.1.1.dist-info/METADATA,sha256=f606KW99I8rOzrPMzTKqB-c8kEDC9FgRStJglmd7-EI,581
+nbs_livetable-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nbs_livetable-0.1.1.dist-info/entry_points.txt,sha256=U6NwttShqrT19WdxjhRyIlOyP5FIIH-erT8czmJ_YVk,346
+nbs_livetable-0.1.1.dist-info/RECORD,,

nbs_livetable-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

nbs_livetable-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,9 @@
+[console_scripts]
+kafka-livetable = nbs_livetable.kafka_table:main
+qt-kafka-livetable = nbs_livetable.QtKafkaTable:main
+qt-zmq-livetable = nbs_livetable.QtZmqTable:main
+zmq-livetable = nbs_livetable.zmq_table:main
+
+[nbs_gui.tabs]
+kafka-table-tab = nbs_livetable.QtKafkaTable:QtKafkaTableTab
+zmq-table-tab = nbs_livetable.QtZmqTable:QtZMQTableTab