Paano Namin Ginamit ang OpenAI API upang Isalin ang Aming Website
- Mga Artikulo, Mga Kwento
- Hugo , OpenAI , Pagsasalin , Awtomasyon
- March 19, 2025
- 10 min read
Panimula
Nang kami ay nagpasya na gawing multilingual ang aming website na batay sa GoHugo.io, nais naming magkaroon ng isang mahusay, scalable, at cost-effective na paraan upang makabuo ng mga pagsasalin. Sa halip na mano-manong isalin ang bawat pahina, ginamit namin ang OpenAI’s API upang awtomatiko ang proseso. Ang artikulong ito ay naglalakad sa kung paano namin isinama ang OpenAI API sa Hugo, gamit ang tema ng HugoPlate mula sa Zeon Studio, upang mabilis at tumpak na makabuo ng mga pagsasalin.
Bakit Namin Pinili ang OpenAI API para sa Pagsasalin
Ang mga tradisyonal na serbisyo ng pagsasalin ay madalas na nangangailangan ng makabuluhang manwal na pagsisikap, at ang mga automated na tool tulad ng Google Translate, habang kapaki-pakinabang, ay hindi palaging nagbibigay ng antas ng pag-customize na kailangan namin. Pinahintulutan kami ng OpenAI’s API na:
- Awtomatikong isalin ang mga nilalaman nang maramihan
- I-customize ang istilo ng pagsasalin
- Panatilihin ang mas mahusay na kontrol sa kalidad
- Makipagsama nang walang putol sa aming website na batay sa Hugo
- Markahan ang mga indibidwal na pahina para sa muling pagsasalin
- Magdagdag ng mga bagong wika na may minimal na pagsisikap
Hakbang-hakbang na Proseso
1. Paghahanda ng Website ng Hugo
Ang aming site ay nakaset up na gamit ang tema ng HugoPlate, na sumusuporta sa multilingual na functionality. Ang unang hakbang ay upang paganahin ang suporta sa wika sa aming Hugo config/_default/languages.toml na file:
```toml
################ English language ##################
[en]
languageName = "English"
languageCode = "en-us"
contentDir = "content/english"
weight = 1
################ Arabic language ##################
[ar]
languageName = "العربية"
languageCode = "ar"
contentDir = "content/arabic"
languageDirection = 'rtl'
weight = 2
```
Tinitiyak ng configuration na ito na makakabuo ang Hugo ng hiwalay na bersyon ng nilalaman sa iba’t ibang wika.
2. Awtomatikong Pagsasalin gamit ang OpenAI API
Nagawa namin ang isang Bash script upang awtomatiko ang pagsasalin ng mga Markdown na file. Ang script na ito:
- Nagbabasa ng mga English na
.mdna file mula sa source directory. - Gumagamit ng OpenAI API upang isalin ang teksto habang pinapanatili ang Markdown na formatting.
- Nagsusulat ng isinaling nilalaman sa mga naaangkop na direktoryo ng wika.
- Nagsusubaybay sa katayuan ng pagsasalin gamit ang isang JSON na file.
Narito ang aming bash script para sa pag-aautomat ng mga pagsasalin. Malaya kang gumamit at i-modify ito para sa iyong mga pangangailangan:
```bash
# MIT License
# Copyright (c) 2024 Williston Technical Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#!/bin/bash
# ===========================================
# Hugo Content Translation and Update Script (Sequential Processing & New-Language Cleanup)
# ===========================================
# This script translates Hugo Markdown (.md) files from English to all supported target languages
# sequentially (one file at a time). It updates a JSON status file after processing each file.
# At the end of the run, it checks translation_status.json and removes any language from
# translate_new_language.txt only if every file for that language is marked as "success".
# ===========================================
set -euo pipefail
# --- Simple Logging Function (writes to stderr) ---
log_step() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >&2
}
# --- Environment Setup ---
export PATH="/opt/homebrew/opt/coreutils/libexec/gnubin:$PATH"
# (Removed "Script starting." log)
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
log_step "SCRIPT_DIR set to: $SCRIPT_DIR"
if [ -f "$SCRIPT_DIR/.env" ]; then
log_step "Loading environment variables from .env"
set -o allexport
source "$SCRIPT_DIR/.env"
set +o allexport
fi
# Load new languages from translate_new_language.txt (if available)
declare -a NEW_LANGUAGES=()
if [ -f "$SCRIPT_DIR/translate_new_language.txt" ]; then
while IFS= read -r line || [[ -n "$line" ]]; do
NEW_LANGUAGES+=("$line")
done <"$SCRIPT_DIR/translate_new_language.txt"
else
log_step "No new languages file found; proceeding with empty NEW_LANGUAGES."
fi
API_KEY="${OPENAI_API_KEY:-}"
if [ -z "$API_KEY" ]; then
log_step "❌ Error: OPENAI_API_KEY environment variable is not set."
exit 1
fi
# Supported Languages (full list)
SUPPORTED_LANGUAGES=("ar" "bg" "bn" "cs" "da" "de" "el" "es" "fa" "fi" "fr" "ha" "he" "hi" "hr" "hu" "id" "ig" "it" "ja" "ko" "ml" "mr" "ms" "nl" "no" "pa" "pl" "pt" "ro" "ru" "sk" "sn" "so" "sr" "sv" "sw" "ta" "te" "th" "tl" "tr" "uk" "vi" "xh" "yo" "zh" "zu")
STATUS_FILE="$SCRIPT_DIR/translation_status.json"
SRC_DIR="$SCRIPT_DIR/Content/english"
log_step "Source directory: $SRC_DIR"
# Check dependencies
for cmd in jq curl; do
if ! command -v "$cmd" >/dev/null 2>&1; then
log_step "❌ Error: '$cmd' is required. Please install it."
exit 1
fi
done
MAX_RETRIES=5
WAIT_TIME=2 # seconds
# Create/initialize status file if missing
if [ ! -f "$STATUS_FILE" ]; then
echo "{}" >"$STATUS_FILE"
log_step "Initialized status file at: $STATUS_FILE"
fi
# --- Locking for Status Updates ---
lock_status() {
local max_wait=10
local start_time
start_time=$(date +%s)
while ! mkdir "$STATUS_FILE.lockdir" 2>/dev/null; do
sleep 0.01
local now
now=$(date +%s)
if ((now - start_time >= max_wait)); then
log_step "WARNING: Lock wait exceeded ${max_wait}s. Forcibly removing stale lock."
rm -rf "$STATUS_FILE.lockdir"
fi
done
}
unlock_status() {
rmdir "$STATUS_FILE.lockdir"
}
update_status() {
local file_path="$1" lang="$2" status="$3"
lock_status
jq --arg file "$file_path" --arg lang "$lang" --arg status "$status" \
'.[$file][$lang] = $status' "$STATUS_FILE" >"$STATUS_FILE.tmp" && mv "$STATUS_FILE.tmp" "$STATUS_FILE"
unlock_status
}
# --- Translation Function ---
translate_text() {
local text="$1" lang="$2"
local retry_count=0
while [ "$retry_count" -lt "$MAX_RETRIES" ]; do
user_message="Translate the following text to $lang. Preserve all formatting exactly as in the original.
$text"
json_payload=$(jq -n \
--arg system "Translate from English to $lang. Preserve original formatting exactly." \
--arg user_message "$user_message" \
'{
"model": "gpt-4o-mini",
"messages": [
{"role": "system", "content": $system},
{"role": "user", "content": $user_message}
],
"temperature": 0.3
}')
response=$(curl -s https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $API_KEY" \
-d "$json_payload")
log_step "📥 Received API response."
local error_type
error_type=$(echo "$response" | jq -r '.error.type // empty')
local error_message
error_message=$(echo "$response" | jq -r '.error.message // empty')
if [ "$error_type" == "insufficient_quota" ]; then
sleep "$WAIT_TIME"
retry_count=$((retry_count + 1))
elif [[ "$error_type" == "rate_limit_reached" || "$error_type" == "server_error" || "$error_type" == "service_unavailable" ]]; then
sleep "$WAIT_TIME"
retry_count=$((retry_count + 1))
elif [ "$error_type" == "invalid_request_error" ]; then
return 1
elif [ -z "$error_type" ]; then
if ! translated_text=$(echo "$response" | jq -r '.choices[0].message.content' 2>/dev/null); then
return 1
fi
if [ "$translated_text" == "null" ] || [ -z "$translated_text" ]; then
return 1
else
translated_text=$(echo "$translated_text" | sed -e 's/^```[[:space:]]*//; s/[[:space:]]*```$//')
echo "$translated_text"
return 0
fi
else
return 1
fi
done
return 1
}
# --- Process a Single File (Sequential Version) ---
process_file() {
local src_file="$1" target_file="$2" lang="$3" rel_src="$4"
# If target file exists and is non-empty, mark status as success.
if [ -s "$target_file" ]; then
update_status "$rel_src" "$lang" "success"
return 0
fi
content=$(<"$src_file")
if [[ "$content" =~ ^[---|\+\+\+]([:space:)]*$ ]] && [[ "$content" =~ [[:space:]]*[---|\+\+\+\+]([:space:)]*$ ]]; then
front_matter=$(echo "$content" | sed -n '/^\(---\|\+\+\+\)$/,/^\(---\|\+\+\+\)$/p')
body_content=$(echo "$content" | sed -n '/^\(---\|\+\+\+\)$/,/^\(---\|\+\+\+\)$/d')
else
front_matter=""
body_content="$content"
fi
log_step "Translating [$rel_src] to $lang..."
translated_body=$(translate_text "$body_content" "$lang")
if [ $? -ne 0 ]; then
update_status "$rel_src" "$lang" "failed"
return 1
fi
mkdir -p "$(dirname "$target_file")"
if [ -n "$front_matter" ]; then
echo -e "$front_matter
$translated_body" >"$target_file"
else
echo -e "$translated_body" >"$target_file"
fi
updated_content=$(echo "$content" | sed -E 's/^retranslate:\s*true/retranslate: false/')
echo "$updated_content" >"$src_file"
update_status "$rel_src" "$lang" "success"
}
# --- Main Sequential Processing ---
ALL_SUCCESS=true
for TARGET_LANG in "${SUPPORTED_LANGUAGES[@]}"; do
log_step "Processing language: $TARGET_LANG"
TARGET_DIR="$SCRIPT_DIR/Content/$TARGET_LANG"
while IFS= read -r -d '' src_file; do
rel_src="${src_file#$SCRIPT_DIR/}"
target_file="$TARGET_DIR/${src_file#$SRC_DIR/}"
# If file is marked not to retranslate, check that target file exists and is non-empty.
if ! [[ " ${NEW_LANGUAGES[@]:-} " =~ " ${TARGET_LANG} " ]] && grep -q '^retranslate:\s*false' "$src_file"; then
if [ -s "$target_file" ]; then
update_status "$rel_src" "$TARGET_LANG" "success"
else
update_status "$rel_src" "$TARGET_LANG" "failed"
fi
continue
fi
process_file "$src_file" "$target_file" "$TARGET_LANG" "$rel_src"
done < <(find "$SRC_DIR" -type f -name "*.md" -print0)
done
log_step "Translation run completed."
end_time=$(date +%s)
duration=$((end_time - $(date +%s)))
log_step "Execution Time: $duration seconds"
if [ "$ALL_SUCCESS" = true ]; then
log_step "🎉 Translation completed successfully for all supported languages!"
else
log_step "⚠️ Translation completed with some errors."
fi
# --- Clean Up Fully Translated New Languages ---
if [ -f "$SCRIPT_DIR/translate_new_language.txt" ]; then
log_step "Cleaning up fully translated new languages..."
for lang in "${NEW_LANGUAGES[@]:-}"; do
incomplete=$(jq --arg lang "$lang" 'to_entries[] | select(.value[$lang] != null and (.value[$lang] != "success")) | .key' "$STATUS_FILE")
if [ -z "$incomplete" ]; then
log_step "All translations for new language '$lang' are marked as success. Removing from translate_new_language.txt."
sed -E -i '' "/^[[:space:]]*$lang[[:space:]]*$/d" "$SCRIPT_DIR/translate_new_language.txt"
else
log_step "Language '$lang' still has incomplete translations."
fi
done
fi
```
3. Pamamahala ng Katayuan ng Pagsasalin
Upang maiwasan ang mga redundant na pagsasalin at subaybayan ang progreso, ginamit namin ang isang JSON na file (translation_status.json). Ina-update ng script na ito ang file pagkatapos iproseso ang bawat dokumento, na tinitiyak na ang tanging bagong o na-update na nilalaman ang isasalin.
4. Pag-handle ng Mga Error at API Rate Limits
Nagpatupad kami ng retries at error handling upang harapin ang rate limits, API failures, at quota issues. Ang script ay naghihintay bago subukang muli kung ang OpenAI API ay nagbabalik ng error tulad ng rate_limit_reached o service_unavailable.
5. Deployment
Kapag nabuo na ang isinaling nilalaman, ang pagpapatakbo ng hugo --minify ay nagbuo ng multilingual static site, handa na para sa deployment.
Mga Hamon at Solusyon
1. Katumpakan ng Pagsasalin
Habang ang mga pagsasalin ng OpenAI ay karaniwang tumpak, ang ilang mga teknikal na termino ay maaaring mangailangan ng manwal na pagsusuri, ngunit kami ay isang koponan lamang ng dalawa, kaya umaasa kami sa pinakamahusay. Pinino namin ang mga prompt upang mapanatili ang konteksto at tono.
2. Mga Isyu sa Formatting
Minsan ang Markdown syntax ay nagbago sa pagsasalin. Upang ayusin ito, nagdagdag kami ng post-processing logic upang mapanatili ang formatting.
3. Pag-optimize ng Gastos ng API
Upang mabawasan ang mga gastos, nagpatupad kami ng caching upang maiwasan ang muling pagsasalin ng hindi nagbago na nilalaman.
4. Epektibong Pag-handle ng Muling Pagsasalin
Upang muling isalin ang mga tiyak na pahina, nagdagdag kami ng retranslate: true na front matter parameter. Ang script ay muling isasalin lamang ang mga pahinang minarkahan ng parameter na ito. Pinapayagan nito kaming i-update ang mga pagsasalin ayon sa kinakailangan nang hindi kinakailangang muling isalin ang buong site.
Konklusyon
Sa pamamagitan ng pagsasama ng OpenAI API sa Hugo, na-automate namin ang pagsasalin ng aming website habang pinapanatili ang kalidad at kakayahang umangkop. Ang pamamaraang ito ay nakatipid ng oras, tinitiyak ang pagkakapare-pareho, at pinahintulutan kaming mag-scale nang walang hirap. Kung naghahanap ka upang gawing multilingual ang iyong site na Hugo, nag-aalok ang API ng OpenAI ng isang makapangyarihang solusyon.