Update app.py

app.py

@@ -1,7 +1,8 @@
-import asyncio
 import gradio as gr
 from diffusers import AutoPipelineForText2Image
-from generate_prompts import generate_prompt
+from io import BytesIO
+import asyncio
+from generate_propmts import generate_prompt
 
 # Load the model once outside of the function
 model = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo")
@@ -9,61 +10,69 @@ model = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo")
 async def generate_image(prompt, prompt_name):
     try:
         print(f"Generating image for {prompt_name}")
-        output = await model(prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
-        image = output.images[0]
-        img_bytes = image.tobytes()
-        print(f"Image bytes length for {prompt_name}: {len(img_bytes)}")
-        return img_bytes
+        output = await asyncio.to_thread(model, prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
+
+        # Check if the model returned images
+        if isinstance(output.images, list) and len(output.images) > 0:
+            image = output.images[0]
+            buffered = BytesIO()
+            try:
+                image.save(buffered, format="JPEG")
+                image_bytes = buffered.getvalue()
+                print(f"Image bytes length for {prompt_name}: {len(image_bytes)}")
+                return image_bytes
+            except Exception as e:
+                print(f"Error saving image for {prompt_name}: {e}")
+                return None
+        else:
+            raise Exception(f"No images returned by the model for {prompt_name}.")
     except Exception as e:
         print(f"Error generating image for {prompt_name}: {e}")
         return None
 
-async def queue_image_calls(prompts):
-    tasks = [generate_image(prompts[i], f"Prompt {i}") for i in range(len(prompts))]
-    responses = await asyncio.gather(*tasks)
-    return responses
+async def process_prompt(sentence_mapping, character_dict, selected_style):
+    images = {}
+    print(f'sentence_mapping: {sentence_mapping}, character_dict: {character_dict}, selected_style: {selected_style}')
+    prompts = []
 
-def async_image_generation(prompts):
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    results = loop.run_until_complete(queue_image_calls(prompts))
-    return results
+    # Generate prompts for each paragraph
+    for paragraph_number, sentences in sentence_mapping.items():
+        combined_sentence = " ".join(sentences)
+        prompt = generate_prompt(combined_sentence, character_dict, selected_style)
+        prompts.append((paragraph_number, prompt))
+        print(f"Generated prompt for paragraph {paragraph_number}: {prompt}")
 
-def gradio_interface(sentence_mapping, character_dict, selected_style):
-    prompts = generate_prompt(sentence_mapping, character_dict, selected_style)
-    image_bytes_list = async_image_generation(prompts)
-    outputs = [gr.Image.update(value=img_bytes) if img_bytes else gr.Image.update(value=None) for img_bytes in image_bytes_list]
-    return outputs
+    print(f'prompts: {prompts}')
+    # Create tasks for all prompts and run them concurrently
+    tasks = [generate_image(prompt, f"Prompt {paragraph_number}") for paragraph_number, prompt in prompts]
+    print(f'tasks: {tasks}')
+    results = await asyncio.gather(*tasks)
 
-# Gradio Interface
-def update_images(sentence_mapping, character_dict, selected_style):
-    prompts = generate_prompt(sentence_mapping, character_dict, selected_style)
-    image_bytes_list = async_image_generation(prompts)
-    return image_bytes_list
+    # Map results back to paragraphs
+    for i, (paragraph_number, _) in enumerate(prompts):
+        if i < len(results):
+            images[paragraph_number] = results[i]
+        else:
+            print(f"Error: No result for paragraph {paragraph_number}")
 
-with gr.Blocks() as demo:
-    sentence_mapping_input = gr.Textbox(label="Sentence Mapping")
-    character_dict_input = gr.Textbox(label="Character Dictionary")
-    selected_style_input = gr.Textbox(label="Selected Style")
-    
-    output_images = gr.Gallery(label="Generated Images")
+    return images
 
-    def generate_and_update_images(sentence_mapping, character_dict, selected_style):
-        image_bytes_list = update_images(sentence_mapping, character_dict, selected_style)
-        return [gr.Image.update(value=img_bytes) if img_bytes else gr.Image.update(value=None) for img_bytes in image_bytes_list]
+# Helper function to generate a prompt based on the input
+def generate_prompt(combined_sentence, character_dict, selected_style):
+    characters = " ".join([" ".join(character) if isinstance(character, list) else character for character in character_dict.values()])
+    return f"Make an illustration in {selected_style} style from: {characters}. {combined_sentence}"
 
-    sentence_mapping_input.change(fn=generate_and_update_images, 
-                                  inputs=[sentence_mapping_input, character_dict_input, selected_style_input],
-                                  outputs=output_images)
-    character_dict_input.change(fn=generate_and_update_images, 
-                                inputs=[sentence_mapping_input, character_dict_input, selected_style_input],
-                                outputs=output_images)
-    selected_style_input.change(fn=generate_and_update_images, 
-                                inputs=[sentence_mapping_input, character_dict_input, selected_style_input],
-                                outputs=output_images)
+# Gradio interface with high concurrency limit
+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",
+    concurrency_limit=20  # Set a high concurrency limit
+).queue(default_concurrency_limit=20)
 
 if __name__ == "__main__":
-    demo.launch()
+    gradio_interface.launch()