converter.py

import argparse
import csv
import json
import re
import shutil
import zipfile
from pathlib import Path
from datetime import datetime

def parse_args():
    parser = argparse.ArgumentParser(
        description="Convert Hanzi CSV to Yomitan Dictionary"
    )
    parser.add_argument(
        "csv_file",
        type=Path,
        help="Path to the .csv file"
    )
    parser.add_argument(
        "output",
        type=Path,
        help="Path to output directory (Dictionary will be built here)"
    )
    parser.add_argument(
        "--chunk-size",
        type=int,
        default=10_000,
        help="Maximum number of entries per kanji_bank file (default: 10000)"
    )
    parser.add_argument(
        "--title",
        type=str,
        default="Hanzi Dict VN",
        help="Dictionary title in index.json"
    )
    parser.add_argument(
        "--no-zip",
        action="store_true",
        help="Do not create zip file (leave output directory only)"
    )

    args = parser.parse_args()
    return args

def chunk_entries(entries, chunk_size=10_000):
    if chunk_size <= 0:
        raise ValueError("chunk_size must be a positive integer")
    for i in range(0, len(entries), chunk_size):
        yield entries[i:i + chunk_size]

def write_kanji_banks(chunks, output_dir):
    for idx, chunk in enumerate(chunks, start=1):
        filename = f"kanji_bank_{idx}.json"
        path = output_dir / filename
        with path.open("w", encoding="utf-8") as f:
            json.dump(chunk, f, ensure_ascii=False, indent=0, separators=(',', ':'))

def build_index_json(output_dir, title="Hanzi Dictionary"):
    """
    Build index.json for output dictionary.
    """
    index_data = {
        "title": title,
        "format": 3,
        "revision": datetime.now().strftime("%Y.%m.%d"),
        "sequenced": False,
        "author": "",
        "url": "",
        "description": "Từ điển Hán Tự (Hanzi) cho Yomitan"
    }
    
    with (output_dir / "index.json").open("w", encoding="utf-8") as f:
        json.dump(index_data, f, ensure_ascii=False, indent=2)

def zip_output_directory(output_dir, zip_path):
    print(f"Zipping to {zip_path}...")
    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
        for path in output_dir.iterdir():
            if path.is_file():
                zf.write(path, arcname=path.name)


def process_definition_nom(def_nom_str):
    """
    Tách chuỗi defNom chứa <LI> thành list các nghĩa.
    Ví dụ: "<LI>nghĩa 1<LI>nghĩa 2" -> ["nghĩa 1", "nghĩa 2"]
    """
    if not def_nom_str:
        return []
    
    # Tách bằng regex <LI> (case insensitive)
    parts = re.split(r'<LI>', def_nom_str, flags=re.IGNORECASE)
    # Loại bỏ các chuỗi rỗng và khoảng trắng thừa
    return [p.strip() for p in parts if p.strip()]

def clean_han_viet_definition(text):
    if not text:
        return []

    # 1. Thay thế ◎Như: thành Ví dụ:
    text = text.replace("◎Như:", "Ví dụ:")

    # 2. Xử lý các cụm <ach> liên tiếp để gộp vào (Hán Tự) -
    def process_ach_group(match):
        full_block = match.group(0)
        # Tìm tất cả ký tự nằm trong các thẻ <ach> của cụm này
        chars = re.findall(r'">([^<]+)</a>', full_block)
        if chars:
            return f"({''.join(chars)}) -"
        return ""

    # Regex tìm các thẻ <ach> đứng sát nhau hoặc cách nhau bởi khoảng trắng
    ach_pattern = r'(<ach>[^>]+>[^<]+</a>(?:\s*<ach>[^>]+>[^<]+</a>)*)'
    text = re.sub(ach_pattern, process_ach_group, text)

    # 3. Loại bỏ tất cả các thẻ HTML còn lại (<B>, <a>,...)
    text = re.sub(r'<[^>]+>', '', text)

    # 4. Tách các định nghĩa theo từ loại (Danh, Tính, Động, Trạng thanh...)
    # Regex hỗ trợ tiếng Việt có dấu cho từ loại
    parts = re.split(r'(?=\([A-Z][a-zđ]+\))', text)
    
    cleaned_parts = []
    for p in parts:
        item = p.strip()
        if not item: continue
        
        # Làm sạch khoảng trắng và dấu chấm thừa
        item = re.sub(r'\s+', ' ', item)
        item = re.sub(r'\.+$', '', item)
        # Đảm bảo format chuẩn cho cụm "(Hán Tự) - Nghĩa"
        item = item.replace(")-", ") -")
        
        cleaned_parts.append(item)
            
    return cleaned_parts

def create_yomitan_entry(character, row):
    """
    Tạo một entry cấu trúc mảng cho Yomitan từ một dòng CSV và ký tự cụ thể.
    Structure: [char, on, kun, tags, meanings, stats]
    """
    
    # 1. Readings (Han Viet)
    # Xóa dấu phẩy, thay bằng khoảng trắng
    han_viet = row.get('hanViet', '').replace(',', ' ').strip()
    # Chuẩn hóa khoảng trắng (nếu có nhiều dấu cách liền nhau)
    han_viet = re.sub(r'\s+', ' ', han_viet)

    # 2. Meanings
    meanings = []
    
    # Xử lý defNom
    def_nom = row.get('defNom', '')
    if def_nom:
        meanings.extend(process_definition_nom(def_nom))
        
    # Xử lý defHanViet
    def_han_viet = row.get('defHanViet', '')
    if def_han_viet:
        cleaned_definitions = clean_han_viet_definition(def_han_viet)
        meanings.extend(cleaned_definitions)
        
    # Nếu không có nghĩa nào, để trống
    if not meanings:
        meanings.append("...")

    # 3. Stats (Metadata)
    stats = {}
    if row.get('totalStrokes'):
        stats['Strokes'] = row['totalStrokes']
    if row.get('pinyin'):
        stats['Pinyin'] = row['pinyin']

    # Yomitan Kanji Structure
    # [character, onyomi, kunyomi, tags, meanings, stats]
    # Lưu ý: HanViet ở đây mình map vào Onyomi (vị trí số 2) vì nó tương đương âm Hán
    return [
        character,      # Kanji
        han_viet,       # Onyomi (Han Viet)
        "",             # Kunyomi (Empty)
        "",             # Tags (Empty)
        meanings,       # Meanings Array
        stats           # Stats Object
    ]

def write_tag_bank(output_dir):
    """
    Tạo file tag_bank_1.json để hiển thị tiêu đề đẹp cho các trường thông tin.
    """
    tag_data = [
        ["Strokes", "misc", 0, "Tổng nét", 0],
        ["Pinyin", "misc", 0, "Pinyin", 0]
    ]
    
    path = output_dir / "tag_bank_1.json"
    with path.open("w", encoding="utf-8") as f:
        json.dump(tag_data, f, ensure_ascii=False, indent=2)

def main():
    args = parse_args()

    # Tạo thư mục output nếu chưa tồn tại
    if not args.output.exists():
        args.output.mkdir(parents=True)
    else:
        # Clean folder cũ để tránh file rác
        for item in args.output.iterdir():
            if item.is_file():
                item.unlink()

    print(f"Reading CSV: {args.csv_file}")
    
    all_entries = []
    
    try:
        with args.csv_file.open('r', encoding='utf-8-sig') as f:
            reader = csv.DictReader(f)
            
            for row in reader:
                # Lấy các ký tự Hán tự
                primary_char = row.get('unicode', '').strip()
                simp_char = row.get('simplifiedVariant', '').strip()
                
                # Logic: Tạo entry cho unicode
                if primary_char:
                    entry = create_yomitan_entry(primary_char, row)
                    all_entries.append(entry)
                
                # Logic: Tạo entry cho simplifiedVariant (nếu khác primary)
                if simp_char and simp_char != primary_char:
                    entry = create_yomitan_entry(simp_char, row)
                    all_entries.append(entry)
                    
    except Exception as e:
        print(f"Error reading CSV: {e}")
        return

    print(f"Total entries generated: {len(all_entries)}")

    # Chunking và ghi file kanji_bank
    chunks = list(chunk_entries(all_entries, args.chunk_size))
    print(f"Writing {len(chunks)} bank files...")
    write_kanji_banks(chunks, args.output)

    # Tạo index.json
    print("Writing index.json...")
    build_index_json(args.output, title=args.title)
    write_tag_bank(args.output)
    # Zip file
    if not args.no_zip:
        # Tên file zip sẽ là tên folder output + .zip
        zip_filename = args.output.with_suffix(".zip")
        zip_output_directory(args.output, zip_filename)
        print(f"Done! Imported dictionary created at: {zip_filename}")
    else:
        print(f"Done! Dictionary files are in: {args.output}")

if __name__ == "__main__":
    main()