Upload 4 files

README.md

@@ -1,14 +1,67 @@
 ---
-title: IA L2 2D
-emoji: 👁
-colorFrom: gray
-colorTo: pink
+title: Atelier IA Animation 2D
+emoji: 🎨
+colorFrom: yellow
+colorTo: red
 sdk: gradio
-sdk_version: 6.28.0
-python_version: '3.12'
+sdk_version: 5.50.0
 app_file: app.py
 pinned: false
-license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Atelier IA — page de classe (fal.ai)
+
+Page web pour que les étudiants génèrent des images avec **vos** crédits fal.ai, sans jamais voir la clé API.
+
+- **Texte → Image** : Krea 2 Turbo, Z-Image Turbo + templates de prompts (CSV)
+- **Image → Image** : Nano Banana 2 (édition), Seedream 5 Pro (édition), 1 à 4 images de référence
+- **Ma galerie** : images de l'étudiant, prompt, réutilisation comme référence, export .zip (avec `prompts.csv`)
+- **Enseignant** : crédits par étudiant, quota, remise à zéro, import des templates de classe, galeries des étudiants
+
+## Connexion
+
+- **Étudiant** : identifiant = son prénom (ou pseudo), mot de passe = le code de classe (`CLASS_CODE`)
+- **Enseignant** : identifiant `prof`, mot de passe `ADMIN_CODE` → l'onglet « Enseignant » apparaît
+
+Chaque identifiant a sa propre galerie : les étudiants doivent toujours utiliser le même.
+
+## Crédits
+
+Chaque étudiant a un quota (60 crédits par défaut, modifiable dans l'onglet Enseignant).
+Texte → Image = 1 crédit/image, édition = 4 crédits/image (réglable dans `app.py`, dictionnaires `T2I_MODELS` / `I2I_MODELS`).
+Les images bloquées par le filtre de sécurité ne sont pas décomptées.
+Côté fal.ai, ne rechargez que le budget prévu : le solde ne peut pas passer en négatif.
+
+## Option A — Hugging Face Spaces (en ligne, gratuit)
+
+1. Sur huggingface.co : **New Space** → SDK **Gradio** → matériel **CPU basic (gratuit)** → visibilité **Public**
+   (l'accès reste protégé par le code de classe ; un Space privé n'est accessible qu'aux comptes autorisés).
+2. Onglet **Files** → *Upload files* : `app.py`, `requirements.txt`, `templates_exemple.csv`, `README.md`.
+3. **Settings → Variables and secrets** → *New secret* :
+   - `FAL_KEY` = votre clé fal.ai
+   - `CLASS_CODE` = code de la classe
+   - `ADMIN_CODE` = votre mot de passe enseignant
+   - (optionnel) `QUOTA` = 60
+4. **Sauvegarde des galeries (recommandé)** : le disque d'un Space gratuit est effacé à chaque redémarrage.
+   Ajoutez aussi les secrets `HF_TOKEN` (jeton *Write* créé dans Settings → Access Tokens de votre compte)
+   et `DATA_REPO` = `votre-nom/atelier-ia-data`. Les galeries sont copiées toutes les 2 min dans un dataset
+   privé et restaurées au redémarrage.
+5. Donnez aux étudiants l'adresse **directe** du Space : `https://votre-nom-nom-du-space.hf.space`
+   (la connexion fonctionne mal dans la page huggingface.co/spaces/… à cause des cookies).
+
+Un Space gratuit se met en veille après 48 h sans visite : ouvrez-le quelques minutes avant le cours.
+
+## Option B — Sur votre PC pendant le cours
+
+1. Installez Python 3.10+ (cochez « Add Python to PATH »).
+2. Ouvrez `lancer_windows.bat` avec le Bloc-notes, remplissez `FAL_KEY`, `CLASS_CODE`, `ADMIN_CODE`, enregistrez.
+3. Double-cliquez dessus. Les étudiants sur le même Wi-Fi ouvrent `http://<IP de votre PC>:7860`
+   (IP donnée par la commande `ipconfig`). Autorisez Python dans le pare-feu Windows si demandé.
+4. Les images restent dans le dossier `data/`.
+
+## Format des templates CSV
+
+Colonnes `categorie`, `titre`, `prompt` — séparateur `;` ou `,`, UTF-8 ou export Excel.
+Voir `templates_exemple.csv` (14 templates animation 2D, chargés automatiquement au premier lancement).
+L'import dans l'onglet Enseignant remplace les templates de classe.
+Les étudiants peuvent importer leurs propres templates (marqués ★, visibles d'eux seuls).

app.py

@@ -0,0 +1,637 @@
+"""
+Atelier IA — page de classe pour générer des images via fal.ai
+La clé API reste côté serveur : les étudiants ne la voient jamais.
+
+Variables d'environnement :
+  FAL_KEY        (obligatoire) clé API fal.ai
+  CLASS_CODE     mot de passe commun des étudiants            (défaut : atelier2d)
+  ADMIN_USER     identifiant de l'enseignant                  (défaut : prof)
+  ADMIN_CODE     mot de passe de l'enseignant                 (obligatoire pour l'espace prof)
+  QUOTA          crédits par étudiant                         (défaut : 60)
+  DATA_DIR       dossier de stockage                          (défaut : ./data)
+  HF_TOKEN + DATA_REPO   (optionnel, Hugging Face) sauvegarde automatique des galeries
+                         dans un dataset privé, ex. "cedric/atelier-ia-data"
+"""
+
+import csv
+import io
+import json
+import os
+import re
+import threading
+import time
+import unicodedata
+import uuid
+import zipfile
+from datetime import datetime
+
+import fal_client
+import gradio as gr
+import requests
+
+# ---------------------------------------------------------------- configuration
+
+DATA_DIR = os.path.abspath(os.environ.get("DATA_DIR", "data"))
+CLASS_CODE = os.environ.get("CLASS_CODE", "atelier2d")
+ADMIN_USER = os.environ.get("ADMIN_USER", "prof").strip().lower()
+ADMIN_CODE = os.environ.get("ADMIN_CODE", "")
+DEFAULT_QUOTA = int(os.environ.get("QUOTA", "60"))
+
+# "cout" = crédits décomptés par image générée (à ajuster selon vos tarifs fal.ai)
+T2I_MODELS = {
+    "Krea 2 Turbo": {"id": "fal-ai/krea-2/turbo", "cout": 1},
+    "Z-Image Turbo": {"id": "fal-ai/z-image/turbo", "cout": 1},
+}
+I2I_MODELS = {
+    "Nano Banana 2 (édition)": {"id": "fal-ai/nano-banana-2/edit", "cout": 4},
+    "Seedream 5 Pro (édition)": {"id": "bytedance/seedream/v5/pro/edit", "cout": 4},
+}
+
+# Format commun -> paramètres propres à chaque modèle
+FORMATS = ["1:1", "4:3", "3:4", "16:9", "9:16"]
+IMAGE_SIZE = {
+    "auto": "auto_2K",
+    "1:1": "square_hd",
+    "4:3": "landscape_4_3",
+    "3:4": "portrait_4_3",
+    "16:9": "landscape_16_9",
+    "9:16": "portrait_16_9",
+}
+
+MAX_REF_IMAGES = 4
+
+os.makedirs(os.path.join(DATA_DIR, "users"), exist_ok=True)
+EXAMPLE_CSV = os.path.join(os.path.dirname(os.path.abspath(__file__)), "templates_exemple.csv")
+
+# ---------------------------------------------------------------- sauvegarde HF (optionnelle)
+
+_lock = threading.Lock()
+_scheduler = None
+if os.environ.get("HF_TOKEN") and os.environ.get("DATA_REPO"):
+    try:
+        from huggingface_hub import CommitScheduler, snapshot_download
+
+        repo = os.environ["DATA_REPO"]
+        try:
+            snapshot_download(repo_id=repo, repo_type="dataset", local_dir=DATA_DIR,
+                              token=os.environ["HF_TOKEN"])
+        except Exception as e:  # premier lancement : le dataset n'existe pas encore
+            print("Pas de données à restaurer :", e)
+        _scheduler = CommitScheduler(repo_id=repo, repo_type="dataset", folder_path=DATA_DIR,
+                                     every=2, private=True, token=os.environ["HF_TOKEN"])
+        _lock = _scheduler.lock
+        print("Sauvegarde automatique activée vers", repo)
+    except Exception as e:
+        print("Sauvegarde HF désactivée :", e)
+
+# ---------------------------------------------------------------- utilitaires
+
+def slug(name: str) -> str:
+    name = unicodedata.normalize("NFKD", name or "").encode("ascii", "ignore").decode()
+    name = re.sub(r"[^a-z0-9_-]+", "-", name.strip().lower()).strip("-")
+    return name[:30]
+
+
+def read_json(path, default):
+    try:
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return default
+
+
+def write_json(path, data):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tmp = path + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=1)
+    os.replace(tmp, path)
+
+
+def settings():
+    return read_json(os.path.join(DATA_DIR, "settings.json"), {"quota": DEFAULT_QUOTA})
+
+
+def user_dir(user):
+    return os.path.join(DATA_DIR, "users", user)
+
+
+def load_user(user):
+    return read_json(os.path.join(user_dir(user), "gallery.json"), {"used": 0, "items": []})
+
+
+def save_user(user, data):
+    write_json(os.path.join(user_dir(user), "gallery.json"), data)
+
+
+def current_user(request: gr.Request):
+    user = slug(getattr(request, "username", "") or "")
+    if not user:
+        raise gr.Error("Session expirée : rechargez la page et reconnectez-vous.")
+    return user
+
+
+def remaining(user):
+    return settings()["quota"] - load_user(user)["used"]
+
+
+def status_line(user):
+    if user == ADMIN_USER:
+        return f"**Connecté : {user}** (enseignant)"
+    q = settings()["quota"]
+    used = load_user(user)["used"]
+    return f"**Connecté : {user}** · crédits restants : **{max(q - used, 0)} / {q}**"
+
+
+# ---------------------------------------------------------------- templates CSV
+
+def parse_templates_csv(path):
+    """Lit un CSV (virgule ou point-virgule, UTF-8 ou Excel) avec au minimum les colonnes titre et prompt."""
+    raw = open(path, "rb").read()
+    for enc in ("utf-8-sig", "cp1252", "latin-1"):
+        try:
+            text = raw.decode(enc)
+            break
+        except UnicodeDecodeError:
+            continue
+    first = text.splitlines()[0] if text else ""
+    delim = ";" if first.count(";") > first.count(",") else ","
+    rows = list(csv.DictReader(io.StringIO(text), delimiter=delim))
+    out = []
+    for r in rows:
+        r = {(k or "").strip().lower(): (v or "").strip() for k, v in r.items()}
+        prompt = r.get("prompt") or r.get("texte") or ""
+        title = r.get("titre") or r.get("title") or r.get("nom") or prompt[:40]
+        cat = r.get("categorie") or r.get("catégorie") or r.get("category") or ""
+        if prompt:
+            out.append({"categorie": cat, "titre": title, "prompt": prompt})
+    if not out:
+        raise gr.Error("Aucun template trouvé. Le CSV doit contenir au moins les colonnes « titre » et « prompt ».")
+    return out
+
+
+def all_templates(user):
+    cls = read_json(os.path.join(DATA_DIR, "templates.json"), [])
+    perso = read_json(os.path.join(user_dir(user), "templates.json"), []) if user else []
+    return [dict(t, source="classe") for t in cls] + [dict(t, source="perso") for t in perso]
+
+
+def template_label(t):
+    tag = "★ " if t["source"] == "perso" else ""
+    return f"{tag}{t['categorie'] + ' — ' if t['categorie'] else ''}{t['titre']}"
+
+
+def template_choices(user):
+    return [template_label(t) for t in all_templates(user)]
+
+
+def seed_class_templates():
+    """Au premier lancement, charge templates_exemple.csv comme templates de classe."""
+    path = os.path.join(DATA_DIR, "templates.json")
+    if not os.path.exists(path) and os.path.exists(EXAMPLE_CSV):
+        try:
+            write_json(path, parse_templates_csv(EXAMPLE_CSV))
+        except Exception as e:
+            print("Templates d'exemple non chargés :", e)
+
+
+seed_class_templates()
+
+# ---------------------------------------------------------------- génération
+
+def _save_results(user, result, meta, cost_per_image):
+    images = result.get("images") or []
+    nsfw = result.get("has_nsfw_concepts") or [False] * len(images)
+    saved = []
+    for i, img in enumerate(images):
+        if i < len(nsfw) and nsfw[i]:
+            continue
+        r = requests.get(img["url"], timeout=120)
+        r.raise_for_status()
+        ext = "png" if "png" in (img.get("content_type") or "") else (
+            "webp" if "webp" in (img.get("content_type") or "") else "jpg")
+        iid = datetime.now().strftime("%Y%m%d-%H%M%S-") + uuid.uuid4().hex[:6]
+        rel = f"images/{iid}.{ext}"
+        path = os.path.join(user_dir(user), rel)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with _lock:
+            with open(path, "wb") as f:
+                f.write(r.content)
+        saved.append({"id": iid, "file": rel, "created": time.strftime("%Y-%m-%d %H:%M"),
+                      "seed": result.get("seed"), **meta})
+    with _lock:
+        data = load_user(user)
+        data["items"].extend(saved)
+        data["used"] += cost_per_image * len(saved)
+        save_user(user, data)
+    blocked = len(images) - len(saved)
+    return saved, blocked
+
+
+def _check_quota(user, cost):
+    if user == ADMIN_USER:
+        return
+    left = remaining(user)
+    if cost > left:
+        raise gr.Error(f"Crédits insuffisants : cette génération coûte {cost}, il vous reste {max(left, 0)}.")
+
+
+def _call_fal(endpoint, args):
+    if not os.environ.get("FAL_KEY"):
+        raise gr.Error("La clé FAL_KEY n'est pas configurée sur le serveur. Prévenez l'enseignant.")
+    try:
+        return fal_client.subscribe(endpoint, arguments=args)
+    except Exception as e:
+        raise gr.Error(f"Erreur fal.ai : {e}")
+
+
+def _result_message(saved, blocked, cost, user):
+    msg = f"{len(saved)} image(s) générée(s) · {cost * len(saved)} crédit(s) utilisé(s)."
+    if blocked:
+        msg += f" {blocked} image(s) bloquée(s) par le filtre de sécurité (non décomptée(s))."
+    return msg
+
+
+def generate_t2i(prompt, model_label, fmt, n, seed, request: gr.Request):
+    user = current_user(request)
+    prompt = (prompt or "").strip()
+    if not prompt:
+        raise gr.Error("Écrivez un prompt (ou choisissez un template).")
+    model = T2I_MODELS[model_label]
+    n = int(n)
+    cost = model["cout"] * n
+    _check_quota(user, cost)
+    args = {"prompt": prompt, "num_images": n, "image_size": IMAGE_SIZE[fmt],
+            "enable_safety_checker": True, "output_format": "png"}
+    if seed and int(seed) > 0:
+        args["seed"] = int(seed)
+    result = _call_fal(model["id"], args)
+    saved, blocked = _save_results(user, result, {"mode": "Texte → Image", "model": model_label,
+                                                  "prompt": prompt}, model["cout"])
+    gal = [(os.path.join(user_dir(user), s["file"]), s["model"]) for s in saved]
+    return gal, _result_message(saved, blocked, model["cout"], user), status_line(user)
+
+
+def generate_i2i(refs, prompt, model_label, fmt, n, request: gr.Request):
+    user = current_user(request)
+    prompt = (prompt or "").strip()
+    paths = [r[0] if isinstance(r, (list, tuple)) else r for r in (refs or [])]
+    if not paths:
+        raise gr.Error("Ajoutez au moins une image de référence.")
+    if len(paths) > MAX_REF_IMAGES:
+        raise gr.Error(f"{MAX_REF_IMAGES} images de référence maximum.")
+    if not prompt:
+        raise gr.Error("Décrivez la modification souhaitée.")
+    model = I2I_MODELS[model_label]
+    n = int(n)
+    cost = model["cout"] * n
+    _check_quota(user, cost)
+    try:
+        urls = [fal_client.upload_file(p) for p in paths]
+    except Exception as e:
+        raise gr.Error(f"Envoi des images impossible : {e}")
+    args = {"prompt": prompt, "image_urls": urls, "num_images": n}
+    if "nano-banana" in model["id"]:
+        args.update({"aspect_ratio": fmt, "resolution": "1K", "output_format": "png"})
+    else:
+        args.update({"image_size": IMAGE_SIZE[fmt], "enable_safety_checker": True})
+    result = _call_fal(model["id"], args)
+    saved, blocked = _save_results(user, result, {"mode": "Image → Image", "model": model_label,
+                                                  "prompt": prompt, "refs": len(paths)}, model["cout"])
+    gal = [(os.path.join(user_dir(user), s["file"]), s["model"]) for s in saved]
+    return gal, _result_message(saved, blocked, model["cout"], user), status_line(user)
+
+
+# ---------------------------------------------------------------- galerie
+
+def visible_items(user):
+    return [it for it in reversed(load_user(user)["items"]) if not it.get("deleted")]
+
+
+def gallery_view(user):
+    items = visible_items(user)
+    gal = [(os.path.join(user_dir(user), it["file"]), f"{it['model']} · {it['prompt'][:80]}") for it in items]
+    return gal, [it["id"] for it in items]
+
+
+def refresh_gallery(request: gr.Request):
+    user = current_user(request)
+    gal, ids = gallery_view(user)
+    return gal, ids, None, "Cliquez sur une image pour voir son prompt.", status_line(user)
+
+
+def select_item(ids, evt: gr.SelectData, request: gr.Request):
+    user = current_user(request)
+    if evt.index is None or evt.index >= len(ids):
+        return None, ""
+    iid = ids[evt.index]
+    it = next((x for x in load_user(user)["items"] if x["id"] == iid), None)
+    if not it:
+        return None, ""
+    info = (f"**{it['mode']}** · {it['model']} · {it['created']}"
+            + (f" · seed {it['seed']}" if it.get("seed") else "")
+            + f"\n\n> {it['prompt']}")
+    return iid, info
+
+
+def _item_path(user, iid):
+    it = next((x for x in load_user(user)["items"] if x["id"] == iid), None)
+    return os.path.join(user_dir(user), it["file"]) if it else None
+
+
+def send_to_i2i(iid, current_refs, request: gr.Request):
+    user = current_user(request)
+    if not iid:
+        raise gr.Error("Sélectionnez d'abord une image dans votre galerie.")
+    refs = [r[0] if isinstance(r, (list, tuple)) else r for r in (current_refs or [])]
+    if len(refs) >= MAX_REF_IMAGES:
+        raise gr.Error(f"{MAX_REF_IMAGES} images de référence maximum.")
+    refs.append(_item_path(user, iid))
+    gr.Info("Image ajoutée dans l'onglet Image → Image.")
+    return refs
+
+
+def reuse_prompt(iid, request: gr.Request):
+    user = current_user(request)
+    it = next((x for x in load_user(user)["items"] if x["id"] == iid), None)
+    if not it:
+        raise gr.Error("Sélectionnez d'abord une image.")
+    gr.Info("Prompt copié dans l'onglet Texte → Image.")
+    return it["prompt"]
+
+
+def delete_item(iid, request: gr.Request):
+    user = current_user(request)
+    if not iid:
+        raise gr.Error("Sélectionnez d'abord une image.")
+    with _lock:
+        data = load_user(user)
+        for it in data["items"]:
+            if it["id"] == iid:
+                it["deleted"] = True
+        save_user(user, data)
+    gal, ids = gallery_view(user)
+    return gal, ids, None, "Image retirée de la galerie."
+
+
+def zip_gallery(request: gr.Request):
+    user = current_user(request)
+    items = visible_items(user)
+    if not items:
+        raise gr.Error("Votre galerie est vide.")
+    zpath = os.path.join(DATA_DIR, "_exports", f"galerie-{user}.zip")
+    os.makedirs(os.path.dirname(zpath), exist_ok=True)
+    lines = ["fichier;date;mode;modele;prompt"]
+    with zipfile.ZipFile(zpath, "w", zipfile.ZIP_DEFLATED) as z:
+        for it in items:
+            name = os.path.basename(it["file"])
+            z.write(os.path.join(user_dir(user), it["file"]), name)
+            lines.append(f"{name};{it['created']};{it['mode']};{it['model']};\"{it['prompt'].replace(chr(34), chr(39))}\"")
+        z.writestr("prompts.csv", "" + "\n".join(lines))
+    return zpath
+
+
+# ---------------------------------------------------------------- templates (UI)
+
+def on_template(label, request: gr.Request):
+    user = current_user(request)
+    for t in all_templates(user):
+        if template_label(t) == label:
+            return t["prompt"]
+    return gr.update()
+
+
+def import_perso_templates(file, request: gr.Request):
+    user = current_user(request)
+    if not file:
+        raise gr.Error("Choisissez un fichier CSV.")
+    new = parse_templates_csv(file)
+    path = os.path.join(user_dir(user), "templates.json")
+    with _lock:
+        write_json(path, read_json(path, []) + new)
+    gr.Info(f"{len(new)} template(s) personnel(s) importé(s).")
+    return gr.Dropdown(choices=template_choices(user), value=None), None
+
+
+# ---------------------------------------------------------------- espace enseignant
+
+def _require_admin(request):
+    user = current_user(request)
+    if user != ADMIN_USER:
+        raise gr.Error("Réservé à l'enseignant.")
+    return user
+
+
+def admin_overview(request: gr.Request):
+    _require_admin(request)
+    q = settings()["quota"]
+    rows, total = [], 0
+    base = os.path.join(DATA_DIR, "users")
+    for u in sorted(os.listdir(base)):
+        if u == ADMIN_USER or not os.path.isdir(os.path.join(base, u)):
+            continue
+        d = load_user(u)
+        n = len([i for i in d["items"] if not i.get("deleted")])
+        rows.append([u, n, d["used"], max(q - d["used"], 0)])
+        total += d["used"]
+    admin = load_user(ADMIN_USER)
+    summary = (f"**{len(rows)} étudiant(s)** · quota actuel : **{q} crédits** · "
+               f"crédits consommés par les étudiants : **{total}** · par l'enseignant : **{admin['used']}**")
+    students = [r[0] for r in rows]
+    return rows, summary, gr.Dropdown(choices=students), gr.Dropdown(choices=students)
+
+
+def admin_set_quota(q, request: gr.Request):
+    _require_admin(request)
+    with _lock:
+        s = settings()
+        s["quota"] = int(q)
+        write_json(os.path.join(DATA_DIR, "settings.json"), s)
+    gr.Info(f"Quota fixé à {int(q)} crédits par étudiant.")
+    return admin_overview(request)
+
+
+def admin_reset(student, request: gr.Request):
+    _require_admin(request)
+    if not student:
+        raise gr.Error("Choisissez un étudiant.")
+    with _lock:
+        d = load_user(student)
+        d["used"] = 0
+        save_user(student, d)
+    gr.Info(f"Crédits de {student} remis à zéro.")
+    return admin_overview(request)
+
+
+def admin_view_gallery(student, request: gr.Request):
+    _require_admin(request)
+    if not student:
+        return []
+    return gallery_view(student)[0]
+
+
+def admin_import_templates(file, request: gr.Request):
+    _require_admin(request)
+    if not file:
+        raise gr.Error("Choisissez un fichier CSV.")
+    new = parse_templates_csv(file)
+    with _lock:
+        write_json(os.path.join(DATA_DIR, "templates.json"), new)
+    gr.Info(f"{len(new)} template(s) de classe importé(s) (remplacent les précédents).")
+    return None
+
+
+# ---------------------------------------------------------------- authentification
+
+def check_auth(username, password):
+    u = slug(username)
+    if not u:
+        return False
+    if u == ADMIN_USER:
+        return bool(ADMIN_CODE) and password == ADMIN_CODE
+    return password == CLASS_CODE
+
+
+# ---------------------------------------------------------------- interface
+
+CSS = """
+.gradio-container {max-width: 1200px !important}
+#status {text-align:right}
+footer {display:none !important}
+"""
+
+with gr.Blocks(title="Atelier IA — Animation 2D", theme=gr.themes.Soft(primary_hue="orange"), css=CSS) as demo:
+    with gr.Row():
+        gr.Markdown("## Atelier IA générative · Animation 2D")
+        status = gr.Markdown("", elem_id="status")
+
+    with gr.Tabs() as tabs:
+        # ----------------------------------------------------- Texte → Image
+        with gr.Tab("Texte → Image", id="t2i"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    tpl = gr.Dropdown(label="Template de prompt", choices=[], value=None,
+                                      info="Choisir un modèle de prompt, puis l'adapter (remplacer les [CROCHETS]).")
+                    t2i_prompt = gr.Textbox(label="Prompt", lines=5,
+                                            placeholder="Décrivez l'image : sujet, style, cadrage, lumière…")
+                    with gr.Row():
+                        t2i_model = gr.Dropdown(list(T2I_MODELS), value="Krea 2 Turbo", label="Modèle")
+                        t2i_fmt = gr.Dropdown(FORMATS, value="1:1", label="Format")
+                    with gr.Row():
+                        t2i_n = gr.Slider(1, 4, value=1, step=1, label="Nombre d'images")
+                        t2i_seed = gr.Number(value=0, precision=0, label="Seed (0 = aléatoire)")
+                    t2i_btn = gr.Button("Générer", variant="primary")
+                    with gr.Accordion("Importer mes propres templates (CSV)", open=False):
+                        gr.Markdown("Colonnes : `categorie`, `titre`, `prompt` (séparateur virgule ou point-virgule). "
+                                    "Vos templates apparaissent avec une ★.")
+                        perso_csv = gr.File(label="Fichier CSV", file_types=[".csv"], type="filepath")
+                        perso_btn = gr.Button("Importer")
+                with gr.Column(scale=3):
+                    t2i_out = gr.Gallery(label="Résultat", columns=2, height=520, object_fit="contain")
+                    t2i_msg = gr.Markdown()
+
+        # ----------------------------------------------------- Image → Image
+        with gr.Tab("Image → Image", id="i2i"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    refs = gr.Gallery(label=f"Images de référence (1 à {MAX_REF_IMAGES}) — croquis, rough, décor…",
+                                      type="filepath", interactive=True, file_types=["image"],
+                                      columns=4, height=220)
+                    i2i_prompt = gr.Textbox(label="Consigne", lines=4,
+                                            placeholder="Ex. : Colorise ce rough en aplats façon anime, garde le trait original.")
+                    with gr.Row():
+                        i2i_model = gr.Dropdown(list(I2I_MODELS), value="Nano Banana 2 (édition)", label="Modèle")
+                        i2i_fmt = gr.Dropdown(["auto"] + FORMATS, value="auto", label="Format")
+                    i2i_n = gr.Slider(1, 4, value=1, step=1, label="Nombre d'images")
+                    i2i_btn = gr.Button("Générer", variant="primary")
+                    gr.Markdown(f"Les modèles d'édition coûtent plus cher : "
+                                + ", ".join(f"{k} = {v['cout']} crédits/image" for k, v in I2I_MODELS.items())
+                                + ". Texte → Image = 1 crédit/image.")
+                with gr.Column(scale=3):
+                    i2i_out = gr.Gallery(label="Résultat", columns=2, height=520, object_fit="contain")
+                    i2i_msg = gr.Markdown()
+
+        # ----------------------------------------------------- Galerie
+        with gr.Tab("Ma galerie", id="gal") as gal_tab:
+            gal_ids = gr.State([])
+            gal_sel = gr.State(None)
+            with gr.Row():
+                gal_refresh = gr.Button("Actualiser")
+                gal_zip = gr.Button("Tout télécharger (.zip)")
+            my_gal = gr.Gallery(label="Mes images (les plus récentes d'abord)", columns=5, height=560,
+                                object_fit="cover", allow_preview=True)
+            gal_info = gr.Markdown("Cliquez sur une image pour voir son prompt.")
+            with gr.Row():
+                gal_to_i2i = gr.Button("Utiliser comme référence (Image → Image)")
+                gal_reuse = gr.Button("Réutiliser le prompt")
+                gal_del = gr.Button("Retirer de la galerie", variant="stop")
+            gal_file = gr.File(label="Archive", visible=True)
+
+        # ----------------------------------------------------- Espace enseignant
+        with gr.Tab("Enseignant", id="admin", visible=False) as admin_tab:
+            adm_summary = gr.Markdown()
+            adm_table = gr.Dataframe(headers=["Étudiant", "Images", "Crédits utilisés", "Crédits restants"],
+                                     interactive=False)
+            adm_refresh = gr.Button("Actualiser")
+            with gr.Row():
+                adm_quota = gr.Number(value=DEFAULT_QUOTA, precision=0, label="Quota par étudiant (crédits)")
+                adm_quota_btn = gr.Button("Appliquer le quota")
+            with gr.Row():
+                adm_student = gr.Dropdown(label="Étudiant", choices=[])
+                adm_reset_btn = gr.Button("Remettre ses crédits à zéro")
+            with gr.Accordion("Templates de la classe (CSV)", open=True):
+                gr.Markdown("Colonnes : `categorie`, `titre`, `prompt`. L'import **remplace** les templates de classe.")
+                adm_csv = gr.File(label="Fichier CSV", file_types=[".csv"], type="filepath")
+                adm_csv_btn = gr.Button("Importer les templates de classe")
+            with gr.Accordion("Voir la galerie d'un étudiant", open=False):
+                adm_gal_student = gr.Dropdown(label="Étudiant", choices=[])
+                adm_gal = gr.Gallery(columns=5, height=480, object_fit="cover")
+
+    # ----------------------------------------------------- événements
+
+    def on_load(request: gr.Request):
+        user = current_user(request)
+        s = settings()
+        return (status_line(user), gr.Dropdown(choices=template_choices(user), value=None),
+                gr.Tab(visible=(user == ADMIN_USER)), s["quota"])
+
+    demo.load(on_load, None, [status, tpl, admin_tab, adm_quota])
+
+    def refresh_templates(request: gr.Request):
+        return gr.Dropdown(choices=template_choices(current_user(request)))
+
+    tpl.focus(refresh_templates, None, tpl)
+    tpl.input(on_template, tpl, t2i_prompt)
+    perso_btn.click(import_perso_templates, perso_csv, [tpl, perso_csv])
+
+    t2i_btn.click(generate_t2i, [t2i_prompt, t2i_model, t2i_fmt, t2i_n, t2i_seed],
+                  [t2i_out, t2i_msg, status], concurrency_limit=10)
+    i2i_btn.click(generate_i2i, [refs, i2i_prompt, i2i_model, i2i_fmt, i2i_n],
+                  [i2i_out, i2i_msg, status], concurrency_limit=10)
+
+    gal_outputs = [my_gal, gal_ids, gal_sel, gal_info, status]
+    gal_tab.select(refresh_gallery, None, gal_outputs)
+    gal_refresh.click(refresh_gallery, None, gal_outputs)
+    my_gal.select(select_item, gal_ids, [gal_sel, gal_info])
+    gal_to_i2i.click(send_to_i2i, [gal_sel, refs], refs)
+    gal_reuse.click(reuse_prompt, gal_sel, t2i_prompt)
+    gal_del.click(delete_item, gal_sel, [my_gal, gal_ids, gal_sel, gal_info])
+    gal_zip.click(zip_gallery, None, gal_file)
+
+    adm_outputs = [adm_table, adm_summary, adm_student, adm_gal_student]
+    admin_tab.select(admin_overview, None, adm_outputs)
+    adm_refresh.click(admin_overview, None, adm_outputs)
+    adm_quota_btn.click(admin_set_quota, adm_quota, adm_outputs)
+    adm_reset_btn.click(admin_reset, adm_student, adm_outputs)
+    adm_csv_btn.click(admin_import_templates, adm_csv, adm_csv)
+    adm_gal_student.change(admin_view_gallery, adm_gal_student, adm_gal)
+
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=10).launch(
+        auth=check_auth,
+        auth_message="Prénom (ou pseudo) + code de la classe",
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", "7860")),
+        allowed_paths=[DATA_DIR],
+    )

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=5.0,<6
+fal-client
+requests
+huggingface_hub

templates_exemple.csv

@@ -0,0 +1,15 @@
+categorie;titre;prompt
+Personnage;Model sheet (turnaround);"Character model sheet of [PERSONNAGE], full body turnaround: front view, 3/4 view, side view and back view, neutral pose, clean line art with flat colors, white background, 2D animation production style, consistent proportions"
+Personnage;Planche d'expressions;"Expression sheet of [PERSONNAGE], 9 facial expressions in a 3x3 grid (happy, sad, angry, surprised, scared, bored, laughing, thinking, crying), clean 2D cartoon line art, flat colors, white background"
+Personnage;Silhouettes (recherche de forme);"Page of 8 black silhouette thumbnails exploring different body shapes for [PERSONNAGE], strong readable shapes, varied proportions, flat black on white, character design exploration"
+Personnage;Design style cartoon rubber hose;"[PERSONNAGE] designed in 1930s rubber hose cartoon style, pie-cut eyes, white gloves, bendy limbs, black and white ink, film grain"
+Décor;Décor peint à la gouache;"2D animation background painting of [LIEU], gouache and watercolor texture, soft natural light, no characters, wide establishing shot, hand-painted feel, rich atmospheric perspective"
+Décor;Décor anime (lumière dramatique);"Anime background art of [LIEU] at [MOMENT DE LA JOURNEE], detailed hand-painted style, dramatic sky, strong light and shadow, no characters, cinematic composition"
+Décor;Décor tropical (La Réunion);"2D animated film background of a village on Reunion Island, sugar cane fields, volcanic mountains, creole houses with colorful shutters, flamboyant trees, painted style, no characters"
+Décor;Layout en perspective;"Pencil layout drawing of [LIEU] for 2D animation, clear two-point perspective, construction lines visible, grayscale values, no characters, production layout"
+Storyboard;Case de storyboard;"Single storyboard panel, rough pencil sketch, [ACTION], [CADRAGE: plan large / plan moyen / gros plan], arrows indicating movement, black and white, animation storyboard style"
+Storyboard;Planche 6 cases;"Animation storyboard page with 6 panels showing [SEQUENCE], rough grey pencil sketches, simple staging, camera directions noted with arrows, white paper"
+Style;Recherche de style (color script);"Color script for an animated short about [HISTOIRE], sequence of 8 small thumbnail paintings showing the mood evolution from beginning to end, limited palettes, painterly"
+Style;Illustration ligne claire;"[SUJET] in franco-belgian ligne claire comic style, uniform clean black outlines, flat vivid colors, no shading, detailed background"
+Style;Estampe japonaise;"[SUJET] in the style of an ukiyo-e woodblock print, flat color areas, bold outlines, textured paper, limited traditional palette"
+Accessoire;Planche d'accessoires (props);"Prop design sheet for a 2D animated series: [OBJETS], each prop shown from 2 angles, clean line art, flat colors, labels, white background"