Optimize Gallery UI and enable Ctrl+V image pasting

- Remove custom upload/delete buttons in favor of native gr.Gallery features.
- Add support for pasting images (Ctrl+V) directly into the gallery.
- Refactor code to remove unused functions and simplify the layout.

- Improve console logging: Group execution times by image to reduce redundancy and improve readability.
- Optimize ZIP handling: Conditionally create face-related ZIPs only when face restoration is enabled. Added logic to remove empty ZIP files (<= 22 bytes) before returning results.
- Fix filename bug: Reset self.modelInUse at the start of inference to prevent model name suffix accumulation across multiple runs.

README.md

@@ -4,7 +4,7 @@ emoji: 📈
 colorFrom: blue
 colorTo: gray
 sdk: gradio
-sdk_version: 5.44.1
+sdk_version: 5.50.0
 app_file: app.py
 pinned: true
 license: apache-2.0

app.py

@@ -795,6 +795,8 @@ class Upscale:
             if not gallery or (not face_restoration and not upscale_model):
                 raise ValueError("Invalid parameter setting")
             
+            self.modelInUse = "" 
+
             gallery_len = len(gallery)
             print(face_restoration, upscale_model, scale, f"gallery length: {gallery_len}")
 
@@ -826,14 +828,20 @@ class Upscale:
             files = []
             # Create zip files for each output type
             unique_id = str(int(time.time())) # Use timestamp for uniqueness
+            
+            # Define zip file paths
             zip_cropf_path    = f"output/{unique_id}_cropped_faces{self.modelInUse}.zip"
-            zipf_cropf         = zipfile.ZipFile(zip_cropf_path, 'w', zipfile.ZIP_DEFLATED)
             zip_restoref_path = f"output/{unique_id}_restored_faces{self.modelInUse}.zip"
-            zipf_restoref     = zipfile.ZipFile(zip_restoref_path, 'w', zipfile.ZIP_DEFLATED)
             zip_cmp_path      = f"output/{unique_id}_cmp{self.modelInUse}.zip"
-            zipf_cmp          = zipfile.ZipFile(zip_cmp_path, 'w', zipfile.ZIP_DEFLATED)
             zip_restore_path  = f"output/{unique_id}_restored_images{self.modelInUse}.zip"
-            zipf_restore      = zipfile.ZipFile(zip_restore_path, 'w', zipfile.ZIP_DEFLATED)
+
+            # Initialize Zip Objects conditionally
+            # Only create face-related zips if face restoration is actually enabled
+            zipf_cropf    = zipfile.ZipFile(zip_cropf_path, 'w', zipfile.ZIP_DEFLATED) if face_restoration else None
+            zipf_restoref = zipfile.ZipFile(zip_restoref_path, 'w', zipfile.ZIP_DEFLATED) if face_restoration else None
+            zipf_cmp      = zipfile.ZipFile(zip_cmp_path, 'w', zipfile.ZIP_DEFLATED) if face_restoration else None
+            # Always attempt to create the main restoration zip
+            zipf_restore  = zipfile.ZipFile(zip_restore_path, 'w', zipfile.ZIP_DEFLATED)
 
             is_auto_split_upscale = True
             # Dictionary to track counters for each filename
@@ -869,7 +877,7 @@ class Upscale:
                         bg_upsample_img, _ = auto_split_upscale(img_cv2, self.realesrganer.enhance, self.scale) if is_auto_split_upscale else self.realesrganer.enhance(img_cv2, outscale=self.scale)
                         current_progress += progressRatio/progressTotal;
                         progress(current_progress, desc=f"Image {gallery_idx:02d}: Background upscaling...")
-                        timer.checkpoint(f"Image {gallery_idx:02d}: Background upscale section")
+                        timer.checkpoint("Background upscale")
 
                     if face_restoration and self.face_enhancer:
                         cropped_faces, restored_aligned, bg_upsample_img = self.face_enhancer.enhance(img_cv2, has_aligned=False, only_center_face=face_detection_only_center, paste_back=True, bg_upsample_img=bg_upsample_img, eye_dist_threshold=face_detection_threshold)
@@ -879,45 +887,60 @@ class Upscale:
                                 # save cropped face
                                 save_crop_path = f"output/{basename}_{idx:02d}_cropped_faces{self.modelInUse}.png"
                                 self.imwriteUTF8(save_crop_path, cropped_face)
-                                zipf_cropf.write(save_crop_path, arcname=os.path.basename(save_crop_path))
+                                if zipf_cropf:
+                                    zipf_cropf.write(save_crop_path, arcname=os.path.basename(save_crop_path))
                                 # save restored face
                                 save_restore_path = f"output/{basename}_{idx:02d}_restored_faces{self.modelInUse}.png"
                                 self.imwriteUTF8(save_restore_path, restored_face)
-                                zipf_restoref.write(save_restore_path, arcname=os.path.basename(save_restore_path))
+                                if zipf_restoref:
+                                    zipf_restoref.write(save_restore_path, arcname=os.path.basename(save_restore_path))
                                 # save comparison image
                                 save_cmp_path = f"output/{basename}_{idx:02d}_cmp{self.modelInUse}.png"
                                 cmp_img = np.concatenate((cropped_face, restored_face), axis=1)
                                 self.imwriteUTF8(save_cmp_path, cmp_img)
-                                zipf_cmp.write(save_cmp_path, arcname=os.path.basename(save_cmp_path))
+                                if zipf_cmp:
+                                    zipf_cmp.write(save_cmp_path, arcname=os.path.basename(save_cmp_path))
 
                                 files.append(save_crop_path)
                                 files.append(save_restore_path)
                                 files.append(save_cmp_path)
                         current_progress += progressRatio/progressTotal;
                         progress(current_progress, desc=f"Image {gallery_idx:02d}: Face enhancement...")
-                        timer.checkpoint(f"Image {gallery_idx:02d}: Face enhancer section")
+                        timer.checkpoint("Face enhancement")
 
                     restored_img = bg_upsample_img
-                    timer.report() # Report time for this image
+                    # Report time for this image with a Header
+                    timer.report(header=f"[Image {gallery_idx:02d} Stats]")
 
                     # Handle cases where image processing might still result in None
                     if restored_img is None:
                        print(f"Warning: Processing resulted in no image for '{img_path}'. Skipping output.")
                        continue
+                   
+                    # Record the timestamp before I/O starts
+                    timer.checkpoint("I/O preparation")
 
                     # Determine the file extension for the output image based on user preference and image properties.
                     if save_as_png:
-                        # Force PNG output for the best quality, as requested by the user.
                         final_extension = ".png"
                     else:
                         # Use original logic: PNG for images with an alpha channel (RGBA), otherwise use the original extension or default to jpg.
                         final_extension = ".png" if img_mode == "RGBA" else (extension if extension else ".jpg")
+                    
                     save_path = f"output/{basename}{self.modelInUse}{final_extension}"
+
+                    # Execute saving
                     self.imwriteUTF8(save_path, restored_img)
-                    zipf_restore.write(save_path, arcname=os.path.basename(save_path))
+                    if zipf_restore:
+                        zipf_restore.write(save_path, arcname=os.path.basename(save_path))
 
+                    # Color conversion
                     restored_img = cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB)
                     files.append(save_path)
+                    
+                    # --- Record saving end time and report ---
+                    timer.checkpoint("File Saving (IO/CPU)")
+                    timer.report(header=f"[Image {gallery_idx:02d} I/O]")
                 except RuntimeError as error:
                     print(f"Runtime Error while processing image {gallery_idx} ({img_path or 'unknown path'}): {error}")
                     print(traceback.format_exc())
@@ -929,11 +952,31 @@ class Upscale:
 
             progress(1, desc=f"Processing complete.")
             timer.report_all()  # Print all recorded times for the whole batch
-            # Close zip files
-            zipf_cropf.close()
-            zipf_restoref.close()
-            zipf_cmp.close()
-            zipf_restore.close()
+            
+            # Close zip files and clean up empty ones
+            final_zip_paths = []
+            zips_to_process = [
+                (zipf_cropf, zip_cropf_path),
+                (zipf_restoref, zip_restoref_path),
+                (zipf_cmp, zip_cmp_path),
+                (zipf_restore, zip_restore_path)
+            ]
+
+            for zf, path in zips_to_process:
+                if zf:
+                    zf.close()
+                    # Check if the zip file actually contains files.
+                    # A standard empty zip file is 22 bytes (End of central directory record).
+                    # If it's empty, we delete it and don't return it.
+                    if os.path.exists(path):
+                        if os.path.getsize(path) > 22:
+                            final_zip_paths.append(path)
+                        else:
+                            try:
+                                os.remove(path)
+                            except OSError:
+                                pass
+
         except Exception as error:
             print(f"Global exception occurred: {error}")
             print(traceback.format_exc())
@@ -946,7 +989,7 @@ class Upscale:
                 torch.cuda.empty_cache()
             gc.collect()
                 
-        return files, [zip_cropf_path, zip_restoref_path, zip_cmp_path, zip_restore_path]  if face_restoration else [zip_restore_path]
+        return files, final_zip_paths
 
 
     def find_max_numbers(self, state_dict, findkeys):
@@ -1012,36 +1055,38 @@ class Timer:
         now = time.perf_counter()
         self.checkpoints.append((label, now))
 
-    def report(self, is_clear_checkpoints = True):
+    def report(self, header=None, is_clear_checkpoints=True):
         # Determine the max label width for alignment
+        # If there are no checkpoints to report, skip
+        if len(self.checkpoints) <= 1:
+            return
+
+        # Print header if provided (e.g., "[Image 00]")
+        if header:
+            print(header)
+            indent = "  " # Indent detailed logs if header exists
+        else:
+            indent = ""
+
         max_label_length = max(len(label) for label, _ in self.checkpoints)
 
         prev_time = self.checkpoints[0][1]
         for label, curr_time in self.checkpoints[1:]:
             elapsed = curr_time - prev_time
-            print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
+            print(f"{indent}{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
             prev_time = curr_time
         
         if is_clear_checkpoints:
             self.checkpoints.clear()
-            self.checkpoint()  # Store checkpoints
+            self.checkpoint("Loop Start/Reset") # Reset start point
 
     def report_all(self):
         """Print all recorded checkpoints and total execution time with aligned formatting."""
         print("\n> Execution Time Report:")
-
-        # Determine the max label width for alignment
-        max_label_length = max(len(label) for label, _ in self.checkpoints) if len(self.checkpoints) > 0 else 0
-
-        prev_time = self.start_time
-        for label, curr_time in self.checkpoints[1:]:
-            elapsed = curr_time - prev_time
-            print(f"{label.ljust(max_label_length)}: {elapsed:.3f} seconds")
-            prev_time = curr_time
-        
-        total_time = self.checkpoints[-1][1] - self.start_time
-        print(f"{'Total Execution Time'.ljust(max_label_length)}: {total_time:.3f} seconds\n")
-
+        # Use current time (perf_counter) as the end point, instead of the last checkpoint
+        end_time = time.perf_counter()
+        total_time = end_time - self.start_time
+        print(f"Total Execution Time: {total_time:.3f} seconds\n")
         self.checkpoints.clear()
 
     def restart(self):
@@ -1080,73 +1125,6 @@ def limit_gallery(gallery):
     """
     return gallery[:input_images_limit] if input_images_limit > 0 and gallery else gallery
 
-def append_gallery(gallery: list, image: str):
-    """
-    Append a single image to the gallery while respecting input_images_limit.
-
-    Parameters:
-    - gallery (list): Existing list of images. If None, initializes an empty list.
-    - image (str): The image to be added. If None or empty, no action is taken.
-
-    Returns:
-    - list: Updated gallery.
-    """
-    if gallery is None:
-        gallery = []
-    if not image:
-        return gallery, None
-    
-    if input_images_limit == -1 or len(gallery) < input_images_limit:
-        gallery.append(image)
-
-    return gallery, None
-
-
-def extend_gallery(gallery: list, images):
-    """
-    Extend the gallery with new images while respecting the input_images_limit.
-    
-    Parameters:
-    - gallery (list): Existing list of images. If None, initializes an empty list.
-    - images (list): New images to be added. If None, defaults to an empty list.
-    
-    Returns:
-    - list: Updated gallery with the new images added.
-    """
-    if gallery is None:
-        gallery = []
-    if not images:
-        return gallery
-    
-    # Add new images to the gallery
-    gallery.extend(images)
-
-    # Trim gallery to the specified limit, if applicable
-    if input_images_limit > 0:
-        gallery = gallery[:input_images_limit]
-
-    return gallery
-
-def remove_image_from_gallery(gallery: list, selected_image: str):
-    """
-    Removes a selected image from the gallery if it exists.
-
-    Args:
-        gallery (list): The current list of images in the gallery.
-        selected_image (str): The image to be removed, represented as a string 
-                              that needs to be parsed into a tuple.
-
-    Returns:
-        list: The updated gallery after removing the selected image.
-    """
-    if not gallery or not selected_image:
-        return gallery
-
-    selected_image = ast.literal_eval(selected_image) # Use ast.literal_eval to parse text into a tuple in remove_image_from_gallery.
-    # Remove the selected image from the gallery
-    if selected_image in gallery:
-        gallery.remove(selected_image)
-    return gallery
 
 def main():
     if torch.cuda.is_available():
@@ -1159,6 +1137,7 @@ def main():
         # https://github.com/CompVis/stable-diffusion/issues/69#issuecomment-1260722801
         torch.backends.cudnn.enabled = True
         torch.backends.cudnn.benchmark = True
+        print(f"CUDA is available. Using GPU: {torch.cuda.get_device_name(0)}")
     # Ensure the target directory exists
     os.makedirs('output', exist_ok=True)
 
@@ -1182,6 +1161,74 @@ def main():
         text-align: left !important;
         width: 55.5% !important;
     }
+
+    /* Make the Dropdown options display more compactly */
+    .tag-dropdown span.svelte-1f354aw {
+        font-family: monospace;
+    }
+    /* Add hover effect to Gallery to indicate it is an interactive area */
+    #input_gallery:hover {
+        border-color: var(--color-accent) !important;
+        box-shadow: 0 0 10px rgba(0,0,0,0.1);
+    }
+    """
+    
+    # JavaScript to handle Ctrl+V paste for MULTIPLE files ONLY when hovering over the gallery
+    paste_js = """
+    function initPaste() {
+        document.addEventListener('paste', function(e) {
+            // 1. First find the Gallery component
+            const gallery = document.getElementById('input_gallery');
+            if (!gallery) return;
+            
+            // 2. Check if mouse is hovering over the Gallery
+            // If mouse is not over the gallery, ignore this paste event
+            if (!gallery.matches(':hover')) {
+                return;
+            }
+
+            const clipboardData = e.clipboardData || e.originalEvent.clipboardData;
+            if (!clipboardData) return;
+
+            const items = clipboardData.items;
+            const files = [];
+
+            // 3. Check clipboard content
+            for (let i = 0; i < items.length; i++) {
+                if (items[i].kind === 'file' && items[i].type.startsWith('image/')) {
+                    files.push(items[i].getAsFile());
+                }
+            }
+            
+            // 4. Check file list (Copied files from OS)
+            if (files.length === 0 && clipboardData.files.length > 0) {
+                 for (let i = 0; i < clipboardData.files.length; i++) {
+                    if (clipboardData.files[i].type.startsWith('image/')) {
+                        files.push(clipboardData.files[i]);
+                    }
+                }
+            }
+
+            if (files.length === 0) return;
+            
+            // 5. Execute upload logic
+            // Find input inside the gallery component
+            const uploadInput = gallery.querySelector('input[type="file"]');
+            
+            if (uploadInput) {
+                e.preventDefault();
+                e.stopPropagation();
+
+                const dataTransfer = new DataTransfer();
+                files.forEach(file => dataTransfer.items.add(file));
+                
+                uploadInput.files = dataTransfer.files;
+
+                // Trigger Gradio update
+                uploadInput.dispatchEvent(new Event('change', { bubbles: true }));
+            }
+        });
+    }
     """
 
     upscale = Upscale()
@@ -1209,12 +1256,14 @@ def main():
         with gr.Row():
             with gr.Column(variant="panel"):
                 submit = gr.Button(value="Submit", variant="primary", size="lg")
-                # Create an Image component for uploading images
-                input_image                = gr.Image(label="Upload an Image or clicking paste from clipboard button", type="filepath", format="png", height=150)
-                with gr.Row():
-                    upload_button          = gr.UploadButton("Upload multiple images", file_types=["image"], file_count="multiple", size="sm")
-                    remove_button          = gr.Button("Remove Selected Image", size="sm")
-                input_gallery              = gr.Gallery(columns=5, rows=5, show_share_button=False, interactive=True, height="500px", label="Gallery that displaying a grid of images" + (f"(The online environment image limit is {input_images_limit})" if input_images_limit > 0 else ""))
+                input_gallery              = gr.Gallery(columns=5, rows=5, interactive=True, height=500, label="Gallery that displaying a grid of images" + (f"(The online environment image limit is {input_images_limit})" if input_images_limit > 0 else ""), elem_id="input_gallery")
+                gr.Markdown(
+                    """
+                    <div style="text-align: right; font-size: 0.9em; color: gray;">
+                    💡 Tip: Hover over the gallery and press <b>Ctrl+V</b> to paste images.
+                    </div>
+                    """
+                )
                 face_model                 = gr.Dropdown([None]+list(face_models.keys()), type="value", value='GFPGANv1.4.pth', label='Face Restoration version', info="Face Restoration and RealESR can be freely combined in different ways, or one can be set to \"None\" to use only the other model. Face Restoration is primarily used for face restoration in real-life images, while RealESR serves as a background restoration model.")
                 upscale_model              = gr.Dropdown([None]+list(typed_upscale_models.keys()), type="value", value='SRVGG, realesr-general-x4v3.pth', label='UpScale version')
                 upscale_scale              = gr.Number(label="Rescaling factor", value=4)
@@ -1225,17 +1274,11 @@ def main():
                 # Add a checkbox to always save the output as a PNG file for the best quality.
                 save_as_png                = gr.Checkbox(label="Always save output as PNG", value=True, info="If enabled, all output images will be saved in PNG format to ensure the best quality. If disabled, the format will be determined automatically (PNG for images with transparency, otherwise JPG).")
 
-                # Define the event listener to add the uploaded image to the gallery
-                input_image.change(append_gallery, inputs=[input_gallery, input_image], outputs=[input_gallery, input_image])
-                # When the upload button is clicked, add the new images to the gallery
-                upload_button.upload(extend_gallery, inputs=[input_gallery, upload_button], outputs=input_gallery)
                 # Event to update the selected image when an image is clicked in the gallery
                 selected_image = gr.Textbox(label="Selected Image", visible=False)
                 input_gallery.select(get_selection_from_gallery, inputs=None, outputs=selected_image)
                 # Trigger update when gallery changes
                 input_gallery.change(limit_gallery, input_gallery, input_gallery)
-                # Event to remove a selected image from the gallery
-                remove_button.click(remove_image_from_gallery, inputs=[input_gallery, selected_image], outputs=input_gallery)
 
                 with gr.Row():
                     clear = gr.ClearButton(
@@ -1257,8 +1300,8 @@ def main():
             # Generate output array
             output_arr = []
             for file_name in example_list:
-                output_arr.append([file_name,])
-            gr.Examples(output_arr, inputs=[input_image,], examples_per_page=20)
+                output_arr.append([[file_name],])
+            gr.Examples(output_arr, inputs=[input_gallery,], examples_per_page=20)
         with gr.Row(variant="panel"):
             # Convert to Markdown table
             header = "| Face Model Name | Info | Download URL |\n|------------|------|--------------|"
@@ -1288,9 +1331,12 @@ def main():
             ],
             outputs=[gallerys, outputs],
         )
+        
+        # Load the JavaScript
+        demo.load(None, None, None, js=paste_js)
     
     demo.queue(default_concurrency_limit=1)
-    demo.launch(inbrowser=True)
+    demo.launch(inbrowser=True) # , css = css
 
 
 if __name__ == "__main__":

requirements.txt

@@ -1,6 +1,6 @@
 --extra-index-url https://download.pytorch.org/whl/cu128
 
-gradio
+gradio==5.50.0
 
 basicsr @ git+https://github.com/avan06/BasicSR
 facexlib @ git+https://github.com/avan06/facexlib