a runnable example (i'm sure i must be missing something obvious):
from anyio import Event, create_task_group, sleep, get_cancelled_exc_class, run
async def task(cancel_event: Event):
async def long_task():
while True:
await sleep(1)
async with create_task_group() as tg:
try:
tg.start_soon(long_task)
await cancel_event.wait()
tg.cancel_scope.cancel()
except get_cancelled_exc_class():
print("Never printed")
raise
async def main():
cancel_event = Event()
async with create_task_group() as tg:
tg.start_soon(task, cancel_event)
await sleep(2)
cancel_event.set()
run(main)
14 replies
Really the cleanup should handle being awaited in a cancellation
You should be able to refactor your code to aclose forcefully without shield at all
(I think shield is an antipatten)
There's two kinds of cleanup typically, returning a connection to a pool or terminating a connection
When terminating a connection you let aclose_forcefully Peirce your protocol stack to a socket.close call and let the kernel handle waiting on the connection
When returning a connection to a pool your pool maintains a task group that handles graceful termination
You'd create a nursery responsible for reporting errors start reporting tasks in that
So you'd be like
async with reporter() as r:
async def some_thing()
try:
await foo()
except BaseException as e:
r.report(e)
...
Ah I see, requires a reporter to be passed around. Right now we have a
async with report_crashes(): ... which captures and reports on a wide range of errors. It's actually outside the our cancel scope so we don't normally need shielding but we don't have control over how the user is running their event loop so there may be a cancel scope outside of our code and we need to report that failure still.
But you can use a contextvar to pass stuff through code that doesn't know about your reporter tool
If the user cares about error reporting they should open an async context manager for you to run a nursery to handle that in
Yeah there should always be a place where a user of @madkinsz: library can introduce an async with above their cancellation
I prefer setting a reasonable timeout with
move_on_after(..., shield=True):
no success :(
it's a mess, don't judge xD
Is there a reason TaskGroup.start_soon is annotated to require a Coroutine and not accept a general Awaitable (asking because I want to schedule an async generators aclose method which is an awaitable and get type complaints (it seems to work in this case and I can cast it to fix the "error")
Or rather it needs a Callable returning a Coroutine but couldn't that still be loosened to an Awaitable?
in master we accept any awaitables
With positional only arguments, you could do a more elegant interface, but those were added later. https://peps.python.org/pep-0570/
@nilueps you could just use a lambda
thanks