Upload comic/schema.py with huggingface_hub

comic/schema.py

@@ -0,0 +1,124 @@
+"""Typed structures for a generated comic.
+
+The flow produces, in order:
+  ComicBible  — the fixed story + cast (Gemma call #1). `characters` are FIXED for
+                the whole story: their `appearance` text is injected verbatim into
+                every panel image prompt, which is what keeps the art consistent.
+  Panel       — one of 20 panels (Gemma calls #2..N): a visual `scene` (drives FLUX)
+                and a `caption` (the reader text shown under the image).
+  Comic       — the assembled result: 10 pages, two panels each, images attached.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+PAGES = 25
+PANELS_PER_PAGE = 2
+TOTAL_PANELS = PAGES * PANELS_PER_PAGE  # 50
+
+
+@dataclass
+class Character:
+    """A fixed cast member. `appearance` is reused verbatim in image prompts."""
+    name: str
+    appearance: str
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Character":
+        return cls(
+            name=str(d.get("name", "")).strip(),
+            appearance=str(d.get("appearance", "")).strip(),
+        )
+
+
+@dataclass
+class PageSynopsis:
+    page: int
+    synopsis: str
+
+
+@dataclass
+class ComicBible:
+    """The fixed story bible from the gatekeeper/planning call."""
+    approved: bool
+    refusal_reason: str = ""
+    title: str = ""
+    logline: str = ""
+    art_style: str = ""
+    palette: str = ""
+    characters: List[Character] = field(default_factory=list)
+    pages: List[PageSynopsis] = field(default_factory=list)  # length 10 when approved
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "ComicBible":
+        chars = [Character.from_dict(c) for c in (d.get("characters") or [])
+                 if str(c.get("name", "")).strip()]
+        pages = []
+        for i, p in enumerate(d.get("pages") or [], start=1):
+            pages.append(PageSynopsis(
+                page=int(p.get("page", i) or i),
+                synopsis=str(p.get("synopsis", "")).strip(),
+            ))
+        return cls(
+            approved=bool(d.get("approved", False)),
+            refusal_reason=str(d.get("refusal_reason", "")).strip(),
+            title=str(d.get("title", "")).strip() or "Untitled",
+            logline=str(d.get("logline", "")).strip(),
+            art_style=str(d.get("art_style", "")).strip(),
+            palette=str(d.get("palette", "")).strip(),
+            characters=chars,
+            pages=pages,
+        )
+
+    def character(self, name: str) -> Optional[Character]:
+        key = (name or "").strip().lower()
+        for c in self.characters:
+            if c.name.strip().lower() == key:
+                return c
+        return None
+
+
+@dataclass
+class Panel:
+    """One rendered panel. `image` is JPEG/PNG bytes once the artist has run."""
+    page: int
+    panel: int                       # 1 or 2 within the page
+    scene: str                       # purely-visual description -> FLUX
+    caption: str                     # reader text shown under the image
+    characters: List[str] = field(default_factory=list)
+    image_prompt: str = ""           # the assembled FLUX prompt (set by imaging)
+    image: Optional[bytes] = None    # rendered bytes (set by the artist)
+
+    @property
+    def index(self) -> int:
+        """0-based global panel index across the whole comic (0..19)."""
+        return (self.page - 1) * PANELS_PER_PAGE + (self.panel - 1)
+
+    @classmethod
+    def from_dict(cls, d: dict, default_page: int = 1, default_panel: int = 1) -> "Panel":
+        chars = [str(c).strip() for c in (d.get("characters") or []) if str(c).strip()]
+        return cls(
+            page=int(d.get("page", default_page) or default_page),
+            panel=int(d.get("panel", default_panel) or default_panel),
+            scene=str(d.get("scene", "")).strip(),
+            caption=str(d.get("caption", "")).strip(),
+            characters=chars,
+        )
+
+
+@dataclass
+class Comic:
+    """The finished comic: bible + the 20 panels in reading order."""
+    bible: ComicBible
+    panels: List[Panel] = field(default_factory=list)
+
+    @property
+    def title(self) -> str:
+        return self.bible.title
+
+    def page_panels(self, page: int) -> List[Panel]:
+        """The (up to two) panels on a given 1-based page, in order."""
+        ps = [p for p in self.panels if p.page == page]
+        return sorted(ps, key=lambda p: p.panel)