Consider the following class and mixin:

```py
class Target(ClassThatUsesAMetaclass):

    def foo(self):
        pass

class Mixin:

    def __init__(self):
        self.foo()  # type error: type checker doesn't know Mixin will have
                    # access to foo once in use.

class Combined(Mixin, Target):

    def __init__(self):
        Target.__init__(self)
        Mixin.__init__(self)

```

I'm trying to avoid the type checker error in the above scenario. One option is this:

```py
from typing import Protocol

class Fooable(Protocol):
    def foo(self): ...

class Mixin(Fooable):

    def __init__(self):
        self.foo()

```

Would've worked great, except that `Target` inherits from a class that uses a metaclass, so `Combined` can't inherit from both `Target` and `Mixin`.
So now I'm trying an alternative, annotating `self` in `Mixin`:

```py
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from .this import Mixin, Target
    Mixin_T = type('Mixin_T', (Mixin, Target), {})

class Mixin:

    def __init__(self: Mixin_T):
        self.foo()  # No longer an error

class Combined(Mixin, Target):

    def __init__(self):
        Target.__init__(self)
        Mixin.__init__(self)  # Now this is an error: "Type[Mixin]" is not
                              # assignable to parameter "self"
                              # "Mixin" is incompatible with "Mixin_T"

```

So how am I supposed to win this aside from using `# type: ignore`?