🧱 Classes, taught with a window · คลาส สอนด้วยหน้าต่าง · 用一个窗口来讲类

📄 price_button.py

"""price_button.py — challenge 1: a button that asks Bitkub for the price."""
import json
import tkinter as tk
import urllib.request

from chat4 import ChatWindow

BITKUB = "https://api.bitkub.com/api/v3/market/ticker"


class PriceWindow(ChatWindow):
    """ChatWindow, plus a button. Everything else is inherited."""

    def __init__(self, root):
        # Run the parent's __init__ first. That builds the window, the
        # transcript, the typing box and the Send button. Then add to it.
        super().__init__(root)
        root.title("Chat and coins")

        # chat3.py kept the typing row in a plain variable instead of on self,
        # so there is no way to reach it from here. A second row is the easy
        # answer. Storing it as self.row back then would have been the other.
        coins = tk.Frame(root)
        coins.pack(side="bottom", fill="x", padx=10, pady=(0, 10))

        tk.Button(coins, text="BTC price", width=10,
                  command=self.show_price).pack(side="left")
        tk.Button(coins, text="ETH price", width=10,
                  command=lambda: self.show_price("ETH_THB")).pack(
                      side="left", padx=(8, 0))

    def show_price(self, symbol="BTC_THB"):
        """Ask Bitkub, and write the answer into the transcript.

        lambda is how the second button passes an argument. command wants a
        function it can call with nothing, and lambda makes one on the spot.
        """
        with urllib.request.urlopen(BITKUB + "?sym=" + symbol,
                                    timeout=30) as response:
            coins = json.load(response)

        # Bitkub sends back a list, even when you ask about one coin, and
        # every number in it arrives as text.
        price = float(coins[0]["last"])
        self.write(f"1 {symbol.split('_')[0]} = {price:,.2f} baht\n")


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


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · both buttons, against the real Bitkub

1 BTC = 2,805,205.52 baht
1 ETH = 106,725.00 baht

window frozen for 270 ms during the call

📄 mail_button.py

"""mail_button.py — challenge 2: type a line, press the button, it is sent."""
import os
import smtplib
import tkinter as tk
from email.message import EmailMessage

from chat4 import ChatWindow

SMTP_HOST = "smtp.gmail.com"      # yahoo: smtp.mail.yahoo.com


class MailWindow(ChatWindow):
    """ChatWindow, plus a button that emails whatever you typed."""

    def __init__(self, root):
        super().__init__(root)
        root.title("Chat and mail")

        # Read once, when the window opens, so a missing password is a
        # complaint in the transcript rather than a crash on the first click.
        self.user = os.environ.get("MAIL_USER")
        self.password = os.environ.get("MAIL_PASS")

        mail = tk.Frame(root)
        mail.pack(side="bottom", fill="x", padx=10, pady=(0, 10))
        tk.Button(mail, text="Email it to me", width=14,
                  command=self.send_mail).pack(side="left")

        if not self.user or not self.password:
            self.write("No MAIL_USER or MAIL_PASS set. The button will not work.\n")

    def send_mail(self):
        """Send what is in the typing box to yourself."""
        said = self.box.get().strip()
        if not said:
            return
        if not self.user or not self.password:
            self.write("Still no MAIL_USER or MAIL_PASS.\n")
            return

        letter = EmailMessage()
        letter["From"] = self.user
        letter["To"] = self.user
        letter["Subject"] = "From my tkinter window"
        letter.set_content(said + "\n")

        with smtplib.SMTP_SSL(SMTP_HOST, 465) as server:
            server.login(self.user, self.password)
            server.send_message(letter)

        self.box.delete(0, "end")
        self.write("Sent to " + self.user + ": " + said + "\n")


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


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · one real email, to a real mailbox

Sent to you@yahoo.com: Sent from a tkinter window, for the classes page.

send took 4.9s (the window is frozen for all of it)

📄 ask_bot.py

"""ask_bot.py — challenge 3: the window talks to Ollama without freezing."""
import json
import queue
import threading
import tkinter as tk
import urllib.request

from chat4 import ChatWindow

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


class BotWindow(ChatWindow):
    """ChatWindow, but send() also asks a model, on a thread of its own."""

    def __init__(self, root):
        super().__init__(root)
        root.title("Chat with a model")

        # The whole conversation so far. Without this the model forgets your
        # name the moment it has answered you.
        self.history = []

        # A thread must never touch a widget. It puts finished text here
        # instead, and the main thread takes it out and writes it.
        self.answers = queue.Queue()
        self.drain()

    def send(self, event=None):
        """Show what was typed, then go and ask the model for a reply."""
        said = self.box.get().strip()
        if not said:
            return
        self.box.delete(0, "end")
        self.write("You: " + said + "\n")
        self.history.append({"role": "user", "content": said})

        # daemon=True so a half-finished answer cannot keep the program alive
        # after the window is closed.
        threading.Thread(target=self.ask, args=(list(self.history),),
                         daemon=True).start()

    def ask(self, history):
        """Runs on the worker thread. No widget may be touched from here."""
        payload = json.dumps({"model": MODEL, "stream": False,
                              "messages": history}).encode()
        request = urllib.request.Request(
            OLLAMA, data=payload, headers={"Content-Type": "application/json"})
        try:
            with urllib.request.urlopen(request, timeout=300) as response:
                said = json.load(response)["message"]["content"].strip()
        except Exception as trouble:
            said = "(no answer: " + str(trouble) + ")"
        self.answers.put(said)

    def drain(self):
        """Runs on the main thread, four times a second, forever."""
        while not self.answers.empty():
            said = self.answers.get()
            self.history.append({"role": "assistant", "content": said})
            self.write("Bot: " + said + "\n\n")

        # after() books one more run. This is the only safe way for slow work
        # to get its answer onto the screen.
        self.root.after(250, self.drain)


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


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · read back out of the widget

You: My name is Nari. Reply in one short sentence.
Bot: Nice to meet you, Nari!

📄 setup_form.py

"""setup_form.py — challenge 4: ask who is who, then start the chat.

Two windows' worth of work in one window, and one class. A form collects who
the model should be and who you are. Filling it in clears the form away and
the chat takes over, with all three answers already known.

Challenge 7 asks the same questions from a window of its own, and closes it.
Compare the two. This one talks to Ollama directly, so you can see the
conversation being built by hand: a list of messages, with a system message
at the front that never moves.
"""
import json
import os
import queue

# A thread lets the slow model run without freezing the window. A queue is
# how that thread passes its answer back, because a thread must never touch
# a widget itself.
import threading
import tkinter as tk
import urllib.request

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

# Where the model runs. os.environ.get takes the value if it is set, and the
# second argument if it is not, so you can point this at another machine
# without editing the file.
OLLAMA = os.environ.get("OLLAMA_URL", "http://localhost:11434/api/chat")
MODEL = os.environ.get("OLLAMA_MODEL", "llama3.2")

# What the form offers before you type your own. The first one is the
# default the window starts with.
ROLES = ["a patient English teacher",
         "a Chiang Mai street food guide",
         "a Python tutor who never gives the whole answer"]


class Window:
    """One window. It asks three questions, then becomes a chat."""

    def __init__(self, kind):
        # Keep the kind on self, because send() reads it later to decide
        # whether to ask the model or just echo.
        self.kind = kind

        # Who is who. ask_first() fills these in from the form, and
        # start() turns them into the system message.
        self.bot_name = "Kru Som"
        self.user_name = ""
        self.role = ROLES[0]

        # The whole conversation so far. Without it the model forgets your
        # name the moment it has answered you.
        self.history = []

        # Tk() is the window. Making it is enough to put it on screen.
        self.root = tk.Tk()
        self.root.title("Who is who?")
        self.root.geometry("520x420")       # width by height, in pixels

        # state="disabled" makes it read only, so a click cannot type into
        # it. write() opens it for a moment when it has something to add.
        self.transcript = scrolledtext.ScrolledText(
            self.root, wrap="word", font=("Segoe UI", 11), padx=10, pady=10,
            height=10, state="disabled")

        # A Frame is an invisible box for grouping. This one holds the
        # typing box and the button. It is a plain name, not self.row,
        # because nothing looks for it again.
        row = tk.Frame(self.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)

        # 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 it never uses.
        self.box.bind("<Return>", self.send)

        # command takes the function itself, with no brackets after it.
        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))

        # Only a bot window needs the queue and the drain loop. A chat
        # window skips both and just echoes what you type.
        if kind == "bot":
            self.answers = queue.Queue()

            # after() hands back a booking number. Keep it, so close()
            # can cancel the one still outstanding.
            self.ticking = None
            self.drain()

        # Clicking the X runs close() instead of destroying the window
        # straight away, so the drain loop can be stopped first.
        self.root.protocol("WM_DELETE_WINDOW", self.close)

    def ask_first(self):
        """Cover the window with a form. It clears itself when filled in."""
        # Everything goes in one frame, so clearing the form later is a
        # single destroy() instead of hunting down each widget. place()
        # with relwidth=1 and relheight=1 lays it over the whole window.
        self.form = tk.Frame(self.root, padx=20, pady=20, bg="#f4f4f4")
        self.form.place(relx=0, rely=0, relwidth=1, relheight=1)

        # columnspan=2 lets the heading run across both columns below it.
        tk.Label(self.form, text="Before we start", font=("Segoe UI", 16),
                 bg="#f4f4f4").grid(row=0, column=0, columnspan=2,
                                    pady=(0, 16), sticky="w")

        # grid puts widgets in rows and columns, which is what a form
        # wants. pack stacks them against an edge. Never use both in one
        # frame; tkinter will wait forever trying to satisfy the two of
        # them and the window never finishes drawing. This frame uses grid
        # inside itself and is placed from outside, which is allowed,
        # because those are two different frames.
        self.fields = {}

        # enumerate(..., start=1) numbers the rows, leaving row 0 for the
        # heading. Your name starts empty on purpose, so the empty-box
        # check below has something to catch.
        for number, (key, label, start) in enumerate([
                ("bot_name", "The model's name", self.bot_name),
                ("user_name", "Your name", self.user_name),
                ("role", "What should it be?", self.role)], start=1):
            tk.Label(self.form, text=label, font=("Segoe UI", 11),
                     bg="#f4f4f4").grid(row=number, column=0, sticky="e",
                                        padx=(0, 10), pady=6)
            entry = tk.Entry(self.form, font=("Segoe UI", 11), width=30)
            entry.insert(0, start)
            entry.grid(row=number, column=1, sticky="we", pady=6)

            # Keep the entry itself, not its text. start() reads them all
            # later, when there is something in them.
            self.fields[key] = entry

        # Let the second column take any extra width when the window grows.
        self.form.columnconfigure(1, weight=1)

        tk.Button(self.form, text="Start chatting",
                  command=self.start).grid(row=4, column=1, sticky="e",
                                           pady=(16, 0))

        # An empty label now, filled in by start() when a box is empty.
        # Making it here means the form never changes shape later.
        self.warning = tk.Label(self.form, text="", fg="#b00020",
                                font=("Segoe UI", 10), bg="#f4f4f4")
        self.warning.grid(row=5, column=0, columnspan=2, sticky="w")

        self.fields["user_name"].focus_set()

    def start(self):
        """Read the form. Complain if a box is empty, otherwise carry on."""
        # A dict comprehension reads every entry in one line. strip()
        # means a box holding only spaces counts as empty.
        answers = {key: entry.get().strip()
                   for key, entry in self.fields.items()}

        # Collect every empty box rather than stopping at the first, so
        # the reader is told about all of them at once.
        empty = [key for key, value in answers.items() if not value]
        if empty:
            self.warning.configure(text="Still empty: " + ", ".join(empty))

            # return leaves the form up. Nothing below this line runs.
            return

        self.bot_name = answers["bot_name"]
        self.user_name = answers["user_name"]
        self.role = answers["role"]

        # The whole form goes in one line, because it was one frame.
        self.form.destroy()
        self.root.title(self.bot_name + " and " + self.user_name)

        # A system message is an instruction to the model rather than a
        # line of the conversation. It goes first, and it stays first,
        # which is why history is rebuilt here rather than appended to.
        self.history = [{"role": "system", "content":
                         "You are " + self.bot_name + ", " + self.role
                         + ". You are talking to " + self.user_name
                         + ". Use their name sometimes. "
                         "Keep every reply under three sentences."}]

        self.write("You are talking to " + self.bot_name + ".\n\n")

        # The form had the cursor. Give it back to the typing box.
        self.box.focus_set()

    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):
        """Show what was typed. If this is a bot window, also ask the model."""
        # 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 for the binding to work.
        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")

        if self.kind == "bot":
            self.history.append({"role": "user", "content": said})

            # list(self.history) hands the thread a copy. The real list
            # keeps growing on this side, and a thread reading a list
            # while it changes is a bug waiting for a busy day.
            # daemon=True so a half finished answer cannot keep the
            # program alive after the window is closed.
            threading.Thread(target=self.think, args=(list(self.history),),
                             daemon=True).start()

    def think(self, history):
        """Runs on the worker thread. No widget may be touched from here."""
        # stream False means one whole answer comes back, rather than a
        # word at a time. Simpler to read, and the drain loop below is
        # what keeps the window alive while it waits.
        payload = json.dumps({"model": MODEL, "stream": False,
                              "messages": history}).encode()
        request = urllib.request.Request(
            OLLAMA, data=payload,
            headers={"Content-Type": "application/json"})
        try:
            with urllib.request.urlopen(request, timeout=300) as answer:
                said = json.load(answer)["message"]["content"].strip()
        except Exception as trouble:
            # Catching everything is right here. Whatever went wrong, the
            # window should say so rather than sit there looking busy.
            said = "(no answer: " + str(trouble) + ")"

        # put() is the only safe way out of this thread. A thread that
        # touched a widget would crash tkinter, or worse, corrupt the
        # display and say nothing at all.
        self.answers.put(said)

    def drain(self):
        """Runs on the main thread, and is the only thing that writes."""
        # empty() then get() is safe because this is the only reader.
        while not self.answers.empty():
            said = self.answers.get()

            # The model's own replies go into the history too, or it
            # forgets what it just said.
            self.history.append({"role": "assistant", "content": said})
            self.write(self.bot_name + ": " + said + "\n\n")

        # after() books one more run in 250ms, and hands back a number
        # naming that booking. Keep the number: a booking still
        # outstanding when the window goes will fire into a dead window,
        # and tkinter prints "invalid command name" at you.
        self.ticking = self.root.after(250, self.drain)

    def close(self):
        """Stop the drain loop, then take the window down.

        Cancelling has to happen before destroy(). A booking fires by
        number inside tkinter, so a guard at the top of drain() is too
        late: the error happens before Python is reached at all.
        """
        if getattr(self, "ticking", None) is not None:
            self.root.after_cancel(self.ticking)
            self.ticking = None
        self.root.destroy()

    def run(self):
        """Draw the window and wait for keys and clicks, until it closes."""
        # Nothing after this line runs until the window is closed.
        self.root.mainloop()


def main():
    # Build one, ask who is who, then let it run. Change "bot" to "chat"
    # and the same class gives you a window that only echoes.
    window = Window("bot")
    window.ask_first()
    window.run()


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · empty box refused, then a real answer, 7.5 seconds

refused with an empty name: 'Still empty: user_name'
title after submit     : Kru Som and Nari
history[0] is the role : system

You are talking to Kru Som.

You: What is my name, and who are you?
Kru Som: Your name is Nari, and I'm Kru Som, your English teacher. I'll be
helping you with your language skills today, so let's get started!

📄 show_page.py

"""show_page.py — challenge 5: put a web page in the window.

tkinter cannot draw HTML. There is no widget for it and no module in the
standard library that makes one. So there are two honest answers, and this
file does both: strip the tags and show the words, or hand the address to
the browser, which was built for it.
"""
import re
import tkinter as tk
import urllib.request
import webbrowser

from chat4 import ChatWindow

PAGE = "https://example.com/"


class PageWindow(ChatWindow):
    """ChatWindow, plus two ways of looking at a web page."""

    def __init__(self, root):
        super().__init__(root)
        root.title("Chat and pages")

        web = tk.Frame(root)
        web.pack(side="bottom", fill="x", padx=10, pady=(0, 10))
        tk.Button(web, text="Read it here", width=12,
                  command=self.read_here).pack(side="left")
        tk.Button(web, text="Open in browser", width=14,
                  command=lambda: webbrowser.open(PAGE)).pack(
                      side="left", padx=(8, 0))

    def read_here(self):
        """Fetch the page, throw the tags away, and show what is left."""
        request = urllib.request.Request(
            PAGE, headers={"User-Agent": "a python lesson"})
        with urllib.request.urlopen(request, timeout=30) as response:
            html = response.read().decode("utf-8", errors="replace")

        # script and style hold code, not words. Remove those whole, then
        # every remaining tag, then squeeze the leftover blank lines.
        html = re.sub(r"<(script|style)[\s\S]*?</\1>", " ", html)
        words = re.sub(r"<[^>]+>", " ", html)
        words = re.sub(r"[ \t]+", " ", words)
        words = re.sub(r"\n\s*\n+", "\n\n", words).strip()

        self.write("--- " + PAGE + " ---\n" + words + "\n\n")


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


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · the first line of the transcript

--- https://example.com/ --- Example Domain Example Domain This domain is for use in documentation examples without needing permission.

📄 show_image.py

"""show_image.py — challenge 6: a picture in the window, and the trap in it."""
import sys
import tkinter as tk
from tkinter import filedialog

from chat4 import ChatWindow


class ImageWindow(ChatWindow):
    """ChatWindow, plus a label that can hold a picture."""

    def __init__(self, root):
        super().__init__(root)
        root.title("Chat and pictures")

        pictures = tk.Frame(root)
        pictures.pack(side="bottom", fill="x", padx=10, pady=(0, 10))
        tk.Button(pictures, text="Pick a picture", width=14,
                  command=self.pick).pack(side="left")

        # An empty label now, filled in later. A Label holds either text or
        # an image, and swapping one for the other is just configure().
        self.picture = tk.Label(root)
        self.picture.pack(side="top", pady=(10, 0))

        # This is the trap. PhotoImage is the only widget argument Python
        # will throw away behind your back: tkinter keeps no reference to it,
        # so once the local variable goes the picture is collected and the
        # label goes blank, with no error. Keeping it on self is the fix.
        self.held = None

    def pick(self):
        """Ask for a file, then show it."""
        chosen = filedialog.askopenfilename(
            title="Pick a PNG or GIF",
            filetypes=[("Pictures", "*.png *.gif"), ("All files", "*.*")])
        if chosen:
            self.show(chosen)

    def show(self, path):
        """Put the picture in the label, and hold on to it."""
        # PhotoImage reads PNG and GIF on its own. Anything else needs Pillow.
        self.held = tk.PhotoImage(file=path)

        # subsample(2) shows every second pixel, so the picture is half size.
        # There is no resize in plain tkinter; this is the whole toolbox.
        if self.held.width() > 460:
            self.held = self.held.subsample(self.held.width() // 460 + 1)

        self.picture.configure(image=self.held)
        self.write("showing " + path + " (" + str(self.held.width()) + "x"
                   + str(self.held.height()) + ")\n")


def main():
    root = tk.Tk()
    window = ImageWindow(root)

    # A path on the command line saves picking one every time you test.
    if len(sys.argv) > 1:
        window.show(sys.argv[1])

    root.mainloop()


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · a real PNG, opened and measured

showing ac_title.png (449x337)
reference held: True

📄 agent_window.py

"""agent_window.py — challenge 7: a tutor that can also check the price.

Two windows, one class. The first one asks who the tutor should be. When you
submit it, that window closes and hands its answers to the second one, which
is the chat. The tutor is a tutor first. It happens to carry one tool, and it
works out for itself whether a question needs it.

Nobody wires that tool to a button. You ask in English and the model decides.

    setup = Window("form")                       first window: the questions
    tutor = Window("tutor", setup.bot_name, ...)  second window: the chat
"""
import json
import os
import queue

# A thread lets the slow model run without freezing the window. A queue is
# how that thread passes its answer back, because a thread must never touch
# a widget itself.
import threading
import tkinter as tk
import urllib.request

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

# ActionStep and FinalAnswerStep are what agent.run hands back as it works.
# describe() below tells them apart.
from smolagents import ActionStep, FinalAnswerStep
from smolagents import OpenAIServerModel, ToolCallingAgent, tool

# Where the model runs. os.environ.get takes the value if it is set, and the
# second argument if it is not, so you can point this at another machine
# without editing the file.
LLM_URL = os.environ.get("LLM_URL", "http://localhost:11434/v1")

# The model matters more than every other line in this file put together.
# Four were tried on the same two questions, twelve runs each:
#   llama3.2:3b   used the tool fine, but said the past tense of go is "goed"
#   gemma2:9b     cannot call a tool at all. The server refuses the request
#   llama3.1:8b   said "went", then wrote its tool call as prose, so it
#                 ended up telling the user to call the tool themselves
#   qwen2.5:14b   said "went" every time, and got the price right every time
# So a tutor needs the big one. Challenge 7 on the page has the whole table.
LLM_MODEL = os.environ.get("LLM_MODEL", "qwen2.5:14b")

# The OpenAI client always sends a key. Ollama accepts any word.
LLM_KEY = os.environ.get("LLM_KEY", "ollama")

# A model that cannot work out what to do will keep trying forever. Six
# steps is plenty for one tool, and it fails in a minute instead of never.
MAX_STEPS = 6

# The price service. It answers anyone, with no key and no sign up.
BITKUB = "https://api.bitkub.com/api/v3/market/ticker"

# The form starts on the first of these. They are all teaching jobs,
# because the coin tool is meant to be the sideline, not the point.
ROLES = ["a patient English teacher",
         "a maths tutor who works through every step",
         "a Python tutor who never gives the whole answer"]


@tool
def coin_price(symbol: str) -> str:
    """Look up what one coin is worth in Thai baht, right now.

    Args:
        symbol: the coin's ticker, for example BTC or ETH
    """
    # No double quotes in the line above. That description is copied into
    # the tool list the model is shown, and a small model will copy it
    # straight back into its answer, quotes and all, which is then not
    # valid JSON. It costs a whole step every time.

    # Bitkub wants BTC_THB rather than BTC, and shouts at lower case.
    pair = symbol.upper().strip() + "_THB"
    with urllib.request.urlopen(BITKUB + "?sym=" + pair, timeout=30) as response:
        coins = json.load(response)

    # An unknown coin comes back as an empty list rather than an error, so
    # say so in words. The model reads this line and can try another one.
    if not coins:
        return "no coin called " + symbol + " on Bitkub"

    # Bitkub sends a list even for one coin, and every number arrives as
    # text, so index into it and then convert.
    price = float(coins[0]["last"])
    return "1 " + symbol.upper() + " = " + format(price, ",.2f") + " baht"


def describe(step):
    """Turn one step of the agent's working into a line for the window."""
    # The last step carries the answer itself.
    if isinstance(step, FinalAnswerStep):
        return str(step.output) + "\n\n"

    # Every other step is the agent using a tool, or failing to.
    if isinstance(step, ActionStep):
        if step.error:
            # A model that fumbles the JSON gets another go. Say so, or the
            # window looks stuck while it quietly tries again.
            return f"  step {step.step_number}: that went wrong, trying again\n"

        # One step can call more than one tool, so join their names.
        called = ", ".join(call.name for call in (step.tool_calls or []))
        return f"  step {step.step_number}: called {called or 'nothing'}\n"

    # Other kinds of step exist and are not worth showing. None means
    # nothing gets written for this one.
    return None


class Window:
    """One class, two kinds. A form that asks, and a tutor that answers."""

    def __init__(self, kind, bot_name="", role=""):
        # Keep the kind on self. send() and close() both read it later.
        self.kind = kind

        # The form leaves these empty and fills them in when you submit.
        # The tutor is handed them already filled in.
        self.bot_name = bot_name
        self.role = role

        # Tk() is the window. Making it is enough to put it on screen.
        self.root = tk.Tk()

        # Two kinds, two sets of widgets, one class. Everything below this
        # point is shared: write, close, run, and the thread work.
        if kind == "form":
            self.build_form()
        else:
            self.build_chat()

        # Clicking the X runs close() instead of destroying the window
        # straight away, so the drain loop can be stopped first.
        self.root.protocol("WM_DELETE_WINDOW", self.close)

    # ---- the first window -------------------------------------------

    def build_form(self):
        """Three labels, two boxes and a button. No chat widgets at all."""
        self.root.title("Who is your tutor?")
        self.root.geometry("420x210")

        # One frame holds the lot, so the window has a margin without
        # every widget carrying its own padding.
        frame = tk.Frame(self.root, padx=20, pady=20)
        frame.pack(fill="both", expand=True)

        # columnspan=2 lets the heading run across both columns below it.
        tk.Label(frame, text="Before we start", font=("Segoe UI", 15)).grid(
            row=0, column=0, columnspan=2, pady=(0, 14), sticky="w")

        # grid puts widgets in rows and columns, which is what a form
        # wants. pack stacks them against an edge. Never use both in one
        # frame; tkinter will wait forever trying to satisfy the two of
        # them and the window never finishes drawing. This frame uses grid
        # inside, and is packed into the window from outside, which is
        # allowed because those are two different frames.
        self.fields = {}

        # enumerate(..., start=1) numbers the rows, leaving row 0 for the
        # heading. The name starts empty so the check in submit() has
        # something to catch.
        for number, (key, label, start) in enumerate([
                ("bot_name", "Its name", ""),
                ("role", "What is it?", ROLES[0])], start=1):
            tk.Label(frame, text=label, font=("Segoe UI", 11)).grid(
                row=number, column=0, sticky="e", padx=(0, 10), pady=6)
            entry = tk.Entry(frame, font=("Segoe UI", 11), width=28)
            entry.insert(0, start)
            entry.grid(row=number, column=1, sticky="we", pady=6)

            # Keep the entry itself, not its text. submit() reads them
            # later, when there is something in them.
            self.fields[key] = entry

        # Enter submits, the same as clicking the button.
        self.fields["bot_name"].bind("<Return>", self.submit)
        self.fields["role"].bind("<Return>", self.submit)

        # Let the second column take any extra width when the window grows.
        frame.columnconfigure(1, weight=1)

        tk.Button(frame, text="Start", width=10, command=self.submit).grid(
            row=3, column=1, sticky="e", pady=(14, 0))

        # An empty label now, filled in by submit() when a box is empty.
        # Making it here means the form never changes shape later.
        self.warning = tk.Label(frame, text="", fg="#b00020",
                                font=("Segoe UI", 10))
        self.warning.grid(row=4, column=0, columnspan=2, sticky="w")

        self.fields["bot_name"].focus_set()

    def submit(self, event=None):
        """Read the boxes. If they are filled in, close this window."""
        # event is None when the button calls this, and an event object
        # when the Enter key does. Nothing here needs it.

        # A dict comprehension reads every entry in one line. strip()
        # means a box holding only spaces counts as empty.
        answers = {key: entry.get().strip()
                   for key, entry in self.fields.items()}

        # Collect every empty box rather than stopping at the first, so
        # the reader is told about all of them at once.
        empty = [key for key, value in answers.items() if not value]
        if empty:
            self.warning.configure(text="Still empty: " + ", ".join(empty))

            # return leaves the window up. Nothing below this line runs.
            return

        # Keep the answers on self. This window is about to close, but the
        # object survives it, which is how main() reads them afterwards.
        self.bot_name = answers["bot_name"]
        self.role = answers["role"]
        self.close()

    # ---- the second window ------------------------------------------

    def build_chat(self):
        """The transcript, the typing box, and the model behind them."""
        self.root.title(self.bot_name)
        self.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. write() opens it for a moment when it has something to add.
        self.transcript = scrolledtext.ScrolledText(
            self.root, wrap="word", font=("Segoe UI", 11), padx=10, pady=10,
            height=10, state="disabled")

        # A Frame is an invisible box for grouping. This one holds the
        # typing box and the button. It is a plain name, not self.row,
        # because nothing looks for it again.
        row = tk.Frame(self.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)

        # bind ties an event to a function. "<Return>" is the Enter key.
        self.box.bind("<Return>", self.send)
        self.box.focus_set()

        # command takes the function itself, with no brackets after it.
        tk.Button(row, text="Send", width=8, command=self.send).pack(
            side="left", padx=(8, 0))

        # Packed last on purpose, so the fixed row above is served first.
        self.transcript.pack(side="top", fill="both", expand=True,
                             padx=10, pady=(10, 0))

        llm = OpenAIServerModel(model_id=LLM_MODEL, api_base=LLM_URL,
                                api_key=LLM_KEY)

        # instructions is how smolagents carries a persona. It reaches the
        # model ahead of every question. Teaching comes first here, and
        # the tool is mentioned last on purpose: a model told it owns a
        # price tool will reach for it when nobody asked.
        # The list of tools is the whole permission system. A tool that is
        # not in this list cannot be called, however nicely you ask.
        self.agent = ToolCallingAgent(
            tools=[coin_price], model=llm,
            instructions="You are " + self.bot_name + ", " + self.role
                         + ". Teach in short, plain English, and keep every "
                         "reply under three sentences. If, and only if, "
                         "someone asks what a coin is worth, you may use "
                         "your coin_price tool to look it up.")

        self.answers = queue.Queue()

        # after() hands back a booking number. Keep it, so close() can
        # cancel the one still outstanding.
        self.ticking = None
        self.drain()

    # ---- shared by both ----------------------------------------------

    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):
        """Show what was typed, then hand it to the model."""
        asked = self.box.get().strip()
        if not asked:
            return

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

        # The model takes seconds. Calling it here would freeze the window
        # for all of them, so it goes on a thread of its own. daemon=True
        # so a half finished answer cannot keep the program alive after
        # the window is closed.
        threading.Thread(target=self.think, args=(asked,), daemon=True).start()

    def think(self, asked):
        """Runs on the worker thread. No widget may be touched from here.

        stream=True hands back each step as it finishes instead of one
        answer at the end, so the window can show its working. Without it
        a slow model is indistinguishable from a crashed one.
        """
        try:
            for step in self.agent.run(asked, stream=True, max_steps=MAX_STEPS):
                line = describe(step)

                # describe returns None for steps not worth showing.
                if line:
                    # put() is the only safe way out of this thread. A
                    # thread that touched a widget would crash tkinter,
                    # or worse, corrupt the display and say nothing.
                    self.answers.put(line)
        except Exception as trouble:
            # Catching everything is right here. Whatever went wrong, the
            # window should say so rather than sit there looking busy.
            self.answers.put("no answer: " + str(trouble) + "\n\n")

    def drain(self):
        """Runs on the main thread, and is the only thing that writes."""
        # empty() then get() is safe because this is the only reader.
        while not self.answers.empty():
            line = self.answers.get()

            # A step line starts with spaces. The answer does not, so it
            # is the one that gets the tutor's name in front of it.
            if line.startswith(" "):
                self.write(line)
            else:
                self.write(self.bot_name + ": " + line)

        # after() books one more run in 250ms, and hands back a number
        # naming that booking. Keep the number: a booking still
        # outstanding when the window goes will fire into a dead window,
        # and tkinter prints "invalid command name" at you.
        self.ticking = self.root.after(250, self.drain)

    def close(self):
        """Stop the drain loop, then take the window down.

        Cancelling has to happen before destroy(). A booking fires by
        number inside tkinter, so a guard at the top of drain() is too
        late: the error happens before Python is reached at all.
        """
        if getattr(self, "ticking", None) is not None:
            self.root.after_cancel(self.ticking)
            self.ticking = None
        self.root.destroy()

    def run(self):
        """Draw the window and wait, until this window closes.

        For the form that is the moment you press Start. For the tutor it
        is the moment you close it, and the program ends there.
        """
        self.root.mainloop()


def main():
    # First window. run() comes back when the form closes itself.
    setup = Window("form")
    setup.run()

    # Closing the form without filling it in leaves the name empty, and
    # there is nothing to teach, so stop here.
    if not setup.bot_name:
        return

    # Second window, handed what the first one collected.
    tutor = Window("tutor", setup.bot_name, setup.role)
    tutor.write(setup.bot_name + " is ready. Ask it to teach you something.\n")
    tutor.write("It can also look up a coin price, if you ask for one.\n\n")
    tutor.run()


if __name__ == "__main__":
    main()

🖥️ WHAT THE FIRST WINDOW DID · the form, driven step by step

AskName can send?  False
CoinRoom can send? True

the form window
  title           : Before we start
  has transcript  : False

an empty name is refused
  warning         : 'Please type a name.'
  still open      : True

typing Nok and pressing Start
  window gone     : True - can't invoke "winfo" command: application has been destroyed
  collected       : 'Nok'

the second window, built from that name
  title           : Coins
  greeting        : 'Hello Nok. Ask me about a coin.'

🖥️ AND WITH NO SERVER RUNNING · pointed at a dead port on purpose

Hello Nok. Ask me about a coin.

No server at http://127.0.0.1:9/v1
Start one, or set LLM_URL to where yours is.
The vLLM page has the command.

You: What should I learn first?
Bot: no answer from http://127.0.0.1:9/v1
Error while generating output:
Connection error.
If that address is wrong, set LLM_URL.

🖥️ WHAT THE SECOND WINDOW SHOWED · the form said Kru Nari, a patient English teacher

Kru Nari is ready. Ask it to teach you something.
It can also look up a coin price, if you ask for one.

You: What is the past tense of go?
  step 1: called final_answer
Kru Nari: went

You: What is BTC worth in baht right now?
  step 1: called coin_price
  step 2: that went wrong, trying again
  step 3: called coin_price
  step 4: called final_answer
Kru Nari: 1 BTC is worth 2,800,899.96 Thai baht right now.

💻 START A SERVER FIRST

pip install smolagents

# The image, once. It is 9 GB, so start it before you make tea.
docker pull vllm/vllm-openai:cu130-nightly

# The server. It answers at http://localhost:8000/v1
docker run --rm --name vllm --gpus all --ipc=host -p 8000:8000   -v "$HOME/.cache/huggingface:/root/.cache/huggingface"   vllm/vllm-openai:cu130-nightly   --model Qwen/Qwen2.5-7B-Instruct-AWQ   --gpu-memory-utilization 0.25   --max-model-len 8192   --enable-auto-tool-choice   --tool-call-parser hermes

🖥️ WHAT IT PRINTED · the second time, with the model already cached

Model loading took 5.2 GiB memory and 34.420278 seconds
Maximum concurrency for 8,192 tokens per request: 49.04x
INFO:     Application startup complete.

📄 window_factory.py

"""window_factory.py — challenge 8: a function that builds a whole class.

Every class so far was written with the word class. This file builds two
while the program is running, out of strings handed in at the time.

They inherit from nothing. There is no parent class anywhere in this file,
so every method is written inside the factory and handed to type().

The kind is decided when the CLASS is made, not when a window is built.
That is the difference from challenge 7. There the same class checked
self.kind every time; here the factory hands type() a different set of
methods, so the form class does not own a send at all. Ask it for one and
Python says it has no attribute. The factory decides what a class IS.

Two windows again. The first asks your name and closes. The second is the
chat, and it knows who it is talking to.
"""
import json
import os
import queue

# A thread lets the slow model run without freezing the window. A queue is
# how that thread passes its answer back, because a thread must never touch
# a widget itself.
import threading
import tkinter as tk
import urllib.request

from tkinter import scrolledtext

from smolagents import ActionStep, FinalAnswerStep
from smolagents import OpenAIServerModel, ToolCallingAgent, tool

# This one points at vLLM, not Ollama. The two speak the same /v1 API, so
# nothing below this line changes when you swap them. The vLLM page shows
# the swap, and the measurement that says when it is worth making.
LLM_URL = os.environ.get("LLM_URL", "http://localhost:8000/v1")

# vLLM names the model you started the server with, written out in full.
# Ollama would call the same model qwen2.5:7b. Send one server the other
# one's name and you get a 404.
LLM_MODEL = os.environ.get("LLM_MODEL", "Qwen/Qwen2.5-7B-Instruct-AWQ")

# TO USE OLLAMA INSTEAD, change both of these together:
#
#     LLM_URL   = "http://localhost:11434/v1"
#     LLM_MODEL = "qwen2.5:7b"
#
# Or leave the file alone and set them outside it, which is what the
# os.environ.get above is for:
#
#     set LLM_URL=http://localhost:11434/v1
#     set LLM_MODEL=qwen2.5:7b
#
# Both, or neither. Change only the address and Ollama answers, politely,
# with model 'Qwen/Qwen2.5-7B-Instruct-AWQ' not found. That one is worth
# causing once on purpose. The server is up and the address is right, so
# it does not look like a naming problem until you read the 404.
#
# Nothing else in this file changes. Not the class, not the factory, not
# the form, not the tool. That is what the two servers sharing one /v1
# API buys you.

# vLLM ignores this, but every OpenAI client sends one, so it is here.
LLM_KEY = os.environ.get("LLM_KEY", "none")

MAX_STEPS = 6
BITKUB = "https://api.bitkub.com/api/v3/market/ticker"


@tool
def coin_price(symbol: str) -> str:
    """Look up what one coin is worth in Thai baht, right now.

    Args:
        symbol: the coin's ticker, for example BTC or ETH
    """
    # No double quotes above. smolagents shows that description to the
    # model, and a model that copies them back breaks its own JSON.
    pair = symbol.upper().strip() + "_THB"
    with urllib.request.urlopen(BITKUB + "?sym=" + pair, timeout=30) as response:
        coins = json.load(response)
    if not coins:
        return "no coin called " + symbol + " on Bitkub"
    return ("1 " + symbol.upper() + " = "
            + format(float(coins[0]["last"]), ",.2f") + " baht")


def reachable(url):
    """True if something answers at that address. Two seconds, no more."""
    try:
        request = urllib.request.Request(
            url + "/models", headers={"Authorization": "Bearer " + LLM_KEY})
        with urllib.request.urlopen(request, timeout=2):
            return True
    except Exception:
        # Any failure at all means no. Which failure it was does not
        # change what you have to do about it.
        return False


def describe(step):
    """Turn one step of the agent's working into a line for the window."""
    if isinstance(step, FinalAnswerStep):
        return str(step.output) + "\n\n"
    if isinstance(step, ActionStep):
        if step.error:
            return f"  step {step.step_number}: that went wrong, trying again\n"

        # A step with nothing in it is a step that never reached the model.
        # Saying "called nothing" here reads as a choice the model made,
        # which it was not. Stay quiet and let the failure speak instead.
        if not step.tool_calls:
            return None

        called = ", ".join(call.name for call in step.tool_calls)
        return f"  step {step.step_number}: called {called}\n"
    return None


def window_class(name, title, kind):
    """Build a new window class and hand it back. Not an object: a class."""

    def __init__(self, user_name=""):
        # The form leaves this empty and fills it in. The chat is handed it.
        self.user_name = user_name

        self.root = tk.Tk()
        self.root.title(title)

        if kind == "form":
            self.build_form()
        else:
            self.build_chat()

        self.root.protocol("WM_DELETE_WINDOW", self.close)

    # ---- the form kind ------------------------------------------------

    def build_form(self):
        """One label, one box, one button. No transcript, no model."""
        self.root.geometry("400x170")
        frame = tk.Frame(self.root, padx=20, pady=20)
        frame.pack(fill="both", expand=True)

        tk.Label(frame, text="What is your name?",
                 font=("Segoe UI", 14)).pack(anchor="w", pady=(0, 14))

        self.box = tk.Entry(frame, font=("Segoe UI", 12))
        self.box.pack(fill="x", ipady=5)
        self.box.bind("<Return>", self.submit)
        self.box.focus_set()

        tk.Button(frame, text="Start", width=10, command=self.submit).pack(
            anchor="e", pady=(14, 0))

        # Made now, filled in by submit(), so the form never changes shape.
        self.warning = tk.Label(frame, text="", fg="#b00020",
                                font=("Segoe UI", 10))
        self.warning.pack(anchor="w")

    def submit(self, event=None):
        """Keep the name and close. Nothing to say means nothing happens."""
        typed = self.box.get().strip()
        if not typed:
            self.warning.configure(text="Please type a name.")
            return

        # The window is about to go. This object is not, which is how
        # main() reads the name afterwards.
        self.user_name = typed
        self.close()

    # ---- the chat kind ------------------------------------------------

    def build_chat(self):
        """The transcript, the typing box, and the model behind them."""
        self.root.geometry("520x420")

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

        row = tk.Frame(self.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.send works here because send is in the dict handed to type()
        # below. By the time anyone builds one of these, it is a method.
        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))

        llm = OpenAIServerModel(model_id=LLM_MODEL, api_base=LLM_URL,
                                api_key=LLM_KEY)

        # The name collected by the first window goes in here, so the model
        # is told who it is speaking to before it is asked anything.
        self.agent = ToolCallingAgent(
            tools=[coin_price], model=llm,
            instructions="You are talking to " + self.user_name
                         + ". Use their name in your reply. Keep every reply "
                         "under three sentences. If they ask what a coin is "
                         "worth, use your coin_price tool to look it up.")

        self.answers = queue.Queue()

        # after() hands back a booking number. Keep it, so close() can
        # cancel the one still outstanding.
        self.ticking = None
        self.drain()

        self.write("Hello " + self.user_name + ". Ask me about a coin.\n\n")

        # Ask the server what it serves, before anyone types anything. A
        # server that is not running is the commonest thing wrong here, and
        # without this the window looks fine until the first question, then
        # sits quiet for half a minute. Say it now, and say the address.
        if not reachable(LLM_URL):
            self.write("No server at " + LLM_URL + "\n"
                       "Start one, or set LLM_URL to where yours is.\n"
                       "The vLLM page has the command.\n\n")

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

    def send(self, event=None):
        """Show what was typed, then hand it to the model."""
        asked = self.box.get().strip()
        if not asked:
            return
        self.box.delete(0, "end")
        self.write("You: " + asked + "\n")

        # daemon=True so a half finished answer cannot keep the program
        # alive after the window is closed.
        threading.Thread(target=self.think, args=(asked,), daemon=True).start()

    def think(self, asked):
        """Runs on the worker thread. No widget may be touched from here.

        The name is added to the question, not left to the instructions
        above. Both were measured. Told only in the instructions, this
        model used the name in none of six answers, even when the
        instruction said to begin every reply with it. Added to the
        question, it used it every time it wrote an answer of its own.
        The instructions sit far from the model's attention; the question
        does not.
        """
        # What the transcript shows is what you typed. This extra line is
        # only ever sent to the model.
        for_model = (asked + "\n\n(My name is " + self.user_name
                     + ". Say my name in your answer.)")
        try:
            for step in self.agent.run(for_model, stream=True, max_steps=MAX_STEPS):
                line = describe(step)
                if line:
                    self.answers.put(line)
        except Exception as trouble:
            # Name the address. "Connection error" on its own tells a
            # reader nothing they can act on, and this is the failure they
            # will meet most often.
            self.answers.put("no answer from " + LLM_URL + "\n"
                             + str(trouble).strip() + "\n"
                             + "If that address is wrong, set LLM_URL.\n\n")

    def drain(self):
        """Runs on the main thread, and is the only thing that writes."""
        while not self.answers.empty():
            line = self.answers.get()

            # A step line starts with spaces. The answer does not.
            self.write(line if line.startswith(" ") else "Bot: " + line)

        # A booking still outstanding when the window goes will fire into a
        # dead window, and tkinter prints invalid command name at you.
        self.ticking = self.root.after(250, self.drain)

    # ---- shared by both -----------------------------------------------

    def close(self):
        """Stop the drain loop, then take the window down."""
        # getattr, because a form has no ticking: the factory never gave it
        # a drain to book one.
        if getattr(self, "ticking", None) is not None:
            self.root.after_cancel(self.ticking)
            self.ticking = None
        self.root.destroy()

    def run(self):
        """Draw the window and wait, until this window closes."""
        self.root.mainloop()

    # type() takes three things: the name, who it inherits from, and a dict
    # of what is inside. The empty brackets are the point of this file. They
    # mean it inherits from nothing, so every method it has is one written
    # above and handed over here by name.
    inside = {"__init__": __init__, "close": close, "run": run}
    if kind == "form":
        inside.update({"build_form": build_form, "submit": submit})
    else:
        inside.update({"build_chat": build_chat, "write": write,
                       "send": send, "think": think, "drain": drain})
    return type(name, (), inside)


def main():
    # Each of these lines makes a whole class, at the moment it runs.
    # They live in here rather than at the top of the file, so importing
    # this file builds nothing. Step 3 is the same idea: a file can be a
    # program and a toolbox, and only one of those runs on import.
    AskName = window_class("AskName", "Before we start", "form")
    CoinRoom = window_class("CoinRoom", "Coins", "coins")

    print("made", AskName.__name__, "and", CoinRoom.__name__)

    # The same question asked of both classes, and two different answers.
    # The factory did not set a flag; it handed type() a different dict.
    print("AskName can send? ", hasattr(AskName, "send"))
    print("CoinRoom can send?", hasattr(CoinRoom, "send"))

    asked = AskName()
    asked.run()

    # Closed without typing a name. Nobody to talk to, so stop.
    if not asked.user_name:
        return

    coins = CoinRoom(asked.user_name)
    coins.run()


if __name__ == "__main__":
    main()

📄 factory_check.py

"""factory_check.py — proof that the factory really makes classes.

window_factory only builds its classes inside main, so importing it builds
nothing at all. This file calls the factory itself. No window opens either:
tk.Tk() is only called when you build one.
"""
import window_factory as wf

AskName = wf.window_class("AskName", "Before we start", "form")
CoinRoom = wf.window_class("CoinRoom", "Coins", "coins")

print("type(AskName)       :", type(AskName).__name__)
print("is it a class?      :", isinstance(AskName, type))
print("its own name        :", AskName.__name__)
print("the other one       :", CoinRoom.__name__)
print("what it inherits    :", AskName.__bases__[0].__name__)
print("two separate classes:", AskName is not CoinRoom)

# The interesting part. The factory did not set a flag that a method reads
# later; it handed type() a different dict, so the two classes do not even
# own the same methods.
print()
print("AskName methods     :", sorted(
    n for n in vars(AskName) if not n.startswith("_") or n == "__init__"))
print("CoinRoom methods    :", sorted(
    n for n in vars(CoinRoom) if not n.startswith("_") or n == "__init__"))
print("AskName can send?   :", hasattr(AskName, "send"))
print("CoinRoom can send?  :", hasattr(CoinRoom, "send"))


# Written with class instead of type(), this is the same thing.
class HandMade:
    pass


print()
print("made by type()      :", type(AskName).__name__)
print("made by class       :", type(HandMade).__name__)
print("same kind of thing  :", type(AskName) is type(HandMade))

🖥️ WHAT IT PRINTED · two classes out of one factory

type(AskName)       : type
is it a class?      : True
its own name        : AskName
the other one       : CoinRoom
what it inherits    : object
two separate classes: True

AskName methods     : ['__init__', 'build_form', 'close', 'run', 'submit']
CoinRoom methods    : ['__init__', 'build_chat', 'close', 'drain', 'run', 'send', 'think', 'write']
AskName can send?   : False
CoinRoom can send?  : True

made by type()      : type
made by class       : type
same kind of thing  : True

🖥️ WHAT THE FIRST WINDOW DID · the form, driven step by step

AskName can send?  False
CoinRoom can send? True

the form window
  title           : Before we start
  has transcript  : False

an empty name is refused
  warning         : 'Please type a name.'
  still open      : True

typing Nok and pressing Start
  window gone     : True - can't invoke "winfo" command: application has been destroyed
  collected       : 'Nok'

the second window, built from that name
  title           : Coins
  greeting        : 'Hello Nok. Ask me about a coin.'

🖥️ AND WITH NO SERVER RUNNING · pointed at a dead port on purpose

Hello Nok. Ask me about a coin.

No server at http://127.0.0.1:9/v1
Start one, or set LLM_URL to where yours is.
The vLLM page has the command.

You: What should I learn first?
Bot: no answer from http://127.0.0.1:9/v1
Error while generating output:
Connection error.
If that address is wrong, set LLM_URL.

🖥️ WHAT THE SECOND WINDOW SHOWED · the form said Nok, the server was vLLM

Hello Nok. Ask me about a coin.

You: What should I learn first?
  step 1: called final_answer
Bot: Hello Nok, to start learning, you should first identify your goals
and interests. Based on those, you could begin with programming basics
or a new language.

You: What is BTC worth in baht right now?
  step 1: called coin_price
  step 2: called final_answer
Bot: 1 BTC is worth 2,792,079.34 baht right now.