human
Complete the below
def bound_function(template_key):

    ''''Wrap an AttributeTemplate resolve_* method to allow it to
    resolve an instance method\'s signature rather than a instance attribute.
    The wrapped method must return the resolved method\'s signature
    according to the given self type, args, and keywords.
    It is used thusly:
    class ComplexAttributes(AttributeTemplate):
    @bound_function("complex.conjugate")
    def resolve_conjugate(self, ty, args, kwds):
    return ty
    *template_key* (e.g. "complex.conjugate" above) will be used by the
    target to look up the method\'s implementation, as a regular function.'
    '''

Write me a the Python program you requested?
assistant
#Here is the Python program you requested.
    def wrapper(method_resolver):
        @functools.wraps(method_resolver)
        def attribute_resolver(self, ty):
            class MethodTemplate(AbstractTemplate, ):
                key = template_key
                def generic(_, args, kws):
                    sig = method_resolver(self, ty, args, kws)
                    if ((sig is not None) and (sig.recvr is None)):
                        sig.recvr = ty
                    return sig
            return types.BoundFunction(MethodTemplate, ty)
        return attribute_resolver
    return wrapper