Upload 7 files

Dockerfile

@@ -12,10 +12,5 @@ ENV HOME=/home/user \
 WORKDIR $HOME/app
 
 COPY --chown=user . $HOME/app
-RUN mkdir -p $HOME/app/models
-RUN chmod 777 $HOME/app/models
-ENV MODELS_PATH=$HOME/app/models
-RUN mkdir -p $HOME/app/uploads
-RUN chmod 777 $HOME/app/uploads
 
 CMD ["python", "-m", "apis.chat_api"]

README.md

@@ -15,8 +15,7 @@ Multilingual Translation and Language Detection API.
 ✅ Implemented:
 
 - Language detection (`/detect`)
-- Translation via Google Translate (`/translate`)
-- Translation via local AI models (`/translate/ai`) using Hugging Face `transformers`
+- Translation via Google Translate (`/translate`) using `deep_translator`
 - Docker deployment
 
 🔤 Supported languages (primary):
@@ -70,7 +69,7 @@ curl -X POST http://127.0.0.1:23333/detect \
   -d '{"input_text": "Hello, how are you?"}'
 ```
 
-- Translate (Google)
+- Translate
 
 ```bash
 curl -X POST http://127.0.0.1:23333/translate \
@@ -78,10 +77,14 @@ curl -X POST http://127.0.0.1:23333/translate \
   -d '{"to_language": "ar", "input_text": "Hello"}'
 ```
 
-- Translate (AI model)
+- Stream translate (OpenAI-compatible SSE)
 
 ```bash
-curl -X POST http://127.0.0.1:23333/translate/ai \
+curl -N -X POST http://127.0.0.1:23333/translate/stream \
   -H "Content-Type: application/json" \
-  -d '{"model": "t5-base", "from_language": "en", "to_language": "fr", "input_text": "How are you?"}'
+  -d '{"to_language": "am", "input_text": "Hello, nice to meet you!"}'
 ```
+
+Response is a stream of `data: {json}\n\n` chunks ending with `data: [DONE]`.
+
+ 

apis/chat_api.py

@@ -1,19 +1,17 @@
 import argparse
 import uvicorn
 import sys
-import os
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-import time
 import json
-import torch
-import logging
 
 
 from fastapi import FastAPI
 from fastapi.encoders import jsonable_encoder
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, StreamingResponse
+import uuid
+import time
 from pydantic import BaseModel, Field
-from googletrans import Translator
+from deep_translator import GoogleTranslator
+from deep_translator import single_detection
 from fastapi.middleware.cors import CORSMiddleware
 
 class ChatAPIApp:
@@ -37,7 +35,7 @@ class ChatAPIApp:
             description="(str) `Detect`",
         )
         to_language: str = Field(
-            default="fa",
+            default="am",
             description="(str) `en`",
         )
         input_text: str = Field(
@@ -47,114 +45,60 @@ class ChatAPIApp:
    
 
     def translate_completions(self, item: TranslateCompletionsPostItem):
-        translator = Translator()
         f = open('apis/lang_name.json', "r")
         available_langs = json.loads(f.read())
-        from_lang = 'en'
-        to_lang = 'en'
-        for lang_item in available_langs:
-          if item.to_language == lang_item['code']:
-              to_lang = item.to_language
-              break
-              
-          
-        translated = translator.translate(item.input_text, dest=to_lang)
-        item_response = {
-            "from_language": translated.src,
-            "to_language": translated.dest,
-            "text": item.input_text,
-            "translate": translated.text
-        }
-        json_compatible_item_data = jsonable_encoder(item_response)
-        return JSONResponse(content=json_compatible_item_data)
-
-    def translate_ai_completions(self, item: TranslateCompletionsPostItem):
-        translator = Translator()
-        f = open('apis/lang_name.json', "r")
-        available_langs = json.loads(f.read())
-        from_lang = 'en'
         to_lang = 'en'
         for lang_item in available_langs:
             if item.to_language == lang_item['code']:
                 to_lang = item.to_language
-            if item.from_language == lang_item['code']:
-                from_lang = item.from_language
+                break
 
         if to_lang == 'auto':
             to_lang = 'en'
 
-        if from_lang == 'auto':
-            from_lang = translator.detect(item.input_text).lang
-
-        # Map ISO/lang codes to NLLB-200 language codes
-        nllb_code_map = {
-            'en': 'eng_Latn',
-            'am': 'amh_Ethi',
-            'ar': 'arb_Arab',
-            'ti': 'tir_Ethi',
-            'om': 'orm_Latn',
-            'so': 'som_Latn',
-            'ko': 'kor_Hang',
-            'zh-CN': 'zho_Hans',
-            'zh-TW': 'zho_Hant',
-            'fr': 'fra_Latn',
-            'de': 'deu_Latn',
-            'it': 'ita_Latn',
-            'ja': 'jpn_Jpan',
-        }
+        detected_src = None
+        try:
+            detected_src = single_detection(item.input_text)
+        except Exception:
+            detected_src = 'auto'
 
-        nllb_src = nllb_code_map.get(from_lang, 'eng_Latn')
-        nllb_tgt = nllb_code_map.get(to_lang, 'eng_Latn')
-
-        if torch.cuda.is_available():
-            device = torch.device("cuda:0")
-        else:
-            device = torch.device("cpu")
-            logging.warning("GPU not found, using CPU, translation will be very slow.")
-
-        time_start = time.time()
-        pretrained_model = "facebook/nllb-200-distilled-1.3B"
-        cache_dir = "models/"
-        tokenizer = AutoTokenizer.from_pretrained(pretrained_model, cache_dir=cache_dir)
-        model = AutoModelForSeq2SeqLM.from_pretrained(pretrained_model, cache_dir=cache_dir).to(device)
-        model.eval()
-
-        tokenizer.src_lang = nllb_src
-        with torch.no_grad():
-            encoded_input = tokenizer(item.input_text, return_tensors="pt").to(device)
-            generated_tokens = model.generate(
-                **encoded_input,
-                forced_bos_token_id=tokenizer.lang_code_to_id[nllb_tgt],
-            )
-            translated_text = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
-
-        time_end = time.time()
-        translated = translated_text
+        translated_text = GoogleTranslator(source='auto', target=to_lang).translate(item.input_text)
         item_response = {
-            "from_language": from_lang,
+            "from_language": detected_src,
             "to_language": to_lang,
             "text": item.input_text,
-            "translate": translated,
-            "start": str(time_start),
-            "end": str(time_end)
+            "translate": translated_text,
         }
         json_compatible_item_data = jsonable_encoder(item_response)
         return JSONResponse(content=json_compatible_item_data)
 
     
+
+    
     class DetectLanguagePostItem(BaseModel):
         input_text: str = Field(
             default="Hello, how are you?",
             description="(str) `Text for detection`",
         )
 
+    class ChatTranslateStreamItem(BaseModel):
+        # OpenAI-style payload compatibility
+        model: str | None = Field(default=None, description="(optional) ignored")
+        stream: bool | None = Field(default=True, description="(optional) ignored")
+        to_language: str = Field(default="am", description="Target language code")
+        messages: list[dict] = Field(
+            default_factory=list,
+            description="OpenAI-style messages; the last user message's content is translated",
+        )
+
     def detect_language(self, item: DetectLanguagePostItem):
-        translator = Translator()
-        detected = translator.detect(item.input_text)
+        try:
+            detected_lang = single_detection(item.input_text)
+        except Exception:
+            detected_lang = None
 
         item_response = {
-            "lang": detected.lang,
-            "confidence": detected.confidence,
+            "lang": detected_lang,
         }
         json_compatible_item_data = jsonable_encoder(item_response)
         return JSONResponse(content=json_compatible_item_data)
@@ -171,16 +115,101 @@ class ChatAPIApp:
                 summary="translate text",
             )(self.translate_completions)
 
-            self.app.post(
-                prefix + "/translate/ai",
-                summary="translate text with ai",
-            )(self.translate_ai_completions)
+            # Removed AI translation endpoint
             
             self.app.post(
                 prefix + "/detect",
                 summary="detect language",
             )(self.detect_language)
 
+            self.app.post(
+                prefix + "/translate/stream",
+                summary="stream translated text (OpenAI-compatible SSE)",
+            )(self.translate_stream)
+
+            self.app.post(
+                prefix + "/translate/chat/stream",
+                summary="stream translated text from OpenAI-style chat payload",
+            )(self.translate_chat_stream)
+
+    def translate_stream(self, item: TranslateCompletionsPostItem):
+        f = open('apis/lang_name.json', "r")
+        available_langs = json.loads(f.read())
+        to_lang = 'en'
+        for lang_item in available_langs:
+            if item.to_language == lang_item['code']:
+                to_lang = item.to_language
+                break
+
+        if to_lang == 'auto':
+            to_lang = 'en'
+
+        try:
+            translated_full = GoogleTranslator(source='auto', target=to_lang).translate(item.input_text)
+        except Exception as e:
+            error_event = {
+                "id": f"trans-{uuid.uuid4()}",
+                "object": "chat.completion.chunk",
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {"content": ""},
+                        "finish_reason": "error",
+                    }
+                ],
+                "error": str(e),
+            }
+            def error_gen():
+                yield f"data: {json.dumps(error_event, ensure_ascii=False)}\n\n"
+                yield "data: [DONE]\n\n"
+            return StreamingResponse(error_gen(), media_type="text/event-stream")
+
+        # Character-based streaming for natural flow in languages without spaces
+        chars = list(translated_full) if translated_full else []
+        stream_id = f"trans-{uuid.uuid4()}"
+
+        def event_generator():
+            for ch in chars:
+                chunk = {
+                    "id": stream_id,
+                    "object": "chat.completion.chunk",
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {"content": ch},
+                            "finish_reason": None,
+                        }
+                    ],
+                }
+                yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+                time.sleep(0.005)
+
+            # Stream end
+            yield "data: [DONE]\n\n"
+
+        return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+    def translate_chat_stream(self, item: ChatTranslateStreamItem):
+        # Extract latest user content
+        input_text = None
+        for message in reversed(item.messages or []):
+            if message.get("role") == "user":
+                input_text = message.get("content", "")
+                break
+
+        if not input_text:
+            # Fallback to empty stream end
+            def empty_gen():
+                yield "data: [DONE]\n\n"
+            return StreamingResponse(empty_gen(), media_type="text/event-stream")
+
+        # Reuse the streaming translator
+        payload = self.TranslateCompletionsPostItem(
+            to_language=item.to_language,
+            input_text=input_text,
+        )
+        return self.translate_stream(payload)
+
 class ArgParser(argparse.ArgumentParser):
     def __init__(self, *args, **kwargs):
         super(ArgParser, self).__init__(*args, **kwargs)

requirements.txt

@@ -1,9 +1,6 @@
 fastapi
 pydantic
 uvicorn
-googletrans==3.1.0a0
-torch
-transformers
-transformers[sentencepiece]
+deep-translator
 requests
 termcolor