Upload app.py with huggingface_hub

app.py

@@ -1074,268 +1074,155 @@ def save_to_html(content, source_type, filename=None):
 # Function to analyze images with a prompt for folder analysis
 def analyze_folder_images(folder_path, prompt):
     """Analyze all images in a folder."""
-    if not os.path.exists(folder_path):
-        return f"Folder path does not exist: {folder_path}"
+    # Add extensive logging to debug panel
+    logger.info(f"analyze_folder_images called with path: '{folder_path}'")
     
-    # Get list of image files
+    # Increment operations counter
+    gui_stats['operations_completed'] += 1
+    
+    if not folder_path or folder_path.strip() == "":
+        error_msg = "No folder path provided. Please enter a valid folder path."
+        logger.error(error_msg)
+        gui_stats['errors'] += 1
+        gui_stats['last_error'] = error_msg
+        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        return error_msg
+    
+    # Clean up the folder path
+    folder_path = folder_path.strip()
+    logger.debug(f"Cleaned folder path: '{folder_path}'")
+    
+    # Try multiple path options
+    potential_paths = [
+        folder_path,  # As provided
+        os.path.join(os.getcwd(), folder_path),  # Relative to cwd
+        os.path.normpath(folder_path),  # Normalized path
+        os.path.abspath(folder_path),  # Absolute path
+        os.path.expanduser(folder_path)  # Expand user directory (~)
+    ]
+    
+    # If we're in a Hugging Face Space, try the /data path
+    if os.path.exists("/data"):
+        potential_paths.append(os.path.join("/data", folder_path))
+    
+    # Debug information
+    logger.debug(f"Current working directory: {os.getcwd()}")
+    try:
+        logger.debug(f"Directory contents of current directory: {os.listdir('.')}")
+    except Exception as e:
+        logger.warning(f"Could not list current directory: {str(e)}")
+    
+    # Try each path
+    valid_path = None
+    for test_path in potential_paths:
+        logger.debug(f"Testing path: '{test_path}'")
+        if os.path.exists(test_path):
+            logger.debug(f"Path exists: '{test_path}'")
+            if os.path.isdir(test_path):
+                valid_path = test_path
+                logger.info(f"Found valid directory path: '{valid_path}'")
+                break
+            else:
+                logger.debug(f"Path exists but is not a directory: '{test_path}'")
+    
+    if not valid_path:
+        error_msg = f"Could not find a valid directory at '{folder_path}'. Please provide a complete and valid folder path."
+        logger.error(error_msg)
+        gui_stats['errors'] += 1
+        gui_stats['last_error'] = error_msg
+        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        
+        # Try to provide helpful information about available directories
+        try:
+            available_dirs = [d for d in os.listdir('.') if os.path.isdir(d)]
+            if available_dirs:
+                return f"Error: {error_msg}\n\nAvailable directories in current location: {', '.join(available_dirs)}"
+            else:
+                return f"Error: {error_msg}\n\nNo directories found in the current location."
+        except:
+            return f"Error: {error_msg}"
+    
+    # Convert to Path object for easier handling
+    folder_path = Path(valid_path)
+    logger.debug(f"Using folder path: {folder_path}")
+    
+    # Find all image files in the directory
     image_files = []
     for ext in SUPPORTED_EXTENSIONS:
-        image_files.extend(glob.glob(os.path.join(folder_path, f"*{ext}")))
+        logger.debug(f"Searching for files with extension: {ext}")
+        # Use glob patterns that are case-insensitive
+        image_files.extend(list(folder_path.glob(f"*{ext.lower()}")))
+        image_files.extend(list(folder_path.glob(f"*{ext.upper()}")))
+    
+    logger.info(f"Found {len(image_files)} images in {folder_path}")
     
     if not image_files:
-        return f"No supported images found in folder: {folder_path}"
+        error_msg = f"No supported image files found in '{folder_path}'. Supported formats: {', '.join(SUPPORTED_EXTENSIONS)}"
+        logger.warning(error_msg)
+        gui_stats['warnings'] += 1
+        gui_stats['last_warning'] = error_msg
+        gui_stats['last_warning_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        return error_msg
     
-    # Sort files by name
+    # Sort the files for consistent output
     image_files.sort()
     
-    result = f"Found {len(image_files)} images in folder: {os.path.basename(folder_path)}\n\n"
+    results = []
+    results.append(f"Found {len(image_files)} images in {folder_path}\n")
     
-    # Process each image file
-    for image_file in image_files:
-        file_name = os.path.basename(image_file)
-        result += f"---\nImage: {file_name}\n"
-        
-        # For PDF files, handle differently
-        if file_name.lower().endswith('.pdf'):
-            try:
-                logger.info(f"Processing PDF file in folder analysis: {image_file}")
-                logger.debug(f"PDF absolute path: {os.path.abspath(image_file)}")
-                logger.debug(f"PDF exists: {os.path.exists(image_file)}")
-                logger.debug(f"PDF file size: {os.path.getsize(image_file) if os.path.exists(image_file) else 'N/A'}")
-                
-                # Load model here to ensure it's ready
-                model, tokenizer = load_model()
-                if model is None or tokenizer is None:
-                    logger.error("Model failed to load for PDF analysis")
-                    result += "Error: Model failed to load for PDF analysis.\n"
-                    continue
-                
-                # Try a completely different approach for PDFs to avoid tensor issues
-                try:
-                    # Convert PDF to images with detailed logging
-                    logger.info(f"Starting PDF to image conversion for {file_name}")
-                    with open(image_file, 'rb') as pdf_file:
-                        pdf_data = pdf_file.read()
-                        logger.debug(f"Read {len(pdf_data)} bytes from PDF file")
-                    
-                    # Try both methods
-                    try:
-                        logger.debug("Attempting convert_from_path...")
-                        pdf_images = convert_from_path(image_file)
-                        logger.info(f"convert_from_path successful: {len(pdf_images)} pages")
-                    except Exception as path_err:
-                        logger.error(f"convert_from_path failed: {str(path_err)}")
-                        logger.error(traceback.format_exc())
-                        
-                        # Fall back to bytes method
-                        logger.debug("Falling back to convert_from_bytes...")
-                        pdf_images = convert_from_bytes(pdf_data)
-                        logger.info(f"convert_from_bytes successful: {len(pdf_images)} pages")
-                    
-                    logger.info(f"PDF converted to {len(pdf_images)} pages")
-                    
-                    if not pdf_images or len(pdf_images) == 0:
-                        logger.error("PDF converted but no pages were extracted")
-                        result += "PDF converted but no pages were extracted.\n"
-                        continue
-                    
-                    # Process each page separately to avoid batch issues
-                    for i, img in enumerate(pdf_images):
-                        try:
-                            logger.info(f"Processing PDF page {i+1}/{len(pdf_images)}")
-                            logger.debug(f"Page {i+1} image: size={img.size}, mode={img.mode}")
-                            
-                            # Manual preprocessing - don't use the typical image loading pipeline
-                            logger.debug("Converting image to RGB")
-                            img = img.convert('RGB')
-                            
-                            # Log the image info for debugging
-                            logger.debug(f"After RGB conversion: size={img.size}, mode={img.mode}")
-                            
-                            # Resize and transform manually
-                            logger.debug(f"Resizing image to {IMAGE_SIZE}x{IMAGE_SIZE}")
-                            img_resized = img.resize((IMAGE_SIZE, IMAGE_SIZE))
-                            logger.debug(f"After resize: size={img_resized.size}, mode={img_resized.mode}")
-                            
-                            # Build transform and apply it
-                            logger.debug("Building and applying transform")
-                            transform = T.Compose([
-                                T.ToTensor(),
-                                T.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)
-                            ])
-                            
-                            # Transform to tensor with explicit error handling
-                            try:
-                                logger.debug("Converting image to tensor")
-                                tensor = transform(img_resized)
-                                logger.debug(f"Transform successful: tensor shape={tensor.shape}, dtype={tensor.dtype}")
-                                
-                                # Log tensor stats for debugging numerical issues
-                                if tensor.numel() > 0:
-                                    logger.debug(f"Tensor stats: min={tensor.min().item():.4f}, max={tensor.max().item():.4f}, "
-                                                f"mean={tensor.mean().item():.4f}, std={tensor.std().item():.4f}")
-                                
-                                # Add batch dimension with careful checking
-                                if isinstance(tensor, torch.Tensor):
-                                    logger.debug("Adding batch dimension")
-                                    tensor = tensor.unsqueeze(0)
-                                    logger.debug(f"After unsqueeze: shape={tensor.shape}")
-                                else:
-                                    logger.error(f"Expected tensor but got {type(tensor)}")
-                                    raise TypeError(f"Transform returned {type(tensor)} instead of tensor")
-                            except Exception as tensor_err:
-                                logger.error(f"Error in tensor creation: {str(tensor_err)}")
-                                logger.error(traceback.format_exc())
-                                raise
-                            
-                            # Move to device and set data type
-                            device = "cuda" if torch.cuda.is_available() else "cpu"
-                            logger.debug(f"Moving tensor to device: {device}")
-                            tensor = tensor.to(device)
-                            
-                            if torch.cuda.is_available():
-                                logger.debug("Converting tensor to bfloat16")
-                                tensor = tensor.to(torch.bfloat16)
-                            
-                            logger.info(f"Preprocessed tensor: shape={tensor.shape}, device={tensor.device}, dtype={tensor.dtype}")
-                            
-                            # Use direct text generation
-                            page_prompt = f"PDF Page {i+1}: {prompt}"
-                            logger.debug(f"Preparing tokenization for prompt: {page_prompt}")
-                            input_tokens = tokenizer(page_prompt, return_tensors="pt").to(device)
-                            logger.debug(f"Tokenization complete: shape={input_tokens['input_ids'].shape}")
-                            
-                            # Generate with proper error handling
-                            try:
-                                # Try direct generation first
-                                logger.info("Attempting direct generation")
-                                outputs = model.generate(
-                                    input_tokens["input_ids"],
-                                    pixel_values=tensor,
-                                    max_new_tokens=512,
-                                    do_sample=False
-                                )
-                                logger.info("Generation successful")
-                                response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-                                logger.debug(f"Response length: {len(response)} chars")
-                            except Exception as gen_err:
-                                logger.error(f"Error in direct generation: {str(gen_err)}")
-                                logger.error(traceback.format_exc())
-                                
-                                # Fall back to chat method
-                                try:
-                                    print("Trying chat method fallback")
-                                    question = f"<image>\n{page_prompt}"
-                                    # IMPORTANT: Ensure we're not passing a list here!
-                                    if isinstance(tensor, list):
-                                        print("WARNING: tensor is a list, converting...")
-                                        if len(tensor) > 0:
-                                            # Take the first item if it's a tensor
-                                            if isinstance(tensor[0], torch.Tensor):
-                                                tensor = tensor[0].unsqueeze(0)
-                                            else:
-                                                # Create a new tensor from scratch
-                                                print("Creating new tensor from scratch")
-                                                tensor = torch.zeros((1, 3, IMAGE_SIZE, IMAGE_SIZE), 
-                                                                   dtype=torch.float32).to(device)
-                                                if torch.cuda.is_available():
-                                                    tensor = tensor.to(torch.bfloat16)
-                                        else:
-                                            # Create a dummy tensor
-                                            tensor = torch.zeros((1, 3, IMAGE_SIZE, IMAGE_SIZE), 
-                                                               dtype=torch.float32).to(device)
-                                            if torch.cuda.is_available():
-                                                tensor = tensor.to(torch.bfloat16)
-                                    
-                                    # Verify tensor shape and type before passing to model
-                                    print(f"Final tensor type: {type(tensor)}, shape: {tensor.shape if hasattr(tensor, 'shape') else 'unknown'}")
-                                    
-                                    # Use the chat method with verified tensor
-                                    response, _ = model.chat(
-                                        tokenizer=tokenizer,
-                                        pixel_values=tensor,
-                                        question=question,
-                                        generation_config={"max_new_tokens": 512, "do_sample": False},
-                                        history=None,
-                                        return_history=True
-                                    )
-                                except Exception as chat_err:
-                                    print(f"Chat fallback failed: {str(chat_err)}")
-                                    import traceback
-                                    print(traceback.format_exc())
-                                    
-                                    # Last attempt - use direct model forward pass
-                                    try:
-                                        print("Attempting direct model forward pass")
-                                        # Create inputs manually
-                                        if hasattr(model, "forward"):
-                                            # Create tensors from scratch if needed
-                                            if not isinstance(tensor, torch.Tensor):
-                                                tensor = torch.zeros((1, 3, IMAGE_SIZE, IMAGE_SIZE), 
-                                                                   dtype=torch.float32).to(device)
-                                                if torch.cuda.is_available():
-                                                    tensor = tensor.to(torch.bfloat16)
-                                                    
-                                            # Get input tokens in the right format
-                                            input_ids = input_tokens["input_ids"]
-                                            if len(input_ids.shape) == 1:
-                                                input_ids = input_ids.unsqueeze(0)
-                                            
-                                            # Prepare inputs for direct call
-                                            inputs = {
-                                                "input_ids": input_ids,
-                                                "pixel_values": tensor,
-                                                "return_dict": True,
-                                            }
-                                            # Call model directly
-                                            outputs = model(**inputs)
-                                            # Try to get some output
-                                            if hasattr(outputs, "logits") and outputs.logits is not None:
-                                                pred_ids = torch.argmax(outputs.logits, dim=-1)
-                                                response = tokenizer.decode(pred_ids[0], skip_special_tokens=True)
-                                            else:
-                                                response = "Failed to generate analysis - model output didn't contain usable data"
-                                        else:
-                                            response = "Failed to generate analysis - model doesn't support direct calling"
-                                    except Exception as final_err:
-                                        print(f"All attempts failed: {str(final_err)}")
-                                        import traceback
-                                        print(traceback.format_exc())
-                                        response = f"Analysis failed due to model error: {str(final_err)}"
-                            
-                            # Add to result
-                            result += f"\n-- PDF Page {i+1} --\n{response.strip()}\n"
-                            
-                        except Exception as page_err:
-                            print(f"Error processing page {i+1}: {str(page_err)}")
-                            import traceback
-                            print(traceback.format_exc())
-                            result += f"\n-- PDF Page {i+1} --\nError: {str(page_err)}\n"
-                    
-                except Exception as pdf_err:
-                    print(f"PDF processing error: {str(pdf_err)}")
-                    import traceback
-                    print(traceback.format_exc())
-                    result += f"Failed to process PDF: {str(pdf_err)}\n"
-                
-            except Exception as e:
-                print(f"General exception in PDF processing: {str(e)}")
-                import traceback
-                print(traceback.format_exc())
-                result += f"Failed to process PDF: {str(e)}\n"
-        else:
-            # Regular image processing
+    # Load model once for all images
+    logger.info("Loading model for folder analysis")
+    model, tokenizer = load_model()
+    if model is None or tokenizer is None:
+        error_msg = "Error: Could not load model for image analysis"
+        logger.error(error_msg)
+        gui_stats['errors'] += 1
+        gui_stats['last_error'] = error_msg
+        gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+        return error_msg
+    
+    # Process each image
+    for i, img_path in enumerate(image_files, 1):
+        try:
+            logger.info(f"Processing image {i}/{len(image_files)}: {img_path.name}")
+            
+            # Open and process the image
             try:
-                image = Image.open(image_file).convert('RGB')
-                image_result = process_image_with_text(image, prompt)
-                result += f"\n{image_result}\n"
-            except Exception as e:
-                print(f"Error processing image {image_file}: {str(e)}")
-                import traceback
-                print(traceback.format_exc())
-                result += f"Error processing image: {str(e)}\n"
+                image = Image.open(img_path).convert('RGB')
+                logger.debug(f"Image loaded: size={image.size}, mode={image.mode}")
+            except Exception as img_err:
+                error_msg = f"Error opening image {img_path.name}: {str(img_err)}"
+                logger.error(error_msg)
+                logger.error(traceback.format_exc())
+                gui_stats['errors'] += 1
+                gui_stats['last_error'] = error_msg
+                gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+                results.append(f"---\nImage {i}/{len(image_files)}: {img_path.name}\nError opening image: {str(img_err)}\n")
+                continue
+            
+            # Process image
+            logger.debug(f"Processing image with prompt: {prompt}")
+            # Use the more reliable process_image_with_text function
+            image_result = process_image_with_text(image, f"Image {i}/{len(image_files)} - {img_path.name}: {prompt}")
+            
+            # Add result with separator
+            results.append(f"---\nImage {i}/{len(image_files)}: {img_path.name}\n{image_result}\n")
+            
+            # Log success
+            logger.info(f"Successfully processed image {i}/{len(image_files)}: {img_path.name}")
+            
+        except Exception as e:
+            error_msg = f"Error processing image {img_path.name}: {str(e)}"
+            logger.error(error_msg)
+            logger.error(traceback.format_exc())
+            gui_stats['errors'] += 1
+            gui_stats['last_error'] = error_msg
+            gui_stats['last_error_time'] = datetime.datetime.now().strftime("%H:%M:%S")
+            results.append(f"---\nImage {i}/{len(image_files)}: {img_path.name}\nError: {str(e)}\n")
     
-    return result
+    combined_result = "\n".join(results)
+    logger.info(f"Folder analysis complete, processed {len(image_files)} images")
+    return combined_result
 
 # Function to process an image with text prompt
 def process_image_with_text(image, prompt):
@@ -1882,10 +1769,36 @@ def main():
             
             # Tab for folder analysis
             with gr.Tab("Folder Analysis"):
-                gr.Markdown("Analyze all images and PDFs in a specified folder")
+                gr.Markdown("## Analyze all images and PDFs in a folder")
+                gr.Markdown("""
+                Please enter a complete folder path. You can try these options:
+                - Absolute path (e.g., `/home/user/images`)
+                - Relative path from current directory (e.g., `example_images`)
+                - Path with ~ for home directory (e.g., `~/images`)
+                """)
                 
                 with gr.Row():
-                    folder_path = gr.Textbox(label="Folder Path", placeholder="Enter the path to the folder")
+                    with gr.Column(scale=4):
+                        folder_path = gr.Textbox(
+                            label="Folder Path", 
+                            placeholder="Enter the complete path to the folder containing images",
+                            value="example_images"  # Default to example folder
+                        )
+                    with gr.Column(scale=1):
+                        example_folders = gr.Dropdown(
+                            choices=["example_images", "example_images_2", "/data/images", "images"],
+                            label="Example Folders",
+                            value="example_images"
+                        )
+                
+                def set_folder_path(folder):
+                    return folder
+                
+                example_folders.change(
+                    fn=set_folder_path,
+                    inputs=[example_folders],
+                    outputs=[folder_path]
+                )
                 
                 prompt_folder = gr.Dropdown(
                     label="Analysis Prompt",
@@ -1893,23 +1806,142 @@ def main():
                     value=prompts[0],
                     allow_custom_value=True
                 )
-                analyze_btn_folder = gr.Button("Analyze Folder")
+                
+                # Show folder contents without analyzing
+                view_folder_btn = gr.Button("View Folder Contents")
+                folder_contents = gr.Markdown("Select a folder and click 'View Folder Contents' to see available images")
+                
+                def view_folder_contents(folder_path):
+                    """List all image files in the folder without analyzing them."""
+                    logger.info(f"Viewing contents of folder: '{folder_path}'")
+                    
+                    if not folder_path or folder_path.strip() == "":
+                        return "Please enter a folder path."
+                    
+                    # Clean up the folder path
+                    folder_path = folder_path.strip()
+                    
+                    # Try multiple path options
+                    potential_paths = [
+                        folder_path,
+                        os.path.join(os.getcwd(), folder_path),
+                        os.path.normpath(folder_path),
+                        os.path.abspath(folder_path),
+                        os.path.expanduser(folder_path)
+                    ]
+                    
+                    # If we're in a Hugging Face Space, try the /data path
+                    if os.path.exists("/data"):
+                        potential_paths.append(os.path.join("/data", folder_path))
+                    
+                    # Try each path
+                    valid_path = None
+                    for test_path in potential_paths:
+                        if os.path.exists(test_path) and os.path.isdir(test_path):
+                            valid_path = test_path
+                            break
+                    
+                    if not valid_path:
+                        return f"Could not find a valid directory at '{folder_path}'.\n\nTried the following paths:\n" + "\n".join(f"- {p}" for p in potential_paths)
+                    
+                    # List image files
+                    image_files = []
+                    for ext in SUPPORTED_EXTENSIONS:
+                        files = glob.glob(os.path.join(valid_path, f"*{ext}"))
+                        files.extend(glob.glob(os.path.join(valid_path, f"*{ext.upper()}")))
+                        image_files.extend(files)
+                    
+                    # Sort
+                    image_files.sort()
+                    
+                    if not image_files:
+                        return f"No supported image files found in '{valid_path}'.\n\nSupported formats: {', '.join(SUPPORTED_EXTENSIONS)}"
+                    
+                    # Format as markdown
+                    output = f"### Found {len(image_files)} images in '{valid_path}'\n\n"
+                    for i, file in enumerate(image_files, 1):
+                        file_name = os.path.basename(file)
+                        file_size = os.path.getsize(file) / 1024  # KB
+                        output += f"{i}. **{file_name}** ({file_size:.1f} KB)\n"
+                    
+                    output += f"\nPath used: `{valid_path}`"
+                    return output
+                
+                view_folder_btn.click(
+                    fn=view_folder_contents,
+                    inputs=[folder_path],
+                    outputs=[folder_contents]
+                )
+                
+                gr.Markdown("---")
+                analyze_btn_folder = gr.Button("Analyze All Images in Folder", variant="primary")
                 output_folder = gr.Textbox(label="Analysis Result", lines=20)
                 
-                # Save button for folder analysis
-                save_btn_folder = gr.Button("Save Results to File")
-                save_status_folder = gr.Textbox(label="Save Status", lines=1)
+                # Status indicator
+                with gr.Row():
+                    folder_status = gr.Markdown("Ready to analyze folder images")
+                
+                # Define a function to update status while processing
+                def analyze_with_status(folder_path, prompt):
+                    folder_status_msg = "Starting folder analysis..."
+                    yield folder_status_msg, ""
+                    
+                    try:
+                        # Get number of potential images
+                        try:
+                            folder_path = folder_path.strip()
+                            folder_obj = Path(folder_path)
+                            if folder_obj.exists() and folder_obj.is_dir():
+                                image_count = sum(1 for _ in folder_obj.glob("*.*") if _.suffix.lower() in SUPPORTED_EXTENSIONS)
+                                folder_status_msg = f"Found {image_count} images to process. Starting analysis..."
+                                yield folder_status_msg, ""
+                        except:
+                            pass
+                            
+                        # Run analysis
+                        folder_status_msg = "Processing images... (this may take several minutes)"
+                        yield folder_status_msg, ""
+                        
+                        # Run the actual analysis
+                        result = analyze_folder_images(folder_path, prompt)
+                        
+                        folder_status_msg = "Folder analysis complete!"
+                        yield folder_status_msg, result
+                    except Exception as e:
+                        error_msg = f"Error analyzing folder: {str(e)}"
+                        folder_status_msg = "Analysis failed! See error message in results."
+                        yield folder_status_msg, error_msg
                 
                 analyze_btn_folder.click(
-                    fn=analyze_folder_images,
+                    fn=analyze_with_status,
                     inputs=[folder_path, prompt_folder],
-                    outputs=output_folder
+                    outputs=[folder_status, output_folder]
                 )
                 
+                # Save button for folder analysis
+                with gr.Row():
+                    save_btn_folder = gr.Button("Save Results to Text File")
+                    save_json_folder = gr.Button("Save Results as JSON")
+                    save_html_folder = gr.Button("Save Results as HTML")
+                
+                save_status_folder = gr.Textbox(label="Save Status", lines=1)
+                
                 save_btn_folder.click(
                     fn=lambda text, prompt: save_to_file(text, "folder_analysis", prompt=prompt),
                     inputs=[output_folder, prompt_folder],
-                    outputs=save_status_folder
+                    outputs=[save_status_folder]
+                )
+                
+                save_json_folder.click(
+                    fn=lambda content: save_to_json(content, "folder", "Folder analysis", None)[0],
+                    inputs=[output_folder],
+                    outputs=[save_status_folder]
+                )
+                
+                save_html_folder.click(
+                    fn=lambda content: save_to_html(content, "folder")[0],
+                    inputs=[output_folder],
+                    outputs=[save_status_folder]
                 )
             
             # Add a new tab for logs