Upload persian_legal_scraper.py

app/persian_legal_scraper.py

@@ -0,0 +1,1720 @@
+# app.py - سیستم پیشرفته استخراج و تحلیل اسناد حقوقی فارسی
+import os
+import gc
+import sys
+import time
+import json
+import logging
+import resource
+import requests
+import threading
+import re
+import random
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Tuple, Union
+from dataclasses import dataclass
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from urllib.parse import urljoin, urlparse
+import hashlib
+
+import gradio as gr
+import pandas as pd
+import torch
+from bs4 import BeautifulSoup
+from transformers import (
+    AutoTokenizer, 
+    AutoModelForSequenceClassification,
+    pipeline,
+    logging as transformers_logging
+)
+import warnings
+
+# تنظیمات اولیه
+warnings.filterwarnings('ignore')
+transformers_logging.set_verbosity_error()
+
+# محدودیت حافظه برای HF Spaces
+try:
+    resource.setrlimit(resource.RLIMIT_AS, (2*1024*1024*1024, 2*1024*1024*1024))
+except:
+    pass
+
+# تنظیمات محیط
+os.environ['TRANSFORMERS_CACHE'] = '/tmp/hf_cache'
+os.environ['HF_HOME'] = '/tmp/hf_cache'
+os.environ['TORCH_HOME'] = '/tmp/torch_cache'
+os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+
+# تنظیم لاگ
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# SVG Icons
+SVG_ICONS = {
+    'search': '🔍',
+    'document': '📄',
+    'analyze': '🤖',
+    'export': '📊',
+    'settings': '⚙️',
+    'preview': '👁️',
+    'link': '🔗',
+    'success': '✅',
+    'error': '❌',
+    'warning': '⚠️'
+}
+
+# منابع حقوقی معتبر ایران
+LEGAL_SOURCES_CONFIG = {
+    "مجلس شورای اسلامی": {
+        "base_url": "https://rc.majlis.ir",
+        "patterns": ["/fa/law/", "/fa/report/", "/fa/news/"],
+        "selectors": [".main-content", ".article-body", ".content", "article"],
+        "delay_range": (2, 5),
+        "max_depth": 2
+    },
+    "پورتال ملی قوانین": {
+        "base_url": "https://www.dotic.ir",
+        "patterns": ["/portal/", "/law/", "/regulation/"],
+        "selectors": [".content-area", ".law-content", ".main-text"],
+        "delay_range": (1, 4),
+        "max_depth": 2
+    },
+    "قوه قضاییه": {
+        "base_url": "https://www.judiciary.ir",
+        "patterns": ["/fa/news/", "/fa/verdict/", "/fa/law/"],
+        "selectors": [".news-content", ".verdict-text", ".main-content"],
+        "delay_range": (3, 6),
+        "max_depth": 2
+    },
+    "وزارت دادگستری": {
+        "base_url": "https://www.moj.ir",
+        "patterns": ["/fa/news/", "/fa/law/", "/fa/regulation/"],
+        "selectors": [".news-body", ".law-text", ".content"],
+        "delay_range": (2, 4),
+        "max_depth": 2
+    },
+    "دیوان عدالت اداری": {
+        "base_url": "https://www.adcourt.ir",
+        "patterns": ["/fa/verdict/", "/fa/news/"],
+        "selectors": [".verdict-content", ".news-text"],
+        "delay_range": (1, 3),
+        "max_depth": 2
+    }
+}
+
+# واژگان حقوقی فارسی پیشرفته
+PERSIAN_LEGAL_DICTIONARY = {
+    "قوانین_اساسی": [
+        "قانون اساسی", "اصول قانون اساسی", "مجلس شورای اسلامی", "شورای نگهبان",
+        "رهبری", "جمهوری اسلامی", "حاکمیت ملی", "ولایت فقیه"
+    ],
+    "قوانین_عادی": [
+        "ماده", "تبصره", "اصل", "فصل", "باب", "قسمت", "بخش", "کتاب",
+        "قانون مدنی", "قانون جزا", "قانون آیین دادرسی", "قانون تجارت"
+    ],
+    "مقررات_اجرایی": [
+        "آیین‌نامه", "مقرره", "دستورالعمل", "شیوه‌نامه", "بند", "جزء", "فقره",
+        "ضابطه", "رهنمود", "دستور", "اعلامیه", "ابلاغیه"
+    ],
+    "اصطلاحات_حقوقی": [
+        "شخص حقیقی", "شخص حقوقی", "حق", "تکلیف", "مسئولیت", "جرم", "مجازات",
+        "دعوا", "طرف دعوا", "خواهان", "خوانده", "شاکی", "متهم", "مجنی‌علیه"
+    ],
+    "نهادهای_قضایی": [
+        "دادگاه", "قاضی", "دادرس", "مدعی‌العموم", "وکیل", "کارشناس", "مترجم",
+        "رای", "حکم", "قرار", "اجرائیه", "کیفرخواست", "لایحه دفاعیه"
+    ],
+    "اصطلاحات_اداری": [
+        "وزارت", "اداره", "سازمان", "مدیر", "مقام", "مسئول", "کارمند", "کارگزار",
+        "بخشنامه", "تصویب‌نامه", "مصوبه", "تصمیم", "نظریه", "استعلام"
+    ],
+    "مفاهیم_مالی": [
+        "مالیات", "عوارض", "پرداخت", "وجه", "ریال", "درهم", "خسارت", "دیه",
+        "تأمین", "ضمانت", "وثیقه", "سپرده", "جریمه", "جزا�� نقدی"
+    ]
+}
+
+@dataclass
+class ProcessingProgress:
+    current_step: str = ""
+    progress: float = 0.0
+    total_documents: int = 0
+    processed_documents: int = 0
+    status: str = "آماده"
+    error: Optional[str] = None
+
+class MemoryManager:
+    """مدیریت هوشمند حافظه برای HF Spaces"""
+    
+    @staticmethod
+    def get_memory_usage() -> float:
+        try:
+            with open('/proc/self/status') as f:
+                for line in f:
+                    if line.startswith('VmRSS:'):
+                        return float(line.split()[1]) / 1024
+            return 0.0
+        except:
+            return 0.0
+    
+    @staticmethod
+    def check_memory_available(required_mb: float) -> bool:
+        try:
+            current_usage = MemoryManager.get_memory_usage()
+            return current_usage + required_mb < 1800
+        except:
+            return True
+    
+    @staticmethod
+    def cleanup_memory():
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+class SmartTextProcessor:
+    """پردازشگر هوشمند متن با قابلیت‌های پیشرفته"""
+    
+    def __init__(self):
+        self.sentence_endings = ['۔', '.', '!', '؟', '?', ';', '؛']
+        self.paragraph_indicators = ['ماده', 'تبصره', 'بند', 'الف', 'ب', 'ج', 'د', 'ه', 'و']
+        
+        # الگوهای شناسایی ارجاعات حقوقی
+        self.citation_patterns = [
+            r'ماده\s*(\d+)',
+            r'تبصره\s*(\d+)', 
+            r'بند\s*([الف-ی]|\d+)',
+            r'فصل\s*(\d+)',
+            r'باب\s*(\d+)',
+            r'قسمت\s*(\d+)',
+            r'اصل\s*(\d+)'
+        ]
+        
+        # الگوهای پاکسازی متن
+        self.cleanup_patterns = [
+            (r'\s+', ' '),
+            (r'([۰-۹])\s+([۰-۹])', r'\1\2'),
+            (r'([a-zA-Z])\s+([a-zA-Z])', r'\1\2'),
+            (r'([ا-ی])\s+(ها|های|ان|ات|ین)', r'\1\2'),
+            (r'(می|نمی|خواهد)\s+(شود|گردد|باشد)', r'\1‌\2'),
+        ]
+    
+    def normalize_persian_text(self, text: str) -> str:
+        """نرمال‌سازی پیشرفته متن فارسی"""
+        if not text:
+            return ""
+        
+        # نرمال‌سازی کاراکترهای فارسی
+        persian_normalization = {
+            'ي': 'ی', 'ك': 'ک', 'ة': 'ه', 'ؤ': 'و', 'إ': 'ا', 'أ': 'ا',
+            'ء': '', 'ئ': 'ی', '٠': '۰', '١': '۱', '٢': '۲', '٣': '۳', '٤': '۴',
+            '٥': '۵', '٦': '۶', '٧': '۷', '٨': '۸', '٩': '۹'
+        }
+        
+        for old, new in persian_normalization.items():
+            text = text.replace(old, new)
+        
+        # اعمال الگوهای پاکسازی
+        for pattern, replacement in self.cleanup_patterns:
+            text = re.sub(pattern, replacement, text)
+        
+        # حذف کاراکترهای غیرضروری
+        text = re.sub(r'[^\u0600-\u06FF\u200C\u200D\s\w\d.,;:!؟()«»\-]', '', text)
+        
+        return text.strip()
+    
+    def detect_long_sentences(self, text: str) -> List[Dict[str, Any]]:
+        """تشخیص جملات طولانی و پیچیده"""
+        sentences = self._split_into_sentences(text)
+        long_sentences = []
+        
+        for i, sentence in enumerate(sentences):
+            sentence_info = {
+                'index': i,
+                'text': sentence,
+                'word_count': len(sentence.split()),
+                'is_long': False,
+                'suggestions': []
+            }
+            
+            # بررسی طول جمله
+            if sentence_info['word_count'] > 30:
+                sentence_info['is_long'] = True
+                sentence_info['suggestions'].append('جمله بسیار طولانی - تقسیم توصیه می‌شود')
+            
+            # بررسی پیچیدگی
+            complexity_score = self._calculate_complexity(sentence)
+            if complexity_score > 5:
+                sentence_info['suggestions'].append('جمله پیچیده - ساده‌سازی توصیه می‌شود')
+            
+            if sentence_info['is_long'] or sentence_info['suggestions']:
+                long_sentences.append(sentence_info)
+        
+        return long_sentences
+    
+    def _split_into_sentences(self, text: str) -> List[str]:
+        """تقسیم متن به جملات"""
+        boundaries = self.detect_sentence_boundaries(text)
+        sentences = []
+        
+        start = 0
+        for boundary in boundaries:
+            sentence = text[start:boundary].strip()
+            if sentence and len(sentence) > 5:
+                sentences.append(sentence)
+            start = boundary
+        
+        # جمله آخر
+        if start < len(text):
+            last_sentence = text[start:].strip()
+            if last_sentence and len(last_sentence) > 5:
+                sentences.append(last_sentence)
+        
+        return sentences
+    
+    def _calculate_complexity(self, sentence: str) -> float:
+        """محاسبه پیچیدگی جمله"""
+        complexity = 0
+        
+        # تعداد کلمات ربط
+        conjunctions = ['که', 'اگر', 'چون', 'زیرا', 'ولی', 'اما', 'درحالیکه', 'درصورتیکه']
+        complexity += sum(sentence.count(conj) for conj in conjunctions) * 0.5
+        
+        # تعداد ویرگول
+        complexity += sentence.count('،') * 0.3
+        
+        # تعداد کلمات
+        complexity += len(sentence.split()) * 0.02
+        
+        # جملات تودرتو
+        if sentence.count('(') > 0:
+            complexity += sentence.count('(') * 0.5
+        
+        return complexity
+    
+    def detect_sentence_boundaries(self, text: str) -> List[int]:
+        """تشخیص هوشمند مرزهای جمله در متون حقوقی فارسی"""
+        boundaries = []
+        
+        for i, char in enumerate(text):
+            if char in self.sentence_endings:
+                is_real_ending = True
+                
+                # بررسی برای اعداد و اختصارات
+                if i > 0 and text[i-1].isdigit() and char == '.':
+                    is_real_ending = False
+                
+                # بررسی برای اختصارات رایج
+                if i > 2:
+                    prev_text = text[max(0, i-10):i].strip()
+                    if any(abbr in prev_text for abbr in ['ماده', 'بند', 'ج.ا.ا', 'ق.م', 'ق.ج']):
+                        if char == '.' and i < len(text) - 1 and not text[i+1].isspace():
+                            is_real_ending = False
+                
+                if is_real_ending:
+                    if i < len(text) - 1:
+                        next_char = text[i + 1]
+                        if next_char.isspace() or next_char in '«"\'':
+                            boundaries.append(i + 1)
+                    else:
+                        boundaries.append(i + 1)
+        
+        return boundaries
+    
+    def reconstruct_legal_text(self, content_fragments: List[str]) -> str:
+        """بازسازی هوشمند متن حقوقی از قطعات پراکنده"""
+        if not content_fragments:
+            return ""
+        
+        # مرحله 1: نرمال‌سازی تمام قطعات
+        normalized_fragments = []
+        for fragment in content_fragments:
+            normalized = self.normalize_persian_text(fragment)
+            if normalized and len(normalized.strip()) > 10:
+                normalized_fragments.append(normalized)
+        
+        if not normalized_fragments:
+            return ""
+        
+        # مرحله 2: ادغام هوشمند قطعات
+        combined_text = self._smart_join_fragments(normalized_fragments)
+        
+        # مرحله 3: اعمال قالب‌بندی حقوقی
+        formatted = self._apply_legal_formatting(combined_text)
+        
+        return formatted
+    
+    def _smart_join_fragments(self, fragments: List[str]) -> str:
+        """ادغام هوشمند قطعات با در نظر گیری زمینه"""
+        if len(fragments) == 1:
+            return fragments[0]
+        
+        result = [fragments[0]]
+        
+        for i in range(1, len(fragments)):
+            current_fragment = fragments[i]
+            prev_fragment = result[-1]
+            
+            # بررسی ادامه جمله
+            if self._should_continue_sentence(prev_fragment, current_fragment):
+                result[-1] += ' ' + current_fragment
+            # بررسی ادغام بدون فاصله (نیم‌فاصله)
+            elif self._should_join_without_space(prev_fragment, current_fragment):
+                result[-1] += current_fragment
+            # شروع پاراگراف جدید
+            elif self._is_new_paragraph(current_fragment):
+                result.append('\n\n' + current_fragment)
+            else:
+                result.append(' ' + current_fragment)
+        
+        return ''.join(result)
+    
+    def _should_continue_sentence(self, prev: str, current: str) -> bool:
+        """تشخیص ادامه جمله"""
+        # کلمات ادامه‌دهنده
+        continuation_words = ['که', 'تا', 'اگر', 'چون', 'زیرا', 'ولی', 'اما', 'و', 'یا']
+        
+        # اگر جمله قبلی ناتمام باشد
+        if not any(prev.endswith(end) for end in self.sentence_endings):
+            return True
+        
+        # اگر جمله فعلی با کلمه ادامه شروع شود
+        if any(current.strip().startswith(word) for word in continuation_words):
+            return True
+        
+        return False
+    
+    def _should_join_without_space(self, prev: str, current: str) -> bool:
+        """تشخیص ادغام بدون فاصله"""
+        # پسوندها و پیشوندها
+        suffixes = ['��ا', 'های', 'ان', 'ات', 'ین', 'تان', 'شان', 'تون', 'شون']
+        prefixes = ['می‌', 'نمی‌', 'برمی‌', 'درمی‌']
+        
+        current_stripped = current.strip()
+        
+        # بررسی پسوندها
+        if any(current_stripped.startswith(suffix) for suffix in suffixes):
+            return True
+        
+        # بررسی ادامه فعل
+        if prev.endswith(('می', 'نمی', 'خواهد', 'است')):
+            verb_continuations = ['شود', 'گردد', 'باشد', 'کرد', 'کند']
+            if any(current_stripped.startswith(cont) for cont in verb_continuations):
+                return True
+        
+        return False
+    
+    def _is_new_paragraph(self, text: str) -> bool:
+        """تشخیص شروع پاراگراف جدید"""
+        text_stripped = text.strip()
+        
+        # شاخص‌های پاراگراف در متون حقوقی
+        paragraph_starters = [
+            'ماده', 'تبصره', 'بند', 'فصل', 'باب', 'قسمت', 'کتاب',
+            'الف)', 'ب)', 'ج)', 'د)', 'ه)', 'و)', 'ز)', 'ح)', 'ط)',
+            '۱-', '۲-', '۳-', '۴-', '۵-', '۶-', '۷-', '۸-', '۹-', '۱۰-'
+        ]
+        
+        return any(text_stripped.startswith(starter) for starter in paragraph_starters)
+    
+    def _apply_legal_formatting(self, text: str) -> str:
+        """اعمال قالب‌بندی مخصوص اسناد حقوقی"""
+        lines = text.split('\n')
+        formatted_lines = []
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # قالب‌بندی مواد و تبصره‌ها
+            if any(line.startswith(indicator) for indicator in ['ماده', 'تبصره']):
+                formatted_lines.append(f"\n{line}")
+            # قالب‌بندی بندها
+            elif any(line.startswith(indicator) for indicator in ['الف)', 'ب)', 'ج)']):
+                formatted_lines.append(f"    {line}")
+            # قالب‌بندی فصول و ابواب
+            elif any(line.startswith(indicator) for indicator in ['فصل', 'باب', 'کتاب']):
+                formatted_lines.append(f"\n\n{line.upper()}\n")
+            else:
+                formatted_lines.append(line)
+        
+        return '\n'.join(formatted_lines)
+    
+    def extract_legal_entities(self, text: str) -> Dict[str, List[str]]:
+        """استخراج موجودیت‌های حقوقی از متن"""
+        entities = {
+            'articles': [],
+            'citations': [],
+            'legal_terms': [],
+            'organizations': [],
+            'laws': []
+        }
+        
+        # استخراج مواد و تبصره‌ها
+        for pattern in self.citation_patterns:
+            matches = re.findall(pattern, text)
+            if matches:
+                entities['citations'].extend(matches)
+        
+        # استخراج اصطلاحات حقوقی
+        for category, terms in PERSIAN_LEGAL_DICTIONARY.items():
+            found_terms = [term for term in terms if term in text]
+            entities['legal_terms'].extend(found_terms)
+        
+        # استخراج نام قوانین
+        law_patterns = [
+            r'قانون\s+([^۔\.\n]{5,50})',
+            r'آیین‌نامه\s+([^۔\.\n]{5,50})',
+            r'مقرره\s+([^۔\.\n]{5,50})'
+        ]
+        
+        for pattern in law_patterns:
+            matches = re.findall(pattern, text)
+            entities['laws'].extend(matches)
+        
+        return entities
+
+class AntiDDoSManager:
+    """مدیریت ضد حملات DDoS و تنوع درخواست‌ها"""
+    
+    def __init__(self):
+        self.request_history = {}
+        self.user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0'
+        ]
+    
+    def get_request_delay(self, domain: str) -> float:
+        """محاسبه تأخیر مناسب برای هر منبع"""
+        source_info = self._identify_source(domain)
+        
+        if source_info and 'delay_range' in source_info:
+            min_delay, max_delay = source_info['delay_range']
+            return random.uniform(min_delay, max_delay)
+        
+        # تأخیر پیش‌فرض
+        return random.uniform(1, 3)
+    
+    def get_random_headers(self) -> Dict[str, str]:
+        """تولید هدرهای تصادفی"""
+        return {
+            'User-Agent': random.choice(self.user_agents),
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': random.choice(['fa,en;q=0.9', 'fa-IR,fa;q=0.9,en;q=0.8', 'fa;q=0.9,en;q=0.8']),
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+            'Cache-Control': random.choice(['no-cache', 'max-age=0', 'no-store'])
+        }
+    
+    def _identify_source(self, domain: str) -> Optional[Dict]:
+        """شناسایی منبع بر اساس دامنه"""
+        for source_name, config in LEGAL_SOURCES_CONFIG.items():
+            base_domain = config['base_url'].replace('https://', '').replace('http://', '')
+            if base_domain in domain:
+                return config
+        return None
+    
+    def should_allow_request(self, domain: str) -> bool:
+        """بررسی اینکه آیا درخواست مجاز است"""
+        current_time = time.time()
+        
+        if domain not in self.request_history:
+            self.request_history[domain] = []
+        
+        # حذف درخواست‌های قدیمی (بیش از 1 ساعت)
+        self.request_history[domain] = [
+            req_time for req_time in self.request_history[domain]
+            if current_time - req_time < 3600
+        ]
+        
+        # بررسی تعداد درخواست‌ها در ساعت گذشته
+        if len(self.request_history[domain]) >= 50:  # حداکثر 50 درخواست در ساعت
+            return False
+        
+        # ثبت درخواست جدید
+        self.request_history[domain].append(current_time)
+        return True
+
+class ModelManager:
+    """مدیریت پیشرفته مدل‌های هوش مصنوعی"""
+    
+    def __init__(self):
+        self.models = {}
+        self.model_status = {}
+    
+    def load_models_progressively(self, progress_callback=None) -> Dict[str, Any]:
+        """بارگذاری تدریجی مدل‌ها با مدیریت حافظه"""
+        logger.info("🚀 شروع بارگذاری مدل‌های هوش مصنوعی...")
+        
+        if progress_callback:
+            progress_callback("آماده‌سازی محیط...", 0.05)
+        
+        # ایجاد دایرکتوری کش
+        cache_dir = "/tmp/hf_cache"
+        os.makedirs(cache_dir, exist_ok=True)
+        
+        # فاز 1: Tokenizer
+        try:
+            if MemoryManager.check_memory_available(100):
+                logger.info("📝 بارگذاری Tokenizer...")
+                if progress_callback:
+                    progress_callback("بارگذاری Tokenizer...", 0.2)
+                
+                self.models['tokenizer'] = AutoTokenizer.from_pretrained(
+                    "HooshvareLab/bert-fa-base-uncased",
+                    cache_dir=cache_dir,
+                    local_files_only=False
+                )
+                self.model_status['tokenizer'] = 'loaded'
+                logger.info("✅ Tokenizer بارگذاری شد")
+            else:
+                self.model_status['tokenizer'] = 'memory_insufficient'
+        except Exception as e:
+            logger.error(f"❌ خطا در بارگذاری Tokenizer: {e}")
+            self.model_status['tokenizer'] = 'failed'
+        
+        # فاز 2: مدل طبقه‌بندی متن
+        try:
+            if MemoryManager.check_memory_available(400):
+                logger.info("🏷️ بارگذاری مدل طبقه‌بندی...")
+                if progress_callback:
+                    progress_callback("بارگذاری مدل طبقه‌بندی...", 0.5)
+                
+                self.models['classifier'] = pipeline(
+                    "text-classification",
+                    model="HooshvareLab/bert-fa-base-uncased-clf-persiannews",
+                    tokenizer="HooshvareLab/bert-fa-base-uncased-clf-persiannews",
+                    device=-1,
+                    return_all_scores=True,
+                    model_kwargs={"cache_dir": cache_dir}
+                )
+                self.model_status['classifier'] = 'loaded'
+                logger.info("✅ مدل طبقه‌بندی بارگذاری شد")
+            else:
+                self.model_status['classifier'] = 'memory_insufficient'
+        except Exception as e:
+            logger.error(f"❌ خطا در بارگذاری مدل طبقه‌بندی: {e}")
+            self.model_status['classifier'] = 'failed'
+        
+        # فاز 3: مدل تشخیص موجودیت
+        try:
+            if MemoryManager.check_memory_available(500):
+                logger.info("👤 بارگذاری مدل NER...")
+                if progress_callback:
+                    progress_callback("بارگذاری مدل تشخیص موجودیت...", 0.8)
+                
+                self.models['ner'] = pipeline(
+                    "ner",
+                    model="HooshvareLab/bert-fa-base-uncased-ner",
+                    tokenizer="HooshvareLab/bert-fa-base-uncased-ner",
+                    device=-1,
+                    aggregation_strategy="simple",
+                    model_kwargs={"cache_dir": cache_dir}
+                )
+                self.model_status['ner'] = 'loaded'
+                logger.info("✅ مدل NER بارگذاری شد")
+            else:
+                self.model_status['ner'] = 'memory_insufficient'
+        except Exception as e:
+            logger.error(f"❌ خطا در بارگذاری مدل NER: {e}")
+            self.model_status['ner'] = 'failed'
+        
+        if progress_callback:
+            progress_callback("تکمیل بارگذاری مدل‌ها", 1.0)
+        
+        # پاکسازی حافظه
+        MemoryManager.cleanup_memory()
+        
+        loaded_count = sum(1 for status in self.model_status.values() if status == 'loaded')
+        logger.info(f"🎯 {loaded_count} مدل با موفقیت بارگذاری شد")
+        
+        return self.models
+    
+    def get_model_status(self) -> str:
+        """دریافت وضعیت مدل‌ها"""
+        status_lines = []
+        status_icons = {
+            'loaded': '✅',
+            'failed': '❌', 
+            'memory_insufficient': '⚠️',
+            'not_loaded': '⏳'
+        }
+        
+        for model_name, status in self.model_status.items():
+            icon = status_icons.get(status, '❓')
+            status_persian = {
+                'loaded': 'بارگذاری شده',
+                'failed': 'خطا در بارگذاری',
+                'memory_insufficient': 'حافظه ناکافی',
+                'not_loaded': 'بارگذاری نشده'
+            }.get(status, 'نامشخص')
+            
+            status_lines.append(f"{icon} {model_name}: {status_persian}")
+        
+        memory_usage = MemoryManager.get_memory_usage()
+        status_lines.append(f"\n💾 مصرف حافظه: {memory_usage:.1f} MB")
+        
+        return '\n'.join(status_lines)
+
+class LegalDocumentScraper:
+    """استخراج‌کننده پیشرفته اسناد حقوقی"""
+    
+    def __init__(self, model_manager: ModelManager, text_processor: SmartTextProcessor):
+        self.model_manager = model_manager
+        self.text_processor = text_processor
+        self.anti_ddos = AntiDDoSManager()
+        self.session = self._create_session()
+    
+    def _create_session(self) -> requests.Session:
+        """ایجاد session با تنظیمات بهینه"""
+        session = requests.Session()
+        
+        # تنظیم adapter برای retry
+        from requests.adapters import HTTPAdapter
+        from urllib3.util.retry import Retry
+        
+        retry_strategy = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[429, 500, 502, 503, 504]
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+        
+        return session
+    
+    def scrape_legal_source(self, url: str, progress_callback=None) -> Dict[str, Any]:
+        """استخراج هوشمند سند حقوقی"""
+        try:
+            domain = urlparse(url).netloc
+            
+            # بررسی مجوز
+            if not self.anti_ddos.should_allow_request(domain):
+                raise Exception("تعداد درخواست‌ها از حد مجاز تجاوز کرده است")
+            
+            if progress_callback:
+                progress_callback(f"🔗 اتصال به {domain}...", 0.1)
+            
+            # اعمال تأخیر ضد DDoS
+            delay = self.anti_ddos.get_request_delay(domain)
+            time.sleep(delay)
+            
+            # درخواست اصلی
+            headers = self.anti_ddos.get_random_headers()
+            response = self.session.get(url, headers=headers, timeout=30, allow_redirects=True)
+            response.raise_for_status()
+            response.encoding = 'utf-8'
+            
+            if progress_callback:
+                progress_callback("📄 تجزیه محتوای HTML...", 0.3)
+            
+            # تجزیه HTML
+            soup = BeautifulSoup(response.content, 'html.parser')
+            self._clean_soup(soup)
+            
+            # شناسایی منبع
+            source_info = self._identify_legal_source(url)
+            
+            if progress_callback:
+                progress_callback("🎯 استخراج محتوای هدفمند...", 0.5)
+            
+            # استخراج محتوا
+            content_fragments = self._extract_content_intelligently(soup, source_info)
+            
+            # بازسازی متن
+            reconstructed_text = self.text_processor.reconstruct_legal_text(content_fragments)
+            
+            if not reconstructed_text or len(reconstructed_text.strip()) < 50:
+                raise Exception("محتوای کافی استخراج نشد")
+            
+            if progress_callback:
+                progress_callback("🔧 تحلیل و پردازش متن...", 0.7)
+            
+            # تحلیل‌های پیشرفته
+            quality_assessment = self._assess_content_quality(reconstructed_text)
+            legal_entities = self.text_processor.extract_legal_entities(reconstructed_text)
+            long_sentences = self.text_processor.detect_long_sentences(reconstructed_text)
+            ai_analysis = self._apply_ai_analysis(reconstructed_text)
+            
+            # نتیجه نهایی
+            result = {
+                'url': url,
+                'source_info': source_info,
+                'title': self._extract_title(soup),
+                'content': reconstructed_text,
+                'word_count': len(reconstructed_text.split()),
+                'character_count': len(reconstructed_text),
+                'quality_assessment': quality_assessment,
+                'legal_entities': legal_entities,
+                'long_sentences': long_sentences,
+                'ai_analysis': ai_analysis,
+                'extraction_metadata': {
+                    'method': 'advanced_extraction',
+                    'fragments_count': len(content_fragments),
+                    'response_size': len(response.content),
+                    'encoding': response.encoding,
+                    'anti_ddos_delay': delay
+                },
+                'timestamp': datetime.now().isoformat(),
+                'status': 'موفق'
+            }
+            
+            if progress_callback:
+                progress_callback("✅ استخراج با موفقیت تکمیل شد", 1.0)
+            
+            return result
+            
+        except requests.RequestException as e:
+            return self._create_error_result(url, f"خطای شبکه: {str(e)}")
+        except Exception as e:
+            return self._create_error_result(url, f"خطای پردازش: {str(e)}")
+    
+    def _identify_legal_source(self, url: str) -> Dict[str, Any]:
+        """شناسایی منبع حقوقی"""
+        domain = urlparse(url).netloc
+        
+        for source_name, config in LEGAL_SOURCES_CONFIG.items():
+            if config['base_url'].replace('https://', '').replace('http://', '') in domain:
+                return {
+                    'name': source_name,
+                    'type': 'official',
+                    'credibility': 'high',
+                    'config': config
+                }
+        
+        # بررسی الگوهای عمومی سایت‌های حقوقی
+        legal_indicators = ['law', 'legal', 'court', 'judiciary', 'قانون', 'حقوق', 'دادگاه']
+        if any(indicator in domain.lower() for indicator in legal_indicators):
+            return {
+                'name': 'منبع حقوقی شناخته نشده',
+                'type': 'legal_related',
+                'credibility': 'medium',
+                'config': {'max_depth': 1, 'delay_range': (2, 4)}
+            }
+        
+        return {
+            'name': 'منبع عمومی',
+            'type': 'general',
+            'credibility': 'low',
+            'config': {'max_depth': 0, 'delay_range': (3, 6)}
+        }
+    
+    def _clean_soup(self, soup: BeautifulSoup) -> None:
+        """پاکسازی پیشرفته HTML"""
+        # حذف عناصر غیرضروری
+        unwanted_tags = [
+            'script', 'style', 'nav', 'footer', 'header', 'aside',
+            'advertisement', 'ads', 'sidebar', 'menu', 'breadcrumb',
+            'social', 'share', 'comment', 'popup', 'modal'
+        ]
+        
+        for tag in unwanted_tags:
+            for element in soup.find_all(tag):
+                element.decompose()
+        
+        # حذف عناصر با کلاس‌های مشخص
+        unwanted_classes = [
+            'ad', 'ads', 'advertisement', 'sidebar', 'menu', 'nav',
+            'footer', 'header', 'social', 'share', 'comment', 'popup'
+        ]
+        
+        for class_name in unwanted_classes:
+            for element in soup.find_all(class_=lambda x: x and class_name in ' '.join(x).lower()):
+                element.decompose()
+    
+    def _extract_content_intelligently(self, soup: BeautifulSoup, source_info: Dict) -> List[str]:
+        """استخراج هوشمند محتوا"""
+        fragments = []
+        
+        # استراتژی 1: استفاده از تنظیمات منبع شناخته شده
+        if source_info.get('config') and source_info['config'].get('selectors'):
+            for selector in source_info['config']['selectors']:
+                elements = soup.select(selector)
+                for element in elements:
+                    text = self._extract_clean_text(element)
+                    if self._is_valid_content(text):
+                        fragments.append(text)
+        
+        # استراتژی 2: جستجوی محتوای اصلی
+        if not fragments:
+            main_selectors = [
+                'main', 'article', '.main-content', '.content', '.post-content',
+                '.article-content', '.news-content', '.law-content', '.legal-text',
+                '#main', '#content', '#article', '.document-content'
+            ]
+            
+            for selector in main_selectors:
+                elements = soup.select(selector)
+                for element in elements:
+                    text = self._extract_clean_text(element)
+                    if self._is_valid_content(text):
+                        fragments.append(text)
+                if fragments:
+                    break
+        
+        # استراتژی 3: استخراج از پاراگراف‌ها
+        if not fragments:
+            for tag in ['p', 'div', 'section', 'article']:
+                elements = soup.find_all(tag)
+                for element in elements:
+                    text = self._extract_clean_text(element)
+                    if self._is_valid_content(text, min_length=30):
+                        fragments.append(text)
+        
+        # استراتژی 4: fallback به body
+        if not fragments:
+            body = soup.find('body')
+            if body:
+                text = self._extract_clean_text(body)
+                if text:
+                    paragraphs = [p.strip() for p in text.split('\n') if p.strip()]
+                    fragments.extend(p for p in paragraphs if self._is_valid_content(p, min_length=20))
+        
+        return fragments
+    
+    def _extract_clean_text(self, element) -> str:
+        """استخراج متن تمیز"""
+        if not element:
+            return ""
+        
+        # حذف عناصر تودرتو غیرضروری
+        for unwanted in element.find_all(['script', 'style', 'nav', 'aside']):
+            unwanted.decompose()
+        
+        text = element.get_text(separator=' ', strip=True)
+        text = re.sub(r'\s+', ' ', text)
+        
+        return text.strip()
+    
+    def _is_valid_content(self, text: str, min_length: int = 50) -> bool:
+        """بررسی اعتبار محتوا"""
+        if not text or len(text) < min_length:
+            return False
+        
+        # بررسی نسبت کاراکترهای فارسی
+        persian_chars = sum(1 for c in text if '\u0600' <= c <= '\u06FF')
+        persian_ratio = persian_chars / len(text) if text else 0
+        
+        if persian_ratio < 0.2:
+            return False
+        
+        # بررسی کلمات کلیدی حقوقی
+        legal_keywords = ['قانون', 'ماده', 'تبصره', 'مقرره', 'آیین‌نامه', 'دادگاه', 'حکم', 'رای']
+        has_legal_content = any(keyword in text for keyword in legal_keywords)
+        
+        return has_legal_content or persian_ratio > 0.5
+    
+    def _extract_title(self, soup: BeautifulSoup) -> str:
+        """استخراج عنوان"""
+        title_selectors = [
+            'h1', 'h2', 'title', '.page-title', '.article-title',
+            '.post-title', '.document-title', '.news-title', '.law-title'
+        ]
+        
+        for selector in title_selectors:
+            element = soup.select_one(selector)
+            if element:
+                title = element.get_text(strip=True)
+                if title and 5 < len(title) < 200:
+                    return re.sub(r'\s+', ' ', title)
+        
+        return "بدون عنوان"
+    
+    def _assess_content_quality(self, text: str) -> Dict[str, Any]:
+        """ارزیابی کیفیت محتوا"""
+        assessment = {
+            'overall_score': 0,
+            'factors': {},
+            'issues': [],
+            'strengths': []
+        }
+        
+        if not text:
+            assessment['issues'].append('متن خالی')
+            return assessment
+        
+        factors = {}
+        
+        # طول متن
+        word_count = len(text.split())
+        if word_count >= 100:
+            factors['length'] = min(100, word_count / 10)
+            assessment['strengths'].append('طول مناسب متن')
+        else:
+            factors['length'] = word_count
+            assessment['issues'].append('متن کوتاه')
+        
+        # نسبت فارسی
+        persian_chars = sum(1 for c in text if '\u0600' <= c <= '\u06FF')
+        persian_ratio = persian_chars / len(text) if text else 0
+        factors['persian_content'] = persian_ratio * 100
+        
+        if persian_ratio >= 0.7:
+            assessment['strengths'].append('محتوای فارسی غنی')
+        elif persian_ratio < 0.3:
+            assessment['issues'].append('محتوای فارسی کم')
+        
+        # محتوای حقوقی
+        legal_terms_count = 0
+        for category, terms in PERSIAN_LEGAL_DICTIONARY.items():
+            legal_terms_count += sum(1 for term in terms if term in text)
+        
+        factors['legal_content'] = min(100, legal_terms_count * 5)
+        
+        if legal_terms_count >= 10:
+            assessment['strengths'].append('غنی از اصطلاحات حقوقی')
+        elif legal_terms_count < 3:
+            assessment['issues'].append('فقر اصطلاحات حقوقی')
+        
+        # ساختار متن
+        structure_score = 0
+        if 'ماده' in text:
+            structure_score += 20
+        if any(indicator in text for indicator in ['تبصره', 'بند', 'فصل']):
+            structure_score += 15
+        if re.search(r'[۰-۹]+', text):
+            structure_score += 10
+        
+        factors['structure'] = structure_score
+        
+        if structure_score >= 30:
+            assessment['strengths'].append('ساختار منظم حقوقی')
+        
+        # محاسبه امتیاز کلی
+        assessment['factors'] = factors
+        assessment['overall_score'] = sum(factors.values()) / len(factors) if factors else 0
+        assessment['overall_score'] = min(100, max(0, assessment['overall_score']))
+        
+        return assessment
+    
+    def _apply_ai_analysis(self, text: str) -> Dict[str, Any]:
+        """اعمال تحلیل هوش مصنوعی"""
+        analysis = {
+            'classification': None,
+            'entities': [],
+            'confidence_scores': {},
+            'model_performance': {}
+        }
+        
+        if not text or len(text.split()) < 10:
+            return analysis
+        
+        # آماده‌سازی متن
+        text_sample = ' '.join(text.split()[:300])
+        
+        # طبقه‌بندی متن
+        if 'classifier' in self.model_manager.models:
+            try:
+                start_time = time.time()
+                classification_result = self.model_manager.models['classifier'](text_sample)
+                
+                if classification_result:
+                    analysis['classification'] = classification_result[:3]
+                    analysis['confidence_scores']['classification'] = classification_result[0]['score']
+                
+                analysis['model_performance']['classification_time'] = time.time() - start_time
+                
+            except Exception as e:
+                logger.error(f"خطا در طبقه‌بندی: {e}")
+        
+        # تشخیص موجودیت
+        if 'ner' in self.model_manager.models:
+            try:
+                start_time = time.time()
+                ner_result = self.model_manager.models['ner'](text_sample[:1000])
+                
+                if ner_result:
+                    high_confidence_entities = [
+                        entity for entity in ner_result 
+                        if entity.get('score', 0) > 0.5
+                    ]
+                    analysis['entities'] = high_confidence_entities[:15]
+                
+                analysis['model_performance']['ner_time'] = time.time() - start_time
+                
+            except Exception as e:
+                logger.error(f"خطا در تشخیص موجودیت: {e}")
+        
+        return analysis
+    
+    def _create_error_result(self, url: str, error_message: str) -> Dict[str, Any]:
+        """ایجاد نتیجه خطا"""
+        return {
+            'url': url,
+            'error': error_message,
+            'status': 'ناموفق',
+            'timestamp': datetime.now().isoformat(),
+            'content': '',
+            'word_count': 0,
+            'quality_assessment': {'overall_score': 0, 'issues': [error_message]}
+        }
+
+class PersianLegalScraperApp:
+    """اپلیکیشن اصلی با رابط کاربری پیشرفته"""
+    
+    def __init__(self):
+        self.text_processor = SmartTextProcessor()
+        self.model_manager = ModelManager()
+        self.scraper = None
+        self.results = []
+        self.processing_stats = {
+            'total_processed': 0,
+            'successful': 0,
+            'failed': 0,
+            'total_words': 0
+        }
+        
+        # مقداردهی اولیه
+        self._initialize_system()
+    
+    def _initialize_system(self):
+        """مقداردهی سیستم"""
+        try:
+            logger.info("🚀 مقداردهی سیستم...")
+            self.model_manager.load_models_progressively()
+            self.scraper = LegalDocumentScraper(self.model_manager, self.text_processor)
+            logger.info("✅ سیستم آماده است")
+        except Exception as e:
+            logger.error(f"❌ خطا در مقداردهی: {e}")
+    
+    def process_single_url(self, url: str, progress=gr.Progress()) -> Tuple[str, str, str]:
+        """پردازش یک URL"""
+        if not url or not url.strip():
+            return "❌ خطا: آدرس معتبری وارد کنید", "", ""
+        
+        url = url.strip()
+        if not url.startswith(('http://', 'https://')):
+            url = 'https://' + url
+        
+        try:
+            progress(0.0, desc="شروع پردازش...")
+            
+            def progress_callback(message: str, value: float):
+                progress(value, desc=message)
+            
+            result = self.scraper.scrape_legal_source(url, progress_callback)
+            
+            if result.get('status') == 'موفق':
+                # به‌روزرسانی آمار
+                self.processing_stats['total_processed'] += 1
+                self.processing_stats['successful'] += 1
+                self.processing_stats['total_words'] += result.get('word_count', 0)
+                
+                # ذخیره نتیجه
+                self.results.append(result)
+                
+                # تنظیم خروجی‌ها
+                status_text = self._format_single_result(result)
+                analysis_text = self._format_analysis_result(result)
+                content_text = result.get('content', '')
+                
+                return status_text, content_text, analysis_text
+            else:
+                self.processing_stats['total_processed'] += 1
+                self.processing_stats['failed'] += 1
+                error_msg = result.get('error', 'خطای نامشخص')
+                return f"❌ خطا: {error_msg}", "", ""
+                
+        except Exception as e:
+            self.processing_stats['total_processed'] += 1
+            self.processing_stats['failed'] += 1
+            logger.error(f"خطا در پردازش: {e}")
+            return f"❌ خطای سیستمی: {str(e)}", "", ""
+    
+    def _format_single_result(self, result: Dict[str, Any]) -> str:
+        """قالب‌بندی نتیجه با آیکون‌های SVG"""
+        quality = result.get('quality_assessment', {})
+        source_info = result.get('source_info', {})
+        legal_entities = result.get('legal_entities', {})
+        long_sentences = result.get('long_sentences', [])
+        
+        lines = [
+            f"{SVG_ICONS['success']} **وضعیت**: {result.get('status')}",
+            f"{SVG_ICONS['document']} **عنوان**: {result.get('title', 'بدون عنوان')}",
+            f"🏛️ **منبع**: {source_info.get('name', 'نامشخص')} ({source_info.get('credibility', 'نامشخص')})",
+            f"📊 **آمار محتوا**: {result.get('word_count', 0):,} کلمه، {result.get('character_count', 0):,} کاراکتر",
+            f"🎯 **کیفیت کلی**: {quality.get('overall_score', 0):.1f}/100",
+            f"📈 **محتوای فارسی**: {quality.get('factors', {}).get('persian_content', 0):.1f}%",
+            f"⚖️ **محتوای حقوقی**: {quality.get('factors', {}).get('legal_content', 0):.1f}/100",
+            f"📚 **ارجاعات حقوقی**: {len(legal_entities.get('citations', []))} مورد",
+            f"🏷️ **اصطلاحات حقوقی**: {len(legal_entities.get('legal_terms', []))} مورد"
+        ]
+        
+        # جملات طولانی
+        if long_sentences:
+            lines.append(f"{SVG_ICONS['warning']} **جملات طولانی**: {len(long_sentences)} مورد")
+        
+        # نقاط قوت
+        strengths = quality.get('strengths', [])
+        if strengths:
+            lines.append(f"\n✨ **نقاط قوت**: {' | '.join(strengths)}")
+        
+        # مشکلات
+        issues = quality.get('issues', [])
+        if issues:
+            lines.append(f"{SVG_ICONS['warning']} **نکات**: {' | '.join(issues)}")
+        
+        lines.append(f"🕐 **زمان**: {result.get('timestamp', '')[:19]}")
+        
+        return '\n'.join(lines)
+    
+    def _format_analysis_result(self, result: Dict[str, Any]) -> str:
+        """قالب‌بندی تحلیل هوش مصنوعی"""
+        ai_analysis = result.get('ai_analysis', {})
+        legal_entities = result.get('legal_entities', {})
+        long_sentences = result.get('long_sentences', [])
+        
+        lines = [
+            f"{SVG_ICONS['analyze']} **تحلیل هوش مصنوعی**\n",
+            f"📊 **وضعیت مدل‌ها**: {self.model_manager.get_model_status()}\n"
+        ]
+        
+        # طبقه‌بندی
+        classification = ai_analysis.get('classification')
+        if classification:
+            lines.append("🏷️ **طبقه‌بندی محتوا**:")
+            for i, item in enumerate(classification[:3], 1):
+                label = item.get('label', 'نامشخص')
+                score = item.get('score', 0)
+                lines.append(f"{i}. {label}: {score:.1%}")
+        
+        # موجودیت‌های شناسایی شده
+        entities = ai_analysis.get('entities', [])
+        if entities:
+            lines.append("\n👥 **موجودیت‌های شناسایی شده**:")
+            for entity in entities[:8]:  # 8 مورد اول
+                word = entity.get('word', '')
+                label = entity.get('entity_group', '')
+                score = entity.get('score', 0)
+                lines.append(f"• {word} ({label}): {score:.1%}")
+        
+        # ارجاعات حقوقی
+        citations = legal_entities.get('citations', [])
+        if citations:
+            lines.append(f"\n📚 **ارجاعات حقوقی**: {len(citations)} مورد")
+            unique_citations = list(set(citations))[:10]
+            lines.append(f"نمونه: {', '.join(unique_citations)}")
+        
+        # قوانین شناسایی شده
+        laws = legal_entities.get('laws', [])
+        if laws:
+            lines.append(f"\n⚖️ **قوانین شناسایی شده**: {len(laws)} مورد")
+            for law in laws[:3]:
+                lines.append(f"• {law}")
+        
+        # جملات طولانی
+        if long_sentences:
+            lines.append(f"\n{SVG_ICONS['warning']} **جملات طولانی شناسایی شده**:")
+            for i, sentence_info in enumerate(long_sentences[:3], 1):
+                word_count = sentence_info.get('word_count', 0)
+                suggestions = sentence_info.get('suggestions', [])
+                lines.append(f"{i}. {word_count} کلمه - {', '.join(suggestions[:2])}")
+        
+        # عملکرد مدل
+        performance = ai_analysis.get('model_performance', {})
+        if performance:
+            lines.append(f"\n⏱️ **عملکرد**: ")
+            if 'classification_time' in performance:
+                lines.append(f"طبقه‌بندی: {performance['classification_time']:.2f}s")
+            if 'ner_time' in performance:
+                lines.append(f"تشخیص موجودیت: {performance['ner_time']:.2f}s")
+        
+        return '\n'.join(lines)
+    
+    def process_multiple_urls(self, urls_text: str, progress=gr.Progress()) -> Tuple[str, str]:
+        """پردازش چندین URL"""
+        if not urls_text or not urls_text.strip():
+            return "❌ لطفا لیست آدرس‌ها را وارد کنید", ""
+        
+        urls = [url.strip() for url in urls_text.split('\n') if url.strip()]
+        if not urls:
+            return "❌ آدرس معتبری یافت نشد", ""
+        
+        # محدودیت تعداد برای HF Spaces
+        if len(urls) > 10:
+            urls = urls[:10]
+            warning_msg = f"{SVG_ICONS['warning']} به دلیل محدودیت‌ها، تنها 10 آدرس اول پردازش می‌شود.\n\n"
+        else:
+            warning_msg = ""
+        
+        results = []
+        total_urls = len(urls)
+        
+        try:
+            progress(0.0, desc=f"شروع پردازش {total_urls} آدرس...")
+            
+            for i, url in enumerate(urls):
+                if not url.startswith(('http://', 'https://')):
+                    url = 'https://' + url
+                
+                progress_value = i / total_urls
+                progress(progress_value, desc=f"پردازش {i+1} از {total_urls}: {url[:50]}...")
+                
+                def progress_callback(message: str, value: float):
+                    overall_progress = progress_value + (value * (1/total_urls))
+                    progress(overall_progress, desc=f"{message} ({i+1}/{total_urls})")
+                
+                result = self.scraper.scrape_legal_source(url, progress_callback)
+                results.append(result)
+                
+                # به‌روزرسانی آمار
+                self.processing_stats['total_processed'] += 1
+                if result.get('status') == 'موفق':
+                    self.processing_stats['successful'] += 1
+                    self.processing_stats['total_words'] += result.get('word_count', 0)
+                else:
+                    self.processing_stats['failed'] += 1
+                
+                # پاکسازی حافظه هر 3 درخواست
+                if (i + 1) % 3 == 0:
+                    MemoryManager.cleanup_memory()
+                    time.sleep(1)  # کمی استراحت
+            
+            progress(1.0, desc="تکمیل پردازش")
+            
+            # ذخیره نتایج
+            self.results.extend(results)
+            
+            # تنظیم خروجی‌ها
+            summary_text = warning_msg + self._format_batch_summary(results)
+            detailed_results = self._format_batch_details(results)
+            
+            return summary_text, detailed_results
+            
+        except Exception as e:
+            logger.error(f"خطا در پردازش دسته‌ای: {e}")
+            return f"❌ خطای سیستمی: {str(e)}", ""
+    
+    def _format_batch_summary(self, results: List[Dict[str, Any]]) -> str:
+        """خلاصه پردازش دسته‌ای با آیکون‌ها"""
+        total = len(results)
+        successful = sum(1 for r in results if r.get('status') == 'موفق')
+        failed = total - successful
+        
+        if successful > 0:
+            total_words = sum(r.get('word_count', 0) for r in results if r.get('status') == 'موفق')
+            avg_quality = sum(r.get('quality_assessment', {}).get('overall_score', 0) 
+                            for r in results if r.get('status') == 'موفق') / successful
+        else:
+            total_words = 0
+            avg_quality = 0
+        
+        lines = [
+            f"{SVG_ICONS['analyze']} **خلاصه پردازش دسته‌ای**",
+            f"📈 **کل آدرس‌ها**: {total}",
+            f"{SVG_ICONS['success']} **موفق**: {successful} ({successful/total*100:.1f}%)",
+            f"{SVG_ICONS['error']} **ناموفق**: {failed} ({failed/total*100:.1f}%)",
+            f"📝 **کل کلمات**: {total_words:,}",
+            f"🎯 **میانگین کیفیت**: {avg_quality:.1f}/100",
+            f"💾 **حافظه**: {MemoryManager.get_memory_usage():.1f} MB",
+            f"🕐 **زمان**: {datetime.now().strftime('%H:%M:%S')}"
+        ]
+        
+        return '\n'.join(lines)
+    
+    def _format_batch_details(self, results: List[Dict[str, Any]]) -> str:
+        """جزئیات نتایج دسته‌ای"""
+        lines = []
+        
+        for i, result in enumerate(results, 1):
+            url = result.get('url', '')
+            status = result.get('status', '')
+            
+            if status == 'موفق':
+                title = result.get('title', 'بدون عنوان')
+                word_count = result.get('word_count', 0)
+                quality = result.get('quality_assessment', {}).get('overall_score', 0)
+                source = result.get('source_info', {}).get('name', 'نامشخص')
+                
+                lines.extend([
+                    f"\n**{i}. {SVG_ICONS['success']} {title}**",
+                    f"{SVG_ICONS['link']} {url[:70]}{'...' if len(url) > 70 else ''}",
+                    f"🏛️ منبع: {source}",
+                    f"📊 {word_count:,} کلمه | کیفیت: {quality:.1f}/100"
+                ])
+            else:
+                error = result.get('error', 'خطای نامشخص')
+                lines.extend([
+                    f"\n**{i}. {SVG_ICONS['error']} ناموفق**",
+                    f"{SVG_ICONS['link']} {url[:70]}{'...' if len(url) > 70 else ''}",
+                    f"❗ {error[:80]}{'...' if len(error) > 80 else ''}"
+                ])
+        
+        return '\n'.join(lines)
+    
+    def export_results(self) -> Tuple[str, Optional[str]]:
+        """صادرات نتایج"""
+        if not self.results:
+            return f"{SVG_ICONS['error']} نتیجه‌ای برای صادرات وجود ندارد", None
+        
+        try:
+            successful_results = [r for r in self.results if r.get('status') == 'موفق']
+            
+            if not successful_results:
+                return f"{SVG_ICONS['error']} نتیجه موفقی برای صادرات وجود ندارد", None
+            
+            export_data = []
+            for result in successful_results:
+                quality = result.get('quality_assessment', {})
+                source_info = result.get('source_info', {})
+                ai_analysis = result.get('ai_analysis', {})
+                
+                # استخراج اطلاعات طبقه‌بندی
+                classification = ai_analysis.get('classification', [])
+                top_class = classification[0].get('label', '') if classification else ''
+                
+                export_data.append({
+                    'آدرس': result.get('url', ''),
+                    'عنوان': result.get('title', ''),
+                    'منبع': source_info.get('name', ''),
+                    'اعتبار منبع': source_info.get('credibility', ''),
+                    'تعداد کلمات': result.get('word_count', 0),
+                    'کیفیت کلی': round(quality.get('overall_score', 0), 1),
+                    'محتوای فارسی (%)': round(quality.get('factors', {}).get('persian_content', 0), 1),
+                    'محتوای حقوقی': round(quality.get('factors', {}).get('legal_content', 0), 1),
+                    'طبقه‌بندی AI': top_class,
+                    'زمان استخراج': result.get('timestamp', ''),
+                    'محتوا': result.get('content', '')[:2000] + '...' if len(result.get('content', '')) > 2000 else result.get('content', '')
+                })
+            
+            df = pd.DataFrame(export_data)
+            
+            # ذخیره فایل
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            csv_path = f"/tmp/legal_scraping_results_{timestamp}.csv"
+            df.to_csv(csv_path, index=False, encoding='utf-8-sig')
+            
+            summary = f"{SVG_ICONS['export']} {len(export_data)} سند با موفقیت صادر شد"
+            return summary, csv_path
+            
+        except Exception as e:
+            logger.error(f"خطا در صادرات: {e}")
+            return f"{SVG_ICONS['error']} خطا در صادرات: {str(e)}", None
+    
+    def get_system_status(self) -> str:
+        """وضعیت سیستم"""
+        model_status = self.model_manager.get_model_status()
+        memory_usage = MemoryManager.get_memory_usage()
+        
+        lines = [
+            f"{SVG_ICONS['settings']} **وضعیت سیستم**\n",
+            f"💾 **حافظه**: {memory_usage:.1f} MB",
+            f"📊 **آمار کلی**:",
+            f"  • کل پردازش شده: {self.processing_stats['total_processed']}",
+            f"  • موفق: {self.processing_stats['successful']}",
+            f"  • ناموفق: {self.processing_stats['failed']}",
+            f"  • کل کلمات: {self.processing_stats['total_words']:,}",
+            f"\n🤖 **مدل‌ها**:",
+            model_status,
+            f"\n⏰ **آخرین بروزرسانی**: {datetime.now().strftime('%Y/%m/%d %H:%M:%S')}"
+        ]
+        
+        return '\n'.join(lines)
+    
+    def clear_results(self) -> str:
+        """پاکسازی نتایج و حافظه"""
+        self.results.clear()
+        self.processing_stats = {
+            'total_processed': 0,
+            'successful': 0,
+            'failed': 0,
+            'total_words': 0
+        }
+        MemoryManager.cleanup_memory()
+        return f"{SVG_ICONS['success']} نتایج و حافظه پاکسازی شد"
+    
+    def create_interface(self):
+        """ایجاد رابط کاربری Gradio"""
+        
+        # CSS سفارشی برای RTL و فونت فارسی
+        custom_css = """
+        .rtl {
+            direction: rtl;
+            text-align: right;
+            font-family: 'Vazirmatn', 'Tahoma', sans-serif;
+        }
+        
+        .persian-title {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+            margin-bottom: 20px;
+            font-family: 'Vazirmatn', 'Tahoma', sans-serif;
+        }
+        
+        .status-box {
+            border: 1px solid #ddd;
+            border-radius: 8px;
+            padding: 15px;
+            background-color: #f9f9f9;
+            direction: rtl;
+            font-family: 'Vazirmatn', 'Tahoma', sans-serif;
+        }
+        
+        .gradio-container {
+            font-family: 'Vazirmatn', 'Tahoma', sans-serif !important;
+        }
+        """
+        
+        with gr.Blocks(
+            title="سیستم پیشرفته استخراج و تحلیل اسناد حقوقی فارسی",
+            css=custom_css,
+            theme=gr.themes.Soft()
+        ) as interface:
+            
+            # عنوان اصلی
+            gr.HTML(f"""
+            <div class="persian-title">
+                <h1>{SVG_ICONS['document']} سیستم پیشرفته استخراج و تحلیل اسناد حقوقی فارسی</h1>
+                <p>{SVG_ICONS['analyze']} مجهز به مدل‌های BERT فارسی | 📊 تحلیل هوشمند محتوا | ⚡ بهینه‌سازی شده برای Hugging Face Spaces</p>
+                <p>🎯 منابع معتبر: مجلس، قوه قضاییه، وزارت دادگستری، دیوان عدالت اداری</p>
+            </div>
+            """)
+            
+            with gr.Tabs():
+                
+                # تب پردازش تک URL
+                with gr.Tab(f"{SVG_ICONS['search']} پردازش تک آدرس"):
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            single_url = gr.Textbox(
+                                label=f"{SVG_ICONS['link']} آدرس سند حقوقی",
+                                placeholder="https://rc.majlis.ir/fa/law/show/12345",
+                                lines=2,
+                                elem_classes=["rtl"]
+                            )
+                            
+                            with gr.Row():
+                                single_btn = gr.Button(
+                                    f"{SVG_ICONS['analyze']} شروع استخراج و تحلیل",
+                                    variant="primary",
+                                    size="lg"
+                                )
+                                clear_single_btn = gr.Button(
+                                    "🧹 پاک کردن",
+                                    variant="secondary"
+                                )
+                        
+                        with gr.Column(scale=1):
+                            system_status = gr.Textbox(
+                                label=f"{SVG_ICONS['settings']} وضعیت سیستم",
+                                interactive=False,
+                                lines=12,
+                                elem_classes=["rtl", "status-box"]
+                            )
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            single_status = gr.Textbox(
+                                label=f"{SVG_ICONS['analyze']} خلاصه نتایج",
+                                interactive=False,
+                                lines=12,
+                                elem_classes=["rtl"]
+                            )
+                        
+                        with gr.Column():
+                            single_analysis = gr.Textbox(
+                                label=f"{SVG_ICONS['analyze']} تحلیل هوش مصنوعی",
+                                interactive=False,
+                                lines=12,
+                                elem_classes=["rtl"]
+                            )
+                    
+                    single_content = gr.Textbox(
+                        label=f"{SVG_ICONS['document']} محتوای استخراج شده",
+                        interactive=False,
+                        lines=15,
+                        elem_classes=["rtl"]
+                    )
+                
+                # تب پردازش چندتایی
+                with gr.Tab(f"{SVG_ICONS['document']} پردازش دسته‌ای"):
+                    gr.Markdown("""
+                    ### 📝 راهنمای استفاده:
+                    - هر آدرس را در خط جداگانه‌ای قرار دهید
+                    - حداکثر 10 آدرس به دلیل محدودیت‌های سیستم
+                    - از منابع معتبر حقوقی استفاده کنید
+                    """, elem_classes=["rtl"])
+                    
+                    multi_urls = gr.Textbox(
+                        label=f"{SVG_ICONS['document']} فهرست آدرس‌ها (هر آدرس در خط جداگانه)",
+                        placeholder="""https://rc.majlis.ir/fa/law/show/12345
+https://www.judiciary.ir/fa/news/67890
+https://www.dotic.ir/portal/law/54321""",
+                        lines=8,
+                        elem_classes=["rtl"]
+                    )
+                    
+                    with gr.Row():
+                        multi_btn = gr.Button(
+                            f"{SVG_ICONS['analyze']} شروع پردازش دسته‌ای",
+                            variant="primary",
+                            size="lg"
+                        )
+                        clear_multi_btn = gr.Button(
+                            "🧹 پاک کردن",
+                            variant="secondary"
+                        )
+                    
+                    with gr.Row():
+                        with gr.Column():
+                            batch_summary = gr.Textbox(
+                                label=f"{SVG_ICONS['analyze']} خلاصه پردازش",
+                                interactive=False,
+                                lines=10,
+                                elem_classes=["rtl"]
+                            )
+                        
+                        with gr.Column():
+                            batch_details = gr.Textbox(
+                                label=f"{SVG_ICONS['document']} جزئیات نتایج",
+                                interactive=False,
+                                lines=10,
+                                elem_classes=["rtl"]
+                            )
+                
+                # تب صادرات و مدیریت
+                with gr.Tab(f"{SVG_ICONS['export']} مدیریت و صادرات"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown(f"### {SVG_ICONS['export']} صادرات نتایج", elem_classes=["rtl"])
+                            
+                            export_btn = gr.Button(
+                                f"{SVG_ICONS['export']} صادرات به CSV",
+                                variant="primary"
+                            )
+                            
+                            export_status = gr.Textbox(
+                                label="وضعیت صادرات",
+                                interactive=False,
+                                lines=3,
+                                elem_classes=["rtl"]
+                            )
+                            
+                            export_file = gr.File(
+                                label="📁 فایل صادر شده",
+                                interactive=False
+                            )
+                        
+                        with gr.Column():
+                            gr.Markdown(f"### {SVG_ICONS['settings']} مدیریت سیستم", elem_classes=["rtl"])
+                            
+                            with gr.Row():
+                                refresh_btn = gr.Button(
+                                    "🔄 بروزرسانی وضعیت",
+                                    variant="secondary"
+                                )
+                                cleanup_btn = gr.Button(
+                                    "🧹 پاکسازی حافظه",
+                                    variant="secondary"
+                                )
+                            
+                            clear_results_btn = gr.Button(
+                                "🗑️ پاک کردن تمام نتایج",
+                                variant="stop"
+                            )
+                            
+                            management_status = gr.Textbox(
+                                label="وضعیت عملیات",
+                                interactive=False,
+                                lines=5,
+                                elem_classes=["rtl"]
+                            )
+            
+            # اتصال event handlerها
+            
+            # تک URL
+            single_btn.click(
+                fn=self.process_single_url,
+                inputs=[single_url],
+                outputs=[single_status, single_content, single_analysis],
+                show_progress=True
+            )
+            
+            clear_single_btn.click(
+                lambda: ("", "", "", ""),
+                outputs=[single_url, single_status, single_content, single_analysis]
+            )
+            
+            # چندتایی
+            multi_btn.click(
+                fn=self.process_multiple_urls,
+                inputs=[multi_urls],
+                outputs=[batch_summary, batch_details],
+                show_progress=True
+            )
+            
+            clear_multi_btn.click(
+                lambda: ("", "", ""),
+                outputs=[multi_urls, batch_summary, batch_details]
+            )
+            
+            # صادرات
+            export_btn.click(
+                fn=self.export_results,
+                outputs=[export_status, export_file]
+            )
+            
+            # مدیریت
+            refresh_btn.click(
+                fn=self.get_system_status,
+                outputs=[system_status]
+            )
+            
+            cleanup_btn.click(
+                fn=MemoryManager.cleanup_memory,
+                outputs=[management_status]
+            ).then(
+                lambda: "✅ حافظه پاکسازی شد",
+                outputs=[management_status]
+            )
+            
+            clear_results_btn.click(
+                fn=self.clear_results,
+                outputs=[management_status]
+            )
+            
+            # بارگذاری اولیه وضعیت سیستم
+            interface.load(
+                fn=self.get_system_status,
+                outputs=[system_status]
+            )
+        
+        return interface
+
+def main():
+    """تابع اصلی برای اجرای برنامه"""
+    logger.info("🚀 راه‌اندازی سیستم استخراج اسناد حقوقی فارسی...")
+    
+    try:
+        # ایجاد نمونه برنامه
+        app = PersianLegalScraperApp()
+        
+        # ایجاد و راه‌اندازی رابط
+        interface = app.create_interface()
+        
+        # راه‌اندازی با پیکربندی Hugging Face Spaces
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+            show_tips=True,
+            enable_queue=True,
+            max_threads=2
+        )
+        
+    except Exception as e:
+        logger.error(f"خطا در راه‌اندازی برنامه: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()