Create app.py

app.py

@@ -0,0 +1,95 @@
+import os
+import asyncio
+from concurrent.futures import ProcessPoolExecutor
+from io import BytesIO
+from PIL import Image
+from diffusers import StableDiffusionPipeline
+import gradio as gr
+from generate_prompts import generate_prompt
+
+# Load the model once at the start
+print("Loading the Stable Diffusion model...")
+try:
+    model = StableDiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo")
+    print("Model loaded successfully.")
+except Exception as e:
+    print(f"Error loading model: {e}")
+    model = None
+
+def generate_image(prompt, prompt_name):
+    try:
+        if model is None:
+            raise ValueError("Model not loaded properly.")
+        
+        print(f"Generating image for {prompt_name} with prompt: {prompt}")
+        output = model(prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
+        print(f"Model output for {prompt_name}: {output}")
+
+        if output is None:
+            raise ValueError(f"Model returned None for {prompt_name}")
+
+        if hasattr(output, 'images') and output.images:
+            print(f"Image generated for {prompt_name}")
+            image = output.images[0]
+            buffered = BytesIO()
+            image.save(buffered, format="JPEG")
+            image_bytes = buffered.getvalue()
+            return image_bytes
+        else:
+            print(f"No images found in model output for {prompt_name}")
+            raise ValueError(f"No images found in model output for {prompt_name}")
+    except Exception as e:
+        print(f"An error occurred while generating image for {prompt_name}: {e}")
+        return None
+
+async def queue_api_calls(sentence_mapping, character_dict, selected_style):
+    print("Starting to queue API calls...")
+    prompts = []
+    for paragraph_number, sentences in sentence_mapping.items():
+        combined_sentence = " ".join(sentences)
+        prompt = generate_prompt(combined_sentence, sentence_mapping, character_dict, selected_style)
+        prompts.append((paragraph_number, prompt))
+        print(f"Generated prompt for paragraph {paragraph_number}: {prompt}")
+
+    loop = asyncio.get_running_loop()
+    with ProcessPoolExecutor() as pool:
+        tasks = [
+            loop.run_in_executor(pool, generate_image, prompt, f"Prompt {paragraph_number}")
+            for paragraph_number, prompt in prompts
+        ]
+        responses = await asyncio.gather(*tasks)
+    
+    images = {paragraph_number: response for (paragraph_number, _), response in zip(prompts, responses)}
+    print("Finished queuing API calls. Generated images: ", images)
+    return images
+
+def process_prompt(sentence_mapping, character_dict, selected_style):
+    print("Processing prompt...")
+    print(f"Sentence Mapping: {sentence_mapping}")
+    print(f"Character Dict: {character_dict}")
+    print(f"Selected Style: {selected_style}")
+    try:
+        loop = asyncio.get_running_loop()
+        print("Using existing event loop.")
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        print("Created new event loop.")
+
+    cmpt_return = loop.run_until_complete(queue_api_calls(sentence_mapping, character_dict, selected_style))
+    print("Prompt processing complete. Generated images: ", cmpt_return)
+    return cmpt_return
+
+gradio_interface = gr.Interface(
+    fn=process_prompt,
+    inputs=[
+        gr.JSON(label="Sentence Mapping"),
+        gr.JSON(label="Character Dict"),
+        gr.Dropdown(["oil painting", "sketch", "watercolor"], label="Selected Style")
+    ],
+    outputs="json"
+).queue(default_concurrency_limit=20)  # Set concurrency limit if needed
+
+if __name__ == "__main__":
+    print("Launching Gradio interface...")
+    gradio_interface.launch()