[Core] Guild scoped I18n

redbot/cogs/alias/alias.py

@@ -83,7 +83,7 @@ async def get_prefix(self, message: discord.Message) -> str:
         for p in prefixes:
             if content.startswith(p):
                 return p
-        raise ValueError(_("No prefix found."))
+        raise ValueError("No prefix found.")
 
     async def call_alias(self, message: discord.Message, prefix: str, alias: AliasEntry):
         new_message = copy(message)

redbot/core/bot.py

@@ -40,7 +40,7 @@
 from .events import init_events
 from .global_checks import init_global_checks
 
-from .settings_caches import PrefixManager, IgnoreManager, WhitelistBlacklistManager
+from .settings_caches import PrefixManager, IgnoreManager, WhitelistBlacklistManager, I18nManager
 
 from .rpc import RPCMixin
 from .utils import common_filters
@@ -131,6 +131,8 @@ def __init__(self, *args, cli_flags=None, bot_dir: Path = Path.cwd(), **kwargs):
             disabled_commands=[],
             autoimmune_ids=[],
             delete_delay=-1,
+            locale=None,
+            regional_format=None
         )
 
         self._config.register_channel(embeds=None, ignored=False)
@@ -144,6 +146,7 @@ def __init__(self, *args, cli_flags=None, bot_dir: Path = Path.cwd(), **kwargs):
         self._prefix_cache = PrefixManager(self._config, cli_flags)
         self._ignored_cache = IgnoreManager(self._config)
         self._whiteblacklist_cache = WhitelistBlacklistManager(self._config)
+        self._i18n_cache = I18nManager(self._config)
 
         async def prefix_manager(bot, message) -> List[str]:
             prefixes = await self._prefix_cache.get_prefixes(message.guild)

redbot/core/core_commands.py

@@ -1302,7 +1302,7 @@ async def serverprefix(self, ctx: commands.Context, *prefixes: str):
 
     @_set.command()
     @checks.is_owner()
-    async def locale(self, ctx: commands.Context, language_code: str):
+    async def globallocale(self, ctx: commands.Context, language_code: str):
         """
         Changes bot's locale.
 
@@ -1327,11 +1327,44 @@ async def locale(self, ctx: commands.Context, language_code: str):
         standardized_locale_name = f"{locale.language}-{locale.territory}"
         i18n.set_locale(standardized_locale_name)
         await ctx.bot._config.locale.set(standardized_locale_name)
+        await ctx.send(_("Global locale has been set."))
+
+    @_set.command()
+    @checks.guildowner_or_permissions(manage_guild=True)
+    async def locale(self, ctx: commands.Context, language_code: str):
+        """
+        Changes the bot's locale in this server.
+
+        `<language_code>` can be any language code with country code included,
+        e.g. `en-US`, `de-DE`, `fr-FR`, `pl-PL`, etc.
+
+        Go to Red's Crowdin page to see locales that are available with translations:
+        https://translate.discord.red
+
+        Use "default" to return to the bot's default set language.
+        To reset to English, use "en-US".
+        """
+        if language_code.lower() == "default":
+            await self.bot._i18n_cache.set_guild_locale(ctx.guild, None)
+            await ctx.send(_("Locale has been set to the default."))
+            return
+        try:
+            locale = BabelLocale.parse(language_code, sep="-")
+        except (ValueError, UnknownLocaleError):
+            await ctx.send(_("Invalid language code. Use format: `en-US`"))
+            return
+        if locale.territory is None:
+            await ctx.send(
+                _("Invalid format - language code has to include country code, e.g. `en-US`")
+            )
+            return
+        standardized_locale_name = f"{locale.language}-{locale.territory}"
+        await self.bot._i18n_cache.set_guild_locale(ctx.guild, standardized_locale_name)
         await ctx.send(_("Locale has been set."))
 
-    @_set.command(aliases=["region"])
+    @_set.command(aliases=["globalregion"])
     @checks.is_owner()
-    async def regionalformat(self, ctx: commands.Context, language_code: str = None):
+    async def globalregionalformat(self, ctx: commands.Context, language_code: str = None):
         """
         Changes bot's regional format. This is used for formatting date, time and numbers.
 
@@ -1364,6 +1397,7 @@ async def regionalformat(self, ctx: commands.Context, language_code: str = None)
                 language_code=standardized_locale_name
             )
         )
+    # TODO Regional formating i18n bullcrap what was its name again. IDFK
 
     @_set.command()
     @checks.is_owner()

redbot/core/events.py

@@ -15,7 +15,7 @@
 from pkg_resources import DistributionNotFound
 
 from redbot.core.commands import RedHelpFormatter, HelpSettings
-from redbot.core.i18n import Translator
+from redbot.core.i18n import Translator, set_locale, set_context_locale
 from .utils import AsyncIter
 from .. import __version__ as red_version, version_info as red_version_info, VersionInfo
 from . import commands
@@ -294,6 +294,9 @@ async def on_command_error(ctx, error, unhandled_by_cog=False):
 
     @bot.event
     async def on_message(message):
+        locale = await bot._i18n_cache.get_locale(message.guild)
+        set_context_locale(locale)
+
         await bot.process_commands(message)
         discord_now = message.created_at
         if (

redbot/core/i18n.py

@@ -2,8 +2,11 @@
 import functools
 import io
 import os
+import logging
+
 from pathlib import Path
 from typing import Callable, Union, Dict, Optional
+from contextvars import ContextVar
 
 import babel.localedata
 from babel.core import Locale
@@ -17,7 +20,9 @@
     "get_babel_locale",
 ]
 
-_current_locale = "en-US"
+log = logging.getLogger("red.i18n")
+
+_current_locale = ContextVar("_current_locale", default="en-US")
 _current_regional_format = None
 
 WAITING_FOR_MSGID = 1
@@ -32,12 +37,17 @@
 
 
 def get_locale() -> str:
-    return _current_locale
+    return str(_current_locale.get())
 
 
 def set_locale(locale: str) -> None:
     global _current_locale
-    _current_locale = locale
+    _current_locale = ContextVar("_current_locale", default=locale)
+    reload_locales()
+
+
+def set_context_locale(locale: str) -> None:
+    _current_locale.set(locale)
     reload_locales()
 
 
@@ -77,14 +87,18 @@ def _parse(translation_file: io.TextIOWrapper) -> Dict[str, str]:
     untranslated = ""
     translated = ""
     translations = {}
+    locale = get_locale()
+
+    translations[locale] = {}
+
     for line in translation_file:
         line = line.strip()
 
         if line.startswith(MSGID):
             # New msgid
             if step is IN_MSGSTR and translated:
                 # Store the last translation
-                translations[_unescape(untranslated)] = _unescape(translated)
+                translations[locale][_unescape(untranslated)] = _unescape(translated)
             step = IN_MSGID
             untranslated = line[len(MSGID) : -1]
         elif line.startswith('"') and line.endswith('"'):
@@ -101,7 +115,7 @@ def _parse(translation_file: io.TextIOWrapper) -> Dict[str, str]:
 
     if step is IN_MSGSTR and translated:
         # Store the final translation
-        translations[_unescape(untranslated)] = _unescape(translated)
+        translations[locale][_unescape(untranslated)] = _unescape(translated)
     return translations
 
 
@@ -147,6 +161,7 @@ def __init__(self, name: str, file_location: Union[str, Path, os.PathLike]):
         self.cog_folder = Path(file_location).resolve().parent
         self.cog_name = name
         self.translations = {}
+        self.assume_loaded_locale = []
 
         _translators.append(self)
 
@@ -158,20 +173,38 @@ def __call__(self, untranslated: str) -> str:
         This will look for the string in the translator's :code:`.pot` file,
         with respect to the current locale.
         """
+        locale = get_locale()
         try:
-            return self.translations[untranslated]
+            return self.translations[locale][untranslated]
         except KeyError:
+            log.debug(f"missed hit for {locale}/{untranslated[:10]}")
             return untranslated
 
+    def check_cache_for_locale(self, locale: str) -> bool:
+        """Check is an locale exists with in the cache"""
+        if locale in self.translations:
+            return True
+        return False
+
     def load_translations(self):
         """
         Loads the current translations.
         """
-        self.translations = {}
+        locale = get_locale()
+
+        if locale.lower() == "en-us":
+            # Red is written in en-US, no point in loading it
+            return
+        if locale in self.translations:
+            return
+        if locale in self.assume_loaded_locale:
+            return
+
         locale_path = get_locale_path(self.cog_folder, "po")
         with contextlib.suppress(IOError, FileNotFoundError):
             with locale_path.open(encoding="utf-8") as file:
                 self._parse(file)
+        self.assume_loaded_locale.append(locale)
 
     def _parse(self, translation_file):
         self.translations.update(_parse(translation_file))

redbot/core/settings_caches.py

@@ -53,6 +53,32 @@ async def set_prefixes(
             await self._config.guild_from_id(gid).prefix.set(prefixes)
 
 
+class I18nManager:
+    def __init__(self, config: Config):
+        self._config: Config = config
+        self._guild_locale: Dict[int, str] = {}
+
+    async def get_locale(self, guild: Union[discord.Guild, None]) -> Optional[str]:
+        """Get the guild locale from the cache"""
+        if guild is None:
+            # Return the bot's globally set locale if its None on a guild scope.
+            out = await self._config.locale()
+        elif guild.id in self._guild_locale:
+            out = self._guild_locale[guild.id]
+        else:
+            out = await self._config.guild(guild).locale()
+            if out is None:
+                out = await self._config.locale()
+            self._guild_locale[guild.id] = out
+
+        return out
+
+    async def set_guild_locale(self, guild: discord.Guild, locale: Union[str, None]):
+        """Set the guild locale in the cache"""
+        self._guild_locale[guild.id] = locale
+        await self._config.guild(guild).locale.set(locale)
+
+
 class IgnoreManager:
     def __init__(self, config: Config):
         self._config: Config = config