upload

app.py

@@ -0,0 +1,1136 @@
+import gradio as gr
+import re
+import os
+import requests
+import time
+import logging
+from packaging import version
+
+# تنظیم logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def auto_setup_models():
+    """راه‌اندازی خودکار مدل‌ها در صورت عدم وجود"""
+    models_dir = "./models"
+    required_models = {
+        'bert-fa-ner': 'HooshvareLab/bert-fa-zwnj-base-ner',
+        'bert-base-NER': 'dslim/bert-base-NER',
+    }
+    
+    missing_models = []
+    for model_name in required_models.keys():
+        model_path = os.path.join(models_dir, model_name)
+        if not os.path.exists(model_path) or not os.listdir(model_path):
+            missing_models.append(model_name)
+    
+    if not missing_models:
+        logger.info("✅ All models are already available")
+        return True
+    
+    logger.info(f"📥 Auto-downloading missing models: {missing_models}")
+    
+    try:
+        from transformers import AutoTokenizer, AutoModelForTokenClassification
+        os.makedirs(models_dir, exist_ok=True)
+        
+        for model_name in missing_models:
+            hf_repo = required_models[model_name]
+            model_path = os.path.join(models_dir, model_name)
+            logger.info(f"📥 Downloading {model_name} from {hf_repo}...")
+            try:
+                tokenizer = AutoTokenizer.from_pretrained(hf_repo)
+                model = AutoModelForTokenClassification.from_pretrained(hf_repo)
+                tokenizer.save_pretrained(model_path)
+                model.save_pretrained(model_path)
+                logger.info(f"✅ {model_name} downloaded successfully")
+                del tokenizer, model
+            except Exception as e:
+                logger.error(f"❌ Failed to download {model_name}: {e}")
+                if os.path.exists(model_path):
+                    import shutil
+                    shutil.rmtree(model_path)
+        
+        logger.info("🎉 Auto-setup completed!")
+        return True
+        
+    except ImportError:
+        logger.error("❌ transformers library not available for auto-download")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Auto-setup failed: {e}")
+        return False
+
+# اجرای auto-setup در startup
+try:
+    auto_setup_models()
+except Exception as e:
+    logger.warning(f"⚠️ Auto-setup encountered an issue: {e}")
+    logger.info("ℹ️ Continuing with manual setup...")
+
+class BilingualDataAnonymizer:
+    def __init__(self):
+        self.mapping_table = {}
+        # counters به‌روزرسانی شده با دسته‌های جدید
+        self.counters = {
+            'COMPANY': 0, 'PERSON': 0, 'AMOUNT': 0, 'ACCOUNT': 0, 
+            'DATE': 0, 'STOCK_SYMBOL': 0, 'PETROCHEMICAL': 0, 
+            'PRODUCT': 0, 'PERCENTAGE': 0, 'LOCATION': 0,
+            'VOLUME': 0, 'PHONE': 0, 'EMAIL': 0, 'ID_NUMBER': 0,
+            'FINANCIAL_TERMS': 0, 'BUSINESS_TERMS': 0, 'RATIOS': 0
+        }
+        
+        self.api_key = os.getenv("OPENAI_API_KEY", "")
+        self.models_base_path = "./models"
+        self.models_loaded = False
+        self.model_status = {}
+        self.load_local_ner_models()
+    
+    def ensure_models_directory(self):
+        if not os.path.exists(self.models_base_path):
+            try:
+                os.makedirs(self.models_base_path, exist_ok=True)
+                logger.info(f"📁 Created models directory: {self.models_base_path}")
+            except Exception as e:
+                logger.error(f"❌ Failed to create models directory: {e}")
+                return False
+        return True
+    
+    def download_model_if_missing(self, local_name, hf_repo):
+        model_path = os.path.join(self.models_base_path, local_name)
+        if os.path.exists(model_path) and os.listdir(model_path):
+            return True, f"Model {local_name} already exists"
+        try:
+            logger.info(f"📥 Auto-downloading {local_name} from {hf_repo}...")
+            from transformers import AutoTokenizer, AutoModelForTokenClassification
+            tokenizer = AutoTokenizer.from_pretrained(hf_repo)
+            model = AutoModelForTokenClassification.from_pretrained(hf_repo)
+            tokenizer.save_pretrained(model_path)
+            model.save_pretrained(model_path)
+            logger.info(f"✅ {local_name} auto-downloaded successfully")
+            return True, f"Downloaded {local_name}"
+        except Exception as e:
+            logger.error(f"❌ Auto-download failed for {local_name}: {e}")
+            return False, str(e)
+    
+    def _load_pipeline(self, task, model_path, tokenizer_path=None):
+        """لود مدل با مدیریت صحیح پارامترهای ورژن مختلف transformers"""
+        try:
+            from transformers import pipeline, AutoTokenizer, AutoModelForTokenClassification, __version__ as tr_version
+            
+            # بررسی پشتیبانی از aggregation_strategy
+            supports_agg = version.parse(tr_version) >= version.parse("4.11.0")
+            
+            # لود توکنایزر و مدل به صورت جداگانه
+            if tokenizer_path:
+                tokenizer = AutoTokenizer.from_pretrained(tokenizer_path, local_files_only=True)
+            else:
+                tokenizer = AutoTokenizer.from_pretrained(model_path, local_files_only=True)
+            
+            model = AutoModelForTokenClassification.from_pretrained(model_path, local_files_only=True)
+            
+            # ایجاد pipeline با پارامترهای مناسب
+            pipeline_kwargs = {
+                "model": model,
+                "tokenizer": tokenizer,
+                "device": -1  # استفاده از CPU
+            }
+            
+            # اضافه کردن aggregation_strategy اگر پشتیبانی می‌شود
+            if supports_agg:
+                pipeline_kwargs["aggregation_strategy"] = "simple"
+            
+            return pipeline(task, **pipeline_kwargs)
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to load pipeline for {model_path}: {e}")
+            return None
+
+    def load_local_ner_models(self):
+        logger.info("🔄 Loading local NER models with auto-download...")
+        if not self.ensure_models_directory():
+            self.models_loaded = False
+            self.model_status['directory'] = "❌ Cannot create models directory"
+            return
+        
+        try:
+            try:
+                import torch
+                from transformers import AutoTokenizer, AutoModelForTokenClassification
+                transformers_available = True
+                logger.info("✅ Transformers library available")
+            except ImportError as e:
+                transformers_available = False
+                self.model_status['transformers'] = f"❌ Transformers library not installed: {str(e)}"
+                self.models_loaded = False
+                return
+            
+            # Persian model
+            persian_model_path = os.path.join(self.models_base_path, "bert-fa-ner")
+            self.download_model_if_missing("bert-fa-ner", "HooshvareLab/bert-fa-zwnj-base-ner")
+            if os.path.exists(persian_model_path) and os.listdir(persian_model_path):
+                try:
+                    self.persian_ner = self._load_pipeline("ner", persian_model_path)
+                    if self.persian_ner:
+                        self.model_status['persian'] = f"✅ Local Persian NER: {persian_model_path}"
+                    else:
+                        self.model_status['persian'] = f"❌ Failed to load Persian model: {persian_model_path}"
+                except Exception as e:
+                    self.persian_ner = None
+                    self.model_status['persian'] = f"❌ Persian model loading error: {str(e)[:100]}"
+            else:
+                self.persian_ner = None
+                self.model_status['persian'] = f"❌ Persian model not found: {persian_model_path}"
+            
+            # English model
+            english_model_path = os.path.join(self.models_base_path, "bert-base-NER")
+            self.download_model_if_missing("bert-base-NER", "dslim/bert-base-NER")
+            if os.path.exists(english_model_path) and os.listdir(english_model_path):
+                try:
+                    self.english_ner = self._load_pipeline("ner", english_model_path)
+                    if self.english_ner:
+                        self.model_status['english'] = f"✅ Local English NER: {english_model_path}"
+                    else:
+                        self.model_status['english'] = f"❌ Failed to load English model: {english_model_path}"
+                except Exception as e:
+                    self.english_ner = None
+                    self.model_status['english'] = f"❌ English model loading error: {str(e)[:100]}"
+            else:
+                self.english_ner = None
+                self.model_status['english'] = f"❌ English model not found: {english_model_path}"
+            
+            loaded_models = sum(1 for status in self.model_status.values() if status.startswith("✅"))
+            self.models_loaded = loaded_models > 0
+            if loaded_models == 0:
+                self.model_status['fallback'] = "⚠️ Using regex-only mode (no local models found)"
+                
+        except Exception as e:
+            self.models_loaded = False
+            self.model_status['critical'] = f"❌ Critical error: {str(e)[:100]}..."
+
+    def detect_language(self, text):
+        """تشخیص زبان متن"""
+        if not text:
+            return 'fa'
+        
+        persian_chars = len(re.findall(r'[\u0600-\u06FF]', text))
+        english_chars = len(re.findall(r'[a-zA-Z]', text))
+        total = persian_chars + english_chars
+        
+        if total == 0:
+            return 'fa'
+        
+        if persian_chars / total > 0.6:
+            return 'fa'
+        elif english_chars / total > 0.6:
+            return 'en'
+        else:
+            return 'mixed'
+
+    def extract_entities_with_ner(self, text, lang='fa'):
+        """استخراج entities با مدل‌های NER محلی"""
+        entities = []
+        
+        if not self.models_loaded:
+            logger.info("ℹ️ Local NER models not available - using regex only")
+            return entities
+        
+        try:
+            # مدل فارسی محلی
+            if lang in ['fa', 'mixed'] and hasattr(self, 'persian_ner') and self.persian_ner:
+                try:
+                    persian_results = self.persian_ner(text)
+                    for entity in persian_results:
+                        # بررسی فرمت خروجی بر اساس ورژن transformers
+                        if isinstance(entity, dict):
+                            if 'entity_group' in entity:
+                                # ورژن جدید با aggregation_strategy
+                                entities.append({
+                                    'text': entity['word'].strip(),
+                                    'label': entity['entity_group'],
+                                    'start': entity['start'],
+                                    'end': entity['end'],
+                                    'confidence': entity['score'],
+                                    'source': 'local_persian_ner'
+                                })
+                            else:
+                                # ورژن قدیمی
+                                entities.append({
+                                    'text': entity['word'].strip(),
+                                    'label': entity['entity'],
+                                    'start': entity['start'],
+                                    'end': entity['end'],
+                                    'confidence': entity['score'],
+                                    'source': 'local_persian_ner'
+                                })
+                    logger.info(f"Local Persian NER found {len(persian_results)} entities")
+                except Exception as e:
+                    logger.error(f"Local Persian NER extraction error: {e}")
+            
+            # مدل انگلیسی محلی
+            if lang in ['en', 'mixed'] and hasattr(self, 'english_ner') and self.english_ner:
+                try:
+                    english_results = self.english_ner(text)
+                    for entity in english_results:
+                        # بررسی فرمت خروجی بر اساس ورژن transformers
+                        if isinstance(entity, dict):
+                            if 'entity_group' in entity:
+                                # ورژن جدید با aggregation_strategy
+                                entities.append({
+                                    'text': entity['word'].strip(),
+                                    'label': entity['entity_group'],
+                                    'start': entity['start'],
+                                    'end': entity['end'],
+                                    'confidence': entity['score'],
+                                    'source': 'local_english_ner'
+                                })
+                            else:
+                                # ورژن قدیمی
+                                entities.append({
+                                    'text': entity['word'].strip(),
+                                    'label': entity['entity'],
+                                    'start': entity['start'],
+                                    'end': entity['end'],
+                                    'confidence': entity['score'],
+                                    'source': 'local_english_ner'
+                                })
+                    logger.info(f"Local English NER found {len(english_results)} entities")
+                except Exception as e:
+                    logger.error(f"Local English NER extraction error: {e}")
+                    
+        except Exception as e:
+            logger.error(f"Local NER extraction general error: {e}")
+        
+        # حذف تکراری‌ها
+        unique_entities = []
+        seen = set()
+        for entity in entities:
+            key = (entity['text'].lower(), entity['start'], entity['end'])
+            if key not in seen:
+                seen.add(key)
+                unique_entities.append(entity)
+        
+        logger.info(f"Total unique entities found by local models: {len(unique_entities)}")
+        return unique_entities
+
+    def map_ner_to_categories(self, ner_label, source=''):
+        """نگاشت برچسب‌های NER به دسته‌های سیستم"""
+        mapping = {
+            'PER': 'PERSON', 'PERSON': 'PERSON',
+            'ORG': 'COMPANY', 'ORGANIZATION': 'COMPANY',
+            'LOC': 'LOCATION', 'LOCATION': 'LOCATION',
+            'MISC': 'BUSINESS_TERMS', 'MISCELLANEOUS': 'BUSINESS_TERMS',
+            'B-PER': 'PERSON', 'I-PER': 'PERSON',
+            'B-ORG': 'COMPANY', 'I-ORG': 'COMPANY',
+            'B-LOC': 'LOCATION', 'I-LOC': 'LOCATION',
+            'B-MISC': 'BUSINESS_TERMS', 'I-MISC': 'BUSINESS_TERMS',
+            'MONEY': 'AMOUNT', 'PERCENT': 'PERCENTAGE',
+            'DATE': 'DATE', 'TIME': 'DATE'
+        }
+        return mapping.get(ner_label.upper(), 'BUSINESS_TERMS')
+
+    def anonymize_text(self, original_text, lang='fa'):
+        """گام 1: ناشناس‌سازی متن"""
+        try:
+            if not original_text or not original_text.strip():
+                return "❌ Please enter input text!" if lang == 'en' else "❌ لطفاً متن ورودی را وارد کنید!"
+            
+            # ریست متغیرها
+            self.mapping_table = {}
+            self.counters = {key: 0 for key in self.counters.keys()}
+            
+            anonymized = original_text
+            found_entities = set()
+            
+            # تشخیص زبان
+            detected_lang = self.detect_language(original_text)
+            logger.info(f"Detected language: {detected_lang}")
+            
+            # مرحله 1: استخراج با Local NER
+            if self.models_loaded:
+                logger.info("🤖 Running local NER extraction...")
+                ner_entities = self.extract_entities_with_ner(original_text, detected_lang)
+                
+                for entity in ner_entities:
+                    if (entity['text'] not in found_entities and 
+                        len(entity['text'].strip()) > 1 and 
+                        entity['confidence'] > 0.5):
+                        
+                        category = self.map_ner_to_categories(entity['label'], entity['source'])
+                        
+                        if entity['text'] not in self.mapping_table:
+                            self.counters[category] += 1
+                            code = f"{category}_{self.counters[category]:03d}_LOCAL_NER"
+                            self.mapping_table[entity['text']] = code
+                            found_entities.add(entity['text'])
+                            logger.info(f"Local NER: {entity['text']} -> {code}")
+            else:
+                logger.info("ℹ️ Using regex-only mode")
+            
+            # مرحله 2: الگوهای Regex - الگوهای جدید اضافه شده
+            patterns = {
+                'STOCK_SYMBOL': [
+                    r'نماد\s+([آ-ی‌a-zA-Z0-9]+)',
+                    r'(سبهان|غدیر|شتران|شپنا|پترول|فارس|خارک|پلاسکو|جم|کرمان|مارون|اراک|رازی|شازند|کاوه|بندر|پارس|خوزستان|ماهشهر|عسلویه)(?=\s|$|،|\.|\s+—)',
+                    r'شرکت\s+([آ-ی‌a-zA-Z\s]+?)(?=\s+در|\s+که|\s+با|،|\.|\s+$|\s+را|\s+به)',
+                    r'پتروشیمی\s+([آ-ی‌a-zA-Z\s]+?)(?=\s+در|\s+که|\s+با|،|\.|\s+$|\s+توان)',
+                    r'(AAPL|GOOGL|MSFT|AMZN|TSLA|META|NVDA|SABIC)(?=\s|$|,|\.)'
+                ],
+                'COMPANY': [
+                    r'شرکت(?=\s+در|\s+که|\s+با|\s+را|\s+به|\s+طی)',
+                    r'([آ-ی‌a-zA-Z\s]+)\s+شرکت',
+                    r'این\s+شرکت(?=\s|$|،|\.)',
+                    r'(بانک\s+[آ-ی‌a-zA-Z\s]+)',
+                    r'([A-Z][a-zA-Z\s]+(?:Inc|Corp|Corporation|Company|Ltd|Limited|LLC))'
+                ],
+                'PERSON': [
+                    r'آقای\s+([آ-ی‌a-zA-Z]+(?:\s+[آ-ی‌a-zA-Z]+)*)',
+                    r'خانم\s+([آ-ی‌a-zA-Z]+(?:\s+[آ-ی‌a-zA-Z]+)*)',
+                    r'مهندس\s+([آ-ی‌a-zA-Z]+(?:\s+[آ-ی‌a-zA-Z]+)*)',
+                    r'دکتر\s+([آ-ی‌a-zA-Z]+(?:\s+[آ-ی‌a-zA-Z]+)*)',
+                    r'([آ-ی‌a-zA-Z]+\s+[آ-ی‌a-zA-Z]+)(?=،\s+مدیرعامل|\s+مدیرعامل|\s+رئیس)',
+                    r'مدیرعامل(?=\s|$|،|\.)',
+                    r'سرپرست(?=\s+و|\s|$|،|\.)',
+                    r'رئیس\s+هیأت‌مدیره',
+                    r'وی(?=\s+ادامه|\s+اظهار|\s+گفت|\s+اعلام|\s+همچنین)'
+                ],
+                'AMOUNT': [
+                    r'\d+(?:,\d{3})*\s*(?:میلیون|میلیارد|هزار)\s*تومان',
+                    r'مبلغ\s+\d+(?:,\d{3})*\s*(?:میلیون|میلیارد|هزار)?\s*تومان',
+                    r'\d+\s*تومان(?=\s+به\s+ازای|\s+فروش|\s+،)',
+                    r'رقم\s+فعلی\s+\d+(?:,\d{3})*\s*(?:میلیون|میلیارد)\s*تومان',
+                    r'رقم\s+\d+(?:,\d{3})*\s*(?:میلیون|میلیارد)\s*تومان',
+                    r'به\s+\d+(?:,\d{3})*\s*(?:میلیون|میلیارد|هزار)\s*تومان',
+                    r'از\s+\d+(?:,\d{3})*\s*(?:میلیون|میلیارد|هزار)\s*تومان',
+                    r'برابر\s+با\s+\d+(?:,\d{3})*\s*(?:میلیون|میلیارد|هزار)\s*تومان',
+                    r'\d+(?:میلیارد|میلیون)\s*تومان(?=\s+رسیده|\s+ثبت|\s+بوده|\s+،)',
+                    r'\$\d+(?:,\d{3})*(?:\.\d+)?\s*(?:million|billion|thousand|M|B|K)?',
+                    r'\d+(?:,\d{3})*\s*ریال',
+                    r'€\d+(?:,\d{3})*(?:\.\d+)?'
+                ],
+                'PERCENTAGE': [
+                    r'\d+(?:\.\d+)?\s*درصد(?:\s+افزایش|\s+رشد|\s+کاهش|\s+بالاتر|\s+پایین‌تر)?',
+                    r'\d+(?:\.\d+)?\s*%',
+                    r'معادل\s+\d+(?:\.\d+)?\s*درصد',
+                    r'حدود\s+\d+(?:\.\d+)?\s*درصد',
+                    r'با\s+\d+(?:\.\d+)?\s*درصد\s+افزایش',
+                    r'رشد\s+\d+(?:\.\d+)?\s*درصدی',
+                    r'\d+(?:\.\d+)?\s*درصدی(?=\s+همراه|\s+بوده)',
+                    r'میزان\s+رشد(?=\s+نسبت|\s+معادل)',
+                    r'افزایش\s+قابل‌توجهی',
+                    r'بهبود\s+نسبی'
+                ],
+                'PHONE': [
+                    r'(?:تلفن[\s:]*)?(?:شماره[\s:]*)?(?:0)?(?:[۰-۹0-9]{2,3}[-\s]?)?[۰-۹0-9]{7,8}',
+                    r'(?:تماس[\s:]*)?(?:شماره[\s:]*)?(?:با[\s]*)?(?:0)?(?:[۰-۹0-9]{2,3}[-\s]?)?[۰-۹0-9]{7,8}',
+                    r'(?:موبایل[\s:]*)?(?:شماره[\s:]*)?(?:0)?9[۰-۹0-9]{9}',
+                    r'[۰-۹0-9]{3,4}[-\s][۰-۹0-9]{7,8}',
+                    r'[۰-۹0-9]{11}(?!\d)',
+                    r'(?:\+98|0098)?[۰-۹0-9]{10}',
+                    r'[۰-۹0-9]{3,4}[-\s]?[۰-۹0-9]{3,4}[-\s]?[۰-۹0-9]{3,4}'
+                ],
+                'EMAIL': [
+                    r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
+                    r'ایمیل[\s:]*[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
+                    r'email[\s:]*[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
+                    r'نشانی[\s]*الکترونیک[\s:]*[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
+                    r'آدرس[\s]*ایمیل[\s:]*[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
+                ],
+                'ACCOUNT': [
+                    r'(?:شماره[\s]*)?(?:حساب[\s]*)?(?:بانکی[\s:]*)?(?:[۰-۹0-9]{1,3}[-\s]?)*[۰-۹0-9]{8,20}',
+                    r'حساب[\s]*(?:شماره[\s:]*)?(?:[۰-۹0-9]{1,3}[-\s]?)*[۰-۹0-9]{8,20}',
+                    r'شماره[\s]*حساب[\s:]*(?:[۰-۹0-9]{1,3}[-\s]?)*[۰-۹0-9]{8,20}',
+                    r'Account[\s]*(?:Number[\s:]*)?(?:[0-9]{1,3}[-\s]?)*[0-9]{8,20}',
+                    r'[۰-۹0-9]{3}[-\s]?[۰-۹0-9]{3}[-\s]?[۰-۹0-9]{6,12}',
+                    r'[۰-۹0-9]{2,4}[-\s]?[۰-۹0-9]{6,12}[-\s]?[۰-۹0-9]{2,4}',
+                    r'واریز[\s]*(?:سود[\s:]*)?(?:[۰-۹0-9]{1,3}[-\s]?)*[۰-۹0-9]{8,20}',
+                    r'سود[\s:]*(?:[۰-۹0-9]{1,3}[-\s]?)*[۰-۹0-9]{8,20}'
+                ],
+                'ID_NUMBER': [
+                    r'IR[۰-۹0-9]{24}',
+                    r'شبا[\s:]*IR[۰-۹0-9]{24}',
+                    r'IBAN[\s:]*IR[۰-۹0-9]{24}',
+                    r'شماره[\s]*شبا[\s:]*IR[۰-۹0-9]{24}',
+                    r'(?:کد[\s]*)?(?:ملی[\s:]*)?[۰-۹0-9]{10}',
+                    r'(?:شناسه[\s]*)?(?:ملی[\s:]*)?[۰-۹0-9]{10}',
+                    r'National[\s]*(?:ID[\s:]*)?[0-9]{10}',
+                    r'(?:پاسپورت[\s:]*)?[A-Z][0-9]{8}',
+                    r'(?:Passport[\s:]*)?[A-Z][0-9]{8}',
+                    r'(?:کارت[\s:]*)?(?:[۰-۹0-9]{4}[-\s]?){3}[۰-۹0-9]{4}',
+                    r'(?:Card[\s:]*)?(?:[0-9]{4}[-\s]?){3}[0-9]{4}'
+                ],
+                'DATE': [
+                    r'[۰-۹0-9]{4}[/-][۰-۹0-9]{1,2}[/-][۰-۹0-9]{1,2}',
+                    r'[۰-۹0-9]{1,2}[/-][۰-۹0-9]{1,2}[/-][۰-۹0-9]{4}',
+                    r'(?:[۰-۹0-9]{1,2})\s*(?:فروردین|اردیبهشت|خرداد|تیر|مرداد|شهریور|مهر|آبان|آذر|دی|بهمن|اسفند)\s*(?:[۰-۹0-9]{4})',
+                    r'(?:[0-9]{1,2})\s*(?:January|February|March|April|May|June|July|August|September|October|November|December)\s*(?:[0-9]{4})',
+                    r'(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s*[0-9]{1,2},?\s*[0-9]{4}'
+                ]
+            }
+            
+            # پردازش patterns با اولویت‌بندی - از خاص به عام
+            logger.info("🔍 Running prioritized regex extraction...")
+            
+            # پردازش به ترتیب اولویت برای جلوگیری از تداخل
+            processed_entities = set()  # برای جلوگیری از تکرار
+            
+            for category, pattern_list in patterns.items():
+                for pattern in pattern_list:
+                    matches = re.finditer(pattern, original_text, re.IGNORECASE | re.MULTILINE)
+                    for match in matches:
+                        if match.groups():
+                            item = match.group(1).strip()
+                            full_match = match.group(0).strip()
+                        else:
+                            item = match.group(0).strip()
+                            full_match = item
+                        
+                        # بررسی تداخل با entities قبلی
+                        overlaps = False
+                        match_start, match_end = match.span()
+                        
+                        for proc_start, proc_end in processed_entities:
+                            # بررسی تداخل موقعیت
+                            if not (match_end <= proc_start or match_start >= proc_end):
+                                overlaps = True
+                                break
+                        
+                        if (not overlaps and
+                            full_match not in found_entities and 
+                            full_match not in self.mapping_table and 
+                            len(full_match) >= 2):
+                            
+                            self.counters[category] += 1
+                            code = f"{category}_{self.counters[category]:03d}_REGEX"
+                            self.mapping_table[full_match] = code
+                            found_entities.add(full_match)
+                            processed_entities.add((match_start, match_end))
+                            logger.info(f"Regex ({category}): {full_match} -> {code}")
+            
+            # جایگزینی در متن با ترتیب طولانی‌ترین اول
+            sorted_items = sorted(self.mapping_table.items(), key=lambda x: len(x[0]), reverse=True)
+            for original_item, code in sorted_items:
+                anonymized = anonymized.replace(original_item, code)
+            
+            logger.info(f"✅ Anonymization completed. Found {len(self.mapping_table)} entities.")
+            return anonymized
+            
+        except Exception as e:
+            return f"❌ Error in anonymization: {str(e)}" if lang == 'en' else f"❌ خطا در ناشناس‌سازی: {str(e)}"
+
+    def send_to_chatgpt(self, anonymized_text, lang='fa'):
+        """گام 2: ارسال به ChatGPT"""
+        try:
+            if not anonymized_text or not anonymized_text.strip():
+                return "❌ Anonymized text is empty!" if lang == 'en' else "❌ متن ناشناس‌شده خالی است!"
+            
+            if not self.api_key:
+                return "❌ API Key not configured! Please set OPENAI_API_KEY environment variable." if lang == 'en' else "❌ کلید API تنظیم نشده است! لطفاً OPENAI_API_KEY را در متغیرهای محیطی تنظیم کنید."
+            
+            system_msg = "You are a professional financial analyst. The text contains anonymous codes. Answer questions accurately." if lang == 'en' else "شما یک تحلیلگر مالی حرفه‌ای هستید. متن حاوی کدهای ناشناس است. به سوالات با دقت پاسخ دهید."
+            
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            data = {
+                "model": "gpt-4o-mini",
+                "messages": [
+                    {"role": "system", "content": system_msg},
+                    {"role": "user", "content": anonymized_text}
+                ],
+                "max_tokens": 2000,
+                "temperature": 0.7
+            }
+            
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers=headers,
+                json=data,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result['choices'][0]['message']['content']
+            else:
+                error_data = response.json() if response.content else {}
+                error_message = error_data.get('error', {}).get('message', response.text)
+                
+                if 'Incorrect API key' in error_message:
+                    return "❌ Invalid API key." if lang == 'en' else "❌ کلید API نامعتبر است."
+                elif 'quota' in error_message:
+                    return "❌ API quota exceeded." if lang == 'en' else "❌ سهمیه API تمام شده است."
+                else:
+                    return f"❌ API Error: {error_message}"
+                
+        except Exception as e:
+            return f"❌ Error connecting to ChatGPT: {str(e)}" if lang == 'en' else f"❌ خطا در ارتباط با ChatGPT: {str(e)}"
+
+    def deanonymize_response(self, gpt_response, lang='fa'):
+        """گام 3: بازگردانی"""
+        try:
+            if not gpt_response or not gpt_response.strip():
+                return "❌ ChatGPT response is empty!" if lang == 'en' else "❌ پاسخ ChatGPT خالی است!"
+            
+            if not self.mapping_table:
+                return "❌ Mapping table is empty!" if lang == 'en' else "❌ جدول نگاشت خالی است!"
+            
+            final_result = gpt_response
+            reverse_mapping = {code: original for original, code in self.mapping_table.items()}
+            
+            sorted_codes = sorted(reverse_mapping.items(), key=lambda x: len(x[0]), reverse=True)
+            for code, original in sorted_codes:
+                final_result = final_result.replace(code, original)
+                escaped_code = code.replace('_', '\\_')
+                final_result = final_result.replace(escaped_code, original)
+            
+            return final_result
+            
+        except Exception as e:
+            return f"❌ Deanonymization error: {str(e)}" if lang == 'en' else f"❌ خطا در بازگردانی: {str(e)}"
+
+    def get_model_status(self):
+        """وضعیت مدل‌های محلی"""
+        status = "🤖 **Local Model Status (Enhanced with Priority-Based Sensitive Data Detection):**\n\n"
+        
+        if hasattr(self, 'model_status') and self.model_status:
+            for model_type, model_status in self.model_status.items():
+                if model_type == 'persian':
+                    status += f"• **Persian NER**: {model_status}\n"
+                elif model_type == 'english':
+                    status += f"• **English NER**: {model_status}\n"
+                elif model_type == 'financial':
+                    status += f"• **Financial NER**: {model_status}\n"
+                elif model_type == 'transformers':
+                    status += f"• **Transformers**: {model_status}\n"
+                elif model_type == 'fallback':
+                    status += f"• **Fallback Mode**: {model_status}\n"
+                elif model_type == 'critical':
+                    status += f"• **Critical**: {model_status}\n"
+                elif model_type == 'directory':
+                    status += f"• **Directory**: {model_status}\n"
+        
+        loaded_count = sum(1 for status in getattr(self, 'model_status', {}).values() 
+                          if status.startswith("✅"))
+        status += f"\n📊 **Summary**: {loaded_count}/2 local models loaded"
+        
+        status += f"\n📁 **Models Path**: {self.models_base_path}"
+        status += f"\n🔧 **Latest Features**: Priority-based detection with overlap prevention"
+        
+        status += f"\n\n🔍 **Enhanced Sensitive Data Detection (Priority Order):**"
+        status += f"\n   1️⃣ **ID Numbers**: IBAN/SHEBA codes, National IDs, Passport numbers"
+        status += f"\n   2️⃣ **Contact Info**: Email addresses with context keywords"
+        status += f"\n   3️⃣ **Phone Numbers**: Mobile & landline with country codes"
+        status += f"\n   4️⃣ **Bank Accounts**: Account numbers with Persian keywords"
+        status += f"\n   5️⃣ **Financial Data**: Amounts, percentages, stock symbols"
+        status += f"\n   6️⃣ **Corporate Data**: Company names, person names, dates"
+        
+        status += f"\n\n✨ **Key Improvements:**"
+        status += f"\n   🎯 Overlap detection prevents double-matching"
+        status += f"\n   🇮🇷 Full Persian digit support (۰-۹)"
+        status += f"\n   🔄 Context-aware pattern matching"
+        status += f"\n   📏 Length-based replacement order"
+        
+        return status
+
+def process_all_steps(input_text, language):
+    """پردازش خودکار تمام مراحل"""
+    lang = 'en' if language == 'English' else 'fa'
+    
+    if not input_text.strip():
+        error_msg = "❌ Please enter input text!" if lang == 'en' else "❌ لطفاً متن ورودی را وارد کنید!"
+        return error_msg, "", "", ""
+    
+    try:
+        start_time = time.time()
+        
+        anonymized_text = anonymizer.anonymize_text(input_text, lang)
+        if anonymized_text.startswith("❌"):
+            return anonymized_text, "", "", ""
+        
+        gpt_response = anonymizer.send_to_chatgpt(anonymized_text, lang)
+        if gpt_response.startswith("❌"):
+            entities_found = len(anonymizer.mapping_table)
+            local_ner_count = sum(1 for code in anonymizer.mapping_table.values() if '_LOCAL_NER' in code)
+            regex_count = sum(1 for code in anonymizer.mapping_table.values() if '_REGEX' in code)
+            
+            # آمار اطلاعات حساس
+            sensitive_categories = ['ID_NUMBER', 'EMAIL', 'PHONE', 'ACCOUNT']
+            sensitive_count = sum(1 for code in anonymizer.mapping_table.values() 
+                                if any(cat in code for cat in sensitive_categories))
+            
+            method = "Priority-Based Local NER + Regex" if anonymizer.models_loaded else "Priority-Based Regex Only"
+            success_msg = (f"✅ Anonymization completed with {method}!\n"
+                          f"🔍 Sensitive data: {sensitive_count} | 🤖 NER: {local_ner_count} | 🔎 Regex: {regex_count}\n"
+                          f"📊 Total: {entities_found} entities protected")
+            return success_msg, anonymized_text, gpt_response, ""
+        
+        final_result = anonymizer.deanonymize_response(gpt_response, lang)
+        
+        total_time = time.time() - start_time
+        entities_found = len(anonymizer.mapping_table)
+        local_ner_count = sum(1 for code in anonymizer.mapping_table.values() if '_LOCAL_NER' in code)
+        regex_count = sum(1 for code in anonymizer.mapping_table.values() if '_REGEX' in code)
+        
+        # آمار تفصیلی اطلاعات حساس
+        id_count = sum(1 for code in anonymizer.mapping_table.values() if 'ID_NUMBER' in code)
+        email_count = sum(1 for code in anonymizer.mapping_table.values() if 'EMAIL' in code)
+        phone_count = sum(1 for code in anonymizer.mapping_table.values() if 'PHONE' in code)
+        account_count = sum(1 for code in anonymizer.mapping_table.values() if 'ACCOUNT' in code)
+        
+        sensitive_details = []
+        if id_count > 0: sensitive_details.append(f"🆔 IDs: {id_count}")
+        if email_count > 0: sensitive_details.append(f"📧 Emails: {email_count}")
+        if phone_count > 0: sensitive_details.append(f"📞 Phones: {phone_count}")
+        if account_count > 0: sensitive_details.append(f"🏦 Accounts: {account_count}")
+        
+        method = "Priority-Based Local NER + Regex" if anonymizer.models_loaded else "Priority-Based Regex Only"
+        success_msg = (f"🎉 Complete anonymization & restoration successful!\n"
+                      f"🔧 Method: {method}\n"
+                      f"🔍 Sensitive data: {' | '.join(sensitive_details) if sensitive_details else '0'}\n"
+                      f"📊 Total: {entities_found} entities | ⏱️ Time: {total_time:.2f}s")
+        
+        return success_msg, anonymized_text, gpt_response, final_result
+        
+    except Exception as e:
+        error_msg = f"❌ Processing error: {str(e)}" if lang == 'en' else f"❌ خطا در پردازش: {str(e)}"
+        return error_msg, "", "", ""
+
+def get_mapping_table(language):
+    """نمایش جدول نگاشت"""
+    lang = 'en' if language == 'English' else 'fa'
+    
+    if not anonymizer.mapping_table:
+        return "❌ Mapping table is empty! Please process some text first." if lang == 'en' else "❌ جدول نگاشت خالی است! ابتدا متنی را پردازش کنید."
+    
+    result = "📋 **Priority-Based Sensitive Data Mapping Table:**\n\n" if lang == 'en' else "📋 **جدول نگاشت اطلاعات حساس با اولویت‌بندی:**\n\n"
+    
+    local_ner_items = {k: v for k, v in anonymizer.mapping_table.items() if '_LOCAL_NER' in v}
+    regex_items = {k: v for k, v in anonymizer.mapping_table.items() if '_REGEX' in v}
+    
+    # گروه‌بندی بر اساس نوع اطلاعات حساس
+    priority_categories = {
+        'ID_NUMBER': '🆔 **Identity & Financial Codes**',
+        'EMAIL': '📧 **Email Addresses**', 
+        'PHONE': '📞 **Phone Numbers**',
+        'ACCOUNT': '🏦 **Bank Account Numbers**'
+    }
+    
+    sensitive_found = False
+    for category, title in priority_categories.items():
+        category_items = {k: v for k, v in anonymizer.mapping_table.items() if category in v}
+        if category_items:
+            sensitive_found = True
+            result += f"{title}:\n"
+            for original, code in list(category_items.items())[:8]:
+                result += f"   • `{original}` → `{code}`\n"
+            if len(category_items) > 8:
+                result += f"   ... و {len(category_items) - 8} مورد دیگر\n"
+            result += "\n"
+    
+    if local_ner_items:
+        result += "🤖 **Local NER Detected**:\n"
+        for original, code in list(local_ner_items.items())[:8]:
+            result += f"   • `{original}` → `{code}`\n"
+        if len(local_ner_items) > 8:
+            result += f"   ... و {len(local_ner_items) - 8} مورد دیگر\n"
+        result += "\n"
+    
+    # سایر موارد (مالی، شرکتی و غیره)
+    other_categories = ['AMOUNT', 'PERCENTAGE', 'COMPANY', 'PERSON', 'STOCK_SYMBOL', 'DATE']
+    other_items = {k: v for k, v in regex_items.items() 
+                  if any(cat in v for cat in other_categories)}
+    
+    if other_items:
+        result += "💼 **Business & Financial Data**:\n"
+        for original, code in list(other_items.items())[:8]:
+            result += f"   • `{original}` → `{code}`\n"
+        if len(other_items) > 8:
+            result += f"   ... و {len(other_items) - 8} مورد دیگر\n"
+    
+    # آمار کلی
+    sensitive_count = sum(len({k: v for k, v in anonymizer.mapping_table.items() if cat in v}) 
+                         for cat in priority_categories.keys())
+    
+    result += f"\n📊 **Statistics**:\n"
+    result += f"🔍 **Sensitive Data**: {sensitive_count} items\n"
+    result += f"🤖 **NER Detected**: {len(local_ner_items)} items\n" 
+    result += f"💼 **Business Data**: {len(other_items)} items\n"
+    result += f"📋 **Total**: {len(anonymizer.mapping_table)} entities\n"
+    
+    result += f"\n✨ **Enhancement Applied**: Priority-based detection with overlap prevention\n"
+    result += f"🎯 **Success**: All major sensitive data types detected and anonymized!"
+    
+    return result
+
+def clear_all():
+    """پاک کردن همه"""
+    anonymizer.mapping_table = {}
+    anonymizer.counters = {key: 0 for key in anonymizer.counters.keys()}
+    return "", "", "", "", ""
+
+def update_ui_text(language):
+    """به‌روزرسانی متن‌های رابط کاربری"""
+    if language == 'English':
+        return {
+            'title': 'Priority-Based Bilingual Data Anonymization System',
+            'step1': 'Input Text & Settings',
+            'step2': 'Anonymized Text',
+            'step3': 'Raw ChatGPT Response',
+            'step4': 'Final Restored Response',
+            'input_placeholder': 'Enter your original text here...\nExample: Company reports, person names, financial amounts, phone numbers, emails, IBAN codes, bank accounts, etc.',
+            'process_btn': 'Process with Smart Priority Detection',
+            'clear_btn': 'Clear All',
+            'mapping_btn': 'Show Priority-Based Mapping Table',
+            'copy_btn': 'Copy',
+            'direction': 'ltr'
+        }
+    else:
+        return {
+            'title': 'سیستم ناشناس‌سازی هوشمند با اولویت‌بندی',
+            'step1': 'متن ورودی و تنظیمات',
+            'step2': 'متن ناشناس‌شده',
+            'step3': 'پاسخ خام ChatGPT',
+            'step4': 'پاسخ نهایی بازگردانده شده',
+            'input_placeholder': 'متن اصلی خود را اینجا وارد کنید...\nمثال: گزارش‌های شرکت، نام اشخاص، مبالغ مالی، شماره تلفن، ایمیل، شماره شبا، حساب بانکی و غیره',
+            'process_btn': 'پردازش با تشخیص هوشمند اولویت‌دار',
+            'clear_btn': 'پاک کردن همه',
+            'mapping_btn': 'نمایش جدول نگاشت اولویت‌دار',
+            'copy_btn': 'کپی',
+            'direction': 'rtl'
+        }
+
+def update_interface(language):
+    """تغییر رابط کاربری بر اساس زبان"""
+    ui_text = update_ui_text(language)
+    is_english = (language == 'English')
+    
+    # تغییر direction برای workflow
+    workflow_css = "workflow ltr" if is_english else "workflow rtl"
+    
+    return [
+        gr.update(value=f"<h1 style='text-align: center; color: #FFD700; font-size: 3.5em; font-weight: bold; text-shadow: 3px 3px 6px rgba(0,0,0,0.5); margin: 20px 0; background: linear-gradient(45deg, #FFD700, #FFA500); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;'>📊 {ui_text['title']}</h1>"),
+        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>📝 {ui_text['step1']}</h2>"),
+        gr.update(placeholder=ui_text['input_placeholder'], rtl=not is_english),
+        gr.update(value=f"🚀 {ui_text['process_btn']}"),
+        gr.update(value=f"🗑️ {ui_text['clear_btn']}"),
+        gr.update(rtl=not is_english),
+        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>🎭 {ui_text['step2']}</h2>"),
+        gr.update(rtl=not is_english),
+        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>🤖 {ui_text['step3']}</h2>"),
+        gr.update(rtl=not is_english),
+        gr.update(value=f"<h2 style='direction: {ui_text['direction']};'>✅ {ui_text['step4']}</h2>"),
+        gr.update(rtl=not is_english),
+        gr.update(value=f"📋 {ui_text['mapping_btn']}"),
+        gr.update(rtl=not is_english),
+        gr.update(elem_classes=workflow_css)
+    ]
+
+# ایجاد instance
+anonymizer = BilingualDataAnonymizer()
+
+# CSS اصلاح شده برای ترازبندی عمودی مناسب
+custom_css = """
+body, .gradio-container {
+    font-family: 'Segoe UI', Tahoma, Arial, sans-serif !important;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    min-height: 100vh !important;
+    padding: 20px !important;
+}
+
+.rtl {
+    direction: rtl !important;
+    text-align: right !important;
+}
+
+.ltr {
+    direction: ltr !important;
+    text-align: left !important;
+}
+
+.workflow {
+    display: grid !important;
+    grid-template-columns: 1fr 1fr 1fr 1fr !important;
+    gap: 25px !important;
+    padding: 30px !important;
+    align-items: start !important;
+    align-content: start !important;
+    grid-auto-rows: auto !important;
+}
+
+.workflow > * {
+    align-self: start !important;
+    vertical-align: top !important;
+    margin-top: 0 !important;
+}
+
+.workflow .gradio-column,
+.workflow-column {
+    display: flex !important;
+    flex-direction: column !important;
+    align-items: stretch !important;
+    justify-content: flex-start !important;
+    height: auto !important;
+    min-height: 0 !important;
+    margin-top: 0 !important;
+    padding-top: 0 !important;
+}
+
+.gradio-textbox {
+    border-radius: 10px !important;
+    box-shadow: 0 4px 15px rgba(0,0,0,0.1) !important;
+    flex-grow: 1 !important;
+    min-height: 380px !important;
+    max-height: 380px !important;
+    height: 380px !important;
+}
+
+.gradio-textbox textarea {
+    min-height: 350px !important;
+    max-height: 350px !important;
+    height: 350px !important;
+    resize: vertical !important;
+}
+
+.workflow.rtl {
+    direction: rtl !important;
+}
+
+.workflow.ltr {
+    direction: ltr !important;
+}
+
+h1, h2, h3 {
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.3) !important;
+    margin-top: 0 !important;
+    margin-bottom: 10px !important;
+    padding-top: 0 !important;
+    line-height: 1.2 !important;
+}
+
+h2 {
+    min-height: 40px !important;
+    max-height: 40px !important;
+    display: flex !important;
+    align-items: center !important;
+    margin-bottom: 15px !important;
+}
+
+.status-box {
+    background: linear-gradient(135deg, #4CAF50, #45a049) !important;
+    border: 3px solid #2E7D32 !important;
+    border-radius: 15px !important;
+    padding: 15px !important;
+    margin: 10px 0 !important;
+    box-shadow: 0 8px 32px rgba(76, 175, 80, 0.3) !important;
+    animation: pulse 2s infinite !important;
+    min-height: 120px !important;
+    max-height: 120px !important;
+}
+
+.status-box textarea {
+    background: rgba(255, 255, 255, 0.95) !important;
+    border: none !important;
+    border-radius: 10px !important;
+    font-weight: bold !important;
+    font-size: 1.1em !important;
+    color: #1B5E20 !important;
+    text-shadow: 1px 1px 2px rgba(255, 255, 255, 0.8) !important;
+    min-height: 80px !important;
+    max-height: 80px !important;
+}
+
+@keyframes pulse {
+    0% { box-shadow: 0 8px 32px rgba(76, 175, 80, 0.3); }
+    50% { box-shadow: 0 8px 40px rgba(76, 175, 80, 0.6); }
+    100% { box-shadow: 0 8px 32px rgba(76, 175, 80, 0.3); }
+}
+
+.gradio-button {
+    border-radius: 25px !important;
+    font-weight: bold !important;
+    transition: all 0.3s ease !important;
+    margin: 5px 0 !important;
+    min-height: 50px !important;
+    max-height: 50px !important;
+}
+
+.gradio-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(0,0,0,0.2) !important;
+}
+
+h1 {
+    background: linear-gradient(45deg, #FFD700, #FFA500) !important;
+    -webkit-background-clip: text !important;
+    -webkit-text-fill-color: transparent !important;
+    background-clip: text !important;
+    min-height: 80px !important;
+}
+
+@media (max-width: 1200px) {
+    .workflow {
+        grid-template-columns: 1fr 1fr !important;
+        gap: 20px !important;
+    }
+}
+
+@media (max-width: 768px) {
+    .workflow {
+        grid-template-columns: 1fr !important;
+        gap: 15px !important;
+    }
+    
+    .gradio-textbox {
+        min-height: 300px !important;
+        max-height: 300px !important;
+        height: 300px !important;
+    }
+}
+
+[data-testid="textbox"]:dir(rtl) {
+    text-align: right !important;
+    direction: rtl !important;
+}
+
+[data-testid="textbox"]:dir(ltr) {
+    text-align: left !important;
+    direction: ltr !important;
+}
+
+.gradio-container .gradio-column {
+    align-self: start !important;
+    vertical-align: top !important;
+}
+
+.gradio-container .gradio-row {
+    align-items: flex-start !important;
+}
+
+* {
+    box-sizing: border-box !important;
+}
+
+.gradio-container {
+    align-items: start !important;
+    justify-content: start !important;
+}
+"""
+
+# رابط کاربری Gradio با ترازبندی اصلاح شده
+with gr.Blocks(title="📊 Priority-Based Anonymization System", theme=gr.themes.Soft(), css=custom_css) as app:
+    
+    with gr.Row():
+        language_selector = gr.Radio(
+            choices=["فارسی", "English"],
+            value="فارسی",
+            label="Language / زبان",
+            interactive=True
+        )
+    
+    with gr.Column():
+        title = gr.HTML("<h1 style='text-align: center; color: #FFD700; font-size: 3.5em; font-weight: bold; text-shadow: 3px 3px 6px rgba(0,0,0,0.5); margin: 20px 0; background: linear-gradient(45deg, #FFD700, #FFA500); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;'>📊 سیستم ناشناس‌سازی هوشمند با اولویت‌بندی</h1>")
+        
+        with gr.Row(elem_classes="workflow rtl") as workflow_row:
+            with gr.Column(elem_classes="workflow-column"):
+                step1_title = gr.HTML('<h2 style="direction: rtl;">📝 متن ورودی و تنظیمات</h2>')
+                
+                input_text = gr.Textbox(
+                    lines=15,
+                    placeholder="متن اصلی خود را اینجا وارد کنید...\n✨ سیستم هوشمند اطلاعات حساس مثل شماره تلفن، ایمیل، شماره شبا، حسا�� بانکی را به ترتیب اولویت تشخیص می‌دهد",
+                    label="",
+                    rtl=True
+                )
+                
+                process_btn = gr.Button("🚀 پردازش با تشخیص هوشمند اولویت‌دار", variant="primary")
+                clear_btn = gr.Button("🗑️ پاک کردن همه", variant="stop")
+                
+                status = gr.Textbox(
+                    label="وضعیت",
+                    lines=4,
+                    interactive=False,
+                    rtl=True,
+                    elem_classes=["status-box"]
+                )
+
+            with gr.Column(elem_classes="workflow-column"):
+                step2_title = gr.HTML('<h2 style="direction: rtl;">🎭 متن ناشناس‌شده</h2>')
+                
+                anonymized_output = gr.Textbox(
+                    lines=15,
+                    placeholder="متن ناشناس‌شده اینجا نمایش داده می‌شود...",
+                    label="",
+                    interactive=False,
+                    rtl=True
+                )
+
+            with gr.Column(elem_classes="workflow-column"):
+                step3_title = gr.HTML('<h2 style="direction: rtl;">🤖 پاسخ خام ChatGPT</h2>')
+                
+                gpt_output = gr.Textbox(
+                    lines=15,
+                    placeholder="پاسخ خام ChatGPT اینجا نمایش داده می‌شود...",
+                    label="",
+                    interactive=False,
+                    rtl=True
+                )
+
+            with gr.Column(elem_classes="workflow-column"):
+                step4_title = gr.HTML('<h2 style="direction: rtl;">✅ پاسخ نهایی بازگردانده شده</h2>')
+                
+                final_output = gr.Textbox(
+                    lines=15,
+                    placeholder="پاسخ نهایی اینجا نمایش داده می‌شود...",
+                    label="",
+                    interactive=False,
+                    rtl=True
+                )
+
+        with gr.Row():
+            with gr.Column():
+                mapping_title = gr.HTML('<h2>🗂️ جدول نگاشت اولویت‌دار</h2>')
+                mapping_btn = gr.Button("📋 نمایش جدول نگاشت اولویت‌دار")
+                
+                mapping_output = gr.Textbox(
+                    lines=10,
+                    label="جدول نگاشت اطلاعات",
+                    interactive=False,
+                    visible=False,
+                    rtl=True
+                )
+
+    # Event handlers
+    language_selector.change(
+        fn=update_interface,
+        inputs=[language_selector],
+        outputs=[title, step1_title, input_text, process_btn, clear_btn, 
+                status, step2_title, anonymized_output, step3_title, gpt_output, 
+                step4_title, final_output, mapping_btn, mapping_output, workflow_row]
+    )
+
+    process_btn.click(
+        fn=process_all_steps,
+        inputs=[input_text, language_selector],
+        outputs=[status, anonymized_output, gpt_output, final_output]
+    )
+
+    clear_btn.click(
+        fn=clear_all,
+        outputs=[input_text, anonymized_output, gpt_output, final_output, status]
+    )
+
+    mapping_btn.click(
+        fn=get_mapping_table,
+        inputs=[language_selector],
+        outputs=[mapping_output]
+    )
+
+    mapping_btn.click(
+        fn=lambda: gr.update(visible=True),
+        outputs=[mapping_output]
+    )
+
+if __name__ == "__main__":
+    app.launch(share=True)