How to annotate function type argument that will affect types of other arguments?

[khardix]

Consider the following code:

import typing as t
from collections import abc

T = t.TypeVar("T")
NORETURN: t.Final = object()

async def isolate(coroutine: abc.Awaitable[T], *, catch: type[BaseException] = Exception, caught: abc.MutableSequence[BaseException] | None = None) -> T | t.Literal[NORETURN]:
    try:
        return await coroutine
    except catch as exception:
        if caught is not None:
            caught.append(exception)
        return NORETURN

I would like to change the typing in such a way that the caught has the (covariant) type of MutableSequence[catch].

The usage that errors for now:

exception_queue: MutableSequence[Exception] = []
await isolate(coroutine(), caught=exception_queue)

error: Argument "caught" to "isolate" has incompatible type "MutableSequence[Exception]"; expected "MutableSequence[BaseException] | None"  [arg-type]

I have tried to use typevars, but that only lead to different error:

EXC = t.TypeVar("EXC", bound=BaseException)

async def isolate(coroutine: abc.Awaitable[T], *, catch: type[EXC] = Exception, caught: abc.MutableSequence[EXC] | None = None) -> T | Literal[NORETURN]: ...  # same code

error: Incompatible default for argument "catch" (default has type "type[Exception]", argument has type "type[EXC]")  [assignment]

Any hints greatly appreciated.

[Daverball]

There's not really any way to make this covariant, since that would not be safe. Using a type var will work, but you will need to add a separate overload for it:

I'm using PEP695 notation for brevity

@overload
async def isolate[T](
    coroutine: Awaitable[T],
    *,
    catch: type[BaseException] = Exception,
    caught: MutableSequence[BaseException] | None = None
) -> T | Literal[NORETURN]: ...

@overload
async def isolate[T, ExceptionT: BaseException](
    coroutine: Awaitable[T],
    *,
    catch: type[ExceptionT],
    caught: MutableSequence[ExceptionT]
) -> T | Literal[NORETURN]: ...

Making use of PEP696 and setting a default for ExceptionT should allow this to work without an overload, although IIRC mypy doesn't handle that case properly yet and will still emit an error for the mismatched default value type. It would also require you to import TypeVar from typing_extensions, since otherwise you will not have the default parameter available.