mirror of
https://github.com/brandons209/Red-bot-Cogs.git
synced 2024-05-07 05:53:13 +12:00
457 lines
18 KiB
Python
457 lines
18 KiB
Python
import discord
|
|
import logging
|
|
from typing import Optional, Union
|
|
|
|
from discord.ext.commands.errors import BadArgument
|
|
from redbot.core import Config, checks, commands, version_info, VersionInfo
|
|
from redbot.core.i18n import Translator, cog_i18n
|
|
from redbot.core.utils.chat_formatting import humanize_list, error
|
|
|
|
from .api import FlagTranslation, GoogleTranslateAPI
|
|
from .converters import ChannelUserRole
|
|
from .errors import GoogleTranslateAPIError
|
|
|
|
"""
|
|
Translator cog
|
|
|
|
Cog credit to aziz#5919 for the idea and
|
|
|
|
Links
|
|
|
|
Wiki https://goo.gl/3fxjSA
|
|
GitHub https://goo.gl/oQAQde
|
|
Support the developer https://goo.gl/Brchj4
|
|
Invite the bot to your guild https://goo.gl/aQm2G7
|
|
Join the official development guild https://discord.gg/uekTNPj
|
|
"""
|
|
|
|
BASE_URL = "https://translation.googleapis.com"
|
|
_ = Translator("Translate", __file__)
|
|
log = logging.getLogger("red.trusty-cogs.Translate")
|
|
|
|
|
|
@cog_i18n(_)
|
|
class Translate(GoogleTranslateAPI, commands.Cog):
|
|
"""
|
|
Translate messages using Google Translate
|
|
"""
|
|
|
|
__author__ = ["Aziz", "TrustyJAID"]
|
|
__version__ = "2.3.7"
|
|
|
|
def __init__(self, bot):
|
|
self.bot = bot
|
|
self.config = Config.get_conf(self, 156434873547585, force_registration=True)
|
|
default_guild = {
|
|
"reaction": False,
|
|
"text": False,
|
|
"whitelist": [],
|
|
"blacklist": [],
|
|
"count": {"characters": 0, "requests": 0, "detect": 0},
|
|
"autosend": {},
|
|
}
|
|
default = {
|
|
"cooldown": {"past_flags": [], "timeout": 0, "multiple": False},
|
|
"count": {"characters": 0, "requests": 0, "detect": 0},
|
|
}
|
|
self.config.register_guild(**default_guild)
|
|
self.config.register_global(**default)
|
|
self.cache = {
|
|
"translations": [],
|
|
"cooldown_translations": {},
|
|
"guild_messages": [],
|
|
"guild_reactions": [],
|
|
"cooldown": {},
|
|
"guild_blacklist": {},
|
|
"guild_whitelist": {},
|
|
"autolangs": {},
|
|
}
|
|
self._key: Optional[str] = None
|
|
self._clear_cache = self.bot.loop.create_task(self.cleanup_cache())
|
|
self._save_loop = self.bot.loop.create_task(self.save_usage())
|
|
self._guild_counter = {}
|
|
self._global_counter = {}
|
|
|
|
def format_help_for_context(self, ctx: commands.Context) -> str:
|
|
"""
|
|
Thanks Sinbad!
|
|
"""
|
|
pre_processed = super().format_help_for_context(ctx)
|
|
return f"{pre_processed}\n\nCog Version: {self.__version__}"
|
|
|
|
async def red_delete_data_for_user(self, **kwargs):
|
|
"""
|
|
Nothing to delete
|
|
"""
|
|
return
|
|
|
|
async def init(self) -> None:
|
|
try:
|
|
key = await self.config.api_key()
|
|
except AttributeError:
|
|
return
|
|
try:
|
|
central_key = await self.bot.get_shared_api_tokens("google_translate")
|
|
except AttributeError:
|
|
# Red 3.1 support
|
|
central_key = await self.bot.db.api_tokens.get_raw("google_translate", default={})
|
|
if not central_key:
|
|
try:
|
|
await self.bot.set_shared_api_tokens("google_translate", api_key=key)
|
|
except AttributeError:
|
|
await self.bot.db.api_tokens.set_raw("google_translate", value={"api_key": key})
|
|
await self.config.api_key.clear()
|
|
self._global_counter = await self.config.count()
|
|
all_guilds = await self.config.all_guilds()
|
|
for g_id, data in all_guilds.items():
|
|
self._guild_counter[g_id] = data["count"]
|
|
|
|
@commands.command()
|
|
async def translate(
|
|
self,
|
|
ctx: commands.Context,
|
|
to_language: FlagTranslation,
|
|
*,
|
|
message: Union[discord.Message, str],
|
|
) -> None:
|
|
"""
|
|
Translate messages with Google Translate
|
|
|
|
`<to_language>` is the language you would like to translate
|
|
`<message>` is the message to translate, this can be words you want
|
|
to translate, a channelID-messageID from SHIFT + clicking a message and copying ID,
|
|
a message ID from the current channel, or message link
|
|
"""
|
|
if not await self._get_google_api_key():
|
|
msg = _("The bot owner needs to set an api key first!")
|
|
await ctx.send(msg)
|
|
return
|
|
author = ctx.message.author
|
|
requestor = ctx.message.author
|
|
msg = ctx.message
|
|
if isinstance(message, discord.Message):
|
|
msg = message
|
|
author = message.author
|
|
message = message.clean_content
|
|
try:
|
|
detected_lang = await self.detect_language(message)
|
|
await self.add_detect(ctx.guild)
|
|
except GoogleTranslateAPIError as e:
|
|
await ctx.send(str(e))
|
|
return
|
|
from_lang = detected_lang[0][0]["language"]
|
|
original_lang = detected_lang[0][0]["language"]
|
|
if to_language == original_lang:
|
|
return await ctx.send(
|
|
_("I cannot translate `{from_lang}` to `{to}`").format(from_lang=from_lang, to=to_language)
|
|
)
|
|
try:
|
|
translated_text = await self.translate_text(original_lang, to_language, message)
|
|
await self.add_requests(ctx.guild, message)
|
|
except GoogleTranslateAPIError as e:
|
|
await ctx.send(str(e))
|
|
return
|
|
|
|
if ctx.channel.permissions_for(ctx.me).embed_links:
|
|
translation = (translated_text, from_lang, to_language)
|
|
em = await self.translation_embed(author, translation, requestor)
|
|
if version_info >= VersionInfo.from_str("3.4.6") and msg.channel.id == ctx.channel.id:
|
|
await ctx.send(embed=em, reference=msg, mention_author=False)
|
|
else:
|
|
await ctx.send(embed=em)
|
|
else:
|
|
if version_info >= VersionInfo.from_str("3.4.6") and msg.channel.id == ctx.channel.id:
|
|
await ctx.send(translated_text, reference=msg, mention_author=False)
|
|
else:
|
|
await ctx.send(translated_text)
|
|
|
|
@commands.group()
|
|
async def translateset(self, ctx: commands.Context) -> None:
|
|
"""
|
|
Toggle the bot auto translating
|
|
"""
|
|
pass
|
|
|
|
@translateset.command(name="auto")
|
|
async def translate_auto(self, ctx: commands.Context, languages: str, *links: discord.TextChannel) -> None:
|
|
"""
|
|
Set channels to auto translate messages from and to
|
|
|
|
All channels will be linked together, that is every channel's messages will be translated to every other channel.
|
|
|
|
Languages should be the **receive language** that every message sent to it should be translated to.
|
|
|
|
**languages** should be a comma seperated list of languages with no spaces matching the links!
|
|
"""
|
|
langs = [l.strip() for l in languages.strip().split(",")]
|
|
if len(langs) != len(links):
|
|
return await ctx.send(error("The number of lanuages and link channels don't match!"), delete_after=30)
|
|
|
|
await self.config.guild(ctx.guild).autosend.set({l.id: lang for l, lang in zip(links, langs)})
|
|
await ctx.tick()
|
|
|
|
@translateset.command(name="stats")
|
|
async def translate_stats(self, ctx: commands.Context, guild_id: Optional[int]):
|
|
"""
|
|
Shows translation usage
|
|
"""
|
|
if guild_id and not await self.bot.is_owner(ctx.author):
|
|
return await ctx.send(_("That is only available for the bot owner."))
|
|
elif guild_id and await self.bot.is_owner(ctx.author):
|
|
if not (guild := self.bot.get_guild(guild_id)):
|
|
return await ctx.send(_("Guild `{guild_id}` not found.").format(guild_id=guild_id))
|
|
else:
|
|
guild = ctx.guild
|
|
tr_keys = {
|
|
"requests": _("API Requests:"),
|
|
"detect": _("API Detect Language:"),
|
|
"characters": _("Characters requested:"),
|
|
}
|
|
count = (
|
|
self._guild_counter[guild.id] if guild.id in self._guild_counter else await self.config.guild(guild).count()
|
|
)
|
|
gl_count = self._global_counter if self._global_counter else await self.config.count()
|
|
msg = _("__Global Usage__:\n")
|
|
for key, value in gl_count.items():
|
|
msg += tr_keys[key] + f" **{value}**\n"
|
|
msg += _("__{guild} Usage__:\n").format(guild=guild.name)
|
|
for key, value in count.items():
|
|
msg += tr_keys[key] + f" **{value}**\n"
|
|
await ctx.maybe_send_embed(msg)
|
|
|
|
@translateset.group(aliases=["blocklist"])
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def blacklist(self, ctx: commands.Context) -> None:
|
|
"""
|
|
Set blacklist options for translations
|
|
|
|
blacklisting supports channels, users, or roles
|
|
"""
|
|
pass
|
|
|
|
@translateset.group(aliases=["allowlist"])
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def whitelist(self, ctx: commands.Context) -> None:
|
|
"""
|
|
Set whitelist options for translations
|
|
|
|
whitelisting supports channels, users, or roles
|
|
"""
|
|
pass
|
|
|
|
@whitelist.command(name="add")
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def whitelist_add(self, ctx: commands.Context, *channel_user_role: ChannelUserRole) -> None:
|
|
"""
|
|
Add a channel, user, or role to translation whitelist
|
|
"""
|
|
if len(channel_user_role) < 1:
|
|
return await ctx.send(_("You must supply 1 or more channels users or roles to be whitelisted."))
|
|
for obj in channel_user_role:
|
|
if obj.id not in await self.config.guild(ctx.guild).whitelist():
|
|
async with self.config.guild(ctx.guild).whitelist() as whitelist:
|
|
whitelist.append(obj.id)
|
|
await self._bw_list_cache_update(ctx.guild)
|
|
msg = _("`{list_type}` added to translation whitelist.")
|
|
list_type = humanize_list([c.name for c in channel_user_role])
|
|
await ctx.send(msg.format(list_type=list_type))
|
|
|
|
@whitelist.command(name="remove", aliases=["rem", "del"])
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def whitelist_remove(self, ctx: commands.Context, *channel_user_role: ChannelUserRole) -> None:
|
|
"""
|
|
Remove a channel, user, or role from translation whitelist
|
|
"""
|
|
if len(channel_user_role) < 1:
|
|
return await ctx.send(
|
|
_("You must supply 1 or more channels, users, " "or roles to be removed from the whitelist")
|
|
)
|
|
for obj in channel_user_role:
|
|
if obj.id in await self.config.guild(ctx.guild).whitelist():
|
|
async with self.config.guild(ctx.guild).whitelist() as whitelist:
|
|
whitelist.remove(obj.id)
|
|
await self._bw_list_cache_update(ctx.guild)
|
|
msg = _("`{list_type}` removed from translation whitelist.")
|
|
list_type = humanize_list([c.name for c in channel_user_role])
|
|
await ctx.send(msg.format(list_type=list_type))
|
|
|
|
@whitelist.command(name="list")
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def whitelist_list(self, ctx: commands.Context) -> None:
|
|
"""
|
|
List Channels, Users, and Roles in the servers translation whitelist.
|
|
"""
|
|
whitelist = []
|
|
for _id in await self.config.guild(ctx.guild).whitelist():
|
|
try:
|
|
whitelist.append(await ChannelUserRole().convert(ctx, str(_id)))
|
|
except BadArgument:
|
|
continue
|
|
whitelist_s = ", ".join(x.name for x in whitelist)
|
|
await ctx.send(_("`{whitelisted}` are currently whitelisted.").format(whitelisted=whitelist_s))
|
|
|
|
@blacklist.command(name="add")
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def blacklist_add(self, ctx: commands.Context, *channel_user_role: ChannelUserRole) -> None:
|
|
"""
|
|
Add a channel, user, or role to translation blacklist
|
|
"""
|
|
if len(channel_user_role) < 1:
|
|
return await ctx.send(_("You must supply 1 or more channels users or roles to be blacklisted."))
|
|
for obj in channel_user_role:
|
|
if obj.id not in await self.config.guild(ctx.guild).blacklist():
|
|
async with self.config.guild(ctx.guild).blacklist() as blacklist:
|
|
blacklist.append(obj.id)
|
|
await self._bw_list_cache_update(ctx.guild)
|
|
msg = _("`{list_type}` added to translation blacklist.")
|
|
list_type = humanize_list([c.name for c in channel_user_role])
|
|
await ctx.send(msg.format(list_type=list_type))
|
|
|
|
@blacklist.command(name="remove", aliases=["rem", "del"])
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def blacklist_remove(self, ctx: commands.Context, *channel_user_role: ChannelUserRole) -> None:
|
|
"""
|
|
Remove a channel, user, or role from translation blacklist
|
|
"""
|
|
if len(channel_user_role) < 1:
|
|
return await ctx.send(
|
|
_("You must supply 1 or more channels, users, " "or roles to be removed from the blacklist")
|
|
)
|
|
for obj in channel_user_role:
|
|
if obj.id in await self.config.guild(ctx.guild).blacklist():
|
|
async with self.config.guild(ctx.guild).blacklist() as blacklist:
|
|
blacklist.remove(obj.id)
|
|
await self._bw_list_cache_update(ctx.guild)
|
|
msg = _("`{list_type}` removed from translation blacklist.")
|
|
list_type = humanize_list([c.name for c in channel_user_role])
|
|
await ctx.send(msg.format(list_type=list_type))
|
|
|
|
@blacklist.command(name="list")
|
|
@checks.mod_or_permissions(manage_messages=True)
|
|
@commands.guild_only()
|
|
async def blacklist_list(self, ctx: commands.Context) -> None:
|
|
"""
|
|
List Channels, Users, and Roles in the servers translation blacklist.
|
|
"""
|
|
blacklist = []
|
|
for _id in await self.config.guild(ctx.guild).blacklist():
|
|
try:
|
|
blacklist.append(await ChannelUserRole().convert(ctx, str(_id)))
|
|
except BadArgument:
|
|
continue
|
|
blacklist_s = ", ".join(x.name for x in blacklist)
|
|
await ctx.send(_("`{blacklisted}` are currently blacklisted.").format(blacklisted=blacklist_s))
|
|
|
|
@translateset.command(aliases=["reaction", "reactions"])
|
|
@checks.mod_or_permissions(manage_channels=True)
|
|
@commands.guild_only()
|
|
async def react(self, ctx: commands.Context) -> None:
|
|
"""
|
|
Toggle translations to flag emoji reactions
|
|
"""
|
|
guild = ctx.message.guild
|
|
toggle = not await self.config.guild(guild).reaction()
|
|
if toggle:
|
|
verb = _("on")
|
|
else:
|
|
verb = _("off")
|
|
if guild.id in self.cache["guild_reactions"]:
|
|
self.cache["guild_reactions"].remove(guild.id)
|
|
await self.config.guild(guild).reaction.set(toggle)
|
|
msg = _("Reaction translations have been turned ")
|
|
await ctx.send(msg + verb)
|
|
|
|
@translateset.command(aliases=["multi"])
|
|
@checks.is_owner()
|
|
@commands.guild_only()
|
|
async def multiple(self, ctx: commands.Context) -> None:
|
|
"""
|
|
Toggle multiple translations for the same message
|
|
|
|
This will also ignore the translated message from
|
|
being translated into another language
|
|
"""
|
|
toggle = not await self.config.cooldown.multiple()
|
|
if toggle:
|
|
verb = _("on")
|
|
else:
|
|
verb = _("off")
|
|
await self.config.cooldown.multiple.set(toggle)
|
|
self.cache["cooldown"] = await self.config.cooldown()
|
|
msg = _("Multiple translations have been turned ")
|
|
await ctx.send(msg + verb)
|
|
|
|
@translateset.command(aliases=["cooldown"])
|
|
@checks.is_owner()
|
|
@commands.guild_only()
|
|
async def timeout(self, ctx: commands.Context, time: int) -> None:
|
|
"""
|
|
Set the cooldown before a message can be reacted to again
|
|
for translation
|
|
|
|
`<time>` Number of seconds until that message can be reacted to again
|
|
Note: If multiple reactions are not allowed the timeout setting
|
|
is ignored until the cache cleanup ~10 minutes.
|
|
"""
|
|
await self.config.cooldown.timeout.set(time)
|
|
self.cache["cooldown"] = await self.config.cooldown()
|
|
msg = _("Translation timeout set to {time}s.").format(time=time)
|
|
await ctx.send(msg)
|
|
|
|
@translateset.command(aliases=["flags"])
|
|
@checks.mod_or_permissions(manage_channels=True)
|
|
@commands.guild_only()
|
|
async def flag(self, ctx: commands.Context) -> None:
|
|
"""
|
|
Toggle translations with flag emojis in text
|
|
"""
|
|
guild = ctx.message.guild
|
|
toggle = not await self.config.guild(guild).text()
|
|
if toggle:
|
|
verb = _("on")
|
|
else:
|
|
verb = _("off")
|
|
if guild.id in self.cache["guild_messages"]:
|
|
self.cache["guild_messages"].remove(guild.id)
|
|
await self.config.guild(guild).text.set(toggle)
|
|
msg = _("Flag emoji translations have been turned ")
|
|
await ctx.send(msg + verb)
|
|
|
|
@translateset.command()
|
|
@checks.is_owner()
|
|
async def creds(self, ctx: commands.Context) -> None:
|
|
"""
|
|
You must get an API key from Google to set this up
|
|
|
|
Note: Using this cog costs money, current rates are $20 per 1 million characters.
|
|
"""
|
|
msg = _(
|
|
"1. Go to Google Developers Console and log in with your Google account."
|
|
"(https://console.developers.google.com/)\n"
|
|
"2. You should be prompted to create a new project (name does not matter).\n"
|
|
"3. Click on Enable APIs and Services at the top.\n"
|
|
"4. In the list of APIs choose or search for Cloud Translate API and click on it."
|
|
"Choose Enable.\n"
|
|
"5. Click on Credentials on the left navigation bar.\n"
|
|
"6. Click on Create Credential at the top.\n"
|
|
'7. At the top click the link for "API key".\n'
|
|
"8. No application restrictions are needed. Click Create at the bottom.\n"
|
|
"9. You now have a key to add to \n"
|
|
"`{prefix}set api google_translate api_key,YOUR_KEY_HERE`\n"
|
|
).format(prefix=ctx.prefix)
|
|
await ctx.maybe_send_embed(msg)
|
|
|
|
def cog_unload(self):
|
|
self._clear_cache.cancel()
|
|
self._save_loop.cancel()
|
|
self.bot.loop.create_task(self._save_usage_stats())
|
|
|
|
__unload = cog_unload
|