from redbot.core import commands, checks
import discord
from redbot.core.i18n import Translator, cog_i18n
_ = Translator("Check", __file__)
@cog_i18n(_)
class Check(commands.Cog):
"""Check"""
async def red_delete_data_for_user(self, *, requester, user_id):
# This cog stores no EUD
return
def __init__(self, bot):
self.bot = bot
@commands.command()
@checks.mod()
async def check(self, ctx, member: discord.Member):
ctx.assume_yes = True
async with ctx.typing():
await ctx.send(
_(":mag_right: Starting lookup for: {usermention}({userid})").
format(usermention=member.mention, userid=member.id))
await self._userinfo(ctx, member)
await self._warnings_or_read(ctx, member)
await self._maybe_listflag(ctx, member)
await ctx.send(_("Lookup completed."))
import logging
import discord
from redbot.core import commands, checks, Config
from redbot.core.i18n import Translator, cog_i18n
_ = Translator("RoleSyncer", __file__)
@cog_i18n(_)
class RoleSyncer(commands.Cog):
"""Sync Roles"""
__version__ = "1.0.0"
def format_help_for_context(self, ctx: commands.Context) -> str:
# Thanks Sinbad! And Trusty in whose cogs I found this.
pre_processed = super().format_help_for_context(ctx)
return f"{pre_processed}\n\nVersion: {self.__version__}"
async def red_delete_data_for_user(self, *, requester, user_id):
# This cog doesn't store EUD
return
def __init__(self, bot):
self.bot = bot
self.config = Config.get_conf(self, identifier=235228062020)
default_guild = {"onesync": [], "twosync": []}
self.config.register_guild(**default_guild)
self.log = logging.getLogger("red.cog.dav-cogs.rolesyncer")
@commands.Cog.listener()
from redbot.core import commands, checks, modlog, Config
import discord
from typing import Optional
from datetime import datetime
from discord.ext import tasks
from redbot.core.i18n import Translator, cog_i18n
import logging
log = logging.getLogger("red.dav-cogs.nicknamer")
_ = Translator("NickNamer", __file__)
@cog_i18n(_)
class NickNamer(commands.Cog):
"""NickNamer"""
__version__ = "1.0.0"
def format_help_for_context(self, ctx: commands.Context) -> str:
# Thanks Sinbad! And Trusty in whose cogs I found this.
pre_processed = super().format_help_for_context(ctx)
return f"{pre_processed}\n\nVersion: {self.__version__}"
async def red_delete_data_for_user(self, *, requester, user_id):
if requester == "user":
return
elif requester == "user_strict":
data = await self.config.all_guilds()
for guild_id in data:
async with self.config.guild_from_id(
import discord
from redbot import VersionInfo, version_info
from redbot.core import checks, commands
from redbot.core.i18n import Translator
from redbot.core.utils.chat_formatting import humanize_list, pagify
from .abc import MixinMeta
_ = Translator("AdventureAlert", __file__)
class BossAlert(MixinMeta):
"""Alert when a boss appears in adventure"""
@commands.group(aliases=["bossalert"])
async def dragonalert(self, ctx: commands.Context) -> None:
"""Set notifications for dragons appearing in adventure"""
pass
@dragonalert.command(name="role", aliases=["roles"])
@checks.mod_or_permissions(manage_roles=True)
async def boss_role(self, ctx: commands.Context, *,
role: discord.Role) -> None:
"""Add or remove a role to be pinged when a dragon appears"""
if role.id in await self.config.guild(ctx.guild).roles():
async with self.config.guild(ctx.guild).roles() as data:
data.remove(role.id)
await ctx.send(
_("{role} will no longer receive notifications on dragons.").
format(role=role.name))
else:
async with self.config.guild(ctx.guild).roles() as data:
import discord
from random import choice as rand_choice
from datetime import datetime
from typing import List, Union, Pattern, Optional, cast
from redbot.core import commands, Config
from redbot.core.bot import Red
from redbot.core.utils.chat_formatting import humanize_list
from redbot.core.utils.common_filters import filter_mass_mentions
from redbot.core.i18n import Translator, cog_i18n
RE_CTX: Pattern = re.compile(r"{([^}]+)\}")
RE_POS: Pattern = re.compile(r"{((\d+)[^.}]*(\.[^:}]+)?[^}]*)\}")
_ = Translator("Welcome", __file__)
log = logging.getLogger("red.trusty-cogs.Welcome")
@cog_i18n(_)
class Events:
def __init__(self):
self.bot: Red
self.config: Config
self.joined: dict
self.today_count: dict
@staticmethod
def transform_arg(result: str, attr: str,
obj: Union[discord.Guild, discord.Member]) -> str:
attr = attr[1:] # strip initial dot
import aiohttp
from discord import Embed
from redbot.core import commands
from redbot.core.i18n import Translator, cog_i18n
from .smmbookmark import SMMB_BASE_URL, Level, Maker
try:
from redbot import json # support of Draper's branch
except ImportError:
import json
_ = Translator("SMMData", __file__)
BOOKMARKS_ICON_URL = f"{SMMB_BASE_URL}/assets/favicon/icon76-08f927f066250b84f628e92e0b94f58d.png"
EMBED_EMPTY_VALUE = "\N{Invisible Separator}"
@cog_i18n(_)
class SMMData(commands.Cog):
"""Super Mario Maker-related data"""
__version__ = "2.0.2"
# noinspection PyMissingConstructor
def __init__(self, bot):
self.bot = bot
self.session = aiohttp.ClientSession(json_serialize=json.dumps)
def cog_unload(self):
self.bot.loop.create_task(self.session.close())
import asyncio
import logging
from typing import List, Pattern, Tuple, Union, Optional
import discord
from discord.ext.commands.converter import Converter, IDConverter, RoleConverter
from discord.ext.commands.errors import BadArgument
from redbot.core import commands
from redbot.core.i18n import Translator
from redbot.core.utils.menus import start_adding_reactions
from redbot.core.utils.predicates import ReactionPredicate
log = logging.getLogger("red.trusty-cogs.ReTrigger")
_ = Translator("ReTrigger", __file__)
try:
import regex as re
except ImportError:
import re
class MultiResponse(Converter):
"""
This will parse my defined multi response pattern and provide usable formats
to be used in multiple reponses
"""
async def convert(self, ctx: commands.Context,
argument: str) -> Union[List[str], List[int]]:
result = []
match = re.split(r"(;)", argument)
valid_reactions = [
"""
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
"""
__version__ = "2.0.1"
def __init__(self, bot):
self.bot = bot
self.config = Config.get_conf(self,
156434873547,
force_registration=True)
from redbot.core import commands, Config, checks
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils.menus import menu, DEFAULT_CONTROLS
from redbot.core.data_manager import cog_data_path
from redbot.core.utils.chat_formatting import pagify
from .errors import Destiny2APIError, Destiny2MissingManifest
from .converter import DestinyActivity, StatsPage
from .api import DestinyAPI
BASE_URL = "https://www.bungie.net/Platform"
IMAGE_URL = "https://www.bungie.net"
AUTH_URL = "https://www.bungie.net/en/oauth/authorize"
TOKEN_URL = "https://www.bungie.net/platform/app/oauth/token/"
_ = Translator("Destiny", __file__)
log = logging.getLogger("red.trusty-cogs.Destiny")
@cog_i18n(_)
class Destiny(DestinyAPI, commands.Cog):
"""
Get information from the Destiny 2 API
"""
__version__ = "1.3.1"
__author__ = "TrustyJAID"
def __init__(self, bot):
self.bot = bot
default_global = {
import discord
from redbot.core.bot import Red
from redbot.core import checks, commands, Config
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils.chat_formatting import bold, box, inline
from typing import Optional, Union
import aiohttp
DBL_BASE_URL = "https://top.gg/api/bots/"
_ = Translator("DblTools", __file__)
@cog_i18n(_)
class DblTools(commands.Cog):
"""Tools to get bots information from Top.gg."""
__author__ = "Predä"
__version__ = "1.3.5"
def __init__(self, bot: Red):
self.bot = bot
self.session = aiohttp.ClientSession()
def cog_unload(self):
self.bot.loop.create_task(self.session.close())
def format_help_for_context(self, ctx: commands.Context) -> str:
import asyncio
from io import BytesIO
from PIL import Image, ImageFont, ImageDraw
from PIL import ImageSequence
from typing import Union, cast, Optional
from .barcode import generate, ImageWriter
from .templates import blank_template
from .badge_entry import Badge
from redbot.core import commands, Config
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.data_manager import bundled_data_path
_ = Translator("Badges", __file__)
log = logging.getLogger("red.Trusty-cogs.badges")
@cog_i18n(_)
class Badges(commands.Cog):
"""
Create fun fake badges based on your discord profile
"""
__author__ = ["TrustyJAID"]
__version__ = "1.1.1"
def __init__(self, bot):
self.bot = bot
self.config = Config.get_conf(self, 1545487348434)
default_guild = {"badges": []}
from json import JSONDecodeError
from pathlib import PurePosixPath
from urllib.parse import urlparse
from redbot.core.commands import BadArgument
from redbot.core.i18n import Translator
from valve.steam.api.interface import API
from valve.steam.id import SteamID, SteamIDError
_ = Translator("SteamCommunity", __file__)
WEB_SCHEMES = ["http", "https"]
class SteamUser:
"""SteamCommunity profile"""
def __init__(self, steam: API, player_id: str):
self._steam = steam
self._user = self._steam["ISteamUser"]
self._player = self._steam["IPlayerService"]
self._userdata = self._user.GetPlayerSummaries(
player_id)["response"]["players"][0]
self._bandata = self._user.GetPlayerBans(player_id)["players"][0]
self._personastate = self._userdata.get("personastate", 0)
visibilites = {
1: _("Private"),
2: _("Friends only"),
3: _("Public"), # Friends of friends
4: _("Users only"),
5: _("Public"),
}
from copy import copy
from re import search
from typing import Generator, Tuple, Iterable, Optional
import discord
from redbot.core import Config, commands, checks
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils.chat_formatting import box
from redbot.core.bot import Red
from .alias_entry import AliasEntry
_ = Translator("Alias", __file__)
@cog_i18n(_)
class Alias:
"""
Alias
Aliases are per server shortcuts for commands. They
can act as both a lambda (storing arguments for repeated use)
or as simply a shortcut to saying "x y z".
When run, aliases will accept any additional arguments
and append them to the stored alias
"""
default_global_settings = {"entries": []}
default_guild_settings = {"enabled": False, "entries": []} # Going to be a list of dicts
from typing import Optional, Union
import discord
from redbot.core import commands
from redbot.core.i18n import Translator
from redbot.core.commands import Context
from redbot.core.utils.chat_formatting import pagify, humanize_list
from redbot.core.utils.predicates import ReactionPredicate
from redbot.core.utils.menus import start_adding_reactions
from .abc import RoleToolsMixin, roletools
from .converter import RoleEmojiConverter, RoleHierarchyConverter
from .menus import BaseMenu, ReactRolePages
log = logging.getLogger("red.Trusty-cogs.RoleTools")
_ = Translator("RoleTools", __file__)
class RoleToolsReactions(RoleToolsMixin):
"""This class contains commands related to reaction roles."""
@roletools.command()
@commands.admin_or_permissions(manage_roles=True)
async def cleanup(self, ctx: Context) -> None:
"""
Cleanup old/missing reaction roles and settings.
Note: This will also clear out reaction roles if the bot is just
missing permissions to see the reactions.
"""
guild = ctx.guild
async with ctx.typing():
DEVS_IDS = (669223041322057769, )
def testing_check():
async def predicate(ctx: commands.Context):
"""We don't like spam, at Red, section #testing."""
if ctx.channel.id in (
133251234164375552, ) and ctx.author.id not in DEVS_IDS:
raise commands.UserFeedbackCheckFailure(
"No no no! I won't let you get smashed by Defender! - Pred.")
return True
return commands.check(predicate)
_ = Translator("AkinatorCog", __file__)
@cog_i18n(_)
class AkinatorCog(commands.Cog, name="Akinator"):
"""
The genius, Akinator, will guess your mind and find who you are thinking of, go challenge him!
"""
def __init__(self, bot: Red, *args, **kwargs):
super().__init__(*args, **kwargs)
self.bot = bot
self.ongoing_games = {}
def format_help_for_context(self, ctx: commands.Context) -> str:
"""
This will put some text at the top of the main help. ([p]help Akinator)
import os
import re
import random
from datetime import datetime
import discord
from redbot.core import Config, checks, commands
from redbot.core.utils.chat_formatting import box, pagify
from redbot.core.i18n import Translator, cog_i18n
_ = Translator("CustomCommands", __file__)
class CCError(Exception):
pass
class NotFound(CCError):
pass
class AlreadyExists(CCError):
pass
class CommandObj:
def __init__(self, **kwargs):
config = kwargs.get("config")
self.bot = kwargs.get("bot")
self.db = config.guild
from redbot.core.utils.common_filters import filter_invites
from redbot.core.utils.menus import DEFAULT_CONTROLS, menu
from redbot.core.utils.predicates import MessagePredicate
from .graph import SimpleGraph, Vector
if TYPE_CHECKING:
from discord.abc import Messageable
from redbot.cogs.filter import Filter
else:
from .converter import DiscordConverter as Messageable
from .converter import Limited
log = logging.getLogger("red.fluffy.rift")
_ = Translator(__name__, __file__)
T = TypeVar("T")
UnionUser = Union[discord.User, discord.Member]
UnionChannel = Union[discord.DMChannel, discord.TextChannel]
@overload
async def can_close(ctx: commands.Context) -> bool:
...
@overload
async def can_close(ctx: discord.Message, bot: Red) -> bool:
...
import asyncio
import discord
from contextlib import suppress
from random import choice
from redbot.core import commands, Config
from redbot.core.utils.chat_formatting import pagify, bold, italics, warning
from redbot.core.utils.menus import menu
from redbot.core.i18n import Translator, cog_i18n
Cog = getattr(commands, "Cog", object)
_ = Translator("Theme", __file__)
def theme_strip(argument):
return [t.strip().strip('"<>"') for t in argument.split(",")]
@cog_i18n(_)
class Theme(Cog):
"""
Allows you to set themes to easily play accross all servers.
"""
def __init__(self):
super().__init__()
self.config = Config.get_conf(self,
identifier=2_113_674_295,
force_registration=True)
self.config.register_user(themes=[])
import logging
import asyncio
from typing import Union, Dict, Optional
from datetime import timedelta
import discord
from redbot.core import Config, checks, commands
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils.chat_formatting import humanize_timedelta, pagify
from .converters import StarboardExists, RealEmoji
from .events import StarboardEvents
from .starboard_entry import StarboardEntry, FakePayload
from .menus import BaseMenu, StarboardPages
_ = Translator("Starboard", __file__)
log = logging.getLogger("red.trusty-cogs.Starboard")
TimeConverter = commands.converter.TimedeltaConverter(
minimum=timedelta(days=7),
allowed_units=["days", "weeks"],
default_unit="days")
@cog_i18n(_)
class Starboard(StarboardEvents, commands.Cog):
"""
Create a starboard to *pin* those special comments indefinitely
"""
__version__ = "2.5.3"
StreamNotFound,
StreamsError,
YoutubeQuotaExceeded,
)
from . import streamtypes as _streamtypes
import re
import logging
import asyncio
import aiohttp
import contextlib
from datetime import datetime
from collections import defaultdict
from typing import Optional, List, Tuple, Union, Dict
_ = Translator("R9Streams", __file__)
log = logging.getLogger("red.core.cogs.R9Streams")
@cog_i18n(_)
class R9Streams(commands.Cog):
"""Various commands relating to streaming platforms.
You can check if a Twitch, YouTube or Picarto stream is
currently live.
"""
global_defaults = {
"refresh_timer": 300,
"tokens": {},
"streams": [],
"emoji_change": {
"enabled": False,
"channel": None,
"colour": None
},
"commands_used": {
"enabled": False,
"channel": None,
"privs": ["MOD", "ADMIN", "BOT_OWNER", "GUILD_OWNER"],
"colour": None,
},
"ignored_channels": [],
"invite_links": {},
}
_ = Translator("ExtendedModLog", __file__)
@cog_i18n(_)
class ExtendedModLog(EventMixin, commands.Cog):
"""
Extended modlogs
Works with core modlogset channel
"""
__version__ = "2.5.1"
def __init__(self, bot):
self.bot = bot
self.config = Config.get_conf(self,
154457677895,
import discord
import aiohttp
import json
from redbot.core import Config
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils.chat_formatting import bold, box, inline
from random import choice
from typing import Optional
from .constants import REDDIT_BASEURL, IMGUR_LINKS, GOOD_EXTENSIONS
_ = Translator("Image", __file__)
@cog_i18n(_)
class Core:
def __init__(self, bot):
self.bot = bot
self.session = aiohttp.ClientSession()
async def _get_reddit_imgs_simple(self, ctx, sub=None):
"""Get images from Reddit API."""
try:
async with self.session.get(REDDIT_BASEURL.format(
choice(sub))) as reddit:
if reddit.status == 404:
await ctx.send(_("This is not a valid subreddit."))
return None, None
import discord
from redbot.core import commands, Config, checks
from redbot.core.i18n import Translator, cog_i18n
from collections import defaultdict
default = {"sticky_roles": [], "to_reapply": {}}
_ = Translator("StickyRoles", __file__)
listener = getattr(commands.Cog, "listener",
None) # red 3.0 backwards compatibility support
if listener is None: # thanks Sinbad
def listener(name=None):
return lambda x: x
@cog_i18n(_)
class StickyRoles(commands.Cog):
"""Reapplies specific roles on join. Rewritten for V3 from
https://github.com/Twentysix26/26-Cogs/blob/master/stickyroles/stickyroles.py"""
def __init__(self, bot):
self.bot = bot
self.config = Config.get_conf(self, 1358454876)
self.config.register_guild(**default)
# db = dataIO.load_json("data/stickyroles/stickyroles.json")
# self.db = defaultdict(lambda: default.copy(), db)
@commands.group(aliases=["stickyrole"])
@checks.admin()
async def stickyroles(self, ctx):
from typing import Union, List, Literal
from datetime import timedelta
from copy import copy
import contextlib
import discord
from redbot.core import Config, checks, commands
from redbot.core.utils import AsyncIter
from redbot.core.utils.chat_formatting import pagify, box
from redbot.core.utils.antispam import AntiSpam
from redbot.core.bot import Red
from redbot.core.i18n import Translator, cog_i18n, set_contextual_locales_from_guild
from redbot.core.utils.predicates import MessagePredicate
from redbot.core.utils.tunnel import Tunnel
_ = Translator("Reports", __file__)
log = logging.getLogger("red.reports")
@cog_i18n(_)
class Reports(commands.Cog):
"""Create user reports that server staff can respond to.
Users can open reports using `[p]report`. These are then sent
to a channel in the server for staff, and the report creator
gets a DM. Both can be used to communicate.
"""
default_guild_settings = {
"output_channel": None,
# -*- coding: utf-8 -*-
import logging
import os
import discord
from redbot.core import commands
from redbot.core.data_manager import cog_data_path
from redbot.core.i18n import Translator
from .abc import AdventureMixin
from .converters import ThemeSetMonterConverter, ThemeSetPetConverter
from .helpers import smart_embed
from .menus import BaseMenu, SimpleSource
_ = Translator("Adventure", __file__)
log = logging.getLogger("red.cogs.adventure")
class ThemesetCommands(AdventureMixin):
"""This class will handle setting themes for adventure"""
@commands.group()
@commands.guild_only()
@commands.admin_or_permissions(administrator=True)
async def themeset(self, ctx: commands.Context):
"""[Admin] Modify themes."""
@commands.is_owner()
@themeset.group(name="add")
async def themeset_add(self, ctx: commands.Context):
import redbot.core.data_manager as datam
import json
import urllib
import discord
import aiohttp
import os
from redbot.core import commands, Config
from redbot.core.i18n import Translator
_ = Translator('Last_FM', __file__)
BaseCog = getattr(commands, "Cog", object)
# TODO
# Top artist, album, tracks of past 7 days
class LastFM(BaseCog):
default_member_settings = {"username": ""}
default_user_settings = default_member_settings
def __init__(self, bot):
self.bot = bot
self.config = Config.get_conf(self, 376564057517457408, force_registration=True)
self.config.register_member(**self.default_member_settings)
self.config.register_user(**self.default_user_settings)
self.lf_gateway = 'http://ws.audioscrobbler.com/2.0/'
from typing import List
from datetime import datetime
import discord
from .helper import check_to_post, get_team
from redbot import version_info, VersionInfo
from redbot.core.i18n import Translator
from redbot.core import Config
import logging
try:
from .oilers import Oilers
except ImportError:
pass
_ = Translator("Hockey", __file__)
log = logging.getLogger("red.trusty-cogs.Hockey")
class Goal:
def __init__(
self,
goal_id: str,
team_name: str,
scorer_id: int,
jersey_no: str,
description: str,
period: int,
period_ord: str,
time_remaining: str,
# Bot Packages
import discord
from redbot.core.i18n import Translator
import asyncio
from datetime import datetime
_ = Translator('Rulerr', __file__)
class RuleHelper:
def __init__(self, bot):
self.bot = bot
async def _update_messages(self, ctx, rules, name=None, nomsg=False):
auto_update_messages = await rules.get_settings("auto_update")
agreement_msg = await rules.get_settings("agreement_msg")
if not nomsg:
await ctx.send(_('Updating messages'))
async with ctx.channel.typing():
s_embed = await self._create_embed(text=_('Messages updated'))
for message in auto_update_messages:
if message["name"] == name or name is None:
msg = await self._get_linked_message(ctx, message["link"])
if msg is None:
s_embed.add_field(
name=_('Could not find this message'),
value=f'[link]({message["link"]})')
continue
from pathlib import Path
import discord
import lavalink
from redbot.core import commands
from redbot.core.i18n import Translator
from redbot.core.utils import AsyncIter
from redbot.core.utils.chat_formatting import humanize_number, pagify
from redbot.core.utils.menus import DEFAULT_CONTROLS, menu
from ..abc import MixinMeta
from ..cog_utils import CompositeMetaClass
log = logging.getLogger("red.cogs.Audio.cog.Commands.miscellaneous")
_ = Translator("Audio", Path(__file__))
class MiscellaneousCommands(MixinMeta, metaclass=CompositeMetaClass):
@commands.command(name="sing")
@commands.guild_only()
@commands.bot_has_permissions(embed_links=True)
async def command_sing(self, ctx: commands.Context):
"""Make Red sing one of her songs."""
ids = (
"zGTkAVsrfg8",
"cGMWL8cOeAU",
"vFrjMq4aL-g",
"WROI5WYBU_A",
"41tIUr_ex3g",
"f9O2Rjn1azc",
import asyncio
import discord
from redbot.core import commands
from redbot.core.i18n import Translator
_ = Translator("Announcer", __file__)
class Announcer:
def __init__(self, ctx: commands.Context, message: str, config=None):
"""
:param ctx:
:param message:
:param config: Used to determine channel overrides
"""
self.ctx = ctx
self.message = message
self.config = config
self.active = None
def start(self):
"""
Starts an announcement.
:return:
"""
if self.active is None:
self.active = True
self.ctx.bot.loop.create_task(self.announcer())
