limoka/AlpacaGang/ftg-modules/range.py

# encoding: utf-8
import asyncio
import time
import logging

from .. import loader, utils
logger = logging.getLogger(__name__)


def register(cb):
    cb(RangeMod())


@loader.tds
class RangeMod(loader.Module):
    """Provides numbers as in Python range with delay"""
    strings = {
        "name": "Range",
        "no_args": "<b>Not enough args (minimum {})</b>",
        "delay_num": "<b>Delay must be a number</b>",
        "args_int": "<b>All range args must be integers</b>",
        "many_args": "<b>There must be no more than {} arguments</b>"
    }

    def __init__(self):
        self.config = loader.ModuleConfig(
            "msg_format", "{0}", "Format of each message. {0} replaces current number.",
            "default_delay", 1.0, "Delay in all commands by default"
        )
        self.name = self.strings['name']

    def config_complete(self):
        self.name = self.strings['name']

    async def _do_range(self, range_args, delay, message):
        """for internal usage; do range itself"""
        await message.delete()
        for now in range(*range_args):
            before = time.time()
            await message.respond(self.config['msg_format'].format(now))
            delta = time.time() - before
            await asyncio.sleep(max(delay - delta, 0))

    async def _get_args(self, message, minn, maxn):
        args = utils.get_args(message)
        if len(args) < minn:
            logger.warning(f'Minimum {minn} {"args" if minn != 1 else "arg"}, {len(args)} provided')
            await utils.answer(message, self.strings['no_args'].format(minn))
            return None
        elif len(args) > maxn:
            logger.warning(f'Maximum {maxn} {"args" if maxn != 1 else "arg"}, {len(args)} provided')
            await utils.answer(message, self.strings['many_args'].format(maxn))
            return None
        return args

    async def _check_range_args(self, range_args, message):
        """for internal usage; check if range args are int"""
        try:
            range_args = [int(x) for x in range_args]
            return range_args
        except ValueError:
            logger.warning(f'Impossible to convert all range args to int ({range_args})')
            await utils.answer(message, self.strings['args_int'])
            return None

    async def rangecmd(self, message):
        """Iterates over the given range and returns each number in separate message.
        Usage: .range <python_range_args>"""
        args = await self._get_args(message, 1, 3)
        if args is None:
            return  # user done sth wrong

        delay = self.config['default_delay']
        range_args = await self._check_range_args(args, message)
        if range_args is None:
            return  # user done sth wrong

        await self._do_range(range_args, delay, message)

    async def drangecmd(self, message):
        """Iterates over the given range and returns each number in separate message.
        Usage: .drange <delay> <python_range_args>"""
        args = await self._get_args(message, 2, 4)
        if args is None:
            return  # user done sth wrong

        try:
            delay = float(args[0])
        except ValueError:
            logger.warning(f'Impossible to convert delay to float ({args[0]})')
            await utils.answer(message, self.strings['delay_num'])
            return

        range_args = await self._check_range_args(args[1:], message)
        if range_args is None:
            return

        await self._do_range(range_args, delay, message)

    async def countcmd(self, message):
        """Count from 1 to N.\nUsage: .count <delay> <N> or .count <N>"""
        args = await self._get_args(message, 1, 2)
        if args is None:
            return

        if len(args) == 1:
            delay = self.config['default_delay']
            range_args = (1, args[0], 1)
        elif len(args) == 2:
            try:
                delay = float(args[0])
            except ValueError:
                logger.warning(f'Impossible to convert delay to float ({args[0]})')
                await utils.answer(message, self.strings['delay_num'])
                return
            range_args = (1, args[1], 1)

        range_args = await self._check_range_args(range_args, message)
        if range_args is None:
            return
        range_args[1] += 1  # so last number we print will be N itself

        await self._do_range(range_args, delay, message)

    async def rcountcmd(self, message):
        """Count from N to 1.\nUsage: .rcount <delay> <N> or .rcount <N>"""
        args = await self._get_args(message, 1, 2)
        if args is None:
            return

        if len(args) == 1:
            delay = self.config['default_delay']
            range_args = (args[0], 0, -1)
        elif len(args) == 2:
            try:
                delay = float(args[0])
            except ValueError:
                logger.warning(f'Impossible to convert delay to float ({args[0]})')
                await utils.answer(message, self.strings['delay_num'])
                return
            range_args = (args[1], 0, -1)

        range_args = await self._check_range_args(range_args, message)
        if range_args is None:
            return

        await self._do_range(range_args, delay, message)