Upload app(5).py

app(5).py

@@ -0,0 +1,519 @@
+import gradio as gr
+from gradio_client import Client, handle_file
+import re
+import torch
+from diffusers import FluxPipeline
+import os
+
+# Instantiate a Client object from gradio_client pointing to the 'selfit-camera/Omni-Image-Editor' Space.
+client = Client("selfit-camera/Omni-Image-Editor")
+
+# Instantiate a Client object for video generation using alexnasa/ltx-2-TURBO Space.
+video_client = Client("alexnasa/ltx-2-TURBO")
+
+# Initialize the Flux pipeline for GPU-accelerated image generation
+pipe = None
+
+def initialize_pipe():
+    """Initialize the Flux pipeline for image generation."""
+    global pipe
+    if pipe is None:
+        try:
+            print("Loading Flux pipeline...")
+            pipe = FluxPipeline.from_pretrained(
+                "black-forest-labs/FLUX.1-dev",
+                torch_dtype=torch.bfloat16
+            )
+            pipe.enable_attention_slicing()
+            pipe = pipe.to("cuda")
+            print("Flux pipeline loaded successfully!")
+        except Exception as e:
+            print(f"Error loading Flux pipeline: {str(e)}")
+            raise gr.Error(f"Failed to load image generation model: {str(e)}")
+
+# Define a Python function for local GPU-accelerated image generation
+def generate_image_gpu(prompt, height, width, num_inference_steps, seed, randomize_seed, num_images):
+    """
+    Generate images locally using Flux model on GPU.
+    
+    Args:
+        prompt (str): Text description of the image to generate
+        height (int): Height of the image in pixels
+        width (int): Width of the image in pixels
+        num_inference_steps (int): Number of inference steps
+        seed (int): Random seed for reproducibility
+        randomize_seed (bool): Whether to randomize the seed
+        num_images (int): Number of images to generate (1-4)
+        
+    Returns:
+        tuple: (list of generated PIL images, seed used)
+    """
+    try:
+        # Initialize pipeline if not already done
+        initialize_pipe()
+        
+        # Validate prompt
+        if not prompt or not prompt.strip():
+            raise gr.Error("Please enter a prompt.")
+        
+        # Randomize seed if requested
+        if randomize_seed:
+            seed = torch.randint(0, 2**32 - 1, (1,)).item()
+        
+        # Clamp number of images to valid range (1-4)
+        num_images = min(max(1, int(num_images)), 4)
+        
+        # Create generator with seed
+        generator = torch.Generator("cuda").manual_seed(int(seed))
+        
+        # Generate images
+        with torch.no_grad():
+            result = pipe(
+                prompt=prompt,
+                height=int(height),
+                width=int(width),
+                num_inference_steps=int(num_inference_steps),
+                guidance_scale=0.0,
+                generator=generator,
+                max_sequence_length=1024,
+                num_images_per_prompt=num_images,
+                output_type="pil",
+            )
+        
+        return result.images, seed
+        
+    except gr.Error:
+        raise
+    except Exception as e:
+        raise gr.Error(f"Error generating images: {str(e)}")
+
+# Define a Python function for text-to-image generation
+def generate_image(prompt):
+    """
+    Generate an image from a text prompt using the Omni Image Editor API.
+    
+    Args:
+        prompt (str): Text description of the image to generate
+        
+    Returns:
+        str: URL of the generated image or error message
+    """
+    try:
+        # Call the client.predict() method with the user's prompt, aspect_ratio='16:9', and api_name='/text_to_image_interface'.
+        result = client.predict(
+            prompt=prompt,
+            aspect_ratio="16:9",
+            api_name="/text_to_image_interface"
+        )
+
+        # The predict method returns a tuple. The first element of this tuple is an HTML string containing the image.
+        # Extract the image URL from this HTML string.
+        html_string = result[0]
+        match = re.search(r"src='([^']+)'", html_string)
+        if match:
+            image_url = match.group(1)
+            return image_url
+        else:
+            # Handle cases where the URL might not be found
+            return "https://via.placeholder.com/400x200?text=Error:Image+Not+Found"
+    except Exception as e:
+        return f"Error generating image: {str(e)}"
+
+# Define a Python function for image editing
+def edit_image(input_image, edit_prompt):
+    """
+    Edit an image based on a text prompt using the Omni Image Editor API.
+    
+    Args:
+        input_image (str): Path to the image file or image object
+        edit_prompt (str): Text description of the edits to apply
+        
+    Returns:
+        str: URL of the edited image or error message
+    """
+    try:
+        if input_image is None:
+            return "Please upload an image first"
+        
+        # Use handle_file to properly handle the image upload
+        result = client.predict(
+            input_image=handle_file(input_image),
+            prompt=edit_prompt,
+            api_name="/edit_image_interface"
+        )
+        
+        # Extract the image URL from the HTML response
+        if isinstance(result, tuple) and len(result) > 0:
+            html_string = result[0]
+            match = re.search(r"src='([^']+)'", html_string)
+            if match:
+                image_url = match.group(1)
+                return image_url
+            else:
+                return "https://via.placeholder.com/400x200?text=Error:Image+Not+Found"
+        else:
+            return str(result)
+            
+    except Exception as e:
+        return f"Error editing image: {str(e)}"
+
+# Define a Python function for image upscaling
+def upscale_image(input_image):
+    """
+    Upscale an image to higher resolution using the Omni Image Editor API.
+    
+    Args:
+        input_image (str): Path to the image file or image object to upscale
+        
+    Returns:
+        str: URL of the upscaled image or error message
+    """
+    try:
+        if input_image is None:
+            return "Please upload an image first"
+        
+        # Use handle_file to properly handle the image upload
+        result = client.predict(
+            input_image=handle_file(input_image),
+            api_name="/image_upscale_interface"
+        )
+        
+        # Extract the image URL from the HTML response
+        if isinstance(result, tuple) and len(result) > 0:
+            html_string = result[0]
+            match = re.search(r"src='([^']+)'", html_string)
+            if match:
+                image_url = match.group(1)
+                return image_url
+            else:
+                return "https://via.placeholder.com/400x200?text=Error:Image+Not+Found"
+        else:
+            return str(result)
+            
+    except Exception as e:
+        return f"Error upscaling image: {str(e)}"
+
+# Define a Python function for video generation from images
+def generate_video(first_frame, end_frame, prompt, duration, height, width, enhance_prompt, seed, randomize_seed, camera_lora):
+    """
+    Generate a video from start and end frames using the LTX-2-TURBO API.
+    
+    Args:
+        first_frame (str): Path to the starting frame image
+        end_frame (str): Path to the ending frame image
+        prompt (str): Text description of the video to generate
+        duration (int): Duration of the video in seconds
+        height (int): Height of the video in pixels
+        width (int): Width of the video in pixels
+        enhance_prompt (bool): Whether to enhance the prompt with AI
+        seed (int): Random seed for reproducibility
+        randomize_seed (bool): Whether to randomize the seed
+        camera_lora (str): Camera LoRA setting
+        
+    Returns:
+        str: Path to the generated video or error message
+    """
+    try:
+        if first_frame is None or end_frame is None:
+            return "Please upload both start and end frame images"
+        
+        if not prompt.strip():
+            return "Please enter a video prompt"
+        
+        # Use handle_file to properly handle the image uploads
+        result = video_client.predict(
+            first_frame=handle_file(first_frame),
+            end_frame=handle_file(end_frame),
+            prompt=prompt,
+            duration=duration,
+            input_video=None,
+            generation_mode="Image-to-Video",
+            enhance_prompt=enhance_prompt,
+            seed=seed,
+            randomize_seed=randomize_seed,
+            height=height,
+            width=width,
+            camera_lora=camera_lora,
+            audio_path=None,
+            api_name="/generate_video"
+        )
+        
+        # Return the result directly (should be a video file path)
+        if result:
+            return result
+        else:
+            return "Error: No video generated"
+            
+    except Exception as e:
+        return f"Error generating video: {str(e)}"
+
+# Create a Gradio application using gr.Blocks for more granular control.
+with gr.Blocks(
+    title='Omni Image Editor with Gradio',
+    theme=gr.themes.Soft()
+) as demo:
+    gr.Markdown("# Omni Image Editor Studio")
+    gr.Markdown("Generate images from text descriptions or edit existing images with AI-powered tools.")
+    
+    with gr.Tabs():
+        # GPU-Accelerated Text-to-Image Tab
+        with gr.TabItem("GPU Image Generator"):
+            gr.Markdown("### High-Quality Image Generation (Local GPU)")
+            gr.Markdown("Generate high-quality images using Flux model running locally on your GPU. Faster and more private than API-based generation.")
+            
+            with gr.Row():
+                with gr.Column():
+                    gpu_prompt_input = gr.Textbox(
+                        label='Image Description',
+                        placeholder='e.g., A serene landscape with mountains and aurora borealis, photorealistic, 4K quality',
+                        lines=3
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    gpu_height = gr.Slider(
+                        label='Height (pixels)',
+                        minimum=256,
+                        maximum=1024,
+                        value=768,
+                        step=64
+                    )
+                with gr.Column():
+                    gpu_width = gr.Slider(
+                        label='Width (pixels)',
+                        minimum=256,
+                        maximum=1024,
+                        value=768,
+                        step=64
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    gpu_steps = gr.Slider(
+                        label='Inference Steps',
+                        minimum=1,
+                        maximum=50,
+                        value=20,
+                        step=1
+                    )
+                with gr.Column():
+                    gpu_num_images = gr.Slider(
+                        label='Number of Images',
+                        minimum=1,
+                        maximum=4,
+                        value=1,
+                        step=1
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    gpu_seed = gr.Number(
+                        label='Seed',
+                        value=0,
+                        precision=0
+                    )
+                with gr.Column():
+                    gpu_randomize = gr.Checkbox(
+                        label='Randomize Seed',
+                        value=True
+                    )
+            
+            with gr.Row():
+                gpu_generate_btn = gr.Button("🖼️ Generate Images (GPU)", variant="primary", size='lg')
+            
+            gpu_seed_output = gr.Number(label='Seed Used', interactive=False)
+            gpu_generated_images = gr.Gallery(label='Generated Images', show_label=True, columns=2)
+            
+            # Bind the generate_image_gpu function to the button click event
+            gpu_generate_btn.click(
+                fn=generate_image_gpu,
+                inputs=[
+                    gpu_prompt_input,
+                    gpu_height,
+                    gpu_width,
+                    gpu_steps,
+                    gpu_seed,
+                    gpu_randomize,
+                    gpu_num_images
+                ],
+                outputs=[gpu_generated_images, gpu_seed_output]
+            )
+        
+        # Text-to-Image Tab (API-based)
+        with gr.TabItem("Text to Image Generator"):
+            gr.Markdown("### Generate Images from Text")
+            gr.Markdown("Describe the image you want to generate in detail for best results.")
+            
+            with gr.Row():
+                with gr.Column():
+                    prompt_input = gr.Textbox(
+                        label='Image Description',
+                        placeholder='e.g., A futuristic city at sunset with flying cars, neon lights, cyberpunk style, high quality',
+                        lines=3
+                    )
+                    generate_btn = gr.Button("🎨 Generate Image", variant="primary")
+            
+            generated_image = gr.Image(label='Generated Image', type='filepath')
+            
+            # Bind the generate_image function to the button click event
+            generate_btn.click(
+                fn=generate_image,
+                inputs=[prompt_input],
+                outputs=[generated_image]
+            )
+        
+        # Image Editing Tab
+        with gr.TabItem("Image Editor"):
+            gr.Markdown("### Edit Images with AI")
+            gr.Markdown("Upload an image and describe the changes you want to make.")
+            
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.Image(
+                        label='Upload Image',
+                        type='filepath'
+                    )
+                    
+            with gr.Row():
+                with gr.Column():
+                    edit_prompt = gr.Textbox(
+                        label='Edit Instructions',
+                        placeholder='e.g., Change the sky to sunset colors, add stars, increase contrast',
+                        lines=3
+                    )
+                    edit_btn = gr.Button("✨ Edit Image", variant="primary")
+            
+            edited_image = gr.Image(label='Edited Image', type='filepath')
+            
+            # Bind the edit_image function to the button click event
+            edit_btn.click(
+                fn=edit_image,
+                inputs=[input_image, edit_prompt],
+                outputs=[edited_image]
+            )
+        
+        # Image Upscaling Tab
+        with gr.TabItem("Image Upscaler"):
+            gr.Markdown("### Upscale Images to Higher Resolution")
+            gr.Markdown("Upload an image and enhance it to higher resolution using AI-powered upscaling.")
+            
+            with gr.Row():
+                with gr.Column():
+                    upscale_input = gr.Image(
+                        label='Upload Image to Upscale',
+                        type='filepath'
+                    )
+                    upscale_btn = gr.Button("⬆️ Upscale Image", variant="primary")
+            
+            upscaled_image = gr.Image(label='Upscaled Image', type='filepath')
+            
+            # Bind the upscale_image function to the button click event
+            upscale_btn.click(
+                fn=upscale_image,
+                inputs=[upscale_input],
+                outputs=[upscaled_image]
+            )
+        
+        # Video Generation Tab
+        with gr.TabItem("Video Generator"):
+            gr.Markdown("### Generate Videos from Images")
+            gr.Markdown("Upload start and end frame images and describe the motion you want to create.")
+            
+            with gr.Row():
+                with gr.Column():
+                    video_first_frame = gr.Image(
+                        label='First Frame (Start Image)',
+                        type='filepath'
+                    )
+                with gr.Column():
+                    video_end_frame = gr.Image(
+                        label='End Frame (Final Image)',
+                        type='filepath'
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    video_prompt = gr.Textbox(
+                        label='Video Description',
+                        placeholder='e.g., Make this image come alive with cinematic motion, smooth camera pan, 4K quality',
+                        lines=3
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    video_duration = gr.Slider(
+                        label='Duration (seconds)',
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1
+                    )
+                with gr.Column():
+                    video_height = gr.Slider(
+                        label='Height (pixels)',
+                        minimum=256,
+                        maximum=1024,
+                        value=512,
+                        step=64
+                    )
+                with gr.Column():
+                    video_width = gr.Slider(
+                        label='Width (pixels)',
+                        minimum=256,
+                        maximum=1024,
+                        value=768,
+                        step=64
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    video_enhance = gr.Checkbox(
+                        label='Enhance Prompt with AI',
+                        value=True
+                    )
+                with gr.Column():
+                    video_randomize = gr.Checkbox(
+                        label='Randomize Seed',
+                        value=True
+                    )
+                with gr.Column():
+                    video_seed = gr.Number(
+                        label='Seed',
+                        value=10,
+                        precision=0
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    video_camera = gr.Dropdown(
+                        label='Camera LoRA',
+                        choices=['No LoRA', 'Pan Left', 'Pan Right', 'Zoom In', 'Zoom Out', 'Rotate CW', 'Rotate CCW'],
+                        value='No LoRA'
+                    )
+            
+            with gr.Row():
+                video_generate_btn = gr.Button("🎬 Generate Video", variant="primary", size='lg')
+            
+            generated_video = gr.Video(label='Generated Video')
+            
+            # Bind the generate_video function to the button click event
+            video_generate_btn.click(
+                fn=generate_video,
+                inputs=[
+                    video_first_frame,
+                    video_end_frame,
+                    video_prompt,
+                    video_duration,
+                    video_height,
+                    video_width,
+                    video_enhance,
+                    video_seed,
+                    video_randomize,
+                    video_camera
+                ],
+                outputs=[generated_video]
+            )
+
+# Launch the Gradio application.
+if __name__ == "__main__":
+    demo.launch(share=True)