def test_type_inference0(self):
code = '''
def wc(content):
d = {}
for word in content.split():
d[word] = d.get(word, 0) + 1
# Use list comprehension
l = [(freq, word) for word, freq in d.items()]
return sorted(l)
'''
self.run_test(code, "cha-la head cha-la", wc=[str])
code_bis = code.replace("1", "'1'")
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code_bis))
code_ter = code.replace("0", "None")
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code_ter))
def test_complex_import_manipulation2(self):
code = """
from bisect import bisect_right
def unsupported_module():
return bisect()"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("complex_import_manipulation2", dedent(code), pyonly=True)
def test_type_inference9(self):
code = """
def invalid_multi_yield(n):
for i in n:
yield [n]
yield n"""
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_type_inference8(self):
code = """
def invalid_multi_return(n):
for i in n:
return [n]
return {n}"""
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_type_inference1(self):
code = """
def invalid_augassign(n):
s = n + "1"
s += 2
return s"""
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_type_inference1(self):
code = '''
def invalid_augassign(n):
s = n + "1"
s += 2
return s'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_type_inference8(self):
code = '''
def invalid_multi_return(n):
for i in n:
return [n]
return {n}'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_complex_import_manipulation3(self):
code = """
from numpy import random
def unsupported_module():
return random.i_do_not_exist()"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("complex_import_manipulation3", dedent(code), pyonly=True)
def test_type_inference9(self):
code = '''
def invalid_multi_yield(n):
for i in n:
yield [n]
yield n'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_complex_import_manipulation(self):
"""
Check correct error is returned for incorrect module manipulation.
"""
code = """
import math
def unsupported_module():
return math"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("flamby", dedent(code))
def test_complex_import_manipulation(self):
"""
Check correct error is returned for incorrect module manipulation.
"""
code = """
import math
def unsupported_module():
return math"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("flamby", dedent(code))
def test_import_collections(self):
"""
Check correct error is returned for incorrect module import.
Check is done for module as .py file.
"""
code = """
import collections
def unsupported_module():
return collections.Counter()"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("flamby", dedent(code), pyonly=True)
self.assertIn("Module 'collections' not found.", str(ex.exception))
def test_import_collections(self):
"""
Check correct error is returned for incorrect module import.
Check is done for module as .py file.
"""
code = """
import collections
def unsupported_module():
return collections.Counter()"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("flamby", dedent(code))
self.assertIn("Module 'collections' not found.", str(ex.exception))
def pythran(self, line, cell):
"""
Compile and import everything from a Pythran code cell.
%%pythran
#pythran export foo(int)
def foo(x):
return x + x
"""
args = magic_arguments.parse_argstring(self.pythran, line)
kwargs = {}
if args.D:
kwargs['define_macros'] = args.D
if args.O:
kwargs.setdefault('extra_compile_args', []).extend(
'-O' + str(x) for x in args.O)
if args.march:
kwargs.setdefault('extra_compile_args', []).extend(
'-march=' + str(x) for x in args.march)
if args.fopenmp:
kwargs.setdefault('extra_compile_args', []).append(
'-fopenmp')
m = hashlib.md5()
m.update(cell)
module_name = "pythranized_" + m.hexdigest()
module_path = pythran.compile_pythrancode(module_name, cell, **kwargs)
module = imp.load_dynamic(module_name, module_path)
self._import_all(module)
def test_import_collections(self):
"""
Check correct error is returned for incorrect module import.
Check is done for module as .py file.
"""
code = """
import collections
def unsupported_module():
return collections.Counter()"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("flamby", dedent(code))
self.assertEqual(ex.exception.message,
"Unpythranizable module: collections")
def pythran(self, line, cell):
"""
Compile and import everything from a Pythran code cell.
%%pythran
#pythran export foo(int)
def foo(x):
return x + x
"""
args = magic_arguments.parse_argstring(self.pythran, line)
kwargs = {}
if args.D:
kwargs['define_macros'] = args.D
if args.O:
kwargs.setdefault('extra_compile_args',
[]).extend('-O' + str(x) for x in args.O)
if args.march:
kwargs.setdefault('extra_compile_args',
[]).extend('-march=' + str(x)
for x in args.march)
if args.fopenmp:
kwargs.setdefault('extra_compile_args', []).append('-fopenmp')
kwargs.setdefault('extra_link_args', []).append('-fopenmp')
m = hashlib.md5()
m.update(line.encode('utf-8'))
m.update(cell.encode('utf-8'))
module_name = "pythranized_" + m.hexdigest()
module_path = pythran.compile_pythrancode(module_name, cell, **kwargs)
module = imp.load_dynamic(module_name, module_path)
self._import_all(module)
def pythran(self, line, cell):
"""
Compile and import everything from a Pythran code cell.
%%pythran
#pythran export foo(int)
def foo(x):
return x + x
"""
args = magic_arguments.parse_argstring(self.pythran, line)
kwargs = {}
if args.D:
kwargs['define_macros'] = args.D
for v in "OmWf":
args_v = getattr(args, v)
for target in ('extra_compile_args', 'extra_link_args'):
kwargs.setdefault(target, []).extend('-{}{}'.format(v, x)
for x in args_v)
m = hashlib.md5()
m.update(line.encode('utf-8'))
m.update(cell.encode('utf-8'))
module_name = "pythranized_" + m.hexdigest()
module_path = pythran.compile_pythrancode(module_name, cell, **kwargs)
module = imp.load_dynamic(module_name, module_path)
self._import_all(module)
def test_import_collections(self):
"""
Check correct error is returned for incorrect module import.
Check is done for module as .py file.
"""
code = """
import collections
def unsupported_module():
return collections.Counter()"""
with self.assertRaises(pythran.syntax.PythranSyntaxError) as ex:
pythran.compile_pythrancode("flamby", dedent(code))
self.assertEqual(str(ex.exception),
"Unpythranizable module: collections")
def jit_pythran(self):
import pythran
import imp
import hashlib
# self._import_all(module)
names = []
funcs = set(vaex.dataset.expression_namespace.keys())
expression = self.expression
if expression in self.ds.virtual_columns:
expression = self.ds.virtual_columns[self.expression]
all_vars = self.ds.get_column_names(virtual=True, strings=True, hidden=True) + list(self.ds.variables.keys())
vaex.expresso.validate_expression(expression, all_vars, funcs, names)
names = list(set(names))
types = ", ".join(str(self.ds.dtype(name)) + "[]" for name in names)
argstring = ", ".join(names)
code = '''
from numpy import *
#pythran export f({2})
def f({0}):
return {1}'''.format(argstring, expression, types)
print(code)
m = hashlib.md5()
m.update(code.encode('utf-8'))
module_name = "pythranized_" + m.hexdigest()
print(m.hexdigest())
module_path = pythran.compile_pythrancode(module_name, code, extra_compile_args=["-DBOOST_SIMD", "-march=native"])
module = imp.load_dynamic(module_name, module_path)
function_name = "f_" + m.hexdigest()
vaex.dataset.expression_namespace[function_name] = module.f
return Expression(self.ds, "{0}({1})".format(function_name, argstring))
def pythran(self, line, cell):
"""
Compile and import everything from a Pythran code cell.
%%pythran
#pythran export foo(int)
def foo(x):
return x + x
"""
args = magic_arguments.parse_argstring(self.pythran, line)
kwargs = {}
if args.D:
kwargs['define_macros'] = args.D
for v in "OmWf":
args_v = getattr(args, v)
for target in ('extra_compile_args', 'extra_link_args'):
kwargs.setdefault(target, []).extend('-{}{}'.format(v, x)
for x in args_v)
m = hashlib.md5()
m.update(line.encode('utf-8'))
m.update(cell.encode('utf-8'))
module_name = "pythranized_" + m.hexdigest()
module_path = pythran.compile_pythrancode(module_name, cell, **kwargs)
module = imp.load_dynamic(module_name, module_path)
self._import_all(module)
def run_test_case(self, code, module_name, runas, **interface):
"""
Test if a function call return value is equal for Pythran and Pythran.
Args:
code (str): python (pythran valid) module to test.
module_name (str): name of the compiled module
runas (str): command line to run to check output
interface (dict): pythran interface for the module to test.
Each key is the name of a function to call,
the value is a list of the arguments' type.
Returns: nothing.
Raises:
AssertionError by 'unittest' if return value differ.
SyntaxError if code is not python valid.
pythran.CompileError if generated code can't be compiled.
...possibly others...
"""
# Extract special keys from interface.
if runas:
# runas is a python code string to run the test. By convention
# the last statement of the sequence is the value to test.
# We insert ourselves a variable to capture this value:
# "a=1; b=2; myfun(a+b,a-b)" => "a=1; b=2; RES=myfun(a+b,a-b)"
runas_commands = runas.split(";")
begin = ";".join(runas_commands[:-1])
# this tests the runas initialisation syntax
exec(code + "\n" + begin, {})
last = self.TEST_RETURNVAL + '=' + runas_commands[-1]
runas = begin + "\n" + last
# We run test for each exported function (not for each possible
# signature.
for i, name in enumerate(sorted(interface.keys())):
# If no module name was provided, create one
modname = (module_name or ("test_" + name)) + str(i)
# Compile the code using pythran
cxx_compiled = compile_pythrancode(
modname,
code,
interface,
extra_compile_args=self.PYTHRAN_CXX_FLAGS)
if not runas:
continue
python_ref = self.run_python(code, runas)
pythran_res = self.run_pythran(modname, cxx_compiled, runas)
print("Python result: ", python_ref)
print("Pythran result: ", pythran_res)
self.assertAlmostEqual(python_ref, pythran_res)
def run_test(self, code, *params, **interface):
"""
Test if a function call return value is equal for Pythran and Pythran.
Args:
code (str): python (pythran valid) module to test.
params (tuple): arguments to pass to the function to test.
prelude (fct): function to call between 'code' and the c++
generated code
interface (dict): pythran interface for the module to test.
Each key is the name of a function to call,
the value is a list of the arguments' type.
Special keys are 'prelude' and 'check_exception'.
Returns: nothing.
Raises:
AssertionError by 'unittest' if return value differ.
SyntaxError if code is not python valid.
pythran.CompileError if generated code can't be compiled.
...possibly others...
"""
# Extract special keys from interface.
prelude = interface.pop('prelude', None)
check_exception = interface.pop('check_exception', False)
assert len(interface) == 1
name = interface.keys()[0]
modname = "test_" + name
code = dedent(code)
cxx_compiled = compile_pythrancode(
modname,
code,
interface,
extra_compile_args=self.PYTHRAN_CXX_FLAGS)
# FIXME Check should be done on input parameters after function call
python_ref = self.run_python(code, (name, copy.deepcopy(params)),
prelude, check_exception)
pythran_res = self.run_pythran(modname, cxx_compiled, (name, params),
prelude, check_exception)
if check_exception:
if pythran_res != python_ref:
raise AssertionError(
"expected exception was %s, but received %s" %
(python_ref, pythran_res))
print "Python result: ", python_ref
print "Pythran result: ", pythran_res
self.assertAlmostEqual(python_ref, pythran_res)
def run_test_case(self, code, module_name, runas, **interface):
"""
Test if a function call return value is equal for Pythran and Pythran.
Args:
code (str): python (pythran valid) module to test.
module_name (str): name of the compiled module
runas (str): command line to run to check output
interface (dict): pythran interface for the module to test.
Each key is the name of a function to call,
the value is a list of the arguments' type.
Returns: nothing.
Raises:
AssertionError by 'unittest' if return value differ.
SyntaxError if code is not python valid.
pythran.CompileError if generated code can't be compiled.
...possibly others...
"""
# Extract special keys from interface.
if runas:
# runas is a python code string to run the test. By convention
# the last statement of the sequence is the value to test.
# We insert ourselves a variable to capture this value:
# "a=1; b=2; myfun(a+b,a-b)" => "a=1; b=2; RES=myfun(a+b,a-b)"
runas_commands = runas.split(";")
begin = ";".join(runas_commands[:-1])
# this tests the runas initialisation syntax
exec code + "\n" + begin in {}
last = self.TEST_RETURNVAL + '=' + runas_commands[-1]
runas = begin + "\n" + last
# We run test for each exported function (not for each possible
# signature.
for i, name in enumerate(sorted(interface.keys())):
# If no module name was provided, create one
modname = (module_name or ("test_" + name)) + str(i)
# Compile the code using pythran
cxx_compiled = compile_pythrancode(
modname, code, None, extra_compile_args=self.PYTHRAN_CXX_FLAGS)
if not runas:
continue
python_ref = self.run_python(code, runas)
pythran_res = self.run_pythran(modname, cxx_compiled, runas)
print "Python result: ", python_ref
print "Pythran result: ", pythran_res
self.assertAlmostEqual(python_ref, pythran_res)
def pythran(self, line, cell):
"""
Compile and import everything from a Pythran code cell
%%pythran
#pythran export foo(int)
def foo(x):
return x + x
"""
module_name = "pythranized"
module_path = pythran.compile_pythrancode(module_name, cell)
module = imp.load_dynamic(module_name, module_path)
self._import_all(module)
def jit_pythran(self, verbose=False):
import logging
logger = logging.getLogger('pythran')
log_level = logger.getEffectiveLevel()
try:
if not verbose:
logger.setLevel(logging.ERROR)
import pythran
import imp
import hashlib
# self._import_all(module)
names = []
funcs = set(vaex.dataset.expression_namespace.keys())
expression = self.expression
if expression in self.ds.virtual_columns:
expression = self.ds.virtual_columns[self.expression]
all_vars = self.ds.get_column_names(
virtual=True, strings=True, hidden=True) + list(
self.ds.variables.keys())
vaex.expresso.validate_expression(expression, all_vars, funcs,
names)
names = list(set(names))
types = ", ".join(
str(self.ds.dtype(name)) + "[]" for name in names)
argstring = ", ".join(names)
code = '''
from numpy import *
#pythran export f({2})
def f({0}):
return {1}'''.format(argstring, expression, types)
if verbose:
print("generated code")
print(code)
m = hashlib.md5()
m.update(code.encode('utf-8'))
module_name = "pythranized_" + m.hexdigest()
# print(m.hexdigest())
module_path = pythran.compile_pythrancode(
module_name,
code,
extra_compile_args=["-DBOOST_SIMD", "-march=native"] +
[] if verbose else ["-w"])
module = imp.load_dynamic(module_name, module_path)
function_name = "f_" + m.hexdigest()
vaex.dataset.expression_namespace[function_name] = module.f
return Expression(self.ds,
"{0}({1})".format(function_name, argstring))
finally:
logger.setLevel(log_level)
def run_test(self, code, *params, **interface):
"""
Test if a function call return value is equal for Pythran and Pythran.
Args:
code (str): python (pythran valid) module to test.
params (tuple): arguments to pass to the function to test.
prelude (fct): function to call between 'code' and the c++
generated code
interface (dict): pythran interface for the module to test.
Each key is the name of a function to call,
the value is a list of the arguments' type.
Special keys are 'prelude' and 'check_exception'.
Returns: nothing.
Raises:
AssertionError by 'unittest' if return value differ.
SyntaxError if code is not python valid.
pythran.CompileError if generated code can't be compiled.
...possibly others...
"""
# Extract special keys from interface.
prelude = interface.pop('prelude', None)
check_exception = interface.pop('check_exception', False)
assert len(interface) == 1
name = interface.keys()[0]
modname = "test_" + name
code = dedent(code)
cxx_compiled = compile_pythrancode(
modname, code, interface, extra_compile_args=self.PYTHRAN_CXX_FLAGS)
# FIXME Check should be done on input parameters after function call
python_ref = self.run_python(code, (name, copy.deepcopy(params)),
prelude, check_exception)
pythran_res = self.run_pythran(modname, cxx_compiled, (name, params),
prelude, check_exception)
if check_exception:
if pythran_res != python_ref:
raise AssertionError(
"expected exception was %s, but received %s" %
(python_ref, pythran_res))
print "Python result: ", python_ref
print "Pythran result: ", pythran_res
self.assertAlmostEqual(python_ref, pythran_res)
def test_type_inference0(self):
code = """
def wc(content):
d = {}
for word in content.split():
d[word] = d.get(word, 0) + 1
# Use list comprehension
l = [(freq, word) for word, freq in d.items()]
return sorted(l)
"""
self.run_test(code, "cha-la head cha-la", wc=[str])
code_bis = code.replace("1", "'1'")
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code_bis))
code_ter = code.replace("0", "None")
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code_ter))
def jit_pythran(self, verbose=False):
import logging
logger = logging.getLogger('pythran')
log_level = logger.getEffectiveLevel()
try:
if not verbose:
logger.setLevel(logging.ERROR)
import pythran
import imp
import hashlib
# self._import_all(module)
names = []
funcs = set(expression_namespace.keys())
expression = self.expression
if expression in self.ds.virtual_columns:
expression = self.ds.virtual_columns[self.expression]
all_vars = self.ds.get_column_names(virtual=True, strings=True, hidden=True) + list(self.ds.variables.keys())
vaex.expresso.validate_expression(expression, all_vars, funcs, names)
names = list(set(names))
types = ", ".join(str(self.ds.dtype(name)) + "[]" for name in names)
argstring = ", ".join(names)
code = '''
from numpy import *
#pythran export f({2})
def f({0}):
return {1}'''.format(argstring, expression, types)
if verbose:
print("generated code")
print(code)
m = hashlib.md5()
m.update(code.encode('utf-8'))
module_name = "pythranized_" + m.hexdigest()
# print(m.hexdigest())
module_path = pythran.compile_pythrancode(module_name, code, extra_compile_args=["-DBOOST_SIMD", "-march=native"] + [] if verbose else ["-w"])
module = imp.load_dynamic(module_name, module_path)
function_name = "f_" + m.hexdigest()
expression_namespace[function_name] = module.f
return Expression(self.ds, "{0}({1})".format(function_name, argstring))
finally:
logger.setLevel(log_level)
def pythran(self, line, cell):
"""
Compile and import everything from a Pythran code cell.
%%pythran
#pythran export foo(int)
def foo(x):
return x + x
"""
args = magic_arguments.parse_argstring(self.pythran, line)
kwargs = {}
if args.D:
kwargs['define_macros'] = args.D
if args.O:
kwargs.setdefault('extra_compile_args',
[]).extend('-O' + str(x) for x in args.O)
if args.march:
kwargs.setdefault('extra_compile_args',
[]).extend('-march=' + str(x)
for x in args.march)
module_name = "pythranized"
module_path = pythran.compile_pythrancode(module_name, cell, **kwargs)
module = imp.load_dynamic(module_name, module_path)
self._import_all(module)
def test_type_inference10(self):
code = '''
def valid_augassign(l):
l *= 0
return l[1,2]'''
pythran.compile_pythrancode("dumbo", dedent(code))
def test_type_inference4(self):
code = """
def invalid_list(n):
return [n, len(n)]"""
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
from inspect import getsource
import re, imp
# grab imports
imports = 'import math'
exports = '''
#pythran export growcut_python(float[][][], float[][][], float [][][], int)
'''
modname = 'growcut_pythran'
# grab the source from the original functions
sources = map(getsource,
(growcut_python.window_floor,
growcut_python.window_ceil,
growcut_python.growcut_python,
)
)
source = '\n'.join(sources)
# compile to a native module
native = compile_pythrancode(modname,
'\n'.join([imports, exports, source]))
# load it
native = imp.load_dynamic(modname, native)
benchmarks = (
("growcut_pythran",
native.growcut_python),
)
def test_invalid_specs2(self):
code = "#pythran export bar(int)\ndef foo(): pass"
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumber", code)
def test_invalid_specs0(self):
code = "#pythran export foo()\ndef foo(n): return n"
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumber", code)
from pythran import compile_pythrancode
from inspect import getsource
import re
import imp
# grab imports
imports = 'import numpy as np'
exports = '#pythran export pairwise_python_nested_for_loops(float[][])'
modname = 'pairwise_pythran'
# grab the source from the original function
source = getsource(pairwise_python.pairwise_python_nested_for_loops)
# a few rewriting rules to prune unsupported features
source = re.sub(r'dtype=data.dtype', 'np.double', source)
source = re.sub(r'#"omp', '"omp', source)
# compile to a native module
native = compile_pythrancode(modname,
'\n'.join([imports, exports, source]),
cxxflags=['-O2', '-fopenmp']
)
# load it
native = imp.load_dynamic(modname, native)
benchmarks = (
("pairwise_pythran_nested_for_loops",
native.pairwise_python_nested_for_loops),
)
def test_type_inference7(self):
code = """
def invalid_dict_value(n):
return {1:n, 2:len(n)}"""
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
# grab imports
imports = '''
import numpy as np
from math import *
'''
exports = '''
#pythran export arc_distance_python_nested_for_loops(float [][], float [][])
'''
modname = 'arc_distance_pythran'
# grab the source from original functions
funs = (arc_distance_python.arc_distance_python_nested_for_loops,)
sources = map(getsource, funs)
source = '\n'.join(sources)
# patch
source = re.sub(r'\[a_nrows, b_nrows\]', '(a_nrows, b_nrows)', source)
# compile to native module
source = '\n'.join([exports, imports, source])
native = compile_pythrancode(modname, source)
# load
native = imp.load_dynamic(modname, native)
benchmarks = (("arc_distance_pythran_nested_for_loops",
native.arc_distance_python_nested_for_loops),
)
def test_type_inference4(self):
code = '''
def invalid_list(n):
return [n, len(n)]'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_type_inference2(self):
code = '''
def invalid_ifexp(n):
return 1 if n else "1"'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_type_inference3(self):
code = """
def invalid_unary_op(n):
return -(n + 'n')"""
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_module_bad_attribute(self):
code = 'def module_bad_attribute(): import random as m; return m.real'
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumbo", code)
def test_invalid_specs3(self):
code = '#pythran export bar(int, int?, int)\ndef bar(x, y=1, z=1): pass'
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumber", code)
def test_type_inference2(self):
code = '''
def invalid_ifexp(n):
return 1 if n else "1"'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_undefinied_variable_in_test(self):
code = 'def undefinied_variable_in_test(x):\n if x: print(A)'
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumbo", code, pyonly=True)
def test_type_inference3(self):
code = '''
def invalid_unary_op(n):
return -(n + 'n')'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_immutable_default1(self):
code = 'def immutable_default1(x={1}): pass'
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumbo", code, pyonly=True)
def test_type_inference7(self):
code = '''
def invalid_dict_value(n):
return {1:n, 2:len(n)}'''
with self.assertRaises(pythran.types.tog.PythranTypeError):
pythran.compile_pythrancode("dumbo", dedent(code))
def test_immutable_default4(self):
code = 'def immutable_default4(x=None): pass'
pythran.compile_pythrancode("dumbo", code, pyonly=True)
def run_test(self, code, *params, **interface):
"""Test if a function call return value is unchanged when
executed using python eval or compiled with pythran.
Args:
code (str): python (pythran valid) module to test.
params (tuple): arguments to pass to the function to test.
prelude (fct): function to call between 'code' and the c++
generated code
interface (dict): pythran interface for the module to test.
Each key is the name of a function to call,
the value is a list of the arguments' type.
Special keys are 'module_name', 'prelude',
'runas', 'check_refcount', 'check_exception'
and 'check_output'.
Returns: nothing.
Raises:
AssertionError by 'unittest' if return value differ.
SyntaxError if code is not python valid.
pythran.CompileError if generated code can't be compiled.
...possibly others...
"""
# Extract special keys from interface.
module_name = interface.pop('module_name', None)
prelude = interface.pop('prelude', None)
check_output = interface.pop('check_output', True)
runas = interface.pop('runas', None)
check_refcount = interface.pop('check_refcount', False)
check_exception = interface.pop('check_exception', False)
if runas:
# runas is a python code string to run the test. By convention
# the last statement of the sequence is the value to test.
# We insert ourselves a variable to capture this value:
# "a=1; b=2; myfun(a+b,a-b)" => "a=1; b=2; RES=myfun(a+b,a-b)"
runas_commands = runas.split(";")
begin = ";".join(runas_commands[:-1]+[''])
exec code+"\n"+begin in {} # this just tests the syntax of runas
last = self.TEST_RETURNVAL + '=' + runas_commands[-1]
runas = begin+"\n"+last
for name in sorted(interface.keys()):
if not runas:
# No runas provided, derive one from interface and params
attributes = []
runas = ""
for p in params:
if isinstance(p, str):
param = "'{0}'".format(p)
elif isinstance(p, ndarray):
param = "numpy.{0}".format(
repr(p).replace("\n", "")
.replace("dtype=", "dtype=numpy."))
runas = "import numpy\n"
else:
# repr preserve the "L" suffix for long
param = repr(p)
attributes.append(param.replace("nan", "float('nan')")
.replace("inf", "float('inf')"))
arglist = ",".join(attributes)
function_call = "{0}({1})".format(name, arglist)
runas += self.TEST_RETURNVAL + '=' + function_call
# Caller may requires some cleaning
prelude and prelude()
# Produce the reference, python-way, run in an separated 'env'
env = {'__builtin__': __import__('__builtin__')}
refcode = code+"\n"+runas
# Compare if exception raised in python and in pythran are the same
python_exception_type = None
pythran_exception_type = None
try:
if check_output:
exec refcode in env
python_ref = env[self.TEST_RETURNVAL]
if check_refcount:
python_refcount = sys.getrefcount(python_ref)
except BaseException as e:
python_exception_type = type(e)
if not check_exception:
raise
# If no module name was provided, create one
modname = module_name or ("test_" + name)
# Compile the code using pythran
cxx_compiled = compile_pythrancode(modname, code,
interface, cxxflags=self.PYTHRAN_CXX_FLAGS)
try:
if not check_output:
return
# Caller may requires some cleaning
prelude and prelude()
pymod = load_dynamic(modname, cxx_compiled)
try:
# Produce the pythran result, exec in the loaded module ctx
exec runas in pymod.__dict__
except BaseException as e:
pythran_exception_type = type(e)
else:
pythran_res = getattr(pymod, self.TEST_RETURNVAL)
if check_refcount:
pythran_refcount = sys.getrefcount(pythran_res)
self.assertEqual(python_refcount, pythran_refcount)
# Test Results, assert if mismatch
if python_exception_type:
raise AssertionError(
"expected exception was %s, but nothing happend!" %
python_exception_type)
self.compare_pythonpythran_results(python_ref, pythran_res)
finally:
# Clean temporary DLL
os.remove(cxx_compiled)
# Only compare the type of exceptions raised
if pythran_exception_type != python_exception_type:
if python_exception_type is None:
raise e
else:
raise AssertionError(
"expected exception was %s, but received %s" %
(python_exception_type, pythran_exception_type))
def test_immutable_default7(self):
code = 'def g(): pass\ndef immutable_default7(x=g): pass'
pythran.compile_pythrancode("dumbo", code, pyonly=True)
def test_type_inference11(self):
code = '''
def valid_tuple_index(l):
return (1, 2, 3, 4)[l]'''
pythran.compile_pythrancode("dumbo", dedent(code))
def test_invalid_specs1(self):
code = '#pythran export boo(int)\ndef boo(): pass'
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumber", code)
def test_module_bad_attribute(self):
code = 'def module_bad_attribute(): import random as m; return m.real'
with self.assertRaises(pythran.syntax.PythranSyntaxError):
pythran.compile_pythrancode("dumbo", code)
def run_test(self, code, *params, **interface):
"""
Test if a function call return value is equal for Pythran and Pythran.
Args:
code (str): python (pythran valid) module to test.
params (tuple): arguments to pass to the function to test.
prelude (fct): function to call between 'code' and the c++
generated code
interface (dict): pythran interface for the module to test.
Each key is the name of a function to call,
the value is a list of the arguments' type.
Special keys are 'prelude' and 'check_exception'.
Returns: nothing.
Raises:
AssertionError by 'unittest' if return value differ.
SyntaxError if code is not python valid.
pythran.CompileError if generated code can't be compiled.
...possibly others...
"""
# Extract special keys from interface.
prelude = interface.pop('prelude', None)
check_exception = interface.pop('check_exception', False)
assert len(interface) == 1
name = next(iter(interface.keys()))
modname = "test_" + name
code = dedent(code)
if sys.version_info.major == 3:
from tempfile import NamedTemporaryFile
from lib2to3 import main as lib2to3
tmp_py = NamedTemporaryFile(suffix='.py', delete=False)
tmp_py.write(code.encode('ascii'))
tmp_py.close()
lib2to3.main('lib2to3.fixes', [tmp_py.name, '-w', '-n'])
code = open(tmp_py.name).read()
os.remove(tmp_py.name)
cxx_compiled = compile_pythrancode(
modname, code, interface, extra_compile_args=self.PYTHRAN_CXX_FLAGS)
# FIXME Check should be done on input parameters after function call
python_ref = self.run_python(code, (name, copy.deepcopy(params)),
prelude, check_exception)
pythran_res = self.run_pythran(modname, cxx_compiled, (name, params),
prelude, check_exception)
if check_exception:
if pythran_res != python_ref:
raise AssertionError(
"expected exception was %s, but received %s" %
(python_ref, pythran_res))
print("Python result: ", python_ref)
print("Pythran result: ", pythran_res)
self.assertAlmostEqual(python_ref, pythran_res)
