Spaces:
Sleeping
Sleeping
Download app.py from TeacherTerry/Copy-Cat: direct link, hf CLI and curl.
- Browser
- Download file 10 kB
-
https://huggingface.co/spaces/TeacherTerry/Copy-Cat/resolve/main/app.py
- Command line
-
hf download hf://spaces/TeacherTerry/Copy-Cat/app.py
-
curl -L -o app.py https://huggingface.co/spaces/TeacherTerry/Copy-Cat/resolve/main/app.py
10 kB
| ADMIN_KEY = "teacher123" | |
| # force rebuild 1 | |
| import os | |
| import sqlite3 | |
| import datetime as dt | |
| from typing import Optional, Tuple | |
| import gradio as gr | |
| import numpy as np | |
| from PIL import Image | |
| # --- Lightweight image similarity (no torch / no transformers) --- | |
| def dhash(img: Image.Image, hash_size: int = 8) -> np.ndarray: | |
| img = img.convert("L").resize((hash_size + 1, hash_size), Image.BILINEAR) | |
| pixels = np.asarray(img, dtype=np.int16) | |
| diff = pixels[:, 1:] > pixels[:, :-1] | |
| return diff.flatten().astype(np.float32) | |
| def color_hist(img: Image.Image, bins: int = 16) -> np.ndarray: | |
| img = img.convert("RGB").resize((128, 128), Image.BILINEAR) | |
| arr = np.asarray(img, dtype=np.uint8) | |
| hist = [] | |
| for c in range(3): | |
| h, _ = np.histogram(arr[:, :, c], bins=bins, range=(0, 256), density=True) | |
| hist.append(h.astype(np.float32)) | |
| vec = np.concatenate(hist) | |
| vec /= (np.linalg.norm(vec) + 1e-8) | |
| return vec | |
| def image_embedding(img: Image.Image) -> np.ndarray: | |
| a = dhash(img) # structure/layout | |
| b = color_hist(img, bins=16) # palette/style | |
| vec = np.concatenate([a, b]).astype(np.float32) | |
| vec /= (np.linalg.norm(vec) + 1e-8) | |
| return vec | |
| def cosine(a: np.ndarray, b: np.ndarray) -> float: | |
| return float(np.clip(np.dot(a, b), -1.0, 1.0)) | |
| def score_percent(a: np.ndarray, b: np.ndarray) -> float: | |
| sim = cosine(a, b) | |
| return float(np.clip(sim * 100.0, 0.0, 100.0)) | |
| # --- Persistence (SQLite) --- | |
| DB_PATH = os.environ.get("TWINCLASS_DB", "twinclass.sqlite3") | |
| def db(): | |
| conn = sqlite3.connect(DB_PATH, check_same_thread=False) | |
| conn.execute(""" | |
| CREATE TABLE IF NOT EXISTS challenge ( | |
| id INTEGER PRIMARY KEY, | |
| title TEXT NOT NULL, | |
| created_at TEXT NOT NULL, | |
| target_path TEXT NOT NULL | |
| ); | |
| """) | |
| conn.execute(""" | |
| CREATE TABLE IF NOT EXISTS submissions ( | |
| id INTEGER PRIMARY KEY, | |
| challenge_id INTEGER NOT NULL, | |
| nickname TEXT NOT NULL, | |
| prompt TEXT, | |
| image_path TEXT NOT NULL, | |
| score REAL NOT NULL, | |
| created_at TEXT NOT NULL, | |
| FOREIGN KEY(challenge_id) REFERENCES challenge(id) | |
| ); | |
| """) | |
| conn.commit() | |
| return conn | |
| UPLOAD_DIR = os.environ.get("TWINCLASS_UPLOADS", "uploads") | |
| os.makedirs(UPLOAD_DIR, exist_ok=True) | |
| def current_challenge(conn) -> Optional[Tuple[int, str, str]]: | |
| row = conn.execute("SELECT id, title, target_path FROM challenge ORDER BY id DESC LIMIT 1").fetchone() | |
| return row if row else None | |
| def set_new_challenge(conn, title: str, target_img: Image.Image) -> str: | |
| ts = dt.datetime.utcnow().isoformat(timespec="seconds") | |
| fname = f"target_{ts.replace(':','-')}.png" | |
| path = os.path.join(UPLOAD_DIR, fname) | |
| target_img.convert("RGB").save(path) | |
| conn.execute("INSERT INTO challenge(title, created_at, target_path) VALUES (?,?,?)", (title, ts, path)) | |
| conn.commit() | |
| return "✅ New challenge created and locked for students." | |
| def reset_all(conn) -> str: | |
| conn.execute("DELETE FROM submissions") | |
| conn.execute("DELETE FROM challenge") | |
| conn.commit() | |
| return "✅ Reset complete (all challenges and submissions cleared)." | |
| def add_submission(conn, challenge_id: int, nickname: str, prompt: str, img: Image.Image, score: float) -> None: | |
| ts = dt.datetime.utcnow().isoformat(timespec="seconds") | |
| safe = "".join([c for c in nickname.strip()[:24] if c.isalnum() or c in ("-","_")]) or "student" | |
| fname = f"{safe}_{ts.replace(':','-')}.png" | |
| path = os.path.join(UPLOAD_DIR, fname) | |
| img.convert("RGB").save(path) | |
| conn.execute( | |
| "INSERT INTO submissions(challenge_id, nickname, prompt, image_path, score, created_at) VALUES (?,?,?,?,?,?)", | |
| (challenge_id, nickname.strip()[:64], (prompt or "").strip()[:500], path, float(score), ts) | |
| ) | |
| conn.commit() | |
| def leaderboard_df(conn, challenge_id: int): | |
| # Best score per nickname | |
| rows = conn.execute(""" | |
| SELECT nickname, MAX(score) AS best_score, COUNT(*) AS attempts, MIN(created_at) AS first_try, MAX(created_at) AS last_try | |
| FROM submissions | |
| WHERE challenge_id=? | |
| GROUP BY nickname | |
| ORDER BY best_score DESC, last_try ASC | |
| """, (challenge_id,)).fetchall() | |
| import pandas as pd | |
| df = pd.DataFrame(rows, columns=["Nickname", "Best %", "Attempts", "First try (UTC)", "Last try (UTC)"]) | |
| if len(df): | |
| df["Best %"] = df["Best %"].map(lambda x: round(float(x), 2)) | |
| return df | |
| def gallery_items(conn, challenge_id: int, limit: int = 24): | |
| rows = conn.execute(""" | |
| SELECT nickname, score, image_path | |
| FROM submissions | |
| WHERE challenge_id=? | |
| ORDER BY score DESC, created_at DESC | |
| LIMIT ? | |
| """, (challenge_id, limit)).fetchall() | |
| items = [] | |
| for nick, sc, path in rows: | |
| items.append((path, f"{nick} — {sc:.1f}%")) | |
| return items | |
| # --- Gradio App --- | |
| def teacher_panel(admin_key: str, title: str, target_img: Image.Image): | |
| if admin_key != ADMIN_KEY: | |
| return gr.update(value="❌ Wrong admin key."), None, None, None | |
| if not title or target_img is None: | |
| return gr.update(value="❌ Please provide a title and a target image."), None, None, None | |
| conn = db() | |
| msg = set_new_challenge(conn, title.strip()[:120], target_img) | |
| ch = current_challenge(conn) | |
| # Precompute target embedding once and cache in memory (per process) | |
| target_embed = image_embedding(Image.open(ch[2])) | |
| return gr.update(value=msg), ch, ch[1], target_embed | |
| def teacher_reset(admin_key: str): | |
| if admin_key != ADMIN_KEY: | |
| return gr.update(value="❌ Wrong admin key."), None, None, None | |
| conn = db() | |
| msg = reset_all(conn) | |
| return gr.update(value=msg), None, "", None | |
| def load_for_students(): | |
| conn = db() | |
| ch = current_challenge(conn) | |
| if not ch: | |
| # Always return 6 outputs | |
| return None, gr.update(value="No challenge yet. Ask your teacher to set one."), None, None, None, [] | |
| target_img = Image.open(ch[2]) | |
| target_embed = image_embedding(target_img) | |
| df = leaderboard_df(conn, ch[0]) | |
| gal = gallery_items(conn, ch[0]) | |
| return target_img, gr.update(value=f"Challenge: **{ch[1]}**"), ch[0], target_embed, df, gal | |
| def submit_student(nickname: str, prompt: str, student_img: Image.Image, challenge_id: int, target_embed): | |
| if not challenge_id or target_embed is None: | |
| return gr.update(value="❌ No active challenge."), None, None | |
| if not nickname or student_img is None: | |
| return gr.update(value="❌ Add a nickname and upload your image."), None, None | |
| # Score | |
| emb = image_embedding(student_img) | |
| pct = score_percent(target_embed, emb) | |
| conn = db() | |
| add_submission(conn, int(challenge_id), nickname, prompt or "", student_img, pct) | |
| df = leaderboard_df(conn, int(challenge_id)) | |
| gal = gallery_items(conn, int(challenge_id)) | |
| return gr.update(value=f"✅ Submitted! Your likeness score: **{pct:.1f}%**"), df, gal | |
| with gr.Blocks(title="TwinClass: Image Likeness Leaderboard") as demo: | |
| gr.Markdown("# TwinClass 🪞🖼️\nA classroom “TwinPics-style” likeness game: one target image, many student attempts, live leaderboard.\n\n**Tip:** Allow 2–3 attempts and keep the best score to reduce generator randomness.") | |
| with gr.Tab("Student View"): | |
| target = gr.Image(label="Target Image (teacher)", type="pil", interactive=False) | |
| ch_label = gr.Markdown("No challenge yet.") | |
| challenge_id = gr.Number(label="(hidden) challenge id", visible=False) | |
| target_embed = gr.State(None) | |
| with gr.Row(): | |
| nickname = gr.Textbox(label="Nickname", placeholder="e.g., Lina_1", max_lines=1) | |
| prompt = gr.Textbox(label="Prompt you used (optional)", placeholder="Paste your Nano Banana prompt here…", lines=2) | |
| student_img = gr.Image(label="Upload your generated image", type="pil") | |
| submit_btn = gr.Button("Submit") | |
| feedback = gr.Markdown() | |
| leaderboard = gr.Dataframe(label="Leaderboard (best score per nickname)", interactive=False) | |
| gallery = gr.Gallery(label="Top submissions", columns=4, rows=2, height="auto") | |
| refresh_btn = gr.Button("Refresh target + leaderboard") | |
| def refresh(): | |
| timg, lbl, cid, temb, df, gal = load_for_students() | |
| return timg, lbl, cid, temb, df, gal | |
| refresh_btn.click(refresh, outputs=[target, ch_label, challenge_id, target_embed, leaderboard, gallery]) | |
| submit_btn.click(submit_student, inputs=[nickname, prompt, student_img, challenge_id, target_embed], | |
| outputs=[feedback, leaderboard, gallery]) | |
| # Load once on app start | |
| demo.load(refresh, outputs=[target, ch_label, challenge_id, target_embed, leaderboard, gallery]) | |
| with gr.Tab("Teacher Admin"): | |
| gr.Markdown( | |
| "### Teacher: set the target image\n" | |
| "Enter the **teacher admin key** to create or reset a challenge." | |
| ) | |
| admin_key = gr.Textbox(label="Admin key", type="password", placeholder="Enter admin key") | |
| title = gr.Textbox(label="Challenge title", placeholder="e.g., Neon mirror eagles", max_lines=1) | |
| target_img = gr.Image(label="Upload target image", type="pil") | |
| create_btn = gr.Button("Create / Replace Challenge") | |
| reset_btn = gr.Button("Reset EVERYTHING (danger)") | |
| admin_msg = gr.Markdown() | |
| ch_state = gr.State(None) | |
| title_state = gr.State("") | |
| target_state = gr.State(None) | |
| create_btn.click(teacher_panel, inputs=[admin_key, title, target_img], | |
| outputs=[admin_msg, ch_state, title_state, target_state]) | |
| reset_btn.click(teacher_reset, inputs=[admin_key], | |
| outputs=[admin_msg, ch_state, title_state, target_state]) | |
| gr.Markdown("—\n**Privacy tip:** Use nicknames, not full names. Host on your own machine for full control.") | |
| if __name__ == "__main__": | |
| demo.launch(ssr_mode=False) | |