Rename t2i-prompter.py to verifier

t2i-prompter.py

@@ -1,269 +0,0 @@
-import json, time, uuid, random, requests, re
-from pathlib import Path
-
-HOST = "http://127.0.0.1:3020"
-PROMPT_FILE   = "/app/workspace/prompts.txt"
-AUTH_URL = "http://49.12.247.141:8001"  
-
-# Optional: fixed seeds (None = random)
-FIXED_SEEDS = None
-
-# Optional overrides
-OVERRIDE_STEPS    = None
-OVERRIDE_WIDTH    = None
-OVERRIDE_HEIGHT   = None
-OVERRIDE_GUIDANCE = None
-
-# Node-IDs from your workflow
-NODE_PROMPT = "28"
-NODE_NOISE  = "25"
-NODE_SCHED  = "17"
-NODE_LATENT = "5"
-NODE_GUIDE  = "80"
-NODE_SAVE   = "9"
-
-# ===== Translations =====
-TEXTS = {
-    "en": {
-        "intro": """Greta | SimpleAI : Hey! Ready to generate some images? Here’s how it works:
-1️⃣ Don’t forget to fill your prompts.txt file. Separate each prompt with {} and a new line.
-2️⃣ Export your workflow as API (Save (API)) in ComfyUI, save it into the same folder as this script, 
-   and when I ask, type the exact filename (e.g. schedule-prompts-api.json).
-3️⃣ Set the number of times I should loop through the list of prompts.
-4️⃣ Set your resolution. For normal images I recommend 4:5 ➡️ 1080x1350px. 
-   For pictures for reels I recommend 9:16 ➡️ 1080×1920px.
-Then you’re ready to go! 🚀
-To stop this process press CTRL+Z and then type 'kill -9 %1' in the terminal.
-You can follow the process live in ComfyUI. Images will be saved in Outputs.
-""",
-        "understand": "Did you understand? yes/no: ",
-        "not_understood": "Please read the instructions again carefully. 🙏",
-        "ask_api": "Please enter the filename of your exported workflow API JSON (e.g. schedule-prompts-api.json): ",
-        "ask_k": "How many times should I loop through the entire prompt list? [Default {default}]: ",
-        "ask_width": "Enter image width (px): ",
-        "ask_height": "Enter image height (px): ",
-        "invalid": "❌ Invalid input, try again.",
-        "start": "Great! 🎉 We’ll generate {total} images "
-                 "({n_prompts} prompts × {k} runs) at resolution {w}×{h}px.\n",
-        "summary": "=== Summary ===",
-        "done": "✅ All done! Check your Outputs folder."
-    },
-    "de": {
-        "intro": """Greta | SimpleAI : Hey! Bereit ein paar Bilder zu generieren? So funktioniert’s:
-1️⃣ Vergiss nicht deine prompts.txt Datei zu befüllen. Trenne jeden Prompt durch {} und einen Zeilenumbruch.
-2️⃣ Exportiere deinen Workflow in ComfyUI als API (Save (API)), speichere ihn im selben Ordner wie dieses Skript 
-   und gib mir gleich den exakten Dateinamen an (z. B. schedule-prompts-api.json).
-3️⃣ Stelle ein, wie oft ich die Liste der Prompts durchlaufen soll.
-4️⃣ Stelle deine Auflösung ein. Für normale Bilder empfehle ich 4:5 ➡️ 1080x1350px. 
-   Für Bilder für Reels empfehle ich 9:16 ➡️ 1080×1920px.
-Dann bist du ready to go! 🚀
-Um den Prozess zu stoppen drücke STRG+Z und tippe anschließend 'kill -9 %1' im Terminal ein.
-Den Prozess kannst du live in ComfyUI verfolgen. Die Bilder findest du im Output-Ordner.
-""",
-        "understand": "Alles verstanden? ja/nein: ",
-        "not_understood": "Bitte lies dir die Anweisungen noch einmal genau durch. 🙏",
-        "ask_api": "Bitte gib den Dateinamen deiner exportierten Workflow-API-JSON ein (z. B. schedule-prompts-api.json): ",
-        "ask_k": "Wie oft soll ich die gesamte Prompt-Liste durchlaufen? [Standard {default}]: ",
-        "ask_width": "Gib die Bildbreite (px) ein: ",
-        "ask_height": "Gib die Bildhöhe (px) ein: ",
-        "invalid": "❌ Ungültige Eingabe, versuche es erneut.",
-        "start": "Super! 🎉 Wir generieren {total} Bilder "
-                 "({n_prompts} Prompts × {k} Durchläufe) in Auflösung {w}×{h}px.\n",
-        "summary": "=== Zusammenfassung ===",
-        "done": "✅ Fertig! Schau im Output-Ordner nach."
-    }
-}
-
-# ===== Helpers =====
-def load_graph(path: str) -> dict:
-    obj = json.loads(Path(path).read_text(encoding="utf-8"))
-    return obj["prompt"] if "prompt" in obj else obj
-
-def load_prompts(path: str):
-    text = Path(path).read_text(encoding="utf-8")
-    parts = re.findall(r"\{(.*?)\}", text, flags=re.DOTALL)
-    return [p.strip() for p in parts if p.strip()]
-
-def slug(s, maxlen=40):
-    s = re.sub(r"[^a-zA-Z0-9]+", "-", s).strip("-").lower()
-    return (s[:maxlen].rstrip("-") or "img")
-
-def post_prompt(graph: dict, client_id: str) -> str:
-    r = requests.post(f"{HOST}/prompt", json={"prompt": graph, "client_id": client_id}, timeout=60)
-    r.raise_for_status()
-    return r.json().get("prompt_id")
-
-def wait_done(prompt_id: str, poll=1.0, timeout=600) -> dict:
-    t0 = time.time()
-    while True:
-        r = requests.get(f"{HOST}/history/{prompt_id}", timeout=30)
-        if r.ok:
-            j = r.json()
-            if j.get(prompt_id, {}).get("outputs"):
-                return j[prompt_id]
-        if time.time() - t0 > timeout:
-            raise TimeoutError(f"Timeout after {timeout}s")
-        time.sleep(poll)
-
-def extract_files(history_obj: dict):
-    files = []
-    for _, node_out in history_obj.get("outputs", {}).items():
-        for im in node_out.get("images", []):
-            if im.get("filename"):
-                files.append(im["filename"])
-    return files
-
-# ===== Dialogs =====
-def choose_language():
-    while True:
-        lang = input("Greta | SimpleAI : english or german? ").strip().lower()
-        if lang in ["english", "en"]:
-            return "en"
-        elif lang in ["german", "deutsch", "de"]:
-            return "de"
-        else:
-            print("❌ Invalid choice, type 'english' or 'german'.")
-
-def dialog_intro(TEXT):
-    print(TEXT["intro"])
-    while True:
-        understood = input(TEXT["understand"]).strip().lower()
-        if understood in ["yes", "y", "ja", "j"]:
-            break
-        elif understood in ["no", "n", "nein"]:
-            print(TEXT["not_understood"])
-        else:
-            print(TEXT["invalid"])
-
-def ask_api_filename(TEXT):
-    while True:
-        fname = input(TEXT["ask_api"]).strip()
-        # baue den Pfad mit workspace-Verzeichnis
-        full_path = Path("/app/workspace") / fname
-        if full_path.exists():
-            return str(full_path)
-        else:
-            print("❌ File not found in /app/workspace, please try again.")
-
-def ask_k(TEXT, default=1):
-    while True:
-        raw = input(TEXT["ask_k"].format(default=default)).strip()
-        if raw == "":
-            return default
-        try:
-            k = int(raw)
-            if k > 0:
-                return k
-        except ValueError:
-            pass
-        print(TEXT["invalid"])
-
-def ask_resolution(TEXT):
-    while True:
-        try:
-            w = int(input(TEXT["ask_width"]).strip())
-            h = int(input(TEXT["ask_height"]).strip())
-            if w > 0 and h > 0:
-                return w, h
-        except ValueError:
-            pass
-        print(TEXT["invalid"])
-
-def membership_check(email, discord_id):
-    try:
-        r = requests.post(
-            f"{AUTH_URL}/check",
-            json={"email": email, "discord_id": discord_id},  # <--- richtiges Feld
-            timeout=10
-        )
-
-        if r.status_code != 200:
-            print("❌ Membership inactive:", r.text)
-            return False
-
-        data = r.json()
-        if not data.get("active"):
-            print("❌ Membership inactive:", data)
-            return False
-
-        return True
-
-    except Exception as e:
-        print("❌ Could not contact auth server:", e)
-        return False
-
-# ===== Main =====
-def main():
-    email = input("Enter your membership email: ").strip()
-    discord = input("Enter your Discord-ID: ").strip()
-
-    if not membership_check(email, discord):
-        print("❌ Access denied. Exiting.")
-        return
-
-    lang = choose_language()
-    TEXT = TEXTS[lang]
-
-    dialog_intro(TEXT)
-    api_filename = ask_api_filename(TEXT)
-
-    base = load_graph(api_filename)
-    prompts = load_prompts(PROMPT_FILE)
-    if not prompts:
-        print("❌ No prompts found in prompts.txt")
-        return
-
-    client_id = str(uuid.uuid4())
-    k = ask_k(TEXT, default=1)
-    w, h = ask_resolution(TEXT)
-
-    total = len(prompts) * k
-    print(TEXT["start"].format(total=total, n_prompts=len(prompts), k=k, w=w, h=h))
-
-    summary = []
-    run_counter = 0
-
-    for run in range(1, k+1):
-        print(f"=== Run {run}/{k} ===")
-        for i, prompt_text in enumerate(prompts, 1):
-            run_counter += 1
-            g = json.loads(json.dumps(base))
-
-            # Prompt
-            g[NODE_PROMPT]["inputs"]["string"] = prompt_text
-
-            # Seed
-            if FIXED_SEEDS:
-                seed = int(FIXED_SEEDS[(run_counter-1) % len(FIXED_SEEDS)])
-            else:
-                seed = random.randrange(0, 2**31 - 1)
-            g[NODE_NOISE]["inputs"]["noise_seed"] = seed
-
-            # Overrides
-            if OVERRIDE_STEPS is not None:
-                g[NODE_SCHED]["inputs"]["steps"] = int(OVERRIDE_STEPS)
-            if w and h:
-                g[NODE_LATENT]["inputs"]["width"] = int(w)
-                g[NODE_LATENT]["inputs"]["height"] = int(h)
-            if OVERRIDE_GUIDANCE is not None:
-                g[NODE_GUIDE]["inputs"]["guidance"] = float(OVERRIDE_GUIDANCE)
-
-            # Filename
-            prefix = f"r{run:02d}_p{i:02d}_{slug(prompt_text)}"
-            g[NODE_SAVE]["inputs"]["filename_prefix"] = prefix
-
-            pid = post_prompt(g, client_id)
-            print(f"[{run}/{k} · {i}/{len(prompts)}] pid={pid} seed={seed} prefix={prefix}")
-            hist = wait_done(pid)
-            files = extract_files(hist)
-            print(" -> Files:", files)
-            summary.append({"run": run, "prompt": prompt_text, "seed": seed, "files": files})
-
-    print("\n" + TEXT["summary"])
-    for row in summary:
-        print(f"- Run {row['run']} | Prompt: {row['prompt']}\n"
-              f"  Seed: {row['seed']}\n  Files: {row['files']}\n")
-    print(TEXT["done"])
-
-if __name__ == "__main__":
-    main()

verifier

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+import os
+import sys
+import json
+import time
+import zipfile
+import requests
+from pathlib import Path
+
+AUTH_URL = os.environ.get("AUTH_URL", "http://49.12.247.141:8001")
+HF_URL = "https://huggingface.co/simpleai22/simple-workflows/resolve/main/simple_workflows.zip"
+
+DEST_DIR = Path("/app/workspace")
+ZIP_PATH = DEST_DIR / "simple_workflows.zip"
+
+# Optional: falls ZIP verschlüsselt ist (ZipCrypto)
+ZIP_PASSWORD = os.environ.get("ZIP_PASSWORD", "simpleai22rockt")  # bei Bedarf anpassen oder leer lassen
+
+# Optional: falls das HF-Repo privat ist
+HF_TOKEN = os.environ.get("HF_TOKEN", "").strip()
+
+TIMEOUT = 20
+
+
+def membership_check(email: str, discord_id: str) -> bool:
+    """Verifiziert Membership via Auth-Server."""
+    try:
+        r = requests.post(
+            f"{AUTH_URL}/check",
+            json={"email": email, "discord_id": discord_id},
+            timeout=TIMEOUT,
+        )
+        if r.status_code != 200:
+            print(f"❌ Auth server returned {r.status_code}: {r.text}")
+            return False
+
+        data = r.json()
+        if not data.get("active"):
+            print(f"❌ Membership inactive: {data}")
+            return False
+
+        print("✅ Membership verified.")
+        return True
+    except requests.RequestException as e:
+        print(f"❌ Could not contact auth server: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error during verification: {e}")
+        return False
+
+
+def download_zip(url: str, dest_path: Path, token: str = "") -> None:
+    """Lädt die ZIP per Streaming-Download."""
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    headers = {}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    print(f"⬇️  Downloading ZIP to {dest_path} ...")
+    with requests.get(url, stream=True, headers=headers, timeout=TIMEOUT) as r:
+        r.raise_for_status()
+        total = int(r.headers.get("content-length", 0))
+        downloaded = 0
+        chunk_size = 1024 * 256
+        with open(dest_path, "wb") as f:
+            for chunk in r.iter_content(chunk_size=chunk_size):
+                if chunk:
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    if total:
+                        pct = downloaded * 100 // total
+                        print(f"\r   {downloaded}/{total} bytes ({pct}%)", end="")
+        print()
+
+    if not dest_path.exists() or dest_path.stat().st_size == 0:
+        raise RuntimeError("Download failed or file is empty")
+
+    print("✅ Download complete.")
+
+
+def extract_zip(zip_path: Path, target_dir: Path) -> None:
+    """Entpackt ZIP; versucht erst ohne Passwort, dann (falls nötig) mit ZIP_PASSWORD."""
+    print(f"📦 Extracting into {target_dir} ...")
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    def _extract(zf: zipfile.ZipFile, pwd: bytes | None):
+        for member in zf.infolist():
+            # Sicherheit: keine Pfad-Traversal
+            extracted_path = target_dir / member.filename
+            if not str(extracted_path.resolve()).startswith(str(target_dir.resolve())):
+                raise RuntimeError(f"Blocked suspicious path: {member.filename}")
+            zf.extract(member, path=target_dir, pwd=pwd)
+
+    try:
+        with zipfile.ZipFile(zip_path) as zf:
+            try:
+                # Versuch ohne Passwort
+                _extract(zf, None)
+                print("✅ Extracted without password.")
+                return
+            except RuntimeError as e:
+                # evtl. verschlüsselt
+                if "encrypted" not in str(e).lower():
+                    raise
+                print("ℹ️ ZIP seems encrypted. Trying with password ...")
+                zf.close()
+
+        # erneutes Öffnen und mit Passwort versuchen
+        with zipfile.ZipFile(zip_path) as zf:
+            pwd = ZIP_PASSWORD.encode("utf-8") if ZIP_PASSWORD else None
+            if not pwd:
+                raise RuntimeError("ZIP is encrypted but no password provided.")
+            _extract(zf, pwd)
+            print("✅ Extracted with password.")
+
+    except zipfile.BadZipFile:
+        raise RuntimeError("Invalid or corrupted ZIP file.")
+    except Exception as e:
+        raise RuntimeError(f"Extraction failed: {e}") from e
+
+
+def main():
+    print("=== Verification required ===")
+    email = input("Enter your membership email: ").strip()
+    discord = input("Enter your Discord-ID: ").strip()
+
+    if not email or not discord:
+        print("❌ Email and Discord-ID are required.")
+        sys.exit(1)
+
+    if not membership_check(email, discord):
+        print("❌ Access denied. Exiting.")
+        sys.exit(1)
+
+    try:
+        download_zip(HF_URL, ZIP_PATH, token=HF_TOKEN)
+        extract_zip(ZIP_PATH, DEST_DIR)
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        sys.exit(1)
+    finally:
+        # ZIP aufräumen
+        if ZIP_PATH.exists():
+            try:
+                ZIP_PATH.unlink()
+                print("🧹 Removed ZIP file.")
+            except Exception as e:
+                print(f"⚠️ Could not remove ZIP: {e}")
+
+    print(f"✅ Done. Files are ready in: {DEST_DIR}")
+
+
+if __name__ == "__main__":
+    main()