Gemini 4 Argon Draws a Python Reading a Book

import turtle


def setup_canvas():
    screen = turtle.Screen()
    screen.title("A Python Reading a Book")
    screen.bgcolor("#F0F8FF")  # Alice Blue background
    screen.setup(width=800, height=600)

    t = turtle.Turtle()
    t.speed(8)  # 1 is slow, 10 is fast, 0 is instant
    t.hideturtle()
    return t, screen


def draw_circle(t, x, y, radius, color, outline="black", pen_size=2):
    t.penup()
    t.goto(x, y - radius)
    t.pendown()
    t.pensize(pen_size)
    t.color(outline, color)
    t.begin_fill()
    t.circle(radius)
    t.end_fill()


def draw_snake_body(t):
    # We draw overlapping circles from the tail to the neck to create a coiled effect
    body_segments = [
        # Base coil (left to right)
        (-130, -140, 20),
        (-100, -145, 25),
        (-60, -150, 30),
        (-20, -150, 32),
        (20, -150, 32),
        (60, -145, 30),
        # Middle coil (right to left)
        (40, -110, 28),
        (0, -110, 30),
        (-40, -110, 30),
        (-80, -105, 28),
        # Rising neck (curving up)
        (-95, -70, 25),
        (-90, -30, 24),
        (-75, 10, 23),
        (-55, 45, 22),
        (-35, 75, 22),
    ]

    # Alternate slightly between two shades of green for texture
    for i, (x, y, r) in enumerate(body_segments):
        color = "#558B2F" if i % 2 == 0 else "#689F38"
        draw_circle(t, x, y, r, color)


def draw_snake_head(t):
    # Main head
    draw_circle(t, -10, 95, 35, "#7CB342")
    # Snout
    draw_circle(t, 15, 85, 28, "#7CB342")

    # Tongue
    t.penup()
    t.goto(43, 80)
    t.pendown()
    t.color("#D32F2F")
    t.pensize(3)
    t.setheading(-15)
    t.forward(20)
    # Fork in the tongue
    t.left(30)
    t.forward(8)
    t.backward(8)
    t.right(60)
    t.forward(8)


def draw_glasses_and_eyes(t):
    # Left Eye
    draw_circle(t, 0, 105, 8, "white", pen_size=1)
    draw_circle(t, 3, 103, 3, "black", pen_size=1)  # Looking down at the book

    # Right Eye
    draw_circle(t, 25, 100, 8, "white", pen_size=1)
    draw_circle(t, 28, 98, 3, "black", pen_size=1)  # Looking down at the book

    # Glasses Frames (Gold/Brown)
    t.pensize(3)
    t.color("#5D4037")

    # Left Lens
    t.penup()
    t.goto(0, 105 - 12)
    t.setheading(0)
    t.pendown()
    t.circle(12)

    # Right Lens
    t.penup()
    t.goto(25, 100 - 12)
    t.setheading(0)
    t.pendown()
    t.circle(12)

    # Bridge of glasses
    t.penup()
    t.goto(11, 105)
    t.pendown()
    t.goto(14, 103)

    # Earpiece (going back to the head)
    t.penup()
    t.goto(-12, 105)
    t.pendown()
    t.goto(-35, 115)


def draw_book(t):
    # Draw an open book tilted for reading

    # 1. Red Book Cover (Background polygon)
    t.penup()
    t.goto(60, -140)  # Bottom spine
    t.pendown()
    t.color("black", "#C62828")  # Dark Red
    t.pensize(2)
    t.begin_fill()
    t.goto(-10, -90)  # Bottom left
    t.goto(-30, 10)  # Top left
    t.goto(40, -40)  # Top spine
    t.goto(120, 10)  # Top right
    t.goto(140, -90)  # Bottom right
    t.goto(60, -140)  # Back to bottom spine
    t.end_fill()

    # 2. Left Page (White)
    t.penup()
    t.goto(60, -130)  # Bottom spine
    t.pendown()
    t.color("black", "#FFFDF7")  # Off-white
    t.begin_fill()
    t.goto(-5, -85)  # Bottom left
    t.goto(-22, 5)  # Top left
    t.goto(40, -35)  # Top spine
    t.goto(60, -130)  # Back to bottom spine
    t.end_fill()

    # 3. Right Page (White)
    t.penup()
    t.goto(60, -130)  # Bottom spine
    t.pendown()
    t.begin_fill()
    t.goto(130, -85)  # Bottom right
    t.goto(112, 5)  # Top right
    t.goto(40, -35)  # Top spine
    t.goto(60, -130)  # Back to bottom spine
    t.end_fill()

    # 4. Draw "Text" lines on the pages
    t.pensize(2)
    t.color("#9E9E9E")  # Grey for text

    # Left page text
    for i in range(1, 5):
        t.penup()
        t.goto(40 - (i * 4), -35 - (i * 18))
        t.pendown()
        t.goto(-15 + (i * 3), -5 - (i * 18))

    # Right page text
    for i in range(1, 5):
        t.penup()
        t.goto(50 + (i * 4), -35 - (i * 18))
        t.pendown()
        t.goto(105 + (i * 3), -5 - (i * 18))


def draw_tail_holding_book(t):
    # Drawn AFTER the book so it overlaps the pages, looking like it's holding it
    tail_segments = [
        (130, -130, 15),
        (145, -105, 13),
        (135, -80, 11),  # Overlapping the right edge of the book
        (115, -70, 9),  # Pointing onto the page
        (100, -70, 6),  # Tail tip
    ]

    for x, y, r in tail_segments:
        draw_circle(t, x, y, r, "#7CB342")


def write_title(t):
    t.penup()
    t.goto(0, 200)
    t.color("#2E7D32")
    t.write(
        "Learning Python...", align="center", font=("Comic Sans MS", 24, "bold")
    )


def main():
    t, screen = setup_canvas()

    draw_snake_body(t)
    draw_snake_head(t)
    draw_glasses_and_eyes(t)
    draw_book(t)
    draw_tail_holding_book(t)
    write_title(t)

    # Keep the window open until clicked
    screen.exitonclick()


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""stash: A file scanning, reporting, and archiving CLI tool."""

import argparse
from collections import defaultdict
from dataclasses import asdict, dataclass
from datetime import datetime, timezone
import fnmatch
import hashlib
from itertools import batched
import json
from pathlib import Path
import shutil
import sys
import tomllib
from typing import Any, Self

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


@dataclass(slots=True, frozen=True)
class Config:
    ignore: list[str]
    batch_size: int
    label: str | None = None

    @classmethod
    def load(cls, path: Path) -> Self:
        if not path.is_file():
            sys.exit(f"Error: Configuration file not found at '{path}'.")
        try:
            with path.open("rb") as f:
                data = tomllib.load(f)
            ignore = list(data.get("ignore", []))
            batch_size = int(data["batch_size"])
            if batch_size < 1:
                raise ValueError("batch_size must be at least 1")
            label = data.get("label")
            return cls(ignore=ignore, batch_size=batch_size, label=label)
        except KeyError as e:
            sys.exit(f"Error: Missing required setting {e} in '{path}'.")
        except (tomllib.TOMLDecodeError, ValueError, TypeError) as e:
            sys.exit(f"Error: Invalid configuration in '{path}': {e}")


@dataclass(slots=True, frozen=True)
class FileRecord:
    path: str
    size: int
    sha256: str
    mtime: str

    @property
    def extension(self) -> str:
        ext = Path(self.path).suffix.lower()
        return ext if ext else "<no ext>"

    @property
    def mtime_dt(self) -> datetime:
        return datetime.fromisoformat(self.mtime)

    def to_dict(self) -> dict[str, Any]:
        return asdict(self)

    @classmethod
    def from_dict(cls, data: dict[str, Any]) -> Self:
        return cls(
            path=str(data["path"]),
            size=int(data["size"]),
            sha256=str(data["sha256"]),
            mtime=str(data["mtime"]),
        )


def is_ignored(file_path: Path, root: Path, patterns: list[str]) -> bool:
    rel_posix = file_path.relative_to(root).as_posix()
    name = file_path.name
    for pattern in patterns:
        if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(
            rel_posix, pattern
        ):
            return True
    return False


def hash_file(path: Path) -> str:
    with path.open("rb") as f:
        return hashlib.file_digest(f, "sha256").hexdigest()


def load_stash(path: Path) -> tuple[str | None, list[FileRecord]]:
    if not path.is_file():
        sys.exit(
            f"Error: '{path}' not found. Run 'stash scan <DIRECTORY>' first."
        )
    try:
        with path.open("r", encoding="utf-8") as f:
            data = json.load(f)
        if isinstance(data, list):
            return None, [FileRecord.from_dict(item) for item in data]
        return data.get("label"), [
            FileRecord.from_dict(item) for item in data.get("files", [])
        ]
    except (json.JSONDecodeError, KeyError, TypeError, ValueError) as e:
        sys.exit(f"Error: Failed to parse '{path}': {e}")


def cmd_scan(directory: Path, config: Config) -> None:
    if not directory.exists():
        sys.exit(f"Error: Directory '{directory}' does not exist.")
    if not directory.is_dir():
        sys.exit(f"Error: '{directory}' is not a directory.")

    files_to_process: list[Path] = []
    for root, _, files in directory.walk():
        for file in files:
            file_path = root / file
            if file_path.is_symlink():
                continue
            if not is_ignored(file_path, directory, config.ignore):
                files_to_process.append(file_path)

    records: list[FileRecord] = []
    total_files = len(files_to_process)

    for batch_num, batch in enumerate(
        batched(files_to_process, config.batch_size), start=1
    ):
        for file_path in batch:
            try:
                stat = file_path.stat()
                sha256 = hash_file(file_path)
                mtime = datetime.fromtimestamp(
                    stat.st_mtime, tz=timezone.utc
                ).isoformat()
                records.append(
                    FileRecord(
                        path=str(file_path),
                        size=stat.st_size,
                        sha256=sha256,
                        mtime=mtime,
                    )
                )
            except OSError as e:
                print(
                    f"Warning: Skipping '{file_path}': {e}", file=sys.stderr
                )

        label_prefix = f"[{config.label}] " if config.label else ""
        print(
            f"{label_prefix}Processed batch {batch_num}: {len(records)}/{total_files} files hashed"
        )

    output_data = {
        "label": config.label,
        "files": [r.to_dict() for r in records],
    }

    with STASH_JSON_PATH.open("w", encoding="utf-8") as f:
        json.dump(output_data, f, indent=2)


def cmd_report(config: Config) -> None:
    label, records = load_stash(STASH_JSON_PATH)
    effective_label = label or config.label
    if effective_label:
        print(f"Report ({effective_label})")
        print("=" * (9 + len(effective_label)))

    if not records:
        print("No files recorded in stash.")
        return

    grouped: dict[str, list[FileRecord]] = defaultdict(list)
    for r in records:
        grouped[r.extension].append(r)

    print(
        f"{'Extension':<12} | {'Count':>7} | {'Total Size (B)':>16} | Newest File"
    )
    print("-" * 76)

    for ext in sorted(grouped):
        group = grouped[ext]
        count = len(group)
        total_size = sum(r.size for r in group)
        newest = max(group, key=lambda r: r.mtime_dt)
        print(f"{ext:<12} | {count:>7} | {total_size:>16,} | {newest.path}")


def cmd_archive(config: Config) -> None:
    _, records = load_stash(STASH_JSON_PATH)
    if not records:
        print("No files to archive.")
        return

    grouped: dict[str, list[FileRecord]] = defaultdict(list)
    for r in records:
        grouped[r.extension].append(r)

    ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)

    for ext, group in sorted(grouped.items()):
        newest = max(group, key=lambda r: r.mtime_dt)
        src = Path(newest.path)
        if not src.is_file():
            sys.exit(f"Error: Source file for archiving '{src}' does not exist.")

        dest = ARCHIVE_DIR / src.name
        try:
            if src.resolve() != dest.resolve():
                shutil.copy2(src, dest)
        except OSError as e:
            sys.exit(f"Error: Failed to copy '{src}' to '{dest}': {e}")

    print(f"Archived {len(grouped)} file(s) to '{ARCHIVE_DIR}'.")


def main() -> None:
    parser = argparse.ArgumentParser(
        prog="stash",
        description="Scan, report, and archive files based on stash.toml configuration.",
    )
    subparsers = parser.add_subparsers(dest="subcommand", required=True)

    scan_parser = subparsers.add_parser("scan", help="Scan a directory")
    scan_parser.add_argument(
        "directory", type=Path, help="Directory to scan recursively"
    )

    subparsers.add_parser("report", help="Report statistics from stash.json")
    subparsers.add_parser(
        "archive", help="Archive the newest file of each extension"
    )

    args = parser.parse_args()
    config = Config.load(CONFIG_PATH)

    match args.subcommand:
        case "scan":
            cmd_scan(args.directory, config)
        case "report":
            cmd_report(config)
        case "archive":
            cmd_archive(config)


if __name__ == "__main__":
    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 and not filenames[i].endswith(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")
     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]

import itertools

list_of_lists = [[1, 2], [3, 4], [5, 6]]

flattened = list(itertools.chain.from_iterable(list_of_lists))
# Output: [1, 2, 3, 4, 5, 6]