Update app.py

app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-سیستم کامل benchmark برای ناشناس‌سازی - همه چیز در یک فایل - ورژن کاملاً اصلاح شده
+سیستم benchmark برای ناشناس‌سازی - فقط پردازش فایل آپلودی کاربر
 """
 
 import pandas as pd
@@ -34,43 +34,36 @@ def convert_to_serializable(obj):
     else:
         return obj
 
-# ===== کلاس ناشناس‌ساز بهبود یافته =====
-class LightweightDataAnonymizer:
+# ===== کلاس پردازش entities =====
+class EntityExtractor:
     def __init__(self):
-        self.mapping_table = {}
-        self.counters = {
-            'PERSON': 0, 'MIXED_NAMES': 0, 'ID_NUMBER': 0, 'ENGLISH_TITLES': 0,
-            'AMOUNT': 0, 'INTERNATIONAL_CURRENCIES': 0, 'ACCOUNT': 0, 
-            'FINANCIAL_TERMS': 0, 'STOCK_SYMBOL': 0,
-            'DATE': 0, 'ADVANCED_DATE_FORMATS': 0, 'TIME_RANGES': 0,
-            'LOCATION': 0, 'COMPLEX_ADDRESSES': 0,
-            'TECHNICAL_CODES': 0, 'NETWORK_ADDRESSES': 0, 'TECHNICAL_UNITS': 0,
-            'ACRONYMS_ABBREVIATIONS': 0,
-            'COMPANY': 0, 'BUSINESS_TERMS': 0, 'PRODUCT': 0, 'PETROCHEMICAL': 0,
-            'PERCENTAGE': 0, 'VOLUME': 0, 'RATIOS': 0,
-            'PHONE': 0, 'EMAIL': 0
-        }
-        self.api_key = os.getenv("OPENAI_API_KEY", "")
-
-    def get_improved_patterns(self):
-        """الگوهای کاملاً بهبود یافته و تست شده"""
-        return {
+        self.patterns = {
             'COMPANY': [
-                r'شرکت\s+پتروشیمی\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+?(?=\s|$|،|\.)',
-                r'شرکت\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]*(?:پتروشیمی|نفت|گاز|صنایع|تولید)[\u0600-\u06FF\u0750-\u077F\s\u200C]*',
-                r'بانک\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
                 r'شرکت\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
-                r'(?:پتروشیمی|بانک)\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
-                r'[A-Z][a-zA-Z\s]+(?:Inc|Corp|Corporation|Company|Ltd|Limited|LLC)'
+                r'بانک\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+', 
+                r'[\u0600-\u06FF\u0750-\u077F\s\u200C]*(?:پتروشیمی|بانک|شرکت|صنایع|تولید)[\u0600-\u06FF\u0750-\u077F\s\u200C]*',
+                r'[A-Z][a-zA-Z\s]+(?:Inc|Corp|Corporation|Company|Ltd|Limited|LLC)',
             ],
             
             'LOCATION': [
                 r'بندر\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
                 r'شهر\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
                 r'استان\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
-                r'\b(?:تهران|اصفهان|ماهشهر|عسلویه|بندرعباس|اهواز|شیراز|مشهد|تبریز|کرج|قم|رشت|کرمان|یزد|زاهدان|بوشهر|خرمشهر|آبادان|اراک|قزوین)\b',
+                r'\b(?:تهران|اصفهان|ماهشهر|عسلویه|بندرعباس|اهواز|شیراز|مشهد|تبریز|کرج|قم|رشت|کرمان|یزد|زاهدان|بوشهر|خرمشهر|آبادان|اراک|قزوین|خوزستان)\b',
                 r'\b(?:ایران|عراق|کویت|عربستان|امارات|قطر|عمان|بحرین|ترکیه|پاکستان|افغانستان)\b',
-                r'\b(?:London|Paris|Tokyo|New\s+York|Dubai|Singapore|Hong\s+Kong|Shanghai|Mumbai|Frankfurt|Amsterdam)\b'
+                r'\b(?:London|Paris|Tokyo|New\s+York|Dubai|Singapore|Hong\s+Kong)\b'
+            ],
+            
+            'PERSON': [
+                r'آقای\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
+                r'خانم\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
+                r'مهندس\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
+                r'دکتر\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
+                r'مدیرعامل\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+',
+                r'[\u0600-\u06FF\u0750-\u077F\s\u200C]+\s+مدیرعامل',
+                r'Mr\.\s+[a-zA-Z\s]+',
+                r'Ms\.\s+[a-zA-Z\s]+',
+                r'Dr\.\s+[a-zA-Z\s]+'
             ],
             
             'DATE': [
@@ -83,223 +76,213 @@ class LightweightDataAnonymizer:
                 r'(?:13[0-9]{2}|14[0-9]{2}|20[0-9]{2}|19[0-9]{2})(?=\s|$|،|\.)'
             ],
             
-            'PERSON': [
-                r'آقای\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+?(?=\s|$|،|\.)',
-                r'خانم\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+?(?=\s|$|،|\.)',
-                r'مهندس\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+?(?=\s|$|،|\.)',
-                r'دکتر\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+?(?=\s|$|،|\.)',
-                r'استاد\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+?(?=\s|$|،|\.)',
-                r'مدیرعامل\s+[\u0600-\u06FF\u0750-\u077F\s\u200C]+?(?=\s|$|،|\.)',
-                r'[\u0600-\u06FF\u0750-\u077F\s\u200C]+\s+مدیرعامل(?=\s|$|،|\.)',
-                r'Mr\.\s+[a-zA-Z\s]+?(?=\s|,|\.|$)',
-                r'Ms\.\s+[a-zA-Z\s]+?(?=\s|,|\.|$)',
-                r'Dr\.\s+[a-zA-Z\s]+?(?=\s|,|\.|$)'
-            ],
-            
             'PHONE': [
-                r'(?:تلفن[\s:]*)?(?:شماره[\s:]*)?(?:0)?(?:[\u06F0-\u06F90-9]{2,3}[-\s]?)?[\u06F0-\u06F90-9]{7,8}',
-                r'(?:تماس[\s:]*)?(?:شماره[\s:]*)?(?:با[\s]*)?(?:0)?(?:[\u06F0-\u06F90-9]{2,3}[-\s]?)?[\u06F0-\u06F90-9]{7,8}',
-                r'(?:موبایل[\s:]*)?(?:شماره[\s:]*)?(?:0)?9[\u06F0-\u06F90-9]{9}',
-                r'[\u06F0-\u06F90-9]{3,4}[-\s][\u06F0-\u06F90-9]{7,8}',
+                r'(?:شماره[\s]*تماس[\s:]*)?(?:0)?9[\u06F0-\u06F90-9]{9}',
+                r'(?:تلفن[\s:]*)?(?:0)?[\u06F0-\u06F90-9]{2,3}[-\s]?[\u06F0-\u06F90-9]{7,8}',
                 r'[\u06F0-\u06F90-9]{11}(?!\d)',
-                r'09[\u06F0-\u06F90-9]{9}',
-                r'\+[0-9]{1,3}-[0-9]{3}-[0-9]{3}-[0-9]{4}(?:\s+ext\.\s+[0-9]{3,4})?',
-                r'\([0-9]{3}\)\s+[0-9]{3}-[0-9]{4}'
+                r'\+[0-9]{1,3}[-\s][0-9]{3}[-\s][0-9]{3}[-\s][0-9]{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,}'
             ],
             
             'AMOUNT': [
                 r'\d+(?:,\d{3})*\s*(?:میلیون|میلیارد|هزار)\s*تومان',
                 r'مبلغ\s+\d+(?:,\d{3})*\s*(?:میلیون|میلیارد|هزار)?\s*تومان',
                 r'\d+\s*تومان',
-                r'\$\d+(?:,\d{3})*(?:\.\d+)?\s*(?:million|billion|thousand|M|B|K)?',
+                r'\$\d+(?:,\d{3})*(?:\.\d+)?(?:\s*(?:million|billion|thousand|M|B|K))?',
                 r'\d+(?:,\d{3})*\s*ریال'
             ],
             
             'ACCOUNT': [
-                r'(?:شماره[\s]*)?(?:حساب[\s]*)?(?:بانکی[\s:]*)?(?:[\u06F0-\u06F90-9]{1,3}[-\s]?)*[\u06F0-\u06F90-9]{8,20}',
-                r'حساب[\s]*(?:شماره[\s:]*)?(?:[\u06F0-\u06F90-9]{1,3}[-\s]?)*[\u06F0-\u06F90-9]{8,20}',
-                r'شماره[\s]*حساب[\s:]*(?:[\u06F0-\u06F90-9]{1,3}[-\s]?)*[\u06F0-\u06F90-9]{8,20}',
-                r'Account[\s]*(?:Number[\s:]*)?(?:[0-9]{1,3}[-\s]?)*[0-9]{8,20}',
-                r'[\u06F0-\u06F90-9]{3}[-\s]?[\u06F0-\u06F90-9]{3}[-\s]?[\u06F0-\u06F90-9]{6,12}'
+                r'(?:شماره[\s]*حساب[\s:]*)?[\u06F0-\u06F90-9]{3}[-\s]?[\u06F0-\u06F90-9]{3}[-\s]?[\u06F0-\u06F90-9]{6,12}',
+                r'(?:حساب[\s]*شماره[\s:]*)?[\u06F0-\u06F90-9]{8,20}',
             ]
         }
-
-    def is_valid_entity(self, entity_text, category):
-        """بررسی معتبر بودن entity"""
-        # کلمات ممنوع عمومی
-        forbidden_words = ['شد', 'کرد', 'داد', 'است', 'بود', 'در', 'که', 'با', 'از', 'به', 'را', 'و', 'یا']
-        
+    
+    def clean_entity(self, text):
+        """تمیز کردن entity استخراج شده"""
+        # حذف کلمات اضافی در انتها
+        text = re.sub(r'\s*(در|که|با|به|از|را|و|یا)\s*$', '', text).strip()
         # حذف فاصله‌های اضافی
-        entity_text = re.sub(r'\s+', ' ', entity_text.strip())
-        
-        # بررسی طول کافی
-        if len(entity_text) < 3:
+        text = re.sub(r'\s+', ' ', text).strip()
+        return text
+    
+    def is_valid_entity(self, text):
+        """بررسی معتبر بودن entity"""
+        if len(text) < 2:
             return False
         
-        # بررسی کلمات ممنوع
-        for word in forbidden_words:
-            if entity_text.endswith(' ' + word) or entity_text.startswith(word + ' '):
-                return False
-        
-        # بررسی‌های خاص بر اساس دسته‌بندی
-        if category == 'COMPANY':
-            # شرکت نباید فقط کلمات عمومی باشد
-            if entity_text in ['شرکت', 'بانک', 'پتروشیمی']:
-                return False
+        # کلمات ممنوع
+        forbidden = ['شد', 'کرد', 'است', 'بود', 'در', 'که', 'با', 'از', 'به', 'را', 'و', 'یا']
+        if text.lower() in forbidden:
+            return False
         
         return True
-
-# ===== کلاس Benchmark بهبود یافته =====
-class AnonymizationBenchmark:
-    def __init__(self):
-        self.anonymizer = LightweightDataAnonymizer()
-        self.results = []
-        
-    def extract_entities_from_text(self, text: str) -> Dict[str, List[str]]:
-        """استخراج تمام entities موجود در متن اصلی با الگوهای بهبود یافته"""
-        entities = defaultdict(list)
-        
+    
+    def extract_entities(self, text):
+        """استخراج entities از متن"""
         if not text or text.strip() == '':
-            return dict(entities)
+            return {}
         
-        # استفاده از الگوهای بهبود یافته
-        patterns = self.anonymizer.get_improved_patterns()
+        entities = {}
         
-        for category, pattern_list in patterns.items():
+        for category, pattern_list in self.patterns.items():
+            found_entities = []
+            
             for pattern_str in pattern_list:
                 try:
-                    # تبدیل string به regex object
                     pattern = re.compile(pattern_str, re.IGNORECASE | re.MULTILINE)
-                    
                     matches = pattern.finditer(text)
+                    
                     for match in matches:
-                        # capture کل match
-                        full_match = match.group(0).strip()
-                        
-                        # تمیز کردن match
-                        full_match = re.sub(r'\s+', ' ', full_match)
-                        full_match = re.sub(r'\s*(در|که|با|به|از|را)\s*$', '', full_match).strip()
-                        
-                        if self.anonymizer.is_valid_entity(full_match, category):
-                            entities[category].append(full_match)
-                            
+                        entity = self.clean_entity(match.group(0))
+                        if self.is_valid_entity(entity):
+                            found_entities.append(entity)
+                
                 except re.error as e:
                     logger.error(f"Regex error in pattern {pattern_str}: {e}")
                     continue
-                except Exception as e:
-                    logger.error(f"Unexpected error in pattern {pattern_str}: {e}")
-                    continue
-        
-        # حذف duplicates و مرتب‌سازی
-        for category in entities:
-            entities[category] = sorted(list(set(entities[category])))
+            
+            # حذف تکراری‌ها و مرتب‌سازی
+            if found_entities:
+                entities[category] = sorted(list(set(found_entities)))
         
-        return dict(entities)
+        return entities
     
-    def extract_anonymized_codes(self, anonymized_text: str) -> Dict[str, List[str]]:
-        """استخراج کدهای ناشناس‌سازی شده از متن خروجی"""
-        anonymized_entities = defaultdict(list)
-        
-        if not anonymized_text or anonymized_text.strip() == '':
-            return dict(anonymized_entities)
+    def extract_anonymized_codes(self, text):
+        """استخراج کدهای ناشناس‌سازی"""
+        if not text or text.strip() == '':
+            return {}
         
-        # الگو برای کدهای ناشناس‌سازی: category_number
+        codes = {}
         pattern = r'([a-zA-Z_]+)_(\d{3})'
         
         try:
-            matches = re.finditer(pattern, anonymized_text, re.IGNORECASE)
+            matches = re.finditer(pattern, text, re.IGNORECASE)
             for match in matches:
                 category = match.group(1).upper()
                 code = match.group(0)
-                anonymized_entities[category].append(code)
+                
+                if category not in codes:
+                    codes[category] = []
+                codes[category].append(code)
+        
         except Exception as e:
-            logger.error(f"Error extracting anonymized codes: {e}")
+            logger.error(f"Error extracting codes: {e}")
         
-        # حذف duplicates
-        for category in anonymized_entities:
-            anonymized_entities[category] = sorted(list(set(anonymized_entities[category])))
+        # حذف تکراری‌ها
+        for category in codes:
+            codes[category] = sorted(list(set(codes[category])))
         
-        return dict(anonymized_entities)
+        return codes
+
+# ===== کلاس Benchmark =====
+class AnonymizationBenchmark:
+    def __init__(self):
+        self.extractor = EntityExtractor()
     
-    def calculate_metrics_for_text(self, original_text: str, anonymized_text: str) -> Dict:
-        """محاسبه متریک‌های ارزیابی برای یک جفت متن"""
+    def analyze_single_row(self, original_text, anonymized_text):
+        """تحلیل یک ردیف از CSV"""
+        print(f"\n{'='*60}")
+        print("تحلیل دقیق ردیف:")
+        print(f"{'='*60}")
         
-        logger.info(f"Processing texts - Original length: {len(original_text)}, Anonymized length: {len(anonymized_text)}")
+        print(f"\n📝 متن اصلی:")
+        print(f"'{original_text}'")
+        print(f"طول: {len(original_text)} کاراکتر")
+        
+        print(f"\n🔒 متن ناشناس‌سازی شده:")
+        print(f"'{anonymized_text}'")
+        print(f"طول: {len(anonymized_text)} کاراکتر")
         
         # استخراج entities از متن اصلی
-        original_entities = self.extract_entities_from_text(original_text)
-        logger.info(f"Original entities found: {original_entities}")
+        print(f"\n🔍 استخراج Entities از متن اصلی:")
+        original_entities = self.extractor.extract_entities(original_text)
+        
+        total_original_entities = 0
+        for category, entities in original_entities.items():
+            print(f"  {category}: {len(entities)} عدد")
+            for i, entity in enumerate(entities, 1):
+                print(f"    {i}. '{entity}'")
+            total_original_entities += len(entities)
+        
+        if not original_entities:
+            print("  هیچ entity ای یافت نشد!")
+        else:
+            print(f"\n✅ مجموع entities یافت شده: {total_original_entities}")
         
-        # استخراج کدهای ناشناس‌سازی شده
-        anonymized_codes = self.extract_anonymized_codes(anonymized_text)
-        logger.info(f"Anonymized codes found: {anonymized_codes}")
+        # استخراج کدهای ناشناس‌سازی
+        print(f"\n🔍 استخراج کدهای ناشناس‌سازی:")
+        anonymized_codes = self.extractor.extract_anonymized_codes(anonymized_text)
         
-        # محاسبه متریک‌ها برای هر category
+        total_anonymized_codes = 0
+        for category, codes in anonymized_codes.items():
+            print(f"  {category}: {len(codes)} عدد")
+            for i, code in enumerate(codes, 1):
+                print(f"    {i}. '{code}'")
+            total_anonymized_codes += len(codes)
+        
+        if not anonymized_codes:
+            print("  هیچ کد ناشناس‌سازی یافت نشد!")
+        else:
+            print(f"\n✅ مجموع کدهای ناشناس‌سازی: {total_anonymized_codes}")
+        
+        # محاسبه متریک‌ها
+        print(f"\n📊 محاسبه متریک‌ها:")
         category_metrics = {}
         total_tp, total_fp, total_fn = 0, 0, 0
         
-        # تمام categories که در هر کدام وجود دارند
         all_categories = set(original_entities.keys()) | set(anonymized_codes.keys())
         
         for category in all_categories:
             original_count = len(original_entities.get(category, []))
             anonymized_count = len(anonymized_codes.get(category, []))
             
-            # True Positives: تعداد entities که درست ناشناس‌سازی شدند
             tp = min(original_count, anonymized_count)
-            
-            # False Positives: entities اضافی که اشتباه ناشناس‌سازی شدند
             fp = max(0, anonymized_count - original_count)
-            
-            # False Negatives: entities که شناسایی نشدند
             fn = max(0, original_count - anonymized_count)
             
-            # محاسبه متریک‌های category
             precision = tp / (tp + fp) if (tp + fp) > 0 else 0
             recall = tp / (tp + fn) if (tp + fn) > 0 else 0
             f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
             
+            print(f"\n  {category}:")
+            print(f"    Original: {original_count}, Anonymized: {anonymized_count}")
+            print(f"    TP: {tp}, FP: {fp}, FN: {fn}")
+            print(f"    Precision: {precision:.4f}, Recall: {recall:.4f}, F1: {f1_score:.4f}")
+            
             category_metrics[category] = {
                 'original_count': original_count,
                 'anonymized_count': anonymized_count,
-                'tp': tp,
-                'fp': fp,
-                'fn': fn,
-                'precision': precision,
-                'recall': recall,
-                'f1_score': f1_score
+                'tp': tp, 'fp': fp, 'fn': fn,
+                'precision': precision, 'recall': recall, 'f1_score': f1_score
             }
             
             total_tp += tp
             total_fp += fp
             total_fn += fn
         
-        # محاسبه متریک‌های کلی
+        # متریک‌های کلی
         overall_precision = total_tp / (total_tp + total_fp) if (total_tp + total_fp) > 0 else 0
         overall_recall = total_tp / (total_tp + total_fn) if (total_tp + total_fn) > 0 else 0
         overall_f1 = 2 * (overall_precision * overall_recall) / (overall_precision + overall_recall) if (overall_precision + overall_recall) > 0 else 0
+        accuracy = total_tp / total_original_entities if total_original_entities > 0 else 0
         
-        # Accuracy: نسبت entities درست شناسایی شده به کل entities
-        total_original = sum(len(entities) for entities in original_entities.values())
-        accuracy = total_tp / total_original if total_original > 0 else 0
-        
-        logger.info(f"Calculated metrics - TP: {total_tp}, FP: {total_fp}, FN: {total_fn}")
+        print(f"\n🎯 متریک‌های کلی:")
+        print(f"  Precision: {overall_precision:.4f}")
+        print(f"  Recall: {overall_recall:.4f}")
+        print(f"  F1-Score: {overall_f1:.4f}")
+        print(f"  Accuracy: {accuracy:.4f}")
         
         return {
             'original_entities': original_entities,
             'anonymized_codes': anonymized_codes,
             'category_metrics': category_metrics,
             'overall_metrics': {
-                'total_original_entities': total_original,
-                'total_anonymized_entities': sum(len(codes) for codes in anonymized_codes.values()),
+                'total_original_entities': total_original_entities,
+                'total_anonymized_entities': total_anonymized_codes,
                 'total_tp': total_tp,
                 'total_fp': total_fp,
                 'total_fn': total_fn,
@@ -310,393 +293,211 @@ class AnonymizationBenchmark:
             }
         }
     
-    def benchmark_from_csv(self, csv_file_path: str) -> pd.DataFrame:
-        """اجرای benchmark روی فایل CSV"""
-        
-        # خواندن فایل CSV
+    def process_csv(self, csv_file_path):
+        """پردازش فایل CSV"""
         try:
-            # تلاش برای خواندن با encoding مختلف
+            # خواندن فایل با encoding های مختلف
+            df = None
             for encoding in ['utf-8', 'utf-8-sig', 'cp1256', 'windows-1256']:
                 try:
                     df = pd.read_csv(csv_file_path, encoding=encoding)
-                    logger.info(f"Successfully loaded CSV with {encoding} encoding. Shape: {df.shape}")
+                    print(f"✅ فایل با encoding {encoding} خوانده شد")
                     break
                 except UnicodeDecodeError:
                     continue
-            else:
-                raise Exception("Could not read CSV file with any encoding")
-                
-        except Exception as e:
-            logger.error(f"Error loading CSV file: {e}")
-            return None
-        
-        # بررسی وجود ستون‌های مورد نیاز
-        if 'original_text' not in df.columns or 'anonymized_text' not in df.columns:
-            logger.error(f"CSV file must contain 'original_text' and 'anonymized_text' columns. Found columns: {df.columns.tolist()}")
-            return None
-        
-        # بررسی اینکه آیا داده موجود است
-        if len(df) == 0:
-            logger.error("CSV file is empty")
-            return None
-        
-        results = []
-        
-        for index, row in df.iterrows():
-            logger.info(f"Processing row {index + 1}/{len(df)}")
             
-            try:
+            if df is None:
+                return "❌ خطا: نمی‌توان فایل را با هیچ encoding خواند"
+            
+            print(f"📋 اطلاعات فایل CSV:")
+            print(f"  تعداد ردیف‌ها: {len(df)}")
+            print(f"  ستون‌ها: {df.columns.tolist()}")
+            
+            # بررسی ستون‌ها
+            if 'original_text' not in df.columns or 'anonymized_text' not in df.columns:
+                return f"❌ خطا: فایل باید شامل ستون‌های 'original_text' و 'anonymized_text' باشد. ستون‌های موجود: {df.columns.tolist()}"
+            
+            if len(df) == 0:
+                return "❌ خطا: فایل خالی است"
+            
+            # پردازش هر ردیف
+            results = []
+            all_analysis = []
+            
+            for index, row in df.iterrows():
+                print(f"\n🔄 پردازش ردیف {index + 1} از {len(df)}")
+                
                 original_text = str(row['original_text']) if pd.notna(row['original_text']) else ""
                 anonymized_text = str(row['anonymized_text']) if pd.notna(row['anonymized_text']) else ""
                 
                 if original_text.strip() == "" and anonymized_text.strip() == "":
-                    logger.warning(f"Row {index} has empty texts, skipping...")
+                    print("⚠️  ردیف خالی است، رد می‌شود")
                     continue
                 
-                # محاسبه متریک‌ها
-                metrics = self.calculate_metrics_for_text(original_text, anonymized_text)
+                # تحلیل دقیق
+                analysis = self.analyze_single_row(original_text, anonymized_text)
+                all_analysis.append(analysis)
                 
-                # ذخیره نتایج
+                # ذخیره نتیجه
                 result = {
                     'row_id': int(index),
                     'original_text': original_text,
                     'anonymized_text': anonymized_text,
-                    'total_original_entities': int(metrics['overall_metrics']['total_original_entities']),
-                    'total_anonymized_entities': int(metrics['overall_metrics']['total_anonymized_entities']),
-                    'tp': int(metrics['overall_metrics']['total_tp']),
-                    'fp': int(metrics['overall_metrics']['total_fp']),
-                    'fn': int(metrics['overall_metrics']['total_fn']),
-                    'precision': float(metrics['overall_metrics']['precision']),
-                    'recall': float(metrics['overall_metrics']['recall']),
-                    'f1_score': float(metrics['overall_metrics']['f1_score']),
-                    'accuracy': float(metrics['overall_metrics']['accuracy'])
+                    **{k: convert_to_serializable(v) for k, v in analysis['overall_metrics'].items()}
                 }
                 
-                # اضافه کردن متریک‌های category به result
-                for category, cat_metrics in metrics['category_metrics'].items():
-                    result[f'{category.lower()}_precision'] = float(cat_metrics['precision'])
-                    result[f'{category.lower()}_recall'] = float(cat_metrics['recall'])
-                    result[f'{category.lower()}_f1'] = float(cat_metrics['f1_score'])
-                    result[f'{category.lower()}_original_count'] = int(cat_metrics['original_count'])
-                    result[f'{category.lower()}_anonymized_count'] = int(cat_metrics['anonymized_count'])
+                # اضافه کردن متریک‌های category
+                for category, metrics in analysis['category_metrics'].items():
+                    for metric_name, value in metrics.items():
+                        result[f'{category.lower()}_{metric_name}'] = convert_to_serializable(value)
                 
                 results.append(result)
-                
-            except Exception as e:
-                logger.error(f"Error processing row {index}: {e}")
-                continue
-        
-        if len(results) == 0:
-            logger.error("No valid results were generated")
-            return None
-        
-        return pd.DataFrame(results)
-    
-    def generate_summary_report(self, results_df: pd.DataFrame) -> Dict:
-        """تولید گزارش خلاصه"""
-        
-        if results_df is None or len(results_df) == 0:
-            return {}
-        
-        try:
-            summary = {
-                'total_texts_processed': len(results_df),
-                'average_metrics': {
-                    'precision': float(results_df['precision'].mean()),
-                    'recall': float(results_df['recall'].mean()),
-                    'f1_score': float(results_df['f1_score'].mean()),
-                    'accuracy': float(results_df['accuracy'].mean())
-                },
-                'total_entities': {
-                    'original': int(results_df['total_original_entities'].sum()),
-                    'anonymized': int(results_df['total_anonymized_entities'].sum()),
-                    'tp': int(results_df['tp'].sum()),
-                    'fp': int(results_df['fp'].sum()),
-                    'fn': int(results_df['fn'].sum())
-                }
-            }
-            
-            # محاسبه متریک‌های کلی بر اساس مجموع
-            total_tp = summary['total_entities']['tp']
-            total_fp = summary['total_entities']['fp']
-            total_fn = summary['total_entities']['fn']
-            total_original = summary['total_entities']['original']
-            
-            summary['overall_metrics'] = {
-                'precision': total_tp / (total_tp + total_fp) if (total_tp + total_fp) > 0 else 0,
-                'recall': total_tp / (total_tp + total_fn) if (total_tp + total_fn) > 0 else 0,
-                'accuracy': total_tp / total_original if total_original > 0 else 0
-            }
             
-            # F1-Score کلی
-            overall_precision = summary['overall_metrics']['precision']
-            overall_recall = summary['overall_metrics']['recall']
-            summary['overall_metrics']['f1_score'] = 2 * (overall_precision * overall_recall) / (overall_precision + overall_recall) if (overall_precision + overall_recall) > 0 else 0
+            if not results:
+                return "❌ خطا: هیچ ردیف معتبری برای پردازش یافت نشد"
             
-            # آمار category-wise
-            category_columns = [col for col in results_df.columns if col.endswith('_precision')]
-            categories = [col.replace('_precision', '').upper() for col in category_columns]
-            
-            category_summary = {}
-            for category in categories:
-                cat_lower = category.lower()
-                if f'{cat_lower}_precision' in results_df.columns:
-                    # فیلتر کردن ردیف‌هایی که این category دارند
-                    mask = results_df[f'{cat_lower}_original_count'] > 0
-                    if mask.any():
-                        category_summary[category] = {
-                            'count_texts_with_category': int(mask.sum()),
-                            'average_precision': float(results_df.loc[mask, f'{cat_lower}_precision'].mean()),
-                            'average_recall': float(results_df.loc[mask, f'{cat_lower}_recall'].mean()),
-                            'average_f1': float(results_df.loc[mask, f'{cat_lower}_f1'].mean()),
-                            'total_original': int(results_df[f'{cat_lower}_original_count'].sum()),
-                            'total_anonymized': int(results_df[f'{cat_lower}_anonymized_count'].sum())
-                        }
-            
-            summary['category_summary'] = category_summary
-            
-            # تبدیل همه مقادیر به serializable types
-            summary = convert_to_serializable(summary)
-            
-            return summary
+            return pd.DataFrame(results), all_analysis
             
         except Exception as e:
-            logger.error(f"Error generating summary report: {e}")
-            return {'error': str(e)}
+            return f"❌ خطا در پردازش: {str(e)}"
 
-# ===== رابط گرافیکی =====
-def create_sample_csv():
-    """ایجاد فایل نمونه CSV برای تست"""
-    sample_data = [
-        {
-            'original_text': 'مجمع عمومی عادی سالیانه شرکت پتروشیمی کارون در بندر ماهشهر برگزار شد.',
-            'anonymized_text': 'مجمع عمومی عادی سالیانه company_001 در location_001 برگزار شد.'
-        },
-        {
-            'original_text': 'آقای احمد محمدی مدیرعامل شرکت با شماره تماس 09123456789 و ایمیل ahmad@company.com قرارداد امضا کرد.',
-            'anonymized_text': 'person_001 مدیرعامل شرکت با شماره تماس phone_001 و ایمیل email_001 قرارداد امضا کرد.'
-        },
-        {
-            'original_text': 'بانک ملی ایران مبلغ 500 میلیون تومان به حساب 123-456-789012 واریز کرد.',
-            'anonymized_text': 'company_001 مبلغ amount_001 به حساب account_001 واریز کرد.'
-        }
-    ]
+# ===== رابط Gradio =====
+def process_uploaded_file(file):
+    """پردازش فایل آپلود شده کاربر"""
+    if file is None:
+        return "❌ لطفاً ابتدا فایل CSV را آپلود کنید.", None
     
-    df = pd.DataFrame(sample_data)
-    sample_file_path = 'sample_benchmark_data.csv'
-    df.to_csv(sample_file_path, index=False, encoding='utf-8-sig')
+    print(f"\n🚀 شروع پردازش فایل: {file.name}")
     
-    # همچنین یک فایل نمونه با نام فارسی ایجاد کنیم
-    df.to_csv('نمونه_benchmark.csv', index=False, encoding='utf-8-sig')
+    benchmark = AnonymizationBenchmark()
+    result = benchmark.process_csv(file.name)
     
-    return f"فایل‌های نمونه ایجاد شدند: {sample_file_path} و نمونه_benchmark.csv"
-
-def process_csv_file(file):
-    """پردازش فایل CSV آپلود شده"""
-    if file is None:
-        return "لطفاً فایل CSV را آپلود کنید.", None, None
+    if isinstance(result, str):
+        # خطا رخ داده
+        return result, None
     
-    try:
-        logger.info(f"Processing file: {file.name}")
-        
-        # بررسی وجود فایل
-        if not os.path.exists(file.name):
-            return "فایل آپلود شده یافت نشد.", None, None
-        
-        # خواندن فایل آپلود شده
-        try:
-            df = pd.read_csv(file.name, encoding='utf-8')
-        except UnicodeDecodeError:
-            df = pd.read_csv(file.name, encoding='utf-8-sig')
-        except Exception as e:
-            return f"خطا در خواندن فایل: {str(e)}", None, None
-        
-        logger.info(f"CSV loaded successfully. Shape: {df.shape}, Columns: {df.columns.tolist()}")
-        
-        # بررسی ستون‌ها
-        if 'original_text' not in df.columns or 'anonymized_text' not in df.columns:
-            return f"فایل CSV باید شامل ستون‌های 'original_text' و 'anonymized_text' باشد. ستون‌های موجود: {df.columns.tolist()}", None, None
-        
-        # اجرای benchmark
-        benchmark = AnonymizationBenchmark()
-        results_df = benchmark.benchmark_from_csv(file.name)
-        
-        if results_df is None or len(results_df) == 0:
-            return "خطا در پردازش فایل CSV یا هیچ نتیجه معتبری تولید نشد!", None, None
-        
-        logger.info(f"Benchmark completed. Results shape: {results_df.shape}")
-        
-        # تولید گزارش خلاصه
-        summary = benchmark.generate_summary_report(results_df)
-        
-        if 'error' in summary:
-            return f"خطا در تولید گزارش: {summary['error']}", None, None
-        
-        # آماده‌سازی نتایج برای نمایش
-        metrics_text = f"""
-=== نتایج کلی Benchmark ===
-
-تعداد متون پردازش شده: {summary.get('total_texts_processed', 0)}
-
-=== متریک‌های کلی (بر اساس مجموع) ===
-• Precision: {summary.get('overall_metrics', {}).get('precision', 0):.4f}
-• Recall: {summary.get('overall_metrics', {}).get('recall', 0):.4f}  
-• F1-Score: {summary.get('overall_metrics', {}).get('f1_score', 0):.4f}
-• Accuracy: {summary.get('overall_metrics', {}).get('accuracy', 0):.4f}
+    results_df, all_analysis = result
+    
+    # تولید گزارش نهایی
+    total_rows = len(results_df)
+    avg_precision = results_df['precision'].mean() if 'precision' in results_df.columns else 0
+    avg_recall = results_df['recall'].mean() if 'recall' in results_df.columns else 0
+    avg_f1 = results_df['f1_score'].mean() if 'f1_score' in results_df.columns else 0
+    avg_accuracy = results_df['accuracy'].mean() if 'accuracy' in results_df.columns else 0
+    
+    total_original = results_df['total_original_entities'].sum() if 'total_original_entities' in results_df.columns else 0
+    total_anonymized = results_df['total_anonymized_entities'].sum() if 'total_anonymized_entities' in results_df.columns else 0
+    total_tp = results_df['total_tp'].sum() if 'total_tp' in results_df.columns else 0
+    total_fp = results_df['total_fp'].sum() if 'total_fp' in results_df.columns else 0
+    total_fn = results_df['total_fn'].sum() if 'total_fn' in results_df.columns else 0
+    
+    # گزارش نهایی
+    report = f"""
+{'='*60}
+📊 گزارش نهایی Benchmark
+{'='*60}
 
-=== آمار کلی Entities ===
-• تعداد کل Entities اصلی: {summary.get('total_entities', {}).get('original', 0)}
-• تعداد کل Entities ناشناس‌سازی شده: {summary.get('total_entities', {}).get('anonymized', 0)}
-• True Positives: {summary.get('total_entities', {}).get('tp', 0)}
-• False Positives: {summary.get('total_entities', {}).get('fp', 0)}
-• False Negatives: {summary.get('total_entities', {}).get('fn', 0)}
+📈 آمار کلی:
+  • تعداد ردیف‌های پردازش شده: {total_rows}
+  • مجموع Entities اصلی: {total_original}
+  • مجموع کدهای ناشناس‌سازی: {total_anonymized}
+  • True Positives: {total_tp}
+  • False Positives: {total_fp}
+  • False Negatives: {total_fn}
 
-=== متریک‌های میانگین ===
-• میانگین Precision: {summary.get('average_metrics', {}).get('precision', 0):.4f}
-• میانگین Recall: {summary.get('average_metrics', {}).get('recall', 0):.4f}
-• میانگین F1-Score: {summary.get('average_metrics', {}).get('f1_score', 0):.4f}
-• میانگین Accuracy: {summary.get('average_metrics', {}).get('accuracy', 0):.4f}
-"""
+🎯 متریک‌های میانگین:
+  • Precision: {avg_precision:.4f}
+  • Recall: {avg_recall:.4f}
+  • F1-Score: {avg_f1:.4f}
+  • Accuracy: {avg_accuracy:.4f}
 
-        # اضافه کردن آمار دسته‌بندی‌ها
-        if 'category_summary' in summary and summary['category_summary']:
-            metrics_text += "\n=== آمار دسته‌بندی‌ها ===\n"
-            for category, stats in summary['category_summary'].items():
-                metrics_text += f"""
-{category}:
-• تعداد متون دارای این دسته: {stats.get('count_texts_with_category', 0)}
-• میانگین Precision: {stats.get('average_precision', 0):.4f}
-• میانگین Recall: {stats.get('average_recall', 0):.4f}
-• میانگین F1-Score: {stats.get('average_f1', 0):.4f}
-• کل Entities اصلی: {stats.get('total_original', 0)}
-• کل Entities ناشناس‌سازی شده: {stats.get('total_anonymized', 0)}
+📋 جزئیات هر ردیف در جدول زیر نمایش داده شده است.
 """
-        else:
-            metrics_text += "\n=== آمار دسته‌بندی‌ها ===\nهیچ دسته‌ای یافت نشد.\n"
-
-        # ذخیره گزارش‌ها
-        try:
-            results_df.to_csv("benchmark_results_detailed.csv", index=False, encoding='utf-8-sig')
-            with open("benchmark_results_summary.json", 'w', encoding='utf-8') as f:
-                json.dump(summary, f, ensure_ascii=False, indent=2)
-            logger.info("Results saved successfully")
-        except Exception as e:
-            logger.error(f"Error saving results: {e}")
-        
-        # انتخاب ستون‌های مهم برای نمایش
-        display_columns = ['row_id', 'precision', 'recall', 'f1_score', 'accuracy', 'total_original_entities', 'total_anonymized_entities']
-        display_df = results_df[display_columns] if all(col in results_df.columns for col in display_columns) else results_df
-        
-        return (
-            metrics_text,
-            display_df,
-            summary
-        )
-        
+    
+    # ذخیره نتایج
+    try:
+        results_df.to_csv("benchmark_results.csv", index=False, encoding='utf-8-sig')
+        print("✅ نتایج در فایل benchmark_results.csv ذخیره شد")
     except Exception as e:
-        logger.error(f"Unexpected error in process_csv_file: {e}")
-        return f"خطای غیرمنتظره در پردازش: {str(e)}", None, None
+        print(f"⚠️  خطا در ذخیره فایل: {e}")
+    
+    # ستون‌های مهم برای نمایش
+    display_columns = ['row_id', 'total_original_entities', 'total_anonymized_entities', 
+                      'tp', 'fp', 'fn', 'precision', 'recall', 'f1_score', 'accuracy']
+    
+    display_df = results_df[[col for col in display_columns if col in results_df.columns]]
+    
+    return report, display_df
 
 def download_results():
-    """دانلود فایل نتایج"""
-    if os.path.exists("benchmark_results_detailed.csv"):
-        return "benchmark_results_detailed.csv"
+    """دانلود نتایج"""
+    if os.path.exists("benchmark_results.csv"):
+        return "benchmark_results.csv"
     return None
 
-# ===== رابط اصلی Gradio =====
+# ===== رابط اصلی =====
 def main():
-    """رابط اصلی"""
-    
-    with gr.Blocks(title="Anonymization Benchmark", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(title="Benchmark System", theme=gr.themes.Soft()) as demo:
         
         gr.HTML("""
         <h1 style='text-align: center; color: #2E86AB; margin-bottom: 30px;'>
-        📊 سیستم ارزیابی Benchmark ناشناس‌سازی - ورژن بهبود یافته
+        🎯 سیستم Benchmark ناشناس‌سازی - پردازش فایل آپلودی
         </h1>
         """)
         
         with gr.Row():
             with gr.Column():
-                gr.HTML("<h3>📁 آپلود فایل CSV</h3>")
                 gr.HTML("""
-                <div style='background: #f0f8ff; padding: 15px; border-radius: 10px; margin-bottom: 15px;'>
-                <b>فرمت فایل CSV:</b><br>
-                • ستون اول: <code>original_text</code> (متن اصلی)<br>
-                • ستون دوم: <code>anonymized_text</code> (متن ناشناس‌سازی شده)<br>
-                • انکودینگ: UTF-8 (برای متن فارسی)
+                <div style='background: #e8f4fd; padding: 15px; border-radius: 10px; margin-bottom: 15px;'>
+                <h3>📋 نحوه کارکرد:</h3>
+                <ol>
+                <li><b>ستون اول (original_text)</b>: سیستم تمام entities را پیدا می‌کند</li>
+                <li><b>ستون دوم (anonymized_text)</b>: کدهای ناشناس‌سازی را پیدا می‌کند</li>
+                <li><b>مقایسه</b>: متریک‌های Precision, Recall, F1-Score, Accuracy محاسبه می‌شود</li>
+                <li><b>نتیجه</b>: تحلیل دقیق هر ردیف نمایش داده می‌شود</li>
+                </ol>
                 </div>
                 """)
                 
                 file_input = gr.File(
-                    label="فایل CSV را انتخاب کنید",
+                    label="📁 فایل CSV خود را آپلود کنید",
                     file_types=[".csv"],
                     file_count="single"
                 )
                 
-                with gr.Row():
-                    benchmark_btn = gr.Button("🚀 شروع Benchmark", variant="primary")
-                    sample_btn = gr.Button("📄 ایجاد فایل نمونه", variant="secondary")
+                process_btn = gr.Button("🚀 شروع پردازش فایل آپلودی", variant="primary", size="lg")
         
         with gr.Row():
             with gr.Column():
-                gr.HTML("<h3>📈 نتایج Benchmark</h3>")
+                gr.HTML("<h3>📊 نتایج تحلیل</h3>")
                 
-                metrics_output = gr.Textbox(
-                    label="متریک‌های کلی",
-                    lines=30,
-                    max_lines=35,
+                results_output = gr.Textbox(
+                    label="گزارش کامل",
+                    lines=25,
+                    max_lines=30,
                     interactive=False
                 )
         
         with gr.Row():
             with gr.Column():
-                gr.HTML("<h3>📋 جدول نتایج تفصیلی</h3>")
+                gr.HTML("<h3>📋 جدول نتایج</h3>")
                 
                 results_table = gr.Dataframe(
-                    label="نتایج هر متن",
+                    label="متریک‌های هر ردیف",
                     interactive=False,
                     wrap=True
                 )
         
         with gr.Row():
             with gr.Column():
-                download_btn = gr.Button("💾 دانلود نتایج کامل", variant="secondary")
+                download_btn = gr.Button("💾 دانلود نتایج", variant="secondary")
                 download_file = gr.File(label="فایل نتایج", visible=False)
         
-        with gr.Row():
-            with gr.Column():
-                gr.HTML("""
-                <div style='background: #fff8dc; padding: 15px; border-radius: 10px; margin-top: 15px;'>
-                <h4>🔍 راهنمای استفاده:</h4>
-                <ol>
-                <li>ابتدا با دکمه "ایجاد فایل نمونه" یک فایل تست ایجاد کنید</li>
-                <li>فایل CSV خود را آپلود کنید (حتماً شامل ستون‌های original_text و anonymized_text باشد)</li>
-                <li>روی "شروع Benchmark" کلیک کنید</li>
-                <li>نتایج را در بخش‌های بالا مشاهده کنید</li>
-                <li>در صورت نیاز فایل کامل نتایج را دانلود کنید</li>
-                </ol>
-                </div>
-                """)
-        
         # Event handlers
-        def handle_benchmark_click(file):
-            if file is None:
-                return "لطفاً ابتدا فایل CSV را آپلود کنید.", None, gr.update()
-            return process_csv_file(file)
-        
-        def handle_sample_creation():
-            result = create_sample_csv()
-            return gr.update(value=result, visible=True)
-        
-        benchmark_btn.click(
-            fn=handle_benchmark_click,
+        process_btn.click(
+            fn=process_uploaded_file,
             inputs=[file_input],
-            outputs=[metrics_output, results_table, gr.State()]
-        )
-        
-        sample_btn.click(
-            fn=handle_sample_creation,
-            outputs=[gr.Textbox(visible=False)]
+            outputs=[results_output, results_table]
         )
         
         download_btn.click(
@@ -712,11 +513,12 @@ def main():
     return demo
 
 demo = main()
+
 if __name__ == "__main__":
     port = int(os.getenv("PORT", "7860"))
     demo.launch(
         share=False,
-        server_name="0.0.0.0",
+        server_name="0.0.0.0", 
         server_port=port,
         show_error=True
     )