162 lines
5.3 KiB
Python
162 lines
5.3 KiB
Python
import gettext
|
|
import logging
|
|
from contextvars import ContextVar
|
|
from collections import defaultdict
|
|
from enum import Enum
|
|
|
|
from discord.app_commands import Translator, locale_str
|
|
from discord.enums import Locale
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
SOURCE_LOCALE = 'en-GB'
|
|
ctx_locale: ContextVar[str] = ContextVar('locale', default=SOURCE_LOCALE)
|
|
ctx_translator: ContextVar['LeoBabel'] = ContextVar('translator', default=None) # type: ignore
|
|
|
|
null = gettext.NullTranslations()
|
|
|
|
|
|
class LeoBabel(Translator):
|
|
def __init__(self):
|
|
self.supported_locales = {loc.name for loc in Locale}
|
|
self.supported_domains = {}
|
|
self.translators = defaultdict(dict) # locale -> domain -> GNUTranslator
|
|
|
|
def read_supported(self):
|
|
"""
|
|
Load supported localisations and domains from the config.
|
|
"""
|
|
from meta import conf
|
|
|
|
locales = conf.babel.get('locales', '')
|
|
stripped = (loc.strip(', ') for loc in locales.split(','))
|
|
self.supported_locales = {loc for loc in stripped if loc}
|
|
self.supported_locales.add(SOURCE_LOCALE)
|
|
|
|
domains = conf.babel.get('domains', '')
|
|
stripped = (dom.strip(', ') for dom in domains.split(','))
|
|
self.supported_domains = {dom for dom in stripped if dom}
|
|
|
|
async def load(self):
|
|
self._load()
|
|
|
|
def _load(self):
|
|
"""
|
|
Initialise the gettext translators for the supported_locales.
|
|
"""
|
|
self.read_supported()
|
|
for locale in self.supported_locales:
|
|
for domain in self.supported_domains:
|
|
if locale == SOURCE_LOCALE:
|
|
continue
|
|
try:
|
|
translator = gettext.translation(domain, "locales/", languages=[locale])
|
|
except OSError:
|
|
# Presume translation does not exist
|
|
logger.warning(f"Could not load translator for supported <locale: {locale}> <domain: {domain}>")
|
|
pass
|
|
else:
|
|
logger.debug(f"Loaded translator for <locale: {locale}> <domain: {domain}>")
|
|
self.translators[locale][domain] = translator
|
|
|
|
async def unload(self):
|
|
self.translators.clear()
|
|
|
|
def get_translator(self, locale, domain):
|
|
if locale == SOURCE_LOCALE:
|
|
return null
|
|
|
|
translator = self.translators[locale].get(domain, None)
|
|
if translator is None:
|
|
logger.warning(
|
|
f"Translator missing for requested <locale: {locale}> and <domain: {domain}>. Setting NullTranslator."
|
|
)
|
|
self.translators[locale][domain] = null
|
|
translator = null
|
|
return translator
|
|
|
|
def t(self, lazystr, locale=None):
|
|
domain = lazystr.domain
|
|
translator = self.get_translator(locale or lazystr.locale or ctx_locale.get(), domain)
|
|
return lazystr._translate_with(translator)
|
|
|
|
async def translate(self, string: locale_str, locale: Locale, context):
|
|
if locale.value in self.supported_locales:
|
|
domain = string.extras.get('domain', None)
|
|
if domain is None and isinstance(string, LazyStr):
|
|
logger.debug(
|
|
f"LeoBabel cannot translate a locale_str with no domain set. Context: {context}, String: {string}"
|
|
)
|
|
return None
|
|
|
|
translator = self.get_translator(locale.value, domain)
|
|
if not isinstance(string, LazyStr):
|
|
lazy = LazyStr(Method.GETTEXT, string.message)
|
|
else:
|
|
lazy = string
|
|
return lazy._translate_with(translator)
|
|
|
|
|
|
class Method(Enum):
|
|
GETTEXT = 'gettext'
|
|
NGETTEXT = 'ngettext'
|
|
PGETTEXT = 'pgettext'
|
|
NPGETTEXT = 'npgettext'
|
|
|
|
|
|
class LocalBabel:
|
|
def __init__(self, domain):
|
|
self.domain = domain
|
|
|
|
@property
|
|
def methods(self):
|
|
return (self._, self._n, self._p, self._np)
|
|
|
|
def _(self, message):
|
|
return LazyStr(Method.GETTEXT, message, domain=self.domain)
|
|
|
|
def _n(self, singular, plural, n):
|
|
return LazyStr(Method.NGETTEXT, singular, plural, n, domain=self.domain)
|
|
|
|
def _p(self, context, message):
|
|
return LazyStr(Method.PGETTEXT, context, message, domain=self.domain)
|
|
|
|
def _np(self, context, singular, plural, n):
|
|
return LazyStr(Method.NPGETTEXT, context, singular, plural, n, domain=self.domain)
|
|
|
|
|
|
class LazyStr(locale_str):
|
|
__slots__ = ('method', 'args', 'domain', 'locale')
|
|
|
|
def __init__(self, method, *args, locale=None, domain=None):
|
|
self.method = method
|
|
self.args = args
|
|
self.domain = domain
|
|
self.locale = locale
|
|
|
|
@property
|
|
def message(self):
|
|
return self._translate_with(null)
|
|
|
|
@property
|
|
def extras(self):
|
|
return {'locale': self.locale, 'domain': self.domain}
|
|
|
|
def __str__(self):
|
|
return self.message
|
|
|
|
def _translate_with(self, translator: gettext.GNUTranslations):
|
|
method = getattr(translator, self.method.value)
|
|
return method(*self.args)
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{self.__class__.__name__}({self.method}, {self.args!r}, locale={self.locale}, domain={self.domain})'
|
|
|
|
def __eq__(self, obj: object) -> bool:
|
|
return isinstance(obj, locale_str) and self.message == obj.message
|
|
|
|
def __hash__(self) -> int:
|
|
return hash(self.args)
|