async def initialize(self, audio: Audio, enabled=True) -> None:
_pass_config_to_api(self.config)
global old_audio_cache
if old_audio_cache is None and enabled is True:
old_audio_cache = audio.music_cache
if enabled is True:
audio.music_cache = MusicCache(
audio.bot,
audio.session,
path=str(cog_data_path(raw_name="Audio")))
await audio.music_cache.initialize(audio.config)
elif enabled is False:
audio.music_cache = old_audio_cache
def __init__(self, bot):
super().__init__()
self.bot = bot
self.config = Config.get_conf(self, identifier=736144321857978388, force_registration=True)
default_guild = {'canvas': {}}
self.config.register_guild(**default_guild)
self.temp = cog_data_path(self) / "temp"
self.temp.mkdir(exist_ok=True, parents=True)
self.image_mimes = ["image/png", "image/pjpeg", "image/jpeg", "image/x-icon"]
self.gif_mimes = ["image/gif"]
async def _load_machine(self, source, filename):
if source == "local":
machine = yaml.safe_load(open(data_manager.bundled_data_path(self) / filename))
else:
machine = yaml.safe_load(open(data_manager.cog_data_path(self) / filename))
errors = await self._validate_machine(machine)
if errors == []:
self.slot_machines[machine["name"].lower()] = machine
else:
log.info(f"Failed to parse slot machine {filename}")
log.debug(errors)
return errors
async def themeset_add_monster(self, ctx: commands.Context, *, theme_data: ThemeSetMonterConverter):
"""[Owner] Add/Update a monster object in the specified theme.
Usage: `[p]themeset add monster theme++name++hp++dipl++pdef++mdef++cdef++boss++image`
`theme` is the one-word theme folder name. The default is `default`.
`name` is the name of the monster.
`hp` is the base amount of hp the monster has.
`dipl` is the base amount of charisma/diplomacy the monster has.
`pdef` is the percentage of physical resistance, `0.0` to `100.0`.
`mdef` is the percentage of magic resistance, `0.0` to `100.0`.
`cdef` is the percentage of charisma/diplomacy resistance, `0.0` to `100.0`.
`boss` is whether the monster is a boss, determined with `True` or `False`.
`image` is a URL for an image of the monster.
"""
assert isinstance(theme_data, dict)
theme = theme_data.pop("theme", None)
if theme != "default" and theme not in os.listdir(cog_data_path(self)):
await smart_embed(ctx, _("That theme pack does not exist!"))
return
updated = False
monster = theme_data.pop("name", None)
async with self.config.themes.all() as config_data:
if theme not in config_data:
config_data[theme] = {"monsters": {}}
if "monsters" not in config_data[theme]:
config_data[theme]["monsters"] = {}
if monster in config_data[theme]["monsters"]:
updated = True
config_data[theme]["monsters"][monster] = theme_data
image = theme_data.pop("image", None)
text = _(
"Monster: `{monster}` has been {status} the `{theme}` theme\n"
"```ini\n"
"HP: [{hp}]\n"
"Diplomacy: [{dipl}]\n"
"Physical defence: [{pdef}]\n"
"Magical defence: [{mdef}]\n"
"Persuasion defence: [{cdef}]\n"
"Is a boss: [{boss}]```"
).format(
monster=monster,
theme=theme,
status=_("added to") if not updated else _("updated in"),
**theme_data,
)
embed = discord.Embed(description=text, colour=await ctx.embed_colour())
embed.set_image(url=image)
await ctx.send(embed=embed)
def __init__(self, bot: Red):
self.bot = bot
self._connection = apsw.Connection(
str(cog_data_path(self) / "MartTools.db"))
self.cursor = self._connection.cursor()
self.cursor.execute(PRAGMA_journal_mode)
self.cursor.execute(PRAGMA_wal_autocheckpoint)
self.cursor.execute(PRAGMA_read_uncommitted)
self.cursor.execute(CREATE_TABLE_PERMA)
self.cursor.execute(DROP_TEMP)
self.cursor.execute(CREATE_TABLE_TEMP)
self.uptime = datetime.utcnow()
self.cursor.execute(INSERT_PERMA_DO_NOTHING,
(-1000, "creation_time", time.time()))
def __init__(self, bot: Red) -> None:
self.bot = bot
self.config = Config.get_conf(self,
identifier=176070082584248320,
force_registration=True)
self.config.register_guild(
role_id=None,
channel_id=None,
message_templates=[],
unassign_on_boost_end=False,
)
self.message_images = cog_data_path(self) / "message_images"
self.message_images.mkdir(parents=True, exist_ok=True)
self.guild_cache: Dict[int, GuildData] = {}
def make_crab(self, t, u_id):
"""Non blocking crab rave video generation from DankMemer bot
https://github.com/DankMemer/meme-server/blob/master/endpoints/crab.py
"""
fp = str(cog_data_path(self) / f"Verdana.ttf")
clip = VideoFileClip(str(cog_data_path(self)) + "/template.mp4")
# clip.volume(0.5)
text = TextClip(t[0], fontsize=48, color="white", font=fp)
text2 = (
TextClip("____________________", fontsize=48, color="white", font=fp)
.set_position(("center", 210))
.set_duration(15.4)
)
text = text.set_position(("center", 200)).set_duration(15.4)
text3 = (
TextClip(t[1], fontsize=48, color="white", font=fp)
.set_position(("center", 270))
.set_duration(15.4)
)
video = CompositeVideoClip(
[clip, text.crossfadein(1), text2.crossfadein(1), text3.crossfadein(1)]
).set_duration(15.4)
video = video.volumex(0.1)
video.write_videofile(
str(cog_data_path(self)) + f"/{u_id}crabrave.mp4",
threads=1,
preset="superfast",
verbose=False,
logger=None,
temp_audiofile=str(cog_data_path(self) / f"{u_id}crabraveaudio.mp3")
# ffmpeg_params=["-filter:a", "volume=0.5"]
)
clip.close()
video.close()
return True
def __init__(self, bot: Red) -> None:
self.bot = bot
self.config = Config.get_conf(self,
176070082584248320,
force_registration=True)
self.config.register_global(execution_key=None, ports=None)
self.env = {
"bot": bot,
"aiohttp": aiohttp,
"asyncio": asyncio,
"discord": discord,
"commands": commands,
}
self.connection_file = cog_data_path(self) / "kernel.json"
self.app: Optional[RedIPKernelApp] = None
def __init__(self, bot: Red):
super().__init__()
self.bot = bot
self.config = Config.get_conf(self, identifier=9811198108111121, force_registration=True)
default_guild = {"enabled": False, "channel_id": None}
self.config.register_guild(**default_guild)
# self.detector = NudeDetector()
self.classifier = NudeClassifier()
self.data_path: pathlib.Path = cog_data_path(self)
self.current_processes = 0
def __init__(self, bot):
super().__init__()
self.bot = bot
self.config = Config.get_conf(self, identifier=736144321857978388, force_registration=True)
default_global = {"INSTALOADER_LOGIN": "",
"INSTALOADER_PASSWORD": ""}
default_guild = {"fav_channel": None}
self.config.register_global(**default_global)
self.config.register_guild(**default_guild)
self.instaload = instaloader.Instaloader()
self.cache = {"_instagram": {}, "instaload": False, "tales": {}, "fav_msg": []}
self.temp = cog_data_path(self) / "temp"
self.temp.mkdir(exist_ok=True, parents=True)
async def wordlist(self, ctx, value: str):
"""
Change the wordlist used.
Extra wordlists can be put in the data folder.
Wordlists are a .txt file with every new line being a new word.
This value is server specific.
"""
wordlists = [p.resolve() for p in cog_data_path(self).glob("*.txt")]
try:
fp = next(p for p in wordlists if p.stem == value)
await self.config.guild(ctx.guild).fp.set(str(fp))
await ctx.send(f'The wordlist is now set to `{value}`.')
except StopIteration:
await ctx.send(f'Wordlist `{value}` not found.')
async def rusteval(self,ctx, *, body: str):
if not self.initialized:
return
body = self.cleaninput(body)
if "fn main()" not in body:
#We need to wrap the code in a main function
body = f"fn main(){{\n{body}\n}}"
with open(cog_data_path(self)/"internalproj"/"src"/"main.rs", "w") as outputfile:
outputfile.write(body)
compilerrun = self.subprocessrun(["cargo", "build"])
if len(compilerrun.stdout):
await ctx.send(f"```\n{compilerrun.stdout}```")
if len(compilerrun.stderr):
cleaned = compilerrun.stderr.replace(f"({str(cog_data_path(self)/'internalproj')})", '')
await ctx.send(f"```\n{cleaned}```")
if compilerrun.returncode != 0:
return await ctx.send("Failed to execute...")
progrun = subprocess.run([cog_data_path(self)/"internalproj"/"target"/"debug"/"internalproj"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
if len(progrun.stdout):
await ctx.send(f"```\n{progrun.stdout}```")
if len(progrun.stderr):
await ctx.send(f"```\n{progrun.stderr}```")
async def clean_deleted_images(self, ctx: commands.Context) -> None:
"""
Cleanup deleted images that are not supposed to be saved anymore
"""
images = await self.config.guild(ctx.guild).images()
directory = cog_data_path(self) / str(ctx.guild.id)
saved = os.listdir(str(directory))
for file in images:
if file["image_loc"] in saved:
continue
try:
os.remove(str(directory / file))
except Exception:
log.error(_("Error deleting image {image}").format(image=file), exc_info=True)
await ctx.tick()
def __init__(self, bot):
super().__init__()
self.bot = bot
self.path = cog_data_path(self) / "packs"
self.path.mkdir(exist_ok=True, parents=True)
self.config = Config.get_conf(self, identifier=736144321857978388, force_registration=True)
default_guild = {"default_mode": DEFAULT_MODE,
"original_win": 5,
"plus_win": 5,
"course_start": 5,
"packs": []}
self.config.register_guild(**default_guild)
self.packs = {}
self.load_packs()
def __init__(self, bot: Red):
self.bot = bot
self.config = Config.get_conf(self, identifier=9811198108111121, force_registration=True)
default_global = {"lint": True}
default_guild = {}
self.path = str(cog_data_path(self)).replace("\\", "/")
self.do_lint = None
self.counter = 0
# self.answer_path = self.path + "/tmpfile.py"
self.config.register_global(**default_global)
self.config.register_guild(**default_guild)
def __init__(self, bot: Red):
self.bot = bot
self.saveFolder = data_manager.cog_data_path(cog_instance=self)
self.logger = logging.getLogger("red.luicogs.Avatar")
if self.logger.level == 0:
# Prevents the self.logger from being loaded again in case of module reload.
self.logger.setLevel(logging.INFO)
logPath = os.path.join(self.saveFolder, "info.log")
handler = logging.FileHandler(filename=logPath,
encoding="utf-8",
mode="a")
handler.setFormatter(
logging.Formatter("%(asctime)s %(message)s",
datefmt="[%d/%m/%Y %H:%M:%S]"))
self.logger.addHandler(handler)
def __init__(self, bot):
super().__init__()
self.bot = bot
self.config = Config.get_conf(self,
identifier=95932766180343808,
force_registration=True)
self.config.register_global(
isglobal=True,
hashed=False,
hashes={},
spawnchance=[20, 120],
hintcost=1000,
spawnloop=False,
migration=1,
)
defaults_guild = {
"activechannels": [],
"toggle": False,
"whitelist": [],
"blacklist": [],
"levelup_messages": False,
}
self.config.register_guild(**defaults_guild)
defaults_user = {
"pokeids": {},
"silence": False,
"timestamp": 0,
"pokeid": 1,
"has_starter": False,
"locale": "en",
}
self.config.register_user(**defaults_user)
self.config.register_member(**defaults_user)
self.config.register_channel(pokemon=None)
self.datapath = f"{bundled_data_path(self)}"
self.maybe_spawn = {}
self.guildcache = {}
self.usercache = {}
self.spawnchance = []
self._connection = apsw.Connection(
str(cog_data_path(self) / "pokemon.db"))
self.cursor = self._connection.cursor()
self.cursor.execute(PRAGMA_journal_mode)
self.cursor.execute(PRAGMA_wal_autocheckpoint)
self.cursor.execute(PRAGMA_read_uncommitted)
self.cursor.execute(POKECORD_CREATE_POKECORD_TABLE)
self._executor = concurrent.futures.ThreadPoolExecutor(1)
self.bg_loop_task = None
def __init__(self, bot: Red):
self.bot = bot
self.path = str(cog_data_path(self)).replace("\\", "/")
self.image_path = self.path + "/"
self.config = Config.get_conf(self, identifier=9811198108111121, force_registration=True)
default_global = {
"messages": [],
"images": [],
"time": {"hour": 0, "minute": 0, "second": 0},
}
default_guild = {"channelid": None}
self.config.register_global(**default_global)
self.config.register_guild(**default_guild)
async def on_voice_state_update(self, member, before, after):
user_list = await self.config.get_raw('users')
if str(member.id) in user_list:
volume = user_list[str(member.id)]['volume']
file_name = user_list[str(member.id)]['sfx']
file_path = str(data_manager.cog_data_path(self)) + '/' + file_name
if after.channel is not None and after.channel != member.guild.afk_channel and not await self.isrestricted(
after.channel.id):
if before.channel is not None:
if before.channel.id != after.channel.id:
if os.path.isfile(file_path):
await self.playsound(file_path, volume,
after.channel)
else:
if os.path.isfile(file_path):
await self.playsound(file_path, volume, after.channel)
def __init__(self, bot: Red):
super().__init__()
self.bot = bot
self.config = Config.get_conf(self, identifier=5842647, force_registration=True)
self.config.register_guild(**BASE_GUILD)
self.loop = asyncio.get_running_loop()
saveFolder = data_manager.cog_data_path(cog_instance=self)
self.logger = logging.getLogger("red.luicogs.YOURLS")
if not self.logger.handlers:
logPath = os.path.join(saveFolder, "info.log")
handler = logging.FileHandler(filename=logPath, encoding="utf-8", mode="a")
handler.setFormatter(
logging.Formatter("%(asctime)s %(message)s", datefmt="[%d/%m/%Y %H:%M:%S]")
)
self.logger.addHandler(handler)
def cog_unload(self):
datapath = cog_data_path(self)
for guild in self.fridges.keys():
fridge = self.fridges[guild]
storeditems = list()
for key in fridge.keys():
count = fridge[key]
for _ in range(count):
storeditems.append(key)
filename = Path(datapath, f"{guild.id}.json")
log.info(f"Writing backing store {filename}")
with open(filename, 'w') as backingstore:
json.dump(storeditems, backingstore)
log.info("Unloading")
def __init__(self):
super().__init__()
# Get the path to the local quote csv file
base_path = str(data_manager.cog_data_path(self)).replace("\\", "/")
self.quotes_file = base_path + "/" + QUOTES_FILE_NAME
# Set up the quotes csv file if it doesn't already exist
Path(self.quotes_file).touch()
if not os.path.isfile(self.quotes_file):
with open(self.quotes_file, "w") as new_csv:
logger.info("Quotes csv file not found. Creating a new one.")
# Write quote 0 on init, so real quotes start at 1
self.register_quote(
"\"Hi mortals, I'm buddy!\" - Buddy, at the dawn of time")
logger.info("EWit Online")
async def cogpath(self, ctx: commands.Context, cog: str):
"""Get the paths for a cog."""
cog_obj = self.bot.get_cog(cog)
if cog_obj is None:
await ctx.send("Could not find a cog with this name.")
return
cog_path = pathlib.Path(inspect.getfile(cog_obj.__class__)).parent.resolve()
cog_data_path = pathlib.Path(data_manager.cog_data_path() / cog_obj.qualified_name).resolve()
if not os.path.exists(cog_data_path):
cog_data_path = None
if not isinstance(getattr(cog_obj, "config", None), Config):
reason = "This cog does not store any data."
else:
reason = "This cog had its data directory removed."
message = "Cog path: {}\nData path: {}".format(cog_path, cog_data_path or reason)
await ctx.send(box(message, lang="yaml"))
def __init__(self):
self.tts_languages = list(gtts.lang.tts_langs().keys())
self.last_track_info = None
self.current_sfx = None
self.config = Config.get_conf(self, identifier=134621854878007296)
self.sound_base = (data_manager.cog_data_path(self) / 'sounds').as_posix()
self.session = aiohttp.ClientSession()
default_config = {
'padding': 700,
'tts_lang': 'en',
'sounds': {}
}
self.config.register_guild(**default_config)
lavalink.register_event_listener(self.ll_check)
if not os.path.exists(self.sound_base):
os.makedirs(self.sound_base)
def __init__(self, bot):
self.bot = bot
self.path = str(datam.cog_data_path(self)).replace('\\', '/')
self.settings_file = 'settings'
self.check_folder()
self.check_file()
self.bot.loop.create_task(self.load_settings())
self.lf_gateway = 'http://ws.audioscrobbler.com/2.0/'
self.payload = {}
self.payload['api_key'] = 'c44979d5d86ff515ba9fba378c610474'
self.payload['format'] = 'json'
class Userdata:
users = {}
fp = cog_data_path(
None, "gobcog"
) / 'users.json' # this looks for users.json inside your RedBot/cogs/gobcog folder. Needs to be setup once: create the folder, make a users.json with just an empty {} inside.
with fp.open('r') as f:
users = json.load(f)
@staticmethod
async def save():
with Userdata.fp.open('w') as f:
json.dump(Userdata.users,
f,
indent=4,
default=lambda o: '<not serializable>',
sort_keys=True)
def __init__(self, bot):
self.bot = bot
self.session = aiohttp.ClientSession()
self.conf = Config.get_conf(self, identifier=3271169074)
default_guild_settings = {
"bg_color": "black",
"maxwords": 200,
"excluded": [],
"mask": None,
"colormask": False,
}
self.conf.register_guild(**default_guild_settings)
self.mask_folder = str(cog_data_path(raw_name="WordClouds")) + "/masks"
if not os.path.exists(self.mask_folder):
os.mkdir(self.mask_folder)
async def orly(self, ctx, box_text, title_text, small_text, image_url,
hex):
"""O Rly?"""
data_path = cog_data_path()
orly_logo = os.path.join(data_path, 'orly', 'data', 'orly-logo.png')
gara_font = os.path.join(data_path, 'orly', 'data', 'garamond.otf')
gara_italic_font = os.path.join(data_path, 'orly', 'data',
'garamond_italic.otf')
W, H = (500, 700)
try:
hex = hex.replace("#", "")
except:
return await ctx.send("Invalid hex.")
colour = tuple(int(hex[i:i + 2], 16) for i in (0, 2, 4)) + (255, )
im = Image.new("RGBA", (W, H), (255, 255, 255, 255))
draw = ImageDraw.Draw(im)
box_font = ImageFont.truetype(gara_font, 80)
box_size_w, box_size_h = draw.textsize(box_text, font=box_font)
title_font = ImageFont.truetype(gara_italic_font, 18)
title_size_w, title_size_h = draw.textsize(title_text, font=title_font)
small_font = ImageFont.truetype(gara_italic_font, 24)
small_size_w, small_size_h = draw.textsize(small_text, font=small_font)
draw.line((20, 0, 480, 0), width=20, fill=colour)
draw.line((20, 515, 480, 515), width=175, fill=colour)
logo = Image.open(orly_logo).resize((100, 40), Image.ANTIALIAS)
im.paste(logo, (30, 635), mask=logo)
inp_im = (Image.open(await self.getimage(image_url)).resize(
(350, 350), Image.ANTIALIAS)).convert("RGBA")
im.paste(inp_im, (75, 70), mask=inp_im)
draw.text(((W - title_size_w) / 2, 15),
title_text,
font=title_font,
fill="black")
draw.text((480 - small_size_w, 605),
small_text,
font=small_font,
fill="black")
lines = textwrap.wrap(box_text, width=10)[:2]
line_h, pad = 443, 10
for line in lines:
lw, lh = draw.textsize(line, font=box_font)
draw.text((25, line_h), line, font=box_font)
line_h += lh + pad
img = BytesIO()
im.save(img, "png")
img.seek(0)
await ctx.send(file=discord.File(img, "orly.png"))
def __init__(self, bot: Red) -> None:
super().__init__()
self.bot = bot
self.loop: asyncio.AbstractEventLoop = bot.loop
self._executor = ThreadPoolExecutor()
self.config = Config.get_conf(
self, identifier=6672039729, force_registration=True
)
self.config.register_global(
tier_breakdown={}, competitive_overlay=40, extramodes_overlay=70
)
self.config.register_user(player_id=None, platform=None)
self.rlapi_client: rlapi.Client = None # assigned in initialize()
self.bundled_data_path = bundled_data_path(self)
self.cog_data_path = cog_data_path(self)
self._prepare_templates()
def __init__(self, bot: Red):
super().__init__()
self.bot = bot
self.FOLDER = str(data_manager.cog_data_path(self))
self.PATH_DB = self.FOLDER + "/account_registrations.db"
self.config = Config.get_conf(self,
identifier=80590423,
force_registration=True)
self.config.register_global(psy_token=None, steam_token=None)
# Structure of rankrole_dict: {tier_n: role_id}
self.config.register_guild(rankrole_enabled=False,
rankrole_dict={},
ignore_special=False)
self.psy_api = PsyonixCalls(self.config)
self.steam_api = SteamCalls(self.config)
self.link_db = DbQueries(self.PATH_DB)
self.json_conv = GetJsonData()
def __init__(self, bot: Red):
super().__init__()
self.bot = bot
self.conf = Config.get_conf(self, identifier=998240343, force_registration=True)
self.conf.register_global(installed=[])
self.already_agreed = False
self.LIB_PATH = cog_data_path(self) / "lib"
self.SHAREDLIB_PATH = self.LIB_PATH / "cog_shared"
self.SHAREDLIB_INIT = self.SHAREDLIB_PATH / "__init__.py"
self.LIB_PATH.mkdir(parents=True, exist_ok=True)
self.SHAREDLIB_PATH.mkdir(parents=True, exist_ok=True)
if not self.SHAREDLIB_INIT.exists():
with self.SHAREDLIB_INIT.open(mode="w", encoding="utf-8") as _:
pass
if str(self.LIB_PATH) not in syspath:
syspath.insert(1, str(self.LIB_PATH))
self._repo_manager = RepoManager()
def __init__(self, bot):
self.bot = bot
self.path = str(datam.cog_data_path(self)).replace("\\", "/")
self.attachment_path = self.path + "/attachments"
self.check_folder()
self.event_types = [
"on_member_update",
"on_voice_state_update",
"on_message_edit",
"on_message_delete",
"on_raw_bulk_message_delete",
"on_guild_channel_create",
"on_guild_channel_delete",
"on_guild_channel_update",
"on_guild_update",
"on_guild_role_create",
"on_guild_role_delete",
"on_guild_role_update",
"on_member_ban",
"on_member_unban",
"on_member_kick",
"on_member_remove",
"on_member_join",
]
self.config = Config.get_conf(self, identifier=6198483584)
default_guild = {
"enabled": False,
"compact": False,
"events": {},
"ignore": {"channels": {}, "members": {}},
}
self.config.register_guild(**default_guild)
from pathlib import Path
import logging
from .audio import Audio
from .manager import start_lavalink_server, maybe_download_lavalink
from redbot.core import commands
from redbot.core.data_manager import cog_data_path
import redbot.core
log = logging.getLogger("red.audio")
LAVALINK_DOWNLOAD_URL = (
"https://github.com/Cog-Creators/Red-DiscordBot/releases/download/{}/Lavalink.jar"
).format(redbot.core.__version__)
LAVALINK_DOWNLOAD_DIR = cog_data_path(raw_name="Audio")
LAVALINK_JAR_FILE = LAVALINK_DOWNLOAD_DIR / "Lavalink.jar"
APP_YML_FILE = LAVALINK_DOWNLOAD_DIR / "application.yml"
BUNDLED_APP_YML_FILE = Path(__file__).parent / "data/application.yml"
async def setup(bot: commands.Bot):
cog = Audio(bot)
if not await cog.config.use_external_lavalink():
await maybe_download_lavalink(bot.loop, cog)
await start_lavalink_server(bot.loop)
await cog.initialize()
bot.add_cog(cog)
