Files
2026-03-24 10:53:27 +05:00

392 lines
15 KiB
Python
Executable File

#!/usr/bin/env python3
import argparse
import sys
import re
import ast
from pathlib import Path
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor
from babel.messages.frontend import CommandLineInterface
from pyaspeller import YandexSpeller
# ---------- Пути ----------
LOCALES_PATH = Path(__file__).parent.parent / "portprotonqt" / "locales"
THEMES_PATH = Path(__file__).parent.parent / "portprotonqt" / "themes"
MESON_BUILD = Path(__file__).parent.parent / "portprotonqt" / "meson.build"
POT_FILE = LOCALES_PATH / "portprotonqt.pot"
# ---------- Версия проекта ----------
def _get_version() -> str:
return "0.1.1"
# ---------- PyBabel команды ----------
def compile_locales() -> None:
CommandLineInterface().run([
"pybabel", "compile", "--use-fuzzy", "--directory",
f"{LOCALES_PATH.resolve()}", "--domain=portprotonqt", "--statistics"
])
def extract_strings() -> None:
input_dir = (Path(__file__).parent.parent / "portprotonqt").resolve()
CommandLineInterface().run([
"pybabel", "extract", "--project=PortProtonQt",
f"--version={_get_version()}",
"--strip-comment-tag",
"--no-location",
f"--input-dir={input_dir}",
"--copyright-holder=boria138",
f"--ignore-dirs={THEMES_PATH}",
f"--output-file={POT_FILE.resolve()}"
])
def update_locales() -> None:
saved_headers: dict[Path, list[str]] = {}
saved_po_texts: dict[Path, str] = {}
for po_file in LOCALES_PATH.glob("**/portprotonqt.po"):
saved_po_texts[po_file] = po_file.read_text(encoding="utf-8")
header_block = _get_po_header_block(po_file)
if header_block:
saved_headers[po_file] = header_block
CommandLineInterface().run([
"pybabel", "update",
f"--input-file={POT_FILE.resolve()}",
f"--output-dir={LOCALES_PATH.resolve()}",
"--domain=portprotonqt",
"--ignore-obsolete",
"--ignore-pot-creation-date",
"--update-header-comment",
])
for po_file, header_block in saved_headers.items():
_set_po_header_block(po_file, header_block)
for po_file, original_text in saved_po_texts.items():
_restore_unchanged_po_entries(po_file, original_text)
def _get_po_header_block(po_path: Path) -> list[str] | None:
lines = po_path.read_text(encoding="utf-8").splitlines()
in_header = False
header_start = None
header_end = None
for i, line in enumerate(lines):
if line == 'msgstr ""':
in_header = True
header_start = i + 1
continue
if not in_header:
continue
if not line.startswith('"'):
header_end = i
break
if header_start is None or header_end is None or header_end <= header_start:
return None
return lines[header_start:header_end]
def _set_po_header_block(po_path: Path, block: list[str]) -> None:
lines = po_path.read_text(encoding="utf-8").splitlines()
in_header = False
header_start = None
header_end = None
for i, line in enumerate(lines):
if line == 'msgstr ""':
in_header = True
header_start = i + 1
continue
if not in_header:
continue
if not line.startswith('"'):
header_end = i
break
if header_start is None or header_end is None:
return
lines[header_start:header_end] = block
po_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
def _parse_po_entry_signature(block: list[str]) -> tuple[str, tuple[tuple[str, str], ...]] | None:
msgctxt = ""
msgid = None
msgstr_values: dict[str, str] = {}
i = 0
while i < len(block):
line = block[i]
if line.startswith("msgctxt "):
msgctxt, i = _read_po_value(block, i, "msgctxt ")
continue
if line.startswith("msgid "):
msgid, i = _read_po_value(block, i, "msgid ")
continue
if line.startswith("msgstr "):
value, i = _read_po_value(block, i, "msgstr ")
msgstr_values["msgstr"] = value
continue
if line.startswith("msgstr["):
key = line.split(" ", maxsplit=1)[0]
value, i = _read_po_value(block, i, f"{key} ")
msgstr_values[key] = value
continue
i += 1
if msgid is None or msgid == "":
return None
return f"{msgctxt}\x04{msgid}", tuple(sorted(msgstr_values.items()))
def _read_po_value(block: list[str], idx: int, prefix: str) -> tuple[str, int]:
value = _unquote_po_string(block[idx][len(prefix):])
idx += 1
while idx < len(block) and block[idx].startswith('"'):
value += _unquote_po_string(block[idx])
idx += 1
return value, idx
def _unquote_po_string(value: str) -> str:
value = value.strip()
if not value.startswith('"'):
return ""
return ast.literal_eval(value)
def _split_po_blocks(text: str) -> list[list[str]]:
blocks: list[list[str]] = []
current: list[str] = []
for line in text.splitlines():
if line == "":
if current:
blocks.append(current)
current = []
continue
current.append(line)
if current:
blocks.append(current)
return blocks
def _restore_unchanged_po_entries(po_path: Path, original_text: str) -> None:
original_blocks = _split_po_blocks(original_text)
original_entries: dict[str, tuple[tuple[tuple[str, str], ...], list[str]]] = {}
for block in original_blocks:
signature = _parse_po_entry_signature(block)
if signature is None:
continue
key, values = signature
original_entries[key] = (values, block)
current_blocks = _split_po_blocks(po_path.read_text(encoding="utf-8"))
changed = False
for i, block in enumerate(current_blocks):
signature = _parse_po_entry_signature(block)
if signature is None:
continue
key, values = signature
if key not in original_entries:
continue
original_values, original_block = original_entries[key]
if values != original_values:
continue
if block == original_block:
continue
current_blocks[i] = original_block
changed = True
if not changed:
return
rebuilt = "\n\n".join("\n".join(block) for block in current_blocks)
po_path.write_text(rebuilt + "\n", encoding="utf-8")
def _update_meson_locales(new_locales: list[str]) -> None:
"""Обновляет список языков в meson.build."""
if not MESON_BUILD.exists():
return
text = MESON_BUILD.read_text(encoding="utf-8")
# Ищем foreach lang : ['de', 'es', 'pt', 'ru']
pattern = r"(foreach\s+lang\s*:\s*\[)([^\]]+)(\])"
match = re.search(pattern, text)
if not match:
return
# Парсим текущий список языков
current_langs_str = match.group(2)
current_langs = re.findall(r"'([^']+)'", current_langs_str)
# Добавляем новые языки и сортируем
all_langs = sorted(set(current_langs) | set(new_locales))
# Формируем новый список
new_langs_str = ", ".join(f"'{lang}'" for lang in all_langs)
new_text = text[:match.start()] + match.group(1) + new_langs_str + match.group(3) + text[match.end():]
if new_text != text:
MESON_BUILD.write_text(new_text, encoding="utf-8")
print(f"Updated meson.build with locales: {all_langs}")
def create_new(locales: list[str]) -> None:
if not POT_FILE.exists():
extract_strings()
for locale in locales:
CommandLineInterface().run([
"pybabel", "init",
f"--input-file={POT_FILE.resolve()}",
f"--output-dir={LOCALES_PATH.resolve()}",
"--domain=portprotonqt",
"--no-wrap",
f"--locale={locale}"
])
# Обновляем meson.build с новыми локалями
_update_meson_locales(locales)
# ---------- Игнорируемые префиксы для spellcheck ----------
IGNORED_PREFIXES = ()
def load_ignored_prefixes(ignore_file=".spellignore"):
path = Path(__file__).parent / ignore_file
try:
return tuple(path.read_text(encoding='utf-8').splitlines())
except FileNotFoundError:
return ()
IGNORED_PREFIXES = load_ignored_prefixes() + ("PortProton", "flatpak")
# ---------- Проверка fuzzy строк ----------
def find_fuzzy_entries(filepath: Path) -> list[tuple[int, str, str]]:
"""Находит fuzzy записи в .po файле. Возвращает список (номер_строки, msgid, флаги)."""
fuzzy_entries = []
lines = filepath.read_text(encoding='utf-8').splitlines()
i = 0
while i < len(lines):
line = lines[i].strip()
# Ищем комментарий с флагами, содержащий fuzzy
if line.startswith('#,') and 'fuzzy' in line:
flags = line[2:].strip()
line_num = i + 1
# Ищем следующий msgid
msgid = ""
i += 1
while i < len(lines):
next_line = lines[i].strip()
if next_line.startswith('msgid '):
match = re.match(r'^msgid\s+"(.*)"', next_line)
if match:
msgid = match.group(1)
i += 1
# Собираем многострочный msgid
while i < len(lines) and lines[i].strip().startswith('"'):
msgid += lines[i].strip()[1:-1]
i += 1
break
i += 1
# Пропускаем пустой msgid (заголовок PO файла)
if msgid:
fuzzy_entries.append((line_num, msgid, flags))
else:
i += 1
return fuzzy_entries
# ---------- Проверка орфографии с параллелизмом ----------
speller = YandexSpeller()
MSGID_RE = re.compile(r'^msgid\s+"(.*)"')
MSGSTR_RE = re.compile(r'^msgstr\s+"(.*)"')
def extract_po_strings(filepath: Path) -> list[str]:
# Collect all strings, then filter by ignore list
texts, current_key, buffer = [], None, ""
def flush():
nonlocal buffer
if buffer.strip():
texts.append(buffer)
buffer = ""
for line in filepath.read_text(encoding='utf-8').splitlines():
stripped = line.strip()
if stripped.startswith("msgid ") and filepath.suffix == '.pot':
flush(); current_key = 'msgid'; buffer = MSGID_RE.match(stripped).group(1) or ''
elif stripped.startswith("msgstr "):
flush(); current_key = 'msgstr'; buffer = MSGSTR_RE.match(stripped).group(1) or ''
elif stripped.startswith('"') and stripped.endswith('"') and current_key:
buffer += stripped[1:-1]
else:
flush(); current_key = None
flush()
# Final filter: remove ignored and multi-line
return [
t for t in texts
if t.strip() and all(pref not in t for pref in IGNORED_PREFIXES) and "\n" not in t
]
def _check_text(text: str) -> tuple[str, list[dict]]:
result = speller.spell(text)
errors = [r for r in result if r.get('word') and r.get('s')]
return text, errors
def check_file(filepath: Path, issues_summary: dict) -> bool:
print(f"Checking file: {filepath}")
texts = extract_po_strings(filepath)
has_errors = False
printed_err = False
with ThreadPoolExecutor(max_workers=8) as pool:
for text, errors in pool.map(_check_text, texts):
print(f' In string: "{text}"')
if errors:
if not printed_err:
print(f"❌ Errors in file: {filepath}")
printed_err = True
has_errors = True
for err in errors:
print(f" - typo: {err['word']}, suggestions: {', '.join(err['s'])}")
issues_summary[filepath].extend([(text, err) for err in errors])
return has_errors
# ---------- Основной обработчик ----------
def main(args) -> int:
if args.update_all:
extract_strings(); update_locales()
if args.create_new:
create_new(args.create_new)
if args.spellcheck:
files = list(LOCALES_PATH.glob("**/portprotonqt.po")) + [POT_FILE]
seen = set(); has_err = False
issues_summary = defaultdict(list)
fuzzy_summary = defaultdict(list)
for f in files:
if not f.exists() or f in seen: continue
seen.add(f)
# Проверка fuzzy строк (только для .po файлов)
if f.suffix == '.po':
fuzzy_entries = find_fuzzy_entries(f)
if fuzzy_entries:
fuzzy_summary[f] = fuzzy_entries
has_err = True
if check_file(f, issues_summary):
has_err = True
else:
if f not in fuzzy_summary:
print(f"✅ {f} — no errors found.")
# Вывод fuzzy строк
if fuzzy_summary:
print("\n⚠️ Fuzzy Entries (require review before release):")
for file, entries in fuzzy_summary.items():
print(f"\n⚠ {file}")
print("-----")
for idx, (line_num, msgid, flags) in enumerate(entries, 1):
print(f"{idx}. Line {line_num}: [{flags}]")
print(f" msgid: \"{msgid[:80]}{'...' if len(msgid) > 80 else ''}\"")
print("-----")
# Вывод орфографических ошибок
if issues_summary:
print("\n📋 Summary of Spelling Errors:")
for file, errs in issues_summary.items():
print(f"\n✗ {file}")
print("-----")
for idx, (text, err) in enumerate(errs, 1):
print(f"{idx}. In '{text}': typo '{err['word']}', suggestions: {', '.join(err['s'])}")
print("-----")
return 1 if has_err else 0
extract_strings(); compile_locales()
return 0
if __name__ == "__main__":
parser = argparse.ArgumentParser(prog="l10n", description="Localization utility for PortProtonQt.")
parser.add_argument("--create-new", nargs='+', type=str, default=False, help="Create .po for new locales")
parser.add_argument("--update-all", action='store_true', help="Extract/update locales")
parser.add_argument("--spellcheck", action='store_true', help="Run spellcheck on POT and PO files")
args = parser.parse_args()
sys.exit(main(args))