def decorate(func):
template = """
def {name}({arglist}):
{call_jit_merge_point}({arglist})
return {original}({arglist})
"""
templateargs = {'call_jit_merge_point': call_jit_merge_point.__name__}
globaldict = {call_jit_merge_point.__name__: call_jit_merge_point}
result = rpython_wrapper(func, template, templateargs, **globaldict)
result._inline_jit_merge_point_ = call_jit_merge_point
return result
def decorate(func):
template = """
def {name}({arglist}):
{call_jit_merge_point}({arglist})
return {original}({arglist})
"""
templateargs = {'call_jit_merge_point': call_jit_merge_point.__name__}
globaldict = {call_jit_merge_point.__name__: call_jit_merge_point}
result = rpython_wrapper(func, template, templateargs, **globaldict)
result._inline_jit_merge_point_ = call_jit_merge_point
return result
def test_rpython_wrapper():
calls = []
def bar(a, b):
calls.append(('bar', a, b))
return a + b
template = """
def {name}({arglist}):
calls.append(('decorated', {arglist}))
return {original}({arglist})
"""
bar = rpython_wrapper(bar, template, calls=calls)
assert bar(40, 2) == 42
assert calls == [
('decorated', 40, 2),
('bar', 40, 2),
]
def test_rpython_wrapper():
calls = []
def bar(a, b):
calls.append(('bar', a, b))
return a+b
template = """
def {name}({arglist}):
calls.append(('decorated', {arglist}))
return {original}({arglist})
"""
bar = rpython_wrapper(bar, template, calls=calls)
assert bar(40, 2) == 42
assert calls == [
('decorated', 40, 2),
('bar', 40, 2),
]
def decorator(f):
def get_annotation(t):
from rpython.annotator.signature import annotation
from rpython.annotator.model import SomeObject
if isinstance(t, SomeObject):
return t
return annotation(t)
def get_type_descr_of_argument(arg):
# we don't want to check *all* the items in list/dict: we assume
# they are already homogeneous, so we only check the first
# item. The case of empty list/dict is handled inside typecheck()
if isinstance(arg, list):
return [get_type_descr_of_argument(arg[0])]
elif isinstance(arg, dict):
key, value = next(arg.iteritems())
return {
get_type_descr_of_argument(key):
get_type_descr_of_argument(value)
}
else:
return type(arg)
def typecheck(*args):
from rpython.annotator.model import SomeList, SomeDict, SomeChar,\
SomeInteger
for i, (expected_type, arg) in enumerate(zip(types, args)):
if expected_type is None:
continue
s_expected = get_annotation(expected_type)
# special case: if we expect a list or dict and the argument
# is an empty list/dict, the typecheck always pass
if isinstance(s_expected, SomeList) and arg == []:
continue
if isinstance(s_expected, SomeDict) and arg == {}:
continue
if isinstance(s_expected, SomeChar) and (isinstance(
arg, str) and len(arg) == 1): # a char
continue
if (isinstance(s_expected, SomeInteger)
and isinstance(arg, s_expected.knowntype)):
continue
#
s_argtype = get_annotation(get_type_descr_of_argument(arg))
if not s_expected.contains(s_argtype):
msg = "%s argument %r must be of type %s" % (
f.func_name, srcargs[i], expected_type)
raise TypeError(msg)
#
template = """
def {name}({arglist}):
if not we_are_translated():
typecheck({arglist}) # rpython.rlib.objectmodel
return {original}({arglist})
"""
result = rpython_wrapper(f,
template,
typecheck=typecheck,
we_are_translated=we_are_translated)
#
srcargs, srcvarargs, srckeywords, defaults = inspect.getargspec(f)
if kwds:
types = tuple([kwds.get(arg) for arg in srcargs])
else:
types = types_
assert len(srcargs) == len(types), (
'not enough types provided: expected %d, got %d' %
(len(types), len(srcargs)))
result._annenforceargs_ = types
return result
def decorator(f):
def get_annotation(t):
from rpython.annotator.signature import annotation
from rpython.annotator.model import SomeObject, SomeString, SomeUnicodeString
if isinstance(t, SomeObject):
return t
s_result = annotation(t)
if (isinstance(s_result, SomeString) or
isinstance(s_result, SomeUnicodeString)):
return s_result.__class__(can_be_None=True)
return s_result
def get_type_descr_of_argument(arg):
# we don't want to check *all* the items in list/dict: we assume
# they are already homogeneous, so we only check the first
# item. The case of empty list/dict is handled inside typecheck()
if isinstance(arg, list):
item = arg[0]
return [get_type_descr_of_argument(item)]
elif isinstance(arg, dict):
key, value = next(arg.iteritems())
return {get_type_descr_of_argument(key): get_type_descr_of_argument(value)}
else:
return type(arg)
def typecheck(*args):
from rpython.annotator.model import SomeList, SomeDict, SomeChar,\
SomeInteger
for i, (expected_type, arg) in enumerate(zip(types, args)):
if expected_type is None:
continue
s_expected = get_annotation(expected_type)
# special case: if we expect a list or dict and the argument
# is an empty list/dict, the typecheck always pass
if isinstance(s_expected, SomeList) and arg == []:
continue
if isinstance(s_expected, SomeDict) and arg == {}:
continue
if isinstance(s_expected, SomeChar) and (
isinstance(arg, str) and len(arg) == 1): # a char
continue
if (isinstance(s_expected, SomeInteger) and
isinstance(arg, s_expected.knowntype)):
continue
#
s_argtype = get_annotation(get_type_descr_of_argument(arg))
if not s_expected.contains(s_argtype):
msg = "%s argument %r must be of type %s" % (
f.func_name, srcargs[i], expected_type)
raise TypeError(msg)
#
template = """
def {name}({arglist}):
if not we_are_translated():
typecheck({arglist}) # rpython.rlib.objectmodel
return {original}({arglist})
"""
result = rpython_wrapper(f, template,
typecheck=typecheck,
we_are_translated=we_are_translated)
#
srcargs, srcvarargs, srckeywords, defaults = inspect.getargspec(f)
if kwds:
types = tuple([kwds.get(arg) for arg in srcargs])
else:
types = types_
assert len(srcargs) == len(types), (
'not enough types provided: expected %d, got %d' %
(len(types), len(srcargs)))
result._annenforceargs_ = types
return result
