Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py -- Backend v5 (Gemini -> JSON -> Advanced DOCX)
+# app.py -- Backend v6 (Enhanced: Tables, Images, Emojis, Icons)
 # Universal Document Enhancer - Works for ANY document type
 import os
 import io
@@ -10,16 +10,16 @@ import base64
 from fastapi import FastAPI, File, UploadFile, Form
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, StreamingResponse
-from typing import Optional
+from typing import Optional, List, Dict, Any
 import fitz  # pymupdf
 from docx import Document
 from docx.shared import Pt, Inches, RGBColor
 from docx.enum.text import WD_ALIGN_PARAGRAPH
-from docx.oxml.ns import qn
+from docx.oxml.shared import OxmlElement, qn
 from PIL import Image
 import requests
 
-app = FastAPI(title="Document Enhancer v5")
+app = FastAPI(title="Document Enhancer v6")
 
 app.add_middleware(
     CORSMiddleware,
@@ -62,30 +62,20 @@ def sanitize_filename(filename: str) -> str:
     if not filename:
         return "document.docx"
     
-    # Remove file extension first
     name_without_ext = filename.rsplit('.', 1)[0] if '.' in filename else filename
     
-    # Convert to ASCII, removing/replacing non-ASCII characters
-    # This will convert – to -, é to e, etc.
     try:
         ascii_name = name_without_ext.encode('ascii', 'ignore').decode('ascii')
     except:
         ascii_name = "document"
     
-    # If nothing left after ASCII conversion, use default
     if not ascii_name or not ascii_name.strip():
         ascii_name = "document"
     
-    # Remove any remaining problematic characters (keep only alphanumeric, spaces, hyphens, underscores)
     safe_name = re.sub(r'[^\w\s\-]', '', ascii_name)
-    
-    # Replace multiple spaces/hyphens with single underscore
     safe_name = re.sub(r'[\s\-]+', '_', safe_name)
-    
-    # Trim and ensure not empty
     safe_name = safe_name.strip('_') or "document"
     
-    # Add .docx extension
     return f"{safe_name}.docx"
 
 
@@ -97,35 +87,27 @@ def repair_truncated_json(json_str: str) -> str:
     Attempt to repair truncated JSON by closing open structures.
     """
     try:
-        # Count open/close brackets
         open_braces = json_str.count('{')
         close_braces = json_str.count('}')
         open_brackets = json_str.count('[')
         close_brackets = json_str.count(']')
         
-        # If JSON is truncated mid-string, remove the incomplete part
         if json_str.rstrip().endswith('"'):
-            # Find the last complete object
             last_complete = json_str.rfind('"}')
             if last_complete != -1:
                 json_str = json_str[:last_complete + 2]
         else:
-            # Remove trailing incomplete text
             last_quote = json_str.rfind('"')
             if last_quote != -1:
-                # Check if this quote is part of an incomplete string
                 after_quote = json_str[last_quote + 1:].strip()
                 if after_quote and after_quote[0] not in [',', '}', ']']:
-                    # Incomplete string, remove it
                     prev_comma = json_str.rfind(',', 0, last_quote)
                     if prev_comma != -1:
                         json_str = json_str[:prev_comma]
         
-        # Close any open arrays
         for _ in range(open_brackets - close_brackets):
             json_str += ']'
         
-        # Close any open objects
         for _ in range(open_braces - close_braces):
             json_str += '}'
         
@@ -139,30 +121,23 @@ def repair_truncated_json(json_str: str) -> str:
 # -------------------------
 def clean_gemini_json(raw_text: str) -> str:
     """
-    Removes markdown code fences and wrappers from Gemini output so it becomes
-    valid JSON text for json.loads().
+    Removes markdown code fences and wrappers from Gemini output.
     """
     if not raw_text:
         return raw_text
     cleaned = raw_text.strip()
 
-    # Remove triple-backticks blocks like ```json ... ```
     if cleaned.startswith("```"):
-        # remove first fence and any language marker
         first_line_end = cleaned.find("\n")
         if first_line_end != -1:
             cleaned = cleaned[first_line_end + 1 :]
-        # strip trailing ```
         if cleaned.endswith("```"):
             cleaned = cleaned[: -3]
 
-    # Remove single-line wrappers like: json: { ... }
-    # Remove leading words until first brace
     first_brace = cleaned.find("{")
     if first_brace > 0:
         cleaned = cleaned[first_brace :]
 
-    # Trim again
     return cleaned.strip()
 
 
@@ -181,57 +156,122 @@ def detect_file_type(filename: str) -> str:
 
 
 # -------------------------
-# Extract text (PDF/DOCX/TXT)
+# Extract text, tables, and images (ENHANCED)
 # -------------------------
 def extract_text_and_layout(file_bytes: bytes, kind: str):
     """
-    Returns (text, layout_info). layout_info is reserved for future use.
+    Returns (text, extracted_data) where extracted_data contains:
+    - tables: list of table data
+    - images: list of base64 encoded images with positions
     """
+    extracted_data = {"tables": [], "images": []}
+    
     try:
         if kind == "pdf":
             doc = fitz.open(stream=file_bytes, filetype="pdf")
             texts = []
-            for page in doc:
+            
+            for page_num, page in enumerate(doc):
+                # Extract text
                 texts.append(page.get_text())
-            return "\n\n".join(texts), None
+                
+                # Extract tables
+                tables = page.find_tables()
+                for table_idx, table in enumerate(tables):
+                    try:
+                        table_data = table.extract()
+                        if table_data:
+                            extracted_data["tables"].append({
+                                "page": page_num + 1,
+                                "data": table_data,
+                                "position": f"page_{page_num + 1}_table_{table_idx + 1}"
+                            })
+                    except:
+                        pass
+                
+                # Extract images
+                image_list = page.get_images()
+                for img_idx, img in enumerate(image_list):
+                    try:
+                        xref = img[0]
+                        base_image = doc.extract_image(xref)
+                        image_bytes = base_image["image"]
+                        image_base64 = base64.b64encode(image_bytes).decode()
+                        
+                        extracted_data["images"].append({
+                            "page": page_num + 1,
+                            "data": image_base64,
+                            "ext": base_image["ext"],
+                            "position": f"page_{page_num + 1}_img_{img_idx + 1}"
+                        })
+                    except:
+                        pass
+            
+            return "\n\n".join(texts), extracted_data
 
         elif kind == "docx":
             from docx import Document as DocReader
 
             doc = DocReader(io.BytesIO(file_bytes))
-            paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
-            return "\n\n".join(paragraphs), None
+            texts = []
+            
+            # Extract paragraphs
+            for para in doc.paragraphs:
+                if para.text.strip():
+                    texts.append(para.text)
+            
+            # Extract tables
+            for table_idx, table in enumerate(doc.tables):
+                table_data = []
+                for row in table.rows:
+                    row_data = [cell.text for cell in row.cells]
+                    table_data.append(row_data)
+                
+                if table_data:
+                    extracted_data["tables"].append({
+                        "data": table_data,
+                        "position": f"table_{table_idx + 1}"
+                    })
+            
+            # Extract images (inline shapes)
+            for rel in doc.part.rels.values():
+                if "image" in rel.target_ref:
+                    try:
+                        image_bytes = rel.target_part.blob
+                        image_base64 = base64.b64encode(image_bytes).decode()
+                        extracted_data["images"].append({
+                            "data": image_base64,
+                            "position": f"image_{len(extracted_data['images']) + 1}"
+                        })
+                    except:
+                        pass
+            
+            return "\n\n".join(texts), extracted_data
 
         elif kind == "txt":
-            return file_bytes.decode("utf-8", errors="ignore"), None
+            return file_bytes.decode("utf-8", errors="ignore"), extracted_data
 
         else:
-            return "", None
+            return "", extracted_data
 
     except Exception as e:
         raise RuntimeError(f"Text extraction failed: {e}")
 
 
 # -------------------------
-# Gemini formatting -> JSON layout (UNIVERSAL)
+# Gemini formatting -> JSON layout (ENHANCED with tables & images)
 # -------------------------
-def enhance_text_with_gemini(text: str, doc_type: str = "auto", user_prompt: str = "") -> str:
+def enhance_text_with_gemini(text: str, doc_type: str = "auto", user_prompt: str = "", 
+                             extracted_data: Dict = None) -> str:
     """
-    Send prompt to Gemini to produce JSON document layout for ANY document type.
-    Tries multiple API keys if one fails (rate limit, quota exceeded, etc.).
-    For very long documents, uses a summarization strategy.
-    Returns the raw string response (may include fences), caller should clean it.
-    
-    doc_type: "auto", "resume", "letter", "report", "article", "essay", etc.
-    user_prompt: Custom instructions from user
+    Enhanced: Now includes table and image information in the prompt.
     """
     if not GEMINI_API_KEYS:
         return json.dumps({"error": "No GEMINI_API_KEY configured"})
 
-    # For very long documents, use a more concise output strategy
     is_long_doc = len(text) > 10000
     
-    # Build user instructions section
+    # Build user instructions
     user_instructions = ""
     if user_prompt.strip():
         user_instructions = f"""
@@ -241,49 +281,74 @@ USER INSTRUCTIONS:
 IMPORTANT: Follow the user's instructions while maintaining the JSON format and document structure.
 """
     
-    # Universal prompt that works for ANY document
+    # Add information about extracted tables and images
+    extracted_info = ""
+    if extracted_data:
+        if extracted_data.get("tables"):
+            extracted_info += f"\n\nDOCUMENT CONTAINS {len(extracted_data['tables'])} TABLES. Preserve and format them appropriately."
+        if extracted_data.get("images"):
+            extracted_info += f"\nDOCUMENT CONTAINS {len(extracted_data['images'])} IMAGES. Note their positions for reference."
+    
     prompt = f"""You are a professional document formatter and editor. Analyze the INPUT TEXT and enhance it.
 
 INPUT TEXT:
 {text}
+{extracted_info}
 
 DOCUMENT TYPE: {doc_type}
 {user_instructions}
+
 TASK:
 1) Analyze the document type (resume, cover letter, report, article, essay, notes, etc.)
 2) {"Apply the user's specific instructions" if user_prompt.strip() else "Improve grammar, clarity, and professional tone while preserving all original information"}
-3) Organize content with appropriate structure (headings, paragraphs, lists)
-4) Output ONLY valid JSON following the schema below - NO markdown, NO commentary
+3) Organize content with appropriate structure (headings, paragraphs, lists, tables)
+4) Preserve emojis, special characters, and Unicode symbols
+5) Output ONLY valid JSON following the schema below - NO markdown, NO commentary
 
 JSON SCHEMA:
 {{
   "document": [
-    {{ "type": "heading", "level": 1, "text": "Main Title" }},
+    {{ "type": "heading", "level": 1, "text": "Main Title ✨" }},
     {{ "type": "heading", "level": 2, "text": "Section Title" }},
-    {{ "type": "paragraph", "text": "Regular paragraph text", "align": "left" }},
-    {{ "type": "bullet_list", "items": ["Item 1", "Item 2"] }},
-    {{ "type": "number_list", "items": ["Step 1", "Step 2"] }}
+    {{ "type": "paragraph", "text": "Regular text with emojis 😊", "align": "left" }},
+    {{ "type": "bullet_list", "items": ["Item 1 ✓", "Item 2 ★"] }},
+    {{ "type": "number_list", "items": ["Step 1", "Step 2"] }},
+    {{ "type": "table", "rows": [["Header1", "Header2"], ["Value1", "Value2"]], "has_header": true }},
+    {{ "type": "image_placeholder", "position": "center", "caption": "Figure 1: Description" }}
   ]
 }}
 
 FORMATTING RULES:
 - Use level 1 heading for document title only
 - Use level 2 headings for major sections
+- PRESERVE all emojis, Unicode symbols (★, ✓, →, •, etc.), and special characters
 - {"Keep paragraphs BRIEF - combine similar content" if is_long_doc else "Keep paragraphs concise and well-structured"}
 - Use bullet_list for unordered items, number_list for sequences
+- Use "table" type for tabular data with "has_header": true/false
+- Use "image_placeholder" to mark where images should be inserted
 - {"IMPORTANT: For long documents, be concise - summarize repetitive sections" if is_long_doc else "Preserve ALL original content - do not omit information"}
-- Keep the JSON compact - avoid unnecessary fields
+
+TABLE FORMATTING:
+- First row is typically headers (set "has_header": true)
+- Include all rows and columns from source
+- Preserve cell content including numbers, symbols, emojis
+
+EMOJI & SYMBOL SUPPORT:
+- Keep ALL emojis exactly as they appear (😊, 🎉, ❤️, etc.)
+- Preserve Unicode symbols (★, ✓, →, •, ©, ®, ™, etc.)
+- Maintain special characters (€, £, ¥, °, ±, etc.)
 
 DOCUMENT-SPECIFIC GUIDELINES:
 - **Resume/CV**: Name (h1), Contact (center paragraph), Summary, Skills, Experience, Education, Certifications
 - **Cover Letter**: Your Info, Date, Recipient Info, Salutation, Body, Closing
-- **Report/Article**: Title (h1), Abstract, Introduction, Body Sections (h2), Conclusion
+- **Report/Article**: Title (h1), Abstract, Introduction, Body Sections (h2), Tables, Figures, Conclusion
 - **Essay**: Title (h1, center), Author, Body paragraphs
-- **Notes/General**: Logical headings and structure
+- **Notes/General**: Logical headings, preserve lists, tables, and special formatting
 
 IMPORTANT: 
 - Return COMPLETE, VALID JSON only
 - Ensure all strings are properly closed with quotes
+- Escape special JSON characters properly
 - Ensure all brackets and braces are balanced
 - No trailing commas
 - No markdown fences
@@ -299,7 +364,7 @@ IMPORTANT:
         }
     }
 
-    # Try each API key in sequence until one works
+    # Try each API key in sequence
     last_error = None
     for idx, api_key in enumerate(GEMINI_API_KEYS):
         try:
@@ -311,7 +376,6 @@ IMPORTANT:
                 timeout=240
             )
             
-            # Check for rate limit or quota errors
             if res.status_code == 429:
                 print(f"API key #{idx + 1} rate limited, trying next...")
                 last_error = "Rate limit exceeded"
@@ -325,10 +389,8 @@ IMPORTANT:
             res.raise_for_status()
             resp_json = res.json()
             
-            # Extract content
             content = resp_json["candidates"][0]["content"]["parts"][0]["text"]
             
-            # Check if response looks truncated
             if not content.rstrip().endswith("}") and not content.rstrip().endswith("]"):
                 content = repair_truncated_json(content)
             
@@ -350,35 +412,29 @@ IMPORTANT:
             last_error = str(e)
             continue
     
-    # All API keys failed
     return json.dumps({
         "error": f"All {len(GEMINI_API_KEYS)} API keys failed. Last error: {last_error}"
     })
 
 
 # -------------------------
-# Advanced DOCX builder
+# Advanced DOCX builder (ENHANCED with tables, images, emojis)
 # -------------------------
-def build_docx_from_design(layout_json_text: str) -> bytes:
+def build_docx_from_design(layout_json_text: str, extracted_data: Dict = None) -> bytes:
     """
-    Convert JSON layout (string) into a polished DOCX binary.
-    Raises ValueError on invalid JSON.
+    Enhanced: Now supports tables, images, emojis, and Unicode symbols.
     """
     cleaned = clean_gemini_json(layout_json_text)
     
-    # Try to repair if truncated
     if not cleaned.rstrip().endswith('}'):
         cleaned = repair_truncated_json(cleaned)
     
     try:
         data = json.loads(cleaned)
     except json.JSONDecodeError as e:
-        # If still fails, try to salvage what we can
         try:
-            # Find the last valid complete object
             last_valid = cleaned.rfind('}')
             if last_valid != -1:
-                # Try to close the document array
                 test_json = cleaned[:last_valid + 1] + ']}'
                 data = json.loads(test_json)
             else:
@@ -397,7 +453,7 @@ def build_docx_from_design(layout_json_text: str) -> bytes:
     sec.left_margin = Inches(0.7)
     sec.right_margin = Inches(0.7)
 
-    # Default font
+    # Default font (supports Unicode)
     try:
         style = doc.styles["Normal"]
         style.font.name = "Calibri"
@@ -427,6 +483,9 @@ def build_docx_from_design(layout_json_text: str) -> bytes:
             p.alignment = WD_ALIGN_PARAGRAPH.LEFT
         return p
 
+    # Track image usage
+    image_counter = 0
+    
     for block in data.get("document", []):
         btype = block.get("type", "").lower()
 
@@ -462,24 +521,73 @@ def build_docx_from_design(layout_json_text: str) -> bytes:
             rows = block.get("rows", []) or []
             if not rows:
                 continue
-            cols = len(rows[0])
+            
+            cols = len(rows[0]) if rows else 0
+            if cols == 0:
+                continue
+                
             table = doc.add_table(rows=len(rows), cols=cols)
             table.style = "Table Grid"
+            
+            has_header = block.get("has_header", True)
+            
             for r_idx, row in enumerate(rows):
                 for c_idx, cell in enumerate(row):
                     if isinstance(cell, dict):
                         text = str(cell.get("text", ""))
-                        is_header = cell.get("is_header", False)
                     else:
                         text = str(cell)
-                        is_header = r_idx == 0  # Auto-detect first row as header
+                    
                     cell_obj = table.rows[r_idx].cells[c_idx]
                     cell_obj.text = text
-                    if is_header:
+                    
+                    # Bold header row
+                    if has_header and r_idx == 0:
                         for p in cell_obj.paragraphs:
                             for run in p.runs:
                                 run.bold = True
 
+        elif btype == "image_placeholder" or btype == "image":
+            # Insert image from extracted data
+            if extracted_data and extracted_data.get("images"):
+                if image_counter < len(extracted_data["images"]):
+                    try:
+                        img_data = extracted_data["images"][image_counter]
+                        image_bytes = base64.b64decode(img_data["data"])
+                        image_stream = io.BytesIO(image_bytes)
+                        
+                        # Create paragraph for image
+                        p = doc.add_paragraph()
+                        align = block.get("position", "center")
+                        if align == "center":
+                            p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                        elif align == "right":
+                            p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+                        else:
+                            p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+                        
+                        # Add image
+                        run = p.add_run()
+                        run.add_picture(image_stream, width=Inches(4))
+                        
+                        # Add caption if provided
+                        caption = block.get("caption", "")
+                        if caption:
+                            cap_para = doc.add_paragraph(caption)
+                            cap_para.alignment = p.alignment
+                            for run in cap_para.runs:
+                                run.font.size = Pt(9)
+                                run.font.italic = True
+                        
+                        image_counter += 1
+                    except Exception as e:
+                        print(f"Failed to insert image: {e}")
+                        # Add placeholder text
+                        doc.add_paragraph(f"[Image: {block.get('caption', 'Figure')}]")
+            else:
+                # No image data available, add placeholder
+                doc.add_paragraph(f"[Image: {block.get('caption', 'Figure')}]")
+
         elif btype == "page_break":
             doc.add_page_break()
 
@@ -515,12 +623,16 @@ def build_docx_from_design(layout_json_text: str) -> bytes:
 # -------------------------
 @app.post("/extract")
 async def route_extract(file: UploadFile = File(...)):
-    """Extract plain text from uploaded document."""
+    """Extract plain text, tables, and images from uploaded document."""
     try:
         fb = await file.read()
         kind = detect_file_type(file.filename)
-        text, _ = extract_text_and_layout(fb, kind)
-        return {"text": text}
+        text, extracted_data = extract_text_and_layout(fb, kind)
+        return {
+            "text": text,
+            "tables_count": len(extracted_data.get("tables", [])),
+            "images_count": len(extracted_data.get("images", []))
+        }
     except Exception as e:
         traceback.print_exc()
         return JSONResponse({"error": str(e)}, status_code=500)
@@ -533,26 +645,20 @@ async def route_enhance(
     prompt: str = ""
 ):
     """
-    Universal document enhancer - works for ANY document type.
-    Extracts text, enhances with AI, returns formatted DOCX.
-    
-    Query/Form params:
-    - doc_type: "auto", "resume", "letter", "report", "article", "essay"
-    - prompt: User instructions for enhancement (optional)
+    Enhanced document processor with table, image, and emoji support.
     """
     try:
         fb = await file.read()
         kind = detect_file_type(file.filename)
-        text, _ = extract_text_and_layout(fb, kind)
+        text, extracted_data = extract_text_and_layout(fb, kind)
         
         if not text.strip():
             return JSONResponse({"error": "No text extracted from document"}, status_code=400)
 
-        # Get enhanced JSON from Gemini with user prompt
-        raw = enhance_text_with_gemini(text, doc_type, prompt)
+        # Enhanced: Pass extracted data to Gemini
+        raw = enhance_text_with_gemini(text, doc_type, prompt, extracted_data)
         cleaned = clean_gemini_json(raw)
         
-        # Check if Gemini returned an error
         try:
             test_parse = json.loads(cleaned)
             if "error" in test_parse:
@@ -560,10 +666,9 @@ async def route_enhance(
         except:
             pass
         
-        # Build DOCX from JSON layout
-        docx_bytes = build_docx_from_design(cleaned)
+        # Enhanced: Pass extracted data to DOCX builder
+        docx_bytes = build_docx_from_design(cleaned, extracted_data)
         
-        # Sanitize filename for HTTP header
         safe_filename = sanitize_filename(f"Enhanced_{file.filename or 'document.docx'}")
 
         return StreamingResponse(
@@ -588,22 +693,26 @@ async def route_preview(
     prompt: str = ""
 ):
     """
-    Preview the JSON layout without downloading DOCX.
-    Useful for debugging and seeing the structure.
+    Preview with table and image information.
     """
     try:
         fb = await file.read()
         kind = detect_file_type(file.filename)
-        text, _ = extract_text_and_layout(fb, kind)
+        text, extracted_data = extract_text_and_layout(fb, kind)
         
         if not text.strip():
             return JSONResponse({"error": "No text extracted"}, status_code=400)
 
-        raw = enhance_text_with_gemini(text, doc_type, prompt)
+        raw = enhance_text_with_gemini(text, doc_type, prompt, extracted_data)
         cleaned = clean_gemini_json(raw)
         
-        # Return the JSON structure for preview
-        return {"layout_json": json.loads(cleaned)}
+        return {
+            "layout_json": json.loads(cleaned),
+            "extracted_data": {
+                "tables_count": len(extracted_data.get("tables", [])),
+                "images_count": len(extracted_data.get("images", []))
+            }
+        }
     except Exception as e:
         traceback.print_exc()
         return JSONResponse({"error": str(e)}, status_code=500)
@@ -615,20 +724,18 @@ async def route_design(
     doc_type: str = "auto",
     prompt: str = ""
 ):
-    """
-    Legacy endpoint - same as /enhance with auto detection.
-    """
+    """Legacy endpoint with enhanced features."""
     try:
         fb = await file.read()
         kind = detect_file_type(file.filename)
-        text, _ = extract_text_and_layout(fb, kind)
+        text, extracted_data = extract_text_and_layout(fb, kind)
         
         if not text.strip():
             return JSONResponse({"error": "No text extracted"}, status_code=400)
 
-        raw = enhance_text_with_gemini(text, doc_type, prompt)
+        raw = enhance_text_with_gemini(text, doc_type, prompt, extracted_data)
         cleaned = clean_gemini_json(raw)
-        docx_bytes = build_docx_from_design(cleaned)
+        docx_bytes = build_docx_from_design(cleaned, extracted_data)
         
         safe_filename = sanitize_filename(f"Professional_{file.filename or 'document.docx'}")
 
@@ -652,21 +759,18 @@ async def route_full(
     doc_type: str = "auto",
     prompt: str = ""
 ):
-    """
-    Full pipeline: extract -> Gemini JSON -> DOCX.
-    Universal document enhancer.
-    """
+    """Full pipeline with enhanced features."""
     try:
         fb = await file.read()
         kind = detect_file_type(file.filename)
-        text, _ = extract_text_and_layout(fb, kind)
+        text, extracted_data = extract_text_and_layout(fb, kind)
         
         if not text.strip():
             return JSONResponse({"error": "No text extracted"}, status_code=400)
 
-        raw = enhance_text_with_gemini(text, doc_type, prompt)
+        raw = enhance_text_with_gemini(text, doc_type, prompt, extracted_data)
         cleaned = clean_gemini_json(raw)
-        docx_bytes = build_docx_from_design(cleaned)
+        docx_bytes = build_docx_from_design(cleaned, extracted_data)
         
         safe_filename = sanitize_filename(f"Enhanced_{file.filename or 'document.docx'}")
 
@@ -687,8 +791,8 @@ async def route_full(
 @app.post("/add-signature")
 async def route_add_signature(
     file: UploadFile = File(...),
-    signature: str = Form(...),  # Base64 encoded image
-    position: str = Form("bottom-right"),  # bottom-right, bottom-center, bottom-left, custom
+    signature: str = Form(...),
+    position: str = Form("bottom-right"),
     signer_name: Optional[str] = Form(None)
 ):
     """
@@ -721,11 +825,7 @@ async def route_add_signature(
         except Exception as e:
             return JSONResponse({"error": f"Invalid signature image: {str(e)}"}, status_code=400)
         
-        # Get the last section (last page)
-        last_section = doc.sections[-1]
-        
         # Add signature at the end of document
-        # Add some spacing before signature
         doc.add_paragraph()
         
         # Create signature paragraph
@@ -777,21 +877,38 @@ async def route_add_signature(
 @app.get("/")
 def root():
     return {
-        "service": "Universal Document Enhancer v5",
+        "service": "Universal Document Enhancer v6",
         "status": "ok",
-        "description": "AI-powered document formatter for ANY document type",
+        "description": "AI-powered document formatter with table, image, emoji, and icon support",
         "supported_types": ["Resume/CV", "Cover Letter", "Report", "Article", "Essay", "Notes", "Any text document"],
+        "new_features": [
+            "✓ Table extraction and formatting",
+            "✓ Image extraction and insertion",
+            "✓ Emoji and Unicode symbol preservation (😊, ★, ✓, →)",
+            "✓ Enhanced formatting with icons",
+            "✓ Multi-column table support",
+            "✓ Image captions and positioning"
+        ],
         "endpoints": {
-            "/extract": "Extract plain text from document",
-            "/enhance": "Full pipeline: extract + AI enhancement + DOCX (RECOMMENDED)",
+            "/extract": "Extract text, tables, and images from document",
+            "/enhance": "Full pipeline: extract + AI enhancement + DOCX with tables/images (RECOMMENDED)",
             "/add-signature": "Add signature to existing DOCX file",
-            "/preview": "Preview JSON layout without downloading",
+            "/preview": "Preview JSON layout with table/image counts",
             "/design": "Same as /enhance (legacy)",
             "/full": "Same as /enhance (legacy)"
         },
         "usage": {
             "basic": "POST /enhance with file upload",
-            "with_prompt": "POST /enhance?prompt=your_instructions&doc_type=auto"
+            "with_prompt": "POST /enhance?prompt=your_instructions&doc_type=auto",
+            "supported_content": [
+                "Text with emojis (😊🎉❤️)",
+                "Unicode symbols (★✓→•©®™)",
+                "Special chars (€£¥°±)",
+                "Tables (with headers)",
+                "Images (inline)",
+                "Lists (bullet/numbered)",
+                "Headers and formatting"
+            ]
         }
     }
 
@@ -801,6 +918,17 @@ def health():
     return {
         "status": "healthy",
         "api_keys_configured": len(GEMINI_API_KEYS),
-        "api_keys_available": GEMINI_API_KEYS[:1] if GEMINI_API_KEYS else [],  # Only show first key for security
-        "version": "5.0 - Universal with Prompt Support + Multi-API-Key Fallback"
-    }
+        "version": "6.0 - Enhanced with Tables, Images, Emojis & Icons",
+        "features": {
+            "tables": "✓ Supported",
+            "images": "✓ Supported",
+            "emojis": "✓ Supported",
+            "unicode": "✓ Supported",
+            "multi_api_keys": f"✓ {len(GEMINI_API_KEYS)} keys configured"
+        }
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)