Update app.py

app.py

@@ -13,17 +13,18 @@ from flask import Flask, request, render_template, Response, stream_with_context
 from werkzeug.utils import secure_filename
 
 # Ensure gevent is imported and monkey patched if needed for other libraries
-# that might not be gevent-friendly. For built-in libs and requests (with Gunicorn gevent worker),
-# this is often handled by Gunicorn.
 # from gevent import monkey
 # monkey.patch_all() # Apply this early if you suspect issues with other libs
 
-import requests
+import requests # For requests.exceptions.HTTPError
+from requests.exceptions import HTTPError as RequestsHTTPError # Specific import for clarity
+
 import pdfplumber
 from pdf2image import convert_from_path, convert_from_bytes
 import pytesseract
 from PIL import Image
-from huggingface_hub import HfApi, create_repo, HfHubHTTPError
+from huggingface_hub import HfApi, create_repo
+# from huggingface_hub.utils import HfHubHTTPError # This was the incorrect one
 
 # --- Flask App Initialization ---
 app = Flask(__name__)
@@ -42,13 +43,11 @@ hf_api = HfApi()
 # --- Helper to yield messages for streaming ---
 def yield_message(type, data):
     """Helper to format messages as JSON strings for streaming."""
-    # Add a newline so client can easily split messages
     return json.dumps({"type": type, **data}) + "\n"
 
 # --- PDF Processing Helper Functions (Adapted for Streaming) ---
 
 def check_poppler():
-    # (Same as before)
     try:
         result = subprocess.run(["pdftoppm", "-v"], capture_output=True, text=True, check=False)
         version_info_log = result.stderr.strip() if result.stderr else result.stdout.strip()
@@ -65,37 +64,44 @@ def check_poppler():
         return False
 
 def ensure_hf_dataset():
-    # (Same as before, but logs info useful for streaming if an error occurs)
     if not HF_TOKEN:
         msg = "HF_TOKEN is not set. Cannot ensure Hugging Face dataset. Image uploads will fail."
         logger.warning(msg)
         return "Error: " + msg
     try:
+        # create_repo can raise huggingface_hub.utils.RepositoryNotFoundError, 
+        # huggingface_hub.utils.HfHubHTTPError (which inherits from requests.HTTPError for some cases),
+        # or other requests.exceptions
         repo_id_obj = create_repo(repo_id=HF_DATASET_REPO_NAME, token=HF_TOKEN, repo_type="dataset", exist_ok=True)
         logger.info(f"Dataset repo ensured: {repo_id_obj.repo_id}")
         return repo_id_obj.repo_id
-    except HfHubHTTPError as e:
-        if e.response.status_code == 409:
-             logger.info(f"Dataset repo '{HF_DATASET_REPO_NAME}' already exists.")
+    except RequestsHTTPError as e: # Catch HTTP errors from requests library directly
+        if e.response is not None and e.response.status_code == 409: # Conflict, repo already exists
+             logger.info(f"Dataset repo '{HF_DATASET_REPO_NAME}' already exists (HTTP 409).")
              # Attempt to construct the full repo_id (namespace/repo_name)
              try:
-                 user_info = hf_api.whoami(token=HF_TOKEN)
+                 user_info = hf_api.whoami(token=HF_TOKEN) # This call could also fail
                  namespace = user_info.get('name') if user_info else None
                  if namespace:
                      return f"{namespace}/{HF_DATASET_REPO_NAME}"
+                 else: # Fallback if namespace cannot be determined
+                     logger.warning(f"Could not determine namespace for existing repo '{HF_DATASET_REPO_NAME}'. Using generic ID.")
+                     return HF_DATASET_REPO_NAME # Or f"{YOUR_DEFAULT_USERNAME_IF_KNOWN}/{HF_DATASET_REPO_NAME}"
              except Exception as whoami_e:
-                 logger.error(f"Could not determine namespace for existing repo via whoami: {whoami_e}")
-             return f"hf://datasets/{HF_DATASET_REPO_NAME}" # Fallback, might not be full id
-        logger.error(f"Hugging Face dataset error (HTTP {e.response.status_code}): {str(e)}")
-        return f"Error: Failed to access or create dataset '{HF_DATASET_REPO_NAME}': {str(e)}"
-    except Exception as e:
-        logger.error(f"Hugging Face dataset error: {str(e)}", exc_info=True)
+                 logger.error(f"Could not determine namespace for existing repo via whoami due to: {whoami_e}. Using generic ID.")
+                 return HF_DATASET_REPO_NAME # Fallback
+        else: # Other HTTP errors
+            status_code = e.response.status_code if e.response is not None else "Unknown"
+            logger.error(f"Hugging Face dataset HTTP error (Status: {status_code}): {str(e)}")
+            return f"Error: Failed to access or create dataset '{HF_DATASET_REPO_NAME}' due to HTTP error: {str(e)}"
+    except Exception as e: # Catch other non-HTTP exceptions from huggingface_hub or general errors
+        # This could be Hf একাধিক RepoExistsError if exist_ok=False, or other utility errors.
+        # For exist_ok=True, a 409 is the more likely signal for existing repo.
+        logger.error(f"Hugging Face dataset general error: {str(e)}", exc_info=True)
         return f"Error: Failed to access or create dataset '{HF_DATASET_REPO_NAME}': {str(e)}"
 
 
 def upload_image_to_hf_stream(image_pil, filename_base, page_num_for_log=""):
-    # (Adapted to potentially yield status during this sub-process if it were longer)
-    # For now, it's synchronous but part of the larger stream.
     repo_id_or_error = ensure_hf_dataset()
     if isinstance(repo_id_or_error, str) and repo_id_or_error.startswith("Error"):
         return repo_id_or_error
@@ -117,7 +123,7 @@ def upload_image_to_hf_stream(image_pil, filename_base, page_num_for_log=""):
         )
         logger.info(f"Successfully uploaded image: {file_url}")
         return file_url
-    except Exception as e:
+    except Exception as e: # Catch broadly here; specific HF errors could be caught if needed
         logger.error(f"Image upload error for {filename_base}{page_num_for_log}: {str(e)}", exc_info=True)
         return f"Error uploading image {filename_base}{page_num_for_log}: {str(e)}"
     finally:
@@ -127,11 +133,7 @@ def upload_image_to_hf_stream(image_pil, filename_base, page_num_for_log=""):
 
 
 def format_page_text_to_markdown_chunk(page_text_content):
-    """Formats a single page's text content into a markdown chunk.
-       More complex formatting logic can be applied here page by page.
-    """
     chunk_md = ""
-    # Normalize newlines: multiple consecutive newlines become a single blank line (two \n chars)
     page_text_content = re.sub(r'\n\s*\n+', '\n\n', page_text_content.strip())
     lines = page_text_content.split('\n') 
     is_in_list = False
@@ -160,16 +162,10 @@ def format_page_text_to_markdown_chunk(page_text_content):
 # --- Main PDF Processing Logic (Generator Function for Streaming) ---
 
 def generate_pdf_conversion_stream(pdf_input_source_path_or_url):
-    """
-    Processes the PDF incrementally and yields status messages and markdown content.
-    `pdf_input_source_path_or_url` is a local file path or a URL string.
-    """
     try:
-        # Initial Markdown Title
         yield yield_message("markdown_replace", {"content": "# Extracted PDF Content\n\n"})
-        time.sleep(0.01) # Give gevent a chance to yield
+        time.sleep(0.01) 
 
-        # 1. Text and Table Extraction (Page by Page)
         yield yield_message("status", {"message": "Opening PDF for text extraction..."})
         time.sleep(0.01)
 
@@ -177,22 +173,26 @@ def generate_pdf_conversion_stream(pdf_input_source_path_or_url):
                         pdf_input_source_path_or_url.startswith(('http://', 'https://'))
         
         pdf_handle_for_text = None
-        pdf_bytes_for_images = None # Store bytes if downloaded from URL for image extraction
+        pdf_bytes_for_images = None 
 
         if source_is_url:
             try:
-                response = requests.get(pdf_input_source_path_or_url, stream=True, timeout=60) # Increased timeout
+                response = requests.get(pdf_input_source_path_or_url, stream=False, timeout=60) # stream=False to get content
                 response.raise_for_status()
-                pdf_bytes_for_images = response.content # Read all content for pdf2image
-                pdf_handle_for_text = io.BytesIO(pdf_bytes_for_images) # Use BytesIO for pdfplumber
+                pdf_bytes_for_images = response.content 
+                pdf_handle_for_text = io.BytesIO(pdf_bytes_for_images) 
                 yield yield_message("status", {"message": f"PDF downloaded from URL ({len(pdf_bytes_for_images)/1024:.2f} KB)."})
                 time.sleep(0.01)
-            except requests.RequestException as e:
-                logger.error(f"URL fetch error for PDF processing: {str(e)}", exc_info=True)
-                yield yield_message("error", {"message": f"Error fetching PDF from URL: {str(e)}"})
-                return # Stop generation
-        else: # Local file path
-             pdf_handle_for_text = pdf_input_source_path_or_url # pdfplumber takes path
+            except RequestsHTTPError as e: # Catch HTTP errors specifically
+                logger.error(f"URL fetch HTTP error for PDF processing: {str(e)} (Status: {e.response.status_code if e.response else 'N/A'})", exc_info=True)
+                yield yield_message("error", {"message": f"Error fetching PDF from URL (HTTP {e.response.status_code if e.response else 'N/A'}): {e.response.reason if e.response else str(e)}"})
+                return
+            except requests.RequestException as e: # Catch other network errors
+                logger.error(f"URL fetch network error for PDF processing: {str(e)}", exc_info=True)
+                yield yield_message("error", {"message": f"Network error fetching PDF from URL: {str(e)}"})
+                return 
+        else: 
+             pdf_handle_for_text = pdf_input_source_path_or_url 
 
         total_text_pages = 0
         try:
@@ -203,7 +203,7 @@ def generate_pdf_conversion_stream(pdf_input_source_path_or_url):
 
                 for i, page in enumerate(pdf.pages):
                     yield yield_message("status", {"message": f"Extracting text from page {i+1}/{total_text_pages}..."})
-                    time.sleep(0.01) # gevent yield
+                    time.sleep(0.01) 
                     
                     page_text = page.extract_text(layout=True, x_density=1, y_density=1) or ""
                     
@@ -211,10 +211,11 @@ def generate_pdf_conversion_stream(pdf_input_source_path_or_url):
                     tables = page.extract_tables()
                     if tables:
                         for table_idx, table_data in enumerate(tables):
-                            if table_data:
+                            if table_data and len(table_data) > 0 and len(table_data[0]) > 0 : # Check table has rows and columns
                                 yield yield_message("status", {"message": f"  Processing table {table_idx+1} on page {i+1}..."})
-                                header = [" | ".join(str(cell) if cell is not None else "" for cell in table_data[0])]
-                                separator = [" | ".join(["---"] * len(table_data[0]))]
+                                header_cells = table_data[0]
+                                header = [" | ".join(str(cell) if cell is not None else "" for cell in header_cells)]
+                                separator = [" | ".join(["---"] * len(header_cells))]
                                 body = [" | ".join(str(cell) if cell is not None else "" for cell in row) for row in table_data[1:]]
                                 table_md_lines = header + separator + body
                                 page_tables_md += f"**Table (Page {i+1}):**\n" + "\n".join(table_md_lines) + "\n\n"
@@ -224,11 +225,11 @@ def generate_pdf_conversion_stream(pdf_input_source_path_or_url):
                     yield yield_message("markdown_chunk", {"content": formatted_page_text_md})
                     if page_tables_md:
                         yield yield_message("markdown_chunk", {"content": page_tables_md})
-                    time.sleep(0.01) # gevent yield
+                    time.sleep(0.01) 
         except Exception as e:
             logger.error(f"Error during PDF text/table extraction: {str(e)}", exc_info=True)
             yield yield_message("error", {"message": f"Error during text extraction: {str(e)}"})
-            # Continue to image extraction if possible, or return based on severity
+            # Decide if to return or continue to image extraction. Let's try to continue.
 
         # 2. Image Extraction and OCR
         if not check_poppler():
@@ -242,52 +243,95 @@ def generate_pdf_conversion_stream(pdf_input_source_path_or_url):
             time.sleep(0.01)
             extracted_pil_images = []
             try:
+                image_source_for_convert = None
                 if source_is_url and pdf_bytes_for_images:
-                    # Use the already downloaded bytes
-                    extracted_pil_images = convert_from_bytes(pdf_bytes_for_images, dpi=150) # Lower DPI for speed/memory
-                elif not source_is_url: # local file path
-                    extracted_pil_images = convert_from_path(pdf_input_source_path_or_url, dpi=150)
+                    image_source_for_convert = pdf_bytes_for_images
+                    logger.info("Using downloaded bytes for image conversion.")
+                elif not source_is_url: 
+                    image_source_for_convert = pdf_input_source_path_or_url # Local file path
+                    logger.info("Using local file path for image conversion.")
                 
-                yield yield_message("status", {"message": f"Found {len(extracted_pil_images)} image(s) in PDF (these are rasterized pages for now)."})
-                time.sleep(0.01)
-
-                # TODO: Implement more granular image extraction if pdf2image supports it,
-                # or if you integrate a library that can extract embedded images directly.
-                # For now, convert_from_path/bytes often gives full pages as images.
-
-                for i, img_pil in enumerate(extracted_pil_images):
-                    page_num_for_log = f"page_{i+1}" # Assuming one image per page from convert_from_path
-                    yield yield_message("status", {"message": f"Processing image {i+1}/{len(extracted_pil_images)} (OCR & Upload)..."})
-                    time.sleep(0.01)
-                    
-                    ocr_text = ""
+                if image_source_for_convert:
+                    # Attempt to get page count for more granular image processing if pdf2image is the bottleneck
                     try:
-                        ocr_text = pytesseract.image_to_string(img_pil).strip()
-                        if ocr_text:
-                            yield yield_message("status", {"message": f"  OCR successful for image {i+1}."})
-                    except Exception as ocr_e:
-                        logger.error(f"OCR error for image {i+1}: {str(ocr_e)}")
-                        ocr_text = f"OCR failed: {str(ocr_e)}"
-                    
-                    image_md_chunk = ""
-                    if HF_TOKEN:
-                        image_url_or_error = upload_image_to_hf_stream(img_pil, "pdf_image", page_num_for_log)
-                        if isinstance(image_url_or_error, str) and not image_url_or_error.startswith("Error"):
-                            image_md_chunk += f"![Image {i+1}]({image_url_or_error})\n"
-                            yield yield_message("status", {"message": f"  Image {i+1} uploaded."})
-                        else:
-                            image_md_chunk += f"**Image {i+1} (Upload Error):** {str(image_url_or_error)}\n\n"
-                            yield yield_message("error", {"message": f"Failed to upload image {i+1}: {str(image_url_or_error)}"})
-                    else:
-                        image_md_chunk += f"**Image {i+1} (not uploaded due to missing HF_TOKEN)**\n"
-
-                    if ocr_text:
-                        image_md_chunk += f"**Image {i+1} OCR Text:**\n```\n{ocr_text}\n```\n\n"
-                    
-                    yield yield_message("image_md", {"content": image_md_chunk})
-                    time.sleep(0.01) # gevent yield
-
-            except Exception as e:
+                        pdf_info = None
+                        if isinstance(image_source_for_convert, bytes):
+                            pdf_info = pdf2image.pdfinfo_from_bytes(image_source_for_convert, userpw=None, poppler_path=None)
+                        else: # path
+                            pdf_info = pdf2image.pdfinfo_from_path(image_source_for_convert, userpw=None, poppler_path=None)
+                        
+                        num_image_pages = pdf_info.get("Pages", 0)
+                        yield yield_message("status", {"message": f"PDF has {num_image_pages} page(s) for potential image extraction."})
+                        
+                        # Process images page by page (or small batches) to save memory
+                        batch_size = 1 # Process one page at a time for images
+                        for page_idx_start in range(1, num_image_pages + 1, batch_size):
+                            page_idx_end = min(page_idx_start + batch_size - 1, num_image_pages)
+                            yield yield_message("status", {"message": f"Extracting images from page(s) {page_idx_start}-{page_idx_end}..."})
+                            time.sleep(0.01)
+                            
+                            page_images_pil = []
+                            if isinstance(image_source_for_convert, bytes):
+                                page_images_pil = convert_from_bytes(image_source_for_convert, dpi=150, first_page=page_idx_start, last_page=page_idx_end)
+                            else: # path
+                                page_images_pil = convert_from_path(image_source_for_convert, dpi=150, first_page=page_idx_start, last_page=page_idx_end)
+                            
+                            extracted_pil_images.extend(page_images_pil) # Add to overall list for sequential numbering later
+                            
+                            # Process this batch of images immediately
+                            for img_pil in page_images_pil:
+                                current_image_index = len(extracted_pil_images) # Current overall index
+                                page_num_for_log = f"page_{page_idx_start + page_images_pil.index(img_pil)}"
+                                yield yield_message("status", {"message": f"Processing image {current_image_index} (from PDF page {page_num_for_log}) (OCR & Upload)..."})
+                                time.sleep(0.01)
+                                
+                                ocr_text = ""
+                                try:
+                                    ocr_text = pytesseract.image_to_string(img_pil).strip()
+                                    if ocr_text: yield yield_message("status", {"message": f"  OCR successful for image {current_image_index}."})
+                                except Exception as ocr_e:
+                                    logger.error(f"OCR error for image {current_image_index}: {str(ocr_e)}")
+                                    ocr_text = f"OCR failed: {str(ocr_e)}"
+                                
+                                image_md_chunk = ""
+                                if HF_TOKEN:
+                                    image_url_or_error = upload_image_to_hf_stream(img_pil, "pdf_image", page_num_for_log)
+                                    if isinstance(image_url_or_error, str) and not image_url_or_error.startswith("Error"):
+                                        image_md_chunk += f"![Image {current_image_index}]({image_url_or_error})\n"
+                                        yield yield_message("status", {"message": f"  Image {current_image_index} uploaded."})
+                                    else:
+                                        image_md_chunk += f"**Image {current_image_index} (Upload Error):** {str(image_url_or_error)}\n\n"
+                                        yield yield_message("error", {"message": f"Failed to upload image {current_image_index}: {str(image_url_or_error)}"})
+                                else:
+                                    image_md_chunk += f"**Image {current_image_index} (not uploaded due to missing HF_TOKEN)**\n"
+
+                                if ocr_text:
+                                    image_md_chunk += f"**Image {current_image_index} OCR Text:**\n```\n{ocr_text}\n```\n\n"
+                                
+                                yield yield_message("image_md", {"content": image_md_chunk})
+                                time.sleep(0.01)
+                    except Exception as e_img_info:
+                        logger.error(f"Could not get PDF info for image batching or during batched conversion: {e_img_info}", exc_info=True)
+                        yield yield_message("error", {"message": f"Error preparing for image extraction: {e_img_info}. Trying bulk."})
+                        # Fallback to bulk conversion if pdfinfo or batching fails (original behavior)
+                        if isinstance(image_source_for_convert, bytes):
+                            extracted_pil_images = convert_from_bytes(image_source_for_convert, dpi=150)
+                        else: # path
+                            extracted_pil_images = convert_from_path(image_source_for_convert, dpi=150)
+                        # Process these bulk images (copy-paste the loop from above, adjust indexing)
+                        for i, img_pil in enumerate(extracted_pil_images):
+                            page_num_for_log = f"bulk_image_{i+1}"
+                            yield yield_message("status", {"message": f"Processing image {i+1}/{len(extracted_pil_images)} (OCR & Upload)..."}) # ... (rest of loop) ...
+                            # (omitted rest of duplicated loop for brevity, but it would be the same as the inner loop above)
+                            ocr_text = pytesseract.image_to_string(img_pil).strip() # Simplified for brevity
+                            image_md_chunk = f"![Image {i+1} Fallback]\n**OCR:** {ocr_text}\n\n"
+                            yield yield_message("image_md", {"content": image_md_chunk})
+                            time.sleep(0.01)
+
+                else: # No valid source for image conversion
+                    yield yield_message("status", {"message": "No valid source (URL download failed or no file path) for image extraction."})
+
+            except Exception as e: # Catch errors from the image extraction block
                 logger.error(f"Error during image extraction/processing: {str(e)}", exc_info=True)
                 yield yield_message("error", {"message": f"Error during image extraction: {str(e)}"})
         
@@ -309,12 +353,16 @@ def process_pdf_stream():
     pdf_file = request.files.get('pdf_file')
     pdf_url = request.form.get('pdf_url', '').strip()
     
-    temp_pdf_path = None # To store path of uploaded file for cleanup
-    pdf_input_source_for_generator = None
+    # Use a list to hold temp_pdf_path so it can be modified in the inner function
+    # and accessed in finally. Or pass it around.
+    # For simplicity, we'll rely on the generator's finally block if it's created within.
+    # Here, temp_pdf_path is primarily for the *uploaded* file before passing its path.
+    
+    outer_temp_pdf_path = None # For uploaded file cleanup
 
     def stream_processor():
-        nonlocal temp_pdf_path # Make it accessible in this inner function for cleanup
-        nonlocal pdf_input_source_for_generator
+        nonlocal outer_temp_pdf_path # Make it accessible in this inner function for cleanup
+        pdf_input_source_for_generator = None
 
         try:
             if pdf_file and pdf_file.filename:
@@ -323,13 +371,13 @@ def process_pdf_stream():
                     return
                 
                 filename = secure_filename(pdf_file.filename)
-                # Save to a temporary file (ensure UPLOAD_FOLDER is writable by app user)
                 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-                fd, temp_pdf_path = tempfile.mkstemp(suffix=".pdf", prefix="upload_", dir=app.config['UPLOAD_FOLDER'])
+                fd, temp_path = tempfile.mkstemp(suffix=".pdf", prefix="upload_", dir=app.config['UPLOAD_FOLDER'])
                 os.close(fd) 
-                pdf_file.save(temp_pdf_path)
-                logger.info(f"Uploaded PDF saved to temporary path: {temp_pdf_path}")
-                pdf_input_source_for_generator = temp_pdf_path
+                pdf_file.save(temp_path)
+                outer_temp_pdf_path = temp_path # Store for cleanup
+                logger.info(f"Uploaded PDF saved to temporary path: {outer_temp_pdf_path}")
+                pdf_input_source_for_generator = outer_temp_pdf_path
                 yield yield_message("status", {"message": f"Processing uploaded PDF: {filename}"})
                 time.sleep(0.01)
 
@@ -338,7 +386,6 @@ def process_pdf_stream():
                 if not (unquoted_url.startswith('http://') or unquoted_url.startswith('https://')):
                     yield yield_message("error", {"message": "Invalid URL scheme. Must be http or https."})
                     return
-                # Consider a light check for .pdf extension, but content-type is more reliable
                 
                 pdf_input_source_for_generator = unquoted_url
                 yield yield_message("status", {"message": f"Preparing to process PDF from URL: {unquoted_url}"})
@@ -347,33 +394,32 @@ def process_pdf_stream():
                 yield yield_message("error", {"message": "No PDF file uploaded and no PDF URL provided."})
                 return
 
-            # Yield from the main generator
             for message_part in generate_pdf_conversion_stream(pdf_input_source_for_generator):
                 yield message_part
-                # time.sleep(0.01) # Allow gevent to switch context, important for streaming
 
         except Exception as e:
             logger.error(f"Error setting up stream or in initial validation: {str(e)}", exc_info=True)
             yield yield_message("error", {"message": f"Setup error: {str(e)}"})
+        # The 'finally' block for cleaning outer_temp_pdf_path will be outside this generator,
+        # in the main route function after the Response is fully generated.
+        # However, with stream_with_context, the 'finally' here is better.
         finally:
-            if temp_pdf_path and os.path.exists(temp_pdf_path):
+            if outer_temp_pdf_path and os.path.exists(outer_temp_pdf_path):
                 try:
-                    os.remove(temp_pdf_path)
-                    logger.info(f"Cleaned up temporary PDF: {temp_pdf_path}")
-                    yield yield_message("status", {"message": f"Cleaned up temporary file."})
+                    os.remove(outer_temp_pdf_path)
+                    logger.info(f"Cleaned up temporary PDF: {outer_temp_pdf_path}")
+                    # Yielding from finally inside a generator that's part of a streamed response can be tricky.
+                    # It's better if status messages about cleanup are logged or handled differently.
+                    # For this case, logging is sufficient.
                 except OSError as ose:
-                    logger.error(f"Error removing temporary PDF {temp_pdf_path}: {ose}")
-                    yield yield_message("error", {"message": f"Could not clean temp file: {ose}"})
+                    logger.error(f"Error removing temporary PDF {outer_temp_pdf_path}: {ose}")
     
-    # Using stream_with_context for proper handling of request context within the generator
     return Response(stream_with_context(stream_processor()), mimetype='application/x-ndjson')
 
 
 # --- Main Execution ---
 if __name__ == '__main__':
-    if not check_poppler(): # Check Poppler at startup for local dev
+    if not check_poppler(): 
         logger.warning("Poppler utilities might not be installed correctly. PDF processing might fail.")
     os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-    # For local dev, Flask's built-in server is fine. Gunicorn handles production.
-    # The 'threaded=True' or using gevent server locally can also help test streaming.
     app.run(host='0.0.0.0', port=int(os.getenv("PORT", 7860)), debug=True, threaded=True)