def wrapper(*args, **kwargs):
            if conf._enabled:
                for arg, name in zip(args, arg_names):
                    if not _verify_type_constraint(arg, types[name]):
                        _type_error(
                            "argument %s = %s doesn't match "
                            "signature %s" % (name, repr(arg), _constraint_to_string(types[name]))
                        )

                for k, v in kwargs.items():
                    if k not in types:
                        _type_error("unknown keyword argument %s " "(positional specified as keyword?)" % k)
                    if not _verify_type_constraint(v, types[k]):
                        _type_error(
                            "keyword argument %s = %s "
                            "doesn't match signature %s" % (k, repr(v), _constraint_to_string(types[k]))
                        )
            return fn(*args, **kwargs)
 def wrapper(*args, **kwargs):
     retval = fn(*args, **kwargs)
     if conf._enabled:
         if retval is None and return_type is not type(None):
             _type_error("non-void function didn't return a value",
                         stack=fn.__def_site__)
         elif retval is not None and return_type is type(None):
             _type_error("void function returned a value",
                         stack=fn.__def_site__)
         elif not _verify_type_constraint(retval, return_type):
             _type_error("function returned value %s not matching "
                         "signature %s" % (repr(retval),
                                           _constraint_to_string(return_type)),
                         stack=fn.__def_site__)
     return retval