MAINT: Remove self.assertEqual from testing

Author: gfyoung

pandas/compat/__init__.py

@@ -104,6 +104,7 @@ def signature(f):
     map = map
     zip = zip
     filter = filter
+    intern = sys.intern
     reduce = functools.reduce
     long = int
     unichr = chr
@@ -146,6 +147,7 @@ def signature(f):
 
     # import iterator versions of these functions
     range = xrange
+    intern = intern
     zip = itertools.izip
     filter = itertools.ifilter
     map = itertools.imap

pandas/tests/computation/test_eval.py

@@ -209,7 +209,7 @@ def check_equal(self, result, expected):
         elif isinstance(result, np.ndarray):
             tm.assert_numpy_array_equal(result, expected)
         else:
-            self.assertEqual(result, expected)
+            assert result == expected
 
     def check_complex_cmp_op(self, lhs, cmp1, rhs, binop, cmp2):
         skip_these = _scalar_skip
@@ -610,30 +610,28 @@ def test_scalar_unary(self):
         with pytest.raises(TypeError):
             pd.eval('~1.0', engine=self.engine, parser=self.parser)
 
-        self.assertEqual(
-            pd.eval('-1.0', parser=self.parser, engine=self.engine), -1.0)
-        self.assertEqual(
-            pd.eval('+1.0', parser=self.parser, engine=self.engine), +1.0)
-
-        self.assertEqual(
-            pd.eval('~1', parser=self.parser, engine=self.engine), ~1)
-        self.assertEqual(
-            pd.eval('-1', parser=self.parser, engine=self.engine), -1)
-        self.assertEqual(
-            pd.eval('+1', parser=self.parser, engine=self.engine), +1)
-
-        self.assertEqual(
-            pd.eval('~True', parser=self.parser, engine=self.engine), ~True)
-        self.assertEqual(
-            pd.eval('~False', parser=self.parser, engine=self.engine), ~False)
-        self.assertEqual(
-            pd.eval('-True', parser=self.parser, engine=self.engine), -True)
-        self.assertEqual(
-            pd.eval('-False', parser=self.parser, engine=self.engine), -False)
-        self.assertEqual(
-            pd.eval('+True', parser=self.parser, engine=self.engine), +True)
-        self.assertEqual(
-            pd.eval('+False', parser=self.parser, engine=self.engine), +False)
+        assert pd.eval('-1.0', parser=self.parser,
+                       engine=self.engine) == -1.0
+        assert pd.eval('+1.0', parser=self.parser,
+                       engine=self.engine) == +1.0
+        assert pd.eval('~1', parser=self.parser,
+                       engine=self.engine) == ~1
+        assert pd.eval('-1', parser=self.parser,
+                       engine=self.engine) == -1
+        assert pd.eval('+1', parser=self.parser,
+                       engine=self.engine) == +1
+        assert pd.eval('~True', parser=self.parser,
+                       engine=self.engine) == ~True
+        assert pd.eval('~False', parser=self.parser,
+                       engine=self.engine) == ~False
+        assert pd.eval('-True', parser=self.parser,
+                       engine=self.engine) == -True
+        assert pd.eval('-False', parser=self.parser,
+                       engine=self.engine) == -False
+        assert pd.eval('+True', parser=self.parser,
+                       engine=self.engine) == +True
+        assert pd.eval('+False', parser=self.parser,
+                       engine=self.engine) == +False
 
     def test_unary_in_array(self):
         # GH 11235
@@ -661,47 +659,47 @@ def test_identical(self):
         # GH 10546
         x = 1
         result = pd.eval('x', engine=self.engine, parser=self.parser)
-        self.assertEqual(result, 1)
+        assert result == 1
         assert is_scalar(result)
 
         x = 1.5
         result = pd.eval('x', engine=self.engine, parser=self.parser)
-        self.assertEqual(result, 1.5)
+        assert result == 1.5
         assert is_scalar(result)
 
         x = False
         result = pd.eval('x', engine=self.engine, parser=self.parser)
-        self.assertEqual(result, False)
+        assert result is False
         assert is_scalar(result)
 
         x = np.array([1])
         result = pd.eval('x', engine=self.engine, parser=self.parser)
         tm.assert_numpy_array_equal(result, np.array([1]))
-        self.assertEqual(result.shape, (1, ))
+        assert result.shape == (1, )
 
         x = np.array([1.5])
         result = pd.eval('x', engine=self.engine, parser=self.parser)
         tm.assert_numpy_array_equal(result, np.array([1.5]))
-        self.assertEqual(result.shape, (1, ))
+        assert result.shape == (1, )
 
         x = np.array([False])  # noqa
         result = pd.eval('x', engine=self.engine, parser=self.parser)
         tm.assert_numpy_array_equal(result, np.array([False]))
-        self.assertEqual(result.shape, (1, ))
+        assert result.shape == (1, )
 
     def test_line_continuation(self):
         # GH 11149
         exp = """1 + 2 * \
         5 - 1 + 2 """
         result = pd.eval(exp, engine=self.engine, parser=self.parser)
-        self.assertEqual(result, 12)
+        assert result == 12
 
     def test_float_truncation(self):
         # GH 14241
         exp = '1000000000.006'
         result = pd.eval(exp, engine=self.engine, parser=self.parser)
         expected = np.float64(exp)
-        self.assertEqual(result, expected)
+        assert result == expected
 
         df = pd.DataFrame({'A': [1000000000.0009,
                                  1000000000.0011,
@@ -1121,15 +1119,15 @@ def test_simple_bool_ops(self):
             ex = '{0} {1} {2}'.format(lhs, op, rhs)
             res = self.eval(ex)
             exp = eval(ex)
-            self.assertEqual(res, exp)
+            assert res == exp
 
     def test_bool_ops_with_constants(self):
         for op, lhs, rhs in product(expr._bool_ops_syms, ('True', 'False'),
                                     ('True', 'False')):
             ex = '{0} {1} {2}'.format(lhs, op, rhs)
             res = self.eval(ex)
             exp = eval(ex)
-            self.assertEqual(res, exp)
+            assert res == exp
 
     def test_panel_fails(self):
         with catch_warnings(record=True):
@@ -1169,19 +1167,19 @@ def test_truediv(self):
 
             res = self.eval('1 / 2', truediv=True)
             expec = 0.5
-            self.assertEqual(res, expec)
+            assert res == expec
 
             res = self.eval('1 / 2', truediv=False)
             expec = 0.5
-            self.assertEqual(res, expec)
+            assert res == expec
 
             res = self.eval('s / 2', truediv=False)
             expec = 0.5
-            self.assertEqual(res, expec)
+            assert res == expec
 
             res = self.eval('s / 2', truediv=True)
             expec = 0.5
-            self.assertEqual(res, expec)
+            assert res == expec
         else:
             res = self.eval(ex, truediv=False)
             tm.assert_numpy_array_equal(res, np.array([1]))
@@ -1191,19 +1189,19 @@ def test_truediv(self):
 
             res = self.eval('1 / 2', truediv=True)
             expec = 0.5
-            self.assertEqual(res, expec)
+            assert res == expec
 
             res = self.eval('1 / 2', truediv=False)
             expec = 0
-            self.assertEqual(res, expec)
+            assert res == expec
 
             res = self.eval('s / 2', truediv=False)
             expec = 0
-            self.assertEqual(res, expec)
+            assert res == expec
 
             res = self.eval('s / 2', truediv=True)
             expec = 0.5
-            self.assertEqual(res, expec)
+            assert res == expec
 
     def test_failing_subscript_with_name_error(self):
         df = DataFrame(np.random.randn(5, 3))  # noqa
@@ -1549,7 +1547,7 @@ def test_bool_ops_with_constants(self):
             else:
                 res = self.eval(ex)
                 exp = eval(ex)
-                self.assertEqual(res, exp)
+                assert res == exp
 
     def test_simple_bool_ops(self):
         for op, lhs, rhs in product(expr._bool_ops_syms, (True, False),
@@ -1561,7 +1559,7 @@ def test_simple_bool_ops(self):
             else:
                 res = pd.eval(ex, engine=self.engine, parser=self.parser)
                 exp = eval(ex)
-                self.assertEqual(res, exp)
+                assert res == exp
 
 
 class TestOperationsPythonPython(TestOperationsNumExprPython):
@@ -1650,14 +1648,14 @@ def test_df_arithmetic_subexpression(self):
 
     def check_result_type(self, dtype, expect_dtype):
         df = DataFrame({'a': np.random.randn(10).astype(dtype)})
-        self.assertEqual(df.a.dtype, dtype)
+        assert df.a.dtype == dtype
         df.eval("b = sin(a)",
                 engine=self.engine,
                 parser=self.parser, inplace=True)
         got = df.b
         expect = np.sin(df.a)
-        self.assertEqual(expect.dtype, got.dtype)
-        self.assertEqual(expect_dtype, got.dtype)
+        assert expect.dtype == got.dtype
+        assert expect_dtype == got.dtype
         tm.assert_series_equal(got, expect, check_names=False)
 
     def test_result_types(self):

pandas/tests/dtypes/test_cast.py

@@ -164,7 +164,7 @@ def test_maybe_convert_string_to_array(self):
         assert result.dtype == object
 
         result = maybe_convert_string_to_object(1)
-        self.assertEqual(result, 1)
+        assert result == 1
 
         arr = np.array(['x', 'y'], dtype=str)
         result = maybe_convert_string_to_object(arr)
@@ -187,31 +187,31 @@ def test_maybe_convert_scalar(self):
 
         # pass thru
         result = maybe_convert_scalar('x')
-        self.assertEqual(result, 'x')
+        assert result == 'x'
         result = maybe_convert_scalar(np.array([1]))
-        self.assertEqual(result, np.array([1]))
+        assert result == np.array([1])
 
         # leave scalar dtype
         result = maybe_convert_scalar(np.int64(1))
-        self.assertEqual(result, np.int64(1))
+        assert result == np.int64(1)
         result = maybe_convert_scalar(np.int32(1))
-        self.assertEqual(result, np.int32(1))
+        assert result == np.int32(1)
         result = maybe_convert_scalar(np.float32(1))
-        self.assertEqual(result, np.float32(1))
+        assert result == np.float32(1)
         result = maybe_convert_scalar(np.int64(1))
-        self.assertEqual(result, np.float64(1))
+        assert result == np.float64(1)
 
         # coerce
         result = maybe_convert_scalar(1)
-        self.assertEqual(result, np.int64(1))
+        assert result == np.int64(1)
         result = maybe_convert_scalar(1.0)
-        self.assertEqual(result, np.float64(1))
+        assert result == np.float64(1)
         result = maybe_convert_scalar(Timestamp('20130101'))
-        self.assertEqual(result, Timestamp('20130101').value)
+        assert result == Timestamp('20130101').value
         result = maybe_convert_scalar(datetime(2013, 1, 1))
-        self.assertEqual(result, Timestamp('20130101').value)
+        assert result == Timestamp('20130101').value
         result = maybe_convert_scalar(Timedelta('1 day 1 min'))
-        self.assertEqual(result, Timedelta('1 day 1 min').value)
+        assert result == Timedelta('1 day 1 min').value
 
 
 class TestConvert(tm.TestCase):
@@ -291,34 +291,33 @@ def test_numpy_dtypes(self):
             ((np.dtype('datetime64[ns]'), np.int64), np.object)
         )
         for src, common in testcases:
-            self.assertEqual(find_common_type(src), common)
+            assert find_common_type(src) == common
 
         with pytest.raises(ValueError):
             # empty
             find_common_type([])
 
     def test_categorical_dtype(self):
         dtype = CategoricalDtype()
-        self.assertEqual(find_common_type([dtype]), 'category')
-        self.assertEqual(find_common_type([dtype, dtype]), 'category')
-        self.assertEqual(find_common_type([np.object, dtype]), np.object)
+        assert find_common_type([dtype]) == 'category'
+        assert find_common_type([dtype, dtype]) == 'category'
+        assert find_common_type([np.object, dtype]) == np.object
 
     def test_datetimetz_dtype(self):
         dtype = DatetimeTZDtype(unit='ns', tz='US/Eastern')
-        self.assertEqual(find_common_type([dtype, dtype]),
-                         'datetime64[ns, US/Eastern]')
+        assert find_common_type([dtype, dtype]) == 'datetime64[ns, US/Eastern]'
 
         for dtype2 in [DatetimeTZDtype(unit='ns', tz='Asia/Tokyo'),
                        np.dtype('datetime64[ns]'), np.object, np.int64]:
-            self.assertEqual(find_common_type([dtype, dtype2]), np.object)
-            self.assertEqual(find_common_type([dtype2, dtype]), np.object)
+            assert find_common_type([dtype, dtype2]) == np.object
+            assert find_common_type([dtype2, dtype]) == np.object
 
     def test_period_dtype(self):
         dtype = PeriodDtype(freq='D')
-        self.assertEqual(find_common_type([dtype, dtype]), 'period[D]')
+        assert find_common_type([dtype, dtype]) == 'period[D]'
 
         for dtype2 in [DatetimeTZDtype(unit='ns', tz='Asia/Tokyo'),
                        PeriodDtype(freq='2D'), PeriodDtype(freq='H'),
                        np.dtype('datetime64[ns]'), np.object, np.int64]:
-            self.assertEqual(find_common_type([dtype, dtype2]), np.object)
-            self.assertEqual(find_common_type([dtype2, dtype]), np.object)
+            assert find_common_type([dtype, dtype2]) == np.object
+            assert find_common_type([dtype2, dtype]) == np.object

pandas/tests/dtypes/test_common.py

@@ -30,30 +30,30 @@ def test_invalid_dtype_error(self):
 
     def test_numpy_dtype(self):
         for dtype in ['M8[ns]', 'm8[ns]', 'object', 'float64', 'int64']:
-            self.assertEqual(pandas_dtype(dtype), np.dtype(dtype))
+            assert pandas_dtype(dtype) == np.dtype(dtype)
 
     def test_numpy_string_dtype(self):
         # do not parse freq-like string as period dtype
-        self.assertEqual(pandas_dtype('U'), np.dtype('U'))
-        self.assertEqual(pandas_dtype('S'), np.dtype('S'))
+        assert pandas_dtype('U') == np.dtype('U')
+        assert pandas_dtype('S') == np.dtype('S')
 
     def test_datetimetz_dtype(self):
         for dtype in ['datetime64[ns, US/Eastern]',
                       'datetime64[ns, Asia/Tokyo]',
                       'datetime64[ns, UTC]']:
             assert pandas_dtype(dtype) is DatetimeTZDtype(dtype)
-            self.assertEqual(pandas_dtype(dtype), DatetimeTZDtype(dtype))
-            self.assertEqual(pandas_dtype(dtype), dtype)
+            assert pandas_dtype(dtype) == DatetimeTZDtype(dtype)
+            assert pandas_dtype(dtype) == dtype
 
     def test_categorical_dtype(self):
-        self.assertEqual(pandas_dtype('category'), CategoricalDtype())
+        assert pandas_dtype('category') == CategoricalDtype()
 
     def test_period_dtype(self):
         for dtype in ['period[D]', 'period[3M]', 'period[U]',
                       'Period[D]', 'Period[3M]', 'Period[U]']:
             assert pandas_dtype(dtype) is PeriodDtype(dtype)
-            self.assertEqual(pandas_dtype(dtype), PeriodDtype(dtype))
-            self.assertEqual(pandas_dtype(dtype), dtype)
+            assert pandas_dtype(dtype) == PeriodDtype(dtype)
+            assert pandas_dtype(dtype) == dtype
 
 
 dtypes = dict(datetime_tz=pandas_dtype('datetime64[ns, US/Eastern]'),