mirror of
https://github.com/EDCD/EDMarketConnector.git
synced 2025-04-12 15:27:14 +03:00
398 lines
15 KiB
Python
Executable File
398 lines
15 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
l10n.py - Localize using OSX-Style Strings.
|
|
|
|
Copyright (c) EDCD, All Rights Reserved
|
|
Licensed under the GNU General Public License.
|
|
See LICENSE file.
|
|
|
|
Localization with gettext is a pain on non-Unix systems.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import builtins
|
|
import locale
|
|
import numbers
|
|
import re
|
|
import sys
|
|
import warnings
|
|
from contextlib import suppress
|
|
from os import pardir, listdir, sep, makedirs
|
|
from os.path import basename, dirname, isdir, isfile, join, abspath, exists
|
|
from typing import TYPE_CHECKING, Iterable, TextIO, cast
|
|
from config import config
|
|
from EDMCLogging import get_main_logger
|
|
|
|
if TYPE_CHECKING:
|
|
def _(x: str) -> str: return x
|
|
|
|
# Note that this is also done in EDMarketConnector.py, and thus removing this here may not have a desired effect
|
|
try:
|
|
locale.setlocale(locale.LC_ALL, '')
|
|
except Exception:
|
|
# Locale env variables incorrect or locale package not installed/configured on Linux, mysterious reasons on Windows
|
|
print("Can't set locale!")
|
|
|
|
logger = get_main_logger()
|
|
|
|
# Language name
|
|
LANGUAGE_ID = '!Language'
|
|
LOCALISATION_DIR = 'L10n'
|
|
|
|
if sys.platform == 'darwin':
|
|
from Foundation import ( # type: ignore # exists on Darwin
|
|
NSLocale, NSNumberFormatter, NSNumberFormatterDecimalStyle
|
|
)
|
|
|
|
elif sys.platform == 'win32':
|
|
import ctypes
|
|
from ctypes.wintypes import BOOL, DWORD, LPCVOID, LPCWSTR, LPWSTR
|
|
if TYPE_CHECKING:
|
|
import ctypes.windll # type: ignore # Magic to make linters not complain that windll is special
|
|
|
|
# https://msdn.microsoft.com/en-us/library/windows/desktop/dd318124%28v=vs.85%29.aspx
|
|
MUI_LANGUAGE_ID = 4
|
|
MUI_LANGUAGE_NAME = 8
|
|
GetUserPreferredUILanguages = ctypes.windll.kernel32.GetUserPreferredUILanguages
|
|
GetUserPreferredUILanguages.argtypes = [
|
|
DWORD, ctypes.POINTER(ctypes.c_ulong), LPCVOID, ctypes.POINTER(ctypes.c_ulong)
|
|
]
|
|
|
|
GetUserPreferredUILanguages.restype = BOOL
|
|
|
|
LOCALE_NAME_USER_DEFAULT = None
|
|
GetNumberFormatEx = ctypes.windll.kernel32.GetNumberFormatEx
|
|
GetNumberFormatEx.argtypes = [LPCWSTR, DWORD, LPCWSTR, LPCVOID, LPWSTR, ctypes.c_int]
|
|
GetNumberFormatEx.restype = ctypes.c_int
|
|
|
|
|
|
class _Translations:
|
|
|
|
FALLBACK = 'en' # strings in this code are in English
|
|
FALLBACK_NAME = 'English'
|
|
|
|
TRANS_RE = re.compile(r'\s*"((?:[^"]|\")+)"\s*=\s*"((?:[^"]|\")+)"\s*;\s*$')
|
|
COMMENT_RE = re.compile(r'\s*/\*.*\*/\s*$')
|
|
|
|
def __init__(self) -> None:
|
|
self.translations: dict[str | None, dict[str, str]] = {None: {}}
|
|
|
|
def install_dummy(self) -> None:
|
|
"""
|
|
Install a dummy translation function.
|
|
|
|
Use when translation is not desired or not available
|
|
"""
|
|
self.translations = {None: {}}
|
|
builtins.__dict__['_'] = lambda x: str(x).replace(r'\"', '"').replace('{CR}', '\n')
|
|
|
|
def install(self, lang: str | None = None) -> None: # noqa: CCR001
|
|
"""
|
|
Install the translation function to the _ builtin.
|
|
|
|
:param lang: The language to translate to, defaults to the preferred language
|
|
"""
|
|
available = self.available()
|
|
available.add(_Translations.FALLBACK)
|
|
if not lang:
|
|
# Choose the default language
|
|
for preferred in Locale.preferred_languages():
|
|
components = preferred.split('-')
|
|
if preferred in available:
|
|
lang = preferred
|
|
|
|
elif '-'.join(components[0:2]) in available:
|
|
lang = '-'.join(components[0:2]) # language-script
|
|
|
|
elif components[0] in available:
|
|
lang = components[0] # just base language
|
|
|
|
if lang:
|
|
break
|
|
|
|
if lang not in self.available():
|
|
self.install_dummy()
|
|
return
|
|
|
|
self.translations = {None: self.contents(cast(str, lang))}
|
|
for plugin in listdir(config.plugin_dir_path):
|
|
plugin_path = join(config.plugin_dir_path, plugin, LOCALISATION_DIR)
|
|
if isdir(plugin_path):
|
|
try:
|
|
self.translations[plugin] = self.contents(cast(str, lang), str(plugin_path))
|
|
|
|
except UnicodeDecodeError as e:
|
|
logger.warning(f'Malformed file {lang}.strings in plugin {plugin}: {e}')
|
|
|
|
except Exception:
|
|
logger.exception(f'Exception occurred while parsing {lang}.strings in plugin {plugin}')
|
|
|
|
builtins.__dict__['_'] = self.translate
|
|
|
|
def contents(self, lang: str, plugin_path: str | None = None) -> dict[str, str]:
|
|
"""Load all the translations from a translation file."""
|
|
assert lang in self.available()
|
|
translations = {}
|
|
|
|
h = self.file(lang, plugin_path)
|
|
if not h:
|
|
return {}
|
|
|
|
for line in h:
|
|
if line.strip():
|
|
match = _Translations.TRANS_RE.match(line)
|
|
if match:
|
|
to_set = match.group(2).replace(r'\"', '"').replace('{CR}', '\n')
|
|
translations[match.group(1).replace(r'\"', '"')] = to_set
|
|
|
|
elif not _Translations.COMMENT_RE.match(line):
|
|
logger.debug(f'Bad translation: {line.strip()}')
|
|
h.close()
|
|
|
|
if translations.get(LANGUAGE_ID, LANGUAGE_ID) == LANGUAGE_ID:
|
|
translations[LANGUAGE_ID] = str(lang) # Replace language name with code if missing
|
|
|
|
return translations
|
|
|
|
def translate(self, x: str, context: str | None = None) -> str:
|
|
"""
|
|
Translate the given string to the current lang.
|
|
|
|
:param x: The string to translate
|
|
:param context: Whether or not to search the given directory for translation files, defaults to None
|
|
:return: The translated string
|
|
"""
|
|
if context:
|
|
# TODO: There is probably a better way to go about this now.
|
|
context = context[len(config.plugin_dir)+1:].split(sep)[0]
|
|
if self.translations[None] and context not in self.translations:
|
|
logger.debug(f'No translations for {context!r}')
|
|
|
|
return self.translations.get(context, {}).get(x) or self.translate(x)
|
|
|
|
if self.translations[None] and x not in self.translations[None]:
|
|
logger.debug(f'Missing translation: {x!r}')
|
|
|
|
return self.translations[None].get(x) or str(x).replace(r'\"', '"').replace('{CR}', '\n')
|
|
|
|
def available(self) -> set[str]:
|
|
"""Return a list of available language codes."""
|
|
path = self.respath()
|
|
if getattr(sys, 'frozen', False) and sys.platform == 'darwin':
|
|
available = {
|
|
x[:-len('.lproj')] for x in listdir(path)
|
|
if x.endswith('.lproj') and isfile(join(x, 'Localizable.strings'))
|
|
}
|
|
|
|
else:
|
|
available = {x[:-len('.strings')] for x in listdir(path) if x.endswith('.strings')}
|
|
|
|
return available
|
|
|
|
def available_names(self) -> dict[str | None, str]:
|
|
"""Available language names by code."""
|
|
names: dict[str | None, str] = {
|
|
# LANG: The system default language choice in Settings > Appearance
|
|
None: _('Default'), # Appearance theme and language setting
|
|
}
|
|
names.update(sorted(
|
|
[(lang, self.contents(lang).get(LANGUAGE_ID, lang)) for lang in self.available()] +
|
|
[(_Translations.FALLBACK, _Translations.FALLBACK_NAME)],
|
|
key=lambda x: x[1]
|
|
)) # Sort by name
|
|
|
|
return names
|
|
|
|
def respath(self) -> str:
|
|
"""Path to localisation files."""
|
|
if getattr(sys, 'frozen', False):
|
|
if sys.platform == 'darwin':
|
|
return abspath(join(dirname(sys.executable), pardir, 'Resources'))
|
|
|
|
return abspath(join(dirname(sys.executable), LOCALISATION_DIR))
|
|
|
|
if __file__:
|
|
return abspath(join(dirname(__file__), LOCALISATION_DIR))
|
|
|
|
return abspath(LOCALISATION_DIR)
|
|
|
|
def file(self, lang: str, plugin_path: str | None = None) -> TextIO | None:
|
|
"""
|
|
Open the given lang file for reading.
|
|
|
|
:param lang: The lang file to open (just the name of the lang)
|
|
:param plugin_path: path to plugins dir, to check for plugin based lang files, defaults to None
|
|
:return: the opened file (Note: This should be closed when done)
|
|
"""
|
|
if plugin_path:
|
|
file_path = join(plugin_path, f'{lang}.strings')
|
|
if not exists(file_path):
|
|
return None
|
|
|
|
try:
|
|
return open(file_path, encoding='utf-8')
|
|
except OSError:
|
|
logger.exception(f'could not open {file_path}')
|
|
|
|
elif getattr(sys, 'frozen', False) and sys.platform == 'darwin':
|
|
res_path = join(self.respath(), f'{lang}.lproj', 'Localizable.strings')
|
|
return open(res_path, encoding='utf-16')
|
|
|
|
res_path = join(self.respath(), f'{lang}.strings')
|
|
return open(res_path, encoding='utf-8')
|
|
|
|
|
|
class _Locale:
|
|
"""Locale holds a few utility methods to convert data to and from localized versions."""
|
|
|
|
def __init__(self) -> None:
|
|
if sys.platform == 'darwin':
|
|
self.int_formatter = NSNumberFormatter.alloc().init()
|
|
self.int_formatter.setNumberStyle_(NSNumberFormatterDecimalStyle)
|
|
self.float_formatter = NSNumberFormatter.alloc().init()
|
|
self.float_formatter.setNumberStyle_(NSNumberFormatterDecimalStyle)
|
|
self.float_formatter.setMinimumFractionDigits_(5)
|
|
self.float_formatter.setMaximumFractionDigits_(5)
|
|
|
|
def stringFromNumber(self, number: float | int, decimals: int | None = None) -> str: # noqa: N802
|
|
warnings.warn(DeprecationWarning('use _Locale.string_from_number instead.'))
|
|
return self.string_from_number(number, decimals) # type: ignore
|
|
|
|
def numberFromString(self, string: str) -> int | float | None: # noqa: N802
|
|
warnings.warn(DeprecationWarning('use _Locale.number_from_string instead.'))
|
|
return self.number_from_string(string)
|
|
|
|
def preferredLanguages(self) -> Iterable[str]: # noqa: N802
|
|
warnings.warn(DeprecationWarning('use _Locale.preferred_languages instead.'))
|
|
return self.preferred_languages()
|
|
|
|
def string_from_number(self, number: float | int, decimals: int = 5) -> str:
|
|
"""
|
|
Convert a number to a string.
|
|
|
|
Uses the current system locale, irrespective of language choice.
|
|
|
|
:param number: The number to stringify
|
|
:param decimals: The number of decimals to return, defaults to 5 if the given number is a float, otherwise None
|
|
:return: the stringified number
|
|
"""
|
|
if decimals == 0 and not isinstance(number, numbers.Integral):
|
|
number = int(round(number))
|
|
|
|
if sys.platform == 'darwin':
|
|
if not decimals and isinstance(number, numbers.Integral):
|
|
return self.int_formatter.stringFromNumber_(number)
|
|
|
|
self.float_formatter.setMinimumFractionDigits_(decimals)
|
|
self.float_formatter.setMaximumFractionDigits_(decimals)
|
|
return self.float_formatter.stringFromNumber_(number)
|
|
|
|
if not decimals and isinstance(number, numbers.Integral):
|
|
return locale.format_string('%d', number, True)
|
|
return locale.format_string('%.*f', (decimals, number), True)
|
|
|
|
def number_from_string(self, string: str) -> int | float | None:
|
|
"""
|
|
Convert a string to a number using the system locale.
|
|
|
|
Note that this uses the current SYSTEM locale regardless of set language.
|
|
:param string: The string to convert
|
|
:return: None if the string cannot be parsed, otherwise an int or float dependant on input data.
|
|
"""
|
|
if sys.platform == 'darwin':
|
|
return self.float_formatter.numberFromString_(string)
|
|
|
|
with suppress(ValueError):
|
|
return locale.atoi(string)
|
|
|
|
with suppress(ValueError):
|
|
return locale.atof(string)
|
|
|
|
return None
|
|
|
|
def wszarray_to_list(self, array):
|
|
offset = 0
|
|
while offset < len(array):
|
|
sz = ctypes.wstring_at(ctypes.addressof(array) + offset * 2) # type: ignore
|
|
if sz:
|
|
yield sz
|
|
offset += len(sz) + 1
|
|
else:
|
|
break
|
|
|
|
def preferred_languages(self) -> Iterable[str]:
|
|
"""
|
|
Return a list of preferred language codes.
|
|
|
|
Returned data is in RFC4646 format (i.e. "lang[-script][-region]")
|
|
Where lang is a lowercase 2 alpha ISO 693-1 or 3 alpha ISO 693-2 code
|
|
Where script is a capitalized 4 alpha ISO 15924 code
|
|
Where region is an uppercase 2 alpha ISO 3166 code
|
|
|
|
:return: The preferred language list
|
|
"""
|
|
languages: Iterable[str]
|
|
if sys.platform == 'darwin':
|
|
languages = NSLocale.preferredLanguages()
|
|
|
|
elif sys.platform != 'win32':
|
|
# POSIX
|
|
lang = locale.getlocale()[0]
|
|
languages = [lang.replace('_', '-')] if lang else []
|
|
|
|
else:
|
|
num = ctypes.c_ulong()
|
|
size = ctypes.c_ulong(0)
|
|
languages = []
|
|
if GetUserPreferredUILanguages(
|
|
MUI_LANGUAGE_NAME, ctypes.byref(num), None, ctypes.byref(size)
|
|
) and size.value:
|
|
buf = ctypes.create_unicode_buffer(size.value)
|
|
|
|
if GetUserPreferredUILanguages(
|
|
MUI_LANGUAGE_NAME, ctypes.byref(num), ctypes.byref(buf), ctypes.byref(size)
|
|
):
|
|
languages = self.wszarray_to_list(buf)
|
|
|
|
# HACK: <n/a> | 2021-12-11: OneSky calls "Chinese Simplified" "zh-Hans"
|
|
# in the name of the file, but that will be zh-CN in terms of
|
|
# locale. So map zh-CN -> zh-Hans
|
|
languages = ['zh-Hans' if lang == 'zh-CN' else lang for lang in languages]
|
|
|
|
return languages
|
|
|
|
|
|
# singletons
|
|
Locale = _Locale()
|
|
Translations = _Translations()
|
|
|
|
|
|
# generate template strings file - like xgettext
|
|
# parsing is limited - only single ' or " delimited strings, and only one string per line
|
|
if __name__ == "__main__":
|
|
regexp = re.compile(r'''_\([ur]?(['"])(((?<!\\)\\\1|.)+?)\1\)[^#]*(#.+)?''') # match a single line python literal
|
|
seen: dict[str, str] = {}
|
|
for f in (
|
|
sorted(x for x in listdir('.') if x.endswith('.py')) +
|
|
sorted(join('plugins', x) for x in (listdir('plugins') if isdir('plugins') else []) if x.endswith('.py'))
|
|
):
|
|
with open(f, encoding='utf-8') as h:
|
|
lineno = 0
|
|
for line in h:
|
|
lineno += 1
|
|
match = regexp.search(line)
|
|
if match and not seen.get(match.group(2)): # only record first commented instance of a string
|
|
seen[match.group(2)] = (
|
|
(match.group(4) and (match.group(4)[1:].strip()) + '. ' or '') + f'[{basename(f)}]'
|
|
)
|
|
if seen:
|
|
target_path = join(LOCALISATION_DIR, 'en.template.new')
|
|
makedirs(dirname(target_path), exist_ok=True)
|
|
with open(target_path, 'w', encoding='utf-8') as target_file:
|
|
target_file.write(f'/* Language name */\n"{LANGUAGE_ID}" = "English";\n\n')
|
|
for thing in sorted(seen, key=str.lower):
|
|
if seen[thing]:
|
|
target_file.write(f'/* {seen[thing]} */\n')
|
|
|
|
target_file.write(f'"{thing}" = "{thing}";\n\n')
|