Upload folder using huggingface_hub

README.md

@@ -4,3 +4,120 @@ app_file: app.py
 sdk: gradio
 sdk_version: 4.31.5
 ---
+
+
+Sure, here is a detailed README for your script:
+
+GroOvy SD3 Batch Imagine
+Overview
+The GroOvy SD3 Batch Imagine tool is designed for batch image generation using the SD3 Medium model. This tool allows users to input multiple prompts and generate images in batches, with options for negative prompts, and automated zipping of generated images for easy download. The integration with ComfyUI ensures a seamless workflow for AI-powered image generation.
+
+Features
+Batch Image Generation: Enter multiple prompts and generate images in bulk.
+Negative Prompts: Specify negative prompts to refine image outputs.
+Zip Interval: Set the interval at which images are zipped.
+Real-time Progress Monitoring: Watch the progress of image generation in real-time.
+Automated File Management: Generated images are automatically copied to user-specific folders and zipped at specified intervals.
+Detailed Logging: Monitor detailed logs of the image generation process.
+Prerequisites
+Python 3.7 or higher
+Required Python packages: requests, gradio, logging, shutil, zipfile, os, json, random, time
+Installation
+Clone the repository:
+bash
+Copy code
+git clone https://github.com/your-repo/groovy-sd3-batch-imagine.git
+Navigate to the project directory:
+bash
+Copy code
+cd groovy-sd3-batch-imagine
+Install the required packages:
+bash
+Copy code
+pip install -r requirements.txt
+Usage
+Running the Application
+To run the application, execute the following command in your terminal:
+
+bash
+Copy code
+python app.py
+Accessing the Interface
+Once the application is running, you can access the Gradio interface via the provided local URL (http://127.0.0.1:7860) or a public URL if you choose to share it.
+
+Interface Overview
+Developer Information
+This section provides information about the developer, BeWiZ, including contact details and social media links.
+
+About SD3 Batch Imagine
+Learn about the purpose and features of the GroOvy SD3 Batch Imagine tool.
+
+Instructions
+Follow these instructions to use the tool effectively:
+
+Enter your prompts, one per empty line.
+Enter your negative prompts, one per line (optional).
+Set the zip interval to determine how many images will be included in each zip file.
+Click "Process Prompts" to start generating images.
+Click "Cancel Processing" to stop the current batch run.
+Monitor the progress in real-time.
+Download the generated zip files at the end of the process.
+Components
+Enter Prompts
+Prompts: Input your image generation prompts here, one per empty line.
+Negative Prompts: Input negative prompts here, one per line (optional).
+Zip Interval: Specify the number of images per zip file.
+Process Prompts Button: Start the batch image generation process.
+Cancel Processing Button: Cancel the current batch run.
+Progress: Displays real-time progress of image generation.
+Generated Images
+Gallery: Displays the generated images.
+Zip Files
+Zip Files: Displays the generated zip files for download.
+Detailed Logs
+Logs: Displays detailed logs of the image generation process.
+Script Details
+Constants
+COMFYUI_DIR: Directory path for ComfyUI.
+WORKFLOW_PATH: Path to the workflow JSON file.
+OUTPUT_DIR: Directory path for output images.
+URL: URL for sending the workflow to ComfyUI.
+Functions
+read_workflow(file_path)
+Reads and returns the workflow JSON from the specified file path.
+
+update_workflow(workflow, prompt, negative_prompt)
+Updates the workflow with new prompts and negative prompts.
+
+write_workflow(workflow, file_path)
+Writes the updated workflow back to the specified file path.
+
+send_workflow_to_comfyui(workflow, url)
+Sends the updated workflow to ComfyUI and logs the response.
+
+monitor_output_images(output_dir, previous_images, timeout=60)
+Monitors the output directory for new images, returning the latest image found within the timeout period.
+
+copy_file_with_retry(src, dst_dir, file_index, retries=5, delay=1)
+Copies a file from the source to the destination directory, with retries in case of permission errors.
+
+zip_files(output_images: List[str], zip_interval: int, zip_folder: str)
+Creates zip files from the list of output images at specified intervals and saves them to the zip folder.
+
+process_prompts(prompts_text, negative_prompt_text, user_folder, zip_interval)
+Processes the prompts, generates images, copies them to the user folder, and zips them at specified intervals.
+
+cancel_processing_fn()
+Sets the cancel processing flag to True to stop the current batch run.
+
+reset_cancel_processing_fn()
+Resets the cancel processing flag to False.
+
+Main Function
+The main() function initializes the Gradio interface and sets up the UI components for entering prompts, monitoring progress, displaying generated images, zip files, and logs.
+
+License
+This project is licensed under the MIT License. See the LICENSE file for more details.
+
+Contact
+For any queries or support, please contact downlifted@gmail.com or reach out on Twitter @AiAnarchist.

SD3 Batch Imagine.rar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1cd79d8cb6d2b736058367c93f8a7c4bf137af4782d9624080c4436475ee7ac
+size 7112

app.py

@@ -11,44 +11,44 @@ from typing import List
 
 # Define constants
 COMFYUI_DIR = r"C:\Users\bewiz\OneDrive\Desktop\AI\ComfyUI_windows_portable\ComfyUI"
-WORKFLOW_PATH = os.path.join(COMFYUI_DIR, 'sd3.json')  # Updated to use the new workflow file
+WORKFLOW_PATH = os.path.join(COMFYUI_DIR, 'sd3.json')
 OUTPUT_DIR = os.path.join(COMFYUI_DIR, 'output')
 URL = "http://127.0.0.1:8188/prompt"
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Read the workflow JSON file
+# Shared state for cancellation
+cancel_processing = False
+
 def read_workflow(file_path):
     logging.info(f"Reading workflow from {file_path}")
     with open(file_path, 'r') as file:
         workflow = json.load(file)
     return workflow
 
-# Update the workflow with the new prompt
-def update_workflow(workflow, prompt):
-    logging.info(f"Updating workflow with new prompt: {prompt}")
-    workflow["6"]["inputs"]["text"] = prompt  # Assuming the prompt should go into the same place in the new workflow
+def update_workflow(workflow, prompt, negative_prompt):
+    logging.info(f"Updating workflow with new prompts: {prompt}, negative: {negative_prompt}")
+    workflow["6"]["inputs"]["text"] = prompt
+    workflow["71"]["inputs"]["text"] = negative_prompt
     return workflow
 
-# Write the updated workflow back to the JSON file
 def write_workflow(workflow, file_path):
     logging.info(f"Writing updated workflow to {file_path}")
     with open(file_path, 'w') as file:
         json.dump(workflow, file, indent=4)
 
-# Send the workflow to ComfyUI
 def send_workflow_to_comfyui(workflow, url):
     headers = {"Content-Type": "application/json"}
     try:
         response = requests.post(url, headers=headers, json={"prompt": workflow})
         response.raise_for_status()
         logging.info(f"Workflow sent successfully: {response.status_code}")
+        logging.debug(f"Response content: {response.content}")
     except requests.exceptions.RequestException as e:
         logging.error(f"Error sending workflow to ComfyUI: {e}")
         raise
 
-# Monitor the output directory for new images
 def monitor_output_images(output_dir, previous_images, timeout=60):
     start_time = time.time()
     logging.info(f"Monitoring {output_dir} for new images...")
@@ -60,78 +60,117 @@ def monitor_output_images(output_dir, previous_images, timeout=60):
             logging.info(f"New image found: {latest_image}")
             return latest_image
         time.sleep(1)
-    raise TimeoutError("Timed out waiting for new image.")
+    logging.info(f"Timeout while waiting for new images in {output_dir}")
+    return None
 
-# Move the file with retries if the file is in use
-def move_file_with_retry(src, dst_dir, retries=5, delay=1):
-    dst = os.path.join(dst_dir, os.path.basename(src))
+def copy_file_with_retry(src, dst_dir, file_index, retries=5, delay=1):
+    dst = os.path.join(dst_dir, f"SD3_{file_index:05d}.png")
     for _ in range(retries):
         try:
-            if os.path.exists(dst):
-                base, ext = os.path.splitext(dst)
-                dst = f"{base}_{random.randint(1000, 9999)}{ext}"
-            shutil.move(src, dst)
+            shutil.copy(src, dst)
             return dst
         except PermissionError:
             time.sleep(delay)
-    raise PermissionError(f"Failed to move {src} to {dst} after {retries} retries")
+    raise PermissionError(f"Failed to copy {src} to {dst} after {retries} retries")
 
-# Zip files at specified intervals
 def zip_files(output_images: List[str], zip_interval: int, zip_folder: str):
     zip_files = []
     for i in range(0, len(output_images), zip_interval):
-        zip_filename = os.path.join(zip_folder, f"images_{i//zip_interval + 1}.zip")
+        zip_filename = os.path.join(zip_folder, f"images_{i//zip_interval + 1}_{time.time_ns()}.zip")
         with zipfile.ZipFile(zip_filename, 'w') as zipf:
             for img in output_images[i:i+zip_interval]:
                 zipf.write(img, os.path.basename(img))
         zip_files.append(zip_filename)
     return zip_files
 
-# Process the prompts
-def process_prompts(prompts_text, user_folder, zip_interval):
-    prompts = prompts_text.strip().split('\n')
+def process_prompts(prompts_text, negative_prompt_text, user_folder, zip_interval):
+    global cancel_processing
+    prompts = [line.strip() for line in prompts_text.split('\n\n') if line.strip()]
+    negative_prompts = [line.strip() for line in negative_prompt_text.split('\n') if line.strip()]
     output_images = []
+    zip_files_list = []
+    file_index = 1
 
     workflow = read_workflow(WORKFLOW_PATH)
 
     total_prompts = len(prompts)
     previous_images = os.listdir(OUTPUT_DIR)
-    zip_files_list = []
+
+    logs = ""
 
     try:
         for i, prompt in enumerate(prompts):
+            if cancel_processing:
+                logging.info("Processing cancelled by user.")
+                break
             if not prompt.strip():
                 continue
 
-            updated_workflow = update_workflow(workflow, prompt)
+            negative_prompt = negative_prompts[i] if i < len(negative_prompts) else ""
+
+            updated_workflow = update_workflow(workflow, prompt, negative_prompt)
             write_workflow(updated_workflow, WORKFLOW_PATH)
 
+            logging.debug(f"Updated workflow: {json.dumps(updated_workflow, indent=4)}")
+
             send_workflow_to_comfyui(updated_workflow, URL)
-            logging.info(f"Sent workflow to ComfyUI for prompt {i+1}/{total_prompts}")
+            logging.info(f"Sent workflow to ComfyUI for prompt {i + 1}/{total_prompts}")
 
-            try:
+            new_image = None
+            retries = 0
+            while new_image is None and retries < 5:
                 new_image = monitor_output_images(OUTPUT_DIR, previous_images)
-                new_image_path = os.path.join(OUTPUT_DIR, new_image)
-                moved_image_path = move_file_with_retry(new_image_path, user_folder)
-                logging.info(f"New image generated and moved to user folder: {moved_image_path}")
-            except TimeoutError as e:
-                logging.error(f"Error monitoring output images: {e}")
+                if new_image is None:
+                    retries += 1
+                    logging.warning(f"Retrying ({retries}/5)...")
+                    time.sleep(5)
+                else:
+                    time.sleep(2)
+
+            if new_image is None:
+                logging.error("Error monitoring output images: Timed out waiting for new image.")
+                continue
+
+            new_image_path = os.path.join(OUTPUT_DIR, new_image)
+            try:
+                copied_image_path = copy_file_with_retry(new_image_path, user_folder, file_index)
+                logging.info(f"New image generated and copied to user folder: {copied_image_path}")
+            except PermissionError as e:
+                logging.error(f"Failed to copy file after retries: {e}")
                 continue
 
-            output_images.append(moved_image_path)
-            time.sleep(2)  # Wait for 2 seconds before updating the image
-            yield moved_image_path, f"Processed {i + 1}/{total_prompts} - Done: {i + 1}, Left: {total_prompts - (i + 1)}"
+            output_images.append(copied_image_path)
+            previous_images.append(new_image)
+            file_index += 1
+
+            if len(output_images) % zip_interval == 0 and not cancel_processing:
+                zip_folder = os.path.join(user_folder, "zipped_images")
+                os.makedirs(zip_folder, exist_ok=True)
+                new_zip_files = zip_files(output_images[-zip_interval:], zip_interval, zip_folder)
+                zip_files_list.extend(new_zip_files)
 
-        # Zip files at the specified interval
-        zip_folder = os.path.join(user_folder, "zipped_images")
-        os.makedirs(zip_folder, exist_ok=True)
-        zip_files_list = zip_files(output_images, zip_interval, zip_folder)
+            logs += f"Processed {i + 1}/{total_prompts} - Done: {i + 1}, Left: {total_prompts - (i + 1)}\n"
+            yield output_images, zip_files_list, logs
+
+        if cancel_processing or (len(output_images) % zip_interval != 0):
+            zip_folder = os.path.join(user_folder, "zipped_images")
+            os.makedirs(zip_folder, exist_ok=True)
+            new_zip_files = zip_files(output_images, zip_interval, zip_folder)
+            zip_files_list.extend(new_zip_files)
 
     except KeyboardInterrupt:
         logging.info("Script interrupted by user.")
 
     return output_images, zip_files_list
 
+def cancel_processing_fn():
+    global cancel_processing
+    cancel_processing = True
+
+def reset_cancel_processing_fn():
+    global cancel_processing
+    cancel_processing = False
+
 def main():
     with gr.Blocks(css="""
     .gradio-container {font-family: Arial, sans-serif;}
@@ -151,46 +190,84 @@ def main():
         90% { color: #da70d6; }
         100% { color: #ff69b4; }
     }
+    .image-container img {
+        width: 250px;
+        height: 250px;
+    }
     """) as demo:
-        gr.Markdown("""
-        <h1 class="psychedelic-text">
-            <span>G</span><span>r</span><span>o</span><span>o</span><span>v</span><span>y</span>-
-            <span>S</span><span>t</span><span>y</span><span>l</span><span>S</span><span>u</span><span>i</span><span>t</span>;
-        </h1>
-        """)
-
-        gr.Markdown("ComfyUI Workflow Automation\nWelcome to the Groovy ComfyUI Workflow Automation tool. Enter your prompts below, one per line, and the tool will process each prompt sequentially.")
-
         with gr.Row():
             with gr.Column(scale=1):
+                gr.Markdown("### beWiZ's GroOvy SD3 Batch Imagine")
+                gr.HTML('<div class="image-container"><img src="https://raw.githubusercontent.com/downlifted/Groovy-StyleSuite/main/groovy.png" alt="GroOvy - SD3 Batch Imagine Logo"></div>')
+                with gr.Accordion("Developer Information", open=False):
+                    gr.Markdown("### Made by BeWiZ")
+                    gr.Markdown('<div class="image-container"><a href="https://twitter.com/AiAnarchist"><img src="https://raw.githubusercontent.com/downlifted/pictoprompt/master/aia.png" alt="BeWiZ Logo"></a></div>')
+                    gr.Markdown("Contact: [downlifted@gmail.com](mailto:downlifted@gmail.com)")
+                    gr.Markdown("Twitter: [@AiAnarchist](https://x.com/AiAnarchist)")
+                with gr.Accordion("About SD3 Batch Imagine", open=False):
+                    gr.Markdown("""
+                    ### SD3 Batch Imagine: Batch Image Generation
+                    Produce large batches of images using the latest SD3 Medium model. This tool allows you to generate images quickly and efficiently.
+                    - **ComfyUI**: For seamless integration and image processing.
+                    - **Hugging Face**: For state-of-the-art language models.
+                    - **Gradio**: For an intuitive user interface.
+                    """)
+
+                with gr.Accordion("Instructions", open=True):
+                    gr.Markdown("""
+                    **SD3 Batch Imagine Instructions**
+                    - Enter your prompts below, one per empty line.
+                    - Enter your negative prompts below, one per line. (Optional)
+                    - Set the zip interval to determine how many images will be included in each zip file.
+                    - Click "Process Prompts" to start generating images.
+                    - Click "Cancel Processing" to stop the current batch run.
+                    - Watch the progress as images are generated in real-time.
+                    - At the end of the process, zip files containing your images will be available for download.
+                    """)
+
+            with gr.Column(scale=2):
                 gr.Markdown("### Enter Prompts")
-                prompts_text = gr.Textbox(lines=20, placeholder="Enter your prompts here, one per line.")
+                prompts_text = gr.Textbox(lines=20, placeholder="Enter your prompts here, one per empty line.", label="Prompts")
+                negative_prompts_text = gr.Textbox(lines=5, placeholder="Enter your negative prompts here, one per line.", label="Negative Prompts")
                 zip_interval = gr.Number(value=10, label="Zip Interval", precision=0)
                 process_btn = gr.Button("Process Prompts")
+                cancel_btn = gr.Button("Cancel Processing")
                 progress_text = gr.Markdown("Progress")
-                output_image = gr.Image(label="Generated Image")
-                zip_file_list = gr.File(label="Zipped Files")
+                gallery_output = gr.Gallery(label="Generated Images")
+                zip_files_output = gr.Files(label="Zip Files")
+
+            with gr.Column(scale=1):
+                gr.Markdown("### Detailed Logs")
+                logs_output = gr.Textbox(lines=10, interactive=False, label="Logs")
 
                 def generate_user_folder():
-                    user_folder = os.path.normpath(os.path.join(OUTPUT_DIR, f'SD3{random.randint(100, 999)}'))
+                    user_folder = os.path.normpath(os.path.join(OUTPUT_DIR, f'SD3{random.randint(1000, 9999)}'))
                     os.makedirs(user_folder, exist_ok=True)
                     logging.info(f"Generated user folder: {user_folder}")
                     return user_folder
 
-                def on_click(prompts_text, zip_interval):
+                def on_click(prompts_text, negative_prompts_text, zip_interval):
+                    reset_cancel_processing_fn()
                     user_folder = generate_user_folder()
                     output_images, zip_files_list = [], []
-                    for image_path, progress_msg in process_prompts(prompts_text, user_folder, zip_interval):
-                        output_images.append(image_path)
-                        zip_files_list = zip_files(output_images, zip_interval, user_folder)
-                        yield image_path, zip_files_list, progress_msg
-                    latest_image = output_images[-1] if output_images else None
-                    return latest_image, zip_files_list
+                    logs = ""
+                    for images, zip_files, log_msg in process_prompts(prompts_text, negative_prompts_text, user_folder, zip_interval):
+                        output_images = images
+                        zip_files_list = zip_files
+                        logs = log_msg
+                        yield images, zip_files_list, logs
+                    return output_images, zip_files_list, logs
 
                 process_btn.click(
                     fn=on_click,
-                    inputs=[prompts_text, zip_interval],
-                    outputs=[output_image, zip_file_list, progress_text]
+                    inputs=[prompts_text, negative_prompts_text, zip_interval],
+                    outputs=[gallery_output, zip_files_output, logs_output]
+                )
+
+                cancel_btn.click(
+                    fn=cancel_processing_fn,
+                    inputs=[],
+                    outputs=[]
                 )
 
     demo.launch(share=True)