Update app.py

app.py

@@ -12,86 +12,91 @@ ray.init()
 @ray.remote
 class ModelActor:
     def __init__(self):
-        print("Loading the model...")
+        """
+        Initializes the ModelActor class and loads the text-to-image model.
+        """
         self.model = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo")
-        print("Model loaded successfully.")
 
-    def generate_image(self, prompt, prompt_name):
+    async def generate_image(self, prompt, prompt_name):
+        """
+        Generates an image based on the provided prompt.
+
+        Parameters:
+            - prompt (str): The input text for image generation.
+            - prompt_name (str): A name for the prompt, used for logging.
+
+        Returns:
+            bytes: The generated image data in bytes format, or None if generation fails.
+        """
         start_time = time.time()
         process_id = os.getpid()
         try:
-            print(f"[{process_id}] Generating response for {prompt_name} with prompt: {prompt}")
-            output = self.model(prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
-            print(f"[{process_id}] Output for {prompt_name}: {output}")
-
+            output = await self.model(prompt=prompt, num_inference_steps=1, guidance_scale=0.0)
             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()
-                    end_time = time.time()
-                    print(f"[{process_id}] Image bytes length for {prompt_name}: {len(image_bytes)}")
-                    print(f"[{process_id}] Time taken for {prompt_name}: {end_time - start_time} seconds")
-                    return image_bytes
-                except Exception as e:
-                    print(f"[{process_id}] Error saving image for {prompt_name}: {e}")
-                    return None
+                image.save(buffered, format="JPEG")
+                image_bytes = buffered.getvalue()
+                end_time = time.time()
+                return image_bytes
             else:
-                raise Exception(f"[{process_id}] No images returned by the model for {prompt_name}.")
+                return None
         except Exception as e:
-            print(f"[{process_id}] 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}")
-    prompts = []
+    """
+    Generates images for all provided prompts in parallel using Ray actors.
+
+    Parameters:
+        - sentence_mapping (dict): Mapping between paragraph numbers and sentences.
+        - character_dict (dict): Dictionary mapping characters to their descriptions.
+        - selected_style (str): Selected illustration style.
 
+    Returns:
+        dict: A dictionary where keys are paragraph numbers and values are image data in bytes format.
+    """
+    prompts = []
     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)
         prompts.append((paragraph_number, prompt))
-        print(f"Generated prompt for paragraph {paragraph_number}: {prompt}")
 
     num_prompts = len(prompts)
-    num_actors = min(num_prompts, 20)  # Limit to a maximum of 20 actors
+    num_actors = min(num_prompts, 20)
     model_actors = [ModelActor.remote() for _ in range(num_actors)]
-
     tasks = [model_actors[i % num_actors].generate_image.remote(prompt, f"Prompt {paragraph_number}") for i, (paragraph_number, prompt) in enumerate(prompts)]
-    print("Tasks created for image generation.")
 
     responses = await asyncio.gather(*[asyncio.to_thread(ray.get, task) for task in tasks])
-    print("Responses received from image generation tasks.")
-
     images = {paragraph_number: response for (paragraph_number, _), response in zip(prompts, responses)}
-    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}")
+    """
+    Processes the provided prompts and generates images.
+
+    Parameters:
+        - sentence_mapping (dict): Mapping between paragraph numbers and sentences.
+        - character_dict (dict): Dictionary mapping characters to their descriptions.
+        - selected_style (str): Selected illustration style.
+
+    Returns:
+        dict: A dictionary where keys are paragraph numbers and values are image data in bytes format.
+    """
     try:
         loop = asyncio.get_running_loop()
     except RuntimeError:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-    print("Event loop created.")
 
     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}")
     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")
-    ],
+    inputs=[gr.JSON(label="Sentence Mapping"), gr.JSON(label="Character Dict"), gr.Dropdown(["oil painting", "sketch", "watercolor"], label="Selected Style")],
     outputs="json"
 )
 
 if __name__ == "__main__":
-    print("Launching Gradio interface...")
     gradio_interface.launch()
-    print("Gradio interface launched.")