Get PyCharm to know what classes are mixin for

Question

Our application has set of complex form wizards. To avoid code duplication I created several mixins.

The problem is that PyCharm highlights mixin methods with Unresolved attribute refference error.
This is correct as object does not have such methods. But I know that this mixin will be used only with special classes. Is there any way to tell this info to PyCharm?

For now I use such approach:

class MyMixin(object):
    def get_context_data(self, **kwargs):
        assert isinstance(self, (ClassToBeExtended, MyMixin))
        # super.get_context_data is still highlighter, 
        # as super is considered as object
        context = super(MyMixin, self).get_context_data(**kwargs)
        context.update(self.get_preview_context())
        return context

    def get_preview_context(self):
        # without this line PyCharm highlights the self.initial_data
        assert isinstance(self, (ClassToBeExtended, MyMixin))
        return {'needs': (self.initial_data['needs']
                          if 'type' not in self.initial_data
                          else '%(needs)s %(type)s' % self.initial_data)}

While this works for some cases like autocomplete for self., it fails for other cases like super. Is there a better approach to achieve the desired behavior?

P.S.: I know that I can disable reference check for specific name or whole class, but I don't want to do this as it will not help in typo checks and autocomplete.

Answer 1

You can type-hint to PyCharm what kind of classes to expect.

class DictMixin(object):
    def megamethod(
        self,  # type: dict
        key
    ):
        return self.get(key)

It's still not quite comparable to other type handling. PyCharm is lazy in evaluating it, and only does so when first working on self. Things are a bit tricky when accessing attributes of the mixin as well - self, # type: dict | DictMixin works for one of my classes, but not in my test code. In python 3.5, you should be able to use # type: typing.Union[dict, DictMixin].

Answer 2

If you are creating Mixin, for, let's say ClassSub, which is subclass of ClassSuper, you can implement Mixins this way:

class Mixin1(ClassSuper):
    pass


class Mixin2(ClassSuper):
    pass

and then use them like:

class ClassSub(Mixin1, Mixin2):
    pass

That way I use some mixins for models in Django. Also, django-extensions uses similar pattern (gives models that are actually mixins). Basically, this way you don't have to inherit ClassSuper, because it's "included" in every of your mixins.

Most important - PyCharm works like a charm this way.