Update app.py

app.py

@@ -7,11 +7,9 @@ import io
 import requests
 from PIL import Image
 import json
-import tempfile
-import subprocess
-from pathlib import Path
-import shutil
 import textwrap
+import time
+from datetime import datetime
 
 app = FastAPI(title="CONVERTLY API", version="2.0.0")
 
@@ -25,140 +23,226 @@ app.add_middleware(
 
 HF_TOKEN = os.getenv("HF_TOKEN", "")
 
-# ===== CLEAN PDF GENERATION (NO METADATA) =====
+# ===== PROFESSIONAL PDF GENERATION WITH PROPER FORMATTING =====
 
-def create_clean_pdf(text_content):
-    """Create a clean PDF with just the content - NO extra metadata"""
+def create_professional_pdf(text_content, title="Document"):
+    """Create a properly formatted PDF with correct margins and text flow"""
     try:
-        from reportlab.pdfgen import canvas
-        from reportlab.lib.pagesizes import letter
-        from reportlab.lib.units import inch
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.units import inch, cm
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_JUSTIFY
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
+        from reportlab.lib import colors
         from reportlab.pdfbase import pdfmetrics
         from reportlab.pdfbase.ttfonts import TTFont
         import textwrap
         
         buffer = io.BytesIO()
-        c = canvas.Canvas(buffer, pagesize=letter)
-        width, height = letter
-        
-        # Set up margins
-        left_margin = 72  # 1 inch
-        right_margin = 72
-        top_margin = 72
-        bottom_margin = 72
-        
-        # Set font
-        c.setFont("Helvetica", 11)
-        
-        # Start position
-        x = left_margin
-        y = height - top_margin
-        
-        # Split content into lines and wrap
-        lines = []
-        for paragraph in text_content.split('\n\n'):
-            if paragraph.strip():
+        
+        # ===== DOCUMENT SETUP =====
+        # Use A4 with standard margins (1 inch / 2.54 cm)
+        doc = SimpleDocTemplate(
+            buffer,
+            pagesize=A4,
+            rightMargin=2.54 * cm,
+            leftMargin=2.54 * cm,
+            topMargin=2.54 * cm,
+            bottomMargin=2.54 * cm,
+        )
+        
+        # ===== STYLES =====
+        styles = getSampleStyleSheet()
+        
+        # Title style
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Title'],
+            fontSize=20,
+            fontName='Helvetica-Bold',
+            alignment=TA_CENTER,
+            spaceAfter=20,
+            textColor=colors.HexColor('#1a1a2e')
+        )
+        
+        # Heading style
+        heading_style = ParagraphStyle(
+            'CustomHeading',
+            parent=styles['Heading2'],
+            fontSize=14,
+            fontName='Helvetica-Bold',
+            alignment=TA_LEFT,
+            spaceAfter=10,
+            spaceBefore=15,
+            textColor=colors.HexColor('#2d2d44')
+        )
+        
+        # Body text style - JUSTIFIED for professional look
+        body_style = ParagraphStyle(
+            'CustomBody',
+            parent=styles['Normal'],
+            fontSize=11,
+            fontName='Helvetica',
+            alignment=TA_JUSTIFY,  # Justified text like real documents
+            spaceAfter=8,
+            leading=16,  # Line spacing
+            textColor=colors.HexColor('#333333')
+        )
+        
+        # ===== BUILD CONTENT =====
+        story = []
+        
+        # Add title
+        story.append(Paragraph(f"<b>{title}</b>", title_style))
+        story.append(Spacer(1, 0.3 * inch))
+        
+        # Add date (subtle)
+        date_style = ParagraphStyle(
+            'Date',
+            parent=styles['Normal'],
+            fontSize=10,
+            fontName='Helvetica',
+            alignment=TA_LEFT,
+            textColor=colors.HexColor('#888888'),
+            spaceAfter=20
+        )
+        story.append(Paragraph(f"Generated: {datetime.now().strftime('%B %d, %Y at %I:%M %p')}", date_style))
+        story.append(Spacer(1, 0.2 * inch))
+        
+        # ===== PROCESS TEXT CONTENT =====
+        if text_content:
+            # Split into paragraphs (handle different line endings)
+            paragraphs = []
+            raw_paragraphs = text_content.split('\n\n')
+            
+            for para in raw_paragraphs:
                 # Clean the paragraph
-                clean_para = ' '.join(paragraph.split())
-                # Wrap text
-                wrapped = textwrap.wrap(clean_para, width=80)
-                lines.extend(wrapped)
-                lines.append('')  # Add blank line between paragraphs
-        
-        # Draw each line
-        for line in lines:
-            if line == '':
-                y -= 12  # Blank line
-            else:
-                # Check if we need a new page
-                if y < bottom_margin:
-                    c.showPage()
-                    c.setFont("Helvetica", 11)
-                    y = height - top_margin
+                cleaned = para.strip()
+                if cleaned:
+                    # Remove extra spaces
+                    cleaned = ' '.join(cleaned.split())
+                    paragraphs.append(cleaned)
+            
+            # Add each paragraph with proper formatting
+            for i, para in enumerate(paragraphs):
+                # Check if it might be a heading (short, no period at end)
+                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:
+                    # It's a heading - use heading style
+                    story.append(Paragraph(para, heading_style))
+                else:
+                    # Regular paragraph - use body style
+                    # Wrap long paragraphs for better flow
+                    if len(para) > 800:
+                        # Split into smaller paragraphs
+                        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))
+                    else:
+                        story.append(Paragraph(para, body_style))
                 
-                c.drawString(x, y, line)
-                y -= 15  # Line spacing
+                # Add spacing between paragraphs
+                if i < len(paragraphs) - 1:
+                    story.append(Spacer(1, 0.05 * inch))
         
-        c.save()
+        # ===== BUILD PDF =====
+        doc.build(story)
         buffer.seek(0)
         return buffer.getvalue()
         
     except Exception as e:
-        print(f"PDF generation error: {e}")
-        # Fallback: return plain text
-        return text_content.encode('utf-8')
+        print(f"Professional PDF error: {e}")
+        return create_simple_pdf(text_content, title)
 
-def create_professional_pdf(text_content, title="Document"):
-    """Create a professional PDF with proper formatting - minimal metadata"""
+
+def create_simple_pdf(text_content, title="Document"):
+    """Fallback: Simple PDF with basic formatting"""
     try:
-        from reportlab.pdfgen import canvas
-        from reportlab.lib.pagesizes import letter
-        from reportlab.lib.units import inch
-        import textwrap
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.units import inch, cm
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_JUSTIFY
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+        from reportlab.lib import colors
         
         buffer = io.BytesIO()
-        c = canvas.Canvas(buffer, pagesize=letter)
-        width, height = letter
         
-        # Set up margins
-        left_margin = 72
-        right_margin = 72
-        top_margin = 72
-        bottom_margin = 72
+        doc = SimpleDocTemplate(
+            buffer,
+            pagesize=A4,
+            rightMargin=2.54 * cm,
+            leftMargin=2.54 * cm,
+            topMargin=2.54 * cm,
+            bottomMargin=2.54 * cm,
+        )
         
-        # Set font
-        c.setFont("Helvetica", 11)
+        styles = getSampleStyleSheet()
         
-        # Start position
-        x = left_margin
-        y = height - top_margin
+        body_style = ParagraphStyle(
+            'Body',
+            parent=styles['Normal'],
+            fontSize=11,
+            fontName='Helvetica',
+            alignment=TA_JUSTIFY,
+            spaceAfter=8,
+            leading=16
+        )
         
-        # Split content into paragraphs
-        paragraphs = text_content.split('\n\n') if '\n\n' in text_content else [text_content]
+        story = []
         
-        for paragraph in paragraphs:
-            if paragraph.strip():
-                # Clean the paragraph
-                clean_para = ' '.join(paragraph.split())
-                # Wrap text
-                wrapped = textwrap.wrap(clean_para, width=80)
-                
-                for line in wrapped:
-                    if y < bottom_margin:
-                        c.showPage()
-                        c.setFont("Helvetica", 11)
-                        y = height - top_margin
-                    c.drawString(x, y, line)
-                    y -= 15
-                
-                # Add space between paragraphs
-                y -= 10
+        # Title
+        title_style = ParagraphStyle(
+            'Title',
+            parent=styles['Title'],
+            fontSize=18,
+            alignment=TA_CENTER,
+            spaceAfter=20
+        )
+        story.append(Paragraph(title, title_style))
+        story.append(Spacer(1, 0.2 * inch))
+        
+        # Content
+        for para in text_content.split('\n\n'):
+            if para.strip():
+                cleaned = ' '.join(para.split())
+                story.append(Paragraph(cleaned, body_style))
+                story.append(Spacer(1, 0.05 * inch))
         
-        c.save()
+        doc.build(story)
         buffer.seek(0)
         return buffer.getvalue()
         
     except Exception as e:
-        print(f"PDF generation error: {e}")
-        return create_clean_pdf(text_content)
+        print(f"Simple PDF error: {e}")
+        return text_content.encode('utf-8')
 
-# ===== REAL CONVERSION FUNCTIONS =====
 
-def convert_docx_to_pdf(docx_bytes):
-    """Convert DOCX to PDF with clean content"""
+def extract_text_from_docx(docx_bytes):
+    """Extract text from DOCX with formatting preservation"""
     try:
         from docx import Document
+        from docx.oxml import parse_xml
+        from docx.oxml.ns import qn
         
-        # Read the DOCX
         doc = Document(io.BytesIO(docx_bytes))
         
-        # Extract all text
         full_text = []
         
         # Extract paragraphs
         for para in doc.paragraphs:
             if para.text.strip():
-                full_text.append(para.text)
+                # Check if it's a heading (based on style)
+                is_heading = 'heading' in para.style.name.lower() if para.style else False
+                if is_heading:
+                    full_text.append(f"\n{para.text.strip()}\n")
+                else:
+                    full_text.append(para.text.strip())
         
         # Extract tables
         for table in doc.tables:
@@ -168,39 +252,63 @@ def convert_docx_to_pdf(docx_bytes):
                     if cell.text.strip():
                         row_text.append(cell.text.strip())
                 if row_text:
-                    full_text.append(" | ".join(row_text))
-        
-        text_content = '\n\n'.join(full_text) if full_text else "No text content found in document."
+                    full_text.append(' | '.join(row_text))
         
-        # Create clean PDF
-        return create_clean_pdf(text_content)
+        return '\n\n'.join(full_text) if full_text else "No text content found in document."
         
+    except Exception as e:
+        print(f"DOCX extraction error: {e}")
+        return "Error extracting text from DOCX."
+
+
+# ===== CONVERSION FUNCTIONS =====
+
+def convert_docx_to_pdf(docx_bytes):
+    """Convert DOCX to PDF with professional formatting"""
+    try:
+        text = extract_text_from_docx(docx_bytes)
+        return create_professional_pdf(text, "Document")
     except Exception as e:
         print(f"DOCX to PDF error: {e}")
         return docx_bytes
 
+
 def convert_pdf_to_docx(pdf_bytes):
-    """Convert PDF to DOCX - extract text"""
+    """Convert PDF to DOCX"""
     try:
         from PyPDF2 import PdfReader
         from docx import Document
+        from docx.shared import Inches, Pt
+        from docx.enum.text import WD_ALIGN_PARAGRAPH
         
-        # Read PDF
         pdf = PdfReader(io.BytesIO(pdf_bytes))
-        
-        # Create DOCX
         doc = Document()
         
+        # Title
+        title = doc.add_heading('Converted from PDF', 0)
+        title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        
+        # Date
+        from datetime import datetime
+        date_para = doc.add_paragraph(f"Generated: {datetime.now().strftime('%B %d, %Y at %I:%M %p')}")
+        date_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        doc.add_paragraph()
+        
         # Extract text from each page
-        for page in pdf.pages:
+        for page_num, page in enumerate(pdf.pages, 1):
             text = page.extract_text()
             if text and text.strip():
-                # Split into paragraphs
+                doc.add_heading(f'Page {page_num}', 1)
                 paragraphs = text.split('\n\n')
                 for para in paragraphs:
                     if para.strip():
                         cleaned = ' '.join(para.split())
                         doc.add_paragraph(cleaned)
+            else:
+                doc.add_paragraph(f"[No text extracted from page {page_num}]")
+            
+            if page_num < len(pdf.pages):
+                doc.add_page_break()
         
         buffer = io.BytesIO()
         doc.save(buffer)
@@ -211,28 +319,56 @@ def convert_pdf_to_docx(pdf_bytes):
         print(f"PDF to DOCX error: {e}")
         return pdf_bytes
 
+
 def convert_pdf_to_excel(pdf_bytes):
-    """Convert PDF to Excel - extract tables"""
+    """Convert PDF to Excel"""
     try:
         import openpyxl
+        from openpyxl.styles import Font, PatternFill, Alignment
         from PyPDF2 import PdfReader
         
         wb = openpyxl.Workbook()
         ws = wb.active
         ws.title = "Extracted Data"
         
+        # Style
+        header_font = Font(bold=True, color="FFFFFF")
+        header_fill = PatternFill(start_color="4F46E5", end_color="4F46E5", fill_type="solid")
+        
         pdf = PdfReader(io.BytesIO(pdf_bytes))
         row = 1
         
-        for page in pdf.pages:
+        # Headers
+        ws.cell(row=row, column=1, value="Page")
+        ws.cell(row=row, column=2, value="Content")
+        ws.cell(row=row, column=1).font = header_font
+        ws.cell(row=row, column=1).fill = header_fill
+        ws.cell(row=row, column=2).font = header_font
+        ws.cell(row=row, column=2).fill = header_fill
+        row += 1
+        
+        for page_num, page in enumerate(pdf.pages, 1):
             text = page.extract_text()
             if text:
                 lines = text.split('\n')
                 for line in lines:
                     if line.strip():
-                        ws.cell(row=row, column=1, value=line.strip()[:500])
+                        ws.cell(row=row, column=1, value=page_num)
+                        ws.cell(row=row, column=2, value=line.strip()[:500])
                         row += 1
         
+        # Auto-adjust columns
+        for column in ws.columns:
+            max_length = 0
+            for cell in column:
+                try:
+                    if len(str(cell.value)) > max_length:
+                        max_length = len(str(cell.value))
+                except:
+                    pass
+            adjusted_width = min(max_length + 2, 50)
+            ws.column_dimensions[column[0].column_letter].width = adjusted_width
+        
         buffer = io.BytesIO()
         wb.save(buffer)
         buffer.seek(0)
@@ -242,27 +378,38 @@ def convert_pdf_to_excel(pdf_bytes):
         print(f"PDF to Excel error: {e}")
         return pdf_bytes
 
+
 def convert_pdf_to_pptx(pdf_bytes):
     """Convert PDF to PPTX"""
     try:
         from pptx import Presentation
+        from pptx.util import Inches, Pt
         from PyPDF2 import PdfReader
         
         prs = Presentation()
+        title_slide_layout = prs.slide_layouts[0]
         content_slide_layout = prs.slide_layouts[1]
         
+        # Title slide
+        slide = prs.slides.add_slide(title_slide_layout)
+        title = slide.shapes.title
+        subtitle = slide.placeholders[1]
+        title.text = "PDF Converted to PowerPoint"
+        subtitle.text = f"Generated: {datetime.now().strftime('%B %d, %Y')}"
+        
         pdf = PdfReader(io.BytesIO(pdf_bytes))
         
-        for page in pdf.pages:
+        for i, page in enumerate(pdf.pages):
             slide = prs.slides.add_slide(content_slide_layout)
             title = slide.shapes.title
             content = slide.placeholders[1]
             
+            title.text = f"Page {i+1}"
             text = page.extract_text()
             if text and text.strip():
                 content.text = text[:1000] + "..." if len(text) > 1000 else text
             else:
-                content.text = "No text extracted"
+                content.text = "No text extracted from this page"
         
         buffer = io.BytesIO()
         prs.save(buffer)
@@ -273,51 +420,60 @@ def convert_pdf_to_pptx(pdf_bytes):
         print(f"PDF to PPTX error: {e}")
         return pdf_bytes
 
+
 def convert_excel_to_pdf(excel_bytes):
     """Convert Excel to PDF"""
     try:
         import openpyxl
-        from reportlab.pdfgen import canvas
-        from reportlab.lib.pagesizes import letter
-        from reportlab.lib.units import inch
-        import textwrap
+        from reportlab.lib.pagesizes import A4, landscape
+        from reportlab.lib import colors
+        from reportlab.lib.units import inch, cm
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.enums import TA_CENTER, TA_LEFT
         
         wb = openpyxl.load_workbook(io.BytesIO(excel_bytes))
         ws = wb.active
         
         buffer = io.BytesIO()
-        c = canvas.Canvas(buffer, pagesize=letter)
-        width, height = letter
+        doc = SimpleDocTemplate(
+            buffer,
+            pagesize=landscape(A4),
+            rightMargin=1.5 * cm,
+            leftMargin=1.5 * cm,
+            topMargin=2 * cm,
+            bottomMargin=2 * cm,
+        )
         
-        # Set up margins
-        left_margin = 72
-        top_margin = 72
-        bottom_margin = 72
+        styles = getSampleStyleSheet()
+        title_style = ParagraphStyle('Title', parent=styles['Title'], fontSize=16, alignment=TA_CENTER, spaceAfter=20)
         
-        c.setFont("Helvetica", 10)
-        y = height - top_margin
-        x = left_margin
+        story = []
+        story.append(Paragraph("Excel to PDF Conversion", title_style))
+        story.append(Spacer(1, 0.2 * inch))
         
-        # Extract all cell values
-        cell_values = []
+        # Convert rows
+        data = []
         for row in ws.iter_rows(values=True):
-            row_text = ' | '.join([str(cell) for cell in row if cell])
-            if row_text:
-                cell_values.append(row_text)
-        
-        # Write to PDF with word wrapping
-        for row_text in cell_values:
-            wrapped = textwrap.wrap(row_text, width=80)
-            for line in wrapped:
-                if y < bottom_margin:
-                    c.showPage()
-                    c.setFont("Helvetica", 10)
-                    y = height - top_margin
-                c.drawString(x, y, line)
-                y -= 12
-            y -= 6  # Space between rows
-        
-        c.save()
+            row_data = [str(cell) if cell else '' for cell in row]
+            if any(row_data):
+                data.append(row_data)
+        
+        if data:
+            table = Table(data)
+            table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, 0), 10),
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                ('GRID', (0, 0), (-1, -1), 1, colors.black)
+            ]))
+            story.append(table)
+        
+        doc.build(story)
         buffer.seek(0)
         return buffer.getvalue()
         
@@ -325,48 +481,52 @@ def convert_excel_to_pdf(excel_bytes):
         print(f"Excel to PDF error: {e}")
         return excel_bytes
 
+
 def convert_ppt_to_pdf(pptx_bytes):
     """Convert PPTX to PDF"""
     try:
         from pptx import Presentation
-        from reportlab.pdfgen import canvas
-        from reportlab.lib.pagesizes import letter
-        from reportlab.lib.units import inch
-        import textwrap
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.units import inch, cm
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.enums import TA_LEFT, TA_CENTER
         
         prs = Presentation(io.BytesIO(pptx_bytes))
         
         buffer = io.BytesIO()
-        c = canvas.Canvas(buffer, pagesize=letter)
-        width, height = letter
+        doc = SimpleDocTemplate(
+            buffer,
+            pagesize=A4,
+            rightMargin=2 * cm,
+            leftMargin=2 * cm,
+            topMargin=2 * cm,
+            bottomMargin=2 * cm,
+        )
         
-        left_margin = 72
-        top_margin = 72
-        bottom_margin = 72
+        styles = getSampleStyleSheet()
+        title_style = ParagraphStyle('Title', parent=styles['Title'], fontSize=16, alignment=TA_CENTER, spaceAfter=20)
+        slide_style = ParagraphStyle('Slide', parent=styles['Heading2'], fontSize=14, spaceAfter=10)
         
-        c.setFont("Helvetica", 11)
-        y = height - top_margin
-        x = left_margin
+        story = []
+        story.append(Paragraph("PowerPoint to PDF Conversion", title_style))
+        story.append(Spacer(1, 0.2 * inch))
         
-        for slide in prs.slides:
-            slide_text = []
+        for slide_num, slide in enumerate(prs.slides, 1):
+            story.append(Paragraph(f"<b>Slide {slide_num}</b>", slide_style))
+            story.append(Spacer(1, 0.1 * inch))
+            
             for shape in slide.shapes:
                 if hasattr(shape, "text") and shape.text:
-                    slide_text.append(shape.text.strip())
+                    text = shape.text.strip()
+                    if text:
+                        story.append(Paragraph(text, styles['Normal']))
+                        story.append(Spacer(1, 0.05 * inch))
             
-            if slide_text:
-                text = '\n\n'.join(slide_text)
-                wrapped = textwrap.wrap(text, width=80)
-                for line in wrapped:
-                    if y < bottom_margin:
-                        c.showPage()
-                        c.setFont("Helvetica", 11)
-                        y = height - top_margin
-                    c.drawString(x, y, line)
-                    y -= 15
-                y -= 20  # Space between slides
-        
-        c.save()
+            if slide_num < len(prs.slides):
+                story.append(PageBreak())
+        
+        doc.build(story)
         buffer.seek(0)
         return buffer.getvalue()
         
@@ -374,22 +534,54 @@ def convert_ppt_to_pdf(pptx_bytes):
         print(f"PPT to PDF error: {e}")
         return pptx_bytes
 
+
 def convert_image_to_other(img_bytes, target_format):
     """Convert image to different format"""
-    img = Image.open(io.BytesIO(img_bytes))
-    output = io.BytesIO()
+    try:
+        img = Image.open(io.BytesIO(img_bytes))
+        output = io.BytesIO()
+        
+        fmt = target_format.upper()
+        if fmt == "JPG":
+            fmt = "JPEG"
+            if img.mode in ('RGBA', 'P'):
+                rgb_img = Image.new('RGB', img.size, (255, 255, 255))
+                rgb_img.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
+                img = rgb_img
+        
+        img.save(output, format=fmt, quality=95)
+        output.seek(0)
+        return output.getvalue()
+        
+    except Exception as e:
+        print(f"Image conversion error: {e}")
+        return img_bytes
+
+
+def call_hf_api(url, data, max_retries=3):
+    """Call Hugging Face API with retry logic"""
+    if not HF_TOKEN:
+        return None
     
-    fmt = target_format.upper()
-    if fmt == "JPG":
-        fmt = "JPEG"
-        if img.mode in ('RGBA', 'P'):
-            rgb_img = Image.new('RGB', img.size, (255, 255, 255))
-            rgb_img.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
-            img = rgb_img
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
     
-    img.save(output, format=fmt, quality=95)
-    output.seek(0)
-    return output.getvalue()
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(url, headers=headers, data=data, timeout=60)
+            if response.status_code == 200:
+                return response.content
+            elif response.status_code == 503:
+                time.sleep(2 ** attempt)
+                continue
+            else:
+                return None
+        except:
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            return None
+    return None
+
 
 # ===== API ENDPOINTS =====
 
@@ -422,7 +614,6 @@ async def convert_file(
         ext = filename.split('.')[-1].lower() if '.' in filename else ''
         target = target_format.lower()
         
-        # Map source and target formats
         format_map = {
             ('docx', 'pdf'): ('application/pdf', 'pdf', convert_docx_to_pdf),
             ('pdf', 'docx'): ('application/vnd.openxmlformats-officedocument.wordprocessingml.document', 'docx', convert_pdf_to_docx),
@@ -448,48 +639,16 @@ async def convert_file(
                 )
             except Exception as e:
                 print(f"Conversion error: {e}")
-                # Fall through to text conversion
         
-        # If no specific converter, try text conversion
-        try:
-            text_content = content.decode('utf-8', errors='ignore')
-            
-            if target == 'txt':
-                file_content = text_content.encode('utf-8')
-                mime_type = 'text/plain'
-            elif target == 'csv':
-                lines = text_content.split('\n')
-                csv_content = '\n'.join([','.join(line.split()) for line in lines if line.strip()])
-                file_content = csv_content.encode('utf-8')
-                mime_type = 'text/csv'
-            elif target == 'json':
-                try:
-                    data = json.loads(text_content)
-                    file_content = json.dumps(data, indent=2).encode('utf-8')
-                except:
-                    file_content = json.dumps({"content": text_content[:500]}).encode('utf-8')
-                mime_type = 'application/json'
-            else:
-                file_content = content
-                mime_type = 'application/octet-stream'
-            
-            return Response(
-                content=file_content,
-                media_type=mime_type,
-                headers={
-                    "Content-Disposition": f"attachment; filename=converted.{target}",
-                    "Content-Length": str(len(file_content))
-                }
-            )
-        except:
-            return Response(
-                content=content,
-                media_type='application/octet-stream',
-                headers={
-                    "Content-Disposition": f"attachment; filename=converted.{target}",
-                    "Content-Length": str(len(content))
-                }
-            )
+        # Fallback: return original
+        return Response(
+            content=content,
+            media_type='application/octet-stream',
+            headers={
+                "Content-Disposition": f"attachment; filename=converted.{target}",
+                "Content-Length": str(len(content))
+            }
+        )
         
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
@@ -515,54 +674,6 @@ async def convert_image(
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
 
-@app.post("/api/remove-background")
-async def remove_background(file: UploadFile = File(...)):
-    """Remove background from image"""
-    if not HF_TOKEN:
-        try:
-            content = await file.read()
-            img = Image.open(io.BytesIO(content))
-            if img.mode != 'RGBA':
-                img = img.convert('RGBA')
-            output = io.BytesIO()
-            img.save(output, format='PNG')
-            output.seek(0)
-            return Response(
-                content=output.getvalue(),
-                media_type="image/png",
-                headers={"Content-Disposition": "attachment; filename=no_background.png"}
-            )
-        except:
-            return JSONResponse({"error": "HF_TOKEN not configured"}, status_code=401)
-    
-    try:
-        image_bytes = await file.read()
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-        url = "https://api-inference.huggingface.co/models/briaai/RMBG-1.4"
-        
-        response = requests.post(url, headers=headers, data=image_bytes, timeout=30)
-        
-        if response.status_code == 200:
-            return Response(
-                content=response.content,
-                media_type="image/png",
-                headers={"Content-Disposition": "attachment; filename=no_background.png"}
-            )
-        else:
-            img = Image.open(io.BytesIO(image_bytes))
-            if img.mode != 'RGBA':
-                img = img.convert('RGBA')
-            output = io.BytesIO()
-            img.save(output, format='PNG')
-            output.seek(0)
-            return Response(
-                content=output.getvalue(),
-                media_type="image/png",
-                headers={"Content-Disposition": "attachment; filename=no_background.png"}
-            )
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
 @app.post("/api/extract-text")
 async def extract_text(file: UploadFile = File(...)):
     """Extract text from image using OCR"""
@@ -571,13 +682,11 @@ async def extract_text(file: UploadFile = File(...)):
     
     try:
         image_bytes = await file.read()
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
         url = "https://api-inference.huggingface.co/models/microsoft/trocr-large-printed"
+        result = call_hf_api(url, image_bytes)
         
-        response = requests.post(url, headers=headers, data=image_bytes, timeout=30)
-        
-        if response.status_code == 200:
-            text = response.content.decode('utf-8', errors='ignore')
+        if result:
+            text = result.decode('utf-8', errors='ignore')
             return JSONResponse({"text": text, "success": True})
         else:
             return JSONResponse({"text": "OCR failed", "error": "OCR failed"}, status_code=500)
@@ -592,13 +701,11 @@ async def caption_image(file: UploadFile = File(...)):
     
     try:
         image_bytes = await file.read()
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
         url = "https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-base"
+        result = call_hf_api(url, image_bytes)
         
-        response = requests.post(url, headers=headers, data=image_bytes, timeout=30)
-        
-        if response.status_code == 200:
-            caption = response.content.decode('utf-8', errors='ignore')
+        if result:
+            caption = result.decode('utf-8', errors='ignore')
             return JSONResponse({"caption": caption, "success": True})
         else:
             return JSONResponse({"caption": "Caption generation failed", "error": "Failed"}, status_code=500)
@@ -621,13 +728,11 @@ async def summarize_text(file: UploadFile = File(...)):
         if len(text) > 2000:
             text = text[:2000]
         
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
         url = "https://api-inference.huggingface.co/models/facebook/bart-large-cnn"
+        result = call_hf_api(url, text.encode())
         
-        response = requests.post(url, headers=headers, data=text.encode(), timeout=30)
-        
-        if response.status_code == 200:
-            summary = response.content.decode('utf-8', errors='ignore')
+        if result:
+            summary = result.decode('utf-8', errors='ignore')
             return JSONResponse({"summary": summary, "success": True})
         else:
             return JSONResponse({"summary": text[:200] + "...", "error": "Failed"}, status_code=500)
@@ -645,11 +750,10 @@ async def vectorize_logo(file: UploadFile = File(...)):
         caption = "CONVERTLY Logo"
         if HF_TOKEN:
             try:
-                headers = {"Authorization": f"Bearer {HF_TOKEN}"}
                 url = "https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-base"
-                response = requests.post(url, headers=headers, data=image_bytes, timeout=30)
-                if response.status_code == 200:
-                    caption = response.content.decode('utf-8', errors='ignore')[:50]
+                result = call_hf_api(url, image_bytes)
+                if result:
+                    caption = result.decode('utf-8', errors='ignore')[:50]
             except:
                 pass