import lightbulb
import hikari
import humanize
import datetime as dt
import typing as t
from textwrap import dedent
import utilities.helpers as helpers
from utilities.navigator import ButtonPages
plugin = lightbulb.Plugin("Core",
description="General Commands",
include_datastore=True)
plugin.d.emote = helpers.get_emote(":gear:")
@plugin.command()
@lightbulb.command("changelog", "Show 10 latest changes to the bot.")
@lightbulb.implements(lightbulb.PrefixCommandGroup,
lightbulb.SlashCommandGroup)
async def changelog_base(ctx: lightbulb.Context):
'''
Show 10 latest changes to the bot.
'''
await changelog_stable(ctx)
@changelog_base.child
@lightbulb.command("stable", "Show 10 latest changes to the bot.")
@lightbulb.implements(lightbulb.PrefixSubCommand, lightbulb.SlashSubCommand)
from sqlalchemy import alias, func, not_, orm
from utils.db import Problem as Problem_DB, Contest as Contest_DB, User as User_DB, Submission as Submission_DB
from utils.jomd_common import is_int, calculate_points, PointRangeConverter, gimme_common
from utils.api import ObjectNotFound
from utils.constants import SITE_URL, TZ, SHORTHANDS
import asyncio
import random
from operator import itemgetter
import logging
from lightbulb.converters import base
from lightbulb.commands.base import OptionModifier
from lightbulb.utils import nav
logger = logging.getLogger(__name__)
plugin = lightbulb.Plugin("User")
class StrNotIntConverter(base.BaseConverter[str]):
"""Implementation of the base converter for converting arguments into a point range."""
__slots__ = ()
async def convert(self, arg: str) -> str:
if is_int(arg):
raise TypeError("This is an integer") # kevinyang theorem
return arg
@plugin.command()
@lightbulb.option("amount", "List last N submissions", int, required=False)
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from extensions.utility import commands
from lib import client
import lightbulb
import sys
plugin = lightbulb.Plugin("Utility")
plugin.command(commands.ping)
plugin.command(commands.userinfo)
plugin.command(commands.about)
plugin.command(commands.avatar)
def load(bot: client.Requiem):
bot.add_plugin(plugin)
def unload(bot: client.Requiem):
bot.remove_plugin(plugin)
del sys.modules[commands.__name__]
# 3rd-party imports.
# Import any libraries that are not standard and not your code.
import lightbulb
import hikari
# Standard imports.
# Import std python libraries here.
import datetime as dt
# Utilities
# It's recommended to shorten their names to not include "utilities"
import utilities.helpers as helpers
# Create a category
plugin = lightbulb.Plugin("Category's name", include_datastore=True)
plugin.d.emote = helpers.get_emote("")
# Create a command
# Order of decorator is bottom-up.
@plugin.command()
@lightbulb.add_checks(...)
@lightbulb.option("arg2", "Description", modifier=helpers.CONSUME_REST_OPTION)
@lightbulb.option("arg1", "Description")
@lightbulb.command("Command's name", "Description")
@lightbulb.implements(lightbulb.PrefixCommand, lightbulb.SlashCommand)
async def slash_cmd(ctx: lightbulb.Context):
# If it is a simple one-line command then it's not worth it to do this,
# but you should explicitly declare arguments to shorten the ctx.options.
arg1 = ctx.options.arg1
arg2 = ctx.options.arg2
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from extensions.management import commands
from lib import client
import lightbulb
import sys
plugin = lightbulb.Plugin("Management")
plugin.add_checks(lightbulb.owner_only)
plugin.command(commands.terminate)
plugin.command(commands.reload)
plugin.command(commands.load)
plugin.command(commands.unload)
def load(requiem: client.Requiem):
requiem.add_plugin(plugin)
def unload(requiem: client.Requiem):
requiem.remove_plugin(plugin)
del sys.modules[commands.__name__]
from utils.graph import plot_type_radar, plot_type_bar, plot_rating, plot_points, plot_solved
from utils.jomd_common import calculate_points
from lightbulb.commands.base import OptionModifier
from operator import attrgetter, itemgetter
from sqlalchemy import or_, orm, func
import asyncio
import io
import bisect
import logging
from lightbulb.converters import base
logger = logging.getLogger(__name__)
plugin = lightbulb.Plugin("Plot")
class PeakConverter(base.BaseConverter[str]):
"""Implementation of the base converter for converting arguments into a peak arguement."""
__slots__ = ()
async def convert(self, arg: str) -> str:
if arg == "+peak":
return True
if arg == "+max":
return True
raise TypeError("Argument not known")
def has_any_role_names(role_names: t.List[str]) -> bool:
def _has_any_role_names(ctx: lightbulb.Context, *, role_names: t.List[str]):
assert ctx.member is not None
if any(role.name in role_names for role in ctx.member.get_roles()):
return True
raise lightbulb.errors.MissingRequiredRole(
"You are missing the roles required in order to run this command %s" % role_names
)
return lightbulb.Check(functools.partial(_has_any_role_names, role_names=role_names))
plugin = lightbulb.Plugin("Handles")
@plugin.command()
@lightbulb.option(
"handle",
"Dmoj handle",
str,
required=False,
default=None,
)
@lightbulb.option("member", "Discord user", hikari.Member, required=False, default=None)
@lightbulb.command("whois", "Lookup linked account")
@lightbulb.implements(lightbulb.PrefixCommand, lightbulb.SlashCommand)
async def whois(ctx):
member = ctx.options.member
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from extensions.verins_lunchbox import commands
from lib import client
import lightbulb
import sys
plugin = lightbulb.Plugin("VerinsLunchbox")
plugin.command(commands.neko)
plugin.command(commands.foxgirl)
def load(bot: client.Requiem):
bot.add_plugin(plugin)
def unload(bot: client.Requiem):
bot.remove_plugin(plugin)
del sys.modules[commands.__name__]
)
from utils.query import Query
from utils.api import ObjectNotFound
import hikari
import lightbulb
import typing as t
from datetime import datetime, timezone
from sqlalchemy import orm
import asyncio
from lightbulb.utils import nav
from operator import itemgetter, attrgetter
import logging
logger = logging.getLogger(__name__)
plugin = lightbulb.Plugin("Admin")
# TODO: Post new contests
# Rating change predictions for all users in a server
@plugin.command()
@lightbulb.option(
"args", "[+server, +all, dmoj_handles]", str, required=False, modifier=lightbulb.OptionModifier.GREEDY, default=[]
)
@lightbulb.option("key", "contest key", str)
@lightbulb.command("ranklist", "List rating predictions of a contest", aliases=["contest"])
@lightbulb.implements(lightbulb.PrefixCommand)
async def ranklist(ctx):
"""List rating predictions of a contest"""
key = ctx.options.key
CurrentGitgud as CurrentGitgud_DB,
Json,
)
import lightbulb
from lightbulb.converters import base
from lightbulb.commands.base import OptionModifier
import hikari
from lightbulb.utils import nav
from datetime import datetime
from sqlalchemy import func
import logging
logger = logging.getLogger(__name__)
plugin = lightbulb.Plugin("GitGud")
@plugin.command()
@lightbulb.option("filters", "Problem filters", str, required=False, modifier=OptionModifier.GREEDY, default=[])
@lightbulb.option(
"points",
"point range, e.g. ('1', '1-10') DOES NOT WORK WITH SLASH COMMANDS",
PointRangeConverter,
required=False,
default=None,
)
@lightbulb.set_help(
"""SHORTHANDS:
- adhoc
- math
import lightbulb
import hikari
import utilities.helpers as helpers
from utilities.checks import is_dev
plugin = lightbulb.Plugin("Secret", "Developer-only commands.", include_datastore = True)
plugin.d.emote = helpers.get_emote(":computer:")
plugin.add_checks(is_dev)
@plugin.set_error_handler()
async def on_plugin_error(event: lightbulb.CommandErrorEvent) -> bool:
exception = event.exception.__cause__ or event.exception
if isinstance(exception, lightbulb.BotMissingRequiredPermission):
pass
elif isinstance(exception, lightbulb.MissingRequiredPermission):
pass
elif isinstance(exception, lightbulb.CheckFailure):
exception.message = "`Author must be a MichaelBot developer`"
return False
@plugin.command()
@lightbulb.option("extension", "The extension to reload.")
@lightbulb.command("reload", "Reload an extension.", hidden = True)
@lightbulb.implements(lightbulb.PrefixCommand, lightbulb.SlashCommand)
async def reload(ctx: lightbulb.Context):
ctx.bot.reload_extensions(ctx.options.extension)
await ctx.respond(f"Reloaded extension {ctx.options.extension}.", reply = True)
import os
import requests
import json
import hikari
import lightbulb
from dotenv import load_dotenv, find_dotenv
from datetime import datetime
from geopy.geocoders import Nominatim
weather_plugin = lightbulb.Plugin("Weather")
class Weather:
"""Weather class that interacts with OpenWeatherMap API
for weather information
"""
def __init__(self):
load_dotenv(dotenv_path=find_dotenv(usecwd=True))
self._weather_token = os.environ.get('WEATHER_TOKEN')
self.name = os.environ.get('BOT_NAME')
self.location = os.environ.get('DEFAULT_LOCATION')
def t_convert(self, t, time_format = "%m/%d %H:%M"):
"""Converting UNIX time to human readable time
Args:
t (int): UNIX timestamp
time_format (str, optional): Date format. Defaults to "%m/%d %H:%M".
Returns:
str: Human readable time
import lightbulb
import hikari
import random
import utilities.helpers as helpers
plugin = lightbulb.Plugin("Fun",
description="Fun Commands",
include_datastore=True)
plugin.d.emote = helpers.get_emote(":grin:")
@plugin.command()
@lightbulb.command("dice", "Roll a 6-face dice for you.")
@lightbulb.implements(lightbulb.PrefixCommand, lightbulb.SlashCommand)
async def dice(ctx: lightbulb.Context):
await ctx.respond("It's %d :game_die:" % (random.randint(1, 6)),
reply=True)
@plugin.command()
@lightbulb.option("content",
"The string to repeat.",
modifier=helpers.CONSUME_REST_OPTION)
@lightbulb.command("echo", "Echo echo echo echo.")
@lightbulb.implements(lightbulb.PrefixCommand, lightbulb.SlashCommand)
async def echo(ctx: lightbulb.Context):
if isinstance(ctx, lightbulb.PrefixContext):
await ctx.event.message.delete()
await ctx.respond(ctx.options.content)
import lightbulb
import hikari
import lavaplayer
import datetime as dt
import utilities.helpers as helpers
from utilities.converters import IntervalConverter
from utilities.navigator import ButtonPages
plugin = lightbulb.Plugin("Music",
description="Music Commands",
include_datastore=True)
plugin.d.emote = helpers.get_emote(":musical_note:")
lavalink = lavaplayer.LavalinkClient(
host="0.0.0.0", # Lavalink host
port=2333, # Lavalink port
password="******", # Lavalink password
user_id=577663051722129427)
# Currently lavaplayer doesn't support adding attr to lavaplayer.objects.Node
# so we'll make a dictionary to manually track additional info.
# { guild_id: {} }
node_extra = {}
# This should be the value of node_extra[guild_id]
def default_node_extra():
return {
"queue_loop": False,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from extensions.politics_and_war import commands, background, helpers
from lib import client
import lightbulb
import sys
plugin = lightbulb.Plugin("PoliticsAndWar")
plugin.command(commands.infra_cost)
plugin.command(commands.land_cost)
plugin.command(commands.city_cost)
plugin.command(commands.nation_info)
plugin.command(commands.raids)
plugin.command(commands.alliance_info)
def load(bot: client.Requiem) -> None:
background.gather_and_run_queries.start(bot)
bot.add_plugin(plugin)
def unload(bot: client.Requiem) -> None:
background.gather_and_run_queries.stop()
