Update app.py

app.py

@@ -1,23 +1,19 @@
-import asyncio
+import os
+import multiprocessing
 from generate_prompts import generate_prompt
 from diffusers import AutoPipelineForText2Image
 from io import BytesIO
 import gradio as gr
-import anyio
+import json
 
-# Asynchronously load the model once outside of the function
-model = None
-
-async def load_model():
+# Define a function to initialize the model. This will be called in each process.
+def initialize_model():
     global model
     print("Loading the model...")
     model = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo")
     print("Model loaded successfully.")
 
-# Run the model loading
-asyncio.run(load_model())
-
-async def generate_image(prompt, prompt_name):
+def generate_image(prompt, prompt_name):
     try:
         print(f"Generating response for {prompt_name} with prompt: {prompt}")
         output = model(prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
@@ -31,50 +27,40 @@ async def generate_image(prompt, prompt_name):
                 image.save(buffered, format="JPEG")
                 image_bytes = buffered.getvalue()
                 print(f"Image bytes length for {prompt_name}: {len(image_bytes)}")
-                return image_bytes
+                return prompt_name, image_bytes
             except Exception as e:
                 print(f"Error saving image for {prompt_name}: {e}")
-                return None
+                return prompt_name, 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
+        return prompt_name, None
 
-async def queue_api_calls(sentence_mapping, character_dict, selected_style):
-    print(f"queue_api_calls invoked with sentence_mapping: {sentence_mapping}, character_dict: {character_dict}, selected_style: {selected_style}")
+def process_prompts(sentence_mapping, character_dict, selected_style):
+    print(f"process_prompts called with sentence_mapping: {sentence_mapping}, character_dict: {character_dict}, selected_style: {selected_style}")
+    
     prompts = []
-
-    # Generate prompts for each paragraph
     for paragraph_number, sentences in sentence_mapping.items():
         combined_sentence = " ".join(sentences)
         print(f"combined_sentence for paragraph {paragraph_number}: {combined_sentence}")
-        prompt = generate_prompt(combined_sentence, character_dict, selected_style)  # Correct prompt generation
+        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}")
 
-    # Generate images for each prompt in parallel
-    tasks = [generate_image(prompt, f"Prompt {paragraph_number}") for paragraph_number, prompt in prompts]
-    print("Tasks created for image generation.")
-    responses = await asyncio.gather(*tasks)
-    print("Responses received from image generation tasks.")
+    with multiprocessing.Pool(initializer=initialize_model) as pool:
+        tasks = [(prompt, f"Prompt {paragraph_number}") for paragraph_number, prompt in prompts]
+        results = pool.starmap(generate_image, tasks)
 
-    images = {paragraph_number: response for (paragraph_number, _), response in zip(prompts, responses)}
+    images = {prompt_name: image for prompt_name, image in results}
     print(f"Images generated: {images}")
     return images
 
 def process_prompt(sentence_mapping, character_dict, selected_style):
-    print(f"process_prompt called with sentence_mapping: {sentence_mapping}, character_dict: {character_dict}, selected_style: {selected_style}")
-    
-    async def run_async():
-        async with anyio.create_task_group() as task_group:
-            return await task_group.start(queue_api_calls, sentence_mapping, character_dict, selected_style)
-    
-    cmpt_return = anyio.run(run_async)
-    print(f"process_prompt completed with return value: {cmpt_return}")
-    return cmpt_return
+    sentence_mapping = json.loads(sentence_mapping)
+    character_dict = json.loads(character_dict)
+    return process_prompts(sentence_mapping, character_dict, selected_style)
 
-# Gradio interface with high concurrency limit
 gradio_interface = gr.Interface(
     fn=process_prompt,
     inputs=[