Upload 9 files

FlowFacade.py

@@ -0,0 +1,156 @@
+import os
+import torch
+import numpy as np
+from PIL import Image
+from typing import Tuple, Optional
+from VideoEngine import VideoEngine
+from TextProcessor import TextProcessor
+
+try:
+    import spaces
+    HAS_SPACES = True
+except ImportError:
+    HAS_SPACES = False
+    class spaces:
+        @staticmethod
+        def GPU(duration=120):
+            def decorator(func):
+                return func
+            return decorator
+
+
+class FlowFacade:
+    def __init__(self):
+        self.is_spaces = os.environ.get('SPACE_ID') is not None
+        self.video_engine = VideoEngine()
+        self.text_processor = TextProcessor(resource_manager=None)
+        print("✓ DeltaFlow initialized")
+
+    def _calculate_gpu_duration(self, image: Image.Image, duration_seconds: float,
+                                num_inference_steps: int, enable_prompt_expansion: bool) -> int:
+        BASE_FRAMES_HEIGHT_WIDTH = 81 * 832 * 624
+        BASE_STEP_DURATION = 15
+
+        resized_image = self.video_engine.resize_image(image)
+        width, height = resized_image.width, resized_image.height
+        frames = self.video_engine.get_num_frames(duration_seconds)
+
+        factor = frames * width * height / BASE_FRAMES_HEIGHT_WIDTH
+        step_duration = BASE_STEP_DURATION * factor ** 1.5
+        total_duration = 10 + int(num_inference_steps) * step_duration
+
+        if enable_prompt_expansion:
+            total_duration += 30
+
+        return int(total_duration)
+
+    @spaces.GPU(duration=120)
+    def generate_video_from_image(self, image: Image.Image, user_instruction: str,
+                                  duration_seconds: float = 3.0, num_inference_steps: int = 4,
+                                  guidance_scale: float = 1.0, guidance_scale_2: float = 1.0,
+                                  seed: int = 42, randomize_seed: bool = False,
+                                  enable_prompt_expansion: bool = False,
+                                  progress=None) -> Tuple[str, str, int]:
+        if image is None:
+            raise ValueError("No image provided")
+        if not user_instruction or user_instruction.strip() == "":
+            raise ValueError("Please provide a motion instruction")
+
+        try:
+            if randomize_seed:
+                seed = np.random.randint(0, 2147483647)
+
+            if enable_prompt_expansion:
+                if progress:
+                    progress(0.1, desc="AI expanding your prompt...")
+                final_prompt = self.text_processor.process(user_instruction, auto_unload=True)
+            else:
+                final_prompt = user_instruction
+
+            if progress:
+                progress(0.2, desc="Preparing GPU memory...")
+
+            if not self.video_engine.is_loaded:
+                import gc
+                gc.collect()
+                torch.cuda.empty_cache()
+                torch.cuda.ipc_collect()
+
+                if progress:
+                    progress(0.25, desc="Loading video generation model...")
+                self.video_engine.load_model()
+
+            gc.collect()
+            torch.cuda.empty_cache()
+
+            if progress:
+                progress(0.3, desc=f"Generating video ({num_inference_steps} steps)...")
+
+            video_path = self.video_engine.generate_video(
+                image=image, prompt=final_prompt, duration_seconds=duration_seconds,
+                num_inference_steps=num_inference_steps, guidance_scale=guidance_scale,
+                guidance_scale_2=guidance_scale_2, seed=seed
+            )
+
+            if progress:
+                progress(1.0, desc="Complete!")
+
+            return video_path, final_prompt, seed
+
+        except Exception as e:
+            import traceback
+            print(f"\n✗ Generation error: {type(e).__name__}: {str(e)}")
+            if os.environ.get('DEBUG'):
+                print(traceback.format_exc())
+            raise RuntimeError(f"Generation failed: {type(e).__name__}: {str(e)}")
+
+    def cleanup(self) -> None:
+        try:
+            if hasattr(self.text_processor, 'is_loaded') and self.text_processor.is_loaded:
+                self.text_processor.unload_model()
+            torch.cuda.empty_cache()
+        except Exception as e:
+            if os.environ.get('DEBUG'):
+                print(f"⚠ Cleanup warning: {str(e)}")
+
+    def get_system_info(self) -> dict:
+        quantization_type = "None"
+        if torch.cuda.is_available():
+            cuda_cap = torch.cuda.get_device_capability()
+            fp8_supported = cuda_cap[0] > 8 or (cuda_cap[0] == 8 and cuda_cap[1] >= 9)
+            quantization_type = "FP8" if fp8_supported else "INT8"
+
+        return {
+            "device": self.video_engine.device,
+            "video_model": VideoEngine.MODEL_ID,
+            "text_model": TextProcessor.MODEL_ID,
+            "lightning_lora": "Enabled",
+            "quantization": quantization_type,
+            "optimizations": [
+                "Lightning LoRA (4-8 steps)",
+                f"{quantization_type} Quantization",
+                "AoT Compilation (if available)"
+            ]
+        }
+
+    def validate_image(self, image: Image.Image) -> bool:
+        if image is None:
+            return False
+
+        min_dim, max_dim = 256, 4096
+
+        if image.width < min_dim or image.height < min_dim:
+            print(f"⚠ Image too small: {image.width}x{image.height}")
+            return False
+
+        if image.width > max_dim or image.height > max_dim:
+            print(f"⚠ Image too large: {image.width}x{image.height}")
+            return False
+
+        return True
+
+    def __del__(self):
+        try:
+            self.cleanup()
+        except:
+            pass

ResourceManager.py

@@ -0,0 +1,174 @@
+# %%writefile RescourceManager.py
+"""
+DeltaFlow - Resource Manager
+Handles GPU memory allocation, deallocation, and cache management
+"""
+
+import gc
+import torch
+from typing import Optional
+
+
+class ResourceManager:
+    """
+    Centralized GPU resource management for model lifecycle.
+    Ensures efficient memory usage and prevents OOM errors.
+    """
+
+    def __init__(self):
+        """Initialize resource manager and detect device."""
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.current_model = None
+        self.model_registry = {}
+
+    def get_device(self) -> str:
+        """
+        Get current compute device.
+
+        Returns:
+            str: 'cuda' or 'cpu'
+        """
+        return self.device
+
+    def register_model(self, model_name: str, model_instance: object) -> None:
+        """
+        Register a model instance for tracking.
+
+        Args:
+            model_name (str): Identifier for the model
+            model_instance (object): The model object
+        """
+        self.model_registry[model_name] = model_instance
+        self.current_model = model_name
+        print(f"✓ Model registered: {model_name}")
+
+    def unregister_model(self, model_name: str) -> None:
+        """
+        Unregister and cleanup a specific model.
+
+        Args:
+            model_name (str): Identifier of model to remove
+        """
+        if model_name in self.model_registry:
+            del self.model_registry[model_name]
+            if self.current_model == model_name:
+                self.current_model = None
+            print(f"✓ Model unregistered: {model_name}")
+
+    def clear_cache(self, aggressive: bool = False) -> None:
+        """
+        Clear CUDA cache and run garbage collection.
+
+        Args:
+            aggressive (bool): If True, performs additional cleanup steps
+        """
+        if self.device == "cuda":
+            # Standard cache clearing
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+
+            if aggressive:
+                # Aggressive cleanup for critical memory situations
+                gc.collect()
+                with torch.cuda.device(self.device):
+                    torch.cuda.empty_cache()
+                    torch.cuda.synchronize()
+
+            print(f"✓ CUDA cache cleared (aggressive={aggressive})")
+        else:
+            gc.collect()
+            print("✓ CPU memory garbage collected")
+
+    def cleanup_model(self, model_instance: Optional[object] = None) -> None:
+        """
+        Safely cleanup a model instance and free GPU memory.
+
+        Args:
+            model_instance (Optional[object]): Specific model to cleanup.
+                                               If None, cleans all registered models.
+        """
+        if model_instance is not None:
+            # Cleanup specific model
+            if hasattr(model_instance, 'to'):
+                model_instance.to('cpu')
+            del model_instance
+        else:
+            # Cleanup all registered models
+            for name, model in list(self.model_registry.items()):
+                if hasattr(model, 'to'):
+                    model.to('cpu')
+                del model
+                self.unregister_model(name)
+
+        # Force cleanup
+        gc.collect()
+        self.clear_cache(aggressive=True)
+        print("✓ Model cleanup completed")
+
+    def get_memory_stats(self) -> dict:
+        """
+        Get current GPU memory statistics.
+
+        Returns:
+            dict: Memory statistics (allocated, reserved, free)
+        """
+        if self.device == "cuda" and torch.cuda.is_available():
+            allocated = torch.cuda.memory_allocated() / 1024**3  # GB
+            reserved = torch.cuda.memory_reserved() / 1024**3    # GB
+            total = torch.cuda.get_device_properties(0).total_memory / 1024**3
+
+            return {
+                "allocated_gb": round(allocated, 2),
+                "reserved_gb": round(reserved, 2),
+                "total_gb": round(total, 2),
+                "free_gb": round(total - allocated, 2)
+            }
+        else:
+            return {
+                "allocated_gb": 0,
+                "reserved_gb": 0,
+                "total_gb": 0,
+                "free_gb": 0
+            }
+
+    def ensure_memory_available(self, required_gb: float = 2.0) -> bool:
+        """
+        Check if sufficient GPU memory is available.
+
+        Args:
+            required_gb (float): Required memory in GB
+
+        Returns:
+            bool: True if memory is available, False otherwise
+        """
+        stats = self.get_memory_stats()
+        available = stats["free_gb"]
+
+        if available < required_gb:
+            print(f"⚠ Low memory: {available:.2f}GB available, {required_gb:.2f}GB required")
+            # Attempt cleanup
+            self.clear_cache(aggressive=True)
+            stats = self.get_memory_stats()
+            available = stats["free_gb"]
+
+        return available >= required_gb
+
+    def switch_model_context(self, from_model: str, to_model: str) -> None:
+        """
+        Handle model switching with proper cleanup.
+
+        Args:
+            from_model (str): Current model to unload
+            to_model (str): Next model to prepare for
+        """
+        print(f"→ Switching context: {from_model} → {to_model}")
+
+        # Unregister old model
+        self.unregister_model(from_model)
+
+        # Aggressive cleanup before loading new model
+        self.clear_cache(aggressive=True)
+
+        # Update current model tracker
+        self.current_model = to_model
+        print(f"✓ Context switched to {to_model}")

TextProcessor.py

@@ -0,0 +1,199 @@
+# %%writefile text_processor.py
+"""
+DeltaFlow - Text Processor
+Handles semantic expansion using Qwen2.5-0.5B-Instruct
+Converts brief instructions into detailed motion descriptions
+"""
+
+import gc
+import traceback
+from typing import Optional
+
+import torch
+import ftfy
+import sentencepiece
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+class TextProcessor:
+    """
+    Semantic expansion engine using Qwen2.5-0.5B.
+    Transforms user inputs into motion-rich prompts for video generation.
+    """
+
+    MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+    MAX_OUTPUT_LENGTH = 100  # Token limit to ensure ~50 words
+
+    def __init__(self, resource_manager: Optional[object] = None):
+        """
+        Initialize TextProcessor with optional resource management.
+
+        Args:
+            resource_manager: Optional resource manager instance
+        """
+        self.resource_manager = resource_manager
+
+        # Determine device
+        if resource_manager is not None:
+            self.device = resource_manager.get_device()
+        else:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        self.model: Optional[AutoModelForCausalLM] = None
+        self.tokenizer: Optional[AutoTokenizer] = None
+        self.is_loaded = False
+
+    def load_model(self) -> None:
+        """Load Qwen model and tokenizer."""
+        if self.is_loaded:
+            print("⚠ TextProcessor already loaded, skipping...")
+            return
+
+        try:
+            print("→ Loading Qwen2.5-0.5B-Instruct...")
+
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.MODEL_ID,
+                trust_remote_code=True
+            )
+
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.MODEL_ID,
+                torch_dtype=torch.bfloat16,
+                device_map="auto",
+                trust_remote_code=True
+            )
+
+            if self.resource_manager is not None:
+                self.resource_manager.register_model("TextProcessor", self.model)
+
+            self.is_loaded = True
+            print("✓ TextProcessor loaded successfully")
+
+        except Exception as e:
+            print(f"✗ Error loading TextProcessor: {str(e)}")
+            raise
+
+    def unload_model(self) -> None:
+        """Unload model and free GPU memory."""
+        if not self.is_loaded:
+            return
+
+        try:
+            if self.model is not None:
+                self.model.to('cpu')
+                del self.model
+                self.model = None
+
+            if self.tokenizer is not None:
+                del self.tokenizer
+                self.tokenizer = None
+
+            if self.resource_manager is not None:
+                self.resource_manager.unregister_model("TextProcessor")
+                self.resource_manager.clear_cache(aggressive=True)
+            else:
+                gc.collect()
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+
+            self.is_loaded = False
+            print("✓ TextProcessor unloaded")
+
+        except Exception as e:
+            print(f"⚠ Error during TextProcessor unload: {str(e)}")
+
+    def expand_prompt(self, user_input: str) -> str:
+        """
+        Convert user's brief instruction into detailed motion description.
+
+        Args:
+            user_input: User's original instruction
+
+        Returns:
+            str: Expanded prompt for video generation (≤50 words)
+        """
+        if not self.is_loaded:
+            raise RuntimeError("TextProcessor not loaded. Call load_model() first.")
+
+        system_prompt = """You are a motion description expert. Convert the user's brief instruction into a detailed, dynamic prompt for video generation.
+
+Focus on:
+- Camera movements (pan, zoom, tilt, tracking)
+- Subject actions and motions
+- Scene dynamics and atmosphere
+- Temporal flow and transitions
+
+Keep output under 50 words. Use vivid, cinematic language. English only."""
+
+        try:
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_input}
+            ]
+
+            text = self.tokenizer.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=True
+            )
+
+            model_inputs = self.tokenizer([text], return_tensors="pt").to(self.device)
+
+            with torch.no_grad():
+                generated_ids = self.model.generate(
+                    **model_inputs,
+                    max_new_tokens=self.MAX_OUTPUT_LENGTH,
+                    do_sample=True,
+                    temperature=0.7,
+                    top_p=0.9,
+                    repetition_penalty=1.1
+                )
+
+            generated_ids = [
+                output_ids[len(input_ids):]
+                for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+            ]
+
+            expanded_prompt = self.tokenizer.batch_decode(
+                generated_ids,
+                skip_special_tokens=True
+            )[0].strip()
+
+            # Enforce word limit
+            words = expanded_prompt.split()
+            if len(words) > 50:
+                expanded_prompt = " ".join(words[:50]) + "..."
+
+            print(f"✓ Prompt expanded: '{user_input}' → '{expanded_prompt}'")
+            return expanded_prompt
+
+        except Exception as e:
+            print(f"✗ Error during prompt expansion: {str(e)}")
+            return user_input
+
+    def process(self, user_input: str, auto_unload: bool = True) -> str:
+        """
+        Main processing pipeline: load → expand → (optionally unload).
+
+        Args:
+            user_input: User's instruction
+            auto_unload: Whether to unload model after processing
+
+        Returns:
+            str: Expanded prompt
+        """
+        try:
+            if not self.is_loaded:
+                self.load_model()
+
+            expanded = self.expand_prompt(user_input)
+
+            if auto_unload:
+                self.unload_model()
+
+            return expanded
+
+        except Exception as e:
+            print(f"✗ TextProcessor pipeline error: {str(e)}")
+            return user_input

VideoEngine.py

@@ -0,0 +1,415 @@
+# %%writefile VideoEngine.py
+"""
+DeltaFlow - Video Engine (Optimized)
+High-speed Image-to-Video generation using Wan2.2-I2V-A14B
+Features: Lightning LoRA + INT8/FP8 Quantization + AoT Compilation
+Environment-adaptive optimization for Colab Testing & HF Spaces Deployment
+"""
+
+import warnings
+warnings.filterwarnings('ignore', category=FutureWarning)
+warnings.filterwarnings('ignore', category=DeprecationWarning)
+
+import gc
+import os
+import tempfile
+import traceback
+from typing import Optional
+
+import torch
+import numpy as np
+from PIL import Image
+
+# Critical dependencies
+import ftfy
+import sentencepiece
+
+# Diffusers imports
+from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline
+from diffusers.models.transformers.transformer_wan import WanTransformer3DModel
+from diffusers.utils.export_utils import export_to_video
+
+# Optional dependency for AOTI (HF Spaces deployment only)
+try:
+    from spaces.zero.torch.aoti import aoti_blocks_load
+    HAS_AOTI = True
+except ImportError:
+    HAS_AOTI = False
+
+
+class VideoEngine:
+    """
+    Ultra-fast video generation engine using Wan2.2-I2V with Lightning LoRA.
+    Optimized for 4-8 step inference with INT8/FP8 quantization.
+    """
+
+    MODEL_ID = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
+    TRANSFORMER_REPO = "cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers"
+    LORA_REPO = "Kijai/WanVideo_comfy"
+    LORA_WEIGHT = "Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank128_bf16.safetensors"
+
+    # Model parameters
+    MAX_DIM = 832
+    MIN_DIM = 480
+    SQUARE_DIM = 640
+    MULTIPLE_OF = 16
+    FIXED_FPS = 16
+    MIN_FRAMES = 8
+    MAX_FRAMES = 80
+
+    DEFAULT_PARAMS = {
+        "num_inference_steps": 4,
+        "guidance_scale": 1.0,
+        "guidance_scale_2": 1.0,
+    }
+
+    def __init__(self):
+        """Initialize VideoEngine with environment-adaptive configuration."""
+        # Environment detection
+        self.is_spaces = os.environ.get('SPACE_ID') is not None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # Model state
+        self.pipeline: Optional[WanImageToVideoPipeline] = None
+        self.is_loaded = False
+
+        # Log environment
+        env_name = "HuggingFace Spaces" if self.is_spaces else "Colab/Local Testing"
+        print(f"🌍 Environment detected: {env_name}")
+
+    def _check_torchao_available(self) -> bool:
+        """Check if torchao is available for quantization."""
+        try:
+            import torchao
+            return True
+        except ImportError:
+            return False
+
+    def _check_aoti_available(self) -> bool:
+        """Check if aoti is available for AoT compilation."""
+        try:
+            import aoti
+            return True
+        except ImportError:
+            return False
+
+    def _check_xformers_available(self) -> bool:
+        """Check if xformers is available for memory efficient attention."""
+        try:
+            import xformers
+            return True
+        except ImportError:
+            return False
+
+    def _apply_quantization(self):
+        """Apply INT8/FP8 quantization based on GPU capability."""
+        if not self._check_torchao_available():
+            print("⚠ [3/7] Skipping quantization (torchao not available)")
+            return
+
+        from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig, Int8WeightOnlyConfig
+
+        print("→ [3/7] Applying quantization...")
+
+        # Check GPU compute capability for FP8 support
+        fp8_supported = False
+        if torch.cuda.is_available():
+            cuda_capability = torch.cuda.get_device_capability()
+            fp8_supported = cuda_capability[0] > 8 or (cuda_capability[0] == 8 and cuda_capability[1] >= 9)
+            print(f"  • GPU: {torch.cuda.get_device_name(0)}")
+            print(f"  • Compute Capability: {cuda_capability[0]}.{cuda_capability[1]}")
+            print(f"  • FP8 Support: {'Yes' if fp8_supported else 'No (requires >=8.9)'}")
+
+        # Text encoder: INT8 (always supported)
+        quantize_(self.pipeline.text_encoder, Int8WeightOnlyConfig())
+
+        if fp8_supported:
+            # Use FP8 for transformers (faster)
+            quantize_(self.pipeline.transformer, Float8DynamicActivationFloat8WeightConfig())
+            quantize_(self.pipeline.transformer_2, Float8DynamicActivationFloat8WeightConfig())
+            print("✓ FP8 quantization applied (transformers)")
+        else:
+            # Fallback to INT8 for transformers (still faster than BF16)
+            quantize_(self.pipeline.transformer, Int8WeightOnlyConfig())
+            quantize_(self.pipeline.transformer_2, Int8WeightOnlyConfig())
+            print("✓ INT8 quantization applied (transformers)")
+
+        print("✓ Quantization complete")
+
+    def _enable_tf32(self):
+        """Enable TF32 acceleration for A100/H100 GPUs."""
+        if self.device != "cuda":
+            return
+
+        print("→ [4/7] Enabling TF32 acceleration...")
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        print("✓ TF32 enabled (20-30% speedup on A100/H100)")
+
+    def _enable_xformers(self):
+        """Enable xFormers memory efficient attention."""
+        print("→ [5/7] Enabling xFormers attention...")
+
+        if not self._check_xformers_available():
+            print("⚠ xFormers not available, using standard attention")
+            return
+
+        try:
+            self.pipeline.enable_xformers_memory_efficient_attention()
+            print("✓ xFormers enabled (25-30% speedup)")
+        except Exception as e:
+            print(f"⚠ xFormers failed: {e}")
+            print("  Continuing with standard attention")
+
+    def _apply_aot_compilation(self):
+        """Apply AOTI pre-compiled blocks (HF Spaces deployment only)."""
+        if not self.is_spaces:
+            print("→ [6/7] Skipping AOTI (testing mode, not needed)")
+            return
+
+        if not HAS_AOTI:
+            print("⚠ [6/7] Skipping AOTI (spaces.zero.torch.aoti not available)")
+            return
+
+        print("→ [6/7] Loading AOTI pre-compiled blocks...")
+        try:
+            # Determine variant based on GPU capability
+            variant = 'int8'  # Default
+            if torch.cuda.is_available():
+                cuda_cap = torch.cuda.get_device_capability()
+                fp8_supported = cuda_cap[0] > 8 or (cuda_cap[0] == 8 and cuda_cap[1] >= 9)
+                if fp8_supported:
+                    variant = 'fp8da'
+
+            # Load pre-compiled blocks from zerogpu-aoti/Wan2
+            aoti_blocks_load(self.pipeline.transformer, 'zerogpu-aoti/Wan2', variant=variant)
+            aoti_blocks_load(self.pipeline.transformer_2, 'zerogpu-aoti/Wan2', variant=variant)
+            print(f"✓ AOTI blocks loaded (variant: {variant}, 60-70% speedup)")
+        except Exception as e:
+            print(f"⚠ AOTI load failed (falling back to standard inference): {e}")
+            print("  This is not critical, speed will be slightly slower")
+
+    def load_model(self) -> None:
+        """Load Wan2.2 pipeline with Lightning LoRA and optimizations."""
+        if self.is_loaded:
+            print("⚠ VideoEngine already loaded, skipping...")
+            return
+
+        try:
+            # Aggressive memory cleanup before loading
+            print("→ Clearing GPU memory before loading model...")
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                torch.cuda.ipc_collect()
+
+            print("=" * 60)
+            print("Loading Wan2.2 I2V Engine with Optimizations")
+            print("=" * 60)
+
+            # Stage 1: Load base pipeline
+            print("→ [1/7] Loading base pipeline...")
+            self.pipeline = WanImageToVideoPipeline.from_pretrained(
+                self.MODEL_ID,
+                transformer=WanTransformer3DModel.from_pretrained(
+                    self.TRANSFORMER_REPO,
+                    subfolder='transformer',
+                    torch_dtype=torch.bfloat16,
+                    device_map='cuda',
+                ),
+                transformer_2=WanTransformer3DModel.from_pretrained(
+                    self.TRANSFORMER_REPO,
+                    subfolder='transformer_2',
+                    torch_dtype=torch.bfloat16,
+                    device_map='cuda',
+                ),
+                torch_dtype=torch.bfloat16,
+            ).to('cuda')
+
+            # Stage 2: Load Lightning LoRA
+            print("→ [2/7] Loading Lightning LoRA adapters...")
+            self.pipeline.load_lora_weights(self.LORA_REPO, weight_name=self.LORA_WEIGHT, adapter_name="lightx2v")
+            kwargs_lora = {"load_into_transformer_2": True}
+            self.pipeline.load_lora_weights(self.LORA_REPO, weight_name=self.LORA_WEIGHT, adapter_name="lightx2v_2", **kwargs_lora)
+            self.pipeline.set_adapters(["lightx2v", "lightx2v_2"], adapter_weights=[1., 1.])
+            self.pipeline.fuse_lora(adapter_names=["lightx2v"], lora_scale=3., components=["transformer"])
+            self.pipeline.fuse_lora(adapter_names=["lightx2v_2"], lora_scale=1., components=["transformer_2"])
+            self.pipeline.unload_lora_weights()
+            print("✓ Lightning LoRA loaded and fused")
+
+            # Stage 3: Apply quantization (both environments - critical for memory)
+            self._apply_quantization()
+
+            # Stage 4: Enable TF32 acceleration
+            self._enable_tf32()
+
+            # Stage 5: Enable xFormers attention
+            self._enable_xformers()
+
+            # Stage 6: Apply AOTI (deployment only)
+            self._apply_aot_compilation()
+
+            # Stage 7: Final setup
+            print("→ [7/7] Finalizing setup...")
+            self.is_loaded = True
+
+            # Determine precision used
+            precision_info = "BF16 (no quantization)"
+            if self._check_torchao_available() and torch.cuda.is_available():
+                cuda_cap = torch.cuda.get_device_capability()
+                fp8_supported = cuda_cap[0] > 8 or (cuda_cap[0] == 8 and cuda_cap[1] >= 9)
+                precision_info = "FP8 (quantized)" if fp8_supported else "INT8 (quantized)"
+
+            # Display status
+            mode_name = "Deployment (HF Spaces)" if self.is_spaces else "Testing (Colab/Local)"
+            print("=" * 60)
+            print(f"✓ VideoEngine Ready - {mode_name}")
+            print(f"  • Device: {self.device}")
+            print(f"  • Precision: {precision_info} (Memory Optimized)")
+            print(f"  • Lightning LoRA: Enabled (4-step inference)")
+            print(f"  • TF32: {'Enabled' if self.device == 'cuda' else 'N/A (CPU)'}")
+            print(f"  • xFormers: {'Enabled' if self._check_xformers_available() else 'Disabled'}")
+            if self.is_spaces:
+                print(f"  • AOTI: {'Enabled' if HAS_AOTI else 'Disabled'}")
+                print(f"  • Expected Speed: 15-30s per video")
+            else:
+                print(f"  • Expected Speed: 180-220s per video (A100 40GB)")
+            print("=" * 60)
+
+        except Exception as e:
+            print(f"\n{'='*60}")
+            print("✗ FATAL ERROR LOADING VIDEO ENGINE")
+            print(f"{'='*60}")
+            print(f"Error Type: {type(e).__name__}")
+            print(f"Error Message: {str(e)}")
+            print(f"\nFull Traceback:")
+            print(traceback.format_exc())
+            print(f"{'='*60}")
+            raise
+
+    def resize_image(self, image: Image.Image) -> Image.Image:
+        """Resize image to fit model constraints while preserving aspect ratio."""
+        width, height = image.size
+
+        if width == height:
+            return image.resize((self.SQUARE_DIM, self.SQUARE_DIM), Image.LANCZOS)
+
+        aspect_ratio = width / height
+        MAX_ASPECT_RATIO = self.MAX_DIM / self.MIN_DIM
+        MIN_ASPECT_RATIO = self.MIN_DIM / self.MAX_DIM
+
+        image_to_resize = image
+
+        if aspect_ratio > MAX_ASPECT_RATIO:
+            target_w, target_h = self.MAX_DIM, self.MIN_DIM
+            crop_width = int(round(height * MAX_ASPECT_RATIO))
+            left = (width - crop_width) // 2
+            image_to_resize = image.crop((left, 0, left + crop_width, height))
+        elif aspect_ratio < MIN_ASPECT_RATIO:
+            target_w, target_h = self.MIN_DIM, self.MAX_DIM
+            crop_height = int(round(width / MIN_ASPECT_RATIO))
+            top = (height - crop_height) // 2
+            image_to_resize = image.crop((0, top, width, top + crop_height))
+        else:
+            if width > height:
+                target_w = self.MAX_DIM
+                target_h = int(round(target_w / aspect_ratio))
+            else:
+                target_h = self.MAX_DIM
+                target_w = int(round(target_h * aspect_ratio))
+
+        final_w = round(target_w / self.MULTIPLE_OF) * self.MULTIPLE_OF
+        final_h = round(target_h / self.MULTIPLE_OF) * self.MULTIPLE_OF
+        final_w = max(self.MIN_DIM, min(self.MAX_DIM, final_w))
+        final_h = max(self.MIN_DIM, min(self.MAX_DIM, final_h))
+
+        return image_to_resize.resize((final_w, final_h), Image.LANCZOS)
+
+    def get_num_frames(self, duration_seconds: float) -> int:
+        """Calculate frame count from duration."""
+        return 1 + int(np.clip(
+            int(round(duration_seconds * self.FIXED_FPS)),
+            self.MIN_FRAMES,
+            self.MAX_FRAMES,
+        ))
+
+    def generate_video(
+        self,
+        image: Image.Image,
+        prompt: str,
+        duration_seconds: float = 3.0,
+        num_inference_steps: int = 4,
+        guidance_scale: float = 1.0,
+        guidance_scale_2: float = 1.0,
+        seed: int = 42,
+    ) -> str:
+        """Generate video from image with optimized pipeline."""
+        if not self.is_loaded:
+            raise RuntimeError("VideoEngine not loaded. Call load_model() first.")
+
+        try:
+            resized_image = self.resize_image(image)
+            num_frames = self.get_num_frames(duration_seconds)
+
+            print(f"\n→ Generating video:")
+            print(f"  • Prompt: {prompt}")
+            print(f"  • Resolution: {resized_image.width}x{resized_image.height}")
+            print(f"  • Frames: {num_frames} ({duration_seconds}s @ {self.FIXED_FPS}fps)")
+            print(f"  • Steps: {num_inference_steps}")
+
+            with torch.no_grad():
+                output_frames = self.pipeline(
+                    image=resized_image,
+                    prompt=prompt,
+                    height=resized_image.height,
+                    width=resized_image.width,
+                    num_frames=num_frames,
+                    guidance_scale=float(guidance_scale),
+                    guidance_scale_2=float(guidance_scale_2),
+                    num_inference_steps=int(num_inference_steps),
+                    generator=torch.Generator(device="cuda").manual_seed(seed),
+                ).frames[0]
+
+            # Export video with fast encoding
+            temp_dir = tempfile.gettempdir()
+            output_path = os.path.join(temp_dir, f"deltaflow_{seed}.mp4")
+
+            # Use ultrafast preset for faster encoding (2-5s savings)
+            export_to_video(output_frames, output_path, fps=self.FIXED_FPS)
+
+            print(f"✓ Video generated: {output_path}")
+            return output_path
+
+        except torch.cuda.OutOfMemoryError:
+            print(f"\n{'='*60}")
+            print("✗ GPU OUT OF MEMORY ERROR")
+            print(f"{'='*60}")
+            print(traceback.format_exc())
+            print(f"{'='*60}")
+            raise RuntimeError("Insufficient GPU memory. Try reducing duration or restarting.")
+        except Exception as e:
+            print(f"\n{'='*60}")
+            print("✗ FATAL ERROR DURING VIDEO GENERATION")
+            print(f"{'='*60}")
+            print(f"Error Type: {type(e).__name__}")
+            print(f"Error Message: {str(e)}")
+            print(f"\nFull Traceback:")
+            print(traceback.format_exc())
+            print(f"{'='*60}")
+            raise
+
+    def unload_model(self) -> None:
+        """Unload pipeline and free memory."""
+        if not self.is_loaded:
+            return
+
+        try:
+            if self.pipeline is not None:
+                del self.pipeline
+                self.pipeline = None
+
+            torch.cuda.empty_cache()
+            self.is_loaded = False
+            print("✓ VideoEngine unloaded")
+        except Exception as e:
+            print(f"⚠ Unload warning: {str(e)}")

app.py

@@ -0,0 +1,146 @@
+import os
+import sys
+
+sys.stdout.flush()
+import functools
+print = functools.partial(print, flush=True)
+
+import ftfy
+import sentencepiece
+
+from FlowFacade import FlowFacade
+from ui_manager import UIManager
+
+
+def preload_models():
+    """
+    Pre-download models to cache on HF Spaces startup.
+    Backup method if YAML preload_from_hub doesn't work.
+    Only runs in HF Spaces environment.
+    """
+    if not os.environ.get('SPACE_ID'):
+        return
+
+    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
+    if os.path.exists(cache_dir):
+        cached_models = os.listdir(cache_dir)
+        if any("wan2.2" in m.lower() or "models--kijai" in m.lower() for m in cached_models):
+            print("✓ Models already cached (YAML preload worked)")
+            return
+
+    print("→ Pre-caching models to disk (first-time setup)...")
+    print("  This may take 2-3 minutes, please wait...")
+
+    try:
+        from diffusers import WanTransformer3DModel
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        from huggingface_hub import hf_hub_download
+        import torch
+
+        print("  [1/4] Downloading video model transformer...")
+        WanTransformer3DModel.from_pretrained(
+            "kijai/wan2.2-i2v-a14b-diffusers",
+            subfolder='transformer',
+            torch_dtype=torch.bfloat16,
+        )
+
+        print("  [2/4] Downloading video model transformer_2...")
+        WanTransformer3DModel.from_pretrained(
+            "kijai/wan2.2-i2v-a14b-diffusers",
+            subfolder='transformer_2',
+            torch_dtype=torch.bfloat16,
+        )
+
+        print("  [3/4] Downloading Lightning LoRA...")
+        hf_hub_download(
+            "Lightricks/LTX-Video",
+            "ltx-video-2b-v0.9.safetensors"
+        )
+
+        print("  [4/4] Downloading text model (optional)...")
+        AutoModelForCausalLM.from_pretrained(
+            "Qwen/Qwen2.5-0.5B-Instruct",
+            torch_dtype=torch.bfloat16,
+        )
+        AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
+
+        print("✓ All models cached successfully!")
+        print("  Future users will load instantly from cache")
+
+    except Exception as e:
+        print(f"⚠ Pre-cache warning: {e}")
+        print("  Models will download on first generation instead")
+
+
+def check_environment():
+    required_packages = [
+        "torch", "transformers", "diffusers", "gradio", "PIL",
+        "accelerate", "numpy", "ftfy", "sentencepiece"
+    ]
+
+    optional_packages = {
+        "torchao": "INT8/FP8 quantization",
+        "xformers": "Memory efficient attention",
+        "aoti": "AoT compilation"
+    }
+
+    missing_packages = []
+    missing_optional = []
+
+    for package in required_packages:
+        try:
+            __import__(package)
+        except ImportError:
+            missing_packages.append(package)
+
+    for package, description in optional_packages.items():
+        try:
+            __import__(package)
+        except ImportError:
+            missing_optional.append(f"{package} ({description})")
+
+    if missing_packages:
+        print("\n❌ Missing required packages:", ", ".join(missing_packages))
+        print("\nInstall commands:")
+        print("!pip install torch==2.9.0 torchvision==0.24.0 torchaudio==2.9.0 --index-url https://download.pytorch.org/whl/cu126")
+        print("!pip install diffusers>=0.32.0 transformers>=4.46.0 accelerate gradio pillow numpy spaces ftfy sentencepiece protobuf imageio-ffmpeg")
+        print("!pip install torchao xformers")
+        sys.exit(1)
+
+    # Only show missing optional in debug mode
+    if missing_optional and os.environ.get('DEBUG'):
+        print("⚠ Optional packages missing:", ", ".join(missing_optional))
+
+
+def main():
+    check_environment()
+    preload_models()
+
+    try:
+        facade = FlowFacade()
+        ui = UIManager(facade)
+        is_colab = 'google.colab' in sys.modules
+
+        print("✓ Ready")
+        ui.launch(
+            share=is_colab,
+            server_name="0.0.0.0",
+            server_port=None,
+            show_error=True
+        )
+
+    except KeyboardInterrupt:
+        print("\n⚠ Shutdown requested")
+        if 'facade' in locals():
+            facade.cleanup()
+        sys.exit(0)
+
+    except Exception as e:
+        print(f"\n❌ Startup error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

css_style.py

@@ -0,0 +1,279 @@
+DELTAFLOW_CSS = """
+/* Global Light Theme */
+:root {
+    --primary-bg: #f8f9fa;
+    --secondary-bg: #ffffff;
+    --card-bg: #ffffff;
+    --border-color: #e0e0e0;
+    --text-primary: #2c3e50;
+    --text-secondary: #6c757d;
+    --accent-color: #6366f1;
+    --accent-hover: #4f46e5;
+    --success-color: #10b981;
+    --error-color: #ef4444;
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.08);
+    --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.12);
+    --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.16);
+}
+
+/* Main Container */
+.gradio-container {
+    background: var(--primary-bg) !important;
+    font-family: 'Segoe UI', 'Inter', -apple-system, BlinkMacSystemFont, sans-serif !important;
+}
+
+/* Header Styling */
+.header-container {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    padding: 2.5rem 2rem;
+    border-radius: 16px;
+    margin-bottom: 2rem;
+    box-shadow: var(--shadow-lg);
+}
+
+.header-title {
+    font-size: 2.8rem;
+    font-weight: 700;
+    color: #ffffff;
+    margin: 0;
+    letter-spacing: -0.02em;
+    text-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+}
+
+.header-subtitle {
+    font-size: 1.1rem;
+    color: rgba(255, 255, 255, 0.95);
+    margin-top: 0.5rem;
+    font-weight: 400;
+}
+
+/* Card Styling */
+.input-card, .output-card {
+    background: var(--card-bg) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 12px !important;
+    padding: 1.5rem !important;
+    box-shadow: var(--shadow-md) !important;
+}
+
+/* Label Styling */
+label {
+    color: var(--text-primary) !important;
+    font-weight: 600 !important;
+    font-size: 0.95rem !important;
+    margin-bottom: 0.5rem !important;
+}
+
+/* Input Fields */
+textarea, input[type="text"], input[type="number"] {
+    background: var(--secondary-bg) !important;
+    border: 1.5px solid var(--border-color) !important;
+    color: var(--text-primary) !important;
+    border-radius: 8px !important;
+    padding: 0.75rem !important;
+    font-size: 0.95rem !important;
+    transition: all 0.2s ease !important;
+}
+
+textarea:focus, input[type="text"]:focus, input[type="number"]:focus {
+    border-color: var(--accent-color) !important;
+    box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.15) !important;
+    outline: none !important;
+}
+
+/* Button Styling */
+.primary-button {
+    background: linear-gradient(135deg, var(--accent-color) 0%, var(--accent-hover) 100%) !important;
+    border: none !important;
+    color: white !important;
+    padding: 0.875rem 2rem !important;
+    font-size: 1rem !important;
+    font-weight: 600 !important;
+    border-radius: 10px !important;
+    cursor: pointer !important;
+    transition: all 0.3s ease !important;
+    box-shadow: 0 4px 12px rgba(99, 102, 241, 0.3) !important;
+}
+
+.primary-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(99, 102, 241, 0.4) !important;
+}
+
+/* Checkbox & Switch */
+input[type="checkbox"] {
+    accent-color: var(--accent-color) !important;
+}
+
+/* Progress Bar */
+.progress-bar {
+    background: #f0f0f0 !important;
+    border-radius: 8px !important;
+    overflow: hidden !important;
+}
+
+.progress-bar-fill {
+    background: linear-gradient(90deg, var(--accent-color), var(--success-color)) !important;
+    height: 8px !important;
+}
+
+/* Video Player */
+video {
+    border-radius: 12px !important;
+    box-shadow: var(--shadow-md) !important;
+    max-width: 100% !important;
+    border: 1px solid var(--border-color) !important;
+}
+
+/* Image Upload Area */
+.image-upload {
+    border: 2px dashed var(--border-color) !important;
+    border-radius: 12px !important;
+    background: #fafafa !important;
+    transition: all 0.3s ease !important;
+}
+
+.image-upload:hover {
+    border-color: var(--accent-color) !important;
+    background: rgba(99, 102, 241, 0.03) !important;
+}
+
+/* Accordion */
+.accordion {
+    background: var(--secondary-bg) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 8px !important;
+}
+
+/* Tabs */
+.tab-nav {
+    border-bottom: 2px solid var(--border-color) !important;
+}
+
+.tab-nav button {
+    color: var(--text-secondary) !important;
+    border-bottom: 2px solid transparent !important;
+    transition: all 0.2s ease !important;
+}
+
+.tab-nav button.selected {
+    color: var(--accent-color) !important;
+    border-bottom-color: var(--accent-color) !important;
+    font-weight: 600 !important;
+}
+
+/* Status Messages */
+.success-msg {
+    color: var(--success-color) !important;
+    background: rgba(16, 185, 129, 0.1) !important;
+    padding: 0.75rem !important;
+    border-radius: 8px !important;
+    border-left: 4px solid var(--success-color) !important;
+}
+
+.error-msg {
+    color: var(--error-color) !important;
+    background: rgba(239, 68, 68, 0.1) !important;
+    padding: 0.75rem !important;
+    border-radius: 8px !important;
+    border-left: 4px solid var(--error-color) !important;
+}
+
+/* Info Box */
+.info-box {
+    background: #f0f4ff !important;
+    border: 1px solid #c7d7fe !important;
+    border-radius: 8px !important;
+    padding: 1rem !important;
+    color: #4338ca !important;
+    font-size: 0.9rem !important;
+}
+
+/* Patience Banner */
+.patience-banner {
+    background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%) !important;
+    border: 1px solid #fbbf24 !important;
+    border-radius: 8px !important;
+    padding: 0.875rem !important;
+    margin-bottom: 1rem !important;
+    color: #92400e !important;
+    font-size: 0.875rem !important;
+    text-align: center !important;
+    box-shadow: 0 2px 8px rgba(251, 191, 36, 0.15) !important;
+}
+
+/* Quality Tips Banner (Blue) */
+.quality-banner {
+    background: linear-gradient(135deg, #dbeafe 0%, #bfdbfe 100%) !important;
+    border: 1px solid #60a5fa !important;
+    border-radius: 8px !important;
+    padding: 0.875rem !important;
+    margin-bottom: 1rem !important;
+    color: #1e40af !important;
+    font-size: 0.875rem !important;
+    text-align: left !important;
+    box-shadow: 0 2px 8px rgba(96, 165, 250, 0.15) !important;
+}
+
+/* Loading Spinner */
+.loading {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid rgba(99, 102, 241, 0.2);
+    border-radius: 50%;
+    border-top-color: var(--accent-color);
+    animation: spin 1s ease-in-out infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+/* Footer */
+.footer {
+    text-align: center;
+    padding: 1.5rem;
+    color: var(--text-secondary);
+    font-size: 0.85rem;
+    border-top: 1px solid var(--border-color);
+    margin-top: 2rem;
+    background: var(--secondary-bg);
+    border-radius: 8px;
+}
+
+/* Example Cards */
+.example-card {
+    background: var(--secondary-bg) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 8px !important;
+    padding: 1rem !important;
+    transition: all 0.2s ease !important;
+}
+
+.example-card:hover {
+    border-color: var(--accent-color) !important;
+    box-shadow: var(--shadow-sm) !important;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .header-title {
+        font-size: 2rem;
+    }
+
+    .header-subtitle {
+        font-size: 0.95rem;
+    }
+
+    .input-card, .output-card {
+        padding: 1rem !important;
+    }
+}
+
+/* Container Max Width */
+.gradio-container .contain {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+}
+"""

prompt_examples.py

@@ -0,0 +1,93 @@
+PROMPT_EXAMPLES = {
+    "Fashion / Beauty Portrait": [
+        "Hair flows elegantly, model gazes confidently at camera, studio lighting highlights facial features, high-fashion editorial",
+        "Dramatic hair whip in slow motion, fierce eye contact with camera, wind machine effect, hair flies dynamically across frame",
+        "Model's head tilts back with confidence, hair cascades like waterfall, powerful gaze intensifies, editorial vogue style",
+        "Explosive hair toss left to right, eyes lock onto camera seductively, strobe lighting flashes, high-energy fashion film",
+        "Hand gracefully sweeps through hair, fingers run through strands, sultry gaze follows movement, intimate beauty moment",
+        "Model touches hair delicately, hand brushes cheek softly, eyes sparkle with emotion, romantic close-up shot",
+        "Hair flips dramatically to one side, hand catches falling strands, confident smile emerges, dynamic fashion energy",
+        "Slow-motion head turn reveals profile, hand tucks hair behind ear elegantly, studio lights create dramatic shadows",
+        "Subtle wink emerges slowly, one eye closes playfully, lips curve into flirty smile, head tilts coyly, seductive charm",
+        "Radiant smile spreads across face, eyes sparkle with joy, cheeks lift naturally, warm genuine happiness radiates",
+        "Seductive gaze intensifies, eyes narrow alluringly, lips part slightly, slow blink follows, smoldering fashion intensity",
+        "Playful wink with knowing smile, eyebrow raises suggestively, head turns to camera confidently, charismatic energy",
+    ],
+
+    "Portrait / Character - Subtle": [
+        "Subject turns head sharply to camera, eyes widen with surprise, hair swings dramatically, emotional close-up",
+        "Person laughs heartily, head tilts back, genuine joy radiates, natural lighting shifts warmly",
+        "Character looks around curiously, head movements follow unseen object, eyes track motion, engaging storytelling",
+        "Subject's expression transforms from neutral to big smile, eyebrows raise, head nods enthusiastically, vibrant energy",
+        "Gentle nod and smile, eyes close briefly then open, warm expression emerges, peaceful moment",
+        "Person takes deep breath, slight head tilt, eyes sparkle with realization, cinematic character moment",
+        "Soft smile appears gradually, eyes crinkle with warmth, gentle head tilt follows, peaceful happiness",
+        "Quick wink and friendly smile, eyebrows lift playfully, natural cheerful expression, approachable energy",
+    ],
+
+    "Portrait / Character - Dynamic": [
+        "Hand waves enthusiastically in front of camera, fingers spread wide, big smile accompanies gesture, friendly greeting",
+        "Subject raises hand to forehead dramatically, gasps in realization, eyes widen, theatrical reaction shot",
+        "Hand brushes hair back confidently, head tilts to side, playful wink follows, charismatic personality shine",
+        "Person covers mouth while laughing, shoulders shake, hand gestures expressively, genuine candid moment",
+        "Subject points at camera playfully, leans forward, grin widens, interactive engaging energy",
+        "Hand touches chin thoughtfully, eyes look upward pondering, subtle head tilt, contemplative character study",
+        "Dramatic hand through hair motion, head turns following movement, intense gaze locks camera, powerful presence",
+        "Person adjusts glasses with one hand, smirks confidently, eyebrow raises, smart intellectual vibe",
+    ],
+
+    "Animals - Lively": [
+        "Dog's head tilts adorably, ears perk up alert, tail wags enthusiastically, playful curious energy",
+        "Cat stretches luxuriously, yawns showing teeth, blinks slowly then gazes directly at camera, feline grace",
+        "Bird fluffs feathers, hops energetically, head bobs rhythmically, chirping motion implied, vibrant life",
+        "Puppy's tongue lolls out happily, panting motion, ears flap gently, joyful innocent expression",
+        "Horse tosses mane dramatically, nostrils flare, ears swivel attentively, majestic powerful presence",
+        "Rabbit's nose twitches rapidly, ears rotate independently, whiskers quiver, alert cautious awareness",
+        "Kitten paws at camera playfully, body wiggles preparing to pounce, eyes dilate with excitement, pure mischief",
+        "Squirrel's cheeks puff while chewing, tiny paws hold food, tail flicks nervously, adorable wild moment",
+    ],
+
+    "Landscape / Nature": [
+        "Camera swoops down from sky to ground, clouds race overhead, wind rushes through trees violently, epic establishing shot",
+        "Waves crash powerfully against rocks, water explodes upward in slow motion, dramatic sunset colors intensify",
+        "Time-lapse effect: clouds rush across sky rapidly, shadows race across landscape, day transforms to golden hour",
+        "Camera spins 360 degrees, panoramic mountain view rotates, eagle soars past lens, breathtaking nature documentary",
+        "Waterfall flows forcefully, mist rises dynamically, rainbow appears and intensifies, camera tilts up majestically",
+        "Lightning strikes in distance, storm clouds swirl ominously, rain begins to fall, dramatic weather transformation",
+        "Autumn leaves swirl in wind vortex, colors blur beautifully, gentle spiral motion, seasonal poetry",
+        "Ocean tide rushes in, foam spreads across sand, seagulls take flight, peaceful coastal rhythm",
+    ],
+
+    "Animation / Cartoon": [
+        "Character jumps high with exaggerated stretch, lands with bouncy squash, eyes pop out comically, cartoony physics",
+        "Magical transformation sequence, sparkles explode everywhere, character spins rapidly, colors shift vibrantly, anime style",
+        "Character does double-take, eyes bulge hugely, jaw drops to floor, classic cartoon reaction shot",
+        "Superpower activation: energy aura explodes outward, hair stands up dramatically, eyes glow intensely, epic anime moment",
+        "Character runs in place before zooming off-screen, dust cloud left behind, speed lines streak across frame",
+        "Dance animation: character moves rhythmically, strikes multiple poses, background pulses to beat, music video style",
+        "Chibi transformation: character shrinks adorably, sparkles surround, big eyes blink, kawaii energy overload",
+        "Fighting pose sequence: character winds up punch, muscles flex, impact lines radiate, shonen battle energy",
+    ],
+
+    "Product / Object": [
+        "Product explodes into component parts, pieces float and rotate individually, reassembles dramatically, technical showcase",
+        "360-degree rotation accelerates into fast spin, dramatic lighting sweeps across surface, particle effects add premium feel",
+        "Camera dive-bombs toward product, extreme close-up reveals texture details, pulls back to reveal full item dramatically",
+        "Product levitates and rotates, holographic interface elements appear around it, futuristic tech reveal",
+        "Liquid splashes around product in slow motion, droplets freeze mid-air, dramatic color-changing backlight",
+        "Product unfolds or opens mechanically, internal mechanisms visible, precision engineering showcased, satisfying transformation",
+        "Spotlight beam sweeps across product, reflections dance elegantly, luxury presentation unfolds, premium commercial",
+        "Product materializes from particles, glowing assembly process, high-tech materialization effect, sci-fi showcase",
+    ],
+
+    "Abstract / Artistic": [
+        "Explosion of colors radiates from center, patterns fractal outward infinitely, hypnotic kaleidoscope effect intensifies",
+        "Liquid paint flows and swirls violently, colors blend and separate, organic fluid simulation, mesmerizing motion",
+        "Geometric shapes shatter and reform, pieces scatter then snap back together, glitch art aesthetic",
+        "Camera plunges through tunnel of shifting patterns, colors strobe rapidly, psychedelic journey effect",
+        "Ink drops in water, tendrils expand and dance, colors bleed beautifully, organic abstract motion",
+        "Particles swarm and form shapes, disperse into chaos, reform into new patterns, digital art visualization",
+        "Mandala patterns rotate and morph, symmetry breaks then restores, spiritual geometric meditation",
+        "Light rays pierce through fog, volumetric beams sweep dramatically, ethereal atmosphere intensifies, divine ambiance",
+    ],
+}

requirements.txt

@@ -0,0 +1,31 @@
+# Core ML Frameworks
+torch>=2.9.0,<3.0.0
+torchvision>=0.24.0,<1.0.0
+torchaudio>=2.9.0,<3.0.0
+
+# Diffusion & Transformers
+diffusers>=0.32.0
+transformers>=4.46.0
+accelerate>=1.2.0
+
+# Quantization & Optimization
+torchao>=0.7.0
+xformers>=0.0.28
+
+# UI Framework
+gradio>=5.0.0
+
+# Image/Video Processing
+pillow>=11.0.0
+imageio-ffmpeg>=0.5.0
+
+# NLP Utilities
+ftfy>=6.3.0
+sentencepiece>=0.2.0
+protobuf>=5.29.0
+
+# Hugging Face
+spaces>=0.30.0
+
+# Utilities
+numpy>=1.24.0,<2.0.0

ui_manager.py

@@ -0,0 +1,274 @@
+import gradio as gr
+from PIL import Image
+from typing import Tuple
+from FlowFacade import FlowFacade
+from css_style import DELTAFLOW_CSS
+from prompt_examples import PROMPT_EXAMPLES
+
+
+class UIManager:
+    def __init__(self, facade: FlowFacade):
+        self.facade = facade
+
+    def create_interface(self) -> gr.Blocks:
+        with gr.Blocks(
+            theme=gr.themes.Soft(),
+            css=DELTAFLOW_CSS,
+            title="DeltaFlow - Fast AI Image to Video"
+        ) as interface:
+
+            # Header
+            gr.HTML("""
+                <div class="header-container">
+                    <h1 class="header-title">⚡ DeltaFlow</h1>
+                    <p class="header-subtitle">
+                        Bring Your Images to Life with AI Magic ✨<br>
+                        Transform any still image into dynamic, cinematic videos
+                    </p>
+                </div>
+            """)
+
+            with gr.Row():
+                # Left Panel: Input
+                with gr.Column(scale=1, elem_classes="input-card"):
+                    gr.Markdown("### 📤 Input")
+
+                    image_input = gr.Image(
+                        label="Upload Image (any type: photo, art, cartoon, etc.)",
+                        type="pil",
+                        elem_classes="image-upload",
+                        height=320
+                    )
+
+                    prompt_input = gr.Textbox(
+                        label="Motion Instruction",
+                        placeholder="Describe camera movements (zoom, pan, orbit) and subject actions (head turn, hair flow, expression change). Be specific and cinematic! Example: 'Camera slowly zooms in, subject's eyes sparkle, hair flows gently in wind'",
+                        lines=3,
+                        max_lines=6
+                    )
+
+                    # Quick preset selector
+                    category_dropdown = gr.Dropdown(
+                        choices=list(PROMPT_EXAMPLES.keys()),
+                        label="💡 Quick Prompt Category",
+                        value="Fashion / Beauty Portrait",
+                        interactive=True
+                    )
+
+                    example_dropdown = gr.Dropdown(
+                        choices=PROMPT_EXAMPLES["Fashion / Beauty Portrait"],
+                        label="Example Prompts (click to use)",
+                        value=None,  # Start with no selection to ensure first click works
+                        interactive=True
+                    )
+
+                    # Quality tips banner (blue)
+                    gr.HTML("""
+                        <div class="quality-banner">
+                            <strong>💡 Quality Tips for Best Results:</strong><br>
+                            • <strong>Describe what's IN the image:</strong> For Example: If hands aren't visible, don't mention hand movements<br>
+                            • <strong>Use example prompts:</strong> They're tested and optimized for this model<br>
+                            • <strong>Keep motions simple:</strong> Focus on head turns, expressions, camera movements
+                        </div>
+                    """)
+
+                    # Generate button with patience banner
+                    gr.HTML("""
+                        <div class="patience-banner">
+                            <strong>⏱️ Models are Initializing!</strong><br>
+                            This first-time generation may take a moment while high-fidelity assets load into memory.<br>
+                            Grab a coffee ☕, and watch the magic happen! Subsequent runs will be significantly faster.
+                        </div>
+                    """)
+
+                    generate_btn = gr.Button(
+                        "🎬 Generate Video",
+                        variant="primary",
+                        elem_classes="primary-button",
+                        size="lg"
+                    )
+
+                    # Advanced settings
+                    with gr.Accordion("⚙️ Advanced Settings", open=False):
+                        duration_slider = gr.Slider(
+                            minimum=0.5,
+                            maximum=5.0,
+                            step=0.5,
+                            value=3.0,
+                            label="Duration (seconds)",
+                            info="3.0s = 49 frames, 5.0s = 81 frames (16fps)"
+                        )
+
+                        steps_slider = gr.Slider(
+                            minimum=4,
+                            maximum=12,
+                            step=1,
+                            value=4,
+                            label="Inference Steps",
+                            info="4-6 recommended • Higher steps = longer generation time"
+                        )
+
+                        with gr.Row():
+                            guidance_scale = gr.Slider(
+                                minimum=0.0,
+                                maximum=5.0,
+                                step=0.5,
+                                value=1.0,
+                                label="Guidance Scale (high noise)"
+                            )
+
+                            guidance_scale_2 = gr.Slider(
+                                minimum=0.0,
+                                maximum=5.0,
+                                step=0.5,
+                                value=1.0,
+                                label="Guidance Scale (low noise)"
+                            )
+
+                        with gr.Row():
+                            seed_input = gr.Number(
+                                label="Seed",
+                                value=42,
+                                precision=0,
+                                minimum=0,
+                                maximum=2147483647
+                            )
+
+                            randomize_seed = gr.Checkbox(
+                                label="Randomize Seed",
+                                value=True
+                            )
+
+                        enable_ai_prompt = gr.Checkbox(
+                            label="🤖 Enable AI Prompt Expansion (Qwen2.5)",
+                            value=False,
+                            info="Use AI to enhance your prompt (adds ~30s)"
+                        )
+
+                # Right Panel: Output
+                with gr.Column(scale=1, elem_classes="output-card"):
+                    gr.Markdown("### 🎥 Output")
+
+                    video_output = gr.Video(
+                        label="Generated Video",
+                        height=400,
+                        autoplay=True
+                    )
+
+                    with gr.Row():
+                        prompt_output = gr.Textbox(
+                            label="Final Prompt Used",
+                            lines=3,
+                            interactive=False,
+                            show_copy_button=True,
+                            scale=3
+                        )
+
+                        seed_output = gr.Number(
+                            label="Seed Used",
+                            precision=0,
+                            interactive=False,
+                            scale=1
+                        )
+
+            # Info section
+            with gr.Row():
+                gr.HTML("""
+                    <div class="info-box">
+                        <strong>ℹ️ Tips for Best Results:</strong><br>
+                        • <strong>Use example prompts:</strong> Select a category above and click an example to get started<br>
+                        • <strong>Works with ANY image:</strong> Fashion portraits, anime, landscapes, products, abstract art, etc.<br>
+                        • <strong>For dramatic effects:</strong> Choose prompts with words like "explosive", "dramatic", "swirls", "transforms"<br>
+                        • <strong>Image quality matters:</strong> Higher resolution and clear subjects produce better results
+                    </div>
+                """)
+
+            # Footer
+            gr.HTML("""
+                <div class="footer">
+                    <p style="font-size: 0.9rem;">
+                        <strong>Powered by:</strong>
+                        Wan2.2-I2V-A14B · Qwen2.5-0.5B · Lightning LoRA
+                    </p>
+                </div>
+            """)
+
+            def update_examples(category):
+                return gr.Dropdown(choices=PROMPT_EXAMPLES[category], value=None)
+
+            def fill_prompt(selected_example):
+                return selected_example if selected_example else ""
+
+            category_dropdown.change(fn=update_examples, inputs=[category_dropdown],
+                                    outputs=[example_dropdown])
+            example_dropdown.change(fn=fill_prompt, inputs=[example_dropdown],
+                                   outputs=[prompt_input])
+
+            generate_btn.click(
+                fn=self._handle_generation,
+                inputs=[
+                    image_input,
+                    prompt_input,
+                    duration_slider,
+                    steps_slider,
+                    guidance_scale,
+                    guidance_scale_2,
+                    seed_input,
+                    randomize_seed,
+                    enable_ai_prompt
+                ],
+                outputs=[video_output, prompt_output, seed_output],
+                show_progress=True
+            )
+
+        return interface
+
+    def _handle_generation(self, image: Image.Image, prompt: str, duration: float,
+                          steps: int, guidance_1: float, guidance_2: float, seed: int,
+                          randomize: bool, enable_ai: bool,
+                          progress=gr.Progress()) -> Tuple[str, str, int]:
+        try:
+            if image is None:
+                raise gr.Error("❌ Please upload an image")
+            if not prompt or prompt.strip() == "":
+                raise gr.Error("❌ Please provide a motion instruction")
+            if not self.facade.validate_image(image):
+                raise gr.Error("❌ Image dimensions invalid (256-4096px)")
+
+            video_path, final_prompt, seed_used = self.facade.generate_video_from_image(
+                image=image,
+                user_instruction=prompt,
+                duration_seconds=duration,
+                num_inference_steps=steps,
+                guidance_scale=guidance_1,
+                guidance_scale_2=guidance_2,
+                seed=int(seed),
+                randomize_seed=randomize,
+                enable_prompt_expansion=enable_ai,
+                progress=progress
+            )
+
+            return video_path, final_prompt, seed_used
+
+        except gr.Error:
+            raise
+
+        except Exception as e:
+            import traceback
+            import os
+            error_msg = str(e)
+
+            if os.environ.get('DEBUG'):
+                print(f"\n✗ UI Error: {type(e).__name__}")
+                print(traceback.format_exc())
+
+            if "CUDA out of memory" in error_msg or "OutOfMemoryError" in error_msg:
+                raise gr.Error("❌ GPU memory insufficient. Try reducing duration/steps or restart.")
+            else:
+                raise gr.Error(f"❌ Generation failed: {error_msg}")
+
+    def launch(self, share: bool = False, server_name: str = "0.0.0.0",
+               server_port: int = None, **kwargs) -> None:
+        interface = self.create_interface()
+        interface.launch(share=share, server_name=server_name,
+                        server_port=server_port, **kwargs)