webtoonmtl 0.1.0__tar.gz

webtoonmtl-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.3
+Name: webtoonmtl
+Version: 0.1.0
+Summary: Webtoon machine translation application.
+Author: jyyhuang
+Author-email: jyyhuang <jyyhuanggit@gmail.com>
+Requires-Dist: appdirs>=1.4.4
+Requires-Dist: easyocr>=1.7.2
+Requires-Dist: pyqt6>=6.10.2
+Requires-Dist: sentencepiece>=0.2.1
+Requires-Dist: timm>=1.0.24
+Requires-Dist: torch>=2.10.0
+Requires-Dist: transformers>=5.0.0
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# Webtoon MTL
+
+A Python application for extracting and translating Korean text from webtoon images using OCR and neural machine translation.
+
+## Project Status
+
+Still under development, expect breaking changes
+
+## Table of Contents
+
+- [Webtoon MTL](#webtoon-mtl)
+  - [Table of Contents](#table-of-contents)
+  - [Demo](#demo)
+  - [Background](#background)
+  - [Features](#features)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Roadmap](#roadmap)
+  - [License](#license)
+
+## Demo
+https://github.com/user-attachments/assets/6e52bf87-991e-4488-935f-eeeb72c1f76a  
+
+## Background
+
+After years of reading webtoons and manhwa, I repeatedly ran into the same frustration of reaching the latest available chapter in English, only to find that newer chapters exist only in Korean. While fan translations eventually appear, they are often delayed or incomplete.
+
+With recent advances in optical character recognition (OCR) and neural machine translation (NMT), I decided it was finally time to address this problem myself. This project is personal, but feel free to use it too!
+
+## Features
+
+- **Simple GUI**: Desktop gui with PyQT6
+- **OCR Extraction**: Extract Korean text from images using EasyOCR
+- **Neural Translation**: Translate Korean to English using transformer models
+- **Model Training**: Fine-tune translation models on Korean-English datasets
+
+## Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/jyyhuang/webtoonmtl.git
+cd webtoonmtl
+```
+
+2. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+```
+webtoonmtl start
+```
+
+## Roadmap
+
+- ✅ Extract text from images using OCR
+- ✅ Use transformer to translate Korean text
+- ✅ Add support for fine-tuning the translation model
+- ✅ Create command line usage
+- ✅ Desktop GUI with PyQT
+- ⬜ Add better testing
+- ⬜ Cache OCR, model, and translations
+- ⬜ Improve logging, error handling, and progress reports
+- ⬜ Package as a pip library
+
+## License
+
+See LICENSE file for details.

webtoonmtl-0.1.0/README.md

@@ -0,0 +1,72 @@
+# Webtoon MTL
+
+A Python application for extracting and translating Korean text from webtoon images using OCR and neural machine translation.
+
+## Project Status
+
+Still under development, expect breaking changes
+
+## Table of Contents
+
+- [Webtoon MTL](#webtoon-mtl)
+  - [Table of Contents](#table-of-contents)
+  - [Demo](#demo)
+  - [Background](#background)
+  - [Features](#features)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Roadmap](#roadmap)
+  - [License](#license)
+
+## Demo
+https://github.com/user-attachments/assets/6e52bf87-991e-4488-935f-eeeb72c1f76a  
+
+## Background
+
+After years of reading webtoons and manhwa, I repeatedly ran into the same frustration of reaching the latest available chapter in English, only to find that newer chapters exist only in Korean. While fan translations eventually appear, they are often delayed or incomplete.
+
+With recent advances in optical character recognition (OCR) and neural machine translation (NMT), I decided it was finally time to address this problem myself. This project is personal, but feel free to use it too!
+
+## Features
+
+- **Simple GUI**: Desktop gui with PyQT6
+- **OCR Extraction**: Extract Korean text from images using EasyOCR
+- **Neural Translation**: Translate Korean to English using transformer models
+- **Model Training**: Fine-tune translation models on Korean-English datasets
+
+## Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/jyyhuang/webtoonmtl.git
+cd webtoonmtl
+```
+
+2. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+```
+webtoonmtl start
+```
+
+## Roadmap
+
+- ✅ Extract text from images using OCR
+- ✅ Use transformer to translate Korean text
+- ✅ Add support for fine-tuning the translation model
+- ✅ Create command line usage
+- ✅ Desktop GUI with PyQT
+- ⬜ Add better testing
+- ⬜ Cache OCR, model, and translations
+- ⬜ Improve logging, error handling, and progress reports
+- ⬜ Package as a pip library
+
+## License
+
+See LICENSE file for details.

webtoonmtl-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "webtoonmtl"
+version = "0.1.0"
+description = "Webtoon machine translation application."
+readme = "README.md"
+authors = [
+    { name = "jyyhuang", email = "jyyhuanggit@gmail.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "appdirs>=1.4.4",
+    "easyocr>=1.7.2",
+    "pyqt6>=6.10.2",
+    "sentencepiece>=0.2.1",
+    "timm>=1.0.24",
+    "torch>=2.10.0",
+    "transformers>=5.0.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.26,<0.10.0"]
+build-backend = "uv_build"
+
+[project.scripts]
+webtoonmtl = "webtoonmtl.cli:cli"

webtoonmtl-0.1.0/src/webtoonmtl/__init__.py

@@ -0,0 +1,4 @@
+from .core.mtlcore import MtlCore
+from .core.translator import KoreanTranslator, TranslationConfig
+
+__all__ = ["MtlCore", "KoreanTranslator", "TranslationConfig"]

webtoonmtl-0.1.0/src/webtoonmtl/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    from webtoonmtl.cli import cli
+
+    cli()

webtoonmtl-0.1.0/src/webtoonmtl/_utils/logger.py

@@ -0,0 +1,98 @@
+import datetime as dt
+import json
+import logging
+from typing import override
+
+import appdirs
+import atexit
+import logging.config
+import pathlib
+
+LOG_RECORD_BUILTIN_ATTRS = {
+    "args",
+    "asctime",
+    "created",
+    "exc_info",
+    "exc_text",
+    "filename",
+    "funcName",
+    "levelname",
+    "levelno",
+    "lineno",
+    "module",
+    "msecs",
+    "message",
+    "msg",
+    "name",
+    "pathname",
+    "process",
+    "processName",
+    "relativeCreated",
+    "stack_info",
+    "thread",
+    "threadName",
+    "taskName",
+}
+
+
+class JSONFormatter(logging.Formatter):
+    def __init__(self, *, fmt_keys: dict[str, str] | None = None):
+        super().__init__()
+        self.fmt_keys = fmt_keys if fmt_keys is not None else {}
+
+    @override
+    def format(self, record: logging.LogRecord) -> str:
+        message = self._make_log_dict(record)
+        return json.dumps(message, default=str)
+
+    def _make_log_dict(self, record: logging.LogRecord):
+        always = {
+            "message": record.getMessage(),
+            "timestamp": dt.datetime.fromtimestamp(
+                record.created, tz=dt.timezone.utc
+            ).isoformat(),
+        }
+
+        if record.exc_info is not None:
+            always["exc_info"] = self.formatException(record.exc_info)
+        if record.stack_info is not None:
+            always["stack_info"] = self.formatStack(record.stack_info)
+        message = {
+            key: (
+                msg_val
+                if (msg_val := always.pop(val, None)) is not None
+                else getattr(record, val)
+            )
+            for key, val in self.fmt_keys.items()
+        }
+        message.update(always)
+        for key, val in record.__dict__.items():
+            if key not in LOG_RECORD_BUILTIN_ATTRS:
+                message[key] = val
+
+        return message
+
+
+class StdoutFilter(logging.Filter):
+    @override
+    def filter(self, record: logging.LogRecord) -> bool | logging.LogRecord:
+        return record.levelno <= logging.INFO
+
+
+def setup_logging():
+    config_file = pathlib.Path(__file__).resolve().parent / "logging_config.json"
+
+    log_dir = pathlib.Path(appdirs.user_log_dir("webtoonmtl"))
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    with open(config_file) as file:
+        config = json.load(file)
+
+    config["handlers"]["json_file"]["filename"] = str(log_dir / "webtoonmtl.log.jsonl")
+
+    logging.config.dictConfig(config)
+
+    queue_handler = logging.getHandlerByName("queue_handler")
+    if queue_handler is not None:
+        queue_handler.listener.start()
+        atexit.register(queue_handler.listener.stop)

webtoonmtl-0.1.0/src/webtoonmtl/_utils/logging_config.json

@@ -0,0 +1,61 @@
+{
+  "version": 1,
+  "disable_existing_loggers": false,
+  "formatters": {
+    "simple": {
+      "format": "%(asctime)s [%(levelname)s] %(module)s: %(message)s",
+      "datefmt": "%Y-%m-%dT%H:%M:%S%z"
+    },
+    "json": {
+      "()": "webtoonmtl._utils.logger.JSONFormatter",
+      "fmt_keys": {
+        "level": "levelname",
+        "message": "message",
+        "timestamp": "timestamp",
+        "logger": "name",
+        "module": "module",
+        "function": "funcName",
+        "line": "lineno",
+        "thread_name": "threadName"
+      }
+    }
+  },
+  "filters": {
+    "stdout_filter": {
+      "()": "webtoonmtl._utils.logger.StdoutFilter"
+    }
+  },
+  "handlers": {
+    "stdout": {
+      "class": "logging.StreamHandler",
+      "level": "DEBUG",
+      "filters": ["stdout_filter"],
+      "formatter": "simple",
+      "stream": "ext://sys.stdout"
+    },
+    "stderr": {
+      "class": "logging.StreamHandler",
+      "level": "WARNING",
+      "formatter": "simple",
+      "stream": "ext://sys.stderr"
+    },
+    "json_file": {
+      "class": "logging.handlers.RotatingFileHandler",
+      "level": "DEBUG",
+      "formatter": "json",
+      "maxBytes": 10000,
+      "backupCount": 3
+    },
+    "queue_handler": {
+      "class": "logging.handlers.QueueHandler",
+      "handlers": ["stderr", "json_file"],
+      "respect_handler_level": true
+    }
+  },
+  "loggers": {
+    "root": {
+      "level": "DEBUG",
+      "handlers": ["queue_handler"]
+    }
+  }
+}

webtoonmtl-0.1.0/src/webtoonmtl/_utils/trainer.py

@@ -0,0 +1,244 @@
+#!pip install evaluate
+#!pip install torch
+#!pip install datasets
+#!pip install transformers
+#!pip install sacrebleu
+#!pip install sacremoses
+
+import inspect
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import numpy as np
+import evaluate
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    DataCollatorForSeq2Seq,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+)
+
+@dataclass
+class TrainingConfig:
+    model_name: str = "Helsinki-NLP/opus-mt-ko-en"
+    dataset_name: str = "lemon-mint/Korean-FineTome-100k"
+    max_length: int = 128
+
+    output_dir: Path = Path("~/.webtoonmtl/model").expanduser().resolve()
+    output_data_dir: Path = Path("~/.webtoonmtl/data").expanduser().resolve()
+    gradient_checkpointing: bool = True
+    per_device_train_batch_size: int = 16
+    per_device_eval_batch_size: int = 16
+    learning_rate: float = 2e-5
+    warmup_steps: int = 100
+    num_train_epochs: int = 5
+    optim: str = "adamw_torch"
+    metric_for_best_model: str = "bleu"
+    fp16: bool = True
+    predict_with_generate: bool = True
+    eval_strategy: str = "steps"
+    eval_steps: int = 500
+    save_strategy: str = "steps"
+    save_steps: int = 500
+    logging_steps: int = 100
+    save_total_limit: int = 3
+    load_best_model_at_end: bool = True
+    push_to_hub: bool = False
+
+
+def load_model(model_name: str, gradient_checkpointing: bool = True):
+    """
+    Load tokenizer and model from HuggingFace.
+
+    Args:
+        model_name: str path to HF base model
+        gradient_checkpointing: whether to enable gradient checkpointing
+
+    Returns:
+        tuple: (tokenizer, model)
+    """
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+
+        if gradient_checkpointing:
+            model.gradient_checkpointing_enable(
+                gradient_checkpointing_kwargs={"use_reentrant": False}
+            )
+
+        return tokenizer, model
+    except Exception as e:
+        raise
+
+
+def tokenize_function(examples, tokenizer, max_length: int = 128):
+    """
+    Tokenize examples for translation.
+
+    Args:
+        examples: batch of examples from dataset
+        tokenizer: tokenizer to use
+        max_length: max sequence length
+
+    Returns:
+        dict: tokenized inputs
+    """
+    inputs, targets = [], []
+
+    for msgs in examples["messages"]:
+        if "content" in msgs[0] and "content_en" in msgs[0]:
+            inputs.append(msgs[0]["content"])
+            targets.append(msgs[0]["content_en"])
+        else:
+            inputs.append("")
+            targets.append("")
+
+    model_inputs = tokenizer(
+        inputs,
+        text_target=targets,
+        max_length=max_length,
+        truncation=True,
+        padding="max_length",
+    )
+
+    return model_inputs
+
+
+def prepare_datasets(dataset_name: str, tokenizer, max_length: int = 128):
+    """
+    Load and tokenize dataset.
+
+    Args:
+        dataset_name: name of dataset to load
+        tokenizer: tokenizer to use
+        max_length: max sequence length
+
+    Returns:
+        tuple: (train_dataset, test_dataset)
+    """
+    dataset = load_dataset(dataset_name, split="train")
+    dataset = dataset.train_test_split(test_size=0.2)
+
+    train_dataset = dataset["train"]
+    test_dataset = dataset["test"]
+
+    tokenized_dataset_train = train_dataset.map(
+        lambda examples: tokenize_function(examples, tokenizer, max_length),
+        batched=True,
+        remove_columns=train_dataset.column_names,
+    )
+
+    tokenized_dataset_test = test_dataset.map(
+        lambda examples: tokenize_function(examples, tokenizer, max_length),
+        batched=True,
+        remove_columns=test_dataset.column_names,
+    )
+
+    return tokenized_dataset_train, tokenized_dataset_test
+
+
+def compute_metrics(eval_preds, tokenizer, bleu_metric, chrf_metric):
+    """
+    Compute BLEU and chrF metrics for evaluation.
+
+    Args:
+        eval_preds: tuple of (predictions, labels)
+        tokenizer: tokenizer for decoding
+        bleu_metric: BLEU metric object
+        chrf_metric: chrF metric object
+
+    Returns:
+        dict: metrics dictionary
+    """
+    preds, labels = eval_preds
+    if isinstance(preds, tuple):
+        preds = preds[0]
+
+    decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
+    labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
+    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
+
+    decoded_preds = [p.strip() for p in decoded_preds]
+    decoded_labels = [[l.strip()] for l in decoded_labels]
+
+    bleu_result = bleu_metric.compute(
+        predictions=decoded_preds, references=decoded_labels
+    )
+    chrf_result = chrf_metric.compute(
+        predictions=decoded_preds, references=decoded_labels
+    )
+
+    return {"bleu": bleu_result["score"], "chrf": chrf_result["score"]}
+
+
+def train(
+    config: TrainingConfig | None = None,
+    resume_from_checkpoint: str | None = None,
+):
+    """
+    Starts the fine-tuning process.
+
+    Args:
+        config: Training configuration
+        resume_from_checkpoint: checkpoint path to resume from
+    """
+    config = config or TrainingConfig()
+
+
+    tokenizer, model = load_model(config.model_name, config.gradient_checkpointing)
+
+    train_dataset, test_dataset = prepare_datasets(
+        config.dataset_name, tokenizer, config.max_length
+    )
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+
+    bleu_metric = evaluate.load("sacrebleu")
+    chrf_metric = evaluate.load("chrf")
+
+    valid_args = inspect.signature(Seq2SeqTrainingArguments).parameters
+
+    trainer_settings = {k: v for k, v in asdict(config).items() if k in valid_args}
+
+    training_args = Seq2SeqTrainingArguments(**trainer_settings)
+
+    data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=model)
+
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=test_dataset,
+        data_collator=data_collator,
+        compute_metrics=lambda eval_preds: compute_metrics(
+            eval_preds, tokenizer, bleu_metric, chrf_metric
+        ),
+        processing_class=tokenizer,
+    )
+
+    try:
+        train_result = trainer.train(resume_from_checkpoint=resume_from_checkpoint)
+
+        output_dir = config.output_dir
+        output_data_dir = config.output_data_dir
+        output_dir.mkdir(parents=True, exist_ok=True)
+        output_data_dir.mkdir(parents=True, exist_ok=True)
+
+        trainer.save_model(str(output_dir))
+
+        metrics = train_result.metrics
+        eval_metrics = trainer.evaluate()
+        metrics.update({k: v for k, v in eval_metrics.items()})
+
+        metrics_path = output_data_dir / "metrics.json"
+        with metrics_path.open("w") as f:
+            json.dump(metrics, f, indent=2)
+
+
+    except Exception as e:
+        raise

webtoonmtl-0.1.0/src/webtoonmtl/cli.py

@@ -0,0 +1,15 @@
+import click
+
+
+@click.group()
+@click.version_option("0.1.0", prog_name="webtoonmtl")
+def cli():
+    """Machine Translations for Korean webtoons to English."""
+
+
+@cli.command()
+def start():
+    """Starts the Webtoon MTL GUI application."""
+    from webtoonmtl.ui import run_gui
+
+    run_gui()