Update app.py

app.py

@@ -4,39 +4,67 @@ from generate_prompts import generate_prompt
 from diffusers import AutoPipelineForText2Image
 from io import BytesIO
 import gradio as gr
+import threading
 
 # Load the model once outside of the function
 print("Loading the model...")
 model = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo")
 print("Model loaded successfully.")
 
-# Create an asyncio lock
-lock = asyncio.Lock()
-
-async def generate_image(prompt, prompt_name):
-    async with lock:
-        try:
-            print(f"Generating response for {prompt_name} with prompt: {prompt}")
-            output = model(prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
-            print(f"Output for {prompt_name}: {output}")
-
-            # 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
+# Create a thread-local storage object
+thread_local = threading.local()
+
+class Scheduler:
+    def __init__(self):
+        self._step = threading.local()
+        self._step.step = None
+
+    def _init_step_index(self):
+        self._step.step = 0
+
+    @property
+    def step(self):
+        return self._step.step
+
+    def step_process(self):
+        self._step.step += 1
+
+scheduler = Scheduler()
+
+def generate_image(prompt, prompt_name):
+    try:
+        # Initialize step index for the current thread
+        if scheduler.step is None:
+            scheduler._init_step_index()
+        
+        print(f"Initial step index for {prompt_name}: {scheduler.step}")
+        print(f"Generating response for {prompt_name} with prompt: {prompt}")
+        
+        output = model(prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
+        
+        # Update and print step index
+        scheduler.step_process()
+        print(f"Updated step index for {prompt_name}: {scheduler.step}")
+
+        print(f"Output for {prompt_name}: {output}")
+
+        # 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_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}")
@@ -46,12 +74,13 @@ async def queue_api_calls(sentence_mapping, character_dict, selected_style):
     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, sentence_mapping, character_dict, selected_style)  # Correct prompt generation
+        prompt = generate_prompt(combined_sentence, character_dict, selected_style)  # Correct prompt generation
         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]
+    loop = asyncio.get_running_loop()
+    tasks = [loop.run_in_executor(None, 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.")
@@ -71,6 +100,9 @@ def process_prompt(sentence_mapping, character_dict, selected_style):
         asyncio.set_event_loop(loop)
     print("Event loop created.")
 
+    # Initialize thread-local variables
+    scheduler._init_step_index()
+
     # This sends the prompts to function that sets up the async calls. Once all the calls to the API complete, it returns a list of the gr.Textbox with value= set.
     cmpt_return = loop.run_until_complete(queue_api_calls(sentence_mapping, character_dict, selected_style))
     print(f"process_prompt completed with return value: {cmpt_return}")