Upload 56 files

.gitattributes

@@ -33,3 +33,16 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+demo/examples/0.png filter=lfs diff=lfs merge=lfs -text
+demo/examples/ex0.png filter=lfs diff=lfs merge=lfs -text
+demo/fonts/ariali.ttf filter=lfs diff=lfs merge=lfs -text
+examples/0.png filter=lfs diff=lfs merge=lfs -text
+examples/1.png filter=lfs diff=lfs merge=lfs -text
+examples/2.png filter=lfs diff=lfs merge=lfs -text
+examples/3.png filter=lfs diff=lfs merge=lfs -text
+examples/ex0.png filter=lfs diff=lfs merge=lfs -text
+examples/ex1.png filter=lfs diff=lfs merge=lfs -text
+examples/ex2.png filter=lfs diff=lfs merge=lfs -text
+examples/ex3.png filter=lfs diff=lfs merge=lfs -text
+fonts/ariali.ttf filter=lfs diff=lfs merge=lfs -text
+static/img/loading.gif filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,59 +1,59 @@
-# Manga Translator - HuggingFace Spaces Dockerfile
-# Uses Python 3.10 with CUDA support for YOLO model
-
-FROM python:3.10-slim
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1
-
-# HuggingFace Spaces specific settings
-ENV GRADIO_SERVER_NAME="0.0.0.0" \
-    GRADIO_SERVER_PORT=7860
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    git \
-    libgl1 \
-    libglib2.0-0 \
-    libsm6 \
-    libxext6 \
-    libxrender-dev \
-    libgomp1 \
-    wget \
-    curl \
-    fonts-dejavu-core \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create app user (HuggingFace Spaces requirement)
-RUN useradd -m -u 1000 user
-WORKDIR /app
-
-# Copy requirements first for better caching
-COPY --chown=user requirements.txt .
-
-# Install Python dependencies
-RUN pip install --upgrade pip && \
-    pip install -r requirements.txt
-
-# Copy application files
-COPY --chown=user . .
-
-# Create necessary directories with proper permissions
-RUN mkdir -p /app/uploads /app/outputs && \
-    chown -R user:user /app
-
-# Switch to non-root user
-USER user
-
-# Expose port for HuggingFace Spaces
-EXPOSE 7860
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
-    CMD curl -f http://localhost:7860/ || exit 1
-
-# Run with gunicorn for production
-CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "4", "--timeout", "120", "app:app"]
+# Manga Translator - HuggingFace Spaces Dockerfile
+# Uses Python 3.10 with CUDA support for YOLO model
+
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# HuggingFace Spaces specific settings
+ENV GRADIO_SERVER_NAME="0.0.0.0" \
+    GRADIO_SERVER_PORT=7860
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    wget \
+    curl \
+    fonts-dejavu-core \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create app user (HuggingFace Spaces requirement)
+RUN useradd -m -u 1000 user
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY --chown=user requirements.txt .
+
+# Install Python dependencies
+RUN pip install --upgrade pip && \
+    pip install -r requirements.txt
+
+# Copy application files
+COPY --chown=user . .
+
+# Create necessary directories with proper permissions
+RUN mkdir -p /app/uploads /app/outputs && \
+    chown -R user:user /app
+
+# Switch to non-root user
+USER user
+
+# Expose port for HuggingFace Spaces
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Run with gunicorn for production
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "4", "--timeout", "120", "app:app"]

add_text.py

@@ -2,22 +2,103 @@ from PIL import Image, ImageDraw, ImageFont
 import numpy as np
 import textwrap
 import cv2
+import math
 
 # Font cache to avoid reloading fonts from disk
 _font_cache = {}
 
+# Font sizing configuration
+MIN_FONT_SIZE = 10
+MAX_FONT_SIZE = 60
+PADDING_RATIO = 0.1  # 10% padding inside bubble
+
 
 def get_cached_font(font_path, size):
     """Get font from cache or load it."""
     cache_key = (font_path, size)
     if cache_key not in _font_cache:
-        _font_cache[cache_key] = ImageFont.truetype(font_path, size=size)
+        try:
+            _font_cache[cache_key] = ImageFont.truetype(font_path, size=size)
+        except:
+            # Fallback to default font if custom font fails
+            _font_cache[cache_key] = ImageFont.load_default()
     return _font_cache[cache_key]
 
 
+def calculate_optimal_font_size(text, w, h, font_path):
+    """
+    Calculate optimal font size to fill the bubble nicely.
+    
+    Args:
+        text: Text to render
+        w: Bubble width
+        h: Bubble height
+        font_path: Path to font file
+        
+    Returns:
+        tuple: (font_size, line_height, wrapped_text, font)
+    """
+    # Apply padding
+    usable_w = int(w * (1 - 2 * PADDING_RATIO))
+    usable_h = int(h * (1 - 2 * PADDING_RATIO))
+    
+    if usable_w <= 0 or usable_h <= 0:
+        return MIN_FONT_SIZE, MIN_FONT_SIZE, text, get_cached_font(font_path, MIN_FONT_SIZE)
+    
+    # Estimate initial font size based on bubble area and text length
+    bubble_area = usable_w * usable_h
+    char_count = max(len(text), 1)
+    
+    # Each character needs approximately (font_size * 0.6) * (font_size * 1.2) pixels
+    # So font_size^2 * 0.72 ≈ area / char_count
+    estimated_size = int(math.sqrt(bubble_area / (char_count * 0.8)))
+    
+    # Clamp to reasonable range
+    font_size = max(MIN_FONT_SIZE, min(MAX_FONT_SIZE, estimated_size))
+    
+    # Binary search for optimal font size
+    best_font_size = MIN_FONT_SIZE
+    best_wrapped = text
+    
+    for size in range(font_size, MIN_FONT_SIZE - 1, -2):
+        font = get_cached_font(font_path, size)
+        line_height = int(size * 1.3)
+        
+        # Calculate characters per line based on font size
+        avg_char_width = size * 0.6  # Approximate average character width
+        chars_per_line = max(1, int(usable_w / avg_char_width))
+        
+        # Wrap text
+        wrapped = textwrap.fill(text, width=chars_per_line, break_long_words=True)
+        lines = wrapped.split('\n')
+        
+        # Calculate total height needed
+        total_height = len(lines) * line_height
+        
+        # Check if text fits
+        if total_height <= usable_h:
+            # Check if all lines fit width-wise
+            fits_width = True
+            for line in lines:
+                try:
+                    line_width = font.getlength(line)
+                except:
+                    line_width = len(line) * avg_char_width
+                if line_width > usable_w:
+                    fits_width = False
+                    break
+            
+            if fits_width:
+                best_font_size = size
+                best_wrapped = wrapped
+                break
+    
+    return best_font_size, int(best_font_size * 1.3), best_wrapped, get_cached_font(font_path, best_font_size)
+
+
 def add_text(image, text, font_path, bubble_contour):
     """
-    Add text inside a speech bubble contour.
+    Add text inside a speech bubble contour with dynamic font sizing.
 
     Args:
         image (numpy.ndarray): Processed bubble image (cv2 format - BGR).
@@ -28,49 +109,38 @@ def add_text(image, text, font_path, bubble_contour):
     Returns:
         numpy.ndarray: Image with text placed inside the speech bubble.
     """
+    if not text or not text.strip():
+        return image
+    
     pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
     draw = ImageDraw.Draw(pil_image)
 
     x, y, w, h = cv2.boundingRect(bubble_contour)
-
-    line_height = 16
-    font_size = 14
-    wrapping_ratio = 0.075
-
-    wrapped_text = textwrap.fill(text, width=int(w * wrapping_ratio), 
-                                 break_long_words=True)
     
-    font = get_cached_font(font_path, font_size)
-
+    # Calculate optimal font size
+    font_size, line_height, wrapped_text, font = calculate_optimal_font_size(
+        text, w, h, font_path
+    )
+    
     lines = wrapped_text.split('\n')
-    total_text_height = (len(lines)) * line_height
-
-    while total_text_height > h:
-        line_height -= 2
-        font_size -= 2
-        wrapping_ratio += 0.025
-
-        wrapped_text = textwrap.fill(text, width=int(w * wrapping_ratio), 
-                                 break_long_words=True)
-                                 
-        font = get_cached_font(font_path, font_size)
-
-        lines = wrapped_text.split('\n')
-        total_text_height = (len(lines)) * line_height                         
+    total_text_height = len(lines) * line_height
 
     # Vertical centering
     text_y = y + (h - total_text_height) // 2
 
     for line in lines:
-        text_length = draw.textlength(line, font=font)
+        try:
+            text_length = font.getlength(line)
+        except:
+            text_length = len(line) * font_size * 0.6
 
         # Horizontal centering
         text_x = x + (w - text_length) // 2
 
         draw.text((text_x, text_y), line, font=font, fill=(0, 0, 0))
-
         text_y += line_height
 
     image[:, :, :] = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
 
     return image
+

demo/add_text.py

@@ -0,0 +1,65 @@
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+import textwrap
+import cv2
+
+
+def add_text(image, text, font_path, bubble_contour):
+    """
+    Add text inside a speech bubble contour.
+
+    Args:
+        image (numpy.ndarray): Processed bubble image (cv2 format - BGR).
+        text (str): Text to be placed inside the speech bubble.
+        font_path (str): Font path.
+        bubble_contour (numpy.ndarray): Contour of the detected speech bubble.
+
+    Returns:
+        numpy.ndarray: Image with text placed inside the speech bubble.
+    """
+    pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+    draw = ImageDraw.Draw(pil_image)
+
+    x, y, w, h = cv2.boundingRect(bubble_contour)
+
+    line_height = 16
+    font_size = 14
+    wrapping_ratio = 0.075
+
+    wrapped_text = textwrap.fill(text, width=int(w * wrapping_ratio), 
+                                 break_long_words=True)
+    
+    font = ImageFont.truetype(font_path, size=font_size)
+
+    lines = wrapped_text.split('\n')
+    total_text_height = (len(lines)) * line_height
+
+    while total_text_height > h:
+        line_height -= 2
+        font_size -= 2
+        wrapping_ratio += 0.025
+
+        wrapped_text = textwrap.fill(text, width=int(w * wrapping_ratio), 
+                                 break_long_words=True)
+                                 
+        font = ImageFont.truetype(font_path, size=font_size)
+
+        lines = wrapped_text.split('\n')
+        total_text_height = (len(lines)) * line_height                         
+
+    # Vertical centering
+    text_y = y + (h - total_text_height) // 2
+
+    for line in lines:
+        text_length = draw.textlength(line, font=font)
+
+        # Horizontal centering
+        text_x = x + (w - text_length) // 2
+
+        draw.text((text_x, text_y), line, font=font, fill=(0, 0, 0))
+
+        text_y += line_height
+
+    image[:, :, :] = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+
+    return image

demo/app.py

@@ -0,0 +1,72 @@
+from add_text import add_text
+from detect_bubbles import detect_bubbles
+from process_bubble import process_bubble
+from translator import MangaTranslator
+from ultralytics import YOLO
+from manga_ocr import MangaOcr
+from PIL import Image
+import gradio as gr
+import numpy as np
+import cv2
+
+
+MODEL = "model.pt"
+EXAMPLE_LIST = [["examples/0.png"],
+                 ["examples/ex0.png"]]
+TITLE = "Manga Translator"
+DESCRIPTION = "Translate text in manga bubbles!"
+
+
+def predict(img, translation_method, font):
+    if translation_method == None:
+        translation_method = "google"
+    if font == None:
+        font = "fonts/animeace_i.ttf"
+
+    results = detect_bubbles(MODEL, img)
+
+    manga_translator = MangaTranslator()
+    mocr = MangaOcr()
+
+    image = np.array(img)
+
+    for result in results:
+        x1, y1, x2, y2, score, class_id = result
+
+        detected_image = image[int(y1):int(y2), int(x1):int(x2)]
+
+        im = Image.fromarray(np.uint8((detected_image)*255))
+        text = mocr(im)
+
+        detected_image, cont = process_bubble(detected_image)
+
+        text_translated = manga_translator.translate(text,
+                                                     method=translation_method)
+
+        image[int(y1):int(y2), int(x1):int(x2)] = add_text(detected_image, text_translated, font, cont)
+
+    return Image.fromarray(image)
+
+demo = gr.Interface(fn=predict,
+                    inputs=["image",
+                            gr.Dropdown([("Google", "google"),
+                                         ("Helsinki-NLP's opus-mt-ja-en model",
+                                          "hf"),
+                                         ("Sogou", "sogou"),
+                                         ("Bing", "bing")],
+                                        label="Translation Method",
+                                        value="google"),
+                            gr.Dropdown([("animeace_i", "fonts/animeace_i.ttf"),
+                                         ("mangati", "fonts/mangati.ttf"),
+                                         ("ariali", "fonts/ariali.ttf")],
+                                        label="Text Font",
+                                        value="fonts/animeace_i.ttf")
+                            ],
+                    outputs=[gr.Image()],
+                    examples=EXAMPLE_LIST,
+                    title=TITLE,
+                    description=DESCRIPTION)
+
+
+demo.launch(debug=False,
+            share=False)

demo/detect_bubbles.py

@@ -0,0 +1,19 @@
+import torch.serialization
+from ultralytics import YOLO
+
+def detect_bubbles(model_path, image_path):
+    """
+    Detects bubbles in an image using a YOLOv8 model.
+    Args:
+        model_path (str): The file path to the YOLO model.
+        image_path (str): The file path to the input image.
+    Returns:
+        list: A list containing the coordinates, score, and class_id of 
+              the detected bubbles.
+    """
+    with torch.serialization.safe_globals([YOLO]):
+        model = YOLO(model_path)
+
+    bubbles = model(image_path)[0]
+
+    return bubbles.boxes.data.tolist()

demo/fonts/ariali.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79a5742b865cf06891d4ae43e42cac0e5169c7b7b06b5b3c24ef8e0966d27b62
+size 717428

demo/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f1a64e4e4c0dd30b361eb332866dea0f52eab9acb288b9ffdcb2622cb5d1cdb
+size 6234585

demo/packages.txt

@@ -0,0 +1 @@
+python3-opencv

demo/process_bubble.py

@@ -0,0 +1,27 @@
+import cv2
+import numpy as np
+
+
+def process_bubble(image):
+    """
+    Processes the speech bubble in the given image, making its contents white.
+
+    Parameters:
+    - image (numpy.ndarray): Input image.
+
+    Returns:
+    - image (numpy.ndarray):  Image with the speech bubble content set to white.
+    - largest_contour (numpy.ndarray): Contour of the detected speech bubble.
+    """
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    _, thresh = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY)
+
+    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    largest_contour = max(contours, key=cv2.contourArea)
+
+    mask = np.zeros_like(gray)
+    cv2.drawContours(mask, [largest_contour], -1, 255, cv2.FILLED)
+
+    image[mask == 255] = (255, 255, 255)
+
+    return image, largest_contour

demo/requirements.txt

@@ -0,0 +1,10 @@
+deep-translator==1.11.4
+translators==5.9.1
+huggingface-hub==0.22.2
+manga-ocr==0.1.11
+numpy==1.24.2
+opencv-python==4.9.0.80
+pillow==10.3.0
+ultralytics==8.1.43
+sentencepiece==0.2.0
+torch==2.5.0

demo/translator.py

@@ -0,0 +1,70 @@
+from deep_translator import GoogleTranslator
+from transformers import pipeline
+import translators as ts
+import random
+import time
+
+
+class MangaTranslator:
+    def __init__(self):
+        self.target = "en"
+        self.source = "ja"
+        self.translators = {
+            "google": self._translate_with_google,
+            "hf": self._translate_with_hf,
+            "sogou": self._translate_with_sogou,
+            "bing": self._translate_with_bing
+        }
+
+    def translate(self, text, method="google"):
+        """
+        Translates the given text to the target language using the specified method.
+
+        Args:
+            text (str): The text to be translated.
+            method (str):"google" for Google Translator, 
+                         "hf" for Helsinki-NLP's opus-mt-ja-en model (HF pipeline)
+                         "sogou" for Sogou Translate
+                         "bing" for Microsoft Bing Translator
+
+        Returns:
+            str: The translated text.
+        """
+        translator_func = self.translators.get(method)
+
+        if translator_func:
+            return translator_func(self._preprocess_text(text))
+        else:
+            raise ValueError("Invalid translation method.")
+            
+    def _translate_with_google(self, text):
+        self._delay()
+        translator = GoogleTranslator(source=self.source, target=self.target)
+        translated_text = translator.translate(text)
+        return translated_text if translated_text is not None else text
+
+    def _translate_with_hf(self, text):
+        pipe = pipeline("translation", model=f"Helsinki-NLP/opus-mt-ja-en")
+        translated_text = pipe(text)[0]["translation_text"]
+        return translated_text if translated_text is not None else text
+
+    def _translate_with_sogou(self, text):
+        self._delay()
+        translated_text = ts.translate_text(text, translator="sogou",
+                                            from_language=self.source,
+                                            to_language=self.target)
+        return translated_text if translated_text is not None else text
+
+    def _translate_with_bing(self, text):
+        self._delay()
+        translated_text = ts.translate_text(text, translator="bing",
+                                            from_language=self.source, 
+                                            to_language=self.target)
+        return translated_text if translated_text is not None else text
+
+    def _preprocess_text(self, text):
+        preprocessed_text = text.replace("．", ".")
+        return preprocessed_text
+
+    def _delay(self):
+        time.sleep(random.randint(3, 5))

fonts/ariali.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79a5742b865cf06891d4ae43e42cac0e5169c7b7b06b5b3c24ef8e0966d27b62
+size 717428

model/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f1a64e4e4c0dd30b361eb332866dea0f52eab9acb288b9ffdcb2622cb5d1cdb
+size 6234585

model/model_training.ipynb

@@ -0,0 +1,100 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**YOLOv8 model training using ultralytics**"
+      ],
+      "metadata": {
+        "id": "7PihFE53D92W"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "toxMDptj5Psd"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install ultralytics"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from ultralytics import YOLO\n",
+        "import os"
+      ],
+      "metadata": {
+        "id": "0Jw1Ow2A5_Sf"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Path to the root directory that contains config.yaml file and the dataset\n",
+        "# annotated in the YOLOv8 format\n",
+        "ROOT_DIR = \"Path\"\n",
+        "\n",
+        "# Path to the pretrained model if exists\n",
+        "PRETRAINED_MODEL_PATH = \"Path\"\n",
+        "\n",
+        "# Number of iterations (forward pass) to train the model\n",
+        "NUM_EPOCHS = 100"
+      ],
+      "metadata": {
+        "id": "NDclcuR05QZP"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def train_model(load_model=False):\n",
+        "  if load_model:\n",
+        "    model = YOLO(PRETRAINED_MODEL_PATH)\n",
+        "    results = model.train(data=os.path.join(ROOT_DIR, \"config.yaml\"),\n",
+        "                          epochs=NUM_EPOCHS)\n",
+        "  else:\n",
+        "    model = YOLO(\"yolov8n.yaml\")\n",
+        "    results = model.train(data=os.path.join(ROOT_DIR, \"config.yaml\"),\n",
+        "                          epochs=NUM_EPOCHS)\n",
+        ""
+      ],
+      "metadata": {
+        "id": "PAYhaotC5QcB"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train_model()"
+      ],
+      "metadata": {
+        "id": "mCxI3Xlr7Ryu"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

ocr/__init__.py

@@ -0,0 +1,4 @@
+# OCR modules
+from .chrome_lens_ocr import ChromeLensOCR
+
+__all__ = ["ChromeLensOCR"]

ocr/chrome_lens_ocr.py

@@ -0,0 +1,116 @@
+"""
+Chrome Lens OCR module using chrome-lens-py library.
+Provides OCR functionality using Google Lens API.
+"""
+import asyncio
+from PIL import Image
+import numpy as np
+
+from chrome_lens_py import LensAPI
+
+
+class ChromeLensOCR:
+    """
+    OCR engine using Google Chrome Lens API via chrome-lens-py.
+    
+    This provides an alternative to manga-ocr with the following benefits:
+    - Free Google Lens OCR API
+    - Multi-language support with auto-detection
+    - Text block segmentation for comics/manga
+    """
+    
+    def __init__(self, ocr_language: str = "ja"):
+        """
+        Initialize Chrome Lens OCR.
+        
+        Args:
+            ocr_language: BCP 47 language code for OCR (default: "ja" for Japanese)
+        """
+        self.api = LensAPI()
+        self.ocr_language = ocr_language
+    
+    def __call__(self, image) -> str:
+        """
+        Process an image and extract text.
+        
+        Args:
+            image: Can be a PIL Image, numpy array, file path, or URL
+            
+        Returns:
+            str: Extracted text from the image
+        """
+        # Handle different image input types
+        if isinstance(image, np.ndarray):
+            # Convert numpy array to PIL Image
+            image = Image.fromarray(image)
+        
+        # Use cached event loop to avoid overhead
+        try:
+            loop = asyncio.get_running_loop()
+            # If there's a running loop, use run_coroutine_threadsafe
+            import concurrent.futures
+            future = asyncio.run_coroutine_threadsafe(self._process(image), loop)
+            return future.result(timeout=30)
+        except RuntimeError:
+            # No running loop, create one (but try to reuse)
+            if not hasattr(self, '_loop') or self._loop.is_closed():
+                self._loop = asyncio.new_event_loop()
+            return self._loop.run_until_complete(self._process(image))
+    
+    async def _process(self, image) -> str:
+        """
+        Async method to process image with Chrome Lens API.
+        
+        Args:
+            image: PIL Image, file path, or URL
+            
+        Returns:
+            str: Extracted text
+        """
+        try:
+            result = await self.api.process_image(
+                image_path=image,
+                ocr_language=self.ocr_language
+            )
+            return result.get("ocr_text", "")
+        except Exception as e:
+            print(f"Chrome Lens OCR error: {e}")
+            return ""
+    
+    async def process_with_blocks(self, image) -> dict:
+        """
+        Process image and return text segmented into blocks.
+        Useful for manga/comics with multiple speech bubbles.
+        
+        Args:
+            image: PIL Image, file path, or URL
+            
+        Returns:
+            dict: Contains 'text_blocks' with segmented text and geometry
+        """
+        try:
+            result = await self.api.process_image(
+                image_path=image,
+                ocr_language=self.ocr_language,
+                output_format='blocks'
+            )
+            return result
+        except Exception as e:
+            print(f"Chrome Lens OCR error: {e}")
+            return {"text_blocks": []}
+    
+    def get_text_blocks(self, image) -> list:
+        """
+        Synchronous wrapper to get text blocks from image.
+        
+        Args:
+            image: PIL Image, numpy array, file path, or URL
+            
+        Returns:
+            list: List of text blocks with text and geometry
+        """
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        result = asyncio.run(self.process_with_blocks(image))
+        return result.get("text_blocks", [])

static/css/style.css

@@ -0,0 +1,346 @@
+body {
+	font-family: 'Exo 2', sans-serif;
+	background-color: #f7f7f7;
+	margin: 0;
+	min-height: 100vh;
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+}
+
+header {
+	width: 100%;
+	box-shadow: 0 0 10px #cccccc;
+	background-image: url("../img/header.png");
+	background-size: 100% 100%;
+	padding: 1.4%;
+	margin-bottom: 40px;
+}
+
+.container {
+	background-color: #fff;
+	border-radius: 16px;
+	box-shadow: 0 4px 20px rgba(0, 0, 0, 0.1);
+	padding: 30px 40px;
+	width: 520px;
+	max-width: 90%;
+	box-sizing: border-box;
+}
+
+.container>img {
+	display: block;
+	margin: 0 auto 20px;
+	width: 180px;
+	height: auto;
+}
+
+form {
+	text-align: center;
+}
+
+/* 2-column grid layout */
+.form-grid {
+	display: grid;
+	grid-template-columns: 1fr 1fr;
+	gap: 15px 20px;
+	margin-bottom: 20px;
+}
+
+.select-wrapper {
+	text-align: left;
+}
+
+.select-wrapper.full-width {
+	grid-column: 1 / -1;
+}
+
+label.translator-label {
+	display: block;
+	font-size: 13px;
+	font-weight: 600;
+	color: #333;
+	margin-bottom: 6px;
+}
+
+.custom-select {
+	position: relative;
+	width: 100%;
+}
+
+.select-box {
+	border: 1px solid #ddd;
+	border-radius: 8px;
+	padding: 10px 14px;
+	cursor: pointer;
+	user-select: none;
+	background-color: #fafafa;
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	transition: border-color 0.2s, box-shadow 0.2s;
+}
+
+.select-box:hover {
+	border-color: #5E1675;
+}
+
+.selected {
+	font-size: 14px;
+	overflow: hidden;
+	white-space: nowrap;
+	text-overflow: ellipsis;
+}
+
+.icon {
+	color: #999;
+	font-size: 10px;
+	transition: transform 0.2s;
+}
+
+.custom-select.open .icon {
+	transform: rotate(180deg);
+}
+
+.options {
+	position: absolute;
+	top: calc(100% + 4px);
+	left: 0;
+	right: 0;
+	z-index: 100;
+	display: none;
+	border: 1px solid #ddd;
+	border-radius: 8px;
+	background-color: white;
+	box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+	max-height: 200px;
+	overflow-y: auto;
+}
+
+.option {
+	display: block;
+	padding: 10px 14px;
+	font-size: 14px;
+	cursor: pointer;
+	transition: background-color 0.15s;
+}
+
+.option:hover {
+	background-color: #f5f0f7;
+}
+
+.option.selected {
+	background-color: #f0e6f5;
+	font-weight: 600;
+	color: #5E1675;
+}
+
+/* Custom prompt textarea */
+#custom_prompt {
+	width: 100%;
+	border-radius: 8px;
+	padding: 10px 14px;
+	border: 1px solid #ddd;
+	font-family: inherit;
+	font-size: 14px;
+	resize: vertical;
+	box-sizing: border-box;
+}
+
+#custom_prompt:focus {
+	outline: none;
+	border-color: #5E1675;
+}
+
+/* File upload */
+input[type="file"] {
+	display: none;
+}
+
+.file {
+	display: block;
+	width: 100%;
+	padding: 14px;
+	border: 2px dashed #5E1675;
+	border-radius: 10px;
+	text-align: center;
+	cursor: pointer;
+	color: #5E1675;
+	font-weight: 500;
+	transition: background-color 0.2s, border-color 0.2s;
+	margin-bottom: 10px;
+}
+
+.file:hover {
+	background-color: #f9f5fb;
+}
+
+.file-list {
+	margin-bottom: 15px;
+}
+
+.file-item {
+	font-size: 12px;
+	color: #666;
+	padding: 4px 10px;
+	background: #f5f5f5;
+	border-radius: 4px;
+	margin: 4px 0;
+	text-align: left;
+}
+
+.file-item.more {
+	color: #5E1675;
+	font-style: italic;
+}
+
+/* Submit button */
+button {
+	width: 100%;
+	padding: 14px;
+	background-color: #5E1675;
+	color: white;
+	border: none;
+	border-radius: 10px;
+	cursor: pointer;
+	font-size: 16px;
+	font-weight: 600;
+	transition: background-color 0.2s, transform 0.1s;
+}
+
+button:hover {
+	background-color: #4a1160;
+}
+
+button:active {
+	transform: scale(0.98);
+}
+
+/* Loading */
+#loading-img {
+	display: none;
+	width: 60px;
+	margin: 20px auto;
+}
+
+#loading-p {
+	display: none;
+	text-align: center;
+	color: #666;
+}
+
+/* Results page */
+.results-container {
+	max-width: 1200px;
+	margin: 40px auto;
+	padding: 20px;
+}
+
+.results-title {
+	text-align: center;
+	color: #5E1675;
+	margin-bottom: 30px;
+	font-size: 24px;
+}
+
+.image-gallery {
+	display: grid;
+	grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+	gap: 20px;
+}
+
+.image-card {
+	background: white;
+	border-radius: 12px;
+	box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+	overflow: hidden;
+	transition: transform 0.3s, box-shadow 0.3s;
+}
+
+.image-card:hover {
+	transform: translateY(-5px);
+	box-shadow: 0 8px 25px rgba(0, 0, 0, 0.15);
+}
+
+.gallery-image {
+	width: 100%;
+	height: auto;
+	max-height: 400px;
+	object-fit: contain;
+	background: #f8f8f8;
+}
+
+.image-info {
+	padding: 15px;
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+}
+
+.image-name {
+	font-weight: 500;
+	color: #333;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+	max-width: 60%;
+}
+
+.download-btn {
+	background: #50C878;
+	color: white;
+	padding: 8px 15px;
+	border-radius: 6px;
+	text-decoration: none;
+	font-size: 14px;
+	transition: background 0.2s;
+}
+
+.download-btn:hover {
+	background: #3da85c;
+}
+
+.buttons_image {
+	display: flex;
+	justify-content: center;
+	gap: 15px;
+	margin-top: 20px;
+}
+
+.buttons_image a {
+	padding: 12px 24px;
+	border-radius: 8px;
+	text-decoration: none;
+	font-weight: 600;
+	transition: all 0.2s;
+}
+
+.green {
+	background: #50C878;
+	color: white;
+}
+
+.green:hover {
+	background: #3da85c;
+}
+
+.red {
+	background: white;
+	color: #fd5c63;
+	border: 2px solid #fd5c63;
+}
+
+.red:hover {
+	background: #fd5c63;
+	color: white;
+}
+
+/* Responsive */
+@media (max-width: 600px) {
+	.form-grid {
+		grid-template-columns: 1fr;
+	}
+
+	.container {
+		padding: 20px;
+	}
+}

static/js/app.js

@@ -0,0 +1,124 @@
+// Sets up custom dropdown behavior for all select wrappers
+document.addEventListener("DOMContentLoaded", () => {
+    const selectWrappers = document.querySelectorAll('.select-wrapper');
+
+    selectWrappers.forEach(wrapper => {
+        const selectBox = wrapper.querySelector('.custom-select');
+        if (!selectBox) return;
+
+        const selectedText = selectBox.querySelector('.selected');
+        const options = selectBox.querySelector('.options');
+        const optionList = selectBox.querySelectorAll('.option');
+
+        if (!optionList.length) return;
+
+        const defaultOption = optionList[0];
+        selectedText.textContent = defaultOption.textContent;
+        defaultOption.classList.add('selected');
+
+        // Toggle options display on select box click
+        selectBox.addEventListener('click', () => {
+            options.style.display = options.style.display === 'block' ? 'none' : 'block';
+            selectBox.classList.toggle('open');
+        });
+
+        // Update selected option and hide options on option click
+        optionList.forEach(option => {
+            option.addEventListener('click', () => {
+                selectedText.textContent = option.textContent;
+                optionList.forEach(opt => opt.classList.remove('selected'));
+                option.classList.add('selected');
+
+                // Show/hide custom prompt textarea
+                if (selectBox.id === 'style') {
+                    const customWrapper = document.getElementById('custom-prompt-wrapper');
+                    if (option.textContent.includes('Custom')) {
+                        customWrapper.style.display = 'block';
+                    } else {
+                        customWrapper.style.display = 'none';
+                    }
+                }
+            });
+        });
+
+        // Hide options when clicking outside the select box
+        window.addEventListener('click', e => {
+            if (!wrapper.contains(e.target)) {
+                options.style.display = 'none';
+                selectBox.classList.remove('open');
+            }
+        });
+    });
+});
+
+// Handles multiple file upload change event
+const fileUpload = document.getElementById('file-upload');
+if (fileUpload) {
+    fileUpload.addEventListener('change', function () {
+        const files = this.files;
+        const fileList = document.getElementById('file-list');
+        const fileText = document.getElementById('file-text');
+
+        if (files.length === 0) {
+            fileText.textContent = '📁 Chọn ảnh (có thể chọn nhiều)';
+            fileList.innerHTML = '';
+            return;
+        }
+
+        if (files.length === 1) {
+            fileText.textContent = truncateFileName(files[0].name, 25);
+            fileList.innerHTML = '';
+        } else {
+            fileText.textContent = `📁 ${files.length} ảnh đã chọn`;
+
+            // Show file list preview
+            fileList.innerHTML = '';
+            for (let i = 0; i < Math.min(files.length, 5); i++) {
+                const fileItem = document.createElement('div');
+                fileItem.className = 'file-item';
+                fileItem.textContent = truncateFileName(files[i].name, 30);
+                fileList.appendChild(fileItem);
+            }
+
+            if (files.length > 5) {
+                const moreItem = document.createElement('div');
+                moreItem.className = 'file-item more';
+                moreItem.textContent = `... và ${files.length - 5} ảnh khác`;
+                fileList.appendChild(moreItem);
+            }
+        }
+    });
+}
+
+// Truncates file name if it exceeds the maximum length
+function truncateFileName(fileName, maxLength) {
+    return fileName.length <= maxLength ? fileName : fileName.substr(0, maxLength - 3) + '...';
+}
+
+// Updates hidden input fields with selected options
+function updateHiddenInputs() {
+    const getSelectedText = (id) => {
+        const el = document.querySelector(`#${id} .selected`);
+        return el ? el.innerText : '';
+    };
+
+    document.getElementById("selected_source_lang").value = getSelectedText("source_lang");
+    document.getElementById("selected_language").value = getSelectedText("language");
+    document.getElementById("selected_translator").value = getSelectedText("translator");
+    document.getElementById("selected_style").value = getSelectedText("style");
+    document.getElementById("selected_font").value = getSelectedText("font");
+    document.getElementById("selected_ocr").value = getSelectedText("ocr");
+
+    // Check if files are selected
+    const files = document.getElementById('file-upload').files;
+    if (files.length === 0) {
+        alert('Vui lòng chọn ít nhất 1 ảnh!');
+        return false;
+    }
+
+    document.querySelector('form').style.display = 'none';
+    document.getElementById('loading-img').style.display = 'block';
+    document.getElementById('loading-p').style.display = 'block';
+
+    return true;
+}

templates/index.html

@@ -0,0 +1,161 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+   <meta charset="UTF-8">
+   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+   <link rel="preconnect" href="https://fonts.googleapis.com">
+   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+   <title>Manga Translator</title>
+   <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+   <link href="https://fonts.googleapis.com/css2?family=Exo+2:ital,wght@0,100..900;1,100..900&display=swap"
+      rel="stylesheet">
+</head>
+
+<body>
+   <header>
+   </header>
+   <div class="container">
+      <img src="{{ url_for('static', filename='img/logo.png') }}" alt="Manga Translator">
+      <form action="/translate" method="post" enctype="multipart/form-data" onsubmit="return updateHiddenInputs()">
+
+         <!-- 2-column grid for dropdowns -->
+         <div class="form-grid">
+            <!-- Row 1: Source & Target Language -->
+            <div class="select-wrapper">
+               <label class="translator-label">Ngôn ngữ gốc</label>
+               <div class="custom-select" id="source_lang" tabindex="0">
+                  <div class="select-box">
+                     <span class="selected"></span>
+                     <span class="icon">&#9660;</span>
+                  </div>
+                  <div class="options">
+                     <span class="option">Japanese (Manga)</span>
+                     <span class="option">Chinese (Manhua)</span>
+                     <span class="option">Korean (Manhwa)</span>
+                     <span class="option">English (Comic)</span>
+                  </div>
+               </div>
+            </div>
+
+            <div class="select-wrapper">
+               <label class="translator-label">Dịch sang</label>
+               <div class="custom-select" id="language" tabindex="0">
+                  <div class="select-box">
+                     <span class="selected"></span>
+                     <span class="icon">&#9660;</span>
+                  </div>
+                  <div class="options">
+                     <span class="option">Vietnamese</span>
+                     <span class="option">English</span>
+                     <span class="option">Chinese</span>
+                     <span class="option">Korean</span>
+                     <span class="option">Thai</span>
+                     <span class="option">Indonesian</span>
+                     <span class="option">French</span>
+                     <span class="option">German</span>
+                     <span class="option">Spanish</span>
+                     <span class="option">Russian</span>
+                  </div>
+               </div>
+            </div>
+
+            <!-- Row 2: Translator & Style -->
+            <div class="select-wrapper">
+               <label class="translator-label">Translator</label>
+               <div class="custom-select" id="translator" tabindex="0">
+                  <div class="select-box">
+                     <span class="selected"></span>
+                     <span class="icon">&#9660;</span>
+                  </div>
+                  <div class="options">
+                     <span class="option">Gemini</span>
+                     <span class="option">Google</span>
+                     <span class="option">NLLB</span>
+                     <span class="option">Baidu</span>
+                     <span class="option">Bing</span>
+                  </div>
+               </div>
+            </div>
+
+            <div class="select-wrapper">
+               <label class="translator-label">Phong cách dịch</label>
+               <div class="custom-select" id="style" tabindex="0">
+                  <div class="select-box">
+                     <span class="selected"></span>
+                     <span class="icon">&#9660;</span>
+                  </div>
+                  <div class="options">
+                     <span class="option">Default</span>
+                     <span class="option">Casual (thân mật)</span>
+                     <span class="option">Formal (trang trọng)</span>
+                     <span class="option">Keep Honorifics (-san, senpai...)</span>
+                     <span class="option">Web Novel Style</span>
+                     <span class="option">Action (ngắn gọn)</span>
+                     <span class="option">Literal (sát nghĩa)</span>
+                     <span class="option">Custom...</span>
+                  </div>
+               </div>
+            </div>
+
+            <!-- Row 3: Font & OCR -->
+            <div class="select-wrapper">
+               <label class="translator-label">Font</label>
+               <div class="custom-select" id="font" tabindex="0">
+                  <div class="select-box">
+                     <span class="selected"></span>
+                     <span class="icon">&#9660;</span>
+                  </div>
+                  <div class="options">
+                     <span class="option">Animeace</span>
+                     <span class="option">Mangat</span>
+                     <span class="option">Arial</span>
+                  </div>
+               </div>
+            </div>
+
+            <div class="select-wrapper">
+               <label class="translator-label">OCR Engine</label>
+               <div class="custom-select" id="ocr" tabindex="0">
+                  <div class="select-box">
+                     <span class="selected"></span>
+                     <span class="icon">&#9660;</span>
+                  </div>
+                  <div class="options">
+                     <span class="option">Chrome-Lens</span>
+                     <span class="option">Manga-OCR</span>
+                  </div>
+               </div>
+            </div>
+         </div>
+
+         <!-- Custom Prompt (show when Custom selected) -->
+         <div class="select-wrapper full-width" id="custom-prompt-wrapper" style="display: none;">
+            <label class="translator-label">Custom Prompt</label>
+            <textarea id="custom_prompt" name="custom_prompt"
+               placeholder="Ví dụ: Dịch theo phong cách light novel, giữ nguyên tên nhân vật..." rows="2"></textarea>
+         </div>
+
+         <!-- File upload -->
+         <input id="file-upload" type="file" name="files" accept=".jpg, .jpeg, .png" multiple required>
+         <label for="file-upload" class="file" id="file-label">
+            <span id="file-text">📁 Chọn ảnh</span>
+         </label>
+         <div id="file-list" class="file-list"></div>
+
+         <input type="hidden" id="selected_source_lang" name="selected_source_lang">
+         <input type="hidden" id="selected_language" name="selected_language">
+         <input type="hidden" id="selected_translator" name="selected_translator">
+         <input type="hidden" id="selected_style" name="selected_style">
+         <input type="hidden" id="selected_font" name="selected_font">
+         <input type="hidden" id="selected_ocr" name="selected_ocr">
+         <button type="submit">Translate</button>
+      </form>
+      <img id="loading-img" src="{{ url_for('static', filename='img/loading.gif') }}" alt="">
+      <p id="loading-p">Đang xử lý... Vui lòng đợi!</p>
+   </div>
+
+   <script src="{{ url_for('static', filename='js/app.js') }}"></script>
+</body>
+
+</html>

templates/translate.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+   <meta charset="UTF-8">
+   <title>Manga Translator - Results</title>
+   <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+   <link href="https://fonts.googleapis.com/css2?family=Exo+2:ital,wght@0,100..900;1,100..900&display=swap"
+      rel="stylesheet">
+</head>
+
+<body>
+   <header>
+   </header>
+
+   <div class="results-container">
+      <h2 class="results-title">✨ Kết quả dịch ({{ images|length }} ảnh)</h2>
+
+      {% if images %}
+      <div class="image-gallery">
+         {% for img in images %}
+         <div class="image-card">
+            <img class="gallery-image" src="data:image/jpeg;base64,{{ img.data }}" alt="{{ img.name }}">
+            <div class="image-info">
+               <span class="image-name">{{ img.name }}</span>
+               <a href="#" class="download-btn" data-image="{{ img.data }}" data-name="{{ img.name }}">
+                  💾 Download
+               </a>
+            </div>
+         </div>
+         {% endfor %}
+      </div>
+      {% else %}
+      <p class="no-images">Không có ảnh nào được xử lý.</p>
+      {% endif %}
+   </div>
+
+   <div class="buttons_image">
+      <a href="#" class="green" id="download-all">📦 Download All</a>
+      <a href="/" class="red">← Quay lại</a>
+   </div>
+
+</body>
+<script>
+   // Download single image
+   document.querySelectorAll('.download-btn').forEach(btn => {
+      btn.addEventListener('click', (e) => {
+         e.preventDefault();
+         const imageData = btn.getAttribute('data-image');
+         const imageName = btn.getAttribute('data-name');
+         const a = document.createElement('a');
+         a.href = 'data:image/png;base64,' + imageData;
+         a.download = imageName + '_translated.png';
+         a.click();
+      });
+   });
+
+   // Download all images
+   document.getElementById('download-all').addEventListener('click', (e) => {
+      e.preventDefault();
+      document.querySelectorAll('.download-btn').forEach((btn, index) => {
+         setTimeout(() => {
+            btn.click();
+         }, index * 300); // Delay between downloads
+      });
+   });
+</script>
+
+</html>

translator/__init__.py

@@ -0,0 +1,5 @@
+# Translator modules
+from .translator import MangaTranslator
+from .gemini_translator import GeminiTranslator
+
+__all__ = ["MangaTranslator", "GeminiTranslator"]

translator/gemini_translator.py

@@ -0,0 +1,288 @@
+"""
+Gemini Translator with Batch Processing
+Uses Gemini 2.5 Flash-Lite for cost-effective translation
+Supports multiple source languages and custom prompts
+"""
+import google.generativeai as genai
+import json
+import os
+from typing import List, Dict, Optional
+
+
+class GeminiTranslator:
+    """
+    Translator using Google Gemini 2.5 Flash-Lite.
+    Supports batch translation to minimize API calls.
+    """
+    
+    LANG_NAMES = {
+        "ja": "Japanese",
+        "zh": "Chinese",
+        "ko": "Korean",
+        "en": "English",
+        "vi": "Vietnamese",
+        "th": "Thai",
+        "id": "Indonesian",
+        "fr": "French",
+        "de": "German",
+        "es": "Spanish",
+        "ru": "Russian"
+    }
+    
+    # Preset style templates
+    STYLE_PRESETS = {
+        "default": "",
+        "formal": "Use formal language and polite expressions.",
+        "casual": "Use casual, friendly language like talking to friends.",
+        "keep_honorifics": "Keep Japanese honorifics like -san, -kun, -chan, -sama, senpai, sensei.",
+        "localize": "Fully localize the text, replace cultural references with equivalent ones in target language.",
+        "literal": "Translate as literally as possible while maintaining readability.",
+        "web_novel": "Use web novel translation style with dramatic expressions.",
+        "action": "Use punchy, short sentences suitable for action scenes.",
+    }
+    
+    def __init__(self, api_key: str = None, custom_prompt: str = None, style: str = "default"):
+        """
+        Initialize Gemini translator.
+        
+        Args:
+            api_key: Gemini API key. If None, reads from GEMINI_API_KEY env var.
+            custom_prompt: Custom instructions for translation style.
+            style: Preset style name from STYLE_PRESETS.
+        """
+        self.api_key = api_key or os.environ.get("GEMINI_API_KEY")
+        if not self.api_key:
+            raise ValueError("Gemini API key required. Set GEMINI_API_KEY or pass api_key.")
+        
+        genai.configure(api_key=self.api_key)
+        self.model = genai.GenerativeModel("gemini-2.5-flash-lite")
+        
+        # Set custom prompt (user prompt takes priority over preset)
+        self.custom_prompt = custom_prompt or self.STYLE_PRESETS.get(style, "")
+    
+    def set_custom_prompt(self, prompt: str):
+        """Update custom prompt for translation style."""
+        self.custom_prompt = prompt
+    
+    def _build_style_instructions(self) -> str:
+        """Build style instructions for the prompt."""
+        if self.custom_prompt:
+            return f"\n\nStyle instructions: {self.custom_prompt}"
+        return ""
+        
+    def translate_single(
+        self, 
+        text: str, 
+        source: str = "ja", 
+        target: str = "en",
+        custom_prompt: str = None
+    ) -> str:
+        """
+        Translate a single text string.
+        
+        Args:
+            text: Text to translate
+            source: Source language code (ja, zh, ko, etc.)
+            target: Target language code
+            custom_prompt: Override custom prompt for this call
+            
+        Returns:
+            Translated text
+        """
+        if not text or not text.strip():
+            return text
+            
+        source_name = self.LANG_NAMES.get(source, "Japanese")
+        target_name = self.LANG_NAMES.get(target, "English")
+        style = custom_prompt or self.custom_prompt
+        style_text = f"\nStyle: {style}" if style else ""
+        
+        prompt = f"""Translate the following {source_name} comic/manga text to {target_name}.
+Keep the translation natural and suitable for comic dialogue.{style_text}
+Only return the translated text, nothing else.
+
+Text: {text}"""
+        
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text.strip()
+        except Exception as e:
+            print(f"Gemini translation error: {e}")
+            return text
+    
+    def translate_batch(
+        self, 
+        texts: List[str], 
+        source: str = "ja", 
+        target: str = "en",
+        custom_prompt: str = None
+    ) -> List[str]:
+        """
+        Translate multiple texts in a single API call.
+        
+        Args:
+            texts: List of texts to translate
+            source: Source language code
+            target: Target language code
+            custom_prompt: Override custom prompt for this call
+            
+        Returns:
+            List of translated texts (same order)
+        """
+        if not texts:
+            return []
+            
+        # Filter empty texts but keep track of indices
+        indexed_texts = [(i, t) for i, t in enumerate(texts) if t and t.strip()]
+        
+        if not indexed_texts:
+            return texts
+        
+        source_name = self.LANG_NAMES.get(source, "Japanese")
+        target_name = self.LANG_NAMES.get(target, "English")
+        texts_to_translate = [t for _, t in indexed_texts]
+        
+        style = custom_prompt or self.custom_prompt
+        style_text = f"\nStyle instructions: {style}" if style else ""
+        
+        prompt = f"""You are a professional comic/manga translator. Translate the following {source_name} texts to {target_name}.
+Keep translations natural and suitable for comic speech bubbles.{style_text}
+
+Input texts (JSON array):
+{json.dumps(texts_to_translate, ensure_ascii=False)}
+
+IMPORTANT: Return ONLY a JSON array with translated texts in the same order. No explanations.
+Example output format: ["translated text 1", "translated text 2", ...]"""
+        
+        try:
+            response = self.model.generate_content(prompt)
+            result_text = response.text.strip()
+            
+            # Clean up response if needed
+            if result_text.startswith("```json"):
+                result_text = result_text[7:]
+            if result_text.startswith("```"):
+                result_text = result_text[3:]
+            if result_text.endswith("```"):
+                result_text = result_text[:-3]
+            result_text = result_text.strip()
+            
+            translations = json.loads(result_text)
+            
+            # Rebuild full list with original empty strings preserved
+            result = list(texts)
+            for (orig_idx, _), trans in zip(indexed_texts, translations):
+                result[orig_idx] = trans
+                
+            return result
+            
+        except Exception as e:
+            print(f"Gemini batch translation error: {e}")
+            # Fallback to single translations
+            return [self.translate_single(t, source, target) for t in texts]
+    
+    def translate_pages_batch(
+        self, 
+        pages_texts: Dict[str, List[str]], 
+        source: str = "ja", 
+        target: str = "en",
+        custom_prompt: str = None
+    ) -> Dict[str, List[str]]:
+        """
+        Translate texts from multiple pages in a single API call.
+        Ideal for batch processing 10 manga pages at once.
+        
+        Args:
+            pages_texts: Dict mapping page names to list of texts
+            source: Source language code
+            target: Target language code
+            custom_prompt: Override custom prompt for this call
+            
+        Returns:
+            Dict with same structure but translated texts
+        """
+        if not pages_texts:
+            return {}
+        
+        source_name = self.LANG_NAMES.get(source, "Japanese")
+        target_name = self.LANG_NAMES.get(target, "English")
+        
+        style = custom_prompt or self.custom_prompt
+        style_text = f"\nStyle instructions: {style}" if style else ""
+        
+        prompt = f"""You are a professional comic/manga translator. Translate all {source_name} texts to {target_name}.
+Keep translations natural, conversational, and suitable for comic speech bubbles.
+Maintain the context and flow between pages as they are sequential comic pages.{style_text}
+
+Input (JSON - page names with their text bubbles):
+{json.dumps(pages_texts, ensure_ascii=False, indent=2)}
+
+IMPORTANT: Return ONLY a JSON object with the exact same structure but with translated texts.
+Keep the same page names and order. No explanations or markdown."""
+
+        try:
+            response = self.model.generate_content(prompt)
+            result_text = response.text.strip()
+            
+            # Clean up response
+            if result_text.startswith("```json"):
+                result_text = result_text[7:]
+            if result_text.startswith("```"):
+                result_text = result_text[3:]
+            if result_text.endswith("```"):
+                result_text = result_text[:-3]
+            result_text = result_text.strip()
+            
+            return json.loads(result_text)
+            
+        except Exception as e:
+            print(f"Gemini pages batch translation error: {e}")
+            # Fallback: translate each page separately
+            result = {}
+            for page_name, texts in pages_texts.items():
+                result[page_name] = self.translate_batch(texts, source, target)
+            return result
+
+
+# Convenience function for batch size of 10 pages
+def translate_manga_batch(
+    pages_texts: Dict[str, List[str]],
+    api_key: str,
+    source_lang: str = "ja",
+    target_lang: str = "en",
+    custom_prompt: str = None,
+    batch_size: int = 10
+) -> Dict[str, List[str]]:
+    """
+    Translate manga pages in batches of 10.
+    
+    Args:
+        pages_texts: All pages' texts
+        api_key: Gemini API key
+        source_lang: Source language code (ja, zh, ko, etc.)
+        target_lang: Target language code
+        custom_prompt: Custom style instructions
+        batch_size: Number of pages per API call (default: 10)
+        
+    Returns:
+        All translated texts
+    """
+    translator = GeminiTranslator(api_key, custom_prompt=custom_prompt)
+    
+    page_names = list(pages_texts.keys())
+    all_results = {}
+    
+    # Process in batches
+    for i in range(0, len(page_names), batch_size):
+        batch_pages = page_names[i:i + batch_size]
+        batch_texts = {name: pages_texts[name] for name in batch_pages}
+        
+        print(f"Translating pages {i+1} to {min(i+batch_size, len(page_names))}...")
+        batch_results = translator.translate_pages_batch(
+            batch_texts, 
+            source=source_lang, 
+            target=target_lang
+        )
+        all_results.update(batch_results)
+    
+    return all_results

translator/test_translator.py

@@ -0,0 +1,23 @@
+import pytest
+from translator import MangaTranslator
+
+
+JA_TEXT = "こんばんわ!"
+EN_TRANSLATION = "good evening!"
+
+
+@pytest.fixture
+def translator():
+    return MangaTranslator()
+
+
+@pytest.mark.parametrize("method", ["google", "hf", "baidu", "bing"])
+def test_translate(translator, method):
+    translated_text = translator.translate(JA_TEXT, method=method)
+    assert translated_text.lower() == EN_TRANSLATION
+
+
+def test_invalid_translation_method(translator):
+    with pytest.raises(ValueError) as e:
+        translator.translate(JA_TEXT, method="Mirai")
+    assert str(e.value) == "Invalid translation method."

translator/translator.py

@@ -0,0 +1,172 @@
+from deep_translator import GoogleTranslator
+from transformers import pipeline, AutoModelForSeq2SeqLM, AutoTokenizer
+import translators as ts
+import torch
+
+
+class MangaTranslator:
+    # NLLB language codes mapping
+    NLLB_LANG_CODES = {
+        "ja": "jpn_Jpan",  # Japanese
+        "en": "eng_Latn",  # English
+        "vi": "vie_Latn",  # Vietnamese
+        "zh": "zho_Hans",  # Chinese Simplified
+        "ko": "kor_Hang",  # Korean
+        "th": "tha_Thai",  # Thai
+        "id": "ind_Latn",  # Indonesian
+        "fr": "fra_Latn",  # French
+        "de": "deu_Latn",  # German
+        "es": "spa_Latn",  # Spanish
+        "ru": "rus_Cyrl",  # Russian
+    }
+    
+    def __init__(self, source="ja", target="en", gemini_api_key=None):
+        self.target = target
+        self.source = source
+        self.gemini_api_key = gemini_api_key
+        self.translators = {
+            "google": self._translate_with_google,
+            "hf": self._translate_with_hf,
+            "baidu": self._translate_with_baidu,
+            "bing": self._translate_with_bing,
+            "nllb": self._translate_with_nllb,
+            "gemini": self._translate_with_gemini
+        }
+        # Lazy loading for heavy models
+        self._nllb_model = None
+        self._nllb_tokenizer = None
+        self._gemini_translator = None
+
+    def set_languages(self, source=None, target=None):
+        """Update source and/or target languages."""
+        if source:
+            self.source = source
+        if target:
+            self.target = target
+
+    def translate(self, text, method="google"):
+        """
+        Translates the given text to the target language using the specified method.
+
+        Args:
+            text (str): The text to be translated.
+            method (str):"google" for Google Translator, 
+                         "hf" for Helsinki-NLP's opus-mt-ja-en model (HF pipeline)
+                         "baidu" for Baidu Translate
+                         "bing" for Microsoft Bing Translator
+                         "nllb" for Meta's NLLB-200 model (offline, 200+ languages)
+
+        Returns:
+            str: The translated text.
+        """
+        translator_func = self.translators.get(method)
+        
+        if translator_func:
+            return translator_func(self._preprocess_text(text))
+        else:
+            raise ValueError("Invalid translation method.")
+            
+    def _translate_with_google(self, text):
+        translator = GoogleTranslator(source=self.source, target=self.target)
+        translated_text = translator.translate(text)
+        return translated_text if translated_text is not None else text
+
+    def _translate_with_hf(self, text):
+        # Lazy load HF pipeline (cache it like NLLB)
+        if not hasattr(self, '_hf_pipeline') or self._hf_pipeline is None:
+            print("Loading HuggingFace translation model (first time)...")
+            self._hf_pipeline = pipeline("translation", model="Helsinki-NLP/opus-mt-ja-en")
+            print("HF pipeline loaded and cached!")
+        
+        translated_text = self._hf_pipeline(text)[0]["translation_text"]
+        return translated_text if translated_text is not None else text
+
+    def _translate_with_baidu(self, text):
+        translated_text = ts.translate_text(text, translator="baidu",
+                                            from_language="jp", 
+                                            to_language=self.target)
+        return translated_text if translated_text is not None else text
+
+    def _translate_with_bing(self, text):
+        translated_text = ts.translate_text(text, translator="bing",
+                                            from_language=self.source, 
+                                            to_language=self.target)
+        return translated_text if translated_text is not None else text
+
+    def _load_nllb_model(self):
+        """Lazy load NLLB model only when first needed (saves memory)"""
+        if self._nllb_model is None:
+            print("Loading NLLB model (first time, may take a moment)...")
+            model_name = "facebook/nllb-200-distilled-600M"
+            self._nllb_tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self._nllb_model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+            # Force CPU for stability
+            self._nllb_model = self._nllb_model.to("cpu")
+            self._nllb_model.eval()
+            print("NLLB model loaded successfully!")
+
+    def _translate_with_nllb(self, text):
+        """
+        Translate using Meta's NLLB-200 model.
+        Supports 200+ languages, works offline, optimized for CPU.
+        """
+        try:
+            self._load_nllb_model()
+            
+            # Get NLLB language codes
+            src_lang = self.NLLB_LANG_CODES.get(self.source, "jpn_Jpan")
+            tgt_lang = self.NLLB_LANG_CODES.get(self.target, "eng_Latn")
+            
+            # Set source language
+            self._nllb_tokenizer.src_lang = src_lang
+            
+            # Tokenize
+            inputs = self._nllb_tokenizer(text, return_tensors="pt", padding=True)
+            
+            # Generate translation
+            with torch.no_grad():
+                translated_tokens = self._nllb_model.generate(
+                    **inputs,
+                    forced_bos_token_id=self._nllb_tokenizer.convert_tokens_to_ids(tgt_lang),
+                    max_length=256
+                )
+            
+            # Decode
+            translated_text = self._nllb_tokenizer.batch_decode(
+                translated_tokens, skip_special_tokens=True
+            )[0]
+            
+            return translated_text if translated_text else text
+            
+        except Exception as e:
+            print(f"NLLB translation error: {e}")
+            return text
+
+    def _translate_with_gemini(self, text):
+        """
+        Translate using Google Gemini 2.5 Flash-Lite.
+        For batch processing, use GeminiTranslator directly.
+        """
+        try:
+            if self._gemini_translator is None:
+                from .gemini_translator import GeminiTranslator
+                api_key = self.gemini_api_key or "AIzaSyAplFKOKBEcQku5m6gPEBMlZMGc4sI5rgo"
+                custom_prompt = getattr(self, '_gemini_custom_prompt', None)
+                self._gemini_translator = GeminiTranslator(
+                    api_key=api_key, 
+                    custom_prompt=custom_prompt
+                )
+                print(f"Gemini translator initialized! (source={self.source}, target={self.target})")
+            
+            return self._gemini_translator.translate_single(
+                text, 
+                source=self.source, 
+                target=self.target
+            )
+        except Exception as e:
+            print(f"Gemini translation error: {e}")
+            return text
+
+    def _preprocess_text(self, text):
+        preprocessed_text = text.replace("．", ".")
+        return preprocessed_text