Effetto in regalo · Per imprenditrici, coach e consulenti
Tieni chi guarda per tre secondi fino alla fine.

Nomini una cosa e la sua carta compare sopra la tua testa, poi dai il tuo giudizio e lei vola nella colonna giusta con la spunta o con la croce, così chi guarda resta lì per scoprire come va a finire. Te la regalo insieme al prompt che la fa mettere a Claude sul tuo video, senza programmi di montaggio.
Fa bene e fa maleMigliore e peggioreClaude Pro o MaxMac e Windows
Prendi il prompt
Ti serve Claude a pagamento, con un piano Pro o Max, lo stesso che ti dà Claude Cowork e Claude Code.
In regalo
fatto con il prompt qui sotto
Fa bene o fa male✦Il migliore e il peggiore✦Promosso o bocciato✦Top o flop✦ Fa bene o fa male✦Il migliore e il peggiore✦Promosso o bocciato✦Top o flop✦
In quattro passi
Come si usa

Ti serve Claude a pagamento, con un piano Pro o Max, lo stesso che ti dà Claude Cowork e Claude Code, perché nel piano gratuito la scheda Code non c'è. Poi ti basta l'app Claude sul tuo Mac o sul tuo PC.
Gira il video

Lo giri in verticale, con il viso al centro e parecchio spazio sopra la testa, e per ogni cosa dici prima il nome e subito dopo il tuo giudizio.
Prepara la cartella

Nella cartella Documenti ne crei una che si chiama classifica e ci metti il video, insieme alle foto delle cose che giudichi se le hai, altrimenti Claude fa delle carte con il nome scritto.
Incolla il prompt

Apri l'app Claude, vai nella scheda Code, scegli la cartella classifica e incolli il prompt. Quando Claude ti chiede il permesso clicca per consentire, e la prima volta aspetta qualche minuto mentre prepara i suoi strumenti.
Conferma la classifica

Claude ti mostra la classifica che ha capito dal tuo video, tu confermi e dopo qualche minuto trovi il video finito nella stessa cartella. Ascoltalo prima di pubblicarlo, perché Claude non sente l'audio e gli effetti sonori li controlli tu.
Posso cambiare i titoli delle colonne?
Sì, oltre a Fa bene e Fa male puoi usare Migliore e Peggiore, Sì e No, Top e Flop oppure la coppia che preferisci, ti basta dirlo a Claude.
Devo avere le foto?
No, se non le hai Claude prepara delle carte con il nome scritto e funzionano bene lo stesso.
E se voglio cambiare qualcosa?
Lo scrivi a Claude con le tue parole, per esempio fai comparire la seconda carta un secondo più tardi, usa i colori del mio brand, togli i suoni oppure tieni la classifica fino alla fine del video.
Il tuo regalo
Copia il prompt e incollalo in Claude

Clicca il pulsante e il prompt è pronto da incollare tutto intero, dalla prima all'ultima riga.
Voglio aggiungere al mio reel una sola grafica animata, la classifica a due colonne. Mentre nomino una cosa, la sua carta compare sopra la mia testa, e quando do il giudizio vola nella colonna giusta con una spunta o una croce. Le colonne possono essere Fa bene e Fa male, oppure Migliore e Peggiore, oppure altri due titoli. Il resto del video resta com'è, quindi niente tagli, niente sottotitoli, niente musica e nessun'altra grafica. Alla grafica si aggiungono solo i suoi tre effetti sonori.

COME LAVORI CON ME
- Non so programmare. Parlami in italiano con parole semplici, non mostrarmi codice e non spiegarmi i comandi.
- Se non puoi lanciare comandi su questo computer, dimmi di aprire l'app Claude, andare nella scheda Code, scegliere la cartella del mio video e incollare lì questo messaggio, poi fermati.
- Segui i passi in ordine. Se un passo non riesce usa il piano B scritto in quel passo e vai avanti. Ti fermi solo quando non resta niente da provare, e allora mi dici in una frase cosa è successo e cosa devo fare io.
- Lo script del PASSO 3 è già provato, quindi scrivilo identico e non sostituirlo con uno tuo. Se sul mio computer un comando va adattato, adatta il comando. Se lo script si ferma per un errore, correggi solo la riga sbagliata.
- Installazione, trascrizione e creazione del video possono durare minuti. Lancia questi comandi con un timeout di 10 minuti oppure in background, e dimmi in una riga cosa stai aspettando.
- Il mio video originale non si tocca. Lavora solo nella cartella aperta.

PASSO 1, IL VIDEO
Cerca nella cartella aperta i video (mp4, mov, m4v, webm, avi). Non contare quelli che finiscono con -classifica.mp4 né quelli che hanno già accanto la loro versione -classifica, a meno che io non ti chieda di rifarli.
Se ce n'è uno solo usa quello. Se ce ne sono di più chiedimi quale. Se non ce n'è nessuno chiedimi di mettere il video in questa cartella e aspetta. Se ti dico che non ho ancora girato, chiedimi l'argomento e preparami una scaletta di massimo cinque voci, ognuna con il nome della cosa e subito dopo il giudizio, poi dimmi di girare in verticale, con il viso al centro e parecchio spazio sopra la testa, e di tornare qui con il video.

PASSO 2, GLI STRUMENTI (solo la prima volta)
Se esiste il file .classifica/pronto salta al PASSO 4. Altrimenti installa tutto dentro la cartella .classifica, senza toccare il resto del computer. Non servono password né diritti da amministratore, e servono circa 1 GB di spazio e da due a dieci minuti, a seconda della connessione.

Su Mac, nel terminale, tutto insieme:
mkdir -p .classifica && (cd .classifica && export UV_INSTALL_DIR="$PWD/bin" UV_NO_MODIFY_PATH=1 UV_PYTHON_INSTALL_DIR="$PWD/python" UV_CACHE_DIR="$PWD/cache" && curl -LsSf https://astral.sh/uv/0.13.5/install.sh | sh && bin/uv venv --python 3.12 venv && bin/uv pip install --python venv/bin/python --exclude-newer 2026-10-30T00:00:00Z pillow imageio-ffmpeg && bin/uv pip install --python venv/bin/python --exclude-newer 2026-10-30T00:00:00Z pillow-heif faster-whisper)

Su Windows, in PowerShell, tutto insieme. Se su Windows la tua shell è bash, scrivi queste righe in .classifica/installa.ps1 e lancialo con powershell -NoProfile -ExecutionPolicy Bypass -File:
New-Item -ItemType Directory -Force .classifica | Out-Null; Push-Location .classifica; $env:UV_INSTALL_DIR="$PWD\bin"; $env:UV_NO_MODIFY_PATH="1"; $env:UV_PYTHON_INSTALL_DIR="$PWD\python"; $env:UV_CACHE_DIR="$PWD\cache"; powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://astral.sh/uv/0.13.5/install.ps1 | iex"; bin\uv.exe venv --python 3.12 venv; bin\uv.exe pip install --python venv\Scripts\python.exe --exclude-newer 2026-10-30T00:00:00Z pillow imageio-ffmpeg; bin\uv.exe pip install --python venv\Scripts\python.exe --exclude-newer 2026-10-30T00:00:00Z pillow-heif faster-whisper; Pop-Location

Piano B se uv non si scarica. Usa l'indirizzo senza numero di versione (https://astral.sh/uv/install.sh oppure install.ps1). Se ancora non va usa il Python del computer, creando .classifica/venv con python3 -m venv (su Windows py -3 -m venv) e installando con il suo pip gli stessi quattro pacchetti. Serve Python 3.10 o più recente. Se su Mac compare la richiesta degli strumenti per sviluppatori dimmi di cliccare Installa e aspetta. Se su Windows manca Python usa winget install Python.Python.3.12.
Piano B se falliscono solo pillow-heif o faster-whisper. Vai avanti lo stesso. Senza il primo le foto HEIC diventano carte con il nome, senza il secondo usi il piano B del PASSO 4. Senza pillow o imageio-ffmpeg invece la grafica non parte, quindi riprova almeno una volta.

Da qui in poi PY significa .classifica/venv/bin/python su Mac e .classifica\venv\Scripts\python.exe su Windows.

PASSO 3, LO SCRIPT (solo la prima volta)
Crea il file .classifica/classifica.py con il testo esatto che trovi in fondo a questo messaggio, tra le righe SCRIPT INIZIO e SCRIPT FINE, escluse quelle due righe. Poi lancia:
PY .classifica/classifica.py prova
Quando compare PROVA SUPERATA crea il file vuoto .classifica/pronto e vai avanti. Se compare un errore confronta il file con il testo in fondo, correggi la differenza e riprova, fino a tre volte.

PASSO 4, COSA DICO NEL VIDEO
Lancia, con il nome del video tra virgolette:
PY .classifica/classifica.py trascrivi "video.mp4"
Accanto al video compaiono testo.txt, con le frasi, e parole.txt, con ogni parola e il suo secondo. La prima volta si scaricano circa 500 MB. Se nel video parlo in un'altra lingua aggiungi la parola auto in fondo al comando.
Piano B se la trascrizione non funziona o il video non ha voce. Chiedimi l'elenco delle cose con il loro giudizio e, se li so, i secondi. Se non li so togli i campi appare e vola da tutte le voci, e lo script le distribuisce lungo il video.

PASSO 5, LA CLASSIFICA
Leggi testo.txt e parole.txt e trova ogni cosa che giudico. Per ognuna prepara questi dati.
nome: al massimo tre parole, con la prima lettera maiuscola, corretto dagli errori di trascrizione.
lato: sinistra per il giudizio positivo, destra per il negativo.
appare: il secondo della prima parola del nome, la prima volta che lo dico, preso da parole.txt.
vola: il secondo dell'ultima parola del giudizio su quella cosa, per esempio la parola bene in "fa bene", oppure "evitalo", oppure migliore in "il migliore". Se i giudizi sono due usa il primo. Le frasi generali di apertura non sono giudizi. Se il giudizio arriva prima del nome, oppure manca, usa appare più 1,5.
foto: se nella cartella ci sono immagini (jpg, png, heic, webp), aprile, guardale e abbina quella giusta, aiutandoti con il nome del file. Se non capisci a quale voce appartiene un'immagine non usarla e dimmelo. Una voce senza foto diventa una carta con il nome scritto, e funziona bene lo stesso.
I titoli delle colonne sono due, il positivo sempre per primo, al massimo 12 lettere l'uno. Se te li ho chiesti usa i miei. Altrimenti scegli dal contenuto, cioè Fa bene e Fa male per quello che aiuta o danneggia, Migliore e Peggiore quando confronto delle cose, oppure Sì e No, Top e Flop, Promosso e Bocciato.
Se nel video non si capisce il giudizio di una voce chiedimelo. Se le voci di una colonna sono più di cinque avvisami che le carte vengono piccole.
Ora mostrami la classifica in un elenco corto, con nome, colonna e secondo in cui compare, e chiedimi se va bene.
FERMATI QUI e aspetta la mia risposta. Non andare al PASSO 6 prima che io abbia risposto. È l'unica conferma che ti serve.

PASSO 6, LO SPAZIO SOPRA LA TESTA
Lancia:
PY .classifica/classifica.py fotogrammi "video.mp4"
Apri fotogrammi.jpg, che mostra tre momenti del video con righe gialle numerate. Guarda fin dove arriva la cima della testa nei tre momenti e prendi il punto più alto dei tre, cioè il numero più piccolo, stimando tra una riga e l'altra. Quel numero è cima_testa. Se la testa tocca il bordo alto dell'inquadratura scrivi 0.

PASSO 7, IL VIDEO
Crea classifica.json nella cartella del video, come in questo esempio:
{"video": "video.mp4", "titoli": ["Fa bene", "Fa male"], "cima_testa": 620, "voci": [
  {"nome": "Gancio forte", "lato": "sinistra", "appare": 5.2, "vola": 7.3, "foto": "gancio.jpg"},
  {"nome": "Hashtag a caso", "lato": "destra", "appare": 10.2, "vola": 12.8}
]}
Campi in più, solo se servono. fine: il secondo in cui la classifica sparisce, 9999 per tenerla fino alla fine del video. Senza questo campo resta due secondi dopo l'ultima voce, oppure fino alla fine se dopo l'ultima voce mancano meno di 7 secondi. colore_sinistra, colore_destra, colore_etichetta: colori come "#F80078". suoni: false per togliere gli effetti sonori. y_carta: altezza precisa in cui compare la carta. uscita: nome del video finito. carattere: percorso di un file di carattere ttf.
Poi lancia:
PY .classifica/classifica.py rendi classifica.json
Quando compare FATTO hai il video finito e il foglio controllo.jpg. Il video è un mp4 che si chiama come l'originale con -classifica in fondo, a 1080 per 1920 e 30 fotogrammi al secondo, il formato giusto per Instagram. Lo script corregge da solo i tempi che si accavallano e, se serve, riprova senza conversione dei colori e senza suoni. Le righe che cominciano con NOTA dicono cosa ha dovuto cambiare, tienile a mente per il PASSO 9.

PASSO 8, IL CONTROLLO
Apri controllo.jpg. Le prime immagini mostrano ogni carta nel momento in cui compare, l'ultima la classifica completa. Controlla che la carta non copra il viso, che i nomi si leggano e che ogni voce stia nella colonna giusta. Apri anche tempi-usati.txt e confrontalo con i tempi che hai scritto, perché se lo script ne ha spostato qualcuno io devo saperlo.
Se la carta copre il viso scrivi in cima_testa un numero più piccolo di 80 e rifai il PASSO 7. Se non basta aggiungi y_carta con un numero più piccolo, oppure 1180 per portare la carta sul petto. Se una voce è nella colonna sbagliata correggi il lato. Fai al massimo tre giri, poi consegna e dimmi cosa non ti convince.

PASSO 9, LA CONSEGNA
Dimmi in poche righe dove trovo il video finito e che la classifica contiene le voci che ho approvato. Se le carte sono finite sul petto perché non c'era spazio sopra la testa dimmelo, e spiegami che basta rigirare con più spazio. Dimmi anche ogni altra cosa che lo script ha dovuto cambiare, con parole semplici. Dimmi di ascoltarlo, perché tu non senti l'audio e gli effetti sonori li controllo io. Dimmi che posso chiederti le modifiche a parole mie, per esempio spostare una carta di un secondo, cambiare i titoli, usare i colori del mio brand, togliere i suoni, tenere la classifica fino alla fine. Per ogni modifica cambia classifica.json e rifai i PASSI 7 e 8.
Per il prossimo reel basta mettere il nuovo video in questa stessa cartella e dirtelo in questa chat, oppure incollare questo messaggio in una chat nuova aperta sulla stessa cartella, così gli strumenti sono già pronti.

SCRIPT INIZIO
#!/usr/bin/env python3
# Grafica per reel verticali: classifica a due colonne. La voce compare sopra la testa e vola nella sua colonna.
# Comandi: prova | trascrivi VIDEO [lingua] | fotogrammi VIDEO | rendi classifica.json
import array, json, math, os, random, re, shutil, subprocess, sys, tempfile, wave
from pathlib import Path
from PIL import Image, ImageDraw, ImageFilter, ImageFont, ImageOps

for s_ in (sys.stdout, sys.stderr):
    try: s_.reconfigure(encoding='utf-8', errors='replace')
    except Exception: pass

W, H, FPS = 1080, 1920, 30
X, Y0 = (180, 815), 505                # centro delle due colonne, primo posto
TELA, LATO = 680, 460                  # le carte si disegnano al doppio: tela con il margine, lato della carta
C = TELA // 2
CHIARO, SCURO, VERDE, ROSSO = (253, 241, 239), (42, 12, 35), (33, 179, 97), (235, 56, 61)
CARTELLA = Path(__file__).resolve().parent
os.environ.setdefault('HF_HOME', str(CARTELLA / 'modelli'))
try:          # i file temporanei restano qui dentro e si cancellano appena finito
    (CARTELLA / 'temporanei').mkdir(exist_ok=True); tempfile.tempdir = str(CARTELLA / 'temporanei')
except OSError: pass

def trova_ffmpeg():
    try:
        import imageio_ffmpeg
        return imageio_ffmpeg.get_ffmpeg_exe()
    except Exception:
        p = shutil.which('ffmpeg')
        if p: return p
    sys.exit('ERRORE: manca ffmpeg (pacchetto imageio-ffmpeg non installato)')
FF = trova_ffmpeg()

def lancia(cmd):
    return subprocess.run([str(x) for x in cmd], capture_output=True, text=True, encoding='utf-8', errors='replace')

def info(video):
    e = lancia([FF, '-hide_banner', '-i', video]).stderr
    if 'Video:' not in e: sys.exit('ERRORE: non riesco a leggere il video %s' % video)
    m = re.search(r'Duration: (\d+):(\d+):(\d+(?:\.\d+)?)', e)
    if not m:
        tt = re.findall(r'time=(\d+):(\d+):(\d+(?:\.\d+)?)', lancia([FF, '-hide_banner', '-i', video, '-map', '0:v:0', '-f', 'null', '-']).stderr)
        if not tt: sys.exit('ERRORE: non riesco a capire quanto dura il video')
        g = tt[-1]
    else: g = m.groups()
    return {'durata': int(g[0]) * 3600 + int(g[1]) * 60 + float(g[2]), 'audio': bool(re.search(r'Stream #[^\n]*Audio:', e)), 'hdr': 'arib-std-b67' in e or 'smpte2084' in e}

def catena(inf, hdr=True):
    """dal video di partenza a 1080x1920, 30 fotogrammi al secondo, con i colori normali anche se il telefono ha girato in HDR"""
    f = ''
    if hdr and inf['hdr'] and ' zscale ' in lancia([FF, '-hide_banner', '-filters']).stdout:
        f = 'zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=mobius:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p,'
    return f + 'scale=%d:%d:force_original_aspect_ratio=increase:flags=lanczos,crop=%d:%d,setsar=1,fps=%d' % (W, H, W, H, FPS)

def fotogramma(video, t, filtro, larghezza):
    b = subprocess.run([str(x) for x in (FF, '-v', 'error', '-ss', '%.3f' % t, '-i', video, '-frames:v', '1', '-vf', '%s,scale=%d:-2' % (filtro, larghezza), '-f', 'image2pipe', '-vcodec', 'png', '-')], capture_output=True).stdout
    from io import BytesIO
    return Image.open(BytesIO(b)).convert('RGB') if b else Image.new('RGB', (larghezza, larghezza * H // W), SCURO)

# ---------- caratteri e forme
def scegli_font(scelto=None):
    for p in (scelto, '/System/Library/Fonts/Supplemental/Arial Black.ttf', 'C:/Windows/Fonts/ariblk.ttf', '/System/Library/Fonts/Supplemental/Arial Bold.ttf', '/Library/Fonts/Arial Bold.ttf',
              'C:/Windows/Fonts/arialbd.ttf', 'C:/Windows/Fonts/segoeuib.ttf', '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf'):
        if p and Path(p).exists(): return str(p)
    return None
FONT = scegli_font()
_fonts = {}
def font(z):
    k = (FONT, int(max(8, z)))
    if k not in _fonts: _fonts[k] = ImageFont.truetype(FONT, k[1]) if FONT else ImageFont.load_default(k[1])
    return _fonts[k]

def adatta(s, largo, z, minimo=14):
    while z > minimo and font(z).getlength(s) > largo: z -= 1
    return z

def a_capo(testo, z, largo):
    f = font(z); righe = []; r = ''
    for p in testo.split():
        t = (r + ' ' + p).strip()
        if f.getlength(t) <= largo or not r: r = t
        else: righe.append(r); r = p
    return righe + [r] if r else righe

def tondo(w, h, r, k=3):
    m = Image.new('L', (w * k, h * k), 0)
    ImageDraw.Draw(m).rounded_rectangle((0, 0, w * k - 1, h * k - 1), r * k, fill=255)
    return m.resize((w, h), Image.LANCZOS)

def pastiglia(w, h, r, col):
    im = Image.new('RGBA', (w, h), tuple(col) + (255,)); im.putalpha(tondo(w, h, r)); return im

def distintivo(si, fondo, segno, r):
    D = r * 8; u = D / 64; c = D / 2
    im = Image.new('RGBA', (D, D), (0, 0, 0, 0)); d = ImageDraw.Draw(im)
    d.ellipse((0, 0, D - 1, D - 1), fill=tuple(fondo) + (255,))
    if si: d.line([(c - 15 * u, c + 1 * u), (c - 5 * u, c + 11 * u), (c + 15 * u, c - 10 * u)], fill=tuple(segno) + (255,), width=int(8 * u), joint='curve')
    else:
        d.line([(c - 12 * u, c - 12 * u), (c + 12 * u, c + 12 * u)], fill=tuple(segno) + (255,), width=int(8 * u))
        d.line([(c + 12 * u, c - 12 * u), (c - 12 * u, c + 12 * u)], fill=tuple(segno) + (255,), width=int(8 * u))
    return im.resize((r * 2, r * 2), Image.LANCZOS)

def colonna(i, titolo, col, altezza):
    """pannello trasparente e intestazione di una colonna, su un foglio grande come il video"""
    im = Image.new('RGBA', (W, H), (0, 0, 0, 0)); x = X[i]; y = Y0 - 136; w = 256
    m = tondo(w, altezza, 30); a = m.point(lambda v: int(v * 0.22))
    dentro = Image.new('L', (w, altezza), 0); dentro.paste(tondo(w - 4, altezza - 4, 28), (2, 2)); a.paste(dentro.point(lambda v: int(v * 0.10)), (0, 0), dentro)
    p = Image.new('RGBA', (w, altezza), (255, 255, 255, 255)); p.putalpha(a); im.alpha_composite(p, (x - w // 2, y))
    s = titolo.upper(); z = adatta(s, 190, 34); wp = int(font(z).getlength(s)) + 76
    im.alpha_composite(pastiglia(wp, 60, 30, col), (x - wp // 2, Y0 - 200))
    im.alpha_composite(distintivo(i == 0, (255, 255, 255), col, 17), (x - wp // 2 + 11, Y0 - 187))
    ImageDraw.Draw(im).text((x + 18, Y0 - 170 + z * 0.36), s, font=font(z), fill=(255, 255, 255, 255), anchor='ms')
    return im

def apri_foto(p):
    try:
        import pillow_heif; pillow_heif.register_heif_opener()
    except Exception: pass
    try:
        with Image.open(p) as im: return ImageOps.exif_transpose(im).convert('RGBA')
    except Exception: pass
    d = Path(tempfile.mkdtemp()); t = d / 'foto.png'
    lancia([FF, '-y', '-loglevel', 'error', '-i', p, '-frames:v', '1', t])
    try: return Image.open(t).convert('RGBA')
    except Exception: return None
    finally: shutil.rmtree(d, ignore_errors=True)

def carta(nome, foto, scuro):
    t = Image.new('RGBA', (TELA, TELA), (0, 0, 0, 0)); o = Image.new('L', (TELA, TELA), 0); o.paste(tondo(LATO, LATO, 60), (C - LATO // 2, C - LATO // 2 + 14))
    n = Image.new('RGBA', (TELA, TELA), (0, 0, 0, 255)); n.putalpha(o.filter(ImageFilter.GaussianBlur(24)).point(lambda a: int(a * 0.45))); t.alpha_composite(n)
    t.alpha_composite(pastiglia(LATO, LATO, 60, CHIARO), (C - LATO // 2, C - LATO // 2)); d = ImageDraw.Draw(t)
    if foto is not None:
        b = Image.new('RGBA', foto.size, (255, 255, 255, 255)); b.alpha_composite(foto)
        f = ImageOps.fit(b.convert('RGB'), (408, 408), Image.LANCZOS).convert('RGBA'); f.putalpha(tondo(408, 408, 44)); t.alpha_composite(f, (C - 204, C - 204))
        if nome:
            z = adatta(nome, 470, 56, 38)
            while font(z).getlength(nome) > 470 and len(nome) > 3: nome = nome[:-2].rstrip(' \u2026') + '\u2026'
            wp = int(font(z).getlength(nome)) + 68
            t.alpha_composite(pastiglia(wp, 92, 46, scuro), (C - wp // 2, C + 156))
            d.text((C, C + 202), nome, font=font(z), fill=CHIARO + (255,), anchor='mm')
    else:
        z = 104
        while z > 20:
            righe = a_capo(nome, z, 400)
            if len(righe) * z * 1.14 <= 390 and max(font(z).getlength(r) for r in righe) <= 400: break
            z -= 4
        y = C - (len(righe) - 1) * z * 1.14 / 2
        for r in righe:
            d.text((C, y), r, font=font(z), fill=scuro + (255,), anchor='mm'); y += z * 1.14
    return t

def con_segno(sp, bollino, k=1.0):
    t = sp.copy(); r = max(2, int(bollino.width * k)); b = bollino.resize((r, r), Image.BILINEAR)
    t.alpha_composite(b, (C + 192 - r // 2, C - 192 - r // 2)); return t

def trasforma(sp, s, rot, alfa=1.0):
    w = max(4, int(TELA * s / 2)); im = sp.resize((w, w), Image.BILINEAR)
    if rot: im = im.rotate(rot, Image.BICUBIC, expand=True)
    if alfa < 1: im.putalpha(im.getchannel('A').point(lambda v: int(v * alfa)))
    return im

def incolla(fondo, sp, x, y):
    x = int(x - sp.width / 2); y = int(y - sp.height / 2)
    if x + sp.width <= 0 or y + sp.height <= 0 or x >= W or y >= H: return
    if x >= 0 and y >= 0 and x + sp.width <= W and y + sp.height <= H: fondo.alpha_composite(sp, (x, y))
    else:
        l = Image.new('RGBA', (W, H), (0, 0, 0, 0)); l.paste(sp, (x, y)); fondo.alpha_composite(l)

def ease(u):
    u = max(0.0, min(1.0, u)); return u * u * (3 - 2 * u)

def chiave(kf, t):
    if t <= kf[0][0]: return kf[0][1:]
    for a, b in zip(kf, kf[1:]):
        if t <= b[0]:
            u = ease((t - a[0]) / max(1e-6, b[0] - a[0])); return [x + (y - x) * u for x, y in zip(a[1:], b[1:])]
    return kf[-1][1:]

# ---------- tempi e posti
def e_sinistra(v):
    w = str(v if v is not None else '').strip().lower()
    return not (w in ('destra', 'dx', 'male', 'no', 'peggiore', 'peggio', 'sbagliato', 'flop', '2', 'false') or w.startswith('fa mal'))

def numero(x):
    try: return float(str(x).replace(',', '.'))
    except Exception: return None

def sistema_tempi(voci, dur):
    """ordina le voci e toglie ogni accavallamento: una voce vola via prima che arrivi la successiva, e tutto sta dentro il video"""
    if any(numero(v.get('appare')) is None for v in voci):
        print('NOTA: mancano dei tempi, distribuisco le voci in modo regolare lungo il video')
        p = max(1.0, (dur - 1.0) / len(voci))
        for i, v in enumerate(voci): v['appare'] = 0.4 + i * p; v['vola'] = 0.4 + i * p + min(2.2, p * 0.7)
    for v in voci:
        v['t0'] = max(0.05, numero(v['appare'])); tv = numero(v.get('vola')); v['tv'] = max(tv if tv is not None else v['t0'] + 1.5, v['t0'] + 0.75)
    voci.sort(key=lambda v: v['t0'])
    for a, b in zip(voci, voci[1:]):
        if b['t0'] < a['tv'] + 0.15:
            a['tv'] = max(a['t0'] + 0.75, b['t0'] - 0.15)
            if b['t0'] < a['tv'] + 0.15:
                sp = a['tv'] + 0.15 - b['t0']; b['t0'] += sp; b['tv'] = max(b['tv'], b['t0'] + 0.75)
    ultimo = voci[-1]['tv'] + 0.6
    if ultimo > dur - 0.1:
        k = max(0.05, dur - 0.2 - voci[0]['t0']) / max(0.05, ultimo - voci[0]['t0'])
        print('NOTA: le voci non entravano nel video, ho stretto i tempi')
        for v in voci:
            v['t0'] = voci[0]['t0'] + (v['t0'] - voci[0]['t0']) * k if v is not voci[0] else v['t0']; v['tv'] = voci[0]['t0'] + (v['tv'] - voci[0]['t0']) * k
    for v in voci: v['tl'] = v['tv'] + 0.45

def posto_carta(cfg):
    """dove compare la carta: sopra la testa se c'e spazio, piu piccola se ce n'e poco, sul petto se la testa tocca il bordo alto"""
    if numero(cfg.get('y_carta')) is not None: return numero(cfg['y_carta']), 1.25
    cima = numero(cfg.get('cima_testa')); cima = 640 if cima is None else cima; spazio = cima - 10 - 250
    if spazio >= 288: return min(cima - 154, 560), 1.25
    if spazio >= 190: return 250 + spazio / 2, spazio / 230
    print('NOTA: poco spazio sopra la testa, la carta compare sul petto'); return 1180, 1.25

def passo_colonna(n):
    if n <= 3: return 255, 1.0
    p = min(255, 890 / (n - 1)); return p, max(0.38, p / 255)

# ---------- suoni fatti al momento
def guadagno(video):
    """gli effetti seguono il volume della voce: una voce registrata piano non viene coperta"""
    m = re.search(r'mean_volume: (-?[\d.]+) dB', lancia([FF, '-hide_banner', '-i', video, '-map', '0:a:0', '-af', 'volumedetect', '-f', 'null', '-']).stderr)
    return max(0.2, min(1.3, 10 ** ((float(m[1]) + 20) / 20))) if m else 1.0

def suoni(voci, dur, file, g=1.0):
    sr = 44100; n = int((dur + 1) * sr); b = array.array('f', [0.0]) * n; rnd = random.Random(7)
    def metti(t, s, vol):
        i = int(t * sr)
        for k, x in enumerate(s):
            if 0 <= i + k < n: b[i + k] += x * vol
    def nota(f, d, dec): return [math.sin(2 * math.pi * f * k / sr) * math.exp(-k / (dec * sr)) for k in range(int(d * sr))]
    ph = 0.0; pop = []
    for k in range(int(0.1 * sr)):
        ph += 2 * math.pi * (420 + 6500 * k / sr) / sr; pop.append(math.sin(ph) * math.exp(-k / (0.03 * sr)))
    whoosh = []; l = 0.0; d = int(0.32 * sr)
    for k in range(d):
        u = k / d; a = 0.04 + 0.22 * math.sin(math.pi * u); l += a * (rnd.uniform(-1, 1) - l); whoosh.append(l * math.sin(math.pi * u) * 2.2)
    giusto = nota(1319, 0.3, 0.09); g2 = nota(1976, 0.42, 0.14); o = int(0.09 * sr)
    giusto = [(giusto[k] if k < len(giusto) else 0) + (g2[k - o] if k >= o else 0) for k in range(o + len(g2))]
    sb = []
    for f in (220, 165):
        sb += [(1 if math.sin(2 * math.pi * f * k / sr) > 0 else -1) * 0.5 * (1 - k / (0.15 * sr)) for k in range(int(0.15 * sr))]
    for v in voci:
        metti(v['t0'], pop, 0.32 * g); metti(v['tv'], whoosh, 0.3 * g); metti(v['tl'], giusto if v['si'] else sb, (0.3 if v['si'] else 0.2) * g)
    p = array.array('h', (int(max(-1, min(1, x)) * 32000) for x in b))
    if sys.byteorder == 'big': p.byteswap()
    with wave.open(str(file), 'wb') as w: w.setnchannels(1); w.setsampwidth(2); w.setframerate(sr); w.writeframes(p.tobytes())

# ---------- il video
def cerca(base, nome):
    p = Path(str(nome)).expanduser()
    return p if p.is_absolute() else base / p

def colore(c, altro):
    m = re.fullmatch(r'#?([0-9a-fA-F]{6})', str(c or '').strip())
    return tuple(int(m[1][i:i + 2], 16) for i in (0, 2, 4)) if m else altro

def fotogrammi_grafica(voci, ta, fine, dur, colonne):
    """un fotogramma RGBA alla volta: quando niente si muove riusa lo stesso, cosi resta veloce anche sui video lunghi"""
    vuoto = bytes(W * H * 4); fermo = (None, None); base = (None, None)
    def tavola(k):
        nonlocal base
        if base[0] != k:
            im = Image.new('RGBA', (W, H), (0, 0, 0, 0))
            for c in colonne: im.alpha_composite(c)
            for v in voci[:k]: incolla(im, v['finita'], v['x'], v['y'])
            base = (k, im)
        return base[1]
    for f in range(int(dur * FPS) + 2):
        t = f / FPS
        if t < ta or t >= fine: yield vuoto; continue
        k = sum(1 for v in voci if t >= v['tl'] + 0.1); volo = [v for v in voci if v['t0'] <= t < v['tl'] + 0.1]
        apertura = t < ta + 0.42; chiusura = t >= fine - 0.2
        if not volo and not apertura and not chiusura:
            if fermo[0] != k: fermo = (k, tavola(k).tobytes())
            yield fermo[1]; continue
        if apertura:
            im = Image.new('RGBA', (W, H), (0, 0, 0, 0))
            for i, c in enumerate(colonne):
                u = ease((t - ta - 0.08 * i) / 0.3)
                if u > 0:
                    l = Image.new('RGBA', (W, H), (0, 0, 0, 0)); l.paste(c, (0, int((u - 1) * 60)))
                    im.alpha_composite(Image.blend(Image.new('RGBA', (W, H), (0, 0, 0, 0)), l, u))
            for v in voci[:k]: incolla(im, v['finita'], v['x'], v['y'])
        else: im = tavola(k).copy()
        for v in volo:
            x, y, s, rot, a = chiave(v['kf'], t); sp = v['sprite']
            if t >= v['tl']: sp = con_segno(sp, v['bollino'], min(1.0, 0.3 + (t - v['tl']) / 0.1))
            incolla(im, trasforma(sp, s, rot, a), x, y)
        if chiusura: im = Image.blend(Image.new('RGBA', (W, H), (0, 0, 0, 0)), im, max(0.0, (fine - t) / 0.2))
        yield im.tobytes()

def componi(video, inf, voci, ta, fine, colonne, sfx, out, hdr):
    filtro = '[0:v]%s[b];[b][1:v]overlay=format=auto:eof_action=pass,format=yuv420p[v]' % catena(inf, hdr)
    cmd = [FF, '-y', '-hide_banner', '-loglevel', 'error', '-i', video, '-f', 'rawvideo', '-pix_fmt', 'rgba', '-s', '%dx%d' % (W, H), '-r', str(FPS), '-i', 'pipe:0']
    if sfx and inf['audio']: cmd += ['-i', sfx]; filtro += ';[0:a:0][2:a]amix=inputs=2:duration=first:normalize=0,alimiter=limit=0.97[a]'; audio = ['-map', '[a]']
    elif sfx: cmd += ['-i', sfx]; audio = ['-map', '2:a', '-shortest']
    else: audio = ['-map', '0:a:0?']
    cmd += ['-filter_complex', filtro, '-map', '[v]'] + audio + ['-c:v', 'libx264', '-preset', 'veryfast', '-crf', '18', '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-b:a', '192k', '-movflags', '+faststart', out]
    log = tempfile.TemporaryFile(); p = subprocess.Popen([str(x) for x in cmd], stdin=subprocess.PIPE, stderr=log)
    try:
        for b in fotogrammi_grafica(voci, ta, fine, inf['durata'], colonne): p.stdin.write(b)
        p.stdin.close()
    except (BrokenPipeError, OSError): pass
    p.wait(); log.seek(0); e = log.read().decode('utf-8', 'replace')[-1200:]; ok = p.returncode == 0 and Path(out).exists() and Path(out).stat().st_size > 10000
    if not ok: print('ffmpeg ha detto:', e)
    return ok

def rendi(file_cfg):
    file_cfg = Path(file_cfg).resolve(); base = file_cfg.parent
    try: cfg = json.loads(file_cfg.read_text(encoding='utf-8-sig'))
    except Exception as e: sys.exit('ERRORE: il file %s non si legge: %s' % (file_cfg.name, e))
    video = cerca(base, cfg.get('video', ''))
    if not video.is_file(): sys.exit('ERRORE: non trovo il video %s' % video)
    if not cfg.get('voci'): sys.exit('ERRORE: nel file non ci sono voci')
    global FONT
    FONT = scegli_font(cerca(base, cfg['carattere']) if cfg.get('carattere') else None)
    if not FONT: print('NOTA: nessun carattere di sistema trovato, uso quello di riserva')
    inf = info(video); dur = inf['durata']; voci = [dict(v) for v in cfg['voci']]
    sistema_tempi(voci, dur)
    tit = (list(cfg.get('titoli') or []) + ['Fa bene', 'Fa male'])[:2] if len(cfg.get('titoli') or []) >= 2 else ['Fa bene', 'Fa male']
    col = (colore(cfg.get('colore_sinistra'), VERDE), colore(cfg.get('colore_destra'), ROSSO)); scuro = colore(cfg.get('colore_etichetta'), SCURO)
    n = max(3, sum(1 for v in voci if e_sinistra(v.get('lato'))), sum(1 for v in voci if not e_sinistra(v.get('lato'))))
    pas, sc = passo_colonna(n); yp, sc0 = posto_carta(cfg); conta = [0, 0]
    if n > 8: print('NOTA: %d voci in una colonna: le carte diventano piccole, meglio dividere in due video' % n)
    for v in voci:
        v['si'] = e_sinistra(v.get('lato')); i = 0 if v['si'] else 1
        nome = re.sub(r"[^\w\s'\u2019.,&+%/-]", '', str(v.get('nome', ''))).strip()
        v['x'] = X[i]; v['y'] = Y0 + conta[i] * pas; conta[i] += 1; rot = 4 if v['si'] else -4; foto = None
        if v.get('foto'):
            p = cerca(base, v['foto'])
            foto = apri_foto(p) if p.is_file() else None
            if foto is None: print('NOTA: non riesco ad aprire la foto di "%s", uso la carta con il nome' % nome)
        v['sprite'] = carta(nome or ('' if foto is not None else '?'), foto, scuro); v['bollino'] = distintivo(v['si'], col[i], (255, 255, 255), 64)
        v['finita'] = trasforma(con_segno(v['sprite'], v['bollino']), sc, rot)
        x1, y1 = v['x'], v['y']; t0, tv, tl = v['t0'], v['tv'], v['tl']
        v['kf'] = [[t0, 540, yp + 40, 0.3, 0, 0], [t0 + 0.2, 540, yp - 6, sc0 * 1.06, 0, 1], [t0 + 0.3, 540, yp, sc0, 0, 1], [tv, 540, yp, sc0, 0, 1],
                   [tv + 0.2, (540 + x1) / 2, yp - 50, sc0 * 0.88, rot * 2.4, 1], [tl, x1, y1, sc * 1.08, rot, 1], [tl + 0.1, x1, y1, sc, rot, 1]]
    voci.sort(key=lambda v: v['t0']); ta = max(0.0, voci[0]['t0'] - 0.3)
    scelta = numero(cfg.get('fine')); ultimo = voci[-1]['tl'] + 0.5          # senza scelta resta due secondi dopo l'ultima voce, o fino alla fine se manca poco
    fine = max(scelta, ultimo) if scelta is not None else (dur if dur - ultimo < 6.5 else ultimo + 1.5)
    if fine >= dur - 0.25: fine = dur + 1
    altezza = int((n - 1) * pas + 115 * sc + 150)
    colonne = [colonna(i, str(tit[i]), col[i], altezza) for i in (0, 1)]
    out = cerca(base, cfg.get('uscita') or video.stem + '-classifica.mp4'); tmp = out.with_name('lavorazione-' + out.name)
    cart = Path(tempfile.mkdtemp()); sfx = None
    if cfg.get('suoni', True) is not False:
        sfx = cart / 'suoni.wav'; suoni(voci, dur, sfx, guadagno(video) if inf['audio'] else 1.0)
    print('sto creando il video (%.0f secondi di girato)...' % dur, flush=True)
    ok = componi(video, inf, voci, ta, fine, colonne, sfx, tmp, cfg.get('hdr', True) is not False)
    if not ok and inf['hdr']:
        print('riprovo senza la conversione dei colori HDR...', flush=True); ok = componi(video, inf, voci, ta, fine, colonne, sfx, tmp, False)
    if not ok and sfx:
        print('riprovo senza effetti sonori...', flush=True); ok = componi(video, inf, voci, ta, fine, colonne, None, tmp, False)
    shutil.rmtree(cart, ignore_errors=True)
    if not ok:
        if tmp.exists(): tmp.unlink()
        sys.exit('ERRORE: video non creato')
    os.replace(tmp, out)
    # foglio di controllo: una carta sopra la testa per ogni voce e la classifica completa
    tt = [v['t0'] + 0.5 for v in voci][:7] + [voci[-1]['tl'] + 0.4]; tw, th = 270, 480; rr = (len(tt) + 3) // 4
    fg = Image.new('RGB', (tw * 4, th * rr), SCURO); pass_ = 'format=yuv420p'
    for i, t in enumerate(tt): fg.paste(fotogramma(out, t, pass_, tw).resize((tw, th)), ((i % 4) * tw, (i // 4) * th))
    ctrl = base / 'controllo.jpg'; fg.save(ctrl, quality=85)
    with open(base / 'tempi-usati.txt', 'w', encoding='utf-8') as f:
        for v in voci: f.write('%-30s compare %.2f  vola %.2f  colonna %s\n' % (v.get('nome', ''), v['t0'], v['tv'], 'sinistra' if v['si'] else 'destra'))
    print('FATTO\nvideo: %s\ncontrollo: %s\ndurata %.1f s, %.1f MB' % (out, ctrl, info(out)['durata'], out.stat().st_size / 1e6))

# ---------- trascrizione e fotogrammi di controllo
def trascrivi(video, lingua='it'):
    video = Path(video).resolve()
    if not info(video)['audio']: sys.exit('NESSUN_AUDIO: il video non ha il suono')
    wav = Path(tempfile.mkdtemp()) / 'voce.wav'
    r = lancia([FF, '-y', '-loglevel', 'error', '-i', video, '-vn', '-ac', '1', '-ar', '16000', wav])
    if not wav.exists(): sys.exit('ERRORE: audio non estratto: ' + r.stderr[-400:])
    import numpy as np
    with wave.open(str(wav), 'rb') as w: voce = np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16).astype(np.float32) / 32768.0
    shutil.rmtree(wav.parent, ignore_errors=True)
    from faster_whisper import WhisperModel
    errore = None
    for nome in ('small', 'base', 'tiny'):
        try:
            print('carico il modello %s (la prima volta si scarica, serve qualche minuto)...' % nome, flush=True)
            m = WhisperModel(nome, device='cpu', compute_type='int8'); break
        except Exception as e: errore = e; m = None
    if m is None: sys.exit('ERRORE: modello non scaricato: %s' % errore)
    seg, _ = m.transcribe(voce, language=None if lingua == 'auto' else lingua, word_timestamps=True, condition_on_previous_text=False)
    righe = []; testo = []
    for s in seg:
        testo.append('[%.1f] %s' % (s.start, s.text.strip()))
        for w in s.words or []: righe.append('%.2f %s' % (w.start, w.word.strip()))
    d = video.parent
    (d / 'parole.txt').write_text('\n'.join(righe) + '\n', encoding='utf-8'); (d / 'testo.txt').write_text('\n'.join(testo) + '\n', encoding='utf-8')
    print('FATTO: %d parole in %s' % (len(righe), d / 'parole.txt'))

def fotogrammi(video):
    video = Path(video).resolve(); inf = info(video); fl = catena(inf); tw, th = 360, 640
    fg = Image.new('RGB', (tw * 3, th), SCURO); fnt = font(20); k = tw / W
    for i, u in enumerate((0.1, 0.5, 0.9)):
        im = fotogramma(video, inf['durata'] * u, fl, tw).resize((tw, th)); d = ImageDraw.Draw(im)
        for y in range(100, H, 100):
            d.line([(0, y * k), (tw, y * k)], fill=(255, 230, 0), width=1); d.text((6, y * k - 22), str(y), font=fnt, fill=(255, 230, 0))
        fg.paste(im, (i * tw, 0))
    p = video.parent / 'fotogrammi.jpg'; fg.save(p, quality=85); print('FATTO: %s (le righe gialle dicono l\'altezza su 1920)' % p)

def prova():
    d = Path(tempfile.mkdtemp(prefix='classifica_prova_')); v = d / 'prova con spazi.mp4'
    lancia([FF, '-y', '-loglevel', 'error', '-f', 'lavfi', '-i', 'testsrc2=s=720x1280:r=30:d=6', '-f', 'lavfi', '-i', 'sine=f=220:d=6', '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-shortest', v])
    if not v.exists(): sys.exit('ERRORE: ffmpeg non crea il video di prova')
    Image.new('RGB', (600, 400), (200, 160, 90)).save(d / 'foto.jpg')
    voci = [{'nome': 'Caff\u00e8 con foto', 'lato': 'sinistra', 'appare': 0.5, 'vola': 1.6, 'foto': 'foto.jpg'}, {'nome': 'Una voce con il nome lungo', 'lato': 'destra', 'appare': 2.2, 'vola': 3.4}]
    (d / 'classifica.json').write_text(json.dumps({'video': v.name, 'titoli': ['Migliore', 'Peggiore'], 'cima_testa': 640, 'voci': voci}), encoding='utf-8')
    rendi(d / 'classifica.json'); o = d / 'prova con spazi-classifica.mp4'; im = fotogramma(o, 4.5, 'format=yuv420p', 108)
    if not (o.exists() and (d / 'controllo.jpg').exists() and abs(info(o)['durata'] - 6) < 0.5 and im.width == 108): sys.exit('ERRORE: la prova non e riuscita')
    shutil.rmtree(d, ignore_errors=True); print('PROVA SUPERATA')

if __name__ == '__main__':
    a = sys.argv[1:]
    if a[:1] == ['prova']: prova()
    elif a[:1] == ['trascrivi'] and len(a) >= 2: trascrivi(a[1], a[2] if len(a) > 2 else 'it')
    elif a[:1] == ['fotogrammi'] and len(a) >= 2: fotogrammi(a[1])
    elif a[:1] == ['rendi'] and len(a) >= 2: rendi(a[1])
    else: sys.exit('uso: classifica.py prova | trascrivi VIDEO [lingua] | fotogrammi VIDEO | rendi classifica.json')
SCRIPT FINE
Lista d'attesa
Questo è solo un assaggio, entra in lista

Con il nuovo sistema di Biz Academy fai montare a Claude i tuoi reel interi, partendo da uno stile che chi ti segue riconosce al primo colpo d'occhio. Lasciami nome ed email e quando apriamo le iscrizioni ricevi tutto prima degli altri, compreso il prezzo di lancio.
↑ solo email utili per il tuo business, promesso