Update app.py

app.py

@@ -1,12 +1,41 @@
 import gradio as gr
+import torch
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
 import re
 import warnings
+import io
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urlparse, parse_qs
 warnings.filterwarnings("ignore")
 
-class LightweightPersianSummarizer:
+class PersianSummarizer:
     def __init__(self):
-        """Lightweight Persian summarizer using extractive methods"""
-        print("Initializing lightweight Persian summarizer...")
+        # Using mT5 which is more stable and supports Persian well
+        self.model_name = "google/mt5-small"
+        self.tokenizer = None
+        self.model = None
+        self.load_model()
+    
+    def load_model(self):
+        """Load the multilingual T5 model for Persian summarization"""
+        try:
+            print("Loading mT5 model for Persian summarization...")
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
+            print("mT5 model loaded successfully!")
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            # Fallback to pipeline approach
+            try:
+                from transformers import pipeline
+                self.pipeline = pipeline("summarization", model="facebook/bart-large-cnn")
+                self.model = None
+                print("Fallback pipeline loaded!")
+            except Exception as e2:
+                print(f"All models failed: {e2}")
+                self.model = None
+                self.pipeline = None
     
     def preprocess_persian_text(self, text):
         """Clean and preprocess Persian text"""
@@ -18,102 +47,400 @@ class LightweightPersianSummarizer:
         
         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
+    def summarize_text(self, text, max_length=150, min_length=50):
+        """Summarize Persian text keeping output in Persian"""
+        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 "❌ متن پس از پردازش کوتاه است. متن بلندتری وارد کنید."
+            
+            if self.model is None:
+                # Use fallback methods
+                if hasattr(self, 'pipeline') and self.pipeline:
+                    # Try with pipeline but post-process to stay Persian
+                    result = self.pipeline(clean_text, max_length=max_length, min_length=min_length)
+                    return self.ensure_persian_output(result[0]['summary_text'], clean_text)
+                else:
+                    # Pure extractive method
+                    return self.extractive_summary(clean_text, max_length)
+            
+            # Use mT5 with Persian-specific prompting
+            # Add Persian instruction to encourage Persian output
+            persian_prompt = f"خلاصه کنید: {clean_text}"
+            
+            # Tokenize with proper settings
+            inputs = self.tokenizer(
+                persian_prompt, 
+                max_length=512,  # Reduced for stability
+                padding=True, 
+                truncation=True, 
+                return_tensors="pt"
+            )
+            
+            # Generate summary
+            with torch.no_grad():
+                summary_ids = self.model.generate(
+                    inputs["input_ids"],
+                    attention_mask=inputs.get("attention_mask"),
+                    max_length=max_length,
+                    min_length=min_length,
+                    num_beams=2,  # Reduced for speed
+                    length_penalty=1.0,
+                    repetition_penalty=1.1,
+                    early_stopping=True,
+                    do_sample=False
+                )
+            
+            # Decode and clean
+            summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+            
+            # Clean up the summary and ensure it's Persian
+            summary = self.clean_persian_summary(summary, clean_text)
+            
+            return summary
+
+# 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]
         
-        # 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)
+        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)} کاراکتر)"
         
-        # Combined score
-        final_score = (position_score * 0.4) + (length_score * 0.3) + (persian_ratio * 0.3)
+        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 دارید."
         
-        return final_score
+        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"
     
-    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]
+    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',
+        }
         
-        if len(sentences) <= 2:
-            return text[:target_length] + ("..." if len(text) > target_length else "")
+        # Fetch the webpage
+        response = requests.get(url, headers=headers, timeout=10, verify=False)
+        response.raise_for_status()
         
-        # 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))
+        # Parse HTML content
+        soup = BeautifulSoup(response.content, 'html.parser')
         
-        # Sort by score (highest first)
-        scored_sentences.sort(key=lambda x: x[1], reverse=True)
+        # Remove script and style elements
+        for script in soup(["script", "style", "nav", "footer", "header", "aside"]):
+            script.decompose()
         
-        # Select sentences up to target length
-        selected_sentences = []
-        current_length = 0
+        # 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'
+        ]
         
-        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))
+        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
         
-        # Sort selected sentences by original order
-        selected_sentences.sort(key=lambda x: x[1])
+        # 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)
         
-        # Join sentences
-        summary = ". ".join([sent[0] for sent in selected_sentences])
+        # Clean up the text
+        extracted_text = re.sub(r'\s+', ' ', extracted_text.strip())
         
-        # Final cleanup
-        summary = re.sub(r'\s+', ' ', summary.strip())
+        if len(extracted_text) < 100:
+            return None, "❌ محتوای متنی کافی در این صفحه یافت نشد."
         
-        return summary
+        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 "", "🌐 آدرس وب‌سایت خود را وارد کنید"
     
-    def summarize_text(self, text, max_length=150, min_length=50):
-        """Main summarization function"""
-        if not text or len(text.strip()) < 50:
-            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
+
+# YouTube processing functions
+def extract_youtube_video_id(url):
+    """Extract YouTube video ID from URL"""
+    if not url:
+        return None
+    
+    # Handle different YouTube URL formats
+    patterns = [
+        r'(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([^&\n?#]+)',
+        r'youtube\.com\/watch\?.*v=([^&\n?#]+)'
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, url)
+        if match:
+            return match.group(1)
+    
+    return None
+
+def extract_youtube_transcript(url):
+    """Extract transcript from YouTube video"""
+    if not url or not url.strip():
+        return None, "❌ لطفاً لینک یوتیوب را وارد کنید."
+    
+    try:
+        # Import youtube-transcript-api
+        from youtube_transcript_api import YouTubeTranscriptApi
+        from youtube_transcript_api._errors import TranscriptsDisabled, NoTranscriptFound
+        
+        # Extract video ID
+        video_id = extract_youtube_video_id(url.strip())
+        if not video_id:
+            return None, "❌ لینک یوتیوب معتبر نیست. مثال: https://youtube.com/watch?v=VIDEO_ID"
         
+        # Try to get transcript in Persian first, then English
+        transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+        
+        transcript_text = ""
+        language_used = ""
+        
+        # Try Persian first
         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 "❌ نتوانستم خلاصه مناسبی تولید کنم."
+            transcript = transcript_list.find_transcript(['fa', 'per'])
+            transcript_data = transcript.fetch()
+            language_used = "فارسی"
+        except:
+            # Try English
+            try:
+                transcript = transcript_list.find_transcript(['en'])
+                transcript_data = transcript.fetch()
+                language_used = "انگلیسی"
+            except:
+                # Try any available transcript
+                try:
+                    transcript = transcript_list.find_manually_created_transcript(['fa', 'per', 'en'])
+                    transcript_data = transcript.fetch()
+                    language_used = "دستی"
+                except:
+                    # Try auto-generated
+                    try:
+                        transcript = transcript_list.find_generated_transcript(['fa', 'per', 'en'])
+                        transcript_data = transcript.fetch()
+                        language_used = "خودکار"
+                    except:
+                        return None, "❌ این ویدیو زیرنویس قابل دسترس ندارد."
+        
+        # Combine transcript text
+        transcript_text = ' '.join([entry['text'] for entry in transcript_data])
+        
+        if len(transcript_text) < 100:
+            return None, "❌ متن زیرنویس کوتاه است یا کیفیت مناسبی ندارد."
+        
+        return transcript_text, f"✅ زیرنویس یوتیوب استخراج شد ({language_used}). ({len(transcript_text)} کاراکتر)"
+        
+    except ImportError:
+        return None, "❌ برای استخراج زیرنویس یوتیوب نیاز به نصب youtube-transcript-api دارید."
+    except TranscriptsDisabled:
+        return None, "❌ زیرنویس برای این ویدیو غیرفعال است."
+    except NoTranscriptFound:
+        return None, "❌ هیچ زیرنویسی برای این ویدیو یافت نشد."
+    except Exception as e:
+        return None, f"❌ خطا در استخراج زیرنویس: {str(e)}"
+
+def process_youtube_input(url):
+    """Process YouTube URL and return transcript content"""
+    if not url or not url.strip():
+        return "", "📺 لینک یوتیوب خود را وارد کنید"
+    
+    content, message = extract_youtube_transcript(url.strip())
+    
+    if content:
+        # Clean the content
+        content = persian_summarizer.preprocess_persian_text(content)
+        return content, message
+    else:
+        return "", message if summary else "❌ نتوانستم خلاصه مناسبی تولید کنم. لطفاً متن دیگری امتحان کنید."
             
         except Exception as e:
-            return f"❌ خطا در خلاصه‌سازی: {str(e)}"
+            print(f"Error in summarization: {e}")
+            # Always fallback to extractive
+            return self.extractive_summary(clean_text, max_length)
+    
+    def ensure_persian_output(self, text, original_text):
+        """Ensure output stays in Persian"""
+        # If the output seems to be English, use extractive method instead
+        english_ratio = len(re.findall(r'[a-zA-Z]', text)) / max(len(text), 1)
+        if english_ratio > 0.3:  # If more than 30% English characters
+            return self.extractive_summary(original_text, 150)
+        return text
+    
+    def clean_persian_summary(self, summary, original_text):
+        """Clean and ensure Persian summary quality"""
+        # Remove the prompt prefix if it exists
+        summary = re.sub(r'^خلاصه کنید:?\s*', '', summary)
+        
+        # Remove excessive English characters
+        summary = re.sub(r'[a-zA-Z]{3,}', '', summary)
+        
+        # Check if summary is mostly Persian
+        persian_chars = len(re.findall(r'[\u0600-\u06FF]', summary))
+        total_chars = len(re.sub(r'\s', '', summary))
+        
+        if total_chars == 0 or persian_chars / total_chars < 0.5:
+            # If not enough Persian content, use extractive method
+            return self.extractive_summary(original_text, 150)
+        
+        # Clean whitespace
+        summary = re.sub(r'\s+', ' ', summary.strip())
+        
+        return summary
+    
+    def extractive_summary(self, text, max_length):
+        """Simple extractive summarization fallback that keeps Persian"""
+        sentences = re.split(r'[.!?؟]', text)
+        sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+        
+        if len(sentences) <= 2:
+            return text[:max_length] + ("..." if len(text) > max_length else "")
+        
+        # Score sentences by position and length
+        scored_sentences = []
+        for i, sentence in enumerate(sentences):
+            # Give higher scores to earlier sentences and longer sentences
+            position_score = 1.0 - (i / len(sentences)) * 0.5
+            length_score = min(len(sentence) / 100, 1.0)
+            total_score = position_score + length_score
+            scored_sentences.append((sentence, total_score))
+        
+        # Sort by score and take top sentences
+        scored_sentences.sort(key=lambda x: x[1], reverse=True)
+        
+        # Select sentences until we reach desired length
+        summary_sentences = []
+        current_length = 0
+        
+        for sentence, score in scored_sentences:
+            if current_length + len(sentence) < max_length:
+                summary_sentences.append(sentence)
+                current_length += len(sentence)
+            else:
+                break
+        
+        # Maintain original order
+        original_order = []
+        for sentence in sentences:
+            if sentence in summary_sentences:
+                original_order.append(sentence)
+        
+        summary = ". ".join(original_order)
+        return summary[:max_length] + ("..." if len(summary) > max_length else "")
 
 # Initialize the summarizer
-persian_summarizer = LightweightPersianSummarizer()
+persian_summarizer = PersianSummarizer()
 
 def summarize_persian_text(text, summary_length):
     """Main function to handle summarization requests"""
@@ -129,21 +456,21 @@ def summarize_persian_text(text, summary_length):
 # Sample Persian texts for demonstration
 sample_texts = {
     "خبر سیاسی": """
-    مجلس شورای اسلامی ایران در جلسه علنی روز گذشته لایحه بودجه سال آینده را بررسی کرد. نمایندگان مجلس در این جلسه به بحث و بررسی جزئیات بودجه پرداختند و پیشنهادات مختلفی برای بهبود آن ارائه دادند. وزیر اقتصاد نیز در این جلسه حضور یافت و به سوالات نمایندگان پاسخ داد. بر اساس این لایحه، بودجه عمومی کشور نسبت به سال جاری افزایش قابل توجهی خواهد داشت. همچنین اعتبارات ویژه‌ای برای توسعه زیرساخت‌های کشور در نظر گرفته شده است. نمایندگان بر لزوم شفافیت در هزینه‌کرد بودجه تأکید کردند و خواستار نظارت دقیق‌تر بر اجرای برنامه‌های توسعه‌ای شدند.
+    مجلس شورای اسلامی ایران در جلسه علنی روز گذشته لایحه بودجه سال آینده را بررسی کرد. نمایندگان مجلس در این جلسه به بحث و بررسی جزئیات بودجه پرداختند و پیشنهادات مختلفی برای بهبود آن ارائه دادند. وزیر اقتصاد نیز در این جلسه حضور یافت و به سوالات نمایندگان پاسخ داد. بر اساس این لایحه، بودجه عمومی کشور نسبت به سال جاری افزایش قابل توجهی خواهد داشت. همچنین اعتبارات ویژه‌ای برای توسعه زیرساخت‌های کشور در نظر گرفته شده است.
     """,
     
     "مقاله علمی": """
-    هوش مصنوعی در دهه‌های اخیر به یکی از مهم‌ترین فناوری‌های نوین تبدیل شده است. این فناوری کاربردهای گسترده‌ای در زمینه‌های مختلف نظیر پزشکی، آموزش، حمل و نقل و صنعت دارد. یادگیری ماشین که بخش مهمی از هوش مصنوعی محسوب می‌شود، امکان تحلیل داده‌های پیچیده و الگویابی را فراهم می‌کند. شبکه‌های ع��بی مصنوعی نیز با الهام از مغز انسان طراحی شده‌اند و قابلیت‌های شگفت‌انگیزی در تشخیص الگو و پردازش تصویر دارند. با این حال، چالش‌هایی نظیر اخلاق در هوش مصنوعی و حفظ حریم خصوصی همچنان وجود دارد. محققان بر لزوم توسعه هوش مصنوعی مسئولانه تأکید می‌کنند تا از مزایای این فناوری استفاده کرده و از مضرات احتمالی آن جلوگیری شود.
+    هوش مصنوعی در دهه‌های اخیر به یکی از مهم‌ترین فناوری‌های نوین تبدیل شده است. این فناوری کاربردهای گسترده‌ای در زمینه‌های مختلف نظیر پزشکی، آموزش، حمل و نقل و صنعت دارد. یادگیری ماشین که بخش مهمی از هوش مصنوعی محسوب می‌شود، امکان تحلیل داده‌های پیچیده و الگویابی را فراهم می‌کند. شبکه‌های عصبی مصنوعی نیز با الهام از مغز انسان طراحی شده‌اند و قابلیت‌های شگفت‌انگیزی در تشخیص الگو و پردازش تصویر دارند. با این حال، چالش‌هایی نظیر اخلاق در هوش مصنوعی و حفظ حریم خصوصی همچنان وجود دارد.
     """,
     
     "متن ادبی": """
-    در باغ گل‌های سرخ، پیرمردی با موهای سفید نشسته بود و به آسمان آبی نگاه می‌کرد. نسیم ملایم صبحگاهی برگ‌های درختان را به رقص درآورده بود. صدای آب نهری که از دور می‌آمد، آرامش خاصی به فضا می‌بخشید. پیرمرد در دل خود به یاد روزهای جوانی‌اش بود، زمانی که این باغ را با دستان خود کاشته بود. اکنون پس از سال‌ها، میوه زحماتش را می‌دید. گل‌های رنگارنگ، درختان سایه‌دار و آرامش این مکان، همه نشان از عشق و دلبستگی او به این باغ داشت. او لبخندی بر لب داشت، لبخندی که حاکی از رضایت و آرامش درونی بود. این باغ نه تنها مکانی برای استراحت، بلکه خانه‌ای برای خاطرات شیرین او بود.
+    در باغ گل‌های سرخ، پیرمردی با موهای سفید نشسته بود و به آسمان آبی نگاه می‌کرد. نسیم ملایم صبحگاهی برگ‌های درختان را به رقص درآورده بود. صدای آب نهری که از دور می‌آمد، آرامش خاصی به فضا می‌بخشید. پیرمرد در دل خود به یاد روزهای جوانی‌اش بود، زمانی که این باغ را با دستان خود کاشته بود. اکنون پس از سال‌ها، میوه زحماتش را می‌دید. گل‌های رنگارنگ، درختان سایه‌دار و آرامش این مکان، همه نشان از عشق و دلبستگی او به این باغ داشت.
     """
 }
 
 # Create Gradio interface
 with gr.Blocks(
-    title="خلاصه‌ساز متن فارسی - نسخه سبک",
+    title="خلاصه‌ساز متن فارسی",
     theme=gr.themes.Soft(),
     css="""
     .persian-text {
@@ -162,8 +489,9 @@ with gr.Blocks(
     gr.HTML("""
     <div class="main-header">
         <h1>🤖 خلاصه‌ساز هوشمند متن فارسی</h1>
-        <p><strong>Persian Text Summarization Tool - Lightweight Version</strong></p>
-        <p>این ابزار با روش استخراجی پیشرفته، متن‌های فارسی را خلاصه می‌کند</p>
+        <p><strong>Persian Text Summarization Tool</strong></p>
+        <p>این ابزار با استفاده از هوش مصنوعی، متن‌ها، فایل‌ها، وب‌سایت‌ها و ویدیوهای یوتیوب را خلاصه می‌کند</p>
+        <p>📁 فایل‌ها | 🌐 وب‌سایت‌ها | 📺 یوتیوب (زیرنویس)</p>
     </div>
     """)
     
@@ -171,14 +499,43 @@ with gr.Blocks(
         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>
-            """)
+            # Model status
+            model_status = gr.HTML(
+                f"""<div style="padding: 10px; background-color: #e8f5e8; border-radius: 5px; margin-bottom: 10px;">
+                <strong>🤖 مدل فعال:</strong> mT5-small (پشتیبانی از فارسی)<br>
+                <strong>📊 وضعیت:</strong> {'آماده برای خلاصه‌سازی فارسی' if persian_summarizer.model else 'حالت استخراجی (fallback)'}
+                </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")
+            
+            # YouTube input section
+            with gr.Accordion("📺 خلاصه ویدیو یوتیوب", open=False):
+                youtube_input = gr.Textbox(
+                    label="لینک یوتیوب",
+                    placeholder="https://youtube.com/watch?v=... یا https://youtu.be/...",
+                    lines=1
+                )
+                youtube_status = gr.HTML("🎬 زیرنویس فارسی و انگلیسی پشتیبانی می‌شود")
+                load_youtube_btn = gr.Button("📺 استخراج زیرنویس از یوتیوب", variant="secondary")
             
             # Sample text selector
             sample_selector = gr.Dropdown(
@@ -228,23 +585,55 @@ with gr.Blocks(
         gr.Markdown("""
         ### نحوه استفاده:
         1. **متن خود را وارد کنید**: متن فارسی خود را در قسمت "متن ورودی" بنویسید یا کپی کنید
-        2. **نمونه متن انتخاب کنید**: می‌توانید از نمونه متن‌های آماده استفاده کنید
-        3. **طول خلاصه را تعیین کنید**: کوتاه، متوسط یا بلند
-        4. **دکمه خلاصه‌سازی را بزنید**: منتظر بمانید تا خلاصه تولید شود
-        
-        ### ویژگی‌های نسخه سبک:
-        - ✅ سریع و پایدار (بدون نیاز به مدل‌های سنگین)
-        - ✅ کاملاً فارسی (هیچ ترجمه‌ای انجام نمی‌شود)
-        - ✅ کیفیت بالا برای متن‌های فارسی
-        - ✅ مناسب برای همه سرورها
-        - ✅ روش استخراجی هوشمند
-        - ✅ امتیازدهی پیشرفته به جملات
+        2. **یا فایل آپلود کنید**: فایل متنی (.txt, .docx, .pdf) خود را آپلود کنید
+        3. **یا از وب‌سایت استخراج کنید**: آدرس وب‌سایت مورد نظر را وارد کنید
+        4. **یا ویدیو یوتیوب**: لینک یوتیوب برای استخراج زیرنویس وارد کنید
+        5. **نمونه متن انتخاب کنید**: می‌توانید از نمونه متن‌های آماده استفاده کنید
+        6. **طول خلاصه را تعیین کنید**: کوتاه، متوسط یا بلند
+        7. **دکمه خلاصه‌سازی را بزنید**: منتظر بمانید تا خلاصه تولید شود
+        
+        ### ویژگی‌ها:
+        - ✅ پشتیبانی کامل از زبان فارسی با mT5
+        - ✅ خروجی کاملاً فارسی (بدون ترجمه به انگلیسی)
+        - ✅ آپلود فایل‌های متنی (TXT, DOCX, PDF)
+        - ✅ استخراج محتوا از وب‌سایت‌ها
+        - ✅ خلاصه ویدیوهای یوتیوب (از طریق زیرنویس)
+        - ✅ سه سطح طول خلاصه
+        - ✅ نمونه متن‌های آماده
+        - ✅ نمایش آمار متن
+        - ✅ رابط کاربری فارسی
+        - ✅ سیستم fallback پیشرفته
+        
+        ### منابع ورودی پشتیبانی شده:
+        - **متن مستقیم**: کپی و پیست متن
+        - **فایل‌ها**: TXT, DOCX, PDF
+        - **وب‌سایت‌ها**: خبرگاری‌ها، وبلاگ‌ها، مقالات آنلاین
+        - **یوتیوب**: ویدیوهای دارای زیرنویس فارسی یا انگلیسی
+        
+        ### فرمت‌های فایل:
+        - **TXT**: فایل‌های متن ساده (UTF-8, CP1256)
+        - **DOCX**: اسناد Microsoft Word
+        - **PDF**: اسناد PDF (نیاز به PyPDF2)
+        
+        ### وب‌سایت‌های پشتیبانی شده:
+        - **خبرگاری‌ها**: BBC Persian, Radio Farda, ایسنا و...
+        - **وبلاگ‌ها**: وردپرس، بلاگر و...
+        - **مقالات**: مجلات آنلاین، سایت‌های آموزشی
+        
+        ### یوتیوب:
+        - **زیرنویس فارسی**: ویدیوهای دارای زیرنویس فارسی
+        - **زیرنویس انگلیسی**: ترجمه خودکار برای محتوای انگلیسی
+        - **زیرنویس خودکار**: زیرنویس‌های تولید شده توسط یوتیوب
+        - **فرمت‌های لینک**: youtube.com/watch?v=... یا youtu.be/...
         
         ### نکات:
         - متن ورودی باید حداقل 100 کاراکتر باشد
-        - جملات ابتدایی و میانی متن امتیاز بیشتری دریافت می‌کنند
-        - این نسخه برای استقرار آسان طراحی شده است
-        - هیچ وابستگی پیچیده‌ای ندارد
+        - کیفیت خلاصه با متن‌های طولانی‌تر بهتر است
+        - از mT5 برای حفظ زبان فارسی استفاده می‌کند
+        - خلاصه تولیدی همیشه به زبان فارسی است
+        - برای وب‌سایت‌ها، محتوای اصلی مقاله استخراج می‌شود
+        - برای یوتیوب، ابتدا زیرنویس فارسی، سپس انگلیسی جستجو می‌شود
+        - فایل‌ها، وب‌سایت‌ها و ویدیوهای بزرگ زمان بیشتری نیاز دارند
         """)
     
     # Event handlers
@@ -270,6 +659,21 @@ with gr.Blocks(
         
         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
+    
+    def handle_youtube_input(url):
+        """Handle YouTube URL input and update text input"""
+        content, message = process_youtube_input(url)
+        return content, message
+    
     # Connect events
     sample_selector.change(
         fn=load_sample_text,
@@ -277,6 +681,24 @@ with gr.Blocks(
         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]
+    )
+    
+    load_youtube_btn.click(
+        fn=handle_youtube_input,
+        inputs=[youtube_input],
+        outputs=[text_input, youtube_status]
+    )
+    
     summarize_btn.click(
         fn=process_summarization,
         inputs=[text_input, summary_length],
@@ -284,8 +706,8 @@ with gr.Blocks(
     )
     
     clear_btn.click(
-        fn=lambda: ("", "", 0, 0, 0),
-        outputs=[text_input, summary_output, original_length, summary_length_num, compression_ratio]
+        fn=lambda: ("", "", "", "", "", 0, 0, 0),
+        outputs=[text_input, summary_output, file_status, url_status, youtube_status, original_length, summary_length_num, compression_ratio]
     )
 
 # Launch the app