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())