def get_server_channel(server: discord.Server):
""" Return the server's music channel or None. """
for channel in server.channels:
if channel.id in music_channels.data:
return channel
return None
python类Server()的实例源码
def client_connected(server: discord.Server):
""" Returns True or False whether the bot is client_connected to the
Music channel in this server. """
channel = get_server_channel(server)
return server.me.voice_channel == channel and server in voice_states
def get_notify_channels(server: discord.Server, data_type: str):
""" Find the notifying channel or return the server. """
if server.id not in osu_config.data["server"]:
return None
if data_type + "-channels" not in osu_config.data["server"][server.id]:
return None
return [server.get_channel(s) for s in osu_config.data["server"][server.id][data_type + "-channels"]
if server.get_channel(s)]
def setup_default_config(server: discord.Server):
""" Setup default settings for a server. """
# Set to defaults if there is no config for the server
if server.id not in moderate.data:
moderate.data[server.id] = default_config
moderate.save()
return
# Set to defaults if server's config is missing values
if not all(k in moderate.data[server.id].keys() for k in default_config):
moderate.data[server.id] = default_config
moderate.save()
def get_changelog_channel(server: discord.Server):
""" Return the changelog channel for a server. """
setup_default_config(server)
if not moderate.data[server.id]["changelog"]:
return
channel = discord.utils.get(server.channels, name="changelog")
if not channel:
return
permissions = channel.permissions_for(server.me)
if not permissions.send_messages or not permissions.read_messages:
return
return channel
def on_member_unban(server: discord.Server, user: discord.Member):
""" Update the changelog with unbanned members. """
changelog_channel = get_changelog_channel(server)
if not changelog_channel:
return
await client.send_message(changelog_channel, "{0.mention} was unbanned from the server.".format(user))
def assert_type(slot: str, server: discord.Server):
""" Assert if a type does not exist, and show the valid types. """
match = get_close_matches(slot, api["types"], n=1, cutoff=0.4)
if match:
matches_string = " Perhaps you meant `{}`?".format(match[0])
else:
matches_string = " See `{}help pokedex type`.".format(server_command_prefix(server))
assert slot in api["types"], "**{}** is not a valid pokemon type.{}".format(
slot.capitalize(), matches_string)
def format_help(cmd: Command, server: discord.Server, no_subcommand: bool=False):
""" Format the help string of the given command as a message to be sent.
:param cmd: Type Command
:param server: The server to generate help in.
:param no_subcommand: Use only the given command's usage.
:return: str: help message.
"""
usage = cmd.usage(server) if no_subcommand else format_usage(cmd, server)
# If there is no usage, the command isn't supposed to be displayed as such
# Therefore, we switch to using the parent command instead
if usage is None and cmd.parent is not None:
return format_help(cmd.parent, server)
command_prefix = config.server_command_prefix(server)
desc = cmd.description.format(pre=command_prefix)
# Format aliases
alias_format = ""
if cmd.aliases:
# Don't add blank space unless necessary
if not desc.strip().endswith("```"):
alias_format += "\n"
alias_format += "**Aliases**: ```{}```".format(
", ".join((command_prefix if identifier_prefix.match(alias[0]) and cmd.parent is None else "") +
alias for alias in cmd.aliases))
return "**Usage**: ```{}```**Description**: {}{}".format(usage, desc, alias_format)
def is_valid_server(cmd: Command, server: discord.Server):
""" Return True if the command is allowed in server. """
if not cmd.servers or server.id in cmd.servers:
return True
return False
def _add_event(self, name, command, dest_server, dest_channel,
author, timedelta, repeat=False):
if isinstance(dest_server, discord.Server):
dest_server = dest_server.id
if isinstance(dest_channel, discord.Channel):
dest_channel = dest_channel.id
if isinstance(author, discord.User):
author = author.id
if dest_server not in self.events:
self.events[dest_server] = {}
event_dict = {'name': name,
'channel': dest_channel,
'author': author,
'command': command,
'timedelta': timedelta,
'repeat': repeat}
log.debug('event dict:\n\t{}'.format(event_dict))
now = int(time.time())
event_dict['starttime'] = now
self.events[dest_server][name] = event_dict.copy()
event_dict['server'] = dest_server
e = Event(event_dict.copy())
await self._put_event(e)
self.save_events()
def _is_enabled(self, server):
assert isinstance(server, discord.Server)
if server.id not in self.settings:
return False
if not self.settings[server.id]["ENABLED"]:
return False
return True
def _remove_all_emotes(self, server, chan_id, name=""):
assert isinstance(server, discord.Server)
if server.id not in self.available_emotes:
return
self.available_emotes[server.id] = \
[emote for emote in self.available_emotes[server.id]
if emote["chan_id"] != chan_id or emote["name"] == name]
self.save_available_emotes()
def _add_emote(self, server, chan_id):
assert isinstance(server, discord.Server)
if chan_id == -1:
return
if not os.path.exists("data/emotes/{}".format(chan_id)):
os.makedirs("data/emotes/{}".format(chan_id))
await self._remove_all_emotes(server, chan_id)
for emote in self.emote_list:
if chan_id == emote["images"][0].get("emoticon_set", -1):
url = emote["images"][0].get("url", "")
name = emote.get("regex", "")
file_name = url.split('/')[-1]
if url == "" or name == "":
continue
if not os.path.exists('data/emotes/{}/{}'.format(chan_id,
file_name)):
try:
async with aiohttp.get(url) as r:
image = await r.content.read()
except Exception as e:
print(
"Huh, I have no idea what errors aiohttp throws.")
print("This is one of them:")
print(e)
print(dir(e))
print("------")
continue
self._write_image(chan_id, file_name, image)
if server.id not in self.available_emotes:
self.available_emotes[server.id] = {}
self.available_emotes[server.id].append({
"name": name,
"file_name": file_name,
"chan_id": chan_id
})
self.save_available_emotes()
def master(self, ctx):
"""Makes this server a 'master' that others copy their roles from."""
sid = ctx.message.server.id
if sid not in self.links:
self.links[sid] = {'ENABLED': False, 'SLAVES': []}
await self.bot.say('Server ID: {}'.format(sid))
self.save_links()
log.debug("added master: {}".format(sid))
def get_feed_names(self, server):
if isinstance(server, discord.Server):
server = server.id
ret = []
if server in self.feeds:
for channel in self.feeds[server]:
ret = ret + list(self.feeds[server][channel].keys())
return ret
def _play(self, sid, url):
"""Returns the song object of what's playing"""
if type(sid) is not discord.Server:
server = self.bot.get_server(sid)
else:
server = sid
assert type(server) is discord.Server
log.debug('starting to play on "{}"'.format(server.name))
if self._valid_playable_url(url) or "[SEARCH:]" in url:
try:
song = await self._guarantee_downloaded(server, url)
except MaximumLength:
log.warning("I can't play URL below because it is too long."
" Use [p]audioset maxlength to change this.\n\n"
"{}".format(url))
raise
local = False
else: # Assume local
try:
song = self._make_local_song(url)
local = True
except FileNotFoundError:
raise
voice_client = await self._create_ffmpeg_player(server, song.id,
local=local)
# That ^ creates the audio_player property
voice_client.audio_player.start()
log.debug("starting player on sid {}".format(server.id))
return song
def get_server(self, server):
if server is None:
return self.bot_settings["default"].copy()
assert isinstance(server, discord.Server)
return self.bot_settings.get(server.id,
self.bot_settings["default"]).copy()
def get_server_admin(self, server):
if server is None:
return self.default_admin
assert isinstance(server, discord.Server)
if server.id not in self.bot_settings:
return self.default_admin
return self.bot_settings[server.id].get("ADMIN_ROLE", "")
def set_server_admin(self, server, value):
if server is None:
return
assert isinstance(server, discord.Server)
if server.id not in self.bot_settings:
self.add_server(server.id)
self.bot_settings[server.id]["ADMIN_ROLE"] = value
self.save_settings()
def get_server_mod(self, server):
if server is None:
return self.default_mod
assert isinstance(server, discord.Server)
if server.id not in self.bot_settings:
return self.default_mod
return self.bot_settings[server.id].get("MOD_ROLE", "")
