def main(): logging.basicConfig( level=logging.DEBUG if Config()["DEBUG"] else logging.INFO) Bot(Config()["TELEGRAM_API_TOKEN"]) from bot import start from bot import splitit aiogram.executor.start_polling(Bot().dispatcher, skip_updates=True)
async def censor(self, ctx, *, word: Optional[str] = None) -> None: """ Censors many words """ # Syntax check if word is None: await ctx.send("**Invalid syntax**. `!censor word`") return words = word.split(" ") for w in words: # Make sure the word is not already censored w = w.lower() async with Bot().censored_words_db() as db: db_word = db.search(Query().word == w) if db_word: await ctx.send(f"**{w}** is already censored!") continue # Censor new word async with Bot().censored_words_db() as db: db.insert({"word": w}) # Bot's reply await ctx.send(f"**{w}** is now censored!")
async def uncensor(self, ctx, *, word: Optional[str] = None) -> None: """ Uncensors many words """ # Syntax check if word is None: await ctx.send("**Invalid syntax**. `!uncensor word`") return # Make sure the word is censored for w in word.split(" "): w = w.lower() async with Bot().censored_words_db() as db: db_word = db.search(Query().word == w) if not db_word: await ctx.send(f"**{w}** is not censored!") continue # Uncensor word async with Bot().censored_words_db() as db: db.remove(Query().word == w) # Bot's reply await ctx.send(f"**{w}** isn't censored anymore!")
async def on_message(self, message: discord.Message) -> None: # Don't do anything in private messages or for messages sent in other servers if type(message.channel) is not discord.TextChannel \ or message.channel.guild.id not in Bot().allowed_server_ids \ or message.author == self.bot.user: return # Process commands # try: # await self.bot.process_commands(message) # except discord.ext.commands.errors.CheckFailure: # pass # Censor only for non-admins if not message.author.bot and not checks.is_admin(message): async with Bot().censored_words_db() as db: banned_words = set(x["word"] for x in db.all()) message_words = message.content.lower() for banned_word in banned_words: if banned_word in message_words: await message.delete() Bot().logger.info( f"Deleted message from {message.author.name} [{message.author.id}] ({message.content})" ) await Bot().log( f"**Deleted message from {message.author.mention}:** " f"`{message.clean_content.replace('`', '')}`")
async def on_message(self, message: discord.Message) -> None: if message.channel.id != Bot().reports_user_channel_id \ or message.author == self.bot.user: return e = discord.Embed( title="New Player Report Received!", colour=discord.Colour.from_rgb(*(random.randint(0, 255) for _ in range(3))), timestamp=datetime.now() ).set_thumbnail( url=message.author.avatar_url ).add_field( name="Author", value=message.author.mention, inline=False ).add_field( name="Report", value=message.content, inline=False ) admin_message = await self.bot.get_channel(Bot().reports_admin_channel_id).send(embed=e) async def add_emojis(): for x in ("👍", "👎", "❗"): await admin_message.add_reaction(x) asyncio.ensure_future(add_emojis()) await message.delete() await message.author.send( f"Hey there, {message.author}! Thank you for your report. " "It will be reviewed by the Ripple Community Managers soon!", embed=e )
def main(): # Read config conf = Config().config # Connect to MySQL asyncio.get_event_loop().run_until_complete(Db().create( host=conf["DB_HOST"], port=conf["DB_PORT"], username=conf["DB_USERNAME"], password=conf["DB_PASSWORD"], database=conf["DB_DATABASE"], maxsize=conf["DB_POOL_SIZE"])) # Initialize sentry if Config().config["SENTRY_DSN"] != "": SentryClient(conf["SENTRY_DSN"], enable_breadcrumbs=True, transport=ThreadedHTTPTransport, string_max_length=8192) else: print("Sentry logging disabled") # Initialize bot bot = Bot(conf["TELEGRAM_API_TOKEN"]) from commands import start from commands import meme from commands import chatid from commands import callback print("Click da circlez") bot.run()
def main() -> None: # Logging logging.basicConfig( level=logging.DEBUG if Config()["DEBUG"] else logging.INFO) logging.info(""" __ _ / _| | | | |_ ___ | | ____ ___ _____ ___ ___ | _/ _ \\| |/ / _` \\ \\ /\\ / / _ \\ / _ \\ / _ \\ | || (_) | < (_| |\\ V V / (_) | (_) | (_) | |_| \\___/|_|\\_\\__,_| \\_/\\_/ \\___/ \\___/ \\___/ """) # Setup Bot singleton if use_uvloop: uvloop.install() logging.info("Using uvloop") else: logging.warning("Using asyncio") Bot( wss=Config()["WSS"], nickname=Config()["BOT_NICKNAME"], commands_prefix=Config()["COMMANDS_PREFIX"], bancho_api_client=BanchoApiClient(Config()["BANCHO_API_TOKEN"], Config()["BANCHO_API_BASE"]), ripple_api_client=RippleApiClient(Config()["RIPPLE_API_TOKEN"], Config()["RIPPLE_API_BASE"]), lets_api_client=LetsApiClient(Config()["LETS_API_BASE"]), cheesegull_api_client=CheesegullApiClient( Config()["CHEESEGULL_API_BASE"]), osu_api_client=OsuAPIClient(Config()["OSU_API_TOKEN"]), misirlou_api_client=MisirlouApiClient( Config()["MISIRLOU_API_TOKEN"], Config()["MISIRLOU_API_BASE"], ), http_host=Config()["HTTP_HOST"], http_port=Config()["HTTP_PORT"], redis_host=Config()["REDIS_HOST"], redis_port=Config()["REDIS_PORT"], redis_database=Config()["REDIS_DATABASE"], redis_password=Config()["REDIS_PASSWORD"], redis_pool_size=Config()["REDIS_POOL_SIZE"], tinydb_path=Config()["TINYDB_PATH"], ) # Register all events import events # Import all required plugins (register bot commands) for plugin in Config()["BOT_PLUGINS"]: imported_plugin = importlib.import_module(f"plugins.{plugin}") if hasattr(imported_plugin, "init"): logging.debug(f"Plugin {plugin} has init hook.") Bot().init_hooks.append( InitHook(plugin, getattr(imported_plugin, "init"))) Bot().logger.info(f"Loaded plugin plugins.{plugin}") # Finally, run the bot Bot().run()
async def last(request): resp = {} try: secret = request.headers.get("Secret", None) if secret is None or secret != Config()["INTERNAL_API_SECRET"]: raise FokaAPIError(403, "Forbidden") request_data = await request.json() if "user_id" not in request_data: raise FokaAPIError(400, "Missing required arguments.") users = await Bot().ripple_api_client.get_user( user_id=request_data["user_id"]) if users is None or not users: raise FokaAPIError(404, "No such user") username = users[0]["username"] msg = await pp.last_inner(username, pm=True) Bot().send_message(msg, username) resp = {"code": 200, "message": "ok"} except FokaAPIError as e: resp = {"code": e.status, "message": e.message} except: resp = {"code": 500, "message": "Internal server error"} traceback.print_exc() finally: code = resp["code"] if "code" in resp else 200 return web.json_response(resp, status=code)
async def censoredwords(self, ctx) -> None: """ Lists all currently censored words """ async with Bot().censored_words_db() as db: results = db.all() await ctx.send("**Censored words:** {}".format(", ".join( x["word"] for x in results)))
async def send_message(request): resp = {} try: secret = request.headers.get("Secret", None) if secret is None or secret != Config()["INTERNAL_API_SECRET"]: raise FokaAPIError(403, "Forbidden") request_data = await request.json() if "message" not in request_data or "target" not in request_data: raise FokaAPIError(400, "Missing required arguments.") Bot().send_message(request_data["message"], request_data["target"]) resp = {"code": 200, "message": "ok"} except FokaAPIError as e: resp = {"code": e.status, "message": e.message} except: resp = {"code": 500, "message": "Internal server error"} traceback.print_exc() finally: code = resp["code"] if "code" in resp else 200 return web.json_response(resp, status=code)
import plugins.base import utils from constants.mods import Mod, ModSpecialMode from constants.scoring_types import ScoringType from constants.team_types import TeamType from constants.teams import Team from plugins.base import Arg from constants.privileges import Privileges from singletons.bot import Bot from utils import general, schema from utils.rippleapi import BanchoApiBeatmap from constants.slot_statuses import SlotStatus from constants.game_modes import GameMode bot = Bot() def resolve_mp(f: Callable) -> Callable: async def wrapper(*, recipient: Dict[str, Any], **kwargs): assert recipient["display_name"] == "#multiplayer" match_id = int(recipient["name"].split("_")[1]) return await f(match_id=match_id, recipient=recipient, **kwargs) return wrapper @bot.command("mp make") @plugins.base.protected(Privileges.USER_TOURNAMENT_STAFF) @plugins.base.arguments( plugins.base.Arg("name", Schema(str)),
from singletons.config import Config if __name__ == "__main__": logging.getLogger("discord").setLevel(logging.ERROR) logging.basicConfig(level=logging.INFO) logging.info("""\n _ _ _ ___| |_ ___ _| |_| |___ _ _ _ _ | . | | -_| . | . | .'| | |_'_| |_ |_|_|___|___|___|__,|___|_,_| |___| Gheddaux - Made by Nyo""") bot = Bot(command_prefix=";", allowed_server_ids=Config()["SERVER_IDS"], log_channel_id=Config()["LOG_CHANNEL_ID"], welcome_channel_id=Config()["WELCOME_CHANNEL_ID"], reports_user_channel_id=Config()["REPORTS_USER_CHANNEL_ID"], reports_admin_channel_id=Config()["REPORTS_ADMIN_CHANNEL_ID"], db_file=Config()["DB_FILE"]).bot @bot.event async def on_command_error(ctx, exception) -> None: # I don't even want to know why the f**k I have to do this in the first place try: raise exception except: Bot().logger.exception("An unhandled exception has been raised.") if Bot().welcome_channel_id: bot.add_cog(Welcome(bot)) else:
async def on_command_error(ctx, exception) -> None: # I don't even want to know why the f**k I have to do this in the first place try: raise exception except: Bot().logger.exception("An unhandled exception has been raised.")
def is_server_allowed(message: discord.Message) -> bool: return message.channel.guild.id in Bot().allowed_server_ids
async def handle(data: Dict[str, Any]) -> None: Bot().send_message(data["message"], data["recipient"])
from typing import Dict, Any import pubsub from singletons.bot import Bot from utils.schema import NonEmptyString bind = Bot().pubsub_binding_manager @bind.register_pubsub_handler("fokabot:message") @pubsub.schema({"recipient": NonEmptyString, "message": NonEmptyString}) async def handle(data: Dict[str, Any]) -> None: Bot().send_message(data["message"], data["recipient"])
print("=> Connecting to database") # Connect to database and create table if needed await Database().connect(Config()["DB_DSN"], loop=asyncio.get_event_loop()) await Database().execute(""" CREATE TABLE IF NOT EXISTS `banned_words` ( `id` INTEGER PRIMARY KEY AUTOINCREMENT, `word` TEXT UNIQUE );""") # Load forbidden words await WordsCache().reload() # Initialize some variables for decorators bot = Bot(command_prefix=";") @bot.event async def on_ready(): print("=> Logged in as {} [{}]. Ready!".format(bot.user.name, bot.user.id)) @bot.event async def on_message(message): # Don't do anything in private messages if message.server is None: return # Process commands try: