Overhauled backend API structure

Dockerfile

@@ -4,6 +4,8 @@ FROM python:3.12-slim
 # 2. Set environment variables
 ENV PYTHONDONTWRITEBYTECODE=1
 ENV PYTHONUNBUFFERED=1
+#huggingface port
+ENV PORT=7860 
 
 # 3. Install system dependencies
 RUN apt-get update && apt-get install -y libgl1 libglib2.0-0
@@ -24,5 +26,5 @@ RUN env PYTHONPATH=. python -c "from helpers import setup_fonts; setup_fonts()"
 RUN env PYTHONPATH=. python -c "from manga_ocr import MangaOcr; MangaOcr()"
 
 # 8. Expose and Start
-EXPOSE 8000
+EXPOSE 7860
 CMD ["python", "main.py"]

api.py

@@ -3,33 +3,35 @@ Read-only API for the frontend. Wraps db list_entries, get_segments, get_chapter
 Run from backend:  uvicorn api:app --reload --host 0.0.0.0 --port 8000
 """
 
-from fastapi import FastAPI, Query
+from fastapi import APIRouter, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 import proxy
 from services import mangadex_service
+from services.image_processor import ImageProcessor
 import httpx
 import db
 from sqlmodel import Session, text
 from db.models import Manga
 from db.schemas import ChapterListOut, SegmentListOut
 
-app = FastAPI(
-    title="Manga Translator API",
-    description="Read endpoints for chapters and segments",
-    version="1.0.0",
-)
+# app = FastAPI(
+#     title="Manga Translator API",
+#     description="Read endpoints for chapters and segments",
+#     version="1.0.0",
+# )
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], # Currently allow all origins, should be restricted to specific origins in production
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"], # Currently allow all origins, should be restricted to specific origins in production
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
 
+router = APIRouter()
 
-@app.get("/")
+@router.get("/")
 def root():
     """API root - confirms the API is running."""
     return {
@@ -39,7 +41,7 @@ def root():
         "health": "/health",
     }
 
-@app.get("/health/db")
+@router.get("/health/db")
 def health_db():
     engine = db.get_engine()
     try:
@@ -50,7 +52,7 @@ def health_db():
         return {"status": "error", "detail": str(e)}
 
 
-@app.get("/mangas", response_model=list[Manga])
+@router.get("/mangas", response_model=list[Manga])
 def list_mangas(
     order_by: str = Query("created_at", description="manga_title | created_at | updated_at"),
     order_desc: bool = Query(True, description="Sort descending"),
@@ -60,7 +62,7 @@ def list_mangas(
     """List mangas (manga_title, created_at, updated_at). Supports pagination."""
     return db.list_mangas(order_by=order_by, order_desc=order_desc, limit=limit, offset=offset)
 
-@app.get("/chapters", response_model=list[ChapterListOut])
+@router.get("/chapters", response_model=list[ChapterListOut])
 def list_chapters(
     manga_title: str = Query(...),
     provider_id: str | None = Query(None, description="e.g. local, mangadex"),
@@ -71,7 +73,7 @@ def list_chapters(
     return db.list_chapters(manga_title, provider_id, limit=limit, offset=offset)
 
 
-@app.get("/segments", response_model=list[SegmentListOut])
+@router.get("/segments", response_model=list[SegmentListOut])
 def get_segments(
     provider_id: str | None = Query(None, description="e.g. local, mangadex"),
     manga_title: str | None = Query(None),
@@ -91,7 +93,7 @@ def get_segments(
     )
 
 
-@app.get("/chapters/segments", response_model=list[SegmentListOut])
+@router.get("/chapters/segments", response_model=list[SegmentListOut])
 def get_chapter_segments(
     provider_id: str = Query(..., description="e.g. local, mangadex"),
     manga_title: str = Query(...),
@@ -104,22 +106,16 @@ def get_chapter_segments(
 
 
 # to make sure api is running and responding
-@app.get("/health")
+@router.get("/health")
 def health():
     """Health check."""
     return {"status": "ok"}
 
-
-@app.exception_handler(ValueError)
-def value_error_handler(request, exc):
-    """Return 400 for invalid provider_id etc."""
-    return JSONResponse(status_code=400, content={"detail": str(exc)})
-
 ###########
 ###########
 ###########
 
-@app.get("/api/manga/chapter/{chapter_id}/page/{page_index}")
+@router.get("/api/manga/chapter/{chapter_id}/page/{page_index}")
 async def proxy_manga_page(chapter_id: str, page_index: int):
     urls = mangadex_service.get_chapter_panel_urls(chapter_id)
     if not urls or page_index >= len(urls):
@@ -127,12 +123,12 @@ async def proxy_manga_page(chapter_id: str, page_index: int):
 
     return await proxy.get_manga_page_stream(urls[page_index])
 
-@app.get("/api/manga/cover_art")
+@router.get("/api/manga/cover_art")
 async def proxy_manga_cover_art(manga_id: str, cover_url: str, size: int = 256):
     url = f"https://uploads.mangadex.org/covers/{manga_id}/{cover_url}.{size}.jpg"
     return await proxy.get_manga_page_stream(url)
 
-@app.get("/api/manga/search")
+@router.get("/api/manga/search")
 async def get_popular_manga(
     title: str = "",
     limit: int = 15,
@@ -152,7 +148,7 @@ async def get_popular_manga(
     return results
 
 
-@app.get("/api/manga/{manga_id}/chapters")
+@router.get("/api/manga/{manga_id}/chapters")
 async def get_chapters(
     manga_id: str,
     limit: int = 100,

main.py

@@ -15,7 +15,31 @@ from fastapi import FastAPI
 from typing import Optional
 import db as manga_db
 import uvicorn
+from manga_ocr import MangaOcr
+from fastapi.middleware.cors import CORSMiddleware
+from api import router as manga_router
+from fastapi.responses import JSONResponse
+from services.image_processor import ImageProcessor
+
+######################
+
+app = FastAPI(
+    title="Manga Translator API",
+    description="Read endpoints for chapters and segments",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # Currently allow all origins, should be restricted to specific origins in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(manga_router)
 
+#####################
 
 ###
 ###
@@ -44,9 +68,7 @@ device = torch.device(device_name)
 
 print(f"Loading models from {MODEL_PATH} and fonts from {FONT_PATH}")
 
-app = FastAPI()
-
-#####################
+################################################
 
 # GLMOCR_MODEL_DIR = MODEL_PATH / "GlmOcr"
 # ocr_model = OCR_Glm_Service(GLMOCR_MODEL_DIR)
@@ -61,6 +83,7 @@ bubble_detector_model = Bubble_Detector_Kiuyha_Service(BUBBLE_DETECTOR_MODEL_DIR
 
 translate_model = Translate_Qwen_Service()
 
+ocr_model = MangaOcr()
 
 if not FONT_PATH.exists():
     print(f"Font NotoSansCJK not found at {FONT_PATH}. Attempting to download.")
@@ -75,251 +98,20 @@ if FONT_PATH.exists():
 else:
     raise FileNotFoundError(f"Font NotoSansCJK not found at {FONT_PATH}")
 
+processor = ImageProcessor(bubble_detector_model, ocr_model, translate_model)
 print("Finished loading all models and fonts")
 
 ###
 ###
 ###
 
-def get_ocr():
-    from manga_ocr import MangaOcr
-    return MangaOcr()
-
-def show_boxes(image_path):
-    result = bubble_detector_model.predict(image_path)
-    img = Image.open(image_path).convert("RGB")
-    draw = ImageDraw.Draw(img)
-    for box in result.boxes:
-        # Get coordinates as a list of floats
-        coords = box.xyxy[0].tolist() # [x1, y1, x2, y2]
-        draw.rectangle(coords, outline="red", width=1)
-
-        # label
-        conf = box.conf[0].item()
-        box_cropped = img.crop(coords)
-        # box_cropped = upscale_for_ocr(box_cropped, scale=3)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
-            box_cropped.save(f.name)
-            temp_path = f.name
-        draw.text(
-            (coords[0], coords[1] - 10),
-            "b",
-            fill="red",
-            font=font
-        )
-    img.show()
-
-def get_wrapped_text(text, font, max_width):
-    lines = []
-    words = text.split(' ') # Split by words for English
-    current_line = []
-
-    for word in words:
-        # Check if adding the next word exceeds the width
-        test_line = ' '.join(current_line + [word])
-        # getlength() is more accurate than getbbox for text width
-        if font.getlength(test_line) <= max_width:
-            current_line.append(word)
-        else:
-            lines.append(' '.join(current_line))
-            current_line = [word]
-
-    lines.append(' '.join(current_line))
-    return lines
-
-def fit_text_to_box(draw, text, box_coords, font_path, padding=5, initial_size=40):
-    x1, y1, x2, y2 = box_coords
-
-    padding = padding
-    target_width = (x2 - x1) - (padding * 2)
-    target_height = (y2 - y1) - (padding * 2)
-
-    current_size = initial_size
-    lines = []
-
-    while current_size > 8:
-        # index=0 for Japanese, 1 for Korean in NotoSansCJK
-        font = ImageFont.truetype(font_path, size=current_size)
-        lines = get_wrapped_text(text, font, target_width)
-
-        # Use a more reliable line height measurement
-        # getbbox can be inconsistent; use font.size * constant for better leading
-        line_height = int(current_size * 1.2)
-        total_height = line_height * len(lines)
-
-        if total_height <= target_height:
-            break
-        current_size -= 2 # Step down by 2 for speed
-
-    return lines, font, current_size, line_height
-
-def upscale_for_ocr(img, scale=2):
-    w, h = img.size
-    return img.resize((w*scale, h*scale), Image.BICUBIC)
-
-def process_image(image_path, language):
-    bubble_results = bubble_detector_model.predict(image_path)
-    print(f"bubble results: {bubble_results}")
-    img = Image.open(image_path)
-    draw = ImageDraw.Draw(img)
-
-    ocr_model = get_ocr()
-    texts = []
-    coordinates={}
-    i=0
-    for box_data in bubble_results:
-        print(f"box_data {i}")
-        coords = box_data['coords']
-        draw.rectangle(coords, outline="red", width=1)
-        box_cropped = img.crop(coords)
-        # box_cropped = upscale_for_ocr(box_cropped, scale=3)
-        # box_cropped.show()
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
-            box_cropped.save(f.name)
-            temp_path = f.name
-
-        text = ""
-        # if language == "japanese":
-        #     # text = ocr_japanese_model.runOCR(temp_path)
-        #     text = ocr_model(temp_path)
-        # else:
-        #     text = ocr_model.runOCR(temp_path)
-
-        try:
-            # MangaOcr is callable: mocr(image)
-            text = ocr_model(box_cropped) 
-        except Exception as e:
-            print(f"OCR Error on bubble {i}: {e}")
-
-        text = re.sub(r'[\n\r\u2028\u2029]+', ' ', text) #remove new lines
-        texts.append({"id": i, "text": text})
-        coordinates[i] = coords
-        i+=1
-    print(f'OCR Complete, total {len(texts)} bubbles.')
-
-    #add translated text to manga image
-    try:
-        print("Translating with cloud Qwen model...")
-        translated = translate_model.translate_cloud(texts)
-    except Exception as e:
-        print("API translation failed with Qwen, falling back to local model...")
-        translated = translate_model.translate(texts)
-
-    print(translated)
-
-    bubble_data = []
-    for i in range(len(texts)):
-        coords = coordinates[i]
-        x1, y1, x2, y2 = coords
-        original_text = texts[i]["text"]
-        translated_text = translated.get(str(i), translated.get(i, ""))
-        if not isinstance(translated_text, str):
-            translated_text = str(translated_text)
-        print(f"{i}: {original_text}")
-        print(translated_text)
-        print("==================================")
-
-        bubble_data.append({
-            "bubble_index": i,
-            "x1": float(x1), "y1": float(y1), "x2": float(x2), "y2": float(y2),
-            "original_text": original_text,
-            "translated_text": translated_text,
-        })
-
-        #wipe the space
-        draw.rectangle(coords, fill="white", outline="white")
-
-        # 1. Calculate the best fit
-        lines, best_font, final_size, line_h = fit_text_to_box(draw, translated_text, coords, FONT_PATH)
-
-        # Calculate total height of the block
-        total_h = line_h * len(lines)
-
-        # Start_y adjusted for the block height relative to the box center
-        start_y = coords[1] + ((coords[3] - coords[1]) - total_h) / 2
-
-        # 3. Draw each line centered horizontally
-        for line in lines:
-            line = line.strip()
-            if not line: continue
-
-            # Horizontal Centering
-            line_w = draw.textlength(line, font=best_font)
-            start_x = coords[0] + ((coords[2] - coords[0]) - line_w) / 2
-
-            draw.text((start_x, start_y), line, font=best_font, fill="black")
-            start_y += line_h
-
-    return img, bubble_data
-
-def translate_text(text, language):
-    # translated_text = ""
-    # if language == "japanese":
-    #     translated_text =
-
-    translated_text = translate_model.translate(text)
-
-    return translated_text
-
-def _language_to_code(language: str) -> str:
-    """Map language name to ISO 639-1 style code for DB."""
-    m = {"japanese": "ja", "english": "en", "korean": "ko", "chinese": "zh"}
-    return m.get(language.lower(), language[:2] if len(language) >= 2 else "ja")
-
-
-def process_chapter(
-    manga_title: str,
-    chapter_number: float,
-    page_paths: list,
-    language: str = "japanese",
-    provider_id: str = "local",
-    external_manga_id: Optional[str] = None,
-    db_url: str = None,
-):
-    """
-    Process each page of a chapter, draw translated text on images, and save
-    to the PostgreSQL text repository (provider_id, manga_title, chapter/page,
-    segment coordinates, original/translated text, language code). No images stored.
-    page_paths: list of paths to page images in order.
-    provider_id: source/provider identifier (e.g. 'mangadex', 'local').
-    db_url: PostgreSQL URL or set DATABASE_URL.
-    Returns (list of (img, bubble_data) per page).
-    """
-    manga_db.init_db(db_url)
-    language_code = _language_to_code(language)
-    results = []
-    for page_number, image_path in enumerate(page_paths, start=1):
-        path = Path(image_path)
-        if not path.exists():
-            print(f"Skip missing page {page_number}: {path}")
-            continue
-        print(f"Processing chapter {chapter_number} page {page_number}/{len(page_paths)}: {path.name}")
-        img, bubble_data = process_image(str(path), language)
-        manga_db.save_page_translation(
-            provider_id=provider_id,
-            manga_title=manga_title,
-            chapter_number=chapter_number,
-            page_number=page_number,
-            bubbles=bubble_data,
-            language_code=language_code,
-            external_manga_id=external_manga_id,
-            db_url=db_url,
-        )
-        results.append((img, bubble_data))
-    print(f"Chapter '{manga_title}' ch.{chapter_number} saved to DB ({len(results)} pages).")
-    return results
-
+@app.exception_handler(ValueError)
+def value_error_handler(request, exc):
+    """Return 400 for invalid provider_id etc."""
+    return JSONResponse(status_code=400, content={"detail": str(exc)})
 
-def main():
-    img_path = "./test_2.png"
-    img, bubble_data = process_image(img_path, "japanese")
-    print(bubble_data)
-    img.show()
-    # manga_db.save_page_translation(provider_id="local", manga_title="Test", chapter_number=0,
-    #     page_number=1, bubbles=bubble_data, language_code="ja")
 
-@app.post("/")
+@app.post("/test")
 def test(img_path: Optional[str] = None):
     print("test called")
     if not img_path:
@@ -327,15 +119,13 @@ def test(img_path: Optional[str] = None):
     img_path = Path(img_path)
     print(f"image path: {img_path}")
     if img_path.exists():
-        img, bubble_data = process_image(img_path, "japanese")
+        bubble_data = processor.process_image(img_path, "japanese")
         print(bubble_data)
         return {"result": bubble_data}
     else:
         print(f"{img_path} does not exist")
 
 if __name__ == "__main__":
-    # main()
     port = int(os.environ.get("PORT", 8000))
     print(f"--- Starting Production Server on Port {port} ---")
-    uvicorn.run("api:app", host="0.0.0.0", port=port, reload=False) #uses api.py
-    # uvicorn.run("main:app", host="0.0.0.0", port=port, reload=False)
+    uvicorn.run("main:app", host="0.0.0.0", port=port, reload=False)

services/image_processor.py

@@ -0,0 +1,284 @@
+from services.bubble_detector_kiuyha_service import Bubble_Detector_Kiuyha_Service
+from services.translate_qwen_service import Translate_Qwen_Service
+from PIL import Image, ImageDraw, ImageFont
+import tempfile
+import os
+import re
+import torch
+from pathlib import Path
+from helpers import get_project_root, setup_fonts
+from manga_ocr import MangaOcr
+
+class ImageProcessor:
+    def __init__(self, bubble_detector, ocr_model, translate_model):
+        self.bubble_detector_model = bubble_detector
+        self.ocr_model = ocr_model
+        self.translate_model = translate_model
+
+    def process_image(self, image_path, language):
+        bubble_results = self.bubble_detector_model.predict(image_path)
+        print(f"bubble results: {bubble_results}")
+        img = Image.open(image_path)
+        draw = ImageDraw.Draw(img)
+
+        texts = []
+        coordinates={}
+        i=0
+        for box_data in bubble_results:
+            coords = box_data['coords']
+            draw.rectangle(coords, outline="red", width=1)
+            box_cropped = img.crop(coords)
+            # box_cropped = upscale_for_ocr(box_cropped, scale=3)
+            # box_cropped.show()
+
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
+                box_cropped.save(f.name)
+                temp_path = f.name
+
+            text = ""
+            try:
+                text = self.ocr_model(box_cropped) 
+            except Exception as e:
+                print(f"text OCR failed for {i}")
+
+            text = re.sub(r'[\n\r\u2028\u2029]+', ' ', text) #remove new lines
+            texts.append({"id": i, "text": text})
+            coordinates[i] = coords
+            i+=1
+        print(f'OCR Complete, total {len(texts)} bubbles.')
+
+        #add translated text to manga image
+        try:
+            print("Translating with cloud Qwen model...")
+            translated = self.translate_model.translate_cloud(texts)
+        except Exception as e:
+            print("API translation failed with Qwen, falling back to local model...")
+            translated = self.translate_model.translate(texts)
+
+        print(translated)
+
+        bubble_data = []
+        for i in range(len(texts)):
+            coords = coordinates[i]
+            x1, y1, x2, y2 = coords
+            original_text = texts[i]["text"]
+            translated_text = translated.get(str(i), translated.get(i, ""))
+            if not isinstance(translated_text, str):
+                translated_text = str(translated_text)
+            print(f"{i}: {original_text}")
+            print(translated_text)
+            print("==================================")
+
+            bubble_data.append({
+                "bubble_index": i,
+                "x1": float(x1), "y1": float(y1), "x2": float(x2), "y2": float(y2),
+                "original_text": original_text,
+                "translated_text": translated_text,
+            })
+
+            ######### Code for drawing translated text onto manga panel directly) ###########
+
+            # #wipe the space
+            # draw.rectangle(coords, fill="white", outline="white")
+
+            # # 1. Calculate the best fit
+            # lines, best_font, final_size, line_h = fit_text_to_box(draw, translated_text, coords, FONT_PATH)
+
+            # # Calculate total height of the block
+            # total_h = line_h * len(lines)
+
+            # # Start_y adjusted for the block height relative to the box center
+            # start_y = coords[1] + ((coords[3] - coords[1]) - total_h) / 2
+
+            # # 3. Draw each line centered horizontally
+            # for line in lines:
+            #     line = line.strip()
+            #     if not line: continue
+
+            #     # Horizontal Centering
+            #     line_w = draw.textlength(line, font=best_font)
+            #     start_x = coords[0] + ((coords[2] - coords[0]) - line_w) / 2
+
+            #     draw.text((start_x, start_y), line, font=best_font, fill="black")
+            #     start_y += line_h
+
+        return bubble_data #img, bubble_data
+    
+
+########Test code, keeping it here as reference. Remove later################
+# def show_boxes(image_path):
+#     result = bubble_detector_model.predict(image_path)
+#     img = Image.open(image_path).convert("RGB")
+#     draw = ImageDraw.Draw(img)
+#     for box in result.boxes:
+#         # Get coordinates as a list of floats
+#         coords = box.xyxy[0].tolist() # [x1, y1, x2, y2]
+#         draw.rectangle(coords, outline="red", width=1)
+
+#         # label
+#         conf = box.conf[0].item()
+#         box_cropped = img.crop(coords)
+#         # box_cropped = upscale_for_ocr(box_cropped, scale=3)
+#         with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
+#             box_cropped.save(f.name)
+#             temp_path = f.name
+#         draw.text(
+#             (coords[0], coords[1] - 10),
+#             "b",
+#             fill="red",
+#             font=font
+#         )
+#     img.show()
+
+# def get_wrapped_text(text, font, max_width):
+#     lines = []
+#     words = text.split(' ') # Split by words for English
+#     current_line = []
+
+#     for word in words:
+#         # Check if adding the next word exceeds the width
+#         test_line = ' '.join(current_line + [word])
+#         # getlength() is more accurate than getbbox for text width
+#         if font.getlength(test_line) <= max_width:
+#             current_line.append(word)
+#         else:
+#             lines.append(' '.join(current_line))
+#             current_line = [word]
+
+#     lines.append(' '.join(current_line))
+#     return lines
+
+# def fit_text_to_box(draw, text, box_coords, font_path, padding=5, initial_size=40):
+#     x1, y1, x2, y2 = box_coords
+
+#     padding = padding
+#     target_width = (x2 - x1) - (padding * 2)
+#     target_height = (y2 - y1) - (padding * 2)
+
+#     current_size = initial_size
+#     lines = []
+
+#     while current_size > 8:
+#         # index=0 for Japanese, 1 for Korean in NotoSansCJK
+#         font = ImageFont.truetype(font_path, size=current_size)
+#         lines = get_wrapped_text(text, font, target_width)
+
+#         # Use a more reliable line height measurement
+#         # getbbox can be inconsistent; use font.size * constant for better leading
+#         line_height = int(current_size * 1.2)
+#         total_height = line_height * len(lines)
+
+#         if total_height <= target_height:
+#             break
+#         current_size -= 2 # Step down by 2 for speed
+
+#     return lines, font, current_size, line_height
+
+# def upscale_for_ocr(img, scale=2):
+#     w, h = img.size
+#     return img.resize((w*scale, h*scale), Image.BICUBIC)
+
+# def process_image(image_path, language):
+#     bubble_results = bubble_detector_model.predict(image_path)
+#     print(f"bubble results: {bubble_results}")
+#     img = Image.open(image_path)
+#     draw = ImageDraw.Draw(img)
+
+#     texts = []
+#     coordinates={}
+#     i=0
+#     for box_data in bubble_results:
+#         coords = box_data['coords']
+#         draw.rectangle(coords, outline="red", width=1)
+#         box_cropped = img.crop(coords)
+#         # box_cropped = upscale_for_ocr(box_cropped, scale=3)
+#         # box_cropped.show()
+
+#         with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
+#             box_cropped.save(f.name)
+#             temp_path = f.name
+
+#         text = ""
+#         # if language == "japanese":
+#         #     # text = ocr_japanese_model.runOCR(temp_path)
+#         #     text = ocr_model(temp_path)
+#         # else:
+#         #     text = ocr_model.runOCR(temp_path)
+
+#         text = ocr_model(box_cropped) 
+
+#         text = re.sub(r'[\n\r\u2028\u2029]+', ' ', text) #remove new lines
+#         texts.append({"id": i, "text": text})
+#         coordinates[i] = coords
+#         i+=1
+#     print(f'OCR Complete, total {len(texts)} bubbles.')
+
+#     #add translated text to manga image
+#     try:
+#         print("Translating with cloud Qwen model...")
+#         translated = translate_model.translate_cloud(texts)
+#     except Exception as e:
+#         print("API translation failed with Qwen, falling back to local model...")
+#         translated = translate_model.translate(texts)
+
+#     print(translated)
+
+#     bubble_data = []
+#     for i in range(len(texts)):
+#         coords = coordinates[i]
+#         x1, y1, x2, y2 = coords
+#         original_text = texts[i]["text"]
+#         translated_text = translated.get(str(i), translated.get(i, ""))
+#         if not isinstance(translated_text, str):
+#             translated_text = str(translated_text)
+#         print(f"{i}: {original_text}")
+#         print(translated_text)
+#         print("==================================")
+
+#         bubble_data.append({
+#             "bubble_index": i,
+#             "x1": float(x1), "y1": float(y1), "x2": float(x2), "y2": float(y2),
+#             "original_text": original_text,
+#             "translated_text": translated_text,
+#         })
+
+#         #wipe the space
+#         draw.rectangle(coords, fill="white", outline="white")
+
+#         # 1. Calculate the best fit
+#         lines, best_font, final_size, line_h = fit_text_to_box(draw, translated_text, coords, FONT_PATH)
+
+#         # Calculate total height of the block
+#         total_h = line_h * len(lines)
+
+#         # Start_y adjusted for the block height relative to the box center
+#         start_y = coords[1] + ((coords[3] - coords[1]) - total_h) / 2
+
+#         # 3. Draw each line centered horizontally
+#         for line in lines:
+#             line = line.strip()
+#             if not line: continue
+
+#             # Horizontal Centering
+#             line_w = draw.textlength(line, font=best_font)
+#             start_x = coords[0] + ((coords[2] - coords[0]) - line_w) / 2
+
+#             draw.text((start_x, start_y), line, font=best_font, fill="black")
+#             start_y += line_h
+
+#     return img, bubble_data
+
+# def translate_text(text, language):
+#     # translated_text = ""
+#     # if language == "japanese":
+#     #     translated_text =
+
+#     translated_text = translate_model.translate(text)
+
+#     return translated_text
+
+# def _language_to_code(language: str) -> str:
+#     """Map language name to ISO 639-1 style code for DB."""
+#     m = {"japanese": "ja", "english": "en", "korean": "ko", "chinese": "zh"}
+#     return m.get(language.lower(), language[:2] if len(language) >= 2 else "ja")
+