Ejemplo n.º 1
0
    async def end_giveaway(self, giveaway):
        registered = self.in_progress[giveaway.server.id]
        del self.in_progress[giveaway.server.id]

        if len(registered) == 0:
            await self.send_message(
                giveaway.server.default_channel,
                'No one registered for the giveaway 😢\nNo one wins'
            )
        else:
            winner = choice(list(registered))
            await self.send_message(
                giveaway.server.default_channel,
                '{} You are the giveaway winner!\n'
                'I will whisper you your prize shortly'
                    .format(winner.mention)
            )
            await self.send_message(
                winner,
                'You won the giveaway of {} on `{}`\n'
                'Here is your prize:\n'
                '{}'
                    .format(
                        giveaway.user.mention,
                        giveaway.server.name,
                        f.code_block(giveaway.content)
                    )
            )
Ejemplo n.º 2
0
    async def twitter_three_legged_action(self, tweet, channel, user, action, description):
        oauth_user = self.get_user_oauth(user)

        if oauth_user is None:
            await self.inform_user_about_connections(user)
            return

        user_api = self.get_user_api(oauth_user)

        try:
            action(user_api, tweet)
        except Exception as e:
            await self.send_message(
                user,
                'I couldn\'t {} `{}`\'s tweet for you\n'
                'Twitter said:\n{}'
                    .format(
                        description,
                        tweet['user']['screen_name'],
                        f.code_block(str(e.response_data))
                    )
            )
        else:
            await self.send_message(
                channel,
                '{} I {} `{}`\'s tweet for you 👍'
                    .format(
                        user.mention,
                        PAST_FORMS[description],
                        tweet['user']['screen_name']
                    ),
                delete_after = 5
            )
Ejemplo n.º 3
0
    async def plugin_help(self, message, plugin_name):
        plugin_name = plugin_name.lower()

        if plugin_name not in self.enabled_plugins_names:
            return

        plugin = self.get_plugin(plugin_name)

        def hooks_description(hooks):
            if hooks:
                hook_descriptions = (hook.__doc__.strip() for hook in hooks
                                     if hook.__doc__)
                return '/* {} */'.format(' | '.join(hook_descriptions))
            return ''

        raw_components = [
            '{}{}'.format(validator.parser.name,
                          hooks_description(validator.hooks))
            for validator, _ in plugin.actions
        ]
        components = sorted(
            re.sub(' +', ' ', re.sub(r'[(,)]', '', name)).split(' ')
            for name in raw_components)

        lines = [' '.join(comp) for comp in components]

        help_message = f.code_block(lines, language='css')

        await self.send_message(message.channel,
                                '{} `{}` plugin commands:\n\n{}'.format(
                                    message.author.mention, plugin_name,
                                    help_message),
                                delete_after=30)
Ejemplo n.º 4
0
    async def stats_games(self, message, user_id):
        member = message.server.get_member(str(user_id))
        if member is None:
            return

        # Flush current tracking
        self.update_game(member.id, member.game)

        games = self.top_user_games(user_id)
        top = [(game.name, game.duration) for game in games[:10]]

        if games:
            since = min(map(lambda g: g.created_at, games))
            since_days = int((time() - since.timestamp()) / (3600 * 24))

            response = (
                '{} has played **{}** different games in the last **{}** days '
                'for a total of **{}** seconds\ntop 10:\n{}').format(
                    f.mention(user_id), len(games), since_days,
                    sum(map(lambda g: g.duration, games)),
                    f.code_block(f.format_sql_rows(top)))
        else:
            response = '{} has not played any games yet'.format(
                f.mention(user_id))

        await self.send_message(message.channel, response, delete_after=25)
Ejemplo n.º 5
0
    async def stats_games(self, message, user_id):
        member = message.server.get_member(str(user_id))
        if member is None:
            return

        # Flush current tracking
        self.update_game(member.id, member.game)

        games = self.top_user_games(user_id)
        top = [(game.name, game.duration) for game in games[:10]]

        if games:
            since = min(map(lambda g: g.created_at, games))
            since_days = int((time() - since.timestamp()) / (3600 * 24))

            response = (
                '{} has played **{}** different games in the last **{}** days '
                'for a total of **{}** seconds\ntop 10:\n{}'
            ).format(
                f.mention(user_id), len(games), since_days,
                sum(map(lambda g: g.duration, games)),
                f.code_block(f.format_sql_rows(top))
            )
        else:
            response = '{} has not played any games yet'.format(f.mention(user_id))

        await self.send_message(
            message.channel,
            response,
            delete_after = 25
        )
Ejemplo n.º 6
0
    async def plugin_help(self, message, plugin_name):
        plugin_name = plugin_name.lower()

        if plugin_name not in self.enabled_plugins_names:
            return

        plugin = self.get_plugin(plugin_name)

        raw_components = [
            '{}{}'.format(
                validator.parser.name, ' /* master only */'
                if validator.pre_hook == master_only else '')
            for validator, _ in plugin.actions
        ]
        components = sorted(
            re.sub(' +', ' ', re.sub(r'[(,)]', '', name)).split(' ')
            for name in raw_components)

        lines = [' '.join(comp) for comp in components]

        help_message = f.code_block(lines, language='css')

        await self.send_message(message.channel,
                                '{} `{}` plugin commands:\n\n{}'.format(
                                    message.author.mention, plugin_name,
                                    help_message),
                                delete_after=30)
Ejemplo n.º 7
0
    async def stats_games_top(self, message, count=10):
        data = self.top_games(message.server, count)

        if data:
            await self.send_message(
                message.channel,
                'Most **{}** games played on this server\n{}'.format(
                    len(data), f.code_block(f.format_sql_rows(data))),
                delete_after=25)
Ejemplo n.º 8
0
    async def general_help(self, message):
        help_message = f.code_block(
            ['!help {}'.format(name) for name in self.enabled_plugins_names],
            language='css'  # Kinda look ok
        )

        await self.send_message(message.channel,
                                '{}\n{}'.format(message.author.mention,
                                                help_message),
                                delete_after=30)
Ejemplo n.º 9
0
    async def stats_games_top(self, message, count=10):
        data = self.top_games(message.server, count)

        if data:
            await self.send_message(
                message.channel,
                'Most **{}** games played on this server\n{}'
                    .format(len(data), f.code_block(f.format_sql_rows(data))),
                delete_after = 25
            )
Ejemplo n.º 10
0
    async def eval_env_list(self, message):
        environments = [
            env.name for env in self.get_environments(message.author.id)
            if env.author_id
        ]

        await self.send_message(
            message.channel, '{} You have `{}` saved environments\n{}'.format(
                message.author.mention, len(environments),
                f.code_block(environments)))
Ejemplo n.º 11
0
    async def channels(self, message):
        channels = [
            (channel.name, channel.id)
            for channel in message.server.channels
        ]

        await self.send_message(
            message.channel,
            f.code_block(f.format_sql_rows(channels)),
            delete_after = 30
        )
Ejemplo n.º 12
0
    async def roll_dice_command(self, message, dice):
        grouped_dice = group_dice(dice)
        enforce_dnd_invariants(grouped_dice)

        results = map(roll_die, grouped_dice)

        response = ('{} 🎲 rolling your dice\n'
                    '{}'.format(message.author.mention,
                                f.code_block('\n'.join(results))))

        await self.send_message(message.channel, response, delete_after=30)
Ejemplo n.º 13
0
    async def channels(self, message):
        channels = [
            (channel.name, channel.id)
            for channel in message.server.channels
        ]

        await self.send_message(
            message.channel,
            f.code_block(f.format_sql_rows(channels)),
            delete_after = 30
        )
Ejemplo n.º 14
0
    async def twitch_top_channels(self, message, count=10):
        streams = await self.api.top_channels(count)

        info = [(stream.channel.display_name, '🕹 {}'.format(stream.game),
                 '👀 {:,}'.format(stream.viewers), stream.channel.status)
                for stream in streams]

        await self.send_message(message.channel,
                                'Top {} games on Twitch right now\n{}'.format(
                                    len(streams),
                                    f.code_block(f.pad_rows(info, ' | '))),
                                delete_after=15)
Ejemplo n.º 15
0
    async def twitch_top_games(self, message, count=10):
        top_games = await self.api.top_games(count)

        info = [(top_game.game.name, '📺 {:,}'.format(top_game.channels),
                 '👀 {:,}'.format(top_game.viewers))
                for top_game in top_games]

        await self.send_message(message.channel,
                                'Top {} games on Twitch right now\n{}'.format(
                                    len(top_games),
                                    f.code_block(f.pad_rows(info, ' | '))),
                                delete_after=15)
Ejemplo n.º 16
0
    async def logs_find(self, message, user_id, what, count=10):
        with self.transaction() as trans:
            trans.execute(
                q.find_logs,
                dict(author_id=user_id, str='%%{}%%'.format(what),
                     limit=count))
            results = trans.fetchall()
            messages = [r[0] for r in results]

            await self.send_message(message.channel,
                                    'Found **{}** messages\n{}'.format(
                                        len(results), f.code_block(messages)),
                                    delete_after=30)
Ejemplo n.º 17
0
    async def eval_env_map(self, message):
        environments = self.get_environments(message.author.id)

        padding = max(map(lambda env: len(env.language), environments),
                      default=0)
        mapping = [
            '{:{}} ➡ {}'.format(env.language, padding, env.name)
            for env in environments
        ]

        await self.send_message(
            message.channel,
            '{} Here is your eval mapping\n{}'.format(message.author.mention,
                                                      f.code_block(mapping)))
Ejemplo n.º 18
0
    async def monitored(self, message):
        with self.transaction() as trans:
            trans.execute(q.get_monitored)
            monitored = [MonitoredChannel(*row) for row in trans.fetchall()]

            user_futures = (self.get_user_by_id(channel.user_id)
                            for channel in monitored
                            if str(channel.server_id) == message.server.id)
            users = await asyncio.gather(*user_futures)

            await self.send_message(
                message.channel,
                'I\'m currently monitoring the following channels:\n{}'.format(
                    f.code_block(user['screen_name'] for user in users)))
Ejemplo n.º 19
0
    async def general_help(self, message):
        help_message = f.code_block(
            [
                '!help {}'.format(name) for name in
                self.enabled_plugins_names
            ],
            language='css' # Kinda look ok
        )

        await self.send_message(
            message.channel,
            '{}\n{}'.format(message.author.mention, help_message),
            delete_after=30
        )
Ejemplo n.º 20
0
    async def deleted_messages(self, message, user_id, count=5):
        with self.transaction() as trans:
            trans.execute(q.last_deleted_logs,
                          dict(author_id=user_id, limit=count))
            results = trans.fetchall()
            messages = [
                '{}{}'.format(row[0], ' '.join(row[1])) for row in results
            ]

            await self.send_message(
                message.channel,
                'last **{}** deleted messages from <@{}>:\n{}'.format(
                    len(results), user_id, f.code_block(messages)),
                delete_after=30)
Ejemplo n.º 21
0
    async def monitored(self, message):
        with self.transaction() as trans:
            trans.execute(q.get_monitored)
            monitored = [MonitoredChannel(*row) for row in trans.fetchall()]

            channels = [
                channel.name for channel in monitored
                if str(channel.server_id) == message.server.id
            ]

            await self.send_message(
                message.channel,
                'I\'m currently monitoring the following channels:\n{}'.format(
                    f.code_block(channels)),
                delete_after=15)
Ejemplo n.º 22
0
    async def eval_env_list(self, message):
        environments = [
            env.name for env in self.get_environments(message.author.id)
            if env.author_id
        ]

        await self.send_message(
            message.channel,
            '{} You have `{}` saved environments\n{}'
                .format(
                    message.author.mention,
                    len(environments),
                    f.code_block(environments)
                )
        )
Ejemplo n.º 23
0
    async def sql_exec(self, message, snippet):
        if snippet.language.lower() != 'sql':
            return

        try:
            with self.transaction() as trans:
                trans.execute(snippet.code)
                rows = trans.fetchall()
                self.debug(rows)
                if rows:
                    text = f.code_block(f.format_sql_rows(rows))
                else:
                    text = 'Request executed successfully\n`no output`'
                await self.send_message(message.channel, text)
        except Exception as e:
            await self.send_message(message.channel, '```\n{}\n```'.format(e))
Ejemplo n.º 24
0
    async def logs_find(self, message, user_id, what, count=10):
        with self.transaction() as trans:
            trans.execute(q.find_logs, dict(
                author_id = user_id,
                str       = '%%{}%%'.format(what),
                limit     = count
            ))
            results = trans.fetchall()
            messages = [r[0] for r in results]

            await self.send_message(
                message.channel,
                'Found **{}** messages\n{}'
                    .format(len(results), f.code_block(messages)),
                delete_after = 30
            )
Ejemplo n.º 25
0
    async def twitch_top_games(self, message, count=10):
        top_games = await self.api.top_games(count)

        info = [
            (top_game.game.name,
            '📺 {:,}'.format(top_game.channels),
            '👀 {:,}'.format(top_game.viewers))
            for top_game in top_games
        ]

        await self.send_message(
            message.channel,
            'Top {} games on Twitch right now\n{}'
                .format(len(top_games), f.code_block(f.pad_rows(info, ' | '))),
            delete_after=15
        )
Ejemplo n.º 26
0
    async def monitored(self, message):
        with self.transaction() as trans:
            trans.execute(q.get_monitored)
            monitored = [MonitoredChannel(*row) for row in trans.fetchall()]

            channels = [
                channel.name for channel in monitored
                if str(channel.server_id) == message.server.id
            ]

            await self.send_message(
                message.channel,
                'I\'m currently monitoring the following channels:\n{}'
                    .format(f.code_block(channels)),
                delete_after=15
            )
Ejemplo n.º 27
0
    async def monitored(self, message):
        with self.transaction() as trans:
            trans.execute(q.get_monitored)
            monitored = [MonitoredChannel(*row) for row in trans.fetchall()]

            users = [
                self.get_user_by_id(channel.user_id)['screen_name']
                for channel in monitored
                if str(channel.server_id) == message.server.id
            ]

            await self.send_message(
                message.channel,
                'I\'m currently monitoring the following channels:\n{}'
                    .format(f.code_block(users))
            )
Ejemplo n.º 28
0
    async def eval_env_inspect(self, message, env_name):
        environments = self.get_environments(message.author.id)

        try:
            env = next(e for e in environments if e.name == env_name)
        except StopIteration:
            await self.send_message(
                message.channel,
                '{} You don\'t have any environment saved under the name `{}`'.
                format(message.author.mention, env_name),
                delete_after=10)

        await self.send_message(
            message.channel, '{} `{}` environment was built from:\n{}'.format(
                message.author.mention, env_name,
                f.code_block(env.dockerfile, language='dockerfile')))
Ejemplo n.º 29
0
    async def permissions(self, message, channel_id=None):
        if channel_id is None:
            channel_id = message.channel.id

        channel = next(
            channel for channel in message.server.channels
            if channel.id == str(channel_id)
        )

        perms = [' - {}'.format(perm) for perm in self.permissions_in(channel)]

        await self.send_message(
            message.channel,
            'In {}, I can:\n{}'
                .format(f.channel(channel_id), f.code_block(perms)),
            delete_after = 30
        )
Ejemplo n.º 30
0
    async def eval_env_map(self, message):
        environments = self.get_environments(message.author.id)

        padding = max(map(lambda env: len(env.language), environments), default=0)
        mapping = [
            '{:{}} ➡ {}'.format(env.language, padding, env.name)
            for env in environments
        ]

        await self.send_message(
            message.channel,
            '{} Here is your eval mapping\n{}'
                .format(
                    message.author.mention,
                    f.code_block(mapping)
                )
        )
Ejemplo n.º 31
0
    async def twitch_top_channels(self, message, count=10):
        streams = await self.api.top_channels(count)

        info = [
            (stream.channel.display_name,
            '🕹 {}'.format(stream.game),
            '👀 {:,}'.format(stream.viewers),
            stream.channel.status)
            for stream in streams
        ]

        await self.send_message(
            message.channel,
            'Top {} games on Twitch right now\n{}'
                .format(len(streams), f.code_block(f.pad_rows(info, ' | '))),
            delete_after=15
        )
Ejemplo n.º 32
0
    async def permissions(self, message, channel_id=None):
        if channel_id is None:
            channel_id = message.channel.id

        channel = next(
            channel for channel in message.server.channels
            if channel.id == str(channel_id)
        )

        perms = [' - {}'.format(perm) for perm in self.permissions_in(channel)]

        await self.send_message(
            message.channel,
            'In {}, I can:\n{}'
                .format(f.channel(channel_id), f.code_block(perms)),
            delete_after = 30
        )
Ejemplo n.º 33
0
    async def trivia_stats_all(self, message, topic=None):
        ranks = self.get_ranks(message.server.id, topic)
        ranks = ranks[:10]

        def user_name(u_id):
            user = self.bot.find_user(str(u_id))
            return user.name if user else '???'

        leaderboard = '\n'.join(
            '#{:>2} {:<30} ({:>3} pts)'.format(i +
                                               1, user_name(user_id), points)
            for i, (points, user_id) in enumerate(ranks))

        for_string = '' if topic is None else ' for `{}`'.format(topic)
        await self.send_message(
            message.channel,
            'Top {} on this server{}:\n{}'.format(len(ranks), for_string,
                                                  f.code_block(leaderboard)))
Ejemplo n.º 34
0
    async def deleted_messages(self, message, user_id, count=5):
        with self.transaction() as trans:
            trans.execute(q.last_deleted_logs, dict(
                author_id = user_id,
                limit     = count
            ))
            results = trans.fetchall()
            messages = [
                '{}{}'.format(row[0], ' '.join(row[1]))
                for row in results
            ]

            await self.send_message(
                message.channel,
                'last **{}** deleted messages from <@{}>:\n{}'
                    .format(len(results), user_id, f.code_block(messages)),
                delete_after = 30
            )
Ejemplo n.º 35
0
def format_tweet(tweet):
    text = ('Last tweet from `@{screen_name}`:\n\n'
            '{text}\n'
            '**{retweets}** 🔄   **{favourites}** 👍').format(
                screen_name=tweet['user']['screen_name'],
                text=f.code_block(tweet['text']),
                retweets=tweet['retweet_count'],
                favourites=tweet['favorite_count'])

    try:
        entities = tweet['extended_entities']['media']
        media_urls = [entity['media_url_https'] for entity in entities]
        text += ('\n\nMedia files attached in the tweet:\n{}'.format(
            '\n'.join(media_urls)))
    except:
        pass

    return text
Ejemplo n.º 36
0
def format_price(ticker, exchange):
    name, symbol = ticker['name'], ticker['symbol']
    change_1h = float(ticker.get('percent_change_1h', 0))
    change_24h = float(ticker.get('percent_change_24h', 0))
    change_7d = float(ticker.get('percent_change_7d', 0))

    exchanges = list()

    if exchange is not None:
        exchanges.append(
            (exchange.upper(), ticker['price_{}'.format(exchange.lower())]))
    exchanges.append(('USD', ticker['price_usd']))
    if symbol != 'BTC':
        btc_price = float(ticker['price_btc'])
        btc_price_string = '{} (1 BTC ~= {:.3f} {})'.format(
            btc_price, 1 / btc_price, symbol)
        exchanges.append(('BTC', btc_price_string))

    price_message = '\n'.join('{} :: {}'.format(exchange, value)
                              for exchange, value in exchanges)

    changes = (change_1h, change_24h, change_7d)
    periods = ('hour', 'day', 'week')
    change_message = '\n'.join('{} {:<{}} % over the last {}'.format(
        '-' if change < 0 else '+', abs(change),
        max(map(lambda x: len(str(abs(x))), changes)), period)
                               for change, period in zip(changes, periods))

    reply_message = '{} ({})\n{}\n{}\n{}\n{}'.format(
        name, symbol, '=' * (len(name) + len(symbol) + 3), price_message,
        '_' * (len(name) + len(symbol) + 3), change_message)

    last_updated_stamp = int(ticker['last_updated'])
    time_diff = int(time()) - last_updated_stamp
    if time_diff < 60:
        last_updated = '{} second{} ago'.format(time_diff,
                                                's' if time_diff != 1 else '')
    else:
        minute_diff = time_diff // 60
        last_updated = '~{} minute{} ago'.format(
            minute_diff, 's' if minute_diff != 1 else '')

    return ('{}\n*last updated: {}*'.format(
        f.code_block(reply_message, language='asciidoc'), last_updated))
Ejemplo n.º 37
0
    async def end_giveaway(self, giveaway):
        registered = self.in_progress[giveaway.server.id]
        del self.in_progress[giveaway.server.id]

        if len(registered) == 0:
            await self.send_message(
                giveaway.server.default_channel,
                'No one registered for the giveaway 😢\nNo one wins')
        else:
            winner = choice(list(registered))
            await self.send_message(
                giveaway.server.default_channel,
                '{} You are the giveaway winner!\n'
                'I will whisper you your prize shortly'.format(winner.mention))
            await self.send_message(
                winner, 'You won the giveaway of {} on `{}`\n'
                'Here is your prize:\n'
                '{}'.format(giveaway.user.mention, giveaway.server.name,
                            f.code_block(giveaway.content)))
Ejemplo n.º 38
0
    async def roll_dice_command(self, message, dice):
        grouped_dice = group_dice(dice)
        enforce_dnd_invariants(grouped_dice)

        results = map(roll_die, grouped_dice)

        response = (
            '{} 🎲 rolling your dice\n'
            '{}'
                .format(
                    message.author.mention,
                    f.code_block('\n'.join(results))
                )
        )

        await self.send_message(
            message.channel,
            response,
            delete_after = 30
        )
Ejemplo n.º 39
0
def format_tweet(tweet):
    time_difference = datetime.now() - tweet_time(tweet)

    screen_name = tweet['user']['screen_name']
    text = (
        'Last tweet from `@{screen_name}` ({ago}):\n\n'
        '{text}\n'
        '🔄 **{retweets}**    ❤ **{favourites}**\n\n'
        '**__source__: {tweet_link}**\n\n'
        '*Click on the reactions below to retweet or like the tweet*'
    ).format(
        screen_name = screen_name,
        text        = f.code_block(tweet['text']),
        retweets    = tweet['retweet_count'],
        favourites  = tweet['favorite_count'],
        ago         = naturaltime(time_difference),
        tweet_link  = 'https://twitter.com/{}/status/{}'.format(screen_name, tweet['id'])
    )

    return text
Ejemplo n.º 40
0
    async def plugin_help(self, message, plugin_name):
        plugin_name = plugin_name.lower()

        if plugin_name not in self.enabled_plugins_names:
            return

        plugin = self.get_plugin(plugin_name)

        def hooks_description(hooks):
            if hooks:
                hook_descriptions = (
                    hook.__doc__.strip() for hook in hooks
                    if hook.__doc__
                )
                return '/* {} */'.format(' | '.join(hook_descriptions))
            return ''

        raw_components =[
            '{}{}'.format(
                validator.parser.name,
                hooks_description(validator.hooks)
            )
            for validator, _ in plugin.actions
        ]
        components = sorted(
            re.sub(' +',' ', re.sub(r'[(,)]', '', name)).split(' ')
            for name in raw_components
        )

        lines = [
            ' '.join(comp) for comp in components
        ]

        help_message = f.code_block(lines, language='css')

        await self.send_message(
            message.channel,
            '{} `{}` plugin commands:\n\n{}'
                .format(message.author.mention, plugin_name, help_message),
            delete_after=30
        )
Ejemplo n.º 41
0
    async def convert(self, message, unit_values):
        converted = [(uv, system_convert(uv)) for uv in unit_values]
        output = ['{} = {}'.format(uv, conv) for uv, conv in converted]

        for t, uvs in groupby(converted, key=lambda uvs: type(uvs[0].unit)):
            values = list(map(lambda x: x[0], uvs))

            if len(values) >= 2:
                summed = sum_units(*values)
                converted_summed = system_convert(summed)
                output.append(
                    '{} total: {} = {}'
                        .format(t.__name__.lower(), summed, converted_summed)
                )

        await self.send_message(
            message.channel,
            'Converted units\n{}'
                .format(f.code_block(output)),
            delete_after = 60
        )
Ejemplo n.º 42
0
    async def eval_env_inspect(self, message, env_name):
        environments = self.get_environments(message.author.id)

        try:
            env = next(e for e in environments if e.name == env_name)
        except StopIteration:
            await self.send_message(
                message.channel,
                '{} You don\'t have any environment saved under the name `{}`'
                    .format(message.author.mention, env_name),
                delete_after=10
            )

        await self.send_message(
            message.channel,
            '{} `{}` environment was built from:\n{}'
                .format(
                    message.author.mention,
                    env_name,
                    f.code_block(env.dockerfile, language='dockerfile')
                )
        )
Ejemplo n.º 43
0
    async def twitter_three_legged_action(self, tweet, channel, user, action,
                                          description):
        oauth_user = self.get_user_oauth(user)

        if oauth_user is None:
            await self.inform_user_about_connections(user)
            return

        user_api = self.get_user_api(oauth_user)

        try:
            action(user_api, tweet)
        except Exception as e:
            await self.send_message(
                user, 'I couldn\'t {} `{}`\'s tweet for you\n'
                'Twitter said:\n{}'.format(description,
                                           tweet['user']['screen_name'],
                                           f.code_block(str(e.response_data))))
        else:
            await self.send_message(channel,
                                    '{} I {} `{}`\'s tweet for you 👍'.format(
                                        user.mention, PAST_FORMS[description],
                                        tweet['user']['screen_name']),
                                    delete_after=5)
Ejemplo n.º 44
0
 async def eval_langs(self, message):
     await self.send_message(
         message.channel,
         f.code_block('\n'.join(
             f'{lang: <10} -> {spec.image: <15} {spec.command("file.ext")}'
             for lang, spec in EVALSPEC_PER_LANGUAGES.items())))
Ejemplo n.º 45
0
 async def send_update():
     if logs:
         tail = ''.join(logs[-C.MAX_STREAM_LINES:])
         await self.bot.edit_message(message, f.code_block(tail))