def voice_connect(self, guild, channel):
guild_id = get(guild, 'id', guild)
channel_id = get(channel, 'id', channel)
path = 'guild/{}/voice_connect/{}'.format(guild_id, channel_id)
try:
r = self.http.get(path)
except RPCException as e:
if e.status_code == 404:
return None
raise e
return True
def get_guild_member(self, guild, member):
guild_id = get(guild, 'id', guild)
member_id = get(member, 'id', member)
path = 'guild/{}/members/{}'.format(guild_id, member_id)
try:
r = self.http.get(path)
except RPCException as e:
if e.status_code == 404:
return None
raise e
payload = r.json()
return Member(**payload)
def __init__(self, in_bot=True):
self.plugin_db = PrefixedRedis(self.db, 'plugin.' + self.id + '.')
self.in_bot = in_bot
methods = inspect.getmembers(self, predicate=inspect.ismethod)
commands_callbacks = [
meth for name, meth in methods if get(meth, 'command_info')
]
self.commands = []
for cb in commands_callbacks:
info = cb.command_info
opts = dict()
opts['expression'] = info['expression']
opts['description'] = info['description']
opts['callback'] = cb
opts['plugin'] = self
opts['restrict_default'] = info.get('restrict_default', False)
command = Command(**opts)
self.commands.append(command)
# Configs group keys
self.config_db = GroupKeys(self.id + '.config',
self.plugin_db,
cache=in_bot,
callback=self.handle_config_change)
# Commands Configs group keys
self.commands_config_db = GroupKeys(
self.id + '.cmd-config',
self.plugin_db,
cache=in_bot,
callback=self.handle_commands_config_change)
def check_guild(self, guild):
guild_id = get(guild, 'id', guild)
if not self.db.sismember('servers', guild_id):
return False
plugins = self.db.smembers('plugins:{}'.format(guild_id))
return self.name in plugins
def get_dict(self):
dct = dict()
for field_name in self.top_level_fields:
value = get(self, field_name)
if value:
dct[field_name] = value
footer = dict()
for field_name in self.footer_fields:
value = get(self, 'footer_' + field_name)
if value:
footer[field_name] = randomize(field_name, value, light=True)
if footer != {}:
dct['footer'] = footer
image = dict()
for field_name in self.image_fields:
value = get(self, 'image_' + field_name)
if value:
image[field_name] = randomize(field_name, value, light=False)
if image != {}:
dct['image'] = image
thumbnail = dict()
for field_name in self.thumbnail_fields:
value = get(self, 'thumbnail_' + field_name)
if value:
thumbnail[field_name] = randomize(field_name,
value,
light=False)
if thumbnail != {}:
dct['thumbnail'] = thumbnail
author = dict()
for field_name in self.author_fields:
value = get(self, 'author_' + field_name)
if value:
author[field_name] = randomize(field_name, value, light=True)
if author != {}:
dct['author'] = author
dct['fields'] = self.fields
return dct
def get_config(self, guild):
guild_id = get(guild, 'id', guild)
raw_config = self.config_db.get('config.{}'.format(guild_id))
if raw_config is None:
return self.default_config(guild)
config = json.loads(raw_config)
return CommandConfig(**config)
def patch_config(self, guild, partial_new_config):
guild_id = get(guild, 'id', guild)
config = self.get_config(guild)
for field_name in config.__class__._fields:
new_value = partial_new_config.get(field_name)
if new_value is not None:
setattr(config, field_name, new_value)
config.sanitize()
config.validate()
raw_config = json.dumps(config.serialize())
self.config_db.set('config.{}'.format(guild_id), raw_config)
return config
def get_config(self, guild):
guild_id = get(guild, 'id', guild)
key = 'config.{}'.format(guild_id)
raw_config = self.config_db.get(key)
if raw_config:
config = self.config_model(**json.loads(raw_config))
else:
config = self.get_default_config(guild_id)
return config
def voice_stop(self, guild):
guild_id = get(guild, 'id', guild)
path = 'guild/{}/voice_stop'.format(guild_id)
try:
r = self.http.get(path)
except RPCException as e:
if e.status_code == 404:
return None
raise e
return True
def get_guild_storage(self, guild):
guild_id = get(guild, 'id', guild)
guild_storage = self.guild_storages.get(guild_id)
if guild_storage:
return guild_storage
prefix = 'plugin.{}.guild.{}.storage.'.format(self.id, guild_id)
guild_storage = PrefixedRedis(self.db, prefix)
self.guild_storages[guild_id] = guild_storage
return guild_storage
def voice_play(self, guild, url):
guild_id = get(guild, 'id', guild)
path = 'guild/{}/voice_play'.format(guild_id)
json_body = {'url': url}
try:
r = self.http.post(path, json=json_body)
except RPCException as e:
if e.status_code == 404:
return None
raise e
return True
def get_guild_members(self, guild):
guild_id = get(guild, 'id', guild)
path = 'guild/{}/members'.format(guild_id)
try:
r = self.http.get(path)
except RPCException as e:
if e.status_code == 404:
return None
raise e
payload = r.json()
return [Member(**m) for m in payload.values()]
def get_guild(self, guild):
guild_id = get(guild, 'id', guild)
path = 'guild/{}'.format(guild_id)
try:
r = self.http.get(path)
except RPCException as e:
if e.status_code == 404:
return None
raise e
payload = r.json()
return Guild(**payload)
def patch_config(self, guild, raw_config):
guild_id = get(guild, 'id', guild)
config = self.get_config(guild_id)
new_config = self.config_model(**raw_config)
new_config.sanitize()
new_config.validate()
# pre-hook
self.before_config_patch(guild_id, config, new_config)
self.config_db.set('config.{}'.format(guild_id),
json.dumps(new_config.serialize()))
# post-hook
self.after_config_patch(guild_id, new_config)
return new_config
def default_config(self, guild):
guild_id = get(guild, 'id', guild)
default_config = {
'allowed_roles': [],
'enabled': True,
'global_cooldown': -1,
'personal_cooldown': -1
}
if not self.restrict_default:
default_config['allowed_roles'] = [guild_id]
return CommandConfig(**default_config)
def run(self):
loops = []
for name, method in self.__class__.__dict__.items():
if hasattr(method, 'is_loop'):
loops.append(name)
loops = [get(self, loop) for loop in loops]
active_loops = []
import copy
for loop in loops:
active_loops.append(gevent.spawn(self.get_loop_container(loop)))
gevent.joinall(active_loops)
def handle_event(self, payload):
event_type = payload['t']
guild_id = payload['g']
data = payload.get('d')
if data:
data_type_name = event_type.split('_')[0].lower()
data_type_module = get(mee6.types, data_type_name)
if data_type_module:
data_type = get(data_type_module, data_type_name.capitalize())
else:
data_type = None
if data_type:
decoded_data = data_type(**data)
else:
decoded_data = data
listener = get(self, 'on_' + event_type.lower())
if listener:
if data:
gevent.spawn(listener, guild_id, decoded_data)
else:
gevent.spawn(listener, guild_id)
def check_permission(self, ctx):
member_permissions = ctx.author.guild_permissions
if (member_permissions >> 5 & 1) or (member_permissions >> 3 & 1):
return True
if int(ctx.author.id) == int(ctx.guild.owner_id):
return True
config = self.get_config(ctx.guild)
allowed_roles = config.allowed_roles
for role in ctx.author.roles:
role_id = get(role, 'id', role)
if role_id in allowed_roles:
return True
return False
def patch_config_old(self, guild, partial_new_config):
guild_id = get(guild, 'id', guild)
config = self.get_config(guild_id)
new_config = deepcopy(config)
for field_name, field in config.__class__._fields.items():
new_value = partial_new_config.get(field_name)
if new_value is not None:
setattr(new_config, field_name, field.deserialize(new_value))
new_config.sanitize()
new_config.validate()
# pre-hook
self.before_config_patch(guild_id, config, new_config)
self.config_db.set('config.{}'.format(guild_id),
json.dumps(new_config.serialize()))
# post-hook
self.after_config_patch(guild_id, new_config)
return new_config
def patch_config(self, guild, new_config):
guild_id = get(guild, 'id', guild)
old_config = self.get_config(guild_id)
# pre-hook
self.before_config_patch(guild_id, old_config, new_config)
config = {
k: new_config.get(k, old_config[k])
for k in old_config.keys()
}
# validation
config = self.validate_config(guild_id, config)
self.config_db.set('config.{}'.format(guild_id), json.dumps(config))
# post-hook
self.after_config_patch(guild_id, config)
return config
def send(self, guild, channel):
guild_id = get(guild, 'id', guild)
channel_id = get(channel, 'id', channel)
return send_message(channel_id, self.message, embed=self.embed)
def disable(self, guild):
guild_id = get(guild, 'id', guild)
self.db.srem('plugins:{}'.format(guild_id), self.name)
self.db.srem('plugin.{}.guilds'.format(self.name), guild_id)
def worker(plugins):
plugins = [get(mee6.plugins, plugin_name) for plugin_name in plugins]
mee6_worker.run(*plugins)
def plugin(plugin_name):
plugins_name = plugin_name.capitalize()
plugin = get(mee6.plugins, plugin_name)()
plugin.run()
def delete_config(self, guild):
guild_id = get(guild, 'id', guild)
self.config_db.delete('config.{}'.format(guild_id))
