promote hybrid: 8B map + 30B read + split build (VRAM) + FLUX preload + CUDA cache

arcana/build.py

@@ -101,11 +101,13 @@ def _back_prompt(style_suffix: str) -> str:
 
 
 # ------------------------------------------------------------------ build
-def build_deck(theme: str, visual_style: str = "rider-waite-smith",
-               custom_style: str | None = None,
-               progress: Progress | None = None) -> dict:
-    """Design + paint a full deck. Writes image files under decks/<deck_id>/ and
-    returns the in-memory deck dict (NOT yet saved — call save_deck to persist)."""
+def design_phase(theme: str, visual_style: str = "rider-waite-smith",
+                 custom_style: str | None = None,
+                 progress: Progress | None = None) -> dict:
+    """LLM phase ONLY (the 30B mapping + loremaster). Returns a deck dict with
+    concepts + meanings but NO images yet. Split out so it can run in its own
+    @spaces.GPU call — the 30B and the FLUX image model are too big to share the
+    48GB GPU, so we never load them together."""
     def emit(msg, frac):
         if progress:
             progress(msg, frac)
@@ -113,43 +115,53 @@ def build_deck(theme: str, visual_style: str = "rider-waite-smith",
     theme = (theme or "").strip()
     style_id, style_suffix = resolve_style(visual_style, custom_style)
     deck_id = f"{slugify(theme)}-{style_id}-{int(time.time())}"
-    out_dir = deck_dir(deck_id)
-    os.makedirs(out_dir, exist_ok=True)
+    os.makedirs(deck_dir(deck_id), exist_ok=True)
     seed_base = _seed_base(theme, style_id)
 
     llm = get_llm()
-    emit("Consulting the deck designer…", 0.02)
+    emit("Consulting the deck designer…", 0.05)
     deck = design_deck(theme, llm=llm)
-    emit("The loremaster reinterprets the cards…", 0.05)
-    try:
-        deck = refine_deck(deck, llm=llm)
-    except Exception:
-        pass  # keep the designer's draft meanings if refinement hiccups
+    if os.environ.get("SKIP_LOREMASTER", "").lower() not in ("1", "true", "yes"):
+        emit("The loremaster reinterprets the cards…", 0.10)
+        try:
+            deck = refine_deck(deck, llm=llm)
+        except Exception:
+            pass  # keep the designer's draft meanings if refinement hiccups
 
     deck.update({
-        "deck_id": deck_id,
-        "theme": theme,
-        "visual_style": style_id,
-        "style_suffix": style_suffix,
-        "seed_base": seed_base,
+        "deck_id": deck_id, "theme": theme, "visual_style": style_id,
+        "style_suffix": style_suffix, "seed_base": seed_base,
     })
+    return deck
+
+
+def paint_phase(deck: dict, progress: Progress | None = None) -> dict:
+    """Image phase ONLY (FLUX). Paints the back + 22 cards into the deck dir and
+    fills in the image paths. Runs in its own @spaces.GPU call (see design_phase)."""
+    def emit(msg, frac):
+        if progress:
+            progress(msg, frac)
 
-    ig = get_imagegen(deck_style=style_suffix)
+    deck_id = deck["deck_id"]
+    out_dir = deck_dir(deck_id)
+    os.makedirs(out_dir, exist_ok=True)
+    seed_base = deck["seed_base"]
+    ig = get_imagegen(deck_style=deck.get("style_suffix"))
 
-    emit("Pressing the deck-back…", 0.08)
+    emit("Pressing the deck-back…", 0.15)
     back_path = os.path.join(out_dir, "back.png")
     try:
-        back = ig.generate(_back_prompt(style_suffix), seed=seed_base - 1)
+        back = ig.generate(_back_prompt(deck.get("style_suffix") or ""), seed=seed_base - 1)
         back.save(back_path)
         deck["back_path"] = os.path.relpath(back_path, ROOT)
-        deck["back_disp"] = save_display(back, deck_id, "back")  # light WEBP for the flip
+        deck["back_disp"] = save_display(back, deck_id, "back")
     except Exception:
         deck["back_path"] = deck["back_disp"] = None
 
     n = len(deck["cards"])
     for i, c in enumerate(deck["cards"]):
         num = c["arcana_number"]
-        emit(f"Painting {c['concept']}…", 0.10 + 0.88 * i / n)
+        emit(f"Painting {c['concept']}…", 0.18 + 0.80 * i / n)
         seed = seed_base + num
         art = ig.generate(c["art_prompt"], seed=seed)
         card = compose_card(art, c["concept"], ROMAN_BY_NUMBER[num])
@@ -158,13 +170,21 @@ def build_deck(theme: str, visual_style: str = "rider-waite-smith",
         card.save(path)
         c["seed"] = seed
         c["art_path"] = os.path.relpath(path, ROOT)
-        c["disp_path"] = save_display(card, deck_id, base)  # small WEBP (grid)
-        c["full_path"] = save_full(card, deck_id, base)     # capped WEBP (on click)
+        c["disp_path"] = save_display(card, deck_id, base)
+        c["full_path"] = save_full(card, deck_id, base)
 
     emit("The deck is ready.", 1.0)
     return deck
 
 
+def build_deck(theme: str, visual_style: str = "rider-waite-smith",
+               custom_style: str | None = None,
+               progress: Progress | None = None) -> dict:
+    """Convenience: design + paint in one go (used off-Space / non-split callers)."""
+    deck = design_phase(theme, visual_style, custom_style, progress=progress)
+    return paint_phase(deck, progress=progress)
+
+
 # ------------------------------------------------------------------ persistence
 def save_deck(deck: dict) -> str:
     """Write deck.json into the deck's dir, registering it as a saved deck (§12)."""