oj

.roo/mcp.json

@@ -0,0 +1,3 @@
+{
+  "mcpServers": {}
+}

README.md

@@ -1,5 +1,5 @@
 ---
-title: Innovideo
+title: ImageGen AI
 emoji: 🖼
 colorFrom: purple
 colorTo: red
@@ -8,7 +8,81 @@ sdk_version: 5.25.2
 app_file: app.py
 pinned: false
 license: mit
-short_description: Innovatehub Video Generator
+short_description: AI-Powered Text-to-Image Generator
 ---
 
+# ImageGen AI
+
+A powerful text-to-image generation application built with Gradio and Hugging Face's diffusers library. This application allows users to generate high-quality images from text descriptions using Stability AI's SDXL-Turbo model.
+
+## Features
+
+- **Text-to-Image Generation**: Create images from text descriptions
+- **Customizable Parameters**: Adjust settings like image size, guidance scale, and inference steps
+- **Negative Prompts**: Specify what you don't want in the generated image
+- **Image History**: View and manage previously generated images
+- **Save Images**: Save your favorite generations to disk
+- **Example Prompts**: Get started quickly with example prompts
+
+## Technical Details
+
+This application uses:
+- **Stability AI's SDXL-Turbo model** for fast, high-quality image generation
+- **Gradio** for the user interface
+- **Hugging Face's diffusers library** for the AI backend
+- **PyTorch** as the deep learning framework
+
+## Project Structure
+
+- `app.py`: Main entry point for the application
+- `model.py`: Model initialization and inference logic
+- `ui.py`: Gradio UI components and layout
+- `utils.py`: Utility functions for image saving and history management
+- `config.py`: Configuration settings
+- `test_app.py`: Unit tests for the application
+
+## Getting Started
+
+1. Install the required dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+2. Run the application:
+   ```
+   python app.py
+   ```
+
+3. Open your browser and navigate to the URL displayed in the terminal (the application will try ports 7860-7869 until it finds an available one)
+
+   You can also specify a custom port by setting the GRADIO_SERVER_PORT environment variable:
+   ```
+   GRADIO_SERVER_PORT=8000 python app.py
+   ```
+
+## Usage
+
+1. Enter a text description in the "Prompt" field
+2. (Optional) Enter what you want to avoid in the "Negative Prompt" field
+3. (Optional) Adjust advanced settings like image size, guidance scale, etc.
+4. Click "Generate Image" and wait for the result
+5. Save your favorite images using the "Save Image" button
+
+## Examples
+
+Try these prompts:
+- "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
+- "A serene mountain lake with reflections of pine trees"
+- "Futuristic cityscape at sunset with flying cars"
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- [Hugging Face](https://huggingface.co/) for the diffusers library
+- [Stability AI](https://stability.ai/) for the SDXL-Turbo model
+- [Gradio](https://gradio.app/) for the UI framework
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,143 +1,41 @@
-import gradio as gr
-import numpy as np
-import random
-
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
-
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
 """
+ImageGen AI - A text-to-image generation application.
 
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
-
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
-
-            run_button = gr.Button("Run", scale=0, variant="primary")
-
-        result = gr.Image(label="Result", show_label=False)
-
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
-
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
-            )
-
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-
-            with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
-            with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
-                )
-
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
-                )
+This is the main entry point for the application, which initializes
+the model and UI components and launches the Gradio interface.
+"""
 
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
+import logging
+import os
+import sys
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Import application modules
+from model import ModelManager
+from ui import ImageGenUI
+
+
+def main():
+    """Initialize and launch the application."""
+    try:
+        logger.info("Initializing ImageGen AI application")
+        
+        # Initialize the model
+        logger.info("Loading AI model")
+        model_manager = ModelManager()
+        model_manager.load_model()
+        
+        # Create wrapper function for image generation
+        def generate_image(
             prompt,
             negative_prompt,
             seed,
@@ -146,9 +44,43 @@ with gr.Blocks(css=css) as demo:
             height,
             guidance_scale,
             num_inference_steps,
-        ],
-        outputs=[result, seed],
-    )
+            progress_callback=None
+        ):
+            return model_manager.generate_image(
+                prompt,
+                negative_prompt,
+                seed,
+                randomize_seed,
+                width,
+                height,
+                guidance_scale,
+                num_inference_steps,
+                progress_callback
+            )
+        
+        # Initialize and launch the UI
+        logger.info("Setting up user interface")
+        ui = ImageGenUI(generate_image)
+        ui.build_ui()
+        
+        logger.info("Launching application")
+        # Try multiple ports in case some are already in use
+        for port in range(7860, 7870):
+            try:
+                logger.info(f"Attempting to launch on port {port}")
+                ui.launch(share=False, server_port=port)
+                logger.info(f"Successfully launched on port {port}")
+                break
+            except OSError as e:
+                logger.warning(f"Port {port} is in use, trying next port. Error: {str(e)}")
+                if port == 7869:  # Last port in range
+                    logger.error("Could not find an available port in range 7860-7869")
+                    raise
+        
+    except Exception as e:
+        logger.error(f"Error starting application: {str(e)}")
+        raise
+
 
 if __name__ == "__main__":
-    demo.launch()
+    main()

config.py

@@ -0,0 +1,48 @@
+"""
+Configuration settings for the image generation application.
+
+This module contains all the configuration parameters used throughout the application,
+making it easier to modify settings in one place.
+"""
+
+import numpy as np
+
+# Model settings
+MODEL_REPO_ID = "stabilityai/sdxl-turbo"
+DEFAULT_GUIDANCE_SCALE = 0.0
+DEFAULT_INFERENCE_STEPS = 2
+DEFAULT_WIDTH = 1024
+DEFAULT_HEIGHT = 1024
+
+# UI settings
+APP_TITLE = "ImageGen AI"
+APP_DESCRIPTION = "Generate stunning images from text descriptions using SDXL-Turbo"
+MAX_IMAGE_SIZE = 1024
+MAX_SEED = np.iinfo(np.int32).max
+
+# Example prompts
+EXAMPLE_PROMPTS = [
+    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
+    "An astronaut riding a green horse",
+    "A delicious ceviche cheesecake slice",
+    "Futuristic cityscape at sunset with flying cars",
+    "A serene mountain lake with reflections of pine trees"
+]
+
+# CSS for UI styling
+CSS = """
+#col-container {
+    margin: 0 auto;
+    max-width: 640px;
+}
+.output-image {
+    border-radius: 8px;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+.footer {
+    text-align: center;
+    margin-top: 20px;
+    font-size: 0.8em;
+    color: #666;
+}
+"""

model.py

@@ -0,0 +1,116 @@
+"""
+Model initialization and inference logic for image generation.
+
+This module handles loading the diffusion model and provides functions
+for generating images from text prompts with error handling.
+"""
+
+import logging
+import random
+from typing import Tuple, Optional, Union
+
+import numpy as np
+import torch
+from diffusers import DiffusionPipeline
+from PIL import Image
+
+from config import MODEL_REPO_ID, MAX_SEED
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class ModelManager:
+    """Manages the diffusion model for image generation."""
+    
+    def __init__(self):
+        """Initialize the ModelManager and load the model."""
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+        self.pipe = None
+        
+    def load_model(self) -> None:
+        """
+        Load the diffusion model from the specified repository.
+        
+        Handles potential errors during model loading.
+        """
+        try:
+            logger.info(f"Loading model {MODEL_REPO_ID} on {self.device} with {self.torch_dtype}")
+            self.pipe = DiffusionPipeline.from_pretrained(
+                MODEL_REPO_ID, 
+                torch_dtype=self.torch_dtype
+            )
+            self.pipe = self.pipe.to(self.device)
+            logger.info("Model loaded successfully")
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}")
+            raise RuntimeError(f"Failed to load model: {str(e)}")
+    
+    def generate_image(
+        self,
+        prompt: str,
+        negative_prompt: str = "",
+        seed: int = 0,
+        randomize_seed: bool = True,
+        width: int = 1024,
+        height: int = 1024,
+        guidance_scale: float = 0.0,
+        num_inference_steps: int = 2,
+        progress_callback: Optional[callable] = None
+    ) -> Tuple[Union[Image.Image, None], int]:
+        """
+        Generate an image based on the provided prompt and parameters.
+        
+        Args:
+            prompt: Text description of the desired image
+            negative_prompt: Text description of what to avoid in the image
+            seed: Random seed for reproducibility
+            randomize_seed: Whether to use a random seed
+            width: Width of the generated image
+            height: Height of the generated image
+            guidance_scale: How closely to follow the prompt
+            num_inference_steps: Number of denoising steps
+            progress_callback: Optional callback function for progress updates
+            
+        Returns:
+            Tuple containing the generated image and the seed used
+        """
+        if self.pipe is None:
+            logger.error("Model not loaded. Call load_model() first.")
+            return None, seed
+            
+        # Validate inputs
+        if not prompt or prompt.strip() == "":
+            logger.warning("Empty prompt provided, using default")
+            prompt = "A beautiful landscape"
+            
+        # Handle seed randomization
+        if randomize_seed:
+            seed = random.randint(0, MAX_SEED)
+        
+        # Set up generator for reproducibility
+        generator = torch.Generator(device=self.device).manual_seed(seed)
+        
+        try:
+            logger.info(f"Generating image with prompt: '{prompt}'")
+            
+            # Generate the image
+            result = self.pipe(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                guidance_scale=guidance_scale,
+                num_inference_steps=num_inference_steps,
+                width=width,
+                height=height,
+                generator=generator,
+                callback=progress_callback
+            )
+            
+            image = result.images[0]
+            logger.info(f"Image generated successfully with seed {seed}")
+            return image, seed
+            
+        except Exception as e:
+            logger.error(f"Error generating image: {str(e)}")
+            return None, seed

requirements.txt

@@ -1,6 +1,9 @@
 accelerate
 diffusers
+gradio>=5.25.2
 invisible_watermark
+numpy
+pillow
 torch
 transformers
 xformers

test_app.py

@@ -0,0 +1,180 @@
+"""
+Tests for the image generation application.
+
+This module contains unit tests for the various components of the application.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+import os
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+# Import application modules
+from config import MODEL_REPO_ID, MAX_SEED
+from model import ModelManager
+from utils import save_image, format_generation_info, GenerationHistory
+
+
+class TestConfig(unittest.TestCase):
+    """Test the configuration module."""
+    
+    def test_config_values(self):
+        """Test that configuration values are properly set."""
+        from config import (
+            MODEL_REPO_ID, 
+            DEFAULT_GUIDANCE_SCALE,
+            DEFAULT_INFERENCE_STEPS,
+            DEFAULT_WIDTH,
+            DEFAULT_HEIGHT,
+            MAX_IMAGE_SIZE,
+            EXAMPLE_PROMPTS
+        )
+        
+        self.assertEqual(MODEL_REPO_ID, "stabilityai/sdxl-turbo")
+        self.assertEqual(DEFAULT_GUIDANCE_SCALE, 0.0)
+        self.assertEqual(DEFAULT_INFERENCE_STEPS, 2)
+        self.assertEqual(DEFAULT_WIDTH, 1024)
+        self.assertEqual(DEFAULT_HEIGHT, 1024)
+        self.assertEqual(MAX_IMAGE_SIZE, 1024)
+        self.assertIsInstance(EXAMPLE_PROMPTS, list)
+        self.assertTrue(len(EXAMPLE_PROMPTS) > 0)
+
+
+class TestModelManager(unittest.TestCase):
+    """Test the ModelManager class."""
+    
+    @patch('model.DiffusionPipeline')
+    def test_init(self, mock_pipeline):
+        """Test ModelManager initialization."""
+        manager = ModelManager()
+        self.assertIn(manager.device, ["cuda", "cpu"])
+        self.assertIsNone(manager.pipe)
+    
+    @patch('model.DiffusionPipeline.from_pretrained')
+    def test_load_model(self, mock_from_pretrained):
+        """Test model loading."""
+        # Setup mock
+        mock_pipe = MagicMock()
+        mock_from_pretrained.return_value = mock_pipe
+        mock_pipe.to.return_value = mock_pipe
+        
+        # Test loading
+        manager = ModelManager()
+        manager.load_model()
+        
+        # Verify calls
+        mock_from_pretrained.assert_called_once_with(
+            MODEL_REPO_ID, 
+            torch_dtype=manager.torch_dtype
+        )
+        mock_pipe.to.assert_called_once_with(manager.device)
+        self.assertEqual(manager.pipe, mock_pipe)
+    
+    @patch('model.DiffusionPipeline')
+    def test_generate_image_with_randomize(self, mock_pipeline):
+        """Test image generation with randomized seed."""
+        # Setup mock
+        manager = ModelManager()
+        manager.pipe = MagicMock()
+        mock_image = MagicMock()
+        manager.pipe.return_value = MagicMock(images=[mock_image])
+        
+        # Test generation with randomized seed
+        prompt = "test prompt"
+        image, seed = manager.generate_image(
+            prompt=prompt,
+            randomize_seed=True
+        )
+        
+        # Verify result
+        self.assertEqual(image, mock_image)
+        self.assertGreaterEqual(seed, 0)
+        self.assertLessEqual(seed, MAX_SEED)
+
+
+class TestUtils(unittest.TestCase):
+    """Test utility functions."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        # Create a test image
+        self.test_image = Image.new('RGB', (100, 100), color='red')
+        
+        # Ensure test output directory exists
+        from utils import OUTPUTS_DIR
+        self.test_outputs_dir = OUTPUTS_DIR
+        self.test_outputs_dir.mkdir(exist_ok=True)
+    
+    def test_save_image(self):
+        """Test image saving functionality."""
+        prompt = "test image prompt"
+        filepath = save_image(self.test_image, prompt)
+        
+        # Check that file was created
+        self.assertTrue(os.path.exists(filepath))
+        self.assertTrue(filepath.endswith(".png"))
+        
+        # Clean up
+        os.remove(filepath)
+    
+    def test_format_generation_info(self):
+        """Test generation info formatting."""
+        prompt = "test prompt"
+        negative_prompt = "test negative"
+        seed = 42
+        width = 512
+        height = 512
+        guidance_scale = 7.5
+        steps = 30
+        
+        info = format_generation_info(
+            prompt, negative_prompt, seed, width, height, guidance_scale, steps
+        )
+        
+        # Check that all parameters are included in the info string
+        self.assertIn(prompt, info)
+        self.assertIn(negative_prompt, info)
+        self.assertIn(str(seed), info)
+        self.assertIn(str(width), info)
+        self.assertIn(str(height), info)
+        self.assertIn(str(guidance_scale), info)
+        self.assertIn(str(steps), info)
+    
+    def test_generation_history(self):
+        """Test the GenerationHistory class."""
+        history = GenerationHistory(max_history=3)
+        
+        # Test empty history
+        self.assertEqual(len(history.history), 0)
+        self.assertEqual(history.get_latest(), [])
+        
+        # Add entries
+        for i in range(5):
+            history.add(
+                self.test_image,
+                f"prompt {i}",
+                f"negative {i}",
+                i,
+                512,
+                512,
+                7.5,
+                30
+            )
+        
+        # Check that history is limited to max_history
+        self.assertEqual(len(history.history), 3)
+        
+        # Check that entries are in correct order (newest last)
+        latest = history.get_latest(1)[0]
+        self.assertEqual(latest["prompt"], "prompt 4")
+        
+        # Test clear
+        history.clear()
+        self.assertEqual(len(history.history), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

ui.py

@@ -0,0 +1,301 @@
+"""
+Gradio UI components and layout for the image generation application.
+
+This module defines the user interface using Gradio components,
+including input controls, output displays, and event handlers.
+"""
+
+import gradio as gr
+import time
+from typing import Callable, Dict, Any, List, Tuple
+
+from config import (
+    APP_TITLE, 
+    APP_DESCRIPTION, 
+    EXAMPLE_PROMPTS, 
+    CSS, 
+    MAX_IMAGE_SIZE,
+    MAX_SEED, 
+    DEFAULT_WIDTH, 
+    DEFAULT_HEIGHT,
+    DEFAULT_GUIDANCE_SCALE, 
+    DEFAULT_INFERENCE_STEPS
+)
+from utils import save_image, format_generation_info, GenerationHistory
+
+
+class ImageGenUI:
+    """Manages the Gradio UI for the image generation application."""
+    
+    def __init__(self, generate_func: Callable):
+        """
+        Initialize the UI with the image generation function.
+        
+        Args:
+            generate_func: Function to call for image generation
+        """
+        self.generate_func = generate_func
+        self.history = GenerationHistory(max_history=10)
+        self.demo = None
+        
+    def build_ui(self) -> gr.Blocks:
+        """
+        Build and configure the Gradio UI.
+        
+        Returns:
+            Configured Gradio Blocks interface
+        """
+        with gr.Blocks(css=CSS) as demo:
+            gr.Markdown(f"# {APP_TITLE}")
+            gr.Markdown(APP_DESCRIPTION)
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    # Input controls
+                    with gr.Group():
+                        prompt = gr.Text(
+                            label="Prompt",
+                            placeholder="Describe the image you want to generate",
+                            lines=2
+                        )
+                        
+                        negative_prompt = gr.Text(
+                            label="Negative Prompt",
+                            placeholder="Describe what you want to avoid in the image",
+                            lines=2
+                        )
+                        
+                        with gr.Row():
+                            generate_btn = gr.Button("Generate Image", variant="primary")
+                            clear_btn = gr.Button("Clear")
+                    
+                    # Advanced settings
+                    with gr.Accordion("Advanced Settings", open=False):
+                        with gr.Row():
+                            with gr.Column():
+                                seed = gr.Slider(
+                                    label="Seed",
+                                    minimum=0,
+                                    maximum=MAX_SEED,
+                                    step=1,
+                                    value=0
+                                )
+                                randomize_seed = gr.Checkbox(
+                                    label="Randomize seed", 
+                                    value=True
+                                )
+                            
+                            with gr.Column():
+                                width = gr.Slider(
+                                    label="Width",
+                                    minimum=256,
+                                    maximum=MAX_IMAGE_SIZE,
+                                    step=32,
+                                    value=DEFAULT_WIDTH
+                                )
+                                height = gr.Slider(
+                                    label="Height",
+                                    minimum=256,
+                                    maximum=MAX_IMAGE_SIZE,
+                                    step=32,
+                                    value=DEFAULT_HEIGHT
+                                )
+                        
+                        with gr.Row():
+                            guidance_scale = gr.Slider(
+                                label="Guidance Scale",
+                                minimum=0.0,
+                                maximum=10.0,
+                                step=0.1,
+                                value=DEFAULT_GUIDANCE_SCALE,
+                                info="How closely to follow the prompt (higher = more faithful)"
+                            )
+                            
+                            num_inference_steps = gr.Slider(
+                                label="Inference Steps",
+                                minimum=1,
+                                maximum=50,
+                                step=1,
+                                value=DEFAULT_INFERENCE_STEPS,
+                                info="More steps = higher quality but slower generation"
+                            )
+                
+                with gr.Column(scale=4):
+                    # Output display
+                    with gr.Group():
+                        result_image = gr.Image(
+                            label="Generated Image", 
+                            elem_classes=["output-image"]
+                        )
+                        image_info = gr.Markdown(label="Image Details")
+                        
+                        with gr.Row():
+                            save_btn = gr.Button("Save Image")
+                            save_status = gr.Markdown("")
+            
+            # Example prompts
+            gr.Examples(
+                examples=EXAMPLE_PROMPTS,
+                inputs=prompt,
+                label="Example Prompts"
+            )
+            
+            # Generation history
+            with gr.Accordion("Generation History", open=False):
+                history_gallery = gr.Gallery(
+                    label="Previous Generations",
+                    show_label=True,
+                    elem_id="history-gallery",
+                    columns=5,
+                    height="auto"
+                )
+                refresh_history_btn = gr.Button("Refresh History")
+            
+            # Footer
+            gr.Markdown(
+                "Made with ❤️ using Gradio and Hugging Face Diffusers", 
+                elem_classes=["footer"]
+            )
+            
+            # Event handlers
+            def generate_image(
+                prompt_text, 
+                negative_prompt_text, 
+                seed_val, 
+                randomize, 
+                width_val, 
+                height_val, 
+                guidance, 
+                steps,
+                progress=gr.Progress(track_tqdm=True)
+            ):
+                """Handle image generation and update UI."""
+                # Generate the image
+                image, used_seed = self.generate_func(
+                    prompt_text,
+                    negative_prompt_text,
+                    seed_val,
+                    randomize,
+                    width_val,
+                    height_val,
+                    guidance,
+                    steps,
+                    progress_callback=progress.tqdm
+                )
+                
+                # Update info text
+                info = format_generation_info(
+                    prompt_text, 
+                    negative_prompt_text, 
+                    used_seed, 
+                    width_val, 
+                    height_val, 
+                    guidance, 
+                    steps
+                )
+                
+                # Add to history
+                if image is not None:
+                    self.history.add(
+                        image, 
+                        prompt_text, 
+                        negative_prompt_text, 
+                        used_seed, 
+                        width_val, 
+                        height_val, 
+                        guidance, 
+                        steps
+                    )
+                
+                return image, info, used_seed
+            
+            def save_current_image(image, prompt_text):
+                """Save the current image and return status."""
+                if image is None:
+                    return "No image to save"
+                
+                try:
+                    filepath = save_image(image, prompt_text)
+                    return f"Image saved to {filepath}"
+                except Exception as e:
+                    return f"Error saving image: {str(e)}"
+            
+            def update_history():
+                """Update the history gallery."""
+                entries = self.history.get_latest(10)
+                if not entries:
+                    return []
+                
+                # Format for gallery
+                images = [entry["image"] for entry in entries]
+                labels = [f"{entry['prompt'][:30]}..." for entry in entries]
+                return gr.Gallery.update(value=images, label=labels)
+            
+            def clear_inputs():
+                """Clear all input fields."""
+                return [
+                    gr.Text.update(value=""),  # prompt
+                    gr.Text.update(value=""),  # negative_prompt
+                    gr.Slider.update(value=0),  # seed
+                    gr.Checkbox.update(value=True),  # randomize_seed
+                    gr.Markdown.update(value="")  # image_info
+                ]
+            
+            # Connect event handlers
+            generate_btn.click(
+                fn=generate_image,
+                inputs=[
+                    prompt, 
+                    negative_prompt, 
+                    seed, 
+                    randomize_seed, 
+                    width, 
+                    height, 
+                    guidance_scale, 
+                    num_inference_steps
+                ],
+                outputs=[result_image, image_info, seed]
+            )
+            
+            prompt.submit(
+                fn=generate_image,
+                inputs=[
+                    prompt, 
+                    negative_prompt, 
+                    seed, 
+                    randomize_seed, 
+                    width, 
+                    height, 
+                    guidance_scale, 
+                    num_inference_steps
+                ],
+                outputs=[result_image, image_info, seed]
+            )
+            
+            save_btn.click(
+                fn=save_current_image,
+                inputs=[result_image, prompt],
+                outputs=[save_status]
+            )
+            
+            refresh_history_btn.click(
+                fn=update_history,
+                inputs=[],
+                outputs=[history_gallery]
+            )
+            
+            clear_btn.click(
+                fn=clear_inputs,
+                inputs=[],
+                outputs=[prompt, negative_prompt, seed, randomize_seed, image_info]
+            )
+            
+            self.demo = demo
+            return demo
+    
+    def launch(self, **kwargs):
+        """Launch the Gradio interface with the specified parameters."""
+        if self.demo is None:
+            self.build_ui()
+        
+        self.demo.launch(**kwargs)

utils.py

@@ -0,0 +1,156 @@
+"""
+Utility functions for the image generation application.
+
+This module provides helper functions for tasks like image saving,
+timestamp generation, and other common operations.
+"""
+
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+from PIL import Image
+
+# Create output directory for saved images
+OUTPUTS_DIR = Path("outputs")
+OUTPUTS_DIR.mkdir(exist_ok=True)
+
+
+def save_image(image: Image.Image, prompt: str) -> str:
+    """
+    Save the generated image to disk with a filename based on timestamp and prompt.
+    
+    Args:
+        image: The PIL Image to save
+        prompt: The prompt used to generate the image
+        
+    Returns:
+        Path to the saved image
+    """
+    if image is None:
+        return ""
+        
+    # Create a filename from the timestamp and a shortened version of the prompt
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    # Clean prompt for filename use (first 20 chars, alphanumeric only)
+    clean_prompt = "".join(c for c in prompt if c.isalnum() or c.isspace())[:20].strip()
+    clean_prompt = clean_prompt.replace(" ", "_")
+    
+    filename = f"{timestamp}_{clean_prompt}.png"
+    filepath = OUTPUTS_DIR / filename
+    
+    # Save the image
+    image.save(filepath)
+    return str(filepath)
+
+
+def format_generation_info(
+    prompt: str, 
+    negative_prompt: str, 
+    seed: int, 
+    width: int, 
+    height: int, 
+    guidance_scale: float, 
+    steps: int
+) -> str:
+    """
+    Format generation parameters into a readable string.
+    
+    Args:
+        prompt: Text prompt used
+        negative_prompt: Negative prompt used
+        seed: Random seed used
+        width: Image width
+        height: Image height
+        guidance_scale: Guidance scale value
+        steps: Number of inference steps
+        
+    Returns:
+        Formatted string with generation parameters
+    """
+    info = f"**Prompt:** {prompt}\n"
+    if negative_prompt:
+        info += f"**Negative prompt:** {negative_prompt}\n"
+    info += f"**Seed:** {seed}\n"
+    info += f"**Size:** {width}x{height}\n"
+    info += f"**Guidance scale:** {guidance_scale}\n"
+    info += f"**Steps:** {steps}\n"
+    return info
+
+
+class GenerationHistory:
+    """Manages a history of generated images and their parameters."""
+    
+    def __init__(self, max_history: int = 10):
+        """
+        Initialize the generation history.
+        
+        Args:
+            max_history: Maximum number of items to keep in history
+        """
+        self.history = []
+        self.max_history = max_history
+        
+    def add(
+        self, 
+        image: Image.Image, 
+        prompt: str, 
+        negative_prompt: str, 
+        seed: int, 
+        width: int, 
+        height: int, 
+        guidance_scale: float, 
+        steps: int
+    ) -> None:
+        """
+        Add a new generation to the history.
+        
+        Args:
+            image: Generated image
+            prompt: Text prompt used
+            negative_prompt: Negative prompt used
+            seed: Random seed used
+            width: Image width
+            height: Image height
+            guidance_scale: Guidance scale value
+            steps: Number of inference steps
+        """
+        if image is None:
+            return
+            
+        # Create entry with all relevant information
+        entry = {
+            "image": image,
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "seed": seed,
+            "width": width,
+            "height": height,
+            "guidance_scale": guidance_scale,
+            "steps": steps,
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        
+        # Add to history and maintain max size
+        self.history.append(entry)
+        if len(self.history) > self.max_history:
+            self.history.pop(0)
+            
+    def get_latest(self, n: int = 1) -> list:
+        """
+        Get the latest n entries from history.
+        
+        Args:
+            n: Number of entries to retrieve
+            
+        Returns:
+            List of history entries
+        """
+        return self.history[-n:] if self.history else []
+        
+    def clear(self) -> None:
+        """Clear the generation history."""
+        self.history = []