python类Client()的实例源码

def setUpClass(cls):
        logging.getLogger("discord").setLevel(logging.ERROR)
        logging.getLogger("websockets").setLevel(logging.ERROR)

        bot = discord.Client(fetch_offline_members=False)
        await bot.login(os.environ['DISCORD_TOKEN'])
        cls.bot = bot
        cls.task = asyncio.ensure_future(bot.connect())
        await cls.bot.wait_until_ready()
        cls.channel = bot.get_channel(182580524743655424)

def add_page(self, emoji: str, page: discord.Embed):
        r"""
        Adds a page to this PagedEmbed.

        Arguments:
            emoji : str
                A Unicode Emoji like ?? or ??, or
                the full "text" of a discord Emoji
                which you can obtain by prepending
                a \ to the front of a Discord Emoji,
                resulting in something like this:
                <:FeelsWOAWMan:273546398996234242>
                Note, however, that the bot must be
                able to use the reaction. Since
                bots have access to Emojis as if
                they have Nitro, all valid emojis
                are stored in discord.Client.emojis.
            page : discord.Embed
                The discord.Embed which should be
                displayed when the given Emoji
                is reacted with / clicked.
        """

        if emoji in self._pages:
            raise ValueError("A handler or an discord.Embed for this Emoji was already added")
        self._pages[emoji] = page

def post_login_init(
            self,
            client: discord.Client,
            server_id: int,
            load_config_fn
    ) -> None:
        """Initializes object; call after client has been logged in to discord"""
        self._load_config_fn = load_config_fn

        # Find the correct server
        try:
            int(server_id)
            id_is_int = True
        except ValueError:
            id_is_int = False

        the_server = None  # type: discord.Server
        for s in client.servers:
            if id_is_int and s.id == server_id:
                the_server = s
            elif s.name == server_id:
                the_server = s

        if the_server is None:
            console.warning('Could not find the server.')
            exit(1)

        server.init(client, the_server)

        if not self._initted:
            await self._load_config_fn(self)
            self._initted = True
            for manager in self._managers:
                await manager.initialize()
        else:
            await self.refresh()

        console.info(
            '\n'
            '-Logged in---------------\n'
            '   User name: {0}\n'
            ' Server name: {1}\n'
            '-------------------------'.format(the_server.me.display_name, the_server.name)
        )

def ready_client_events(
            self,
            client: discord.Client,
            load_config_fn: Callable[[], None],
            on_ready_fn: Callable[[], None] = None
    ):
        """Set the code for event-handling in the discord.Client"""

        @client.event
        async def on_ready():
            """Called after the client has successfully logged in"""
            await self.post_login_init(
                client=client,
                server_id=Config.SERVER_ID,
                load_config_fn=load_config_fn
            )
            if on_ready_fn is not None:
                await on_ready_fn(self)

        @client.event
        async def on_message(message: discord.Message):
            """Called whenever a new message is posted in any channel on any server"""
            if not self._initted:
                return

            if Config.testing():
                await msgqueue.send_message(message)

            if message.author.id == self.client.user.id:
                return

            cmd = Command(message)
            await self._execute(cmd)

        # noinspection PyUnusedLocal
        @client.event
        async def on_error(event: str, *args, **kwargs):
            """Called when an event raises an uncaught exception"""
            exc_info = sys.exc_info()
            exc_type = exc_info[0].__name__ if exc_info[0] is not None else '<no exception>'
            exc_what = str(exc_info[1]) if exc_info[1] is not None else ''
            console.error(
                'Uncaught exception {exc_type}: {exc_what}'.format(exc_type=exc_type, exc_what=exc_what)
            )

            # @client.event
            # async def on_member_join(member: discord.Member):
            #     """Called when anyone joins the server"""
            #     if not self._initted:
            #         return
            #
            #     await userdb.register_discord_user(member)
            #
            # @client.event
            # async def on_member_update(member_before: discord.Member, member_after: discord.Member):
            #     """Called when anyone updates their discord profile"""
            #     if not self._initted:
            #         return
            #
            #     if member_before.display_name != member_after.display_name:
            #         await userdb.register_discord_user(member_after)