Update app.py

app.py

@@ -1,34 +1,47 @@
+# server.py
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
 import threading
-import torch
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 import time
 import json
 import hashlib
 import re
 from datetime import datetime, timedelta
-import threading
 from queue import Queue
 import logging
-from typing import Dict, List, Tuple, Optional
+from typing import Dict, List, Tuple, Optional, Any
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import uvicorn
+import os
+
+# Optional: Transformers (if you want local model)
+# If you don't plan to run a local transformer, you can still keep API and adapt.
+try:
+    from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+    TRANSFORMERS_AVAILABLE = True
+except Exception:
+    TRANSFORMERS_AVAILABLE = False
+
+# ----------------------- Configuration -----------------------
+LOG_FILE = os.environ.get("TRANSLATION_LOG", "translation.log")
+HF_MODEL = os.environ.get("HF_MODEL", "facebook/m2m100_418M")  # change to 1.2B if you have resources
+MAX_WORKERS = int(os.environ.get("MAX_WORKERS", "3"))
+CACHE_MINUTES = int(os.environ.get("CACHE_MINUTES", "60"))
+MAX_CHUNK_SIZE = int(os.environ.get("MAX_CHUNK_SIZE", "350"))
+SERVER_HOST = os.environ.get("SERVER_HOST", "0.0.0.0")
+SERVER_PORT = int(os.environ.get("SERVER_PORT", "7860"))
 
-# Enhanced logging configuration
+# ----------------------- Logging -----------------------
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler('translation.log')
-    ]
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(), logging.FileHandler(LOG_FILE)]
 )
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("translator-server")
 
-# Pydantic models for request/response
+# ----------------------- Pydantic Models -----------------------
 class TranslationRequest(BaseModel):
     text: str
     source_lang: str
@@ -46,481 +59,13 @@ class TranslationResponse(BaseModel):
     estimated_time_remaining: Optional[float] = None
     current_chunk: Optional[int] = None
     total_chunks: Optional[int] = None
+    session_id: Optional[str] = None
 
-class TranslationCache:
-    def __init__(self, cache_duration_minutes: int = 60):
-        self.cache = {}
-        self.cache_duration = timedelta(minutes=cache_duration_minutes)
-        self.lock = threading.Lock()
-    
-    def _generate_key(self, text: str, source_lang: str, target_lang: str) -> str:
-        """Generate cache key from text and languages"""
-        content = f"{text}_{source_lang}_{target_lang}"
-        return hashlib.md5(content.encode()).hexdigest()
-    
-    def get(self, text: str, source_lang: str, target_lang: str) -> str:
-        """Get translation from cache if exists and not expired"""
-        with self.lock:
-            key = self._generate_key(text, source_lang, target_lang)
-            if key in self.cache:
-                translation, timestamp = self.cache[key]
-                if datetime.now() - timestamp < self.cache_duration:
-                    logger.info(f"[CACHE HIT] Retrieved cached translation for key: {key[:8]}... | Length: {len(translation)} chars")
-                    return translation
-                else:
-                    # Remove expired entry
-                    del self.cache[key]
-                    logger.info(f"[CACHE EXPIRED] Removed expired cache entry for key: {key[:8]}...")
-            logger.info(f"[CACHE MISS] No cached translation found for key: {key[:8]}...")
-            return None
-    
-    def set(self, text: str, source_lang: str, target_lang: str, translation: str):
-        """Store translation in cache"""
-        with self.lock:
-            key = self._generate_key(text, source_lang, target_lang)
-            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
-        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")
-
-        # Load model - using a powerful multilingual model
-        self.model_name = "facebook/m2m100_1.2B"
-        logger.info(f"[INIT] Loading model: {self.model_name}")
-        
-        try:
-            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
-            self.model.to(self.device)
-            logger.info(f"[INIT] Model loaded successfully on {self.device}!")
-        except Exception as e:
-            logger.error(f"[INIT] Error loading model: {e}")
-            raise
-        
-        # تنظیمات بهینه برای ترجمه متن‌های بلند
-        self.max_chunk_size = 350  # حداکثر طول هر قسمت
-        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
-        
-        # Track translation progress
-        self.current_translation = {}
-        self.translation_lock = threading.Lock()
-        
-        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]}")
-            
-            # 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 ها برای کیفیت بهتر
-                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
-            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)
-            
-            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)
-            
-            return final_translation, processing_time, len(chunks)
-            
-        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
-
-    async def translate_text_async(self, text: str, source_lang: str, target_lang: str, session_id: str = None):
-        """Async wrapper for translate_text"""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(
-            self.executor, 
-            self.translate_text, 
-            text, source_lang, target_lang, session_id
-        )
-
-# Language mappings for M2M100 model
+# ----------------------- Language Map -----------------------
 LANGUAGE_MAP = {
     "English": "en",
-    "Persian (Farsi)": "fa", 
+    "Persian (Farsi)": "fa",
+    "Persian": "fa",
     "Arabic": "ar",
     "French": "fr",
     "German": "de",
@@ -529,6 +74,7 @@ LANGUAGE_MAP = {
     "Portuguese": "pt",
     "Russian": "ru",
     "Chinese (Simplified)": "zh",
+    "Chinese": "zh",
     "Japanese": "ja",
     "Korean": "ko",
     "Hindi": "hi",
@@ -588,156 +134,555 @@ LANGUAGE_MAP = {
     "Zulu": "zu"
 }
 
-# Initialize translator
-translator = MultilingualTranslator(60)
+# ----------------------- Helpers -----------------------
+def generate_session_id(prefix: str = "") -> str:
+    return hashlib.md5(f"{prefix}_{time.time()}_{os.urandom(8)}".encode()).hexdigest()[:12]
 
-# Create FastAPI app
-app = FastAPI(title="Enhanced Multilingual Translation API", version="2.1.0")
+# ----------------------- Cache -----------------------
+class TranslationCache:
+    def __init__(self, cache_duration_minutes: int = CACHE_MINUTES):
+        self.cache: Dict[str, Tuple[str, datetime]] = {}
+        self.cache_duration = timedelta(minutes=cache_duration_minutes)
+        self.lock = threading.Lock()
+
+    def _generate_key(self, text: str, source_lang: str, target_lang: str) -> str:
+        content = f"{text}__{source_lang}__{target_lang}"
+        return hashlib.sha256(content.encode()).hexdigest()
+
+    def get(self, text: str, source_lang: str, target_lang: str) -> Optional[str]:
+        with self.lock:
+            key = self._generate_key(text, source_lang, target_lang)
+            entry = self.cache.get(key)
+            if entry:
+                translation, ts = entry
+                if datetime.utcnow() - ts < self.cache_duration:
+                    logger.info(f"[CACHE HIT] {key[:8]} len={len(translation)}")
+                    return translation
+                else:
+                    del self.cache[key]
+                    logger.info(f"[CACHE EXPIRED] {key[:8]}")
+            logger.debug(f"[CACHE MISS] {key[:8]}")
+        return None
+
+    def set(self, text: str, source_lang: str, target_lang: str, translation: str):
+        with self.lock:
+            key = self._generate_key(text, source_lang, target_lang)
+            self.cache[key] = (translation, datetime.utcnow())
+            logger.info(f"[CACHE SET] {key[:8]} len={len(translation)}")
+
+# ----------------------- Smart Chunker -----------------------
+class TextChunker:
+    """Smart splitting: paragraphs -> sentences -> commas fallback."""
+
+    @staticmethod
+    def split_text_smart(text: str, max_chunk_size: int = MAX_CHUNK_SIZE) -> List[str]:
+        text = text.strip()
+        if not text:
+            return []
+        if len(text) <= max_chunk_size:
+            return [text]
+
+        # First split by paragraphs to preserve structure
+        paragraphs = [p.strip() for p in re.split(r'\n{2,}', text) if p.strip()]
+        chunks: List[str] = []
+        current = ""
+
+        for p in paragraphs:
+            if len(p) <= max_chunk_size:
+                if not current:
+                    current = p
+                else:
+                    if len(current) + 2 + len(p) <= max_chunk_size:
+                        current += "\n\n" + p
+                    else:
+                        chunks.append(current.strip())
+                        current = p
+            else:
+                # paragraph too large -> split to sentences
+                if current:
+                    chunks.append(current.strip())
+                    current = ""
+                parts = TextChunker._split_paragraph(p, max_chunk_size)
+                chunks.extend(parts)
+
+        if current:
+            chunks.append(current.strip())
+
+        # Safety: merge very small chunks
+        merged: List[str] = []
+        for c in chunks:
+            if not merged:
+                merged.append(c)
+            else:
+                if len(merged[-1]) + 1 + len(c) <= max_chunk_size:
+                    merged[-1] = merged[-1] + "\n\n" + c
+                else:
+                    merged.append(c)
+
+        logger.info(f"[CHUNKER] split into {len(merged)} chunks (avg {sum(len(x) for x in merged)/len(merged):.1f} chars)")
+        return merged
+
+    @staticmethod
+    def _split_paragraph(paragraph: str, max_chunk_size: int) -> List[str]:
+        sentences = re.split(r'(?<=[.!?])\s+', paragraph)
+        chunks: List[str] = []
+        current = ""
+        for s in sentences:
+            s = s.strip()
+            if not s:
+                continue
+            if len(s) > max_chunk_size:
+                # fallback: split by commas
+                parts = TextChunker._split_by_comma(s, max_chunk_size)
+                if current:
+                    chunks.append(current.strip()); current = ""
+                chunks.extend(parts)
+            else:
+                if not current:
+                    current = s
+                elif len(current) + 1 + len(s) <= max_chunk_size:
+                    current += " " + s
+                else:
+                    chunks.append(current.strip())
+                    current = s
+        if current:
+            chunks.append(current.strip())
+        return chunks
+
+    @staticmethod
+    def _split_by_comma(sentence: str, max_chunk_size: int) -> List[str]:
+        parts = [p.strip() for p in sentence.split(',') if p.strip()]
+        chunks: List[str] = []
+        current = ""
+        for p in parts:
+            if len(p) > max_chunk_size:
+                # hard cut
+                i = 0
+                while i < len(p):
+                    slice_ = p[i:i+max_chunk_size].strip()
+                    if slice_:
+                        chunks.append(slice_)
+                    i += max_chunk_size
+            else:
+                if not current:
+                    current = p
+                elif len(current) + 2 + len(p) <= max_chunk_size:
+                    current += ", " + p
+                else:
+                    chunks.append(current.strip())
+                    current = p
+        if current:
+            chunks.append(current.strip())
+        return chunks
+
+# ----------------------- Translator Core -----------------------
+class MultilingualTranslator:
+    def __init__(self, cache_minutes: int = CACHE_MINUTES, max_workers: int = MAX_WORKERS):
+        self.device = "cpu"
+        self.model_name = HF_MODEL
+        self.tokenizer = None
+        self.model = None
+        self.generation_lock = threading.Lock()  # ensure model.generate serialized
+        self.executor = ThreadPoolExecutor(max_workers=max_workers)
+        self.background_tasks: Dict[str, asyncio.Task] = {}
+        self.cache = TranslationCache(cache_minutes)
+        self.current_translation: Dict[str, Dict[str, Any]] = {}
+        self.translation_lock = threading.Lock()
+        self.max_chunk_size = MAX_CHUNK_SIZE
+
+        if TRANSFORMERS_AVAILABLE:
+            try:
+                # prefer GPU if available
+                import torch as _torch
+                self.device = "cuda" if _torch.cuda.is_available() else "cpu"
+                logger.info(f"[MODEL] Loading {self.model_name} on {self.device} (this may take time)...")
+                self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, use_fast=False)
+                self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
+                if self.device == "cuda":
+                    self.model.to("cuda")
+                logger.info("[MODEL] Model loaded successfully.")
+            except Exception as e:
+                logger.exception(f"[MODEL] Failed to load model '{self.model_name}': {e}")
+                self.model = None
+                self.tokenizer = None
+        else:
+            logger.warning("[MODEL] transformers not available — running in mock mode (no local model).")
+
+    # internal chunk translation executed in threadpool (but generation uses generation_lock)
+    def _translate_chunk_sync(self, text: str, src_code: str, tgt_code: str, chunk_index: int = 0, total_chunks: int = 1) -> str:
+        """Synchronous chunk translation (called in executor)."""
+        if not text:
+            return ""
+        if self.model is None or self.tokenizer is None:
+            # mock: prefix target language code if no model
+            logger.warning("[TRANSLATE] No model available, returning mock translation.")
+            return f"[{tgt_code}] {text}"
+
+        try:
+            # set tokenizer language if model supports
+            with self.generation_lock:
+                # some tokenizers use .src_lang (M2M100)
+                try:
+                    if hasattr(self.tokenizer, "src_lang"):
+                        self.tokenizer.src_lang = src_code
+                except Exception:
+                    pass
+
+                inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+                if hasattr(inputs, "to"):
+                    # pyright typing
+                    pass
+                # Move tensors to device if cuda
+                import torch as _torch
+                if self.device == "cuda":
+                    for k, v in inputs.items():
+                        if isinstance(v, _torch.Tensor):
+                            inputs[k] = v.to("cuda")
+
+                # determine forced_bos_token_id if available
+                forced_bos = None
+                try:
+                    if hasattr(self.tokenizer, "get_lang_id"):
+                        forced_bos = self.tokenizer.get_lang_id(tgt_code)
+                except Exception:
+                    forced_bos = None
+
+                gen_kwargs = dict(
+                    **inputs,
+                    max_length=1024,
+                    num_beams=4,
+                    early_stopping=True
+                )
+                if forced_bos is not None:
+                    gen_kwargs["forced_bos_token_id"] = forced_bos
+
+                t0 = time.time()
+                outputs = self.model.generate(**gen_kwargs)
+                gen_time = time.time() - t0
+
+                # move to cpu if needed for decode
+                decoded = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0].strip()
+                logger.info(f"[GEN] chunk {chunk_index+1}/{total_chunks} generated in {gen_time:.2f}s len={len(decoded)}")
+                return decoded
+        except Exception as e:
+            logger.exception(f"[TRANSLATE] Error generating chunk: {e}")
+            return f"[Translation Error: {str(e)}]"
 
-# Add CORS middleware
+    async def translate_chunk_async(self, text: str, src_code: str, tgt_code: str, chunk_index: int = 0, total_chunks: int = 1) -> str:
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(self.executor, self._translate_chunk_sync, text, src_code, tgt_code, chunk_index, total_chunks)
+
+    async def translate_text_async(self, text: str, src_code: str, tgt_code: str, session_id: Optional[str] = None) -> Tuple[str, float, int]:
+        """Full translation (async wrapper). Returns (translation, processing_time, chunks_count)"""
+        start_time = time.time()
+        if not session_id:
+            session_id = generate_session_id("sess")
+
+        # check cache full text
+        cached_full = self.cache.get(text, src_code, tgt_code)
+        if cached_full:
+            return cached_full, time.time() - start_time, 1
+
+        # short text
+        if len(text) <= self.max_chunk_size:
+            # update progress
+            with self.translation_lock:
+                self.current_translation[session_id] = {
+                    "total_chunks": 1,
+                    "completed_chunks": 0,
+                    "start_time": start_time,
+                    "source_lang": src_code,
+                    "target_lang": tgt_code
+                }
+            chunk_result = await self.translate_chunk_async(text, src_code, tgt_code, 0, 1)
+            self.cache.set(text, src_code, tgt_code, chunk_result)
+            elapsed = time.time() - start_time
+            with self.translation_lock:
+                self.current_translation.pop(session_id, None)
+            return chunk_result, elapsed, 1
+
+        # long text -> chunking
+        chunks = TextChunker.split_text_smart(text, self.max_chunk_size)
+        total = len(chunks)
+        translated_chunks: List[str] = []
+
+        with self.translation_lock:
+            self.current_translation[session_id] = {
+                "total_chunks": total,
+                "completed_chunks": 0,
+                "start_time": start_time,
+                "source_lang": src_code,
+                "target_lang": tgt_code
+            }
+
+        for i, chunk in enumerate(chunks):
+            # check cached per-chunk
+            c_cached = self.cache.get(chunk, src_code, tgt_code)
+            if c_cached:
+                translated_chunks.append(c_cached)
+                with self.translation_lock:
+                    self.current_translation[session_id]["completed_chunks"] = i + 1
+                logger.debug(f"[SESSION {session_id}] chunk {i+1}/{total} from cache")
+                continue
+
+            # translate chunk
+            chunk_translation = await self.translate_chunk_async(chunk, src_code, tgt_code, i, total)
+            translated_chunks.append(chunk_translation)
+            self.cache.set(chunk, src_code, tgt_code, chunk_translation)
+            with self.translation_lock:
+                self.current_translation[session_id]["completed_chunks"] = i + 1
+
+            # short pause to yield CPU
+            await asyncio.sleep(0.01)
+
+        # combine
+        final = self._combine_translations(translated_chunks, text)
+
+        # set full-text cache
+        self.cache.set(text, src_code, tgt_code, final)
+
+        elapsed = time.time() - start_time
+        with self.translation_lock:
+            self.current_translation.pop(session_id, None)
+
+        return final, elapsed, total
+
+    def submit_background(self, text: str, src_code: str, tgt_code: str, session_id: Optional[str] = None) -> str:
+        """Schedule background translation and return session_id immediately"""
+        if not session_id:
+            session_id = generate_session_id("bg")
+        loop = asyncio.get_event_loop()
+        task = loop.create_task(self._bg_task_wrapper(text, src_code, tgt_code, session_id))
+        self.background_tasks[session_id] = task
+        logger.info(f"[BG] Scheduled background task {session_id}")
+        return session_id
+
+    async def _bg_task_wrapper(self, text: str, src_code: str, tgt_code: str, session_id: str):
+        """Wrapper executed in background to run translate_text_async and keep result accessible"""
+        try:
+            result, elapsed, chunks = await self.translate_text_async(text, src_code, tgt_code, session_id)
+            # store result for retrieval
+            with self.translation_lock:
+                # we can store result in background_tasks as result property or a separate dict
+                # here, we'll attach attributes to task for simplicity
+                task = self.background_tasks.get(session_id)
+                if task is not None:
+                    # monkeypatch result
+                    setattr(task, "result_data", {
+                        "translation": result,
+                        "processing_time": elapsed,
+                        "chunks": chunks,
+                        "character_count": len(text),
+                        "status": "completed"
+                    })
+            logger.info(f"[BG] Completed background {session_id} len={len(result)}")
+        except Exception as e:
+            logger.exception(f"[BG] Error in background task {session_id}: {e}")
+            task = self.background_tasks.get(session_id)
+            if task is not None:
+                setattr(task, "result_data", {
+                    "translation": None,
+                    "processing_time": 0.0,
+                    "chunks": 0,
+                    "character_count": len(text),
+                    "status": "failed",
+                    "error": str(e)
+                })
+
+    def get_background_result(self, session_id: str) -> Optional[Dict]:
+        task = self.background_tasks.get(session_id)
+        if not task:
+            return None
+        if task.done():
+            # if result_data present, return it
+            res = getattr(task, "result_data", None)
+            # cleanup
+            try:
+                del self.background_tasks[session_id]
+            except KeyError:
+                pass
+            return res
+        else:
+            return {
+                "status": "processing",
+                "progress": self.get_translation_progress(session_id)
+            }
+
+    def get_translation_progress(self, session_id: str) -> Optional[Dict]:
+        with self.translation_lock:
+            if session_id not in self.current_translation:
+                return None
+            p = self.current_translation[session_id].copy()
+        elapsed = time.time() - p['start_time']
+        completed = p.get('completed_chunks', 0)
+        total = p.get('total_chunks', 1)
+        estimated_remaining = None
+        if completed > 0:
+            avg = elapsed / completed
+            estimated_remaining = avg * (total - completed)
+        return {
+            "total_chunks": total,
+            "completed_chunks": completed,
+            "elapsed_time": elapsed,
+            "estimated_remaining": estimated_remaining,
+            "progress_percentage": (completed / total) * 100 if total else 0
+        }
+
+    def _combine_translations(self, translated_chunks: List[str], original_text: str) -> str:
+        # simple join preserving paragraph breaks if existed
+        if not translated_chunks:
+            return ""
+        # if original had paragraphs
+        if "\n\n" in original_text:
+            sep = "\n\n"
+        else:
+            sep = " "
+        combined = sep.join([c.strip() for c in translated_chunks if c and c.strip()])
+        # normalize whitespace
+        combined = re.sub(r'\s+', ' ', combined).strip()
+        return combined
+
+# ----------------------- Translator Initialization -----------------------
+translator = MultilingualTranslator(cache_minutes=CACHE_MINUTES, max_workers=MAX_WORKERS)
+
+# ----------------------- FastAPI App -----------------------
+app = FastAPI(title="Enhanced Multilingual Translation API", version="2.1.0")
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["*"],  # in production, set your WP domain(s)
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# ----------------------- Routes -----------------------
 @app.get("/")
 async def root():
     return {
-        "message": "Enhanced Multilingual Translation API v2.1", 
-        "status": "active", 
-        "features": [
-            "enhanced_logging", 
-            "progress_tracking", 
-            "long_text_support", 
-            "smart_chunking", 
-            "cache_optimization"
-        ]
+        "message": "Enhanced Multilingual Translation API v2.1",
+        "status": "active",
+        "model": translator.model_name,
+        "device": getattr(translator, "device", "cpu"),
+        "features": ["cache", "background_tasks", "progress_tracking", "chunking"]
     }
 
-@app.post("/api/translate")
+@app.post("/api/translate", response_model=TranslationResponse)
 async def api_translate(request: TranslationRequest):
-    """API endpoint for translation with enhanced logging and progress tracking"""
-    if not request.text.strip():
+    """
+    JSON endpoint for synchronous translation. Waits until translation completes.
+    (Suitable for short texts)
+    """
+    text = request.text or ""
+    if not text.strip():
         raise HTTPException(status_code=400, detail="No text provided")
-    
-    source_code = LANGUAGE_MAP.get(request.source_lang)
-    target_code = LANGUAGE_MAP.get(request.target_lang)
-    
-    if not source_code or not target_code:
-        raise HTTPException(status_code=400, detail="Invalid language codes")
-    
+
+    # map language names to codes if needed
+    src_code = LANGUAGE_MAP.get(request.source_lang, request.source_lang)
+    tgt_code = LANGUAGE_MAP.get(request.target_lang, request.target_lang)
+
+    # Run translation (async)
     try:
-        # 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(
-            request.text, source_code, target_code, session_id
-        )
-        
+        translation, processing_time, chunks_count = await translator.translate_text_async(text, src_code, tgt_code)
         return TranslationResponse(
             translation=translation,
             source_language=request.source_lang,
             target_language=request.target_lang,
-            processing_time=processing_time,
-            character_count=len(request.text),
+            processing_time=float(processing_time),
+            character_count=len(text),
             status="success",
-            chunks_processed=chunks_count
+            chunks_processed=chunks_count,
+            estimated_time_remaining=0.0,
+            current_chunk=chunks_count,
+            total_chunks=chunks_count,
+            session_id=None
         )
     except Exception as e:
-        logger.error(f"[API] Translation error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")
+        logger.exception("[API] translate error")
+        raise HTTPException(status_code=500, detail=str(e))
 
-# 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"""
+    """
+    Compatibility endpoint for form-data (used by WP plugin's call).
+    Accepts either form-encoded or JSON payload.
+    Behavior:
+      - If short text -> translate immediately and return translation
+      - If long text -> check cache; if cached return result; else schedule background and return session info
+    """
     try:
-        form_data = await request.form()
-        text = form_data.get("text", "")
-        source_lang = form_data.get("source_lang", "")
-        target_lang = form_data.get("target_lang", "")
-        api_key = form_data.get("api_key", None)
-    except:
+        form = await request.form()
+        # form() returns a starlette.datastructures.FormData object; fallback if empty
+        data = dict(form) if form else {}
+        # prefer form fields
+        text = data.get("text") or (await request.json()).get("text") if request.headers.get("content-type", "").startswith("application/json") else None
+        source_lang = data.get("source_lang") or (await request.json()).get("source_lang") if text is None else data.get("source_lang")
+        target_lang = data.get("target_lang") or (await request.json()).get("target_lang") if text is None else data.get("target_lang")
+        api_key = data.get("api_key") or None
+    except Exception:
+        # fallback: try json directly
         try:
-            json_data = await request.json()
-            text = json_data.get("text", "")
-            source_lang = json_data.get("source_lang", "")
-            target_lang = json_data.get("target_lang", "")
-            api_key = json_data.get("api_key", None)
-        except:
+            payload = await request.json()
+            text = payload.get("text", "")
+            source_lang = payload.get("source_lang", "")
+            target_lang = payload.get("target_lang", "")
+            api_key = payload.get("api_key", None)
+        except Exception:
             raise HTTPException(status_code=400, detail="Invalid request format")
-    
-    logger.info(f"[FORM API] Translation request | {source_lang} → {target_lang} | Length: {len(text)} chars")
-    
+
+    text = text or ""
+    source_lang = source_lang or ""
+    target_lang = target_lang or ""
+
+    logger.info(f"[FORM API] Request: {len(text)} chars | {source_lang} -> {target_lang}")
+
     if not text.strip():
-        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:
-        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]
-    
-    # Check if it's a long text that should be processed in background
+
+    src_code = LANGUAGE_MAP.get(source_lang, source_lang)
+    tgt_code = LANGUAGE_MAP.get(target_lang, target_lang)
+
+    # Generate session id
+    session_id = generate_session_id("req")
+
+    # If long text -> 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}")
+        # Check full-text cache first
+        cached_full = translator.cache.get(text, src_code, tgt_code)
+        if cached_full:
+            logger.info(f"[FORM API] returning cached full result for session {session_id}")
             return {
-                "translation": cached_result,
-                "source_language": source_lang,
-                "target_language": target_lang,
+                "translation": cached_full,
                 "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)
-        )
+
+        # schedule background translation
+        # ensure we schedule within event loop
+        loop = asyncio.get_event_loop()
+        task = loop.create_task(translator._bg_task_wrapper(text, src_code, tgt_code, session_id))
         translator.background_tasks[session_id] = task
-        
-        logger.info(f"[FORM API] Started background translation for session: {session_id}")
-        
+        logger.info(f"[FORM API] background scheduled session {session_id}")
         return {
             "session_id": session_id,
             "request_id": session_id,
             "status": "processing",
-            "message": "Translation started in background. Use CHECK RESULT to get your translation.",
+            "message": "Translation started in background. Use /api/status/{session_id} or /api/progress/{session_id} to check.",
             "character_count": len(text),
             "is_background": True,
             "is_heavy_text": True
         }
     else:
-        # Process short text immediately
+        # short text - translate 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")
+            translation, processing_time, chunks_count = await translator.translate_text_async(text, src_code, tgt_code, session_id)
+            # validate
+            if not translation or (isinstance(translation, str) and translation.lower().startswith("translation error")):
+                logger.error("[FORM API] Invalid translation result")
+                return {"status": "error", "message": "Translation failed - empty or invalid result", "session_id": session_id}
             return {
                 "translation": translation,
                 "source_language": source_lang,
@@ -746,172 +691,119 @@ async def api_translate_form(request: Request):
                 "character_count": len(text),
                 "status": "success",
                 "chunks_processed": chunks_count,
-                "session_id": session_id
+                "session_id": session_id,
+                "cached": False
             }
         except Exception as e:
-            logger.error(f"[FORM API] Translation error: {str(e)}")
+            logger.exception("[FORM API] translation error")
             return {"status": "error", "message": f"Translation error: {str(e)}"}
 
+@app.get("/api/status/{session_id}")
+async def get_session_status(session_id: str):
+    """Return completed result if available, or processing state."""
+    # check background tasks dict first
+    bg = translator.background_tasks.get(session_id)
+    if bg:
+        if bg.done():
+            res = getattr(bg, "result_data", None)
+            if res:
+                return {
+                    "status": "completed",
+                    "translation": res.get("translation"),
+                    "processing_time": res.get("processing_time"),
+                    "chunks_processed": res.get("chunks"),
+                    "character_count": res.get("character_count")
+                }
+            else:
+                return {"status": "completed", "message": "Completed but no data"}
+        else:
+            progress = translator.get_translation_progress(session_id)
+            return {"status": "processing", "progress": progress}
+
+    # else check current_translation (in-progress immediate)
+    prog = translator.get_translation_progress(session_id)
+    if prog:
+        return {"status": "processing", "progress": prog}
+    return {"status": "not_found", "message": "Session not found or already cleaned up"}
+
 @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:
+    p = translator.get_translation_progress(session_id)
+    if p is None:
         raise HTTPException(status_code=404, detail="Session not found or completed")
-    
-    return {
-        "status": "success",
-        "progress": progress
-    }
+    return {"status": "success", "progress": p}
+
+@app.get("/api/result/{session_id}")
+async def get_result(session_id: str):
+    # check background
+    bg = translator.background_tasks.get(session_id)
+    if bg and bg.done():
+        res = getattr(bg, "result_data", None)
+        if res:
+            return {
+                "status": "success",
+                "translation": res.get("translation"),
+                "processing_time": res.get("processing_time"),
+                "character_count": res.get("character_count"),
+                "chunks_processed": res.get("chunks"),
+                "session_id": session_id
+            }
+        else:
+            return {"status": "error", "message": "Completed but no result data"}
+
+    # if still processing
+    prog = translator.get_translation_progress(session_id)
+    if prog:
+        return {"status": "processing", "progress": prog}
+
+    # maybe not found
+    raise HTTPException(status_code=404, detail="Session not found")
 
 @app.get("/api/languages")
 async def get_languages():
-    """Get supported languages"""
-    return {
-        "languages": list(LANGUAGE_MAP.keys()),
-        "language_codes": LANGUAGE_MAP,
-        "status": "success"
-    }
+    return {"languages": list(LANGUAGE_MAP.keys()), "language_codes": LANGUAGE_MAP, "status": "success"}
 
 @app.get("/api/health")
 async def health_check():
-    """Health check endpoint"""
     return {
         "status": "healthy",
-        "device": str(translator.device),
-        "model": translator.model_name,
+        "device": getattr(translator, "device", "cpu"),
+        "model": getattr(translator, "model_name", None),
         "cache_size": len(translator.cache.cache),
         "max_chunk_size": translator.max_chunk_size,
         "active_translations": len(translator.current_translation),
+        "background_tasks": len(translator.background_tasks),
         "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"
-    }
-
 @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
-            
+        for sid, progress in translator.current_translation.items():
+            elapsed = time.time() - progress['start_time']
+            completed = progress.get('completed_chunks', 0)
+            total = progress.get('total_chunks', 1)
+            percent = (completed / total) * 100 if total else 0
             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
+                "session_id": sid,
+                "source_lang": progress.get('source_lang'),
+                "target_lang": progress.get('target_lang'),
+                "total_chunks": total,
+                "completed_chunks": completed,
+                "progress_percentage": percent,
+                "elapsed_time": elapsed
             })
-    
-    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"
-        }
+    bg_count = len(translator.background_tasks)
+    return {
+        "has_active_translation": bool(active_sessions) or bg_count > 0,
+        "active_sessions": active_sessions,
+        "background_tasks": bg_count,
+        "message": f"{len(active_sessions)} active, {bg_count} in background"
+    }
 
+# ----------------------- Run -----------------------
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    # uvicorn.run(app, host="0.0.0.0", port=7860)
+    logger.info(f"Starting server on {SERVER_HOST}:{SERVER_PORT} (model={translator.model_name})")
+    uvicorn.run("server:app", host=SERVER_HOST, port=SERVER_PORT, log_level="info", reload=False)