Afta documentation

afta-owl/
  weights.json
  scripts/generate.py
  images/
    Background/   void.png  dusk.png  circuit.png  nebula.png  ice.png
    Body/         obsidian.png  chrome.png  voidPurple.png  sentinelCyan.png  rustPlate.png
    Eyes/         None.png  violetCore.png  cyanCore.png  goldCore.png
    ChestMark/    None.png  letterA.png  circuitA.png  crackedA.png
    Wings/        None.png  folded.png  spreadViolet.png  spreadCyan.png
  output/         (created by the script: 1.png, 2.png, … metadata.json)

{
  "layerOrder": ["Background", "Wings", "Body", "Eyes", "ChestMark"],
  "weights": {
    "Background": {
      "void": 2800, "dusk": 2200, "circuit": 2000, "nebula": 1800, "ice": 1200
    },
    "Body": {
      "obsidian": 3400, "chrome": 2400, "voidPurple": 2000,
      "sentinelCyan": 1400, "rustPlate": 800
    },
    "Wings": {
      "None": 6200, "folded": 2000, "spreadViolet": 1200, "spreadCyan": 600
    },
    "Eyes": {
      "None": 5000, "violetCore": 2200, "cyanCore": 1800, "goldCore": 1000
    },
    "ChestMark": {
      "None": 4500, "letterA": 3000, "circuitA": 1600, "crackedA": 900
    }
  }
}

#!/usr/bin/env python3
"""Stack Afta owl layers into unique tokens. Token ids start at 1."""
from __future__ import annotations
import argparse, json, random
from pathlib import Path
import numpy as np
from PIL import Image, ImageChops, ImageFilter

ROOT = Path(__file__).resolve().parents[1]
IMAGES, OUT = ROOT / "images", ROOT / "output"
W = json.loads((ROOT / "weights.json").read_text())
ORDER = W["layerOrder"]

def pick(folder: str) -> str:
    names, counts = zip(*W["weights"][folder].items())
    return random.choices(names, weights=counts, k=1)[0]

def combo() -> dict[str, str]:
    return {folder: pick(folder) for folder in ORDER}

def load(folder: str, name: str, cache: dict) -> Image.Image:
    path = IMAGES / folder / f"{name}.png"
    if path not in cache:
        im = Image.open(path).convert("RGBA")
        a = np.array(im)
        r, g, b = a[:, :, 0].astype(np.int16), a[:, :, 1].astype(np.int16), a[:, :, 2].astype(np.int16)
        # True screen green only. Keep cyan / violet glow (high B).
        screen = (g > 100) & (g > r + 30) & (g > b + 30) & (r < 110)
        a[screen, 3] = 0
        cache[path] = Image.fromarray(a, "RGBA")
    return cache[path]

def clip_to_body(overlay: Image.Image, body: Image.Image) -> Image.Image:
    mask = body.split()[-1].point(lambda p: 255 if p > 40 else 0)
    mask = mask.filter(ImageFilter.MaxFilter(7))
    out = overlay.copy()
    out.putalpha(ImageChops.multiply(out.split()[-1], mask))
    return out

def composite(c: dict[str, str], cache: dict) -> Image.Image:
    body = load("Body", c["Body"], cache)
    canvas = None
    for folder in ORDER:
        layer = load(folder, c[folder], cache)
        if folder in ("Eyes", "ChestMark") and c[folder] != "None":
            layer = clip_to_body(layer, body)
        if canvas is None:
            canvas = layer.copy()
        else:
            canvas.alpha_composite(layer)
    return canvas

def main() -> None:
    p = argparse.ArgumentParser()
    p.add_argument("--count", type=int, default=24)
    p.add_argument("--seed", type=int, default=1)
    args = p.parse_args()
    random.seed(args.seed)
    OUT.mkdir(exist_ok=True)
    cache, seen, meta = {}, set(), []
    n, token, tries = 0, 1, 0
    while n < args.count and tries < args.count * 40:
        tries += 1
        c = combo()
        k = tuple(c[f] for f in ORDER)
        if k in seen:
            continue
        seen.add(k)
        composite(c, cache).convert("RGB").save(OUT / f"{token}.png", quality=95)
        meta.append({"tokenId": token, "attributes": c})
        print(token, " ".join(f"{f}={c[f]}" for f in ORDER))
        token += 1
        n += 1
    (OUT / "metadata.json").write_text(json.dumps(meta, indent=2))
    print("unique", n, "ids 1 to", token - 1)

if __name__ == "__main__":
    main()

cd afta-owl
python3 scripts/generate.py --count 12 --seed 42
# open output/1.png … 12.png and check stacking
python3 scripts/generate.py --count 1200 --seed 7

You are helping me build a generative NFT collection for afta.cash called Afta Owl.

LOCK
- One character: the Afta Cash owl — dark plate armour, tufted ear-plates, hooked beak, glowing circuit lines, a capital A on the chest.
- One pose forever: ¾ standing, head slightly turned, full body in frame. Never sit, never crop to a bust unless I ask.
- Canvas 1600×1600, flat green #00FF00 background, thick readable shapes, cel-shaded or clean hard-surface (match the attached master).
- Paint ON this drawing. Use image_edit from the master. Do not start a new owl from a text prompt.

MAKE THESE PNGS (same pose, green bg)
1) Master body palettes (folder Body): obsidian, chrome, voidPurple (violet glow), sentinelCyan (cyan glow), rustPlate.
2) Eyes only overlays (folder Eyes): violetCore, cyanCore, goldCore — only the eye discs change, sockets stay put.
3) Chest mark overlays (folder ChestMark): letterA, circuitA, crackedA — the A sits on the same breastplate as the master.
4) Optional wing overlays (folder Wings): folded, spreadViolet, spreadCyan — wings must attach to the shoulder plates. If they float, bake them into a Body file instead of an overlay.
5) Studio backgrounds (folder Background): void (near-black), dusk (purple-orange), circuit (grid), nebula, ice. Full canvas, no owl.

RULES
- Same silhouette and camera on every body.
- Do not add extra limbs, hats that clip the ears, or text except the chest A.
- Keep teal/violet emissive glow; do not chroma-key it as green.
- After each batch, tell me which files to save as images/<Folder>/<name>.png.
- Then help me write weights.json (weights sum 10,000 per folder) and run a Python compositor that outputs 1.png…N.png + metadata.json for Afta Create → Generative.

First: restyle the attached master into Body/obsidian.png on green. Show me. Wait for my OK before the next palette.

# Crypto / ICP
GET /api/prices?include=crypto&symbols=ICP,BTC,ETH

# DAB bags
GET /api/prices?include=dab&bags=<bag1>,<bag2>

# Marketplace listings sample
GET /api/prices?include=marketplace&limit=48

# One XFT listing context
GET /api/prices?xft_contract=<p>&xft_id=12

# Convert e8s
GET /api/prices?convert=usd_to_icp&amount_e8s=100000000
GET /api/prices?convert=icp_to_usd&amount_e8s=100000000

# Everything (heavier)
GET /api/prices?include=all