primocode 10.16.0 → 10.17.0

package/editor/helpers/motion/templates/selo_garantia.py

@@ -0,0 +1,150 @@
+"""selo_garantia: o selo redondo de garantia, com serrilha, fita e o prazo em dias.
+
+O selo entra girando e crescendo, a fita cai atrás e o número do prazo dá um pulinho. Serve para a
+parte da garantia: "são 7 dias", "30 dias para testar", "garantia de 1 ano".
+
+Tempo: `delay` até o selo entrar; o número pulsa logo depois.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from functools import lru_cache
+
+from motion import engine as E
+
+TEMPLATE = {
+    "id": "selo_garantia",
+    "label_pt": "Selo de garantia",
+    "description_pt": "Selo redondo com serrilha e fita, com o prazo em dias no meio e uma linha embaixo. "
+                      "Entra girando e o número dá um pulinho.",
+    "use_when_pt": "Quando a fala fala de garantia, prazo para testar ou devolução: 7 dias, 30 dias, "
+                   "risco zero.",
+    "notes_pt": "O número é o que aparece grande: deixe a palavra em `unidade` curta (dias, meses).",
+    "category": "enfase",
+    "version": 1,
+    "params": {
+        "numero": {"type": "text", "default": "7", "max_len": 4, "required_text": True,
+                   "label_pt": "O número do prazo (até 4 caracteres)"},
+        "unidade": {"type": "text", "default": "dias", "max_len": 10,
+                    "label_pt": "A unidade embaixo do número (dias, meses...)"},
+        "titulo": {"type": "text", "default": "GARANTIA", "max_len": 16,
+                   "label_pt": "Palavra em cima do número, dentro do selo"},
+        "legenda": {"type": "text", "default": "", "max_len": 34,
+                    "label_pt": "Linha embaixo do selo (opcional). *Palavra* entre asteriscos fica na cor de destaque"},
+        "delay": {"type": "number", "default": 0.15, "min": 0, "max": 30,
+                  "label_pt": "Segundos até o selo entrar"},
+        "fita": {"type": "bool", "default": True, "label_pt": "Fitas atrás do selo"},
+    },
+    "default_duration": 2.4,
+    "default_region": "centro",
+    "sfx": [{"at": 0.15, "name": "pop"}, {"at": 0.55, "name": "success", "volume": 0.8}],
+    "example": {"numero": "30", "unidade": "dias", "titulo": "GARANTIA", "legenda": "para testar *sem risco*"},
+}
+
+NUM_FONT = "sans_black"
+TXT_FONT = "text_bold"
+ENTRA = 0.42           # entrada do selo (gira e cresce)
+PULO = 0.30            # pulinho do número
+PONTAS = 18            # dentes da serrilha
+PRE = 0.16             # o selo começa a crescer um pouco antes, para o quadro 0 nunca sair vazio
+
+
+@lru_cache(maxsize=64)
+def _layout(params_json: str, box: E.Box) -> dict:
+    p = json.loads(params_json)
+    legenda = p["legenda"].strip()
+    plain = " ".join(w for w, _ in E.parse_accent(legenda)) if legenda else ""
+    leg_size = leg_cap = 0.0
+    if legenda:
+        leg_size = E.fit_text(plain, TXT_FONT, box.w * 0.9, 52.0, 22.0)
+        leg_cap = E.measure("H", TXT_FONT, leg_size).cap
+    espaco = box.h - (leg_cap * 2.2 if legenda else 0.0)
+    r = max(90.0, min(box.w * 0.42, espaco * 0.42))
+    num_size = E.fit_text(p["numero"], NUM_FONT, r * 1.25, r * 1.12, 40.0)
+    uni_size = min(r * 0.30, E.fit_text(p["unidade"], TXT_FONT, r * 1.3, r * 0.30, 16.0))
+    tit_size = min(r * 0.24, E.fit_text(p["titulo"], TXT_FONT, r * 1.3, r * 0.24, 14.0))
+    cy = box.cy - (leg_cap * 1.1 if legenda else 0.0)
+    return {"r": r, "cx": box.cx, "cy": cy, "num_size": num_size, "uni_size": uni_size,
+            "tit_size": tit_size, "leg_size": leg_size, "leg_cap": leg_cap, "legenda": legenda,
+            "num_cap": E.measure("H", NUM_FONT, num_size).cap}
+
+
+def _serrilha(cx: float, cy: float, r: float) -> list[tuple[float, float]]:
+    """Contorno do selo: dentes suaves em volta do círculo."""
+    pts = []
+    passos = PONTAS * 6
+    for i in range(passos):
+        a = 2 * math.pi * i / passos
+        raio = r * (1.0 + 0.055 * math.cos(PONTAS * a))
+        pts.append((cx + raio * math.cos(a), cy + raio * math.sin(a)))
+    return pts
+
+
+def render(frame_index: int, fps: int, params: dict, box: E.Box) -> E.Canvas:
+    cv = E.Canvas(box)
+    t = frame_index / fps + 1.0 / fps
+    L = _layout(json.dumps(params, sort_keys=True), box)
+    inicio = max(0.0, float(params["delay"]) - PRE)
+    if t < inicio:
+        return cv
+    ent = E.eased(t, inicio, ENTRA + PRE, "out_back")
+    if ent <= 0:
+        return cv
+    opac = min(1.0, E.eased(t, inicio, (ENTRA + PRE) * 0.5, "out_quad") * 1.4)
+    giro = -26.0 * (1.0 - E.clamp01(ent))
+    cx, cy, r = L["cx"], L["cy"], L["r"]
+    with cv.group(opacity=opac, scale=0.35 + 0.65 * min(1.15, ent), pivot=(cx, cy), rotate=giro):
+        if params["fita"]:
+            larg = r * 0.42
+            for lado in (-1, 1):
+                x0 = cx + lado * r * 0.36
+                pts = [(x0 - larg / 2, cy + r * 0.2), (x0 + larg / 2, cy + r * 0.2),
+                       (x0 + larg / 2 + lado * r * 0.14, cy + r * 1.25),
+                       (x0 + lado * r * 0.07, cy + r * 1.0),
+                       (x0 - larg / 2 + lado * r * 0.14, cy + r * 1.25)]
+                cv.polygon(pts, fill="danger", shadow=E.Shadow(blur=12.0, dy=6.0, opacity=0.35))
+        cv.polygon(_serrilha(cx, cy, r), fill="accent",
+                   shadow=E.Shadow(blur=16.0, dy=8.0, opacity=0.4))
+        cv.ring(cx, cy, r * 0.86, max(3.0, r * 0.035), color="on_accent", opacity=0.55)
+        cv.text(cx, cy - r * 0.34, params["titulo"], TXT_FONT, L["tit_size"], color="on_accent",
+                anchor="mc", opacity=0.9, upper=True)
+        bate = inicio + (ENTRA + PRE) * 0.7
+        pulo = 1.0 + 0.10 * (1.0 - E.clamp01((t - bate) / PULO)) if bate <= t < bate + PULO else 1.0
+        with cv.group(scale=pulo, pivot=(cx, cy + r * 0.05)):
+            cv.text(cx, cy + L["num_cap"] * 0.5 + r * 0.02, params["numero"], NUM_FONT, L["num_size"],
+                    color="on_accent", anchor="ms")
+        cv.text(cx, cy + r * 0.56, params["unidade"], TXT_FONT, L["uni_size"], color="on_accent",
+                anchor="mc", opacity=0.95)
+    if L["legenda"]:
+        la = E.eased(t, inicio + (ENTRA + PRE) * 0.6, 0.3, "out_cubic")
+        if la > 0:
+            y = cy + r * 1.35 + L["leg_cap"]
+            palavras = E.parse_accent(L["legenda"])
+            larguras = [E.measure(w, TXT_FONT, L["leg_size"]).width for w, _ in palavras]
+            espaco = (E.measure("a a", TXT_FONT, L["leg_size"]).width
+                      - E.measure("aa", TXT_FONT, L["leg_size"]).width)
+            total = sum(larguras) + espaco * max(0, len(palavras) - 1)
+            x = cx - total / 2.0
+            for (palavra, destaque), larg in zip(palavras, larguras):
+                cor = "accent" if destaque else "text"
+                cv.text(x, y + (1.0 - la) * 12.0, palavra, TXT_FONT, L["leg_size"], color=cor,
+                        opacity=la, anchor="ls", stroke=3.0, stroke_color=(0, 0, 0, 140))
+                x += larg + espaco
+    return cv
+
+
+def sfx(params: dict, fps: int, frames: int) -> list[dict]:
+    d = float(params["delay"])
+    return [{"frame": E.frame_of(d, fps), "name": "pop", "why": "entrada do selo"},
+            {"frame": E.frame_of(d + ENTRA * 0.7, fps), "name": "success", "volume": 0.8,
+             "why": "o prazo aparece"}]
+
+
+def settle(params: dict, fps: int) -> float:
+    return float(params["delay"]) + ENTRA + PULO + 0.05
+
+
+def suggested_duration(params: dict) -> float:
+    return round(max(TEMPLATE["default_duration"], float(params["delay"]) + ENTRA + PULO + 1.2), 2)

package/editor/helpers/motion_render.py

@@ -0,0 +1,241 @@
+"""Renders one animated template (helpers/motion) to check it: transparent .mov, PNG frames, an .mp4 over a
+background and a contact sheet. The compose uses the same renderer (SPEC Contract 12).
+
+Usage:
+    uv run python helpers/motion_render.py --list [--json]
+    uv run python helpers/motion_render.py --describe contador
+    uv run python helpers/motion_render.py --template contador --params '{"value": 1904152.87, "prefix": "R$"}' \\
+        --out DIR [--formato mov,sheet,mp4,png,clip] [--duracao 3] [--fps 30] [--tamanho 1080x1920] \\
+        [--cor '#FFC400'] [--regiao centro | --regiao 140,640,800,640] [--fundo frame.png] [--quadros 8]
+    --params-file F  reads the params from a JSON file (easier with R$ and quotes).
+
+The last stdout line is a JSON object with the files, the frames and the sound cues.
+Exit 2 for things to fix (unknown template, bad params), 1 for ffmpeg or disk trouble.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from motion import engine as E  # noqa: E402
+from motion import registry as Rg  # noqa: E402
+from motion import render as R  # noqa: E402
+from motion.engine import MotionError  # noqa: E402
+
+FORMATS = ("mov", "sheet", "mp4", "png", "clip")
+
+
+def _utf8() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+        except (AttributeError, ValueError):
+            pass
+
+
+def parse_size(text: str) -> tuple[int, int]:
+    try:
+        w, h = (int(v) for v in str(text).lower().split("x"))
+    except ValueError:
+        raise MotionError(f"--tamanho inválido: {text!r} (ex.: 1080x1920)") from None
+    if w < 16 or h < 16 or w > 4096 or h > 4096:
+        raise MotionError(f"--tamanho fora do limite: {text!r}")
+    return w, h
+
+
+def parse_region(text: str | None):
+    if text is None:
+        return None
+    t = text.strip()
+    if "," in t:
+        parts = t.replace("[", "").replace("]", "").split(",")
+        try:
+            return [float(v) for v in parts]
+        except ValueError:
+            raise MotionError(f"--regiao inválida: {text!r} (use um nome ou x,y,largura,altura)") from None
+    return t
+
+
+def load_params(args) -> dict:
+    if args.params and args.params_file:
+        raise MotionError("use --params ou --params-file, não os dois")
+    raw = None
+    if args.params_file:
+        p = Path(args.params_file)
+        if not p.exists():
+            raise MotionError(f"arquivo de params não encontrado: {p}")
+        raw = p.read_text(encoding="utf-8")
+    elif args.params:
+        raw = args.params
+    if raw is None:
+        return {}
+    try:
+        data = json.loads(raw)
+    except ValueError as e:
+        raise MotionError(f"params não é um JSON válido ({e}). Dica: use --params-file com o JSON num arquivo") from None
+    if not isinstance(data, dict):
+        raise MotionError("params precisa ser um objeto JSON, ex.: {\"value\": 37}")
+    return data
+
+
+def cmd_list(as_json: bool) -> int:
+    found, errs = Rg.discover()
+    if as_json:
+        print(json.dumps({"templates": [t.describe() for t in found.values()], "errors": errs}, ensure_ascii=False))
+        return 0
+    if not found:
+        print("nenhum modelo de animação encontrado")
+    for t in sorted(found.values(), key=lambda x: x.id):
+        print(f"{t.id:18s} {t.label} · {t.default_duration:g} s · {t.description}")
+    for e in errs:
+        print(f"aviso: {e}", file=sys.stderr)
+    return 0
+
+
+def _limits(spec: dict) -> list[str]:
+    extra = []
+    if "choices" in spec:
+        extra.append("opções: " + ", ".join(map(str, spec["choices"])))
+    if "min" in spec or "max" in spec:
+        lo = E.format_number(spec["min"], E.auto_decimals(spec["min"])) if "min" in spec else "-"
+        hi = E.format_number(spec["max"], E.auto_decimals(spec["max"])) if "max" in spec else "-"
+        extra.append(f"de {lo} a {hi}")
+    if "max_len" in spec:
+        extra.append(f"até {spec['max_len']} letras")
+    if "min_items" in spec or "max_items" in spec:
+        extra.append(f"de {spec.get('min_items', 0)} a {spec.get('max_items', '?')} itens")
+    if spec.get("nullable"):
+        extra.append("pode ser null")
+    return extra
+
+
+def cmd_describe(tid: str) -> int:
+    t = Rg.get(tid)
+    print(f"{t.id}: {t.label}")
+    print(t.description)
+    if t.use_when:
+        print(f"Quando usar: {t.use_when}")
+    if t.notes:
+        print(f"Atenção: {t.notes}")
+    region = t.default_region if isinstance(t.default_region, str) else list(t.default_region)
+    print(f"Duração padrão: {t.default_duration:g} s · região padrão: {region} · saída: {t.exit}")
+    print("Parâmetros:")
+    for name, spec in t.all_params().items():
+        extra = _limits(spec)
+        default = json.dumps(spec["default"], ensure_ascii=False) if "default" in spec else "obrigatório"
+        print(f"  {name} ({spec['type']}, padrão {default}){' · ' + '; '.join(extra) if extra else ''}: "
+              f"{spec.get('label_pt', '')}")
+        if spec.get("type") == "list" and isinstance(spec.get("item"), dict):
+            item = spec["item"]
+            if item.get("type") == "object":
+                for fname, fspec in (item.get("fields") or {}).items():
+                    fextra = _limits(fspec)
+                    fdefault = (json.dumps(fspec["default"], ensure_ascii=False) if "default" in fspec
+                                else "obrigatório")
+                    print(f"    cada item.{fname} ({fspec['type']}, padrão {fdefault})"
+                          f"{' · ' + '; '.join(fextra) if fextra else ''}: {fspec.get('label_pt', '')}")
+            else:
+                iextra = _limits(item)
+                if iextra:
+                    print(f"    cada item ({item['type']}): {'; '.join(iextra)}")
+    print("Sons: " + (", ".join(f"{c['name']} em {c.get('at', 0):g} s" for c in t.sfx) or "nenhum"))
+    if t.example:
+        print("Exemplo de params: " + json.dumps(t.example, ensure_ascii=False))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    _utf8()
+    ap = argparse.ArgumentParser(description="Renderiza um modelo de animação (contador, lista, preço...) para conferir.")
+    ap.add_argument("--list", action="store_true", help="lista os modelos disponíveis")
+    ap.add_argument("--json", action="store_true", help="com --list: saída em JSON")
+    ap.add_argument("--describe", metavar="ID", help="mostra os parâmetros de um modelo")
+    ap.add_argument("--template", "-t", help="id do modelo (veja --list)")
+    ap.add_argument("--params", help="parâmetros em JSON, ex.: '{\"value\": 37}'")
+    ap.add_argument("--params-file", help="arquivo .json com os parâmetros")
+    ap.add_argument("--out", "-o", help="pasta de saída")
+    ap.add_argument("--formato", default="mov,sheet",
+                    help=f"o que gerar, separado por vírgula: {', '.join(FORMATS)} (padrão mov,sheet)")
+    ap.add_argument("--duracao", type=float, help="segundos na tela (padrão: o do modelo)")
+    ap.add_argument("--fps", type=int, default=30)
+    ap.add_argument("--tamanho", default="1080x1920", help="tamanho da tela, ex.: 1080x1920 ou 540x960")
+    ap.add_argument("--cor", default=E.DEFAULT_ACCENT, help="cor de destaque do vídeo (#RRGGBB)")
+    ap.add_argument("--regiao", help="nome (topo, centro, baixo, faixa_topo, tela) ou x,y,largura,altura em 1080x1920")
+    ap.add_argument("--fundo", help="imagem de fundo para a folha e o .mp4 (ex.: um quadro do corte)")
+    ap.add_argument("--quadros", type=int, default=8, help="quadros na folha (padrão 8)")
+    ap.add_argument("--nome", help="nome base dos arquivos (padrão: o id do modelo)")
+    args = ap.parse_args(argv)
+
+    try:
+        if args.list:
+            return cmd_list(args.json)
+        if args.describe:
+            return cmd_describe(args.describe)
+        if not args.template:
+            raise MotionError("diga o modelo com --template (veja --list)")
+        if not args.out:
+            raise MotionError("diga a pasta de saída com --out")
+        formats = [f.strip() for f in args.formato.split(",") if f.strip()]
+        bad = [f for f in formats if f not in FORMATS]
+        if bad or not formats:
+            raise MotionError(f"--formato inválido: {', '.join(bad) or '(vazio)'} (use {', '.join(FORMATS)})")
+        E.rgba(args.cor)
+        if args.quadros < 1 or args.quadros > 48:
+            raise MotionError("--quadros precisa ficar entre 1 e 48")
+        if args.nome is not None and (not args.nome.strip() or any(c in args.nome for c in '/\\:*?"<>|')):
+            raise MotionError("--nome precisa ser um nome de arquivo simples, sem barras")
+        params = load_params(args)
+        t0 = time.time()
+        item = R.plan_item(args.template, params, fps=args.fps, canvas=parse_size(args.tamanho),
+                           region=parse_region(args.regiao), duration=args.duracao, accent=args.cor)
+        out = Path(args.out).expanduser().resolve()
+        out.mkdir(parents=True, exist_ok=True)
+        base = args.nome or item.template.id
+        result: dict = {"template": item.template.id, "frames": item.frames, "fps": item.fps,
+                        "duration": round(item.frames / item.fps, 4), "canvas": list(item.canvas),
+                        "region": [round(v, 2) for v in item.region], "params": item.params,
+                        "sfx": R.sfx_cues(item, check_names=True), "files": {}}
+        print(f"{item.template.label}: {item.frames} quadros ({E.format_number(item.frames / item.fps, 2)} s) "
+              f"em {item.canvas[0]}x{item.canvas[1]}")
+        if "mov" in formats:
+            result["files"]["mov"] = str(R.write_mov(item, out / f"{base}.mov"))
+        if "clip" in formats:
+            clip = R.render_clip(item, out, cache=False)
+            result["files"]["clip"] = clip["file"]
+            result["clip"] = {k: clip[k] for k in ("x", "y", "w", "h", "ink")}
+        if "png" in formats:
+            pngs = R.write_pngs(item, out / f"{base}_quadros")
+            result["files"]["png"] = str(out / f"{base}_quadros")
+            result["png_count"] = len(pngs)
+        if "mp4" in formats:
+            result["files"]["mp4"] = str(R.write_mp4(item, out / f"{base}.mp4", args.fundo))
+        if "sheet" in formats:
+            result["files"]["sheet"] = str(R.contact_sheet(item, out / f"{base}_folha.png", args.quadros, args.fundo))
+        result["seconds"] = round(time.time() - t0, 2)
+        for kind, path in result["files"].items():
+            print(f"ok    {kind}: {path}")
+        sounds = ", ".join(f"{c['name']} no quadro {c['frame']}" for c in result["sfx"]) or "nenhum"
+        print(f"sons sugeridos: {sounds}")
+        for w in item.warnings:
+            print(f"aviso: {w}")
+        print(f"pronto em {result['seconds']:.1f} s")
+        print(json.dumps(result, ensure_ascii=False))
+        return 0
+    except MotionError as e:
+        print(f"erro: {e}", file=sys.stderr)
+        return e.code
+    except KeyboardInterrupt:
+        print("interrompido", file=sys.stderr)
+        return 130
+    except OSError as e:
+        print(f"erro: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())