Update app.py

app.py

@@ -11,212 +11,125 @@ import sys
 import os
 import re
 import random
-import torch
 import gc
 import logging
 import time
 import io
 import threading
-import urllib.request
-import zipfile
 from datetime import datetime
-from diffusers import (
-    StableDiffusionXLPipeline,
-    StableDiffusionXLImg2ImgPipeline,
-    EulerDiscreteScheduler,
-)
-from huggingface_hub import hf_hub_download, HfApi, CommitOperationAdd
-from huggingface_hub.utils import HfHubHTTPError
+
+import torch
 from PIL import Image
 import gradio as gr
+from huggingface_hub import hf_hub_download, HfApi, CommitOperationAdd
+from huggingface_hub.utils import HfHubHTTPError
 
-# ===== SETUP LOGGING CONFIGURATION =====
+# ===== LOGGING =====
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[logging.StreamHandler(sys.stdout)],
 )
-logger = logging.getLogger("AdultAIEngine")
-logger.info("🚀 Initialization: Mad-mode engine live (3 chefs, stackable styles, batch 3).")
+logger = logging.getLogger("NextGenEngine")
+logger.info("🚀 Next-gen multi-engine Space boot (FLUX / SD3.5 / Adult SDXL)")
 
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8")
 if hasattr(sys.stderr, "reconfigure"):
     sys.stderr.reconfigure(encoding="utf-8")
 
-# ===== CONFIGURATIONS & PRESETS =====
-HF_REPO_ID = "AriaVale2/my-safetensors-backup"
+BACKUP_DATASET_ID = "JustinD/generation-images"
+LAST_GEN_TIME = {}
+COOLDOWN_SECONDS = 8
 
+# ---------------------------------------------------------------------------
+# ENGINES
+# ---------------------------------------------------------------------------
+ENGINE_FLUX = "FLUX.1 Schnell (latest fast)"
+ENGINE_SD35 = "SD 3.5 Medium (latest quality)"
+ENGINE_SDXL = "Adult SDXL (NSFW chefs)"
+
+ENGINE_CHOICES = [ENGINE_FLUX, ENGINE_SD35, ENGINE_SDXL]
+
+# Adult SDXL single-file + Diffusers (proven Justin lane)
+HF_REPO_ID = "AriaVale2/my-safetensors-backup"
 MODEL_REPOS = {
+    "pornworksSexyBeauty_v04.safetensors": "AI-Porn/PornWorks-Sexy-Beauty-Aesthetic-Erotic-NSFW-SDXL-Chekpoint",
+    "pornworksRealPornPhoto_v04.safetensors": "Manjushri/pornworks-real-porn-photo-realistic-nsfw-sdxl-and-pony-chekpoint",
+    "pornworksHardcoreFantasy_v04.safetensors": "AI-Porn/PornWorks-Hardcore-Fantasy-NSFW-3D-SDXL-Chekpoint",
+    "CyberRealisticXLPlay_V10.0_FP16.safetensors": "cyberdelia/CyberRealisticXL",
     "Juggernaut-XL_v9_RunDiffusionPhoto_v2.safetensors": "saber-end/Juggernaut-XL-v9",
     "RealVisXL_V4.0.safetensors": "SG161222/RealVisXL_V4.0",
-    "CyberRealisticXLPlay_V10.0_FP16.safetensors": "cyberdelia/CyberRealisticXL",
-    "animagine-xl-4.0.safetensors": "cagliostrolab/animagine-xl-4.0",
-    "OnomaAIResearch_Illustrious-XL-v1.0.safetensors": "AriaVale2/my-safetensors-backup",
     "Pony Diffusion V6 XL.safetensors": "AriaVale2/my-safetensors-backup",
     "Hassaku XL (Illustrious).safetensors": "AriaVale2/my-safetensors-backup",
-    "pornworksRealPornPhoto_v04.safetensors": "Manjushri/pornworks-real-porn-photo-realistic-nsfw-sdxl-and-pony-chekpoint",
-    "pornworksSexyBeauty_v04.safetensors": "AI-Porn/PornWorks-Sexy-Beauty-Aesthetic-Erotic-NSFW-SDXL-Chekpoint",
-    "pornworksHardcoreFantasy_v04.safetensors": "AI-Porn/PornWorks-Hardcore-Fantasy-NSFW-3D-SDXL-Chekpoint",
+    "animagine-xl-4.0.safetensors": "cagliostrolab/animagine-xl-4.0",
+    "OnomaAIResearch_Illustrious-XL-v1.0.safetensors": "AriaVale2/my-safetensors-backup",
     "UnfilteredAI_NSFW-GEN-ANIME-v2.safetensors": "AriaVale2/my-safetensors-backup",
     "Mala Anime Mix NSFW PonyXL.safetensors": "AriaVale2/my-safetensors-backup",
     "PornWorks_Anime_Desire_NSFW_Anime_Hentai_SDXL_Pony_Chekpoint.safetensors": "AriaVale2/my-safetensors-backup",
 }
 
 DIFFUSERS_MODELS = {
-    "OhMyDaughter Beautiful Woman (Pony)": "John6666/omd-ohmaydaughter-beautiful-woman-pony-v10-sdxl",
     "OhMySister Beautiful Asian Woman": "John6666/oms-oh-my-sister-beautiful-asian-woman-v10-sdxl",
+    "OhMyDaughter Beautiful Woman (Pony)": "John6666/omd-ohmaydaughter-beautiful-woman-pony-v10-sdxl",
     "Fucktastic Anime Pony NSFW": "John6666/fucktastic-anime-checkpoint-pony-pdxl-porn-nsfw-sfw-22-sdxl",
     "Mala Anime Mix NSFW Pony v7": "John6666/mala-anime-mix-nsfw-pony-xl-v7-sdxl",
     "YAAI WAI NSFW Illustrious": "John6666/yaai-yet-another-anime-illustrious-model-full-fine-tune-based-on-wai-nsfw-v20-sdxl",
     "Flare Diffusion NSFW Anime": "John6666/flare-diffusion-nsfw-v16-semi-realism-anime-sdxl",
-    "Perfect RSB Anime Cartoon Hentai": "John6666/perfect-rsb-mix-illustrious-real-anime-sfw-nsfw-definitive-iota-sdxl",
     "PornWorks Anime Desire (Diffusers)": "John6666/pornworks-anime-desire-nsfw-pony-sdxl",
-    "NSFW Anime XL v1": "John6666/nsfw-anime-xl-v1-sdxl",
-    "Coco Anime Pony Turnup": "John6666/coco-anime-pony-model-final-sfw-nsfw-turnup-sdxl",
-    "Easy Full NSFW Pony": "John6666/easy-sfw-nsfw-pony-xl-fullnsfwv1-sdxl",
-    "Perfect RSB Pony Real Anime": "John6666/perfect-rsb-mix-pony-real-anime-sfw-nsfw-lastversion-sdxl",
 }
 
-BACKUP_DATASET_ID = "JustinD/generation-images"
-
-LAST_GEN_TIME = {}
-COOLDOWN_SECONDS = 10
+SDXL_CHOICES = list(DIFFUSERS_MODELS.keys()) + list(MODEL_REPOS.keys())
 
-# Stackable style packs (CheckboxGroup). Pick several at once.
-STYLE_KEYWORDS = {
+STYLE_PACKS = {
     "Men Only": {
-        "prefix": "for men's eyes only, hyper sexual pinup porn asina big tits, looking down her top, hungry male gaze with big tits, high angle looking down at her big tits and her top that is too small for her",
-        "suffix": "deep cleavage focus, arched back, chest out and full tits, sexy eyes",
+        "prefix": "for men's eyes only, hyper sexual pinup, hungry male gaze",
+        "suffix": "deep cleavage, arched back, bedroom eyes, wet parted lips",
     },
-    "Cartoon Slut": {
-        "prefix": "score_9, score_8_up, score_7_up, source_anime, source_cartoon, rating_explicit, anime cartoon cel shading, thick ink lineart, glossy highlights",
-        "suffix": "slutty pinup pose, exaggerated hourglass, large breasts, full breasts, heavy breasts, deep cleavage",
+    "Art Nude": {
+        "prefix": "classical art nude, museum erotic nude",
+        "suffix": "bare breasts, soft weight, masterpiece lighting",
     },
-    "Art Nude Meta": {
-        "prefix": "classical art nude, museum erotic nude, adult East Asian woman early 40s, Chinese, Japanese, Korean",
-        "suffix": "large breasts, full breasts, heavy breasts, bare full tits and breasts, masterpiece paint texture",
+    "Cartoon Slut": {
+        "prefix": "score_9, score_8_up, source_anime, rating_explicit, anime cartoon cel shading",
+        "suffix": "slutty pinup, exaggerated hourglass, heavy cleavage",
     },
     "Rembrandt Oil": {
-        "prefix": "Rembrandt oil painting, warm Rembrandt side light, visible brushstrokes, rich brown shadows",
-        "suffix": "classical academic nude energy, oil paint skin",
-    },
-    "Rubens Baroque": {
-        "prefix": "Rubens baroque oil painting, lush soft flesh, warm golden glow, dramatic drapery",
-        "suffix": "voluptuous hourglass, soft weighty breasts, old master nude",
-    },
-    "Caravaggio Light": {
-        "prefix": "Caravaggio Baroque oil painting, dramatic chiaroscuro, candle lit, deep black background",
-        "suffix": "spotlight on body, erotic old master composition",
-    },
-    "Ingres Salon": {
-        "prefix": "Jean-Auguste-Dominique Ingres neoclassical oil painting, smooth porcelain skin, salon nude",
-        "suffix": "elegant erotic academic pose, refined classical anatomy",
-    },
-    "Klimt Gold": {
-        "prefix": "Gustav Klimt style, gold leaf patterns, ornate mosaic backdrop, Art Nouveau erotic",
-        "suffix": "decorative gold frame energy, sensual patterned nude",
-    },
-    "Art Nouveau": {
-        "prefix": "Alphonse Mucha Art Nouveau poster, gold ornate linework, floral decorative borders",
-        "suffix": "elegant erotic illustration, flowing hair, classic poster nude",
-    },
-    "Titian Venetian": {
-        "prefix": "Titian Venetian Renaissance oil, rich red drapery, warm skin glazes",
-        "suffix": "reclining odalisque energy, classical erotic painting",
-    },
-    "Boucher Rococo": {
-        "prefix": "Francois Boucher rococo oil, soft pastel light, silk pillows, playful erotic",
-        "suffix": "flushed skin, intimate boudoir nude",
-    },
-    "Nude": {
-        "prefix": "Full body",
-        "suffix": "nude woman, large breasts, full breasts, heavy breasts, bare breasts",
-    },
-    "Editorial Lingerie": {
-        "prefix": "photorealistic editorial fashion photo, dramatic side lighting, chiaroscuro",
-        "suffix": "high-end lingerie campaign, soft warm interior background, sharp focus, cleavage",
-    },
-    "Erk Pin-up": {
-        "prefix": "Erk IAart style, polished anime digital pin-up, clean lineart, soft airbrushed shading",
-        "suffix": "hourglass figure, lace thigh highs, garter straps, soft warm lighting, large breasts, cleavage",
+        "prefix": "Rembrandt oil painting, warm side light, visible brushstrokes",
+        "suffix": "classical academic nude energy",
     },
     "4K TV Wide": {
-        "prefix": "16:9 ultra wide composition, cinematic framing for 4K TV, razor sharp details, high contrast",
-        "suffix": "clean edges when blown up large, living-room TV wall look",
-    },
-    "Harness Chains": {
-        "prefix": "dark emerald leather body harness, thick straps, metal rings buckles, silver chains draped across chest and hips",
-        "suffix": "harness framing and lifting breasts, oiled shiny skin, ultra detailed leather and chain metal",
+        "prefix": "16:9 ultra wide cinematic framing for 4K TV",
+        "suffix": "razor sharp when blown up large",
     },
-    "Library Sofa": {
-        "prefix": "brown tufted leather Chesterfield sofa, busy classic library, floor to ceiling packed bookshelves, warm brass lamp, whiskey glass",
-        "suffix": "soft golden light, ultra detailed books leather fabric skin",
+    "Photo Gloss": {
+        "prefix": "photorealistic, wet shiny skin, editorial flash",
+        "suffix": "ultra detailed skin pores and fabric",
     },
 }
 
-STYLE_CHOICES = list(STYLE_KEYWORDS.keys())
-
-DEFAULT_QUALITY_PREFIX = "(masterpiece huge tits:1.2), (best quality:1.2), (detailed face:1.2), beautifully framed, for men's eyes only"
-QUALITY_TAGS = (
-    "perfect anatomy, proportional body, correct proportions, "
-    "large breasts, full breasts, heavy breasts, cleavage, deep cleavage, "
-    "perky breasts, round breasts, natural breasts, breasts straining fabric, "
-    "tiny waist, wide hips, thick thighs, hourglass figure, "
-    "ultra-detailed iris, sub-surface skin scattering, smooth detailed skin texture, "
-    "seductive expression, bedroom eyes, parted glossy lips"
+DEFAULT_QUALITY = (
+    "masterpiece, best quality, detailed face, "
+    "adult Korean woman late 20s, beautiful Korean face, "
+    "large breasts, full breasts, heavy breasts, cleavage, "
+    "tiny waist, wide hips, hourglass figure"
 )
 
 BASE_NEGATIVES = (
-    "small tits, small breasts, small chest, flat chest, tiny breasts, "
-    "bad hands, deformed hands, malformed hands, fused fingers, extra fingers, missing fingers, "
-    "too many fingers, bad finger anatomy, webbed fingers, blurry hands, poorly drawn hands, "
-    "bad anatomy, wrong anatomy, bad eyes, deformed eyes, mismatched eyes, dead eyes, empty eyes, "
-    "blurry eyes, poorly drawn eyes, low quality eyes, extra limbs, extra arms, extra legs, mutated, "
-    "disfigured, ugly, deformed, bad proportions, asymmetrical breasts, "
-    "bad face, ugly face, blurry face, plastic skin, doll, barbie, child, loli, underage, censored, "
-    "watermark, text, signature, grainy, noisy, lowres, worst quality, "
-    "elongated torso, stretched body, distorted anatomy, long neck, deformed spine, elongated body"
+    "child, loli, underage, teen, young, "
+    "small breasts, flat chest, bad hands, extra fingers, deformed, "
+    "blurry, lowres, watermark, text, censored, ugly"
 )
 
-MODEL_CHOICES = [
-    "Fucktastic Anime Pony NSFW",
-    "Mala Anime Mix NSFW Pony v7",
-    "YAAI WAI NSFW Illustrious",
-    "Flare Diffusion NSFW Anime",
-    "Perfect RSB Anime Cartoon Hentai",
-    "Perfect RSB Pony Real Anime",
-    "PornWorks Anime Desire (Diffusers)",
-    "NSFW Anime XL v1",
-    "Coco Anime Pony Turnup",
-    "Easy Full NSFW Pony",
-    "OhMyDaughter Beautiful Woman (Pony)",
-    "OhMySister Beautiful Asian Woman",
-    "PornWorks_Anime_Desire_NSFW_Anime_Hentai_SDXL_Pony_Chekpoint.safetensors",
-    "UnfilteredAI_NSFW-GEN-ANIME-v2.safetensors",
-    "Mala Anime Mix NSFW PonyXL.safetensors",
-    "pornworksSexyBeauty_v04.safetensors",
-    "pornworksRealPornPhoto_v04.safetensors",
-    "pornworksHardcoreFantasy_v04.safetensors",
-    "CyberRealisticXLPlay_V10.0_FP16.safetensors",
-    "Pony Diffusion V6 XL.safetensors",
-    "Hassaku XL (Illustrious).safetensors",
-    "animagine-xl-4.0.safetensors",
-    "OnomaAIResearch_Illustrious-XL-v1.0.safetensors",
-    "Juggernaut-XL_v9_RunDiffusionPhoto_v2.safetensors",
-    "RealVisXL_V4.0.safetensors",
-]
-
-BLEND_NONE = "(none - skip this chef)"
-MODEL_CHOICES_OPTIONAL = [BLEND_NONE] + MODEL_CHOICES
-
 RANDOM_PROMPTS = [
-    "adult East Asian woman 20s early 20s, a lot of asians features, tit's face, bedroom sex eyes, parted glossy lips, long sleek black hair, extreme hourglass, tiny waist, wide hips, thick thighs, large breasts, full breasts, heavy breasts, bare breasts, erect nipples, classical art nude, reclining odalisque on silk drapery",
-    "adult East Asian woman late 20s early 30s, Chinese Japanese Korean features, beautiful slutty face, wet parted lips, long messy black hair, extreme hourglass, large breasts, full breasts, heavy breasts, deep cleavage, modern erotic qipao ripped open, translucent lace, ultra high slit, oiled shiny skin, for men's eyes only",
-    "adult East Asian woman, cartoon anime slut pinup, huge breasts, heavy cleavage, tiny waist, wide hips, sheer lingerie, shiny skin, looking at viewer, seductive smile, busy cluttered bedroom, male gaze low angle",
+    "adult Korean woman late 20s, beautiful Korean face, bedroom eyes, parted glossy lips, long wavy black hair, extreme hourglass, large breasts, full breasts, heavy breasts, bare breasts, soft weight, classical art nude, warm Rembrandt light",
+    "adult Korean woman late 20s, tight black crop top no bra, tiny skirt, deep cleavage, wet shiny skin, luxury condo night, for men's eyes only",
+    "adult Korean woman late 20s, anime cartoon slut pinup, huge breasts, heavy cleavage, sheer lingerie, looking at viewer, busy bedroom",
 ]
 
-# ===== LOAD RESTRICTED WORDS =====
+# ---------------------------------------------------------------------------
+# SAFETY
+# ---------------------------------------------------------------------------
 FORBIDDEN_KEYWORDS = []
 if os.path.exists("restricted_words.txt"):
     try:
@@ -227,17 +140,17 @@ if os.path.exists("restricted_words.txt"):
                 if line.strip() and not line.strip().startswith("#")
             ]
     except Exception as e:
-        logger.error(f"❌ Failed to load restricted words: {str(e)}")
+        logger.error(f"restricted words load failed: {e}")
 
 AGE_PATTERN = re.compile(
     r"\b(one|two|three|four|five|six|seven|eight|nine|ten|"
-    r"eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen"
-    r"|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17)"
+    r"eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|"
+    r"1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17)"
     r"\s*[-\s]?\s*(year|yr|y\/o|yo)\b"
 )
 
 
-def check_prompt_safety(prompt):
+def check_prompt_safety(prompt: str):
     clean = prompt.lower().replace("-", " ").replace("_", " ")
     for word in FORBIDDEN_KEYWORDS:
         if word in clean:
@@ -248,15 +161,14 @@ def check_prompt_safety(prompt):
     return True, None
 
 
-def build_style_layers(selected_styles):
-    """Stack multiple style packs into one prefix/suffix pair."""
-    if not selected_styles:
+def build_styles(selected):
+    if not selected:
         return "", ""
-    if isinstance(selected_styles, str):
-        selected_styles = [selected_styles]
+    if isinstance(selected, str):
+        selected = [selected]
     prefixes, suffixes = [], []
-    for name in selected_styles:
-        cfg = STYLE_KEYWORDS.get(name)
+    for name in selected:
+        cfg = STYLE_PACKS.get(name)
         if not cfg:
             continue
         if cfg.get("prefix"):
@@ -266,571 +178,358 @@ def build_style_layers(selected_styles):
     return ", ".join(prefixes), ", ".join(suffixes)
 
 
-def send_telegram_zipped_document(img_bytes, filename_base, username, model_name, prompt, seed, width, height, steps, cfg_scale):
-    bot_token = os.environ.get("TELEGRAM_BOT_TOKEN")
-    chat_id = os.environ.get("TELEGRAM_CHAT_ID")
-    if not bot_token or not chat_id:
-        return
-    try:
-        zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-            zip_file.writestr(f"{filename_base}.webp", img_bytes)
-        zip_buffer.seek(0)
-        zip_data = zip_buffer.getvalue()
-
-        safe_prompt = prompt if len(prompt) < 700 else prompt[:700] + "..."
-        caption_text = (
-            f"📦 ADULT AI ZIP ARCHIVE DISPATCH 📦\n"
-            f"━━━━━━━━━━━━━━━━━━━\n"
-            f"👤 User ID: {username} \n"
-            f"🤖 Model: {model_name} \n"
-            f"🎲 Seed Token: {seed} \n"
-            f"📐 Resolution: {width}x{height} \n"
-            f"📊 Configs: {steps} steps | CFG {cfg_scale}\n"
-            f"━━━━━━━━━━━━━━━━━━━\n"
-            f"💬 Prompt: \n {safe_prompt} "
-        )
-
-        boundary = "----AdultAIEngineBoundary" + str(int(time.time()))
-        body = []
-        parts = [
-            ("chat_id", chat_id),
-            ("caption", caption_text),
-            ("parse_mode", "HTML"),
-        ]
-        for key, val in parts:
-            body.append(f"--{boundary}".encode("utf-8"))
-            body.append(f'Content-Disposition: form-data; name="{key}"'.encode("utf-8"))
-            body.append(b"")
-            body.append(str(val).encode("utf-8"))
-
-        body.append(f"--{boundary}".encode("utf-8"))
-        body.append(
-            f'Content-Disposition: form-data; name="document"; filename="{filename_base}.zip"'.encode("utf-8")
-        )
-        body.append(b"Content-Type: application/zip")
-        body.append(b"")
-        body.append(zip_data)
-        body.append(f"--{boundary}--".encode("utf-8"))
-        body.append(b"")
-
-        payload_body = b"\r\n".join(body)
-        req = urllib.request.Request(
-            f"https://api.telegram.org/bot{bot_token}/sendDocument",
-            data=payload_body,
-            method="POST",
-        )
-        req.add_header("Content-Type", f"multipart/form-data; boundary={boundary}")
-        req.add_header("Content-Length", str(len(payload_body)))
-        with urllib.request.urlopen(req, timeout=15) as response:
-            response.read()
-    except Exception as e:
-        logger.error(f"⚠️ Telegram dispatch failed: {str(e)}")
-
+# ---------------------------------------------------------------------------
+# LOGGING UPLOAD (same pantry)
+# ---------------------------------------------------------------------------
 
-def async_traffic_log_upload_worker(pil_img, seed, model_name, prompt, username, width, height, steps, cfg_scale):
+def async_log_upload(pil_img, seed, model_name, prompt, username, width, height, steps, cfg_scale):
     hf_token = os.environ.get("HF_TOKEN")
-    if not username or username.strip() == "":
+    if not username or not str(username).strip():
         username = "Unknown_Visitor"
-
     timestamp = int(time.time())
-    clean_model_name = str(model_name).split(".")[0][:10]
-    filename_base = f"gen_{timestamp}_seed_{seed}_{clean_model_name}"
-
-    img_byte_arr = io.BytesIO()
-    pil_img.save(img_byte_arr, format="WEBP", quality=95)
-    raw_webp_bytes = img_byte_arr.getvalue()
-
-    send_telegram_zipped_document(
-        raw_webp_bytes, filename_base, username, model_name, prompt, seed, width, height, steps, cfg_scale
-    )
-
+    clean = str(model_name).replace("/", "_")[:18]
+    filename_base = f"gen_{timestamp}_seed_{seed}_{clean}"
+    buf = io.BytesIO()
+    pil_img.save(buf, format="WEBP", quality=95)
+    raw = buf.getvalue()
     if not hf_token:
-        logger.error(
-            f"❌ HF_TOKEN not found in environment for {username}'s generation — upload skipped entirely (this is the silent failure)."
-        )
+        logger.error("HF_TOKEN missing — log upload skipped")
         return
-
     api = HfApi(token=hf_token)
     date_str = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timestamp))
     log_entry = f"[{date_str}] | User: {username} | Model: {model_name} | Seed: {seed} | Prompt: {prompt[:150]}...\n"
-    user_log_filename = f"user_logs/{username}_history.txt"
-
-    max_attempts = 4
-    for attempt in range(1, max_attempts + 1):
+    user_log = f"user_logs/{username}_history.txt"
+    for attempt in range(1, 4):
         try:
             try:
-                traffic_path = hf_hub_download(
-                    repo_id=BACKUP_DATASET_ID,
-                    filename="traffic_logs.txt",
-                    repo_type="dataset",
-                    token=hf_token,
-                )
-                with open(traffic_path, "r", encoding="utf-8") as f:
-                    current_logs = f.read()
+                path = hf_hub_download(BACKUP_DATASET_ID, "traffic_logs.txt", repo_type="dataset", token=hf_token)
+                current = open(path, encoding="utf-8").read()
             except Exception:
-                current_logs = "=== TRAFFIC LOGS ===\n"
-
+                current = "=== TRAFFIC LOGS ===\n"
             try:
-                user_log_path = hf_hub_download(
-                    repo_id=BACKUP_DATASET_ID,
-                    filename=user_log_filename,
-                    repo_type="dataset",
-                    token=hf_token,
-                )
-                with open(user_log_path, "r", encoding="utf-8") as f:
-                    user_logs = f.read()
+                upath = hf_hub_download(BACKUP_DATASET_ID, user_log, repo_type="dataset", token=hf_token)
+                user_logs = open(upath, encoding="utf-8").read()
             except Exception:
                 user_logs = f"=== HISTORY FOR {username} ===\n"
-
-            operations = [
-                CommitOperationAdd(
-                    path_in_repo="traffic_logs.txt",
-                    path_or_fileobj=(current_logs + log_entry).encode("utf-8"),
-                ),
-                CommitOperationAdd(
-                    path_in_repo=user_log_filename,
-                    path_or_fileobj=(user_logs + log_entry).encode("utf-8"),
-                ),
-                CommitOperationAdd(
-                    path_in_repo=f"data/{filename_base}.webp",
-                    path_or_fileobj=raw_webp_bytes,
-                ),
+            ops = [
+                CommitOperationAdd(path_in_repo="traffic_logs.txt", path_or_fileobj=(current + log_entry).encode()),
+                CommitOperationAdd(path_in_repo=user_log, path_or_fileobj=(user_logs + log_entry).encode()),
+                CommitOperationAdd(path_in_repo=f"data/{filename_base}.webp", path_or_fileobj=raw),
             ]
-
             api.create_commit(
                 repo_id=BACKUP_DATASET_ID,
                 repo_type="dataset",
-                operations=operations,
+                operations=ops,
                 commit_message=f"gen for {username} @ {timestamp}",
             )
-            logger.info(f"☁️ Cloud dataset completely updated for {username}. (attempt {attempt})")
+            logger.info(f"☁️ logged {username} attempt {attempt}")
             return
-        except HfHubHTTPError as e:
-            status = getattr(e.response, "status_code", None)
-            if status == 429:
-                wait = 2**attempt
-                logger.error(
-                    f"⚠️ Rate limited (429) on attempt {attempt}/{max_attempts} for {username}. Retrying in {wait}s."
-                )
-                time.sleep(wait)
-                continue
-            logger.error(f"⚠️ Storage worker HTTP error ({status}) for {username}: {str(e)}")
-            time.sleep(1.5 * attempt)
-            continue
         except Exception as e:
-            logger.error(f"⚠️ Storage worker failed for {username} on attempt {attempt}: {str(e)}")
+            logger.error(f"log fail {attempt}: {e}")
             time.sleep(1.5 * attempt)
-            continue
 
-    logger.error(f"❌ Storage worker gave up after {max_attempts} attempts for {username}. Entry NOT saved.")
-
-
-pipeline = None
-device = None
-current_loaded_model = None
-
-
-def get_infinite_embeddings(pipe, prompt, negative_prompt):
-    pos_ids_1 = pipe.tokenizer(prompt, return_tensors="pt", truncation=False).input_ids.to(device)
-    neg_ids_1 = pipe.tokenizer(negative_prompt, return_tensors="pt", truncation=False).input_ids.to(device)
-    pos_ids_2 = pipe.tokenizer_2(prompt, return_tensors="pt", truncation=False).input_ids.to(device)
-    neg_ids_2 = pipe.tokenizer_2(negative_prompt, return_tensors="pt", truncation=False).input_ids.to(device)
-
-    max_len = max(pos_ids_1.shape[1], neg_ids_1.shape[1], pos_ids_2.shape[1], neg_ids_2.shape[1])
-    num_chunks = (max_len - 2 + 74) // 75
-    if num_chunks == 0:
-        num_chunks = 1
-
-    def chunk_and_pad_tokens(token_ids, tokenizer, target_chunks):
-        raw_ids = token_ids[0, 1:-1].tolist()
-        chunks_list = []
-        for idx in range(target_chunks):
-            start_i = idx * 75
-            end_i = start_i + 75
-            chunk_slice = raw_ids[start_i:end_i]
-            formatted_chunk = [tokenizer.bos_token_id] + chunk_slice + [tokenizer.eos_token_id]
-            padding_needed = 77 - len(formatted_chunk)
-            if padding_needed > 0:
-                formatted_chunk += [tokenizer.pad_token_id] * padding_needed
-            chunks_list.append(formatted_chunk)
-        return torch.tensor(chunks_list, dtype=torch.long, device=device)
-
-    pos_pieces_1 = chunk_and_pad_tokens(pos_ids_1, pipe.tokenizer, num_chunks)
-    neg_pieces_1 = chunk_and_pad_tokens(neg_ids_1, pipe.tokenizer, num_chunks)
-    pos_pieces_2 = chunk_and_pad_tokens(pos_ids_2, pipe.tokenizer_2, num_chunks)
-    neg_pieces_2 = chunk_and_pad_tokens(neg_ids_2, pipe.tokenizer_2, num_chunks)
-
-    pos_embeds_1_list, neg_embeds_1_list = [], []
-    pos_embeds_2_list, neg_embeds_2_list = [], []
-    pooled_pos_list, pooled_neg_list = [], []
-
-    for i in range(num_chunks):
-        out_p1 = pipe.text_encoder(pos_pieces_1[i : i + 1], output_hidden_states=True)
-        out_n1 = pipe.text_encoder(neg_pieces_1[i : i + 1], output_hidden_states=True)
-        pos_embeds_1_list.append(out_p1.hidden_states[-2])
-        neg_embeds_1_list.append(out_n1.hidden_states[-2])
-
-        out_p2 = pipe.text_encoder_2(pos_pieces_2[i : i + 1], output_hidden_states=True)
-        out_n2 = pipe.text_encoder_2(neg_pieces_2[i : i + 1], output_hidden_states=True)
-        pos_embeds_2_list.append(out_p2.hidden_states[-2])
-        neg_embeds_2_list.append(out_n2.hidden_states[-2])
-        pooled_pos_list.append(out_p2.text_embeds)
-        pooled_neg_list.append(out_n2.text_embeds)
-
-    pos_embeds_1 = torch.cat(pos_embeds_1_list, dim=1)
-    neg_embeds_1 = torch.cat(neg_embeds_1_list, dim=1)
-    pos_embeds_2 = torch.cat(pos_embeds_2_list, dim=1)
-    neg_embeds_2 = torch.cat(neg_embeds_2_list, dim=1)
-
-    prompt_embeds = torch.cat([pos_embeds_1, pos_embeds_2], dim=-1)
-    negative_prompt_embeds = torch.cat([neg_embeds_1, neg_embeds_2], dim=-1)
-    return prompt_embeds, pooled_pos_list[0], negative_prompt_embeds, pooled_neg_list[0]
-
-
-def initialize_model(model_name):
-    global pipeline, device, current_loaded_model
-    if current_loaded_model == model_name and pipeline is not None:
-        return True
-    try:
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        if pipeline is not None:
-            del pipeline
-            pipeline = None
-            gc.collect()
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-
-        dtype = torch.float16 if torch.cuda.is_available() else torch.float32
-
-        if model_name in DIFFUSERS_MODELS:
-            repo_id = DIFFUSERS_MODELS[model_name]
-            pipeline = StableDiffusionXLPipeline.from_pretrained(
-                repo_id,
-                torch_dtype=dtype,
-                use_safetensors=True,
-            )
-        else:
-            repo_id = MODEL_REPOS.get(model_name, HF_REPO_ID)
-            local_model_path = hf_hub_download(repo_id=repo_id, filename=model_name)
-            pipeline = StableDiffusionXLPipeline.from_single_file(
-                local_model_path,
-                torch_dtype=dtype,
-                use_safetensors=True,
-                safety_checker=None,
-                requires_safety_checker=False,
-            )
 
-        if hasattr(pipeline, "scheduler"):
-            pipeline.scheduler = EulerDiscreteScheduler.from_config(
-                pipeline.scheduler.config,
-                timestep_spacing="trailing",
-            )
-        pipeline = pipeline.to(device)
-        if torch.cuda.is_available():
-            pipeline.vae.enable_slicing()
-            pipeline.vae.enable_tiling()
-        current_loaded_model = model_name
-        return True
-    except Exception as e:
-        logger.error(f"❌ CRITICAL LOAD ERROR for {model_name}: {str(e)}")
-        return False
-
-
-def remix_pass(base_images, chef_name, strength, enhanced_prompt, final_negative, steps, cfg_scale, seed_offset):
-    """Load chef and img2img-remix a list of (pil, seed)."""
-    strength = max(0.05, min(0.95, float(strength)))
-    if not initialize_model(chef_name):
-        raise RuntimeError(f"Failed to load remix chef: {chef_name}")
-
-    img2img = StableDiffusionXLImg2ImgPipeline(
-        vae=pipeline.vae,
-        text_encoder=pipeline.text_encoder,
-        text_encoder_2=pipeline.text_encoder_2,
-        tokenizer=pipeline.tokenizer,
-        tokenizer_2=pipeline.tokenizer_2,
-        unet=pipeline.unet,
-        scheduler=pipeline.scheduler,
-    )
-    img2img = img2img.to(device)
-    pe, ppe, npe, nppe = get_infinite_embeddings(pipeline, enhanced_prompt, final_negative)
-    remix_steps = max(10, int(int(steps) * 0.7))
-    remixed = []
-    for img, current_seed in base_images:
-        generator = torch.Generator(device).manual_seed(int(current_seed) + int(seed_offset))
-        out = img2img(
-            image=img,
-            prompt_embeds=pe,
-            pooled_prompt_embeds=ppe,
-            negative_prompt_embeds=npe,
-            negative_pooled_prompt_embeds=nppe,
-            strength=strength,
-            num_inference_steps=remix_steps,
-            guidance_scale=float(cfg_scale),
-            generator=generator,
-            output_type="pil",
-        ).images[0]
-        remixed.append((out, current_seed))
-    del img2img
+# ---------------------------------------------------------------------------
+# PIPELINE CACHE
+# ---------------------------------------------------------------------------
+_pipes = {}
+_current_key = None
+
+
+def _dtype():
+    if torch.cuda.is_available():
+        # Flux prefers bfloat16 when available
+        return torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+    return torch.float32
+
+
+def unload_all():
+    global _pipes, _current_key
+    _pipes.clear()
+    _current_key = None
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
-    return remixed
 
 
-@spaces.GPU(duration=240) if SPACES_AVAILABLE else (lambda f: f)
-def generate_image(
+def get_flux_pipe():
+    key = "flux-schnell"
+    if key in _pipes:
+        return _pipes[key]
+    from diffusers import FluxPipeline
+
+    unload_all()
+    logger.info("Loading FLUX.1 Schnell…")
+    pipe = FluxPipeline.from_pretrained(
+        "black-forest-labs/FLUX.1-schnell",
+        torch_dtype=_dtype(),
+    )
+    if torch.cuda.is_available():
+        pipe.to("cuda")
+    _pipes[key] = pipe
+    return pipe
+
+
+def get_sd35_pipe():
+    key = "sd35-medium"
+    if key in _pipes:
+        return _pipes[key]
+    from diffusers import StableDiffusion3Pipeline
+
+    unload_all()
+    logger.info("Loading SD 3.5 Medium…")
+    # May require accepting the model license on HF while logged in (Space has hf_oauth)
+    pipe = StableDiffusion3Pipeline.from_pretrained(
+        "stabilityai/stable-diffusion-3.5-medium",
+        torch_dtype=_dtype(),
+    )
+    if torch.cuda.is_available():
+        pipe.to("cuda")
+    _pipes[key] = pipe
+    return pipe
+
+
+def get_sdxl_pipe(model_name: str):
+    key = f"sdxl:{model_name}"
+    if key in _pipes:
+        return _pipes[key]
+    from diffusers import StableDiffusionXLPipeline, EulerDiscreteScheduler
+
+    # Keep only one heavy pipe resident
+    unload_all()
+    dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+    logger.info(f"Loading Adult SDXL chef: {model_name}")
+    if model_name in DIFFUSERS_MODELS:
+        pipe = StableDiffusionXLPipeline.from_pretrained(
+            DIFFUSERS_MODELS[model_name],
+            torch_dtype=dtype,
+            use_safetensors=True,
+        )
+    else:
+        repo = MODEL_REPOS.get(model_name, HF_REPO_ID)
+        path = hf_hub_download(repo_id=repo, filename=model_name)
+        pipe = StableDiffusionXLPipeline.from_single_file(
+            path,
+            torch_dtype=dtype,
+            use_safetensors=True,
+        )
+    if hasattr(pipe, "scheduler"):
+        pipe.scheduler = EulerDiscreteScheduler.from_config(
+            pipe.scheduler.config,
+            timestep_spacing="trailing",
+        )
+    if torch.cuda.is_available():
+        pipe.to("cuda")
+        if hasattr(pipe, "vae"):
+            pipe.vae.enable_slicing()
+            pipe.vae.enable_tiling()
+    _pipes[key] = pipe
+    return pipe
+
+
+def enhance_prompt(prompt, styles):
+    pre, suf = build_styles(styles)
+    parts = [DEFAULT_QUALITY, pre, prompt.strip(), suf]
+    return ", ".join([p for p in parts if p])
+
+
+# ---------------------------------------------------------------------------
+# GENERATE
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=180) if SPACES_AVAILABLE else (lambda f: f)
+def generate(
+    engine,
     prompt,
     styles,
-    negative_prompt,
+    negative,
+    sdxl_model,
     steps,
-    cfg_scale,
+    cfg,
     seed,
-    num_images,
     width,
     height,
-    model_a,
-    model_b,
-    blend_b,
-    model_c,
-    blend_c,
+    batch,
     username,
 ):
-    if not prompt:
-        return None, "", "❌ Prompt missing", []
+    if not prompt or not str(prompt).strip():
+        return None, "❌ Prompt missing", "", []
 
     now = time.time()
-    user_key = username if username else "anonymous"
-    if user_key in LAST_GEN_TIME:
-        elapsed = now - LAST_GEN_TIME[user_key]
-        if elapsed < COOLDOWN_SECONDS:
-            remaining = int(COOLDOWN_SECONDS - elapsed)
-            gr.Warning(f"⏳ Slow down! Cooldown active. Please wait {remaining} seconds.")
-            return None, f"⏳ Cooldown active. Wait {remaining}s.", f"Anti-Spam Block: {remaining}s remaining", []
-
-    is_safe, flagged_term = check_prompt_safety(prompt)
-    if not is_safe:
-        gr.Warning("❌ Request denied. Restricted content detected.")
-        return None, "❌ Restricted content detected.", "Content Policy Violation", []
-
-    num_images = int(max(1, min(3, int(num_images))))
-
-    if not initialize_model(model_a):
-        return None, "", f"❌ Failed to load Chef A: {model_a}", []
-
-    use_b = model_b and model_b != BLEND_NONE and model_b != model_a and float(blend_b) > 0.02
-    use_c = model_c and model_c != BLEND_NONE and model_c != model_a and float(blend_c) > 0.02
-    if use_c and use_b and model_c == model_b:
-        # still ok, second pass with same chef; allow it
-        pass
+    user_key = username or "anonymous"
+    if user_key in LAST_GEN_TIME and now - LAST_GEN_TIME[user_key] < COOLDOWN_SECONDS:
+        left = int(COOLDOWN_SECONDS - (now - LAST_GEN_TIME[user_key]))
+        gr.Warning(f"Cooldown {left}s")
+        return None, f"⏳ Cooldown {left}s", "", []
+
+    ok, bad = check_prompt_safety(prompt)
+    if not ok:
+        gr.Warning("Restricted content")
+        return None, "❌ Restricted content", "", []
+
+    batch = int(max(1, min(3, int(batch))))
+    seeds = [
+        random.randint(0, 2**31 - 1) if int(seed) < 0 else int(seed) + i
+        for i in range(batch)
+    ]
+    enhanced = enhance_prompt(prompt, styles)
+    neg = BASE_NEGATIVES
+    if negative and str(negative).strip():
+        neg = f"{BASE_NEGATIVES}, {negative.strip()}"
+
+    LAST_GEN_TIME[user_key] = now
+    gallery = []
+    jobs = []
 
     try:
-        LAST_GEN_TIME[user_key] = now
-        seeds = [random.randint(0, 99999999) if seed == -1 else int(seed) + i for i in range(num_images)]
-        style_prefix, style_suffix = build_style_layers(styles)
-
-        components = [
-            DEFAULT_QUALITY_PREFIX,
-            style_prefix,
-            prompt.strip(),
-            style_suffix,
-            QUALITY_TAGS,
-        ]
-        enhanced_prompt = ", ".join([x for x in components if x])
-
-        final_negative = BASE_NEGATIVES
-        if negative_prompt.strip():
-            final_negative = f"{BASE_NEGATIVES}, {negative_prompt.strip()}"
-
-        prompt_embeds, pooled_prompt_embeds, negative_prompt_embeds, negative_pooled_prompt_embeds = get_infinite_embeddings(
-            pipeline, enhanced_prompt, final_negative
-        )
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        if engine == ENGINE_FLUX:
+            pipe = get_flux_pipe()
+            # Schnell: low steps, guidance often ~0
+            use_steps = int(max(1, min(8, int(steps) if int(steps) <= 8 else 4)))
+            for s in seeds:
+                gen = torch.Generator(device=device).manual_seed(int(s))
+                out = pipe(
+                    prompt=enhanced,
+                    num_inference_steps=use_steps,
+                    guidance_scale=0.0,
+                    width=int(width),
+                    height=int(height),
+                    generator=gen,
+                    max_sequence_length=256,
+                ).images[0]
+                label = f"FLUX · seed {s} · {datetime.now().strftime('%I:%M:%S %p')}"
+                gallery.append((out, label))
+                jobs.append((out, s, "FLUX.1-schnell", prompt, username, width, height, use_steps, 0.0))
+
+        elif engine == ENGINE_SD35:
+            pipe = get_sd35_pipe()
+            use_steps = int(max(15, min(40, int(steps))))
+            for s in seeds:
+                gen = torch.Generator(device=device).manual_seed(int(s))
+                out = pipe(
+                    prompt=enhanced,
+                    negative_prompt=neg,
+                    num_inference_steps=use_steps,
+                    guidance_scale=float(cfg),
+                    width=int(width),
+                    height=int(height),
+                    generator=gen,
+                ).images[0]
+                label = f"SD3.5 · seed {s} · {datetime.now().strftime('%I:%M:%S %p')}"
+                gallery.append((out, label))
+                jobs.append((out, s, "SD3.5-medium", prompt, username, width, height, use_steps, cfg))
 
-        base_images = []
-        for current_seed in seeds:
-            generator = torch.Generator(device).manual_seed(current_seed)
-            out = pipeline(
-                prompt_embeds=prompt_embeds,
-                pooled_prompt_embeds=pooled_prompt_embeds,
-                negative_prompt_embeds=negative_prompt_embeds,
-                negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
-                num_inference_steps=int(steps),
-                guidance_scale=float(cfg_scale),
-                width=int(width),
-                height=int(height),
-                generator=generator,
-                output_type="pil",
-            ).images[0]
-            base_images.append((out, current_seed))
-
-        chain = [f"A:{model_a}"]
-        if use_b:
-            base_images = remix_pass(
-                base_images, model_b, blend_b, enhanced_prompt, final_negative, steps, cfg_scale, seed_offset=17
-            )
-            chain.append(f"B:{model_b}@{float(blend_b):.2f}")
-        if use_c:
-            # if C equals current loaded B, still re-run remix with new strength
-            base_images = remix_pass(
-                base_images, model_c, blend_c, enhanced_prompt, final_negative, steps, cfg_scale, seed_offset=31
-            )
-            chain.append(f"C:{model_c}@{float(blend_c):.2f}")
-
-        gallery_items = []
-        upload_jobs = []
-        log_model = " > ".join(chain)
-        for out, current_seed in base_images:
-            current_time = datetime.now().strftime("%I:%M:%S %p")
-            display_label = f"✨ Seed: {current_seed} | {log_model} | ⏱️ {current_time}"
-            gallery_items.append((out, display_label))
-            upload_jobs.append((out, current_seed, log_model, prompt, username, width, height, steps, cfg_scale))
-
-        style_note = ", ".join(styles) if isinstance(styles, (list, tuple)) else str(styles)
-        gen_info = f"Seeds: {seeds} | {width}x{height} | {log_model} | styles: {style_note}"
-        return gallery_items, gen_info, enhanced_prompt, upload_jobs
-    except Exception as e:
-        logger.error(f"❌ GENERATION CRASH: {str(e)}")
-        return None, "", f"❌ Crashed: {str(e)}", []
+        else:
+            pipe = get_sdxl_pipe(sdxl_model)
+            use_steps = int(max(10, min(40, int(steps))))
+            for s in seeds:
+                gen = torch.Generator(device=device).manual_seed(int(s))
+                out = pipe(
+                    prompt=enhanced,
+                    negative_prompt=neg,
+                    num_inference_steps=use_steps,
+                    guidance_scale=float(cfg),
+                    width=int(width),
+                    height=int(height),
+                    generator=gen,
+                ).images[0]
+                label = f"SDXL · {sdxl_model[:28]} · seed {s}"
+                gallery.append((out, label))
+                jobs.append((out, s, sdxl_model, prompt, username, width, height, use_steps, cfg))
+
+        info = f"{engine} | seeds {seeds} | {width}x{height} | enhanced prompt ready"
+        return gallery, info, enhanced, jobs
 
+    except Exception as e:
+        logger.exception("generate failed")
+        msg = str(e)
+        if "gated" in msg.lower() or "401" in msg or "403" in msg:
+            msg += " — open the model page on HF, accept the license, ensure Space secret HF_TOKEN can read it (or use HF login)."
+        return None, f"❌ {msg}", "", []
 
-js_theme_injector = """
-function() {
- const formatDark = () => {
- document.documentElement.classList.add('dark');
- document.body.classList.add('dark');
- const root = document.querySelector(':root');
- if(root) {
- root.style.setProperty('--background-fill-primary', '#0b0f19');
- root.style.setProperty('--background-fill-secondary', '#111827');
- root.style.setProperty('--block-background-fill', '#111827');
- root.style.setProperty('--body-text-color', '#f3f4f6');
- root.style.setProperty('--border-color-primary', '#1f2937');
- }
- };
- formatDark();
- setTimeout(formatDark, 500);
- setTimeout(formatDark, 2000);
-}
-"""
 
-js_get_visitor = """
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+js_visitor = """
 function() {
- let visitor_id = localStorage.getItem('adult_ai_visitor_id');
- if (!visitor_id) {
- let randomNum = Math.floor(1000 + Math.random() * 9000);
- visitor_id = "Visitor_" + randomNum;
- localStorage.setItem('adult_ai_visitor_id', visitor_id);
- }
- return visitor_id;
+  let id = localStorage.getItem('adult_ai_visitor_id');
+  if (!id) {
+    id = 'Visitor_' + Math.floor(1000 + Math.random() * 9000);
+    localStorage.setItem('adult_ai_visitor_id', id);
+  }
+  return id;
 }
 """
 
 css = """
-.gradio-container, html, body, .dark { background-color: #0b0b19 !important; color: #f3f4f6 !important; }
-.form, .block, .gr-box, .fieldset { background-color: #111827 !important; border: 1px solid #1f2937 !important; padding: 14px !important; border-radius: 8px !important; margin-bottom: 12px !important; }
-span, label, p, h1, h2, h3, .gr-label, .meta-text { color: #f3f4f6 !important; font-weight: 600 !important; }
-input, textarea, select { background-color: #1f2937 !important; color: #ffffff !important; border: 1px solid #374151 !important; border-radius: 6px !important; padding: 8px !important; }
-div[role="listbox"], .dropdown-menu, .v-select, select { background-color: #1f2937 !important; background: #1f2937 !important; border: 1px solid #4b5563 !important; color: #ffffff !important; z-index: 99999 !important; }
-option, .dark option { background-color: #1f2937 !important; color: #ffffff !important; }
-.gradio-gallery, .image-output, .image-container {
- max-height: 70vh !important;
- overflow-y: auto !important;
-}
+.gradio-container, html, body { background:#0b0b19 !important; color:#f3f4f6 !important; }
+.block { background:#111827 !important; border:1px solid #1f2937 !important; border-radius:8px !important; }
 """
 
 THEME = gr.themes.Default(primary_hue="purple", secondary_hue="indigo", neutral_hue="slate")
 
 
-def create_interface():
-    with gr.Blocks() as interface:
-        user_id_store = gr.Textbox(visible=False, elem_id="user_id_store")
-
-        gr.Markdown("# 🔥 MEN ONLY — Mad Mode")
+def create_ui():
+    with gr.Blocks() as demo:
+        user_id = gr.Textbox(visible=False)
+        gr.Markdown("# ⚡ Next-Gen Image Lab")
         gr.Markdown(
-            "### ⚠️ 18+ · stack styles · Chef A draws · optional B then C remix · batch up to 3\\n more porn yahoo.ca"
-            "Tip: 3 chefs + batch 3 is heavy on ZeroGPU. Start with batch 1 while testing blends."
+            "### FLUX.1 Schnell · SD 3.5 Medium · Adult SDXL NSFW chefs · ZeroGPU\\n\\n"
+            "18+ only. FLUX = newest fast tech. SD3.5 = newest quality (may need HF license accept). "
+            "Adult SDXL = your proven smut chefs."
         )
 
         with gr.Row():
             with gr.Column(scale=2):
-                prompt_input = gr.Textbox(
-                    label="Prompt (what you want her to look like)",
-                    value=random.choice(RANDOM_PROMPTS),
-                    lines=8,
+                prompt = gr.Textbox(label="Prompt", value=random.choice(RANDOM_PROMPTS), lines=7)
+                negative = gr.Textbox(label="Negatives (SD3.5 / SDXL; ignored by FLUX)", value=BASE_NEGATIVES, lines=4)
+                styles = gr.CheckboxGroup(
+                    label="Style packs (stackable)",
+                    choices=list(STYLE_PACKS.keys()),
+                    value=["Men Only", "Photo Gloss"],
                 )
-                negative_prompt_input = gr.Textbox(
-                    label="Negatives (stuff to kill)",
-                    value=BASE_NEGATIVES,
-                    lines=5,
-                )
-                style_input = gr.CheckboxGroup(
-                    label="Style packs (stack as many as you want)",
-                    choices=STYLE_CHOICES,
-                    value=["Men Only", "Art Nude Meta", "Rembrandt Oil"],
-                )
-                generate_button = gr.Button("GENERATE — HIT IT", variant="primary", size="lg")
-
+                go = gr.Button("GENERATE", variant="primary", size="lg")
             with gr.Column(scale=1):
-                model_a_input = gr.Dropdown(label="Chef A (base draw)", choices=MODEL_CHOICES, value="pornworksSexyBeauty_v04.safetensors")
-                model_b_input = gr.Dropdown(label="Chef B (remix 1)", choices=MODEL_CHOICES_OPTIONAL, value=BLEND_NONE)
-                blend_b_input = gr.Slider(label="B blend", minimum=0.0, maximum=0.85, value=0.35, step=0.05)
-                model_c_input = gr.Dropdown(label="Chef C (remix 2)", choices=MODEL_CHOICES_OPTIONAL, value=BLEND_NONE)
-                blend_c_input = gr.Slider(label="C blend", minimum=0.0, maximum=0.85, value=0.25, step=0.05)
-                seed_input = gr.Number(label="Seed (-1 = random)", value=-1, precision=0)
-                width_input = gr.Slider(label="Width", minimum=512, maximum=1536, value=1024, step=64)
-                height_input = gr.Slider(label="Height", minimum=512, maximum=1536, value=1024, step=64)
-                steps_input = gr.Slider(label="Steps", minimum=10, maximum=40, value=28, step=1)
-                cfg_input = gr.Slider(label="CFG", minimum=1.0, maximum=12.0, value=6.0, step=0.5)
-                num_images_input = gr.Slider(label="Batch (up to 3 at once)", minimum=1, maximum=3, value=1, step=1)
-
-        with gr.Row():
-            image_output = gr.Gallery(label="Outputs", columns=3, height="auto")
-
-        generation_info = gr.Textbox(label="Metadata Engine Logs", visible=False)
-        metadata_display = gr.Textbox(label="Properties Dump", visible=False)
-
-        interface.load(fn=None, inputs=None, outputs=user_id_store, js=js_get_visitor)
-
-        def on_generate(*args):
-            images, info, metadata, upload_jobs = generate_image(*args)
-            for job in upload_jobs:
-                threading.Thread(target=async_traffic_log_upload_worker, args=job, daemon=True).start()
-            if images is not None:
-                return images, info, metadata, gr.update(visible=True, value=info), gr.update(visible=True, value=metadata)
-            return None, info, "", gr.update(visible=False), gr.update(visible=False)
-
-        generate_button.click(
-            fn=on_generate,
-            inputs=[
-                prompt_input,
-                style_input,
-                negative_prompt_input,
-                steps_input,
-                cfg_input,
-                seed_input,
-                num_images_input,
-                width_input,
-                height_input,
-                model_a_input,
-                model_b_input,
-                blend_b_input,
-                model_c_input,
-                blend_c_input,
-                user_id_store,
-            ],
-            outputs=[image_output, generation_info, metadata_display, generation_info, metadata_display],
+                engine = gr.Radio(label="Engine", choices=ENGINE_CHOICES, value=ENGINE_FLUX)
+                sdxl_model = gr.Dropdown(
+                    label="Adult SDXL chef (only used on Adult SDXL engine)",
+                    choices=SDXL_CHOICES,
+                    value="OhMySister Beautiful Asian Woman",
+                )
+                seed = gr.Number(label="Seed (-1 random)", value=-1, precision=0)
+                width = gr.Slider(512, 1536, value=1024, step=64, label="Width")
+                height = gr.Slider(512, 1536, value=1024, step=64, label="Height")
+                steps = gr.Slider(1, 40, value=4, step=1, label="Steps (FLUX~4, SD3.5~28, SDXL~28)")
+                cfg = gr.Slider(0.0, 12.0, value=4.5, step=0.5, label="CFG (FLUX uses 0)")
+                batch = gr.Slider(1, 3, value=1, step=1, label="Batch (max 3)")
+
+        gallery = gr.Gallery(label="Outputs", columns=3, height="auto")
+        info = gr.Textbox(label="Run info", visible=True)
+        meta = gr.Textbox(label="Enhanced prompt", visible=True)
+
+        demo.load(fn=None, inputs=None, outputs=user_id, js=js_visitor)
+
+        def on_go(*args):
+            images, run_info, enhanced, jobs = generate(*args)
+            if jobs:
+                for job in jobs:
+                    threading.Thread(target=async_log_upload, args=job, daemon=True).start()
+            if images is None:
+                return None, run_info, enhanced or ""
+            return images, run_info, enhanced
+
+        go.click(
+            fn=on_go,
+            inputs=[engine, prompt, styles, negative, sdxl_model, steps, cfg, seed, width, height, batch, user_id],
+            outputs=[gallery, info, meta],
         )
-    return interface
+    return demo
 
 
 if __name__ == "__main__":
-    os.environ["GRADIO_WATCH_DIRS"] = ""
     os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-    app = create_interface()
-    app.queue(max_size=10)
-    app.launch(
-        ssr_mode=False,
-        theme=THEME,
-        css=css,
-        js=js_theme_injector,
-    )
+    app = create_ui()
+    app.queue(max_size=12)
+    app.launch(ssr_mode=False, theme=THEME, css=css)