Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,364 @@
+I'll create a comprehensive text-to-video and image-to-video application using the Hugging Face Inference Client with fal-ai provider.
+
+```python
+import gradio as gr
+import os
+from huggingface_hub import InferenceClient
+import tempfile
+import shutil
+from pathlib import Path
+
+# Initialize the client
+client = InferenceClient(
+    provider="fal-ai",
+    api_key=os.environ.get("HF_TOKEN"),
+    bill_to="huggingface",
+)
+
+def text_to_video(prompt, duration=5, aspect_ratio="16:9", resolution="720p"):
+    """Generate video from text prompt"""
+    try:
+        if not prompt or prompt.strip() == "":
+            return None, "Please enter a text prompt"
+        
+        # Generate video from text
+        video = client.text_to_video(
+            prompt,
+            model="akhaliq/veo3.1-fast",
+        )
+        
+        # Save the video to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_file:
+            tmp_file.write(video)
+            video_path = tmp_file.name
+        
+        return video_path, f"✅ Video generated successfully from prompt: '{prompt[:50]}...'"
+    
+    except Exception as e:
+        return None, f"❌ Error generating video: {str(e)}"
+
+def image_to_video(image, prompt, duration=5, aspect_ratio="16:9", resolution="720p"):
+    """Generate video from image and prompt"""
+    try:
+        if image is None:
+            return None, "Please upload an image"
+        
+        if not prompt or prompt.strip() == "":
+            return None, "Please enter a prompt describing the motion"
+        
+        # Read the image file
+        if isinstance(image, str):
+            # If image is a file path
+            with open(image, "rb") as image_file:
+                input_image = image_file.read()
+        else:
+            # If image is already bytes or similar
+            import io
+            from PIL import Image as PILImage
+            
+            # Convert to bytes if necessary
+            if isinstance(image, PILImage.Image):
+                buffer = io.BytesIO()
+                image.save(buffer, format='PNG')
+                input_image = buffer.getvalue()
+            else:
+                # Assume it's a numpy array or similar
+                pil_image = PILImage.fromarray(image)
+                buffer = io.BytesIO()
+                pil_image.save(buffer, format='PNG')
+                input_image = buffer.getvalue()
+        
+        # Generate video from image
+        video = client.image_to_video(
+            input_image,
+            prompt=prompt,
+            model="akhaliq/veo3.1-fast-image-to-video",
+        )
+        
+        # Save the video to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_file:
+            tmp_file.write(video)
+            video_path = tmp_file.name
+        
+        return video_path, f"✅ Video generated successfully with motion: '{prompt[:50]}...'"
+    
+    except Exception as e:
+        return None, f"❌ Error generating video: {str(e)}"
+
+def clear_text_tab():
+    """Clear text-to-video tab"""
+    return "", None, ""
+
+def clear_image_tab():
+    """Clear image-to-video tab"""
+    return None, "", None, ""
+
+# Custom CSS for better styling
+custom_css = """
+.container {
+    max-width: 1200px;
+    margin: auto;
+}
+.header-link {
+    text-decoration: none;
+    color: #2196F3;
+    font-weight: bold;
+}
+.header-link:hover {
+    text-decoration: underline;
+}
+.status-box {
+    padding: 10px;
+    border-radius: 5px;
+    margin-top: 10px;
+}
+"""
+
+# Create the Gradio interface
+with gr.Blocks(css=custom_css, theme=gr.themes.Soft(), title="AI Video Generator") as demo:
+    gr.Markdown(
+        """
+        # 🎬 AI Video Generator
+        ### Generate stunning videos from text or animate your images with AI
+        #### Powered by VEO 3.1 Fast Model | [Built with anycoder](https://huggingface.co/spaces/akhaliq/anycoder)
+        """
+    )
+    
+    with gr.Tabs() as tabs:
+        # Text-to-Video Tab
+        with gr.Tab("📝 Text to Video", id=0):
+            gr.Markdown("### Transform your text descriptions into dynamic videos")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    text_prompt = gr.Textbox(
+                        label="Text Prompt",
+                        placeholder="Describe the video you want to create... (e.g., 'A young man walking on the street during sunset')",
+                        lines=4,
+                        max_lines=6
+                    )
+                    
+                    with gr.Accordion("Advanced Settings", open=False):
+                        text_duration = gr.Slider(
+                            minimum=1,
+                            maximum=10,
+                            value=5,
+                            step=1,
+                            label="Duration (seconds)",
+                            info="Video duration in seconds"
+                        )
+                        text_aspect_ratio = gr.Dropdown(
+                            choices=["16:9", "9:16", "1:1", "4:3", "21:9"],
+                            value="16:9",
+                            label="Aspect Ratio",
+                            info="Video aspect ratio"
+                        )
+                        text_resolution = gr.Dropdown(
+                            choices=["480p", "720p", "1080p"],
+                            value="720p",
+                            label="Resolution",
+                            info="Video resolution"
+                        )
+                    
+                    with gr.Row():
+                        text_generate_btn = gr.Button("🎬 Generate Video", variant="primary", scale=2)
+                        text_clear_btn = gr.ClearButton(value="🗑️ Clear", scale=1)
+                    
+                    text_status = gr.Textbox(
+                        label="Status",
+                        interactive=False,
+                        visible=True,
+                        elem_classes=["status-box"]
+                    )
+                
+                with gr.Column(scale=1):
+                    text_video_output = gr.Video(
+                        label="Generated Video",
+                        autoplay=True,
+                        show_download_button=True,
+                        height=400
+                    )
+            
+            # Examples for text-to-video
+            gr.Examples(
+                examples=[
+                    ["A serene beach at sunset with gentle waves"],
+                    ["A bustling city street with neon lights at night"],
+                    ["A majestic eagle soaring through mountain peaks"],
+                    ["An astronaut floating in space near the International Space Station"],
+                    ["Cherry blossoms falling in slow motion in a Japanese garden"],
+                ],
+                inputs=text_prompt,
+                label="Example Prompts"
+            )
+        
+        # Image-to-Video Tab
+        with gr.Tab("🖼️ Image to Video", id=1):
+            gr.Markdown("### Bring your static images to life with motion")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    image_input = gr.Image(
+                        label="Upload Image",
+                        type="pil",
+                        height=300
+                    )
+                    
+                    image_prompt = gr.Textbox(
+                        label="Motion Prompt",
+                        placeholder="Describe how the image should move... (e.g., 'The cat starts to dance')",
+                        lines=3,
+                        max_lines=5
+                    )
+                    
+                    with gr.Accordion("Advanced Settings", open=False):
+                        image_duration = gr.Slider(
+                            minimum=1,
+                            maximum=10,
+                            value=5,
+                            step=1,
+                            label="Duration (seconds)",
+                            info="Video duration in seconds"
+                        )
+                        image_aspect_ratio = gr.Dropdown(
+                            choices=["16:9", "9:16", "1:1", "4:3", "21:9"],
+                            value="16:9",
+                            label="Aspect Ratio",
+                            info="Video aspect ratio"
+                        )
+                        image_resolution = gr.Dropdown(
+                            choices=["480p", "720p", "1080p"],
+                            value="720p",
+                            label="Resolution",
+                            info="Video resolution"
+                        )
+                    
+                    with gr.Row():
+                        image_generate_btn = gr.Button("🎬 Animate Image", variant="primary", scale=2)
+                        image_clear_btn = gr.ClearButton(value="🗑️ Clear", scale=1)
+                    
+                    image_status = gr.Textbox(
+                        label="Status",
+                        interactive=False,
+                        visible=True,
+                        elem_classes=["status-box"]
+                    )
+                
+                with gr.Column(scale=1):
+                    image_video_output = gr.Video(
+                        label="Generated Video",
+                        autoplay=True,
+                        show_download_button=True,
+                        height=400
+                    )
+            
+            # Examples for image-to-video
+            gr.Examples(
+                examples=[
+                    [None, "The person starts walking forward"],
+                    [None, "The animal begins to run"],
+                    [None, "Camera slowly zooms in while the subject smiles"],
+                    [None, "The flowers sway gently in the breeze"],
+                    [None, "The clouds move across the sky in time-lapse"],
+                ],
+                inputs=[image_input, image_prompt],
+                label="Example Motion Prompts"
+            )
+    
+    # How to Use section
+    with gr.Accordion("📖 How to Use", open=False):
+        gr.Markdown(
+            """
+            ### Text to Video:
+            1. Enter a detailed description of the video you want to create
+            2. Optionally adjust advanced settings (duration, aspect ratio, resolution)
+            3. Click "Generate Video" and wait for the AI to create your video
+            4. Download or preview your generated video
+            
+            ### Image to Video:
+            1. Upload an image you want to animate
+            2. Describe the motion or action you want to add to the image
+            3. Optionally adjust advanced settings
+            4. Click "Animate Image" to bring your image to life
+            5. Download or preview your animated video
+            
+            ### Tips for Better Results:
+            - Be specific and descriptive in your prompts
+            - For image-to-video, describe natural motions that fit the image
+            - Use high-quality input images for better results
+            - Experiment with different prompts to get the desired effect
+            """
+        )
+    
+    # Event handlers
+    text_generate_btn.click(
+        fn=text_to_video,
+        inputs=[text_prompt, text_duration, text_aspect_ratio, text_resolution],
+        outputs=[text_video_output, text_status],
+        show_progress="full"
+    )
+    
+    text_clear_btn.click(
+        fn=clear_text_tab,
+        inputs=[],
+        outputs=[text_prompt, text_video_output, text_status]
+    )
+    
+    image_generate_btn.click(
+        fn=image_to_video,
+        inputs=[image_input, image_prompt, image_duration, image_aspect_ratio, image_resolution],
+        outputs=[image_video_output, image_status],
+        show_progress="full"
+    )
+    
+    image_clear_btn.click(
+        fn=clear_image_tab,
+        inputs=[],
+        outputs=[image_input, image_prompt, image_video_output, image_status]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        show_api=True,
+        share=False,
+        show_error=True
+    )
+```
+
+This application provides:
+
+## Features:
+
+1. **Text-to-Video Generation**:
+   - Convert text descriptions into videos
+   - Customizable duration, aspect ratio, and resolution
+   - Example prompts for inspiration
+   - Status updates and error handling
+
+2. **Image-to-Video Animation**:
+   - Upload static images and add motion
+   - Describe the desired animation with text prompts
+   - Same customization options as text-to-video
+   - Example motion descriptions
+
+3. **User-Friendly Interface**:
+   - Clean, tabbed interface separating the two functions
+   - Advanced settings in collapsible accordions
+   - Real-time status updates
+   - Download capability for generated videos
+   - Clear buttons to reset inputs
+
+4. **Professional Design**:
+   - Soft theme for pleasant viewing
+   - Responsive layout
+   - Proper error handling and user feedback
+   - "Built with anycoder" attribution link in header
+
+5. **Additional Features**:
+   - Auto-play for generated videos
+   - Example inputs to help users get started
+   - How-to-use guide
+   - Progress indicators during generation
+
+The app handles both text-to-video and image-to-video generation using the VEO 3.1 Fast models through the Hugging Face Inference Client with fal-ai provider. It includes proper error handling, user feedback, and a clean interface that makes it easy for users to generate AI videos.