Rename app.py to story_to_comic.py

app.py

@@ -1,68 +0,0 @@
-import gradio as gr
-import requests
-import base64
-import os
-import time
-
-# Get your Hugging Face access token from the secrets
-HUGGING_FACE_API_KEY = os.getenv("onteddu")  # Ensure your access token is properly set
-
-def generate_images_from_text(text):
-    # Generate an image using Hugging Face's API
-    headers = {
-        "Authorization": f"Bearer {HUGGING_FACE_API_KEY}"
-    }
-    
-    response = requests.post(
-        "https://api-inference.huggingface.co/models/brushpenbob/flux-midjourney-anime",  # Correct model name
-        headers=headers,
-        json={"inputs": text}
-    )
-    
-    if response.status_code == 200:
-        # The API response contains the image as raw binary data
-        image_data = response.content
-        
-        # Convert the image to Base64 for embedding in HTML
-        base64_image = base64.b64encode(image_data).decode('utf-8')
-        return f"data:image/png;base64,{base64_image}"
-    else:
-        print(f"Error generating image: {response.text}")
-        return None
-
-def generate_comic(short_story):
-    sentences = short_story.split('. ')
-    images = []
-
-    for sentence in sentences:
-        if sentence.strip():
-            try:
-                # Generate one image for each sentence
-                image_data = generate_images_from_text(sentence)
-                if image_data:
-                    images.append(image_data)
-
-                # Sleep for a short duration to avoid hitting rate limits
-                time.sleep(2)  # Adjust this time if needed
-
-            except Exception as e:
-                print(f"Error generating image: {e}")
-
-    # Create comic HTML with reduced image sizes and panel layout
-    comic_html = '<div style="display: flex; flex-wrap: wrap;">'
-    for img in images:
-        comic_html += f'<div style="flex: 1; margin: 5px;"><img src="{img}" style="max-width: 300px; max-height: 300px;" /></div>'
-    comic_html += '</div>'
-    
-    return comic_html
-
-# Gradio interface
-iface = gr.Interface(
-    fn=generate_comic,
-    inputs=gr.Textbox(label="Your Short Story", lines=10, placeholder="Enter your short story here..."),
-    outputs=gr.HTML(label="Generated Comic"),
-    title="Narrative to Comic Generator",
-    description="Enter a short story, and the app will generate a comic-style storybook with images and dialogues."
-)
-
-iface.launch()

story_to_comic.py

@@ -0,0 +1,145 @@
+import os
+import requests
+import gradio as gr
+import nltk
+from nltk.tokenize import sent_tokenize
+from io import BytesIO
+from PIL import Image
+import base64
+
+# Ensure NLTK's punkt tokenizer is downloaded
+nltk.download('punkt')
+
+# Function to generate image from a prompt using Hugging Face's API
+def generate_image(prompt, api_key, model="stabilityai/stable-diffusion-2"):
+    """
+    Generates an image from a text prompt using Hugging Face's Inference API.
+
+    Args:
+        prompt (str): The text prompt to generate the image.
+        api_key (str): Hugging Face API key for authentication.
+        model (str): The Hugging Face model to use for generation.
+
+    Returns:
+        Image object if successful, None otherwise.
+    """
+    API_URL = f"https://api-inference.huggingface.co/models/{model}"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    
+    payload = {
+        "inputs": prompt,
+        "options": {
+            "use_gpu": True  # Optional: Use GPU if available
+        }
+    }
+    
+    response = requests.post(API_URL, headers=headers, json=payload, stream=True)
+    
+    if response.status_code == 200:
+        try:
+            # Hugging Face returns the image directly
+            image = Image.open(BytesIO(response.content))
+            return image
+        except Exception as e:
+            print(f"Error processing image: {e}")
+            return None
+    else:
+        print(f"Error {response.status_code}: {response.text}")
+        return None
+
+# Main function to process the story and generate images
+def story_to_comic(story, api_key):
+    """
+    Processes the input story, generates comic-style images for each sentence,
+    and returns them for display.
+
+    Args:
+        story (str): The input short story.
+        api_key (str): Hugging Face API key for authentication.
+
+    Returns:
+        List of images or error message.
+    """
+    if not api_key:
+        return "🔒 Hugging Face API key is required. Please enter your API key."
+
+    # Split the story into sentences
+    sentences = sent_tokenize(story)
+    
+    if not sentences:
+        return "❌ No valid sentences found in the input story."
+
+    images = []
+    for idx, sentence in enumerate(sentences, 1):
+        # Customize the prompt for comic-style images
+        prompt = f"A vibrant comic-style illustration of: {sentence}"
+        print(f"Generating image for sentence {idx}: {sentence}")
+        
+        image = generate_image(prompt, api_key)
+        if image:
+            # Convert PIL Image to a format compatible with Gradio Gallery
+            buffered = BytesIO()
+            image.save(buffered, format="PNG")
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            img_data = f"data:image/png;base64,{img_str}"
+            images.append([img_data])  # Each image should be in its own list for Gallery
+        else:
+            # Placeholder for failed image generation
+            images.append([None])
+
+    return images
+
+# Gradio Interface
+def create_interface():
+    """
+    Creates and returns the Gradio interface.
+    """
+    with gr.Blocks() as demo:
+        gr.Markdown("# 📚 Story to Comic Generator")
+        gr.Markdown(
+            """
+            **Enter a short story**, and this tool will generate a **comic-style image** for each sentence in your story.
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                story_input = gr.Textbox(
+                    label="📝 Enter Your Short Story",
+                    placeholder="Once upon a time in a land far away...",
+                    lines=10
+                )
+                api_key_input = gr.Textbox(
+                    label="🔑 Hugging Face API Key",
+                    placeholder="Enter your Hugging Face API key here",
+                    type="password"
+                )
+                generate_button = gr.Button("🎨 Generate Comic")
+            with gr.Column(scale=2):
+                gallery = gr.Gallery(
+                    label="📖 Generated Comic Panels",
+                    show_label=True,
+                    columns=[1],
+                    object_fit="contain",
+                    height="auto"
+                ).style(grid=[1], height="auto")
+        
+        generate_button.click(
+            fn=story_to_comic,
+            inputs=[story_input, api_key_input],
+            outputs=gallery
+        )
+        
+        gr.Markdown(
+            """
+            ---
+            **Need a Hugging Face API Key?**  
+            Visit [Hugging Face Tokens](https://huggingface.co/settings/tokens) to create one.
+            """
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()