Create app.py

app.py

@@ -0,0 +1,243 @@
+import os
+import gradio as gr
+from PIL import Image
+from typing import List, Optional, Tuple
+import logging
+import random
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def create_gif_from_folder(
+    input_folder: str,
+    output_path: str,
+    duration: int = 100,
+    loop: int = 0,
+    resize: Optional[tuple] = None,
+    quality: int = 90,
+    shuffle: bool = False
+) -> None:
+    """
+    Convert a folder of images into a GIF.
+
+    Args:
+        input_folder (str): Path to the folder containing images
+        output_path (str): Path where the GIF will be saved
+        duration (int): Duration of each frame in milliseconds
+        loop (int): Number of times to loop the GIF (0 for infinite)
+        resize (Optional[tuple]): Tuple of (width, height) to resize images
+        quality (int): Quality of the output GIF (1-100)
+        shuffle (bool): Whether to randomize the order of images
+    """
+    try:
+        # Get all image files from the folder
+        image_files = [
+            f for f in os.listdir(input_folder)
+            if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif'))
+        ]
+
+        if not image_files:
+            raise ValueError(f"No image files found in {input_folder}")
+
+        # Sort or shuffle files
+        if shuffle:
+            random.shuffle(image_files)
+            logger.info("Images will be shown in random order")
+        else:
+            image_files.sort()
+            logger.info("Images will be shown in alphabetical order")
+
+        # Load images
+        images: List[Image.Image] = []
+        for file in image_files:
+            try:
+                img_path = os.path.join(input_folder, file)
+                img = Image.open(img_path)
+
+                # Convert to RGB if necessary
+                if img.mode != 'RGB':
+                    img = img.convert('RGB')
+
+                # Resize if specified
+                if resize:
+                    img = img.resize(resize, Image.Resampling.LANCZOS)
+
+                images.append(img)
+                logger.info(f"Processed image: {file}")
+            except Exception as e:
+                logger.warning(f"Failed to process {file}: {str(e)}")
+                continue
+
+        if not images:
+            raise ValueError("No valid images were processed")
+
+        # Save as GIF with optimized settings
+        images[0].save(
+            output_path,
+            save_all=True,
+            append_images=images[1:],
+            duration=duration,
+            loop=loop,
+            optimize=True,
+            quality=quality,
+            disposal=2  # Clear background between frames
+        )
+
+        logger.info(f"Successfully created GIF at {output_path}")
+        logger.info(f"Processed {len(images)} images")
+        logger.info(f"Settings: {duration}ms/frame, quality={quality}")
+        logger.info(f"Shuffle: {'enabled' if shuffle else 'disabled'}")
+
+    except Exception as e:
+        logger.error(f"Error creating GIF: {str(e)}")
+        raise
+
+
+def create_gif_interface(
+    input_folder: str,
+    output_name: str,
+    duration: int,
+    quality: int,
+    width: int,
+    height: int,
+    shuffle: bool
+) -> Tuple[str, str]:
+    """
+    Web interface wrapper for GIF creation.
+
+    Returns:
+        Tuple of (output path, status message)
+    """
+    try:
+        # Validate inputs
+        if not os.path.exists(input_folder):
+            return "", f"Error: Input folder '{input_folder}' does not exist"
+
+        if not output_name.endswith('.gif'):
+            output_name += '.gif'
+
+        # Save to current working directory (Hugging Face Spaces best practice)
+        output_path = os.path.join(os.getcwd(), output_name)
+
+        # Create the GIF
+        create_gif_from_folder(
+            input_folder=input_folder,
+            output_path=output_path,
+            duration=duration,
+            quality=quality,
+            resize=(width, height),
+            shuffle=shuffle
+        )
+
+        return output_path, "GIF created successfully!"
+
+    except Exception as e:
+        error_msg = f"Error creating GIF: {str(e)}"
+        return "", error_msg
+
+
+# Create the Gradio interface
+with gr.Blocks(
+    title="🎞️ Image to GIF Converter",
+    theme=gr.themes.Soft()
+) as interface:
+    gr.Markdown("# 🎞️ Image to GIF Converter")
+    gr.Markdown("Convert a folder of images into an animated GIF")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            input_folder = gr.Textbox(
+                label="Input Folder Path",
+                placeholder="Enter the path to your images folder"
+            )
+            output_name = gr.Textbox(
+                label="Output GIF Name",
+                value="animation.gif",
+                placeholder="Enter the name for your GIF"
+            )
+
+            with gr.Row():
+                duration = gr.Slider(
+                    minimum=50,
+                    maximum=1000,
+                    value=100,
+                    step=50,
+                    label="Frame Duration (ms)"
+                )
+                quality = gr.Slider(
+                    minimum=1,
+                    maximum=100,
+                    value=90,
+                    step=1,
+                    label="Quality"
+                )
+
+            with gr.Row():
+                width = gr.Number(
+                    value=800,
+                    label="Width (px)",
+                    precision=0
+                )
+                height = gr.Number(
+                    value=600,
+                    label="Height (px)",
+                    precision=0
+                )
+
+            shuffle = gr.Checkbox(
+                label="Shuffle Images",
+                value=True
+            )
+
+            create_btn = gr.Button(
+                "Create GIF",
+                variant="primary"
+            )
+
+        with gr.Column(scale=3):
+            output = gr.Textbox(
+                label="Output Path",
+                interactive=False
+            )
+            error_msg = gr.Textbox(
+                label="Status",
+                interactive=False
+            )
+            preview = gr.Image(
+                label="GIF Preview",
+                type="filepath",
+                interactive=False
+            )
+
+    # Set up the event handler
+    create_btn.click(
+        fn=create_gif_interface,
+        inputs=[
+            input_folder,
+            output_name,
+            duration,
+            quality,
+            width,
+            height,
+            shuffle
+        ],
+        outputs=[output, error_msg]
+    ).then(
+        fn=lambda x: x if x else None,
+        inputs=[output],
+        outputs=[preview]
+    )
+
+
+if __name__ == "__main__":
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )