app.py

import gradio as gr
import re
import warnings
import io
import requests
from bs4 import BeautifulSoup
from urllib.parse import urlparse
warnings.filterwarnings("ignore")

class LightweightPersianSummarizer:
    def __init__(self):
        """Lightweight Persian summarizer using extractive methods"""
        print("Initializing lightweight Persian summarizer...")
    
    def preprocess_persian_text(self, text):
        """Clean and preprocess Persian text"""
        # Remove extra whitespaces
        text = re.sub(r'\s+', ' ', text.strip())
        
        # Remove unwanted characters but keep Persian text
        text = re.sub(r'[^\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\s\.\!\?\،\؛\:\«\»\(\)\[\]\{\}0-9a-zA-Z]', '', text)
        
        return text
    
    def score_sentence(self, sentence, position, total_sentences):
        """Score sentences for importance"""
        # Position score (earlier sentences are more important)
        position_score = 1.0 - (position / total_sentences) * 0.3
        
        # Length score (moderate length sentences are preferred)
        length = len(sentence.strip())
        if length < 20:
            length_score = 0.1
        elif length > 200:
            length_score = 0.7
        else:
            length_score = 1.0
        
        # Keyword density score (sentences with more Persian content)
        persian_chars = len(re.findall(r'[\u0600-\u06FF]', sentence))
        total_chars = len(sentence.replace(' ', ''))
        persian_ratio = persian_chars / max(total_chars, 1)
        
        # Combined score
        final_score = (position_score * 0.4) + (length_score * 0.3) + (persian_ratio * 0.3)
        
        return final_score
    
    def extractive_summary(self, text, target_length):
        """Advanced extractive summarization for Persian text"""
        # Split into sentences
        sentences = re.split(r'[.!?؟]', text)
        sentences = [s.strip() for s in sentences if len(s.strip()) > 15]
        
        if len(sentences) <= 2:
            return text[:target_length] + ("..." if len(text) > target_length else "")
        
        # Score all sentences
        scored_sentences = []
        for i, sentence in enumerate(sentences):
            score = self.score_sentence(sentence, i, len(sentences))
            scored_sentences.append((sentence, score, i))
        
        # Sort by score (highest first)
        scored_sentences.sort(key=lambda x: x[1], reverse=True)
        
        # Select sentences up to target length
        selected_sentences = []
        current_length = 0
        
        for sentence, score, original_index in scored_sentences:
            sentence_length = len(sentence)
            if current_length + sentence_length <= target_length:
                selected_sentences.append((sentence, original_index))
                current_length += sentence_length
            elif len(selected_sentences) == 0:  # At least include one sentence
                # Truncate the sentence if needed
                truncated = sentence[:target_length-10] + "..."
                selected_sentences.append((truncated, original_index))
                break
        
        # Sort selected sentences by original order
        selected_sentences.sort(key=lambda x: x[1])
        
        # Join sentences
        summary = ". ".join([sent[0] for sent in selected_sentences])
        
        # Final cleanup
        summary = re.sub(r'\s+', ' ', summary.strip())
        
        return summary
    
    def summarize_text(self, text, max_length=150, min_length=50):
        """Main summarization function"""
        if not text or len(text.strip()) < 50:
            return "❌ متن ورودی کوتاه است. لطفاً متن طولانی‌تری وارد کنید."
        
        try:
            # Preprocess text
            clean_text = self.preprocess_persian_text(text)
            
            # Check text length
            if len(clean_text) < 100:
                return "❌ متن پس از پردازش کوتاه است. متن بلندتری وارد کنید."
            
            # Use extractive summarization
            summary = self.extractive_summary(clean_text, max_length)
            
            # Ensure minimum length
            if len(summary) < min_length and len(clean_text) > min_length:
                # Try with higher target length
                summary = self.extractive_summary(clean_text, min(max_length + 50, len(clean_text)))
            
            return summary if summary else "❌ نتوانستم خلاصه مناسبی تولید کنم."
            
        except Exception as e:
            return f"❌ خطا در خلاصه‌سازی: {str(e)}"

# File processing functions
def extract_text_from_file(file_path):
    """Extract text from uploaded file"""
    if file_path is None:
        return None, "❌ فایلی انتخاب نشده است."
    
    try:
        file_extension = file_path.name.lower().split('.')[-1]
        
        if file_extension == 'txt':
            # Read plain text file
            with open(file_path.name, 'r', encoding='utf-8') as f:
                content = f.read()
            return content, f"✅ فایل متنی با موفقیت خوانده شد. ({len(content)} کاراکتر)"
        
        elif file_extension == 'docx':
            # Try to read Word document
            try:
                import docx
                doc = docx.Document(file_path.name)
                content = '\n'.join([paragraph.text for paragraph in doc.paragraphs])
                return content, f"✅ فایل Word با موفقیت خوانده شد. ({len(content)} کاراکتر)"
            except ImportError:
                return None, "❌ برای خواندن فایل Word نیاز به نصب python-docx دارید."
        
        elif file_extension == 'pdf':
            # Try to read PDF
            try:
                import PyPDF2
                with open(file_path.name, 'rb') as file:
                    pdf_reader = PyPDF2.PdfReader(file)
                    content = ''
                    for page in pdf_reader.pages:
                        content += page.extract_text() + '\n'
                return content, f"✅ فایل PDF با موفقیت خوانده شد. ({len(content)} کاراکتر)"
            except ImportError:
                return None, "❌ برای خواندن فایل PDF نیاز به نصب PyPDF2 دارید."
        
        else:
            # Try to read as plain text anyway
            try:
                with open(file_path.name, 'r', encoding='utf-8') as f:
                    content = f.read()
                return content, f"✅ فایل به عنوان متن خوانده شد. ({len(content)} کاراکتر)"
            except UnicodeDecodeError:
                try:
                    with open(file_path.name, 'r', encoding='cp1256') as f:
                        content = f.read()
                    return content, f"✅ فایل با کدگذاری cp1256 خوانده شد. ({len(content)} کاراکتر)"
                except:
                    return None, f"❌ قادر به خواندن فایل {file_extension} نیستم. فرمت‌های پشتیبانی شده: txt, docx, pdf"
    
    except Exception as e:
        return None, f"❌ خطا در خواندن فایل: {str(e)}"

def process_uploaded_file(file):
    """Process uploaded file and return text content"""
    if file is None:
        return "", "📁 فایل خود را انتخاب کنید"
    
    content, message = extract_text_from_file(file)
    
    if content:
        # Clean the content
        content = persian_summarizer.preprocess_persian_text(content)
        return content, message
    else:
        return "", message

# URL processing functions
def extract_text_from_url(url):
    """Extract text content from a URL"""
    if not url or not url.strip():
        return None, "❌ لطفاً آدرس وب‌سایت را وارد کنید."
    
    # Add protocol if missing
    if not url.startswith(('http://', 'https://')):
        url = 'https://' + url
    
    # Validate URL format
    try:
        parsed = urlparse(url)
        if not parsed.netloc:
            return None, "❌ آدرس وب‌سایت معتبر نیست."
    except:
        return None, "❌ آدرس وب‌سایت معتبر نیست."
    
    try:
        # Set headers to mimic a real browser
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
            'Accept-Language': 'fa,en-US,en;q=0.5',
            'Accept-Encoding': 'gzip, deflate',
            'Connection': 'keep-alive',
        }
        
        # Fetch the webpage
        response = requests.get(url, headers=headers, timeout=10, verify=False)
        response.raise_for_status()
        
        # Parse HTML content
        soup = BeautifulSoup(response.content, 'html.parser')
        
        # Remove script and style elements
        for script in soup(["script", "style", "nav", "footer", "header", "aside"]):
            script.decompose()
        
        # Extract text from common content areas
        content_selectors = [
            'article', 'main', '.content', '.post', '.article', 
            '.entry-content', '.post-content', '.article-content',
            '.story-body', '.article-body', '.content-body'
        ]
        
        extracted_text = ""
        
        # Try to find content in specific areas first
        for selector in content_selectors:
            content_area = soup.select_one(selector)
            if content_area:
                extracted_text = content_area.get_text(separator=' ', strip=True)
                break
        
        # If no specific content area found, extract from body
        if not extracted_text:
            body = soup.find('body')
            if body:
                extracted_text = body.get_text(separator=' ', strip=True)
            else:
                extracted_text = soup.get_text(separator=' ', strip=True)
        
        # Clean up the text
        extracted_text = re.sub(r'\s+', ' ', extracted_text.strip())
        
        if len(extracted_text) < 100:
            return None, "❌ محتوای متنی کافی در این صفحه یافت نشد."
        
        return extracted_text, f"✅ محتوای وب‌سایت با موفقیت استخراج شد. ({len(extracted_text)} کاراکتر)"
        
    except requests.exceptions.Timeout:
        return None, "❌ زمان اتصال به وب‌سایت تمام شد. لطفاً دوباره تلاش کنید."
    except requests.exceptions.ConnectionError:
        return None, "❌ خطا در اتصال به وب‌سایت. لطفاً اتصال اینترنت خود را بررسی کنید."
    except requests.exceptions.HTTPError as e:
        return None, f"❌ خطا در دریافت صفحه: {e.response.status_code}"
    except Exception as e:
        return None, f"❌ خطا در پردازش وب‌سایت: {str(e)}"

def process_url_input(url):
    """Process URL input and return text content"""
    if not url or not url.strip():
        return "", "🌐 آدرس وب‌سایت خود را وارد کنید"
    
    content, message = extract_text_from_url(url.strip())
    
    if content:
        # Clean the content
        content = persian_summarizer.preprocess_persian_text(content)
        return content, message
    else:
        return "", message

# Initialize the summarizer
persian_summarizer = LightweightPersianSummarizer()

def summarize_persian_text(text, summary_length):
    """Main function to handle summarization requests"""
    if summary_length == "کوتاه":
        max_len, min_len = 100, 30
    elif summary_length == "متوسط":
        max_len, min_len = 200, 50
    else:  # بلند
        max_len, min_len = 300, 100
    
    return persian_summarizer.summarize_text(text, max_len, min_len)

# Sample Persian texts for demonstration
sample_texts = {
    "خبر سیاسی": """
    مجلس شورای اسلامی ایران در جلسه علنی روز گذشته لایحه بودجه سال آینده را بررسی کرد. نمایندگان مجلس در این جلسه به بحث و بررسی جزئیات بودجه پرداختند و پیشنهادات مختلفی برای بهبود آن ارائه دادند. وزیر اقتصاد نیز در این جلسه حضور یافت و به سوالات نمایندگان پاسخ داد. بر اساس این لایحه، بودجه عمومی کشور نسبت به سال جاری افزایش قابل توجهی خواهد داشت. همچنین اعتبارات ویژه‌ای برای توسعه زیرساخت‌های کشور در نظر گرفته شده است. نمایندگان بر لزوم شفافیت در هزینه‌کرد بودجه تأکید کردند و خواستار نظارت دقیق‌تر بر اجرای برنامه‌های توسعه‌ای شدند.
    """,
    
    "مقاله علمی": """
    هوش مصنوعی در دهه‌های اخیر به یکی از مهم‌ترین فناوری‌های نوین تبدیل شده است. این فناوری کاربردهای گسترده‌ای در زمینه‌های مختلف نظیر پزشکی، آموزش، حمل و نقل و صنعت دارد. یادگیری ماشین که بخش مهمی از هوش مصنوعی محسوب می‌شود، امکان تحلیل داده‌های پیچیده و الگویابی را فراهم می‌کند. شبکه‌های عصبی مصنوعی نیز با الهام از مغز انسان طراحی شده‌اند و قابلیت‌های شگفت‌انگیزی در تشخیص الگو و پردازش تصویر دارند. با این حال، چالش‌هایی نظیر اخلاق در هوش مصنوعی و حفظ حریم خصوصی همچنان وجود دارد. محققان بر لزوم توسعه هوش مصنوعی مسئولانه تأکید می‌کنند تا از مزایای این فناوری استفاده کرده و از مضرات احتمالی آن جلوگیری شود.
    """,
    
    "متن ادبی": """
    در باغ گل‌های سرخ، پیرمردی با موهای سفید نشسته بود و به آسمان آبی نگاه می‌کرد. نسیم ملایم صبحگاهی برگ‌های درختان را به رقص درآورده بود. صدای آب نهری که از دور می‌آمد، آرامش خاصی به فضا می‌بخشید. پیرمرد در دل خود به یاد روزهای جوانی‌اش بود، زمانی که این باغ را با دستان خود کاشته بود. اکنون پس از سال‌ها، میوه زحماتش را می‌دید. گل‌های رنگارنگ، درختان سایه‌دار و آرامش این مکان، همه نشان از عشق و دلبستگی او به این باغ داشت. او لبخندی بر لب داشت، لبخندی که حاکی از رضایت و آرامش درونی بود. این باغ نه تنها مکانی برای استراحت، بلکه خانه‌ای برای خاطرات شیرین او بود.
    """
}

# Create Gradio interface
with gr.Blocks(
    title="خلاصه‌ساز متن فارسی - نسخه سبک",
    theme=gr.themes.Soft(),
    css="""
    .persian-text {
        direction: rtl;
        text-align: right;
        font-family: 'Tahoma', 'Arial Unicode MS', sans-serif;
    }
    .main-header {
        text-align: center;
        color: #2c3e50;
        margin-bottom: 20px;
    }
    """
) as app:
    
    gr.HTML("""
    <div class="main-header">
        <h1>🤖 خلاصه‌ساز هوشمند متن فارسی</h1>
        <p><strong>Persian Text Summarization Tool - Lightweight Version</strong></p>
        <p>این ابزار با روش استخراجی پیشرفته، متن‌ها، فایل‌ها و وب‌سایت‌ها را خلاصه می‌کند</p>
        <p>📁 فایل‌های TXT, DOCX, PDF | 🌐 وب‌سایت‌ها و مقالات آنلاین</p>
    </div>
    """)
    
    with gr.Row():
        with gr.Column(scale=2):
            gr.Markdown("## 📝 متن ورودی")
            
            # Method info
            gr.HTML("""
            <div style="padding: 10px; background-color: #e3f2fd; border-radius: 5px; margin-bottom: 10px;">
                <strong>⚡ روش:</strong> خلاصه‌سازی استخراجی پیشرفته<br>
                <strong>✅ مزیت:</strong> سریع، پایدار و کاملاً فارسی<br>
                <strong>🎯 کیفیت:</strong> بالا برای متن‌های فارسی
            </div>
            """)
            
            # File upload section
            with gr.Accordion("📁 آپلود فایل متنی", open=False):
                file_upload = gr.File(
                    label="فایل متنی خود را انتخاب کنید",
                    file_types=[".txt", ".docx", ".pdf"],
                    type="filepath"
                )
                file_status = gr.HTML("📋 فرمت‌های پشتیبانی شده: TXT, DOCX, PDF")
                load_file_btn = gr.Button("📂 بارگذاری متن از فایل", variant="secondary")
            
            # URL input section
            with gr.Accordion("🌐 استخراج از وب‌سایت", open=False):
                url_input = gr.Textbox(
                    label="آدرس وب‌سایت (URL)",
                    placeholder="https://example.com یا example.com",
                    lines=1
                )
                url_status = gr.HTML("🌍 وب‌سایت‌های فارسی و انگلیسی پشتیبانی می‌شوند")
                load_url_btn = gr.Button("🔗 استخراج متن از وب‌سایت", variant="secondary")
            
            # Sample text selector
            sample_selector = gr.Dropdown(
                choices=list(sample_texts.keys()),
                label="نمونه متن‌ها",
                value=None
            )
            
            # Main text input
            text_input = gr.Textbox(
                label="متن فارسی خود را وارد کنید",
                placeholder="متن خود را اینجا بنویسید یا کپی کنید...",
                lines=10,
                elem_classes=["persian-text"]
            )
            
            # Summary length option
            summary_length = gr.Radio(
                choices=["کوتاه", "متوسط", "بلند"],
                value="متوسط",
                label="طول خلاصه"
            )
            
            # Buttons
            with gr.Row():
                summarize_btn = gr.Button("🚀 خلاصه‌سازی", variant="primary")
                clear_btn = gr.Button("🗑️ پاک کردن", variant="secondary")
        
        with gr.Column(scale=2):
            gr.Markdown("## 📄 خلاصه متن")
            
            summary_output = gr.Textbox(
                label="خلاصه تولید شده",
                placeholder="خلاصه اینجا نمایش داده می‌شود...",
                lines=8,
                elem_classes=["persian-text"]
            )
            
            # Statistics
            with gr.Row():
                original_length = gr.Number(label="طول متن اصلی", interactive=False)
                summary_length_num = gr.Number(label="طول خلاصه", interactive=False)
                compression_ratio = gr.Number(label="نرخ فشرده‌سازی (%)", interactive=False)
    
    # Instructions
    with gr.Accordion("📖 راهنمای استفاده", open=False):
        gr.Markdown("""
        ### نحوه استفاده:
        1. **متن خود را وارد کنید**: متن فارسی خود را در قسمت "متن ورودی" بنویسید یا کپی کنید
        2. **یا فایل آپلود کنید**: فایل متنی (.txt, .docx, .pdf) خود را آپلود کنید
        3. **نمونه متن انتخاب کنید**: می‌توانید از نمونه متن‌های آماده استفاده کنید
        4. **طول خلاصه را تعیین کنید**: کوتاه، متوسط یا بلند
        5. **دکمه خلاصه‌سازی را بزنید**: منتظر بمانید تا خلاصه تولید شود
        
        ### ویژگی‌های نسخه سبک:
        - ✅ سریع و پایدار (بدون نیاز به مدل‌های سنگین)
        - ✅ کاملاً فارسی (هیچ ترجمه‌ای انجام نمی‌شود)
        - ✅ آپلود فایل‌های متنی (TXT, DOCX, PDF)
        - ✅ کیفیت بالا برای متن‌های فارسی
        - ✅ مناسب برای همه سرورها
        - ✅ روش استخراجی هوشمند
        - ✅ امتیازدهی پیشرفته به جملات
        
        ### فرمت‌های فایل پشتیبانی شده:
        - **TXT**: فایل‌های متن ساده (UTF-8, CP1256)
        - **DOCX**: اسناد Microsoft Word
        - **PDF**: اسناد PDF (نیاز به PyPDF2)
        
        ### نکات:
        - متن ورودی باید حداقل 100 کاراکتر باشد
        - جملات ابتدایی و میانی متن امتیاز بیشتری دریافت می‌کنند
        - این نسخه برای استقرار آسان طراحی شده است
        - هیچ وابستگی پیچیده‌ای ندارد
        - فایل‌های بزرگ ممکن است زمان بیشتری برای پردازش نیاز داشته باشند
        """)
    
    # Event handlers
    def load_sample_text(sample_name):
        if sample_name:
            return sample_texts[sample_name]
        return ""
    
    def calculate_stats(original, summary):
        if original and summary:
            orig_len = len(original)
            summ_len = len(summary)
            ratio = round((1 - summ_len/orig_len) * 100, 1) if orig_len > 0 else 0
            return orig_len, summ_len, ratio
        return 0, 0, 0
    
    def process_summarization(text, length):
        if not text.strip():
            return "❌ لطفاً متن ورودی را وارد کنید.", 0, 0, 0
        
        summary = summarize_persian_text(text, length)
        orig_len, summ_len, ratio = calculate_stats(text, summary)
        
        return summary, orig_len, summ_len, ratio
    
    def handle_file_upload(file):
        """Handle file upload and update text input"""
        content, message = process_uploaded_file(file)
        return content, message
    
    def handle_url_input(url):
        """Handle URL input and update text input"""
        content, message = process_url_input(url)
        return content, message
    
    # Connect events
    sample_selector.change(
        fn=load_sample_text,
        inputs=[sample_selector],
        outputs=[text_input]
    )
    
    load_file_btn.click(
        fn=handle_file_upload,
        inputs=[file_upload],
        outputs=[text_input, file_status]
    )
    
    load_url_btn.click(
        fn=handle_url_input,
        inputs=[url_input],
        outputs=[text_input, url_status]
    )
    
    summarize_btn.click(
        fn=process_summarization,
        inputs=[text_input, summary_length],
        outputs=[summary_output, original_length, summary_length_num, compression_ratio]
    )
    
    clear_btn.click(
        fn=lambda: ("", "", "📋 فرمت‌های پشتیبانی شده: TXT, DOCX, PDF", "🌍 وب‌سایت‌های فارسی و انگلیسی پشتیبانی می‌شوند", 0, 0, 0),
        outputs=[text_input, summary_output, file_status, url_status, original_length, summary_length_num, compression_ratio]
    )

# Launch the app
if __name__ == "__main__":
    app.launch(share=True)