hot axle
for t in tasks:
t.cancel()
group = asyncio.gather(*tasks, return_exceptions=True) loop.run_until_complete(group)
What exactly happens , here? Does the group task monitor all the tasks that were pending in the loop , if so what do we need the loop.run_until_complete for?
warm cargoBOT
```Python
for t in tasks:
t.cancel()
group = asyncio.gather(*tasks, return_excep...
@hot axle
Python help channel opened
karmic flare
```Python
for t in tasks:
t.cancel()
group = asyncio.gather(*tasks, return_excep...
run_until_complete generally means running a coroutine or a task within a specified loop. This is where you actually run all the tasks. Whereas group is a task/coroutine responsible for waiting for all the tasks to complete.
Since tasks there are already running while loop is active, group is only to wait for those tasks to complete.
Without group, loop doesn't know when to stop running.
Another option is to loop.run_forever and have something loop.stop(), but that'd be quite complicated.
hot axle
so gather is waiting for the tasks to complete the cleanup ?
karmic flare
To exit the event loop, yes.
There is an alternative thing for that, by the way.
!d asyncio.TaskGroup
warm cargoBOT
hot axle
then why does it hav e to run run_until_complete again?
karmic flare
run_until_complete runs the event loop itself. This is what asyncio.run uses too.
Before you call run_until_complete, no tasks are running yet, even if they were scheduled.
karmic flare
yes... but it is used twice
The example you sent doesn't have that. Can you provide broader context?
hot axle
yes
karmic flare
```Python
for t in tasks:
t.cancel()
group = asyncio.gather(*tasks, return_excep...
Is this code happening inside an async def?
Likely you just need to await group if that is the case.
loop.run_until_complete and asyncio.run can be thought of as an await equivalent which can be called outside an async def.
hot axle
here
karmic flare
here
Ah, okay. In this case you have to involve it the second time because it got interrupted earlier.
Signal interrupts the event loop, you catch it, then go back into it to cleanup.
Alternative approach is to save this task, then cancel it directly.
hot axle
can you please tell me what exactly happens from the moment i run the cancel in the for loop
karmic flare
Just before you interrupt the program, this thing is running
# < Here, we are outside an event loop.
loop.run_forever() # Here, we are in an event loop.
# < Here, we are outside an event loop.
All the tasks are being executed there until an interrupt.
Next like I think is already self-describing.
Here, we cancel all tasks which raises a CancelledError inside them.
for t in tasks
t.cancel()
But that exception hasn't yet hit any code inside the tasks.
They can't yet catch it and handle it, since they aren't running.
(Because we exited the event loop)
Once we raised that exception in all tasks, we come back into the event loop.
group = ...
loop.run_until_complete(group)
asyncio.group just waits until everything you gave it is done. You can think of it as making one task from many tasks.
karmic flare
Once we raised that exception in all tasks, we come back into the event loop.
``...
Inside that run_until_complete, remaining tasks are run until completion.
hot axle
gotcha
thankyou
do you have any suggestions for book on asyncio
i read half of calebs book
karmic flare
There is a great talk about the internal of asyncio. I'm not aware of any books on it.
warm cargoBOT
Python help channel closed using Discord native close action