comicforge 0.0.1__py3-none-any.whl

comicforge/bubbles.py

@@ -0,0 +1,133 @@
+"""Speech bubbles: speech, thought, and shout, with naive word-wrap + tails.
+
+All coordinates here are absolute page px. A bubble is positioned by its centre
+(bx, by); the tail points toward `tail` (also page px).
+"""
+
+from __future__ import annotations
+
+import math
+from xml.sax.saxutils import escape
+
+FONT = "DejaVu Sans, Helvetica, Arial, sans-serif"
+INK = "#21304a"
+
+
+def _wrap(text: str, max_chars: int) -> list[str]:
+    lines, cur = [], ""
+    for word in text.split():
+        if cur and len(cur) + 1 + len(word) > max_chars:
+            lines.append(cur)
+            cur = word
+        else:
+            cur = f"{cur} {word}".strip()
+    if cur:
+        lines.append(cur)
+    return lines or [""]
+
+
+def _text_block(lines, cx, top, fs, lh):
+    spans = []
+    for i, ln in enumerate(lines):
+        spans.append(
+            f'<tspan x="{cx:.1f}" y="{top + fs + i * lh:.1f}">{escape(ln)}</tspan>'
+        )
+    weight = ""
+    return (
+        f'<text text-anchor="middle" font-family="{FONT}" '
+        f'font-size="{fs}" fill="{INK}" {weight}>{"".join(spans)}</text>'
+    )
+
+
+def bubble(text, bx, by, tail=None, kind="speech", max_chars=22,
+           fs=16, pad=14):
+    lines = _wrap(text, max_chars)
+    lh = fs * 1.25
+    longest = max((len(ln) for ln in lines), default=1)
+    w = max(longest * fs * 0.56 + 2 * pad, 60)
+    h = len(lines) * lh + 2 * pad
+    x, y = bx - w / 2, by - h / 2
+    txt = _text_block(lines, bx, y + pad, fs, lh)
+
+    if kind == "shout":
+        body = _burst(x, y, w, h)
+    elif kind == "thought":
+        rx, ry = w / 2 + 6, h / 2 + 8
+        body = (f'<ellipse cx="{bx:.1f}" cy="{by:.1f}" rx="{rx:.1f}" ry="{ry:.1f}" '
+                f'fill="#ffffff" stroke="{INK}" stroke-width="3"/>')
+    else:
+        body = (f'<rect x="{x:.1f}" y="{y:.1f}" width="{w:.1f}" height="{h:.1f}" '
+                f'rx="{min(18, h/2):.1f}" fill="#ffffff" stroke="{INK}" '
+                f'stroke-width="3"/>')
+
+    tail_svg = ""
+    if tail is not None:
+        tail_svg = _tail(bx, by, w, h, tail, kind)
+
+    return f'<g>{body}{tail_svg}{txt}</g>'
+
+
+def _tail(bx, by, w, h, tail, kind):
+    """A slim tail that drops from the bubble underside and points toward the
+    target — but stops well short of it, so the tip never reaches the figure."""
+    tx, ty = tail
+    # exit from the bottom edge, nudged horizontally toward the target but kept
+    # under the bubble body
+    ex = min(max(tx, bx - w * 0.3), bx + w * 0.3)
+    ey = by + h / 2
+    dx, dy = tx - ex, ty - ey
+    dist = math.hypot(dx, dy) or 1.0
+    reach = min(dist * 0.45, 46)  # capped length keeps the tip off the figure
+    ux, uy = dx / dist, dy / dist
+    tipx, tipy = ex + ux * reach, ey + uy * reach
+
+    if kind == "thought":
+        dots = ""
+        for f in (0.45, 0.74, 1.0):
+            r = 6 * (1 - f) + 2.5
+            dots += (f'<circle cx="{ex + ux * reach * f:.1f}" '
+                     f'cy="{ey + uy * reach * f:.1f}" r="{r:.1f}" '
+                     f'fill="#ffffff" stroke="{INK}" stroke-width="2.5"/>')
+        return dots
+    # narrow tapered tail for speech/shout
+    perp = math.atan2(uy, ux) + math.pi / 2
+    base = 6
+    ax = ex + math.cos(perp) * base
+    ay = ey + math.sin(perp) * base
+    bx2 = ex - math.cos(perp) * base
+    by2 = ey - math.sin(perp) * base
+    return (
+        f'<path d="M{ax:.1f} {ay:.1f} L{tipx:.1f} {tipy:.1f} '
+        f'L{bx2:.1f} {by2:.1f} Z" fill="#ffffff" stroke="{INK}" '
+        f'stroke-width="2.5" stroke-linejoin="round"/>'
+    )
+
+
+def _cloud(x, y, w, h):
+    # rounded body + scalloped top edge via overlapping circles
+    rx = min(20, h / 2)
+    body = (f'<rect x="{x:.1f}" y="{y:.1f}" width="{w:.1f}" height="{h:.1f}" '
+            f'rx="{rx:.1f}" fill="#ffffff" stroke="{INK}" stroke-width="3"/>')
+    bumps = ""
+    n = max(3, int(w // 34))
+    for i in range(n):
+        cx = x + (i + 0.5) * w / n
+        bumps += (f'<circle cx="{cx:.1f}" cy="{y:.1f}" r="13" '
+                  f'fill="#ffffff" stroke="{INK}" stroke-width="3"/>')
+    # mask the inner stroke segments by redrawing body fill on top edge
+    cover = (f'<rect x="{x+3:.1f}" y="{y:.1f}" width="{w-6:.1f}" height="14" '
+             f'fill="#ffffff" stroke="none"/>')
+    return body + bumps + cover + body.replace('fill="#ffffff"', 'fill="none"')
+
+
+def _burst(x, y, w, h):
+    cx, cy = x + w / 2, y + h / 2
+    rx, ry = w / 2 + 8, h / 2 + 8
+    n = 18
+    pts = []
+    for i in range(n * 2):
+        a = math.pi * i / n
+        rr = 1.0 if i % 2 == 0 else 0.78
+        pts.append(f"{cx + math.cos(a) * rx * rr:.1f},{cy + math.sin(a) * ry * rr:.1f}")
+    return (f'<polygon points="{" ".join(pts)}" fill="#ffffff" '
+            f'stroke="{INK}" stroke-width="3" stroke-linejoin="round"/>')

comicforge/cli.py

@@ -0,0 +1,396 @@
+"""Command line interface.
+
+python -m comicforge render examples/pes/pages/slepice.yaml -o out.pdf
+python -m comicforge scene  examples/pes/pages/dvur-scene.yaml -o out.png
+python -m comicforge characters --library examples/pes/characters
+python -m comicforge scenes --scenes examples/pes/scenes
+python -m comicforge inspire examples/pes/references.yaml --review
+
+When `-o` is omitted, render/scene/panel/character write a timestamped file into
+the gitignored ``output/`` dir (so successive renders accumulate for comparison).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+
+from rich import print as rich_print
+
+from .library import Library
+from .pixelart import PixelLibrary
+from .render import (
+    render_all_panels,
+    render_character,
+    render_panel,
+    render_scene,
+    render_spec,
+)
+from .scene import SceneLibrary
+from .validate import validate_spec
+
+# Where renders land when -o is omitted. Gitignored; filenames carry a timestamp
+# so successive renders accumulate and you can watch a page/character evolve.
+OUTPUT_DIR = Path("output")
+
+
+def _stamp() -> str:
+    return datetime.now(UTC).astimezone().strftime("%Y%m%d-%H%M%S")
+
+
+def _default_out(stem: str, ext: str = ".png") -> Path:
+    """A timestamped path inside the gitignored output dir."""
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    return OUTPUT_DIR / f"{stem}-{_stamp()}{ext}"
+
+
+def _parse_selection(char, tokens, pose):
+    """Turn CLI tokens into a (selection, pose) pair for one character.
+
+    A token is either ``key=value`` (``pose=walk``, ``face=happy``) or a bare
+    name that is matched against the character's poses, then its slot variants.
+    """
+    # pass 1: settle the pose first, so variant lookup uses the right slots
+    for tok in tokens:
+        if "=" in tok:
+            k, v = tok.split("=", 1)
+            if k == "pose":
+                pose = v
+        elif tok in char.poses:
+            pose = tok
+
+    slots = char.slots_for(pose)
+    selection: dict[str, str] = {}
+    for tok in tokens:
+        if "=" in tok:
+            k, v = tok.split("=", 1)
+            if k != "pose":
+                selection[k] = v
+        elif tok in char.poses:
+            continue
+        else:
+            slot = next((s for s, variants in slots.items() if tok in variants), None)
+            if slot is None:
+                raise SystemExit(
+                    f"don't know '{tok}' for {char.name}: "
+                    f"not a pose {list(char.poses)} nor a variant in {slots}"
+                )
+            selection[slot] = tok
+    return selection, pose
+
+
+def main(argv=None):  # noqa: PLR0912, PLR0915 — flat CLI dispatcher; clearer linear
+    p = argparse.ArgumentParser(prog="comicforge")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    init = sub.add_parser(
+        "init", help="scaffold a new data-only project (no Python needed)"
+    )
+    init.add_argument(
+        "dest", type=Path, help="directory to create the project in (e.g. ./my-comic)"
+    )
+    init.add_argument(
+        "--force",
+        action="store_true",
+        help="overwrite existing files (default: skip files that already exist)",
+    )
+
+    r = sub.add_parser("render", help="render a comic page spec")
+    r.add_argument("spec", type=Path)
+    r.add_argument(
+        "-o",
+        "--out",
+        type=Path,
+        default=None,
+        help="output .svg / .png / .pdf (default: output/<spec>-<timestamp>.png)",
+    )
+    r.add_argument("--library", type=Path, default=None)
+    r.add_argument("--scenes", type=Path, default=None)
+    r.add_argument(
+        "--pixel-dir",
+        type=Path,
+        default=None,
+        dest="pixel_dir",
+        help="pixel-art sprite library directory",
+    )
+
+    v = sub.add_parser(
+        "validate", help="check a page/scene spec against its libraries (no render)"
+    )
+    v.add_argument("spec", type=Path)
+    v.add_argument("--library", type=Path, default=None)
+    v.add_argument("--scenes", type=Path, default=None)
+    v.add_argument(
+        "--pixel-dir",
+        type=Path,
+        default=None,
+        dest="pixel_dir",
+        help="pixel-art sprite library directory",
+    )
+
+    s = sub.add_parser("scene", help="render a standalone scene illustration")
+    s.add_argument("spec", type=Path)
+    s.add_argument(
+        "-o",
+        "--out",
+        type=Path,
+        default=None,
+        help="output .svg / .png / .pdf (default: output/<spec>-<timestamp>.png)",
+    )
+    s.add_argument("--library", type=Path, default=None)
+    s.add_argument("--scenes", type=Path, default=None)
+    s.add_argument(
+        "--pixel-dir",
+        type=Path,
+        default=None,
+        dest="pixel_dir",
+        help="pixel-art sprite library directory",
+    )
+
+    pn = sub.add_parser(
+        "panel", help="render individual panel(s) at low res for review"
+    )
+    pn.add_argument("spec", type=Path)
+    pn.add_argument(
+        "-o",
+        "--out",
+        type=Path,
+        default=None,
+        help="output file, or a directory when --all "
+        "(default: timestamped path under output/)",
+    )
+    pn.add_argument("--row", type=int, default=0)
+    pn.add_argument("--col", type=int, default=0)
+    pn.add_argument(
+        "--all", action="store_true", help="render every panel into the -o directory"
+    )
+    pn.add_argument(
+        "--scale",
+        type=float,
+        default=0.5,
+        help="size vs full-page panel (default 0.5 = low res)",
+    )
+    pn.add_argument("--library", type=Path, default=None)
+    pn.add_argument("--scenes", type=Path, default=None)
+    pn.add_argument(
+        "--pixel-dir",
+        type=Path,
+        default=None,
+        dest="pixel_dir",
+        help="pixel-art sprite library directory",
+    )
+
+    ch = sub.add_parser(
+        "character", help="render a single character on its own, for review"
+    )
+    ch.add_argument("name", help="character to render")
+    ch.add_argument(
+        "selections",
+        nargs="*",
+        help="pose and slot variants as bare names (sit, happy) or key=value "
+        "(face=happy, pose=walk)",
+    )
+    ch.add_argument(
+        "-o",
+        "--out",
+        type=Path,
+        default=None,
+        help="output .svg / .png / .pdf (default: output/<name>-<timestamp>.png)",
+    )
+    ch.add_argument(
+        "--library", type=Path, required=True, help="character library directory"
+    )
+    ch.add_argument(
+        "--pose", default=None, help="pose to render (default: character's)"
+    )
+    ch.add_argument(
+        "--scale", type=float, default=2.0, help="px per viewBox unit (default 2)"
+    )
+    ch.add_argument("--bg", default="#ffffff", help="canvas background colour")
+    ch.add_argument("--flip", action="store_true", help="mirror horizontally")
+    ch.add_argument(
+        "--thumb-px",
+        type=int,
+        default=320,
+        dest="thumb_px",
+        help="body width of the small companion PNG (0 to skip it)",
+    )
+
+    c = sub.add_parser("characters", help="print the character library contract")
+    c.add_argument(
+        "--library",
+        type=Path,
+        required=True,
+        help="character library directory (required)",
+    )
+
+    sc = sub.add_parser("scenes", help="print the scene library contract")
+    sc.add_argument(
+        "--scenes", type=Path, required=True, help="scenes directory (required)"
+    )
+
+    ins = sub.add_parser(
+        "inspire", help="generate reference images from a theme + descriptions"
+    )
+    ins.add_argument("references", type=Path, help="references spec (list of items)")
+    ins.add_argument(
+        "-o",
+        "--out",
+        type=Path,
+        default=None,
+        help="output dir (default: references/ next to the spec)",
+    )
+    ins.add_argument(
+        "--theme",
+        type=Path,
+        default=None,
+        help="theme.yaml (default: sibling of the spec)",
+    )
+    ins.add_argument(
+        "--only",
+        default=None,
+        help="generate only these ids (comma-separated)",
+    )
+    ins.add_argument(
+        "--force", action="store_true", help="regenerate even if a .png exists"
+    )
+    ins.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="write composed prompts only; no API call, no token needed",
+    )
+    ins.add_argument(
+        "--review", action="store_true", help="also write a review.html grid"
+    )
+
+    args = p.parse_args(argv)
+
+    if args.cmd == "init":
+        from .scaffold import init_project  # noqa: PLC0415 — keep import local
+
+        created = init_project(args.dest, force=args.force)
+        for f in created:
+            rich_print(f"created {f}")
+        if not created:
+            rich_print(f"{args.dest}: nothing to do (all files exist; use --force)")
+        else:
+            rich_print(
+                f"\nProject ready in {args.dest}. Next:\n"
+                f"  cmf render {args.dest / 'pages' / 'hello.yaml'}"
+            )
+    elif args.cmd in ("render", "scene"):
+        lib = Library(args.library) if args.library else None
+        scenes = SceneLibrary(args.scenes) if args.scenes else None
+        px = PixelLibrary(args.pixel_dir) if args.pixel_dir else None
+        fn = render_spec if args.cmd == "render" else render_scene
+        out = args.out or _default_out(args.spec.stem)
+        try:
+            fn(args.spec, out, library=lib, scenes=scenes, pixel_library=px)
+        except ValueError as e:
+            rich_print(f"{args.spec}: {e}")
+            return 1
+        rich_print(f"wrote {out}")
+    elif args.cmd == "validate":
+        lib = Library(args.library) if args.library else None
+        scenes = SceneLibrary(args.scenes) if args.scenes else None
+        px = PixelLibrary(args.pixel_dir) if args.pixel_dir else None
+        problems = validate_spec(
+            args.spec, library=lib, scenes=scenes, pixel_library=px
+        )
+        if problems:
+            rich_print(f"{args.spec}: {len(problems)} problem(s)")
+            for msg in problems:
+                rich_print(f"  - {msg}")
+            return 1
+        rich_print(f"{args.spec}: ok")
+        return 0
+    elif args.cmd == "panel":
+        lib = Library(args.library) if args.library else None
+        scenes = SceneLibrary(args.scenes) if args.scenes else None
+        px = PixelLibrary(args.pixel_dir) if args.pixel_dir else None
+        if args.all:
+            out = args.out or (OUTPUT_DIR / f"{args.spec.stem}-panels-{_stamp()}")
+            for o in render_all_panels(
+                args.spec,
+                out,
+                library=lib,
+                scenes=scenes,
+                pixel_library=px,
+                scale=args.scale,
+            ):
+                rich_print(f"wrote {o}")
+        else:
+            out = args.out or _default_out(
+                f"{args.spec.stem}-r{args.row}c{args.col}"
+            )
+            render_panel(
+                args.spec,
+                out,
+                args.row,
+                args.col,
+                library=lib,
+                scenes=scenes,
+                scale=args.scale,
+                pixel_library=px,
+            )
+            rich_print(f"wrote {out}")
+    elif args.cmd == "character":
+        lib = Library(args.library)
+        char = lib.get(args.name)
+        selection, pose = _parse_selection(char, args.selections, args.pose)
+        out = args.out or _default_out(args.name)
+        render_character(
+            args.name,
+            out,
+            selection,
+            pose=pose,
+            library=lib,
+            scale=args.scale,
+            bg=args.bg,
+            flip=args.flip,
+        )
+        rich_print(f"wrote {out}")
+        # a smaller PNG alongside it, sized for Claude to read with fewer tokens
+        if args.thumb_px > 0:
+            thumb = out.with_name(f"{out.stem}.small.png")
+            thumb_scale = min(args.scale, args.thumb_px / char.resolve_pose(pose).w)
+            render_character(
+                args.name,
+                thumb,
+                selection,
+                pose=pose,
+                library=lib,
+                scale=thumb_scale,
+                bg=args.bg,
+                flip=args.flip,
+            )
+            rich_print(f"wrote {thumb}")
+    elif args.cmd == "characters":
+        lib = Library(args.library)
+        json.dump(lib.manifest(), sys.stdout, indent=2, ensure_ascii=False)
+        rich_print()
+    elif args.cmd == "scenes":
+        scenes = SceneLibrary(args.scenes)
+        json.dump(scenes.manifest(), sys.stdout, indent=2, ensure_ascii=False)
+        rich_print()
+    elif args.cmd == "inspire":
+        from .inspire import generate  # noqa: PLC0415 — lazy: keeps Replicate optional
+
+        only = {s.strip() for s in args.only.split(",")} if args.only else None
+        out = generate(
+            args.references,
+            args.out,
+            theme_path=args.theme,
+            only=only,
+            force=args.force,
+            review=args.review,
+            dry_run=args.dry_run,
+        )
+        rich_print(f"wrote {len(out)} file(s)")
+
+
+if __name__ == "__main__":
+    main()