Ensuring that attributes referenced by a mixin are present in the children class I have implemented the below _get_schema method to ensure that schema attribute is always present on the Todos instance, and can therefore be used in the mixin.
Is it OK to do it like this? As far as I know, mixins usually do not implement constructors.
Is there a better way to make sure that someone did not forget to explicitly set the schema attribute in the Todos class, especially that this attribute is also not inherited from View?
class Mixin:
    def __init__(self):
        self._get_schema()
        super().__init__()

    def _get_schema(self):
        if not hasattr(self, 'schema'):
            msg = f'No &quot;schema&quot; attribute provided in {self.__class__.__name__} class'
            raise Exception(msg)

class View:
    def __init__(self):
        print('view constructor')

class Todos(SchemaMixin, MethodView):
    schema = 'todo schema'

todos = Todos()
The point of a mixin, at least as I've always understood it, is to inject
methods into other classes -- and not to create instances of the mixin class
itself. So putting an __init__() in a mixin does seem like an odd pattern. Of
course, __init__() is just a method: why not inject that method too? Fair
enough, but it still feels off. And is it really necessary?
One option is to inject the schema checking method and then call it in a proper
__init__():
class SchemaMixin:

    def _check_schema(self):
        ...

class Todos(SchemaMixin):

    def __init__(self):
        ...
        self._check_schema()

Or just use regular functions and get out of the awkward business of
inheritance. Without knowing more details about your case, I would lean in this
direction.
def check_schema(obj):
    ...

class Todos():

    def __init__(self):
        check_schema(self)

I find myself almost never using inheritance these days -- regular or
mixin-style. I don't have a blanket policy against it, but I increasingly find
that I just don't need it. If a class needs something, I pass it in as an
argument. If multiple classes need the same operation, I use functions.