Skip to content

Commit df34ecb

Browse files
committed
TST: Replace ENGINES_PARSERS by parametrize.
1 parent bbb583c commit df34ecb

File tree

2 files changed

+63
-117
lines changed

2 files changed

+63
-117
lines changed

pandas/tests/computation/test_compat.py

+3-8
Original file line numberDiff line numberDiff line change
@@ -11,8 +11,6 @@
1111
from pandas.computation.engines import _engines
1212
import pandas.computation.expr as expr
1313

14-
ENGINES_PARSERS = list(product(_engines, expr._parsers))
15-
1614

1715
def test_compat():
1816
# test we have compat with our version of nu
@@ -34,12 +32,9 @@ def test_compat():
3432
pytest.skip("not testing numexpr version compat")
3533

3634

37-
def test_invalid_numexpr_version():
38-
for engine, parser in ENGINES_PARSERS:
39-
yield check_invalid_numexpr_version, engine, parser
40-
41-
42-
def check_invalid_numexpr_version(engine, parser):
35+
@pytest.mark.parametrize('engine', _engines)
36+
@pytest.mark.parametrize('parser', expr._parsers)
37+
def test_invalid_numexpr_version(engine, parser):
4338
def testit():
4439
a, b = 1, 2
4540
res = pd.eval('a + b', engine=engine, parser=parser)

pandas/tests/computation/test_eval.py

+60-109
Original file line numberDiff line numberDiff line change
@@ -774,16 +774,19 @@ def check_chained_cmp_op(self, lhs, cmp1, mid, cmp2, rhs):
774774
f = lambda *args, **kwargs: np.random.randn()
775775

776776

777-
ENGINES_PARSERS = list(product(_engines, expr._parsers))
778-
779777
#-------------------------------------
780778
# typecasting rules consistency with python
781779
# issue #12388
782780

783781

784782
class TestTypeCasting(object):
785-
786-
def check_binop_typecasting(self, engine, parser, op, dt):
783+
@pytest.mark.parametrize('engine', _engines)
784+
@pytest.mark.parametrize('parser', expr._parsers)
785+
@pytest.mark.parametrize('op', ['+', '-', '*', '**', '/'])
786+
# maybe someday... numexpr has too many upcasting rules now
787+
# chain(*(np.sctypes[x] for x in ['uint', 'int', 'float']))
788+
@pytest.mark.parametrize('dt', [np.float32, np.float64])
789+
def test_binop_typecasting(self, engine, parser, op, dt):
787790
tm.skip_if_no_ne(engine)
788791
df = mkdf(5, 3, data_gen_f=f, dtype=dt)
789792
s = 'df {} 3'.format(op)
@@ -798,15 +801,6 @@ def check_binop_typecasting(self, engine, parser, op, dt):
798801
assert res.values.dtype == dt
799802
assert_frame_equal(res, eval(s))
800803

801-
def test_binop_typecasting(self):
802-
for engine, parser in ENGINES_PARSERS:
803-
for op in ['+', '-', '*', '**', '/']:
804-
# maybe someday... numexpr has too many upcasting rules now
805-
# for dt in chain(*(np.sctypes[x] for x in ['uint', 'int',
806-
# 'float'])):
807-
for dt in [np.float32, np.float64]:
808-
yield self.check_binop_typecasting, engine, parser, op, dt
809-
810804

811805
#-------------------------------------
812806
# basic and complex alignment
@@ -826,18 +820,18 @@ class TestAlignment(object):
826820
index_types = 'i', 'u', 'dt'
827821
lhs_index_types = index_types + ('s',) # 'p'
828822

829-
def check_align_nested_unary_op(self, engine, parser):
823+
@pytest.mark.parametrize('engine', _engines)
824+
@pytest.mark.parametrize('parser', expr._parsers)
825+
def test_align_nested_unary_op(self, engine, parser):
830826
tm.skip_if_no_ne(engine)
831827
s = 'df * ~2'
832828
df = mkdf(5, 3, data_gen_f=f)
833829
res = pd.eval(s, engine=engine, parser=parser)
834830
assert_frame_equal(res, df * ~2)
835831

836-
def test_align_nested_unary_op(self):
837-
for engine, parser in ENGINES_PARSERS:
838-
yield self.check_align_nested_unary_op, engine, parser
839-
840-
def check_basic_frame_alignment(self, engine, parser):
832+
@pytest.mark.parametrize('engine', _engines)
833+
@pytest.mark.parametrize('parser', expr._parsers)
834+
def test_basic_frame_alignment(self, engine, parser):
841835
tm.skip_if_no_ne(engine)
842836
args = product(self.lhs_index_types, self.index_types,
843837
self.index_types)
@@ -856,11 +850,9 @@ def check_basic_frame_alignment(self, engine, parser):
856850
res = pd.eval('df + df2', engine=engine, parser=parser)
857851
assert_frame_equal(res, df + df2)
858852

859-
def test_basic_frame_alignment(self):
860-
for engine, parser in ENGINES_PARSERS:
861-
yield self.check_basic_frame_alignment, engine, parser
862-
863-
def check_frame_comparison(self, engine, parser):
853+
@pytest.mark.parametrize('engine', _engines)
854+
@pytest.mark.parametrize('parser', expr._parsers)
855+
def test_frame_comparison(self, engine, parser):
864856
tm.skip_if_no_ne(engine)
865857
args = product(self.lhs_index_types, repeat=2)
866858
for r_idx_type, c_idx_type in args:
@@ -874,11 +866,10 @@ def check_frame_comparison(self, engine, parser):
874866
res = pd.eval('df < df3', engine=engine, parser=parser)
875867
assert_frame_equal(res, df < df3)
876868

877-
def test_frame_comparison(self):
878-
for engine, parser in ENGINES_PARSERS:
879-
yield self.check_frame_comparison, engine, parser
880-
881-
def check_medium_complex_frame_alignment(self, engine, parser):
869+
@slow
870+
@pytest.mark.parametrize('engine', _engines)
871+
@pytest.mark.parametrize('parser', expr._parsers)
872+
def test_medium_complex_frame_alignment(self, engine, parser):
882873
tm.skip_if_no_ne(engine)
883874
args = product(self.lhs_index_types, self.index_types,
884875
self.index_types, self.index_types)
@@ -899,12 +890,9 @@ def check_medium_complex_frame_alignment(self, engine, parser):
899890
engine=engine, parser=parser)
900891
assert_frame_equal(res, df + df2 + df3)
901892

902-
@slow
903-
def test_medium_complex_frame_alignment(self):
904-
for engine, parser in ENGINES_PARSERS:
905-
yield self.check_medium_complex_frame_alignment, engine, parser
906-
907-
def check_basic_frame_series_alignment(self, engine, parser):
893+
@pytest.mark.parametrize('engine', _engines)
894+
@pytest.mark.parametrize('parser', expr._parsers)
895+
def test_basic_frame_series_alignment(self, engine, parser):
908896
tm.skip_if_no_ne(engine)
909897

910898
def testit(r_idx_type, c_idx_type, index_name):
@@ -932,11 +920,9 @@ def testit(r_idx_type, c_idx_type, index_name):
932920
for r_idx_type, c_idx_type, index_name in args:
933921
testit(r_idx_type, c_idx_type, index_name)
934922

935-
def test_basic_frame_series_alignment(self):
936-
for engine, parser in ENGINES_PARSERS:
937-
yield self.check_basic_frame_series_alignment, engine, parser
938-
939-
def check_basic_series_frame_alignment(self, engine, parser):
923+
@pytest.mark.parametrize('engine', _engines)
924+
@pytest.mark.parametrize('parser', expr._parsers)
925+
def test_basic_series_frame_alignment(self, engine, parser):
940926
tm.skip_if_no_ne(engine)
941927

942928
def testit(r_idx_type, c_idx_type, index_name):
@@ -968,11 +954,9 @@ def testit(r_idx_type, c_idx_type, index_name):
968954
for r_idx_type, c_idx_type, index_name in args:
969955
testit(r_idx_type, c_idx_type, index_name)
970956

971-
def test_basic_series_frame_alignment(self):
972-
for engine, parser in ENGINES_PARSERS:
973-
yield self.check_basic_series_frame_alignment, engine, parser
974-
975-
def check_series_frame_commutativity(self, engine, parser):
957+
@pytest.mark.parametrize('engine', _engines)
958+
@pytest.mark.parametrize('parser', expr._parsers)
959+
def test_series_frame_commutativity(self, engine, parser):
976960
tm.skip_if_no_ne(engine)
977961
args = product(self.lhs_index_types, self.index_types, ('+', '*'),
978962
('index', 'columns'))
@@ -1000,11 +984,10 @@ def check_series_frame_commutativity(self, engine, parser):
1000984
if engine == 'numexpr':
1001985
assert_frame_equal(a, b)
1002986

1003-
def test_series_frame_commutativity(self):
1004-
for engine, parser in ENGINES_PARSERS:
1005-
yield self.check_series_frame_commutativity, engine, parser
1006-
1007-
def check_complex_series_frame_alignment(self, engine, parser):
987+
@slow
988+
@pytest.mark.parametrize('engine', _engines)
989+
@pytest.mark.parametrize('parser', expr._parsers)
990+
def test_complex_series_frame_alignment(self, engine, parser):
1008991
tm.skip_if_no_ne(engine)
1009992

1010993
import random
@@ -1050,12 +1033,9 @@ def check_complex_series_frame_alignment(self, engine, parser):
10501033
tm.assert_equal(res.shape, expected.shape)
10511034
assert_frame_equal(res, expected)
10521035

1053-
@slow
1054-
def test_complex_series_frame_alignment(self):
1055-
for engine, parser in ENGINES_PARSERS:
1056-
yield self.check_complex_series_frame_alignment, engine, parser
1057-
1058-
def check_performance_warning_for_poor_alignment(self, engine, parser):
1036+
@pytest.mark.parametrize('engine', _engines)
1037+
@pytest.mark.parametrize('parser', expr._parsers)
1038+
def test_performance_warning_for_poor_alignment(self, engine, parser):
10591039
tm.skip_if_no_ne(engine)
10601040
df = DataFrame(randn(1000, 10))
10611041
s = Series(randn(10000))
@@ -1098,11 +1078,6 @@ def check_performance_warning_for_poor_alignment(self, engine, parser):
10981078
"".format(1, 'df', np.log10(s.size - df.shape[1])))
10991079
tm.assert_equal(msg, expected)
11001080

1101-
def test_performance_warning_for_poor_alignment(self):
1102-
for engine, parser in ENGINES_PARSERS:
1103-
yield (self.check_performance_warning_for_poor_alignment, engine,
1104-
parser)
1105-
11061081

11071082
#------------------------------------
11081083
# slightly more complex ops
@@ -1832,31 +1807,27 @@ def test_disallowed_nodes():
18321807
yield check_disallowed_nodes, engine, visitor
18331808

18341809

1835-
def check_syntax_error_exprs(engine, parser):
1810+
@pytest.mark.parametrize('engine', _engines)
1811+
@pytest.mark.parametrize('parser', expr._parsers)
1812+
def test_syntax_error_exprs(engine, parser):
18361813
tm.skip_if_no_ne(engine)
18371814
e = 's +'
18381815
with pytest.raises(SyntaxError):
18391816
pd.eval(e, engine=engine, parser=parser)
18401817

18411818

1842-
def test_syntax_error_exprs():
1843-
for engine, parser in ENGINES_PARSERS:
1844-
yield check_syntax_error_exprs, engine, parser
1845-
1846-
1847-
def check_name_error_exprs(engine, parser):
1819+
@pytest.mark.parametrize('engine', _engines)
1820+
@pytest.mark.parametrize('parser', expr._parsers)
1821+
def test_name_error_exprs(engine, parser):
18481822
tm.skip_if_no_ne(engine)
18491823
e = 's + t'
18501824
with tm.assertRaises(NameError):
18511825
pd.eval(e, engine=engine, parser=parser)
18521826

18531827

1854-
def test_name_error_exprs():
1855-
for engine, parser in ENGINES_PARSERS:
1856-
yield check_name_error_exprs, engine, parser
1857-
1858-
1859-
def check_invalid_local_variable_reference(engine, parser):
1828+
@pytest.mark.parametrize('engine', _engines)
1829+
@pytest.mark.parametrize('parser', expr._parsers)
1830+
def test_invalid_local_variable_reference(engine, parser):
18601831
tm.skip_if_no_ne(engine)
18611832

18621833
a, b = 1, 2
@@ -1870,12 +1841,9 @@ def check_invalid_local_variable_reference(engine, parser):
18701841
pd.eval(exprs, engine=engine, parser=parser)
18711842

18721843

1873-
def test_invalid_local_variable_reference():
1874-
for engine, parser in ENGINES_PARSERS:
1875-
yield check_invalid_local_variable_reference, engine, parser
1876-
1877-
1878-
def check_numexpr_builtin_raises(engine, parser):
1844+
@pytest.mark.parametrize('engine', _engines)
1845+
@pytest.mark.parametrize('parser', expr._parsers)
1846+
def test_numexpr_builtin_raises(engine, parser):
18791847
tm.skip_if_no_ne(engine)
18801848
sin, dotted_line = 1, 2
18811849
if engine == 'numexpr':
@@ -1887,48 +1855,34 @@ def check_numexpr_builtin_raises(engine, parser):
18871855
tm.assert_equal(res, sin + dotted_line)
18881856

18891857

1890-
def test_numexpr_builtin_raises():
1891-
for engine, parser in ENGINES_PARSERS:
1892-
yield check_numexpr_builtin_raises, engine, parser
1893-
1894-
1895-
def check_bad_resolver_raises(engine, parser):
1858+
@pytest.mark.parametrize('engine', _engines)
1859+
@pytest.mark.parametrize('parser', expr._parsers)
1860+
def test_bad_resolver_raises(engine, parser):
18961861
tm.skip_if_no_ne(engine)
18971862
cannot_resolve = 42, 3.0
18981863
with tm.assertRaisesRegexp(TypeError, 'Resolver of type .+'):
18991864
pd.eval('1 + 2', resolvers=cannot_resolve, engine=engine,
19001865
parser=parser)
19011866

19021867

1903-
def test_bad_resolver_raises():
1904-
for engine, parser in ENGINES_PARSERS:
1905-
yield check_bad_resolver_raises, engine, parser
1906-
1907-
1908-
def check_empty_string_raises(engine, parser):
1868+
@pytest.mark.parametrize('engine', _engines)
1869+
@pytest.mark.parametrize('parser', expr._parsers)
1870+
def test_empty_string_raises(engine, parser):
19091871
# GH 13139
19101872
tm.skip_if_no_ne(engine)
19111873
with tm.assertRaisesRegexp(ValueError, 'expr cannot be an empty string'):
19121874
pd.eval('', engine=engine, parser=parser)
19131875

19141876

1915-
def test_empty_string_raises():
1916-
for engine, parser in ENGINES_PARSERS:
1917-
yield check_empty_string_raises, engine, parser
1918-
1919-
1920-
def check_more_than_one_expression_raises(engine, parser):
1877+
@pytest.mark.parametrize('engine', _engines)
1878+
@pytest.mark.parametrize('parser', expr._parsers)
1879+
def test_more_than_one_expression_raises(engine, parser):
19211880
tm.skip_if_no_ne(engine)
19221881
with tm.assertRaisesRegexp(SyntaxError,
19231882
'only a single expression is allowed'):
19241883
pd.eval('1 + 1; 2 + 2', engine=engine, parser=parser)
19251884

19261885

1927-
def test_more_than_one_expression_raises():
1928-
for engine, parser in ENGINES_PARSERS:
1929-
yield check_more_than_one_expression_raises, engine, parser
1930-
1931-
19321886
def check_bool_ops_fails_on_scalars(gen, lhs, cmp, rhs, engine, parser):
19331887
tm.skip_if_no_ne(engine)
19341888
mid = gen[type(lhs)]()
@@ -1951,19 +1905,16 @@ def test_bool_ops_fails_on_scalars():
19511905
gen[dtype2](), engine, parser)
19521906

19531907

1954-
def check_inf(engine, parser):
1908+
@pytest.mark.parametrize('engine', _engines)
1909+
@pytest.mark.parametrize('parser', expr._parsers)
1910+
def test_inf(engine, parser):
19551911
tm.skip_if_no_ne(engine)
19561912
s = 'inf + 1'
19571913
expected = np.inf
19581914
result = pd.eval(s, engine=engine, parser=parser)
19591915
tm.assert_equal(result, expected)
19601916

19611917

1962-
def test_inf():
1963-
for engine, parser in ENGINES_PARSERS:
1964-
yield check_inf, engine, parser
1965-
1966-
19671918
def check_negate_lt_eq_le(engine, parser):
19681919
tm.skip_if_no_ne(engine)
19691920
df = pd.DataFrame([[0, 10], [1, 20]], columns=['cat', 'count'])

0 commit comments

Comments
 (0)