"""AI KING©️ generators on ZeroGPU (open models only, no paid inference). - Text → Image and Image → Image: FLUX.1 [schnell] (Apache-2.0), 4-step distilled. - Text/Image → Video + seamless loops: LTX-Video 0.9.5 (2B, LTXV Open Weights License, free for companies under $10M annual revenue). Shares FLUX's T5-XXL text encoder (byte-identical weights) so both fit in one ZeroGPU slot. Set AIKING_NO_MODELS=1 to run the UI without loading models (local design work). """ from __future__ import annotations import math, os, random, tempfile, time, traceback import numpy as np from PIL import Image, ImageOps try: import spaces # ZeroGPU except Exception: # local / non-Spaces class _S: @staticmethod def GPU(*a, **k): if a and callable(a[0]): return a[0] return lambda f: f spaces = _S() NO_MODELS = os.environ.get("AIKING_NO_MODELS") == "1" HUB_TOKEN = os.environ.get("AIKING_HUB_TOKEN") or None FLUX_ID = "black-forest-labs/FLUX.1-schnell" LTX_ID = "Lightricks/LTX-Video-0.9.5" OUT_DIR = os.path.join(tempfile.gettempdir(), "aiking_out") os.makedirs(OUT_DIR, exist_ok=True) STATUS = {"image": "off", "video": "off"} ERRORS: dict[str, str] = {} t2i = i2i = ltx = None LTXVideoCondition = None STYLES = { "None": "", "🎬 ARRI ALEXA 35": "cinematic film still shot on ARRI ALEXA 35, anamorphic lens, shallow depth of field, natural film grain, hyperrealistic skin texture, dramatic motivated lighting", "💿 Album Cover": "premium album cover art, bold centered composition, iconic silhouette, luxury finish, high contrast, crisp detail", "👑 Royal Gold": "black and gold luxury aesthetic, regal, glossy reflections, crown motifs, studio rim light, hyperdetailed", "🌃 Neon Lofi": "cozy lofi aesthetic, neon city at night, rain on glass, soft bloom, warm desk lamp, cinematic anime-inspired color", "🚀 Intergalactic": "cosmic nebula backdrop, starfield, iridescent rim light, epic sci-fi scale, glossy chrome accents", "📸 Editorial": "luxury fashion editorial photograph, softbox key light, magazine cover quality, clean background", "🧸 3D Toy": "glossy 3D render, collectible vinyl toy style, soft global illumination, studio backdrop", "🎮 Game Cinematic": "AAA video game cinematic key art, unreal engine 5 render, volumetric light, epic composition", } ASPECTS = {"9:16 Story": (768, 1344), "1:1 Square": (1024, 1024), "4:5 Portrait": (896, 1120), "16:9 Cinema": (1344, 768)} VIDEO_ASPECTS = {"9:16 Story": (480, 832), "1:1 Square": (640, 640), "16:9 Cinema": (832, 480)} VIDEO_NEG = "worst quality, inconsistent motion, blurry, jittery, distorted face, morphing, warped hands, text, watermark, logo" def _load(): global t2i, i2i, ltx, LTXVideoCondition import torch from huggingface_hub import snapshot_download from diffusers import FluxImg2ImgPipeline, FluxPipeline flux_dir = snapshot_download(FLUX_ID, token=HUB_TOKEN, allow_patterns=[ "model_index.json", "scheduler/*", "text_encoder/*", "text_encoder_2/*", "tokenizer/*", "tokenizer_2/*", "transformer/*", "vae/*"]) t2i = FluxPipeline.from_pretrained(flux_dir, dtype=torch.bfloat16).to("cuda") i2i = FluxImg2ImgPipeline.from_pipe(t2i, dtype=torch.bfloat16) # from_pipe defaults to fp32! STATUS["image"] = "ready" try: from diffusers import (AutoencoderKLLTXVideo, FlowMatchEulerDiscreteScheduler, LTXConditionPipeline, LTXVideoTransformer3DModel) from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition as _C LTXVideoCondition = _C ltx_dir = snapshot_download(LTX_ID, token=HUB_TOKEN, allow_patterns=[ "model_index.json", "scheduler/*", "transformer/*", "vae/*", "tokenizer/*"]) ltx = LTXConditionPipeline( scheduler=FlowMatchEulerDiscreteScheduler.from_pretrained(ltx_dir, subfolder="scheduler"), vae=AutoencoderKLLTXVideo.from_pretrained(ltx_dir, subfolder="vae", dtype=torch.bfloat16), text_encoder=t2i.text_encoder_2, # identical T5-XXL v1.1 weights tokenizer=t2i.tokenizer_2, transformer=LTXVideoTransformer3DModel.from_pretrained(ltx_dir, subfolder="transformer", dtype=torch.bfloat16), ).to("cuda") STATUS["video"] = "ready" except Exception as e: # keep images working even if video can't load ERRORS["video"] = f"{type(e).__name__}: {e}"[:500] STATUS["video"] = "error" traceback.print_exc() if not NO_MODELS: try: _load() except Exception as e: ERRORS["image"] = f"{type(e).__name__}: {e}"[:500] STATUS["image"] = STATUS["image"] if STATUS["image"] == "ready" else "error" traceback.print_exc() class GenError(RuntimeError): pass def _seed(seed): try: s = int(seed) except Exception: s = -1 return random.randint(0, 2**31 - 1) if s < 0 else s CLEAN = "original unbranded design, plain clothing and products without any brand logos or third-party trademarks, no watermark" def style_prompt(prompt: str, style: str) -> str: extra = STYLES.get(style, "") p = (prompt or "").strip().rstrip(".") p = f"{p}, {extra}" if extra else p return f"{p}, {CLEAN}" def _save_png(img: Image.Image, tag: str) -> str: path = os.path.join(OUT_DIR, f"aiking-{tag}-{int(time.time()*1000)}-{random.randint(100,999)}.png") img.save(path) return path def _fit16(img: Image.Image, max_side=1024) -> Image.Image: img = ImageOps.exif_transpose(img).convert("RGB") w, h = img.size s = min(1.0, max_side / max(w, h)) w, h = max(256, int(w * s) // 16 * 16), max(256, int(h * s) // 16 * 16) return img.resize((w, h), Image.LANCZOS) def _cover(img: Image.Image, w: int, h: int) -> Image.Image: return ImageOps.fit(ImageOps.exif_transpose(img).convert("RGB"), (w, h), Image.LANCZOS) def _need(kind): if STATUS.get(kind) != "ready": msg = ERRORS.get(kind) or ("models are disabled in this preview" if NO_MODELS else "model is still loading, try again in a minute") raise GenError(f"{'Image' if kind == 'image' else 'Video'} engine not ready ({msg}).") # ---------------- GPU functions ---------------- def _t2i_dur(prompt, style, aspect, n, seed): return min(90, 20 + 8 * int(n or 1)) @spaces.GPU(duration=_t2i_dur) def text_to_image(prompt, style, aspect, n, seed): import torch _need("image") w, h = ASPECTS.get(aspect, (1024, 1024)) s = _seed(seed) imgs = t2i(prompt=style_prompt(prompt, style), width=w, height=h, num_inference_steps=4, guidance_scale=0.0, num_images_per_prompt=int(n or 1), max_sequence_length=256, generator=torch.Generator("cpu").manual_seed(s)).images return [_save_png(im, "img") for im in imgs], s def _i2i_dur(image_path, prompt, style, strength, seed): return 40 @spaces.GPU(duration=_i2i_dur) def image_to_image(image_path, prompt, style, strength, seed): import torch _need("image") src = _fit16(Image.open(image_path)) st = float(strength) steps = max(4, math.ceil(4 / max(st, 0.05))) s = _seed(seed) img = i2i(prompt=style_prompt(prompt, style), image=src, strength=st, width=src.width, height=src.height, num_inference_steps=min(steps, 16), guidance_scale=0.0, max_sequence_length=256, generator=torch.Generator("cpu").manual_seed(s)).images[0] return _save_png(img, "edit"), s def _frames(seconds: float) -> int: n = int(round(float(seconds) * 24 / 8)) * 8 + 1 return max(25, min(n, 129)) def _vid_dur(prompt, image_path, mode, seconds, aspect, steps, seed): return int(min(170, 35 + int(steps) * (_frames(seconds) / 97) * 2.2)) def _write_mp4(frames, fps=24) -> str: import imageio.v2 as imageio path = os.path.join(OUT_DIR, f"aiking-video-{int(time.time()*1000)}.mp4") arr = (np.clip(np.asarray(frames), 0, 1) * 255).astype(np.uint8) if np.asarray(frames).dtype != np.uint8 else np.asarray(frames) with imageio.get_writer(path, fps=fps, codec="libx264", quality=8, pixelformat="yuv420p", macro_block_size=16, ffmpeg_params=["-movflags", "+faststart"]) as wr: for f in arr: wr.append_data(f) return path @spaces.GPU(duration=_vid_dur) def make_video(prompt, image_path, mode, seconds, aspect, steps, seed): """mode: 'Text → Video', 'Image → Video', 'Seamless Loop'.""" import torch _need("video") w, h = VIDEO_ASPECTS.get(aspect, (832, 480)) n = _frames(seconds) s = _seed(seed) gen = torch.Generator("cpu").manual_seed(s) keyframe = None if image_path: keyframe = _cover(Image.open(image_path), w, h) elif mode != "Text → Video" or STATUS["image"] == "ready": # cinematic keyframe from FLUX first: sharper, more on-brand than raw text-to-video _need("image") kw, kh = (w * 2 // 16 * 16, h * 2 // 16 * 16) k = t2i(prompt=style_prompt(prompt, "🎬 ARRI ALEXA 35"), width=kw, height=kh, num_inference_steps=4, guidance_scale=0.0, max_sequence_length=256, generator=torch.Generator("cpu").manual_seed(s)).images[0] keyframe = k.resize((w, h), Image.LANCZOS) conds = None if keyframe is not None: conds = [LTXVideoCondition(image=keyframe, frame_index=0)] if mode == "Seamless Loop": conds.append(LTXVideoCondition(image=keyframe, frame_index=n - 1)) motion = (prompt or "").strip().rstrip(".") + ". Smooth natural motion, cinematic camera, consistent identity and lighting, high detail." out = ltx(conditions=conds, prompt=motion, negative_prompt=VIDEO_NEG, width=w, height=h, num_frames=n, num_inference_steps=int(steps), guidance_scale=3.0, decode_timestep=0.05, decode_noise_scale=0.025, generator=gen, output_type="np").frames[0] return _write_mp4(out), s