Can you test 3.11 and main branch as the signal handling was changed recently ?

Can you test 3.11 and main branch as the signal handling was changed recently ?

@kumaraditya303 I have tested on docker 3.11.0b1-bullseye, but still got the same problem. May test main branch later.

update: tested on main branch still have the same problem

The traceback message appears at the end of the script after the last line of __name__ == __main__ block.
This is bout the main_taskcoroutine: Task exception was never retrieved

So I tried to cancel this current task when exception raises, updating your main_task coroutine as below:

async def main_task():
    try:
        r = await asyncio.gather(sub_task(), asyncio.sleep(1))

    except (SystemExit, KeyboardInterrupt): 
        # cancel current task
       asyncio.current_task().cancel()

        # give time to other tasks to run (including me)
        await asyncio.sleep(0)
        raise

    except:
        raise

I don't really figure out in detail why but now the traceback message does not appear.
I suppose that other tasks run updating their internal state. This is including the current task main_wait.
And may be some loop flags are updated too.

I wonder whether something is not missing in except (SystemExit, KeyboardInterrupt): part of the def _run(self)method ?

I'd like to understand too.

@YvesDup In your case

import asyncio

e = KeyboardInterrupt  # or SystemExit


async def main_task():
    try:
        r = await asyncio.gather(sub_task(), asyncio.sleep(1))

    except (SystemExit, KeyboardInterrupt):
        # cancel current task
        asyncio.current_task().cancel()
        # give time to other tasks to run (including me)
        await asyncio.sleep(0)
        print('never reach here')
        raise
    except:
        print('')
        raise


async def sub_task():
    raise e


if __name__ == '__main__':
    try:
        asyncio.run(main_task())
    except e:
        print(f'Handle {e}')

There are two independent KeyboardInterrupt raised. One in sub_task and one in await asyncio.sleep(0).

print('never reach here')
raise

is nerver reached (test by debug). So two try except catch these two interrupt, no traceback anymore, but still very confusing why await asyncio.sleep(0) raised another interrupt🥲, or not in sleep but in event loop somewhere, I dont know.

asyncio.sleep(0) raised CancelErrorcause by asyncio.current_task().cancel() the line above
Sorry, bad solution and no more explanation.

asyncio.sleep(0) raised CancelErrorcause by asyncio.current_task().cancel() the line above Sorry, bad solution and no more explanation.

I'm pretty sure it's not a CancelError but a KeyboradInterrupt.

Hi @HFrost0
I checked the documentation on asyncio.gather and there is nothing about the keyboardInterrupt exception. Before opening a PR, I think it would be a good idea to send a message to python-dev asking what the behavior of asyncio.gather is when a keyboardInterrupt is raised.

IMO there is also another gap in the documentation about what happens when two or more exceptions raise in tasks.

Hi @YvesDup

Agree, but I'm a little bit busy right now and not familiar with python-dev. Could you send this message please?

I notice you already asked this question link, thank you

async def main_task():
    try:
        await asyncio.gather(
            sub_task(),
            asyncio.sleep(0)
        )
    except Exception as e:
        raise
   
    except BaseException as e:
        print(repr(e))

if you catch the exception in the main_task() coroutine, there is no more error with one or two tasks.

Any update for this?

I'd like to chip in, hope it's fine. With wait one gets rid of the unexpected exception (run the excerpt below, change use_gather to True for the old behavior), although to make the code run without the additional "Task exception was never retrieved" it gets a bit messy. One could also change the ALL_COMPLETED, which simulates the behavior of gather to FIRST_EXCEPTION and then the task creations and retrieving their exceptions all goes away, however, one would need to iterate and make sure pending tasks are finished, but that's another topic.

import asyncio

e = KeyboardInterrupt  # or SystemExit


async def main_task(use_gather=True):
    loop = asyncio.get_running_loop()

    tasks = [loop.create_task(sub_task()), loop.create_task(asyncio.sleep(0))]

    try:
        if use_gather:
            await asyncio.gather(*tasks)
        else:
            await asyncio.wait(tasks, return_when=asyncio.ALL_COMPLETED)
    except:
        for t in tasks:
            try:
                # Prevent "Task exception was never retrieved"
                t.exception()
            except:
                pass
        raise


async def sub_task():
    raise e


if __name__ == '__main__':
    try:
        asyncio.run(main_task(use_gather=False))
    except e:
        print(f'Handle {e}')

I also bumped into the same problem as the never reach here above, an example and the wait-based solution can be found in my gist.

I think except and finally blocks not running through is a serious issue which should be addressed and before it's solved the documentation should warn about this.

This would be a good issue for triagers to test the current behavior and document here.