Update app.py

app.py

@@ -350,40 +350,59 @@ with gr.Blocks(theme="bethecloud/storj_theme", css=css) as demo:
         num_steps,
         guidance_scale,
         seed,
+        randomize_seed, # Added randomize_seed to config
     ]
     with gr.Row():
         helper_text = gr.Markdown("## Tap and hold (on mobile) to save the image.", visible=True)
 
-    # Gradio Event Handling Functions
+    # Re-adding randomize_seed_fn inside the Blocks context
+    def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
+        if randomize_seed:
+            seed = random.randint(0, MAX_SEED)
+        return seed
+
+    # Gradio Event Handling Functions - MOVED INSIDE gr.Blocks context
     @gr.on(triggers=[image.upload, prompt.submit, run_button.click], inputs=config,
            outputs=result, show_progress="minimal")
     def auto_process_image(image, style_selection, prompt, a_prompt, n_prompt, num_images,
                            image_resolution, preprocess_resolution, num_steps, guidance_scale,
-                           seed, progress=gr.Progress(track_tqdm=True)):
+                           seed, randomize_seed, progress=gr.Progress(track_tqdm=True)): # Added randomize_seed
+        # Apply seed randomization
+        processed_seed = randomize_seed_fn(seed, randomize_seed)
+        print(f"Using processed seed: {processed_seed}") # Debug print
+
         # Call the core processing function
         return process_image(image, style_selection, prompt, a_prompt, n_prompt, num_images,
                              image_resolution, preprocess_resolution, num_steps, guidance_scale,
-                             seed)
+                             processed_seed) # Pass processed_seed
 
     @gr.on(triggers=[use_ai_button.click], inputs=[result] + config, outputs=[image, result],
            show_progress="minimal")
     def submit(previous_result, image, style_selection, prompt, a_prompt, n_prompt, num_images,
                image_resolution, preprocess_resolution, num_steps, guidance_scale, seed,
-               progress=gr.Progress(track_tqdm=True)):
+               randomize_seed, progress=gr.Progress(track_tqdm=True)): # Added randomize_seed
         # First, yield the previous result to update the input image immediately
         yield previous_result, gr.update()
+
+        # Apply seed randomization
+        processed_seed = randomize_seed_fn(seed, randomize_seed)
+        print(f"Using processed seed: {processed_seed}") # Debug print
+
         # Then, process the new input image
         new_result = process_image(previous_result, style_selection, prompt, a_prompt,
                                    n_prompt, num_images, image_resolution,
-                                   preprocess_resolution, num_steps, guidance_scale, seed)
+                                   preprocess_resolution, num_steps, guidance_scale,
+                                   processed_seed) # Pass processed_seed
         # Finally, yield the new result
         yield previous_result, new_result
 
+    # Turn off buttons when processing - These functions remain the same
     @gr.on(triggers=[image.upload, use_ai_button.click, run_button.click], inputs=None,
            outputs=[run_button, use_ai_button], show_progress="hidden")
     def turn_buttons_off():
         return gr.update(visible=False), gr.update(visible=False)
 
+    # Turn on buttons when processing is complete - These functions remain the same
     @gr.on(triggers=[result.change], inputs=None, outputs=[use_ai_button, run_button],
            show_progress="hidden")
     def turn_buttons_on():
@@ -404,59 +423,30 @@ def process_image(
         preprocess_resolution,
         num_steps,
         guidance_scale,
-        seed,
+        seed, # Now receives the potentially randomized seed
 ):
-    # Use provided seed or generate a random one based on randomize_seed checkbox (need to add randomize_seed input)
-    # The original Gradio code used randomize_seed_fn, but the logic is simple enough to keep here
-    # Let's add randomize_seed as an input parameter to this function
-    # Re-checking the original Gradio code, randomize_seed is an input to the Gradio event function,
-    # but not directly passed to process_image. Instead, the seed is randomized *before* calling process_image
-    # in the Gradio event handlers. Let's replicate that.
-
-    # Seed randomization logic from original Gradio code
-    # The seed parameter in the config list is used here
+    """
+    Processes an input image to generate a new image based on style and prompts.
+
+    Args:
+        image: Input PIL Image.
+        style_selection: Name of the design style to apply.
+        prompt: Custom design prompt.
+        a_prompt: Additional positive prompt.
+        n_prompt: Negative prompt.
+        num_images: Number of images to generate (currently only 1 supported by pipeline).
+        image_resolution: Resolution for the output image.
+        preprocess_resolution: Resolution for the preprocessor.
+        num_steps: Number of inference steps.
+        guidance_scale: Guidance scale for the diffusion process.
+        seed: Random seed for reproducibility.
+
+    Returns:
+        A PIL Image of the generated result.
+    """
+    # Use the seed passed from the event handler
     current_seed = seed
-    # Note: The original `auto_process_image` and `submit` functions did NOT use the `randomize_seed` checkbox
-    # to potentially override the seed slider value before passing it to `process_image`.
-    # The `randomize_seed_fn` was defined but not called in the provided Gradio code snippet.
-    # Let's stick to the provided Gradio code's logic which seems to just use the seed slider value.
-    # If randomization is needed, it should be handled in the event handler before calling process_image.
-    # However, the original `process_image` function *itself* had `seed = random.randint(0, MAX_SEED)`.
-    # This means the seed slider was ignored! Let's fix that and use the seed slider value,
-    # applying randomization if the checkbox is checked in the event handler.
-
-    # Re-adding randomize_seed to the inputs list `config` and event handler functions
-    # Then applying randomization logic in the event handler before calling process_image
-
-    # *** Correction: Re-reading the original Gradio code snippet provided at the very beginning,
-    # the `randomize_seed_fn` was defined but not used. The `process_image` function
-    # *inside* the `if gr.NO_RELOAD:` block *did* have `seed = random.randint(0, MAX_SEED)`
-    # at the beginning, effectively ignoring the input seed slider value unless randomize_seed_fn
-    # was somehow implicitly called or the logic was elsewhere.
-    # Let's assume the intention was to use the seed slider, with an option to randomize.
-    # The `randomize_seed_fn` should be called in the Gradio event handlers.
-
-    # Let's modify the Gradio event handlers to use randomize_seed_fn
-
-    # *** Another Correction: The `process_image` function signature in the original Gradio code
-    # included `seed` as a parameter, but the first line inside the function was `seed = random.randint(0, MAX_SEED)`.
-    # This is contradictory. It implies the input `seed` was always overwritten by a random value.
-    # Let's assume the *intent* was to use the input `seed` unless `randomize_seed` was True.
-    # The `randomize_seed_fn` should be called in the event handler to get the final seed value.
-
-    # Let's modify the event handlers to call randomize_seed_fn and pass the result as `seed` to `process_image`.
-    # The `process_image` function itself should *not* randomize the seed internally if a seed is passed.
-
-    # *** Final Decision: Let's revert `process_image` to its signature from the original Gradio code,
-    # but remove the internal `seed = random.randint(0, MAX_SEED)` line.
-    # The randomization logic will be added to the Gradio event handlers using `randomize_seed_fn`.
-    # The `config` list and event handlers will need `randomize_seed` as an input.
-
-    # Re-adding randomize_seed to config and event handler signatures
-    # Adding call to randomize_seed_fn in event handlers
-
-    # --- Start of process_image logic ---
-    # Seed handling moved to event handlers
+    generator = torch.cuda.manual_seed(current_seed) if torch.cuda.is_available() else torch.manual_seed(current_seed)
 
     if preprocessor.name != "NormalBae":
          preprocessor.load("NormalBae")
@@ -481,13 +471,10 @@ def process_image(
     negative_prompt = str(n_prompt)
     print(f"Using prompt: {full_prompt}")
     print(f"Using negative prompt: {negative_prompt}")
-    print(f"Using seed: {seed}") # Use the seed passed from the event handler
+    print(f"Using seed: {current_seed}")
 
     pipe.to("cuda" if torch.cuda.is_available() else "cpu")
 
-    # Use the generator created with the potentially randomized seed
-    generator = torch.cuda.manual_seed(seed) if torch.cuda.is_available() else torch.manual_seed(seed)
-
     with torch.no_grad():
         initial_result = pipe(
             prompt=full_prompt,
@@ -525,76 +512,6 @@ def process_image(
         print(f"Error saving or uploading image: {e}")
 
     return initial_result
-    # --- End of process_image logic ---
-
-# Re-adding randomize_seed_fn
-def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    return seed
-
-# Re-adding randomize_seed to config list
-config = [
-    image,
-    style_selection,
-    prompt,
-    a_prompt,
-    n_prompt,
-    num_images,
-    image_resolution,
-    preprocess_resolution,
-    num_steps,
-    guidance_scale,
-    seed,
-    randomize_seed, # Added randomize_seed to config
-]
-
-# Re-defining Gradio Event Handling Functions with randomize_seed input and seed randomization logic
-@gr.on(triggers=[image.upload, prompt.submit, run_button.click], inputs=config,
-       outputs=result, show_progress="minimal")
-def auto_process_image(image, style_selection, prompt, a_prompt, n_prompt, num_images,
-                       image_resolution, preprocess_resolution, num_steps, guidance_scale,
-                       seed, randomize_seed, progress=gr.Progress(track_tqdm=True)): # Added randomize_seed
-    # Apply seed randomization
-    processed_seed = randomize_seed_fn(seed, randomize_seed)
-    print(f"Using processed seed: {processed_seed}") # Debug print
-
-    # Call the core processing function with the processed seed
-    return process_image(image, style_selection, prompt, a_prompt, n_prompt, num_images,
-                         image_resolution, preprocess_resolution, num_steps, guidance_scale,
-                         processed_seed) # Pass processed_seed
-
-@gr.on(triggers=[use_ai_button.click], inputs=[result] + config, outputs=[image, result],
-       show_progress="minimal")
-def submit(previous_result, image, style_selection, prompt, a_prompt, n_prompt, num_images,
-           image_resolution, preprocess_resolution, num_steps, guidance_scale, seed,
-           randomize_seed, progress=gr.Progress(track_tqdm=True)): # Added randomize_seed
-    # First, yield the previous result to update the input image immediately
-    yield previous_result, gr.update()
-
-    # Apply seed randomization
-    processed_seed = randomize_seed_fn(seed, randomize_seed)
-    print(f"Using processed seed: {processed_seed}") # Debug print
-
-    # Then, process the new input image
-    new_result = process_image(previous_result, style_selection, prompt, a_prompt,
-                               n_prompt, num_images, image_resolution,
-                               preprocess_resolution, num_steps, guidance_scale,
-                               processed_seed) # Pass processed_seed
-    # Finally, yield the new result
-    yield previous_result, new_result
-
-# Turn off buttons when processing - These functions remain the same
-@gr.on(triggers=[image.upload, use_ai_button.click, run_button.click], inputs=None,
-       outputs=[run_button, use_ai_button], show_progress="hidden")
-def turn_buttons_off():
-    return gr.update(visible=False), gr.update(visible=False)
-
-# Turn on buttons when processing is complete - These functions remain the same
-@gr.on(triggers=[result.change], inputs=None, outputs=[use_ai_button, run_button],
-       show_progress="hidden")
-def turn_buttons_on():
-    return gr.update(visible=True), gr.update(visible=True)
 
 
 # Launch the Gradio app