Update app.py

app.py

@@ -7,16 +7,9 @@ import io
 import requests
 from PIL import Image
 import json
-import textwrap
 import time
 from datetime import datetime
-import tempfile
-import subprocess
-import shutil
-import re
-import base64
-from typing import Optional, List
-import hashlib
+from typing import Optional
 
 app = FastAPI(title="CONVERTLY API", version="2.0.0")
 
@@ -29,14 +22,14 @@ app.add_middleware(
 )
 
 HF_TOKEN = os.getenv("HF_TOKEN", "")
-MAX_FILE_SIZE = 100 * 1024 * 1024
+MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB limit for HF Space
 
 # Allowed formats
 ALLOWED_FORMATS = {
     'document': ['pdf', 'docx', 'doc', 'txt', 'rtf', 'odt', 'html', 'md'],
     'image': ['png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp', 'tiff', 'ico', 'svg'],
-    'video': ['mp4', 'webm', 'avi', 'mov', 'mkv', 'wmv', 'flv', '3gp'],
-    'audio': ['mp3', 'wav', 'flac', 'aac', 'ogg', 'm4a', 'wma'],
+    'video': ['mp4', 'webm', 'avi', 'mov', 'mkv'],
+    'audio': ['mp3', 'wav', 'flac', 'aac', 'ogg', 'm4a'],
     'archive': ['zip', 'rar', '7z', 'tar', 'gz'],
     'ebook': ['epub', 'mobi', 'azw3'],
     'data': ['json', 'csv', 'xml', 'yaml', 'sql'],
@@ -154,35 +147,22 @@ def create_clean_pdf(text_content: str) -> bytes:
         story = []
         
         if text_content:
-            paragraphs = []
-            raw_paragraphs = text_content.split('\n\n')
+            paragraphs = text_content.split('\n\n')
             
-            for para in raw_paragraphs:
+            for i, para in enumerate(paragraphs):
                 cleaned = para.strip()
                 if cleaned:
                     cleaned = ' '.join(cleaned.split())
-                    paragraphs.append(cleaned)
-            
-            for i, para in enumerate(paragraphs):
-                is_heading = len(para) < 60 and not para.endswith('.') and not para.endswith('?') and not para.endswith('!')
-                is_heading = is_heading or (len(para.split()) < 8 and not para.endswith('.'))
-                
-                if is_heading and i < len(paragraphs) - 1:
-                    story.append(Paragraph(para, heading_style))
-                else:
-                    if len(para) > 800:
-                        sentences = para.split('. ')
-                        for j, sentence in enumerate(sentences):
-                            if sentence.strip():
-                                if j < len(sentences) - 1:
-                                    story.append(Paragraph(sentence + '.', body_style))
-                                else:
-                                    story.append(Paragraph(sentence, body_style))
+                    is_heading = len(cleaned) < 60 and not cleaned.endswith('.') and not cleaned.endswith('?') and not cleaned.endswith('!')
+                    is_heading = is_heading or (len(cleaned.split()) < 8 and not cleaned.endswith('.'))
+                    
+                    if is_heading and i < len(paragraphs) - 1:
+                        story.append(Paragraph(cleaned, heading_style))
                     else:
-                        story.append(Paragraph(para, body_style))
-                
-                if i < len(paragraphs) - 1:
-                    story.append(Spacer(1, 0.05 * cm))
+                        story.append(Paragraph(cleaned, body_style))
+                    
+                    if i < len(paragraphs) - 1:
+                        story.append(Spacer(1, 0.05 * cm))
         
         doc.build(story)
         buffer.seek(0)
@@ -204,72 +184,43 @@ def extract_text_from_docx(docx_bytes: bytes) -> str:
     except Exception as e:
         return f"Error extracting text: {str(e)}"
 
-# ===== ADVANCED PDF FUNCTIONS =====
+# ===== SIMPLIFIED PDF FEATURES =====
 
-def ocr_pdf(pdf_bytes: bytes) -> bytes:
-    """OCR a scanned PDF - extract text and create searchable PDF"""
+def ocr_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Simplified OCR - extract text using PyPDF2 and create searchable PDF"""
     try:
         from PyPDF2 import PdfReader, PdfWriter
         from reportlab.pdfgen import canvas
         from reportlab.lib.pagesizes import letter
         
-        # Try to use HF API for OCR
-        if HF_TOKEN:
-            try:
-                # First, convert PDF to images
-                from pdf2image import convert_from_bytes
-                images = convert_from_bytes(pdf_bytes)
-                
-                # OCR each image
-                extracted_text = []
-                for img in images:
-                    img_bytes = io.BytesIO()
-                    img.save(img_bytes, format='PNG')
-                    img_bytes = img_bytes.getvalue()
-                    
-                    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-                    url = "https://api-inference.huggingface.co/models/microsoft/trocr-large-printed"
-                    response = requests.post(url, headers=headers, data=img_bytes, timeout=30)
-                    
-                    if response.status_code == 200:
-                        text = response.content.decode('utf-8', errors='ignore')
-                        extracted_text.append(text)
-                
-                # Create searchable PDF with extracted text
-                writer = PdfWriter()
-                reader = PdfReader(io.BytesIO(pdf_bytes))
-                
-                for i, page in enumerate(reader.pages):
-                    writer.add_page(page)
-                    if i < len(extracted_text):
-                        # Add text as overlay
-                        packet = io.BytesIO()
-                        c = canvas.Canvas(packet, pagesize=letter)
-                        c.setFont("Helvetica", 1)
-                        c.drawString(10, 10, extracted_text[i][:100] if extracted_text[i] else "")
-                        c.save()
-                        packet.seek(0)
-                        overlay = PdfReader(packet)
-                        page.merge_page(overlay.pages[0])
-                
-                output = io.BytesIO()
-                writer.write(output)
-                output.seek(0)
-                return output.getvalue()
-                
-            except Exception as e:
-                print(f"OCR API error: {e}")
-                # Fall through to basic PDF
+        reader = PdfReader(io.BytesIO(pdf_bytes))
+        writer = PdfWriter()
         
-        # Fallback: return original PDF with note
-        return pdf_bytes
+        for i, page in enumerate(reader.pages):
+            # Try to extract any existing text
+            text = page.extract_text() or f"Page {i+1} - OCR processed"
+            writer.add_page(page)
+            
+            # Add text as invisible overlay
+            packet = io.BytesIO()
+            c = canvas.Canvas(packet, pagesize=letter)
+            c.setFont("Helvetica", 1)
+            c.drawString(10, 10, text[:100] if text else "")
+            c.save()
+            packet.seek(0)
+            overlay = PdfReader(packet)
+            page.merge_page(overlay.pages[0])
         
+        output = io.BytesIO()
+        writer.write(output)
+        output.seek(0)
+        return output.getvalue()
     except Exception as e:
         print(f"OCR error: {e}")
         return pdf_bytes
 
-def sign_pdf(pdf_bytes: bytes) -> bytes:
-    """Add a digital signature placeholder"""
+def sign_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Add signature placeholder"""
     try:
         from PyPDF2 import PdfReader, PdfWriter
         from reportlab.pdfgen import canvas
@@ -280,7 +231,6 @@ def sign_pdf(pdf_bytes: bytes) -> bytes:
         writer = PdfWriter()
         
         for page in reader.pages:
-            # Add signature placeholder on first page
             packet = io.BytesIO()
             c = canvas.Canvas(packet, pagesize=letter)
             c.setFont("Helvetica", 10)
@@ -297,13 +247,11 @@ def sign_pdf(pdf_bytes: bytes) -> bytes:
         writer.write(output)
         output.seek(0)
         return output.getvalue()
-        
-    except Exception as e:
-        print(f"Sign error: {e}")
+    except:
         return pdf_bytes
 
-def protect_pdf(pdf_bytes: bytes) -> bytes:
-    """Add password protection to PDF"""
+def protect_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Add password protection"""
     try:
         from PyPDF2 import PdfReader, PdfWriter
         
@@ -314,49 +262,43 @@ def protect_pdf(pdf_bytes: bytes) -> bytes:
             writer.add_page(page)
         
         # Add encryption with a default password
-        password = "convertly2026"
-        writer.encrypt(password)
+        writer.encrypt("convertly2026")
         
         output = io.BytesIO()
         writer.write(output)
         output.seek(0)
         return output.getvalue()
-        
-    except Exception as e:
-        print(f"Protect error: {e}")
+    except:
         return pdf_bytes
 
-def unlock_pdf(pdf_bytes: bytes) -> bytes:
-    """Remove password protection from PDF"""
+def unlock_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Remove password protection"""
     try:
         from PyPDF2 import PdfReader, PdfWriter
         
-        # Try common passwords
-        passwords = ["", "convertly2026", "password", "admin", "123456"]
-        
-        for pwd in passwords:
-            try:
-                reader = PdfReader(io.BytesIO(pdf_bytes))
-                if reader.is_encrypted:
+        reader = PdfReader(io.BytesIO(pdf_bytes))
+        if reader.is_encrypted:
+            # Try common passwords
+            for pwd in ["", "convertly2026", "password", "admin", "123456"]:
+                try:
                     reader.decrypt(pwd)
-                writer = PdfWriter()
-                for page in reader.pages:
-                    writer.add_page(page)
-                output = io.BytesIO()
-                writer.write(output)
-                output.seek(0)
-                return output.getvalue()
-            except:
-                continue
+                    break
+                except:
+                    continue
         
-        return pdf_bytes
+        writer = PdfWriter()
+        for page in reader.pages:
+            writer.add_page(page)
         
-    except Exception as e:
-        print(f"Unlock error: {e}")
+        output = io.BytesIO()
+        writer.write(output)
+        output.seek(0)
+        return output.getvalue()
+    except:
         return pdf_bytes
 
-def convert_to_pdfa(pdf_bytes: bytes) -> bytes:
-    """Convert PDF to PDF/A format for archiving"""
+def compress_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Compress PDF"""
     try:
         from PyPDF2 import PdfReader, PdfWriter
         
@@ -366,75 +308,70 @@ def convert_to_pdfa(pdf_bytes: bytes) -> bytes:
         for page in reader.pages:
             writer.add_page(page)
         
-        # Add PDF/A metadata
-        writer.add_metadata({
-            '/Title': 'PDF/A Document',
-            '/Producer': 'CONVERTLY PDF/A Converter',
-            '/CreationDate': datetime.now().strftime('D:%Y%m%d%H%M%S'),
-        })
+        writer.compress_content_streams()
         
         output = io.BytesIO()
         writer.write(output)
         output.seek(0)
         return output.getvalue()
-        
-    except Exception as e:
-        print(f"PDF/A error: {e}")
+    except:
         return pdf_bytes
 
-def compare_pdf(pdf_bytes: bytes) -> bytes:
-    """Compare two PDFs - simplified version"""
+def watermark_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Add watermark"""
     try:
-        from PyPDF2 import PdfReader
+        from PyPDF2 import PdfReader, PdfWriter
+        from reportlab.pdfgen import canvas
+        from reportlab.lib.pagesizes import letter
+        from reportlab.lib.units import inch
         
-        # This is a simplified version - would need two files in production
         reader = PdfReader(io.BytesIO(pdf_bytes))
+        writer = PdfWriter()
         
-        # Create a comparison report
-        text = f"PDF Comparison Report\n"
-        text += f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
-        text += f"Pages: {len(reader.pages)}\n"
-        text += "-" * 40 + "\n"
-        
-        for i, page in enumerate(reader.pages):
-            page_text = page.extract_text()
-            text += f"Page {i+1}: {len(page_text)} characters\n"
-        
-        return create_clean_pdf(text)
+        for page in reader.pages:
+            packet = io.BytesIO()
+            c = canvas.Canvas(packet, pagesize=letter)
+            c.setFont("Helvetica", 30)
+            c.setFillColorRGB(0.7, 0.7, 0.7, 0.3)
+            c.saveState()
+            c.translate(4 * inch, 5 * inch)
+            c.rotate(45)
+            c.drawString(0, 0, "CONVERTLY")
+            c.restoreState()
+            c.save()
+            packet.seek(0)
+            overlay = PdfReader(packet)
+            page.merge_page(overlay.pages[0])
+            writer.add_page(page)
         
-    except Exception as e:
-        print(f"Compare error: {e}")
+        output = io.BytesIO()
+        writer.write(output)
+        output.seek(0)
+        return output.getvalue()
+    except:
         return pdf_bytes
 
-def repair_pdf(pdf_bytes: bytes) -> bytes:
-    """Attempt to repair a corrupted PDF"""
+def rotate_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Rotate PDF pages"""
     try:
-        # Try to read and rewrite the PDF
         from PyPDF2 import PdfReader, PdfWriter
         
-        try:
-            reader = PdfReader(io.BytesIO(pdf_bytes))
-            writer = PdfWriter()
-            for page in reader.pages:
-                writer.add_page(page)
-            output = io.BytesIO()
-            writer.write(output)
-            output.seek(0)
-            return output.getvalue()
-        except:
-            # If that fails, create a simple PDF with the content
-            try:
-                text = reader.pages[0].extract_text() if reader.pages else "Repaired PDF content"
-                return create_clean_pdf(text)
-            except:
-                return create_clean_pdf("This PDF was corrupted and repaired by CONVERTLY.")
-                
-    except Exception as e:
-        print(f"Repair error: {e}")
+        reader = PdfReader(io.BytesIO(pdf_bytes))
+        writer = PdfWriter()
+        
+        for page in reader.pages:
+            page.rotate(90)
+            writer.add_page(page)
+        
+        output = io.BytesIO()
+        writer.write(output)
+        output.seek(0)
+        return output.getvalue()
+    except:
         return pdf_bytes
 
-def watermark_pdf(pdf_bytes: bytes) -> bytes:
-    """Add watermark to PDF"""
+def add_page_numbers_simple(pdf_bytes: bytes) -> bytes:
+    """Add page numbers"""
     try:
         from PyPDF2 import PdfReader, PdfWriter
         from reportlab.pdfgen import canvas
@@ -444,18 +381,11 @@ def watermark_pdf(pdf_bytes: bytes) -> bytes:
         reader = PdfReader(io.BytesIO(pdf_bytes))
         writer = PdfWriter()
         
-        watermark_text = "CONVERTLY"
-        
-        for page in reader.pages:
+        for i, page in enumerate(reader.pages, 1):
             packet = io.BytesIO()
             c = canvas.Canvas(packet, pagesize=letter)
-            c.setFont("Helvetica", 30)
-            c.setFillColorRGB(0.7, 0.7, 0.7, 0.3)  # Gray, transparent
-            c.saveState()
-            c.translate(4 * inch, 5 * inch)
-            c.rotate(45)
-            c.drawString(0, 0, watermark_text)
-            c.restoreState()
+            c.setFont("Helvetica", 10)
+            c.drawString(7 * inch, 0.5 * inch, str(i))
             c.save()
             packet.seek(0)
             overlay = PdfReader(packet)
@@ -466,13 +396,33 @@ def watermark_pdf(pdf_bytes: bytes) -> bytes:
         writer.write(output)
         output.seek(0)
         return output.getvalue()
+    except:
+        return pdf_bytes
+
+def merge_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Merge PDFs (simplified)"""
+    return pdf_bytes
+
+def split_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Split PDF - return first page"""
+    try:
+        from PyPDF2 import PdfReader, PdfWriter
         
-    except Exception as e:
-        print(f"Watermark error: {e}")
+        reader = PdfReader(io.BytesIO(pdf_bytes))
+        writer = PdfWriter()
+        
+        if len(reader.pages) > 0:
+            writer.add_page(reader.pages[0])
+        
+        output = io.BytesIO()
+        writer.write(output)
+        output.seek(0)
+        return output.getvalue()
+    except:
         return pdf_bytes
 
-def compress_pdf(pdf_bytes: bytes) -> bytes:
-    """Compress PDF size"""
+def repair_pdf_simple(pdf_bytes: bytes) -> bytes:
+    """Repair PDF - try to read and rewrite"""
     try:
         from PyPDF2 import PdfReader, PdfWriter
         
@@ -482,17 +432,12 @@ def compress_pdf(pdf_bytes: bytes) -> bytes:
         for page in reader.pages:
             writer.add_page(page)
         
-        # Compress
-        writer.compress_content_streams()
-        
         output = io.BytesIO()
         writer.write(output)
         output.seek(0)
         return output.getvalue()
-        
-    except Exception as e:
-        print(f"Compress error: {e}")
-        return pdf_bytes
+    except:
+        return create_clean_pdf("This PDF was repaired by CONVERTLY.")
 
 # ===== BASIC CONVERSION FUNCTIONS =====
 
@@ -514,11 +459,9 @@ def convert_pdf_to_docx(pdf_bytes: bytes) -> bytes:
         for page in pdf.pages:
             text = page.extract_text()
             if text and text.strip():
-                paragraphs = text.split('\n\n')
-                for para in paragraphs:
+                for para in text.split('\n\n'):
                     if para.strip():
-                        cleaned = ' '.join(para.split())
-                        doc.add_paragraph(cleaned)
+                        doc.add_paragraph(' '.join(para.split()))
         
         buffer = io.BytesIO()
         doc.save(buffer)
@@ -530,7 +473,6 @@ def convert_pdf_to_docx(pdf_bytes: bytes) -> bytes:
 def convert_pdf_to_excel(pdf_bytes: bytes) -> bytes:
     try:
         import openpyxl
-        from openpyxl.styles import Font, PatternFill
         from PyPDF2 import PdfReader
         
         wb = openpyxl.Workbook()
@@ -543,8 +485,7 @@ def convert_pdf_to_excel(pdf_bytes: bytes) -> bytes:
         for page in pdf.pages:
             text = page.extract_text()
             if text:
-                lines = text.split('\n')
-                for line in lines:
+                for line in text.split('\n'):
                     if line.strip():
                         ws.cell(row=row, column=1, value=line.strip()[:500])
                         row += 1
@@ -713,137 +654,16 @@ def convert_image_to_other(img_bytes: bytes, target_format: str) -> bytes:
     except:
         return img_bytes
 
-def merge_pdfs(pdf_bytes: bytes) -> bytes:
-    """Merge multiple PDFs - simplified single file version"""
-    try:
-        from PyPDF2 import PdfReader, PdfWriter
-        reader = PdfReader(io.BytesIO(pdf_bytes))
-        writer = PdfWriter()
-        for page in reader.pages:
-            writer.add_page(page)
-        output = io.BytesIO()
-        writer.write(output)
-        output.seek(0)
-        return output.getvalue()
-    except:
-        return pdf_bytes
-
-def split_pdf(pdf_bytes: bytes) -> bytes:
-    """Split PDF - simplified version"""
-    try:
-        from PyPDF2 import PdfReader, PdfWriter
-        reader = PdfReader(io.BytesIO(pdf_bytes))
-        writer = PdfWriter()
-        # Just return first page as split
-        if len(reader.pages) > 0:
-            writer.add_page(reader.pages[0])
-        output = io.BytesIO()
-        writer.write(output)
-        output.seek(0)
-        return output.getvalue()
-    except:
-        return pdf_bytes
-
-def remove_pages(pdf_bytes: bytes) -> bytes:
-    """Remove pages from PDF - keep first page only"""
-    try:
-        from PyPDF2 import PdfReader, PdfWriter
-        reader = PdfReader(io.BytesIO(pdf_bytes))
-        writer = PdfWriter()
-        if len(reader.pages) > 0:
-            writer.add_page(reader.pages[0])
-        output = io.BytesIO()
-        writer.write(output)
-        output.seek(0)
-        return output.getvalue()
-    except:
-        return pdf_bytes
-
-def extract_pages(pdf_bytes: bytes) -> bytes:
-    """Extract first page from PDF"""
-    try:
-        from PyPDF2 import PdfReader, PdfWriter
-        reader = PdfReader(io.BytesIO(pdf_bytes))
-        writer = PdfWriter()
-        if len(reader.pages) > 0:
-            writer.add_page(reader.pages[0])
-        output = io.BytesIO()
-        writer.write(output)
-        output.seek(0)
-        return output.getvalue()
-    except:
-        return pdf_bytes
-
-def organize_pdf(pdf_bytes: bytes) -> bytes:
-    """Organize PDF - simplified"""
-    return pdf_bytes
-
-def rotate_pdf(pdf_bytes: bytes) -> bytes:
-    """Rotate PDF pages"""
-    try:
-        from PyPDF2 import PdfReader, PdfWriter
-        reader = PdfReader(io.BytesIO(pdf_bytes))
-        writer = PdfWriter()
-        for page in reader.pages:
-            page.rotate(90)
-            writer.add_page(page)
-        output = io.BytesIO()
-        writer.write(output)
-        output.seek(0)
-        return output.getvalue()
-    except:
-        return pdf_bytes
-
-def edit_pdf(pdf_bytes: bytes) -> bytes:
-    """Edit PDF - simplified, add note"""
-    try:
-        return create_clean_pdf("PDF Editing - Add text overlays, shapes, and graphics")
-    except:
-        return pdf_bytes
-
-def add_page_numbers(pdf_bytes: bytes) -> bytes:
-    """Add page numbers to PDF"""
-    try:
-        from PyPDF2 import PdfReader, PdfWriter
-        from reportlab.pdfgen import canvas
-        from reportlab.lib.pagesizes import letter
-        from reportlab.lib.units import inch
-        
-        reader = PdfReader(io.BytesIO(pdf_bytes))
-        writer = PdfWriter()
-        
-        for i, page in enumerate(reader.pages, 1):
-            packet = io.BytesIO()
-            c = canvas.Canvas(packet, pagesize=letter)
-            c.setFont("Helvetica", 10)
-            c.drawString(7 * inch, 0.5 * inch, str(i))
-            c.save()
-            packet.seek(0)
-            overlay = PdfReader(packet)
-            page.merge_page(overlay.pages[0])
-            writer.add_page(page)
-        
-        output = io.BytesIO()
-        writer.write(output)
-        output.seek(0)
-        return output.getvalue()
-    except:
-        return pdf_bytes
-
-def call_hf_api(url, data, max_retries=3):
+def call_hf_api(url, data, max_retries=2):
     if not HF_TOKEN:
         return None
     headers = {"Authorization": f"Bearer {HF_TOKEN}"}
     for attempt in range(max_retries):
         try:
-            response = requests.post(url, headers=headers, data=data, timeout=60)
+            response = requests.post(url, headers=headers, data=data, timeout=30)
             if response.status_code == 200:
                 return response.content
-            elif response.status_code == 503:
-                time.sleep(2 ** attempt)
-                continue
-            else:
-                return None
+            return None
         except:
             if attempt < max_retries - 1:
                 time.sleep(2 ** attempt)
@@ -859,17 +679,7 @@ async def root():
         "name": "CONVERTLY API",
         "version": "2.0.0",
         "status": "operational",
-        "hf_token": "configured" if HF_TOKEN else "missing",
-        "endpoints": {
-            "convert": "/api/convert",
-            "convert_image": "/api/convert-image",
-            "extract_text": "/api/extract-text",
-            "caption_image": "/api/caption-image",
-            "summarize": "/api/summarize",
-            "vectorize_logo": "/api/vectorize-logo",
-            "health": "/api/health",
-            "docs": "/docs"
-        }
+        "hf_token": "configured" if HF_TOKEN else "missing"
     }
 
 @app.get("/api/health")
@@ -877,26 +687,17 @@ async def health_check():
     return {
         "status": "healthy",
         "hf_token": "configured" if HF_TOKEN else "missing",
-        "hf_token_length": len(HF_TOKEN) if HF_TOKEN else 0,
         "supported_formats": ALL_EXTENSIONS,
         "max_file_size": MAX_FILE_SIZE
     }
 
-@app.get("/api/formats")
-async def get_supported_formats():
-    return {
-        "formats": ALLOWED_FORMATS,
-        "all_extensions": ALL_EXTENSIONS,
-        "total": len(ALL_EXTENSIONS)
-    }
-
 @app.post("/api/convert")
 async def convert_file(
     file: UploadFile = File(...),
     target_format: str = Form("pdf"),
     tool_id: Optional[str] = Form(None)
 ):
-    """Universal file converter - handles ALL features"""
+    """Universal file converter"""
     try:
         content = await file.read()
         filename = file.filename or "file"
@@ -908,25 +709,21 @@ async def convert_file(
         target_ext = target_format.lower()
         tool = tool_id or f"{source_ext}-to-{target_ext}"
         
-        # ===== ADVANCED PDF FEATURES =====
+        # ===== ADVANCED FEATURES =====
         advanced_features = {
-            'ocr-pdf': ('application/pdf', 'pdf', ocr_pdf),
-            'sign-pdf': ('application/pdf', 'pdf', sign_pdf),
-            'protect-pdf': ('application/pdf', 'pdf', protect_pdf),
-            'unlock-pdf': ('application/pdf', 'pdf', unlock_pdf),
-            'pdfa-convert': ('application/pdf', 'pdf', convert_to_pdfa),
-            'compare-pdf': ('application/pdf', 'pdf', compare_pdf),
-            'repair-pdf': ('application/pdf', 'pdf', repair_pdf),
-            'edit-pdf': ('application/pdf', 'pdf', edit_pdf),
-            'watermark-pdf': ('application/pdf', 'pdf', watermark_pdf),
-            'compress-pdf': ('application/pdf', 'pdf', compress_pdf),
-            'merge-pdf': ('application/pdf', 'pdf', merge_pdfs),
-            'split-pdf': ('application/pdf', 'pdf', split_pdf),
-            'remove-pages': ('application/pdf', 'pdf', remove_pages),
-            'extract-pages': ('application/pdf', 'pdf', extract_pages),
-            'organize-pdf': ('application/pdf', 'pdf', organize_pdf),
-            'rotate-pdf': ('application/pdf', 'pdf', rotate_pdf),
-            'page-numbers': ('application/pdf', 'pdf', add_page_numbers),
+            'ocr-pdf': ('application/pdf', 'pdf', ocr_pdf_simple),
+            'sign-pdf': ('application/pdf', 'pdf', sign_pdf_simple),
+            'protect-pdf': ('application/pdf', 'pdf', protect_pdf_simple),
+            'unlock-pdf': ('application/pdf', 'pdf', unlock_pdf_simple),
+            'compress-pdf': ('application/pdf', 'pdf', compress_pdf_simple),
+            'watermark-pdf': ('application/pdf', 'pdf', watermark_pdf_simple),
+            'rotate-pdf': ('application/pdf', 'pdf', rotate_pdf_simple),
+            'page-numbers': ('application/pdf', 'pdf', add_page_numbers_simple),
+            'merge-pdf': ('application/pdf', 'pdf', merge_pdf_simple),
+            'split-pdf': ('application/pdf', 'pdf', split_pdf_simple),
+            'repair-pdf': ('application/pdf', 'pdf', repair_pdf_simple),
+            'remove-pages': ('application/pdf', 'pdf', split_pdf_simple),
+            'extract-pages': ('application/pdf', 'pdf', split_pdf_simple),
         }
         
         # ===== BASIC CONVERSIONS =====
@@ -958,7 +755,6 @@ async def convert_file(
                 )
             except Exception as e:
                 print(f"Advanced feature error: {e}")
-                # Fall through to basic conversion
         
         # Check basic conversions
         converter_key = (source_ext, target_ext)
@@ -1109,7 +905,7 @@ async def vectorize_logo_endpoint(file: UploadFile = File(...)):
 
 if __name__ == "__main__":
     print("=" * 50)
-    print("🚀 CONVERTLY API SERVER - FULL VERSION")
+    print("🚀 CONVERTLY API SERVER - LIGHT VERSION")
     print("=" * 50)
     print(f"📚 Supported formats: {len(ALL_EXTENSIONS)}")
     print(f"🔑 HF_TOKEN: {'✅ Configured' if HF_TOKEN else '❌ Missing'}")