Update app.py

app.py

@@ -125,11 +125,11 @@ class TranslationQueue:
                     thread.start()
 
 class TextChunker:
-    """کلاس برای تقسیم متن طولانی به بخش‌های کوچک‌تر"""
+    """کلاس برای تقسیم متن طولانی به بخش‌های کوچک‌تر"""
     
     @staticmethod
     def split_text_smart(text: str, max_chunk_size: int = 400) -> List[str]:
-        """تقسیم هوشمند متن بر اساس جملات و پاراگراف‌ها"""
+        """تقسیم هوشمند متن بر اساس جملات و پاراگراف‌ها"""
         logger.info(f"[CHUNKER] Starting smart text splitting | Text length: {len(text)} chars | Max chunk size: {max_chunk_size}")
         
         if len(text) <= max_chunk_size:
@@ -138,27 +138,27 @@ class TextChunker:
         
         chunks = []
         
-        # تقسیم بر اساس پاراگراف‌ها
+        # تقسیم بر اساس پاراگراف‌ها
         paragraphs = text.split('\n\n')
         current_chunk = ""
         
         for i, paragraph in enumerate(paragraphs):
             logger.debug(f"[CHUNKER] Processing paragraph {i+1}/{len(paragraphs)} | Length: {len(paragraph)}")
             
-            # اگر پاراگراف خودش بزرگ است آن را تقسیم کن
+            # اگر پاراگراف خودش بزرگ است آن را تقسیم کن
             if len(paragraph) > max_chunk_size:
-                # ذخیره قسمت فعلی اگر وجود دارد
+                # ذخیره قسمت فعلی اگر وجود دارد
                 if current_chunk.strip():
                     chunks.append(current_chunk.strip())
                     logger.debug(f"[CHUNKER] Added chunk from accumulated paragraphs | Length: {len(current_chunk.strip())}")
                     current_chunk = ""
                 
-                # تقسیم پاراگراف بزرگ
+                # تقسیم پاراگراف بزرگ
                 sub_chunks = TextChunker._split_paragraph(paragraph, max_chunk_size)
                 chunks.extend(sub_chunks)
                 logger.debug(f"[CHUNKER] Split large paragraph into {len(sub_chunks)} sub-chunks")
             else:
-                # بررسی اینکه آیا اضافه کردن این پاراگراف از حد تجاوز می‌کند
+                # بررسی اینکه آیا اضافه کردن این پاراگراف از حد تجاوز می‌کند
                 if len(current_chunk) + len(paragraph) + 2 > max_chunk_size:
                     if current_chunk.strip():
                         chunks.append(current_chunk.strip())
@@ -170,7 +170,7 @@ class TextChunker:
                     else:
                         current_chunk = paragraph
         
-        # اضافه کردن آخرین قسمت
+        # اضافه کردن آخرین قسمت
         if current_chunk.strip():
             chunks.append(current_chunk.strip())
             logger.debug(f"[CHUNKER] Added final chunk | Length: {len(current_chunk.strip())}")
@@ -180,10 +180,10 @@ class TextChunker:
     
     @staticmethod
     def _split_paragraph(paragraph: str, max_chunk_size: int) -> List[str]:
-        """تقسیم پاراگراف بزرگ به جملات"""
+        """تقسیم پاراگراف بزرگ به جملات"""
         logger.debug(f"[CHUNKER] Splitting large paragraph | Length: {len(paragraph)}")
         
-        # تقسیم بر اساس جملات
+        # تقسیم بر اساس جملات
         sentences = re.split(r'[.!?]+\s+', paragraph)
         chunks = []
         current_chunk = ""
@@ -192,12 +192,12 @@ class TextChunker:
             if not sentence.strip():
                 continue
                 
-            # اضافه کردن علامت نقطه اگر حذف شده
+            # اضافه کردن علامت نقطه اگر حذف شده
             if not sentence.endswith(('.', '!', '?')):
                 sentence += '.'
             
             if len(sentence) > max_chunk_size:
-                # جمله خودش خیلی بلند است - تقسیم بر اساس کاما
+                # جمله خودش خیلی بلند است - تقسیم بر اساس کاما
                 if current_chunk.strip():
                     chunks.append(current_chunk.strip())
                     current_chunk = ""
@@ -223,7 +223,7 @@ class TextChunker:
     
     @staticmethod
     def _split_by_comma(sentence: str, max_chunk_size: int) -> List[str]:
-        """تقسیم جمله طولانی بر اساس کاما"""
+        """تقسیم جمله طولانی بر اساس کاما"""
         logger.debug(f"[CHUNKER] Splitting long sentence by comma | Length: {len(sentence)}")
         
         parts = sentence.split(', ')
@@ -232,12 +232,12 @@ class TextChunker:
         
         for part in parts:
             if len(part) > max_chunk_size:
-                # قسمت خودش خیلی بلند است - تقسیم اجباری
+                # قسمت خودش خیلی بلند است - تقسیم اجباری
                 if current_chunk.strip():
                     chunks.append(current_chunk.strip())
                     current_chunk = ""
                 
-                # تقسیم اجباری بر اساس طول
+                # تقسیم اجباری بر اساس طول
                 while len(part) > max_chunk_size:
                     chunks.append(part[:max_chunk_size].strip())
                     part = part[max_chunk_size:].strip()
@@ -288,9 +288,9 @@ class MultilingualTranslator:
             logger.error(f"[INIT] Error loading model: {e}")
             raise
         
-        # تنظیمات بهینه برای ترجمه متن‌های بلند
-        self.max_chunk_size = 350  # حداکثر طول هر قسمت
-        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
+        # تنظیمات بهینه برای ترجمه متن‌های بلند
+        self.max_chunk_size = 350  # حداکثر طول هر قسمت
+        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
         
         # Track translation progress
         self.current_translation = {}
@@ -299,9 +299,9 @@ class MultilingualTranslator:
         logger.info(f"[INIT] Translator initialized | Max chunk size: {self.max_chunk_size} chars")
     
     def translate_chunk(self, text: str, source_lang: str, target_lang: str, chunk_index: int = 0, total_chunks: int = 1) -> str:
-        """ترجمه یک قسمت کوچک از متن"""
+        """ترجمه یک قسمت کوچک از متن"""
         try:
-            logger.info(f"[TRANSLATE] Starting chunk translation [{chunk_index+1}/{total_chunks}] | {source_lang} → {target_lang} | Length: {len(text)} chars")
+            logger.info(f"[TRANSLATE] Starting chunk translation [{chunk_index+1}/{total_chunks}] | {source_lang} → {target_lang} | Length: {len(text)} chars")
             
             # Set source language for tokenizer
             self.tokenizer.src_lang = source_lang
@@ -315,15 +315,15 @@ class MultilingualTranslator:
             generated_tokens = self.model.generate(
                 **encoded,
                 forced_bos_token_id=self.tokenizer.get_lang_id(target_lang),
-                max_length=1024,  # افزایش طول خروجی
-                min_length=10,    # حداقل طول خروجی
-                num_beams=5,      # افزایش تعداد beam ها برای کیفیت بهتر
+                max_length=1024,  # افزایش طول خروجی
+                min_length=10,    # حداقل طول خروجی
+                num_beams=5,      # افزایش تعداد beam ها برای کیفیت بهتر
                 early_stopping=True,
-                no_repeat_ngram_size=3,  # جلوگیری از تکرار
-                length_penalty=1.0,      # تنظیم جریمه طول
-                repetition_penalty=1.2,  # جلوگیری از تکرار کلمات
-                do_sample=False,         # استفاده از روش قطعی
-                temperature=0.7,         # کنترل تنوع
+                no_repeat_ngram_size=3,  # جلوگیری از تکرار
+                length_penalty=1.0,      # تنظیم جریمه طول
+                repetition_penalty=1.2,  # جلوگیری از تکرار کلمات
+                do_sample=False,         # استفاده از روش قطعی
+                temperature=0.7,         # کنترل تنوع
                 pad_token_id=self.tokenizer.pad_token_id,
                 eos_token_id=self.tokenizer.eos_token_id
             )
@@ -332,7 +332,7 @@ class MultilingualTranslator:
             # Decode result
             translation = self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
             
-            # پاک‌سازی ترجمه از کاراکترهای اضافی
+            # پاک‌سازی ترجمه از کاراکترهای اضافی
             translation = translation.strip()
             
             logger.info(f"[TRANSLATE] Chunk translation completed [{chunk_index+1}/{total_chunks}] | Generation time: {generation_time:.2f}s | Output length: {len(translation)} chars")
@@ -344,34 +344,34 @@ class MultilingualTranslator:
             return f"[Translation Error: {str(e)}]"
     
     def translate_text(self, text: str, source_lang: str, target_lang: str, session_id: str = None) -> Tuple[str, float, int]:
-        """ترجمه متن با پشتیبانی از متن‌های طولانی و لاگ‌های مفصل"""
+        """ترجمه متن با پشتیبانی از متن‌های طولانی و لاگ‌های مفصل"""
         start_time = time.time()
         
         if not session_id:
             session_id = hashlib.md5(f"{text[:100]}{time.time()}".encode()).hexdigest()[:8]
         
-        logger.info(f"[SESSION:{session_id}] Starting translation | {source_lang} → {target_lang} | Text length: {len(text)} chars")
+        logger.info(f"[SESSION:{session_id}] Starting translation | {source_lang} → {target_lang} | Text length: {len(text)} chars")
         
-        # بررسی کش برای کل متن
+        # بررسی کش برای کل متن
         cached_result = self.cache.get(text, source_lang, target_lang)
         if cached_result:
             logger.info(f"[SESSION:{session_id}] Translation completed from cache | Time: {time.time() - start_time:.2f}s")
             return cached_result, time.time() - start_time, 1
         
         try:
-            # اگر متن کوتاه است مستقیماً ترجمه کن
+            # اگر متن کوتاه است مستقیماً ترجمه کن
             if len(text) <= self.max_chunk_size:
                 logger.info(f"[SESSION:{session_id}] Processing as short text")
                 translation = self.translate_chunk(text, source_lang, target_lang, 0, 1)
                 
-                # ذخیره در کش
+                # ذخیره در کش
                 self.cache.set(text, source_lang, target_lang, translation)
                 processing_time = time.time() - start_time
                 logger.info(f"[SESSION:{session_id}] Short text translation completed | Total time: {processing_time:.2f}s")
                 
                 return translation, processing_time, 1
             
-            # تقسیم متن طولانی به قسمت‌های کوچک‌تر
+            # تقسیم متن طولانی به قسمت‌های کوچک‌تر
             logger.info(f"[SESSION:{session_id}] Processing as long text - starting chunking")
             chunks = TextChunker.split_text_smart(text, self.max_chunk_size)
             logger.info(f"[SESSION:{session_id}] Text split into {len(chunks)} chunks")
@@ -386,13 +386,13 @@ class MultilingualTranslator:
                     'target_lang': target_lang
                 }
             
-            # ترجمه هر قسمت
+            # ترجمه هر قسمت
             translated_chunks = []
             for i, chunk in enumerate(chunks):
                 chunk_start_time = time.time()
                 logger.info(f"[SESSION:{session_id}] Starting chunk {i+1}/{len(chunks)} | Chunk length: {len(chunk)} chars")
                 
-                # بررسی کش برای هر قسمت
+                # بررسی کش برای هر قسمت
                 chunk_translation = self.cache.get(chunk, source_lang, target_lang)
                 
                 if not chunk_translation:
@@ -404,7 +404,7 @@ class MultilingualTranslator:
                         logger.info(f"[SESSION:{session_id}] Progress: {i}/{len(chunks)} | Avg time per chunk: {avg_time_per_chunk:.1f}s | Estimated remaining: {estimated_remaining:.1f}s")
                     
                     chunk_translation = self.translate_chunk(chunk, source_lang, target_lang, i, len(chunks))
-                    # ذخیره قسمت در کش
+                    # ذخیره قسمت در کش
                     self.cache.set(chunk, source_lang, target_lang, chunk_translation)
                     
                     chunk_time = time.time() - chunk_start_time
@@ -419,15 +419,15 @@ class MultilingualTranslator:
                     if session_id in self.current_translation:
                         self.current_translation[session_id]['completed_chunks'] = i + 1
                 
-                # کمی استراحت بین ترجمه‌ها برای جلوگیری از بارذاری زیاد
+                # کمی استراحت بین ترجمه‌ها برای جلوگیری از بارذاری زیاد
                 if i < len(chunks) - 1:
                     time.sleep(0.1)
             
-            # ترکیب قسمت‌های ترجمه شده
+            # ترکیب قسمت‌های ترجمه شده
             logger.info(f"[SESSION:{session_id}] Combining translated chunks")
             final_translation = self._combine_translations(translated_chunks, text)
             
-            # ذخیره نتیجه نهایی در کش
+            # ذخیره نتیجه نهایی در کش
             self.cache.set(text, source_lang, target_lang, final_translation)
             
             processing_time = time.time() - start_time
@@ -490,7 +490,7 @@ class MultilingualTranslator:
             }
     
     def _combine_translations(self, translated_chunks: List[str], original_text: str) -> str:
-        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
+        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
         if not translated_chunks:
             return ""
         
@@ -499,23 +499,23 @@ class MultilingualTranslator:
         
         logger.debug(f"[COMBINER] Combining {len(translated_chunks)} translated chunks")
         
-        # ترکیب قسمت‌ها با در نظر گیری ساختار اصلی متن
+        # ترکیب قسمت‌ها با در نظر گیری ساختار اصلی متن
         combined = []
         
         for i, chunk in enumerate(translated_chunks):
-            # پاک‌سازی قسمت
+            # پاک‌سازی قسمت
             chunk = chunk.strip()
             
             if not chunk:
                 continue
             
-            # اضافه کردن فاصله مناسب بین قسمت‌ها
+            # اضافه کردن فاصله مناسب بین قسمت‌ها
             if i > 0 and combined:
-                # اگر قسمت قبلی با نقطه تمام نمی‌شود فاصله اضافه کن
-                if not combined[-1].rstrip().endswith(('.', '!', '?', ':', 'Û”', '.')):
+                # اگر قسمت قبلی با نقطه تمام نمی‌شود فاصله اضافه کن
+                if not combined[-1].rstrip().endswith(('.', '!', '?', ':', '۔', '.')):
                     combined[-1] += '.'
                 
-                # بررسی اینکه آیا نیاز به پاراگراف جدید دارکم
+                # بررسی اینکه آیا نیاز به پاراگراف جدید دارکم
                 if '\n\n' in original_text:
                     combined.append('\n\n' + chunk)
                 else:
@@ -525,9 +525,9 @@ class MultilingualTranslator:
         
         result = ''.join(combined)
         
-        # پاک‌سازی نهایی
-        result = re.sub(r'\s+', ' ', result)  # حذف فاصله‌های اضافی
-        result = re.sub(r'\.+', '.', result)  # حذف نقطه‌های تکراری
+        # پاک‌سازی نهایی
+        result = re.sub(r'\s+', ' ', result)  # حذف فاصله‌های اضافی
+        result = re.sub(r'\.+', '.', result)  # حذف نقطه‌های تکراری
         result = result.strip()
         
         logger.debug(f"[COMBINER] Combined translation length: {len(result)} chars")
@@ -544,7 +544,8 @@ class MultilingualTranslator:
 
 def process_heavy_translation_background(request_id: str, text: str, source_lang: str, target_lang: str):
     """
-    FIXED: Background function with better error handling and status updates
+    Background function to process heavy text translations for WordPress integration.
+    Updates the completed_translations dict when done and automatically charges credits.
     """
     try:
         logger.info(f"[HF Server] Background processing started for request: {request_id}")
@@ -555,55 +556,45 @@ def process_heavy_translation_background(request_id: str, text: str, source_lang
         with translation_requests_lock:
             if request_id in translation_requests:
                 translation_requests[request_id]['progress'] = 10
-                translation_requests[request_id]['status'] = 'processing'
         
         # Perform actual translation
         translation, processing_time, chunks_count = translator.translate_text(
             text, source_lang, target_lang, request_id
         )
         
-        total_processing_time = time.time() - start_time
-        
-        # FIXED: Validate translation result
-        if not translation or not translation.strip():
-            logger.error(f"[HF Server] Empty translation result for request: {request_id}")
-            
-            # Store failed translation
-            with translation_requests_lock:
-                completed_translations[request_id] = {
-                    'translation': '',
-                    'error': 'Translation completed but result is empty',
-                    'status': 'failed',
-                    'processing_time': total_processing_time,
-                    'completed_at': datetime.now().isoformat(),
-                    'request_id': request_id
-                }
-                
-                if request_id in translation_requests:
-                    del translation_requests[request_id]
-            return
+        processing_time = time.time() - start_time
         
         # Store completed translation
         with translation_requests_lock:
             completed_translations[request_id] = {
                 'translation': translation,
-                'processing_time': total_processing_time,
+                'processing_time': processing_time,
                 'character_count': len(text),
                 'source_lang': source_lang,
                 'target_lang': target_lang,
                 'completed_at': datetime.now().isoformat(),
                 'request_id': request_id,
                 'status': 'completed',
-                'chunks_processed': chunks_count,
-                'source_lang_display': translation_requests[request_id].get('source_lang_display', source_lang),
-                'target_lang_display': translation_requests[request_id].get('target_lang_display', target_lang)
+                'auto_charged': False  # فلگ برای ردیابی کسر خودکار اعتبار
             }
             
             # Remove from processing queue
             if request_id in translation_requests:
                 del translation_requests[request_id]
         
-        logger.info(f"[HF Server] Heavy text translation completed for request: {request_id} in {total_processing_time:.2f}s with {len(translation)} chars")
+        logger.info(f"[HF Server] Long text translation completed for request: {request_id} in {processing_time:.2f}s")
+        
+        # NEW: اطلاع‌رسانی خودکار به ووردپرس برای کسر اعتبار
+        charge_success = notify_wordpress_completion_and_charge(request_id)
+        
+        if charge_success:
+            # علامت‌گذاری به عنوان کسر شده
+            with translation_requests_lock:
+                if request_id in completed_translations:
+                    completed_translations[request_id]['auto_charged'] = True
+            logger.info(f"[HF Server] Automatic charging completed for request: {request_id}")
+        else:
+            logger.warning(f"[HF Server] Automatic charging failed for request: {request_id}")
         
     except Exception as e:
         logger.error(f"[HF Server] Background processing error for {request_id}: {str(e)}")
@@ -616,13 +607,80 @@ def process_heavy_translation_background(request_id: str, text: str, source_lang
                 'status': 'failed',
                 'processing_time': time.time() - start_time if 'start_time' in locals() else 0,
                 'completed_at': datetime.now().isoformat(),
-                'request_id': request_id
+                'request_id': request_id,
+                'auto_charged': False
             }
             
             # Remove from processing queue
             if request_id in translation_requests:
                 del translation_requests[request_id]
 
+def notify_wordpress_completion_and_charge(request_id: str, wordpress_url: str = None):
+    """
+    اطلاع‌رسانی به ووردپرس پس از تکمیل ترجمه و کسر خودکار اعتبار
+    """
+    try:
+        if not wordpress_url:
+            # آدرس ووردپرس باید از متغیر محیطی یا تنظیمات دریافت شود
+            wordpress_url = os.getenv('WORDPRESS_URL', 'https://your-wordpress-site.com')
+        
+        # پیدا کردن اطلاعات ترجمه تکمیل شده
+        with translation_requests_lock:
+            if request_id not in completed_translations:
+                logger.error(f"[AUTO CHARGE] Translation not found in completed cache: {request_id}")
+                return False
+            
+            translation_data = completed_translations[request_id]
+        
+        # ارسال درخواست به ووردپرس برای کسر خودکار اعتبار
+        charge_url = f"{wordpress_url.rstrip('/')}/wp-admin/admin-ajax.php"
+        
+        charge_payload = {
+            'action': 'amt_auto_charge_completed',
+            'request_id': request_id,
+            'character_count': translation_data.get('character_count', 0),
+            'processing_time': translation_data.get('processing_time', 0),
+            'translation_length': len(translation_data.get('translation', '')),
+            'source_lang': translation_data.get('source_lang', ''),
+            'target_lang': translation_data.get('target_lang', ''),
+            'completed_at': translation_data.get('completed_at', ''),
+            'nonce': 'auto_charge_nonce'  # باید از ووردپرس دریافت شود
+        }
+        
+        logger.info(f"[AUTO CHARGE] Notifying WordPress for automatic charging: {request_id}")
+        
+        # ارسال درخواست POST به ووردپرس
+        import requests
+        response = requests.post(
+            charge_url,
+            data=charge_payload,
+            timeout=30,
+            headers={
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'User-Agent': 'HuggingFace-Translation-Server/2.1.0'
+            }
+        )
+        
+        if response.status_code == 200:
+            try:
+                result = response.json()
+                if result.get('success'):
+                    logger.info(f"[AUTO CHARGE] WordPress automatic charging successful: {request_id} - Cost: {result.get('cost', 0)}")
+                    return True
+                else:
+                    logger.error(f"[AUTO CHARGE] WordPress charging failed: {result.get('data', {}).get('message', 'Unknown error')}")
+                    return False
+            except:
+                logger.error(f"[AUTO CHARGE] Invalid JSON response from WordPress")
+                return False
+        else:
+            logger.error(f"[AUTO CHARGE] WordPress request failed with status: {response.status_code}")
+            return False
+    
+    except Exception as e:
+        logger.error(f"[AUTO CHARGE] Error notifying WordPress: {str(e)}")
+        return False
+
 def perform_translation_internal(text: str, source_lang: str, target_lang: str) -> str:
     """
     Internal translation function - wrapper for translator.translate_text
@@ -725,7 +783,8 @@ app.add_middleware(
 @app.post("/api/check-completion")
 async def check_completion(request: Request):
     """
-    FIXED: Enhanced completion verification endpoint
+    Endpoint to verify if a translation request has been completed.
+    WordPress calls this to confirm before charging credits.
     """
     try:
         form_data = await request.form()
@@ -751,8 +810,6 @@ async def check_completion(request: Request):
                     'request_id': request_id,
                     'completed_at': completion_data.get('completed_at'),
                     'processing_time': completion_data.get('processing_time', 0),
-                    'character_count': completion_data.get('character_count', 0),
-                    'translation_length': len(completion_data.get('translation', '')),
                     'verified': True
                 }
             
@@ -763,7 +820,6 @@ async def check_completion(request: Request):
                 return {
                     'status': 'processing',
                     'request_id': request_id,
-                    'progress': translation_requests[request_id].get('progress', 0),
                     'verified': False
                 }
             
@@ -786,7 +842,8 @@ async def check_completion(request: Request):
 @app.post("/api/check-translation-status")
 async def check_translation_status(request: Request):
     """
-    FIXED: Enhanced translation status endpoint with full translation content
+    Endpoint to get the current status and result of a translation request.
+    Returns translation content if completed.
     """
     try:
         form_data = await request.form()
@@ -805,7 +862,7 @@ async def check_translation_status(request: Request):
             if request_id in completed_translations:
                 result = completed_translations[request_id]
                 
-                logger.info(f"[HF Server] Translation status check for {request_id}: COMPLETED - returning full data")
+                logger.info(f"[HF Server] Translation status check for {request_id}: COMPLETED - returning translation")
                 
                 return {
                     'status': 'completed',
@@ -814,10 +871,8 @@ async def check_translation_status(request: Request):
                     'processing_time': result.get('processing_time', 0),
                     'character_count': result.get('character_count', 0),
                     'completed_at': result.get('completed_at'),
-                    'source_lang': result.get('source_lang_display', result.get('source_lang', '')),
-                    'target_lang': result.get('target_lang_display', result.get('target_lang', '')),
-                    'chunks_processed': result.get('chunks_processed', 1),
-                    'translation_length': len(result.get('translation', ''))
+                    'source_lang': result.get('source_lang', ''),
+                    'target_lang': result.get('target_lang', '')
                 }
             
             # Check if still processing
@@ -830,10 +885,7 @@ async def check_translation_status(request: Request):
                     'status': 'processing',
                     'request_id': request_id,
                     'started_at': req_data.get('started_at'),
-                    'progress': req_data.get('progress', 0),
-                    'character_count': req_data.get('character_count', 0),
-                    'source_lang': req_data.get('source_lang_display', req_data.get('source_lang', '')),
-                    'target_lang': req_data.get('target_lang_display', req_data.get('target_lang', ''))
+                    'progress': req_data.get('progress', 0)
                 }
             
             else:
@@ -857,7 +909,8 @@ async def check_translation_status(request: Request):
 @app.post("/api/translate/form")
 async def api_translate_form(request: Request):
     """
-    FIXED: Enhanced translation endpoint with better heavy text handling
+    Enhanced translation endpoint that handles both short and long texts.
+    For long texts, returns immediately with request_id for background processing.
     """
     try:
         form_data = await request.form()
@@ -887,12 +940,10 @@ async def api_translate_form(request: Request):
         return {"status": "error", "message": "Invalid language codes"}
     
     char_count = len(text)
-    # FIXED: Correct heavy text threshold detection
-    is_heavy_text = char_count > 1000  # Same as WordPress threshold
+    is_heavy_text = char_count > 1000  # Same threshold as WordPress
     
     logger.info(f"[FORM API] Translation request: {char_count} chars, {source_lang} → {target_lang}, Heavy: {is_heavy_text}")
     
-    # FIXED: Always use background processing for heavy texts
     if is_heavy_text:
         # Generate request ID for background processing
         request_id = str(uuid.uuid4())
@@ -921,9 +972,7 @@ async def api_translate_form(request: Request):
                 'target_lang': target_code,
                 'started_at': datetime.now().isoformat(),
                 'character_count': char_count,
-                'progress': 0,
-                'source_lang_display': source_lang,
-                'target_lang_display': target_lang
+                'progress': 0
             }
         
         # Start background processing
@@ -934,20 +983,15 @@ async def api_translate_form(request: Request):
         thread.daemon = True
         thread.start()
         
-        logger.info(f"[FORM API] Started background processing for heavy text - request: {request_id}")
+        logger.info(f"[FORM API] Started background processing for request: {request_id}")
         
-        # FIXED: Return proper background response for WordPress
         return {
             'is_background': True,
             'session_id': request_id,
             'request_id': request_id,
-            'server_request_id': request_id,  # Added for compatibility
             'status': 'processing',
-            'is_heavy_text': True,
-            'message': f'Heavy text ({char_count} characters) is being processed in background. Translation will appear automatically.',
-            'character_count': char_count,
-            'source_lang': source_lang,
-            'target_lang': target_lang
+            'message': f'Long text ({char_count} characters) is being processed in background. Use the request ID to check status.',
+            'character_count': char_count
         }
     
     else:
@@ -975,9 +1019,7 @@ async def api_translate_form(request: Request):
                 'processing_time': processing_time,
                 'character_count': char_count,
                 'source_lang': source_lang,
-                'target_lang': target_lang,
-                'is_heavy_text': False,
-                'chunks_processed': chunks_count
+                'target_lang': target_lang
             }
             
         except Exception as e:
@@ -1135,11 +1177,51 @@ async def get_session_status(session_id: str):
         "message": "Session not found or completed"
     }
 
-@app.get("/api/server-status")
-async def get_server_status():
+# اضافه کردن endpoint جدید برای بررسی وضعیت کسر اعتبار
+@app.post("/api/check-auto-charge-status")
+async def check_auto_charge_status(request: Request):
     """
-    FIXED: Enhanced server status with better information
+    بررسی وضعیت کسر خودکار اعتبار برای درخواست خاص
     """
+    try:
+        form_data = await request.form()
+        request_id = form_data.get('request_id', '').strip()
+        
+        if not request_id:
+            return {
+                'status': 'error',
+                'message': 'Request ID is required'
+            }
+        
+        with translation_requests_lock:
+            if request_id in completed_translations:
+                translation_data = completed_translations[request_id]
+                
+                return {
+                    'status': 'completed',
+                    'request_id': request_id,
+                    'auto_charged': translation_data.get('auto_charged', False),
+                    'completed_at': translation_data.get('completed_at'),
+                    'processing_time': translation_data.get('processing_time', 0),
+                    'character_count': translation_data.get('character_count', 0)
+                }
+            else:
+                return {
+                    'status': 'not_found',
+                    'request_id': request_id,
+                    'message': 'Translation not found'
+                }
+                
+    except Exception as e:
+        logger.error(f"[HF Server] Error checking auto charge status: {str(e)}")
+        return {
+            'status': 'error',
+            'message': 'Server error occurred'
+        }
+
+@app.get("/api/server-status")
+async def get_server_status():
+    """Get current server status - enhanced for WordPress integration"""
     active_sessions = []
     
     with translation_requests_lock:
@@ -1183,8 +1265,7 @@ async def get_server_status():
             "active_sessions": len(active_sessions),
             "background_tasks": background_tasks_count,
             "total_active": total_active,
-            "completed_cache": completed_count,
-            "active_session_details": active_sessions[:3] if active_sessions else []  # Return first 3 for details
+            "completed_cache": completed_count
         }
     else:
         return {
@@ -1200,7 +1281,8 @@ async def get_server_status():
 
 def cleanup_old_requests():
     """
-    FIXED: Enhanced cleanup with better time handling
+    Clean up old completed translations and stuck processing requests.
+    Should be called periodically.
     """
     current_time = datetime.now()