mirror of
https://github.com/Ultimaker/Cura.git
synced 2025-07-25 15:44:04 -06:00
135 lines
5.3 KiB
Python
135 lines
5.3 KiB
Python
# Copyright (c) 2023 UltiMaker.
|
|
# Cura is released under the terms of the LGPLv3 or higher.
|
|
|
|
import argparse
|
|
import os
|
|
import subprocess
|
|
from os.path import isfile
|
|
|
|
from pathlib import Path
|
|
|
|
def extract_all_strings(root_path: Path, script_path: Path, translations_root_path: Path, all_strings_pot_path: Path):
|
|
""" Extracts all strings into a pot file with empty translations.
|
|
|
|
Strings are extracted everywhere that i18n is used in python and qml in the project. It also checks the project
|
|
for JSON files with 'settings' in the root node and extracts these for translation as well.
|
|
|
|
@param root_path: The root path of the project. This is the root for string searching.
|
|
@param script_path: The location of the bash scripts used for translating.
|
|
@param translations_root_path: The root of the translations folder (resources/i18n).
|
|
@param all_strings_pot_path: The path of the pot file where all strings will be outputted (resources/i8n/cura.pot).
|
|
"""
|
|
|
|
# # Extract the setting strings from any json file with settings at its root
|
|
# extract_json_arguments = [
|
|
# script_path.joinpath("extract-json"),
|
|
# root_path.joinpath("resources", "definitions"),
|
|
# translations_root_path
|
|
# ]
|
|
# subprocess.run(extract_json_arguments)
|
|
#
|
|
# Extract all strings from qml and py files
|
|
extract_qml_py_arguments = [
|
|
script_path.joinpath("extract-all"),
|
|
root_path,
|
|
all_strings_pot_path
|
|
]
|
|
subprocess.run(extract_qml_py_arguments)
|
|
|
|
# Extract all the name and description from all plugins
|
|
extract_plugin_arguments = [
|
|
script_path.joinpath("extract-plugins"),
|
|
root_path.joinpath("plugins"),
|
|
all_strings_pot_path
|
|
]
|
|
subprocess.run(extract_plugin_arguments)
|
|
|
|
# Convert the output file to utf-8
|
|
convert_encoding_arguments = [
|
|
"msgconv",
|
|
"--to-code=UTF-8",
|
|
all_strings_pot_path,
|
|
"-o",
|
|
all_strings_pot_path
|
|
]
|
|
subprocess.run(convert_encoding_arguments)
|
|
|
|
|
|
def update_po_files_all_languages(translation_root_path: Path) -> None:
|
|
""" Updates all po files in translation_root_path with new strings mapped to blank translations.
|
|
|
|
This will take all newly generated po files in the root of the translations path (i18n/cura.pot, i18n/fdmextruder.json.def.pot)
|
|
and merge them with the existing po files for every language. This will create new po files with empty translations
|
|
for all new words added to the project.
|
|
|
|
@param translation_root_path: Root of the translations folder (resources/i18n).
|
|
"""
|
|
new_pot_files = []
|
|
|
|
for file in os.listdir(translation_root_path):
|
|
path = translations_root_path.joinpath(file)
|
|
if path.suffix == ".pot":
|
|
new_pot_files.append(path)
|
|
print(new_pot_files)
|
|
|
|
for directory, _, po_files in os.walk(translation_root_path):
|
|
print(directory)
|
|
print(po_files)
|
|
for pot in new_pot_files:
|
|
|
|
po_filename = pot.name.rstrip("t")
|
|
if po_filename not in po_files:
|
|
continue # We only want to merge files that have matching names
|
|
|
|
pot_file = pot
|
|
po_file = Path(directory, po_filename).absolute()
|
|
|
|
# # Initialize the new po file
|
|
# init_files_arguments = [
|
|
# "msginit",
|
|
# "--no-wrap",
|
|
# "--no-translator",
|
|
# "-l", language,
|
|
# "-i", pot_file,
|
|
# "-o", po_file
|
|
# ]
|
|
#
|
|
# subprocess.run(init_files_arguments)
|
|
|
|
merge_files_arguments = [
|
|
"msgmerge",
|
|
"--no-wrap",
|
|
"--no-fuzzy-matching",
|
|
"--update",
|
|
"--sort-by-file", # Sort by file location, this is better than pure sorting for translators
|
|
po_file, # po file that will be updated
|
|
pot_file # source of new strings
|
|
]
|
|
|
|
subprocess.run(merge_files_arguments)
|
|
|
|
return
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description="Extract strings from project into .po files")
|
|
parser.add_argument("root_path", type=str, help="The root of the project to extract translatable strings from")
|
|
parser.add_argument("translation_file_name", type=str, help="The .pot file that all strings from python/qml files will be inserted into")
|
|
parser.add_argument("script_path", type=str, help="The path containing the scripts for translating files")
|
|
args = parser.parse_args()
|
|
|
|
root_path = Path(args.root_path) # root of the project
|
|
script_path = Path(args.script_path) # location of bash scripts
|
|
|
|
# Path where all translation file are
|
|
translations_root_path = root_path.joinpath("resources", "i18n")
|
|
translations_root_path.mkdir(parents=True, exist_ok=True) # Make sure we have an output path
|
|
|
|
all_strings_pot_path = translations_root_path.joinpath(args.translation_file_name) # pot file containing all strings untranslated
|
|
|
|
# Clear the output file, otherwise deleted strings will still be in the output.
|
|
if os.path.exists(all_strings_pot_path):
|
|
os.remove(all_strings_pot_path)
|
|
|
|
extract_all_strings(root_path, script_path, translations_root_path, all_strings_pot_path)
|
|
update_po_files_all_languages(translations_root_path)
|