Support for custom mro ?

[ArthurZucker]

Hey! Heavy pylance user 🚀
Working on some automatic documentation in transformers, and having a few issues as we kinda want to have pseudo dynamic docstring (they are based on the signature, but the documented arguments are all in a big dictionary).

I have absolutely no idea how to circumvent this, so realized the simplest might just to inherit from a lot of Parent classes that would store all possible variations (if foo is there, bar is not etc), and MRO would solve which doc to choose from.

import inspect

# Custom metaclass that modifies the MRO based on the signature of the forward method
class CustomMeta(type):
    def mro(cls):
        # Get the default MRO (superclasses in the default method resolution order)
        default_mro = super().mro()
        default_sig = inspect.signature(cls.__dict__['forward']).parameters.keys()
        # Extract classes with the forward method
        classes_with_forward = []
        new_mro = []
        for klass in default_mro:
            if 'forward' in klass.__dict__ and klass in cls.__bases__:
                method = klass.__dict__['forward']
                # Get the signature of the forward method
                sig = inspect.signature(method).parameters.keys()
                union = default_sig == sig
                # Append the class along with the parameter count
                if union:
                    classes_with_forward = [klass]
                    break
            else:
                new_mro.append(klass)
        new_mro = classes_with_forward + new_mro
        return new_mro



class ParentOne:
    def forward(self, foo):
        """ParentOne's forward with one param"""
        print(f"ParentOne: foo={foo}")

class ParentTwo:
    def forward(self, foo, bar):
        """ParentTwo's forward with two parameters"""
        print(f"ParentTwo: foo={foo}, bar={bar}")

class ParentThree:
    def forward(self, foo, bar, charly):
        """ParentThree's forward with three parameter"""
        print(f"ParentThree: foo={foo}, bar={bar}, charly={charly}")

# Child class inheriting from multiple parents
class Child(ParentOne, ParentTwo, ParentThree, metaclass=CustomMeta):
    def forward(self, foo, bar):
        pass


print("MRO:", Child.mro())
print("MRO:", Child.__mro__)
# Calling forward method, this will follow the custom MRO
Child.forward

I am using VSCode, and pretty sure it's just not calling my custom MRO (for probably a justified reason!)

So this might be more of a feature request, but also a question: what is the best way to do this statically ? 😅

[rchiodo]

Transferring to a question. I don't believe what you want to do is possible, but somebody else might have other ideas.

[ArthurZucker]

Thanks!