169 lines
5.3 KiB
Python
169 lines
5.3 KiB
Python
import json
|
|
import os.path
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
import yaml
|
|
|
|
from . import Localizer
|
|
|
|
DEFAULT_LANG = "en"
|
|
ALLOWED_LANGS = ["en", "fr"]
|
|
|
|
L10N = Localizer(DEFAULT_LANG, ALLOWED_LANGS)
|
|
|
|
|
|
def reload_strings(strings_root: str) -> None:
|
|
global L10N
|
|
|
|
for allowed_lang in ALLOWED_LANGS:
|
|
print(f"Adding lang '{allowed_lang}'...")
|
|
L10N.add_lang(allowed_lang)
|
|
|
|
for lang_dir in os.listdir(strings_root):
|
|
lang_dir_path = os.path.join(strings_root, lang_dir)
|
|
|
|
if not os.path.isdir(lang_dir_path):
|
|
print(f"Ignoring lang non-folder '{lang_dir}'...")
|
|
continue
|
|
|
|
if lang_dir not in ALLOWED_LANGS:
|
|
print(f"Ignoring lang folder '{lang_dir}'...")
|
|
continue
|
|
|
|
for lang_domain in os.listdir(os.path.join(lang_dir_path)):
|
|
if lang_domain.startswith("_"):
|
|
continue
|
|
|
|
lang_domain_path = os.path.join(os.getcwd(), strings_root, lang_dir, lang_domain)
|
|
|
|
if not os.path.isfile(lang_domain_path):
|
|
continue
|
|
|
|
domain_key = str(Path(lang_domain).with_suffix(''))
|
|
|
|
if lang_domain.endswith(".json"):
|
|
#print(f"Loading JSON lang data from '{lang_domain_path}'...")
|
|
L10N.add_domain(
|
|
lang_dir,
|
|
domain_key,
|
|
json.loads(open(lang_domain_path, "rb").read().decode("utf-8"))
|
|
)
|
|
|
|
if lang_domain.endswith(".yml"):
|
|
#print(f"Loading YAML lang data from '{lang_domain_path}'...")
|
|
L10N.add_domain(
|
|
lang_dir,
|
|
domain_key,
|
|
yaml.safe_load(open(lang_domain_path, "rb").read().decode("utf-8"))
|
|
)
|
|
|
|
|
|
def localize(strings_key: str, domain: str, language: str, args: list[str] = None) -> str:
|
|
global L10N
|
|
# print(f"l10n({strings_key}, {domain}, {language})")
|
|
return L10N.localize(language, domain, strings_key, args)
|
|
|
|
|
|
def get_user_lang(url_lang: Optional[str], header_langs: Optional[str], simplify_entries: bool = True) -> str:
|
|
if url_lang is not None:
|
|
return url_lang
|
|
|
|
if header_langs is None:
|
|
return DEFAULT_LANG
|
|
|
|
processed_header_langs: list[tuple[str, float]] = list()
|
|
processed_header_langs.append((DEFAULT_LANG, 0.01))
|
|
|
|
for header_lang in header_langs.split(","):
|
|
header_lang_parts: list[str] = header_lang.split(";")
|
|
|
|
# Modifying entries without a "q=<float>" part to have a '0.1' value
|
|
if len(header_lang_parts) == 1:
|
|
header_lang_parts.append("0.1")
|
|
|
|
if len(header_lang_parts) != 2:
|
|
continue
|
|
|
|
header_lang_parts: list[str, float]
|
|
|
|
# Simplifying complex entries from "en-US" to "en".
|
|
# We'll ignore duplicates since it won't matter after sorting.
|
|
if simplify_entries and "-" in header_lang_parts[0]:
|
|
header_lang_parts[0] = header_lang_parts[0].split("-")[0]
|
|
|
|
# Only allowing supported languages
|
|
if header_lang_parts[0] not in ALLOWED_LANGS:
|
|
continue
|
|
|
|
# Parsing the language's weight
|
|
try:
|
|
header_lang_parts[1] = float(header_lang_parts[1].replace("q=", ""))
|
|
except ValueError:
|
|
continue
|
|
|
|
processed_header_langs.append((header_lang_parts[0], header_lang_parts[1], ))
|
|
|
|
# Returning the preferred language
|
|
return max(processed_header_langs, key=lambda x: x[1])[0]
|
|
|
|
|
|
def l10n_url_abs(url: str, raw_lang: Optional[str] = None) -> str:
|
|
if raw_lang is None:
|
|
return f"/{url}".replace("//", "/")
|
|
else:
|
|
return f"/{raw_lang}/{url}".replace("//", "/")
|
|
|
|
|
|
def l10n_url_switch(url: str, new_lang: Optional[str] = None) -> str:
|
|
for allowed_lang in ALLOWED_LANGS:
|
|
url = url.replace(f"/{allowed_lang}/", "/")
|
|
|
|
if new_lang is not None:
|
|
url = "/" + new_lang + url
|
|
|
|
return url.replace("//", "/")
|
|
|
|
|
|
# STRINGS = dict()
|
|
# STRINGS[DEFAULT_LANG] = dict()
|
|
# STRINGS["_compile_date"] = "1970-01-01T00:00:00.000000+00:00Z"
|
|
#
|
|
#
|
|
# def reload_strings(strings_file: str) -> None:
|
|
# global STRINGS
|
|
# STRINGS = dict()
|
|
# STRINGS[DEFAULT_LANG] = dict()
|
|
# STRINGS["_compile_date"] = "1970-01-01T00:00:00.000000+00:00Z"
|
|
# STRINGS = json.loads(open(strings_file, "r").read())
|
|
#
|
|
#
|
|
# def localize_internal(string_key: str, language: str, lang_data: dict, fallback: Optional[str]) -> Optional[str]:
|
|
# if language not in ALLOWED_LANGS:
|
|
# return fallback
|
|
#
|
|
# if language not in lang_data.keys():
|
|
# language = DEFAULT_LANG
|
|
#
|
|
# localized_string = lang_data[language].get(string_key)
|
|
# if localized_string is None and language != DEFAULT_LANG:
|
|
# localized_string = lang_data[DEFAULT_LANG].get(string_key)
|
|
#
|
|
# if localized_string is None:
|
|
# return fallback
|
|
# return localized_string
|
|
#
|
|
#
|
|
# def localize(strings_key: str, language: str, extra_lang_data: Optional[dict] = None) -> str:
|
|
# localized_string = None
|
|
#
|
|
# if extra_lang_data is not None:
|
|
# localized_string = localize_internal(strings_key, language, extra_lang_data, None)
|
|
#
|
|
# if localized_string is None:
|
|
# localized_string = localize_internal(strings_key, language, STRINGS, None)
|
|
#
|
|
# if localized_string is None:
|
|
# return f"${strings_key}"
|
|
# return localized_string
|