Initial Commit

.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+**/.DS_Store
+.venv
+
+# Python-generated files
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+data/examples/*/scene*.png

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,139 @@
----
-title: MangakAI
-emoji: 🐢
-colorFrom: yellow
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MangakAI 📚✨
+
+Transform your stories into stunning manga panels with AI! MangakAI is an intelligent manga generation tool that converts written narratives into visual manga-style panels using Google's Gemini AI models.
+
+## 🌟 Features
+
+- **🎨 AI-Powered Generation**: Convert stories into professional manga panels with scene intelligence
+- **🎭 Style Customization**: Multiple art styles, moods, color palettes, and composition options
+- **🔄 Panel Management**: Regenerate specific panels with custom modifications and reference images
+- **📋 Custom Templates**: Upload your own panel layouts for personalized manga creation
+- **📁 Export Options**: Generate PDFs and organize panels with version control
+- **🖥️ Web Interface**: User-friendly Gradio interface with text/file input and example stories
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Python 3.11 or higher
+- Google Gemini API key
+- UV package manager (recommended) or pip
+
+### Installation
+
+1. **Clone the repository**
+   ```bash
+   git clone https://github.com/Shiva4113/MangakAI.git
+   cd MangakAI
+   ```
+
+2. **Install dependencies**
+   ```bash
+   # Using UV (recommended)
+   uv sync
+   ```
+
+3. **Set up environment variables**
+   ```bash
+   # Create .env file
+   echo "GEMINI_API_KEY=your_gemini_api_key_here" > .env
+   ```
+
+4. **Run the application**
+   ```bash
+   uv run app.py
+   ```
+
+5. **Access the interface**
+   Open your browser and navigate to `http://localhost:7860`
+
+## 📖 Usage Guide
+
+### 🖋️ **Generate Manga from Text**
+
+1. Enter your story in the text area
+2. Select number of scenes (1-10 panels)
+3. Choose style preferences (optional)
+4. Upload custom template (optional)
+5. Click "Generate Manga"
+
+### 📄 **Generate from File**
+
+1. Upload a .txt story file
+2. Configure settings and generate
+
+### 🔄 **Regenerate Panels**
+
+1. Select panel number to modify
+2. Enter modification instructions
+3. Upload reference image (optional)
+4. Choose to replace original or keep both
+
+### 📥 **Export as PDF**
+
+1. Generate your manga first
+2. Go to "Download PDF" tab and click "Create PDF"
+
+## 🏗️ Project Structure
+
+```
+MangakAI/
+├── app.py              # Main Gradio interface
+├── manga.py            # Core manga generation logic
+├── utils.py            # Utility functions and prompts
+├── main.py             # Entry point
+├── pyproject.toml      # Project configuration
+├── .env               # Environment variables (create this)
+├── data/
+│   ├── examples/      # Example manga panels
+│   │   ├── LittleLantern/
+│   │   ├── PaperKite/
+│   │   └── StrayPuppy/
+│   ├── output/        # Generated manga panels
+│   ├── stories/       # Story text files
+│   └── templates/     # Panel templates
+└── README.md
+```
+
+## 🛠️ Configuration
+
+### Environment Variables
+
+Create a `.env` file with the following variables:
+
+```env
+GEMINI_API_KEY=your_gemini_api_key_here
+TEMPLATE_PATH=data/templates/template1.png
+OUTPUT_DIR=data/output
+STORIES_DIR=data/stories
+IMAGE_MODEL_NAME=gemini-2.5-flash-image-preview
+SCENE_MODEL_NAME=gemini-2.0-flash
+```
+
+### API Setup
+
+1. **Get Gemini API Key**:
+   - Visit [Google AI Studio](https://makersuite.google.com/app/apikey)
+   - Create a new API key
+   - Add it to your `.env` file
+
+## 🎨 Style Options
+
+Choose from various art styles (Traditional Manga, Shonen, Shoujo, Seinen, Chibi, Cyberpunk, Fantasy, Horror), moods (Epic, Dark, Light, Dramatic, Action-packed), color palettes, character styles, and composition options to create your unique manga aesthetic.
+
+## 🔧 Advanced Features
+
+- **Smart Prompts**: Analyzes story structure and maintains character consistency
+- **Custom Templates**: Upload your own panel layouts with automatic AI adaptation
+- **Reference Images**: Guide style, composition, and character appearance
+
+## 📋 Examples
+
+The project includes three example stories with generated panels:
+
+1. **The Little Lantern**: A heartwarming tale of courage and kindness
+2. **The Paper Kite**: A story about letting go and finding wonder
+3. **The Stray Puppy**: A touching story of compassion and friendship
+
+
+
+*Transform your imagination into visual stories with the power of AI!*

app.py

@@ -0,0 +1,541 @@
+import gradio as gr
+from manga import (
+    generate_manga_interface, 
+    generate_manga_from_file_interface,
+    regenerate_and_replace_interface,
+    create_pdf_interface,
+    get_current_panels,
+    create_user_session
+)
+from utils import ART_STYLES, MOOD_OPTIONS, COLOR_PALETTES, CHARACTER_STYLES, LINE_STYLES, COMPOSITION_STYLES
+import os
+
+# Define your example data
+EXAMPLES = {
+    "The Little Lantern": {
+        "title": "The Little Lantern",
+        "story": """In a small coastal village, where the sea whispered secrets to the shore, there lived a curious boy named Arun. Every evening, as the sun dipped behind the hills and the sky turned shades of orange and violet, Arun would carry his little lantern and sit on the rocks, watching the restless waves dance under the fading light.
+
+His lantern was old, with a glass chimney slightly cracked, but Arun cared for it as if it were a treasure. "One day, this light will help someone," he would whisper to himself, as the sea breeze tousled his hair.
+
+One night, the sky darkened earlier than usual. Thick clouds rolled in, and the wind began to howl like a wild beast. The sea churned, waves slamming against the shore with fierce force. Arun, worried, held his lantern tighter and scanned the horizon.
+
+Suddenly, through the curtain of rain and spray, he spotted a small fishing boat tossed about by the waves, its lantern barely visible. The boat's crew struggled to control it, fear written on their faces.
+
+Without a second thought, Arun jumped onto the rocks, his lantern held high above his head. "Here! This way!" he shouted through the roar of the wind and water.
+
+The captain of the boat saw the glow and turned the vessel toward the shore. The villagers, alerted by Arun's brave signal, ran to the beach with ropes and nets. Together, they pulled the boat safely onto land.
+
+The captain, drenched but smiling, knelt down and embraced Arun. "You saved us," he said. "Your little lantern became our lighthouse."
+
+From that day forward, Arun's lantern became more than just an object—it became a symbol of courage and kindness. Every evening, Arun continued to sit by the sea, his light shining steadily. The villagers often gathered around him, sharing stories, laughter, and warmth. And whenever a storm brewed on the horizon, Arun's lantern stood as a reminder that even the smallest light, held with love, can brighten the darkest night.""",
+        "panels": [
+            "data/examples/LittleLantern/scene1.png",
+            "data/examples/LittleLantern/scene2.png",
+            "data/examples/LittleLantern/scene3.png",
+            "data/examples/LittleLantern/scene4.png",
+            "data/examples/LittleLantern/scene5.png"
+        ]
+    },
+    "The Paper Kite": {
+        "title": "The Paper Kite",
+        "story": """Mira loved making kites. She would spend hours folding colorful paper, gluing tails, and tying strings until each kite looked perfect. Her favorite one was a bright red kite with golden edges that danced beautifully in the wind.
+
+One afternoon, while flying it near the meadow, a sudden gust of wind tore the string and the kite soared away. Mira's heart sank as she watched it drift higher and higher, beyond the trees and far into the sky.
+
+Feeling sad, she sat on a rock, staring at the empty sky. Just then, an old man passing by smiled gently. "Sometimes, letting go leads to something wonderful," he said.
+
+The next morning, while walking through the meadow, Mira found her kite caught on a branch. But this time, instead of grabbing it, she smiled and left it there. She realized the wind had given her kite a chance to explore new heights.
+
+From that day on, Mira made many more kites—not all stayed with her, but each one carried her dreams farther than she ever imagined.""",
+        "panels": [
+            "data/examples/PaperKite/scene1.png",
+            "data/examples/PaperKite/scene2.png",
+            "data/examples/PaperKite/scene3.png",
+            "data/examples/PaperKite/scene4.png",
+            "data/examples/PaperKite/scene5.png"
+        ]
+    },
+    "The Stray Puppy": {
+        "title": "The Stray Puppy",
+        "story": """One chilly evening, as the sun was setting, Leo was walking home from school when he heard soft whimpering near the park bench. Curious, he peeked behind it and found a tiny, shivering puppy with big, sad eyes.
+
+Leo gently picked it up and wrapped it in his jacket. The puppy licked his cheek as if thanking him. He took it home, gave it warm milk, and made a little bed from an old blanket.
+
+The next day, Leo asked his neighbors if the puppy belonged to anyone, but no one came forward. So he decided to keep it and named it "Buddy".""",
+        "panels": [
+            "data/examples/StrayPuppy/scene1.png",
+            "data/examples/StrayPuppy/scene2.png",
+            "data/examples/StrayPuppy/scene3.png",
+            "data/examples/StrayPuppy/scene4.png"
+        ]
+    }
+}
+
+def load_example(example_name):
+    """Load example data when user selects an example."""
+    if example_name in EXAMPLES:
+        example = EXAMPLES[example_name]
+        existing_panels = [panel for panel in example["panels"] if os.path.exists(panel)]
+        return example["title"], example["story"], existing_panels
+    return "", "", []
+
+def initialize_session(api_key: str):
+    """Initialize a new user session with API key."""
+    try:
+        if not api_key or not api_key.strip():
+            return None, "❌ Please enter your API key", gr.Tabs(visible=False)
+        
+        session_id = create_user_session(api_key.strip())
+        status_message = f"✅ Session initialized successfully! Session ID: {session_id[:8]}..."
+        
+        return session_id, status_message, gr.Tabs(visible=True)
+    except Exception as e:
+        return None, f"❌ Error initializing session: {str(e)}", gr.Tabs(visible=False)
+
+def create_gradio_interface():
+    with gr.Blocks(title="MangakAI", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 📚 MangakAI")
+        gr.Markdown("Transform your stories into manga panels with AI and custom style preferences!")
+        
+        # Session state
+        session_id_state = gr.State(value=None)
+        
+        # API Key Section at the top
+        gr.Markdown("## 🔑 API Configuration")
+        gr.Markdown("**Enter your Gemini API Key to get started.** You can get one from [Google AI Studio](https://makersuite.google.com/app/apikey)")
+        
+        with gr.Row():
+            api_key_input = gr.Textbox(
+                label="Gemini API Key",
+                placeholder="Enter your Gemini API key here...",
+                type="password",
+                scale=4
+            )
+            initialize_btn = gr.Button("🚀 Initialize Session", variant="primary", scale=1)
+        
+        session_status = gr.Textbox(
+            label="Session Status",
+            value="⚠️ Please enter your API key and initialize session",
+            interactive=False
+        )
+        
+        gr.Markdown("---")
+        
+        # Main tabs (initially hidden until session is initialized)
+        main_tabs = gr.Tabs(visible=False)
+        
+        with main_tabs:
+            with gr.Tab("📝 Generate Manga"):
+                with gr.Tab("Text Input"):
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            story_input = gr.Textbox(
+                                label="Enter your story", 
+                                placeholder="Once upon a time...",
+                                lines=10
+                            )
+                        with gr.Column(scale=1):
+                            num_scenes_text = gr.Slider(
+                                minimum=1, 
+                                maximum=10, 
+                                value=5,
+                                step=1,
+                                label="Number of Scenes"
+                            )
+                    
+                    # Style Preferences Section
+                    gr.Markdown("### 🎨 Style Preferences")
+                    with gr.Row():
+                        with gr.Column():
+                            art_style_text = gr.Dropdown(
+                                choices=["None"] + ART_STYLES,
+                                value="None",
+                                label="Art Style"
+                            )
+                            mood_text = gr.Dropdown(
+                                choices=["None"] + MOOD_OPTIONS,
+                                value="None",
+                                label="Overall Mood"
+                            )
+                            color_palette_text = gr.Dropdown(
+                                choices=["None"] + COLOR_PALETTES,
+                                value="None",
+                                label="Color Palette"
+                            )
+                        with gr.Column():
+                            character_style_text = gr.Dropdown(
+                                choices=["None"] + CHARACTER_STYLES,
+                                value="None",
+                                label="Character Style"
+                            )
+                            line_style_text = gr.Dropdown(
+                                choices=["None"] + LINE_STYLES,
+                                value="None",
+                                label="Line Art Style"
+                            )
+                            composition_text = gr.Dropdown(
+                                choices=["None"] + COMPOSITION_STYLES,
+                                value="None",
+                                label="Composition Style"
+                            )
+                    
+                    additional_notes_text = gr.Textbox(
+                        label="Additional Style Notes",
+                        placeholder="Any specific style preferences, character descriptions, or artistic directions...",
+                        lines=3
+                    )
+                    
+                    # Custom Template Upload Section
+                    gr.Markdown("### 📋 Custom Template (Optional)")
+                    gr.Markdown("*Upload your own manga panel template. If not provided, default template will be used.*")
+                    with gr.Row():
+                        user_template_text = gr.File(
+                            label="Upload Custom Template",
+                            file_types=[".png", ".jpg", ".jpeg", ".webp"]
+                        )
+                    
+                    gr.Markdown("**Template Guidelines:**")
+                    gr.Markdown("""
+                    - Use PNG format for best results
+                    - Template should have clear panel borders
+                    - Recommended size: 1024x1024 or higher
+                    - The AI will use your template as a guide for panel layout
+                    """)
+                    
+                    generate_btn = gr.Button("🎨 Generate Manga", variant="primary", size="lg")
+                    
+                    with gr.Row():
+                        output_gallery = gr.Gallery(
+                            label="Generated Manga Panels",
+                            show_label=True,
+                            elem_id="gallery",
+                            columns=2,
+                            rows=3,
+                            height="auto"
+                        )
+                    
+                    scene_output = gr.Textbox(
+                        label="Scene Descriptions / Status",
+                        lines=5,
+                        max_lines=10
+                    )
+                
+                with gr.Tab("File Upload"):
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            file_input = gr.File(
+                                label="Upload Story File (.txt)",
+                                file_types=[".txt"]
+                            )
+                        with gr.Column(scale=1):
+                            num_scenes_file = gr.Slider(
+                                minimum=1,
+                                maximum=10, 
+                                value=5,
+                                step=1,
+                                label="Number of Scenes"
+                            )
+                    
+                    # Style Preferences Section for File Upload
+                    gr.Markdown("### 🎨 Style Preferences")
+                    with gr.Row():
+                        with gr.Column():
+                            art_style_file = gr.Dropdown(
+                                choices=["None"] + ART_STYLES,
+                                value="None",
+                                label="Art Style"
+                            )
+                            mood_file = gr.Dropdown(
+                                choices=["None"] + MOOD_OPTIONS,
+                                value="None",
+                                label="Overall Mood"
+                            )
+                            color_palette_file = gr.Dropdown(
+                                choices=["None"] + COLOR_PALETTES,
+                                value="None",
+                                label="Color Palette"
+                            )
+                        with gr.Column():
+                            character_style_file = gr.Dropdown(
+                                choices=["None"] + CHARACTER_STYLES,
+                                value="None",
+                                label="Character Style"
+                            )
+                            line_style_file = gr.Dropdown(
+                                choices=["None"] + LINE_STYLES,
+                                value="None",
+                                label="Line Art Style"
+                            )
+                            composition_file = gr.Dropdown(
+                                choices=["None"] + COMPOSITION_STYLES,
+                                value="None",
+                                label="Composition Style"
+                            )
+                    
+                    additional_notes_file = gr.Textbox(
+                        label="Additional Style Notes",
+                        placeholder="Any specific style preferences, character descriptions, or artistic directions...",
+                        lines=3
+                    )
+                    
+                    # Custom Template Upload Section for File Upload
+                    gr.Markdown("### 📋 Custom Template (Optional)")
+                    gr.Markdown("*Upload your own manga panel template. If not provided, default template will be used.*")
+                    with gr.Row():
+                        user_template_file = gr.File(
+                            label="Upload Custom Template",
+                            file_types=[".png", ".jpg", ".jpeg", ".webp"]
+                        )
+                    
+                    generate_file_btn = gr.Button("🎨 Generate Manga from File", variant="primary", size="lg")
+                    
+                    with gr.Row():
+                        output_gallery_file = gr.Gallery(
+                            label="Generated Manga Panels",
+                            show_label=True,
+                            columns=2,
+                            rows=3,
+                            height="auto"
+                        )
+                    
+                    scene_output_file = gr.Textbox(
+                        label="Scene Descriptions / Status",
+                        lines=5,
+                        max_lines=10
+                    )
+            
+            with gr.Tab("🔄 Regenerate Panels"):
+                gr.Markdown("### Select a panel to regenerate with modifications")
+                gr.Markdown("**Note:** You must generate manga first before you can regenerate panels.")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        panel_selector = gr.Number(
+                            label="Panel Number to Regenerate",
+                            value=1,
+                            minimum=1,
+                            maximum=10,
+                            precision=0
+                        )
+                        
+                        modification_input = gr.Textbox(
+                            label="Modification Instructions",
+                            placeholder="e.g., 'Make the lighting more dramatic', 'Change character expression to angry', 'Add more action lines'",
+                            lines=3
+                        )
+                        
+                        # Reference Image Upload Section
+                        gr.Markdown("### 🖼️ Reference Image (Optional)")
+                        gr.Markdown("*Upload an image to guide the regeneration style, composition, or specific elements*")
+                        reference_image_upload = gr.File(
+                            label="Upload Reference Image",
+                            file_types=[".png", ".jpg", ".jpeg", ".webp"]
+                        )
+                        
+                        replace_checkbox = gr.Checkbox(
+                            label="Replace original panel",
+                            value=False
+                        )
+                        gr.Markdown("*Check this to replace the original panel in the main gallery*")
+                        
+                        regenerate_btn = gr.Button("🔄 Regenerate Panel", variant="secondary", size="lg")
+                    
+                    with gr.Column(scale=2):
+                        regenerated_image = gr.Image(
+                            label="Regenerated Panel",
+                            show_label=True
+                        )
+                
+                regeneration_status = gr.Textbox(
+                    label="Status",
+                    interactive=False
+                )
+                
+                # Updated main gallery display (shows when panels are replaced)
+                with gr.Row():
+                    updated_main_gallery = gr.Gallery(
+                        label="Updated Main Gallery (when replacing panels)",
+                        show_label=True,
+                        columns=2,
+                        rows=3,
+                        height="auto",
+                        visible=False
+                    )
+                
+                gr.Markdown("### Reference Image Guidelines:")
+                gr.Markdown("""
+                - **Style Reference**: Upload an image with the art style you want to emulate
+                - **Composition Reference**: Show the camera angle, pose, or layout you prefer
+                - **Color Reference**: Provide color palette or lighting inspiration
+                - **Character Reference**: Show specific character appearances or expressions
+                - **Environment Reference**: Demonstrate background or setting elements
+                """)
+                
+                gr.Markdown("### Common Modification Examples:")
+                gr.Markdown("""
+                - **Lighting**: "Make it darker with more shadows", "Add bright sunlight", "Create moody twilight atmosphere"
+                - **Character**: "Make character look more angry", "Change pose to defensive stance", "Add more detailed facial expression"
+                - **Composition**: "Change to close-up shot", "Make it a wide establishing shot", "Add more dynamic camera angle"
+                - **Style**: "Add more action lines", "Make it more dramatic", "Simplify the background"
+                - **Details**: "Add more environmental details", "Remove background clutter", "Focus more on the character"
+                """)
+            
+            with gr.Tab("📥 Download PDF"):
+                gr.Markdown("### Export your manga as a PDF")
+                gr.Markdown("**Note:** You must generate manga first before you can create a PDF.")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        create_pdf_btn = gr.Button("📥 Create PDF", variant="primary", size="lg")
+                    
+                    with gr.Column(scale=2):
+                        pdf_status = gr.Textbox(
+                            label="Status",
+                            interactive=False
+                        )
+                        
+                        download_pdf = gr.File(
+                            label="Download PDF",
+                            visible=False
+                        )
+                
+                gr.Markdown("### PDF Features:")
+                gr.Markdown("""
+                - **A4 format** with proper margins and professional layout
+                - **One panel per page** with panel numbering
+                - **Title page** with manga information
+                - **Custom template notation** if user template was used
+                - **Automatic image scaling** to fit pages while maintaining aspect ratio
+                """)
+            
+            with gr.Tab("🎯 Examples"):
+                gr.Markdown("### Explore Example Stories and Manga")
+                gr.Markdown("Select from our curated examples to see how stories transform into manga panels!")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        example_selector = gr.Dropdown(
+                            choices=list(EXAMPLES.keys()),
+                            label="Select Example",
+                            value=list(EXAMPLES.keys())[0] if EXAMPLES else None
+                        )
+                        
+                        example_title = gr.Textbox(
+                            label="Story Title",
+                            interactive=False,
+                            lines=1
+                        )
+                        
+                        example_story = gr.Textbox(
+                            label="Story Text",
+                            interactive=False,
+                            lines=8,
+                            max_lines=12
+                        )
+                    
+                    with gr.Column(scale=2):
+                        example_gallery = gr.Gallery(
+                            label="Manga Panels",
+                            show_label=True,
+                            columns=2,
+                            rows=3,
+                            height="auto"
+                        )
+                
+                gr.Markdown("### How It Works:")
+                gr.Markdown("""
+                1. **Select an Example**: Choose from the dropdown above
+                2. **View the Story**: Read the original story text
+                3. **See the Manga**: Observe how AI transforms text into visual panels
+                4. **Try Your Own**: Use the "Generate Manga" tab to create your own!
+                """)
+        
+        # Security notice
+        gr.Markdown("---")
+        gr.Markdown("### 🔒 Privacy & Security")
+        gr.Markdown("""
+        - **Your API key is never stored permanently** - it's only kept in memory during your session
+        - **All generated content is isolated** - each user gets their own private workspace
+        - **Sessions automatically expire** after 24 hours of inactivity
+        - **Your files are cleaned up** when your session ends
+        """)
+        
+        # Helper functions
+        def update_gallery_visibility(gallery_images):
+            if gallery_images:
+                return gr.Gallery(visible=True, value=gallery_images)
+            else:
+                return gr.Gallery(visible=False)
+        
+        def create_and_provide_pdf(session_id):
+            if session_id is None:
+                return "Session not initialized. Please refresh and enter your API key.", gr.File(visible=False)
+            
+            status, pdf_path = create_pdf_interface(session_id)
+            if pdf_path:
+                return status, gr.File(value=pdf_path, visible=True)
+            else:
+                return status, gr.File(visible=False)
+        
+        def load_first_example():
+            if EXAMPLES:
+                first_key = list(EXAMPLES.keys())[0]
+                return load_example(first_key)
+            return "", "", []
+        
+        # Event handlers
+        initialize_btn.click(
+            fn=initialize_session,
+            inputs=[api_key_input],
+            outputs=[session_id_state, session_status, main_tabs]
+        )
+        
+        generate_btn.click(
+            fn=generate_manga_interface,
+            inputs=[session_id_state, story_input, num_scenes_text, art_style_text, mood_text, color_palette_text, 
+                   character_style_text, line_style_text, composition_text, additional_notes_text, user_template_text],
+            outputs=[output_gallery, scene_output]
+        )
+        
+        generate_file_btn.click(
+            fn=generate_manga_from_file_interface,
+            inputs=[session_id_state, file_input, num_scenes_file, art_style_file, mood_file, color_palette_file,
+                   character_style_file, line_style_file, composition_file, additional_notes_file, user_template_file],
+            outputs=[output_gallery_file, scene_output_file]
+        )
+        
+        regenerate_btn.click(
+            fn=regenerate_and_replace_interface,
+            inputs=[session_id_state, panel_selector, modification_input, replace_checkbox, reference_image_upload],
+            outputs=[regeneration_status, regenerated_image, updated_main_gallery]
+        ).then(
+            fn=update_gallery_visibility,
+            inputs=[updated_main_gallery],
+            outputs=[updated_main_gallery]
+        )
+        
+        create_pdf_btn.click(
+            fn=create_and_provide_pdf,
+            inputs=[session_id_state],
+            outputs=[pdf_status, download_pdf]
+        )
+        
+        # Example selection
+        example_selector.change(
+            fn=load_example,
+            inputs=[example_selector],
+            outputs=[example_title, example_story, example_gallery]
+        )
+        
+        # Load first example on startup
+        demo.load(
+            fn=load_first_example,
+            outputs=[example_title, example_story, example_gallery]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_gradio_interface()
+    demo.launch(share=True)

data/stories/example_story.txt

@@ -0,0 +1,11 @@
+In a quiet village surrounded by hills, there stood an ancient oak tree at the edge of the forest. The villagers said it was magical—that if you whispered your wish to its trunk, the tree would carry it to the stars.
+
+Nine-year-old Nora didn’t believe in magic, but she loved stories. One evening, as the sky turned purple and the fireflies came out, she tiptoed to the tree with a secret wish. “I want to find a friend who understands me,” she whispered, pressing her cheek against the rough bark.
+
+The next day, while walking through the woods, she heard soft humming. Following the sound, she found a small fox with bright amber eyes, tangled in some vines. Without thinking, she freed it gently. The fox didn’t run away but sat beside her, tail wagging.
+
+From that day on, Nora and the fox became inseparable. They explored streams, climbed hills, and lay beneath the stars sharing dreams. No one else saw the fox, but Nora didn’t mind.
+
+On clear nights, she would sit by the oak tree and thank it. The tree’s leaves rustled in response, as if smiling.
+
+The villagers still whispered about the magic tree, but Nora knew the truth—it wasn’t about spells or charms. Sometimes, all it takes is a wish, a little courage, and a heart open enough to hear the world’s softest whispers.

manga.py

@@ -0,0 +1,616 @@
+import os
+import PIL
+from io import BytesIO
+from google import genai
+from dotenv import load_dotenv
+import pathlib
+from utils import (
+    get_scene_splitting_prompt, 
+    get_panel_prompt, 
+    SCENE_BREAK_DELIMITER,
+    get_regeneration_prompt
+)
+import time
+from PIL import Image
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import A4
+import shutil
+import uuid
+import hashlib
+from typing import Dict, Optional
+
+# Load environment variables
+load_dotenv()
+
+class UserSession:
+    """Represents a user session with isolated data and API key."""
+    
+    def __init__(self, session_id: str, api_key: str):
+        self.session_id = session_id
+        self.api_key_hash = self._hash_api_key(api_key)  # Store only hash for security
+        self._api_key = api_key  # Keep encrypted or in memory only
+        self.created_at = time.time()
+        self.last_activity = time.time()
+        
+        # Session-specific directories
+        self.base_dir = os.path.join("data", "sessions", session_id)
+        self.output_dir = os.path.join(self.base_dir, "output")
+        self.user_templates_dir = os.path.join(self.base_dir, "templates")
+        self.user_references_dir = os.path.join(self.base_dir, "references")
+        
+        # Create session directories
+        os.makedirs(self.output_dir, exist_ok=True)
+        os.makedirs(self.user_templates_dir, exist_ok=True)
+        os.makedirs(self.user_references_dir, exist_ok=True)
+        
+        # Session generation data
+        self.current_generation = {
+            'scenes': [],
+            'generated_images': [],
+            'chat': None,
+            'user_preferences': {},
+            'current_template_path': os.getenv("TEMPLATE_PATH", "data/templates/template.png")
+        }
+    
+    def _hash_api_key(self, api_key: str) -> str:
+        """Create a hash of the API key for identification (not storage)."""
+        return hashlib.sha256(api_key.encode()).hexdigest()[:16]
+    
+    def get_api_key(self) -> str:
+        """Get the API key (should be implemented with proper encryption in production)."""
+        return self._api_key
+    
+    def update_activity(self):
+        """Update last activity timestamp."""
+        self.last_activity = time.time()
+    
+    def is_expired(self, timeout_hours: int = 24) -> bool:
+        """Check if session has expired."""
+        return (time.time() - self.last_activity) > (timeout_hours * 3600)
+    
+    def cleanup(self):
+        """Clean up session files and data."""
+        try:
+            if os.path.exists(self.base_dir):
+                shutil.rmtree(self.base_dir)
+            print(f"Cleaned up session: {self.session_id}")
+        except Exception as e:
+            print(f"Error cleaning up session {self.session_id}: {e}")
+
+
+class SessionManager:
+    """Manages user sessions and provides isolation between users."""
+    
+    def __init__(self):
+        self.sessions: Dict[str, UserSession] = {}
+        self.session_timeout_hours = 24
+    
+    def create_session(self, api_key: str) -> str:
+        """Create a new session for a user with their API key."""
+        session_id = str(uuid.uuid4())
+        self.sessions[session_id] = UserSession(session_id, api_key)
+        self._cleanup_expired_sessions()
+        return session_id
+    
+    def get_session(self, session_id: str) -> Optional[UserSession]:
+        """Get a session by ID, return None if not found or expired."""
+        if session_id not in self.sessions:
+            return None
+        
+        session = self.sessions[session_id]
+        if session.is_expired(self.session_timeout_hours):
+            self._remove_session(session_id)
+            return None
+        
+        session.update_activity()
+        return session
+    
+    def _remove_session(self, session_id: str):
+        """Remove and cleanup a session."""
+        if session_id in self.sessions:
+            self.sessions[session_id].cleanup()
+            del self.sessions[session_id]
+    
+    def _cleanup_expired_sessions(self):
+        """Clean up all expired sessions."""
+        expired_sessions = [
+            sid for sid, session in self.sessions.items() 
+            if session.is_expired(self.session_timeout_hours)
+        ]
+        for session_id in expired_sessions:
+            self._remove_session(session_id)
+
+
+class MangaGenerator:
+    def __init__(self, session: UserSession):
+        """Initialize the manga generator for a specific user session."""
+        self.session = session
+        self.api_key = session.get_api_key()
+        
+        # Use session-specific directories
+        self.template_path = os.getenv("TEMPLATE_PATH", "data/templates/template.png")
+        self.output_dir = session.output_dir
+        self.user_templates_dir = session.user_templates_dir
+        self.user_references_dir = session.user_references_dir
+        
+        self.image_gen_model_name = os.getenv("IMAGE_MODEL_NAME", "gemini-2.5-flash-image-preview")
+        self.scene_gen_model_name = os.getenv("SCENE_MODEL_NAME", "gemini-2.0-flash")
+        
+        # Initialize clients with session's API key
+        try:
+            self.image_gen_client = genai.Client(api_key=self.api_key)
+            self.scene_gen_client = genai.Client(api_key=self.api_key)
+        except Exception as e:
+            raise ValueError(f"Invalid API key or client initialization failed: {e}")
+
+    @property
+    def current_generation(self):
+        """Access current generation data from session."""
+        return self.session.current_generation
+
+    def save_user_template(self, uploaded_file):
+        """Save user uploaded template and return the path."""
+        if uploaded_file is None:
+            return None
+        
+        try:
+            # Generate unique filename with timestamp
+            timestamp = int(time.time())
+            filename = f"user_template_{timestamp}.png"
+            template_path = os.path.join(self.user_templates_dir, filename)
+            
+            # Handle different file input types
+            if hasattr(uploaded_file, 'name'):  # Gradio file object
+                shutil.copy2(uploaded_file.name, template_path)
+            else:
+                if isinstance(uploaded_file, str):
+                    shutil.copy2(uploaded_file, template_path)
+                elif hasattr(uploaded_file, 'save'):  # PIL Image
+                    uploaded_file.save(template_path)
+            
+            # Verify the template was saved and is a valid image
+            test_image = PIL.Image.open(template_path)
+            test_image.verify()
+            
+            print(f"User template saved to: {template_path}")
+            return template_path
+            
+        except Exception as e:
+            print(f"Error saving user template: {e}")
+            return None
+
+    def save_user_reference_image(self, uploaded_file):
+        """Save user uploaded reference image and return the path."""
+        if uploaded_file is None:
+            return None
+        
+        try:
+            timestamp = int(time.time())
+            filename = f"user_reference_{timestamp}.png"
+            reference_path = os.path.join(self.user_references_dir, filename)
+            
+            if hasattr(uploaded_file, 'name'):  # Gradio file object
+                shutil.copy2(uploaded_file.name, reference_path)
+            else:
+                if isinstance(uploaded_file, str):
+                    shutil.copy2(uploaded_file, reference_path)
+                elif hasattr(uploaded_file, 'save'):  # PIL Image
+                    uploaded_file.save(reference_path)
+            
+            test_image = PIL.Image.open(reference_path)
+            test_image.verify()
+            
+            print(f"User reference image saved to: {reference_path}")
+            return reference_path
+            
+        except Exception as e:
+            print(f"Error saving user reference image: {e}")
+            return None
+
+    def set_template_for_generation(self, template_path):
+        """Set the template to use for the current generation session."""
+        if template_path and os.path.exists(template_path):
+            self.current_generation['current_template_path'] = template_path
+            return True
+        return False
+
+    def get_current_template_path(self):
+        """Get the current template path being used."""
+        return self.current_generation.get('current_template_path', self.template_path)
+
+    def read_story(self, file_path):
+        """Read story text from file."""
+        with open(file_path, "r") as f:
+            return f.read()
+
+    def split_into_scenes(self, story_text: str, n_scenes: int):
+        """Split story into visual scenes with descriptions."""
+        prompt = get_scene_splitting_prompt(story_text, n_scenes)
+        
+        response = self.scene_gen_client.models.generate_content(
+            model=self.scene_gen_model_name,
+            contents=[prompt]
+        )
+
+        full_response_text = ""
+        for part in response.candidates[0].content.parts:
+            if part.text:
+                full_response_text += part.text
+
+        scenes = [scene.strip() for scene in full_response_text.split(SCENE_BREAK_DELIMITER)]
+        scenes = [scene for scene in scenes if scene]
+
+        return scenes[:n_scenes]
+
+    def save_image(self, response, path):
+        """Save the generated image from response."""
+        time.sleep(3)
+        for part in response.parts:
+            if image := part.as_image():
+                image.save(path)
+                return image
+        return None
+
+    def generate_image_for_scene(self, scene_description: str, output_path: str):
+        """Generate image for a single scene."""
+        current_template = self.get_current_template_path()
+        response = self.image_gen_client.models.generate_content(
+            model=self.image_gen_model_name,
+            contents=[
+                scene_description,
+                PIL.Image.open(current_template)
+            ]
+        )
+        
+        saved_image = self.save_image(response, output_path)
+        return response, saved_image
+
+    def generate_image_with_chat(self, scene_description: str, output_path: str, chat):
+        """Generate image using chat context for consistency."""
+        current_template = self.get_current_template_path()
+        response = chat.send_message([
+            scene_description,
+            PIL.Image.open(current_template)
+        ])
+        
+        saved_image = self.save_image(response, output_path)
+        return response, saved_image
+
+    def generate_image_with_chat_and_reference(self, scene_description: str, output_path: str, chat, reference_image_path=None):
+        """Generate image using chat context with optional reference image."""
+        current_template = self.get_current_template_path()
+        
+        content = [scene_description, PIL.Image.open(current_template)]
+        
+        if reference_image_path and os.path.exists(reference_image_path):
+            content.append(PIL.Image.open(reference_image_path))
+            print(f"Using reference image: {reference_image_path}")
+        
+        response = chat.send_message(content)
+        saved_image = self.save_image(response, output_path)
+        return response, saved_image
+
+    def regenerate_specific_panel(self, panel_index: int, modification_request: str, reference_image=None):
+        """Regenerate a specific panel with modifications and optional reference image."""
+        if not self.current_generation['scenes'] or not self.current_generation['chat']:
+            raise ValueError("No active generation session. Please generate manga first.")
+        
+        if panel_index >= len(self.current_generation['scenes']):
+            raise ValueError(f"Panel index {panel_index} is out of range.")
+        
+        original_scene = self.current_generation['scenes'][panel_index]
+        
+        reference_image_path = None
+        if reference_image is not None:
+            reference_image_path = self.save_user_reference_image(reference_image)
+            if reference_image_path:
+                modification_request += "\n\nIMPORTANT: Use the provided reference image as visual guidance for style, composition, or specific elements while maintaining the story's integrity."
+        
+        user_preferences = self.current_generation.get('user_preferences', {})
+        modified_prompt = get_regeneration_prompt(
+            original_scene, 
+            modification_request, 
+            is_first_panel=(panel_index == 0),
+            user_preferences=user_preferences
+        )
+        
+        current_version = self.current_generation['generated_images'][panel_index].get('version', 1)
+        output_path = os.path.join(self.output_dir, f"scene{panel_index+1}_v{current_version + 1}.png")
+        
+        response, saved_image = self.generate_image_with_chat_and_reference(
+            modified_prompt, 
+            output_path, 
+            self.current_generation['chat'],
+            reference_image_path
+        )
+        
+        return output_path, saved_image
+
+    def replace_panel(self, panel_index: int, new_image_path: str, new_image: PIL.Image):
+        """Replace a panel in the current generation."""
+        if not self.current_generation['generated_images']:
+            raise ValueError("No active generation session.")
+        
+        if panel_index >= len(self.current_generation['generated_images']):
+            raise ValueError(f"Panel index {panel_index} is out of range.")
+        
+        current_version = self.current_generation['generated_images'][panel_index].get('version', 1)
+        self.current_generation['generated_images'][panel_index].update({
+            'image_path': new_image_path,
+            'image': new_image,
+            'version': current_version + 1
+        })
+
+    def get_current_gallery_paths(self):
+        """Get current image paths for gallery display."""
+        if not self.current_generation['generated_images']:
+            return []
+        return [img['image_path'] for img in self.current_generation['generated_images']]
+
+    def generate_manga_from_story(self, story_text: str, n_scenes: int = 5, user_preferences: dict = None, user_template=None):
+        """Generate complete manga from story text with user preferences and optional custom template."""
+        if user_template is not None:
+            template_path = self.save_user_template(user_template)
+            if template_path:
+                self.set_template_for_generation(template_path)
+                print(f"Using user template: {template_path}")
+            else:
+                print("Failed to save user template, using default template")
+        
+        if user_preferences is None:
+            user_preferences = {}
+        
+        scenes = self.split_into_scenes(story_text, n_scenes)
+        
+        chat = self.image_gen_client.chats.create(model=self.image_gen_model_name)
+        
+        generated_images = []
+        responses = []
+        
+        for i, scene in enumerate(scenes):
+            scene_description = get_panel_prompt(scene, is_first_panel=(i == 0), user_preferences=user_preferences)
+            
+            output_path = os.path.join(self.output_dir, f"scene{i+1}.png")
+            response, saved_image = self.generate_image_with_chat(scene_description, output_path, chat)
+            
+            responses.append(response)
+            generated_images.append({
+                'scene_number': i + 1,
+                'scene_text': scene,
+                'image_path': output_path,
+                'image': saved_image,
+                'version': 1
+            })
+            
+            print(f"Generated scene {i+1}")
+        
+        self.current_generation.update({
+            'scenes': scenes,
+            'generated_images': generated_images,
+            'chat': chat,
+            'user_preferences': user_preferences
+        })
+        
+        return generated_images, scenes
+
+    def generate_manga_from_file(self, story_file_path: str, n_scenes: int = 5, user_preferences: dict = None, user_template=None):
+        """Generate manga from story file with user preferences and optional custom template."""
+        story_text = self.read_story(story_file_path)
+        return self.generate_manga_from_story(story_text, n_scenes, user_preferences, user_template)
+
+    def get_current_panels(self):
+        """Get current panel information for the interface."""
+        if not self.current_generation['generated_images']:
+            return []
+        
+        return [(i+1, img['image_path']) for i, img in enumerate(self.current_generation['generated_images'])]
+
+    def create_manga_pdf(self, output_filename=None):
+        """Create a PDF file from all current manga panels."""
+        if not self.current_generation['generated_images']:
+            raise ValueError("No manga panels to export. Please generate manga first.")
+        
+        if output_filename is None:
+            output_filename = os.path.join(self.output_dir, "manga_complete.pdf")
+        
+        c = canvas.Canvas(output_filename, pagesize=A4)
+        page_width, page_height = A4
+        
+        c.setFont("Helvetica-Bold", 24)
+        title_text = "Generated Manga"
+        title_width = c.stringWidth(title_text, "Helvetica-Bold", 24)
+        c.drawString((page_width - title_width) / 2, page_height - 100, title_text)
+        
+        c.setFont("Helvetica", 12)
+        subtitle_text = f"Total Panels: {len(self.current_generation['generated_images'])}"
+        subtitle_width = c.stringWidth(subtitle_text, "Helvetica", 12)
+        c.drawString((page_width - subtitle_width) / 2, page_height - 130, subtitle_text)
+        
+        current_template = self.get_current_template_path()
+        if current_template != self.template_path:
+            template_info = "Custom Template Used"
+            template_width = c.stringWidth(template_info, "Helvetica", 12)
+            c.drawString((page_width - template_width) / 2, page_height - 150, template_info)
+        
+        c.showPage()
+        
+        for i, panel_data in enumerate(self.current_generation['generated_images']):
+            image_path = panel_data['image_path']
+            
+            if os.path.exists(image_path):
+                img = Image.open(image_path)
+                
+                img_width, img_height = img.size
+                aspect_ratio = img_width / img_height
+                
+                max_width = page_width - 100
+                max_height = page_height - 150
+                
+                if aspect_ratio > 1:
+                    new_width = min(max_width, img_width)
+                    new_height = new_width / aspect_ratio
+                else:
+                    new_height = min(max_height, img_height)
+                    new_width = new_height * aspect_ratio
+                
+                x = (page_width - new_width) / 2
+                y = (page_height - new_height) / 2
+                
+                c.drawImage(image_path, x, y, width=new_width, height=new_height)
+                
+                c.setFont("Helvetica", 10)
+                c.drawString(50, page_height - 30, f"Panel {i + 1}")
+                
+                c.showPage()
+        
+        c.save()
+        print(f"PDF saved to: {output_filename}")
+        return output_filename
+
+
+# Global session manager
+_session_manager = SessionManager()
+
+def get_session_manager() -> SessionManager:
+    """Get the global session manager."""
+    return _session_manager
+
+def get_generator_for_session(session_id: str) -> Optional[MangaGenerator]:
+    """Get a manga generator for a specific session."""
+    session = _session_manager.get_session(session_id)
+    if session is None:
+        return None
+    return MangaGenerator(session)
+
+def create_user_session(api_key: str) -> str:
+    """Create a new user session with API key."""
+    if not api_key or not api_key.strip():
+        raise ValueError("API key is required")
+    return _session_manager.create_session(api_key.strip())
+
+# Interface functions with session support
+def generate_manga_interface(session_id: str, story_text: str, num_scenes: int = 5, art_style: str = None, mood: str = None, 
+                           color_palette: str = None, character_style: str = None, line_style: str = None,
+                           composition: str = None, additional_notes: str = "", user_template=None):
+    """Interface function for Gradio - generates manga from text input with session support."""
+    try:
+        generator = get_generator_for_session(session_id)
+        if generator is None:
+            return [], "Session expired or invalid. Please refresh and enter your API key again."
+        
+        user_preferences = {}
+        if art_style and art_style != "None":
+            user_preferences['art_style'] = art_style
+        if mood and mood != "None":
+            user_preferences['mood'] = mood
+        if color_palette and color_palette != "None":
+            user_preferences['color_palette'] = color_palette
+        if character_style and character_style != "None":
+            user_preferences['character_style'] = character_style
+        if line_style and line_style != "None":
+            user_preferences['line_style'] = line_style
+        if composition and composition != "None":
+            user_preferences['composition'] = composition
+        if additional_notes.strip():
+            user_preferences['additional_notes'] = additional_notes.strip()
+        
+        generated_images, scenes = generator.generate_manga_from_story(story_text, num_scenes, user_preferences, user_template)
+        
+        image_paths = [img['image_path'] for img in generated_images]
+        scene_descriptions = [img['scene_text'] for img in generated_images]
+        
+        return image_paths, "\n\n".join([f"Scene {i+1}: {scene}" for i, scene in enumerate(scene_descriptions)])
+    except Exception as e:
+        print(f"Error generating manga: {e}")
+        return [], f"Error: {str(e)}"
+
+def generate_manga_from_file_interface(session_id: str, story_file, num_scenes: int = 5, art_style: str = None, mood: str = None,
+                                     color_palette: str = None, character_style: str = None, line_style: str = None,
+                                     composition: str = None, additional_notes: str = "", user_template=None):
+    """Interface function for Gradio - generates manga from uploaded file with session support."""
+    try:
+        generator = get_generator_for_session(session_id)
+        if generator is None:
+            return [], "Session expired or invalid. Please refresh and enter your API key again."
+        
+        if hasattr(story_file, 'name'):  # Gradio file object
+            with open(story_file.name, 'r') as f:
+                story_text = f.read()
+        else:
+            story_text = str(story_file)
+        
+        user_preferences = {}
+        if art_style and art_style != "None":
+            user_preferences['art_style'] = art_style
+        if mood and mood != "None":
+            user_preferences['mood'] = mood
+        if color_palette and color_palette != "None":
+            user_preferences['color_palette'] = color_palette
+        if character_style and character_style != "None":
+            user_preferences['character_style'] = character_style
+        if line_style and line_style != "None":
+            user_preferences['line_style'] = line_style
+        if composition and composition != "None":
+            user_preferences['composition'] = composition
+        if additional_notes.strip():
+            user_preferences['additional_notes'] = additional_notes.strip()
+            
+        generated_images, scenes = generator.generate_manga_from_story(story_text, num_scenes, user_preferences, user_template)
+        
+        image_paths = [img['image_path'] for img in generated_images]
+        scene_descriptions = [img['scene_text'] for img in generated_images]
+        
+        return image_paths, "\n\n".join([f"Scene {i+1}: {scene}" for i, scene in enumerate(scene_descriptions)])
+    except Exception as e:
+        print(f"Error generating manga: {e}")
+        return [], f"Error: {str(e)}"
+
+def regenerate_and_replace_interface(session_id: str, panel_number: int, modification_request: str, replace_original: bool, reference_image=None):
+    """Interface function for Gradio - regenerate panel with session support."""
+    try:
+        generator = get_generator_for_session(session_id)
+        if generator is None:
+            return "Session expired or invalid. Please refresh and enter your API key again.", None, []
+        
+        if not modification_request.strip():
+            return "Please provide modification instructions.", None, []
+        
+        panel_index = panel_number - 1
+        new_image_path, saved_image = generator.regenerate_specific_panel(panel_index, modification_request, reference_image)
+        
+        updated_gallery = []
+        if replace_original and generator.current_generation['generated_images']:
+            generator.replace_panel(panel_index, new_image_path, saved_image)
+            updated_gallery = generator.get_current_gallery_paths()
+            status_message = f"Panel {panel_number} regenerated and replaced successfully!"
+        else:
+            status_message = f"Panel {panel_number} regenerated successfully! (Original preserved)"
+        
+        return status_message, new_image_path, updated_gallery
+        
+    except Exception as e:
+        return f"Error regenerating panel: {e}", None, []
+
+def create_pdf_interface(session_id: str):
+    """Interface function for Gradio - create PDF with session support."""
+    try:
+        generator = get_generator_for_session(session_id)
+        if generator is None:
+            return "Session expired or invalid. Please refresh and enter your API key again.", None
+        
+        if not generator.current_generation['generated_images']:
+            return "No manga panels to export. Please generate manga first.", None
+        
+        pdf_path = generator.create_manga_pdf()
+        message = f"PDF created successfully! ({len(generator.current_generation['generated_images'])} panels)"
+        
+        return message, pdf_path
+    except Exception as e:
+        return f"Error creating PDF: {e}", None
+
+def get_current_panels(session_id: str):
+    """Get current panel information for the interface with session support."""
+    generator = get_generator_for_session(session_id)
+    if generator is None:
+        return []
+    return generator.get_current_panels()

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "MangakAI"
+version = "0.1.0"
+description = "Transform your imagination into visual stories with the power of AI!"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "google-genai>=1.33.0",
+    "gradio>=5.44.1",
+    "pillow>=11.3.0",
+    "python-dotenv>=1.1.1",
+    "reportlab>=4.4.3",
+]

requirements.txt

@@ -0,0 +1,5 @@
+google-genai>=1.33.0
+gradio>=5.44.1
+pillow>=11.3.0
+python-dotenv>=1.1.1
+reportlab>=4.4.3

utils.py

@@ -0,0 +1,238 @@
+"""
+Utility functions and prompt templates for manga generation.
+"""
+
+def get_scene_splitting_prompt(story_text: str, n_scenes: int) -> str:
+    """Generate the prompt for splitting a story into scenes."""
+    return f"""
+    Act as a master film director and veteran comic book artist, with an exceptional eye for cinematic composition and dramatic effect. Your task is to read the following story and transmute it into {n_scenes} distinct, visually-dense scene descriptions, including key dialogues and a reference to the original text.
+
+    The goal is to create a powerful visual description for each scene that can be used directly as a prompt for an AI image generator, while also capturing the most important lines spoken and preserving the source text.
+
+    **STORY:**
+    {story_text}
+
+    ---
+
+    **CRITICAL INSTRUCTIONS FOR EACH SCENE'S DESCRIPTION:**
+    - **Reference the Source:** In the 'Original Scene Text' field, you must include the exact, unaltered passage from the story that you are adapting for this scene.
+    - **Be the Camera:** Describe the scene as if looking through a camera lens. Explicitly mention the shot type (e.g., wide shot, extreme close-up, over-the-shoulder), camera angle, and the composition of elements.
+    - **Paint the Atmosphere:** Weave together the setting, time of day, weather, and mood. Use lighting (e.g., "harsh neon glare," "soft morning light," "dramatic chiaroscuro shadows") to establish the tone.
+    - **Focus on the Subject:** Detail the characters' specific poses, actions, and intense facial expressions. Describe their clothing and how it interacts with their actions and the environment (e.g., "a rain-soaked cloak clinging to their frame," "wind-whipped hair").
+    - **Emphasize the Core Moment:** Ensure the description builds towards the single most important visual element, action, or emotional beat in the scene.
+    - **Isolate Key Dialogue:** If the scene contains crucial, plot-advancing dialogue, extract the most impactful line(s) verbatim.
+
+    **OUTPUT FORMAT:**
+    You must use the following format. Separate each scene block with '---SCENE_BREAK---'.
+
+    **Scene:** [Scene Number]
+    **Original Scene Text:** [The exact, unaltered passage from the story for this scene.]
+    **Visual Description:** [A single, comprehensive paragraph combining all the visual instructions. This must be a self-contained prompt for an image model. **DO NOT include dialogue here**.]
+    **Key Dialogue:** [The most important line(s) of dialogue from the scene. If there is no dialogue, write 'None'.]
+    ---SCENE_BREAK---
+    """
+
+def get_first_panel_prompt(scene: str, user_preferences: dict = None) -> str:
+    """Generate the prompt for the first manga panel."""
+    style_instructions = get_style_instructions(user_preferences) if user_preferences else ""
+    
+    return f"""
+    **Act as a master mangaka creating the first panel of a new manga.**
+
+    **YOUR TASK:** Create a visually stunning manga page based on the scene description below. You have two creative options:
+
+    1.  **USE A TEMPLATE:** Choose ONE of the three provided panel templates. Your illustration must perfectly integrate into the chosen panel's borders, using its layout as the foundation for a dynamic composition.
+    
+    2.  **CREATE A SPLASH PAGE:** If the scene is a powerful establishing shot or a highly dramatic moment, you may ignore the templates and create a full-page, borderless splash image that captures the full impact of the scene.
+
+    **CRITICAL:** You must adhere strictly to the visual details in the scene description.
+    - **Style:** The art style, line weight, and shading must remain consistent.
+    - **Original Story:** Do not deviate from the original story text. Every scene must accurately reflect the source material as well.
+    - **Ensure that there is no repetition of scenes. Each panel must advance the story.**
+    - **If the scene contains dialogue, include the exact lines in speech bubbles.**
+    - **Create multiple panels per page to maintain pacing.**
+    - **Include good story narration boxes so the reader can follow the story.**
+
+    {style_instructions}
+    
+    ---
+    **SCENE DESCRIPTION:**
+    {scene}
+    """
+
+def get_subsequent_panel_prompt(scene: str, user_preferences: dict = None) -> str:
+    """Generate the prompt for subsequent manga panels."""
+    style_instructions = get_style_instructions(user_preferences) if user_preferences else ""
+    
+    return f"""
+    **Act as a master mangaka continuing a manga sequence.**
+
+    **YOUR TASK:** Create the next manga page, ensuring it flows perfectly from the previous panel. You have two creative options:
+
+    1.  **USE A TEMPLATE:** Choose ONE of the three provided panel templates to best fit the action. Your illustration must integrate perfectly into the chosen panel's borders.
+    
+    2.  **CREATE A SPLASH PAGE:** If this scene is a major climax or a dramatic shift, you may ignore the templates and create a full-page, borderless splash image.
+
+    **CRITICAL - MAINTAIN VISUAL CONTINUITY:**
+    - **Characters:** Must have the exact same appearance, clothing, and features as the previous panel.
+    - **Style:** The art style, line weight, and shading must remain consistent.
+    - **Environment:** The setting and lighting must logically follow the previous panel.
+    - **Original Story:** Do not deviate from the original story text. Every scene must accurately reflect the source material as well.
+    - **Ensure that there is no repetition of scenes. Each panel must advance the story.**
+    - **If the scene contains dialogue, include the exact lines in speech bubbles.**
+    - **Create multiple panels per page to maintain pacing.**
+    - **Include good story narration boxes so the reader can follow the story.**
+
+    {style_instructions}
+    
+    ---
+    **SCENE DESCRIPTION:**
+    {scene}
+    """
+
+def get_panel_prompt(scene: str, is_first_panel: bool = False, user_preferences: dict = None) -> str:
+    """Get the appropriate panel prompt based on whether it's the first panel or not."""
+    if is_first_panel:
+        return get_first_panel_prompt(scene, user_preferences)
+    else:
+        return get_subsequent_panel_prompt(scene, user_preferences)
+
+def get_regeneration_prompt(original_scene: str, modification_request: str, is_first_panel: bool = False, user_preferences: dict = None) -> str:
+    """Generate prompt for regenerating a panel with modifications."""
+    base_instruction = get_first_panel_prompt(original_scene, user_preferences) if is_first_panel else get_subsequent_panel_prompt(original_scene, user_preferences)
+    
+    return f"""
+    {base_instruction}
+
+    ---
+    **MODIFICATION REQUEST:**
+    The user has requested the following changes to this panel:
+    {modification_request}
+
+    **CRITICAL:** Incorporate these modifications while maintaining all other aspects of the original scene description and ensuring visual continuity with the manga sequence.
+    """
+
+def get_style_instructions(user_preferences: dict) -> str:
+    """Generate style instructions based on user preferences."""
+    if not user_preferences:
+        return ""
+    
+    instructions = "\n**USER STYLE PREFERENCES:**"
+    
+    if user_preferences.get('art_style'):
+        instructions += f"\n- **Art Style:** {user_preferences['art_style']}"
+    
+    if user_preferences.get('mood'):
+        instructions += f"\n- **Overall Mood:** {user_preferences['mood']}"
+    
+    if user_preferences.get('color_palette'):
+        instructions += f"\n- **Color Palette:** {user_preferences['color_palette']}"
+    
+    if user_preferences.get('character_style'):
+        instructions += f"\n- **Character Design:** {user_preferences['character_style']}"
+    
+    if user_preferences.get('line_style'):
+        instructions += f"\n- **Line Art Style:** {user_preferences['line_style']}"
+    
+    if user_preferences.get('composition'):
+        instructions += f"\n- **Composition Preference:** {user_preferences['composition']}"
+    
+    if user_preferences.get('additional_notes'):
+        instructions += f"\n- **Additional Notes:** {user_preferences['additional_notes']}"
+    
+    instructions += "\n\n**CRITICAL:** Incorporate ALL these style preferences while maintaining the story integrity, visual continuity, and all the requirements above."
+    
+    return instructions
+
+# Constants
+SCENE_BREAK_DELIMITER = "---SCENE_BREAK---"
+
+# Pre-defined style options for the interface
+ART_STYLES = [
+    "Traditional Manga/Anime",
+    "Shonen (Bold, Dynamic)",
+    "Shoujo (Soft, Romantic)",
+    "Seinen (Mature, Detailed)",
+    "Chibi (Cute, Simplified)",
+    "Realistic",
+    "Semi-Realistic",
+    "Minimalist",
+    "Dark/Gothic",
+    "Cyberpunk",
+    "Fantasy",
+    "Horror",
+    "Comedy/Cartoon"
+]
+
+MOOD_OPTIONS = [
+    "Epic/Heroic",
+    "Dark/Mysterious",
+    "Light/Cheerful",
+    "Dramatic/Intense",
+    "Romantic",
+    "Action-Packed",
+    "Peaceful/Serene",
+    "Suspenseful",
+    "Melancholic",
+    "Whimsical"
+]
+
+COLOR_PALETTES = [
+    "Full Color",
+    "Black and White",
+    "Sepia/Vintage",
+    "Monochromatic Blue",
+    "Monochromatic Red",
+    "Warm Tones",
+    "Cool Tones",
+    "High Contrast",
+    "Pastel Colors",
+    "Neon/Vibrant"
+]
+
+CHARACTER_STYLES = [
+    "Detailed/Realistic",
+    "Stylized/Expressive",
+    "Simple/Clean",
+    "Muscular/Athletic",
+    "Elegant/Graceful",
+    "Cute/Moe",
+    "Mature/Adult",
+    "Young/Teen",
+    "Fantasy/Otherworldly"
+]
+
+LINE_STYLES = [
+    "Clean/Precise",
+    "Rough/Sketchy",
+    "Bold/Thick",
+    "Fine/Delicate",
+    "Variable Weight",
+    "Minimalist",
+    "Detailed/Complex"
+]
+
+COMPOSITION_STYLES = [
+    "Dynamic/Action",
+    "Balanced/Stable",
+    "Asymmetrical",
+    "Close-up Focus",
+    "Wide/Environmental",
+    "Dramatic Angles",
+    "Traditional/Conservative"
+]
+
+# Optional: Additional utility functions for prompt customization
+def customize_scene_prompt(base_prompt: str, **kwargs) -> str:
+    """Allow for dynamic prompt customization if needed."""
+    return base_prompt.format(**kwargs)
+
+def get_style_modifiers() -> dict:
+    """Return common style modifiers that can be added to prompts."""
+    return {
+        "manga_style": "in traditional manga/anime art style with clean line art and dynamic compositions",
+        "dark_theme": "with dark, moody atmosphere and dramatic shadows",
+        "action_focus": "emphasizing dynamic action and movement",
+        "character_focus": "with detailed character expressions and emotions",
+        "cinematic": "with cinematic camera angles and professional composition"
+    }