Delete app.py

app.py

@@ -1,946 +0,0 @@
-import requests
-import json
-import gradio as gr
-from typing import Dict, Any, List, Generator
-import os
-from dataclasses import dataclass
-import re
-import pandas as pd
-import time
-from datetime import datetime
-import threading
-from queue import Queue
-import io
-
-@dataclass
-class CerebrasConfig:
-    """تنظیمات Cerebras API"""
-    api_key: str
-    base_url: str = "https://api.cerebras.ai/v1"
-    model: str = "qwen-3-32b"
-    max_tokens: int = 2000
-    temperature: float = 0.1
-
-@dataclass
-class RateLimitConfig:
-    """تنظیمات محدودیت نرخ درخواست برای Cerebras"""
-    # محدودیت‌های Cerebras Free Tier
-    requests_per_minute: int = 30  # حداکثر درخواست در دقیقه
-    tokens_per_minute: int = 60000  # حداکثر توکن در دقیقه
-    min_delay_between_requests: float = 2.0  # حداقل تأخیر بین درخواست‌ها (ثانیه)
-    max_retries: int = 5  # حداکثر تلاش مجدد
-    initial_backoff: float = 5.0  # تأخیر اولیه برای backoff (ثانیه)
-    max_backoff: float = 120.0  # حداکثر تأخیر backoff (ثانیه)
-    backoff_multiplier: float = 2.0  # ضریب افزایش تأخیر
-
-class RateLimiter:
-    """مدیریت محدودیت نرخ درخواست"""
-    
-    def __init__(self, config: RateLimitConfig):
-        self.config = config
-        self.request_times: List[float] = []
-        self.lock = threading.Lock()
-        self.consecutive_failures = 0
-    
-    def wait_if_needed(self) -> float:
-        """انتظار تا زمان مجاز ارسال درخواست بعدی"""
-        with self.lock:
-            now = time.time()
-            
-            # پاک کردن درخواست‌های قدیمی‌تر از 1 دقیقه
-            self.request_times = [t for t in self.request_times if now - t < 60]
-            
-            # محاسبه زمان انتظار
-            wait_time = 0.0
-            
-            # اگر به محدودیت درخواست در دقیقه رسیده‌ایم
-            if len(self.request_times) >= self.config.requests_per_minute:
-                oldest_request = min(self.request_times)
-                wait_time = max(wait_time, 60 - (now - oldest_request) + 1)
-            
-            # حداقل تأخیر بین درخواست‌ها
-            if self.request_times:
-                time_since_last = now - max(self.request_times)
-                if time_since_last < self.config.min_delay_between_requests:
-                    wait_time = max(wait_time, self.config.min_delay_between_requests - time_since_last)
-            
-            # افزایش تأخیر در صورت خطاهای متوالی
-            if self.consecutive_failures > 0:
-                failure_wait = min(
-                    self.config.initial_backoff * (self.config.backoff_multiplier ** self.consecutive_failures),
-                    self.config.max_backoff
-                )
-                wait_time = max(wait_time, failure_wait)
-            
-            if wait_time > 0:
-                time.sleep(wait_time)
-            
-            self.request_times.append(time.time())
-            return wait_time
-    
-    def report_success(self):
-        """گزارش موفقیت درخواست"""
-        with self.lock:
-            self.consecutive_failures = 0
-    
-    def report_failure(self, is_rate_limit: bool = False):
-        """گزارش شکست درخواست"""
-        with self.lock:
-            if is_rate_limit:
-                self.consecutive_failures += 1
-            else:
-                # برای خطاهای غیر rate limit، کمتر افزایش می‌دهیم
-                self.consecutive_failures = min(self.consecutive_failures + 0.5, 3)
-    
-    def get_estimated_wait_time(self) -> float:
-        """تخمین زمان انتظار برای درخواست بعدی"""
-        with self.lock:
-            now = time.time()
-            self.request_times = [t for t in self.request_times if now - t < 60]
-            
-            if len(self.request_times) >= self.config.requests_per_minute:
-                oldest_request = min(self.request_times)
-                return max(0, 60 - (now - oldest_request) + 1)
-            
-            return self.config.min_delay_between_requests
-
-class AdvancedCerebrasAnonymizer:
-    """سیستم پیشرفته ناشناس‌سازی متون مالی/خبری فارسی"""
-    
-    def __init__(self, api_key: str = None, rate_limit_config: RateLimitConfig = None):
-        if api_key is None:
-            api_key = os.getenv("CEREBRAS_API_KEY")
-            if not api_key:
-                raise ValueError("کلید API یافت نشد")
-        
-        self.config = CerebrasConfig(api_key=api_key)
-        self.rate_limit_config = rate_limit_config or RateLimitConfig()
-        self.rate_limiter = RateLimiter(self.rate_limit_config)
-        self.system_prompt = self._create_advanced_system_prompt()
-    
-    def _create_advanced_system_prompt(self) -> str:
-        """ایجاد دستورالعمل سیستمی پیشرفته برای Cerebras"""
-        return """شما یک «ناشناس‌ساز متون مالی/خبری فارسی» هستید. وظیفه‌تان جایگزینی اسامی خاص و مقادیر عددی با شناسه‌های بی‌معناست.
-
-## **قوانین اندیس‌گذاری - CRITICAL**
-### **1. ترتیب شماره‌گذاری الزامی:**
-- شرکت‌ها: company-01, company-02, company-03, company-04, ... (پیوسته و بدون گپ)
-- اشخاص: person-01, person-02, person-03, ... (پیوسته و بدون گپ)
-- اعداد: amount-01, amount-02, amount-03, ... (پیوسته و بدون گپ)
-- درصدها: percent-01, percent-02, percent-03, ... (پیوسته و بدون گپ)
-
-### **2. ثبات شناسه‌ها در متن:**
-- اگر "همراه اول" اول‌بار company-01 شد، در تمام متن همان باشد
-- اگر "مهدی احمدی" اول‌بار person-01 شد، در تمام متن همان باشد
-
-### **3. تشخیص صحیح انواع:**
-**شرکت/سازمان:** همراه اول، بانک ملی، ایران‌خودرو، سایپا، بانک مرکزی، سامانه کدال، وزارت نفت، سازمان تنظیم مقررات رادیویی، سازمان تامین اجتماعی
-**⚠️ CRITICAL - گروه‌ها:** "گروه همراه اول"، "گروه اقتصادی آزادگان"، "گروه مالی صبا" → همه company-XX هستند (نه group-XX)
-**⚠️ CRITICAL - کلمات عمومی:** "سه شرکت دارویی"، "چند بانک"، "یک شرکت" → کلمات عمومی هستند، موجودیت نیستند (حفظ شوند)
-**⚠️ CRITICAL - نام‌های مستعار:** "فاما" همان "فولاد مبارکه اصفهان" است → هر دو company-01
-**شخص:** مهدی اخوان بهابادی، محمدرضا فرزین، ابوالفضل نجارزاده
-**عدد:** 37، 70، 677، 73.7، 178 (هر عددی)
-**درصد:** 37 درصدی، 15 درصدی، 53 درصد، 43%
-
-## **مثال‌های صحیح:**
-
-### **مثال 1 (الگوی کامل):**
-**ورودی:** مهدی اخوان بهابادی، مدیرعامل همراه اول، اعلام کرد درآمد عملیاتی شرکت با رشد 37 درصدی به 70 هزار و 677 میلیارد تومان رسیده است.
-**خروجی صحیح:** person-01، مدیرعامل company-01، اعلام کرد درآمد عملیاتی شرکت با رشد percent-01 به amount-01 رسیده است.
-
-### **مثال 2:**
-**ورودی:** بانک مرکزی و بانک ملی با همکاری محمدرضا فرزین، 60 درصد سپرده‌ها را مدیریت کردند.
-**خروجی:** company-01 و company-02 با همکاری person-01، percent-01 سپرده‌ها را مدیریت کردند.
-
-## **⚠️ CRITICAL - دوره‌های زمانی را حفظ کن:**
-- "۹ ماهه" → حفظ شود (نه amount-XX)
-- "۵ ماهه سال" → حفظ شود (نه amount-XX)
-- "۳ ماهه اول" → حفظ شود (نه amount-XX)
-
-## **موارد حفظ شده:**
-- تاریخ‌ها: 1404/04/23، 30 آذر 1403، پاییز 1401
-- فصل‌های سال: پاییز، بهار، تابستان، زمستان
-- عناوین شغلی: مدیرعامل، رئیس کل، مدیرکل
-- واحدها: میلیارد تومان، همت، ریال، ماه، سال
-- مکان‌ها: تهران، اصفهان، ایران
-
-**فقط متن ناشناس‌شده را برگردان - هیچ توضیح اضافی نیاز نیست.**
-"""
-
-    def _make_api_request_with_retry(self, text: str) -> Dict[str, Any]:
-        """ارسال درخواست به Cerebras API با مدیریت rate limit و retry"""
-        headers = {
-            "Authorization": f"Bearer {self.config.api_key}",
-            "Content-Type": "application/json"
-        }
-        
-        payload = {
-            "messages": [
-                {"role": "system", "content": self.system_prompt},
-                {"role": "user", "content": text}
-            ],
-            "model": self.config.model,
-            "temperature": self.config.temperature,
-            "max_tokens": self.config.max_tokens
-        }
-        
-        last_error = None
-        
-        for attempt in range(self.rate_limit_config.max_retries):
-            # انتظار قبل از ارسال درخواست
-            wait_time = self.rate_limiter.wait_if_needed()
-            
-            try:
-                response = requests.post(
-                    f"{self.config.base_url}/chat/completions",
-                    headers=headers,
-                    json=payload,
-                    timeout=60
-                )
-                
-                # بررسی خطای rate limit (429)
-                if response.status_code == 429:
-                    self.rate_limiter.report_failure(is_rate_limit=True)
-                    
-                    # استخراج زمان انتظار از هدر (اگر موجود باشد)
-                    retry_after = response.headers.get('Retry-After')
-                    if retry_after:
-                        wait_seconds = int(retry_after)
-                    else:
-                        # محاسبه exponential backoff
-                        wait_seconds = min(
-                            self.rate_limit_config.initial_backoff * (self.rate_limit_config.backoff_multiplier ** attempt),
-                            self.rate_limit_config.max_backoff
-                        )
-                    
-                    last_error = f"محدودیت نرخ درخواست (429). تلاش {attempt + 1}/{self.rate_limit_config.max_retries}. انتظار {wait_seconds:.1f} ثانیه..."
-                    time.sleep(wait_seconds)
-                    continue
-                
-                response.raise_for_status()
-                self.rate_limiter.report_success()
-                return response.json()
-                
-            except requests.exceptions.Timeout:
-                self.rate_limiter.report_failure(is_rate_limit=False)
-                last_error = f"خطای timeout. تلاش {attempt + 1}/{self.rate_limit_config.max_retries}"
-                time.sleep(self.rate_limit_config.initial_backoff)
-                
-            except requests.exceptions.RequestException as e:
-                self.rate_limiter.report_failure(is_rate_limit=False)
-                last_error = f"خطای شبکه: {str(e)}. تلاش {attempt + 1}/{self.rate_limit_config.max_retries}"
-                time.sleep(self.rate_limit_config.initial_backoff)
-        
-        raise Exception(f"ناموفق پس از {self.rate_limit_config.max_retries} تلاش. آخرین خطا: {last_error}")
-    
-    def anonymize_text(self, text: str) -> Dict[str, Any]:
-        """ناشناس‌سازی متن با استفاده از Cerebras"""
-        if not text or not text.strip():
-            return {
-                "success": False,
-                "error": "متن ورودی خالی است",
-                "anonymized_text": ""
-            }
-        
-        try:
-            response = self._make_api_request_with_retry(text)
-            
-            if "choices" not in response or not response["choices"]:
-                return {
-                    "success": False,
-                    "error": "پاسخ نامعتبر از API",
-                    "anonymized_text": ""
-                }
-            
-            content = response["choices"][0]["message"]["content"]
-            content = self._clean_markdown(content)
-            content = content.strip()
-            
-            analysis = self._analyze_anonymized_text(content)
-            
-            return {
-                "success": True,
-                "anonymized_text": content,
-                "entities": analysis["entities"],
-                "statistics": analysis["statistics"],
-                "usage": response.get("usage", {})
-            }
-                
-        except Exception as e:
-            return {
-                "success": False,
-                "error": f"خطا در پردازش: {str(e)}",
-                "anonymized_text": ""
-            }
-    
-    def _clean_markdown(self, content: str) -> str:
-        """پاک کردن markdown از پاسخ"""
-        if "```" in content:
-            lines = content.split('\n')
-            clean_lines = []
-            skip = False
-            for line in lines:
-                if line.strip().startswith('```'):
-                    skip = not skip
-                    continue
-                if not skip:
-                    clean_lines.append(line)
-            content = '\n'.join(clean_lines)
-        return content
-    
-    def _analyze_anonymized_text(self, text: str) -> Dict[str, Any]:
-        """تحلیل متن ناشناس‌سازی شده"""
-        companies = re.findall(r'company-(\d+)', text)
-        persons = re.findall(r'person-(\d+)', text)
-        amounts = re.findall(r'amount-(\d+)', text)
-        percents = re.findall(r'percent-(\d+)', text)
-        
-        statistics = {
-            "company": len(set(companies)),
-            "person": len(set(persons)),
-            "amount": len(set(amounts)),
-            "percent": len(set(percents)),
-            "total_replacements": len(companies) + len(persons) + len(amounts) + len(percents)
-        }
-        
-        entities = {
-            "companies": sorted(list(set(companies)), key=lambda x: int(x)),
-            "persons": sorted(list(set(persons)), key=lambda x: int(x)),
-            "amounts": sorted(list(set(amounts)), key=lambda x: int(x)),
-            "percents": sorted(list(set(percents)), key=lambda x: int(x))
-        }
-        
-        return {
-            "statistics": statistics,
-            "entities": entities
-        }
-
-
-class BatchProcessor:
-    """پردازشگر دسته‌ای فایل‌های CSV"""
-    
-    def __init__(self, api_key: str, rate_limit_config: RateLimitConfig = None):
-        self.api_key = api_key
-        self.rate_limit_config = rate_limit_config or RateLimitConfig()
-        self.anonymizer = None
-        self.is_cancelled = False
-        self.current_progress = 0
-        self.total_rows = 0
-        self.processed_rows = 0
-        self.failed_rows = 0
-        self.start_time = None
-    
-    def cancel(self):
-        """لغو پردازش"""
-        self.is_cancelled = True
-    
-    def reset(self):
-        """بازنشانی وضعیت"""
-        self.is_cancelled = False
-        self.current_progress = 0
-        self.total_rows = 0
-        self.processed_rows = 0
-        self.failed_rows = 0
-        self.start_time = None
-    
-    def process_csv(
-        self, 
-        file_path: str, 
-        text_column: str,
-        output_column: str = "anonymized_text",
-        progress_callback=None
-    ) -> Generator[Dict[str, Any], None, None]:
-        """پردازش فایل CSV به صورت streaming"""
-        
-        self.reset()
-        self.start_time = time.time()
-        
-        # خواندن فایل CSV
-        try:
-            df = pd.read_csv(file_path, encoding='utf-8')
-        except UnicodeDecodeError:
-            try:
-                df = pd.read_csv(file_path, encoding='utf-8-sig')
-            except:
-                df = pd.read_csv(file_path, encoding='cp1256')
-        
-        if text_column not in df.columns:
-            yield {
-                "type": "error",
-                "message": f"ستون '{text_column}' در فایل یافت نشد. ستون‌های موجود: {list(df.columns)}"
-            }
-            return
-        
-        self.total_rows = len(df)
-        
-        # ایجاد anonymizer
-        self.anonymizer = AdvancedCerebrasAnonymizer(
-            api_key=self.api_key,
-            rate_limit_config=self.rate_limit_config
-        )
-        
-        # ایجاد ستون خروجی
-        df[output_column] = ""
-        df["anonymization_status"] = ""
-        df["entities_found"] = ""
-        
-        yield {
-            "type": "info",
-            "message": f"🚀 شروع پردازش {self.total_rows} ردیف...",
-            "total": self.total_rows
-        }
-        
-        results = []
-        
-        for idx, row in df.iterrows():
-            if self.is_cancelled:
-                yield {
-                    "type": "cancelled",
-                    "message": "پردازش توسط کاربر لغو شد",
-                    "processed": self.processed_rows,
-                    "failed": self.failed_rows
-                }
-                break
-            
-            text = str(row[text_column]) if pd.notna(row[text_column]) else ""
-            
-            if not text.strip():
-                df.at[idx, output_column] = ""
-                df.at[idx, "anonymization_status"] = "خالی"
-                df.at[idx, "entities_found"] = ""
-                self.processed_rows += 1
-                continue
-            
-            # پردازش متن
-            result = self.anonymizer.anonymize_text(text)
-            
-            if result["success"]:
-                df.at[idx, output_column] = result["anonymized_text"]
-                df.at[idx, "anonymization_status"] = "موفق"
-                stats = result.get("statistics", {})
-                entities_summary = f"شرکت:{stats.get('company',0)} | شخص:{stats.get('person',0)} | مبلغ:{stats.get('amount',0)} | درصد:{stats.get('percent',0)}"
-                df.at[idx, "entities_found"] = entities_summary
-                self.processed_rows += 1
-            else:
-                df.at[idx, output_column] = f"خطا: {result.get('error', 'نامشخص')}"
-                df.at[idx, "anonymization_status"] = "ناموفق"
-                df.at[idx, "entities_found"] = ""
-                self.failed_rows += 1
-            
-            # محاسبه پیشرفت و زمان باقیمانده
-            self.current_progress = (idx + 1) / self.total_rows * 100
-            elapsed = time.time() - self.start_time
-            avg_time_per_row = elapsed / (idx + 1)
-            remaining_rows = self.total_rows - (idx + 1)
-            estimated_remaining = avg_time_per_row * remaining_rows
-            
-            # تخمین زمان انتظار بعدی
-            next_wait = self.anonymizer.rate_limiter.get_estimated_wait_time()
-            
-            yield {
-                "type": "progress",
-                "current": idx + 1,
-                "total": self.total_rows,
-                "progress": self.current_progress,
-                "processed": self.processed_rows,
-                "failed": self.failed_rows,
-                "elapsed": elapsed,
-                "estimated_remaining": estimated_remaining,
-                "next_wait": next_wait,
-                "last_result": result
-            }
-        
-        # ذخیره نتیجه نهایی
-        if not self.is_cancelled:
-            output_path = file_path.replace('.csv', '_anonymized.csv')
-            if output_path == file_path:
-                output_path = file_path + '_anonymized.csv'
-            
-            df.to_csv(output_path, index=False, encoding='utf-8-sig')
-            
-            total_time = time.time() - self.start_time
-            
-            yield {
-                "type": "complete",
-                "message": "✅ پردازش با موفقیت تکمیل شد!",
-                "output_path": output_path,
-                "total": self.total_rows,
-                "processed": self.processed_rows,
-                "failed": self.failed_rows,
-                "total_time": total_time,
-                "dataframe": df
-            }
-
-
-def create_batch_interface():
-    """ایجاد رابط کاربری برای پردازش دسته‌ای"""
-    
-    api_key_available = bool(os.getenv("CEREBRAS_API_KEY"))
-    
-    custom_css = """
-    .gradio-container {
-        font-family: 'Tahoma', 'Arial', sans-serif !important;
-        direction: rtl;
-        max-width: 1400px;
-        margin: 0 auto;
-    }
-    .progress-bar {
-        background-color: #e9ecef;
-        border-radius: 10px;
-        height: 30px;
-        overflow: hidden;
-    }
-    .progress-fill {
-        background: linear-gradient(90deg, #28a745, #20c997);
-        height: 100%;
-        transition: width 0.3s ease;
-    }
-    .stats-card {
-        background-color: #f8f9fa;
-        border-radius: 10px;
-        padding: 15px;
-        margin: 10px 0;
-        border: 1px solid #dee2e6;
-    }
-    .warning-box {
-        background-color: #fff3cd;
-        border: 2px solid #ffeaa7;
-        border-radius: 12px;
-        padding: 15px;
-        color: #856404;
-        margin: 10px 0;
-    }
-    .success-box {
-        background-color: #d4edda;
-        border: 2px solid #c3e6cb;
-        border-radius: 12px;
-        padding: 15px;
-        color: #155724;
-        margin: 10px 0;
-    }
-    .info-box {
-        background-color: #d1ecf1;
-        border: 2px solid #bee5eb;
-        border-radius: 12px;
-        padding: 15px;
-        color: #0c5460;
-        margin: 10px 0;
-    }
-    """
-    
-    # متغیرهای سراسری برای مدیریت پردازش
-    batch_processor = {"instance": None}
-    
-    with gr.Blocks(css=custom_css, title="پردازش دسته‌ای ناشناس‌سازی با Cerebras", theme=gr.themes.Soft()) as interface:
-        
-        gr.Markdown("""
-        # 🔒 سیستم پردازش دسته‌ای ناشناس‌سازی متون فارسی
-        ### ⚡ قدرت‌گرفته از Cerebras AI با مدیریت هوشمند Rate Limit
-        """)
-        
-        with gr.Tabs():
-            # تب پردازش تکی
-            with gr.Tab("📝 پردازش تکی"):
-                if api_key_available:
-                    gr.Markdown('<div class="success-box">✅ <strong>سیستم آماده است</strong> - کلید API تنظیم شده</div>')
-                    single_api_key = gr.Textbox(visible=False, value="")
-                else:
-                    gr.Markdown('<div class="warning-box">⚠️ <strong>کلید API تنظیم نشده</strong> - لطفاً کلید خود را وارد کنید</div>')
-                    single_api_key = gr.Textbox(label="🔑 کلید Cerebras API", placeholder="csk-...", type="password")
-                
-                with gr.Row():
-                    with gr.Column():
-                        single_input = gr.Textbox(label="📝 متن ورودی", placeholder="متن خود را وارد کنید...", lines=10)
-                        single_btn = gr.Button("🔒 ناشناس‌سازی", variant="primary")
-                    with gr.Column():
-                        single_output = gr.Textbox(label="🎯 متن ناشناس‌سازی شده", lines=10)
-                        single_stats = gr.Markdown()
-            
-            # تب پردازش دسته‌ای
-            with gr.Tab("📁 پردازش دسته‌ای CSV"):
-                gr.Markdown("""
-                <div class="info-box">
-                📌 <strong>راهنمای پردازش دسته‌ای:</strong><br>
-                1. فایل CSV خود را آپلود کنید<br>
-                2. ستون حاوی متن را انتخاب کنید<br>
-                3. تنظیمات Rate Limit را بررسی کنید<br>
-                4. پردازش را شروع کنید<br><br>
-                ⚠️ <strong>نکته مهم:</strong> برای جلوگیری از خطای 429، تأخیر بین درخواست‌ها به صورت خودکار مدیریت می‌شود.
-                </div>
-                """)
-                
-                if not api_key_available:
-                    batch_api_key = gr.Textbox(label="🔑 کلید Cerebras API", placeholder="csk-...", type="password")
-                else:
-                    batch_api_key = gr.Textbox(visible=False, value="")
-                
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        csv_file = gr.File(label="📂 فایل CSV", file_types=[".csv"])
-                        
-                        with gr.Row():
-                            text_column = gr.Dropdown(
-                                label="📑 ستون متن",
-                                choices=[],
-                                interactive=True,
-                                info="ستون حاوی متن برای ناشناس‌سازی"
-                            )
-                            output_column = gr.Textbox(
-                                label="📤 نام ستون خروجی",
-                                value="anonymized_text",
-                                info="نام ستون برای ذخیره نتایج"
-                            )
-                    
-                    with gr.Column(scale=1):
-                        gr.Markdown("### ⚙️ تنظیمات Rate Limit")
-                        
-                        delay_between_requests = gr.Slider(
-                            label="⏱️ حداقل تأخیر بین درخواست‌ها (ثانیه)",
-                            minimum=1.0,
-                            maximum=10.0,
-                            value=2.5,
-                            step=0.5,
-                            info="افزایش این مقدار از خطای 429 جلوگیری می‌کند"
-                        )
-                        
-                        requests_per_minute = gr.Slider(
-                            label="📊 حداکثر درخواست در دقیقه",
-                            minimum=5,
-                            maximum=30,
-                            value=20,
-                            step=1,
-                            info="محدودیت Cerebras Free: 30 درخواست/دقیقه"
-                        )
-                        
-                        max_retries = gr.Slider(
-                            label="🔄 حداکثر تلاش مجدد",
-                            minimum=1,
-                            maximum=10,
-                            value=5,
-                            step=1,
-                            info="تعداد تلاش در صورت خطای 429"
-                        )
-                
-                with gr.Row():
-                    start_btn = gr.Button("🚀 شروع پردازش", variant="primary", size="lg")
-                    cancel_btn = gr.Button("⏹️ لغو پردازش", variant="stop", size="lg")
-                
-                # نمایش پیشرفت
-                progress_bar = gr.Slider(
-                    label="📊 پیشرفت کلی",
-                    minimum=0,
-                    maximum=100,
-                    value=0,
-                    interactive=False
-                )
-                
-                with gr.Row():
-                    with gr.Column():
-                        progress_text = gr.Markdown("### 📈 وضعیت پردازش\nدر انتظار شروع...")
-                    with gr.Column():
-                        time_stats = gr.Markdown("### ⏱️ زمان‌بندی\nدر انتظار شروع...")
-                
-                # لاگ پردازش
-                process_log = gr.Textbox(
-                    label="📋 لاگ پردازش",
-                    lines=8,
-                    max_lines=15,
-                    interactive=False
-                )
-                
-                # نمایش نمونه نتایج
-                with gr.Accordion("👁️ پیش‌نمایش نتایج", open=False):
-                    preview_table = gr.Dataframe(
-                        label="نمونه نتایج",
-                        headers=["متن اصلی", "متن ناشناس‌شده", "وضعیت"],
-                        interactive=False
-                    )
-                
-                # دانلود نتیجه
-                output_file = gr.File(label="📥 دانلود فایل خروجی", visible=False)
-            
-            # تب تنظیمات
-            with gr.Tab("⚙️ تنظیمات و راهنما"):
-                gr.Markdown("""
-                ## 📖 راهنمای محدودیت‌های Cerebras API
-                
-                ### 🔒 محدودیت‌های Free Tier:
-                | پارامتر | مقدار |
-                |---------|--------|
-                | درخواست در دقیقه | 30 |
-                | توکن در دقیقه | 60,000 |
-                | توکن در روز | 1,000,000 |
-                
-                ### ⚡ نکات بهینه‌سازی:
-                1. **تأخیر بین درخواست‌ها:** حداقل 2 ثانیه بین هر درخواست
-                2. **Exponential Backoff:** در صورت خطای 429، تأخیر به صورت نمایی افزایش می‌یابد
-                3. **Retry Logic:** سیستم تا 5 بار تلاش مجدد می‌کند
-                
-                ### 🎯 پیشنهادات:
-                - برای فایل‌های بزرگ (>100 ردیف)، تأخیر را روی 3 ثانیه تنظیم کنید
-                - اگر خطای 429 زیاد دیدید، تأخیر را افزایش دهید
-                - در ساعات شلوغ، محدودیت‌ها ممکن است سخت‌تر شوند
-                
-                ### 📊 فرمت فایل CSV:
-                - **Encoding:** UTF-8 یا UTF-8-BOM پیشنهاد می‌شود
-                - **ستون‌ها:** حداقل یک ستون حاوی متن فارسی
-                - **حجم:** بدون محدودیت (اما پردازش فایل‌های بزرگ زمان‌بر است)
-                """)
-        
-        # توابع
-        def update_columns(file):
-            """بروزرسانی لیست ستون‌ها بعد از آپلود فایل"""
-            if file is None:
-                return gr.update(choices=[], value=None)
-            
-            try:
-                df = pd.read_csv(file.name, encoding='utf-8', nrows=5)
-            except:
-                try:
-                    df = pd.read_csv(file.name, encoding='utf-8-sig', nrows=5)
-                except:
-                    df = pd.read_csv(file.name, encoding='cp1256', nrows=5)
-            
-            columns = list(df.columns)
-            return gr.update(choices=columns, value=columns[0] if columns else None)
-        
-        def process_single_text(text, api_key):
-            """پردازش متن تکی"""
-            if not text.strip():
-                return "", "⚠️ متن ورودی خالی است"
-            
-            key = api_key if api_key else os.getenv("CEREBRAS_API_KEY")
-            if not key:
-                return "", "❌ کلید API وارد نشده است"
-            
-            try:
-                anonymizer = AdvancedCerebrasAnonymizer(api_key=key)
-                result = anonymizer.anonymize_text(text)
-                
-                if result["success"]:
-                    stats = result.get("statistics", {})
-                    stats_md = f"""
-### ✅ پردازش موفق
-- 🏢 شرکت‌ها: {stats.get('company', 0)}
-- 👤 اشخاص: {stats.get('person', 0)}
-- 💰 مبالغ: {stats.get('amount', 0)}
-- 📊 درصدها: {stats.get('percent', 0)}
-"""
-                    return result["anonymized_text"], stats_md
-                else:
-                    return "", f"❌ خطا: {result.get('error', 'نامشخص')}"
-            except Exception as e:
-                return "", f"❌ خطا: {str(e)}"
-        
-        def start_batch_processing(
-            file, 
-            text_col, 
-            output_col, 
-            delay, 
-            rpm, 
-            retries,
-            api_key
-        ):
-            """شروع پردازش دسته‌ای"""
-            if file is None:
-                yield (
-                    0,
-                    "### ❌ خطا\nفایل انتخاب نشده است",
-                    "",
-                    "",
-                    None,
-                    gr.update(visible=False)
-                )
-                return
-            
-            key = api_key if api_key else os.getenv("CEREBRAS_API_KEY")
-            if not key:
-                yield (
-                    0,
-                    "### ❌ خطا\nکلید API وارد نشده است",
-                    "",
-                    "",
-                    None,
-                    gr.update(visible=False)
-                )
-                return
-            
-            # تنظیم rate limit
-            rate_config = RateLimitConfig(
-                requests_per_minute=int(rpm),
-                min_delay_between_requests=float(delay),
-                max_retries=int(retries)
-            )
-            
-            # ایجاد پردازشگر
-            processor = BatchProcessor(api_key=key, rate_limit_config=rate_config)
-            batch_processor["instance"] = processor
-            
-            log_lines = []
-            preview_data = []
-            
-            # پردازش
-            for update in processor.process_csv(file.name, text_col, output_col):
-                update_type = update.get("type")
-                
-                if update_type == "error":
-                    log_lines.append(f"❌ {update['message']}")
-                    yield (
-                        0,
-                        f"### ❌ خطا\n{update['message']}",
-                        "",
-                        "\n".join(log_lines),
-                        None,
-                        gr.update(visible=False)
-                    )
-                    return
-                
-                elif update_type == "info":
-                    log_lines.append(f"ℹ️ {update['message']}")
-                
-                elif update_type == "progress":
-                    progress = update["progress"]
-                    current = update["current"]
-                    total = update["total"]
-                    processed = update["processed"]
-                    failed = update["failed"]
-                    elapsed = update["elapsed"]
-                    remaining = update["estimated_remaining"]
-                    next_wait = update.get("next_wait", 0)
-                    
-                    progress_md = f"""
-### 📈 وضعیت پردازش
-- **پردازش شده:** {current}/{total} ({progress:.1f}%)
-- **موفق:** {processed} ✅
-- **ناموفق:** {failed} ❌
-- **تأخیر بعدی:** {next_wait:.1f} ثانیه
-"""
-                    
-                    time_md = f"""
-### ⏱️ زمان‌بندی
-- **سپری شده:** {elapsed/60:.1f} دقیقه
-- **تخمین باقیمانده:** {remaining/60:.1f} دقیقه
-- **سرعت:** {current/elapsed*60:.1f} ردیف/دقیقه
-"""
-                    
-                    # بروزرسانی لاگ هر 10 ردیف
-                    if current % 10 == 0 or current == total:
-                        log_lines.append(f"📊 پردازش {current}/{total} - موفق: {processed}, ناموفق: {failed}")
-                    
-                    # بروزرسانی پیش‌نمایش
-                    last_result = update.get("last_result", {})
-                    if last_result.get("success"):
-                        preview_data.append([
-                            "...",  # متن اصلی خلاصه
-                            last_result.get("anonymized_text", "")[:100] + "...",
-                            "✅ موفق"
-                        ])
-                        if len(preview_data) > 5:
-                            preview_data = preview_data[-5:]
-                    
-                    yield (
-                        progress,
-                        progress_md,
-                        time_md,
-                        "\n".join(log_lines[-20:]),  # فقط 20 خط آخر
-                        preview_data if preview_data else None,
-                        gr.update(visible=False)
-                    )
-                
-                elif update_type == "cancelled":
-                    log_lines.append(f"⏹️ {update['message']}")
-                    yield (
-                        0,
-                        f"### ⏹️ لغو شد\nپردازش شده: {update['processed']}, ناموفق: {update['failed']}",
-                        "",
-                        "\n".join(log_lines),
-                        preview_data if preview_data else None,
-                        gr.update(visible=False)
-                    )
-                    return
-                
-                elif update_type == "complete":
-                    total_time = update["total_time"]
-                    log_lines.append(f"✅ {update['message']}")
-                    log_lines.append(f"📁 فایل خروجی: {update['output_path']}")
-                    
-                    progress_md = f"""
-### ✅ پردازش تکمیل شد!
-- **کل ردیف‌ها:** {update['total']}
-- **موفق:** {update['processed']} ✅
-- **ناموفق:** {update['failed']} ❌
-- **زمان کل:** {total_time/60:.1f} دقیقه
-"""
-                    
-                    time_md = f"""
-### 📊 آمار نهایی
-- **سرعت میانگین:** {update['total']/total_time*60:.1f} ردیف/دقیقه
-- **نرخ موفقیت:** {update['processed']/update['total']*100:.1f}%
-"""
-                    
-                    yield (
-                        100,
-                        progress_md,
-                        time_md,
-                        "\n".join(log_lines),
-                        preview_data if preview_data else None,
-                        gr.update(value=update['output_path'], visible=True)
-                    )
-        
-        def cancel_processing():
-            """لغو پردازش"""
-            if batch_processor["instance"]:
-                batch_processor["instance"].cancel()
-            return "⏹️ درخواست لغو ارسال شد..."
-        
-        # اتصال رویدادها
-        csv_file.change(
-            fn=update_columns,
-            inputs=[csv_file],
-            outputs=[text_column]
-        )
-        
-        single_btn.click(
-            fn=process_single_text,
-            inputs=[single_input, single_api_key],
-            outputs=[single_output, single_stats]
-        )
-        
-        start_btn.click(
-            fn=start_batch_processing,
-            inputs=[
-                csv_file,
-                text_column,
-                output_column,
-                delay_between_requests,
-                requests_per_minute,
-                max_retries,
-                batch_api_key
-            ],
-            outputs=[
-                progress_bar,
-                progress_text,
-                time_stats,
-                process_log,
-                preview_table,
-                output_file
-            ]
-        )
-        
-        cancel_btn.click(
-            fn=cancel_processing,
-            outputs=[process_log]
-        )
-    
-    return interface
-
-
-# اجرای برنامه
-if __name__ == "__main__":
-    interface = create_batch_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        show_error=True
-    )