python async - efficiency of sleeping multiple coroutines-CodePudding

Context: I am making a discord bot, and the mute command comes with a duration specifier for when the user should be unmuted again (this is being done via assigning a role to the user that removes their ability to send messages).

Idea 1: I could make a loop that checks every, say, 30 seconds and looks through to see which mutes have expired and cancel them.

Idea 2: Each time a mute is processed, I could await asyncio.sleep(however long) and then cancel it.

I would like to ask - which is more idiomatic, and also more importantly, which is more efficient? The first one has the advantage that it only has one coroutine running whereas the last one spawns a new one for each individual case (I don't really know how many that might be, but let's say around 10 concurrent cases maximum). However, the last one is easier for me to implement and feels like a more direct solution, on top of making the unmute happen exactly on time instead of on a timed loop.

There is one idea to make a loop that awaits until the next task and then when it processes that, queue up the next one, but then you can't insert tasks at the front of the queue.

TL;DR - if I need to schedule multiple events, do I run a loop to constantly check the scheduler, or do I open a coroutine for each and just await asyncio.sleep(however long) each of them?

CodePudding user response：

Your second idea seems the most accurate and straightforward as you can simply use asyncio.create_task to run an unmute coroutine after a certain amount of time. By using asyncio.create_task, you do not need to return or yield back the unmute coroutine to be gathered later or submit it to be checked by a loop at an established interval, for awaiting the returned response from asyncio.create_task will run the task in the background:

import asyncio
async def unmute(delay, user_id):
  await asyncio.sleep(delay)
  #run unmute process

async def mute(user_id):
  #your mute function
  mute_for = await do_mute(user_id) #some mute function
  u = asyncio.create_task(unmute(umute_for, user_id))
  await u #submitting the task to be run in the background