GPT-6.1 Terra Draws a Python Reading a Book

import math
import turtle

screen = turtle.Screen()
screen.setup(800, 650)
screen.bgcolor("#f8f4e8")
screen.title("A Python Reading a Book")

pen = turtle.Turtle()
pen.hideturtle()
pen.speed(0)
screen.tracer(0)


def move(x, y):
    pen.penup()
    pen.goto(x, y)
    pen.pendown()


def polygon(points, fill, outline="#324a35", width=2):
    pen.color(outline, fill)
    pen.pensize(width)
    move(*points[0])
    pen.begin_fill()
    for point in points[1:]:
        pen.goto(*point)
    pen.goto(*points[0])
    pen.end_fill()


def ellipse(cx, cy, rx, ry, fill, outline=None, width=2):
    points = [
        (cx + rx * math.cos(i * math.tau / 100),
         cy + ry * math.sin(i * math.tau / 100))
        for i in range(100)
    ]
    polygon(points, fill, outline or fill, width)


def line(points, color, width=2):
    pen.color(color)
    pen.pensize(width)
    move(*points[0])
    for point in points[1:]:
        pen.goto(*point)


def bezier(p0, p1, p2, p3):
    points = []
    for i in range(101):
        t = i / 100
        u = 1 - t
        points.append((
            u**3 * p0[0] + 3*u**2*t * p1[0] + 3*u*t**2 * p2[0] + t**3 * p3[0],
            u**3 * p0[1] + 3*u**2*t * p1[1] + 3*u*t**2 * p2[1] + t**3 * p3[1],
        ))
    return points


# Coiled body: a dark border with a green stroke on top.
coil = [
    (45 + 180 * math.cos(i * math.tau / 180),
     -165 + 70 * math.sin(i * math.tau / 180))
    for i in range(181)
]
line(coil, "#314c35", 54)
line(coil, "#78a85c", 44)

# Markings along the coil.
for angle in range(0, 360, 30):
    a = math.radians(angle)
    ellipse(45 + 180 * math.cos(a), -165 + 70 * math.sin(a),
            12, 7, "#b9cd77")

# Neck rising behind the book.
neck = bezier((210, -155), (265, -95), (200, 90), (145, 145))
line(neck, "#314c35", 54)
line(neck, "#78a85c", 44)
for i in (18, 38, 58, 78):
    x, y = neck[i]
    ellipse(x, y, 9, 13, "#b9cd77")

# Open book, including its cover and two pages.
polygon([(-240, 100), (-35, 45), (165, 100),
         (165, -75), (-35, -130), (-240, -75)],
        "#9b523e", "#65372c", 3)
polygon([(-230, 100), (-35, 45), (-35, -120), (-230, -65)],
        "#fffdf2", "#806c56", 2)
polygon([(-35, 45), (155, 100), (155, -65), (-35, -120)],
        "#fffdf2", "#806c56", 2)

# Lines of print on the pages.
for y in (70, 45, 20, -5, -30):
    line([(-210, y), (-55, y - 43)], "#b9ab91", 2)
    line([(-15, y - 43), (135, y)], "#b9ab91", 2)

line([(-35, 45), (-35, -120)], "#806c56", 3)

# Head and face, looking down at the book.
ellipse(105, 145, 70, 39, "#78a85c", "#314c35", 3)
ellipse(73, 159, 14, 14, "white", "#314c35", 2)
ellipse(115, 162, 14, 14, "white", "#314c35", 2)
ellipse(69, 155, 5, 6, "#24382a")
ellipse(111, 158, 5, 6, "#24382a")
ellipse(48, 138, 3, 3, "#314c35")
line([(43, 128), (55, 123), (68, 124)], "#314c35", 2)

screen.update()
turtle.done()

#!/usr/bin/env python3
"""Scan, report on, and archive files.

Place stash.toml next to this script, for example:

    ignore = ["*.tmp", "build/*"]
    batch_size = 100
    label = "My files"  # optional

Ignore patterns are matched case-sensitively against both the filename and
its slash-separated path relative to the scanned directory. As with fnmatch,
a wildcard can match a slash.
"""

from __future__ import annotations

import argparse
import fnmatch
import hashlib
import json
import os
import shutil
import stat
import sys
import tempfile
import tomllib
from dataclasses import dataclass
from datetime import datetime, timezone
from pathlib import Path
from typing import Iterator


SCRIPT_DIR = Path(__file__).resolve().parent
CONFIG_PATH = SCRIPT_DIR / "stash.toml"
RESULTS_PATH = SCRIPT_DIR / "stash.json"
ARCHIVE_DIR = SCRIPT_DIR / "archive"


@dataclass(frozen=True)
class Settings:
    ignore: tuple[str, ...]
    batch_size: int
    label: str | None


@dataclass(frozen=True)
class FileRecord:
    path: Path
    size: int
    sha256: str
    modified: datetime

    def to_json(self) -> dict[str, str | int]:
        return {
            "path": str(self.path),
            "size": self.size,
            "sha256": self.sha256,
            "modified": self.modified.isoformat().replace("+00:00", "Z"),
        }

    @classmethod
    def from_json(cls, value: object) -> FileRecord:
        if not isinstance(value, dict):
            raise ValueError("each file record must be an object")

        path = value.get("path")
        size = value.get("size")
        digest = value.get("sha256")
        modified = value.get("modified")

        if not isinstance(path, str) or not Path(path).is_absolute():
            raise ValueError("file record path must be an absolute path")
        if type(size) is not int or size < 0:
            raise ValueError(f"invalid size for {path}")
        if (
            not isinstance(digest, str)
            or len(digest) != 64
            or any(c not in "0123456789abcdef" for c in digest)
        ):
            raise ValueError(f"invalid SHA-256 hash for {path}")
        if not isinstance(modified, str):
            raise ValueError(f"invalid modification time for {path}")

        try:
            timestamp = datetime.fromisoformat(modified)
        except ValueError as exc:
            raise ValueError(f"invalid modification time for {path}") from exc
        if timestamp.tzinfo is None or timestamp.utcoffset() is None:
            raise ValueError(f"modification time for {path} has no timezone")

        return cls(
            path=Path(path),
            size=size,
            sha256=digest,
            modified=timestamp.astimezone(timezone.utc),
        )


def load_settings() -> Settings:
    try:
        with CONFIG_PATH.open("rb") as file:
            data = tomllib.load(file)
    except FileNotFoundError as exc:
        raise ValueError(f"config file not found: {CONFIG_PATH}") from exc

    ignore = data.get("ignore")
    batch_size = data.get("batch_size")
    label = data.get("label")

    if not isinstance(ignore, list) or not all(
        isinstance(pattern, str) for pattern in ignore
    ):
        raise ValueError("config 'ignore' must be a list of strings")
    if type(batch_size) is not int or batch_size <= 0:
        raise ValueError("config 'batch_size' must be a positive integer")
    if label is not None and not isinstance(label, str):
        raise ValueError("config 'label' must be a string")

    return Settings(tuple(ignore), batch_size, label)


def matches_ignore(path: Path, root: Path, patterns: tuple[str, ...]) -> bool:
    relative = path.relative_to(root).as_posix()
    return any(
        fnmatch.fnmatchcase(relative, pattern)
        or fnmatch.fnmatchcase(path.name, pattern)
        for pattern in patterns
    )


def walk_files(root: Path, patterns: tuple[str, ...]) -> Iterator[Path]:
    def raise_walk_error(error: OSError) -> None:
        raise error

    for directory, subdirectories, filenames in os.walk(
        root, onerror=raise_walk_error
    ):
        subdirectories.sort()
        for filename in sorted(filenames):
            path = Path(directory) / filename
            if not matches_ignore(path, root, patterns) and path.is_file():
                yield path


def hash_file(path: Path) -> FileRecord:
    with path.open("rb") as file:
        metadata = os.fstat(file.fileno())
        if not stat.S_ISREG(metadata.st_mode):
            raise ValueError(f"not a regular file: {path}")
        digest = hashlib.file_digest(file, "sha256").hexdigest()
        metadata = os.fstat(file.fileno())

    return FileRecord(
        path=path,
        size=metadata.st_size,
        sha256=digest,
        modified=datetime.fromtimestamp(metadata.st_mtime, timezone.utc),
    )


def write_results(records: list[FileRecord], label: str | None) -> None:
    document = {"label": label, "files": [record.to_json() for record in records]}
    temporary_path: Path | None = None
    try:
        with tempfile.NamedTemporaryFile(
            mode="w",
            encoding="utf-8",
            dir=SCRIPT_DIR,
            prefix=".stash-",
            suffix=".tmp",
            delete=False,
        ) as file:
            temporary_path = Path(file.name)
            json.dump(document, file, indent=2, ensure_ascii=False)
            file.write("\n")
        os.replace(temporary_path, RESULTS_PATH)
    finally:
        if temporary_path is not None:
            temporary_path.unlink(missing_ok=True)


def read_results() -> tuple[str | None, list[FileRecord]]:
    try:
        with RESULTS_PATH.open("r", encoding="utf-8") as file:
            document = json.load(file)
    except FileNotFoundError as exc:
        raise ValueError(f"results file not found: {RESULTS_PATH}; run scan first") from exc

    if not isinstance(document, dict) or not isinstance(document.get("files"), list):
        raise ValueError("results must contain a 'files' list")
    label = document.get("label")
    if label is not None and not isinstance(label, str):
        raise ValueError("results label must be a string or null")

    return label, [FileRecord.from_json(item) for item in document["files"]]


def scan(directory: str, settings: Settings) -> None:
    root = Path(directory).resolve()
    if not root.is_dir():
        raise ValueError(f"directory not found or not a directory: {directory}")

    paths = list(walk_files(root, settings.ignore))
    records: list[FileRecord] = []
    total = len(paths)
    batches = (total + settings.batch_size - 1) // settings.batch_size

    for start in range(0, total, settings.batch_size):
        batch = paths[start : start + settings.batch_size]
        records.extend(hash_file(path) for path in batch)
        batch_number = start // settings.batch_size + 1
        print(f"Batch {batch_number}/{batches}: processed {len(records)}/{total} files")

    write_results(records, settings.label)


def group_by_extension(records: list[FileRecord]) -> dict[str, list[FileRecord]]:
    groups: dict[str, list[FileRecord]] = {}
    for record in records:
        extension = record.path.suffix.lower()
        groups.setdefault(extension, []).append(record)
    return groups


def newest(records: list[FileRecord]) -> FileRecord:
    return max(records, key=lambda record: (record.modified, str(record.path)))


def report() -> None:
    label, records = read_results()
    if label is not None:
        print(f"Label: {label}")

    for extension, group in sorted(group_by_extension(records).items()):
        latest = newest(group)
        display_extension = extension or "(no extension)"
        timestamp = latest.modified.isoformat().replace("+00:00", "Z")
        print(
            f"{display_extension}: {len(group)} files, "
            f"{sum(record.size for record in group)} bytes; "
            f"newest: {latest.path} ({timestamp})"
        )


def archive() -> None:
    _, records = read_results()
    ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)

    for _, group in sorted(group_by_extension(records).items()):
        source = newest(group).path
        destination = ARCHIVE_DIR / source.name
        if destination.exists() and os.path.samefile(source, destination):
            continue
        shutil.copy2(source, destination)


def main() -> int:
    parser = argparse.ArgumentParser(prog="stash", description=__doc__)
    subparsers = parser.add_subparsers(dest="command", required=True)

    scan_parser = subparsers.add_parser("scan", help="scan a directory")
    scan_parser.add_argument("directory", metavar="DIRECTORY")
    subparsers.add_parser("report", help="report on scanned files")
    subparsers.add_parser("archive", help="copy the newest file of each extension")

    args = parser.parse_args()
    try:
        settings = load_settings()
        if args.command == "scan":
            scan(args.directory, settings)
        elif args.command == "report":
            report()
        else:
            archive()
    except (OSError, ValueError) as exc:
        print(f"stash: error: {exc}", file=sys.stderr)
        return 1
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

--- original.py
+++ updated.py
@@ -15,9 +15,11 @@


-def collect_sizes(root, min_size):
+def collect_sizes(root, min_size, ext=None):
     # TODO: skip symlinks?
     sizes = []
     for dirpath, dirnames, filenames in os.walk(root):
         for i in range(len(filenames)):
+            if ext is not None and os.path.splitext(filenames[i])[1] != ext:
+                continue
             path = os.path.join(dirpath, filenames[i])
             try:
@@ -40,4 +42,5 @@
     parser.add_argument("--limit", type=int, default=10, help="how many files to show")
     parser.add_argument("--min-size", type=int, default=0, help="skip files smaller than this many bytes")
+    parser.add_argument("--ext", help="only count files with this extension, e.g. .log")
     args = parser.parse_args()

@@ -47,5 +50,5 @@
         sys.exit(1)

-    top = largest(collect_sizes(args.root, args.min_size), args.limit)
+    top = largest(collect_sizes(args.root, args.min_size, args.ext), args.limit)
     for i in range(len(top)):
         size, path = top[i]

from itertools import chain

flattened = list(chain.from_iterable(list_of_lists))