Document Task.loop behaviour when one task exceeds

[Haiz14]

behaviour: only one task runs at a time, if a task exceeds waiting time, the next few tasks are run simultaneously until the lost time is recovered.

example: if a task repeats after 3 second but only the first task takes more than 10 seconds and after that all tasks takes 0.1 seconds

then something like this happens

• first_task completes in 10 seconds
• seconds, third, fourth task runs instantaneouly
• fifth task runs after 0.7 seconds
• and rest of the task runs normaly

class TaskConsumer(commands.Cog):                                                                                                                  
    def __init__(self, bot: Avon):                                                                                                                             
        self.bot = bot                                                                                                                                         
        self.task_consumer.start()                                                                                                                             
        self.index = 0                                                                                                                                                                                                                                                                                            
    def cog_unload(self):                                                                                                                                      
        self.task_consumer.cancel()                                                                                                                                                                                                                                                                               
    @tasks.loop(seconds=3)                                                                                                                                 
    async def task_consumer(self):                                                                                                                             
        """                                                                                                                                                    
        behaviour: only one task runs at a time, if a task exceeds waiting time, the next few tasks are run simaltaneously until the lost time is recovered.                                                                                                                                                                                                                                                                                                                 
        example: if a task repeats after 3 second but only the first task takes more than 10 seconds and after that all tasks takes 0.1 seconds
        then something like this happens                                                                                                               
        - first_task completes in 10 seconds
        - seconds, third, fourth task runs instantaneouly
        - fifth task runs after 0.7 seconds
        - and rest of the task runs normaly

        """
        index = self.index
        if index == 0:
            sleep_for = 5
        else:
            sleep_for = 0.1
        self.index += 1
        print(index)
        await async_sleep(sleep_for)
        print(index)
        await async_sleep(sleep_for)
        print(index)

    @task_consumer.before_loop
    async def before_printer(self):
        print('waiting...')
        await self.bot.wait_until_ready()

[Glinte]

your code is incomplete

[Haiz14]

Yep sorry about that, the data was already there while editing, but due to messed up indentation (the hidden parts had lost spaces) GitHub hid those parts of code blocks. Maybe a bug in GitHub markdown, not sure.