async def eval(self, ctx, *, code):
client = mystbin.Client()
code = code.lstrip("```").rstrip("```")
code = code.splitlines()
lang = code.pop(0)
code = "\n".join(code)
json = {"language": lang, "source": code}
async with self.bot.session.post(
"https://emkc.org/api/v1/piston/execute", json=json) as resp:
data = await resp.json()
if data.get("message"):
return await ctx.send(embed=ctx.embed(
title="Something went wrong...",
description=data.get("message"),
))
if len(data.get("output")) > 2000:
thing = await client.post(content=data.get("output"), syntax=lang)
return await ctx.send(embed=ctx.embed(
title="Your output was too long so I uploaded it here:",
description=thing,
))
await ctx.send(embed=ctx.embed(
title=f"Ran your code in `{lang}`",
description=f'```{lang}\n{data.get("output")}\n```',
))
async def exc(e):
user = models.User.get_from_cache()
error_channel = bot.get_channel(836993491485458454)
emb = discord.Embed(color=discord.Color.red(), title="Error Occured!")
error = "".join(traceback.format_exception(type(e), e, e.__traceback__))
if len(error) > 2000:
mystbin_client = mystbin.Client()
error = await mystbin_client.post(error, syntax='python')
else:
error = f"```py\n{error}```"
emb.description = f"{error}"
await error_channel.send(embed=emb, content="Error occured!")
return await render_template(
'errors/exception.html',
not_found_icon=not_found_icon,
color=WebsiteTheme.color,
icon=image,
staff=cache.get_from_cache(cache, 'staff_open'),
logged_in=await discord_session.authorized,
is_staff=verify_staff(db, user),
announcement=cache.get_from_cache(cache, 'announcement'),
announcement_color=cache.get_from_cache(cache, 'announcement_color'),
error=e,
user=user)
def __init__(self):
_allowed_mentions = discord.AllowedMentions(users=True,
replied_user=False,
roles=False,
everyone=False)
_intents = discord.Intents.all()
super().__init__(command_prefix=get_prefix,
case_insensitive=True,
allowed_mentions=_allowed_mentions,
intents=_intents,
help_command=ShrimpMasterHelpCommand(),
owner_id=414556245178056706)
self.db = None
self.timers = None
self.evaluator = None
self.command_usage = {}
self.up_since = datetime.datetime.utcnow()
self.handler = handler.Handler()
self.session = aiohttp.ClientSession()
self.mystbin = mystbin.Client()
self.gist = Gist(self.session)
self.crime_messages = {"good": [], "bad": [], "die": []}
self._setup()
def __init__(self, bot):
self.bot = bot
self._last_result = None
self.help_icon = ''
self.big_icon = ''
self.anti_spam_commands = CooldownByContent.from_cooldown(17, 15.0, commands.BucketType.member) # 12 commands per 15 seconds
self.pre_anti_spam = CooldownByContent.from_cooldown(5, 10, commands.BucketType.member) # 5 commands per 10 seconds
self.mystbin_client = mystbin.Client()
def __init__(self, bot):
self.bot = bot
self.token = bot.config["githubkey"]
self.bot.snipe = {}
self.bot.editsnipe = {}
self.mystbin = mystbin.Client()
self.cleverbot = async_cleverbot.Cleverbot(
self.bot.config['travitiakey'])
def __init__(self, *args, **kwargs):
super().__init__(get_prefix,
description="A moderation / fun bot",
intents=intents,
allowed_mentions=discord.AllowedMentions.none(),
activity=discord.Activity(
type=discord.ActivityType.listening,
name="@Penguin"),
owner_ids={447422100798570496},
**kwargs)
self._logger = logging.getLogger(__name__)
self.loop = asyncio.get_event_loop()
self.session = aiohttp.ClientSession()
self.start_time = dt.datetime.now()
with open("config.json") as res:
self.config = json.load(res)
self.ipc = ipc.Server(self, "localhost", self.config['ipc-port'],
self.config['ipc-key'])
self.load_extension("utils.ipc")
self.db = self.loop.run_until_complete(
asyncpg.create_pool(**self.config['db']))
# Cache stuff
self.stats = {}
self.prefixes = {}
self.cache = {}
self.disabledCommands = []
self.blacklistedUsers = []
self.reactionRoleDict = self.loop.run_until_complete(
self.cache_reactionroles())
records = self.loop.run_until_complete(
self.db.fetch("SELECT * FROM blacklist"))
for i in records:
self.blacklistedUsers.append(i["id"])
records = self.loop.run_until_complete(
self.db.fetch("SELECT * FROM guild_config"))
self.prefixes = dict(
self.loop.run_until_complete(
self.db.fetch("SELECT id, prefix FROM guild_config")))
for record in records:
d = self.refresh_template(record)
self.cache.update(d)
self.get_announcement()
self.dagpi_client = Client(self.config['dagpi'])
self.command_stats = {}
self.mystbin = mystbin.Client()
self.load_cogs()
async def funky_shit(self):
""" A quick coro to set the bot's owner. """
await self.wait_until_ready()
# if not self.owner_id:
# self.owner_id = (await self.application_info()).owner.id
if not self.session:
self.session = aiohttp.ClientSession()
if not self.mb_client:
self.mb_client = mystbin.Client(session=self.session)
def run(self, *args, **kwargs):
# self.ipc.start()
subprocess.check_output("pip install speedtest-cli", shell=True)
self.before_invoke(self.start_typing)
self.utils = utils
self.deleted_message_cache = LimitedSizeDict()
self.concurrency = []
self.color = 0x00ff6a
self.psutil_process = psutil.Process()
self._message_cache = {}
self.prefixes = {}
self.socket_receive = 0
self.start_time = time.time()
self.socket_stats = Counter()
self.command_counter = 0
self.commandsusages = Counter()
self.session = aiohttp.ClientSession(
headers={
"User-Agent":
f"python-requests/2.25.1 The Anime Bot/1.1.0 Python/{sys.version_info[0]}.{sys.version_info[1]}.{sys.version_info[2]} aiohttp/{aiohttp.__version__}"
})
self.mystbin = mystbin.Client(session=self.session)
self.vacefron_api = vacefron.Client(session=self.session,
loop=self.loop)
self.dag = Client(api_token, session=self.session, loop=self.loop)
self.alex = alexflipnote.Client(alex_,
session=self.session,
loop=self.loop)
self.ball = eight_ball.ball()
self.zaneapi = aiozaneapi.Client(zane_api)
for command in self.commands:
self.command_list.append(str(command))
self.command_list.extend([alias for alias in command.aliases])
if isinstance(command, commands.Group):
for subcommand in command.commands:
self.command_list.append(str(subcommand))
self.command_list.extend([
f"{command} {subcommand_alias}"
for subcommand_alias in subcommand.aliases
])
if isinstance(subcommand, commands.Group):
for subcommand2 in subcommand.commands:
self.command_list.append(str(subcommand2))
self.command_list.extend([
f"{subcommand} {subcommand2_alias}"
for subcommand2_alias in subcommand2.aliases
])
if isinstance(subcommand2, commands.Group):
for subcommand3 in subcommand2.commands:
self.command_list.append(str(subcommand3))
self.command_list.extend([
f"{subcommand2} {subcommand3_alias}"
for subcommand3_alias in
subcommand3.aliases
])
super().run(*args, **kwargs)
def __init__(self) -> None:
super().__init__(
status=discord.Status.dnd,
activity=discord.Activity(type=discord.ActivityType.playing,
name="aaaaa!"),
allowed_mentions=discord.AllowedMentions(everyone=False,
users=True,
roles=True,
replied_user=False),
help_command=custom.HelpCommand(),
intents=discord.Intents.all(),
command_prefix=self.get_prefix,
case_insensitive=True,
owner_ids=config.OWNER_IDS,
)
self._BotBase__cogs = commands.core._CaseInsensitiveDict()
self.session: aiohttp.ClientSession = aiohttp.ClientSession()
self.process: psutil.Process = psutil.Process()
self.socket_stats: collections.Counter = collections.Counter()
self.ERROR_LOG: discord.Webhook = discord.Webhook.from_url(
session=self.session, url=config.ERROR_WEBHOOK_URL)
self.GUILD_LOG: discord.Webhook = discord.Webhook.from_url(
session=self.session, url=config.GUILD_WEBHOOK_URL)
self.DMS_LOG: discord.Webhook = discord.Webhook.from_url(
session=self.session, url=config.DM_WEBHOOK_URL)
self.db: asyncpg.Pool = utils.MISSING
self.redis: aioredis.Redis | None = None
self.scheduler: aioscheduler.Manager = aioscheduler.Manager()
self.mystbin: mystbin.Client = mystbin.Client(session=self.session)
self.slate: obsidian.NodePool[Life, custom.Context,
custom.Player] = obsidian.NodePool()
self.ipc: ipc.Server = ipc.Server(bot=self,
secret_key=config.SECRET_KEY,
multicast_port=config.MULTICAST_PORT)
self.topgg: topgg.DBLClient | None = topgg.DBLClient(
bot=self, token=config.TOPGG, autopost=True
) if config.ENV is enums.Environment.PRODUCTION else None
self.user_manager: managers.UserManager = managers.UserManager(
bot=self)
self.guild_manager: managers.GuildManager = managers.GuildManager(
bot=self)
self.first_ready: bool = True
self.start_time: float = time.time()
self.add_check(checks.global_check, call_once=True) # type: ignore
self.converters |= values.CONVERTERS
async def look_at(self, ctx):
if isinstance(ctx.message.channel, discord.TextChannel):
message_emojis = ""
for x in ctx.guild.emojis:
message_emojis = message_emojis + " " + str(x) + "\n"
mystbin_client = mystbin.Client(session=self.client.session)
paste = await mystbin_client.post(message_emojis)
await ctx.send(paste.url)
if isinstance(ctx.channel, discord.DMChannel):
await ctx.send("We can't use that in DMS")
def __init__(self):
intents = discord.Intents.all()
super().__init__(
command_prefix=_prefix_callable,
description=DESCRIPTION,
allowed_mentions=discord.AllowedMentions.none(),
intents=intents,
application_id=565095015874035742,
)
self.session = aiohttp.ClientSession()
self.mb_client = mystbin.Client(session=self.session)
self.hentai_client = nhentaio.Client()
md_user = config.mangadex_auth["username"]
assert md_user is not None
md_pass = config.mangadex_auth["password"]
assert md_pass is not None
md_token = config.mangadex_auth["refresh_token"]
self.manga_client = hondana.Client(username=md_user,
password=md_pass,
refresh_token=md_token)
self._prev_events = deque(maxlen=10)
self.prefixes = Config("prefixes.json")
self.blacklist = Config("blacklist.json")
self.emoji = {
True: "<:TickYes:735498312861351937>",
False: "<:CrossNo:735498453181923377>",
None: "<:QuestionMaybe:738038828928860269>",
}
self.colour: discord.Colour = discord.Colour(0xEC9FED)
# in case of even further spam, add a cooldown mapping
# for people who excessively spam commands
self.spam_control = commands.CooldownMapping.from_cooldown(
10, 12.0, commands.BucketType.user)
# A counter to auto-ban frequent spammers
# Triggering the rate limit 5 times in a row will auto-ban the user from the bot.
self._auto_spam_count = Counter()
for extension in EXTENSIONS:
try:
self.load_extension(extension)
except Exception:
print(f"Failed to load extension {extension}.",
file=sys.stderr)
traceback.print_exc()
def __init__(self, **kwargs):
super().__init__(
**kwargs,
command_prefix=get_prefix,
owner_ids=[668906205799907348, 746807014658801704],
case_insensitive=True,
)
# Cogs
self.coglist = [
f"cogs.{item[:-3]}"
for item in os.listdir("/storage/emulated/0/PacMe/cogs")
if item != "__pycache__"
] + ["jishaku"] + ["listeners.error"]
for extension in self.coglist:
try:
self.load_extension(extension)
except Exception as e:
print(e)
# Cache
self.cache = {}
# Config
self.ipc = ipc.Server(self, secret_key="ConfirmItsMe")
self._token = secret_file["token"]
self.dagpi = secret_file["dagpi"]
self.asyncpg = secret_file['postgres']
self.blacklist = set()
self.embed_color = 0x8936FF
self.embed_colour = self.embed_color
self.maint = False
self.maintenence = False
self._underscore = True
self.mystbin = mystbin.Client()
self.start_time = datetime.datetime.utcnow()
self.emoji_dict = {
"greyTick": "<:greyTick:596576672900186113>",
"greenTick": "<:greenTick:820316551340490752>",
"redTick": "<:redTick:820319748561829949>",
"dpy": "<:dpy:596577034537402378>",
"py": "<:python:286529073445076992>"
}
self.custom_errors = utils.errors
def __init__(self):
super().__init__(
command_prefix=get_prefix,
description="A multipurpose discord bot made in python.",
intents=intents,
case_insensitive=True,
owner_ids=[int(owner_id)
for owner_id in os.environ.get("OWNERIDS").split(" ")],
allowed_mentions=mentions
)
self.ready = False
self.__name__ = 'Saturn'
self.src = 'https://github.com/SynchronousDev/saturn-discord-bot'
self.path = str(Path(__file__).parents[0])
self.__version__ = '1.1.0'
self.mongo_connection_url = os.environ.get("MONGO")
self.TOKEN = os.environ.get("TOKEN")
self.edit_snipes = {}
self.snipes = {}
self.banned_users = {}
self.muted_users = {}
self.message_cache = {}
self.mongo = motor.motor_asyncio.AsyncIOMotorClient(
str(self.mongo_connection_url))
self.db = self.mongo[self.__name__]
self.config = self.db["config"]
self.mutes = self.db["mutes"]
self.blacklists = self.db["blacklists"]
self.tags = self.db["tags"]
self.mod = self.db["mod"]
self.bans = self.db["bans"]
self.starboard = self.db["starboard"]
self.paste = mystbin.Client()
self.topgg_client = topgg.DBLClient(self, os.environ.get(
"TOPGGTOKEN"), autopost=False)
self.topgg_webhook = topgg.WebhookManager(
self).dbl_webhook("/dblwebhook", os.environ.get("TOPGGAUTH"))
self.topgg_webhook.run(5678)
def __init__(self):
intents = discord.Intents.all()
super().__init__(
command_prefix=_prefix_callable,
description=DESCRIPTION,
activity=discord.Game(name="a!help for help."),
allowed_mentions=discord.AllowedMentions.none(),
intents=intents,
)
self.session = aiohttp.ClientSession()
self.mb_client = mystbin.Client(session=self.session)
self.hentai_client = nhentaio.Client()
self._prev_events = deque(maxlen=10)
self.prefixes = Config("prefixes.json")
self.blacklist = Config("blacklist.json")
self.emoji = {
True: "<:TickYes:735498312861351937>",
False: "<:CrossNo:735498453181923377>",
None: "<:QuestionMaybe:738038828928860269>",
}
self.colour: Dict[str, Union[Tuple[int, ...], discord.Colour]] = {
"dsc": discord.Colour(0xEC9FED),
"rgb": (236, 159, 237),
"hsv": (299, 33, 93),
}
# in case of even further spam, add a cooldown mapping
# for people who excessively spam commands
self.spam_control = commands.CooldownMapping.from_cooldown(
10, 12.0, commands.BucketType.user)
# A counter to auto-ban frequent spammers
# Triggering the rate limit 5 times in a row will auto-ban the user from the bot.
self._auto_spam_count = Counter()
for extension in EXTENSIONS:
try:
self.load_extension(extension)
except Exception:
print(f"Failed to load extension {extension}.",
file=sys.stderr)
traceback.print_exc()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.remove_command('help')
self._commands = 0
self.currency_cache = {}
self.session = ClientSession(loop=self.loop)
self.dag = Client(dagpi_token, loop=self.loop)
self.mystbin = mystbin.Client()
self._start = time.time()
self._prefixes = json.load(open('./prefixes.json', 'r'))
self._banned = json.load(open('./bans.json', 'r'))
self._edit_cache = {}
self.cse = cse.Search(google_key)
self.ipc = ipc.Server(self, 'localhost', 8080, secret_key=ipc_key)
self.ball = ball()
self.load_extension('jishaku')
os.environ["JISHAKU_NO_UNDERSCORE"] = "true"
os.environ["JISHAKU_NO_DM_TRACEBACK"] = "true"
os.environ["JISHAKU_HIDE"] = "true"
async def text_backup(self, ctx):
if ctx.message.attachments:
for x in ctx.message.attachments:
file = await x.read()
if len(file) > 0:
encoding = chardet.detect(file)["encoding"]
if encoding:
text = file.decode(encoding)
mystbin_client = mystbin.Client(
session=self.client.session)
paste = await mystbin_client.post(text)
await ctx.send(
content=f"Added text file to mystbin: \n{paste.url}"
)
if encoding is None:
await ctx.send(
"it looks like it couldn't decode this file, if this is an issue DM JDJG Inc. Official#3439 or it wasn't a text file."
)
if len(file) < 1:
await ctx.send("this doesn't contain any bytes.")
async def setup_hook(self) -> None:
self.session: ClientSession = ClientSession()
self.cache: Cache = Cache(self)
self.pool: asyncpg.Pool = await asyncpg.create_pool(
**self.settings["postgresql"])
self.topgg: DBLClient = DBLClient(self,
self.api["TopGG"],
autopost_interval=None,
session=self.session)
self.topgg_webhook: WebhookManager = WebhookManager(self).dbl_webhook(
"/dbl", self.api["TopGGWH"])
self.gist: asyncgist.Client = asyncgist.Client(self.api["GitHub"],
self.session)
self.sr: sr_api.Client = sr_api.Client()
self.dagpi: asyncdagpi.Client = asyncdagpi.Client(self.api["DagpiAPI"],
session=self.session)
self.myst: mystbin.Client = mystbin.Client(session=self.session)
self.loop.create_task(self.cache.populate_cache())
self.loop.create_task(self.load_extensions())
self.loop.create_task(self.start_nodes())
self.loop.create_task(self.find_restart_message())
self.topgg_webhook.run(8025)
replied_user=False),
embed_color=0x31A1F1,
activity=activity,
owner_ids={447422100798570496})
@bot.event
async def on_ready():
print("Logged in! \n"
f"{'-' * 20}\n"
f"Bot Name: {bot.user} \n"
f"Bot ID: {bot.user.id} \n"
f"{'-' * 20}")
bot.mystbin = mystbin.Client()
@bot.event
async def on_error(event, *args, **kwargs):
ignored_events = ["on_member_join", "on_message", "on_raw_reaction_add"]
if event in ignored_events:
return
else:
raise
if __name__ == "__main__":
bot.ipc.start()
for extension in startup_extensions:
try:
def __init__(self, bot):
self.bot = bot
self.mystbin_client = mystbin.Client()
self.description = "Some random fun and usefull commands."
async def get_prefix(bot, message):
if message.guild is None:
prefixes = ["th,", "th.", "th ", "please dont find this one, "]
elif message.author.id == 787800565512929321:
prefixes = ["th,", "th.", "th ", ""]
else:
prefixes = ["th,", "th.", "th ", "please dont find this one,"]
return commands.when_mentioned_or(*prefixes)(bot, message)
bot = commands.Bot(command_prefix=get_prefix, intents=intents, help_command=Help(), allowed_mentions=discord.AllowedMentions(users=True, roles=False, everyone=False, replied_user=True),case_insensitive=True)
bot.db = aiosqlite.connect("main.sqlite")
bot.mystbin_client = mystbin.Client()
bot.version = "15"
START_BAL = 250
token = open("toke.txt", "r").read()
bot.load_extension("jishaku")
hce = bot.get_command("help")
hce.hidden = True
dagpitoken = open("asy.txt", "r").read()
robloxcookie = open("roblox.txt", "r").read()
topastoken = open("top.txt", "r").read()
chatbottoken = open("chat.txt", "r").read()
hypixel = open("hypixel.txt", "r").read()
bot.robloxc = f"{robloxcookie}"
bot.hypixel = f"{hypixel}"
bot.topken = f"{topastoken}"
bot.chatbot = ac.Cleverbot(f"{chatbottoken}")
def __init__(self, bot):
self.bot = bot
self.myst = mystbin.Client()
self.translator = google_translator()
def __init__(self, bot):
self.bot = bot
self.session = aiohttp.ClientSession()
self.myst = mystbin.Client()
def __init__(self, bot):
self.bot = bot
self.mystbin = mystbin.Client()
def __init__(self, bot: Life) -> None:
self.bot = bot
self.bot.error_formatter = prettify_exceptions.DefaultFormatter()
self.bot.mystbin = mystbin.Client()
