Update app.py

app.py

@@ -1,4 +1,3 @@
-# translator_server_with_progress.py
 import torch
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 import time
@@ -9,27 +8,17 @@ from datetime import datetime, timedelta
 import threading
 from queue import Queue
 import logging
-from typing import Dict, List, Tuple, Optional, Any
-from fastapi import FastAPI, HTTPException, Request, BackgroundTasks
+from typing import Dict, List, Tuple, Optional
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse, JSONResponse
 from pydantic import BaseModel
 import uvicorn
-import uuid
-import asyncio
 
-# ------------------------
-# Logging setup
-# ------------------------
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
-)
-logger = logging.getLogger("translator_app")
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# ------------------------
-# Pydantic models
-# ------------------------
+# Pydantic models for request/response
 class TranslationRequest(BaseModel):
     text: str
     source_lang: str
@@ -45,67 +34,6 @@ class TranslationResponse(BaseModel):
     status: str
     chunks_processed: Optional[int] = None
 
-# ------------------------
-# Job / Progress management
-# ------------------------
-class JobStore:
-    """Thread-safe in-memory job store for tracking translation progress and results."""
-    def __init__(self):
-        self._store: Dict[str, Dict[str, Any]] = {}
-        self._lock = threading.Lock()
-
-    def create_job(self, text: str, source_lang: str, target_lang: str) -> str:
-        job_id = uuid.uuid4().hex
-        with self._lock:
-            self._store[job_id] = {
-                "job_id": job_id,
-                "status": "queued",            # queued, running, success, failed, cancelled
-                "progress": 0.0,               # percent 0.0 - 100.0
-                "chunks_total": None,
-                "chunks_processed": 0,
-                "start_time": None,
-                "last_update": None,
-                "eta_seconds": None,
-                "message": "Job created",
-                "source_lang": source_lang,
-                "target_lang": target_lang,
-                "character_count": len(text),
-                "result": None,
-                "error": None
-            }
-        logger.info(f"Created job {job_id[:8]}... (chars={len(text)})")
-        return job_id
-
-    def update(self, job_id: str, **kwargs):
-        with self._lock:
-            if job_id not in self._store:
-                logger.warning(f"Attempt to update unknown job {job_id}")
-                return
-            self._store[job_id].update(kwargs)
-            self._store[job_id]["last_update"] = datetime.utcnow()
-        # log a concise message for visibility
-        logger.info(f"Job {job_id[:8]}... update: status={self._store[job_id]['status']} progress={self._store[job_id]['progress']:.1f}% message={self._store[job_id]['message']}")
-
-    def get(self, job_id: str) -> Optional[Dict[str, Any]]:
-        with self._lock:
-            return dict(self._store[job_id]) if job_id in self._store else None
-
-    def set_result(self, job_id: str, result: str, status: str = "success", error: Optional[str] = None):
-        with self._lock:
-            if job_id not in self._store:
-                return
-            self._store[job_id]["result"] = result
-            self._store[job_id]["status"] = status
-            self._store[job_id]["error"] = error
-            self._store[job_id]["progress"] = 100.0 if status == "success" else self._store[job_id]["progress"]
-            self._store[job_id]["last_update"] = datetime.utcnow()
-        logger.info(f"Job {job_id[:8]}... finished with status={status} error={error}")
-
-job_store = JobStore()
-
-# ------------------------
-# Cache (unchanged logic but thread-safe)
-# ------------------------
 class TranslationCache:
     def __init__(self, cache_duration_minutes: int = 60):
         self.cache = {}
@@ -113,10 +41,12 @@ class TranslationCache:
         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) -> Optional[str]:
+    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:
@@ -125,18 +55,17 @@ class TranslationCache:
                     logger.info(f"Cache hit for key: {key[:8]}...")
                     return translation
                 else:
+                    # Remove expired entry
                     del self.cache[key]
             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"Cached translation for key: {key[:8]}...")
 
-# ------------------------
-# Queue for background tasks (keeps existing behavior)
-# ------------------------
 class TranslationQueue:
     def __init__(self, max_workers: int = 3):
         self.queue = Queue()
@@ -145,9 +74,11 @@ class TranslationQueue:
         self.lock = threading.Lock()
     
     def add_task(self, task_func, *args, **kwargs):
+        """Add translation task to queue"""
         self.queue.put((task_func, args, kwargs))
     
     def process_queue(self):
+        """Process tasks from queue"""
         while not self.queue.empty():
             with self.lock:
                 if self.current_workers >= self.max_workers:
@@ -160,35 +91,43 @@ class TranslationQueue:
                     
                     def worker():
                         try:
-                            task_func(*args, **kwargs)
+                            result = task_func(*args, **kwargs)
+                            return result
                         finally:
                             with self.lock:
                                 self.current_workers -= 1
                     
-                    thread = threading.Thread(target=worker, daemon=True)
+                    thread = threading.Thread(target=worker)
                     thread.start()
 
-translation_queue = TranslationQueue(max_workers=3)
-
-# ------------------------
-# Text chunker (unchanged)
-# ------------------------
 class TextChunker:
+    """کلاس برای تقسیم متن طولانی به بخش‌های کوچکتر"""
+    
     @staticmethod
     def split_text_smart(text: str, max_chunk_size: int = 400) -> List[str]:
+        """تقسیم هوشمند متن بر اساس جملات و پاراگراف‌ها"""
         if len(text) <= max_chunk_size:
             return [text]
+        
         chunks = []
+        
+        # تقسیم بر اساس پاراگراف‌ها
         paragraphs = text.split('\n\n')
         current_chunk = ""
+        
         for paragraph in paragraphs:
+            # اگر پاراگراف خودش بزرگ است، آن را تقسیم کن
             if len(paragraph) > max_chunk_size:
+                # ذخیره قسمت فعلی اگر وجود دارد
                 if current_chunk.strip():
                     chunks.append(current_chunk.strip())
                     current_chunk = ""
+                
+                # تقسیم پاراگراف بزرگ
                 sub_chunks = TextChunker._split_paragraph(paragraph, max_chunk_size)
                 chunks.extend(sub_chunks)
             else:
+                # بررسی اینکه آیا اضافه کردن این پاراگراف از حد تجاوز می‌کند
                 if len(current_chunk) + len(paragraph) + 2 > max_chunk_size:
                     if current_chunk.strip():
                         chunks.append(current_chunk.strip())
@@ -198,24 +137,35 @@ class TextChunker:
                         current_chunk += "\n\n" + paragraph
                     else:
                         current_chunk = paragraph
+        
+        # اضافه کردن آخرین قسمت
         if current_chunk.strip():
             chunks.append(current_chunk.strip())
+        
         return chunks
     
     @staticmethod
     def _split_paragraph(paragraph: str, max_chunk_size: int) -> List[str]:
+        """تقسیم پاراگراف بزرگ به جملات"""
+        # تقسیم بر اساس جملات
         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:
@@ -228,23 +178,31 @@ class TextChunker:
                         current_chunk += " " + sentence
                     else:
                         current_chunk = sentence
+        
         if current_chunk.strip():
             chunks.append(current_chunk.strip())
+        
         return chunks
     
     @staticmethod
     def _split_by_comma(sentence: str, max_chunk_size: int) -> List[str]:
+        """تقسیم جمله طولانی بر اساس کاما"""
         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:
@@ -257,16 +215,180 @@ class TextChunker:
                         current_chunk += ", " + part
                     else:
                         current_chunk = part
+        
         if current_chunk.strip():
             chunks.append(current_chunk.strip())
+        
         return chunks
 
-# ------------------------
-# Language map (same)
-# ------------------------
+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"Using device: {self.device}")
+        
+        # Initialize cache and queue
+        self.cache = TranslationCache(cache_duration_minutes)
+        self.queue = TranslationQueue()
+        
+        # Load model - using a powerful multilingual model
+        self.model_name = "facebook/m2m100_1.2B"
+        logger.info(f"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("Model loaded successfully!")
+        except Exception as e:
+            logger.error(f"Error loading model: {e}")
+            raise
+        
+        # تنظیمات بهینه برای ترجمه متن‌های بلند
+        self.max_chunk_size = 350  # حداکثر طول هر قسمت
+        self.min_chunk_overlap = 20  # همپوشانی بین قسمت‌ها
+    
+    def translate_chunk(self, text: str, source_lang: str, target_lang: str) -> str:
+        """ترجمه یک قسمت کوچک از متن"""
+        try:
+            # 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)
+            
+            # Generate translation with optimized parameters
+            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
+            )
+            
+            # Decode result
+            translation = self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
+            
+            # پاک‌سازی ترجمه از کاراکترهای اضافی
+            translation = translation.strip()
+            
+            return translation
+            
+        except Exception as e:
+            logger.error(f"Chunk translation error: {e}")
+            return f"[Translation Error: {str(e)}]"
+    
+    def translate_text(self, text: str, source_lang: str, target_lang: str) -> Tuple[str, float, int]:
+        """ترجمه متن با پشتیبانی از متن‌های طولانی"""
+        start_time = time.time()
+        
+        # بررسی کش برای کل متن
+        cached_result = self.cache.get(text, source_lang, target_lang)
+        if cached_result:
+            return cached_result, time.time() - start_time, 1
+        
+        try:
+            # اگر متن کوتاه است، مستقیماً ترجمه کن
+            if len(text) <= self.max_chunk_size:
+                translation = self.translate_chunk(text, source_lang, target_lang)
+                
+                # ذخیره در کش
+                self.cache.set(text, source_lang, target_lang, translation)
+                processing_time = time.time() - start_time
+                logger.info(f"Short text translation completed in {processing_time:.2f} seconds")
+                
+                return translation, processing_time, 1
+            
+            # تقسیم متن طولانی به قسمت‌های کوچکتر
+            chunks = TextChunker.split_text_smart(text, self.max_chunk_size)
+            logger.info(f"Split long text into {len(chunks)} chunks")
+            
+            # ترجمه هر قسمت
+            translated_chunks = []
+            for i, chunk in enumerate(chunks):
+                logger.info(f"Translating chunk {i+1}/{len(chunks)} (length: {len(chunk)})")
+                
+                # بررسی کش برای هر قسمت
+                chunk_translation = self.cache.get(chunk, source_lang, target_lang)
+                
+                if not chunk_translation:
+                    chunk_translation = self.translate_chunk(chunk, source_lang, target_lang)
+                    # ذخیره قسمت در کش
+                    self.cache.set(chunk, source_lang, target_lang, chunk_translation)
+                
+                translated_chunks.append(chunk_translation)
+                
+                # کمی استراحت بین ترجمه‌ها برای جلوگیری از بارگذاری زیاد
+                if i < len(chunks) - 1:
+                    time.sleep(0.1)
+            
+            # ترکیب قسمت‌های ترجمه شده
+            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"Long text translation completed in {processing_time:.2f} seconds ({len(chunks)} chunks)")
+            
+            return final_translation, processing_time, len(chunks)
+            
+        except Exception as e:
+            logger.error(f"Translation error: {e}")
+            return f"Translation error: {str(e)}", time.time() - start_time, 0
+    
+    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]
+        
+        # ترکیب قسمت‌ها با در نظر گیری ساختار اصلی متن
+        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()
+        
+        return result
+
+# Language mappings for M2M100 model
 LANGUAGE_MAP = {
     "English": "en",
-    "Persian (Farsi)": "fa",
+    "Persian (Farsi)": "fa", 
     "Arabic": "ar",
     "French": "fr",
     "German": "de",
@@ -334,194 +456,13 @@ LANGUAGE_MAP = {
     "Zulu": "zu"
 }
 
-# ------------------------
-# Translator with progress callbacks
-# ------------------------
-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"Using device: {self.device}")
-
-        self.cache = TranslationCache(cache_duration_minutes)
-        self.queue = translation_queue
-
-        # Load model
-        self.model_name = "facebook/m2m100_1.2B"
-        logger.info(f"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("Model loaded successfully!")
-        except Exception as e:
-            logger.error(f"Error loading model: {e}")
-            raise
-
-        self.max_chunk_size = 350
-        self.min_chunk_overlap = 20
-
-    def translate_chunk(self, text: str, source_lang: str, target_lang: str) -> str:
-        try:
-            # set tokenizer src lang if model requires
-            # Some m2m tokenizers require src_lang attribute
-            try:
-                self.tokenizer.src_lang = source_lang
-            except Exception:
-                pass
-
-            encoded = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(self.device)
-            generated_tokens = self.model.generate(
-                **encoded,
-                forced_bos_token_id=self.tokenizer.get_lang_id(target_lang) if hasattr(self.tokenizer, "get_lang_id") else None,
-                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,
-                pad_token_id=self.tokenizer.pad_token_id,
-                eos_token_id=self.tokenizer.eos_token_id
-            )
-            translation = self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-            return translation.strip()
-        except Exception as e:
-            logger.exception("Chunk translation error")
-            return f"[Translation Error: {str(e)}]"
-
-    def translate_text(self, text: str, source_lang: str, target_lang: str, job_id: Optional[str] = None) -> Tuple[str, float, int]:
-        """
-        Translate text. If job_id is provided, update job_store with progress.
-        Returns (translation, processing_time, chunks_count)
-        """
-        start_time = time.time()
-        if job_id:
-            job_store.update(job_id, status="running", message="Starting translation", start_time=datetime.utcnow())
-
-        # whole-text cache
-        cached_result = self.cache.get(text, source_lang, target_lang)
-        if cached_result:
-            processing_time = time.time() - start_time
-            if job_id:
-                job_store.set_result(job_id, cached_result, status="success")
-                job_store.update(job_id, progress=100.0, chunks_processed=1, chunks_total=1, message="Cache hit - completed", eta_seconds=0)
-            logger.info(f"Cache returned result in {processing_time:.2f}s")
-            return cached_result, processing_time, 1
-
-        try:
-            if len(text) <= self.max_chunk_size:
-                # single chunk fast path
-                if job_id:
-                    job_store.update(job_id, chunks_total=1, chunks_processed=0, message="Translating single chunk")
-                translation = self.translate_chunk(text, source_lang, target_lang)
-                self.cache.set(text, source_lang, target_lang, translation)
-                processing_time = time.time() - start_time
-                if job_id:
-                    job_store.set_result(job_id, translation, status="success")
-                    job_store.update(job_id, progress=100.0, chunks_processed=1, chunks_total=1, message="Completed", eta_seconds=0)
-                logger.info(f"Short text translation completed in {processing_time:.2f} seconds")
-                return translation, processing_time, 1
-
-            # long text -> chunking
-            chunks = TextChunker.split_text_smart(text, self.max_chunk_size)
-            total_chunks = len(chunks)
-            if job_id:
-                job_store.update(job_id, chunks_total=total_chunks, chunks_processed=0, progress=0.0, message=f"Split into {total_chunks} chunks")
-            logger.info(f"Split long text into {total_chunks} chunks")
-
-            translated_chunks = []
-            chunk_times: List[float] = []
-            for i, chunk in enumerate(chunks):
-                chunk_start = time.time()
-                logger.info(f"Translating chunk {i+1}/{total_chunks} length={len(chunk)}")
-                if job_id:
-                    job_store.update(job_id, message=f"Translating chunk {i+1}/{total_chunks}")
-
-                # check per-chunk cache
-                chunk_cached = self.cache.get(chunk, source_lang, target_lang)
-                if chunk_cached:
-                    ct = chunk_cached
-                    logger.info(f"Chunk {i+1} cache hit")
-                else:
-                    ct = self.translate_chunk(chunk, source_lang, target_lang)
-                    self.cache.set(chunk, source_lang, target_lang, ct)
-
-                translated_chunks.append(ct)
-                chunk_elapsed = time.time() - chunk_start
-                chunk_times.append(chunk_elapsed)
-
-                # update progress
-                processed = i + 1
-                avg = sum(chunk_times) / len(chunk_times) if chunk_times else 0.0
-                remaining = max(0, total_chunks - processed)
-                eta = avg * remaining
-                progress_percent = (processed / total_chunks) * 100.0
-
-                if job_id:
-                    job_store.update(job_id,
-                                     chunks_processed=processed,
-                                     progress=round(progress_percent, 2),
-                                     eta_seconds=round(eta, 1),
-                                     message=f"Processed {processed}/{total_chunks} chunks (avg_chunk={avg:.2f}s)")
-
-                # small throttle to be kind to device
-                if i < total_chunks - 1:
-                    time.sleep(0.05)
-
-            # combine
-            final_translation = self._combine_translations(translated_chunks, text)
-            self.cache.set(text, source_lang, target_lang, final_translation)
-            processing_time = time.time() - start_time
-
-            if job_id:
-                job_store.set_result(job_id, final_translation, status="success")
-                job_store.update(job_id, progress=100.0, chunks_processed=total_chunks, chunks_total=total_chunks,
-                                 message=f"Completed in {processing_time:.2f}s", eta_seconds=0)
-
-            logger.info(f"Long text translation completed in {processing_time:.2f} seconds ({total_chunks} chunks)")
-            return final_translation, processing_time, total_chunks
-
-        except Exception as e:
-            logger.exception("Translation error")
-            processing_time = time.time() - start_time
-            if job_id:
-                job_store.set_result(job_id, "", status="failed", error=str(e))
-                job_store.update(job_id, progress=0.0, message=f"Failed: {str(e)}")
-            return f"Translation error: {str(e)}", processing_time, 0
-
-    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]
-        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)
-        return result.strip()
-
-# initialize translator (loads model) - this can take time at startup
+# Initialize translator
 translator = MultilingualTranslator(60)
 
-# ------------------------
-# FastAPI app
-# ------------------------
-app = FastAPI(title="Multilingual Translation API with Progress", version="2.0.0")
+# Create FastAPI app
+app = FastAPI(title="Multilingual Translation API", version="2.0.0")
 
+# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -532,169 +473,92 @@ app.add_middleware(
 
 @app.get("/")
 async def root():
-    return {"message": "Multilingual Translation API v2.0 (with progress)", "status": "active", "features": ["long_text_support", "smart_chunking", "cache_optimization", "progress_tracking", "sse"]}
+    return {"message": "Multilingual Translation API v2.0", "status": "active", "features": ["long_text_support", "smart_chunking", "cache_optimization"]}
 
-# Synchronous translate endpoint (keeps previous behavior but logs progress and updates job_store)
 @app.post("/api/translate")
 async def api_translate(request: TranslationRequest):
+    """API endpoint for translation with long text support"""
     if not request.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")
-
-    # create a job so consumer can check progress even for sync call
-    job_id = job_store.create_job(request.text, request.source_lang, request.target_lang)
-    job_store.update(job_id, message="Synchronous translation requested")
-
-    # Run translation in a separate thread but wait (so endpoint remains sync from client's POV)
-    result_container = {"translation": None, "time": None, "chunks": None, "error": None}
-    def do_translate():
+    
+    try:
+        translation, processing_time, chunks_count = translator.translate_text(request.text, source_code, target_code)
+        
+        return TranslationResponse(
+            translation=translation,
+            source_language=request.source_lang,
+            target_language=request.target_lang,
+            processing_time=processing_time,
+            character_count=len(request.text),
+            status="success",
+            chunks_processed=chunks_count
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")
+
+# Alternative endpoint for form data (compatibility with WordPress)
+@app.post("/api/translate/form")
+async def api_translate_form(request: Request):
+    """Alternative endpoint that accepts form data with long text support"""
+    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:
         try:
-            translation, processing_time, chunks_count = translator.translate_text(request.text, source_code, target_code, job_id=job_id)
-            result_container["translation"] = translation
-            result_container["time"] = processing_time
-            result_container["chunks"] = chunks_count
-        except Exception as e:
-            result_container["error"] = str(e)
-    thread = threading.Thread(target=do_translate)
-    thread.start()
-    # Wait for thread (because this endpoint is synchronous in original)
-    thread.join()
-
-    if result_container["error"]:
-        raise HTTPException(status_code=500, detail=f"Translation error: {result_container['error']}")
-
-    return TranslationResponse(
-        translation=result_container["translation"],
-        source_language=request.source_lang,
-        target_language=request.target_lang,
-        processing_time=result_container["time"],
-        character_count=len(request.text),
-        status="success",
-        chunks_processed=result_container["chunks"]
-    )
-
-# Async background endpoint: returns job_id immediately and does work in background
-@app.post("/api/translate_async")
-async def api_translate_async(request: TranslationRequest, background_tasks: BackgroundTasks):
-    if not request.text.strip():
+            # Try to get JSON data if form data fails
+            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:
+            raise HTTPException(status_code=400, detail="Invalid request format")
+    
+    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)
+    
+    source_code = LANGUAGE_MAP.get(source_lang)
+    target_code = LANGUAGE_MAP.get(target_lang)
+    
     if not source_code or not target_code:
         raise HTTPException(status_code=400, detail="Invalid language codes")
+    
+    try:
+        translation, processing_time, chunks_count = translator.translate_text(text, source_code, target_code)
+        
+        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
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")
 
-    job_id = job_store.create_job(request.text, request.source_lang, request.target_lang)
-
-    def background_work(text, s_code, t_code, jobid):
-        try:
-            translator.translate_text(text, s_code, t_code, job_id=jobid)
-        except Exception as e:
-            logger.exception("Background translation failed")
-            job_store.set_result(jobid, "", status="failed", error=str(e))
-            job_store.update(jobid, message="Background task failed")
-
-    background_tasks.add_task(background_work, request.text, source_code, target_code, job_id)
-    return {"job_id": job_id, "status": "accepted", "message": "Translation started in background. Use /api/job/{job_id} or /api/stream/{job_id} to monitor progress."}
-
-# Job status endpoint
-@app.get("/api/job/{job_id}")
-async def get_job_status(job_id: str):
-    job = job_store.get(job_id)
-    if not job:
-        raise HTTPException(status_code=404, detail="Job not found")
-    # Return a subset that is safe to expose
-    safe = {
-        "job_id": job["job_id"],
-        "status": job["status"],
-        "progress": job["progress"],
-        "chunks_total": job["chunks_total"],
-        "chunks_processed": job["chunks_processed"],
-        "eta_seconds": job["eta_seconds"],
-        "message": job["message"],
-        "source_lang": job["source_lang"],
-        "target_lang": job["target_lang"],
-        "character_count": job["character_count"],
-        "error": job["error"]
-    }
-    if job["result"] is not None and job["status"] == "success":
-        safe["translation_available"] = True
-    else:
-        safe["translation_available"] = False
-    return safe
-
-# SSE stream for live updates (client can connect with EventSource)
-@app.get("/api/stream/{job_id}")
-async def stream_job_progress(job_id: str):
-    job = job_store.get(job_id)
-    if not job:
-        raise HTTPException(status_code=404, detail="Job not found")
-
-    async def event_generator():
-        logger.info(f"SSE client connected for job {job_id[:8]}...")
-        last_snapshot = None
-        while True:
-            job_snapshot = job_store.get(job_id)
-            if job_snapshot is None:
-                # job disappeared
-                yield f"event: error\ndata: {json.dumps({'message': 'job not found'})}\n\n"
-                break
-
-            # send update only if changed
-            if job_snapshot != last_snapshot:
-                payload = {
-                    "job_id": job_snapshot["job_id"],
-                    "status": job_snapshot["status"],
-                    "progress": job_snapshot["progress"],
-                    "chunks_total": job_snapshot["chunks_total"],
-                    "chunks_processed": job_snapshot["chunks_processed"],
-                    "eta_seconds": job_snapshot["eta_seconds"],
-                    "message": job_snapshot["message"],
-                    "source_lang": job_snapshot["source_lang"],
-                    "target_lang": job_snapshot["target_lang"],
-                    "character_count": job_snapshot["character_count"],
-                    "error": job_snapshot["error"],
-                }
-                # if completed and success, include small result preview (not full text to avoid huge SSE)
-                if job_snapshot["status"] in ("success", "failed") and job_snapshot["result"] is not None:
-                    payload["result_preview"] = job_snapshot["result"][:1000]  # first 1k chars
-                data = json.dumps(payload, default=str)
-                yield f"data: {data}\n\n"
-                last_snapshot = job_snapshot
-
-            # stop if finished
-            if job_snapshot["status"] in ("success", "failed", "cancelled"):
-                logger.info(f"SSE: job {job_id[:8]} finished with status {job_snapshot['status']}")
-                break
-
-            await asyncio.sleep(0.5)  # poll interval
-
-        # final close message
-        yield f"event: close\ndata: {json.dumps({'message': 'stream closed'})}\n\n"
-
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
-
-# endpoint to fetch final translation (if ready)
-@app.get("/api/result/{job_id}")
-async def get_result(job_id: str):
-    job = job_store.get(job_id)
-    if not job:
-        raise HTTPException(status_code=404, detail="Job not found")
-    if job["status"] != "success":
-        return JSONResponse(status_code=202, content={"status": job["status"], "message": "Result not ready"})
-    return {"job_id": job_id, "translation": job["result"], "character_count": job["character_count"]}
-
-# languages and health (preserve)
 @app.get("/api/languages")
 async def get_languages():
-    return {"languages": list(LANGUAGE_MAP.keys()), "language_codes": LANGUAGE_MAP, "status": "success"}
+    """Get supported languages"""
+    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),
@@ -704,7 +568,5 @@ async def health_check():
         "version": "2.0.0"
     }
 
-# Run
 if __name__ == "__main__":
-    # IMPORTANT: for production, use uvicorn/gunicorn with workers and proper GPU visibility
-    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
+    uvicorn.run(app, host="0.0.0.0", port=7860)