Delete app.py

app.py

@@ -1,1520 +0,0 @@
-import gradio as gr
-import re
-import os
-import requests
-import json
-import logging
-import csv
-import io
-import tempfile
-import time
-from typing import Dict, List, Tuple, Optional
-from llm_sender_unified import create_llm_sender
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ─────────────────────────────────────────────────────────────
-# مدل‌های موجود — برای تحلیل LLM
-# ─────────────────────────────────────────────────────────────
-AVAILABLE_MODELS = {
-    "chatgpt":   ["gpt-5.1", "gpt-5", "gpt-4.1", "gpt-4o", "gpt-4o-mini", "gpt-4-turbo"],
-    "grok":      ["grok-4-0709", "grok-3", "grok-3-mini", "grok-2-1212"],
-    "deepinfra": [
-        "Qwen/Qwen3-14B", "Qwen/Qwen3-32B", "Qwen/Qwen3-30B-A3B",
-        "Qwen/Qwen2.5-72B-Instruct", "Qwen/Qwen2.5-14B-Instruct",
-    ],
-}
-
-ANON_MODEL   = "Qwen/Qwen3-14B"
-ANON_API_URL = "https://api.deepinfra.com/v1/openai/chat/completions"
-
-# ─────────────────────────────────────────────────────────────
-# SYSTEM PROMPT — برگرفته از نسخه بنچمارک ۹۰٪+
-# ترکیب با قابلیت JSON output برای single call
-# Thinking mode فعال — همان چیزی که دقت بالا می‌داد
-# ─────────────────────────────────────────────────────────────
-ANON_SYSTEM_PROMPT = """شما یک «ناشناس‌ساز متون مالی/خبری فارسی» هستید. وظیفه‌تان جایگزینی اسامی خاص و مقادیر عددی با شناسه‌های بی‌معناست.
-
-قبل از دادن پاسخ نهایی، ابتدا در تگ <thinking> گام‌به‌گام تحلیل کنید:
-1. موجودیت‌های موجود در متن را شناسایی کنید (شرکت، شخص، مبلغ، درصد)
-2. ترتیب ظهور آن‌ها را مشخص کنید
-3. نام‌های مختصر/تکرار را به همان توکن اول نسبت دهید
-4. سپس JSON نهایی را بدهید
-
-### قوانین اندیس‌گذاری:
-- شرکت‌ها: company-01, company-02, ... (بر اساس ترتیب ظهور)
-- اشخاص: person-01, person-02, ...
-- اعداد/مبالغ: amount-01, amount-02, ...
-- درصدها: percent-01, percent-02, ...
-- هر بار که همان موجودیت تکرار می‌شود → همان توکن قبلی
-- فقط: company, person, amount, percent  ❌ ممنوع: bank-01, sazman-01, group-XX
-
-### تشخیص شرکت‌ها:
-- با پیشوند: شرکت، بانک، سازمان، گروه، هلدینگ، صندوق، بیمه، پتروشیمی، ملی، سرمایه‌گذاری
-- بدون پیشوند (نام‌های تجاری): ایران خودرو، سایپا، تاپیکو، پارسیان → company-XX
-- نمادهای بورسی: شپنا، وبملت، وتجارت، خودرو، خساپا، شتران، فملی، فولاد، کگل → company-XX
-- نام مختصر = همان توکن: «شرکت پتروشیمی بوعلی سینا» = «بوعلی» → هر دو company-01
-- نام در پرانتز = همان توکن: «شرکت X (Y)» → company-01، و «Y» بعداً → company-01
-- حسابرس/بازرس قانونی هم company-XX است: «وانیا نیک تدبیر» → company-XX
-- سازمان‌های دولتی مشخص: سازمان بورس، سازمان ثبت احوال، سازمان غذا و دارو → company-XX
-- کلمات عمومی ناشناس نشوند: «بانک‌های کشور»، «این بانک»، «12 بانک کشور»، «سه شرکت»
-
-### قوانین amount (مبلغ + واحد = یک موجودیت):
-✅ «100 میلیون دلار» → amount-01   ❌ «amount-01 دلار»
-✅ «283 ریال» → amount-01           ❌ «amount-01 ریال»
-✅ «41.5 همت» → amount-01
-✅ «1,429,349 میلیون ریال» → amount-01
-✅ «812 هزار و 567 نوزاد» → amount-01 (عدد + واحد شمارشی)
-✅ «320,000 تن» → amount-01
-✅ «3.4 میلیارد دلار» → amount-01
-✅ «15 نفر» → amount-01 (تعداد افراد)
-✅ «۱۲ فقره» → amount-01
-
-### قوانین percent (عدد + درصد = یک موجودیت):
-✅ «80 درصد» → percent-01          ❌ «percent-01 درصد»
-✅ «14%» → percent-01
-✅ «منفی 345 درصد» → percent-01    ❌ «منفی percent-01»
-✅ «37 درصدی» → percent-01
-
-### بازه‌ها (یک توکن برای کل بازه):
-✅ «50 الی 70 درصد» → percent-01   ❌ «percent-01 الی percent-02»
-✅ «40–60٪» → percent-01           ❌ «percent-01–percent-02»
-✅ «12 تا 18 ماه» → amount-01      ❌ «amount-01 تا amount-02»
-✅ «یک تا 1.5 میلیون تن» → amount-01
-
-### موارد که باید حفظ شوند (ناشناس نشوند):
-- تاریخ: «30 آذر 1403»، «1403/04/12»، «1404/04/29»
-- مکان: تهران، اصفهان، ایران، خوزستان
-- زمان: «راس ساعت 10:00»، «روز سه شنبه»، «مردادماه»
-- دوره زمانی: «۹ ماهه»، «سال مالی منتهی به»، «سه‌ماهه نخست»
-- عناوین شغلی: مدیرعامل، رئیس کل، بازرس قانونی، حسابرس
-- کلمات عمومی: «19 بانکی»، «12 بانک کشور»، «سه شرکت»، «بانک‌های مورد بررسی»
-- نماد بورسی → با company-XX جایگزین شود (همان شرکت مربوطه)
-
-### فرمت خروجی نهایی (بعد از thinking):
-{
-  "anonymized": "متن ناشناس شده اینجا",
-  "mapping": {"company-01": "نام کامل", "amount-01": "عدد+واحد", ...}
-}"""
-
-
-# ─────────────────────────────────────────────────────────────
-# few-shot examples — از باگ‌های واقعی شناسایی‌شده
-# ─────────────────────────────────────────────────────────────
-FEW_SHOT_EXAMPLES = """
-=== EXAMPLES ===
-
-EXAMPLE 1 — نام مختصر + نام در پرانتز + تکرار:
-INPUT:  شرکت گروه توسعه مالی مهر آیندگان (ومهان) رشد 14 درصدی داشت. سرمایه‌گذاری‌های ومهان به 16 هزار و 495 میلیارد تومان رسید.
-OUTPUT json:
-{"anonymized": "company-01 رشد percent-01 داشت. سرمایه‌گذاری‌های company-01 به amount-01 رسید.", "mapping": {"company-01": "شرکت گروه توسعه مالی مهر آیندگان (ومهان)", "percent-01": "14 درصد", "amount-01": "16 هزار و 495 میلیارد تومان"}}
-KEY: «ومهان» = company-01 (same token, NOT company-02)
-
-EXAMPLE 2 — نام کوتاه متفاوت برای شرکت‌های متفاوت:
-INPUT:  مجمع شرکت پتروشیمی بوعلی سینا برگزار شد و وانیا نیک تدبیر بازرس شد. هزینه بوعلی 100 میلیون دلار بود. تحلیل شپنا (شرکت پالایش نفت اصفهان) نشان می‌دهد EPS به 936 ریال برسد.
-OUTPUT json:
-{"anonymized": "مجمع company-01 برگزار شد و company-02 بازرس شد. هزینه company-01 amount-01 بود. تحلیل company-03 نشان می‌دهد EPS به amount-02 برسد.", "mapping": {"company-01": "شرکت پتروشیمی بوعلی سینا", "company-02": "وانیا نیک تدبیر", "amount-01": "100 میلیون دلار", "company-03": "شرکت پالایش نفت اصفهان", "amount-02": "936 ریال"}}
-KEY: «بوعلی» = company-01. «شپنا» = company-03 (شرکت پالایش نفت اصفهان، موجودیت جداگانه از بوعلی)
-
-EXAMPLE 3 — کلمات عمومی ناشناس نشوند + بانک‌های مشخص:
-INPUT:  دو بانک ملت و پاسارگاد سود 157 و 155 هزار میلیارد ریال داشتند. مجموع بانک‌های مورد بررسی زیان 1388 هزار میلیارد ریال داشتند که 10 درصد افزایش یافت. 12 بانک کشور زیان 336 هزار میلیارد تومانی رقم زدند.
-OUTPUT json:
-{"anonymized": "دو company-01 و company-02 سود amount-01 و amount-02 داشتند. مجموع بانک‌های مورد بررسی زیان amount-03 داشتند که percent-01 افزایش یافت. 12 بانک کشور زیان amount-04 رقم زدند.", "mapping": {"company-01": "بانک ملت", "company-02": "بانک پاسارگاد", "amount-01": "157 هزار میلیارد ریال", "amount-02": "155 هزار میلیارد ریال", "amount-03": "1388 هزار میلیارد ریال", "percent-01": "10 درصد", "amount-04": "336 هزار میلیارد تومانی"}}
-KEY: «بانک‌های مورد بررسی» و «12 بانک کشور» = generic → ناشناس نشوند
-
-EXAMPLE 4 — نام چندکلمه‌ای با مکان + بازه درصد:
-INPUT:  شرکت فولاد مبارکه اصفهان با شرکت ملی نفت ایران قرارداد امضا کرد. شرکت فاما سرمایه را از 8,700 میلیارد ریال به 12,500 میلیارد ریال افزایش می‌دهد. سهم سودهای ارزی 40 الی 60 درصد است.
-OUTPUT json:
-{"anonymized": "company-01 با company-02 قرارداد امضا کرد. company-03 سرمایه را از amount-01 به amount-02 افزایش می‌دهد. سهم سودهای ارزی percent-01 است.", "mapping": {"company-01": "شرکت فولاد مبارکه اصفهان", "company-02": "شرکت ملی نفت ایران", "company-03": "شرکت فاما", "amount-01": "8,700 میلیارد ریال", "amount-02": "12,500 میلیارد ریال", "percent-01": "40 الی 60 درصد"}}
-KEY: «اصفهان» داخل company-01. «شرکت فاما» = company-03. بازه «40 الی 60 درصد» = یک توکن percent-01
-
-EXAMPLE 5 — چند شرکت هم‌نام + مبالغ کوچک + درصد با %:
-INPUT:  شرکت بیمه پارسیان از شرکت سرمایه گذاری پارسیان 1,429,349 میلیون ریال سود شناسایی کرد که 89 ریال برای هر سهم است. جواد شکرخواه مدیرعامل بانک پارسیان گفت سود 41.5 همت شد و 99.99 درصد سهام در اختیار است.
-OUTPUT json:
-{"anonymized": "company-01 از company-02 amount-01 سود شناسایی کرد که amount-02 برای هر سهم است. person-01 مدیرعامل company-03 گفت سود amount-03 شد و percent-01 سهام در اختیار است.", "mapping": {"company-01": "شرکت بیمه پارسیان", "company-02": "شرکت سرمایه گذاری پارسیان", "amount-01": "1,429,349 میلیون ریال", "amount-02": "89 ریال", "person-01": "جواد شکرخواه", "company-03": "بانک پارسیان", "amount-03": "41.5 همت", "percent-01": "99.99 درصد"}}
-KEY: واحد داخل توکن. مبالغ کوچک ریال هم ناشناس می‌شوند.
-
-EXAMPLE 6 — نام مختصر + پادرو + تیپیکو + شپنا:
-INPUT:  شرکت سرمایه‌گذاری دارویی تأمین (تیپیکو) درآمد 681,667 میلیارد ریال داشت. صورت‌های مالی شرکت آسان پادرو 6 میلیارد تومان زیان نشان داد. پادرو 30 میلیارد تومان درآمد کسب کرد. شپنا EPS 936 ریال گزارش داد.
-OUTPUT json:
-{"anonymized": "company-01 درآمد amount-01 داشت. صورت‌های مالی company-02 amount-02 زیان نشان داد. company-02 amount-03 درآمد کسب کرد. company-03 EPS amount-04 گزارش داد.", "mapping": {"company-01": "شرکت سرمایه‌گذاری دارویی تأمین (تیپیکو)", "amount-01": "681,667 میلیارد ریال", "company-02": "شرکت آسان پادرو", "amount-02": "6 میلیارد تومان", "amount-03": "30 میلیارد تومان", "company-03": "شرکت پالایش نفت اصفهان", "amount-04": "936 ریال"}}
-KEY: «تیپیکو» = company-01. «پادرو» = company-02 (همان شرکت آسان پادرو). «شپنا» = company-03 (شرکت پالایش نفت اصفهان)
-
-=== END EXAMPLES ===
-"""
-
-
-# ─────────────────────────────────────────────────────────────
-# ساخت prompt
-# ─────────────────────────────────────────────────────────────
-
-def build_single_call_prompt(text: str, entities: list) -> str:
-    """
-    یک prompt = یک call
-    Thinking mode فعال — برای دقت بالا (نسخه ۹۰٪+)
-    """
-    active = []
-    if "company" in entities: active.append("company-XX (همه سازمان‌ها)")
-    if "person"  in entities: active.append("person-XX (نام اشخاص)")
-    if "amount"  in entities: active.append("amount-XX (اعداد+واحد)")
-    if "percent" in entities: active.append("percent-XX (درصدها)")
-
-    mapping_hints = []
-    if "person"  in entities: mapping_hints.append('"person-XX": "نام کامل"')
-    if "company" in entities: mapping_hints.append('"company-XX": "نام کامل سازمان"')
-    if "amount"  in entities: mapping_hints.append('"amount-XX": "عدد + واحد کامل"')
-    if "percent" in entities: mapping_hints.append('"percent-XX": "عدد + درصد/% کامل"')
-
-    return f"""{FEW_SHOT_EXAMPLES}
-
-موجودیت‌های فعال: {' | '.join(active)}
-
-متن زیر را ناشناس کن. ابتدا در <thinking> تحلیل کن، سپس JSON نهایی بده:
-
-فرمت خروجی نهایی (بعد از </thinking>):
-{{
-  "anonymized": "متن ناشناس شده",
-  "mapping": {{ {", ".join(mapping_hints)} }}
-}}
-
-متن:
-{text}"""
-
-
-def build_verification_prompt(
-    original_text: str,
-    anonymized_text: str,
-    current_mapping: Dict[str, str],
-    entities: list
-) -> str:
-    """
-    پاس تأیید: متن اصلی و ناشناس‌شده رو مقایسه کن
-    موجودیت‌های جامانده رو پیدا کن
-    """
-    active = []
-    if "company" in entities: active.append("company-XX (سازمان/شرکت/بانک)")
-    if "person"  in entities: active.append("person-XX (نام اشخاص)")
-    if "amount"  in entities: active.append("amount-XX (عدد+واحد)")
-    if "percent" in entities: active.append("percent-XX (درصد)")
-
-    # لیست توکن‌های فعلی
-    existing_tokens = ""
-    if current_mapping:
-        existing_lines = [f"  {tok} → {val}" for tok, val in sorted(current_mapping.items())]
-        existing_tokens = "\n".join(existing_lines)
-
-    # بالاترین شماره هر نوع برای ادامه شماره‌گذاری
-    next_numbers = {}
-    for etype in entities:
-        nums = [int(t.split("-")[1]) for t in current_mapping.keys() if t.startswith(f"{etype}-")]
-        next_numbers[etype] = max(nums) + 1 if nums else 1
-
-    next_info = ", ".join(f"{e}: از {next_numbers[e]:02d}" for e in entities if e in next_numbers)
-
-    return f"""تو یک بازبین ناشناس‌سازی هستی. متن اصلی و نسخه ناشناس‌شده رو مقایسه کن.
-
-موجودیت‌های فعال: {' | '.join(active)}
-
-=== توکن‌های فعلی ===
-{existing_tokens}
-
-=== متن اصلی ===
-{original_text}
-
-=== متن ناشناس‌شده فعلی ===
-{anonymized_text}
-
-وظیفه: متن اصلی و ناشناس‌شده رو کلمه‌به‌کلمه مقایسه کن.
-- هر نام شخص، نام شرکت/سازمان/بانک، مبلغ+واحد، و درصد که هنوز در متن ناشناس‌شده باقی مانده (تبدیل به توکن نشده) را پیدا کن.
-- اگر نام مختصر یکی از توکن‌های موجود است → از همان توکن استفاده کن.
-- شماره‌گذاری توکن‌های جدید: {next_info}
-
-مهم:
-- تاریخ، مکان، عنوان شغلی، کلمات عمومی (مثل «بانک‌ها»، «شرکت‌ها») ناشناس نشوند.
-- واحد مبلغ داخل توکن: ✅ amount-XX (شامل عدد+واحد) ❌ amount-XX ریال
-- واحد درصد داخل توکن: ✅ percent-XX (شامل عدد+درصد) ❌ percent-XX درصد
-
-خروجی: فقط JSON (بدون توضیح):
-{{
-  "fixed_text": "متن ناشناس‌شده اصلاح‌شده با توکن‌های جدید",
-  "new_mapping": {{"token": "مقدار اصلی"}}
-}}
-
-اگر هیچ موجودیتی جا نمانده:
-{{
-  "fixed_text": "",
-  "new_mapping": {{}}
-}}"""
-
-
-def build_analysis_prompt(anonymized_text: str, analysis_prompt: str, entities: list) -> str:
-    tokens = []
-    if "person"  in entities: tokens.append("person-XX")
-    if "company" in entities: tokens.append("company-XX")
-    if "amount"  in entities: tokens.append("amount-XX")
-    if "percent" in entities: tokens.append("percent-XX")
-
-    return f"""متن ناشناس‌سازی شده:
-{anonymized_text}
-
-دستورات:
-{analysis_prompt}
-
-قوانین:
-- فقط از توکن‌های موجود استفاده کن: {', '.join(tokens)}
-- هیچ کلمه‌ای قبل/بعد از توکن‌ها اضافه نکن
-- توکن جدید ایجاد نکن"""
-
-
-# ─────────────────────────────────────────────────────────────
-# توابع کمکی
-# ─────────────────────────────────────────────────────────────
-
-def strip_thinking(text: str) -> str:
-    """
-    حذف بلوک‌های think/thinking از خروجی
-    thinking mode فعال است — برای دقت استفاده می‌شود ولی در خروجی نهایی نمی‌آید
-    """
-    if not text:
-        return text
-    # تگ‌های Qwen3 thinking
-    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
-    # تگ‌های نسخه قدیمی
-    text = re.sub(r"<thinking>.*?</thinking>", "", text, flags=re.DOTALL)
-    return text.strip()
-
-
-def parse_json_response(raw: str) -> dict:
-    """parse JSON مقاوم — thinking block + markdown fence"""
-    raw = strip_thinking(raw)
-    raw = re.sub(r"```(?:json)?", "", raw).replace("```", "").strip()
-    start = raw.find("{")
-    end   = raw.rfind("}") + 1
-    if start == -1 or end == 0:
-        raise ValueError("JSON یافت نشد")
-    return json.loads(raw[start:end])
-
-
-def post_deepinfra(prompt: str, system: str, max_tokens: int = 6000, timeout: int = 60) -> str:
-    """
-    DeepInfra Qwen3-14B
-    Thinking mode فعال — برای دقت بالا
-    timeout = (connect, read) — سریع شناسایی مشکل اتصال
-    """
-    api_key = os.getenv("DEEPINFRA_API_KEY")
-    if not api_key:
-        raise ValueError("DEEPINFRA_API_KEY موجود نیست")
-
-    # connect: 10s | read: بقیه timeout
-    connect_timeout = 10
-    read_timeout    = max(timeout - connect_timeout, 30)
-
-    resp = requests.post(
-        ANON_API_URL,
-        headers={
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type":  "application/json"
-        },
-        json={
-            "model":       ANON_MODEL,
-            "messages":    [
-                {"role": "system", "content": system},
-                {"role": "user",   "content": prompt}
-            ],
-            "max_tokens":  max_tokens,
-            "temperature": 0.3,
-            "top_p":       0.9,
-        },
-        timeout=(connect_timeout, read_timeout)
-    )
-
-    if resp.status_code != 200:
-        raise Exception(f"DeepInfra {resp.status_code}: {resp.text[:300]}")
-
-    content = resp.json()["choices"][0]["message"]["content"]
-    if "<think>" in content or "<thinking>" in content:
-        thinking = re.search(r"<think(?:ing)?>(.*?)</think(?:ing)?>", content, re.DOTALL)
-        if thinking:
-            logger.info(f"🧠 Thinking ({len(thinking.group(1))} chars)...")
-
-    return strip_thinking(content)
-
-
-# ─────────────────────────────────────────────────────────────
-# تخمین هوشمند max_tokens و Chunking
-# ─────────────────────────────────────────────────────────────
-
-# آستانه‌های chunking
-CHUNK_MAX_CHARS    = 900       # حداکثر کاراکتر هر chunk
-CHUNK_MAX_ENTITIES = 12        # حداکثر موجودیت تخمینی هر chunk
-LONG_TEXT_THRESHOLD = 1200     # بالای این → chunking فعال
-
-def estimate_entity_count(text: str) -> int:
-    """تخمین تعداد موجودیت‌ها بر اساس نشانه‌های متن"""
-    markers = 0
-    # شرکت‌ها
-    markers += len(re.findall(r'(?:شرکت|بانک|سازمان|گروه|هلدینگ|صندوق|بیمه|پتروشیمی|سرمایه\s*گذاری)\s+', text))
-    # اشخاص (نام و نام خانوادگی فارسی)
-    markers += len(re.findall(r'(?:آقای|خانم|دکتر|مهندس|حجت\s*الاسلام)\s+', text))
-    markers += len(re.findall(r'[ء-ی]+\s+[ء-ی]+(?:‌?زاده|‌?پور|‌?نژاد|‌?فر)', text))
-    # مبالغ
-    markers += len(re.findall(r'[\d۰-۹][,،\d۰-۹]*(?:\.\d+)?\s*(?:میلیارد|میلیون|هزار|همت|تومان|ریال|دلار|یورو)', text))
-    markers += len(re.findall(r'[\d۰-۹][,،\d۰-۹]*\s*(?:نفر|تن|دستگاه|واحد|فقره)', text))
-    # درصدها
-    markers += len(re.findall(r'[\d۰-۹]+(?:\.\d+)?\s*(?:درصد|%|٪)', text))
-    return max(markers, 1)
-
-
-def estimate_max_tokens(text: str) -> int:
-    """محاسبه max_tokens بر اساس طول متن و تعداد موجودیت تخمینی"""
-    entity_est = estimate_entity_count(text)
-    text_len   = len(text)
-
-    # thinking ≈ 1500-3000 tok + JSON output ≈ text_len*0.8 + mapping ≈ entity*80
-    base_thinking = 2500
-    json_output   = int(text_len * 0.7)
-    mapping_space = entity_est * 100
-    buffer        = 1500
-
-    tokens = base_thinking + json_output + mapping_space + buffer
-    # حداقل 6000، حداکثر 16000
-    return max(6000, min(tokens, 16000))
-
-
-def split_text_to_chunks(text: str, max_chars: int = CHUNK_MAX_CHARS) -> List[str]:
-    """
-    تقسیم متن به chunk‌های کوچکتر بر اساس پاراگراف و جمله
-    """
-    # اول تقسیم بر اساس خط جدید
-    paragraphs = re.split(r'\n+', text)
-    paragraphs = [p.strip() for p in paragraphs if p.strip()]
-
-    # اگر فقط یک پاراگراف بلند داریم، بر اساس نقطه تقسیم کن
-    if len(paragraphs) == 1 and len(paragraphs[0]) > max_chars:
-        sentences = re.split(r'(?<=[.،؛!؟\n])\s+', paragraphs[0])
-        paragraphs = [s.strip() for s in sentences if s.strip()]
-
-    chunks = []
-    current_chunk = ""
-
-    for para in paragraphs:
-        # اگه پاراگراف خودش بلندتر از حد هست
-        if len(para) > max_chars:
-            if current_chunk:
-                chunks.append(current_chunk.strip())
-                current_chunk = ""
-            # تقسیم بر اساس جمله
-            sents = re.split(r'(?<=[.،؛!؟])\s+', para)
-            sub_chunk = ""
-            for s in sents:
-                if len(sub_chunk) + len(s) + 1 <= max_chars:
-                    sub_chunk += (" " if sub_chunk else "") + s
-                else:
-                    if sub_chunk:
-                        chunks.append(sub_chunk.strip())
-                    sub_chunk = s
-            if sub_chunk:
-                chunks.append(sub_chunk.strip())
-        elif len(current_chunk) + len(para) + 1 <= max_chars:
-            current_chunk += ("\n" if current_chunk else "") + para
-        else:
-            if current_chunk:
-                chunks.append(current_chunk.strip())
-            current_chunk = para
-
-    if current_chunk:
-        chunks.append(current_chunk.strip())
-
-    # اگر هنوز خالیه، کل متن رو برگردون
-    if not chunks:
-        chunks = [text]
-
-    return chunks
-
-
-def merge_chunk_mappings(
-    chunk_results: List[Tuple[str, Dict]],
-    entities: List[str]
-) -> Tuple[str, Dict]:
-    """
-    ادغام نتایج chunk‌ها + بازشماره‌گذاری توکن‌ها به صورت سراسری
-    """
-    merged_text = ""
-    merged_mapping = {}
-    global_counters = {e: 0 for e in entities}
-
-    for chunk_text, chunk_mapping in chunk_results:
-        if not chunk_mapping:
-            merged_text += ("\n" if merged_text else "") + chunk_text
-            continue
-
-        # نگاشت توکن‌های محلی chunk به شماره سراسری
-        local_to_global = {}
-
-        # مرتب‌سازی بر اساس ترتیب ظاهر شدن در متن
-        sorted_tokens = sorted(
-            chunk_mapping.keys(),
-            key=lambda t: (t.split("-")[0], int(t.split("-")[1]))
-        )
-
-        for local_token in sorted_tokens:
-            original_value = chunk_mapping[local_token]
-            etype = local_token.split("-")[0]
-
-            # بررسی آیا این مقدار قبلاً در mapping سراسری هست
-            existing_token = None
-            for g_token, g_value in merged_mapping.items():
-                if g_value == original_value and g_token.startswith(etype):
-                    existing_token = g_token
-                    break
-
-            if existing_token:
-                local_to_global[local_token] = existing_token
-            else:
-                global_counters[etype] += 1
-                new_token = f"{etype}-{global_counters[etype]:02d}"
-                local_to_global[local_token] = new_token
-                merged_mapping[new_token] = original_value
-
-        # جایگزینی توکن‌های محلی با سراسری در متن chunk
-        renamed_text = chunk_text
-        # از بلندترین شروع کن تا تداخل نباشه
-        for local_token in sorted(local_to_global.keys(), key=len, reverse=True):
-            global_token = local_to_global[local_token]
-            if local_token != global_token:
-                renamed_text = renamed_text.replace(local_token, global_token)
-
-        merged_text += ("\n" if merged_text else "") + renamed_text
-
-    return merged_text, merged_mapping
-
-
-# ─────────────────────────────────────────────────────────────
-# کلاس اصلی
-# ─────────────────────────────────────────────────────────────
-class AnonymizerAdvanced:
-
-    def __init__(
-        self,
-        llm_provider: str = "chatgpt",
-        llm_model:    str = None,
-        entities_to_anonymize: List[str] = None
-    ):
-        self.llm_provider = llm_provider
-        self.llm_model    = llm_model
-        self.entities_to_anonymize = entities_to_anonymize or ["person", "company", "amount", "percent"]
-        self.mapping_table:   Dict[str, str] = {}
-        self.reverse_mapping: Dict[str, str] = {}
-        self._create_llm_sender()
-        logger.info(f"✅ Anonymizer — {llm_provider}")
-
-    # ── LLM sender (تحلیل) ──────────────────────────────────
-
-    def _create_llm_sender(self):
-        try:
-            key_map = {
-                "chatgpt":   os.getenv("OPENAI_API_KEY"),
-                "grok":      os.getenv("XAI_API_KEY"),
-                "deepinfra": os.getenv("DEEPINFRA_API_KEY"),
-            }
-            self.llm_sender = create_llm_sender(
-                provider=self.llm_provider,
-                api_key=key_map.get(self.llm_provider),
-                model=self.llm_model
-            )
-            logger.info(f"✅ LLM Sender: {self.llm_provider} — {self.llm_sender.model}")
-        except Exception as e:
-            logger.error(f"❌ LLM Sender خطا: {e}")
-            self.llm_sender = create_llm_sender("chatgpt")
-
-    def set_llm_provider(self, provider: str, model: str = None, entities: List[str] = None):
-        self.llm_provider = provider
-        self.llm_model    = model
-        if entities is not None:
-            self.entities_to_anonymize = entities
-        self._create_llm_sender()
-
-    # ── ناشناس‌سازی — thinking فعال، retry + chunking + verify ──
-
-    def anonymize(self, text: str) -> Tuple[str, Dict]:
-        """
-        ناشناس‌سازی هوشمند:
-        1. متن کوتاه → single call
-        2. متن طولانی → chunking
-        3. هر call با retry
-        4. پاس تأیید (verification) برای پیدا کردن موجودیت‌های جامانده
-        """
-        if not self.entities_to_anonymize:
-            return text, {}
-
-        text_len   = len(text)
-        entity_est = estimate_entity_count(text)
-
-        logger.info(f"🧠 ورودی: {text_len} char | ~{entity_est} موجودیت تخمینی")
-
-        # ── مرحله ۱: ناشناس‌سازی اولیه ──
-        needs_chunking = (
-            text_len > LONG_TEXT_THRESHOLD or
-            entity_est > CHUNK_MAX_ENTITIES
-        )
-
-        if needs_chunking:
-            anon_text, mapping = self._anonymize_chunked(text)
-        else:
-            anon_text, mapping = self._anonymize_single(text)
-
-        # ── مرحله ۲: پاس تأیید ──
-        if anon_text and anon_text.strip() != text.strip():
-            anon_text, mapping = self._verification_pass(text, anon_text, mapping)
-
-        return anon_text, mapping
-
-    def _verification_pass(
-        self,
-        original_text: str,
-        anonymized_text: str,
-        current_mapping: Dict[str, str]
-    ) -> Tuple[str, Dict]:
-        """
-        پاس تأیید: مقایسه متن اصلی با ناشناس‌شده برای یافتن موجودیت‌های جامانده
-        """
-        found_count = len(current_mapping)
-        entity_est  = estimate_entity_count(original_text)
-
-        # تصمیم: آیا verify لازمه؟
-        # ۱) تخمین بیشتر از یافته‌ها → احتمالاً جا مونده
-        # ۲) متن طولانی → احتمال miss بیشتر
-        # ۳) تعداد یافته‌ها صفر → verify بی‌فایده (مشکل جدی‌تره)
-        needs_verify = (
-            found_count > 0 and
-            (entity_est > found_count + 1 or len(original_text) > 500)
-        )
-
-        if not needs_verify:
-            logger.info(f"  ⏭️ Verify skip: {found_count} found, ~{entity_est} est, {len(original_text)} char")
-            return anonymized_text, current_mapping
-
-        logger.info(f"  🔍 Verification Pass: {found_count} یافته، ~{entity_est} تخمینی")
-
-        try:
-            prompt = build_verification_prompt(
-                original_text, anonymized_text,
-                current_mapping, self.entities_to_anonymize
-            )
-
-            raw = post_deepinfra(
-                prompt,
-                "You are a verification agent. Compare texts and find missed entities. Output ONLY valid JSON.",
-                max_tokens=estimate_max_tokens(original_text),
-                timeout=60
-            )
-
-            result = parse_json_response(raw)
-            fixed_text  = result.get("fixed_text", "")
-            new_mapping = result.get("new_mapping", {})
-
-            # اگه مدل گفت هیچی جا نمونده
-            if not fixed_text or not new_mapping:
-                logger.info(f"  ✅ Verify: هیچ موجودیت جامانده‌ای یافت نشد")
-                return anonymized_text, current_mapping
-
-            # اعتبارسنجی: fixed_text نباید خیلی متفاوت باشه
-            # بررسی: آیا توکن‌های قبلی هنوز هستن؟
-            old_tokens = set(re.findall(r'(?:company|person|amount|percent)-\d+', anonymized_text))
-            new_tokens = set(re.findall(r'(?:company|person|amount|percent)-\d+', fixed_text))
-
-            # اگه توکن‌های قبلی رو از دست داده → reject
-            lost_tokens = old_tokens - new_tokens
-            if len(lost_tokens) > len(old_tokens) * 0.3:
-                logger.warning(f"  ⚠️ Verify reject: {len(lost_tokens)} توکن قبلی حذف شده")
-                return anonymized_text, current_mapping
-
-            # ادغام mapping
-            merged_mapping = dict(current_mapping)
-            added_count = 0
-            for token, value in new_mapping.items():
-                if token not in merged_mapping and re.match(r'(company|person|amount|percent)-\d+', token):
-                    merged_mapping[token] = value
-                    added_count += 1
-
-            if added_count == 0:
-                logger.info(f"  ✅ Verify: mapping جدیدی اضافه نشد")
-                return anonymized_text, current_mapping
-
-            # پاک‌سازی: حذف توکن‌هایی که در متن نیستن
-            final_tokens = set(re.findall(r'(?:company|person|amount|percent)-\d+', fixed_text))
-            merged_mapping = {k: v for k, v in merged_mapping.items() if k in final_tokens}
-
-            self.mapping_table   = merged_mapping
-            self.reverse_mapping = {v: k for k, v in merged_mapping.items()}
-
-            logger.info(f"  ✅ Verify: +{added_count} موجودیت جدید | کل: {len(merged_mapping)}")
-            return fixed_text, merged_mapping
-
-        except Exception as e:
-            logger.warning(f"  ⚠️ Verify fail: {e} — نتیجه اولیه حفظ می‌شود")
-            return anonymized_text, current_mapping
-
-    def _anonymize_single(self, text: str, max_retries: int = 2, is_chunk: bool = False) -> Tuple[str, Dict]:
-        """
-        ناشناس‌سازی تک‌تکه با retry سریع
-        is_chunk=True → بدون fallback به chunking (جلوگیری از حلقه بازگشتی)
-        """
-        base_max_tokens = estimate_max_tokens(text)
-
-        for attempt in range(max_retries):
-            # افزایش ملایم tokens — timeout ثابت و کوتاه
-            current_max_tokens = min(base_max_tokens + (attempt * 1500), 16000)
-            current_timeout    = 60 + (attempt * 30)  # 60s, 90s
-
-            logger.info(f"  🔄 تلاش {attempt+1}/{max_retries} | max_tokens={current_max_tokens} | timeout={current_timeout}s")
-
-            prompt = build_single_call_prompt(text, self.entities_to_anonymize)
-
-            try:
-                raw = post_deepinfra(
-                    prompt, ANON_SYSTEM_PROMPT,
-                    max_tokens=current_max_tokens,
-                    timeout=current_timeout
-                )
-                logger.info(f"  ✅ پاسخ: {len(raw)} کاراکتر")
-
-                result = parse_json_response(raw)
-                anonymized_text    = result.get("anonymized", "")
-                self.mapping_table = result.get("mapping", {})
-
-                # ── بررسی کیفیت: آیا واقعاً ناشناس شده؟ ──
-                if anonymized_text.strip() == text.strip():
-                    logger.warning(f"  ⚠️ متن تغییر نکرده! (attempt {attempt+1})")
-                    if attempt < max_retries - 1:
-                        time.sleep(0.5)
-                        continue
-                    # آخرین تلاش fail شد
-                    if not is_chunk:
-                        logger.warning("  ⚠️ retry fail → chunking")
-                        return self._anonymize_chunked(text)
-                    else:
-                        return text, {}  # در حالت chunk: متن اصلی برگرده
-
-                # آیا mapping خالی هست ولی توکن در متن هست؟
-                tokens_in_text = re.findall(r'(?:company|person|amount|percent)-\d+', anonymized_text)
-                if tokens_in_text and not self.mapping_table:
-                    logger.warning(f"  ⚠️ mapping خالی ولی {len(tokens_in_text)} توکن در متن!")
-                    if attempt < max_retries - 1:
-                        time.sleep(0.5)
-                        continue
-
-                self._clean_orphan_tokens(anonymized_text)
-                self._fix_mapping()
-                self.reverse_mapping = {v: k for k, v in self.mapping_table.items()}
-
-                for etype in self.entities_to_anonymize:
-                    found = sorted(set(re.findall(rf'{etype}-\d+', anonymized_text)))
-                    if found:
-                        logger.info(f"    {etype}: {found}")
-
-                logger.info(f"  ✅ mapping: {len(self.mapping_table)} موجودیت")
-                return anonymized_text, self.mapping_table
-
-            except json.JSONDecodeError as e:
-                logger.warning(f"  ⚠️ JSON خطا (attempt {attempt+1}): {e}")
-                if attempt < max_retries - 1:
-                    time.sleep(0.5)
-                    continue
-                # آخرین تلاش: fallback
-                if not is_chunk:
-                    logger.info("  🔄 fallback دو-call...")
-                    try:
-                        return self._anonymize_fallback(text)
-                    except Exception:
-                        return self._anonymize_chunked(text)
-                return text, {}
-
-            except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
-                logger.warning(f"  ⏳ اتصال/Timeout (attempt {attempt+1}): {type(e).__name__}")
-                if attempt < max_retries - 1:
-                    time.sleep(1)
-                    continue
-                # timeout → chunking فقط اگه chunk نیستیم
-                if not is_chunk:
-                    return self._anonymize_chunked(text)
-                return text, {}
-
-            except Exception as e:
-                logger.error(f"  ❌ Exception (attempt {attempt+1}): {e}")
-                if attempt < max_retries - 1:
-                    time.sleep(0.5)
-                    continue
-                if is_chunk:
-                    return text, {}
-                raise
-
-        # اگه هیچ‌کدوم جواب نداد
-        if not is_chunk:
-            logger.warning("  ⚠️ همه retry‌ها fail → chunking")
-            return self._anonymize_chunked(text)
-        return text, {}
-
-    def _anonymize_chunked(self, text: str) -> Tuple[str, Dict]:
-        """
-        تقسیم متن به chunk و ناشناس‌سازی جداگانه + ادغام
-        هر chunk فقط ۱ retry و بدون بازگشت به chunking
-        """
-        chunks = split_text_to_chunks(text, max_chars=CHUNK_MAX_CHARS)
-        logger.info(f"  📦 Chunking: {len(chunks)} قطعه از {len(text)} کاراکتر")
-
-        chunk_results = []
-        for i, chunk in enumerate(chunks):
-            logger.info(f"  📦 Chunk {i+1}/{len(chunks)}: {len(chunk)} char")
-
-            # ریست mapping برای هر chunk
-            self.mapping_table   = {}
-            self.reverse_mapping = {}
-
-            try:
-                # is_chunk=True → بدون fallback بازگشتی به chunking
-                anon_chunk, mapping = self._anonymize_single(chunk, max_retries=2, is_chunk=True)
-                chunk_results.append((anon_chunk, mapping))
-            except Exception as e:
-                logger.error(f"  ❌ Chunk {i+1} fail: {e} — متن اصلی حفظ می‌شود")
-                chunk_results.append((chunk, {}))
-
-            time.sleep(0.3)
-
-        # ادغام chunk‌ها
-        merged_text, merged_mapping = merge_chunk_mappings(
-            chunk_results, self.entities_to_anonymize
-        )
-
-        self.mapping_table   = merged_mapping
-        self.reverse_mapping = {v: k for k, v in merged_mapping.items()}
-
-        logger.info(f"  ✅ Chunked: {len(merged_mapping)} موجودیت از {len(chunks)} chunk")
-        return merged_text, merged_mapping
-
-    def _anonymize_fallback(self, text: str) -> Tuple[str, Dict]:
-        """Fallback: دو call — اگر JSON parse شکست خورد"""
-        logger.info("🔄 fallback: دو call...")
-
-        rules_fa = (
-            "متن زیر را ناشناس کن.\n"
-            "- company-XX: نام کامل سازمان (بانک/شرکت/بیمه/پتروشیمی/...) — نام مختصر = همان توکن\n"
-            "- person-XX: نام کامل اشخاص\n"
-            "- amount-XX: عدد + واحد با هم\n"
-            "- percent-XX: عدد + درصد با هم (بازه هم یک توکن)\n"
-            "کلمات عمومی را دست نزن. فقط متن ناشناس شده."
-        )
-
-        prompt1 = f"{FEW_SHOT_EXAMPLES}\n{rules_fa}\n\nمتن:\n{text}"
-        anonymized_text = post_deepinfra(prompt1, ANON_SYSTEM_PROMPT, max_tokens=4096, timeout=60)
-
-        hints = []
-        if "person"  in self.entities_to_anonymize: hints.append('"person-XX": "نام کامل"')
-        if "company" in self.entities_to_anonymize: hints.append('"company-XX": "نام کامل سازمان"')
-        if "amount"  in self.entities_to_anonymize: hints.append('"amount-XX": "عدد+واحد"')
-        if "percent" in self.entities_to_anonymize: hints.append('"percent-XX": "عدد+درصد"')
-
-        prompt2 = (
-            f"متن اصلی: {text}\n"
-            f"متن ناشناس: {anonymized_text}\n\n"
-            f"فقط JSON mapping:\n{{ {', '.join(hints)} }}"
-        )
-
-        try:
-            raw2 = post_deepinfra(prompt2, "Output ONLY valid JSON. No explanation.", max_tokens=2048, timeout=45)
-            self.mapping_table = parse_json_response(raw2)
-        except Exception:
-            self._extract_mapping_fallback(text, anonymized_text)
-
-        self._clean_orphan_tokens(anonymized_text)
-        self._fix_mapping()
-        self.reverse_mapping = {v: k for k, v in self.mapping_table.items()}
-        return anonymized_text, self.mapping_table
-
-    # ── پاک‌سازی mapping ────────────────────────────────────
-
-    def _clean_orphan_tokens(self, anonymized_text: str):
-        to_remove = [t for t in self.mapping_table if t not in anonymized_text]
-        for t in to_remove:
-            logger.info(f"  🗑️ توکن اضافی: {t}")
-            del self.mapping_table[t]
-
-    def _fix_mapping(self):
-        """اطمینان از صحت مقادیر — فقط percent بدون واحد"""
-        for token, value in list(self.mapping_table.items()):
-            val = str(value).strip()
-            if token.startswith("percent-") and not re.search(r"(درصد|%|٪|درصدی)", val):
-                self.mapping_table[token] = f"{val} درصد"
-                logger.info(f"  اصلاح {token}: '{val}' → '{val} درصد'")
-
-    # ── fallback mapping با regex ────────────────────────────
-
-    def _extract_mapping_fallback(self, original: str, anonymized: str):
-        pats: Dict[str, str] = {}
-        if "person"  in self.entities_to_anonymize:
-            pats["person"]  = r'(?<![ء-یa-zA-Z])[ء-ی]+\s+[ء-ی]+(?:\s+[ء-ی]+)*(?![ء-یa-zA-Z])'
-        if "company" in self.entities_to_anonymize:
-            pats["company"] = (
-                r'(?:(?:شرکت|بانک|سازمان|گروه|هلدینگ|صندوق|بیمه|پتروشیمی|ملی|سرمایه\s*گذاری)\s+)'
-                r'[ء-ی][ء-ی\s]+(?:\([ء-یa-zA-Z۰-۹]+\))?'
-            )
-        if "amount"  in self.entities_to_anonymize:
-            pats["amount"]  = r'[\d۰-۹][,،\d۰-۹]*(?:\.\d+)?\s*(?:هزار\s+و\s+\d+|هزار|میلیون|میلیارد|همت)?\s*(?:میلیارد|میلیون|هزار|تومان|ریال|دلار|دستگاه|تن)?'
-        if "percent" in self.entities_to_anonymize:
-            pats["percent"] = r'[\d۰-۹]+(?:\.\d+)?\s*(?:الی|تا)?\s*(?:[\d۰-۹]+(?:\.\d+)?\s*)?(?:درصد|%|٪|درصدی)'
-
-        orig_entities = {
-            etype: [m.strip() for m in re.findall(pat, original) if m.strip()]
-            for etype, pat in pats.items()
-        }
-
-        for etype in self.entities_to_anonymize:
-            tokens = sorted(set(re.findall(rf'{etype}-(\d+)', anonymized)), key=int)
-            values = orig_entities.get(etype, [])
-            for tok_num in tokens:
-                token = f"{etype}-{tok_num}"
-                idx   = int(tok_num) - 1
-                self.mapping_table[token] = values[idx] if idx < len(values) else (values[-1] if values else token)
-
-        self.reverse_mapping = {v: k for k, v in self.mapping_table.items()}
-        logger.info(f"✅ Fallback mapping: {len(self.mapping_table)} موجودیت")
-
-    # ── تحلیل LLM ───────────────────────────────────────────
-
-    def analyze_with_llm(self, anonymized_text: str, analysis_prompt: str = None) -> str:
-        logger.info(f"🤖 {self.llm_provider.upper()} تحلیل...")
-
-        if not analysis_prompt or not analysis_prompt.strip():
-            return "⚠️ هیچ دستور تحلیل داده نشده است"
-
-        prompt = build_analysis_prompt(anonymized_text, analysis_prompt, self.entities_to_anonymize)
-        try:
-            response = self.llm_sender.send(prompt, lang="fa", temperature=0.2, max_tokens=2000)
-            logger.info(f"✅ {self.llm_provider.upper()}: {len(response)} کاراکتر")
-            return response
-        except Exception as e:
-            logger.error(f"❌ {self.llm_provider.upper()} Exception: {e}")
-            return f"❌ خطا: {str(e)}"
-
-    # ── بازگردانی ────────────────────────────────────────────
-
-    def restore_text(self, anonymized_text: str) -> str:
-        logger.info("🔄 بازگردانی...")
-
-        if not self.mapping_table:
-            return anonymized_text
-
-        restored = self._normalize_tokens(anonymized_text)
-        count = 0
-
-        for placeholder, original in sorted(
-            self.mapping_table.items(), key=lambda x: len(x[0]), reverse=True
-        ):
-            if placeholder in restored:
-                restored = restored.replace(placeholder, original)
-                count += 1
-                logger.info(f"  ✅ {placeholder} → {original[:40]}")
-            else:
-                logger.warning(f"  ⚠️ {placeholder} یافت نشد")
-
-        logger.info(f"✅ {count}/{len(self.mapping_table)} بازگردانی شد")
-
-        if count < len(self.mapping_table):
-            restored = self._restore_with_regex(restored)
-
-        return restored
-
-    def _normalize_tokens(self, text: str) -> str:
-        normalized = text
-        unicode_hyphens = r'[\u2010\u2011\u2012\u2013\u2014\u2212]'
-        for etype in self.entities_to_anonymize:
-            normalized = re.sub(rf'{etype}{unicode_hyphens}(\d+)', rf'{etype}-\1', normalized)
-            normalized = re.sub(rf'{etype}\s+-\s+(\d+)',            rf'{etype}-\1', normalized)
-            normalized = re.sub(rf'({etype}-\d+)([ء-ی])',           r'\1 \2',       normalized)
-            normalized = re.sub(rf'({etype}-\d+)([،؛:.!?])',        r'\1 \2',       normalized)
-        return normalized
-
-    def _restore_with_regex(self, text: str) -> str:
-        restored = text
-        for placeholder, original in self.mapping_table.items():
-            if placeholder not in restored:
-                continue
-            etype, num = placeholder.split("-")
-            if re.search(rf'{etype}\s*-\s*{num}', restored):
-                restored = re.sub(rf'{etype}\s*-\s*{num}', original, restored)
-                logger.info(f"  ✅ regex: {placeholder} → {original[:40]}")
-        return restored
-
-    def get_mapping_table_md(self) -> str:
-        if not self.mapping_table:
-            return "### 📋 جدول نگاشت\n\nهیچ موجودیتی شناسایی نشد"
-        table = "### 📋 جدول نگاشت\n\n| شناسه | متن اصلی |\n|-------|----------|\n"
-        for token, original in sorted(self.mapping_table.items()):
-            table += f"| **{token}** | {original} |\n"
-        return table
-
-
-# ─────────────────────────────────────────────────────────────
-# متغیر سراسری
-# ─────────────────────────────────────────────────────────────
-anonymizer: Optional[AnonymizerAdvanced] = None
-
-
-# ─────────────────────────��───────────────────────────────────
-# تابع اصلی
-# ─────────────────────────────────────────────────────────────
-def process(
-    input_text: str,
-    analysis_prompt: str,
-    llm_provider: str,
-    llm_model: str,
-    anonymize_all: bool,
-    anonymize_person: bool,
-    anonymize_company: bool,
-    anonymize_amount: bool,
-    anonymize_percent: bool
-):
-    global anonymizer
-
-    if not input_text.strip():
-        return "", "", "", ""
-
-    entities = ["person", "company", "amount", "percent"] if anonymize_all else [
-        e for e, flag in [
-            ("person",  anonymize_person),
-            ("company", anonymize_company),
-            ("amount",  anonymize_amount),
-            ("percent", anonymize_percent),
-        ] if flag
-    ]
-
-    if not entities:
-        return "", "❌ لطفاً حداقل یک موجودیت انتخاب کنید", "", ""
-
-    if not anonymizer:
-        anonymizer = AnonymizerAdvanced(
-            llm_provider=llm_provider,
-            llm_model=llm_model,
-            entities_to_anonymize=entities
-        )
-    else:
-        anonymizer.set_llm_provider(llm_provider, llm_model, entities)
-        anonymizer.mapping_table   = {}
-        anonymizer.reverse_mapping = {}
-
-    try:
-        logger.info("=" * 60)
-        logger.info(f"🧠 Qwen3-14B (thinking ON | single-call)")
-        logger.info(f"🤖 تحلیل: {llm_provider} ({llm_model})")
-        logger.info(f"🎯 موجودیت‌ها: {entities}")
-        logger.info("=" * 60)
-
-        anon_text, _ = anonymizer.anonymize(input_text)
-
-        has_analysis = bool(analysis_prompt and analysis_prompt.strip())
-        llm_response = anonymizer.analyze_with_llm(anon_text, analysis_prompt) if has_analysis \
-                       else "⚠️ هیچ دستور تحلیل داده نشده است"
-
-        source   = llm_response if has_analysis else anon_text
-        restored = anonymizer.restore_text(source)
-
-        return restored, llm_response, anon_text, anonymizer.get_mapping_table_md()
-
-    except Exception as e:
-        logger.error(f"❌ خطا: {e}", exc_info=True)
-        return "", f"❌ خطا: {str(e)}", "", ""
-
-
-def clear_all():
-    return "", "", "", "", "", "", True, False, False, False, False
-
-
-# ─────────────────────────────────────────────────────────────
-# توابع CSV — پردازش دسته‌ای
-# ─────────────────────────────────────────────────────────────
-
-def read_csv_columns(file):
-    """خواندن نام ستون‌ها و تعداد ردیف‌های CSV"""
-    if file is None:
-        return gr.update(choices=[], value=[]), "⚠️ فایلی آپلود نشده", gr.update(value=1), gr.update(value=1, maximum=1)
-
-    file_path = file if isinstance(file, str) else file.name
-
-    try:
-        with open(file_path, "r", encoding="utf-8-sig") as f:
-            reader = csv.reader(f)
-            headers = next(reader)
-            headers = [h.strip() for h in headers if h.strip()]
-            row_count = sum(1 for _ in reader)
-
-        if not headers:
-            return gr.update(choices=[], value=[]), "❌ ستونی یافت نشد", gr.update(value=1), gr.update(value=1, maximum=1)
-
-        return (
-            gr.update(choices=headers, value=headers),
-            f"✅ {len(headers)} ستون | {row_count} ردیف — ستون‌ها: {' | '.join(headers)}",
-            gr.update(value=1, minimum=1, maximum=row_count),
-            gr.update(value=min(row_count, 50), minimum=1, maximum=row_count),
-        )
-    except Exception as e:
-        return gr.update(choices=[], value=[]), f"❌ خطا: {str(e)}", gr.update(value=1), gr.update(value=1, maximum=1)
-
-
-def process_csv(
-    file,
-    selected_columns: list,
-    csv_anonymize_all: bool,
-    csv_anonymize_person: bool,
-    csv_anonymize_company: bool,
-    csv_anonymize_amount: bool,
-    csv_anonymize_percent: bool,
-    row_start: int,
-    row_end: int,
-    batch_size: int,
-    delay_between_batches: float,
-    progress=gr.Progress()
-):
-    """ناشناس‌سازی دسته‌ای ستون‌های انتخاب‌شده فایل CSV"""
-    if file is None:
-        return None, "❌ فایلی آپلود نشده", ""
-
-    file_path = file if isinstance(file, str) else file.name
-
-    if not selected_columns:
-        return None, "❌ حداقل یک ستون انتخاب کنید", ""
-
-    # تعیین موجودیت‌ها
-    entities = ["person", "company", "amount", "percent"] if csv_anonymize_all else [
-        e for e, flag in [
-            ("person",  csv_anonymize_person),
-            ("company", csv_anonymize_company),
-            ("amount",  csv_anonymize_amount),
-            ("percent", csv_anonymize_percent),
-        ] if flag
-    ]
-
-    if not entities:
-        return None, "❌ حداقل یک نوع موجودیت انتخاب کنید", ""
-
-    try:
-        # خواندن CSV
-        with open(file_path, "r", encoding="utf-8-sig") as f:
-            reader = csv.DictReader(f)
-            headers = reader.fieldnames
-            all_rows = list(reader)
-
-        total_rows = len(all_rows)
-        if total_rows == 0:
-            return None, "❌ فایل خالی است", ""
-
-        # تنظیم بازه ردیف‌ها (1-indexed → 0-indexed)
-        start_idx = max(0, int(row_start) - 1)
-        end_idx   = min(total_rows, int(row_end))
-        if start_idx >= end_idx:
-            return None, f"❌ بازه نامعتبر: ردیف {row_start} تا {row_end} (کل: {total_rows})", ""
-
-        selected_rows = all_rows[start_idx:end_idx]
-        num_selected  = len(selected_rows)
-        batch_sz      = max(1, int(batch_size))
-
-        logger.info("=" * 60)
-        logger.info(f"📄 CSV: {total_rows} ردیف کل | بازه: {start_idx+1}-{end_idx} ({num_selected} ردیف)")
-        logger.info(f"📦 دسته: {batch_sz} ردیف | ستون‌ها: {selected_columns}")
-        logger.info(f"🎯 موجودیت‌ها: {entities}")
-        logger.info("=" * 60)
-
-        # ساخت anonymizer
-        csv_anon = AnonymizerAdvanced(
-            llm_provider="deepinfra",
-            llm_model=ANON_MODEL,
-            entities_to_anonymize=entities
-        )
-
-        # ساخت ستون‌های جدید برای خروجی ناشناس‌شده
-        # هر ستون انتخابی → ستون جدید با پسوند _Anonymized
-        anon_col_map = {}
-        output_headers = list(headers)
-        for col in selected_columns:
-            if len(selected_columns) == 1:
-                new_col = "Anonymization_text"
-            else:
-                new_col = f"{col}_Anonymized"
-            anon_col_map[col] = new_col
-            if new_col not in output_headers:
-                output_headers.append(new_col)
-
-        logger.info(f"📝 ستون‌های خروجی: {anon_col_map}")
-
-        # جدول نگاشت کلی
-        global_mapping = {}
-        processed_rows = []
-        errors = []
-        total_cells = 0
-        start_time = time.time()
-
-        # تعداد دسته‌ها
-        num_batches = (num_selected + batch_sz - 1) // batch_sz
-
-        for batch_num in range(num_batches):
-            batch_start = batch_num * batch_sz
-            batch_end   = min(batch_start + batch_sz, num_selected)
-            batch_rows  = selected_rows[batch_start:batch_end]
-
-            actual_start = start_idx + batch_start + 1
-            actual_end   = start_idx + batch_end
-
-            progress(
-                (batch_num + 1) / num_batches,
-                desc=f"دسته {batch_num+1}/{num_batches} | ردیف {actual_start}-{actual_end}"
-            )
-
-            logger.info(f"📦 دسته {batch_num+1}/{num_batches}: ردیف {actual_start}-{actual_end}")
-
-            for j, row in enumerate(batch_rows):
-                row_idx = actual_start + j
-                new_row = dict(row)
-
-                # مقدار پیش‌فرض خالی برای ستون‌های جدید
-                for col in selected_columns:
-                    new_row[anon_col_map[col]] = ""
-
-                for col in selected_columns:
-                    if col not in row or not row[col].strip():
-                        new_row[anon_col_map[col]] = row.get(col, "")
-                        continue
-
-                    cell_text = row[col].strip()
-                    total_cells += 1
-
-                    # ریست mapping برای هر سلول
-                    csv_anon.mapping_table = {}
-                    csv_anon.reverse_mapping = {}
-
-                    try:
-                        anon_text, mapping = csv_anon.anonymize(cell_text)
-                        # متن اصلی دست‌نخورده باقی می‌ماند، ناشناس‌شده در ستون جدید
-                        new_row[anon_col_map[col]] = anon_text
-
-                        for token, original in mapping.items():
-                            if token not in global_mapping:
-                                global_mapping[token] = original
-
-                        logger.info(f"  ✅ ردیف {row_idx}, '{col}' → '{anon_col_map[col]}': {len(mapping)} موجودیت")
-
-                    except Exception as e:
-                        logger.error(f"  ❌ ردیف {row_idx}, '{col}': {e}")
-                        errors.append(f"ردیف {row_idx}, ستون '{col}': {str(e)}")
-                        # در صورت خطا متن اصلی در ستون جدید قرار می‌گیرد
-                        new_row[anon_col_map[col]] = cell_text
-
-                    # تاخیر کوتاه بین سلول‌ها
-                    time.sleep(0.2)
-
-                processed_rows.append(new_row)
-
-            # تاخیر بین دسته‌ها
-            if batch_num < num_batches - 1:
-                pause = max(0.5, float(delay_between_batches))
-                logger.info(f"  ⏸️ مکث {pause} ثانیه بین دسته‌ها...")
-                time.sleep(pause)
-
-        elapsed = time.time() - start_time
-
-        # نوشتن CSV خروجی
-        output_dir = tempfile.gettempdir()
-        output_path = os.path.join(output_dir, f"anonymized_{int(time.time())}.csv")
-        with open(output_path, "w", encoding="utf-8-sig", newline="") as f:
-            writer = csv.DictWriter(f, fieldnames=output_headers)
-            writer.writeheader()
-            writer.writerows(processed_rows)
-
-        # ساخت گزارش
-        mins, secs = divmod(int(elapsed), 60)
-        time_str = f"{mins} دقیقه و {secs} ثانیه" if mins > 0 else f"{secs} ثانیه"
-        avg_time = elapsed / total_cells if total_cells > 0 else 0
-
-        anon_cols_str = " | ".join(f"{c} → {anon_col_map[c]}" for c in selected_columns)
-        status_parts = [
-            f"✅ **{len(processed_rows)}** ردیف پردازش شد (ردیف {start_idx+1} تا {end_idx} از {total_rows})",
-            f"📋 **{len(global_mapping)}** موجودیت یکتا ناشناس‌سازی شد",
-            f"📦 **{num_batches}** دسته × **{batch_sz}** ردیف",
-            f"🔢 **{total_cells}** سلول پردازش شد",
-            f"📝 ستون‌ها: {anon_cols_str}",
-            f"⏱️ زمان: {time_str} (میانگین {avg_time:.1f} ثانیه/سلول)",
-        ]
-        if errors:
-            status_parts.append(f"\n⚠️ **{len(errors)}** خطا:")
-            for err in errors[:15]:
-                status_parts.append(f"  - {err}")
-            if len(errors) > 15:
-                status_parts.append(f"  - ... و {len(errors)-15} خطای دیگر")
-
-        status = "\n".join(status_parts)
-
-        # جدول نگاشت
-        if global_mapping:
-            mapping_md = "### 📋 جدول نگاشت کلی\n\n| شناسه | متن اصلی |\n|-------|----------|\n"
-            for token, original in sorted(global_mapping.items()):
-                mapping_md += f"| **{token}** | {original} |\n"
-        else:
-            mapping_md = "### 📋 جدول نگاشت\n\nهیچ موجودیتی شناسایی نشد"
-
-        logger.info(f"✅ CSV کامل شد: {len(processed_rows)} ردیف | {time_str}")
-        return output_path, status, mapping_md
-
-    except Exception as e:
-        logger.error(f"❌ خطای CSV: {e}", exc_info=True)
-        return None, f"❌ خطا: {str(e)}", ""
-
-
-def clear_csv():
-    return (None, gr.update(choices=[], value=[]), "", None,
-            "⏳ هنوز پردازشی انجام نشده",
-            "### 📋 جدول نگاشت\n\nهنوز پردازشی انجام نشده",
-            True, False, False, False, False,
-            1, 50, 10, 1.0)
-
-
-# ─────────────────────────────────────────────────────────────
-# رابط کاربری Gradio
-# ─────────────────────────────────────────────────────────────
-css_rtl = """
-.textbox textarea { direction: rtl; text-align: right; font-family: 'Tahoma', serif; }
-.input-box { direction: rtl; text-align: right; }
-.compact-checkbox label { padding: 5px 10px !important; font-size: 0.95em !important; }
-"""
-
-with gr.Blocks(title="سیستم ناشناس‌سازی متون", theme=gr.themes.Soft(), css=css_rtl) as app:
-
-    gr.Markdown(
-        "# 🔐 پلتفرم ناشناس‌سازی متون فارسی\n"
-        "> 🧠 **Qwen3-14B** با thinking mode — دقت بالا (بنچمارک ۹۰٪+)",
-        elem_classes="input-box"
-    )
-
-    # ═══════════════════════════════════════════════════════════
-    # تب‌ها
-    # ═══════════════════════════════════════════════════════════
-    with gr.Tabs():
-
-        # ─── تب ۱: ناشناس‌سازی متن ────────────────────────────
-        with gr.TabItem("📝 ناشناس‌سازی متن"):
-
-            with gr.Row():
-                with gr.Column(scale=1):
-                    with gr.Group():
-                        gr.Markdown("### ⚙️ مدل تحلیل", elem_classes="input-box")
-                        llm_provider = gr.Dropdown(
-                            choices=["chatgpt", "grok", "deepinfra"],
-                            value="chatgpt", label="🤖 مدل زبانی تحلیل", interactive=True
-                        )
-                        llm_model = gr.Dropdown(
-                            choices=AVAILABLE_MODELS["chatgpt"],
-                            value="gpt-4o-mini", label="📦 نسخه مدل", interactive=True
-                        )
-
-                with gr.Column(scale=1):
-                    with gr.Group():
-                        gr.Markdown("### 🎯 موجودیت‌های ناشناس‌سازی", elem_classes="input-box")
-                        anonymize_all     = gr.Checkbox(label="✅ همه",          value=True,  elem_classes="compact-checkbox")
-                        anonymize_person  = gr.Checkbox(label="👤 اشخاص",        value=False, elem_classes="compact-checkbox")
-                        anonymize_company = gr.Checkbox(label="🏢 سازمان‌ها",    value=False, elem_classes="compact-checkbox")
-                        anonymize_amount  = gr.Checkbox(label="💰 ارقام مالی",   value=False, elem_classes="compact-checkbox")
-                        anonymize_percent = gr.Checkbox(label="📊 درصدها",        value=False, elem_classes="compact-checkbox")
-
-            gr.Markdown("---")
-
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### 📋 دستورات تحلیل (اختیاری)", elem_classes="input-box")
-                    analysis_prompt = gr.Textbox(
-                        lines=20, placeholder="مثال: این متن را خلاصه کن",
-                        label="", elem_classes="textbox"
-                    )
-                with gr.Column(scale=1):
-                    gr.Markdown("### 📝 متن ورودی", elem_classes="input-box")
-                    input_text = gr.Textbox(
-                        lines=20, placeholder="متن فارسی را وارد کنید...",
-                        label="", elem_classes="textbox"
-                    )
-
-            with gr.Row():
-                process_btn = gr.Button("▶️ پردازش", variant="primary", size="lg", scale=2)
-                clear_btn   = gr.Button("🗑️ پاک کردن", variant="stop",  size="lg", scale=1)
-
-            gr.Markdown("## 📊 نتایج", elem_classes="input-box")
-
-            with gr.Row():
-                restored_text     = gr.Textbox(lines=12, label="✅ متن بازگردانی شده", interactive=False, elem_classes="textbox")
-                llm_analysis      = gr.Textbox(lines=12, label="🤖 تحلیل LLM",         interactive=False, elem_classes="textbox")
-                anonymized_output = gr.Textbox(lines=12, label="🔒 متن ناشناس‌شده",    interactive=False, elem_classes="textbox")
-
-            mapping_table = gr.Markdown("### 📋 جدول نگاشت\n\nهنوز پردازشی انجام نشده", elem_classes="input-box")
-
-            # ── رویدادهای تب متن ──
-            def handle_provider_change(provider):
-                models = AVAILABLE_MODELS.get(provider, [])
-                return gr.update(choices=models, value=models[0] if models else None)
-
-            llm_provider.change(fn=handle_provider_change, inputs=[llm_provider], outputs=[llm_model])
-
-            def handle_select_all(select_all):
-                s = gr.update(value=False, interactive=not select_all)
-                return s, s, s, s
-
-            anonymize_all.change(
-                fn=handle_select_all, inputs=[anonymize_all],
-                outputs=[anonymize_person, anonymize_company, anonymize_amount, anonymize_percent]
-            )
-
-            process_btn.click(
-                fn=process,
-                inputs=[
-                    input_text, analysis_prompt, llm_provider, llm_model,
-                    anonymize_all, anonymize_person, anonymize_company, anonymize_amount, anonymize_percent
-                ],
-                outputs=[restored_text, llm_analysis, anonymized_output, mapping_table]
-            )
-
-            clear_btn.click(
-                fn=clear_all,
-                outputs=[
-                    input_text, analysis_prompt, restored_text, llm_analysis,
-                    anonymized_output, mapping_table,
-                    anonymize_all, anonymize_person, anonymize_company, anonymize_amount, anonymize_percent
-                ]
-            )
-
-        # ─── تب ۲: ناشناس‌سازی CSV ────────────────────────────
-        with gr.TabItem("📄 ناشناس‌سازی CSV"):
-
-            gr.Markdown(
-                "### 📄 ناشناس‌سازی دسته‌ای فایل CSV\n"
-                "> فایل CSV را آپلود کنید، بازه ردیف‌ها و اندازه دسته را تنظیم کنید و ناشناس‌سازی را اجرا کنید.",
-                elem_classes="input-box"
-            )
-
-            with gr.Row():
-                # ── ستون ۱: فایل و ستون‌ها ──
-                with gr.Column(scale=1):
-                    with gr.Group():
-                        gr.Markdown("### 📂 فایل ورودی", elem_classes="input-box")
-                        csv_file = gr.File(
-                            label="فایل CSV را آپلود کنید",
-                            file_types=[".csv"],
-                            type="filepath"
-                        )
-                        csv_column_status = gr.Textbox(
-                            label="وضعیت", interactive=False,
-                            value="⏳ فایل آپلود نشده", elem_classes="textbox"
-                        )
-                    with gr.Group():
-                        gr.Markdown("### 📋 ستون‌های قابل ناشناس‌سازی", elem_classes="input-box")
-                        csv_columns = gr.CheckboxGroup(
-                            choices=[], value=[],
-                            label="ستون‌هایی که می‌خواهید ناشناس شوند",
-                            interactive=True
-                        )
-
-                # ── ستون ۲: بازه ردیف‌ها و دسته‌بندی ──
-                with gr.Column(scale=1):
-                    with gr.Group():
-                        gr.Markdown("### 📐 بازه ردیف‌ها", elem_classes="input-box")
-                        with gr.Row():
-                            csv_row_start = gr.Number(
-                                label="از ردیف", value=1, minimum=1, maximum=99999,
-                                precision=0, interactive=True
-                            )
-                            csv_row_end = gr.Number(
-                                label="تا ردیف", value=50, minimum=1, maximum=99999,
-                                precision=0, interactive=True
-                            )
-                    with gr.Group():
-                        gr.Markdown("### 📦 تنظیمات دسته‌ای", elem_classes="input-box")
-                        csv_batch_size = gr.Slider(
-                            label="اندازه هر دسته (تعداد ردیف)",
-                            minimum=1, maximum=50, value=10, step=1,
-                            interactive=True
-                        )
-                        csv_delay = gr.Slider(
-                            label="مکث بین دسته‌ها (ثانیه)",
-                            minimum=0.5, maximum=10.0, value=1.0, step=0.5,
-                            interactive=True
-                        )
-                        gr.Markdown(
-                            "> 💡 **راهنما:** دسته کوچکتر = پایدارتر ولی کندتر | "
-                            "مکث بیشتر = جلوگیری از rate limit",
-                            elem_classes="input-box"
-                        )
-
-                # ── ستون ۳: موجودیت‌ها ──
-                with gr.Column(scale=1):
-                    with gr.Group():
-                        gr.Markdown("### 🎯 موجودیت‌ها", elem_classes="input-box")
-                        csv_anonymize_all     = gr.Checkbox(label="✅ همه",          value=True,  elem_classes="compact-checkbox")
-                        csv_anonymize_person  = gr.Checkbox(label="👤 اشخاص",        value=False, elem_classes="compact-checkbox")
-                        csv_anonymize_company = gr.Checkbox(label="🏢 سازمان‌ها",    value=False, elem_classes="compact-checkbox")
-                        csv_anonymize_amount  = gr.Checkbox(label="💰 ارقام مالی",   value=False, elem_classes="compact-checkbox")
-                        csv_anonymize_percent = gr.Checkbox(label="📊 درصدها",        value=False, elem_classes="compact-checkbox")
-
-            with gr.Row():
-                csv_process_btn = gr.Button("▶️ ناشناس‌سازی CSV", variant="primary", size="lg", scale=2)
-                csv_clear_btn   = gr.Button("🗑️ پاک کردن", variant="stop", size="lg", scale=1)
-
-            gr.Markdown("## 📊 نتایج CSV", elem_classes="input-box")
-
-            with gr.Row():
-                with gr.Column(scale=1):
-                    csv_output_file = gr.File(label="📥 دانلود فایل ناشناس‌شده")
-                with gr.Column(scale=2):
-                    csv_status = gr.Markdown("⏳ هنوز پردازشی انجام نشده", elem_classes="input-box")
-
-            csv_mapping_table = gr.Markdown("### 📋 جدول نگاشت\n\nهنوز پردازشی انجام نشده", elem_classes="input-box")
-
-            # ── رویدادهای تب CSV ──
-
-            csv_file.change(
-                fn=read_csv_columns,
-                inputs=[csv_file],
-                outputs=[csv_columns, csv_column_status, csv_row_start, csv_row_end]
-            )
-
-            def handle_csv_select_all(select_all):
-                s = gr.update(value=False, interactive=not select_all)
-                return s, s, s, s
-
-            csv_anonymize_all.change(
-                fn=handle_csv_select_all, inputs=[csv_anonymize_all],
-                outputs=[csv_anonymize_person, csv_anonymize_company, csv_anonymize_amount, csv_anonymize_percent]
-            )
-
-            csv_process_btn.click(
-                fn=process_csv,
-                inputs=[
-                    csv_file, csv_columns,
-                    csv_anonymize_all, csv_anonymize_person,
-                    csv_anonymize_company, csv_anonymize_amount, csv_anonymize_percent,
-                    csv_row_start, csv_row_end, csv_batch_size, csv_delay
-                ],
-                outputs=[csv_output_file, csv_status, csv_mapping_table]
-            )
-
-            csv_clear_btn.click(
-                fn=clear_csv,
-                outputs=[
-                    csv_file, csv_columns, csv_column_status, csv_output_file,
-                    csv_status, csv_mapping_table,
-                    csv_anonymize_all, csv_anonymize_person, csv_anonymize_company,
-                    csv_anonymize_amount, csv_anonymize_percent,
-                    csv_row_start, csv_row_end, csv_batch_size, csv_delay
-                ]
-            )
-
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("🧠 Qwen3-14B | thinking ON | retry+chunking | بنچمارک ۹۰٪+")
-    print("=" * 60)
-    app.queue(default_concurrency_limit=1)
-    app.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)