From 967b1f7596ba78fab31f9e71cae948ab8dd7d6d1 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:22:03 -0700 Subject: [PATCH 01/15] AttributeError instead of Exception --- pandas/tests/io/excel/test_xlsxwriter.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pandas/tests/io/excel/test_xlsxwriter.py b/pandas/tests/io/excel/test_xlsxwriter.py index 4dae3db2e7abd..63e41c59ecb89 100644 --- a/pandas/tests/io/excel/test_xlsxwriter.py +++ b/pandas/tests/io/excel/test_xlsxwriter.py @@ -50,7 +50,7 @@ def test_column_format(ext): try: read_num_format = cell.number_format - except Exception: + except AttributeError: read_num_format = cell.style.number_format._format_code assert read_num_format == num_format From 1bf4fd22b5ae77fbb69b5c39adb013321f3860a6 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:24:47 -0700 Subject: [PATCH 02/15] CLN: cleanup test --- pandas/tests/test_expressions.py | 70 +++++++++++++------------------- 1 file changed, 29 insertions(+), 41 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 4c977d7fbc609..cfa8153bc9429 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -56,7 +56,7 @@ def setup_method(self, method): def teardown_method(self, method): expr._MIN_ELEMENTS = self._MIN_ELEMENTS - def run_arithmetic(self, df, other, assert_func, check_dtype=False, test_flex=True): + def run_arithmetic(self, df, other, check_dtype=False, test_flex=True): expr._MIN_ELEMENTS = 0 operations = ["add", "sub", "mul", "mod", "truediv", "floordiv"] for arith in operations: @@ -75,21 +75,16 @@ def run_arithmetic(self, df, other, assert_func, check_dtype=False, test_flex=Tr expr.set_use_numexpr(True) result = op(df, other) - try: - if check_dtype: - if arith == "truediv": - assert expected.dtype.kind == "f" - assert_func(expected, result) - except Exception: - pprint_thing("Failed test with operator {op.__name__!r}".format(op=op)) - raise + if check_dtype: + if arith == "truediv": + assert expected.dtype.kind == "f" + tm.assert_equal(expected, result) def test_integer_arithmetic(self): - self.run_arithmetic(self.integer, self.integer, assert_frame_equal) + self.run_arithmetic(self.integer, self.integer) self.run_arithmetic( self.integer.iloc[:, 0], self.integer.iloc[:, 0], - assert_series_equal, check_dtype=True, ) @@ -134,8 +129,8 @@ def run_binary( raise def run_frame(self, df, other, binary_comp=None, run_binary=True, **kwargs): - self.run_arithmetic(df, other, assert_frame_equal, test_flex=False, **kwargs) - self.run_arithmetic(df, other, assert_frame_equal, test_flex=True, **kwargs) + self.run_arithmetic(df, other, test_flex=False, **kwargs) + self.run_arithmetic(df, other, test_flex=True, **kwargs) if run_binary: if binary_comp is None: expr.set_use_numexpr(False) @@ -148,9 +143,9 @@ def run_frame(self, df, other, binary_comp=None, run_binary=True, **kwargs): df, binary_comp, assert_frame_equal, test_flex=True, **kwargs ) - def run_series(self, ser, other, binary_comp=None, **kwargs): - self.run_arithmetic(ser, other, assert_series_equal, test_flex=False, **kwargs) - self.run_arithmetic(ser, other, assert_almost_equal, test_flex=True, **kwargs) + def run_series(self, ser, other): + self.run_arithmetic(ser, other, test_flex=False) + self.run_arithmetic(ser, other, test_flex=True) # FIXME: dont leave commented-out # series doesn't uses vec_compare instead of numexpr... # if binary_comp is None: @@ -180,28 +175,21 @@ def test_mixed_arithmetic_frame(self): def test_mixed_arithmetic_series(self): for col in self.mixed2.columns: - self.run_series(self.mixed2[col], self.mixed2[col], binary_comp=4) + self.run_series(self.mixed2[col], self.mixed2[col]) def test_float_arithemtic(self): - self.run_arithmetic(self.frame, self.frame, assert_frame_equal) - self.run_arithmetic( - self.frame.iloc[:, 0], - self.frame.iloc[:, 0], - assert_series_equal, - check_dtype=True, - ) + self.run_arithmetic(self.frame, self.frame) + self.run_arithmetic(self.frame.iloc[:, 0], self.frame.iloc[:, 0], check_dtype=True,) def test_mixed_arithmetic(self): - self.run_arithmetic(self.mixed, self.mixed, assert_frame_equal) + self.run_arithmetic(self.mixed, self.mixed) for col in self.mixed.columns: - self.run_arithmetic(self.mixed[col], self.mixed[col], assert_series_equal) + self.run_arithmetic(self.mixed[col], self.mixed[col]) def test_integer_with_zeros(self): self.integer *= np.random.randint(0, 2, size=np.shape(self.integer)) - self.run_arithmetic(self.integer, self.integer, assert_frame_equal) - self.run_arithmetic( - self.integer.iloc[:, 0], self.integer.iloc[:, 0], assert_series_equal - ) + self.run_arithmetic(self.integer, self.integer) + self.run_arithmetic(self.integer.iloc[:, 0], self.integer.iloc[:, 0]) def test_invalid(self): @@ -245,20 +233,20 @@ def testit(): op = getattr(operator, "truediv", None) else: op = getattr(operator, opname, None) - if op is not None: - result = expr._can_use_numexpr(op, op_str, f, f, "evaluate") - assert result != f._is_mixed_type + + result = expr._can_use_numexpr(op, op_str, f, f, "evaluate") + assert result != f._is_mixed_type - result = expr.evaluate(op, op_str, f, f, use_numexpr=True) - expected = expr.evaluate(op, op_str, f, f, use_numexpr=False) + result = expr.evaluate(op, op_str, f, f, use_numexpr=True) + expected = expr.evaluate(op, op_str, f, f, use_numexpr=False) - if isinstance(result, DataFrame): - tm.assert_frame_equal(result, expected) - else: - tm.assert_numpy_array_equal(result, expected.values) + if isinstance(result, DataFrame): + tm.assert_frame_equal(result, expected) + else: + tm.assert_numpy_array_equal(result, expected.values) - result = expr._can_use_numexpr(op, op_str, f2, f2, "evaluate") - assert not result + result = expr._can_use_numexpr(op, op_str, f2, f2, "evaluate") + assert not result expr.set_use_numexpr(False) testit() From be53645bad2f8e23f07b91439231f567257485ef Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:27:52 -0700 Subject: [PATCH 03/15] CLN test --- pandas/tests/test_expressions.py | 33 +++++++++++--------------------- 1 file changed, 11 insertions(+), 22 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index cfa8153bc9429..86c8e44e00ef9 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -92,7 +92,6 @@ def run_binary( self, df, other, - assert_func, test_flex=False, numexpr_ops={"gt", "lt", "ge", "le", "eq", "ne"}, ): @@ -117,16 +116,11 @@ def run_binary( expr.get_test_result() result = op(df, other) used_numexpr = expr.get_test_result() - try: - if arith in numexpr_ops: - assert used_numexpr, "Did not use numexpr as expected." - else: - assert not used_numexpr, "Used numexpr unexpectedly." - assert_func(expected, result) - except Exception: - pprint_thing("Failed test with operation {arith!r}".format(arith=arith)) - pprint_thing("test_flex was {test_flex!r}".format(test_flex=test_flex)) - raise + if arith in numexpr_ops: + assert used_numexpr, "Did not use numexpr as expected." + else: + assert not used_numexpr, "Used numexpr unexpectedly." + tm.assert_equal(expected, result) def run_frame(self, df, other, binary_comp=None, run_binary=True, **kwargs): self.run_arithmetic(df, other, test_flex=False, **kwargs) @@ -137,10 +131,10 @@ def run_frame(self, df, other, binary_comp=None, run_binary=True, **kwargs): binary_comp = other + 1 expr.set_use_numexpr(True) self.run_binary( - df, binary_comp, assert_frame_equal, test_flex=False, **kwargs + df, binary_comp, test_flex=False, **kwargs ) self.run_binary( - df, binary_comp, assert_frame_equal, test_flex=True, **kwargs + df, binary_comp, test_flex=True, **kwargs ) def run_series(self, ser, other): @@ -150,10 +144,8 @@ def run_series(self, ser, other): # series doesn't uses vec_compare instead of numexpr... # if binary_comp is None: # binary_comp = other + 1 - # self.run_binary(ser, binary_comp, assert_frame_equal, - # test_flex=False, **kwargs) - # self.run_binary(ser, binary_comp, assert_frame_equal, - # test_flex=True, **kwargs) + # self.run_binary(ser, binary_comp, test_flex=False, **kwargs) + # self.run_binary(ser, binary_comp, test_flex=True, **kwargs) def test_integer_arithmetic_frame(self): self.run_frame(self.integer, self.integer) @@ -219,7 +211,7 @@ def test_invalid(self): @pytest.mark.parametrize( "opname,op_str", - [("add", "+"), ("sub", "-"), ("mul", "*"), ("div", "/"), ("pow", "**")], + [("add", "+"), ("sub", "-"), ("mul", "*"), ("truediv", "/"), ("pow", "**")], ) def test_binary_ops(self, opname, op_str): def testit(): @@ -229,10 +221,7 @@ def testit(): if opname == "pow": continue - if opname == "div": - op = getattr(operator, "truediv", None) - else: - op = getattr(operator, opname, None) + op = getattr(operator, opname) result = expr._can_use_numexpr(op, op_str, f, f, "evaluate") assert result != f._is_mixed_type From 86e096aa601346b091b9f021e00ef212bc6d710f Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:32:01 -0700 Subject: [PATCH 04/15] TST CLN --- pandas/tests/test_expressions.py | 44 ++++++++++++-------------------- 1 file changed, 17 insertions(+), 27 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 86c8e44e00ef9..24f12b43a6f87 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -9,13 +9,9 @@ from pandas.core.computation import expressions as expr import pandas.util.testing as tm from pandas.util.testing import ( - assert_almost_equal, assert_frame_equal, - assert_series_equal, ) -from pandas.io.formats.printing import pprint_thing - _frame = DataFrame(randn(10000, 4), columns=list("ABCD"), dtype="float64") _frame2 = DataFrame(randn(100, 4), columns=list("ABCD"), dtype="float64") _mixed = DataFrame( @@ -83,9 +79,7 @@ def run_arithmetic(self, df, other, check_dtype=False, test_flex=True): def test_integer_arithmetic(self): self.run_arithmetic(self.integer, self.integer) self.run_arithmetic( - self.integer.iloc[:, 0], - self.integer.iloc[:, 0], - check_dtype=True, + self.integer.iloc[:, 0], self.integer.iloc[:, 0], check_dtype=True ) def run_binary( @@ -93,7 +87,6 @@ def run_binary( df, other, test_flex=False, - numexpr_ops={"gt", "lt", "ge", "le", "eq", "ne"}, ): """ tests solely that the result is the same whether or not numexpr is @@ -103,6 +96,7 @@ def run_binary( expr._MIN_ELEMENTS = 0 expr.set_test_mode(True) operations = ["gt", "lt", "ge", "le", "eq", "ne"] + numexpr_ops = {"gt", "lt", "ge", "le", "eq", "ne"} for arith in operations: if test_flex: @@ -122,30 +116,24 @@ def run_binary( assert not used_numexpr, "Used numexpr unexpectedly." tm.assert_equal(expected, result) - def run_frame(self, df, other, binary_comp=None, run_binary=True, **kwargs): - self.run_arithmetic(df, other, test_flex=False, **kwargs) - self.run_arithmetic(df, other, test_flex=True, **kwargs) + def run_frame(self, df, other, run_binary=True): + self.run_arithmetic(df, other, test_flex=False) + self.run_arithmetic(df, other, test_flex=True) if run_binary: - if binary_comp is None: - expr.set_use_numexpr(False) - binary_comp = other + 1 - expr.set_use_numexpr(True) - self.run_binary( - df, binary_comp, test_flex=False, **kwargs - ) - self.run_binary( - df, binary_comp, test_flex=True, **kwargs - ) + expr.set_use_numexpr(False) + binary_comp = other + 1 + expr.set_use_numexpr(True) + self.run_binary(df, binary_comp, test_flex=False) + self.run_binary(df, binary_comp, test_flex=True) def run_series(self, ser, other): self.run_arithmetic(ser, other, test_flex=False) self.run_arithmetic(ser, other, test_flex=True) # FIXME: dont leave commented-out # series doesn't uses vec_compare instead of numexpr... - # if binary_comp is None: - # binary_comp = other + 1 - # self.run_binary(ser, binary_comp, test_flex=False, **kwargs) - # self.run_binary(ser, binary_comp, test_flex=True, **kwargs) + # binary_comp = other + 1 + # self.run_binary(ser, binary_comp, test_flex=False) + # self.run_binary(ser, binary_comp, test_flex=True) def test_integer_arithmetic_frame(self): self.run_frame(self.integer, self.integer) @@ -171,7 +159,9 @@ def test_mixed_arithmetic_series(self): def test_float_arithemtic(self): self.run_arithmetic(self.frame, self.frame) - self.run_arithmetic(self.frame.iloc[:, 0], self.frame.iloc[:, 0], check_dtype=True,) + self.run_arithmetic( + self.frame.iloc[:, 0], self.frame.iloc[:, 0], check_dtype=True + ) def test_mixed_arithmetic(self): self.run_arithmetic(self.mixed, self.mixed) @@ -222,7 +212,7 @@ def testit(): continue op = getattr(operator, opname) - + result = expr._can_use_numexpr(op, op_str, f, f, "evaluate") assert result != f._is_mixed_type From 2b911d661e339c5a9def3a1b7af01d76a02dd923 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:35:06 -0700 Subject: [PATCH 05/15] TST CLN --- pandas/tests/test_expressions.py | 19 +++---------------- 1 file changed, 3 insertions(+), 16 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 24f12b43a6f87..c21ce78742817 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -8,9 +8,7 @@ from pandas.core.api import DataFrame from pandas.core.computation import expressions as expr import pandas.util.testing as tm -from pandas.util.testing import ( - assert_frame_equal, -) +from pandas.util.testing import assert_frame_equal _frame = DataFrame(randn(10000, 4), columns=list("ABCD"), dtype="float64") _frame2 = DataFrame(randn(100, 4), columns=list("ABCD"), dtype="float64") @@ -58,8 +56,6 @@ def run_arithmetic(self, df, other, check_dtype=False, test_flex=True): for arith in operations: operator_name = arith - if arith == "div": - operator_name = "truediv" if test_flex: op = lambda x, y: getattr(x, arith)(y) @@ -82,12 +78,7 @@ def test_integer_arithmetic(self): self.integer.iloc[:, 0], self.integer.iloc[:, 0], check_dtype=True ) - def run_binary( - self, - df, - other, - test_flex=False, - ): + def run_binary(self, df, other, test_flex=False): """ tests solely that the result is the same whether or not numexpr is enabled. Need to test whether the function does the correct thing @@ -96,7 +87,6 @@ def run_binary( expr._MIN_ELEMENTS = 0 expr.set_test_mode(True) operations = ["gt", "lt", "ge", "le", "eq", "ne"] - numexpr_ops = {"gt", "lt", "ge", "le", "eq", "ne"} for arith in operations: if test_flex: @@ -110,10 +100,7 @@ def run_binary( expr.get_test_result() result = op(df, other) used_numexpr = expr.get_test_result() - if arith in numexpr_ops: - assert used_numexpr, "Did not use numexpr as expected." - else: - assert not used_numexpr, "Used numexpr unexpectedly." + assert used_numexpr, "Did not use numexpr as expected." tm.assert_equal(expected, result) def run_frame(self, df, other, run_binary=True): From 143d84782ac4d1bec4b075d2cb76736426db6610 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:38:31 -0700 Subject: [PATCH 06/15] CLN TST --- pandas/tests/test_expressions.py | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index c21ce78742817..7a166d127d211 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -50,7 +50,7 @@ def setup_method(self, method): def teardown_method(self, method): expr._MIN_ELEMENTS = self._MIN_ELEMENTS - def run_arithmetic(self, df, other, check_dtype=False, test_flex=True): + def run_arithmetic(self, df, other, test_flex=True): expr._MIN_ELEMENTS = 0 operations = ["add", "sub", "mul", "mod", "truediv", "floordiv"] for arith in operations: @@ -67,16 +67,16 @@ def run_arithmetic(self, df, other, check_dtype=False, test_flex=True): expr.set_use_numexpr(True) result = op(df, other) - if check_dtype: - if arith == "truediv": + if arith == "truediv": + if expected.ndim == 1: assert expected.dtype.kind == "f" + else: + assert all(x.kind == "f" for x in expected.dtypes.values) tm.assert_equal(expected, result) def test_integer_arithmetic(self): self.run_arithmetic(self.integer, self.integer) - self.run_arithmetic( - self.integer.iloc[:, 0], self.integer.iloc[:, 0], check_dtype=True - ) + self.run_arithmetic(self.integer.iloc[:, 0], self.integer.iloc[:, 0]) def run_binary(self, df, other, test_flex=False): """ @@ -146,9 +146,7 @@ def test_mixed_arithmetic_series(self): def test_float_arithemtic(self): self.run_arithmetic(self.frame, self.frame) - self.run_arithmetic( - self.frame.iloc[:, 0], self.frame.iloc[:, 0], check_dtype=True - ) + self.run_arithmetic(self.frame.iloc[:, 0], self.frame.iloc[:, 0]) def test_mixed_arithmetic(self): self.run_arithmetic(self.mixed, self.mixed) From 61626b15845179fc49b80ece35ecf0deaf4901a1 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:42:00 -0700 Subject: [PATCH 07/15] TST CLN --- pandas/tests/test_expressions.py | 43 ++++++++++++++++---------------- 1 file changed, 21 insertions(+), 22 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 7a166d127d211..cce7533b889ea 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -50,29 +50,30 @@ def setup_method(self, method): def teardown_method(self, method): expr._MIN_ELEMENTS = self._MIN_ELEMENTS - def run_arithmetic(self, df, other, test_flex=True): + def run_arithmetic(self, df, other): expr._MIN_ELEMENTS = 0 operations = ["add", "sub", "mul", "mod", "truediv", "floordiv"] - for arith in operations: - - operator_name = arith + for test_flex in [True, False]: + for arith in operations: - if test_flex: - op = lambda x, y: getattr(x, arith)(y) - op.__name__ = arith - else: - op = getattr(operator, operator_name) - expr.set_use_numexpr(False) - expected = op(df, other) - expr.set_use_numexpr(True) + operator_name = arith - result = op(df, other) - if arith == "truediv": - if expected.ndim == 1: - assert expected.dtype.kind == "f" + if test_flex: + op = lambda x, y: getattr(x, arith)(y) + op.__name__ = arith else: - assert all(x.kind == "f" for x in expected.dtypes.values) - tm.assert_equal(expected, result) + op = getattr(operator, operator_name) + expr.set_use_numexpr(False) + expected = op(df, other) + expr.set_use_numexpr(True) + + result = op(df, other) + if arith == "truediv": + if expected.ndim == 1: + assert expected.dtype.kind == "f" + else: + assert all(x.kind == "f" for x in expected.dtypes.values) + tm.assert_equal(expected, result) def test_integer_arithmetic(self): self.run_arithmetic(self.integer, self.integer) @@ -104,8 +105,7 @@ def run_binary(self, df, other, test_flex=False): tm.assert_equal(expected, result) def run_frame(self, df, other, run_binary=True): - self.run_arithmetic(df, other, test_flex=False) - self.run_arithmetic(df, other, test_flex=True) + self.run_arithmetic(df, other) if run_binary: expr.set_use_numexpr(False) binary_comp = other + 1 @@ -114,8 +114,7 @@ def run_frame(self, df, other, run_binary=True): self.run_binary(df, binary_comp, test_flex=True) def run_series(self, ser, other): - self.run_arithmetic(ser, other, test_flex=False) - self.run_arithmetic(ser, other, test_flex=True) + self.run_arithmetic(ser, other) # FIXME: dont leave commented-out # series doesn't uses vec_compare instead of numexpr... # binary_comp = other + 1 From 661e001f5eb3cda0f5ec9bed121ea501bcc0b165 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:44:28 -0700 Subject: [PATCH 08/15] CLN TST --- pandas/tests/test_expressions.py | 37 ++++++++++++++++---------------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index cce7533b889ea..a4fd960ea5872 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -79,7 +79,7 @@ def test_integer_arithmetic(self): self.run_arithmetic(self.integer, self.integer) self.run_arithmetic(self.integer.iloc[:, 0], self.integer.iloc[:, 0]) - def run_binary(self, df, other, test_flex=False): + def run_binary(self, df, other): """ tests solely that the result is the same whether or not numexpr is enabled. Need to test whether the function does the correct thing @@ -89,20 +89,21 @@ def run_binary(self, df, other, test_flex=False): expr.set_test_mode(True) operations = ["gt", "lt", "ge", "le", "eq", "ne"] - for arith in operations: - if test_flex: - op = lambda x, y: getattr(df, arith)(y) - op.__name__ = arith - else: - op = getattr(operator, arith) - expr.set_use_numexpr(False) - expected = op(df, other) - expr.set_use_numexpr(True) - expr.get_test_result() - result = op(df, other) - used_numexpr = expr.get_test_result() - assert used_numexpr, "Did not use numexpr as expected." - tm.assert_equal(expected, result) + for test_flex in [True, False]: + for arith in operations: + if test_flex: + op = lambda x, y: getattr(df, arith)(y) + op.__name__ = arith + else: + op = getattr(operator, arith) + expr.set_use_numexpr(False) + expected = op(df, other) + expr.set_use_numexpr(True) + expr.get_test_result() + result = op(df, other) + used_numexpr = expr.get_test_result() + assert used_numexpr, "Did not use numexpr as expected." + tm.assert_equal(expected, result) def run_frame(self, df, other, run_binary=True): self.run_arithmetic(df, other) @@ -110,16 +111,14 @@ def run_frame(self, df, other, run_binary=True): expr.set_use_numexpr(False) binary_comp = other + 1 expr.set_use_numexpr(True) - self.run_binary(df, binary_comp, test_flex=False) - self.run_binary(df, binary_comp, test_flex=True) + self.run_binary(df, binary_comp) def run_series(self, ser, other): self.run_arithmetic(ser, other) # FIXME: dont leave commented-out # series doesn't uses vec_compare instead of numexpr... # binary_comp = other + 1 - # self.run_binary(ser, binary_comp, test_flex=False) - # self.run_binary(ser, binary_comp, test_flex=True) + # self.run_binary(ser, binary_comp) def test_integer_arithmetic_frame(self): self.run_frame(self.integer, self.integer) From 853794194d8f764f9d855e773e155b2e6a65294f Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:54:32 -0700 Subject: [PATCH 09/15] CLN TST --- pandas/tests/test_expressions.py | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index a4fd960ea5872..bb409163b69b4 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -130,26 +130,32 @@ def test_float_arithemtic_frame(self): self.run_frame(self.frame2, self.frame2) def test_float_arithmetic_series(self): - self.run_series(self.frame2.iloc[:, 0], self.frame2.iloc[:, 0]) + df = self.frame2 + self.run_series(df.iloc[:, 0], df.iloc[:, 0]) def test_mixed_arithmetic_frame(self): # TODO: FIGURE OUT HOW TO GET IT TO WORK... # can't do arithmetic because comparison methods try to do *entire* # frame instead of by-column - self.run_frame(self.mixed2, self.mixed2, run_binary=False) + df = self.mixed2 + self.run_frame(df, df, run_binary=False) def test_mixed_arithmetic_series(self): - for col in self.mixed2.columns: - self.run_series(self.mixed2[col], self.mixed2[col]) + df = self.mixed2 + for i in range(len(df.columns)): + self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_float_arithemtic(self): - self.run_arithmetic(self.frame, self.frame) - self.run_arithmetic(self.frame.iloc[:, 0], self.frame.iloc[:, 0]) + df = self.frame + self.run_arithmetic(df, df) + for i in range(len(df.columns)): + self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_mixed_arithmetic(self): - self.run_arithmetic(self.mixed, self.mixed) - for col in self.mixed.columns: - self.run_arithmetic(self.mixed[col], self.mixed[col]) + df = self.mixed + self.run_arithmetic(df, df) + for i in range(len(df.columns)): + self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_integer_with_zeros(self): self.integer *= np.random.randint(0, 2, size=np.shape(self.integer)) From 95f38e1c15ba00b5871b75b23b825424d64129e3 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 19:56:48 -0700 Subject: [PATCH 10/15] TST CLN --- pandas/tests/test_expressions.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index bb409163b69b4..61aeb967cfaec 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -76,8 +76,10 @@ def run_arithmetic(self, df, other): tm.assert_equal(expected, result) def test_integer_arithmetic(self): - self.run_arithmetic(self.integer, self.integer) - self.run_arithmetic(self.integer.iloc[:, 0], self.integer.iloc[:, 0]) + df = self.integer + self.run_arithmetic(df, df) + for i in range(len(df.columns)): + self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def run_binary(self, df, other): """ From 4c79b4b46a965d7e1fa7e70d2809b107cade7ebd Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 20:02:19 -0700 Subject: [PATCH 11/15] TST CLN --- pandas/tests/test_expressions.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 61aeb967cfaec..d9d26060788f8 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -77,7 +77,7 @@ def run_arithmetic(self, df, other): def test_integer_arithmetic(self): df = self.integer - self.run_arithmetic(df, df) + self.run_frame(df, df) for i in range(len(df.columns)): self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) @@ -129,7 +129,10 @@ def test_integer_arithmetic_series(self): self.run_series(self.integer.iloc[:, 0], self.integer.iloc[:, 0]) def test_float_arithemtic_frame(self): - self.run_frame(self.frame2, self.frame2) + df = self.frame2 + self.run_frame(df, df) + for i in range(len(df.columns)): + self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_float_arithmetic_series(self): df = self.frame2 @@ -141,6 +144,8 @@ def test_mixed_arithmetic_frame(self): # frame instead of by-column df = self.mixed2 self.run_frame(df, df, run_binary=False) + for i in range(len(df.columns)): + self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_mixed_arithmetic_series(self): df = self.mixed2 @@ -160,9 +165,10 @@ def test_mixed_arithmetic(self): self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_integer_with_zeros(self): - self.integer *= np.random.randint(0, 2, size=np.shape(self.integer)) - self.run_arithmetic(self.integer, self.integer) - self.run_arithmetic(self.integer.iloc[:, 0], self.integer.iloc[:, 0]) + df = self.integer * np.random.randint(0, 2, size=np.shape(self.integer)) + self.run_arithmetic(df, df) + for i in range(len(df.columns)): + self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_invalid(self): From 09cf5080982273998c2e26d2804381d8b51d868e Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 20:08:50 -0700 Subject: [PATCH 12/15] TST: dedup --- pandas/tests/test_expressions.py | 32 +++++++++++--------------------- 1 file changed, 11 insertions(+), 21 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index d9d26060788f8..f852b1e505d62 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -78,8 +78,6 @@ def run_arithmetic(self, df, other): def test_integer_arithmetic(self): df = self.integer self.run_frame(df, df) - for i in range(len(df.columns)): - self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def run_binary(self, df, other): """ @@ -115,28 +113,20 @@ def run_frame(self, df, other, run_binary=True): expr.set_use_numexpr(True) self.run_binary(df, binary_comp) - def run_series(self, ser, other): - self.run_arithmetic(ser, other) - # FIXME: dont leave commented-out - # series doesn't uses vec_compare instead of numexpr... - # binary_comp = other + 1 - # self.run_binary(ser, binary_comp) - - def test_integer_arithmetic_frame(self): - self.run_frame(self.integer, self.integer) - - def test_integer_arithmetic_series(self): - self.run_series(self.integer.iloc[:, 0], self.integer.iloc[:, 0]) - - def test_float_arithemtic_frame(self): - df = self.frame2 - self.run_frame(df, df) for i in range(len(df.columns)): - self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) + self.run_arithmetic(df.iloc[:, i], other.iloc[:, i]) + # FIXME: dont leave commented-out + # series doesn't uses vec_compare instead of numexpr... + # binary_comp = other.iloc[:, i] + 1 + # self.run_binary(df.iloc[:, i], binary_comp) + + def test_integer_arithmetic2(self): + df = _integer2 + self.run_frame(df, df) - def test_float_arithmetic_series(self): + def test_float_arithmetic(self): df = self.frame2 - self.run_series(df.iloc[:, 0], df.iloc[:, 0]) + self.run_frame(df, df) def test_mixed_arithmetic_frame(self): # TODO: FIGURE OUT HOW TO GET IT TO WORK... From ef818d21ca8fe947baac66411250243ad471bd16 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 20:11:44 -0700 Subject: [PATCH 13/15] parametrize --- pandas/tests/test_expressions.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index f852b1e505d62..5c7cdc1b5cf24 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -44,7 +44,6 @@ def setup_method(self, method): self.frame2 = _frame2.copy() self.mixed = _mixed.copy() self.mixed2 = _mixed2.copy() - self.integer = _integer.copy() self._MIN_ELEMENTS = expr._MIN_ELEMENTS def teardown_method(self, method): @@ -75,10 +74,6 @@ def run_arithmetic(self, df, other): assert all(x.kind == "f" for x in expected.dtypes.values) tm.assert_equal(expected, result) - def test_integer_arithmetic(self): - df = self.integer - self.run_frame(df, df) - def run_binary(self, df, other): """ tests solely that the result is the same whether or not numexpr is @@ -120,8 +115,16 @@ def run_frame(self, df, other, run_binary=True): # binary_comp = other.iloc[:, i] + 1 # self.run_binary(df.iloc[:, i], binary_comp) - def test_integer_arithmetic2(self): - df = _integer2 + @pytest.mark.parametrize( + "df", + [ + _integer, + _integer2, + # randint to get a case with zeros + _integer * np.random.randint(0, 2, size=np.shape(_integer)), + ], + ) + def test_integer_arithmetic(self, df): self.run_frame(df, df) def test_float_arithmetic(self): @@ -155,7 +158,7 @@ def test_mixed_arithmetic(self): self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) def test_integer_with_zeros(self): - df = self.integer * np.random.randint(0, 2, size=np.shape(self.integer)) + df = _integer * np.random.randint(0, 2, size=np.shape(_integer)) self.run_arithmetic(df, df) for i in range(len(df.columns)): self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) From de2fe71b6ccac5bc9ddb5c18d1cbee3d5cfa63a7 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Tue, 17 Sep 2019 20:17:58 -0700 Subject: [PATCH 14/15] TST: parametrize --- pandas/tests/test_expressions.py | 44 +++++++------------------------- 1 file changed, 9 insertions(+), 35 deletions(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 5c7cdc1b5cf24..822906e2daa82 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -122,46 +122,20 @@ def run_frame(self, df, other, run_binary=True): _integer2, # randint to get a case with zeros _integer * np.random.randint(0, 2, size=np.shape(_integer)), + _frame, + _frame2, + _mixed, + _mixed2, ], ) - def test_integer_arithmetic(self, df): - self.run_frame(df, df) - - def test_float_arithmetic(self): - df = self.frame2 - self.run_frame(df, df) - - def test_mixed_arithmetic_frame(self): - # TODO: FIGURE OUT HOW TO GET IT TO WORK... + def test_arithmetic(self, df): + # TODO: FIGURE OUT HOW TO GET RUN_BINARY TO WORK WITH MIXED=... # can't do arithmetic because comparison methods try to do *entire* # frame instead of by-column - df = self.mixed2 - self.run_frame(df, df, run_binary=False) - for i in range(len(df.columns)): - self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) + kinds = set(x.kind for x in df.dtypes.values) + should = len(kinds) == 1 - def test_mixed_arithmetic_series(self): - df = self.mixed2 - for i in range(len(df.columns)): - self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) - - def test_float_arithemtic(self): - df = self.frame - self.run_arithmetic(df, df) - for i in range(len(df.columns)): - self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) - - def test_mixed_arithmetic(self): - df = self.mixed - self.run_arithmetic(df, df) - for i in range(len(df.columns)): - self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) - - def test_integer_with_zeros(self): - df = _integer * np.random.randint(0, 2, size=np.shape(_integer)) - self.run_arithmetic(df, df) - for i in range(len(df.columns)): - self.run_arithmetic(df.iloc[:, i], df.iloc[:, i]) + self.run_frame(df, df, run_binary=should) def test_invalid(self): From 3f2ef966a9101a40f84aef39d2c415a21fe15d74 Mon Sep 17 00:00:00 2001 From: jbrockmendel Date: Wed, 18 Sep 2019 07:30:22 -0700 Subject: [PATCH 15/15] CLN: use set comprehension --- pandas/tests/test_expressions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 822906e2daa82..b11698bf89cda 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -132,7 +132,7 @@ def test_arithmetic(self, df): # TODO: FIGURE OUT HOW TO GET RUN_BINARY TO WORK WITH MIXED=... # can't do arithmetic because comparison methods try to do *entire* # frame instead of by-column - kinds = set(x.kind for x in df.dtypes.values) + kinds = {x.kind for x in df.dtypes.values} should = len(kinds) == 1 self.run_frame(df, df, run_binary=should)