Update app.py

app.py

@@ -119,11 +119,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:
@@ -132,27 +132,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())
@@ -164,7 +164,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())}")
@@ -174,10 +174,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 = ""
@@ -186,12 +186,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 = ""
@@ -217,7 +217,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(', ')
@@ -226,12 +226,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()
@@ -282,9 +282,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 = {}
@@ -293,109 +293,79 @@ 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")
-            
-            # بررسی متن ورودی
-            if not text or not text.strip():
-                logger.warning(f"[TRANSLATE] Empty text provided for chunk {chunk_index+1}")
-                return ""
+            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
             
             # Encode input
-            try:
-                encoded = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(self.device)
-                logger.debug(f"[TRANSLATE] Text encoded | Input tokens: {encoded.input_ids.shape[1]}")
-            except Exception as e:
-                logger.error(f"[TRANSLATE] Tokenization error for chunk {chunk_index+1}: {e}")
-                return f"[Tokenization Error: {str(e)}]"
+            encoded = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(self.device)
+            logger.debug(f"[TRANSLATE] Text encoded | Input tokens: {encoded.input_ids.shape[1]}")
             
             # Generate translation with optimized parameters
             start_time = time.time()
-            try:
-                generated_tokens = self.model.generate(
-                    **encoded,
-                    forced_bos_token_id=self.tokenizer.get_lang_id(target_lang),
-                    max_length=1024,
-                    min_length=5,
-                    num_beams=5,
-                    early_stopping=True,
-                    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
-                )
-                generation_time = time.time() - start_time
-            except Exception as e:
-                logger.error(f"[TRANSLATE] Generation error for chunk {chunk_index+1}: {e}")
-                return f"[Generation Error: {str(e)}]"
+            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 ها برای کیفیت بهتر
+                early_stopping=True,
+                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
+            )
+            generation_time = time.time() - start_time
             
             # Decode result
-            try:
-                translation = self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-                
-                # پاک‌سازی ترجمه از کاراکترهای اضافی
-                translation = translation.strip()
-                
-                # بررسی محتوای ترجمه
-                if not translation:
-                    logger.warning(f"[TRANSLATE] Empty translation result for chunk {chunk_index+1}")
-                    return f"[Empty Translation Result for chunk {chunk_index+1}]"
-                
-                logger.info(f"[TRANSLATE] Chunk translation completed [{chunk_index+1}/{total_chunks}] | Generation time: {generation_time:.2f}s | Output length: {len(translation)} chars")
-                
-                return translation
-                
-            except Exception as e:
-                logger.error(f"[TRANSLATE] Decoding error for chunk {chunk_index+1}: {e}")
-                return f"[Decoding Error: {str(e)}]"
-                
+            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")
+            
+            return translation
+            
         except Exception as e:
             logger.error(f"[TRANSLATE] Chunk translation error [{chunk_index+1}/{total_chunks}]: {e}")
             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 and cached_result.strip():  # اطمینان از عدم خالی بودن کش
+        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)
                 
-                # بررسی محتوای ترجمه
-                if not translation or not translation.strip():
-                    logger.error(f"[SESSION:{session_id}] Empty translation received for short text")
-                    return "Translation failed: Empty result received", time.time() - start_time, 0
-                
-                # ذخیره در کش
+                # ذخیره در کش
                 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")
@@ -410,16 +380,16 @@ 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 or not chunk_translation.strip():
+                if not chunk_translation:
                     # Estimate remaining time
                     if i > 0:
                         elapsed_time = time.time() - start_time
@@ -428,14 +398,8 @@ 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))
-                    
-                    # بررسی محتوای ترجمه قسمت
-                    if not chunk_translation or not chunk_translation.strip():
-                        logger.error(f"[SESSION:{session_id}] Empty translation for chunk {i+1}")
-                        chunk_translation = f"[Translation failed for chunk {i+1}]"
-                    else:
-                        # ذخیره قسمت در کش
-                        self.cache.set(chunk, source_lang, target_lang, chunk_translation)
+                    # ذخیره قسمت در کش
+                    self.cache.set(chunk, source_lang, target_lang, chunk_translation)
                     
                     chunk_time = time.time() - chunk_start_time
                     logger.info(f"[SESSION:{session_id}] Chunk {i+1}/{len(chunks)} translated in {chunk_time:.2f}s")
@@ -449,21 +413,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)
             
-            # بررسی نهایی محتوای ترجمه
-            if not final_translation or not final_translation.strip():
-                logger.error(f"[SESSION:{session_id}] Final translation is empty after combining chunks")
-                processing_time = time.time() - start_time
-                return "Translation failed: Empty result after processing", processing_time, len(chunks)
-            
-            # ذخیره نتیجه نهایی در کش
+            # ��°Ø®ÛŒØ±Ù‡ نتیجه نهایی در Ú©Ø´
             self.cache.set(text, source_lang, target_lang, final_translation)
             
             processing_time = time.time() - start_time
@@ -481,8 +439,6 @@ class MultilingualTranslator:
             with self.translation_lock:
                 self.current_translation.pop(session_id, None)
             return f"Translation error: {str(e)}", time.time() - start_time, 0
-
-
     
     def get_translation_progress(self, session_id: str) -> Dict:
         """Get current translation progress"""
@@ -509,9 +465,8 @@ class MultilingualTranslator:
             }
     
     def _combine_translations(self, translated_chunks: List[str], original_text: str) -> str:
-        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
+        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
         if not translated_chunks:
-            logger.warning("[COMBINER] No chunks to combine")
             return ""
         
         if len(translated_chunks) == 1:
@@ -519,31 +474,23 @@ class MultilingualTranslator:
         
         logger.debug(f"[COMBINER] Combining {len(translated_chunks)} translated chunks")
         
-        # فیلتر کردن قسمت‌های خالی یا خرابه
-        valid_chunks = []
-        for i, chunk in enumerate(translated_chunks):
-            chunk = chunk.strip() if chunk else ""
-            
-            # حذف قسمت‌هایی که پیام خطا هستند
-            if chunk and not chunk.startswith('[') and not chunk.startswith('Translation Error'):
-                valid_chunks.append(chunk)
-            else:
-                logger.warning(f"[COMBINER] Skipping invalid chunk {i}: {chunk[:50] if chunk else 'Empty'}")
-        
-        if not valid_chunks:
-            logger.error("[COMBINER] No valid chunks found")
-            return "Translation failed: No valid content produced"
-        
-        # ترکیب قسمت‌ها با در نظر گیری ساختار اصلی متن
+        # ترکیب قسمت‌ها با در نظر گیری ساختار اصلی متن
         combined = []
         
-        for i, chunk in enumerate(valid_chunks):
+        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:
@@ -553,9 +500,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")
@@ -570,7 +517,6 @@ class MultilingualTranslator:
             text, source_lang, target_lang, session_id
         )
 
-
 # Language mappings for M2M100 model
 LANGUAGE_MAP = {
     "English": "en",
@@ -707,7 +653,7 @@ async def api_translate(request: TranslationRequest):
 # Alternative endpoint for form data (compatibility with WordPress)
 @app.post("/api/translate/form")
 async def api_translate_form(request: Request):
-    """Non-blocking translation endpoint"""
+    """Non-blocking translation endpoint with enhanced error handling"""
     try:
         form_data = await request.form()
         text = form_data.get("text", "")
@@ -727,13 +673,15 @@ async def api_translate_form(request: Request):
     logger.info(f"[FORM API] Translation request | {source_lang} → {target_lang} | Length: {len(text)} chars")
     
     if not text.strip():
-        raise HTTPException(status_code=400, detail="No text provided")
+        logger.error("[FORM API] No text provided")
+        return {"status": "error", "message": "No text provided"}
     
     source_code = LANGUAGE_MAP.get(source_lang)
     target_code = LANGUAGE_MAP.get(target_lang)
     
     if not source_code or not target_code:
-        raise HTTPException(status_code=400, detail="Invalid language codes")
+        logger.error(f"[FORM API] Invalid language codes: {source_lang} -> {target_lang}")
+        return {"status": "error", "message": "Invalid language codes"}
     
     # Generate session ID for tracking
     session_id = hashlib.md5(f"{text[:100]}{time.time()}".encode()).hexdigest()[:8]
@@ -762,6 +710,16 @@ async def api_translate_form(request: Request):
                 text, source_code, target_code, session_id
             )
             
+            # بررسی محتوای ترجمه
+            if not translation or not translation.strip() or translation.startswith("Translation error"):
+                logger.error(f"[FORM API] Invalid translation result: {translation[:100] if translation else 'None'}")
+                return {
+                    "status": "error",
+                    "message": "Translation failed - empty or invalid result",
+                    "session_id": session_id
+                }
+            
+            logger.info(f"[FORM API] Translation successful | Length: {len(translation)} chars")
             return {
                 "translation": translation,
                 "source_language": source_lang,
@@ -774,7 +732,7 @@ async def api_translate_form(request: Request):
             }
         except Exception as e:
             logger.error(f"[FORM API] Translation error: {str(e)}")
-            raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")
+            return {"status": "error", "message": f"Translation error: {str(e)}"}
 
 @app.get("/api/progress/{session_id}")
 async def get_translation_progress(session_id: str):
@@ -900,7 +858,7 @@ async def get_server_status():
     if active_sessions or background_tasks_count > 0:
         if active_sessions:
             latest_session = active_sessions[-1]
-            message = f"Processing chunk {latest_session['completed_chunks']}/{latest_session['total_chunks']} | {latest_session['source_lang']} → {latest_session['target_lang']}"
+            message = f"Processing chunk {latest_session['completed_chunks']}/{latest_session['total_chunks']} | {latest_session['source_lang']} → {latest_session['target_lang']}"
         else:
             message = f"{background_tasks_count} translation(s) in background queue"
             
@@ -927,7 +885,7 @@ async def get_server_status():
         return {
             "has_active_translation": True,
             "status": "processing",
-            "message": f"Processing chunk {latest_session['completed_chunks']}/{latest_session['total_chunks']} | {latest_session['source_lang']} → {latest_session['target_lang']}",
+            "message": f"Processing chunk {latest_session['completed_chunks']}/{latest_session['total_chunks']} | {latest_session['source_lang']} → {latest_session['target_lang']}",
             "session_data": latest_session
         }
     else: