Update app.py

app.py

@@ -42,10 +42,6 @@ class TranslationResponse(BaseModel):
     processing_time: float
     character_count: int
     status: str
-    chunks_processed: Optional[int] = None
-    estimated_time_remaining: Optional[float] = None
-    current_chunk: Optional[int] = None
-    total_chunks: Optional[int] = None
 
 class TranslationCache:
     def __init__(self, cache_duration_minutes: int = 60):
@@ -81,191 +77,16 @@ class TranslationCache:
             self.cache[key] = (translation, datetime.now())
             logger.info(f"[CACHE STORE] Cached translation for key: {key[:8]}... | Translation length: {len(translation)} chars")
 
-class TranslationQueue:
-    def __init__(self, max_workers: int = 3):
-        self.queue = Queue()
-        self.max_workers = max_workers
-        self.current_workers = 0
-        self.lock = threading.Lock()
-    
-    def add_task(self, task_func, *args, **kwargs):
-        """Add translation task to queue"""
-        self.queue.put((task_func, args, kwargs))
-        logger.info(f"[QUEUE] Added task to queue | Queue size: {self.queue.qsize()}")
-    
-    def process_queue(self):
-        """Process tasks from queue"""
-        while not self.queue.empty():
-            with self.lock:
-                if self.current_workers >= self.max_workers:
-                    time.sleep(0.1)
-                    continue
-                
-                if not self.queue.empty():
-                    task_func, args, kwargs = self.queue.get()
-                    self.current_workers += 1
-                    logger.info(f"[QUEUE] Starting worker | Current workers: {self.current_workers}")
-                    
-                    def worker():
-                        try:
-                            result = task_func(*args, **kwargs)
-                            return result
-                        finally:
-                            with self.lock:
-                                self.current_workers -= 1
-                                logger.info(f"[QUEUE] Worker finished | Current workers: {self.current_workers}")
-                    
-                    thread = threading.Thread(target=worker)
-                    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:
-            logger.info(f"[CHUNKER] Text is small, no chunking needed | Length: {len(text)}")
-            return [text]
-        
-        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())
-                        logger.debug(f"[CHUNKER] Added chunk | Length: {len(current_chunk.strip())}")
-                    current_chunk = paragraph
-                else:
-                    if current_chunk:
-                        current_chunk += "\n\n" + paragraph
-                    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())}")
-        
-        logger.info(f"[CHUNKER] Text splitting completed | Total chunks: {len(chunks)} | Average chunk size: {sum(len(c) for c in chunks) / len(chunks):.1f} chars")
-        return chunks
-    
-    @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 = ""
-        
-        for sentence in sentences:
-            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 = ""
-                
-                sub_chunks = TextChunker._split_by_comma(sentence, max_chunk_size)
-                chunks.extend(sub_chunks)
-            else:
-                if len(current_chunk) + len(sentence) + 1 > max_chunk_size:
-                    if current_chunk.strip():
-                        chunks.append(current_chunk.strip())
-                    current_chunk = sentence
-                else:
-                    if current_chunk:
-                        current_chunk += " " + sentence
-                    else:
-                        current_chunk = sentence
-        
-        if current_chunk.strip():
-            chunks.append(current_chunk.strip())
-        
-        logger.debug(f"[CHUNKER] Paragraph split into {len(chunks)} sentence chunks")
-        return chunks
-    
-    @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(', ')
-        chunks = []
-        current_chunk = ""
-        
-        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()
-                
-                if part:
-                    current_chunk = part
-            else:
-                if len(current_chunk) + len(part) + 2 > max_chunk_size:
-                    if current_chunk.strip():
-                        chunks.append(current_chunk.strip())
-                    current_chunk = part
-                else:
-                    if current_chunk:
-                        current_chunk += ", " + part
-                    else:
-                        current_chunk = part
-        
-        if current_chunk.strip():
-            chunks.append(current_chunk.strip())
-        
-        return chunks
-
 class MultilingualTranslator:
     def __init__(self, cache_duration_minutes: int = 60):
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         logger.info(f"[INIT] Using device: {self.device}")
         
-        # Initialize cache and queue
+        # Initialize cache
         self.cache = TranslationCache(cache_duration_minutes)
-        self.queue = TranslationQueue()
         
         # Add thread pool for parallel processing
         self.executor = ThreadPoolExecutor(max_workers=3)
-        self.background_tasks = {}
         
         logger.info(f"[INIT] Thread pool initialized with 3 workers")
 
@@ -282,231 +103,65 @@ class MultilingualTranslator:
             logger.error(f"[INIT] Error loading model: {e}")
             raise
         
-        # تنظیمات بهینه برای ترجمه متن‌های بلند
-        self.max_chunk_size = 350  # حداکثر طول هر قسمت
-        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
+        logger.info(f"[INIT] Translator initialized successfully")
+    
+    def translate_text(self, text: str, source_lang: str, target_lang: str, session_id: str = None) -> Tuple[str, float]:
+        """ترجمه متن با پشتیبانی از کش"""
+        start_time = time.time()
         
-        # Track translation progress
-        self.current_translation = {}
-        self.translation_lock = threading.Lock()
+        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")
+        
+        # بررسی کش برای کل متن
+        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
         
-        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")
-            
             # Set source language for tokenizer
             self.tokenizer.src_lang = source_lang
             
             # Encode input
             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]}")
+            logger.debug(f"[SESSION:{session_id}] Text encoded | Input tokens: {encoded.input_ids.shape[1]}")
             
             # Generate translation with optimized parameters
-            start_time = time.time()
             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,
                 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
             )
-            generation_time = time.time() - start_time
             
             # 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")
-            
-            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")
-        
-        # بررسی کش برای کل متن
-        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")
-            
-            # Initialize progress tracking
-            with self.translation_lock:
-                self.current_translation[session_id] = {
-                    'total_chunks': len(chunks),
-                    'completed_chunks': 0,
-                    'start_time': start_time,
-                    'source_lang': source_lang,
-                    '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:
-                    # Estimate remaining time
-                    if i > 0:
-                        elapsed_time = time.time() - start_time
-                        avg_time_per_chunk = elapsed_time / i
-                        estimated_remaining = avg_time_per_chunk * (len(chunks) - i)
-                        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
-                    logger.info(f"[SESSION:{session_id}] Chunk {i+1}/{len(chunks)} translated in {chunk_time:.2f}s")
-                else:
-                    logger.info(f"[SESSION:{session_id}] Chunk {i+1}/{len(chunks)} retrieved from cache")
-                
-                translated_chunks.append(chunk_translation)
-                
-                # Update progress
-                with self.translation_lock:
-                    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)
+            # ذخیره در کش
+            self.cache.set(text, source_lang, target_lang, translation)
             
             processing_time = time.time() - start_time
-            logger.info(f"[SESSION:{session_id}] Long text translation completed | Total time: {processing_time:.2f}s | Chunks: {len(chunks)} | Final length: {len(final_translation)} chars")
-            
-            # Clean up progress tracking
-            with self.translation_lock:
-                self.current_translation.pop(session_id, None)
+            logger.info(f"[SESSION:{session_id}] Translation completed | Total time: {processing_time:.2f}s | Output length: {len(translation)} chars")
             
-            return final_translation, processing_time, len(chunks)
+            return translation, processing_time
             
         except Exception as e:
             logger.error(f"[SESSION:{session_id}] Translation error: {e}")
-            # Clean up progress tracking
-            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"""
-        with self.translation_lock:
-            if session_id not in self.current_translation:
-                return None
-            
-            progress = self.current_translation[session_id].copy()
-            elapsed_time = time.time() - progress['start_time']
-            
-            if progress['completed_chunks'] > 0:
-                avg_time_per_chunk = elapsed_time / progress['completed_chunks']
-                remaining_chunks = progress['total_chunks'] - progress['completed_chunks']
-                estimated_remaining = avg_time_per_chunk * remaining_chunks
-            else:
-                estimated_remaining = None
-            
-            return {
-                'total_chunks': progress['total_chunks'],
-                'completed_chunks': progress['completed_chunks'],
-                'elapsed_time': elapsed_time,
-                'estimated_remaining': estimated_remaining,
-                'progress_percentage': (progress['completed_chunks'] / progress['total_chunks']) * 100
-            }
-    
-    def _combine_translations(self, translated_chunks: List[str], original_text: str) -> str:
-        """ترکیب قسمت‌های ترجمه شده به یک متن یکپارچه"""
-        if not translated_chunks:
-            return ""
-        
-        if len(translated_chunks) == 1:
-            return translated_chunks[0]
-        
-        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(('.', '!', '?', ':', 'Ø›', '.')):
-                    combined[-1] += '.'
-                
-                # بررسی اینکه آیا نیاز به پاراگراف جدید داریم
-                if '\n\n' in original_text:
-                    combined.append('\n\n' + chunk)
-                else:
-                    combined.append(' ' + chunk)
-            else:
-                combined.append(chunk)
-        
-        result = ''.join(combined)
-        
-        # پاک‌سازی نهایی
-        result = re.sub(r'\s+', ' ', result)  # حذف فاصله‌های اضافی
-        result = re.sub(r'\.+', '.', result)  # حذف نقطه‌های تکراری
-        result = result.strip()
-        
-        logger.debug(f"[COMBINER] Combined translation length: {len(result)} chars")
-        return result
+            return f"Translation error: {str(e)}", time.time() - start_time
 
     async def translate_text_async(self, text: str, source_lang: str, target_lang: str, session_id: str = None):
         """Async wrapper for translate_text"""
@@ -592,7 +247,7 @@ LANGUAGE_MAP = {
 translator = MultilingualTranslator(60)
 
 # Create FastAPI app
-app = FastAPI(title="Enhanced Multilingual Translation API", version="2.1.0")
+app = FastAPI(title="Simplified Multilingual Translation API", version="2.0.0")
 
 # Add CORS middleware
 app.add_middleware(
@@ -606,20 +261,18 @@ app.add_middleware(
 @app.get("/")
 async def root():
     return {
-        "message": "Enhanced Multilingual Translation API v2.1", 
+        "message": "Simplified Multilingual Translation API v2.0", 
         "status": "active", 
         "features": [
-            "enhanced_logging", 
-            "progress_tracking", 
-            "long_text_support", 
-            "smart_chunking", 
-            "cache_optimization"
+            "simplified_processing", 
+            "cache_optimization", 
+            "direct_translation"
         ]
     }
 
 @app.post("/api/translate")
 async def api_translate(request: TranslationRequest):
-    """API endpoint for translation with enhanced logging and progress tracking"""
+    """API endpoint for translation"""
     if not request.text.strip():
         raise HTTPException(status_code=400, detail="No text provided")
     
@@ -633,7 +286,7 @@ async def api_translate(request: TranslationRequest):
         # Generate session ID for tracking
         session_id = hashlib.md5(f"{request.text[:100]}{time.time()}".encode()).hexdigest()[:8]
         
-        translation, processing_time, chunks_count = translator.translate_text(
+        translation, processing_time = translator.translate_text(
             request.text, source_code, target_code, session_id
         )
         
@@ -643,8 +296,7 @@ async def api_translate(request: TranslationRequest):
             target_language=request.target_lang,
             processing_time=processing_time,
             character_count=len(request.text),
-            status="success",
-            chunks_processed=chunks_count
+            status="success"
         )
     except Exception as e:
         logger.error(f"[API] Translation error: {str(e)}")
@@ -653,7 +305,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 with enhanced error handling"""
+    """Simplified translation endpoint"""
     try:
         form_data = await request.form()
         text = form_data.get("text", "")
@@ -686,83 +338,33 @@ async def api_translate_form(request: Request):
     # Generate session ID for tracking
     session_id = hashlib.md5(f"{text[:100]}{time.time()}".encode()).hexdigest()[:8]
     
-    # Check if it's a long text that should be processed in background
-    if len(text) > translator.max_chunk_size:
-        # 🔹 اول بررسی کن آیا نتیجه در کش وجود دارد یا نه
-        cached_result = translator.cache.get(text, source_code, target_code)
-        if cached_result:
-            logger.info(f"[FORM API] Returning cached translation immediately for session: {session_id}")
-            return {
-                "translation": cached_result,
-                "source_language": source_lang,
-                "target_language": target_lang,
-                "processing_time": 0.0,
-                "character_count": len(text),
-                "status": "success",
-                "chunks_processed": None,
-                "session_id": session_id,
-                "is_heavy_text": False,
-                "cached": True
-            }
-        # 🔹 اگر در کش نبود → پس بفرست به background
-        task = asyncio.create_task(
-            translator.translate_text_async(text, source_code, target_code, session_id)
+    try:
+        translation, processing_time = await translator.translate_text_async(
+            text, source_code, target_code, session_id
         )
-        translator.background_tasks[session_id] = task
         
-        logger.info(f"[FORM API] Started background translation for session: {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 {
-            "session_id": session_id,
-            "request_id": session_id,
-            "status": "processing",
-            "message": "Translation started in background. Use CHECK RESULT to get your translation.",
+            "translation": translation,
+            "source_language": source_lang,
+            "target_language": target_lang,
+            "processing_time": processing_time,
             "character_count": len(text),
-            "is_background": True,
-            "is_heavy_text": True
+            "status": "success",
+            "session_id": session_id
         }
-    else:
-        # Process short text immediately
-        try:
-            translation, processing_time, chunks_count = await translator.translate_text_async(
-                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,
-                "target_language": target_lang,
-                "processing_time": processing_time,
-                "character_count": len(text),
-                "status": "success",
-                "chunks_processed": chunks_count,
-                "session_id": session_id
-            }
-        except Exception as e:
-            logger.error(f"[FORM API] 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):
-    """Get translation progress for a session"""
-    progress = translator.get_translation_progress(session_id)
-    if progress is None:
-        raise HTTPException(status_code=404, detail="Session not found or completed")
-    
-    return {
-        "status": "success",
-        "progress": progress
-    }
+    except Exception as e:
+        logger.error(f"[FORM API] Translation error: {str(e)}")
+        return {"status": "error", "message": f"Translation error: {str(e)}"}
 
 @app.get("/api/languages")
 async def get_languages():
@@ -781,137 +383,19 @@ async def health_check():
         "device": str(translator.device),
         "model": translator.model_name,
         "cache_size": len(translator.cache.cache),
-        "max_chunk_size": translator.max_chunk_size,
-        "active_translations": len(translator.current_translation),
-        "version": "2.1.0"
-    }
-
-@app.get("/api/status/{session_id}")
-async def get_session_status(session_id: str):
-    """Get translation status - non-blocking"""
-    
-    # Check if task is in background tasks
-    if session_id in translator.background_tasks:
-        task = translator.background_tasks[session_id]
-        
-        if task.done():
-            try:
-                translation, processing_time, chunks_count = await task
-                # Clean up completed task
-                del translator.background_tasks[session_id]
-                
-                return {
-                    "status": "completed",
-                    "translation": translation,
-                    "processing_time": processing_time,
-                    "chunks_processed": chunks_count,
-                    "message": "Translation completed successfully"
-                }
-            except Exception as e:
-                del translator.background_tasks[session_id]
-                return {
-                    "status": "failed",
-                    "message": f"Translation failed: {str(e)}"
-                }
-        else:
-            # Task still running - get progress
-            progress = translator.get_translation_progress(session_id)
-            
-            if progress:
-                return {
-                    "status": "processing",
-                    "progress": progress,
-                    "message": f"Processing chunk {progress['completed_chunks']}/{progress['total_chunks']}",
-                    "estimated_remaining": progress.get('estimated_remaining', 0)
-                }
-            else:
-                return {
-                    "status": "processing",
-                    "message": "Translation in progress...",
-                    "progress": None
-                }
-    
-    # Check current active translations
-    progress = translator.get_translation_progress(session_id)
-    if progress:
-        return {
-            "status": "processing",
-            "progress": progress,
-            "message": f"Processing chunk {progress['completed_chunks']}/{progress['total_chunks']}",
-            "estimated_remaining": progress.get('estimated_remaining', 0)
-        }
-    
-    return {
-        "status": "not_found",
-        "message": "Session not found or completed"
+        "version": "2.0.0"
     }
 
 @app.get("/api/server-status")
 async def get_server_status():
-    """Get current server status - non-blocking"""
-    active_sessions = []
-    background_tasks_count = len(translator.background_tasks)
-    
-    with translator.translation_lock:
-        for session_id, progress in translator.current_translation.items():
-            elapsed_time = time.time() - progress['start_time']
-            if progress['completed_chunks'] > 0:
-                avg_time_per_chunk = elapsed_time / progress['completed_chunks']
-                remaining_chunks = progress['total_chunks'] - progress['completed_chunks']
-                estimated_remaining = avg_time_per_chunk * remaining_chunks
-            else:
-                estimated_remaining = None
-            
-            active_sessions.append({
-                'session_id': session_id,
-                'source_lang': progress['source_lang'],
-                'target_lang': progress['target_lang'],
-                'total_chunks': progress['total_chunks'],
-                'completed_chunks': progress['completed_chunks'],
-                'progress_percentage': (progress['completed_chunks'] / progress['total_chunks']) * 100,
-                'elapsed_time': elapsed_time,
-                'estimated_remaining': estimated_remaining
-            })
-    
-    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']}"
-        else:
-            message = f"{background_tasks_count} translation(s) in background queue"
-            
-        return {
-            "has_active_translation": True,
-            "status": "processing",
-            "message": message,
-            "active_sessions": len(active_sessions),
-            "background_tasks": background_tasks_count,
-            "total_active": len(active_sessions) + background_tasks_count
-        }
-    else:
-        return {
-            "has_active_translation": False,
-            "status": "idle",
-            "message": "Server is ready for new translations",
-            "active_sessions": 0,
-            "background_tasks": 0
-        }
-    
-    if active_sessions:
-        # Return the most recent active session
-        latest_session = active_sessions[-1]
-        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']}",
-            "session_data": latest_session
-        }
-    else:
-        return {
-            "has_active_translation": False,
-            "status": "no_active_translation",
-            "message": "No active translation on server"
-        }
+    """Get current server status"""
+    return {
+        "has_active_translation": False,
+        "status": "idle",
+        "message": "Server is ready for new translations",
+        "active_sessions": 0,
+        "background_tasks": 0
+    }
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)