app.py

import gradio as gr
import logging
import sys
import os

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger(__name__)

# Log startup information
logger.info("Starting StudAI Summarization Service with Gradio")
logger.info(f"Python version: {sys.version}")

# Import model
try:
    from transformers import pipeline
    logger.info("Loading summarization model (t5-small)...")
    
    summarizer = pipeline(
        "summarization", 
        model="t5-small",
        device=-1  # Use CPU for more reliable execution
    )
    logger.info("Model loaded successfully!")
    model_available = True
except Exception as e:
    logger.error(f"Failed to load model: {str(e)}")
    model_available = False
    
def summarize_text(text, max_length=150, min_length=30):
    """Summarize the provided text using the loaded model"""
    try:
        if not text or len(text) < 50:
            return text
            
        if not model_available:
            return "Error: Summarization model is not available"
        
        logger.info(f"Summarizing text of length {len(text)}")
        result = summarizer(
            text, 
            max_length=max_length, 
            min_length=min_length,
            truncation=True
        )
        summary = result[0]["summary_text"]
        logger.info(f"Generated summary of length {len(summary)}")
        return summary
    except Exception as e:
        logger.error(f"Error during summarization: {str(e)}")
        return f"Error: {str(e)}"

def api_summarize(text, max_length=150, min_length=30):
    """API function for summarization"""
    summary = summarize_text(text, max_length, min_length)
    return {"summary": summary}

# Create Gradio interface
with gr.Blocks(title="StudAI Summarization") as demo:
    gr.Markdown("# StudAI Text Summarization")
    gr.Markdown("This service provides text summarization for the StudAI Android app.")
    
    with gr.Row():
        with gr.Column():
            input_text = gr.Textbox(
                label="Input Text", 
                placeholder="Enter text to summarize (at least 50 characters)",
                lines=10
            )
            with gr.Row():
                max_length = gr.Slider(
                    label="Max Length", 
                    minimum=50, 
                    maximum=500, 
                    value=150, 
                    step=10
                )
                min_length = gr.Slider(
                    label="Min Length", 
                    minimum=10, 
                    maximum=200, 
                    value=30, 
                    step=5
                )
            submit_btn = gr.Button("Summarize")
        
        with gr.Column():
            output_text = gr.Textbox(label="Summary", lines=10)
    
    submit_btn.click(
        fn=summarize_text, 
        inputs=[input_text, max_length, min_length], 
        outputs=output_text
    )
    
    # Add API endpoints for Android app
    gr.Interface(
        fn=api_summarize,
        inputs=[
            gr.Textbox(label="text"),
            gr.Number(label="max_length", default=150),
            gr.Number(label="min_length", default=30)
        ],
        outputs=gr.JSON(),
        title="Summarization API",
        description="API for StudAI Android app"
    ).launch(show_api=True)

# Launch the app
demo.launch()