|
|
from openai import OpenAI
|
|
|
import os
|
|
|
from dotenv import load_dotenv
|
|
|
import re
|
|
|
import tkinter as tk
|
|
|
from tkinter import messagebox
|
|
|
import json
|
|
|
import difflib
|
|
|
import time
|
|
|
import logging
|
|
|
from translation_logger import TranslationLogger
|
|
|
from enum import Enum
|
|
|
from text_corrector import TextCorrector, DialogueType
|
|
|
|
|
|
load_dotenv()
|
|
|
|
|
|
|
|
|
class DialogueCache:
|
|
|
def __init__(self):
|
|
|
self.name_history = []
|
|
|
self.last_speaker = None
|
|
|
self.MAX_HISTORY = 5
|
|
|
self.session_speakers = []
|
|
|
self.name_translations = {}
|
|
|
self.speaker_styles = {}
|
|
|
|
|
|
def add_validated_name(self, name):
|
|
|
"""เพิ่มชื่อที่ผ่านการ validate แล้วเท่านั้น"""
|
|
|
if name and name not in self.name_history:
|
|
|
|
|
|
if len(self.name_history) >= self.MAX_HISTORY:
|
|
|
self.name_history.pop(0)
|
|
|
self.name_history.append(name)
|
|
|
self.last_speaker = name
|
|
|
|
|
|
def add_speaker(self, speaker_name, translated_name=None):
|
|
|
"""เพิ่มชื่อผู้พูดพร้อมการแปล (ถ้ามี)"""
|
|
|
if speaker_name:
|
|
|
if speaker_name not in self.session_speakers:
|
|
|
self.session_speakers.append(speaker_name)
|
|
|
if speaker_name not in self.name_history:
|
|
|
self.add_validated_name(speaker_name)
|
|
|
if translated_name:
|
|
|
self.name_translations[speaker_name] = translated_name
|
|
|
|
|
|
def get_speaker_translation(self, speaker_name):
|
|
|
"""ดึงการแปลชื่อที่เคยแปลไว้"""
|
|
|
return self.name_translations.get(speaker_name)
|
|
|
|
|
|
def get_last_speaker(self):
|
|
|
"""ดึงชื่อล่าสุดที่ validate แล้ว"""
|
|
|
return self.last_speaker
|
|
|
|
|
|
def get_recent_names(self):
|
|
|
"""ดึงประวัติชื่อที่ validate แล้ว"""
|
|
|
return self.name_history
|
|
|
|
|
|
def get_speaker_style(self, speaker_name):
|
|
|
"""ดึงรูปแบบการพูดของตัวละคร"""
|
|
|
return self.speaker_styles.get(speaker_name, "")
|
|
|
|
|
|
def clear(self):
|
|
|
"""ล้าง cache"""
|
|
|
self.name_history.clear()
|
|
|
self.last_speaker = None
|
|
|
|
|
|
def clear_session(self):
|
|
|
"""ล้างข้อมูลเซสชั่น"""
|
|
|
self.session_speakers.clear()
|
|
|
self.name_translations.clear()
|
|
|
self.speaker_styles.clear()
|
|
|
self.last_speaker = None
|
|
|
|
|
|
def add_validated_name(self, name):
|
|
|
"""เพิ่มชื่อที่ผ่านการ validate แล้วเท่านั้น"""
|
|
|
if name and name != self.last_speaker:
|
|
|
self.last_speaker = name
|
|
|
if name not in self.name_history:
|
|
|
self.name_history.append(name)
|
|
|
if len(self.name_history) > self.MAX_HISTORY:
|
|
|
self.name_history.pop(0)
|
|
|
|
|
|
def add_speaker(self, speaker_name, translated_name=None):
|
|
|
"""เพิ่มชื่อผู้พูดในเซสชั่น"""
|
|
|
if speaker_name:
|
|
|
if speaker_name not in self.session_speakers:
|
|
|
self.session_speakers.append(speaker_name)
|
|
|
self.last_speaker = speaker_name
|
|
|
if translated_name:
|
|
|
self.name_translations[speaker_name] = translated_name
|
|
|
|
|
|
def get_speaker_translation(self, speaker_name):
|
|
|
"""ดึงการแปลชื่อที่เคยแปลไว้"""
|
|
|
return self.name_translations.get(speaker_name)
|
|
|
|
|
|
def get_last_speaker(self):
|
|
|
"""ดึงชื่อล่าสุดที่ validate แล้ว"""
|
|
|
return self.last_speaker
|
|
|
|
|
|
def get_recent_names(self):
|
|
|
"""ดึงประวัติชื่อที่ validate แล้ว"""
|
|
|
return self.name_history
|
|
|
|
|
|
def get_speaker_style(self, speaker_name):
|
|
|
"""ดึงรูปแบบการพูดของตัวละคร"""
|
|
|
return self.speaker_styles.get(speaker_name, "")
|
|
|
|
|
|
def clear(self):
|
|
|
"""ล้าง cache"""
|
|
|
self.name_history.clear()
|
|
|
self.last_speaker = None
|
|
|
|
|
|
def clear_session(self):
|
|
|
"""ล้างข้อมูลเซสชั่น"""
|
|
|
self.session_speakers.clear()
|
|
|
self.name_translations.clear()
|
|
|
self.speaker_styles.clear()
|
|
|
self.last_speaker = None
|
|
|
|
|
|
|
|
|
class Translator:
|
|
|
def __init__(self, settings=None):
|
|
|
self.api_key = os.getenv("OPENAI_API_KEY")
|
|
|
if not self.api_key:
|
|
|
raise ValueError("OPENAI_API_KEY not found in .env file")
|
|
|
self.client = OpenAI(api_key=self.api_key)
|
|
|
self.translation_logger = TranslationLogger()
|
|
|
|
|
|
|
|
|
if settings:
|
|
|
api_params = settings.get_api_parameters()
|
|
|
self.model = api_params.get("model", "gpt-4o")
|
|
|
self.max_tokens = api_params.get("max_tokens", 500)
|
|
|
self.temperature = api_params.get("temperature", 0.7)
|
|
|
self.top_p = api_params.get("top_p", 0.9)
|
|
|
else:
|
|
|
|
|
|
try:
|
|
|
with open("settings.json", "r") as f:
|
|
|
settings_data = json.load(f)
|
|
|
api_params = settings_data.get("api_parameters", {})
|
|
|
self.model = api_params.get("model", "gpt-4o")
|
|
|
self.max_tokens = api_params.get("max_tokens", 500)
|
|
|
self.temperature = api_params.get("temperature", 0.7)
|
|
|
self.top_p = api_params.get("top_p", 0.9)
|
|
|
except (FileNotFoundError, json.JSONDecodeError):
|
|
|
self.model = "gpt-4o"
|
|
|
self.max_tokens = 500
|
|
|
self.temperature = 0.7
|
|
|
self.top_p = 0.9
|
|
|
logging.warning("Could not load settings.json, using default values")
|
|
|
|
|
|
self.cache = DialogueCache()
|
|
|
self.last_translations = {}
|
|
|
self.character_names_cache = set()
|
|
|
self.text_corrector = TextCorrector()
|
|
|
self.load_npc_data()
|
|
|
self.load_example_translations()
|
|
|
|
|
|
def get_current_parameters(self):
|
|
|
"""Return current translation parameters"""
|
|
|
return {
|
|
|
"model": self.model,
|
|
|
"displayed_model": self.model,
|
|
|
"max_tokens": self.max_tokens,
|
|
|
"temperature": self.temperature,
|
|
|
"top_p": self.top_p,
|
|
|
}
|
|
|
|
|
|
def load_npc_data(self):
|
|
|
try:
|
|
|
with open("NPC.json", "r", encoding="utf-8") as file:
|
|
|
npc_data = json.load(file)
|
|
|
self.character_data = npc_data["main_characters"]
|
|
|
self.context_data = npc_data["lore"]
|
|
|
self.character_styles = npc_data["character_roles"]
|
|
|
|
|
|
|
|
|
self.character_names_cache = set()
|
|
|
self.character_names_cache.add("???")
|
|
|
|
|
|
|
|
|
for char in self.character_data:
|
|
|
self.character_names_cache.add(char["firstName"])
|
|
|
if char["lastName"]:
|
|
|
self.character_names_cache.add(
|
|
|
f"{char['firstName']} {char['lastName']}"
|
|
|
)
|
|
|
|
|
|
|
|
|
for npc in npc_data["npcs"]:
|
|
|
self.character_names_cache.add(npc["name"])
|
|
|
|
|
|
print(
|
|
|
"Translator: Loaded character names:", self.character_names_cache
|
|
|
)
|
|
|
|
|
|
|
|
|
for name, style in self.character_styles.items():
|
|
|
self.cache.speaker_styles[name] = style
|
|
|
|
|
|
|
|
|
if "???" not in self.character_styles:
|
|
|
self.character_styles["???"] = "ใช้ภาษาที่เป็นปริศนา ชวนให้สงสัยในตัวตน"
|
|
|
self.cache.speaker_styles["???"] = self.character_styles["???"]
|
|
|
|
|
|
except FileNotFoundError:
|
|
|
raise FileNotFoundError("NPC.json file not found")
|
|
|
except json.JSONDecodeError:
|
|
|
raise ValueError("Invalid JSON in NPC.json")
|
|
|
|
|
|
def load_example_translations(self):
|
|
|
self.example_translations = {
|
|
|
|
|
|
"'Tis": "ช่างเป็น...",
|
|
|
"'I do": "ฉันเข้าใจ",
|
|
|
"'do": "ฉันเข้าใจ",
|
|
|
"'Twas": "มันเคยเป็น...",
|
|
|
"Nay": "หามิได้",
|
|
|
"Aye": "เป็นเช่นนั้น",
|
|
|
"Mayhaps": "บางที...",
|
|
|
"Hm...": "อืม...",
|
|
|
"Wait!": "เดี๋ยวก่อน!",
|
|
|
"My friend...": "สหายข้า...",
|
|
|
"Tataru?": "Tataru เหรอ?",
|
|
|
"Estinien!": "Estinien!",
|
|
|
"sigh": "เฮ่อ..",
|
|
|
"Hmph.": "ฮึ่ม.",
|
|
|
|
|
|
"Y'shtola: The aetheric fluctuations in this area are most peculiar. We should proceed with caution.": "Y'shtola: ความผันผวนของพลังอีเธอร์แถบนี้... น่าพิศวงยิ่งนัก เราควรก้าวต่อไปด้วยความระมัดระวัง",
|
|
|
"Alphinaud: The political implications of our actions here could be far-reaching. We must consider every possible outcome.": "Alphinaud: นัยทางการเมืองจากการกระทำของพวกเราในครั้งนี้ อาจส่งผลกระทบไปไกล เราต้องนึกถึงทุกความเป็นไปได้อย่างถี่ถ้วน",
|
|
|
"Alisaie: I won't stand idly by while others risk their lives. If we're to face this threat, we do so together.": "Alisaie: ฉันจะไม่ยืนดูดายในขณะที่คนอื่นเสี่ยงชีวิตหรอกนะ ถ้าเราต้องเผชิญหน้ากับภัยคุกคามนี้ เราก็จะสู้ไปด้วยกันนี่แหล่ะ!",
|
|
|
"Urianger: Pray, let us contemplate the implications of our recent discoveries. The path ahead may yet be fraught with unforeseen perils.": "Urianger: ข้าขอวิงวอน ให้พวกเราใคร่ครวญถึงนัยสำคัญแห่งการค้นพบล่าสุดของพวกเรา หนทางเบื้องหน้าอาจเต็มไปด้วยภยันตรายอันมิอาจคาดเดา",
|
|
|
"Thancred: Sometimes, you have to take risks. Calculated risks, mind you. But risks all the same.": "Thancred: บางครั้งเราก็ต้องเสี่ยงบ้างล่ะนะ เสี่ยงแบบคำนวณแล้วน่ะ แต่ก็ยังเป็นการเสี่ยงอยู่ดี",
|
|
|
}
|
|
|
|
|
|
def update_parameters(
|
|
|
self, model=None, max_tokens=None, temperature=None, top_p=None, **kwargs
|
|
|
):
|
|
|
"""อัพเดทค่าพารามิเตอร์สำหรับการแปล"""
|
|
|
try:
|
|
|
old_params = {
|
|
|
"model": self.model,
|
|
|
"max_tokens": self.max_tokens,
|
|
|
"temperature": self.temperature,
|
|
|
"top_p": self.top_p,
|
|
|
}
|
|
|
|
|
|
changes = []
|
|
|
|
|
|
if model is not None:
|
|
|
valid_models = ["gpt-4o", "gpt-4o-mini"]
|
|
|
if model not in valid_models:
|
|
|
raise ValueError(
|
|
|
f"Invalid model for GPT translator. Must be one of: {', '.join(valid_models)}"
|
|
|
)
|
|
|
self.model = model
|
|
|
changes.append(f"Model: {old_params['model']} -> {model}")
|
|
|
|
|
|
if max_tokens is not None:
|
|
|
if not (100 <= max_tokens <= 1000):
|
|
|
raise ValueError(
|
|
|
f"Max tokens must be between 100 and 1000, got {max_tokens}"
|
|
|
)
|
|
|
self.max_tokens = max_tokens
|
|
|
changes.append(
|
|
|
f"Max tokens: {old_params['max_tokens']} -> {max_tokens}"
|
|
|
)
|
|
|
|
|
|
if temperature is not None:
|
|
|
if not (0.5 <= temperature <= 0.9):
|
|
|
raise ValueError(
|
|
|
f"Temperature must be between 0.5 and 0.9, got {temperature}"
|
|
|
)
|
|
|
self.temperature = temperature
|
|
|
changes.append(
|
|
|
f"Temperature: {old_params['temperature']} -> {temperature}"
|
|
|
)
|
|
|
|
|
|
if top_p is not None:
|
|
|
if not (0.5 <= top_p <= 0.9):
|
|
|
raise ValueError(f"Top P must be between 0.5 and 0.9, got {top_p}")
|
|
|
self.top_p = top_p
|
|
|
changes.append(f"Top P: {old_params['top_p']} -> {top_p}")
|
|
|
|
|
|
if changes:
|
|
|
print("\n=== GPT Parameters Updated ===")
|
|
|
for change in changes:
|
|
|
print(change)
|
|
|
print(f"Current model: {self.model}")
|
|
|
print("==========================\n")
|
|
|
|
|
|
return True, None
|
|
|
|
|
|
except ValueError as e:
|
|
|
print(f"[GPT] Parameter update failed: {str(e)}")
|
|
|
return False, str(e)
|
|
|
|
|
|
def translate(
|
|
|
self, text, source_lang="English", target_lang="Thai", is_choice_option=False
|
|
|
):
|
|
|
"""
|
|
|
แปลข้อความพร้อมจัดการบริบทของตัวละคร
|
|
|
Args:
|
|
|
text: ข้อความที่ต้องการแปล
|
|
|
source_lang: ภาษาต้นฉบับ (default: English)
|
|
|
target_lang: ภาษาเป้าหมาย (default: Thai)
|
|
|
is_choice_option: เป็นข้อความตัวเลือกหรือไม่ (default: False)
|
|
|
Returns:
|
|
|
str: ข้อความที่แปลแล้ว
|
|
|
"""
|
|
|
try:
|
|
|
if not text:
|
|
|
logging.warning("Empty text received for translation")
|
|
|
return ""
|
|
|
|
|
|
|
|
|
speaker, content, dialogue_type = (
|
|
|
self.text_corrector.split_speaker_and_content(text)
|
|
|
)
|
|
|
|
|
|
|
|
|
if text.strip() in ["22", "22?", "222", "222?"]:
|
|
|
return "???"
|
|
|
|
|
|
|
|
|
if text.strip() in ["222", "222?", "???"]:
|
|
|
return "???"
|
|
|
|
|
|
|
|
|
if not is_choice_option:
|
|
|
is_choice, prompt_part, choices = self.is_similar_to_choice_prompt(text)
|
|
|
if is_choice:
|
|
|
return self.translate_choice(text)
|
|
|
|
|
|
|
|
|
if dialogue_type == DialogueType.CHARACTER and speaker:
|
|
|
|
|
|
if speaker.startswith("?"):
|
|
|
speaker = "???"
|
|
|
|
|
|
character_name = speaker
|
|
|
dialogue = content
|
|
|
|
|
|
|
|
|
if (
|
|
|
dialogue in self.last_translations
|
|
|
and character_name == self.cache.get_last_speaker()
|
|
|
):
|
|
|
translated_dialogue = self.last_translations[dialogue]
|
|
|
return f"{character_name}: {translated_dialogue}"
|
|
|
|
|
|
|
|
|
character_info = self.get_character_info(character_name)
|
|
|
context = ""
|
|
|
if character_info:
|
|
|
context = (
|
|
|
f"Character: {character_info['firstName']}, "
|
|
|
f"Gender: {character_info['gender']}, "
|
|
|
f"Role: {character_info['role']}, "
|
|
|
f"Relationship: {character_info['relationship']}"
|
|
|
)
|
|
|
elif character_name == "???":
|
|
|
context = "Character: Unknown, Role: Mystery character"
|
|
|
|
|
|
|
|
|
character_style = self.character_styles.get(character_name, "")
|
|
|
if not character_style and character_name == "???":
|
|
|
character_style = (
|
|
|
"ใช้ภาษาที่เป็นปริศนา ชวนให้สงสัยในตัวตน แต่ยังคงบุคลิกที่น่าสนใจ"
|
|
|
)
|
|
|
|
|
|
self.cache.add_speaker(character_name)
|
|
|
|
|
|
else:
|
|
|
|
|
|
dialogue = text
|
|
|
character_name = ""
|
|
|
context = ""
|
|
|
character_style = ""
|
|
|
|
|
|
|
|
|
special_terms = self.context_data.copy()
|
|
|
example_prompt = "Here are examples of good translations:\\n\\n"
|
|
|
for eng, thai in self.example_translations.items():
|
|
|
example_prompt += f"English: {eng}\\nThai: {thai}\\n\\n"
|
|
|
|
|
|
prompt = (
|
|
|
"You are a professional translator specializing in video game localization for Final Fantasy XIV. "
|
|
|
"Your task is to translate English game text to Thai with these requirements:\\n"
|
|
|
"1. Translate the text naturally while preserving the character's tone and style\\n"
|
|
|
"2. Keep proper nouns and character names in English\\n"
|
|
|
"3. For very short text, treat it as either: phrase, exclamation, or name calling only\\n"
|
|
|
"4. If the text contains unclear parts, translate what you can understand and mark unclear parts with [...]\\n"
|
|
|
"5. Maintain character speech patterns and emotional expressions\\n"
|
|
|
"6. Use ellipsis (...) or em dash (—) for pauses as in the original\\n"
|
|
|
"7. Avoid polite particles unless part of character's style\\n"
|
|
|
"8. Focus on natural, conversational Thai that matches the game context\\n"
|
|
|
f"Context: {context}\\n"
|
|
|
f"Character's style: {character_style}\\n"
|
|
|
f"Do not translate: {', '.join(self.character_names_cache)}\\n\\n"
|
|
|
"Special terms:\\n"
|
|
|
)
|
|
|
|
|
|
for term, explanation in special_terms.items():
|
|
|
prompt += f"{term}: {explanation}\\n"
|
|
|
prompt += f"\\n{example_prompt}\\nText to translate: {dialogue}"
|
|
|
|
|
|
try:
|
|
|
response = self.client.chat.completions.create(
|
|
|
model=self.model,
|
|
|
messages=[
|
|
|
{"role": "system", "content": prompt},
|
|
|
{"role": "user", "content": dialogue},
|
|
|
],
|
|
|
max_tokens=self.max_tokens,
|
|
|
temperature=self.temperature,
|
|
|
top_p=self.top_p,
|
|
|
)
|
|
|
translated_dialogue = response.choices[0].message.content.strip()
|
|
|
|
|
|
|
|
|
try:
|
|
|
self.translation_logger.log_translation(text, translated_dialogue)
|
|
|
except Exception as e:
|
|
|
logging.error(f"Error logging translation: {e}")
|
|
|
|
|
|
|
|
|
translated_dialogue = re.sub(
|
|
|
r"\b(ครับ|ค่ะ|ครับ/ค่ะ)\b", "", translated_dialogue
|
|
|
).strip()
|
|
|
for term in special_terms:
|
|
|
translated_dialogue = re.sub(
|
|
|
r"\b" + re.escape(term) + r"\b",
|
|
|
term,
|
|
|
translated_dialogue,
|
|
|
flags=re.IGNORECASE,
|
|
|
)
|
|
|
|
|
|
|
|
|
self.last_translations[dialogue] = translated_dialogue
|
|
|
|
|
|
if character_name:
|
|
|
self.cache.add_validated_name(character_name)
|
|
|
return f"{character_name}: {translated_dialogue}"
|
|
|
return translated_dialogue
|
|
|
|
|
|
except ValueError as e:
|
|
|
logging.error(f"Error in is_similar_to_choice_prompt: {str(e)}")
|
|
|
return self.translate_choice(text)
|
|
|
|
|
|
except Exception as e:
|
|
|
logging.error(f"Unexpected error in translation: {str(e)}")
|
|
|
return f"[Error: {str(e)}]"
|
|
|
|
|
|
def is_similar_to_choice_prompt(self, text, threshold=0.8):
|
|
|
"""
|
|
|
ตรวจสอบและแยกส่วนประกอบของ choice dialogue
|
|
|
Returns:
|
|
|
tuple: (is_choice, prompt_part, choices)
|
|
|
"""
|
|
|
try:
|
|
|
|
|
|
if not text or len(text) < 10:
|
|
|
return False, None, []
|
|
|
|
|
|
|
|
|
choice_headers = [
|
|
|
"What will you say?",
|
|
|
"What will you do?",
|
|
|
"Select an option.",
|
|
|
"Choose your response.",
|
|
|
]
|
|
|
|
|
|
|
|
|
if not any(header.lower() in text.lower() for header in choice_headers):
|
|
|
return False, None, []
|
|
|
|
|
|
|
|
|
header = "What will you say?"
|
|
|
remaining_text = text.replace(header, "").strip()
|
|
|
|
|
|
|
|
|
common_starts = [
|
|
|
"I suppose",
|
|
|
"I think",
|
|
|
"I will",
|
|
|
"I'll",
|
|
|
"I can",
|
|
|
"We should",
|
|
|
"We can",
|
|
|
"We will",
|
|
|
"We'll",
|
|
|
"Yes",
|
|
|
"No",
|
|
|
"Perhaps",
|
|
|
"Maybe",
|
|
|
"The ",
|
|
|
"But ",
|
|
|
"So ",
|
|
|
"You ",
|
|
|
"Let's",
|
|
|
"Please",
|
|
|
"Thank",
|
|
|
"Very",
|
|
|
]
|
|
|
|
|
|
|
|
|
choices = [c.strip() for c in re.split("[!.]", remaining_text) if c.strip()]
|
|
|
|
|
|
|
|
|
if len(choices) <= 1:
|
|
|
temp_text = remaining_text
|
|
|
choices = []
|
|
|
|
|
|
for start in common_starts:
|
|
|
if start in temp_text:
|
|
|
parts = temp_text.split(start)
|
|
|
if parts[0]:
|
|
|
choices.append(parts[0].strip())
|
|
|
temp_text = start + parts[1]
|
|
|
|
|
|
if temp_text:
|
|
|
choices.append(temp_text.strip())
|
|
|
|
|
|
|
|
|
if choices:
|
|
|
return True, header, choices
|
|
|
|
|
|
return False, None, []
|
|
|
|
|
|
except Exception as e:
|
|
|
logging.error(f"Error in is_similar_to_choice_prompt: {str(e)}")
|
|
|
return False, None, []
|
|
|
|
|
|
def translate_choice(self, text):
|
|
|
"""แปลข้อความตัวเลือกของผู้เล่น
|
|
|
Args:
|
|
|
text: ข้อความที่จะแปล เช่น "What will you say?\nOption 1\nOption 2"
|
|
|
Returns:
|
|
|
str: ข้อความที่แปลแล้ว เช่น "คุณจะพูดว่าอย่างไร?\nตัวเลือก 1\nตัวเลือก 2"
|
|
|
"""
|
|
|
try:
|
|
|
|
|
|
is_choice, header, choices = self.is_similar_to_choice_prompt(text)
|
|
|
|
|
|
if is_choice:
|
|
|
|
|
|
translated_header = "คุณจะพูดว่าอย่างไร?"
|
|
|
translated_choices = []
|
|
|
|
|
|
|
|
|
for choice in choices:
|
|
|
choice = choice.strip()
|
|
|
if not choice:
|
|
|
continue
|
|
|
|
|
|
|
|
|
translated_choice = self.translate(choice, is_choice_option=True)
|
|
|
if translated_choice:
|
|
|
|
|
|
if translated_choice != translated_header:
|
|
|
translated_choices.append(translated_choice)
|
|
|
|
|
|
|
|
|
if translated_choices:
|
|
|
|
|
|
result = f"{translated_header}\n" + "\n".join(translated_choices)
|
|
|
logging.debug(f"Choice translation result: {result}")
|
|
|
return result
|
|
|
|
|
|
|
|
|
return translated_header
|
|
|
|
|
|
|
|
|
return self.translate(text)
|
|
|
|
|
|
except Exception as e:
|
|
|
logging.error(f"Error in translating choices: {str(e)}")
|
|
|
return f"[Error in choice translation: {str(e)}]"
|
|
|
|
|
|
def get_character_info(self, character_name):
|
|
|
if character_name == "???":
|
|
|
return {
|
|
|
"firstName": "???",
|
|
|
"gender": "unknown",
|
|
|
"role": "Mystery character",
|
|
|
"relationship": "Unknown/Mysterious",
|
|
|
"pronouns": {"subject": "ฉัน", "object": "ฉัน", "possessive": "ของฉัน"},
|
|
|
}
|
|
|
for char in self.character_data:
|
|
|
if (
|
|
|
character_name == char["firstName"]
|
|
|
or character_name == f"{char['firstName']} {char['lastName']}".strip()
|
|
|
):
|
|
|
return char
|
|
|
return None
|
|
|
|
|
|
def batch_translate(self, texts, batch_size=10):
|
|
|
"""แปลข้อความเป็นชุด"""
|
|
|
translated_texts = []
|
|
|
for i in range(0, len(texts), batch_size):
|
|
|
batch = texts[i : i + batch_size]
|
|
|
translated_batch = [self.translate(text) for text in batch]
|
|
|
translated_texts.extend(translated_batch)
|
|
|
return translated_texts
|
|
|
|
|
|
def analyze_translation_quality(self, original_text, translated_text):
|
|
|
"""วิเคราะห์คุณภาพการแปล"""
|
|
|
prompt = (
|
|
|
"As a translation quality assessor, evaluate the following translation from English to Thai. "
|
|
|
"Consider factors such as accuracy, naturalness, and preservation of the original tone and style. "
|
|
|
f"Original (English): {original_text}\n"
|
|
|
f"Translation (Thai): {translated_text}\n"
|
|
|
"Provide a brief assessment and a score out of 10."
|
|
|
)
|
|
|
|
|
|
try:
|
|
|
|
|
|
response = self.client.chat.completions.create(
|
|
|
model=self.model,
|
|
|
messages=[
|
|
|
{"role": "system", "content": prompt},
|
|
|
{"role": "user", "content": "Assess the translation quality."},
|
|
|
],
|
|
|
max_tokens=200,
|
|
|
)
|
|
|
return response.choices[0].message.content.strip()
|
|
|
except Exception as e:
|
|
|
logging.error(f"Error in translation quality analysis: {str(e)}")
|
|
|
return "Unable to assess translation quality due to an error."
|
|
|
|
|
|
def reload_data(self):
|
|
|
"""โหลดข้อมูลใหม่และล้าง cache"""
|
|
|
print("Translator: Reloading NPC data...")
|
|
|
self.load_npc_data()
|
|
|
self.load_example_translations()
|
|
|
self.cache.clear_session()
|
|
|
self.last_translations.clear()
|
|
|
print("Translator: Data reloaded successfully")
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
try:
|
|
|
translator = Translator()
|
|
|
|
|
|
|
|
|
test_cases = [
|
|
|
"Y'shtola: The aetheric fluctuations in this area are most peculiar.",
|
|
|
"Y'shtola: We should proceed with caution.",
|
|
|
"???: Who goes there?",
|
|
|
"What will you say?\nYes, of course.\nI'm not sure about this.",
|
|
|
"The wind howls through the ancient ruins.",
|
|
|
]
|
|
|
|
|
|
print("=== Translation Test Cases ===")
|
|
|
for text in test_cases:
|
|
|
translated = translator.translate(text)
|
|
|
print(f"\nOriginal: {text}")
|
|
|
print(f"Translation: {translated}")
|
|
|
|
|
|
except ValueError as e:
|
|
|
print(f"Error: {e}")
|
|
|
|
