Add scrollbar to updating label in tkinter python?

Question

The issue I have is that I can't find a way to incorporate a scrollbar with my current code. I have an updating label that adds text that is being spat out by a subprocess but the data disappears as more data is created. In this case, the numbers disappear out of sight. Here is my current code:

import logging
import os
import sys
from subprocess import Popen, PIPE, STDOUT
from threading import Thread

try:
    import tkinter as tk
except ImportError: # Python 3
    import tkinter as tk

info = logging.getLogger(__name__).info

# define dummy subprocess to generate some output
cmd = [sys.executable or "python", "-u", "-c", """
import itertools, time

for i in itertools.count():
    print(i)
    time.sleep(0.5)
"""]

class ShowProcessOutputDemo:
    def __init__(self, root):
        """Start subprocess, make GUI widgets."""
        self.root = root

        # start subprocess
        self.proc = Popen(cmd, stdout=PIPE, stderr=STDOUT)

        # stop subprocess using a button
        tk.Button(root, text="Stop subprocess", command=self.stop).pack()

        self.label = tk.Label(root) # put subprocess output here
        self.label.pack()

        # Create a buffer for the stdout
        self.stdout_data = ""
        # Create a new thread that will read stdout and write the data to
        # `self.stdout_buffer`
        thread = Thread(target=self.read_output, args=(self.proc.stdout, ))
        thread.start()

        # A tkinter loop that will show `self.stdout_data` on the screen
        self.show_stdout()

    def read_output(self, pipe):
        """Read subprocess' output and store it in `self.stdout_data`."""
        while True:
            data = os.read(pipe.fileno(), 1 << 20)
            # Windows uses: "\r\n" instead of "\n" for new lines.
            data = data.replace(b"\r\n", b"\n")
            if data:
                info("got: %r", data)
                self.stdout_data += data.decode()
            else:  # clean up
                info("eof")
                self.root.after(5000, self.stop) # stop in 5 seconds
                return None

    def show_stdout(self):
        """Read `self.stdout_data` and put the data in the GUI."""
        self.label.config(text=self.stdout_data.strip("\n"))
        self.root.after(100, self.show_stdout)

    def stop(self, stopping=[]):
        """Stop subprocess and quit GUI."""
        if stopping:
            return # avoid killing subprocess more than once
        stopping.append(True)

        info("stopping")
        self.proc.terminate() # tell the subprocess to exit

        # kill subprocess if it hasn't exited after a countdown
        def kill_after(countdown):
            if self.proc.poll() is None: # subprocess hasn't exited yet
                countdown -= 1
                if countdown < 0: # do kill
                    info("killing")
                    self.proc.kill() # more likely to kill on *nix
                else:
                    self.root.after(1000, kill_after, countdown)
                    return # continue countdown in a second

            self.proc.stdout.close()  # close fd
            self.proc.wait()          # wait for the subprocess' exit
            self.root.destroy()       # exit GUI
        kill_after(countdown=5)

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
root = tk.Tk()
app = ShowProcessOutputDemo(root)
root.protocol("WM_DELETE_WINDOW", app.stop) # exit subprocess if GUI is closed
root.mainloop()
info("exited")

I understand that labels do not support scrollbars but text does. Although this would be a good solution I haven't found a way to convert the current output data to text.

Thanks For Reading - Connor

Answer 1

The only solution that works well on tkinter is to print a frame on a canvas and then make the canvas scroll-able. My example does the same as yours, you just need to use the Scrolable_Frame as I did.

from subprocess import Popen, PIPE, STDOUT
from threading import Thread
import tkinter as tk
import logging
import time
import sys

info = logging.getLogger(__name__).info
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")

platform = windows = 'mswin'

# define dummy subprocess to generate some output
cmd = [sys.executable or "python", "-u", "-c", """
import itertools, time

for i in itertools.count():
    print(i)
    time.sleep(0.5)
exit()
""", "exit"]

class OStream(Thread):

    enable_print = True

    def handel_line(self, line):
        if platform == windows:
            # Windows uses: "\r\n" instead of "\n" for new lines.
            line = line.replace(b"\r\n", b"\n")
        if self.enable_print:
            info("got: %r", line)
        if self.stream_print is not None:
            self.stream_print(line)

    def stop(self):
        self.alive = False

    def run(self):
        while self.alive:
            for s in self.ostrams:
                line = s.stdout.readline()
                if line:
                    self.handel_line(line)
            time.sleep(0.2)
        info("OStream Exit")

    def pipe_proc(self, stream):
        self.ostrams.append(stream)

    def stream_callback(self, func):
        self.stream_print = func

    def __init__(self):
        self.ostrams = []
        self.alive = True
        self.stream_print = None
        Thread.__init__(self)

class Scrolable_Frame(tk.Frame):

    def get(self):
        return self.interior

    def __init__(self, master):
        tk.Frame.__init__(self, master)

        self.scroll = tk.Scrollbar(self)
        self.scroll.pack(side=tk.RIGHT, fill=tk.Y)
        self.canvas = tk.Canvas(
            self, bd=0, highlightthickness=0,
            yscrollcommand=self.scroll.set)
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.TRUE)
        self.scroll.config(command=self.canvas.yview)

        self.canvas.xview_moveto(0)
        self.canvas.yview_moveto(0)

        self.interior = tk.Frame(self.canvas)
        interior_id = self.canvas.create_window(
            0, 0, window=self.interior, anchor=tk.NW
        )

        def _configure_interior(_):
            size = (self.interior.winfo_reqwidth(), self.interior.winfo_reqheight())
            self.canvas.config(scrollregion="0 0 %s %s" % size)
            if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
                self.canvas.config(width=self.interior.winfo_reqwidth())
        self.interior.bind('<Configure>', _configure_interior)

        def _configure_canvas(_):
            if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
                self.canvas.itemconfigure(interior_id, width=self.canvas.winfo_width())
        self.canvas.bind('<Configure>', _configure_canvas)

        def _on_mousewheel(event):
            self.canvas.yview_scroll(int(-1 * (event.delta / 120)), 'units')
        self.canvas.bind_all("<MouseWheel>", _on_mousewheel)

class ShowProcessOutputDemo(tk.Tk):
    def __init__(self):
        """Start subprocess, make GUI widgets."""
        tk.Tk.__init__(self)
        self.geometry('300x200+500+300')
        self.protocol("WM_DELETE_WINDOW", self.stop)

        self.proc = Popen(cmd, stdout=PIPE, stderr=STDOUT)

        self.ostream = OStream()
        self.ostream.pipe_proc(self.proc)
        self.ostream.stream_callback(self.add_label)
        self.ostream.start()

        self.exit_button = tk.Button(
            self, text="Stop subprocess", command=self.stop
        )
        self.exit_button.pack(pady=20)

        self.scolable_frame = Scrolable_Frame(self)
        self.scolable_frame.pack(
            expand=True, fill=tk.BOTH, pady=20, padx=20
        )

    def add_label(self, line):
        line_text = 'OStream line content: {0}'.format(line[:-1].decode())
        tk.Label(
            self.scolable_frame.get(), text=line_text
        ).pack(anchor=tk.CENTER, expand=True, fill=tk.X)

    def stop(self):
        """Stop subprocess and quit GUI."""

        self.ostream.stop()

        self.proc.kill()
        self.proc.stdout.close()
        self.proc.wait(timeout=2)

        info("GUI Exit")
        self.quit()


if __name__ == '__main__':
    app = ShowProcessOutputDemo()
    app.mainloop()