Create app.py

app.py

@@ -0,0 +1,246 @@
+# app.py
+# Hugging Face Space (Gradio) — CPU-only, uncensored prompt generator
+# - Upload an image or describe a scene
+# - Outputs: Image prompt, Video prompt, or Both
+# Model: Salesforce/blip-image-captioning-base (free, CPU-capable, uncensored)
+
+import os
+import math
+import random
+import gradio as gr
+from PIL import Image, ExifTags
+import torch
+from transformers import BlipProcessor, BlipForConditionalGeneration
+
+HF_MODEL_ID = "Salesforce/blip-image-captioning-base"
+
+# Lazy globals so startup is fast
+_processor = None
+_model = None
+
+def _load_blip():
+    global _processor, _model
+    if _processor is None or _model is None:
+        _processor = BlipProcessor.from_pretrained(HF_MODEL_ID)
+        _model = BlipForConditionalGeneration.from_pretrained(HF_MODEL_ID)
+        _model.to("cpu")
+        _model.eval()
+
+def safe_open_image(inp):
+    if inp is None:
+        return None
+    if isinstance(inp, Image.Image):
+        return inp.convert("RGB")
+    return Image.open(inp).convert("RGB")
+
+def exif_info(img: Image.Image):
+    """Pull a few nice-to-have EXIF hints (if present)."""
+    out = {}
+    try:
+        raw = img.getexif()
+        if not raw:
+            return out
+        # Map EXIF keys to names
+        tag_map = {ExifTags.TAGS.get(k, k): v for k, v in raw.items()}
+        # Focal length can be tuple (num, den)
+        fl = tag_map.get("FocalLength")
+        if isinstance(fl, tuple) and len(fl) == 2 and fl[1] != 0:
+            out["focal_length_mm"] = round(fl[0] / fl[1], 1)
+        elif isinstance(fl, (int, float)):
+            out["focal_length_mm"] = float(fl)
+        # Camera/lens if available
+        if "Model" in tag_map: out["camera_model"] = str(tag_map["Model"]).strip()
+        if "Make" in tag_map: out["camera_make"] = str(tag_map["Make"]).strip()
+    except Exception:
+        pass
+    return out
+
+# Lightweight lexicons for prompt enrichment (kept in-file for mobile simplicity)
+CAMERA_ANGLES = [
+    "eye-level", "low-angle", "high-angle", "aerial/top-down", "worm's-eye", "Dutch tilt"
+]
+SHOT_SIZES = [
+    "extreme close-up", "close-up", "medium shot", "wide shot", "extreme wide shot"
+]
+LENSES = [
+    "14mm ultra-wide", "24mm wide-angle", "35mm street", "50mm standard", "85mm portrait", "135mm telephoto", "200mm telephoto"
+]
+LIGHTING = [
+    "soft diffused light", "golden hour rim light", "overcast softbox feel", "hard noon sun with crisp shadows",
+    "blue hour ambient", "tungsten practicals", "neon key with colored rim", "studio softbox left + kicker right",
+    "volumetric god rays", "moody chiaroscuro"
+]
+COMPOSITION = [
+    "rule of thirds", "leading lines", "central composition", "frame within a frame", "negative space",
+    "foreground bokeh", "shallow depth of field", "symmetry", "diagonal dynamics", "layered depth"
+]
+POST = [
+    "high micro-contrast", "subtle film grain", "cinematic color grade", "Kodak Portra palette",
+    "Teal–orange split tone", "matte shadows", "HDR tonality restrained", "8k detail", "photorealistic finish"
+]
+STYLES = [
+    "documentary realism", "editorial fashion", "street photography", "nature landscape", "architectural minimalism",
+    "cyberpunk neon", "sci-fi cinematic", "fantasy epic", "moody noir", "retro 35mm film"
+]
+
+VIDEO_MOTION = [
+    "slow dolly-in", "gentle push-in", "handheld micro-jitters", "locked-off tripod", "gimbal glide", "orbit right-to-left",
+    "crane rise", "parallax truck shot", "rack focus mid-shot"
+]
+VIDEO_META = [
+    "24 fps", "30 fps", "48 fps", "cinematic motion blur", "shutter 1/48", "global illumination feel"
+]
+VIDEO_TRANSITIONS = ["straight cut", "cinematic fade-in/out", "cross dissolve", "match cut"]
+
+NEGATIVE = [
+    "no distortion", "no chromatic aberration", "no blown highlights", "no excessive sharpening",
+    "no artifacts", "no watermark", "no text overlay"
+]
+
+def smart_choices(caption: str, w: int, h: int, exif: dict, seed: int):
+    """Pick plausible settings using caption/exif/orientation heuristics."""
+    rnd = random.Random(seed)
+    # Orientation heuristic
+    aspect = w / h if h > 0 else 1.0
+    shot = "wide shot" if aspect >= 1.5 else "medium shot"
+    if any(k in caption.lower() for k in ["portrait", "selfie", "face", "headshot"]):
+        shot = "close-up"
+    if any(k in caption.lower() for k in ["aerial", "drone", "top-down", "overhead"]):
+        angle = "aerial/top-down"
+    elif any(k in caption.lower() for k in ["towering", "imposing", "hero", "statue"]):
+        angle = "low-angle"
+    elif any(k in caption.lower() for k in ["bird's-eye", "bird’s-eye"]):
+        angle = "aerial/top-down"
+    else:
+        angle = rnd.choice(CAMERA_ANGLES[:3])  # eye/high/low
+
+    lens = f'{exif["focal_length_mm"]}mm' if "focal_length_mm" in exif else rnd.choice(LENSES)
+    light = rnd.choice(LIGHTING)
+    comp = ", ".join(rnd.sample(COMPOSITION, k=2))
+    style = rnd.choice(STYLES)
+    post = ", ".join(rnd.sample(POST, k=2))
+    neg = ", ".join(NEGATIVE[:3] + rnd.sample(NEGATIVE[3:], k=2))
+    return angle, shot, lens, light, comp, style, post, neg, aspect
+
+def caption_image(img: Image.Image, beam_search: bool, max_len: int):
+    _load_blip()
+    with torch.no_grad():
+        inputs = _processor(images=img, return_tensors="pt")
+        gen_kwargs = dict(max_length=int(max(16, min(128, max_len))), num_beams=3) if beam_search else dict(max_length=int(max(16, min(128, max_len))))
+        out = _model.generate(**inputs, **gen_kwargs)
+        text = _processor.decode(out[0], skip_special_tokens=True).strip()
+    return text
+
+def build_image_prompt(subject_desc: str, angle: str, shot: str, lens: str, light: str, comp: str, style: str, post: str, aspect: float):
+    ar_text = "16:9" if aspect >= 1.6 else ("4:3" if aspect >= 1.3 else "1:1")
+    prompt = (
+        f"{subject_desc}. "
+        f"Camera angle: {angle}. Shot size: {shot}. Lens: {lens}. "
+        f"Lighting: {light}. Composition: {comp}. Style: {style}. Post-processing: {post}. "
+        f"Aspect ratio hint: {ar_text}. "
+        f"Ultra-detailed, physically plausible, consistent scale."
+    )
+    return prompt
+
+def build_video_prompt(image_prompt: str, motion: str, meta: list, transition: str, seconds: int):
+    meta_str = ", ".join(meta)
+    vp = (
+        f"{image_prompt} "
+        f"Now render as a {seconds}s cinematic video; camera motion: {motion}; "
+        f"{meta_str}; transitions: {transition}. "
+        f"Maintain temporal consistency, realistic motion parallax, and coherent lighting through the sequence."
+    )
+    return vp
+
+def generate(
+    image: Image.Image,
+    text_scene: str,
+    mode: str,
+    beam_search: bool,
+    max_len: int,
+    seconds: int,
+    seed: int
+):
+    """
+    Main entry: returns (caption, image_prompt, video_prompt) respecting mode selection.
+    """
+    img = safe_open_image(image)
+    caption = ""
+    base_desc = ""
+
+    if img is not None:
+        caption = caption_image(img, beam_search=beam_search, max_len=max_len)
+        w, h = img.size
+        exif = exif_info(img)
+        angle, shot, lens, light, comp, style, post, neg, aspect = smart_choices(caption, w, h, exif, seed)
+        base_desc = caption
+    else:
+        # Text-only: treat user text as subject description and craft details
+        if not text_scene or not text_scene.strip():
+            return "", "", ""
+        base_desc = text_scene.strip()
+        # fabricate a neutral canvas for heuristics
+        w, h = (1920, 1080)
+        exif = {}
+        angle, shot, lens, light, comp, style, post, neg, aspect = smart_choices(base_desc, w, h, exif, seed)
+
+    # Build prompts
+    image_prompt = build_image_prompt(base_desc, angle, shot, lens, light, comp, style, post, aspect)
+    # Negative prompt as optional hint line
+    neg_line = f"\nNegative prompt hints: {neg}"
+
+    video_prompt = build_video_prompt(
+        image_prompt, motion=random.choice(VIDEO_MOTION),
+        meta=random.sample(VIDEO_META, k=2), transition=random.choice(VIDEO_TRANSITIONS),
+        seconds=int(max(2, min(20, seconds)))
+    )
+
+    if mode == "Image prompt":
+        out_img = image_prompt + neg_line
+        return caption, out_img, ""
+    elif mode == "Video prompt":
+        return caption, "", video_prompt
+    else:
+        out_img = image_prompt + neg_line
+        return caption, out_img, video_prompt
+
+TITLE = "Img2Prompt & VideoPrompt (CPU, Uncensored)"
+DESC = """
+**Upload an image or describe a scene.**  
+Get a **production-ready image prompt**, a **video prompt**, or **both** — with camera angle, shot size, lens, lighting, composition, style, post, aspect ratio hints, plus optional negative prompt hints.
+
+- **Model:** Salesforce/blip-image-captioning-base (CPU; no built-in safety filters)  
+- **Hardware:** Works on Hugging Face free CPU Spaces (first run downloads weights)
+"""
+
+with gr.Blocks(title=TITLE) as demo:
+    gr.Markdown(f"# {TITLE}\n{DESC}")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            with gr.Tab("Image input"):
+                image = gr.Image(type="pil", label="Upload an image", height=360)
+            with gr.Tab("Text input"):
+                text_scene = gr.Textbox(lines=6, placeholder="Describe the scene you want to reproduce...", label="Scene description")
+
+            mode = gr.Radio(choices=["Image prompt", "Video prompt", "Both"], value="Both", label="Output type")
+            beam_search = gr.Checkbox(True, label="Use beam search for caption (better detail, slightly slower)")
+            max_len = gr.Slider(48, 128, value=80, step=1, label="Caption max length")
+            seconds = gr.Slider(3, 12, value=6, step=1, label="Video duration (seconds)")
+            seed = gr.Slider(0, 9999, value=1234, step=1, label="Style seed (change for different angles/lighting)")
+
+            run = gr.Button("Generate prompts", variant="primary")
+
+        with gr.Column(scale=1):
+            caption_box = gr.Textbox(label="Image caption (from model)", interactive=False, lines=3)
+            img_prompt_box = gr.Code(label="Image Prompt (copy-paste to image generators)", language="text")
+            vid_prompt_box = gr.Code(label="Video Prompt (copy-paste to video generators)", language="text")
+
+    run.click(
+        fn=generate,
+        inputs=[image, text_scene, mode, beam_search, max_len, seconds, seed],
+        outputs=[caption_box, img_prompt_box, vid_prompt_box]
+    )
+
+if __name__ == "__main__":
+    demo.launch()