Implementation of instance function overloading achieved with annotations and inspect

overloadable.py

import inspect


class Overloadable(object):
    def __init__(self, fn):
        self.base = fn
        self.overloads = (fn, inspect.signature(fn).parameters),
        self.instance = None
        
    def overload(self, fn):
        self.overloads += (fn, inspect.signature(fn).parameters),
        return self
    
    def __call__(self, *args, **kwargs):
        _args = tuple((None, a) for a in args)
        for fn, o in self.overloads:
            try:
                overloaded_params = tuple(o.items())
                params = _args + tuple(kwargs.items())
                assert len(params) == len(overloaded_params) - 1
                for (sn, st), (rn, rt) in zip(overloaded_params[1:], params):
                    assert isinstance(rt, st.annotation)
                return fn(self.parent_object, *args, **kwargs)
            except AssertionError as ex:
                pass
        raise NotImplemented("this kind of overload is not implemented")
    
    def __get__(self, instance, owner):
        self.parent_object = instance
        return self

def overloadable(fn):
    return Overloadable(fn)