Create app.py

app.py

@@ -1,154 +1,386 @@
+# app.py - Complete ZeroGPU Pages Converter
 import gradio as gr
-import numpy as np
-import random
-
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
-
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
+import os
+import spaces
+import tempfile
+import zipfile
+import json
+from pathlib import Path
+from huggingface_hub import InferenceClient
+import xml.etree.ElementTree as ET
+import time
 
+# Initialize the Cerebras model client
+client = InferenceClient(
+    model="cerebras/llama-3.3-70b-instruct",
+    token=os.getenv("HF_TOKEN")  # Space secret
+)
+
+@spaces.GPU
+def extract_pages_content(file_path):
+    """Extract content from Apple Pages file using ZeroGPU"""
+    try:
+        content_parts = []
+        
+        with zipfile.ZipFile(file_path, 'r') as zip_ref:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                zip_ref.extractall(temp_dir)
+                temp_path = Path(temp_dir)
+                
+                # Strategy 1: Look for index.xml (main document structure)
+                index_xml = temp_path / "index.xml"
+                if index_xml.exists():
+                    content = parse_index_xml(index_xml)
+                    if content:
+                        return content
+                
+                # Strategy 2: Search all XML files
+                for xml_file in temp_path.rglob("*.xml"):
+                    try:
+                        tree = ET.parse(xml_file)
+                        root = tree.getroot()
+                        
+                        # Extract all text content
+                        for elem in root.iter():
+                            if elem.text and elem.text.strip():
+                                content_parts.append(elem.text.strip())
+                    except:
+                        continue
+                
+                # Strategy 3: Look for json files with content
+                for json_file in temp_path.rglob("*.json"):
+                    try:
+                        with open(json_file, 'r', encoding='utf-8') as f:
+                            data = json.load(f)
+                            # Extract text from json recursively
+                            extract_text_from_json(data, content_parts)
+                    except:
+                        continue
+        
+        if content_parts:
+            # Clean and deduplicate
+            unique_content = list(dict.fromkeys(content_parts))
+            return "\n\n".join(unique_content)
+        else:
+            return "Could not extract readable content from .pages file"
+            
+    except Exception as e:
+        return f"Error extracting content: {str(e)}"
+
+def parse_index_xml(xml_file):
+    """Parse the main index.xml file for document structure"""
+    try:
+        tree = ET.parse(xml_file)
+        root = tree.getroot()
+        
+        content_parts = []
+        
+        # Look for specific Pages XML structure
+        # Pages files often have content in specific elements
+        for elem in root.iter():
+            # Extract text from various element types
+            if elem.text and elem.text.strip():
+                text = elem.text.strip()
+                # Avoid adding very short fragments
+                if len(text) > 5:
+                    content_parts.append(text)
+        
+        return "\n".join(content_parts) if content_parts else None
+    except:
+        return None
+
+def extract_text_from_json(obj, content_parts):
+    """Recursively extract text from JSON objects"""
+    if isinstance(obj, dict):
+        for value in obj.values():
+            extract_text_from_json(value, content_parts)
+    elif isinstance(obj, list):
+        for item in obj:
+            extract_text_from_json(item, content_parts)
+    elif isinstance(obj, str) and obj.strip() and len(obj.strip()) > 5:
+        content_parts.append(obj.strip())
+
+@spaces.GPU
+def convert_pages_document(file, output_format, progress=gr.Progress()):
+    """Convert Pages document using Cerebras with ZeroGPU acceleration"""
+    if not file:
+        return None, "❌ Please upload a .pages file"
+    
+    try:
+        progress(0.1, desc="📖 Extracting content from .pages file...")
+        
+        # Extract content
+        content = extract_pages_content(file.name)
+        
+        if not content or len(content.strip()) < 10:
+            return None, "❌ Could not extract sufficient content from .pages file"
+        
+        progress(0.4, desc="🤖 Preparing conversion with Cerebras...")
+        
+        # Create format-specific prompt
+        prompt = create_conversion_prompt(content, output_format)
+        
+        progress(0.6, desc="⚡ Converting with Cerebras Lightning Speed...")
+        
+        # Convert using Cerebras (lightning fast!)
+        response = client.text_generation(
+            prompt,
+            max_new_tokens=4096,
+            temperature=0.1,
+            do_sample=False,
+            return_full_text=False,
+            stop_sequences=None
+        )
+        
+        progress(0.9, desc="💫 Creating output file...")
+        
+        # Create output file
+        output_path = create_output_file(response, output_format)
+        
+        progress(1.0, desc="✅ Conversion complete!")
+        
+        return output_path, f"✅ Successfully converted to {output_format} using ZeroGPU!"
+        
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+def create_conversion_prompt(content, output_format):
+    """Create optimized prompt for Cerebras model"""
+    format_instructions = {
+        "PDF": "Create content suitable for PDF format with proper structure and formatting",
+        "DOCX": "Format as Microsoft Word document with headers, paragraphs, and proper styling",
+        "TXT": "Convert to clean, readable plain text preserving structure",
+        "HTML": "Create well-structured HTML with semantic markup",
+        "Markdown": "Convert to properly formatted Markdown with headers and structure"
+    }
+    
+    return f"""You are an expert document converter. Convert the following Apple Pages document content to {output_format} format.
+
+INSTRUCTIONS:
+1. Preserve the original structure, formatting, and content organization
+2. Maintain headings, paragraphs, lists, and any tables if present
+3. Ensure the output is clean, professional, and well-formatted
+4. {format_instructions.get(output_format, "Format appropriately for the requested output type")}
+5. Return ONLY the converted content without explanations or meta-commentary
+
+ORIGINAL CONTENT:
+{content}
+
+CONVERTED {output_format.upper()} OUTPUT:"""
+
+def create_output_file(content, output_format):
+    """Create output file in specified format"""
+    # Clean the content (remove potential prompt artifacts)
+    content = content.strip()
+    
+    # Create temporary file with appropriate extension
+    extensions = {
+        "PDF": ".html",  # HTML for PDF compatibility
+        "DOCX": ".html", # HTML for Word compatibility  
+        "TXT": ".txt",
+        "HTML": ".html",
+        "Markdown": ".md"
+    }
+    
+    ext = extensions.get(output_format, ".txt")
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix=ext, delete=False, encoding='utf-8') as f:
+        if output_format in ["PDF", "DOCX"] and not content.startswith('<'):
+            # Wrap plain text in HTML for better compatibility
+            f.write(f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Converted Document</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; line-height: 1.6; }}
+        h1, h2, h3 {{ color: #333; }}
+        p {{ margin-bottom: 1em; }}
+    </style>
+</head>
+<body>
+    <pre style="white-space: pre-wrap; font-family: Arial, sans-serif;">{content}</pre>
+</body>
+</html>""")
+        else:
+            f.write(content)
+    
+    return f.name
+
+# Custom CSS for professional appearance
 css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
+.gradio-container {
+    background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
+    min-height: 100vh;
 }
-"""
 
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
+.main-content {
+    max-width: 1000px;
+    margin: 0 auto;
+    padding: 2rem;
+}
 
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
+.hero-section {
+    background: white;
+    border-radius: 1rem;
+    padding: 2rem;
+    text-align: center;
+    box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+    margin-bottom: 2rem;
+}
 
-            run_button = gr.Button("Run", scale=0, variant="primary")
+.upload-section {
+    background: white;
+    border-radius: 1rem;
+    padding: 2rem;
+    box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+}
 
-        result = gr.Image(label="Result", show_label=False)
+.format-selector {
+    background: #f8f9fa;
+    border-radius: 0.5rem;
+    padding: 1rem;
+    margin: 1rem 0;
+}
 
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
+.convert-button {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    padding: 1rem 2rem;
+    border-radius: 0.5rem;
+    font-size: 1.1rem;
+    font-weight: bold;
+    width: 100%;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
-            )
+.convert-button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(102, 126, 234, 0.3);
+}
 
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+.zerogpu-badge {
+    display: inline-block;
+    background: linear-gradient(45deg, #ff6b6b, #feca57);
+    color: white;
+    padding: 0.5rem 1rem;
+    border-radius: 2rem;
+    font-weight: bold;
+    font-size: 0.9rem;
+}
 
-            with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
+.pro-features {
+    background: #e8f5e9;
+    border-radius: 0.5rem;
+    padding: 1rem;
+    margin-top: 1rem;
+}
+"""
 
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
+# Create the Gradio interface
+with gr.Blocks(css=css, title="Pages Converter Pro - ZeroGPU", theme=gr.themes.Soft()) as app:
+    with gr.Column(elem_classes=["main-content"]):
+        # Hero section
+        gr.HTML("""
+        <div class="hero-section">
+            <h1>📄 Pages Converter Pro</h1>
+            <span class="zerogpu-badge">⚡ ZeroGPU Accelerated</span>
+            <p style="margin-top: 1rem; color: #666;">
+                Convert Apple Pages documents with lightning-fast Cerebras Llama-3.3-70B
+            </p>
+        </div>
+        """)
+        
+        # Pro benefits showcase
+        gr.HTML("""
+        <div class="pro-features">
+            <h3>🚀 HuggingFace Pro Benefits Active</h3>
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-top: 1rem;">
+                <div>✅ 5x Usage Quota</div>
+                <div>🔥 Priority Queue Access</div>
+                <div>💎 H200 GPU Hardware</div>
+                <div>⚡ Zero-GPU Acceleration</div>
+            </div>
+        </div>
+        """)
+        
+        # Main conversion interface
+        with gr.Row():
+            with gr.Column(scale=2, elem_classes=["upload-section"]):
+                gr.HTML("<h3>📎 Upload Your Document</h3>")
+                
+                file_input = gr.File(
+                    label="Select .pages file",
+                    file_types=[".pages"],
+                    elem_id="file-upload"
                 )
-
-            with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
+                
+                output_format = gr.Radio(
+                    choices=["PDF", "DOCX", "TXT", "HTML", "Markdown"],
+                    value="PDF",
+                    label="🎯 Output Format",
+                    elem_classes=["format-selector"]
                 )
-
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
+                
+                convert_btn = gr.Button(
+                    "⚡ Convert with ZeroGPU",
+                    variant="primary",
+                    elem_classes=["convert-button"]
                 )
+            
+            with gr.Column(scale=1):
+                gr.HTML("""
+                <div style="background: white; padding: 1.5rem; border-radius: 1rem; box-shadow: 0 5px 15px rgba(0,0,0,0.1);">
+                    <h3>⚡ ZeroGPU Features</h3>
+                    <ul style="color: #666;">
+                        <li>Lightning-fast processing</li>
+                        <li>H200 hardware acceleration</li>
+                        <li>Priority queue access</li>
+                        <li>Cerebras optimization</li>
+                    </ul>
+                    
+                    <h3>📋 Supported Formats</h3>
+                    <ul style="color: #666;">
+                        <li>📄 PDF (best quality)</li>
+                        <li>📝 Microsoft Word (DOCX)</li>
+                        <li>📋 Plain Text (TXT)</li>
+                        <li>🌐 Web Page (HTML)</li>
+                        <li>✏️ Markdown (MD)</li>
+                    </ul>
+                </div>
+                """)
+        
+        # Output section
+        with gr.Row():
+            output_file = gr.File(
+                label="📁 Download Your Converted File",
+                elem_id="output-download"
+            )
+        
+        with gr.Row():
+            status_html = gr.HTML(
+                value="<div style='text-align: center; padding: 1rem; color: #666;'>Ready to convert your Pages document</div>",
+                elem_id="status-display"
+            )
+        
+        # Connect the interface
+        convert_btn.click(
+            fn=convert_pages_document,
+            inputs=[file_input, output_format],
+            outputs=[output_file, status_html],
+            show_progress=True
+        )
+        
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; margin-top: 3rem; padding: 2rem; color: white;">
+            <p>💎 Built exclusively for HuggingFace Pro users</p>
+            <p><small>Powered by Cerebras • Accelerated by ZeroGPU • Made with ❤️</small></p>
+        </div>
+        """)
 
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
-        ],
-        outputs=[result, seed],
-    )
-
+# Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()