feat(app): flux.generate_image2 calls Modal infra

app.py

@@ -80,6 +80,8 @@ with gr.Blocks() as demo:
 
                 This app provides a simple calculator, a dad joke generator, a greeting function, and an image generation feature.
 
+                Read the [project documentation](https://huggingface.co/spaces/Agents-MCP-Hackathon/simple-calculator/blob/main/README.md) to understand its background and motivations.
+
                 Use via API or MCP 🚀 · [Powered by Modal](https://modal.com/) · [Built with Gradio](https://www.gradio.app/) 🟧
                 """
     )
@@ -126,8 +128,7 @@ with gr.Blocks() as demo:
         img_btn = gr.Button("Generate Image")
         img_output = gr.Image(label="Sample Image")
         img_btn.click(
-            fn=flux.generate_image,
-            # fn=flux.generate_image2, # DEBUG
+            fn=flux.generate_image2, # Choose 1 or 2
             inputs=img_prompt,
             outputs=img_output,
             api_name="generate_image")

flux.py

@@ -219,57 +219,9 @@ def optimize(pipe, compile=True):
     return pipe
 
 
-def generate_image(prompt: str):
-    """
-    Generates an image based on a text prompt using the Flux model.
-
-    Args:
-        prompt (str): The text prompt to generate the image from.
-
-    Returns:
-        str: The URL of the generated image.
-    """
-
-    # For demonstration, we'll return a placeholder image URL
-
-    return "https://avatars.githubusercontent.com/u/75182?v=4"
-
-
-app_running = False
-
-def make_sure_app_running():
-    """
-    Ensure the Modal app is running.
-
-    NOTE: WORK-IN-PROGRESS
-    """
-    global app_running
-    # In practice, you would implement logic to check if the Modal app is running.
-    # For example, you could use `modal app list` to check if the app is running.
-    if not app_running:
-        print("⚠️ The Modal app is not running. Should start the app first.")
-        print("Starting Modal app...")
-        # Start the Modal app
-        # This will run the app in the background and allow it to handle requests.
-        # Note: This is a blocking call, so it will not return until the app is stopped.
-        # If you want to run it in the background, you can use `modal run --detach`.
-        # For example:
-        # modal run flux.py --prompt "a beautiful landscape with mountains and a river" --twice --compile
-        app.run(detach=False, interactive=True)
-        print("✅ Modal app started successfully.")
-        app_running = True
-        print("You can now call the generate_image function to generate images.")
-        print("Example usage:")
-        print("generate_image(prompt='a beautiful landscape with mountains and a river', twice=True, compile=False)")
-    else:
-        print("✅ The Modal app is already running. You can call the generate_image function to generate images.")
-    pass
-
-
-def generate_image2(    
-    prompt: str = """
-    A portrait of a handsome software developer
-    """,
+@app.function()
+def generate_image(    
+    prompt: str = "Question Mark",
     twice: bool = True,
     compile: bool = False,
 ):
@@ -283,18 +235,15 @@ def generate_image2(
         compile (bool): Whether to compile the model.
 
     Returns:
-        str: The URL of the generated image.
+        A bytes object containing the generated image.
     """
 
-    print("DEBUG: generate_image2 called with parameters:")
+    print("DEBUG: generate_image called with parameters:")
     print(f"  prompt: {prompt}")
     print(f"  twice: {twice}")
     print(f"  compile: {compile}")
     print("DEBUG: Starting image generation...")
 
-    # Ensure the Modal app is running before making any calls
-    make_sure_app_running()
-
     t0 = time.time()
     image_bytes = Model(compile=compile).inference.remote(prompt)
     print(f"🎨 first inference latency: {time.time() - t0:.2f} seconds")
@@ -304,13 +253,66 @@ def generate_image2(
         image_bytes = Model(compile=compile).inference.remote(prompt)
         print(f"🎨 second inference latency: {time.time() - t0:.2f} seconds")
 
-    output_path = Path("/tmp") / "flux" / "output.jpg"
-    output_path.parent.mkdir(exist_ok=True, parents=True)
-    print(f"🎨 saving output to {output_path}")
-    output_path.write_bytes(image_bytes)
+    print(f"DEBUG: Image generation completed - {len(image_bytes)} image_bytes")
+    return image_bytes
 
-    print(f"✅ Image generated and saved to {output_path}")
-    return output_path
+
+def generate_image1(prompt: str):
+    """
+    Generates an image based on a text prompt using the Flux model.
+    For demonstration, we'll return a placeholder image URL
+
+    Args:
+        prompt (str): The text prompt to generate the image from.
+
+    Returns:
+        str: The URL of the generated image.
+    """
+    return "https://avatars.githubusercontent.com/u/75182?v=4"
+
+
+def generate_image2(prompt: str):
+    """
+    Generates an image based on a text prompt using the Flux model
+    running on Modal serverless infrastructure.
+
+    Args:
+        prompt (str): The text prompt to generate the image from.
+
+    Returns:
+        str: The URL of the generated image.
+    """
+
+    print("DEBUG: generate_image2 called with prompt:", prompt)
+
+    if prompt is None or prompt.strip() == "A portrait of a handsome software developer":
+        print("DEBUG: Returning hardcoded image URL for default prompt")
+        result = generate_image1(prompt)
+    else:
+        # Call the generate_image function in the Modal app context
+        # This will ensure that the function is executed in the Modal environment
+        # and can access the necessary resources and configurations.
+        print("DEBUG: Calling generate_image.remote with prompt:", prompt)
+        with app.run():
+            print("DEBUG: Running in Modal app context")
+            # This will return the path to the generated image.
+            # Note: This is a blocking call, so it will wait for the image generation to complete.
+            image_bytes = generate_image.remote(prompt=prompt)
+            # Use .remote() to call the function asynchronously
+            # This allows the function to run in the Modal serverless infrastructure.
+            # The result will be a future object that can be awaited or used to get the result later.
+            # In this case, we are returning the future object directly.
+        
+        output_path = Path("/tmp") / "flux2" / "output.jpg"
+        output_path.parent.mkdir(exist_ok=True, parents=True)
+        print(f"🎨 Writing {len(image_bytes)} to {output_path}")
+        output_path.write_bytes(image_bytes)
+        
+        print(f"✅ Image generated and saved to {output_path}")
+        result = output_path
+
+    print(f"DEBUG: Image generation completed, returning result: {result}")
+    return result
 
 
 # To run this script, use the command: