Delete app.py

app.py

@@ -1,262 +0,0 @@
-import gradio as gr
-import spaces
-import torch
-from transformers import AutoProcessor, Llama4ForConditionalGeneration
-import fitz  # PyMuPDF for PDF processing
-import docx
-from io import BytesIO
-import os
-from PIL import Image
-import base64
-
-# Initialize the model and processor
-model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct"
-
-# Global variables to store model and processor
-model = None
-processor = None
-
-def load_model():
-    """Load the Llama 4 model and processor"""
-    global model, processor
-    if model is None:
-        processor = AutoProcessor.from_pretrained(model_id)
-        model = Llama4ForConditionalGeneration.from_pretrained(
-            model_id,
-            device_map="auto",
-            torch_dtype=torch.bfloat16,
-            attn_implementation="flex_attention"
-        )
-    return model, processor
-
-# Define the six prompt templates
-PROMPTS = {
-    "summaries": """Write a concise summary of the provided document. The summary should be 150–200 words, capturing the main ideas, key arguments, or findings, and central themes. Exclude minor details or examples unless critical to the core message. Use clear, neutral language, structuring the summary with an introductory sentence stating the document's purpose, followed by main points in a logical order. Conclude with a brief statement on the document's significance or broader implications. Ensure accuracy by directly referencing the document's content and avoid personal opinions.
-
-Document content:
-{content}""",
-    
-    "outlines": """Create a detailed outline of the provided document. The outline should feature a clear hierarchy with main sections, subsections, and bullet points summarizing key concepts, arguments, or findings under each. Use Roman numerals for main sections and letters or numbers for subsections. Include a brief introductory statement (50–100 words) describing the document's scope and purpose. Ensure the outline is comprehensive, logically organized, and captures all major points from the document without extraneous details.
-
-Document content:
-{content}""",
-    
-    "analysis": """Provide a critical analysis of the provided document, focusing on its main arguments, evidence, or methodology. The analysis should be 300–400 words, evaluating strengths and weaknesses, the author's assumptions, biases, or rhetorical strategies, and the document's relevance or impact in its field or broader context. Support your points with direct evidence from the document, such as quotes or data. Organize the analysis with an introduction, body paragraphs (strengths, weaknesses, implications), and a conclusion. Maintain an objective tone, avoiding excessive summarization, and ensure all claims are grounded in the document's content.
-
-Document content:
-{content}""",
-    
-    "study_guides": """Develop a comprehensive study guide for the provided document. The guide should include: (1) a brief overview (50–100 words) of the document's scope and purpose, (2) a list of 5–7 key themes or concepts with concise explanations (50–100 words each), (3) a glossary of 10–15 essential terms from the document with clear definitions, (4) 3–5 critical discussion questions to encourage deeper thinking, and (5) a checklist of key takeaways or study tips. Organize the guide with clear headings and bullet points, ensuring it is student-friendly and focused on retention and understanding.
-
-Document content:
-{content}""",
-    
-    "tables": """Create a comparative table based on the provided document, synthesizing key elements (e.g., theories, findings, arguments, or concepts) across relevant criteria (e.g., assumptions, applications, strengths, weaknesses). The table should compare 3–5 elements, using rows for each element and columns for each criterion. Include a brief introductory paragraph (50–100 words) explaining the table's purpose and scope. Ensure the table is concise, visually organized, and populated with precise information directly from the document.
-
-Document content:
-{content}""",
-    
-    "questions": """Generate a set of 10 high-quality questions based on the provided document. Include: (1) 3 factual questions to test recall of key details, (2) 3 conceptual questions to assess understanding of main ideas or arguments, (3) 2 analytical questions to encourage critical thinking about the document's implications or weaknesses, and (4) 2 open-ended questions to prompt discussion or creative reflection. Label each question by type (factual, conceptual, analytical, open-ended), and ensure questions are clear, specific, and aligned with the document's core themes.
-
-Document content:
-{content}"""
-}
-
-# Enhanced document processing functions
-def extract_text_and_images_from_pdf(file_path):
-    """Extract both text and images from PDF file"""
-    doc = fitz.open(file_path)
-    text = ""
-    images = []
-    
-    for page_num in range(len(doc)):
-        page = doc[page_num]
-        
-        # Extract text
-        text += f"\n--- Page {page_num + 1} ---\n"
-        text += page.get_text()
-        
-        # Extract images
-        image_list = page.get_images()
-        for img_index, img in enumerate(image_list):
-            try:
-                # Get image
-                xref = img[0]
-                pix = fitz.Pixmap(doc, xref)
-                
-                if pix.n - pix.alpha < 4:  # GRAY or RGB
-                    # Convert to PIL Image
-                    img_data = pix.samples
-                    img_pil = Image.frombytes(pix.colorspace.name, [pix.width, pix.height], img_data)
-                    images.append(img_pil)
-                    text += f"\n[IMAGE {len(images)} extracted from page {page_num + 1}]\n"
-                
-                pix = None  # free memory
-            except Exception as e:
-                text += f"\n[IMAGE ERROR: Could not process image {img_index + 1} on page {page_num + 1}: {str(e)}]\n"
-    
-    doc.close()
-    return text, images
-
-def extract_text_from_docx(file_path):
-    """Extract text from DOCX file"""
-    doc = docx.Document(file_path)
-    text = ""
-    for paragraph in doc.paragraphs:
-        text += paragraph.text + "\n"
-    return text, []
-
-def extract_text_from_txt(file_path):
-    """Extract text from TXT file"""
-    with open(file_path, 'r', encoding='utf-8') as file:
-        return file.read(), []
-
-def process_document(file):
-    """Process uploaded document and extract text/images"""
-    if file is None:
-        return "", []
-    
-    file_path = file.name
-    file_extension = os.path.splitext(file_path)[1].lower()
-    
-    try:
-        if file_extension == '.pdf':
-            return extract_text_and_images_from_pdf(file_path)
-        elif file_extension == '.docx':
-            return extract_text_from_docx(file_path)
-        elif file_extension == '.txt':
-            return extract_text_from_txt(file_path)
-        else:
-            return "Unsupported file format. Please upload PDF, DOCX, or TXT files.", []
-    except Exception as e:
-        return f"Error processing file: {str(e)}", []
-
-# AI processing function with ZeroGPU
-@spaces.GPU
-def generate_content(text_input, file_input, task_type):
-    """Generate content using Llama 4 based on task type"""
-    # Load model
-    model, processor = load_model()
-    
-    # Get text content and images
-    if file_input is not None:
-        content, images = process_document(file_input)
-    else:
-        content = text_input
-        images = []
-    
-    if not content:
-        return "Please provide text input or upload a file."
-    
-    # Get the appropriate prompt
-    prompt_template = PROMPTS.get(task_type, PROMPTS["summaries"])
-    prompt = prompt_template.format(content=content)
-    
-    try:
-        # Prepare multimodal input
-        message_content = [{"type": "text", "text": prompt}]
-        
-        # Add images if available
-        for i, img in enumerate(images[:5]):  # Limit to 5 images
-            # Convert PIL image to base64 for the processor
-            buffered = BytesIO()
-            img.save(buffered, format="PNG")
-            img_b64 = base64.b64encode(buffered.getvalue()).decode()
-            img_url = f"data:image/png;base64,{img_b64}"
-            message_content.append({"type": "image", "url": img_url})
-        
-        messages = [{"role": "user", "content": message_content}]
-        
-        # Process with the multimodal processor
-        inputs = processor.apply_chat_template(
-            messages,
-            add_generation_prompt=True,
-            tokenize=True,
-            return_dict=True,
-            return_tensors="pt"
-        ).to(model.device)
-        
-        # Generate response
-        with torch.no_grad():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=2048,
-                temperature=0.7,
-                do_sample=True,
-                top_p=0.9,
-                repetition_penalty=1.1
-            )
-        
-        # Decode the response
-        response = processor.batch_decode(
-            outputs[:, inputs["input_ids"].shape[-1]:], 
-            skip_special_tokens=True
-        )[0]
-        
-        return response
-        
-    except Exception as e:
-        return f"Error generating content: {str(e)}"
-
-# Main Gradio interface
-with gr.Blocks(title="Document Study Assistant", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 📚 Document Study Assistant")
-    gr.Markdown("Upload documents or paste text to generate summaries, outlines, analysis, study guides, tables, and questions using Llama 4.")
-    gr.Markdown("**✨ Now with full multimodal support!** PDFs with images will be analyzed completely.")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            # Input section
-            gr.Markdown("### Input")
-            text_input = gr.Textbox(
-                label="Paste text here",
-                placeholder="Paste your text content here...",
-                lines=10,
-                max_lines=20
-            )
-            
-            gr.Markdown("**OR**")
-            
-            file_input = gr.File(
-                label="Upload Document",
-                file_types=[".pdf", ".docx", ".txt"],
-                file_count="single"
-            )
-            
-            # Task selection
-            gr.Markdown("### Select Task")
-            task_type = gr.Radio(
-                choices=[
-                    ("📝 Summaries", "summaries"),
-                    ("📋 Outlines", "outlines"),
-                    ("🔍 Analysis", "analysis"),
-                    ("📖 Study Guides", "study_guides"),
-                    ("📊 Tables", "tables"),
-                    ("❓ Questions", "questions")
-                ],
-                value="summaries",
-                label="Choose what to generate"
-            )
-            
-            generate_btn = gr.Button("🚀 Generate", variant="primary", size="lg")
-        
-        with gr.Column(scale=1):
-            # Output section
-            gr.Markdown("### Output")
-            output = gr.Textbox(
-                label="Generated Content",
-                lines=25,
-                max_lines=50,
-                show_copy_button=True
-            )
-    
-    # Connect the generate button to the function
-    generate_btn.click(
-        fn=generate_content,
-        inputs=[text_input, file_input, task_type],
-        outputs=output,
-        show_progress=True
-    )
-
-if __name__ == "__main__":
-    app.launch()