📦 From a Python script to an app · จากสคริปต์ Python สู่แอป · 从 Python 脚本到应用程序

2026-10-06 17:57  Windows 11 build 10.0.26200, PyInstaller 6.22.3. Smart App Control: on.
build  1  one folder  blocked   one second later: blocked
build  2  one file    ran
build  3  one folder  ran
build  4  one file    ran
build  5  one folder  ran
build  6  one file    ran
build  7  one folder  ran
build  8  one file    ran
build  9  one folder  ran
build 10  one file    ran
build 11  one folder  ran
build 12  one file    blocked   one second later: ran
build 13  one folder  blocked   one second later: blocked
build 14  one file    ran
build 15  one folder  blocked   one second later: blocked
build 16  one file    ran
build 17  one folder  blocked   one second later: blocked
build 18  one file    ran
build 19  one folder  ran
build 20  one file    ran
build 21  one folder  blocked   one second later: blocked
build 22  one file    ran
build 23  one folder  ran
build 24  one file    ran
build 25  one folder  blocked   one second later: blocked
build 26  one file    blocked   one second later: blocked
build 27  one folder  blocked   one second later: blocked
build 28  one file    blocked   one second later: blocked
build 29  one folder  ran
build 30  one file    ran
build 31  one folder  ran
build 32  one file    ran
build 33  one folder  ran
build 34  one file    blocked   one second later: blocked
build 35  one folder  ran
build 36  one file    ran
build 37  one folder  ran
build 38  one file    blocked   one second later: blocked
build 39  one folder  ran
build 40  one file    ran
one folder: Windows blocked 7 of 20 new apps at the first start.
one file: Windows blocked 5 of 20 new apps at the first start.
In all: 12 of 40 blocked. 1 of those ran one second later.
11 were blocked twice. At the end of the run, 10 of them were still blocked.

2026-10-07 07:44  Smart App Control: on. 40 apps, built from 2026-10-06 17:57 to 18:03.
Now Windows blocks 0 of the 40 apps.

"""pond.py - you are a tiny fish in a pond. Eat, grow, and do not get eaten.

    python pond.py

Move the mouse. Your gold fish swims to it. Eat the white dots to grow.
An animal with a red edge is bigger than you, and it hunts you.
Hide under a leaf, and it cannot see you.
When you are bigger than an animal, its edge is white. Then you can eat it.

Who picks each hunter's move? Put the folder "model" beside this file, and
an AI model picks. With no such folder, a few lines of Python pick.
"""
import math
import os
import random
import threading
import time
import tkinter as tk

WIDE = 800                # the window, in pixels
HIGH = 600
SWIM = 4                  # pixels your fish moves in one frame
QUICK = 0.3               # the most your fish can turn in one frame
SLOW = 1.2                # pixels a hunter moves in one frame when it wanders
TURN = 0.15               # the most a hunter can turn in one frame
ARRIVED = 30              # a hunter has arrived at a place when it is this close
BEND = math.pi / 8        # the most one joint can bend: 22.5 degrees
QUARTER = math.pi / 2     # a quarter turn. Python measures angles in radians.
BONE = 24                 # how long each of the two bones in a leg is
REACH = 36                # how far from the hip a new step lands
STEP = 60                 # a foot takes a step when it is this far behind
NEAR = 150                # inside this many pixels, a hunter says your fish is "near"
FOOD = 12                 # how many white dots are in the pond
BITE = 3                  # how much one white dot makes your fish grow
LEAF = 60                 # how far a leaf's edge is from its centre
WATER = "#12263a"         # the colour behind everything
FIN = "#81c3d7"           # the colour of the fins
GOLD = "#f4a261"          # the colour of your fish
GREEN = "#2d6a4f"         # the colour of the leaves
RED = "#ff5a5f"           # the colour of the edge of an animal that can eat you

# How far the skin is from the spine at each point, from the head to the tail.
# These numbers are for an animal of size 100. A size of 50 uses half of each.
SNAKE = [18, 20, 17, 16, 16, 16, 16, 16, 16, 16, 16, 15, 15, 15,
         14, 14, 13, 13, 12, 12, 11, 10, 9, 8, 7, 6, 5, 4]
FISH = [20, 25, 27, 27, 25, 21, 17, 12, 9, 6]
LIZARD = [17, 19, 13, 20, 22, 23, 21, 16, 9, 6, 5, 4, 3, 3]

# The hunters at the start: the kind, the size, and the place of the head.
HUNTERS = [["fish", 50, [700, 90]], ["fish", 65, [120, 520]],
           ["snake", 80, [720, 520]], ["lizard", 100, [300, 70]]]

# The centre of each leaf.
LEAVES = [[130, 250], [560, 180], [470, 450]]

# The words at the bottom of the window. An app has no manual, so they are here.
HELP = ("Mouse: swim.   White dots: food.   Red edge: it eats you.   "
        "Leaf: hide.   Space: new game.")

# The file of the AI model. It sits in the folder "model", beside this file.
MODEL = "decider-2b-v11-Q4_K_M.gguf"

# The rules of a hunter. The model reads these with every question.
RULES = ("If you cannot see the gold fish, wander. "
         "If the gold fish is bigger than you, flee. "
         "If it is smaller than you and near, hunt it. "
         "If it is smaller than you and far away, wander.")

# The moves a hunter can choose from, and what each one is for.
MOVES = {
    "hunt": ("Swim to the gold fish and eat it. "
             "Do this when it is smaller than you and near."),
    "flee": ("Swim away from the gold fish. "
             "Do this when it is bigger than you."),
    "wander": ("Swim around slowly. Do this when it is smaller than you "
               "and far away, or when you cannot see it."),
}


def angle_to(start, end):
    """The direction you face when you stand at start and look at end."""
    return math.atan2(end[1] - start[1], end[0] - start[0])


def walk(start, angle, far):
    """Stand at start, face angle, walk far pixels. Give back where you are."""
    return [start[0] + math.cos(angle) * far, start[1] + math.sin(angle) * far]


def limit(angle, middle, most):
    """Give back angle, or the nearest angle that is within most of middle."""
    # How far angle is from middle, going the short way round the circle.
    # The answer is from -pi to pi: minus is one way round, plus is the other.
    away = (angle - middle + math.pi) % (2 * math.pi) - math.pi
    if away > most:
        return middle + most
    if away < -most:
        return middle - most
    return angle


def oval(centre, angle, long, wide):
    """Twelve points round the edge of an oval. Its long side points along angle."""
    edge = []
    for k in range(12):
        around = k * math.pi / 6        # twelve of these make one full turn
        # Go along the oval's long side, then out to the edge.
        along = walk(centre, angle, math.cos(around) * long)
        edge.append(walk(along, angle + QUARTER, math.sin(around) * wide))
    return edge


def pull(anchor, point, gap):
    """Give back the place that is gap pixels from anchor, on the way to point."""
    far = math.dist(anchor, point)      # how far apart the two are now
    if far == 0:
        # The same place: there is no direction, and gap / 0 would crash.
        return point
    scale = gap / far                   # 0.5 means "come half as far"
    x = anchor[0] + (point[0] - anchor[0]) * scale
    y = anchor[1] + (point[1] - anchor[1]) * scale
    return [x, y]


def reach(joints, start, end, bone):
    """Bend the chain of joints so it starts at start and reaches toward end."""
    last = len(joints) - 1
    # Forward: put the last joint on the target, then pull the others after it.
    joints[last] = end
    for i in reversed(range(last)):             # count down: last - 1, ..., 1, 0
        joints[i] = pull(joints[i + 1], joints[i], bone)
    # That dragged the first joint off its place. Put it back.
    # Backward: pull the others after it again, this time from the other end.
    joints[0] = start
    for i in range(1, last + 1):
        joints[i] = pull(joints[i - 1], joints[i], bone)


def model_file():
    """The full path of the model's file: in the folder "model", beside this file."""
    here = os.path.dirname(os.path.abspath(__file__))
    return os.path.join(here, "model", MODEL)


def pick(hidden, smaller, near):
    """The rules as Python. The "rules" game asks this, and asks no model."""
    if hidden:
        return "wander"
    if not smaller:
        return "flee"
    if near:
        return "hunt"
    return "wander"


def in_words(hidden, smaller, near):
    """What a hunter sees, in words. The model reads words, not True and False."""
    if hidden:
        return "You cannot see the gold fish."
    if not smaller:
        # No "near" or "far away" here. The rule for a bigger fish does not use
        # them. With them, the model followed those words and forgot "bigger".
        return "The gold fish is bigger than you."
    if near:
        return "The gold fish is smaller than you. It is near."
    return "The gold fish is smaller than you. It is far away."


def ask(model, kind, sees):
    """Give the model the rules, what a hunter sees, and the moves. Give back the move."""
    who = "You are a hungry " + kind + " in a pond. A gold fish swims in the pond too."
    question = {"type": "choice",
                "instructions": "What should you do right now?",
                "criteria": MOVES}
    state = who + " Rules: " + RULES + "\n\nSituation: " + sees
    answer = model.system_one(state, {"move": question})
    return answer["answers"]["move"]["choice"]


def touches(place, far, animal):
    """Is place within far pixels of the animal's skin, at any point of its spine?"""
    for i in range(len(animal.points)):
        if math.dist(place, animal.points[i]) < animal.widths[i] + far:
            return True
    return False


class Animal:
    def __init__(self, canvas, kind, size, place):
        self.canvas = canvas            # the picture this animal draws itself on
        self.kind = kind                # "fish", "snake" or "lizard"
        if kind == "snake":
            self.full_widths = SNAKE
            self.full_gap = 14  # pixels between two points of the spine, at size 100
            self.colour = "#9b72cf"
            self.speed = 3.0    # pixels in one frame when it hunts or flees
        if kind == "fish":
            self.full_widths = FISH
            self.full_gap = 20
            self.colour = "#3a7ca5"
            self.speed = 3.4
        if kind == "lizard":
            self.full_widths = LIZARD
            self.full_gap = 20
            self.colour = "#52796f"
            self.speed = 2.6
        self.rim = "white"              # the colour of its edge
        self.doing = "wander"           # its move now: hunt, flee or wander
        self.goal = place               # the place it swims to when it wanders
        self.resize(size)
        # Start as a straight line. Point 0 is the head.
        self.points = []
        self.angles = []      # which way the body faces at each point
        for i in range(len(self.widths)):
            self.points.append([place[0] - i * self.gap, place[1]])
            self.angles.append(0)       # 0 is "facing right"
        # Only the lizard has legs. Each leg is: which point of the spine it
        # joins, which side (-1 left, 1 right), and how far back its foot starts.
        self.legs = []
        if kind == "lizard":
            half = STEP * self.scale / 2
            self.add_leg(3, -1, 0)
            self.add_leg(3, 1, half)    # half a step behind, so the legs take turns
            self.add_leg(7, -1, half)
            self.add_leg(7, 1, 0)

    def resize(self, size):
        """Make the animal this big. 100 is the size the lists at the top are for."""
        self.size = size
        self.scale = size / 100         # size 50 gives 0.5: half of every number
        self.gap = self.full_gap * self.scale
        self.widths = []
        for wide in self.full_widths:
            self.widths.append(wide * self.scale)

    def add_leg(self, spot, side, behind):
        leg = {"spot": spot, "side": side}
        hip, ahead = self.leg_places(leg)
        # The place on the ground where the foot stands. It stays there until a step.
        leg["ground"] = walk(ahead, self.angles[spot], -behind)
        # Hip, knee, foot. The knee starts on the hip, and reach() moves it.
        leg["joints"] = [hip, hip, leg["ground"]]
        self.legs.append(leg)

    def leg_places(self, leg):
        """Where this leg's hip is now, and where its next step will land."""
        spot = leg["spot"]
        facing = self.angles[spot]
        sideways = facing + leg["side"] * QUARTER
        hip = walk(self.points[spot], sideways, self.widths[spot] - 6 * self.scale)
        # The next step lands out to the side and in front: half a quarter turn.
        ahead = walk(hip, facing + leg["side"] * QUARTER / 2, REACH * self.scale)
        return hip, ahead

    def go(self, place, speed, turn):
        """Move the head toward place. Then the body follows it."""
        head = self.points[0]
        wanted = angle_to(head, place)
        self.angles[0] = limit(wanted, self.angles[0], turn)
        self.points[0] = walk(head, self.angles[0], speed)
        for i in range(1, len(self.widths)):
            # Each point wants to face the point in front of it, within BEND.
            wanted = angle_to(self.points[i], self.points[i - 1])
            self.angles[i] = limit(wanted, self.angles[i - 1], BEND)
            # Then it stands one gap behind that point. Minus is a walk backwards.
            self.points[i] = walk(self.points[i - 1], self.angles[i], -self.gap)

    def move_legs(self):
        for leg in self.legs:
            hip, ahead = self.leg_places(leg)
            # The body walks on and the foot stays. When the foot is too far
            # behind, it gets a new place on the ground: that is one step.
            if math.dist(leg["ground"], ahead) > STEP * self.scale:
                leg["ground"] = ahead
            # The foot does not jump. Each frame it goes 4 tenths of the way there.
            ground = leg["ground"]
            foot = leg["joints"][2]
            x = foot[0] + (ground[0] - foot[0]) * 0.4
            y = foot[1] + (ground[1] - foot[1]) * 0.4
            reach(leg["joints"], hip, [x, y], BONE * self.scale)

    def outline(self):
        """The points of the skin, in order: down one side and back up the other."""
        left = []
        right = []
        for i in range(len(self.widths)):
            # A quarter turn from "forward" is "sideways". Walk out to the skin.
            wide = self.widths[i]
            left.append(walk(self.points[i], self.angles[i] - QUARTER, wide))
            right.append(walk(self.points[i], self.angles[i] + QUARTER, wide))
        right.reverse()       # the right side runs from the tail back to the head
        nose = walk(self.points[0], self.angles[0], self.widths[0])
        return [nose] + left + right

    def shape(self, edge, colour):
        # smooth=True rounds every corner, so the points become one curved shape.
        self.canvas.create_polygon(edge, fill=colour, outline=self.rim,
                                   width=1 + 2 * self.scale, smooth=True)

    def circle(self, centre, radius, fill):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=fill)

    def fin(self, spot, side, long, wide):
        """One fin on the skin beside point spot. side is -1 for left, 1 for right."""
        sideways = self.angles[spot] + side * QUARTER
        centre = walk(self.points[spot], sideways, self.widths[spot])
        # The fin leans out and back. It copies the angle of the point in front
        # of it, so it starts to turn a moment before the body under it does.
        lean = self.angles[spot - 1] + side * math.pi / 4
        self.shape(oval(centre, lean, long * self.scale, wide * self.scale), FIN)

    def draw(self):
        scale = self.scale
        if self.kind == "fish":
            # The fins go on first, so the body covers the place where they join.
            self.fin(3, -1, 26, 10)
            self.fin(3, 1, 26, 10)
            self.fin(7, -1, 15, 5)
            self.fin(7, 1, 15, 5)
            # The tail is one more oval. It sits behind the last point of the spine.
            tail = len(self.widths) - 1
            centre = walk(self.points[tail], self.angles[tail], -16 * scale)
            self.shape(oval(centre, self.angles[tail], 20 * scale, 5 * scale), FIN)
        # The legs go on first too. Each is a thick line in the colour of the
        # edge, with a thinner line on top, so it looks like it has an edge.
        for leg in self.legs:
            self.canvas.create_line(leg["joints"], fill=self.rim, width=14 * scale,
                                    capstyle="round", joinstyle="round")
            self.canvas.create_line(leg["joints"], fill=self.colour, width=8 * scale,
                                    capstyle="round", joinstyle="round")
        self.shape(self.outline(), self.colour)
        if self.kind == "fish":
            # The fin on its back goes on after the body, so it sits on top.
            back = oval(self.points[4], self.angles[4], 22 * scale, 4 * scale)
            self.shape(back, FIN)
        # The eyes. 1.2 is most of a quarter turn (1.57), so one sits on each side.
        head = self.points[0]
        facing = self.angles[0]
        far = self.widths[0] / 2
        self.circle(walk(head, facing - 1.2, far), 1 + 2 * scale, "white")
        self.circle(walk(head, facing + 1.2, far), 1 + 2 * scale, "white")


class Game:
    def __init__(self, brain):
        self.brain = brain              # "model" or "rules": who picks the moves
        self.root = tk.Tk()
        self.root.title("pond")
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.root.bind("<space>", self.start)
        self.note = "A few lines of Python pick the hunters' moves."
        self.loading = False            # True while the model loads. Nothing moves then.
        self.start()
        if brain == "model":
            # Only this brain needs a model, and a second thread to ask it in.
            self.note = "An AI model picks the hunters' moves."
            self.loading = True
            thread = threading.Thread(target=self.think, daemon=True)
            thread.start()

    def start(self, event=None):
        """Put everything back where a new game begins."""
        self.mouse = [WIDE / 2, HIGH / 2]
        self.player = Animal(self.canvas, "fish", 30, [WIDE / 2, HIGH / 2])
        self.player.colour = GOLD
        self.hunters = []
        for kind, size, place in HUNTERS:
            self.hunters.append(Animal(self.canvas, kind, size, place))
        self.food = []
        for i in range(FOOD):
            self.food.append(self.somewhere())
        self.over = ""                  # the words at the end. "" means: still playing.

    def somewhere(self):
        """A place in the pond, picked by chance. It is not too near the edge."""
        return [random.uniform(40, WIDE - 40), random.uniform(60, HIGH - 60)]

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]

    def under_leaf(self):
        """Is the head of your fish under a leaf?"""
        for leaf in LEAVES:
            if math.dist(self.player.points[0], leaf) < LEAF:
                return True
        return False

    def facts(self, hunter):
        """Three things a hunter knows about your fish. Each is True or False."""
        smaller = self.player.size < hunter.size
        near = math.dist(self.player.points[0], hunter.points[0]) < NEAR
        return self.under_leaf(), smaller, near

    def think(self):
        """Load the model. Then ask it for each hunter's move, again and again."""
        # This runs in a second thread, so the window can draw while it asks.
        try:
            # This import takes seconds, and only the model game needs it.
            # So it is here and not at the top.
            from decider.infer import Decider
            # n_ctx is how many tokens (pieces of words) the model has room for.
            # A question here has about 170, and a small room needs less memory.
            model = Decider(model_file(), gguf_options={"n_ctx": 2048})
        except Exception as problem:
            # The library or one of its files is not there. Say why in the
            # window, because an app has no terminal. Then play by the rules.
            # [-70:] keeps the last 70 letters: the end names what is missing.
            self.note = "No AI model: " + str(problem)[-70:]
            self.brain = "rules"
            self.loading = False
            return
        self.loading = False
        known = {}            # every answer so far. Each key is one question.
        while True:
            for hunter in list(self.hunters):
                hidden, smaller, near = self.facts(hunter)
                sees = in_words(hidden, smaller, near)
                key = hunter.kind + ": " + sees
                if key not in known:
                    # The model is slow, and the same question always gets the
                    # same answer. So ask each question once, and keep the answer.
                    known[key] = ask(model, hunter.kind, sees)
                    self.note = "Answers from the AI model: " + str(len(known))
                hunter.doing = known[key]
            # A short rest. A loop that never rests keeps the computer busy.
            time.sleep(0.05)

    def act(self, hunter):
        """Move one hunter for one frame. Its move says how."""
        head = hunter.points[0]
        fish = self.player.points[0]
        if hunter.doing == "hunt":
            hunter.go(fish, hunter.speed, TURN)
            return
        if hunter.doing == "flee":
            # Look from your fish to the hunter. It swims on along that line.
            ahead = walk(head, angle_to(fish, head), 200)
            # Keep that place inside the pond.
            x = min(max(ahead[0], 40), WIDE - 40)
            y = min(max(ahead[1], 40), HIGH - 40)
            hunter.goal = [x, y]
            if math.dist(head, hunter.goal) > ARRIVED:
                hunter.go(hunter.goal, hunter.speed, TURN)
            return
        # The move is "wander": swim slowly to a place, then pick a new place.
        if math.dist(head, hunter.goal) < ARRIVED:
            hunter.goal = self.somewhere()
        hunter.go(hunter.goal, SLOW, TURN)

    def eat_food(self):
        player = self.player
        for dot in list(self.food):
            if math.dist(player.points[0], dot) < player.widths[0] + 6:
                self.food.remove(dot)
                self.food.append(self.somewhere())      # a new dot for the old one
                player.resize(player.size + BITE)

    def meet(self, hunter):
        """Your fish and one hunter. Does one of them eat the other?"""
        player = self.player
        if hunter.size > player.size:
            # It can eat you when its head touches you. Under a leaf you are safe.
            bites = touches(hunter.points[0], hunter.widths[0], player)
            if bites and not self.under_leaf():
                self.over = "A " + hunter.kind + " ate you. Press Space to try again."
            return
        if touches(player.points[0], player.widths[0], hunter):
            self.hunters.remove(hunter)
            player.resize(player.size + hunter.size // 5)
        if not self.hunters:
            self.over = "You are the biggest animal in the pond. You win!"

    def play(self):
        """One frame of the game: everything moves, and some things get eaten."""
        player = self.player
        # Your fish stops when the mouse is on its head. A small fish has a small head.
        if math.dist(player.points[0], self.mouse) > player.widths[0]:
            player.go(self.mouse, SWIM, QUICK)
        self.eat_food()
        for hunter in list(self.hunters):
            if self.brain == "rules":
                hidden, smaller, near = self.facts(hunter)
                hunter.doing = pick(hidden, smaller, near)
            self.act(hunter)
            hunter.move_legs()
            self.meet(hunter)

    def write(self, x, y, text, size, anchor):
        self.canvas.create_text(x, y, text=text, fill="white", anchor=anchor,
                                font=("Arial", size))

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        for dot in self.food:
            self.canvas.create_oval(dot[0] - 4, dot[1] - 4, dot[0] + 4, dot[1] + 4,
                                    fill="white", outline="white")
        for hunter in self.hunters:
            hunter.rim = "white"
            if hunter.size > self.player.size:
                hunter.rim = RED        # it is bigger than you, so it can eat you
            hunter.draw()
            # Above its head: the kind, the size, and the move it does now.
            label = hunter.kind + " " + str(hunter.size) + ": " + hunter.doing
            head = hunter.points[0]
            self.write(head[0], head[1] - hunter.widths[0] - 12, label, 10, "center")
        self.player.draw()
        for x, y in LEAVES:
            # A leaf is a circle with one small piece cut out of it.
            self.canvas.create_arc(x - LEAF, y - LEAF, x + LEAF, y + LEAF,
                                   start=6, extent=348, fill=GREEN, outline="#74c69d",
                                   width=3)
        self.write(12, 16, "You: " + str(self.player.size), 14, "w")
        self.write(WIDE - 12, 16, self.note, 11, "e")
        self.write(WIDE / 2, HIGH - 14, HELP, 10, "center")
        # Big words go a third of the way down, so they do not cover your fish.
        if self.loading:
            self.write(WIDE / 2, HIGH / 3, "The AI model is loading. Wait a little.",
                       20, "center")
        if self.over:
            self.write(WIDE / 2, HIGH / 3, self.over, 20, "center")

    def frame(self):
        if not self.over and not self.loading:
            self.play()
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    brain = "rules"                     # a few lines of Python pick each move
    if os.path.exists(model_file()):
        brain = "model"                 # the AI model picks each move
    game = Game(brain)
    game.run()


if __name__ == "__main__":
    main()

"""get_model.py - download the AI model for pond.py into the folder "model".

    python get_model.py

It downloads five files: 1.3 GB in all. On slow wifi that takes a long time.
If it stops, run it again. It goes on from where it stopped.
"""
import os
import time
import urllib.error
import urllib.request

SITE = "https://huggingface.co/Mapika/decider-2b-GGUF/resolve/main/"
FILES = ["decider_config.json", "tokenizer_config.json", "chat_template.jinja",
         "tokenizer.json", "decider-2b-v11-Q4_K_M.gguf"]
PIECE = 1024 * 1024       # read one megabyte at a time


def size_of(path):
    """How many bytes of the file are here now. 0 when there is no file yet."""
    if os.path.exists(path):
        return os.path.getsize(path)
    return 0


def add_rest(name, path):
    """Ask the site for the bytes that are not here yet. Add them to the file."""
    have = size_of(path)
    request = urllib.request.Request(SITE + name)
    # Range says: start at byte number `have`, and not at the first byte.
    request.add_header("Range", "bytes=" + str(have) + "-")
    with urllib.request.urlopen(request, timeout=60) as reply:
        mode = "ab"           # "ab": add the new bytes at the end of the file
        if reply.status == 200:
            # 200 means the site did not start at `have`: it sends the whole file.
            mode = "wb"       # "wb": throw the old bytes away and start again
            have = 0
        with open(path, mode) as file:
            piece = reply.read(PIECE)
            while piece:
                file.write(piece)
                have = have + len(piece)
                # end="\r" goes back to the start of the line, so the number counts up.
                print("  ", name, have // PIECE, "MB", end="\r")
                piece = reply.read(PIECE)


def fetch(name, path):
    """Download one file. Ask again and again, until the site has no more of it."""
    while True:
        try:
            add_rest(name, path)
        except urllib.error.HTTPError as problem:
            if problem.code == 416:
                return        # 416 means: no bytes come after ours. The file is whole.
            raise
        except OSError as problem:
            print("\n   The connection stopped:", problem)
            print("   Trying again in 5 seconds.")
            time.sleep(5)


def main():
    here = os.path.dirname(os.path.abspath(__file__))
    folder = os.path.join(here, "model")
    os.makedirs(folder, exist_ok=True)
    for name in FILES:
        path = os.path.join(folder, name)
        fetch(name, path)
        print(name, size_of(path), "bytes      ")
    print("Done. The model is in:", folder)


if __name__ == "__main__":
    main()

The library took 4.1 s to import, and the model 2.0 s to load.
fish   wander 0.976 to 0.995   You cannot see the gold fish.
fish   hunt   0.997 to 1.000   The gold fish is smaller than you. It is near.
fish   wander 0.998 to 0.999   The gold fish is smaller than you. It is far away.
   WRONG  fish   moves in the order hunt, flee, wander: the model said hunt {'hunt': 0.9492, 'flee': 0.0464, 'wander': 0.0044}
   WRONG  fish   moves in the order hunt, wander, flee: the model said hunt {'hunt': 0.9393, 'wander': 0.0033, 'flee': 0.0574}
   WRONG  fish   moves in the order flee, hunt, wander: the model said hunt {'flee': 0.0385, 'hunt': 0.9578, 'wander': 0.0036}
   WRONG  fish   moves in the order flee, wander, hunt: the model said hunt {'flee': 0.0476, 'wander': 0.0021, 'hunt': 0.9503}
   WRONG  fish   moves in the order wander, hunt, flee: the model said hunt {'wander': 0.0011, 'hunt': 0.9763, 'flee': 0.0225}
   WRONG  fish   moves in the order wander, flee, hunt: the model said hunt {'wander': 0.0018, 'flee': 0.0368, 'hunt': 0.9614}
fish   flee   0.022 to 0.057   The gold fish is bigger than you. It is near.
   WRONG  fish   moves in the order hunt, flee, wander: the model said wander {'hunt': 0.0006, 'flee': 0.1507, 'wander': 0.8487}
   WRONG  fish   moves in the order hunt, wander, flee: the model said wander {'hunt': 0.0008, 'wander': 0.9244, 'flee': 0.0748}
   WRONG  fish   moves in the order flee, hunt, wander: the model said wander {'flee': 0.3162, 'hunt': 0.0011, 'wander': 0.6827}
   WRONG  fish   moves in the order flee, wander, hunt: the model said wander {'flee': 0.1171, 'wander': 0.882, 'hunt': 0.0008}
   WRONG  fish   moves in the order wander, hunt, flee: the model said wander {'wander': 0.9381, 'hunt': 0.001, 'flee': 0.0609}
   WRONG  fish   moves in the order wander, flee, hunt: the model said wander {'wander': 0.9496, 'flee': 0.0496, 'hunt': 0.0008}
fish   flee   0.050 to 0.316   The gold fish is bigger than you. It is far away.
snake  wander 0.981 to 0.995   You cannot see the gold fish.
snake  hunt   0.996 to 0.999   The gold fish is smaller than you. It is near.
snake  wander 0.998 to 0.999   The gold fish is smaller than you. It is far away.
   WRONG  snake  moves in the order hunt, flee, wander: the model said hunt {'hunt': 0.8412, 'flee': 0.1498, 'wander': 0.0089}
   WRONG  snake  moves in the order hunt, wander, flee: the model said hunt {'hunt': 0.8526, 'wander': 0.0071, 'flee': 0.1403}
   WRONG  snake  moves in the order flee, hunt, wander: the model said hunt {'flee': 0.1496, 'hunt': 0.842, 'wander': 0.0084}
   WRONG  snake  moves in the order flee, wander, hunt: the model said hunt {'flee': 0.1737, 'wander': 0.0057, 'hunt': 0.8206}
   WRONG  snake  moves in the order wander, hunt, flee: the model said hunt {'wander': 0.0024, 'hunt': 0.942, 'flee': 0.0556}
   WRONG  snake  moves in the order wander, flee, hunt: the model said hunt {'wander': 0.0053, 'flee': 0.1589, 'hunt': 0.8358}
snake  flee   0.056 to 0.174   The gold fish is bigger than you. It is near.
   WRONG  snake  moves in the order hunt, flee, wander: the model said wander {'hunt': 0.0009, 'flee': 0.1449, 'wander': 0.8542}
   WRONG  snake  moves in the order hunt, wander, flee: the model said wander {'hunt': 0.0013, 'wander': 0.9244, 'flee': 0.0744}
   WRONG  snake  moves in the order flee, hunt, wander: the model said wander {'flee': 0.2314, 'hunt': 0.0012, 'wander': 0.7674}
   WRONG  snake  moves in the order flee, wander, hunt: the model said wander {'flee': 0.1013, 'wander': 0.8977, 'hunt': 0.0011}
   WRONG  snake  moves in the order wander, hunt, flee: the model said wander {'wander': 0.9311, 'hunt': 0.0014, 'flee': 0.0676}
   WRONG  snake  moves in the order wander, flee, hunt: the model said wander {'wander': 0.9463, 'flee': 0.0527, 'hunt': 0.001}
snake  flee   0.053 to 0.231   The gold fish is bigger than you. It is far away.
lizard wander 0.978 to 0.995   You cannot see the gold fish.
lizard hunt   0.996 to 0.999   The gold fish is smaller than you. It is near.
lizard wander 0.998 to 0.999   The gold fish is smaller than you. It is far away.
   WRONG  lizard moves in the order hunt, flee, wander: the model said hunt {'hunt': 0.9007, 'flee': 0.0933, 'wander': 0.006}
   WRONG  lizard moves in the order hunt, wander, flee: the model said hunt {'hunt': 0.9008, 'wander': 0.0048, 'flee': 0.0944}
   WRONG  lizard moves in the order flee, hunt, wander: the model said hunt {'flee': 0.1055, 'hunt': 0.8888, 'wander': 0.0057}
   WRONG  lizard moves in the order flee, wander, hunt: the model said hunt {'flee': 0.1369, 'wander': 0.0039, 'hunt': 0.8592}
   WRONG  lizard moves in the order wander, hunt, flee: the model said hunt {'wander': 0.0017, 'hunt': 0.9535, 'flee': 0.0448}
   WRONG  lizard moves in the order wander, flee, hunt: the model said hunt {'wander': 0.0034, 'flee': 0.1065, 'hunt': 0.8901}
lizard flee   0.045 to 0.137   The gold fish is bigger than you. It is near.
   WRONG  lizard moves in the order hunt, flee, wander: the model said wander {'hunt': 0.0009, 'flee': 0.2434, 'wander': 0.7557}
   WRONG  lizard moves in the order hunt, wander, flee: the model said wander {'hunt': 0.0012, 'wander': 0.8801, 'flee': 0.1188}
   WRONG  lizard moves in the order flee, hunt, wander: the model said wander {'flee': 0.2761, 'hunt': 0.0012, 'wander': 0.7226}
   WRONG  lizard moves in the order flee, wander, hunt: the model said wander {'flee': 0.1275, 'wander': 0.8714, 'hunt': 0.0011}
   WRONG  lizard moves in the order wander, hunt, flee: the model said wander {'wander': 0.9098, 'hunt': 0.0015, 'flee': 0.0887}
   WRONG  lizard moves in the order wander, flee, hunt: the model said wander {'wander': 0.9236, 'flee': 0.0753, 'hunt': 0.0011}
lizard flee   0.075 to 0.276   The gold fish is bigger than you. It is far away.
90 questions, 36 wrong. The lowest share of a right move: 0.022.
A question is 163 to 169 tokens long.
About 1.7 s for one question on this computer.