def __init__(self, host="localhost", port=6379, db=0): self.log = utilities.getLog("Redis", logging.INFO) self.log.info("Connecting to redis...") self.__redis = redis.Redis(host=host, port=port, db=db) try: self.__redis.ping() except Exception as e: self.log.critical(e) exit(1)
import logging import traceback from datetime import datetime, timedelta import discord.errors import discord.errors import pytz from apscheduler.schedulers.asyncio import AsyncIOScheduler from apscheduler.triggers import cron from discord.ext.commands import BucketType from discord_slash import cog_ext from source import utilities, dataclass, jsonManager from source.shared import * log: logging.Logger = utilities.getLog("Cog::Mute") del_channel_template = [{ "channel_id": None, "delete_after": None, }] class Mute(commands.Cog): """Auto Delete Messages in a specified channel""" def __init__(self, bot): self.bot: dataclass.Bot = bot self.emoji = bot.emoji_list self.guild_data = {}
import asyncio import logging import os from datetime import datetime import discord from discord_slash import cog_ext from PIL import Image from source import dataclass, shared, utilities from source.shared import * log: logging.Logger = utilities.getLog("Cog::Log") class ModLog(commands.Cog): """Configuration commands""" def __init__(self, bot: dataclass.Bot, s="📬"): self.bot = bot self.slash = bot.slash self.emoji = bot.emoji_list async def setup(self): """The startup tasks for this cog""" self.bot.add_listener(self.on_message, "on_message") self.bot.add_listener(self.on_member_join, "on_member_join") self.bot.add_listener(self.on_member_remove, "on_member_remove") self.bot.add_listener(self.on_member_update, "on_member_update") self.bot.add_listener(self.on_message_edit, "on_message_edit")
import asyncio import inspect import traceback import typing from source import utilities, shared log = utilities.getLog("events") class Event(set): def __init__(self, name="DefaultName"): super(Event, self).__init__() self.name = name async def trigger(self, *args, **kwargs): for f in self: log.debug(f"Calling {f.__name__}") try: if inspect.iscoroutinefunction(f): await f(*args, **kwargs) else: await asyncio.to_thread(f, *args, **kwargs) except Exception as e: log.error("Ignoring exception in {}: {}".format( f.__name__, "".join( traceback.format_exception(type(e), e, e.__traceback__)), ))
import logging import typing from datetime import datetime import discord from discord.ext import commands from discord_slash import SlashContext, cog_ext from discord_slash.utils import manage_commands from source import utilities, jsonManager, shared, dataclass log: logging.Logger = utilities.getLog("Cog::uInfo") class UserInfo(commands.Cog): """Gets information about a user""" def __init__(self, bot): self.bot: dataclass.Bot = bot self.emoji = bot.emoji_list # todo: add additional user info commands @cog_ext.cog_subcommand(**jsonManager.getDecorator("info.user")) async def userInfo(self, ctx: SlashContext, user: typing.Union[discord.Member, discord.User]): emb = discord.Embed(colour=shared.new_blurple) emb.set_thumbnail(url=user.avatar_url) emb.description = "" # get db data on user
except Exception as e: print(e) return False return True def main(): from source import bot log.info("Ready, calling bot.py") bot.run() if __name__ == "__main__": logo = r""" __________ .__ .___.__ \______ \_____ | | _____ __| _/|__| ____ | ___/\__ \ | | \__ \ / __ | | |/ \ | | / __ \| |__/ __ \_/ /_/ | | | | \ |____| (____ /____(____ /\____ | |__|___| / \/ \/ \/ \/ """ logo = logo.replace("r", "\033[0m") logo = logo.replace("c", "\033[96m") print(logo) sleep(1) sanityChecks() log = utilities.getLog("Main") log.info("Logging system started") main()
import logging from discord.ext import commands from discord_slash import SlashContext, cog_ext from discord_slash.utils import manage_commands from source import utilities, dataclass, messageObject log: logging.Logger = utilities.getLog("Cog::mail") class ModMail(commands.Cog): """Configuration commands""" def __init__(self, bot: dataclass.Bot, s="📬"): self.bot = bot self.slash = bot.slash self.emoji = s @cog_ext.cog_subcommand( base="mail", name="send", description="Send a message to your moderators", options=[ manage_commands.create_option( name="content", description="The content of your message", option_type=str, required=True, ),
import logging import aiohttp import discord from discord.ext import commands from source import utilities, dataclass log: logging.Logger = utilities.getLog("Cog::base") class Base(commands.Cog): """Configuration commands""" def __init__(self, bot: dataclass.Bot): self.bot = bot self.slash = bot.slash self.emoji = "🚩" @commands.command(name="Shutdown", brief="Shuts down the bot") async def cmdShutdown(self, ctx: commands.Context): if await self.bot.is_owner(ctx.author): log.warning("Shutdown called") await ctx.send("Shutting down 🌙") await self.bot.close() @commands.command(name="setname", brief="Renames the bot") async def cmdSetName(self, ctx: commands.Context, name: str): if await self.bot.is_owner(ctx.author): await self.bot.user.edit(username=name)
import asyncio import json import typing from source import dataclass, utilities log = utilities.getLog("message") class Message: def __init__(self, bot: dataclass.Bot, guild_id: int = 0, author_id: int = 0): # a ref to the bot self.bot = bot # a ref to the bot's db client self.db = bot.db # the message id self._message_id = None # is this message open? self.open: bool = True # the guild this message belongs to self.guildID: int = guild_id # the author of this message self.authorID: int = author_id # the title of this message self.title: typing.Union[None, str] = None # the content of this message self.content: typing.Union[None, str] = None def __eq__(self, other): if isinstance(other, Message): if self._message_id == other._message_id:
import json import logging import time import traceback import typing import discord from discord.ext import commands, tasks from discord_slash import cog_ext, SlashContext from discord_slash.utils import manage_commands from twitchAPI import Twitch as TwitchAPI from twitchAPI.types import TwitchAuthorizationException from source import utilities, dataclass log: logging.Logger = utilities.getLog("Cog::twitch") class SetEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, set): return list(obj) return json.JSONEncoder.default(self, obj) class Twitch(commands.Cog): """Configuration commands""" def __init__(self, bot: dataclass.Bot): self.bot = bot self.slash = bot.slash
import logging import typing from datetime import datetime import discord from discord.ext import commands from discord_slash import SlashContext, cog_ext from discord_slash.utils import manage_commands from source import utilities, pagination, jsonManager, shared log: logging.Logger = utilities.getLog("Cog::lsPerms") class ListPermissions(commands.Cog): """List Permissions for a specified user/role""" def __init__(self, bot): self.bot = bot self.emoji = bot.emoji_list self.paginator = pagination.LinePaginator(prefix="", suffix="") @cog_ext.cog_subcommand( base="permissions", name="get", description="Get the permissions of a role or user", base_default_permission=True, options=[ manage_commands.create_option( name="scope",
import logging import re import typing import discord from discord.ext import commands from discord_slash import cog_ext, SlashContext from discord_slash.utils import manage_commands from source import utilities, dataclass, shared log: logging.Logger = utilities.getLog("Cog::LinkDetect") class LinkDetection(commands.Cog): """Configuration commands""" def __init__(self, bot): self.bot: dataclass.Bot = bot self.emoji = bot.emoji_list self.bot.add_listener(self.on_message, "on_message") async def on_message(self, message: discord.Message): if message.author.id == self.bot.user.id: return discord_invite = "discord.gg/(.*)" bot_invite = "(discord|discordapp).com(/api/|/)oauth2/authorize\?client_id=(\d{18})" generic_url = "((http|ftp|https)://|[\w_-]+(?:(?:\.[\w_-]+)+))([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])(.*)"
import logging import re import traceback import typing import discord from discord.ext import commands from discord_slash import cog_ext, SlashContext, model from discord_slash.utils import manage_commands from source import utilities, dataclass, shared log: logging.Logger = utilities.getLog("Cog::Config") class Config(commands.Cog): """Configuration commands""" def __init__(self, bot): self.bot: dataclass.Bot = bot self.emoji = bot.emoji_list @cog_ext.cog_subcommand( base="guild", name="get_config", description="Show the current config for this server", base_default_permission=True, ) async def get_guild_config(self, ctx: SlashContext): await ctx.defer()
import asyncio import json import logging import traceback from datetime import datetime, timedelta from discord.ext import tasks from discord.utils import snowflake_time from discord_slash import cog_ext from source import utilities, dataclass, jsonManager from source.shared import * log: logging.Logger = utilities.getLog("Cog::AutoDel") del_channel_template = [{ "channel_id": None, "delete_after": None, }] class AutoDelete(commands.Cog): """Auto Delete Messages in a specified channel""" def __init__(self, bot): self.bot: dataclass.Bot = bot self.emoji = bot.emoji_list self.events = self.bot.paladinEvents async def setup(self):
import logging from discord_slash import cog_ext from source import utilities, dataclass, jsonManager, shared from source.shared import * log: logging.Logger = utilities.getLog("Cog::warn") class UserWarnings(commands.Cog): """Configuration commands""" def __init__(self, bot: dataclass.Bot): self.bot: dataclass.Bot = bot self.slash = bot.slash self.emoji = bot.emoji_list @cog_ext.cog_subcommand(**jsonManager.getDecorator("add.warn.user")) async def warnCMD( self, ctx: SlashContext, user: typing.Union[discord.User, discord.Member], reason: str = None, ): """Warns a user, 3 warnings and the user will be kicked""" await ctx.defer() user_data = await self.bot.get_member_data(ctx.guild_id, user.id) warning_num = int(user_data.warnings) + 1
import json import os import logging from pprint import pprint from discord_slash.utils import manage_commands from source import utilities from source.shared import reasonOption log = utilities.getLog("slashParser", level=40) path = "data/commands/" def read(name: str): """Read a json file and returns its information""" log.debug(f"Reading {name} from json") _path = path + f"{name}.json" if not os.path.isfile(_path): log.error(f"{_path} does not exist") raise FileNotFoundError data = json.load(open(_path, "r")) return data def getDecorator(name: str): """Get the decorator data for a command""" return read(name)["decorator"]