Update app.py

app.py

@@ -6,338 +6,136 @@ import tempfile
 from pathlib import Path
 import difflib
 import time
-from typing import Optional, Tuple
 import logging
 from concurrent.futures import ThreadPoolExecutor
 
-# ========== LOGGING SETUP ==========
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
+# Logger Setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("ParaphraserPro")
 
-# ========== MODEL SETUP ==========
-def load_model() -> Tuple[T5ForConditionalGeneration, T5Tokenizer]:
-    """Load model with error handling and progress tracking"""
+# Load Model
+def load_model():
     device = "cuda" if torch.cuda.is_available() else "cpu"
     model_name = "ramsrigouthamg/t5_paraphraser"
-    
-    try:
-        logger.info("Loading tokenizer...")
-        # First try with legacy=False (newer versions)
-        try:
-            tokenizer = T5Tokenizer.from_pretrained(model_name, legacy=False)
-        except:
-            # Fallback to legacy mode if needed
-            tokenizer = T5Tokenizer.from_pretrained(model_name)
-        
-        logger.info("Loading model...")
-        model = T5ForConditionalGeneration.from_pretrained(model_name).to(device)
-        model.eval()
-        
-        logger.info("Model loaded successfully")
-        return model, tokenizer
-    except Exception as e:
-        logger.error(f"Model loading failed: {str(e)}")
-        raise gr.Error(f"Failed to initialize the AI model. Please ensure all dependencies are installed. Error: {str(e)}")
+    tokenizer = T5Tokenizer.from_pretrained(model_name)
+    model = T5ForConditionalGeneration.from_pretrained(model_name).to(device)
+    return model.eval(), tokenizer, device
 
 try:
-    model, tokenizer = load_model()
-    device = next(model.parameters()).device
+    model, tokenizer, device = load_model()
 except Exception as e:
-    logger.error(f"Initial model loading failed: {str(e)}")
-    model, tokenizer = None, None
-    device = "cuda" if torch.cuda.is_available() else "cpu"
+    raise gr.Error(f"Model failed to load: {str(e)}")
 
-# ========== UTILITIES ==========
-def cleanup_file(file_path: Optional[str]) -> None:
-    """Securely delete temporary files with error handling"""
-    if file_path and Path(file_path).exists():
-        try:
-            Path(file_path).unlink()
-            logger.info(f"Cleaned up temporary file: {file_path}")
-        except Exception as e:
-            logger.warning(f"File cleanup error: {e}")
+# Text Extractor
+def extract_text(file_obj):
+    if file_obj.name.endswith(".pdf"):
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(file_obj.read())
+            tmp_path = tmp.name
 
-def extract_text(file_obj) -> Tuple[str, Optional[str]]:
-    """Handle file uploads with comprehensive error handling"""
-    temp_path = None
-    try:
-        if file_obj.name.endswith('.pdf'):
-            # Create temp file with secure permissions
-            with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as tmp:
-                temp_path = tmp.name
-                tmp.write(file_obj.read())
-            
-            with pdfplumber.open(temp_path) as pdf:
-                text = "\n".join(
-                    page.extract_text() or "" 
-                    for page in pdf.pages[:3]  # Limit to 3 pages for performance
-                )
-            return text[:5000], temp_path  # Limit to 5000 chars
-        
-        # Handle text files
-        text = file_obj.read().decode('utf-8')[:5000]
-        return text, None
+        with pdfplumber.open(tmp_path) as pdf:
+            text = "\n".join(page.extract_text() or "" for page in pdf.pages[:3])
+        Path(tmp_path).unlink()
+        return text[:5000]
     
-    except Exception as e:
-        logger.error(f"File processing error: {str(e)}")
-        if temp_path:
-            cleanup_file(temp_path)
-        raise gr.Error(f"File processing failed: {str(e)}")
+    return file_obj.read().decode("utf-8")[:5000]
 
-# ========== CORE FUNCTION ==========
-def process_request(
-    file_obj, 
-    text_input: str, 
-    creativity: int = 3, 
-    tone: str = "professional"
-) -> Tuple[str, int, int, int, list]:
-    """Main processing pipeline with enhanced error handling"""
-    start_time = time.time()
-    temp_file = None
-    progress = []
-    
-    try:
-        # Check if model is loaded
-        if model is None or tokenizer is None:
-            raise gr.Error("AI model failed to load. Please check the logs and try again later.")
-        
-        # Input validation
-        if not (file_obj or text_input):
-            raise gr.Error("Please provide either text or a file")
-        
-        # Process input
-        if file_obj:
-            text, temp_file = extract_text(file_obj)
-            progress.append("📄 File processed successfully")
-        else:
-            text = text_input[:5000]
-            progress.append("📝 Text input received")
-        
-        if not text.strip():
-            return "", 0, 0, 0, progress
-        
-        # Chunk processing with parallelization
-        chunks = [text[i:i+400] for i in range(0, len(text), 400)]
-        outputs = []
-        
-        def process_chunk(chunk: str) -> str:
-            """Process a single text chunk"""
-            inputs = tokenizer(
-                f"paraphrase: {chunk} </s>",
-                max_length=256,
-                padding="max_length",
-                return_tensors="pt",
-                truncation=True
-            ).to(device)
-            
-            outputs = model.generate(
-                **inputs,
-                max_length=256,
-                num_beams=3 + creativity,
-                temperature=0.7 + (creativity * 0.15),
-                early_stopping=True,
-                num_return_sequences=1
-            )
-            return tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Process chunks in parallel (limited threads)
-        with ThreadPoolExecutor(max_workers=2) as executor:
-            outputs = list(executor.map(process_chunk, chunks))
-            progress.extend(f"✍️ Processed chunk {i+1}/{len(chunks)}" 
-                          for i in range(len(chunks)))
-        
-        result = " ".join(outputs)
-        similarity = int(difflib.SequenceMatcher(None, text, result).ratio() * 100)
-        elapsed = time.time() - start_time
-        
-        progress.append(f"✅ Completed in {elapsed:.1f} seconds")
-        logger.info(f"Processed {len(text.split())} words in {elapsed:.2f}s")
-        
-        return result, len(text.split()), len(result.split()), similarity, progress
-    
-    except Exception as e:
-        logger.error(f"Processing error: {str(e)}")
-        progress.append(f"❌ Error: {str(e)}")
-        raise gr.Error(f"Processing failed: {str(e)}")
-    
-    finally:
-        if temp_file:
-            cleanup_file(temp_file)
+# Paraphrasing Core
+def paraphrase(file, text_input, creativity, tone):
+    start = time.time()
+    logs = []
+    input_text = ""
+
+    if file:
+        input_text = extract_text(file)
+        logs.append("📄 File processed.")
+    elif text_input.strip():
+        input_text = text_input.strip()[:5000]
+        logs.append("📝 Text input received.")
+    else:
+        raise gr.Error("Please provide text or upload a file.")
+
+    chunks = [input_text[i:i+400] for i in range(0, len(input_text), 400)]
+
+    def paraphrase_chunk(chunk):
+        inputs = tokenizer(f"paraphrase: {chunk} </s>", return_tensors="pt", padding="max_length", truncation=True, max_length=256).to(device)
+        outputs = model.generate(**inputs, max_length=256, num_beams=3+creativity, temperature=0.7+(creativity*0.15), num_return_sequences=1)
+        return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        results = list(executor.map(paraphrase_chunk, chunks))
+
+    output_text = " ".join(results)
+    similarity = int(difflib.SequenceMatcher(None, input_text, output_text).ratio() * 100)
+    elapsed = time.time() - start
 
-# ========== UI COMPONENTS ==========
+    logs.append(f"✅ Completed in {elapsed:.1f} seconds.")
+
+    return output_text, len(input_text.split()), len(output_text.split()), similarity, "<br>".join(logs)
+
+# Custom CSS
 custom_css = """
-:root {
-    --primary: #2563eb;
-    --primary-dark: #1d4ed8;
-    --text: #1e293b;
-    --light-bg: #f8fafc;
-}
-.gradio-container {
-    font-family: 'Inter', system-ui;
-    max-width: 1200px !important;
-    margin: 0 auto !important;
-}
-.header {
-    background: linear-gradient(135deg, var(--primary) 0%, var(--primary-dark) 100%);
-    border-radius: 12px 12px 0 0;
-    padding: 2rem 1rem;
-    color: white;
-}
-.card {
-    background: white;
-    border-radius: 12px;
-    box-shadow: 0 4px 24px rgba(0,0,0,0.08);
-    padding: 1.5rem;
-    margin-bottom: 1.5rem;
-}
-.progress-log {
-    font-size: 0.9em;
-    color: #64748b;
-    max-height: 120px;
-    overflow-y: auto;
-    background: #f8fafc;
-    padding: 0.75rem;
-    border-radius: 8px;
-}
-.file-upload {
-    border: 2px dashed #e2e8f0 !important;
-    border-radius: 8px !important;
-    padding: 1.5rem !important;
-}
-footer {
-    text-align: center;
-    padding: 1rem;
-    color: #64748b;
-    font-size: 0.9em;
-}
+body { background-color: #f8fafc; margin: 0; font-family: 'Inter', sans-serif; }
+.gradio-container { max-width: 1200px !important; margin: 0 auto !important; }
+h1, h3 { color: #1e293b; }
+.header { background: linear-gradient(135deg, #2563eb, #1d4ed8); padding: 2rem 1rem; color: white; text-align: center; border-radius: 1rem 1rem 0 0; }
+.card { background: white; border-radius: 1rem; padding: 2rem; box-shadow: 0 4px 20px rgba(0,0,0,0.08); margin-bottom: 2rem; }
+textarea, input, .gr-input { border-radius: 8px !important; }
+footer { text-align: center; color: #64748b; padding: 1rem; font-size: 0.9em; }
 """
 
-with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="AI Paraphraser Pro") as demo:
-    # ========== HEADER ==========
-    with gr.Column(elem_classes=["header"]):
-        gr.Markdown("""
-        <div style="text-align: center">
-            <h1 style="font-weight: 700; margin-bottom: 0.5rem">AI Paraphraser Pro</h1>
-            <p style="opacity: 0.9">Enterprise-grade text transformation with semantic preservation</p>
-        </div>
-        """)
-    
-    # ========== MAIN INTERFACE ==========
+# Gradio Interface
+with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as app:
+    with gr.Column(elem_classes="header"):
+        gr.Markdown("# AI Paraphraser Pro")
+        gr.Markdown("### Rewrite like a pro — smarter, faster, and safer")
+
     with gr.Row():
-        # Input Panel
         with gr.Column(scale=1):
-            with gr.Column(elem_classes=["card"]):
-                gr.Markdown("### Input Content")
-                
+            with gr.Column(elem_classes="card"):
+                gr.Markdown("### Input")
+
                 with gr.Tabs():
-                    with gr.TabItem("Text Input"):
-                        text_input = gr.Textbox(
-                            placeholder="Paste your text here...",
-                            lines=8,
-                            max_lines=12,
-                            label="Direct Input",
-                            elem_id="text-input"
-                        )
-                    
-                    with gr.TabItem("File Upload"):
-                        file_upload = gr.File(
-                            label="Upload PDF/TXT (Auto-deleted after processing)",
-                            file_types=[".pdf", ".txt"],
-                            elem_classes=["file-upload"]
-                        )
-                
-                with gr.Row():
-                    creativity = gr.Slider(
-                        1, 5, value=3,
-                        label="Creativity Level",
-                        info="1=Conservative, 5=Highly Creative"
-                    )
-                    tone = gr.Dropdown(
-                        ["professional", "academic", "casual"],
-                        value="professional",
-                        label="Output Style"
-                    )
-                
-                submit_btn = gr.Button(
-                    "Paraphrase Now",
-                    variant="primary",
-                    size="lg"
-                )
-        
-        # Output Panel
+                    with gr.Tab("Paste Text"):
+                        text_input = gr.Textbox(label="Your Text", lines=10, placeholder="Paste or type your content...")
+
+                    with gr.Tab("Upload File"):
+                        file_input = gr.File(label="Upload .pdf or .txt", file_types=[".pdf", ".txt"])
+
+                creativity = gr.Slider(1, 5, value=3, label="Creativity (1 = Conservative, 5 = Creative)")
+                tone = gr.Dropdown(["professional", "academic", "casual"], value="professional", label="Style")
+
+                submit = gr.Button("Paraphrase Now", variant="primary")
+
         with gr.Column(scale=1):
-            with gr.Column(elem_classes=["card"]):
-                gr.Markdown("### Paraphrased Output")
-                
-                output_text = gr.Textbox(
-                    lines=8,
-                    max_lines=12,
-                    label="Result",
-                    interactive=True,
-                    elem_id="output-text"
-                )
+            with gr.Column(elem_classes="card"):
+                gr.Markdown("### Output")
+                output_text = gr.Textbox(label="Paraphrased Output", lines=10, interactive=True)
                 
                 with gr.Row():
-                    copy_btn = gr.Button("Copy to Clipboard", size="sm")
-                    download_btn = gr.Button("Download Result", size="sm")
-                
-                with gr.Column(elem_classes=["card"]):
-                    gr.Markdown("**Text Analysis**")
+                    copy_btn = gr.Button("📋 Copy")
+                    download_btn = gr.Button("⬇️ Download")
+
+                with gr.Accordion("📊 Analysis", open=False):
                     with gr.Row():
-                        input_words = gr.Number(label="Original Words", precision=0)
-                        output_words = gr.Number(label="New Words", precision=0)
-                        similarity_score = gr.Number(label="Similarity (%)", precision=0)
-                
-                with gr.Accordion("Processing Log", open=False):
-                    progress_log = gr.HTML(elem_classes=["progress-log"])
-    
-    # ========== FOOTER ==========
-    gr.HTML("""
-    <footer>
-        <p>© 2024 AI Paraphraser Pro | Secure Processing | Files Never Stored</p>
-    </footer>
-    """)
+                        in_words = gr.Number(label="Input Words", interactive=False)
+                        out_words = gr.Number(label="Output Words", interactive=False)
+                        similarity = gr.Number(label="Similarity (%)", interactive=False)
+
+                logs = gr.HTML(label="Process Logs")
+
+    gr.HTML("<footer>© 2025 AI Paraphraser Pro – No content stored. Privacy-first platform.</footer>")
+
+    # Event Hooks
+    submit.click(paraphrase, inputs=[file_input, text_input, creativity, tone], outputs=[output_text, in_words, out_words, similarity, logs])
     
-    # ========== EVENT HANDLERS ==========
-    submit_btn.click(
-        process_request,
-        [file_upload, text_input, creativity, tone],
-        [output_text, input_words, output_words, similarity_score, progress_log],
-        api_name="paraphrase"
-    )
-    
-    copy_btn.click(
-        None,
-        [output_text],
-        None,
-        js="(text) => { navigator.clipboard.writeText(text); alert('Copied to clipboard!'); }"
-    )
+    copy_btn.click(None, inputs=[output_text], js="(text) => navigator.clipboard.writeText(text)")
     
     download_btn.click(
-        lambda text: (text, "paraphrased_result.txt"),
-        [output_text],
-        [gr.File(label="Downloading...", visible=False)]
+        lambda txt: gr.File.update(value=(tempfile.NamedTemporaryFile(delete=False, suffix=".txt").write(txt.encode()) or txt), visible=True),
+        inputs=[output_text],
+        outputs=[]
     )
 
-# [Previous code remains exactly the same until the launch section]
-
-# ========== LAUNCH SETTINGS ==========
-if __name__ == "__main__":
-    # Simple version without explicit queue
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_api=False,
-        favicon_path="favicon.ico"
-    )
-    
-    # OR for more control:
-    # demo.queue(max_size=2).launch(
-    #     server_name="0.0.0.0",
-    #     server_port=7860,
-    #     show_api=False,
-    #     favicon_path="favicon.ico"
-    # )
+# Launch on Hugging Face
+app.launch()