app.py

import gradio as gr
from markitdown import MarkItDown
import google.generativeai as genai
import tempfile
import os
from pathlib import Path

# Initialize MarkItDown
md = MarkItDown()

# Configure Gemini AI
genai.configure(api_key=os.getenv('GEMINI_KEY'))
model = genai.GenerativeModel('gemini-2.0-flash-exp')

def process_with_markitdown(input_path):
    """Process file or URL with MarkItDown and return text content"""
    try:
        result = md.convert(input_path)
        return result.text_content
    except Exception as e:
        return f"Error processing input: {str(e)}"

import tempfile
import os
import io

import tempfile
import os
import io
from gardio import upload_file

def save_uploaded_file(file_data):
    """Saves a file uploaded with gardio to a temporary location.

    Args:
        file_data: The file data object returned by gardio.get_file().

    Returns:
        The path to the saved file, or an error message as a string.
    """

    if file_data is None:
        return "No file uploaded."
    
    try:
        # Extract the filename; crucial to avoid errors
        filename = file_data.filename if hasattr(file_data, 'filename') else "unknown_file"
        temp_dir = tempfile.gettempdir()
        temp_filename = tempfile.mkstemp(dir=temp_dir, suffix=os.path.splitext(filename)[1])[1]

        with open(temp_filename, 'wb') as f:
            try:
                if hasattr(file_data, 'read'):
                    for chunk in file_data.chunks():
                        f.write(chunk)
                elif hasattr(file_data, 'getvalue'):
                    f.write(file_data.getvalue())
                else:
                    return "Error: Unsupported file-like object."

            except Exception as e:
                return f"Error writing to file: {str(e)}"

        return temp_filename

    except Exception as e:
        return f"An error occurred during file saving: {str(e)}"
        
async def summarize_text(text):
    """Summarize the input text using Gemini AI"""
    try:
        prompt = f"""Please provide a concise summary of the following text. Focus on the main points and key takeaways:

{text}

Summary:"""
        
        response = await model.generate_content_async(prompt)
        return response.text
    except Exception as e:
        return f"Error generating summary: {str(e)}"

async def process_input(input_text, uploaded_file=None):
    """Main function to process either URL or uploaded file"""
    try:
        if uploaded_file is not None:
            # Handle file upload
            temp_path = save_uploaded_file(uploaded_file)
            if temp_path.startswith('Error'):
                return temp_path
                
            text = process_with_markitdown(temp_path)
            
            # Clean up temporary file
            try:
                os.remove(temp_path)
            except:
                pass
        
        elif input_text.startswith(('http://', 'https://')):
            # Handle URL
            text = process_with_markitdown(input_text)
        
        else:
            # Handle direct text input
            text = input_text
        
        if text.startswith('Error'):
            return text
            
        # Generate summary using Gemini AI
        summary = await summarize_text(text)
        return summary
    
    except Exception as e:
        return f"Error processing input: {str(e)}"

def clear_inputs():
    return ["", None, ""]

# Create Gradio interface with drag-and-drop
with gr.Blocks(theme=gr.themes.Soft()) as iface:
    gr.Markdown(
        """
        # Summarizeit
        > Summarize any document!
        
        Enter a URL, paste text, or drag & drop a file to get a summary.
        """
    )
    
    with gr.Row():
        input_text = gr.Textbox(
            label="Enter URL or text",
            placeholder="Enter a URL or paste text here...",
            scale=2
        )
    
    with gr.Row():
        file_upload = gr.File(
            label="Drop files here or click to upload",
            file_types=[
                ".pdf", ".docx", ".xlsx", ".csv", ".txt", ".md", 
                ".html", ".htm", ".xml", ".json"
            ],
            file_count="single",
            scale=2
        )
    
    with gr.Row():
        submit_btn = gr.Button("Summarize", variant="primary")
        clear_btn = gr.Button("Clear")
    
    output_text = gr.Textbox(
        label="Summary",
        lines=10,
        show_copy_button=True
    )
    
    # Set up event handlers
    submit_btn.click(
        fn=process_input,
        inputs=[input_text, file_upload],
        outputs=output_text
    )
    
    clear_btn.click(
        fn=clear_inputs,
        outputs=[input_text, file_upload, output_text]
    )
    
    # Add examples
    gr.Examples(
        examples=[
            ["https://h3manth.com"],
            ["https://www.youtube.com/watch?v=bSHp7WVpPgc"],
            ["https://en.wikipedia.org/wiki/Three-body_problem"]
        ],
        inputs=input_text
    )

if __name__ == "__main__":
    iface.launch()