import argparse

import configparser

import os

from pathlib import Path, PurePosixPath

import shutil

import subprocess

def active_catalogs(config_path):

config = configparser.ConfigParser(interpolation=None)

with config_path.open(encoding="utf-8") as stream:

config.read_file(stream)

catalogs = set()

for section in config.sections():

if section == "main":

continue

source = PurePosixPath(config[section]["source_file"])

relative = source.relative_to("pot")

if ".." in relative.parts or relative.suffix != ".pot":

raise ValueError(f"Invalid catalog path: {source}")

catalogs.add(Path(relative.with_suffix(".po")))

if not catalogs:

raise ValueError(f"No catalogs listed in {config_path}")

return sorted(catalogs)

def tracked_catalogs(root):

result = subprocess.run(

["git", "-C", str(root), "ls-files", "-z", "--", "*.po"],

check=True,

stdout=subprocess.PIPE,

)

return [Path(os.fsdecode(name)) for name in result.stdout.split(b"\0") if name]

def require_catalogs(root, catalogs):

missing = [str(path) for path in catalogs if not (root / path).is_file()]

if missing:

raise FileNotFoundError(f"Missing PO catalogs in {root}: {', '.join(missing)}")

def sync(source, destination, language):

config = source / ".tx/config"

catalogs = active_catalogs(config)

downloaded = source / language / "LC_MESSAGES"

require_catalogs(downloaded, catalogs)

obsolete = set(tracked_catalogs(destination)) - set(catalogs)

for path in catalogs:

target = destination / path

target.parent.mkdir(parents=True, exist_ok=True)

shutil.copyfile(downloaded / path, target)

for path in sorted(obsolete):

(destination / path).unlink(missing_ok=True)

print(f"Removed obsolete catalog: {path}")

(destination / ".tx").mkdir(exist_ok=True)

shutil.copyfile(config, destination / ".tx/config")

def merge(source, destination):

# Ignore stale PO files even if a source checkout still contains them.

catalogs = active_catalogs(source / ".tx/config")

targets = tracked_catalogs(destination)

if not targets:

raise ValueError(f"No target catalogs in {destination}")

require_catalogs(source, catalogs)

require_catalogs(destination, targets)

subprocess.run(

[

"pomerge",

"--from",

*(str(source / path) for path in catalogs),

"--to",

*(str(destination / path) for path in targets),

],

check=True,

)

def main():

parser = argparse.ArgumentParser(description=__doc__)

commands = parser.add_subparsers(dest="command", required=True)

sync_parser = commands.add_parser("sync")

sync_parser.add_argument("source", type=Path)

sync_parser.add_argument("destination", type=Path)

sync_parser.add_argument("--language", default="ja")

merge_parser = commands.add_parser("merge")

merge_parser.add_argument("source", type=Path)

merge_parser.add_argument("destination", type=Path)

args = parser.parse_args()

if args.command == "sync":

sync(args.source, args.destination, args.language)

else:

merge(args.source, args.destination)

if __name__ == "__main__":

main()

LANGUAGE=${1:-ja}

ROOTDIR=$(realpath "$(dirname "$0")/..")

cd "${ROOTDIR}"

exit 1

mkdir -p cpython/Doc/locales

WORKDIR=$(mktemp -d "${ROOTDIR}/cpython/Doc/locales/update.XXXXXX")

trap 'rm -rf "$WORKDIR"' EXIT

trap 'exit 1' HUP INT TERM

cd cpython/Doc

sphinx-build -E -b gettext -D gettext_compact=0 -d "${WORKDIR}/.doctrees" . "${WORKDIR}/pot"

cd "${WORKDIR}"

sphinx-intl create-txconfig

sphinx-intl update-txconfig-resources -p pot -d . --transifex-organization-name python-doc --transifex-project-name python-newest

tx pull -l "${LANGUAGE}" -t --use-git-timestamps

python "${ROOTDIR}/scripts/translations.py" sync "${WORKDIR}" "${ROOTDIR}" --language "${LANGUAGE}"

import json

from pathlib import Path

import shutil

import subprocess

import sys

import tempfile

import unittest

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))

import translations

def write_config(root, catalogs):

path = root / ".tx/config"

path.parent.mkdir(parents=True, exist_ok=True)

text = "[main]\nhost = https://www.transifex.com\n"

for index, catalog in enumerate(catalogs):

template = Path(catalog).with_suffix(".pot").as_posix()

text += f"\n[resource{index}]\nsource_file = pot/{template}\n"

path.write_text(text, encoding="utf-8")

def write_po(root, name, translation):

path = root / name

path.parent.mkdir(parents=True, exist_ok=True)

path.write_text(

'msgid ""\nmsgstr "Content-Type: text/plain; charset=UTF-8\\n"\n\n'

'msgid "example"\nmsgstr ' + json.dumps(translation, ensure_ascii=False) + "\n",

encoding="utf-8",

)

return path

class TranslationTests(unittest.TestCase):

def setUp(self):

temporary = tempfile.TemporaryDirectory()

self.addCleanup(temporary.cleanup)

self.root = Path(temporary.name)

self.source = self.root / "source"

self.destination = self.root / "destination"

self.source.mkdir()

self.destination.mkdir()

subprocess.run(

["git", "init", "--quiet", str(self.destination)], check=True

)

def track(self):

subprocess.run(

["git", "-C", str(self.destination), "add", "."], check=True

)

def test_sync_removes_old_path_and_preserves_untracked_files(self):

catalogs = ["builtins/functions.po", "library/builtins.po", "bugs.po"]

write_config(self.source, catalogs)

download = self.source / "ja/LC_MESSAGES"

for path in catalogs:

write_po(download, path, "新しい訳")

# A stale downloaded file must not be copied back into the repository.

write_po(download, "library/functions.po", "古い訳")

old = write_po(self.destination, "library/functions.po", "古い訳")

write_po(self.destination, "library/builtins.po", "モジュール")

self.track()

scratch = write_po(self.destination, "scratch.po", "作業中")

scratch_before = scratch.read_bytes()

translations.sync(self.source, self.destination, "ja")

self.assertFalse(old.exists())

for path in catalogs:

self.assertEqual(

(download / path).read_bytes(),

(self.destination / path).read_bytes(),

)

self.assertEqual(scratch_before, scratch.read_bytes())

self.assertEqual(

(self.source / ".tx/config").read_bytes(),

(self.destination / ".tx/config").read_bytes(),

)

def test_incomplete_download_does_not_change_repository(self):

write_config(self.source, ["builtins/functions.po", "bugs.po"])

write_po(self.source / "ja/LC_MESSAGES", "builtins/functions.po", "新しい訳")

write_config(self.destination, ["library/functions.po"])

old = write_po(self.destination, "library/functions.po", "古い訳")

self.track()

before = old.read_bytes()

config_before = (self.destination / ".tx/config").read_bytes()

with self.assertRaises(FileNotFoundError):

translations.sync(self.source, self.destination, "ja")

self.assertEqual(before, old.read_bytes())

self.assertEqual(config_before, (self.destination / ".tx/config").read_bytes())

self.assertFalse((self.destination / "builtins/functions.po").exists())

def test_empty_config_does_not_delete_catalogs(self):

write_config(self.source, [])

old = write_po(self.destination, "library/functions.po", "古い訳")

self.track()

with self.assertRaises(ValueError):

translations.sync(self.source, self.destination, "ja")

self.assertTrue(old.exists())

def test_config_cannot_escape_catalog_directory(self):

write_config(self.source, ["../outside.po"])

with self.assertRaises(ValueError):

translations.active_catalogs(self.source / ".tx/config")

@unittest.skipUnless(shutil.which("pomerge"), "pomerge is required")

def test_merge_uses_current_translation_across_renamed_paths(self):

write_config(self.source, ["builtins/functions.po"])

write_po(self.source, "builtins/functions.po", "新しい訳")

write_po(self.source, "library/functions.po", "古い訳")

old = write_po(self.destination, "library/functions.po", "以前の訳")

self.track()

translations.merge(self.source, self.destination)

text = old.read_text(encoding="utf-8")

self.assertIn('msgstr "新しい訳"', text)

self.assertNotIn("古い訳", text)

self.assertFalse((self.destination / "builtins/functions.po").exists())

if __name__ == "__main__":

unittest.main()