Upload 14 files

README.md

@@ -1,303 +1,350 @@
----
-title: AI Thumbnail and Metadata Generator
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.45.0
-app_file: app.py
-pinned: false
----
-
-# 🎨 AI Thumbnail & Metadata Generator
-
-A powerful AI-powered tool that generates catchy YouTube titles, descriptions, tags, and stunning thumbnails using Hugging Face Inference API. Perfect for content creators looking to automate their workflow without requiring expensive GPU hardware!
-
-## ✨ Features
-
-- **🤖 AI Metadata Generation**: Uses Zephyr-7B or Mistral-7B to create engaging YouTube titles, descriptions, and tags
-- **🎨 Dual Thumbnail Generation**: Leverages both SD-Turbo (fast) and SD-1.5 (quality) for optimal results
-- **🎯 6 Style Options**: Choose from Realistic, Cartoon, Cinematic, Minimalist, Gaming, or Tech styles
-- **✏️ Text Overlay Editor**: Add custom title text with different font styles
-- **📱 Responsive UI**: Clean Gradio interface with side-by-side thumbnail comparison
-- **📥 JSON Export**: Download complete metadata package for easy integration
-- **⚡ Cloud-Based**: No GPU required - runs entirely on Hugging Face Inference API
-- **🔄 Progress Tracking**: Real-time generation progress indicators
-
-## 🚀 Live Demo
-
-Try the app on Hugging Face Spaces: [Your Space URL Here]
-
-## 🛠️ Installation & Setup
-
-### Prerequisites
-- Python 3.8+
-- Hugging Face account (for API access)
-- Internet connection
-
-### Local Installation
-
-1. **Clone the repository**
-```bash
-git clone https://github.com/yourusername/ai-thumbnail-generator.git
-cd ai-thumbnail-generator
-```
-
-2. **Install dependencies**
-```bash
-pip install -r requirements.txt
-```
-
-3. **Set up Hugging Face token (Optional but recommended)**
-```bash
-export HF_TOKEN="your_hugging_face_token_here"
-```
-Or set it as an environment variable in your system.
-
-4. **Run the application**
-```bash
-python app.py
-```
-
-5. **Open your browser**
-Navigate to `http://localhost:7860` to use the app
-
-## 📋 Usage
-
-### Basic Workflow
-
-1. **Enter a Topic**: Type your video topic (e.g., "AI in Healthcare", "Cooking Tips")
-2. **Choose Settings**:
-   - **Style**: Select from 6 visual styles (Realistic, Cartoon, etc.)
-   - **Text Model**: Choose between Zephyr-7B (faster) or Mistral-7B (more creative)
-3. **Add Text Overlay** (Optional): 
-   - Enter custom title text for thumbnails
-   - Choose font style (Bold, Elegant, Clean)
-4. **Generate**: Click "Generate Content" and watch the progress
-5. **Review & Edit**: Modify generated metadata if needed
-6. **Download**: Select your preferred thumbnail and download the complete package as JSON
-
-### Advanced Features
-
-- **Dual Generation**: Get both fast (SD-Turbo) and quality (SD-1.5) thumbnails
-- **Style Prompting**: Each style uses carefully crafted prompts for optimal results
-- **Text Overlay**: Automatically positions text with shadows for visibility
-- **Metadata Export**: Complete YouTube-ready package with title, description, and tags
-
-## 🎯 Example Topics
-
-### Tech & AI
-- "Future of Artificial Intelligence"
-- "Best Programming Languages 2024"
-- "Cybersecurity for Beginners"
-
-### Lifestyle & Health
-- "Morning Routine for Productivity" 
-- "Healthy Meal Prep Ideas"
-- "Home Workout Without Equipment"
-
-### Business & Finance
-- "Passive Income Strategies"
-- "Social Media Marketing Tips"
-- "Cryptocurrency Explained"
-
-### Education & Skills
-- "Learn Python in 30 Days"
-- "Photography Composition Rules"
-- "Public Speaking Confidence"
-
-## 🔧 Configuration
-
-### Hugging Face API Setup
-
-The app uses Hugging Face Inference API for all AI generation:
-
-**Text Models:**
-- `HuggingFaceH4/zephyr-7b-beta` (Default - Fast & Reliable)
-- `mistralai/Mistral-7B-Instruct-v0.2` (Creative & Detailed)
-
-**Image Models:**
-- `stabilityai/sd-turbo` (Fast generation - ~3 seconds)
-- `runwayml/stable-diffusion-v1-5` (Quality generation - ~10 seconds)
-
-### Environment Variables
-
-```bash
-HF_TOKEN=your_token_here  # Optional but recommended for rate limits
-```
-
-## 📁 Project Structure
-
-```
-ai-thumbnail-generator/
-├── app.py              # Main Gradio application
-├── app.yaml            # Hugging Face Spaces config
-├── requirements.txt    # Python dependencies
-├── README.md          # This file
-└── .gitignore         # Git ignore patterns
-```
-
-## 🚀 Deployment
-
-### Hugging Face Spaces (Recommended)
-
-1. **Create a new Space** on [Hugging Face Spaces](https://huggingface.co/spaces)
-2. **Choose settings**:
-   - SDK: `gradio`
-   - Hardware: `CPU basic` (sufficient for API calls)
-3. **Upload files** or connect your GitHub repository
-4. **Set secrets** (if using authenticated API):
-   - Go to Settings → Repository secrets
-   - Add: `HF_TOKEN` = your_hugging_face_token
-5. **Deploy**: The app will automatically build and deploy
-
-### Docker (Optional)
-
-```dockerfile
-FROM python:3.9-slim
-
-WORKDIR /app
-COPY requirements.txt .
-RUN pip install -r requirements.txt
-
-COPY . .
-EXPOSE 7860
-ENV HF_TOKEN=""
-
-CMD ["python", "app.py"]
-```
-
-### Local Development
-
-```bash
-# Development server with auto-reload
-python app.py
-```
-
-## 🤖 Models & Performance
-
-### Text Generation
-- **Zephyr-7B**: ~2-3 seconds, excellent for titles and descriptions
-- **Mistral-7B**: ~3-5 seconds, more creative and detailed output
-
-### Image Generation
-- **SD-Turbo**: ~3-5 seconds, good quality for rapid iteration
-- **SD-1.5**: ~8-12 seconds, higher quality for final thumbnails
-
-### Rate Limits
-- **Free Tier**: ~100 requests/hour per model
-- **Pro Tier**: Higher limits with HF_TOKEN authentication
-
-## ⚠️ System Requirements
-
-### Minimal Requirements
-- **CPU**: Any modern processor
-- **RAM**: 2GB available
-- **Storage**: 1GB free space
-- **Network**: Stable internet connection
-- **Python**: 3.8+
-
-### No GPU Required!
-All processing happens on Hugging Face's cloud infrastructure.
-
-## 🔍 Troubleshooting
-
-### Common Issues
-
-1. **API Rate Limits**
-   - Solution: Set up HF_TOKEN for higher limits
-   - Alternative: Wait for rate limit reset
-
-2. **Model Loading Delays**
-   - Cause: Cold start on Hugging Face servers
-   - Solution: Wait 10-20 seconds, models will warm up
-
-3. **Image Generation Failures**
-   - Check internet connection
-   - Verify topic isn't blocked by content filters
-   - Try different style options
-
-4. **Text Overlay Issues**
-   - Ensure text isn't too long (< 50 characters recommended)
-   - Try different font styles
-   - Check image dimensions
-
-### Debug Mode
-
-Set environment variable for detailed logging:
-```bash
-export DEBUG=1
-python app.py
-```
-
-## 🤝 Contributing
-
-We welcome contributions! Here's how to get started:
-
-1. **Fork the Project**
-2. **Create Feature Branch** (`git checkout -b feature/AmazingFeature`)
-3. **Make Changes** and test locally
-4. **Commit Changes** (`git commit -m 'Add some AmazingFeature'`)
-5. **Push to Branch** (`git push origin feature/AmazingFeature`)
-6. **Open Pull Request**
-
-### Development Setup
-
-```bash
-git clone https://github.com/yourusername/ai-thumbnail-generator.git
-cd ai-thumbnail-generator
-pip install -r requirements.txt
-export HF_TOKEN="your_token"
-python app.py
-```
-
-## 🔄 API Reference
-
-### Main Functions
-
-```python
-# Generate metadata
-metadata = generate_metadata(topic, model_choice="zephyr")
-
-# Generate thumbnails
-thumb1, thumb2 = generate_thumbnails(topic, style, text_overlay)
-
-# Add text overlay
-image_with_text = add_text_overlay(image, title_text, style="bold")
-
-# Create download package
-json_data = create_download_data(topic, metadata, thumb1, thumb2, selected)
-```
-
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## 🙏 Acknowledgments
-
-- [Hugging Face](https://huggingface.co/) for the amazing Inference API and model hosting
-- [Gradio](https://gradio.app/) for the intuitive UI framework
-- [Stability AI](https://stability.ai/) for Stable Diffusion models
-- [HuggingFace H4](https://huggingface.co/HuggingFaceH4) for the Zephyr model
-- [Mistral AI](https://mistral.ai/) for the Mistral language model
-
-## 📞 Support & Community
-
-- **Issues**: [GitHub Issues](https://github.com/yourusername/ai-thumbnail-generator/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/yourusername/ai-thumbnail-generator/discussions)
-- **Twitter**: [@yourusername](https://twitter.com/yourusername)
-- **Email**: your-email@example.com
-
-## 🏆 Features Roadmap
-
-- [ ] **Video preview generation**
-- [ ] **Batch processing for multiple topics**
-- [ ] **Custom style training**
-- [ ] **A/B testing for thumbnails**
-- [ ] **Analytics integration**
-- [ ] **Mobile app version**
-
----
-
-⭐ **If you find this project helpful, please give it a star on GitHub!** ⭐
-
-**Built with ❤️ for the creator community**
+# AI Thumbnail & Metadata Generator
+
+A modular Python application that generates YouTube thumbnails and metadata using AI models.
+
+## File Structure
+
+```
+thumbnail_generator/
+├── main.py                 # Main entry point
+├── config.py              # Configuration and constants
+├── ui.py                  # Gradio user interface
+├── api_utils.py           # API utilities and token testing
+├── metadata_generator.py  # Text/metadata generation
+├── image_generator.py     # Image/thumbnail generation
+├── content_processor.py   # Main content processing logic
+├── requirements.txt       # Python dependencies
+└── README.md             # This file
+```
+
+## Features
+
+- 🤖 AI-powered metadata generation using OpenRouter API
+- 🎨 Dual thumbnail generation using Hugging Face FLUX models
+- 🎯 6 different visual styles (Realistic, Cartoon, Cinematic, etc.)
+- ✏️ Custom text overlay editor
+- 📥 JSON export for metadata
+- 🔑 Separate API key management for each service
+
+## Setup
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Run the application:
+```bash
+python main.py
+```
+
+3. Open your browser to `http://localhost:7860`
+
+4. Set your API keys in the UI:
+   - OpenRouter API key for text generation
+   - Hugging Face API key for image generation
+
+## API Keys
+
+- **OpenRouter**: Get your key at [https://openrouter.ai/](https://openrouter.ai/)
+- **Hugging Face**: Get your key at [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+
+## Usage
+
+1. Enter your video topic
+2. Choose thumbnail style and text model
+3. Add custom text overlay (optional)
+4. Generate content and download!
+
+## Modules
+
+- **config.py**: Contains all configuration constants and global variables
+- **api_utils.py**: Handles API interactions and token validation
+- **metadata_generator.py**: Generates YouTube titles, descriptions, and tags
+- **image_generator.py**: Creates thumbnails with various styles and overlays
+- **content_processor.py**: Orchestrates the entire content generation process
+- **ui.py**: Gradio interface for user interaction
+- **main.py**: Entry point that launches the application
+- **📱 Responsive UI**: Clean Gradio interface with side-by-side thumbnail comparison
+- **📥 JSON Export**: Download complete metadata package for easy integration
+- **⚡ Cloud-Based**: No GPU required - runs entirely on Hugging Face Inference API
+- **🔄 Progress Tracking**: Real-time generation progress indicators
+
+## 🚀 Live Demo
+
+Try the app on Hugging Face Spaces: [Your Space URL Here]
+
+## 🛠️ Installation & Setup
+
+### Prerequisites
+- Python 3.8+
+- Hugging Face account (for API access)
+- Internet connection
+
+### Local Installation
+
+1. **Clone the repository**
+```bash
+git clone https://github.com/yourusername/ai-thumbnail-generator.git
+cd ai-thumbnail-generator
+```
+
+2. **Install dependencies**
+```bash
+pip install -r requirements.txt
+```
+
+3. **Set up Hugging Face token (Optional but recommended)**
+```bash
+export HF_TOKEN="your_hugging_face_token_here"
+```
+Or set it as an environment variable in your system.
+
+4. **Run the application**
+```bash
+python app.py
+```
+
+5. **Open your browser**
+Navigate to `http://localhost:7860` to use the app
+
+## 📋 Usage
+
+### Basic Workflow
+
+1. **Enter a Topic**: Type your video topic (e.g., "AI in Healthcare", "Cooking Tips")
+2. **Choose Settings**:
+   - **Style**: Select from 6 visual styles (Realistic, Cartoon, etc.)
+   - **Text Model**: Choose between Zephyr-7B (faster) or Mistral-7B (more creative)
+3. **Add Text Overlay** (Optional): 
+   - Enter custom title text for thumbnails
+   - Choose font style (Bold, Elegant, Clean)
+4. **Generate**: Click "Generate Content" and watch the progress
+5. **Review & Edit**: Modify generated metadata if needed
+6. **Download**: Select your preferred thumbnail and download the complete package as JSON
+
+### Advanced Features
+
+- **Dual Generation**: Get both fast (SD-Turbo) and quality (SD-1.5) thumbnails
+- **Style Prompting**: Each style uses carefully crafted prompts for optimal results
+- **Text Overlay**: Automatically positions text with shadows for visibility
+- **Metadata Export**: Complete YouTube-ready package with title, description, and tags
+
+## 🎯 Example Topics
+
+### Tech & AI
+- "Future of Artificial Intelligence"
+- "Best Programming Languages 2024"
+- "Cybersecurity for Beginners"
+
+### Lifestyle & Health
+- "Morning Routine for Productivity" 
+- "Healthy Meal Prep Ideas"
+- "Home Workout Without Equipment"
+
+### Business & Finance
+- "Passive Income Strategies"
+- "Social Media Marketing Tips"
+- "Cryptocurrency Explained"
+
+### Education & Skills
+- "Learn Python in 30 Days"
+- "Photography Composition Rules"
+- "Public Speaking Confidence"
+
+## 🔧 Configuration
+
+### Hugging Face API Setup
+
+The app uses Hugging Face Inference API for all AI generation:
+
+**Text Models:**
+- `HuggingFaceH4/zephyr-7b-beta` (Default - Fast & Reliable)
+- `mistralai/Mistral-7B-Instruct-v0.2` (Creative & Detailed)
+
+**Image Models:**
+- `stabilityai/sd-turbo` (Fast generation - ~3 seconds)
+- `runwayml/stable-diffusion-v1-5` (Quality generation - ~10 seconds)
+
+### Environment Variables
+
+```bash
+HF_TOKEN=your_token_here  # Optional but recommended for rate limits
+```
+
+## 📁 Project Structure
+
+```
+ai-thumbnail-generator/
+├── app.py              # Main Gradio application
+├── app.yaml            # Hugging Face Spaces config
+├── requirements.txt    # Python dependencies
+├── README.md          # This file
+└── .gitignore         # Git ignore patterns
+```
+
+## 🚀 Deployment
+
+### Hugging Face Spaces (Recommended)
+
+1. **Create a new Space** on [Hugging Face Spaces](https://huggingface.co/spaces)
+2. **Choose settings**:
+   - SDK: `gradio`
+   - Hardware: `CPU basic` (sufficient for API calls)
+3. **Upload files** or connect your GitHub repository
+4. **Set secrets** (if using authenticated API):
+   - Go to Settings → Repository secrets
+   - Add: `HF_TOKEN` = your_hugging_face_token
+5. **Deploy**: The app will automatically build and deploy
+
+### Docker (Optional)
+
+```dockerfile
+FROM python:3.9-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+EXPOSE 7860
+ENV HF_TOKEN=""
+
+CMD ["python", "app.py"]
+```
+
+### Local Development
+
+```bash
+# Development server with auto-reload
+python app.py
+```
+
+## 🤖 Models & Performance
+
+### Text Generation
+- **Zephyr-7B**: ~2-3 seconds, excellent for titles and descriptions
+- **Mistral-7B**: ~3-5 seconds, more creative and detailed output
+
+### Image Generation
+- **SD-Turbo**: ~3-5 seconds, good quality for rapid iteration
+- **SD-1.5**: ~8-12 seconds, higher quality for final thumbnails
+
+### Rate Limits
+- **Free Tier**: ~100 requests/hour per model
+- **Pro Tier**: Higher limits with HF_TOKEN authentication
+
+## ⚠️ System Requirements
+
+### Minimal Requirements
+- **CPU**: Any modern processor
+- **RAM**: 2GB available
+- **Storage**: 1GB free space
+- **Network**: Stable internet connection
+- **Python**: 3.8+
+
+### No GPU Required!
+All processing happens on Hugging Face's cloud infrastructure.
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+1. **API Rate Limits**
+   - Solution: Set up HF_TOKEN for higher limits
+   - Alternative: Wait for rate limit reset
+
+2. **Model Loading Delays**
+   - Cause: Cold start on Hugging Face servers
+   - Solution: Wait 10-20 seconds, models will warm up
+
+3. **Image Generation Failures**
+   - Check internet connection
+   - Verify topic isn't blocked by content filters
+   - Try different style options
+
+4. **Text Overlay Issues**
+   - Ensure text isn't too long (< 50 characters recommended)
+   - Try different font styles
+   - Check image dimensions
+
+### Debug Mode
+
+Set environment variable for detailed logging:
+```bash
+export DEBUG=1
+python app.py
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Here's how to get started:
+
+1. **Fork the Project**
+2. **Create Feature Branch** (`git checkout -b feature/AmazingFeature`)
+3. **Make Changes** and test locally
+4. **Commit Changes** (`git commit -m 'Add some AmazingFeature'`)
+5. **Push to Branch** (`git push origin feature/AmazingFeature`)
+6. **Open Pull Request**
+
+### Development Setup
+
+```bash
+git clone https://github.com/yourusername/ai-thumbnail-generator.git
+cd ai-thumbnail-generator
+pip install -r requirements.txt
+export HF_TOKEN="your_token"
+python app.py
+```
+
+## 🔄 API Reference
+
+### Main Functions
+
+```python
+# Generate metadata
+metadata = generate_metadata(topic, model_choice="zephyr")
+
+# Generate thumbnails
+thumb1, thumb2 = generate_thumbnails(topic, style, text_overlay)
+
+# Add text overlay
+image_with_text = add_text_overlay(image, title_text, style="bold")
+
+# Create download package
+json_data = create_download_data(topic, metadata, thumb1, thumb2, selected)
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- [Hugging Face](https://huggingface.co/) for the amazing Inference API and model hosting
+- [Gradio](https://gradio.app/) for the intuitive UI framework
+- [Stability AI](https://stability.ai/) for Stable Diffusion models
+- [HuggingFace H4](https://huggingface.co/HuggingFaceH4) for the Zephyr model
+- [Mistral AI](https://mistral.ai/) for the Mistral language model
+
+## 📞 Support & Community
+
+- **Issues**: [GitHub Issues](https://github.com/yourusername/ai-thumbnail-generator/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/yourusername/ai-thumbnail-generator/discussions)
+- **Twitter**: [@yourusername](https://twitter.com/yourusername)
+- **Email**: your-email@example.com
+
+## 🏆 Features Roadmap
+
+- [ ] **Video preview generation**
+- [ ] **Batch processing for multiple topics**
+- [ ] **Custom style training**
+- [ ] **A/B testing for thumbnails**
+- [ ] **Analytics integration**
+- [ ] **Mobile app version**
+
+---
+
+⭐ **If you find this project helpful, please give it a star on GitHub!** ⭐
+
+**Built with ❤️ for the creator community**

api_utils.py

@@ -0,0 +1,71 @@
+import requests
+import time
+from config import current_hf_token
+
+
+def test_hf_token(token):
+    """Test Hugging Face token by calling the user endpoint"""
+    if not token or not token.strip():
+        return "❌ Please enter a token first"
+    
+    url = "https://huggingface.co/api/whoami-v2"
+    headers = {"Authorization": f"Bearer {token.strip()}"}
+    try:
+        resp = requests.get(url, headers=headers, timeout=10)
+        if resp.status_code == 200:
+            data = resp.json()
+            user_name = data.get('name', 'unknown')
+            
+            # Test inference providers access
+            test_url = "https://router.huggingface.co/v1/models"
+            test_resp = requests.get(test_url, headers=headers, timeout=10)
+            
+            if test_resp.status_code == 200:
+                return f"✅ Token valid! User: {user_name} - Inference Providers access confirmed!"
+            else:
+                return f"⚠️ Token valid for user {user_name}, but may lack Inference Providers permissions. Check token settings."
+        elif resp.status_code == 401:
+            return "❌ Invalid token. Please check and try again."
+        else:
+            return f"❌ Error: {resp.status_code} {resp.text[:100]}"
+    except Exception as e:
+        return f"❌ Connection error: {e}"
+
+
+def query_hf_api(api_url, payload, max_retries=3):
+    """Query Hugging Face Inference API with retries"""
+    global current_hf_token
+    token = current_hf_token
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
+    print(f"🔄 Calling API: {api_url}")
+    print(f"🔑 Using Hugging Face token: {'Yes' if token else 'No (public access)'}")
+    
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(api_url, headers=headers, json=payload, timeout=60)
+            print(f"📡 Response status: {response.status_code}")
+            
+            if response.status_code == 200:
+                print("✅ API call successful!")
+                return response
+            elif response.status_code == 404:
+                print(f"❌ Model not found (404). Model may not be available.")
+                break  # Don't retry 404 errors
+            elif response.status_code == 503:
+                print(f"⏳ Model loading, waiting... (attempt {attempt + 1})")
+                time.sleep(15)
+            elif response.status_code == 429:
+                print(f"⏱️ Rate limited, waiting... (attempt {attempt + 1})")
+                time.sleep(20)
+            elif response.status_code == 401:
+                print(f"🔐 Authentication error. Check your token.")
+                break  # Don't retry auth errors
+            else:
+                print(f"❌ API Error {response.status_code}: {response.text[:500]}")
+                time.sleep(5)
+        except Exception as e:
+            print(f"❌ Request failed (attempt {attempt + 1}): {e}")
+            time.sleep(5)
+    
+    print("💥 All API attempts failed!")
+    return None

config.py

@@ -0,0 +1,29 @@
+# Configuration file for AI Thumbnail & Metadata Generator
+
+# API configuration
+OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions"
+HF_IMAGE_API_URL = "https://api-inference.huggingface.co/models/"
+
+# Model configurations
+TEXT_MODELS = {
+    "deepseek-r1-free": "deepseek/deepseek-r1:free"  # Use deepseek model for OpenRouter
+}
+
+IMAGE_MODELS = {
+    "fast": "black-forest-labs/FLUX.1-schnell",  # Fast FLUX model  
+    "quality": "black-forest-labs/FLUX.1-dev"   # Quality FLUX model
+}
+
+# Style prompts for different thumbnail styles
+STYLE_PROMPTS = {
+    "Realistic": "photorealistic, high quality, professional photography, detailed, sharp focus",
+    "Cartoon": "cartoon style, animated, colorful, fun, illustrated, digital art, vibrant",
+    "Cinematic": "cinematic lighting, dramatic, movie poster style, epic, atmospheric, high contrast",
+    "Minimalist": "minimalist design, clean, simple, modern, elegant, white background, typography",
+    "Gaming": "gaming style, neon colors, futuristic, glowing effects, action-packed",
+    "Tech": "tech style, sleek, modern, blue and white, professional, corporate"
+}
+
+# Global variables for API keys
+current_hf_token = ""
+current_openrouter_token = ""

content_processor.py

@@ -0,0 +1,57 @@
+import json
+from datetime import datetime
+
+
+def create_download_data(topic, metadata, thumbnail1, thumbnail2, selected_thumbnail):
+    """Create downloadable JSON data"""
+    # Parse metadata
+    lines = metadata.split('\n')
+    title = ""
+    description = ""
+    tags = ""
+    
+    for line in lines:
+        if line.startswith('TITLE:'):
+            title = line.replace('TITLE:', '').strip()
+        elif line.startswith('DESCRIPTION:'):
+            description = line.replace('DESCRIPTION:', '').strip()
+        elif line.startswith('TAGS:'):
+            tags = line.replace('TAGS:', '').strip()
+    
+    data = {
+        "topic": topic,
+        "generated_at": datetime.now().isoformat(),
+        "metadata": {
+            "title": title,
+            "description": description,
+            "tags": tags.split(', ') if tags else []
+        },
+        "selected_thumbnail": selected_thumbnail,
+        "thumbnails_generated": 2
+    }
+    
+    return json.dumps(data, indent=2)
+
+
+def process_content(topic, style, model_choice, text_overlay, overlay_style):
+    """Main function to generate all content"""
+    if not topic.strip():
+        return "Please enter a topic!", None, None, ""
+    
+    print(f"Processing: {topic}")
+    
+    # Generate metadata
+    print("Generating metadata...")
+    from metadata_generator import generate_metadata
+    metadata = generate_metadata(topic, model_choice)
+    
+    print("Generating thumbnails...")
+    from image_generator import generate_thumbnails
+    thumbnail1, thumbnail2 = generate_thumbnails(topic, style, text_overlay, overlay_style)
+    
+    print("Complete!")
+    
+    # Create download data
+    download_data = create_download_data(topic, metadata, thumbnail1, thumbnail2, "thumbnail1")
+    
+    return metadata, thumbnail1, thumbnail2, download_data

image_generator.py

@@ -0,0 +1,179 @@
+import io
+from PIL import Image, ImageDraw, ImageFont
+from config import IMAGE_MODELS, HF_IMAGE_API_URL, STYLE_PROMPTS
+from api_utils import query_hf_api
+
+
+def create_placeholder_image(prompt):
+    """Create a placeholder image when generation fails"""
+    try:
+        img = Image.new('RGB', (1280, 720), color=(100, 149, 237))
+        draw = ImageDraw.Draw(img)
+        
+        try:
+            font = ImageFont.truetype("arial.ttf", 36)
+        except:
+            try:
+                font = ImageFont.load_default()
+            except:
+                font = None
+        
+        # Add title
+        title = "Placeholder Thumbnail"
+        if font:
+            bbox = draw.textbbox((0, 0), title, font=font)
+            text_width = bbox[2] - bbox[0]
+            x = (1280 - text_width) // 2
+            draw.text((x, 200), title, fill='white', font=font)
+        
+        # Add prompt
+        prompt_text = f"Topic: {prompt[:50]}..."
+        if font:
+            bbox = draw.textbbox((0, 0), prompt_text, font=font)
+            text_width = bbox[2] - bbox[0]
+            x = (1280 - text_width) // 2
+            draw.text((x, 300), prompt_text, fill='lightgray', font=font)
+        
+        # Add note
+        note = "AI generation failed - using placeholder"
+        if font:
+            bbox = draw.textbbox((0, 0), note, font=font)
+            text_width = bbox[2] - bbox[0]
+            x = (1280 - text_width) // 2
+            draw.text((x, 400), note, fill='yellow', font=font)
+        
+        return img
+    except Exception as e:
+        print(f"Error creating placeholder: {e}")
+        # Ultimate fallback - solid color
+        return Image.new('RGB', (1280, 720), color=(100, 149, 237))
+
+
+def add_text_overlay(image, title_text, style="bold"):
+    """Add text overlay to image"""
+    if image is None:
+        return None
+    
+    # Create a copy to avoid modifying original
+    img = image.copy()
+    draw = ImageDraw.Draw(img)
+    
+    # Get image dimensions
+    width, height = img.size
+    
+    # Try to load fonts
+    try:
+        if style == "bold":
+            font_size = max(24, width // 20)
+            font = ImageFont.truetype("arial.ttf", font_size)
+        elif style == "elegant":
+            font_size = max(20, width // 25)
+            font = ImageFont.truetype("times.ttf", font_size)
+        else:  # clean
+            font_size = max(18, width // 30)
+            font = ImageFont.truetype("calibri.ttf", font_size)
+    except:
+        font = ImageFont.load_default()
+    
+    # Wrap text to fit image width
+    words = title_text.split()
+    lines = []
+    current_line = ""
+    max_width = width * 0.8
+    
+    for word in words:
+        test_line = current_line + " " + word if current_line else word
+        bbox = draw.textbbox((0, 0), test_line, font=font)
+        if bbox[2] - bbox[0] < max_width:
+            current_line = test_line
+        else:
+            if current_line:
+                lines.append(current_line)
+            current_line = word
+    
+    if current_line:
+        lines.append(current_line)
+    
+    # Position text (top third of image)
+    y_start = height // 6
+    line_height = font_size + 5
+    
+    for i, line in enumerate(lines[:3]):  # Max 3 lines
+        bbox = draw.textbbox((0, 0), line, font=font)
+        text_width = bbox[2] - bbox[0]
+        x = (width - text_width) // 2
+        y = y_start + (i * line_height)
+        
+        # Draw shadow/outline for better visibility
+        for dx, dy in [(-2, -2), (-2, 2), (2, -2), (2, 2)]:
+            draw.text((x + dx, y + dy), line, fill='black', font=font)
+        
+        # Draw main text
+        draw.text((x, y), line, fill='white', font=font)
+    
+    return img
+
+
+def generate_image(prompt, model_choice="fast"):
+    """Generate image using Hugging Face Inference API"""
+    try:
+        model_name = IMAGE_MODELS[model_choice]
+        api_url = HF_IMAGE_API_URL + model_name
+        
+        payload = {"inputs": prompt}
+        
+        print(f"Attempting to generate image with {model_choice}...")
+        response = query_hf_api(api_url, payload)
+        
+        if response and response.status_code == 200:
+            try:
+                image = Image.open(io.BytesIO(response.content))
+                print(f"✅ Image generated successfully with {model_choice}")
+                return image
+            except Exception as img_error:
+                print(f"❌ Error opening image: {img_error}")
+                return create_placeholder_image(prompt)
+        else:
+            print(f"❌ Image generation failed for {model_choice}")
+            return create_placeholder_image(prompt)
+            
+    except Exception as e:
+        print(f"❌ Error generating image with {model_choice}: {e}")
+        return create_placeholder_image(prompt)
+
+
+def generate_thumbnails(topic, style, text_overlay="", overlay_style="bold"):
+    """Generate two thumbnails with different models"""
+    print(f"Generating thumbnails for: {topic} in {style} style")
+    
+    # Get style prompt
+    style_prompt = STYLE_PROMPTS.get(style, STYLE_PROMPTS["Realistic"])
+    
+    # Create enhanced prompts
+    base_prompt = f"YouTube thumbnail, {topic}, {style_prompt}, eye-catching, professional, high contrast, vibrant colors, no text"
+    
+    # Generate with both models
+    prompt1 = f"{base_prompt}, centered composition"
+    prompt2 = f"{base_prompt}, dynamic angle, creative layout"
+    
+    print("Generating thumbnail 1 (Fast)...")
+    thumbnail1 = generate_image(prompt1, "fast")
+    
+    print("Generating thumbnail 2 (Quality)...")
+    thumbnail2 = generate_image(prompt2, "quality")
+    
+    # Resize to YouTube thumbnail dimensions (16:9)
+    target_size = (1280, 720)
+    if thumbnail1:
+        thumbnail1 = thumbnail1.resize(target_size, Image.Resampling.LANCZOS)
+    if thumbnail2:
+        thumbnail2 = thumbnail2.resize(target_size, Image.Resampling.LANCZOS)
+    
+    # Add text overlay if provided
+    if text_overlay.strip():
+        if thumbnail1:
+            thumbnail1 = add_text_overlay(thumbnail1, text_overlay, overlay_style)
+        if thumbnail2:
+            thumbnail2 = add_text_overlay(thumbnail2, text_overlay, overlay_style)
+    
+    return thumbnail1, thumbnail2

main.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+AI Thumbnail & Metadata Generator
+Main entry point for the application
+"""
+
+import os
+from config import current_hf_token, current_openrouter_token
+from ui import create_gradio_ui
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    print("⚠️  python-dotenv not installed. Using system environment variables only.")
+
+def main():
+    """Main function to launch the application"""
+    print("🚀 Starting AI Thumbnail & Metadata Generator...")
+    print("💡 Using OpenRouter API for text generation and Hugging Face for images")
+    print("⚠️  Note: Set API keys in the app UI for authenticated access")
+    
+    # Check if tokens are available from environment
+    hf_env_token = os.getenv('HF_TOKEN')
+    openrouter_env_token = os.getenv('OPENROUTER_TOKEN')
+    
+    if hf_env_token:
+        print("✅ Hugging Face token detected from environment")
+        # Set global token if found in environment
+        import config
+        config.current_hf_token = hf_env_token
+        
+    if openrouter_env_token:
+        print("✅ OpenRouter token detected from environment")
+        # Set global token if found in environment
+        import config
+        config.current_openrouter_token = openrouter_env_token
+    
+    if not hf_env_token and not openrouter_env_token:
+        print("⚠️  No API tokens found in environment - use the app UI to set them")
+    
+    # Create and launch the Gradio app
+    app = create_gradio_ui()
+    
+    app.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

metadata_generator.py

@@ -0,0 +1,108 @@
+import requests
+import random
+import re
+from config import TEXT_MODELS, OPENROUTER_API_URL, current_openrouter_token
+
+
+def create_smart_fallback_metadata(topic):
+    """Create smart fallback metadata when AI generation fails"""
+    
+    # Smart title templates
+    title_templates = [
+        f"Ultimate {topic} Guide",
+        f"{topic} Secrets Revealed",
+        f"Master {topic} in Minutes",
+        f"{topic} Pro Tips & Tricks",
+        f"Everything About {topic}",
+        f"{topic} Made Simple",
+        f"The Complete {topic} Tutorial"
+    ]
+    
+    # Smart description templates
+    desc_templates = [
+        f"Learn everything you need to know about {topic} in this comprehensive guide. Perfect for beginners and experts alike!",
+        f"Discover the best {topic} techniques and strategies. Transform your skills with these proven methods!",
+        f"Master {topic} with this step-by-step tutorial. Get professional results every time!",
+        f"Unlock the secrets of {topic}. This detailed guide covers everything from basics to advanced techniques!",
+        f"The ultimate {topic} resource you've been looking for. Clear explanations and practical examples included!"
+    ]
+    
+    # Generate relevant tags based on topic
+    base_tags = [topic.lower().replace(" ", "-")]
+    topic_words = topic.lower().split()
+    
+    common_tags = ["tutorial", "guide", "tips", "howto", "learn", "beginner", "expert", "professional"]
+    selected_tags = base_tags + topic_words + random.sample(common_tags, 3)
+    
+    return f"""TITLE: {random.choice(title_templates)}
+DESCRIPTION: {random.choice(desc_templates)}
+TAGS: {", ".join(selected_tags[:7])}"""
+
+
+def generate_metadata(topic, model_choice="deepseek-r1-free"):
+    """Generate YouTube metadata using OpenRouter API"""
+    try:
+        print(f"🤖 Generating metadata with {model_choice} for: {topic}")
+        model_name = TEXT_MODELS[model_choice]
+        global current_openrouter_token
+        if not current_openrouter_token:
+            print("⚠️ No OpenRouter API key provided, using smart fallback response")
+            return create_smart_fallback_metadata(topic)
+
+        # OpenRouter expects OpenAI-style chat payload
+        messages = [
+            {
+                "role": "user",
+                "content": f"Create a YouTube title, description, and tags for a video about {topic}. Format: TITLE: [title] DESCRIPTION: [description] TAGS: [tags]"
+            }
+        ]
+        payload = {
+            "model": model_name,
+            "messages": messages,
+            "max_tokens": 200,
+            "temperature": 0.7
+        }
+        headers = {
+            "Authorization": f"Bearer {current_openrouter_token}",
+            "Content-Type": "application/json"
+        }
+        print(f"🔄 Calling OpenRouter API for {model_name}")
+        response = requests.post(OPENROUTER_API_URL, headers=headers, json=payload, timeout=60)
+        print(f"📡 Response status: {response.status_code}")
+        if response.status_code == 200:
+            result = response.json()
+            print(f"📝 Raw API response: {result}")
+            if "choices" in result and len(result["choices"]) > 0:
+                message = result["choices"][0]["message"]
+                generated_text = message.get("content", "")
+                if generated_text.strip():
+                    print(f"✅ Generated text: {generated_text[:200]}...")
+                    return generated_text.strip()
+                # Fallback to reasoning if content is empty
+                reasoning_text = message.get("reasoning", "")
+                if reasoning_text.strip():
+                    print(f"⚠️ Using reasoning as fallback: {reasoning_text[:200]}...")
+                    # Try to extract title, description, tags from reasoning
+                    title_match = re.search(r'title.*?"([^"]+)"', reasoning_text, re.IGNORECASE)
+                    description_match = re.search(r'description.*?"([^"]+)"', reasoning_text, re.IGNORECASE)
+                    tags_match = re.search(r'tags.*?([\w, ]+)', reasoning_text, re.IGNORECASE)
+                    title = title_match.group(1) if title_match else f"{topic}: AI Insights"
+                    description = description_match.group(1) if description_match else f"Explore how AI is transforming {topic}. Discover trends, breakthroughs, and real-world examples in this video."
+                    tags = tags_match.group(1) if tags_match else f"ai, {topic.lower().replace(' ', '-')}, healthcare, technology, innovation"
+                    formatted = f"TITLE: {title}\nDESCRIPTION: {description}\nTAGS: {tags}"
+                    return formatted
+                print("❌ No usable content or reasoning in response; using smart fallback.")
+                return create_smart_fallback_metadata(topic)
+            else:
+                print("❌ No choices in response")
+        elif response.status_code == 401:
+            print(f"🔐 Authentication error. Invalid API key.")
+        elif response.status_code == 403:
+            print(f"🔐 Forbidden. API key may not have required permissions.")
+        else:
+            print(f"❌ API Error {response.status_code}: {response.text[:500]}")
+        print("⚠️ Using smart fallback response...")
+        return create_smart_fallback_metadata(topic)
+    except Exception as e:
+        print(f"❌ Error generating metadata: {e}")
+        return create_smart_fallback_metadata(topic)

requirements.txt

@@ -1,4 +1,5 @@
 gradio>=4.0.0
 requests
 Pillow
-python-dateutil
+python-dateutil
+python-dotenv

ui.py

@@ -0,0 +1,224 @@
+import gradio as gr
+import json
+from config import STYLE_PROMPTS, current_hf_token, current_openrouter_token
+from api_utils import test_hf_token
+from content_processor import process_content
+
+
+def create_gradio_ui():
+    """Create and return the Gradio interface"""
+    with gr.Blocks(title="AI Thumbnail & Metadata Generator", theme=gr.themes.Soft()) as app:
+        gr.Markdown("""
+        ## 🔑 API Key Management
+        **⚠️ Important:**
+        - You need a valid OpenRouter API key for text generation (metadata).
+        - You need a valid Hugging Face API key for image generation (thumbnails).
+        
+        Get your OpenRouter API key at [https://openrouter.ai/](https://openrouter.ai/) (sign up and generate your key)
+        Get your Hugging Face API key at [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+        """)
+        with gr.Row():
+            openrouter_token_input = gr.Textbox(label="OpenRouter API Key", placeholder="Paste your OpenRouter API key here", value="", type="password")
+            set_openrouter_token_btn = gr.Button("Set OpenRouter Key", variant="primary")
+            clear_openrouter_token_btn = gr.Button("Clear OpenRouter Key", variant="secondary")
+            test_openrouter_token_btn = gr.Button("Test OpenRouter Key", variant="secondary")
+        openrouter_token_status = gr.Textbox(label="OpenRouter Key Status", interactive=False)
+
+        with gr.Row():
+            hf_token_input = gr.Textbox(label="Hugging Face API Key", placeholder="Paste your Hugging Face API key here", value="", type="password")
+            set_hf_token_btn = gr.Button("Set HF Key", variant="primary")
+            clear_hf_token_btn = gr.Button("Clear HF Key", variant="secondary")
+            test_hf_token_btn = gr.Button("Test HF Key", variant="secondary")
+        hf_token_status = gr.Textbox(label="HF Key Status", interactive=False)
+
+        # Store keys separately
+        def set_openrouter_token_callback(token):
+            global current_openrouter_token
+            current_openrouter_token = token.strip()
+            return "✅ OpenRouter API key set!"
+
+        def clear_openrouter_token_callback():
+            global current_openrouter_token
+            current_openrouter_token = ""
+            return "🗑️ OpenRouter API key cleared."
+
+        def set_hf_token_callback(token):
+            global current_hf_token
+            current_hf_token = token.strip()
+            return "✅ Hugging Face API key set!"
+
+        def clear_hf_token_callback():
+            global current_hf_token
+            current_hf_token = ""
+            return "🗑️ Hugging Face API key cleared."
+
+        set_openrouter_token_btn.click(fn=set_openrouter_token_callback, inputs=openrouter_token_input, outputs=openrouter_token_status)
+        clear_openrouter_token_btn.click(fn=clear_openrouter_token_callback, inputs=None, outputs=openrouter_token_status)
+        test_openrouter_token_btn.click(fn=lambda k: "✅ Key format looks valid!" if k and len(k) > 10 else "❌ Please enter a valid OpenRouter API key.", inputs=openrouter_token_input, outputs=openrouter_token_status)
+
+        set_hf_token_btn.click(fn=set_hf_token_callback, inputs=hf_token_input, outputs=hf_token_status)
+        clear_hf_token_btn.click(fn=clear_hf_token_callback, inputs=None, outputs=hf_token_status)
+        test_hf_token_btn.click(fn=test_hf_token, inputs=hf_token_input, outputs=hf_token_status)
+        
+        gr.Markdown("""
+        # 🎨 AI Thumbnail & Metadata Generator
+        
+        Generate catchy YouTube titles, descriptions, tags, and stunning thumbnails using AI models!
+        
+        **✨ Features:**
+        - 🤖 AI-powered metadata generation
+        - 🎨 Dual thumbnail generation (Fast & Quality)
+        - 🎯 6 different visual styles
+        - ✏️ Custom text overlay editor
+        - 📥 Download metadata as JSON
+        
+        **How to use:**
+        1. Enter your video topic
+        2. Choose thumbnail style and text model
+        3. Add custom text overlay (optional)
+        4. Generate content and download!
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input section
+                gr.Markdown("### 📝 Input Settings")
+                
+                topic_input = gr.Textbox(
+                    label="Video Topic",
+                    placeholder="e.g., AI in Healthcare, Cooking Tips, Travel Photography...",
+                    lines=2
+                )
+                
+                with gr.Row():
+                    style_dropdown = gr.Dropdown(
+                        choices=list(STYLE_PROMPTS.keys()),
+                        value="Realistic",
+                        label="Thumbnail Style"
+                    )
+                    
+                    model_dropdown = gr.Dropdown(
+                        choices=["deepseek-r1-free"],
+                        value="deepseek-r1-free",
+                        label="Text Model"
+                    )
+                
+                gr.Markdown("### ✏️ Text Overlay (Optional)")
+                
+                text_overlay_input = gr.Textbox(
+                    label="Custom Title Text",
+                    placeholder="Leave empty to use generated title...",
+                    lines=2
+                )
+                
+                overlay_style_dropdown = gr.Dropdown(
+                    choices=["bold", "elegant", "clean"],
+                    value="bold",
+                    label="Text Style"
+                )
+                
+                generate_btn = gr.Button("🚀 Generate Content", variant="primary", size="lg")
+                
+                # Metadata section
+                gr.Markdown("### 📋 Generated Metadata")
+                metadata_output = gr.Textbox(
+                    label="YouTube Title, Description & Tags",
+                    lines=8,
+                    placeholder="Generated metadata will appear here...",
+                    info="✏️ Edit this text before using it for your video!"
+                )
+                
+                # Download section - simplified
+                gr.Markdown("### 📥 Export Data")
+                export_output = gr.Textbox(
+                    label="📋 Copy this JSON data",
+                    lines=5,
+                    placeholder="JSON export will appear here...",
+                    info="Copy this data to save your metadata"
+                )
+                
+                download_data = gr.Textbox(
+                    label="Metadata JSON",
+                    lines=3,
+                    placeholder="JSON data will appear here...",
+                    visible=False
+                )
+        
+            with gr.Column(scale=2):
+                # Thumbnails section
+                gr.Markdown("### 🖼️ Generated Thumbnails")
+                
+                with gr.Row():
+                    thumbnail1_output = gr.Image(
+                        label="🚀 Fast Generation (FLUX.1-schnell)",
+                        type="pil",
+                        show_download_button=True
+                    )
+                    thumbnail2_output = gr.Image(
+                        label="💎 Quality Generation (FLUX.1-dev)", 
+                        type="pil",
+                        show_download_button=True
+                    )
+                
+                # Thumbnail selection for JSON export
+                with gr.Row():
+                    select_thumb1_btn = gr.Button("📥 Use Fast Thumbnail", size="sm")
+                    select_thumb2_btn = gr.Button("📥 Use Quality Thumbnail", size="sm")
+    
+        # Event handlers
+        generate_btn.click(
+            fn=process_content,
+            inputs=[topic_input, style_dropdown, model_dropdown, text_overlay_input, overlay_style_dropdown],
+            outputs=[metadata_output, thumbnail1_output, thumbnail2_output, download_data]
+        )
+        
+        # Thumbnail selection for export
+        def update_export_data(topic, metadata, download_data, selected):
+            if download_data:
+                try:
+                    data = json.loads(download_data)
+                    data["selected_thumbnail"] = selected
+                    return json.dumps(data, indent=2)
+                except Exception as e:
+                    print(f"Export error: {e}")
+                    return f"Error creating export: {e}"
+            return ""
+        
+        select_thumb1_btn.click(
+            fn=lambda t, m, d: update_export_data(t, m, d, "fast_thumbnail"),
+            inputs=[topic_input, metadata_output, download_data],
+            outputs=[export_output]
+        )
+        
+        select_thumb2_btn.click(
+            fn=lambda t, m, d: update_export_data(t, m, d, "quality_thumbnail"),
+            inputs=[topic_input, metadata_output, download_data],
+            outputs=[export_output]
+        )
+        
+        # Example inputs
+        gr.Markdown("""
+        ### 💡 Example Topics to Try:
+        
+        **Tech & AI:**
+        - "Future of Artificial Intelligence"
+        - "Best Programming Languages 2024"
+        - "Cybersecurity for Beginners"
+        
+        **Lifestyle & Health:**
+        - "Morning Routine for Productivity"
+        - "Healthy Meal Prep Ideas"
+        - "Home Workout Without Equipment"
+        
+        **Business & Finance:**
+        - "Passive Income Strategies"
+        - "Social Media Marketing Tips"
+        - "Cryptocurrency Explained"
+        
+        **Education & Skills:**
+        - "Learn Python in 30 Days"
+        - "Photography Composition Rules"
+        - "Public Speaking Confidence"
+        """)
+
+    return app