🖥️ A chat window of your own: tkinter and Ollama · หน้าต่างแชตของคุณเอง: tkinter กับ Ollama · 属于你自己的聊天窗口：tkinter 和 Ollama

1 A window that listens · หน้าต่างที่รับฟัง · 一个会听你说话的窗口

📄 NEW FILE · win1.py

"""win1.py — a window, a box to type in, and somewhere for the words to go."""
import tkinter as tk

# ScrolledText is a Text box with a scrollbar already attached to it. It lives
# in its own module, so importing tkinter alone is not enough.
from tkinter import scrolledtext


class ChatWindow:
    """Everything the window is made of, kept in one place."""

    def __init__(self, root):
        # root is the window itself. Every widget must say which thing it sits
        # inside, and that is what the first argument to each one below is.
        self.root = root
        root.title("Chat")               # the words in the title bar
        root.geometry("520x420")         # width by height, in pixels

        # wrap="word" breaks long lines at spaces instead of mid-word.
        # state="disabled" makes it read-only, so a click cannot type into it.
        # height=10 asks for ten lines. The default is 24, which is taller
        # than the window, and it pushes the typing box off the bottom.
        self.transcript = scrolledtext.ScrolledText(
            root, wrap="word", font=("Segoe UI", 11), padx=10, pady=10,
            height=10, state="disabled")

        # A Frame is an invisible box for grouping widgets. This one holds the
        # typing box and the button, so they sit side by side on one row.
        row = tk.Frame(root)

        # pack() is what actually puts a widget on screen. Build it and forget
        # to pack it and it simply never appears, with no error to tell you.
        #   side  - which edge of the space left over it goes against
        #   fill  - stretch to fill that space: "x", "y" or "both"
        #   padx  - space outside the widget. ipady is space inside it.
        row.pack(side="bottom", fill="x", padx=10, pady=10)

        # Entry is one line of text. Text and ScrolledText hold many.
        # expand=True gives it the leftover width, so it grows with the window.
        self.box = tk.Entry(row, font=("Segoe UI", 11))
        self.box.pack(side="left", fill="x", expand=True, ipady=6)

        # bind ties an event to a function. "<Return>" is the Enter key, and
        # tkinter hands the function an event object, which is why send takes
        # one. focus_set puts the cursor here, so you can type straight away.
        self.box.bind("<Return>", self.send)
        self.box.focus_set()

        # command takes the function itself, with no brackets after it. Write
        # command=self.send() and Python calls send now, once, and hands the
        # button whatever it returned. The button then does nothing on a click.
        tk.Button(row, text="Send", width=8, command=self.send).pack(
            side="left", padx=(8, 0))

        # Packed last on purpose. pack gives each widget its space in the order
        # the calls are made, so the fixed row above is served first, and
        # expand=True here means the transcript takes everything still going.
        self.transcript.pack(side="top", fill="both", expand=True,
                             padx=10, pady=(10, 0))

    def write(self, text):
        """Put text in the transcript. It is read-only until we open it."""
        self.transcript.configure(state="normal")

        # "end" is a text index, not a number. Others are "1.0" for the very
        # start, and "2.5" for line two, character five.
        self.transcript.insert("end", text)

        # Scroll down so the newest line is showing.
        self.transcript.see("end")
        self.transcript.configure(state="disabled")

    def send(self, event=None):
        """Take what was typed and show it. No AI here yet.

        event is None when the button calls this, and an event object when the
        Enter key does. Nothing here needs it, but the argument has to exist.
        """
        said = self.box.get().strip()
        if not said:
            return

        # Entry counts from 0 to "end". This empties the box.
        self.box.delete(0, "end")
        self.write("You: " + said + "\n")


def main():
    # Tk() makes the window. One per program.
    root = tk.Tk()
    ChatWindow(root)

    # mainloop draws the window and waits for keys and clicks, over and over,
    # until the window closes. Nothing after this line runs until then, and
    # anything slow called from inside it stops the drawing. That is the whole
    # difficulty of writing a window, and the next step is about it.
    root.mainloop()


if __name__ == "__main__":
    main()

2 A second thread, and a queue · อีกหนึ่งเธรด กับคิวหนึ่งอัน · 另一个线程，加一个队列

📄 NEW FILE · talk2.py

"""talk2.py — the same chat, but the window stays alive while it thinks."""
import json
import queue
import threading
import tkinter as tk
import urllib.request
from tkinter import scrolledtext

OLLAMA = "http://localhost:11434/api/chat"
MODEL = "llama3.2"


def ask_ollama(question, inbox):
    """Ask Ollama on another thread, and post the answer into the queue.

    This function never touches the window. A thread that did not make the
    window may not touch it at all, and that includes calling after().
    """
    payload = json.dumps({
        "model": MODEL,
        "stream": True,
        "messages": [{"role": "user", "content": question}],
    }).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})

    with urllib.request.urlopen(request, timeout=300) as response:
        # Streaming sends one small JSON object per line, not one per answer.
        for line in response:
            if not line.strip():
                continue
            packet = json.loads(line)
            piece = packet.get("message", {}).get("content", "")
            if piece:
                inbox.put(("word", piece))
            if packet.get("done"):
                break
    inbox.put(("done", ""))


class ChatWindow:
    def __init__(self, root):
        self.root = root
        self.inbox = queue.Queue()
        self.waiting = False
        root.title("Chat that keeps moving")
        root.geometry("520x420")

        self.transcript = scrolledtext.ScrolledText(
            root, wrap="word", font=("Segoe UI", 11), padx=10, pady=10,
            height=10, state="disabled")

        row = tk.Frame(root)
        row.pack(side="bottom", fill="x", padx=10, pady=10)

        self.box = tk.Entry(row, font=("Segoe UI", 11))
        self.box.pack(side="left", fill="x", expand=True, ipady=6)
        self.box.bind("<Return>", self.send)
        self.box.focus_set()

        tk.Button(row, text="Send", width=8, command=self.send).pack(
            side="left", padx=(8, 0))

        self.transcript.pack(side="top", fill="both", expand=True,
                             padx=10, pady=(10, 0))

        # Start the collecting loop now, before anything is waiting. It runs
        # for the life of the window, empty or not, checking twenty times a
        # second. That is cheap, and it means nothing has to wake it up.
        self.drain()

    def write(self, text):
        self.transcript.configure(state="normal")
        self.transcript.insert("end", text)
        self.transcript.see("end")
        self.transcript.configure(state="disabled")

    def drain(self):
        """Empty the queue into the window, then book the next visit.

        This runs on the main thread, the only one allowed to change a widget.
        """
        try:
            while True:
                kind, text = self.inbox.get_nowait()
                if kind == "word":
                    self.write(text)
                elif kind == "done":
                    self.write("\n")
                    self.waiting = False
        except queue.Empty:
            pass

        # after books one call, 50ms from now. It is not a repeating timer,
        # which is why the last thing drain does is book the next drain. Miss
        # this line out and the queue is emptied exactly once, ever.
        self.root.after(50, self.drain)

    def send(self, event=None):
        """Hand the question to a thread, and give the window straight back."""
        said = self.box.get().strip()
        if not said or self.waiting:
            return
        self.box.delete(0, "end")
        self.write("You: " + said + "\n")
        self.write("Bot: ")
        self.waiting = True

        worker = threading.Thread(target=ask_ollama, args=(said, self.inbox),
                                  daemon=True)
        worker.start()
        # send() ends here, in no time at all. The window carries on.


def main():
    root = tk.Tk()
    ChatWindow(root)
    root.mainloop()


if __name__ == "__main__":
    main()

🖥️ MEASURED · the same question, the same model, both ways

asking inside the button handler:
    send() blocked for 34.9 seconds
    a clock set to tick 50 times a second managed 2 ticks

asking on a thread, through a queue:
    send() returned in 2 ms, and the answer still arrived

3 The memory is a list you resend · ความจำคือลิสต์ที่คุณส่งซ้ำ · 记忆就是一个你反复重发的列表

📄 NEW FILE · mem1.py

"""mem1.py — now it remembers, because you tell it everything every time."""
import json
import queue
import threading
import tkinter as tk
import urllib.request
from tkinter import scrolledtext

OLLAMA = "http://localhost:11434/api/chat"
MODEL = "llama3.2"
SYSTEM = "You are a friendly assistant. Keep answers short."
REMEMBER = 20          # how many past messages to send back


def ask_ollama(messages, inbox):
    """Ask Ollama on another thread. messages is the whole conversation."""
    payload = json.dumps({
        "model": MODEL,
        "stream": True,
        "messages": messages,
    }).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})

    with urllib.request.urlopen(request, timeout=300) as response:
        for line in response:
            if not line.strip():
                continue
            packet = json.loads(line)
            piece = packet.get("message", {}).get("content", "")
            if piece:
                inbox.put(("word", piece))
            if packet.get("done"):
                break
    inbox.put(("done", ""))


class ChatWindow:
    def __init__(self, root):
        self.root = root
        self.inbox = queue.Queue()
        self.waiting = False
        self.reply = []

        # The whole memory. Ollama keeps nothing between questions, so this
        # list is the only place the conversation exists.
        self.history = []

        root.title("Chat that remembers")
        root.geometry("520x420")

        self.transcript = scrolledtext.ScrolledText(
            root, wrap="word", font=("Segoe UI", 11), padx=10, pady=10,
            height=10, state="disabled")

        row = tk.Frame(root)
        row.pack(side="bottom", fill="x", padx=10, pady=10)

        self.box = tk.Entry(row, font=("Segoe UI", 11))
        self.box.pack(side="left", fill="x", expand=True, ipady=6)
        self.box.bind("<Return>", self.send)
        self.box.focus_set()

        tk.Button(row, text="Send", width=8, command=self.send).pack(
            side="left", padx=(8, 0))

        self.transcript.pack(side="top", fill="both", expand=True,
                             padx=10, pady=(10, 0))

        # The collecting loop runs for the life of the window. after() books
        # one call at a time, so drain books the next one before it returns.
        self.drain()

    def write(self, text):
        self.transcript.configure(state="normal")
        self.transcript.insert("end", text)
        self.transcript.see("end")
        self.transcript.configure(state="disabled")

    def drain(self):
        """Empty the queue into the window, on the main thread."""
        try:
            while True:
                kind, text = self.inbox.get_nowait()
                if kind == "word":
                    self.reply.append(text)
                    self.write(text)
                elif kind == "done":
                    self.write("\n")
                    # The answer becomes part of what it is told next time.
                    self.history.append({"role": "assistant",
                                         "content": "".join(self.reply)})
                    self.waiting = False
        except queue.Empty:
            pass
        self.root.after(50, self.drain)

    def send(self, event=None):
        """Add the question to the history, then send the history."""
        said = self.box.get().strip()
        if not said or self.waiting:
            return
        self.box.delete(0, "end")

        self.history.append({"role": "user", "content": said})
        self.write("You: " + said + "\n")
        self.write("Bot: ")
        self.waiting = True
        self.reply = []

        # The system line leads, then the newest few turns. This is the whole
        # of the memory: the model is told the conversation, every single time.
        messages = [{"role": "system", "content": SYSTEM}]
        messages.extend(self.history[-REMEMBER:])

        threading.Thread(target=ask_ollama, args=(messages, self.inbox),
                         daemon=True).start()


def main():
    root = tk.Tk()
    ChatWindow(root)
    root.mainloop()


if __name__ == "__main__":
    main()

🖥️ WHAT IT ANSWERED · two questions, one run

You: My name is Nari. Just say hello.
Bot: Hello Nari! Nice to meet you.
You: What is my name?
Bot: Your name is Nari.

4 And still remember tomorrow · และพรุ่งนี้ก็ยังจำได้ · 而且明天还记得

📄 NEW FILE · mem2.py

"""mem2.py — and it still remembers tomorrow, because the list is a file."""
import json
import queue
import threading
import tkinter as tk
import urllib.request
from pathlib import Path
from tkinter import scrolledtext

OLLAMA = "http://localhost:11434/api/chat"
MODEL = "llama3.2"
SYSTEM = "You are a friendly assistant. Keep answers short."
REMEMBER = 20
HISTORY = Path("chat_history.json")


def ask_ollama(messages, inbox):
    """Ask Ollama on another thread. messages is the whole conversation."""
    payload = json.dumps({
        "model": MODEL,
        "stream": True,
        "messages": messages,
    }).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})

    with urllib.request.urlopen(request, timeout=300) as response:
        for line in response:
            if not line.strip():
                continue
            packet = json.loads(line)
            piece = packet.get("message", {}).get("content", "")
            if piece:
                inbox.put(("word", piece))
            if packet.get("done"):
                break
    inbox.put(("done", ""))


class ChatWindow:
    def __init__(self, root):
        self.root = root
        self.inbox = queue.Queue()
        self.waiting = False
        self.reply = []
        self.history = []

        root.title("Chat that remembers tomorrow")
        root.geometry("520x420")

        self.transcript = scrolledtext.ScrolledText(
            root, wrap="word", font=("Segoe UI", 11), padx=10, pady=10,
            height=10, state="disabled")

        row = tk.Frame(root)
        row.pack(side="bottom", fill="x", padx=10, pady=10)

        self.box = tk.Entry(row, font=("Segoe UI", 11))
        self.box.pack(side="left", fill="x", expand=True, ipady=6)
        self.box.bind("<Return>", self.send)
        self.box.focus_set()

        tk.Button(row, text="Send", width=8, command=self.send).pack(
            side="left", padx=(8, 0))

        self.transcript.pack(side="top", fill="both", expand=True,
                             padx=10, pady=(10, 0))

        # Fill the window from the file before the first drain, so the old
        # conversation is on screen the moment it opens.
        self.load()
        self.drain()

    def write(self, text):
        self.transcript.configure(state="normal")
        self.transcript.insert("end", text)
        self.transcript.see("end")
        self.transcript.configure(state="disabled")

    def load(self):
        """Read yesterday's conversation back in, if there is one."""
        if not HISTORY.exists():
            return
        try:
            saved = json.loads(HISTORY.read_text(encoding="utf-8"))
        except ValueError:
            # A file half written when the power went is not worth crashing
            # over. Leave it, and start the conversation again.
            self.write("The old conversation could not be read.\n")
            return

        self.history = saved
        for message in self.history:
            who = "You: " if message["role"] == "user" else "Bot: "
            self.write(who + message["content"] + "\n")

    def save(self):
        """The memory is a list, and a list of dicts is already JSON."""
        HISTORY.write_text(json.dumps(self.history, indent=2), encoding="utf-8")

    def drain(self):
        try:
            while True:
                kind, text = self.inbox.get_nowait()
                if kind == "word":
                    self.reply.append(text)
                    self.write(text)
                elif kind == "done":
                    self.write("\n")
                    self.history.append({"role": "assistant",
                                         "content": "".join(self.reply)})
                    self.save()
                    self.waiting = False
        except queue.Empty:
            pass
        self.root.after(50, self.drain)

    def send(self, event=None):
        said = self.box.get().strip()
        if not said or self.waiting:
            return
        self.box.delete(0, "end")

        self.history.append({"role": "user", "content": said})
        self.write("You: " + said + "\n")
        self.write("Bot: ")
        self.waiting = True
        self.reply = []

        messages = [{"role": "system", "content": SYSTEM}]
        messages.extend(self.history[-REMEMBER:])

        threading.Thread(target=ask_ollama, args=(messages, self.inbox),
                         daemon=True).start()


def main():
    root = tk.Tk()
    ChatWindow(root)
    root.mainloop()


if __name__ == "__main__":
    main()

🖥️ WHAT IT ANSWERED · closed, reopened, then asked

mem2 : after closing and reopening, Khao soi.

5 Five things that go wrong · ห้าเรื่องที่มักพัง · 五件会出错的事

📄 NEW FILE · chatbot.py — the finished program

"""chatbot.py — a chat window that talks to Ollama and remembers what was said."""
import json
import os
import queue
import threading
import tkinter as tk
import urllib.error
import urllib.request
from pathlib import Path
from tkinter import scrolledtext

OLLAMA = os.environ.get("OLLAMA_URL", "http://localhost:11434/api/chat")
MODEL = os.environ.get("OLLAMA_MODEL", "llama3.2")
SYSTEM = "You are a friendly assistant. Keep answers short unless asked for more."

REMEMBER = 20                          # how many past messages to send back
HISTORY = Path("chat_history.json")    # so it still remembers tomorrow


def ask_ollama(messages, inbox):
    """Stream one reply from Ollama. Runs on its own thread.

    It never touches the window. Every piece of the answer goes into the queue,
    and the main thread takes it out. A thread that is not the one that made
    the window may not touch the window at all, not even through after().
    """
    payload = json.dumps({
        "model": MODEL,
        "stream": True,
        "messages": messages,
    }).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})

    try:
        with urllib.request.urlopen(request, timeout=300) as response:
            # Streaming sends one JSON object per line, not one per answer.
            for line in response:
                if not line.strip():
                    continue
                packet = json.loads(line)
                piece = packet.get("message", {}).get("content", "")
                if piece:
                    inbox.put(("word", piece))
                if packet.get("done"):
                    break
    except urllib.error.HTTPError as refused:
        # urllib shows only the status line. Ollama puts the reason in the
        # body, so "404: Not Found" is really "model 'llama9' not found".
        body = refused.read().decode(errors="replace")
        try:
            body = json.loads(body).get("error", body)
        except ValueError:
            pass
        inbox.put(("error", str(refused.code) + ": " + body))
        return
    except Exception as problem:
        inbox.put(("error", str(problem)))
        return
    inbox.put(("done", ""))


class ChatWindow:
    """The window, the transcript, and the memory behind it."""

    def __init__(self, root):
        self.root = root
        self.history = []
        self.waiting = False
        self.inbox = queue.Queue()
        self.next_drain = None
        self.reply = []
        root.title("Ollama chat")
        # The X in the corner destroys the window by itself. protocol puts our
        # own function in the way first, so there is somewhere to tidy up.
        root.protocol("WM_DELETE_WINDOW", self.close)
        root.geometry("620x560")
        root.minsize(420, 380)

        # height=10 keeps the transcript from asking for more room than the
        # window has. Ask for 24 lines, the default, and it pushes the typing
        # box off the bottom edge - where you cannot see it to wonder why.
        self.transcript = scrolledtext.ScrolledText(
            root, wrap="word", font=("Segoe UI", 11), padx=10, pady=10,
            height=10, background="#fbfaf7", relief="flat", state="disabled")

        # A tag is a name for a look. Define it once here, then pass the name
        # to insert(), and that piece of text is drawn that way. It is how one
        # text box can hold blue names, green names and red errors at once.
        self.transcript.tag_config("you", foreground="#1d4ed8",
                                   font=("Segoe UI", 11, "bold"), spacing1=8)
        self.transcript.tag_config("bot", foreground="#166534",
                                   font=("Segoe UI", 11, "bold"), spacing1=8)
        self.transcript.tag_config("words", foreground="#222222")
        self.transcript.tag_config("problem", foreground="#b91c1c")

        row = tk.Frame(root)
        row.pack(side="bottom", fill="x", padx=10, pady=(0, 6))

        self.box = tk.Entry(row, font=("Segoe UI", 11))
        self.box.pack(side="left", fill="x", expand=True, ipady=6)
        self.box.bind("<Return>", self.send)
        self.box.focus_set()

        self.send_button = tk.Button(row, text="Send", width=9, command=self.send)
        self.send_button.pack(side="left", padx=(8, 0))

        bottom = tk.Frame(root)
        bottom.pack(side="bottom", fill="x", padx=10, pady=(0, 10))

        # A Label just shows text. anchor="w" keeps it against the west edge,
        # so it does not jump about as the number of messages changes.
        self.status = tk.Label(bottom, anchor="w", fg="#666666",
                               font=("Segoe UI", 9))
        self.status.pack(side="left")

        self.forget_button = tk.Button(bottom, text="Forget everything",
                                       command=self.forget, font=("Segoe UI", 9))
        self.forget_button.pack(side="right")

        # Packed last and stretchy: it takes the space the fixed rows did
        # not want, which is how the typing box stays on screen.
        self.transcript.pack(side="top", fill="both", expand=True,
                             padx=10, pady=(10, 4))

        self.load()
        self.show_status()
        self.drain()

    def drain(self):
        """Empty the queue into the window, then ask to be called again.

        This runs on the main thread, which is the only thread allowed to
        change a widget. It keeps running whether anything is waiting or not.
        """
        try:
            while True:
                kind, text = self.inbox.get_nowait()
                if kind == "word":
                    self.got_word(text)
                elif kind == "done":
                    self.got_all()
                elif kind == "error":
                    self.went_wrong(text)
        except queue.Empty:
            pass
        self.next_drain = self.root.after(50, self.drain)

    def close(self):
        """Stop the drain loop first, then shut the window.

        A drain still booked when the window goes leaves Tk calling a command
        that no longer exists, and it says so on the way out.
        """
        if self.next_drain is not None:
            self.root.after_cancel(self.next_drain)
            self.next_drain = None
        self.root.destroy()

    # ── the transcript ──────────────────────────────────────────────────
    def write(self, text, tag="words"):
        """Put text in the transcript. Only the main thread may call this."""
        self.transcript.configure(state="normal")
        self.transcript.insert("end", text, tag)
        self.transcript.see("end")
        self.transcript.configure(state="disabled")

    def show_status(self):
        remembered = len(self.history)
        sent = min(remembered, REMEMBER)
        self.status.config(
            text=f"{MODEL}  ·  remembering {remembered} messages, sending {sent}")

    # ── memory ──────────────────────────────────────────────────────────
    def load(self):
        """Read yesterday's conversation back in, if there is one."""
        if not HISTORY.exists():
            return
        try:
            saved = json.loads(HISTORY.read_text(encoding="utf-8"))
        except (ValueError, OSError):
            # A file half-written when the power went is not worth crashing
            # over. Say so, and start the conversation again.
            self.write("The saved conversation could not be read. "
                       "Starting fresh.\n", "problem")
            return
        if not isinstance(saved, list):
            return

        self.history = saved
        for message in self.history:
            who = "You: " if message["role"] == "user" else "Bot: "
            self.write(who, "you" if message["role"] == "user" else "bot")
            self.write(message["content"] + "\n")

    def save(self):
        HISTORY.write_text(json.dumps(self.history, indent=2), encoding="utf-8")

    def forget(self):
        """Empty the memory, the file and the window."""
        if self.waiting:
            # An answer is still arriving. Clear now and that answer lands in
            # an empty history, and gets saved as a conversation of one.
            return
        self.history = []
        if HISTORY.exists():
            HISTORY.unlink()
        self.transcript.configure(state="normal")
        self.transcript.delete("1.0", "end")
        self.transcript.configure(state="disabled")
        self.show_status()

    # ── sending ─────────────────────────────────────────────────────────
    def send(self, event=None):
        """Take what was typed, show it, and ask Ollama about it."""
        said = self.box.get().strip()
        if not said or self.waiting:
            return
        self.box.delete(0, "end")

        self.history.append({"role": "user", "content": said})
        self.write("You: ", "you")
        self.write(said + "\n")
        self.write("Bot: ", "bot")

        self.waiting = True
        self.send_button.config(state="disabled")
        self.forget_button.config(state="disabled")
        self.reply = []

        # The system line leads, then only the newest few turns. This is the
        # whole of the memory: the model is told the conversation every time.
        messages = [{"role": "system", "content": SYSTEM}]
        messages.extend(self.history[-REMEMBER:])

        # Ollama takes seconds, and a window that waits is a window that
        # freezes. So the asking happens on another thread, and drain() picks
        # the answer up from the queue.
        worker = threading.Thread(target=ask_ollama, args=(messages, self.inbox),
                                  daemon=True)
        worker.start()

    def got_word(self, piece):
        self.reply.append(piece)
        self.write(piece)

    def got_all(self):
        """The answer is finished. Remember it, and let the user type again."""
        self.write("\n")
        answer = "".join(self.reply)
        if answer.strip():
            self.history.append({"role": "assistant", "content": answer})
            self.save()
        else:
            # Nothing came back. Saving that would leave a turn with no answer,
            # so drop the question too and let the user ask again.
            self.write("The model said nothing. Ask again.\n", "problem")
            if self.history and self.history[-1]["role"] == "user":
                self.history.pop()
        self.done_waiting()

    def went_wrong(self, problem):
        self.write("\n" + problem + "\n", "problem")
        self.write("Is Ollama running? Try: ollama serve\n", "problem")

        # Drop the question, so a failed turn does not poison the memory.
        if self.history and self.history[-1]["role"] == "user":
            self.history.pop()
        self.done_waiting()

    def done_waiting(self):
        self.waiting = False
        self.send_button.config(state="normal")
        self.forget_button.config(state="normal")
        self.show_status()
        self.box.focus_set()


def main():
    root = tk.Tk()
    ChatWindow(root)
    root.mainloop()


if __name__ == "__main__":
    main()