Is there such a thing as an AbstractSubClass in python?

The background

In python, if you were defining an Abstract Base Class which requires that its methods be overwritten, you'd do:

from abc import ABC, abstractmethod

class MyAbstractClass(ABC):
    @abstractmethod
    def my_method(self):
        pass

The following code would then fail because it doesn't implement my_method.

class MyConcreteClass(MyAbstractClass):
    pass

But what if I want to define the method requirements of a mixin class?

class MyMixin:

    def my_mixin_method(self):
        self.a_required_method()

The following code is then valid:

class MyBase:
    def a_required_method(self):
        pass

class MyFull(MyMixin, MyBase):
    pass

The following code is also valid...

class MyDubious(MyMixin):
    pass

But exposes an error at runtime:

MyFull().my_mixin_method() # Works
MyDubious().my_mixin_method()  # Runtime error

The Question

Is there something like AbstractBaseClass which can be added to Mixin classes, to ensure that a derived class can't be instantiated unless it inherits correctly?

I'm thinking a nice API would look like:

from asc import ASC, requiredmethod

class MyRobustMixin(ASC):
    @requiredmethod
    def a_required_method(self):
        pass

    def my_mixin_method(self):
        self.a_required_method()