From ecc0590d393de93eb4e9d8d029fead1dad1a90fa Mon Sep 17 00:00:00 2001 From: gfyoung Date: Wed, 26 Apr 2017 14:06:46 -0400 Subject: [PATCH] MAINT: Remove self.assertFalse from testing --- pandas/tests/computation/test_eval.py | 4 +- pandas/tests/dtypes/test_dtypes.py | 120 +++++----- pandas/tests/dtypes/test_inference.py | 224 +++++++++--------- pandas/tests/dtypes/test_missing.py | 16 +- pandas/tests/frame/test_analytics.py | 18 +- pandas/tests/frame/test_api.py | 12 +- .../tests/frame/test_axis_select_reindex.py | 4 +- pandas/tests/frame/test_block_internals.py | 6 +- pandas/tests/frame/test_constructors.py | 8 +- pandas/tests/frame/test_indexing.py | 5 +- pandas/tests/frame/test_mutate_columns.py | 2 +- pandas/tests/frame/test_operators.py | 22 +- pandas/tests/frame/test_repr_info.py | 16 +- pandas/tests/frame/test_timeseries.py | 2 +- pandas/tests/groupby/test_groupby.py | 24 +- pandas/tests/indexes/common.py | 18 +- pandas/tests/indexes/datetimelike.py | 2 +- pandas/tests/indexes/datetimes/test_astype.py | 2 +- .../indexes/datetimes/test_construction.py | 2 +- .../tests/indexes/datetimes/test_datetime.py | 4 +- pandas/tests/indexes/datetimes/test_misc.py | 2 +- pandas/tests/indexes/datetimes/test_ops.py | 44 ++-- pandas/tests/indexes/datetimes/test_tools.py | 3 +- pandas/tests/indexes/period/test_ops.py | 32 +-- pandas/tests/indexes/period/test_period.py | 18 +- pandas/tests/indexes/test_base.py | 54 ++--- pandas/tests/indexes/test_category.py | 30 +-- pandas/tests/indexes/test_interval.py | 23 +- pandas/tests/indexes/test_multi.py | 57 +++-- pandas/tests/indexes/test_numeric.py | 16 +- pandas/tests/indexes/test_range.py | 18 +- .../tests/indexes/timedeltas/test_astype.py | 2 +- pandas/tests/indexes/timedeltas/test_ops.py | 22 +- .../indexes/timedeltas/test_timedelta.py | 4 +- pandas/tests/indexing/test_floats.py | 2 +- pandas/tests/indexing/test_indexing.py | 2 +- pandas/tests/indexing/test_loc.py | 4 +- pandas/tests/indexing/test_multiindex.py | 6 +- pandas/tests/io/formats/test_format.py | 58 ++--- pandas/tests/io/formats/test_to_html.py | 2 +- pandas/tests/io/json/test_pandas.py | 2 +- pandas/tests/io/parser/common.py | 8 +- pandas/tests/io/parser/test_network.py | 20 +- pandas/tests/io/test_common.py | 2 +- pandas/tests/io/test_html.py | 6 +- pandas/tests/io/test_pytables.py | 16 +- pandas/tests/io/test_s3.py | 2 +- pandas/tests/io/test_sql.py | 13 +- pandas/tests/plotting/common.py | 4 +- pandas/tests/plotting/test_datetimelike.py | 24 +- pandas/tests/plotting/test_frame.py | 2 +- pandas/tests/plotting/test_hist_method.py | 10 +- pandas/tests/plotting/test_series.py | 8 +- pandas/tests/reshape/test_hashing.py | 6 +- pandas/tests/reshape/test_merge.py | 4 +- pandas/tests/reshape/test_merge_asof.py | 6 +- pandas/tests/reshape/test_pivot.py | 2 +- pandas/tests/scalar/test_period.py | 4 +- pandas/tests/scalar/test_timedelta.py | 6 +- pandas/tests/scalar/test_timestamp.py | 50 ++-- pandas/tests/series/test_analytics.py | 12 +- pandas/tests/series/test_api.py | 4 +- pandas/tests/series/test_asof.py | 2 +- pandas/tests/series/test_constructors.py | 8 +- pandas/tests/series/test_datetime_values.py | 2 +- pandas/tests/series/test_indexing.py | 20 +- pandas/tests/series/test_missing.py | 8 +- pandas/tests/series/test_operators.py | 2 +- pandas/tests/series/test_repr.py | 6 +- pandas/tests/sparse/test_array.py | 8 +- pandas/tests/sparse/test_libsparse.py | 4 +- pandas/tests/test_base.py | 26 +- pandas/tests/test_categorical.py | 62 ++--- pandas/tests/test_config.py | 3 +- pandas/tests/test_expressions.py | 10 +- pandas/tests/test_lib.py | 2 +- pandas/tests/test_multilevel.py | 12 +- pandas/tests/test_nanops.py | 8 +- pandas/tests/test_panel.py | 4 +- pandas/tests/test_panel4d.py | 6 +- pandas/tests/test_resample.py | 4 +- pandas/tests/test_strings.py | 4 +- pandas/tests/test_window.py | 28 +-- pandas/tests/tseries/test_offsets.py | 67 +++--- pandas/tests/tseries/test_timezones.py | 10 +- 85 files changed, 704 insertions(+), 723 deletions(-) diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py index cc14282934f16..52061f7f1e0ae 100644 --- a/pandas/tests/computation/test_eval.py +++ b/pandas/tests/computation/test_eval.py @@ -1443,7 +1443,7 @@ def test_simple_in_ops(self): res = pd.eval('3 in (1, 2)', engine=self.engine, parser=self.parser) - self.assertFalse(res) + assert not res res = pd.eval('3 not in (1, 2)', engine=self.engine, parser=self.parser) @@ -1467,7 +1467,7 @@ def test_simple_in_ops(self): res = pd.eval('(3,) not in [(3,), 2]', engine=self.engine, parser=self.parser) - self.assertFalse(res) + assert not res res = pd.eval('[(3,)] in [[(3,)], 2]', engine=self.engine, parser=self.parser) diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py index e3bae3675a9e4..718efc08394b1 100644 --- a/pandas/tests/dtypes/test_dtypes.py +++ b/pandas/tests/dtypes/test_dtypes.py @@ -59,7 +59,7 @@ def test_hash_vs_equality(self): def test_equality(self): self.assertTrue(is_dtype_equal(self.dtype, 'category')) self.assertTrue(is_dtype_equal(self.dtype, CategoricalDtype())) - self.assertFalse(is_dtype_equal(self.dtype, 'foo')) + assert not is_dtype_equal(self.dtype, 'foo') def test_construction_from_string(self): result = CategoricalDtype.construct_from_string('category') @@ -71,8 +71,8 @@ def test_is_dtype(self): self.assertTrue(CategoricalDtype.is_dtype(self.dtype)) self.assertTrue(CategoricalDtype.is_dtype('category')) self.assertTrue(CategoricalDtype.is_dtype(CategoricalDtype())) - self.assertFalse(CategoricalDtype.is_dtype('foo')) - self.assertFalse(CategoricalDtype.is_dtype(np.float64)) + assert not CategoricalDtype.is_dtype('foo') + assert not CategoricalDtype.is_dtype(np.float64) def test_basic(self): @@ -85,12 +85,12 @@ def test_basic(self): # dtypes self.assertTrue(is_categorical_dtype(s.dtype)) self.assertTrue(is_categorical_dtype(s)) - self.assertFalse(is_categorical_dtype(np.dtype('float64'))) + assert not is_categorical_dtype(np.dtype('float64')) self.assertTrue(is_categorical(s.dtype)) self.assertTrue(is_categorical(s)) - self.assertFalse(is_categorical(np.dtype('float64'))) - self.assertFalse(is_categorical(1.0)) + assert not is_categorical(np.dtype('float64')) + assert not is_categorical(1.0) class TestDatetimeTZDtype(Base, tm.TestCase): @@ -136,8 +136,8 @@ def test_compat(self): self.assertTrue(is_datetime64_any_dtype('datetime64[ns, US/Eastern]')) self.assertTrue(is_datetime64_ns_dtype(self.dtype)) self.assertTrue(is_datetime64_ns_dtype('datetime64[ns, US/Eastern]')) - self.assertFalse(is_datetime64_dtype(self.dtype)) - self.assertFalse(is_datetime64_dtype('datetime64[ns, US/Eastern]')) + assert not is_datetime64_dtype(self.dtype) + assert not is_datetime64_dtype('datetime64[ns, US/Eastern]') def test_construction_from_string(self): result = DatetimeTZDtype('datetime64[ns, US/Eastern]') @@ -149,25 +149,23 @@ def test_construction_from_string(self): lambda: DatetimeTZDtype.construct_from_string('foo')) def test_is_dtype(self): - self.assertFalse(DatetimeTZDtype.is_dtype(None)) + assert not DatetimeTZDtype.is_dtype(None) self.assertTrue(DatetimeTZDtype.is_dtype(self.dtype)) self.assertTrue(DatetimeTZDtype.is_dtype('datetime64[ns, US/Eastern]')) - self.assertFalse(DatetimeTZDtype.is_dtype('foo')) + assert not DatetimeTZDtype.is_dtype('foo') self.assertTrue(DatetimeTZDtype.is_dtype(DatetimeTZDtype( 'ns', 'US/Pacific'))) - self.assertFalse(DatetimeTZDtype.is_dtype(np.float64)) + assert not DatetimeTZDtype.is_dtype(np.float64) def test_equality(self): self.assertTrue(is_dtype_equal(self.dtype, 'datetime64[ns, US/Eastern]')) self.assertTrue(is_dtype_equal(self.dtype, DatetimeTZDtype( 'ns', 'US/Eastern'))) - self.assertFalse(is_dtype_equal(self.dtype, 'foo')) - self.assertFalse(is_dtype_equal(self.dtype, DatetimeTZDtype('ns', - 'CET'))) - self.assertFalse(is_dtype_equal( - DatetimeTZDtype('ns', 'US/Eastern'), DatetimeTZDtype( - 'ns', 'US/Pacific'))) + assert not is_dtype_equal(self.dtype, 'foo') + assert not is_dtype_equal(self.dtype, DatetimeTZDtype('ns', 'CET')) + assert not is_dtype_equal(DatetimeTZDtype('ns', 'US/Eastern'), + DatetimeTZDtype('ns', 'US/Pacific')) # numpy compat self.assertTrue(is_dtype_equal(np.dtype("M8[ns]"), "datetime64[ns]")) @@ -182,13 +180,13 @@ def test_basic(self): # dtypes self.assertTrue(is_datetime64tz_dtype(s.dtype)) self.assertTrue(is_datetime64tz_dtype(s)) - self.assertFalse(is_datetime64tz_dtype(np.dtype('float64'))) - self.assertFalse(is_datetime64tz_dtype(1.0)) + assert not is_datetime64tz_dtype(np.dtype('float64')) + assert not is_datetime64tz_dtype(1.0) self.assertTrue(is_datetimetz(s)) self.assertTrue(is_datetimetz(s.dtype)) - self.assertFalse(is_datetimetz(np.dtype('float64'))) - self.assertFalse(is_datetimetz(1.0)) + assert not is_datetimetz(np.dtype('float64')) + assert not is_datetimetz(1.0) def test_dst(self): @@ -265,10 +263,10 @@ def test_coerce_to_dtype(self): PeriodDtype('period[3M]')) def test_compat(self): - self.assertFalse(is_datetime64_ns_dtype(self.dtype)) - self.assertFalse(is_datetime64_ns_dtype('period[D]')) - self.assertFalse(is_datetime64_dtype(self.dtype)) - self.assertFalse(is_datetime64_dtype('period[D]')) + assert not is_datetime64_ns_dtype(self.dtype) + assert not is_datetime64_ns_dtype('period[D]') + assert not is_datetime64_dtype(self.dtype) + assert not is_datetime64_dtype('period[D]') def test_construction_from_string(self): result = PeriodDtype('period[D]') @@ -297,14 +295,14 @@ def test_is_dtype(self): self.assertTrue(PeriodDtype.is_dtype(PeriodDtype('U'))) self.assertTrue(PeriodDtype.is_dtype(PeriodDtype('S'))) - self.assertFalse(PeriodDtype.is_dtype('D')) - self.assertFalse(PeriodDtype.is_dtype('3D')) - self.assertFalse(PeriodDtype.is_dtype('U')) - self.assertFalse(PeriodDtype.is_dtype('S')) - self.assertFalse(PeriodDtype.is_dtype('foo')) - self.assertFalse(PeriodDtype.is_dtype(np.object_)) - self.assertFalse(PeriodDtype.is_dtype(np.int64)) - self.assertFalse(PeriodDtype.is_dtype(np.float64)) + assert not PeriodDtype.is_dtype('D') + assert not PeriodDtype.is_dtype('3D') + assert not PeriodDtype.is_dtype('U') + assert not PeriodDtype.is_dtype('S') + assert not PeriodDtype.is_dtype('foo') + assert not PeriodDtype.is_dtype(np.object_) + assert not PeriodDtype.is_dtype(np.int64) + assert not PeriodDtype.is_dtype(np.float64) def test_equality(self): self.assertTrue(is_dtype_equal(self.dtype, 'period[D]')) @@ -312,8 +310,8 @@ def test_equality(self): self.assertTrue(is_dtype_equal(self.dtype, PeriodDtype('D'))) self.assertTrue(is_dtype_equal(PeriodDtype('D'), PeriodDtype('D'))) - self.assertFalse(is_dtype_equal(self.dtype, 'D')) - self.assertFalse(is_dtype_equal(PeriodDtype('D'), PeriodDtype('2D'))) + assert not is_dtype_equal(self.dtype, 'D') + assert not is_dtype_equal(PeriodDtype('D'), PeriodDtype('2D')) def test_basic(self): self.assertTrue(is_period_dtype(self.dtype)) @@ -328,14 +326,14 @@ def test_basic(self): # dtypes # series results in object dtype currently, # is_period checks period_arraylike - self.assertFalse(is_period_dtype(s.dtype)) - self.assertFalse(is_period_dtype(s)) + assert not is_period_dtype(s.dtype) + assert not is_period_dtype(s) self.assertTrue(is_period(s)) - self.assertFalse(is_period_dtype(np.dtype('float64'))) - self.assertFalse(is_period_dtype(1.0)) - self.assertFalse(is_period(np.dtype('float64'))) - self.assertFalse(is_period(1.0)) + assert not is_period_dtype(np.dtype('float64')) + assert not is_period_dtype(1.0) + assert not is_period(np.dtype('float64')) + assert not is_period(1.0) def test_empty(self): dt = PeriodDtype() @@ -344,7 +342,7 @@ def test_empty(self): def test_not_string(self): # though PeriodDtype has object kind, it cannot be string - self.assertFalse(is_string_dtype(PeriodDtype('D'))) + assert not is_string_dtype(PeriodDtype('D')) class TestIntervalDtype(Base, tm.TestCase): @@ -388,14 +386,14 @@ def test_is_dtype(self): self.assertTrue(IntervalDtype.is_dtype(IntervalDtype('int64'))) self.assertTrue(IntervalDtype.is_dtype(IntervalDtype(np.int64))) - self.assertFalse(IntervalDtype.is_dtype('D')) - self.assertFalse(IntervalDtype.is_dtype('3D')) - self.assertFalse(IntervalDtype.is_dtype('U')) - self.assertFalse(IntervalDtype.is_dtype('S')) - self.assertFalse(IntervalDtype.is_dtype('foo')) - self.assertFalse(IntervalDtype.is_dtype(np.object_)) - self.assertFalse(IntervalDtype.is_dtype(np.int64)) - self.assertFalse(IntervalDtype.is_dtype(np.float64)) + assert not IntervalDtype.is_dtype('D') + assert not IntervalDtype.is_dtype('3D') + assert not IntervalDtype.is_dtype('U') + assert not IntervalDtype.is_dtype('S') + assert not IntervalDtype.is_dtype('foo') + assert not IntervalDtype.is_dtype(np.object_) + assert not IntervalDtype.is_dtype(np.int64) + assert not IntervalDtype.is_dtype(np.float64) def test_identity(self): self.assertEqual(IntervalDtype('interval[int64]'), @@ -424,9 +422,9 @@ def test_equality(self): self.assertTrue(is_dtype_equal(IntervalDtype('int64'), IntervalDtype('int64'))) - self.assertFalse(is_dtype_equal(self.dtype, 'int64')) - self.assertFalse(is_dtype_equal(IntervalDtype('int64'), - IntervalDtype('float64'))) + assert not is_dtype_equal(self.dtype, 'int64') + assert not is_dtype_equal(IntervalDtype('int64'), + IntervalDtype('float64')) def test_basic(self): self.assertTrue(is_interval_dtype(self.dtype)) @@ -440,8 +438,8 @@ def test_basic(self): # dtypes # series results in object dtype currently, - self.assertFalse(is_interval_dtype(s.dtype)) - self.assertFalse(is_interval_dtype(s)) + assert not is_interval_dtype(s.dtype) + assert not is_interval_dtype(s) def test_basic_dtype(self): self.assertTrue(is_interval_dtype('interval[int64]')) @@ -450,9 +448,9 @@ def test_basic_dtype(self): (IntervalIndex.from_breaks(np.arange(4)))) self.assertTrue(is_interval_dtype( IntervalIndex.from_breaks(date_range('20130101', periods=3)))) - self.assertFalse(is_interval_dtype('U')) - self.assertFalse(is_interval_dtype('S')) - self.assertFalse(is_interval_dtype('foo')) - self.assertFalse(is_interval_dtype(np.object_)) - self.assertFalse(is_interval_dtype(np.int64)) - self.assertFalse(is_interval_dtype(np.float64)) + assert not is_interval_dtype('U') + assert not is_interval_dtype('S') + assert not is_interval_dtype('foo') + assert not is_interval_dtype(np.object_) + assert not is_interval_dtype(np.int64) + assert not is_interval_dtype(np.float64) diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py index 35720b32d756c..8dcf75e8a1aec 100644 --- a/pandas/tests/dtypes/test_inference.py +++ b/pandas/tests/dtypes/test_inference.py @@ -213,15 +213,15 @@ def test_isinf_scalar(self): # GH 11352 self.assertTrue(lib.isposinf_scalar(float('inf'))) self.assertTrue(lib.isposinf_scalar(np.inf)) - self.assertFalse(lib.isposinf_scalar(-np.inf)) - self.assertFalse(lib.isposinf_scalar(1)) - self.assertFalse(lib.isposinf_scalar('a')) + assert not lib.isposinf_scalar(-np.inf) + assert not lib.isposinf_scalar(1) + assert not lib.isposinf_scalar('a') self.assertTrue(lib.isneginf_scalar(float('-inf'))) self.assertTrue(lib.isneginf_scalar(-np.inf)) - self.assertFalse(lib.isneginf_scalar(np.inf)) - self.assertFalse(lib.isneginf_scalar(1)) - self.assertFalse(lib.isneginf_scalar('a')) + assert not lib.isneginf_scalar(np.inf) + assert not lib.isneginf_scalar(1) + assert not lib.isneginf_scalar('a') def test_maybe_convert_numeric_infinities(self): # see gh-13274 @@ -639,24 +639,24 @@ def test_is_datetimelike_array_all_nan_nat_like(self): arr = np.array([np.nan, pd.NaT, np.datetime64('nat')]) self.assertTrue(lib.is_datetime_array(arr)) self.assertTrue(lib.is_datetime64_array(arr)) - self.assertFalse(lib.is_timedelta_array(arr)) - self.assertFalse(lib.is_timedelta64_array(arr)) - self.assertFalse(lib.is_timedelta_or_timedelta64_array(arr)) + assert not lib.is_timedelta_array(arr) + assert not lib.is_timedelta64_array(arr) + assert not lib.is_timedelta_or_timedelta64_array(arr) arr = np.array([np.nan, pd.NaT, np.timedelta64('nat')]) - self.assertFalse(lib.is_datetime_array(arr)) - self.assertFalse(lib.is_datetime64_array(arr)) + assert not lib.is_datetime_array(arr) + assert not lib.is_datetime64_array(arr) self.assertTrue(lib.is_timedelta_array(arr)) self.assertTrue(lib.is_timedelta64_array(arr)) self.assertTrue(lib.is_timedelta_or_timedelta64_array(arr)) arr = np.array([np.nan, pd.NaT, np.datetime64('nat'), np.timedelta64('nat')]) - self.assertFalse(lib.is_datetime_array(arr)) - self.assertFalse(lib.is_datetime64_array(arr)) - self.assertFalse(lib.is_timedelta_array(arr)) - self.assertFalse(lib.is_timedelta64_array(arr)) - self.assertFalse(lib.is_timedelta_or_timedelta64_array(arr)) + assert not lib.is_datetime_array(arr) + assert not lib.is_datetime64_array(arr) + assert not lib.is_timedelta_array(arr) + assert not lib.is_timedelta64_array(arr) + assert not lib.is_timedelta_or_timedelta64_array(arr) arr = np.array([np.nan, pd.NaT]) self.assertTrue(lib.is_datetime_array(arr)) @@ -666,11 +666,11 @@ def test_is_datetimelike_array_all_nan_nat_like(self): self.assertTrue(lib.is_timedelta_or_timedelta64_array(arr)) arr = np.array([np.nan, np.nan], dtype=object) - self.assertFalse(lib.is_datetime_array(arr)) - self.assertFalse(lib.is_datetime64_array(arr)) - self.assertFalse(lib.is_timedelta_array(arr)) - self.assertFalse(lib.is_timedelta64_array(arr)) - self.assertFalse(lib.is_timedelta_or_timedelta64_array(arr)) + assert not lib.is_datetime_array(arr) + assert not lib.is_datetime64_array(arr) + assert not lib.is_timedelta_array(arr) + assert not lib.is_timedelta64_array(arr) + assert not lib.is_timedelta_or_timedelta64_array(arr) def test_date(self): @@ -720,10 +720,10 @@ def test_to_object_array_width(self): def test_is_period(self): self.assertTrue(lib.is_period(pd.Period('2011-01', freq='M'))) - self.assertFalse(lib.is_period(pd.PeriodIndex(['2011-01'], freq='M'))) - self.assertFalse(lib.is_period(pd.Timestamp('2011-01'))) - self.assertFalse(lib.is_period(1)) - self.assertFalse(lib.is_period(np.nan)) + assert not lib.is_period(pd.PeriodIndex(['2011-01'], freq='M')) + assert not lib.is_period(pd.Timestamp('2011-01')) + assert not lib.is_period(1) + assert not lib.is_period(np.nan) def test_categorical(self): @@ -758,18 +758,17 @@ def test_is_number(self): self.assertTrue(is_number(np.complex128(1 + 3j))) self.assertTrue(is_number(np.nan)) - self.assertFalse(is_number(None)) - self.assertFalse(is_number('x')) - self.assertFalse(is_number(datetime(2011, 1, 1))) - self.assertFalse(is_number(np.datetime64('2011-01-01'))) - self.assertFalse(is_number(Timestamp('2011-01-01'))) - self.assertFalse(is_number(Timestamp('2011-01-01', - tz='US/Eastern'))) - self.assertFalse(is_number(timedelta(1000))) - self.assertFalse(is_number(Timedelta('1 days'))) + assert not is_number(None) + assert not is_number('x') + assert not is_number(datetime(2011, 1, 1)) + assert not is_number(np.datetime64('2011-01-01')) + assert not is_number(Timestamp('2011-01-01')) + assert not is_number(Timestamp('2011-01-01', tz='US/Eastern')) + assert not is_number(timedelta(1000)) + assert not is_number(Timedelta('1 days')) # questionable - self.assertFalse(is_number(np.bool_(False))) + assert not is_number(np.bool_(False)) self.assertTrue(is_number(np.timedelta64(1, 'D'))) def test_is_bool(self): @@ -777,45 +776,43 @@ def test_is_bool(self): self.assertTrue(is_bool(np.bool(False))) self.assertTrue(is_bool(np.bool_(False))) - self.assertFalse(is_bool(1)) - self.assertFalse(is_bool(1.1)) - self.assertFalse(is_bool(1 + 3j)) - self.assertFalse(is_bool(np.int64(1))) - self.assertFalse(is_bool(np.float64(1.1))) - self.assertFalse(is_bool(np.complex128(1 + 3j))) - self.assertFalse(is_bool(np.nan)) - self.assertFalse(is_bool(None)) - self.assertFalse(is_bool('x')) - self.assertFalse(is_bool(datetime(2011, 1, 1))) - self.assertFalse(is_bool(np.datetime64('2011-01-01'))) - self.assertFalse(is_bool(Timestamp('2011-01-01'))) - self.assertFalse(is_bool(Timestamp('2011-01-01', - tz='US/Eastern'))) - self.assertFalse(is_bool(timedelta(1000))) - self.assertFalse(is_bool(np.timedelta64(1, 'D'))) - self.assertFalse(is_bool(Timedelta('1 days'))) + assert not is_bool(1) + assert not is_bool(1.1) + assert not is_bool(1 + 3j) + assert not is_bool(np.int64(1)) + assert not is_bool(np.float64(1.1)) + assert not is_bool(np.complex128(1 + 3j)) + assert not is_bool(np.nan) + assert not is_bool(None) + assert not is_bool('x') + assert not is_bool(datetime(2011, 1, 1)) + assert not is_bool(np.datetime64('2011-01-01')) + assert not is_bool(Timestamp('2011-01-01')) + assert not is_bool(Timestamp('2011-01-01', tz='US/Eastern')) + assert not is_bool(timedelta(1000)) + assert not is_bool(np.timedelta64(1, 'D')) + assert not is_bool(Timedelta('1 days')) def test_is_integer(self): self.assertTrue(is_integer(1)) self.assertTrue(is_integer(np.int64(1))) - self.assertFalse(is_integer(True)) - self.assertFalse(is_integer(1.1)) - self.assertFalse(is_integer(1 + 3j)) - self.assertFalse(is_integer(np.bool(False))) - self.assertFalse(is_integer(np.bool_(False))) - self.assertFalse(is_integer(np.float64(1.1))) - self.assertFalse(is_integer(np.complex128(1 + 3j))) - self.assertFalse(is_integer(np.nan)) - self.assertFalse(is_integer(None)) - self.assertFalse(is_integer('x')) - self.assertFalse(is_integer(datetime(2011, 1, 1))) - self.assertFalse(is_integer(np.datetime64('2011-01-01'))) - self.assertFalse(is_integer(Timestamp('2011-01-01'))) - self.assertFalse(is_integer(Timestamp('2011-01-01', - tz='US/Eastern'))) - self.assertFalse(is_integer(timedelta(1000))) - self.assertFalse(is_integer(Timedelta('1 days'))) + assert not is_integer(True) + assert not is_integer(1.1) + assert not is_integer(1 + 3j) + assert not is_integer(np.bool(False)) + assert not is_integer(np.bool_(False)) + assert not is_integer(np.float64(1.1)) + assert not is_integer(np.complex128(1 + 3j)) + assert not is_integer(np.nan) + assert not is_integer(None) + assert not is_integer('x') + assert not is_integer(datetime(2011, 1, 1)) + assert not is_integer(np.datetime64('2011-01-01')) + assert not is_integer(Timestamp('2011-01-01')) + assert not is_integer(Timestamp('2011-01-01', tz='US/Eastern')) + assert not is_integer(timedelta(1000)) + assert not is_integer(Timedelta('1 days')) # questionable self.assertTrue(is_integer(np.timedelta64(1, 'D'))) @@ -825,23 +822,22 @@ def test_is_float(self): self.assertTrue(is_float(np.float64(1.1))) self.assertTrue(is_float(np.nan)) - self.assertFalse(is_float(True)) - self.assertFalse(is_float(1)) - self.assertFalse(is_float(1 + 3j)) - self.assertFalse(is_float(np.bool(False))) - self.assertFalse(is_float(np.bool_(False))) - self.assertFalse(is_float(np.int64(1))) - self.assertFalse(is_float(np.complex128(1 + 3j))) - self.assertFalse(is_float(None)) - self.assertFalse(is_float('x')) - self.assertFalse(is_float(datetime(2011, 1, 1))) - self.assertFalse(is_float(np.datetime64('2011-01-01'))) - self.assertFalse(is_float(Timestamp('2011-01-01'))) - self.assertFalse(is_float(Timestamp('2011-01-01', - tz='US/Eastern'))) - self.assertFalse(is_float(timedelta(1000))) - self.assertFalse(is_float(np.timedelta64(1, 'D'))) - self.assertFalse(is_float(Timedelta('1 days'))) + assert not is_float(True) + assert not is_float(1) + assert not is_float(1 + 3j) + assert not is_float(np.bool(False)) + assert not is_float(np.bool_(False)) + assert not is_float(np.int64(1)) + assert not is_float(np.complex128(1 + 3j)) + assert not is_float(None) + assert not is_float('x') + assert not is_float(datetime(2011, 1, 1)) + assert not is_float(np.datetime64('2011-01-01')) + assert not is_float(Timestamp('2011-01-01')) + assert not is_float(Timestamp('2011-01-01', tz='US/Eastern')) + assert not is_float(timedelta(1000)) + assert not is_float(np.timedelta64(1, 'D')) + assert not is_float(Timedelta('1 days')) def test_is_datetime_dtypes(self): @@ -851,9 +847,9 @@ def test_is_datetime_dtypes(self): self.assertTrue(is_datetime64_dtype('datetime64')) self.assertTrue(is_datetime64_dtype('datetime64[ns]')) self.assertTrue(is_datetime64_dtype(ts)) - self.assertFalse(is_datetime64_dtype(tsa)) + assert not is_datetime64_dtype(tsa) - self.assertFalse(is_datetime64_ns_dtype('datetime64')) + assert not is_datetime64_ns_dtype('datetime64') self.assertTrue(is_datetime64_ns_dtype('datetime64[ns]')) self.assertTrue(is_datetime64_ns_dtype(ts)) self.assertTrue(is_datetime64_ns_dtype(tsa)) @@ -863,14 +859,14 @@ def test_is_datetime_dtypes(self): self.assertTrue(is_datetime64_any_dtype(ts)) self.assertTrue(is_datetime64_any_dtype(tsa)) - self.assertFalse(is_datetime64tz_dtype('datetime64')) - self.assertFalse(is_datetime64tz_dtype('datetime64[ns]')) - self.assertFalse(is_datetime64tz_dtype(ts)) + assert not is_datetime64tz_dtype('datetime64') + assert not is_datetime64tz_dtype('datetime64[ns]') + assert not is_datetime64tz_dtype(ts) self.assertTrue(is_datetime64tz_dtype(tsa)) for tz in ['US/Eastern', 'UTC']: dtype = 'datetime64[ns, {}]'.format(tz) - self.assertFalse(is_datetime64_dtype(dtype)) + assert not is_datetime64_dtype(dtype) self.assertTrue(is_datetime64tz_dtype(dtype)) self.assertTrue(is_datetime64_ns_dtype(dtype)) self.assertTrue(is_datetime64_any_dtype(dtype)) @@ -878,7 +874,7 @@ def test_is_datetime_dtypes(self): def test_is_timedelta(self): self.assertTrue(is_timedelta64_dtype('timedelta64')) self.assertTrue(is_timedelta64_dtype('timedelta64[ns]')) - self.assertFalse(is_timedelta64_ns_dtype('timedelta64')) + assert not is_timedelta64_ns_dtype('timedelta64') self.assertTrue(is_timedelta64_ns_dtype('timedelta64[ns]')) tdi = TimedeltaIndex([1e14, 2e14], dtype='timedelta64') @@ -887,8 +883,8 @@ def test_is_timedelta(self): self.assertTrue(is_timedelta64_ns_dtype(tdi.astype('timedelta64[ns]'))) # Conversion to Int64Index: - self.assertFalse(is_timedelta64_ns_dtype(tdi.astype('timedelta64'))) - self.assertFalse(is_timedelta64_ns_dtype(tdi.astype('timedelta64[h]'))) + assert not is_timedelta64_ns_dtype(tdi.astype('timedelta64')) + assert not is_timedelta64_ns_dtype(tdi.astype('timedelta64[h]')) class Testisscalar(tm.TestCase): @@ -909,13 +905,13 @@ def test_isscalar_builtin_scalars(self): self.assertTrue(is_scalar(pd.NaT)) def test_isscalar_builtin_nonscalars(self): - self.assertFalse(is_scalar({})) - self.assertFalse(is_scalar([])) - self.assertFalse(is_scalar([1])) - self.assertFalse(is_scalar(())) - self.assertFalse(is_scalar((1, ))) - self.assertFalse(is_scalar(slice(None))) - self.assertFalse(is_scalar(Ellipsis)) + assert not is_scalar({}) + assert not is_scalar([]) + assert not is_scalar([1]) + assert not is_scalar(()) + assert not is_scalar((1, )) + assert not is_scalar(slice(None)) + assert not is_scalar(Ellipsis) def test_isscalar_numpy_array_scalars(self): self.assertTrue(is_scalar(np.int64(1))) @@ -933,13 +929,13 @@ def test_isscalar_numpy_zerodim_arrays(self): np.array(np.datetime64('2014-01-01')), np.array(np.timedelta64(1, 'h')), np.array(np.datetime64('NaT'))]: - self.assertFalse(is_scalar(zerodim)) + assert not is_scalar(zerodim) self.assertTrue(is_scalar(lib.item_from_zerodim(zerodim))) def test_isscalar_numpy_arrays(self): - self.assertFalse(is_scalar(np.array([]))) - self.assertFalse(is_scalar(np.array([[]]))) - self.assertFalse(is_scalar(np.matrix('1; 2'))) + assert not is_scalar(np.array([])) + assert not is_scalar(np.array([[]])) + assert not is_scalar(np.matrix('1; 2')) def test_isscalar_pandas_scalars(self): self.assertTrue(is_scalar(Timestamp('2014-01-01'))) @@ -947,15 +943,15 @@ def test_isscalar_pandas_scalars(self): self.assertTrue(is_scalar(Period('2014-01-01'))) def test_lisscalar_pandas_containers(self): - self.assertFalse(is_scalar(Series())) - self.assertFalse(is_scalar(Series([1]))) - self.assertFalse(is_scalar(DataFrame())) - self.assertFalse(is_scalar(DataFrame([[1]]))) + assert not is_scalar(Series()) + assert not is_scalar(Series([1])) + assert not is_scalar(DataFrame()) + assert not is_scalar(DataFrame([[1]])) with catch_warnings(record=True): - self.assertFalse(is_scalar(Panel())) - self.assertFalse(is_scalar(Panel([[[1]]]))) - self.assertFalse(is_scalar(Index([]))) - self.assertFalse(is_scalar(Index([1]))) + assert not is_scalar(Panel()) + assert not is_scalar(Panel([[[1]]])) + assert not is_scalar(Index([])) + assert not is_scalar(Index([1])) def test_datetimeindex_from_empty_datetime64_array(): diff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py index c03ba2b7daf50..3e1a12d439b9a 100644 --- a/pandas/tests/dtypes/test_missing.py +++ b/pandas/tests/dtypes/test_missing.py @@ -49,12 +49,12 @@ class TestIsNull(tm.TestCase): def test_0d_array(self): self.assertTrue(isnull(np.array(np.nan))) - self.assertFalse(isnull(np.array(0.0))) - self.assertFalse(isnull(np.array(0))) + assert not isnull(np.array(0.0)) + assert not isnull(np.array(0)) # test object dtype self.assertTrue(isnull(np.array(np.nan, dtype=object))) - self.assertFalse(isnull(np.array(0.0, dtype=object))) - self.assertFalse(isnull(np.array(0, dtype=object))) + assert not isnull(np.array(0.0, dtype=object)) + assert not isnull(np.array(0, dtype=object)) def test_empty_object(self): @@ -65,12 +65,12 @@ def test_empty_object(self): tm.assert_numpy_array_equal(result, expected) def test_isnull(self): - self.assertFalse(isnull(1.)) + assert not isnull(1.) self.assertTrue(isnull(None)) self.assertTrue(isnull(np.NaN)) self.assertTrue(float('nan')) - self.assertFalse(isnull(np.inf)) - self.assertFalse(isnull(-np.inf)) + assert not isnull(np.inf) + assert not isnull(-np.inf) # series for s in [tm.makeFloatSeries(), tm.makeStringSeries(), @@ -135,7 +135,7 @@ def test_isnull_numpy_nat(self): tm.assert_numpy_array_equal(result, expected) def test_isnull_datetime(self): - self.assertFalse(isnull(datetime.now())) + assert not isnull(datetime.now()) self.assertTrue(notnull(datetime.now())) idx = date_range('1/1/1990', periods=20) diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py index 45d93c187e0b7..6268ccc27c7a6 100644 --- a/pandas/tests/frame/test_analytics.py +++ b/pandas/tests/frame/test_analytics.py @@ -558,11 +558,11 @@ def test_var_std(self): arr = np.repeat(np.random.random((1, 1000)), 1000, 0) result = nanops.nanvar(arr, axis=0) - self.assertFalse((result < 0).any()) + assert not (result < 0).any() if nanops._USE_BOTTLENECK: nanops._USE_BOTTLENECK = False result = nanops.nanvar(arr, axis=0) - self.assertFalse((result < 0).any()) + assert not (result < 0).any() nanops._USE_BOTTLENECK = True def test_numeric_only_flag(self): @@ -671,11 +671,11 @@ def test_sem(self): arr = np.repeat(np.random.random((1, 1000)), 1000, 0) result = nanops.nansem(arr, axis=0) - self.assertFalse((result < 0).any()) + assert not (result < 0).any() if nanops._USE_BOTTLENECK: nanops._USE_BOTTLENECK = False result = nanops.nansem(arr, axis=0) - self.assertFalse((result < 0).any()) + assert not (result < 0).any() nanops._USE_BOTTLENECK = True def test_skew(self): @@ -1131,8 +1131,8 @@ def __nonzero__(self): r0 = getattr(all_na, name)(axis=0) r1 = getattr(all_na, name)(axis=1) if name == 'any': - self.assertFalse(r0.any()) - self.assertFalse(r1.any()) + assert not r0.any() + assert not r1.any() else: self.assertTrue(r0.all()) self.assertTrue(r1.all()) @@ -1801,13 +1801,13 @@ def test_clip(self): median = self.frame.median().median() capped = self.frame.clip_upper(median) - self.assertFalse((capped.values > median).any()) + assert not (capped.values > median).any() floored = self.frame.clip_lower(median) - self.assertFalse((floored.values < median).any()) + assert not (floored.values < median).any() double = self.frame.clip(upper=median, lower=median) - self.assertFalse((double.values != median).any()) + assert not (double.values != median).any() def test_dataframe_clip(self): # GH #2747 diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py index bd4abd6fcd822..7669de17885f8 100644 --- a/pandas/tests/frame/test_api.py +++ b/pandas/tests/frame/test_api.py @@ -141,15 +141,15 @@ def test_get_agg_axis(self): def test_nonzero(self): self.assertTrue(self.empty.empty) - self.assertFalse(self.frame.empty) - self.assertFalse(self.mixed_frame.empty) + assert not self.frame.empty + assert not self.mixed_frame.empty # corner case df = DataFrame({'A': [1., 2., 3.], 'B': ['a', 'b', 'c']}, index=np.arange(3)) del df['A'] - self.assertFalse(df.empty) + assert not df.empty def test_iteritems(self): df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=['a', 'a', 'b']) @@ -208,7 +208,7 @@ def test_itertuples(self): df3 = DataFrame(dict(('f' + str(i), [i]) for i in range(1024))) # will raise SyntaxError if trying to create namedtuple tup3 = next(df3.itertuples()) - self.assertFalse(hasattr(tup3, '_fields')) + assert not hasattr(tup3, '_fields') assert isinstance(tup3, tuple) def test_len(self): @@ -319,9 +319,9 @@ def test_series_put_names(self): def test_empty_nonzero(self): df = DataFrame([1, 2, 3]) - self.assertFalse(df.empty) + assert not df.empty df = pd.DataFrame(index=[1], columns=[1]) - self.assertFalse(df.empty) + assert not df.empty df = DataFrame(index=['a', 'b'], columns=['c', 'd']).dropna() self.assertTrue(df.empty) self.assertTrue(df.T.empty) diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py index b8be7c19203fa..61d0694eea382 100644 --- a/pandas/tests/frame/test_axis_select_reindex.py +++ b/pandas/tests/frame/test_axis_select_reindex.py @@ -129,7 +129,7 @@ def test_drop_multiindex_not_lexsorted(self): not_lexsorted_df = not_lexsorted_df.pivot_table( index='a', columns=['b', 'c'], values='d') not_lexsorted_df = not_lexsorted_df.reset_index() - self.assertFalse(not_lexsorted_df.columns.is_lexsorted()) + assert not not_lexsorted_df.columns.is_lexsorted() # compare the results tm.assert_frame_equal(lexsorted_df, not_lexsorted_df) @@ -224,7 +224,7 @@ def test_reindex(self): # copy with no axes result = self.frame.reindex() assert_frame_equal(result, self.frame) - self.assertFalse(result is self.frame) + assert result is not self.frame def test_reindex_nan(self): df = pd.DataFrame([[1, 2], [3, 5], [7, 11], [9, 23]], diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py index 5e85b890be569..37615179a3f26 100644 --- a/pandas/tests/frame/test_block_internals.py +++ b/pandas/tests/frame/test_block_internals.py @@ -69,7 +69,7 @@ def test_consolidate_inplace(self): def test_as_matrix_consolidate(self): self.frame['E'] = 7. - self.assertFalse(self.frame._data.is_consolidated()) + assert not self.frame._data.is_consolidated() _ = self.frame.as_matrix() # noqa self.assertTrue(self.frame._data.is_consolidated()) @@ -326,7 +326,7 @@ def test_copy_blocks(self): _df.loc[:, column] = _df[column] + 1 # make sure we did not change the original DataFrame - self.assertFalse(_df[column].equals(df[column])) + assert not _df[column].equals(df[column]) def test_no_copy_blocks(self): # API/ENH 9607 @@ -399,7 +399,7 @@ def test_consolidate_datetime64(self): tm.assert_index_equal(pd.DatetimeIndex(df.ending), ser_ending.index) def test_is_mixed_type(self): - self.assertFalse(self.frame._is_mixed_type) + assert not self.frame._is_mixed_type self.assertTrue(self.mixed_frame._is_mixed_type) def test_get_numeric_data(self): diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py index db0293b71c3a3..e9a6f03abbe8d 100644 --- a/pandas/tests/frame/test_constructors.py +++ b/pandas/tests/frame/test_constructors.py @@ -1452,7 +1452,7 @@ def test_constructor_frame_copy(self): cop = DataFrame(self.frame, copy=True) cop['A'] = 5 self.assertTrue((cop['A'] == 5).all()) - self.assertFalse((self.frame['A'] == 5).all()) + assert not (self.frame['A'] == 5).all() def test_constructor_ndarray_copy(self): df = DataFrame(self.frame.values) @@ -1462,7 +1462,7 @@ def test_constructor_ndarray_copy(self): df = DataFrame(self.frame.values, copy=True) self.frame.values[6] = 6 - self.assertFalse((df.values[6] == 6).all()) + assert not (df.values[6] == 6).all() def test_constructor_series_copy(self): series = self.frame._series @@ -1470,7 +1470,7 @@ def test_constructor_series_copy(self): df = DataFrame({'A': series['A']}) df['A'][:] = 5 - self.assertFalse((series['A'] == 5).all()) + assert not (series['A'] == 5).all() def test_constructor_with_nas(self): # GH 5016 @@ -1512,7 +1512,7 @@ def test_constructor_lists_to_object_dtype(self): # from #1074 d = DataFrame({'a': [np.nan, False]}) self.assertEqual(d['a'].dtype, np.object_) - self.assertFalse(d['a'][1]) + assert not d['a'][1] def test_from_records_to_records(self): # from numpy documentation diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py index be4e69fe99a4e..ebc125ae09818 100644 --- a/pandas/tests/frame/test_indexing.py +++ b/pandas/tests/frame/test_indexing.py @@ -1938,7 +1938,7 @@ def test_reindex_frame_add_nat(self): mask = com.isnull(result)['B'] self.assertTrue(mask[-5:].all()) - self.assertFalse(mask[:-5].any()) + assert not mask[:-5].any() def test_set_dataframe_column_ns_dtype(self): x = DataFrame([datetime.now(), datetime.now()]) @@ -2940,8 +2940,7 @@ def test_setitem(self): b1 = df._data.blocks[1] b2 = df._data.blocks[2] self.assertTrue(b1.values.equals(b2.values)) - self.assertFalse(id(b1.values.values.base) == - id(b2.values.values.base)) + assert id(b1.values.values.base) != id(b2.values.values.base) # with nan df2 = df.copy() diff --git a/pandas/tests/frame/test_mutate_columns.py b/pandas/tests/frame/test_mutate_columns.py index b82a549bae3a0..d5035f2908528 100644 --- a/pandas/tests/frame/test_mutate_columns.py +++ b/pandas/tests/frame/test_mutate_columns.py @@ -223,7 +223,7 @@ def test_pop_non_unique_cols(self): self.assertEqual(len(res), 2) self.assertEqual(len(df.columns), 1) self.assertTrue("b" in df.columns) - self.assertFalse("a" in df.columns) + assert "a" not in df.columns self.assertEqual(len(df.index), 2) def test_insert_column_bug_4032(self): diff --git a/pandas/tests/frame/test_operators.py b/pandas/tests/frame/test_operators.py index d90e859509454..7f87666d5ecc4 100644 --- a/pandas/tests/frame/test_operators.py +++ b/pandas/tests/frame/test_operators.py @@ -236,7 +236,7 @@ def test_modulo(self): s = p[0] res = s % p res2 = p % s - self.assertFalse(np.array_equal(res.fillna(0), res2.fillna(0))) + assert not np.array_equal(res.fillna(0), res2.fillna(0)) def test_div(self): @@ -270,7 +270,7 @@ def test_div(self): s = p[0] res = s / p res2 = p / s - self.assertFalse(np.array_equal(res.fillna(0), res2.fillna(0))) + assert not np.array_equal(res.fillna(0), res2.fillna(0)) def test_logical_operators(self): @@ -574,7 +574,7 @@ def _check_unaligned_frame(meth, op, df, other): # DataFrame self.assertTrue(df.eq(df).values.all()) - self.assertFalse(df.ne(df).values.any()) + assert not df.ne(df).values.any() for op in ['eq', 'ne', 'gt', 'lt', 'ge', 'le']: f = getattr(df, op) o = getattr(operator, op) @@ -634,17 +634,17 @@ def _test_seq(df, idx_ser, col_ser): # NA df.loc[0, 0] = np.nan rs = df.eq(df) - self.assertFalse(rs.loc[0, 0]) + assert not rs.loc[0, 0] rs = df.ne(df) self.assertTrue(rs.loc[0, 0]) rs = df.gt(df) - self.assertFalse(rs.loc[0, 0]) + assert not rs.loc[0, 0] rs = df.lt(df) - self.assertFalse(rs.loc[0, 0]) + assert not rs.loc[0, 0] rs = df.ge(df) - self.assertFalse(rs.loc[0, 0]) + assert not rs.loc[0, 0] rs = df.le(df) - self.assertFalse(rs.loc[0, 0]) + assert not rs.loc[0, 0] # complex arr = np.array([np.nan, 1, 6, np.nan]) @@ -652,14 +652,14 @@ def _test_seq(df, idx_ser, col_ser): df = DataFrame({'a': arr}) df2 = DataFrame({'a': arr2}) rs = df.gt(df2) - self.assertFalse(rs.values.any()) + assert not rs.values.any() rs = df.ne(df2) self.assertTrue(rs.values.all()) arr3 = np.array([2j, np.nan, None]) df3 = DataFrame({'a': arr3}) rs = df3.gt(2j) - self.assertFalse(rs.values.any()) + assert not rs.values.any() # corner, dtype=object df1 = DataFrame({'col': ['foo', np.nan, 'bar']}) @@ -1021,7 +1021,7 @@ def test_boolean_comparison(self): assert_numpy_array_equal(result, expected.values) pytest.raises(ValueError, lambda: df == b_c) - self.assertFalse(np.array_equal(df.values, b_c)) + assert not np.array_equal(df.values, b_c) # with alignment df = DataFrame(np.arange(6).reshape((3, 2)), diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py index 630fa5ad57fad..bcb85b6e44d54 100644 --- a/pandas/tests/frame/test_repr_info.py +++ b/pandas/tests/frame/test_repr_info.py @@ -72,9 +72,9 @@ def test_repr(self): self.empty.info(buf=buf) df = DataFrame(["a\n\r\tb"], columns=["a\n\r\td"], index=["a\n\r\tf"]) - self.assertFalse("\t" in repr(df)) - self.assertFalse("\r" in repr(df)) - self.assertFalse("a\n" in repr(df)) + assert "\t" not in repr(df) + assert "\r" not in repr(df) + assert "a\n" not in repr(df) def test_repr_dimensions(self): df = DataFrame([[1, 2, ], [3, 4]]) @@ -82,10 +82,10 @@ def test_repr_dimensions(self): self.assertTrue("2 rows x 2 columns" in repr(df)) with option_context('display.show_dimensions', False): - self.assertFalse("2 rows x 2 columns" in repr(df)) + assert "2 rows x 2 columns" not in repr(df) with option_context('display.show_dimensions', 'truncate'): - self.assertFalse("2 rows x 2 columns" in repr(df)) + assert "2 rows x 2 columns" not in repr(df) @tm.slow def test_repr_big(self): @@ -320,7 +320,7 @@ def test_info_memory_usage(self): res = buf.getvalue().splitlines() # excluded column with object dtype, so estimate is accurate - self.assertFalse(re.match(r"memory usage: [^+]+\+", res[-1])) + assert not re.match(r"memory usage: [^+]+\+", res[-1]) df_with_object_index = pd.DataFrame({'a': [1]}, index=['foo']) df_with_object_index.info(buf=buf, memory_usage=True) @@ -388,7 +388,7 @@ def test_info_memory_usage_qualified(self): df = DataFrame(1, columns=list('ab'), index=[1, 2, 3]) df.info(buf=buf) - self.assertFalse('+' in buf.getvalue()) + assert '+' not in buf.getvalue() buf = StringIO() df = DataFrame(1, columns=list('ab'), @@ -401,7 +401,7 @@ def test_info_memory_usage_qualified(self): index=pd.MultiIndex.from_product( [range(3), range(3)])) df.info(buf=buf) - self.assertFalse('+' in buf.getvalue()) + assert '+' not in buf.getvalue() buf = StringIO() df = DataFrame(1, columns=list('ab'), diff --git a/pandas/tests/frame/test_timeseries.py b/pandas/tests/frame/test_timeseries.py index 7a5afa178208a..66af6aaca6513 100644 --- a/pandas/tests/frame/test_timeseries.py +++ b/pandas/tests/frame/test_timeseries.py @@ -350,7 +350,7 @@ def test_truncate_copy(self): index = self.tsframe.index truncated = self.tsframe.truncate(index[5], index[10]) truncated.values[:] = 5. - self.assertFalse((self.tsframe.values[5:11] == 5).any()) + assert not (self.tsframe.values[5:11] == 5).any() def test_asfreq(self): offset_monthly = self.tsframe.asfreq(offsets.BMonthEnd()) diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py index 177c2345ea143..0696473d0449f 100644 --- a/pandas/tests/groupby/test_groupby.py +++ b/pandas/tests/groupby/test_groupby.py @@ -330,7 +330,7 @@ def test_grouper_column_index_level_precedence(self): expected = df_multi_both.groupby([pd.Grouper(key='inner')]).mean() assert_frame_equal(result, expected) not_expected = df_multi_both.groupby(pd.Grouper(level='inner')).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) # Group single Index by single key with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): @@ -339,7 +339,7 @@ def test_grouper_column_index_level_precedence(self): expected = df_single_both.groupby([pd.Grouper(key='inner')]).mean() assert_frame_equal(result, expected) not_expected = df_single_both.groupby(pd.Grouper(level='inner')).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) # Group MultiIndex by single key list with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): @@ -348,7 +348,7 @@ def test_grouper_column_index_level_precedence(self): expected = df_multi_both.groupby([pd.Grouper(key='inner')]).mean() assert_frame_equal(result, expected) not_expected = df_multi_both.groupby(pd.Grouper(level='inner')).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) # Group single Index by single key list with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): @@ -357,7 +357,7 @@ def test_grouper_column_index_level_precedence(self): expected = df_single_both.groupby([pd.Grouper(key='inner')]).mean() assert_frame_equal(result, expected) not_expected = df_single_both.groupby(pd.Grouper(level='inner')).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) # Group MultiIndex by two keys (1) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): @@ -369,7 +369,7 @@ def test_grouper_column_index_level_precedence(self): not_expected = df_multi_both.groupby(['B', pd.Grouper(level='inner') ]).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) # Group MultiIndex by two keys (2) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): @@ -380,7 +380,7 @@ def test_grouper_column_index_level_precedence(self): assert_frame_equal(result, expected) not_expected = df_multi_both.groupby([pd.Grouper(level='inner'), 'B']).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) # Group single Index by two keys (1) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): @@ -392,7 +392,7 @@ def test_grouper_column_index_level_precedence(self): not_expected = df_single_both.groupby(['B', pd.Grouper(level='inner') ]).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) # Group single Index by two keys (2) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): @@ -403,7 +403,7 @@ def test_grouper_column_index_level_precedence(self): assert_frame_equal(result, expected) not_expected = df_single_both.groupby([pd.Grouper(level='inner'), 'B']).mean() - self.assertFalse(result.index.equals(not_expected.index)) + assert not result.index.equals(not_expected.index) def test_grouper_getting_correct_binner(self): @@ -2626,7 +2626,7 @@ def f(g): group_keys = grouper._get_group_keys() values, mutated = splitter.fast_apply(f, group_keys) - self.assertFalse(mutated) + assert not mutated def test_apply_with_mixed_dtype(self): # GH3480, apply with mixed dtype on axis=1 breaks in 0.11 @@ -3263,7 +3263,7 @@ def test_groupby_multiindex_not_lexsorted(self): not_lexsorted_df = not_lexsorted_df.pivot_table( index='a', columns=['b', 'c'], values='d') not_lexsorted_df = not_lexsorted_df.reset_index() - self.assertFalse(not_lexsorted_df.columns.is_lexsorted()) + assert not not_lexsorted_df.columns.is_lexsorted() # compare the results tm.assert_frame_equal(lexsorted_df, not_lexsorted_df) @@ -3278,7 +3278,7 @@ def test_groupby_multiindex_not_lexsorted(self): df = DataFrame({'x': ['a', 'a', 'b', 'a'], 'y': [1, 1, 2, 2], 'z': [1, 2, 3, 4]}).set_index(['x', 'y']) - self.assertFalse(df.index.is_lexsorted()) + assert not df.index.is_lexsorted() for level in [0, 1, [0, 1]]: for sort in [False, True]: @@ -3595,7 +3595,7 @@ def test_max_nan_bug(self): r = gb[['File']].max() e = gb['File'].max().to_frame() tm.assert_frame_equal(r, e) - self.assertFalse(r['File'].isnull().any()) + assert not r['File'].isnull().any() def test_nlargest(self): a = Series([1, 3, 5, 7, 2, 9, 0, 4, 6, 10]) diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py index 56a9af73e904a..23b1de76234c3 100644 --- a/pandas/tests/indexes/common.py +++ b/pandas/tests/indexes/common.py @@ -170,7 +170,7 @@ def test_repr_max_seq_item_setting(self): idx = idx.repeat(50) with pd.option_context("display.max_seq_items", None): repr(idx) - self.assertFalse('...' in str(idx)) + assert '...' not in str(idx) def test_wrong_number_names(self): def testit(ind): @@ -303,7 +303,7 @@ def test_duplicates(self): if isinstance(ind, MultiIndex): continue idx = self._holder([ind[0]] * 5) - self.assertFalse(idx.is_unique) + assert not idx.is_unique self.assertTrue(idx.has_duplicates) # GH 10115 @@ -327,7 +327,7 @@ def test_get_unique_index(self): # and doesn't contain nans. self.assertTrue(idx_unique.is_unique) try: - self.assertFalse(idx_unique.hasnans) + assert not idx_unique.hasnans except NotImplementedError: pass @@ -705,8 +705,8 @@ def test_equals(self): self.assertTrue(idx.equals(idx.copy())) self.assertTrue(idx.equals(idx.astype(object))) - self.assertFalse(idx.equals(list(idx))) - self.assertFalse(idx.equals(np.array(idx))) + assert not idx.equals(list(idx)) + assert not idx.equals(np.array(idx)) # Cannot pass in non-int64 dtype to RangeIndex if not isinstance(idx, RangeIndex): @@ -716,7 +716,7 @@ def test_equals(self): if idx.nlevels == 1: # do not test MultiIndex - self.assertFalse(idx.equals(pd.Series(idx))) + assert not idx.equals(pd.Series(idx)) def test_equals_op(self): # GH9947, GH10637 @@ -843,7 +843,7 @@ def test_hasnans_isnans(self): # cases in indices doesn't include NaN expected = np.array([False] * len(idx), dtype=bool) tm.assert_numpy_array_equal(idx._isnan, expected) - self.assertFalse(idx.hasnans) + assert not idx.hasnans idx = index.copy() values = idx.values @@ -881,7 +881,7 @@ def test_fillna(self): idx = index.copy() result = idx.fillna(idx[0]) tm.assert_index_equal(result, idx) - self.assertFalse(result is idx) + assert result is not idx msg = "'value' must be a scalar, passed: " with tm.assert_raises_regex(TypeError, msg): @@ -935,5 +935,5 @@ def test_nulls(self): def test_empty(self): # GH 15270 index = self.create_index() - self.assertFalse(index.empty) + assert not index.empty self.assertTrue(index[:0].empty) diff --git a/pandas/tests/indexes/datetimelike.py b/pandas/tests/indexes/datetimelike.py index 470c0c2aad01a..338dba9ef6c4f 100644 --- a/pandas/tests/indexes/datetimelike.py +++ b/pandas/tests/indexes/datetimelike.py @@ -16,7 +16,7 @@ def test_str(self): # test the string repr idx = self.create_index() idx.name = 'foo' - self.assertFalse("length=%s" % len(idx) in str(idx)) + assert not "length=%s" % len(idx) in str(idx) self.assertTrue("'foo'" in str(idx)) self.assertTrue(idx.__class__.__name__ in str(idx)) diff --git a/pandas/tests/indexes/datetimes/test_astype.py b/pandas/tests/indexes/datetimes/test_astype.py index 755944d342ed4..7e695164db971 100644 --- a/pandas/tests/indexes/datetimes/test_astype.py +++ b/pandas/tests/indexes/datetimes/test_astype.py @@ -101,7 +101,7 @@ def test_astype_datetime64(self): result = idx.astype('datetime64[ns]') tm.assert_index_equal(result, idx) - self.assertFalse(result is idx) + assert result is not idx result = idx.astype('datetime64[ns]', copy=False) tm.assert_index_equal(result, idx) diff --git a/pandas/tests/indexes/datetimes/test_construction.py b/pandas/tests/indexes/datetimes/test_construction.py index ea9f7c65fb49b..8ce2085032ca1 100644 --- a/pandas/tests/indexes/datetimes/test_construction.py +++ b/pandas/tests/indexes/datetimes/test_construction.py @@ -493,7 +493,7 @@ def test_is_(self): dti = DatetimeIndex(start='1/1/2005', end='12/1/2005', freq='M') self.assertTrue(dti.is_(dti)) self.assertTrue(dti.is_(dti.view())) - self.assertFalse(dti.is_(dti.copy())) + assert not dti.is_(dti.copy()) def test_index_cast_datetime64_other_units(self): arr = np.arange(0, 100, 10, dtype=np.int64).view('M8[D]') diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py index 8a4cff2974b0d..7ba9bf53abc4d 100644 --- a/pandas/tests/indexes/datetimes/test_datetime.py +++ b/pandas/tests/indexes/datetimes/test_datetime.py @@ -399,10 +399,10 @@ def test_misc_coverage(self): assert isinstance(list(result.values())[0][0], Timestamp) idx = DatetimeIndex(['2000-01-03', '2000-01-01', '2000-01-02']) - self.assertFalse(idx.equals(list(idx))) + assert not idx.equals(list(idx)) non_datetime = Index(list('abc')) - self.assertFalse(idx.equals(list(non_datetime))) + assert not idx.equals(list(non_datetime)) def test_string_index_series_name_converted(self): # #1644 diff --git a/pandas/tests/indexes/datetimes/test_misc.py b/pandas/tests/indexes/datetimes/test_misc.py index 4c7235fea63e8..22e77eebec06b 100644 --- a/pandas/tests/indexes/datetimes/test_misc.py +++ b/pandas/tests/indexes/datetimes/test_misc.py @@ -167,7 +167,7 @@ def test_normalize(self): tm.assert_index_equal(rng_ns_normalized, expected) self.assertTrue(result.is_normalized) - self.assertFalse(rng.is_normalized) + assert not rng.is_normalized class TestDatetime64(tm.TestCase): diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py index 020bb0e27d9de..7e42e5e3db7ef 100644 --- a/pandas/tests/indexes/datetimes/test_ops.py +++ b/pandas/tests/indexes/datetimes/test_ops.py @@ -103,7 +103,7 @@ def test_minmax(self): # non-monotonic idx2 = pd.DatetimeIndex(['2011-01-01', pd.NaT, '2011-01-03', '2011-01-02', pd.NaT], tz=tz) - self.assertFalse(idx2.is_monotonic) + assert not idx2.is_monotonic for idx in [idx1, idx2]: self.assertEqual(idx.min(), Timestamp('2011-01-01', tz=tz)) @@ -889,7 +889,7 @@ def test_nat(self): self.assertTrue(idx._can_hold_na) tm.assert_numpy_array_equal(idx._isnan, np.array([False, False])) - self.assertFalse(idx.hasnans) + assert not idx.hasnans tm.assert_numpy_array_equal(idx._nan_idxs, np.array([], dtype=np.intp)) @@ -910,27 +910,27 @@ def test_equals(self): self.assertTrue(idx.equals(idx.asobject)) self.assertTrue(idx.asobject.equals(idx)) self.assertTrue(idx.asobject.equals(idx.asobject)) - self.assertFalse(idx.equals(list(idx))) - self.assertFalse(idx.equals(pd.Series(idx))) + assert not idx.equals(list(idx)) + assert not idx.equals(pd.Series(idx)) idx2 = pd.DatetimeIndex(['2011-01-01', '2011-01-02', 'NaT'], tz='US/Pacific') - self.assertFalse(idx.equals(idx2)) - self.assertFalse(idx.equals(idx2.copy())) - self.assertFalse(idx.equals(idx2.asobject)) - self.assertFalse(idx.asobject.equals(idx2)) - self.assertFalse(idx.equals(list(idx2))) - self.assertFalse(idx.equals(pd.Series(idx2))) + assert not idx.equals(idx2) + assert not idx.equals(idx2.copy()) + assert not idx.equals(idx2.asobject) + assert not idx.asobject.equals(idx2) + assert not idx.equals(list(idx2)) + assert not idx.equals(pd.Series(idx2)) # same internal, different tz idx3 = pd.DatetimeIndex._simple_new(idx.asi8, tz='US/Pacific') tm.assert_numpy_array_equal(idx.asi8, idx3.asi8) - self.assertFalse(idx.equals(idx3)) - self.assertFalse(idx.equals(idx3.copy())) - self.assertFalse(idx.equals(idx3.asobject)) - self.assertFalse(idx.asobject.equals(idx3)) - self.assertFalse(idx.equals(list(idx3))) - self.assertFalse(idx.equals(pd.Series(idx3))) + assert not idx.equals(idx3) + assert not idx.equals(idx3.copy()) + assert not idx.equals(idx3.asobject) + assert not idx.asobject.equals(idx3) + assert not idx.equals(list(idx3)) + assert not idx.equals(pd.Series(idx3)) class TestDateTimeIndexToJulianDate(tm.TestCase): @@ -1119,7 +1119,7 @@ def test_comparison(self): comp = self.rng > d self.assertTrue(comp[11]) - self.assertFalse(comp[9]) + assert not comp[9] def test_pickle_unpickle(self): unpickled = tm.round_trip_pickle(self.rng) @@ -1189,7 +1189,7 @@ def test_summary_dateutil(self): bdate_range('1/1/2005', '1/1/2009', tz=dateutil.tz.tzutc()).summary() def test_equals(self): - self.assertFalse(self.rng.equals(list(self.rng))) + assert not self.rng.equals(list(self.rng)) def test_identical(self): t1 = self.rng.copy() @@ -1199,14 +1199,14 @@ def test_identical(self): # name t1 = t1.rename('foo') self.assertTrue(t1.equals(t2)) - self.assertFalse(t1.identical(t2)) + assert not t1.identical(t2) t2 = t2.rename('foo') self.assertTrue(t1.identical(t2)) # freq t2v = Index(t2.values) self.assertTrue(t1.equals(t2v)) - self.assertFalse(t1.identical(t2v)) + assert not t1.identical(t2v) class TestCustomDatetimeIndex(tm.TestCase): @@ -1219,7 +1219,7 @@ def test_comparison(self): comp = self.rng > d self.assertTrue(comp[11]) - self.assertFalse(comp[9]) + assert not comp[9] def test_copy(self): cp = self.rng.copy() @@ -1291,4 +1291,4 @@ def test_summary_dateutil(self): cdate_range('1/1/2005', '1/1/2009', tz=dateutil.tz.tzutc()).summary() def test_equals(self): - self.assertFalse(self.rng.equals(list(self.rng))) + assert not self.rng.equals(list(self.rng)) diff --git a/pandas/tests/indexes/datetimes/test_tools.py b/pandas/tests/indexes/datetimes/test_tools.py index 715825417cd31..941c9767e7a3a 100644 --- a/pandas/tests/indexes/datetimes/test_tools.py +++ b/pandas/tests/indexes/datetimes/test_tools.py @@ -1027,8 +1027,7 @@ def test_does_not_convert_mixed_integer(self): bad_date_strings = ('-50000', '999', '123.1234', 'm', 'T') for bad_date_string in bad_date_strings: - self.assertFalse(tslib._does_string_look_like_datetime( - bad_date_string)) + assert not tslib._does_string_look_like_datetime(bad_date_string) good_date_strings = ('2012-01-01', '01/01/2012', diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py index 70c0879a0871a..f133845f8404a 100644 --- a/pandas/tests/indexes/period/test_ops.py +++ b/pandas/tests/indexes/period/test_ops.py @@ -74,7 +74,7 @@ def test_minmax(self): # non-monotonic idx2 = pd.PeriodIndex(['2011-01-01', pd.NaT, '2011-01-03', '2011-01-02', pd.NaT], freq='D') - self.assertFalse(idx2.is_monotonic) + assert not idx2.is_monotonic for idx in [idx1, idx2]: self.assertEqual(idx.min(), pd.Period('2011-01-01', freq='D')) @@ -806,7 +806,7 @@ def test_nat(self): self.assertTrue(idx._can_hold_na) tm.assert_numpy_array_equal(idx._isnan, np.array([False, False])) - self.assertFalse(idx.hasnans) + assert not idx.hasnans tm.assert_numpy_array_equal(idx._nan_idxs, np.array([], dtype=np.intp)) @@ -828,27 +828,27 @@ def test_equals(self): self.assertTrue(idx.equals(idx.asobject)) self.assertTrue(idx.asobject.equals(idx)) self.assertTrue(idx.asobject.equals(idx.asobject)) - self.assertFalse(idx.equals(list(idx))) - self.assertFalse(idx.equals(pd.Series(idx))) + assert not idx.equals(list(idx)) + assert not idx.equals(pd.Series(idx)) idx2 = pd.PeriodIndex(['2011-01-01', '2011-01-02', 'NaT'], freq='H') - self.assertFalse(idx.equals(idx2)) - self.assertFalse(idx.equals(idx2.copy())) - self.assertFalse(idx.equals(idx2.asobject)) - self.assertFalse(idx.asobject.equals(idx2)) - self.assertFalse(idx.equals(list(idx2))) - self.assertFalse(idx.equals(pd.Series(idx2))) + assert not idx.equals(idx2) + assert not idx.equals(idx2.copy()) + assert not idx.equals(idx2.asobject) + assert not idx.asobject.equals(idx2) + assert not idx.equals(list(idx2)) + assert not idx.equals(pd.Series(idx2)) # same internal, different tz idx3 = pd.PeriodIndex._simple_new(idx.asi8, freq='H') tm.assert_numpy_array_equal(idx.asi8, idx3.asi8) - self.assertFalse(idx.equals(idx3)) - self.assertFalse(idx.equals(idx3.copy())) - self.assertFalse(idx.equals(idx3.asobject)) - self.assertFalse(idx.asobject.equals(idx3)) - self.assertFalse(idx.equals(list(idx3))) - self.assertFalse(idx.equals(pd.Series(idx3))) + assert not idx.equals(idx3) + assert not idx.equals(idx3.copy()) + assert not idx.equals(idx3.asobject) + assert not idx.asobject.equals(idx3) + assert not idx.equals(list(idx3)) + assert not idx.equals(pd.Series(idx3)) class TestPeriodIndexSeriesMethods(tm.TestCase): diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py index e563f683bf8ca..df3f6023a6506 100644 --- a/pandas/tests/indexes/period/test_period.py +++ b/pandas/tests/indexes/period/test_period.py @@ -512,16 +512,16 @@ def test_contains(self): rng = period_range('2007-01', freq='M', periods=10) self.assertTrue(Period('2007-01', freq='M') in rng) - self.assertFalse(Period('2007-01', freq='D') in rng) - self.assertFalse(Period('2007-01', freq='2M') in rng) + assert not Period('2007-01', freq='D') in rng + assert not Period('2007-01', freq='2M') in rng def test_contains_nat(self): - # GH13582 + # see gh-13582 idx = period_range('2007-01', freq='M', periods=10) - self.assertFalse(pd.NaT in idx) - self.assertFalse(None in idx) - self.assertFalse(float('nan') in idx) - self.assertFalse(np.nan in idx) + assert pd.NaT not in idx + assert None not in idx + assert float('nan') not in idx + assert np.nan not in idx idx = pd.PeriodIndex(['2011-01', 'NaT', '2011-02'], freq='M') self.assertTrue(pd.NaT in idx) @@ -709,13 +709,13 @@ def test_iteration(self): def test_is_full(self): index = PeriodIndex([2005, 2007, 2009], freq='A') - self.assertFalse(index.is_full) + assert not index.is_full index = PeriodIndex([2005, 2006, 2007], freq='A') self.assertTrue(index.is_full) index = PeriodIndex([2005, 2005, 2007], freq='A') - self.assertFalse(index.is_full) + assert not index.is_full index = PeriodIndex([2005, 2005, 2006], freq='A') self.assertTrue(index.is_full) diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py index caf2dde249600..2f07cf3c8270f 100644 --- a/pandas/tests/indexes/test_base.py +++ b/pandas/tests/indexes/test_base.py @@ -414,13 +414,13 @@ def test_equals_object(self): self.assertTrue(Index(['a', 'b', 'c']).equals(Index(['a', 'b', 'c']))) # different length - self.assertFalse(Index(['a', 'b', 'c']).equals(Index(['a', 'b']))) + assert not Index(['a', 'b', 'c']).equals(Index(['a', 'b'])) # same length, different values - self.assertFalse(Index(['a', 'b', 'c']).equals(Index(['a', 'b', 'd']))) + assert not Index(['a', 'b', 'c']).equals(Index(['a', 'b', 'd'])) # Must also be an Index - self.assertFalse(Index(['a', 'b', 'c']).equals(['a', 'b', 'c'])) + assert not Index(['a', 'b', 'c']).equals(['a', 'b', 'c']) def test_insert(self): @@ -470,25 +470,25 @@ def test_identical(self): i1 = i1.rename('foo') self.assertTrue(i1.equals(i2)) - self.assertFalse(i1.identical(i2)) + assert not i1.identical(i2) i2 = i2.rename('foo') self.assertTrue(i1.identical(i2)) i3 = Index([('a', 'a'), ('a', 'b'), ('b', 'a')]) i4 = Index([('a', 'a'), ('a', 'b'), ('b', 'a')], tupleize_cols=False) - self.assertFalse(i3.identical(i4)) + assert not i3.identical(i4) def test_is_(self): ind = Index(range(10)) self.assertTrue(ind.is_(ind)) self.assertTrue(ind.is_(ind.view().view().view().view())) - self.assertFalse(ind.is_(Index(range(10)))) - self.assertFalse(ind.is_(ind.copy())) - self.assertFalse(ind.is_(ind.copy(deep=False))) - self.assertFalse(ind.is_(ind[:])) - self.assertFalse(ind.is_(ind.view(np.ndarray).view(Index))) - self.assertFalse(ind.is_(np.array(range(10)))) + assert not ind.is_(Index(range(10))) + assert not ind.is_(ind.copy()) + assert not ind.is_(ind.copy(deep=False)) + assert not ind.is_(ind[:]) + assert not ind.is_(ind.view(np.ndarray).view(Index)) + assert not ind.is_(np.array(range(10))) # quasi-implementation dependent self.assertTrue(ind.is_(ind.view())) @@ -497,11 +497,11 @@ def test_is_(self): self.assertTrue(ind.is_(ind2)) self.assertTrue(ind2.is_(ind)) # doesn't matter if Indices are *actually* views of underlying data, - self.assertFalse(ind.is_(Index(ind.values))) + assert not ind.is_(Index(ind.values)) arr = np.array(range(1, 11)) ind1 = Index(arr, copy=False) ind2 = Index(arr, copy=False) - self.assertFalse(ind1.is_(ind2)) + assert not ind1.is_(ind2) def test_asof(self): d = self.dateIndex[0] @@ -519,7 +519,7 @@ def test_asof_datetime_partial(self): expected = Timestamp('2010-02-28') result = idx.asof('2010-02') self.assertEqual(result, expected) - self.assertFalse(isinstance(result, Index)) + assert not isinstance(result, Index) def test_nanosecond_index_access(self): s = Series([Timestamp('20130101')]).values.view('i8')[0] @@ -938,24 +938,24 @@ def test_symmetric_difference(self): self.assertEqual(result.name, 'new_name') def test_is_numeric(self): - self.assertFalse(self.dateIndex.is_numeric()) - self.assertFalse(self.strIndex.is_numeric()) + assert not self.dateIndex.is_numeric() + assert not self.strIndex.is_numeric() self.assertTrue(self.intIndex.is_numeric()) self.assertTrue(self.floatIndex.is_numeric()) - self.assertFalse(self.catIndex.is_numeric()) + assert not self.catIndex.is_numeric() def test_is_object(self): self.assertTrue(self.strIndex.is_object()) self.assertTrue(self.boolIndex.is_object()) - self.assertFalse(self.catIndex.is_object()) - self.assertFalse(self.intIndex.is_object()) - self.assertFalse(self.dateIndex.is_object()) - self.assertFalse(self.floatIndex.is_object()) + assert not self.catIndex.is_object() + assert not self.intIndex.is_object() + assert not self.dateIndex.is_object() + assert not self.floatIndex.is_object() def test_is_all_dates(self): self.assertTrue(self.dateIndex.is_all_dates) - self.assertFalse(self.strIndex.is_all_dates) - self.assertFalse(self.intIndex.is_all_dates) + assert not self.strIndex.is_all_dates + assert not self.intIndex.is_all_dates def test_summary(self): self._check_method_works(Index.summary) @@ -1331,8 +1331,8 @@ def test_tuple_union_bug(self): def test_is_monotonic_incomparable(self): index = Index([5, datetime.now(), 7]) - self.assertFalse(index.is_monotonic) - self.assertFalse(index.is_monotonic_decreasing) + assert not index.is_monotonic + assert not index.is_monotonic_decreasing def test_get_set_value(self): values = np.random.randn(100) @@ -2031,8 +2031,8 @@ def test_is_monotonic_na(self): pd.to_datetime(['2000-01-01', 'NaT', '2000-01-02']), pd.to_timedelta(['1 day', 'NaT']), ] for index in examples: - self.assertFalse(index.is_monotonic_increasing) - self.assertFalse(index.is_monotonic_decreasing) + assert not index.is_monotonic_increasing + assert not index.is_monotonic_decreasing def test_repr_summary(self): with cf.option_context('display.max_seq_items', 10): diff --git a/pandas/tests/indexes/test_category.py b/pandas/tests/indexes/test_category.py index 5dcd45e8c85b0..5c9df55d2b508 100644 --- a/pandas/tests/indexes/test_category.py +++ b/pandas/tests/indexes/test_category.py @@ -183,8 +183,8 @@ def test_contains(self): self.assertTrue(np.nan not in ci) # assert codes NOT in index - self.assertFalse(0 in ci) - self.assertFalse(1 in ci) + assert 0 not in ci + assert 1 not in ci ci = CategoricalIndex( list('aabbca') + [np.nan], categories=list('cabdef')) @@ -423,7 +423,7 @@ def test_reindex_dtype(self): def test_duplicates(self): idx = CategoricalIndex([0, 0, 0], name='foo') - self.assertFalse(idx.is_unique) + assert not idx.is_unique self.assertTrue(idx.has_duplicates) expected = CategoricalIndex([0], name='foo') @@ -539,7 +539,7 @@ def test_identical(self): ordered=True) self.assertTrue(ci1.identical(ci1)) self.assertTrue(ci1.identical(ci1.copy())) - self.assertFalse(ci1.identical(ci2)) + assert not ci1.identical(ci2) def test_ensure_copied_data(self): # gh-12309: Check the "copy" argument of each @@ -563,18 +563,18 @@ def test_equals_categorical(self): ordered=True) self.assertTrue(ci1.equals(ci1)) - self.assertFalse(ci1.equals(ci2)) + assert not ci1.equals(ci2) self.assertTrue(ci1.equals(ci1.astype(object))) self.assertTrue(ci1.astype(object).equals(ci1)) self.assertTrue((ci1 == ci1).all()) - self.assertFalse((ci1 != ci1).all()) - self.assertFalse((ci1 > ci1).all()) - self.assertFalse((ci1 < ci1).all()) + assert not (ci1 != ci1).all() + assert not (ci1 > ci1).all() + assert not (ci1 < ci1).all() self.assertTrue((ci1 <= ci1).all()) self.assertTrue((ci1 >= ci1).all()) - self.assertFalse((ci1 == 1).all()) + assert not (ci1 == 1).all() self.assertTrue((ci1 == Index(['a', 'b'])).all()) self.assertTrue((ci1 == ci1.values).all()) @@ -591,20 +591,20 @@ def test_equals_categorical(self): # tests # make sure that we are testing for category inclusion properly ci = CategoricalIndex(list('aabca'), categories=['c', 'a', 'b']) - self.assertFalse(ci.equals(list('aabca'))) - self.assertFalse(ci.equals(CategoricalIndex(list('aabca')))) + assert not ci.equals(list('aabca')) + assert not ci.equals(CategoricalIndex(list('aabca'))) self.assertTrue(ci.equals(ci.copy())) ci = CategoricalIndex(list('aabca') + [np.nan], categories=['c', 'a', 'b']) - self.assertFalse(ci.equals(list('aabca'))) - self.assertFalse(ci.equals(CategoricalIndex(list('aabca')))) + assert not ci.equals(list('aabca')) + assert not ci.equals(CategoricalIndex(list('aabca'))) self.assertTrue(ci.equals(ci.copy())) ci = CategoricalIndex(list('aabca') + [np.nan], categories=['c', 'a', 'b']) - self.assertFalse(ci.equals(list('aabca') + [np.nan])) - self.assertFalse(ci.equals(CategoricalIndex(list('aabca') + [np.nan]))) + assert not ci.equals(list('aabca') + [np.nan]) + assert not ci.equals(CategoricalIndex(list('aabca') + [np.nan])) self.assertTrue(ci.equals(ci.copy())) def test_string_categorical_index_repr(self): diff --git a/pandas/tests/indexes/test_interval.py b/pandas/tests/indexes/test_interval.py index ec56791a6ec67..2e16e16e0b2c4 100644 --- a/pandas/tests/indexes/test_interval.py +++ b/pandas/tests/indexes/test_interval.py @@ -30,7 +30,7 @@ def test_constructors(self): self.assertTrue(expected.equals(actual)) alternate = IntervalIndex.from_breaks(np.arange(3), closed='left') - self.assertFalse(expected.equals(alternate)) + assert not expected.equals(alternate) actual = IntervalIndex.from_intervals([Interval(0, 1), Interval(1, 2)]) self.assertTrue(expected.equals(actual)) @@ -151,7 +151,7 @@ def test_properties(self): def test_with_nans(self): index = self.index - self.assertFalse(index.hasnans) + assert not index.hasnans tm.assert_numpy_array_equal(index.isnull(), np.array([False, False])) tm.assert_numpy_array_equal(index.notnull(), @@ -196,14 +196,13 @@ def test_equals(self): self.assertTrue(idx.equals(idx)) self.assertTrue(idx.equals(idx.copy())) - self.assertFalse(idx.equals(idx.astype(object))) - self.assertFalse(idx.equals(np.array(idx))) - self.assertFalse(idx.equals(list(idx))) + assert not idx.equals(idx.astype(object)) + assert not idx.equals(np.array(idx)) + assert not idx.equals(list(idx)) - self.assertFalse(idx.equals([1, 2])) - self.assertFalse(idx.equals(np.array([1, 2]))) - self.assertFalse(idx.equals( - pd.date_range('20130101', periods=2))) + assert not idx.equals([1, 2]) + assert not idx.equals(np.array([1, 2])) + assert not idx.equals(pd.date_range('20130101', periods=2)) def test_astype(self): @@ -216,7 +215,7 @@ def test_astype(self): result = idx.astype(object) tm.assert_index_equal(result, Index(idx.values, dtype='object')) - self.assertFalse(idx.equals(result)) + assert not idx.equals(result) self.assertTrue(idx.equals(IntervalIndex.from_intervals(result))) result = idx.astype('interval') @@ -272,11 +271,11 @@ def test_monotonic_and_unique(self): self.assertTrue(idx.is_unique) idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 2)]) - self.assertFalse(idx.is_monotonic) + assert not idx.is_monotonic self.assertTrue(idx.is_unique) idx = IntervalIndex.from_tuples([(0, 2), (0, 2)]) - self.assertFalse(idx.is_unique) + assert not idx.is_unique self.assertTrue(idx.is_monotonic) @pytest.mark.xfail(reason='not a valid repr as we use interval notation') diff --git a/pandas/tests/indexes/test_multi.py b/pandas/tests/indexes/test_multi.py index ab403cf56e033..6f6e1f1544219 100644 --- a/pandas/tests/indexes/test_multi.py +++ b/pandas/tests/indexes/test_multi.py @@ -524,7 +524,7 @@ def test_reference_duplicate_name(self): idx = MultiIndex.from_tuples( [('a', 'b'), ('c', 'd')], names=['x', 'y']) - self.assertFalse(idx._reference_duplicate_name('x')) + assert not idx._reference_duplicate_name('x') def test_astype(self): expected = self.index.copy() @@ -1082,11 +1082,11 @@ def test_contains_with_nat(self): self.assertTrue(val in mi) def test_is_all_dates(self): - self.assertFalse(self.index.is_all_dates) + assert not self.index.is_all_dates def test_is_numeric(self): # MultiIndex is never numeric - self.assertFalse(self.index.is_numeric()) + assert not self.index.is_numeric() def test_getitem(self): # scalar @@ -1280,7 +1280,7 @@ def test_consistency(self): index = MultiIndex(levels=[major_axis, minor_axis], labels=[major_labels, minor_labels]) - self.assertFalse(index.is_unique) + assert not index.is_unique def test_truncate(self): major_axis = Index(lrange(4)) @@ -1526,9 +1526,9 @@ def test_equals_missing_values(self): i = pd.MultiIndex.from_tuples([(0, pd.NaT), (0, pd.Timestamp('20130101'))]) result = i[0:1].equals(i[0]) - self.assertFalse(result) + assert not result result = i[1:2].equals(i[1]) - self.assertFalse(result) + assert not result def test_identical(self): mi = self.index.copy() @@ -1537,7 +1537,7 @@ def test_identical(self): mi = mi.set_names(['new1', 'new2']) self.assertTrue(mi.equals(mi2)) - self.assertFalse(mi.identical(mi2)) + assert not mi.identical(mi2) mi2 = mi2.set_names(['new1', 'new2']) self.assertTrue(mi.identical(mi2)) @@ -1545,7 +1545,7 @@ def test_identical(self): mi3 = Index(mi.tolist(), names=mi.names) mi4 = Index(mi.tolist(), names=mi.names, tupleize_cols=False) self.assertTrue(mi.identical(mi3)) - self.assertFalse(mi.identical(mi4)) + assert not mi.identical(mi4) self.assertTrue(mi.equals(mi4)) def test_is_(self): @@ -1565,15 +1565,15 @@ def test_is_(self): self.assertTrue(mi.is_(mi2)) # levels are inherent properties, they change identity mi3 = mi2.set_levels([lrange(10), lrange(10)]) - self.assertFalse(mi3.is_(mi2)) + assert not mi3.is_(mi2) # shouldn't change self.assertTrue(mi2.is_(mi)) mi4 = mi3.view() mi4.set_levels([[1 for _ in range(10)], lrange(10)], inplace=True) - self.assertFalse(mi4.is_(mi3)) + assert not mi4.is_(mi3) mi5 = mi.view() mi5.set_levels(mi5.levels, inplace=True) - self.assertFalse(mi5.is_(mi)) + assert not mi5.is_(mi) def test_union(self): piece1 = self.index[:5][::-1] @@ -1862,7 +1862,7 @@ def test_drop_not_lexsorted(self): df = df.pivot_table(index='a', columns=['b', 'c'], values='d') df = df.reset_index() not_lexsorted_mi = df.columns - self.assertFalse(not_lexsorted_mi.is_lexsorted()) + assert not not_lexsorted_mi.is_lexsorted() # compare the results tm.assert_index_equal(lexsorted_mi, not_lexsorted_mi) @@ -2119,7 +2119,7 @@ def test_reindex_level(self): level='first') def test_duplicates(self): - self.assertFalse(self.index.has_duplicates) + assert not self.index.has_duplicates self.assertTrue(self.index.append(self.index).has_duplicates) index = MultiIndex(levels=[[0, 1], [0, 1, 2]], labels=[ @@ -2147,7 +2147,7 @@ def test_duplicates(self): (u('x'), u('out'), u('z'), 12, u('y'), u('in'), u('z'), 144)] index = pd.MultiIndex.from_tuples(t) - self.assertFalse(index.has_duplicates) + assert not index.has_duplicates # handle int64 overflow if possible def check(nlevels, with_nulls): @@ -2168,7 +2168,7 @@ def check(nlevels, with_nulls): # no dups index = MultiIndex(levels=levels, labels=labels) - self.assertFalse(index.has_duplicates) + assert not index.has_duplicates # with a dup if with_nulls: @@ -2203,7 +2203,7 @@ def check(nlevels, with_nulls): # GH5873 for a in [101, 102]: mi = MultiIndex.from_arrays([[101, a], [3.5, np.nan]]) - self.assertFalse(mi.has_duplicates) + assert not mi.has_duplicates self.assertEqual(mi.get_duplicates(), []) tm.assert_numpy_array_equal(mi.duplicated(), np.zeros( 2, dtype='bool')) @@ -2215,7 +2215,7 @@ def check(nlevels, with_nulls): mi = MultiIndex(levels=[list('abcde')[:n], list('WXYZ')[:m]], labels=np.random.permutation(list(lab)).T) self.assertEqual(len(mi), (n + 1) * (m + 1)) - self.assertFalse(mi.has_duplicates) + assert not mi.has_duplicates self.assertEqual(mi.get_duplicates(), []) tm.assert_numpy_array_equal(mi.duplicated(), np.zeros( len(mi), dtype='bool')) @@ -2281,8 +2281,7 @@ def test_repr_with_unicode_data(self): with pd.core.config.option_context("display.encoding", 'UTF-8'): d = {"a": [u("\u05d0"), 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]} index = pd.DataFrame(d).set_index(["a", "b"]).index - self.assertFalse("\\u" in repr(index) - ) # we don't want unicode-escaped + assert "\\u" not in repr(index) # we don't want unicode-escaped def test_repr_roundtrip(self): @@ -2376,7 +2375,7 @@ def test_level_setting_resets_attributes(self): inplace=True) # if this fails, probably didn't reset the cache correctly. - self.assertFalse(ind.is_monotonic) + assert not ind.is_monotonic def test_is_monotonic(self): i = MultiIndex.from_product([np.arange(10), @@ -2386,18 +2385,18 @@ def test_is_monotonic(self): i = MultiIndex.from_product([np.arange(10, 0, -1), np.arange(10)], names=['one', 'two']) - self.assertFalse(i.is_monotonic) - self.assertFalse(Index(i.values).is_monotonic) + assert not i.is_monotonic + assert not Index(i.values).is_monotonic i = MultiIndex.from_product([np.arange(10), np.arange(10, 0, -1)], names=['one', 'two']) - self.assertFalse(i.is_monotonic) - self.assertFalse(Index(i.values).is_monotonic) + assert not i.is_monotonic + assert not Index(i.values).is_monotonic i = MultiIndex.from_product([[1.0, np.nan, 2.0], ['a', 'b', 'c']]) - self.assertFalse(i.is_monotonic) - self.assertFalse(Index(i.values).is_monotonic) + assert not i.is_monotonic + assert not Index(i.values).is_monotonic # string ordering i = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'], @@ -2405,8 +2404,8 @@ def test_is_monotonic(self): labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]], names=['first', 'second']) - self.assertFalse(i.is_monotonic) - self.assertFalse(Index(i.values).is_monotonic) + assert not i.is_monotonic + assert not Index(i.values).is_monotonic i = MultiIndex(levels=[['bar', 'baz', 'foo', 'qux'], ['mom', 'next', 'zenith']], @@ -2424,7 +2423,7 @@ def test_is_monotonic(self): labels=[[0, 1, 1, 2, 2, 2, 3], [4, 2, 0, 0, 1, 3, -1]], names=['household_id', 'asset_id']) - self.assertFalse(i.is_monotonic) + assert not i.is_monotonic def test_reconstruct_sort(self): diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py index 8a46da37572ff..8b4179dbf2e0e 100644 --- a/pandas/tests/indexes/test_numeric.py +++ b/pandas/tests/indexes/test_numeric.py @@ -381,8 +381,8 @@ def test_contains_not_nans(self): def test_doesnt_contain_all_the_things(self): i = Float64Index([np.nan]) - self.assertFalse(i.isin([0]).item()) - self.assertFalse(i.isin([1]).item()) + assert not i.isin([0]).item() + assert not i.isin([1]).item() self.assertTrue(i.isin([np.nan]).item()) def test_nan_multiple_containment(self): @@ -465,10 +465,10 @@ def test_view(self): def test_is_monotonic(self): self.assertTrue(self.index.is_monotonic) self.assertTrue(self.index.is_monotonic_increasing) - self.assertFalse(self.index.is_monotonic_decreasing) + assert not self.index.is_monotonic_decreasing index = self._holder([4, 3, 2, 1]) - self.assertFalse(index.is_monotonic) + assert not index.is_monotonic self.assertTrue(index.is_monotonic_decreasing) index = self._holder([1]) @@ -486,19 +486,19 @@ def test_identical(self): self.assertTrue(i.identical(self.index)) same_values_different_type = Index(i, dtype=object) - self.assertFalse(i.identical(same_values_different_type)) + assert not i.identical(same_values_different_type) i = self.index.copy(dtype=object) i = i.rename('foo') same_values = Index(i, dtype=object) self.assertTrue(same_values.identical(i)) - self.assertFalse(i.identical(self.index)) + assert not i.identical(self.index) self.assertTrue(Index(same_values, name='foo', dtype=object).identical( i)) - self.assertFalse(self.index.copy(dtype=object) - .identical(self.index.copy(dtype=self._dtype))) + assert not self.index.copy(dtype=object).identical( + self.index.copy(dtype=self._dtype)) def test_join_non_unique(self): left = Index([4, 4, 3, 3]) diff --git a/pandas/tests/indexes/test_range.py b/pandas/tests/indexes/test_range.py index c3ffb32c36e3b..0baf6636806f6 100644 --- a/pandas/tests/indexes/test_range.py +++ b/pandas/tests/indexes/test_range.py @@ -330,10 +330,10 @@ def test_dtype(self): def test_is_monotonic(self): self.assertTrue(self.index.is_monotonic) self.assertTrue(self.index.is_monotonic_increasing) - self.assertFalse(self.index.is_monotonic_decreasing) + assert not self.index.is_monotonic_decreasing index = RangeIndex(4, 0, -1) - self.assertFalse(index.is_monotonic) + assert not index.is_monotonic self.assertTrue(index.is_monotonic_decreasing) index = RangeIndex(1, 2) @@ -374,19 +374,19 @@ def test_identical(self): return same_values_different_type = Index(i, dtype=object) - self.assertFalse(i.identical(same_values_different_type)) + assert not i.identical(same_values_different_type) i = self.index.copy(dtype=object) i = i.rename('foo') same_values = Index(i, dtype=object) self.assertTrue(same_values.identical(self.index.copy(dtype=object))) - self.assertFalse(i.identical(self.index)) + assert not i.identical(self.index) self.assertTrue(Index(same_values, name='foo', dtype=object).identical( i)) - self.assertFalse(self.index.copy(dtype=object) - .identical(self.index.copy(dtype='int64'))) + assert not self.index.copy(dtype=object).identical( + self.index.copy(dtype='int64')) def test_get_indexer(self): target = RangeIndex(10) @@ -423,7 +423,7 @@ def test_join_outer(self): 5, 4, 3, 2, 1, 0], dtype=np.intp) assert isinstance(res, Int64Index) - self.assertFalse(isinstance(res, RangeIndex)) + assert not isinstance(res, RangeIndex) tm.assert_index_equal(res, eres) tm.assert_numpy_array_equal(lidx, elidx) tm.assert_numpy_array_equal(ridx, eridx) @@ -437,7 +437,7 @@ def test_join_outer(self): tm.assert_index_equal(res, noidx_res) assert isinstance(res, Int64Index) - self.assertFalse(isinstance(res, RangeIndex)) + assert not isinstance(res, RangeIndex) tm.assert_index_equal(res, eres) tm.assert_numpy_array_equal(lidx, elidx) tm.assert_numpy_array_equal(ridx, eridx) @@ -785,7 +785,7 @@ def test_duplicates(self): continue idx = self.indices[ind] self.assertTrue(idx.is_unique) - self.assertFalse(idx.has_duplicates) + assert not idx.has_duplicates def test_ufunc_compat(self): idx = RangeIndex(5) diff --git a/pandas/tests/indexes/timedeltas/test_astype.py b/pandas/tests/indexes/timedeltas/test_astype.py index d269cddcbb5c8..b17433d3aeb51 100644 --- a/pandas/tests/indexes/timedeltas/test_astype.py +++ b/pandas/tests/indexes/timedeltas/test_astype.py @@ -51,7 +51,7 @@ def test_astype_timedelta64(self): result = idx.astype('timedelta64[ns]') tm.assert_index_equal(result, idx) - self.assertFalse(result is idx) + assert result is not idx result = idx.astype('timedelta64[ns]', copy=False) tm.assert_index_equal(result, idx) diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py index c3cc05271e978..9747902f316a6 100644 --- a/pandas/tests/indexes/timedeltas/test_ops.py +++ b/pandas/tests/indexes/timedeltas/test_ops.py @@ -60,7 +60,7 @@ def test_minmax(self): # non-monotonic idx2 = TimedeltaIndex(['1 days', np.nan, '3 days', 'NaT']) - self.assertFalse(idx2.is_monotonic) + assert not idx2.is_monotonic for idx in [idx1, idx2]: self.assertEqual(idx.min(), Timedelta('1 days')), @@ -828,7 +828,7 @@ def test_nat(self): self.assertTrue(idx._can_hold_na) tm.assert_numpy_array_equal(idx._isnan, np.array([False, False])) - self.assertFalse(idx.hasnans) + assert not idx.hasnans tm.assert_numpy_array_equal(idx._nan_idxs, np.array([], dtype=np.intp)) @@ -848,17 +848,17 @@ def test_equals(self): self.assertTrue(idx.equals(idx.asobject)) self.assertTrue(idx.asobject.equals(idx)) self.assertTrue(idx.asobject.equals(idx.asobject)) - self.assertFalse(idx.equals(list(idx))) - self.assertFalse(idx.equals(pd.Series(idx))) + assert not idx.equals(list(idx)) + assert not idx.equals(pd.Series(idx)) idx2 = pd.TimedeltaIndex(['2 days', '1 days', 'NaT']) - self.assertFalse(idx.equals(idx2)) - self.assertFalse(idx.equals(idx2.copy())) - self.assertFalse(idx.equals(idx2.asobject)) - self.assertFalse(idx.asobject.equals(idx2)) - self.assertFalse(idx.asobject.equals(idx2.asobject)) - self.assertFalse(idx.equals(list(idx2))) - self.assertFalse(idx.equals(pd.Series(idx2))) + assert not idx.equals(idx2) + assert not idx.equals(idx2.copy()) + assert not idx.equals(idx2.asobject) + assert not idx.asobject.equals(idx2) + assert not idx.asobject.equals(idx2.asobject) + assert not idx.equals(list(idx2)) + assert not idx.equals(pd.Series(idx2)) class TestTimedeltas(tm.TestCase): diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py index b5bdf031180ec..c90c61170ca93 100644 --- a/pandas/tests/indexes/timedeltas/test_timedelta.py +++ b/pandas/tests/indexes/timedeltas/test_timedelta.py @@ -346,10 +346,10 @@ def test_misc_coverage(self): assert isinstance(list(result.values())[0][0], Timedelta) idx = TimedeltaIndex(['3d', '1d', '2d']) - self.assertFalse(idx.equals(list(idx))) + assert not idx.equals(list(idx)) non_td = Index(list('abc')) - self.assertFalse(idx.equals(list(non_td))) + assert not idx.equals(list(non_td)) def test_map(self): diff --git a/pandas/tests/indexing/test_floats.py b/pandas/tests/indexing/test_floats.py index bdee41acbc8fd..498604aaac853 100644 --- a/pandas/tests/indexing/test_floats.py +++ b/pandas/tests/indexing/test_floats.py @@ -102,7 +102,7 @@ def f(): pytest.raises(error, f) # contains - self.assertFalse(3.0 in s) + assert 3.0 not in s # setting with a float fails with iloc def f(): diff --git a/pandas/tests/indexing/test_indexing.py b/pandas/tests/indexing/test_indexing.py index f8a7c57ad5061..d0f089f0804c3 100644 --- a/pandas/tests/indexing/test_indexing.py +++ b/pandas/tests/indexing/test_indexing.py @@ -438,7 +438,7 @@ def test_string_slice(self): df.loc['2011', 0] df = pd.DataFrame() - self.assertFalse(df.index.is_all_dates) + assert not df.index.is_all_dates with pytest.raises(KeyError): df['2011'] diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py index b2a5e6147cd28..862a6e6326ddd 100644 --- a/pandas/tests/indexing/test_loc.py +++ b/pandas/tests/indexing/test_loc.py @@ -588,7 +588,7 @@ def gen_expected(df, mask): df.take(mask[1:], convert=False)]) df = gen_test(900, 100) - self.assertFalse(df.index.is_unique) + assert not df.index.is_unique mask = np.arange(100) result = df.loc[mask] @@ -596,7 +596,7 @@ def gen_expected(df, mask): tm.assert_frame_equal(result, expected) df = gen_test(900000, 100000) - self.assertFalse(df.index.is_unique) + assert not df.index.is_unique mask = np.arange(100000) result = df.loc[mask] diff --git a/pandas/tests/indexing/test_multiindex.py b/pandas/tests/indexing/test_multiindex.py index a85c6bb446140..dbd0f5a9e6e1c 100644 --- a/pandas/tests/indexing/test_multiindex.py +++ b/pandas/tests/indexing/test_multiindex.py @@ -816,7 +816,7 @@ def test_multiindex_slicers_non_unique(self): C=[1, 2, 1, 3], D=[1, 2, 3, 4])) .set_index(['A', 'B', 'C']).sort_index()) - self.assertFalse(df.index.is_unique) + assert not df.index.is_unique expected = (DataFrame(dict(A=['foo', 'foo'], B=['a', 'a'], C=[1, 1], D=[1, 3])) .set_index(['A', 'B', 'C']).sort_index()) @@ -832,12 +832,12 @@ def test_multiindex_slicers_non_unique(self): C=[1, 2, 1, 2], D=[1, 2, 3, 4])) .set_index(['A', 'B', 'C']).sort_index()) - self.assertFalse(df.index.is_unique) + assert not df.index.is_unique expected = (DataFrame(dict(A=['foo', 'foo'], B=['a', 'a'], C=[1, 1], D=[1, 3])) .set_index(['A', 'B', 'C']).sort_index()) result = df.loc[(slice(None), slice(None), 1), :] - self.assertFalse(result.index.is_unique) + assert not result.index.is_unique tm.assert_frame_equal(result, expected) # GH12896 diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py index 35a71efbbf5ba..ccc1372495106 100644 --- a/pandas/tests/io/formats/test_format.py +++ b/pandas/tests/io/formats/test_format.py @@ -252,20 +252,20 @@ def test_expand_frame_repr(self): 'display.max_rows', 20, 'display.show_dimensions', True): with option_context('display.expand_frame_repr', True): - self.assertFalse(has_truncated_repr(df_small)) - self.assertFalse(has_expanded_repr(df_small)) - self.assertFalse(has_truncated_repr(df_wide)) + assert not has_truncated_repr(df_small) + assert not has_expanded_repr(df_small) + assert not has_truncated_repr(df_wide) self.assertTrue(has_expanded_repr(df_wide)) self.assertTrue(has_vertically_truncated_repr(df_tall)) self.assertTrue(has_expanded_repr(df_tall)) with option_context('display.expand_frame_repr', False): - self.assertFalse(has_truncated_repr(df_small)) - self.assertFalse(has_expanded_repr(df_small)) - self.assertFalse(has_horizontally_truncated_repr(df_wide)) - self.assertFalse(has_expanded_repr(df_wide)) + assert not has_truncated_repr(df_small) + assert not has_expanded_repr(df_small) + assert not has_horizontally_truncated_repr(df_wide) + assert not has_expanded_repr(df_wide) self.assertTrue(has_vertically_truncated_repr(df_tall)) - self.assertFalse(has_expanded_repr(df_tall)) + assert not has_expanded_repr(df_tall) def test_repr_non_interactive(self): # in non interactive mode, there can be no dependency on the @@ -274,8 +274,8 @@ def test_repr_non_interactive(self): with option_context('mode.sim_interactive', False, 'display.width', 0, 'display.height', 0, 'display.max_rows', 5000): - self.assertFalse(has_truncated_repr(df)) - self.assertFalse(has_expanded_repr(df)) + assert not has_truncated_repr(df) + assert not has_expanded_repr(df) def test_repr_max_columns_max_rows(self): term_width, term_height = get_terminal_size() @@ -293,29 +293,29 @@ def mkframe(n): with option_context('display.width', term_width * 2): with option_context('display.max_rows', 5, 'display.max_columns', 5): - self.assertFalse(has_expanded_repr(mkframe(4))) - self.assertFalse(has_expanded_repr(mkframe(5))) - self.assertFalse(has_expanded_repr(df6)) + assert not has_expanded_repr(mkframe(4)) + assert not has_expanded_repr(mkframe(5)) + assert not has_expanded_repr(df6) self.assertTrue(has_doubly_truncated_repr(df6)) with option_context('display.max_rows', 20, 'display.max_columns', 10): # Out off max_columns boundary, but no extending # since not exceeding width - self.assertFalse(has_expanded_repr(df6)) - self.assertFalse(has_truncated_repr(df6)) + assert not has_expanded_repr(df6) + assert not has_truncated_repr(df6) with option_context('display.max_rows', 9, 'display.max_columns', 10): # out vertical bounds can not result in exanded repr - self.assertFalse(has_expanded_repr(df10)) + assert not has_expanded_repr(df10) self.assertTrue(has_vertically_truncated_repr(df10)) # width=None in terminal, auto detection with option_context('display.max_columns', 100, 'display.max_rows', term_width * 20, 'display.width', None): df = mkframe((term_width // 7) - 2) - self.assertFalse(has_expanded_repr(df)) + assert not has_expanded_repr(df) df = mkframe((term_width // 7) + 2) printing.pprint_thing(df._repr_fits_horizontal_()) self.assertTrue(has_expanded_repr(df)) @@ -755,14 +755,14 @@ def test_to_string_truncate_indices(self): self.assertTrue( has_vertically_truncated_repr(df)) else: - self.assertFalse( - has_vertically_truncated_repr(df)) + assert not has_vertically_truncated_repr( + df) with option_context("display.max_columns", 15): if w == 20: self.assertTrue( has_horizontally_truncated_repr(df)) else: - self.assertFalse( + assert not ( has_horizontally_truncated_repr(df)) with option_context("display.max_rows", 15, "display.max_columns", 15): @@ -770,8 +770,8 @@ def test_to_string_truncate_indices(self): self.assertTrue(has_doubly_truncated_repr( df)) else: - self.assertFalse(has_doubly_truncated_repr( - df)) + assert not has_doubly_truncated_repr( + df) def test_to_string_truncate_multilevel(self): arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'], @@ -802,7 +802,7 @@ def test_truncate_with_different_dtypes(self): 'display.max_columns', 3): result = str(df) self.assertTrue('None' in result) - self.assertFalse('NaN' in result) + assert 'NaN' not in result def test_datetimelike_frame(self): @@ -1358,8 +1358,8 @@ def test_show_dimensions(self): with option_context('display.max_rows', 10, 'display.max_columns', 40, 'display.width', 500, 'display.expand_frame_repr', 'info', 'display.show_dimensions', False): - self.assertFalse('5 rows' in str(df)) - self.assertFalse('5 rows' in df._repr_html_()) + assert '5 rows' not in str(df) + assert '5 rows' not in df._repr_html_() with option_context('display.max_rows', 2, 'display.max_columns', 2, 'display.width', 500, 'display.expand_frame_repr', 'info', 'display.show_dimensions', 'truncate'): @@ -1368,8 +1368,8 @@ def test_show_dimensions(self): with option_context('display.max_rows', 10, 'display.max_columns', 40, 'display.width', 500, 'display.expand_frame_repr', 'info', 'display.show_dimensions', 'truncate'): - self.assertFalse('5 rows' in str(df)) - self.assertFalse('5 rows' in df._repr_html_()) + assert '5 rows' not in str(df) + assert '5 rows' not in df._repr_html_() def test_repr_html(self): self.frame._repr_html_() @@ -1386,7 +1386,7 @@ def test_repr_html(self): fmt.set_option('display.show_dimensions', True) self.assertTrue('2 rows' in df._repr_html_()) fmt.set_option('display.show_dimensions', False) - self.assertFalse('2 rows' in df._repr_html_()) + assert '2 rows' not in df._repr_html_() tm.reset_display_options() @@ -1518,7 +1518,7 @@ def test_info_repr_max_cols(self): with option_context('display.large_repr', 'info', 'display.max_columns', 1, 'display.max_info_columns', 5): - self.assertFalse(has_non_verbose_info_repr(df)) + assert not has_non_verbose_info_repr(df) # test verbose overrides # fmt.set_option('display.max_info_columns', 4) # exceeded diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py index 28c6a0e95e0f1..a67bb2fd8eb5c 100644 --- a/pandas/tests/io/formats/test_to_html.py +++ b/pandas/tests/io/formats/test_to_html.py @@ -1461,7 +1461,7 @@ def test_to_html_filename(self): def test_to_html_with_no_bold(self): x = DataFrame({'x': np.random.randn(5)}) ashtml = x.to_html(bold_rows=False) - self.assertFalse('")]) + assert '")] def test_to_html_columns_arg(self): frame = DataFrame(tm.getSeriesData()) diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py index 0dfae0fb88bf6..ac9e4f77db6ac 100644 --- a/pandas/tests/io/json/test_pandas.py +++ b/pandas/tests/io/json/test_pandas.py @@ -415,7 +415,7 @@ def test_frame_to_json_except(self): def test_frame_empty(self): df = DataFrame(columns=['jim', 'joe']) - self.assertFalse(df._is_mixed_type) + assert not df._is_mixed_type assert_frame_equal(read_json(df.to_json(), dtype=dict(df.dtypes)), df, check_index_type=False) # GH 7445 diff --git a/pandas/tests/io/parser/common.py b/pandas/tests/io/parser/common.py index 9abd3c5bfe993..afb23f540264e 100644 --- a/pandas/tests/io/parser/common.py +++ b/pandas/tests/io/parser/common.py @@ -113,7 +113,7 @@ def test_squeeze_no_view(self): # Series should not be a view data = """time,data\n0,10\n1,11\n2,12\n4,14\n5,15\n3,13""" result = self.read_csv(StringIO(data), index_col='time', squeeze=True) - self.assertFalse(result._is_view) + assert not result._is_view def test_malformed(self): # see gh-6607 @@ -1656,11 +1656,11 @@ def test_file_handles(self): fh = StringIO('a,b\n1,2') self.read_csv(fh) - self.assertFalse(fh.closed) + assert not fh.closed with open(self.csv1, 'r') as f: self.read_csv(f) - self.assertFalse(f.closed) + assert not f.closed # mmap not working with python engine if self.engine != 'python': @@ -1671,7 +1671,7 @@ def test_file_handles(self): self.read_csv(m) # closed attribute new in python 3.2 if PY3: - self.assertFalse(m.closed) + assert not m.closed m.close() def test_invalid_file_buffer(self): diff --git a/pandas/tests/io/parser/test_network.py b/pandas/tests/io/parser/test_network.py index 4a8d2e997ee06..b9920983856d4 100644 --- a/pandas/tests/io/parser/test_network.py +++ b/pandas/tests/io/parser/test_network.py @@ -61,14 +61,14 @@ def test_parse_public_s3_bucket(self): df = read_csv('s3://pandas-test/tips.csv' + ext, compression=comp) self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv( tm.get_data_path('tips.csv')), df) # Read public file from bucket with not-public contents df = read_csv('s3://cant_get_it/tips.csv') self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv(tm.get_data_path('tips.csv')), df) @tm.network @@ -76,7 +76,7 @@ def test_parse_public_s3n_bucket(self): # Read from AWS s3 as "s3n" URL df = read_csv('s3n://pandas-test/tips.csv', nrows=10) self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv( tm.get_data_path('tips.csv')).iloc[:10], df) @@ -85,7 +85,7 @@ def test_parse_public_s3a_bucket(self): # Read from AWS s3 as "s3a" URL df = read_csv('s3a://pandas-test/tips.csv', nrows=10) self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv( tm.get_data_path('tips.csv')).iloc[:10], df) @@ -95,7 +95,7 @@ def test_parse_public_s3_bucket_nrows(self): df = read_csv('s3://pandas-test/tips.csv' + ext, nrows=10, compression=comp) self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv( tm.get_data_path('tips.csv')).iloc[:10], df) @@ -113,7 +113,7 @@ def test_parse_public_s3_bucket_chunked(self): # properly. df = df_reader.get_chunk() self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty true_df = local_tips.iloc[ chunksize * i_chunk: chunksize * (i_chunk + 1)] tm.assert_frame_equal(true_df, df) @@ -132,7 +132,7 @@ def test_parse_public_s3_bucket_chunked_python(self): # Read a couple of chunks and make sure we see them properly. df = df_reader.get_chunk() self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty true_df = local_tips.iloc[ chunksize * i_chunk: chunksize * (i_chunk + 1)] tm.assert_frame_equal(true_df, df) @@ -143,7 +143,7 @@ def test_parse_public_s3_bucket_python(self): df = read_csv('s3://pandas-test/tips.csv' + ext, engine='python', compression=comp) self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv( tm.get_data_path('tips.csv')), df) @@ -153,7 +153,7 @@ def test_infer_s3_compression(self): df = read_csv('s3://pandas-test/tips.csv' + ext, engine='python', compression='infer') self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv( tm.get_data_path('tips.csv')), df) @@ -163,7 +163,7 @@ def test_parse_public_s3_bucket_nrows_python(self): df = read_csv('s3://pandas-test/tips.csv' + ext, engine='python', nrows=10, compression=comp) self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) + assert not df.empty tm.assert_frame_equal(read_csv( tm.get_data_path('tips.csv')).iloc[:10], df) diff --git a/pandas/tests/io/test_common.py b/pandas/tests/io/test_common.py index 82819b94413b4..700915b81dd31 100644 --- a/pandas/tests/io/test_common.py +++ b/pandas/tests/io/test_common.py @@ -129,7 +129,7 @@ def test_get_attr(self): for attr in attrs: self.assertTrue(hasattr(wrapper, attr)) - self.assertFalse(hasattr(wrapper, 'foo')) + assert not hasattr(wrapper, 'foo') def test_next(self): with open(self.mmap_file, 'r') as target: diff --git a/pandas/tests/io/test_html.py b/pandas/tests/io/test_html.py index 5a30ff2afe7e5..cf08754a18527 100644 --- a/pandas/tests/io/test_html.py +++ b/pandas/tests/io/test_html.py @@ -168,7 +168,7 @@ def test_banklist_no_match(self): def test_spam_header(self): df = self.read_html(self.spam_data, '.*Water.*', header=1)[0] self.assertEqual(df.columns[0], 'Proximates') - self.assertFalse(df.empty) + assert not df.empty def test_skiprows_int(self): df1 = self.read_html(self.spam_data, '.*Water.*', skiprows=1) @@ -378,7 +378,7 @@ def test_thousands_macau_stats(self): attrs={'class': 'style1'}) df = dfs[all_non_nan_table_index] - self.assertFalse(any(s.isnull().any() for _, s in df.iteritems())) + assert not any(s.isnull().any() for _, s in df.iteritems()) @tm.slow def test_thousands_macau_index_col(self): @@ -387,7 +387,7 @@ def test_thousands_macau_index_col(self): dfs = self.read_html(macau_data, index_col=0, header=0) df = dfs[all_non_nan_table_index] - self.assertFalse(any(s.isnull().any() for _, s in df.iteritems())) + assert not any(s.isnull().any() for _, s in df.iteritems()) def test_empty_tables(self): """ diff --git a/pandas/tests/io/test_pytables.py b/pandas/tests/io/test_pytables.py index 1b656e7b1b004..6e7fca9a29e98 100644 --- a/pandas/tests/io/test_pytables.py +++ b/pandas/tests/io/test_pytables.py @@ -332,7 +332,7 @@ def test_api_default_format(self): pandas.set_option('io.hdf.default_format', 'fixed') _maybe_remove(store, 'df') store.put('df', df) - self.assertFalse(store.get_storer('df').is_table) + assert not store.get_storer('df').is_table pytest.raises(ValueError, store.append, 'df2', df) pandas.set_option('io.hdf.default_format', 'table') @@ -352,7 +352,7 @@ def test_api_default_format(self): pandas.set_option('io.hdf.default_format', 'fixed') df.to_hdf(path, 'df') with HDFStore(path) as store: - self.assertFalse(store.get_storer('df').is_table) + assert not store.get_storer('df').is_table pytest.raises(ValueError, df.to_hdf, path, 'df2', append=True) pandas.set_option('io.hdf.default_format', 'table') @@ -545,14 +545,14 @@ def test_reopen_handle(self): # invalid mode change pytest.raises(PossibleDataLossError, store.open, 'w') store.close() - self.assertFalse(store.is_open) + assert not store.is_open # truncation ok here store.open('w') self.assertTrue(store.is_open) self.assertEqual(len(store), 0) store.close() - self.assertFalse(store.is_open) + assert not store.is_open store = HDFStore(path, mode='a') store['a'] = tm.makeTimeSeries() @@ -563,7 +563,7 @@ def test_reopen_handle(self): self.assertEqual(len(store), 1) self.assertEqual(store._mode, 'r') store.close() - self.assertFalse(store.is_open) + assert not store.is_open # reopen as append store.open('a') @@ -571,7 +571,7 @@ def test_reopen_handle(self): self.assertEqual(len(store), 1) self.assertEqual(store._mode, 'a') store.close() - self.assertFalse(store.is_open) + assert not store.is_open # reopen as append (again) store.open('a') @@ -579,7 +579,7 @@ def test_reopen_handle(self): self.assertEqual(len(store), 1) self.assertEqual(store._mode, 'a') store.close() - self.assertFalse(store.is_open) + assert not store.is_open def test_open_args(self): @@ -599,7 +599,7 @@ def test_open_args(self): store.close() # the file should not have actually been written - self.assertFalse(os.path.exists(path)) + assert not os.path.exists(path) def test_flush(self): diff --git a/pandas/tests/io/test_s3.py b/pandas/tests/io/test_s3.py index 2983fa647445c..cff8eef74a607 100644 --- a/pandas/tests/io/test_s3.py +++ b/pandas/tests/io/test_s3.py @@ -7,4 +7,4 @@ class TestS3URL(tm.TestCase): def test_is_s3_url(self): self.assertTrue(_is_s3_url("s3://pandas/somethingelse.com")) - self.assertFalse(_is_s3_url("s4://pandas/somethingelse.com")) + assert not _is_s3_url("s4://pandas/somethingelse.com") diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py index 36ff3bdbb24b5..0930d99ea5c30 100644 --- a/pandas/tests/io/test_sql.py +++ b/pandas/tests/io/test_sql.py @@ -625,9 +625,7 @@ def test_date_parsing(self): # Test date parsing in read_sq # No Parsing df = sql.read_sql_query("SELECT * FROM types_test_data", self.conn) - self.assertFalse( - issubclass(df.DateCol.dtype.type, np.datetime64), - "DateCol loaded with incorrect type") + assert not issubclass(df.DateCol.dtype.type, np.datetime64) df = sql.read_sql_query("SELECT * FROM types_test_data", self.conn, parse_dates=['DateCol']) @@ -1230,8 +1228,7 @@ def test_drop_table(self): pandasSQL.drop_table('temp_frame') - self.assertFalse( - temp_conn.has_table('temp_frame'), 'Table not deleted from DB') + assert not temp_conn.has_table('temp_frame') def test_roundtrip(self): self._roundtrip() @@ -1727,8 +1724,7 @@ def test_default_date_load(self): df = sql.read_sql_table("types_test_data", self.conn) # IMPORTANT - sqlite has no native date type, so shouldn't parse, but - self.assertFalse(issubclass(df.DateCol.dtype.type, np.datetime64), - "DateCol loaded with incorrect type") + assert not issubclass(df.DateCol.dtype.type, np.datetime64) def test_bigint_warning(self): # test no warning for BIGINT (to support int64) is raised (GH7433) @@ -1988,8 +1984,7 @@ def test_create_and_drop_table(self): self.pandasSQL.drop_table('drop_test_frame') - self.assertFalse(self.pandasSQL.has_table('drop_test_frame'), - 'Table not deleted from DB') + assert not self.pandasSQL.has_table('drop_test_frame') def test_roundtrip(self): self._roundtrip() diff --git a/pandas/tests/plotting/common.py b/pandas/tests/plotting/common.py index 22f471a01b9d2..35625670f0641 100644 --- a/pandas/tests/plotting/common.py +++ b/pandas/tests/plotting/common.py @@ -491,13 +491,13 @@ def is_grid_on(): spndx += 1 mpl.rc('axes', grid=False) obj.plot(kind=kind, **kws) - self.assertFalse(is_grid_on()) + assert not is_grid_on() self.plt.subplot(1, 4 * len(kinds), spndx) spndx += 1 mpl.rc('axes', grid=True) obj.plot(kind=kind, grid=False, **kws) - self.assertFalse(is_grid_on()) + assert not is_grid_on() if kind != 'pie': self.plt.subplot(1, 4 * len(kinds), spndx) diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py index f0a56592158d3..7534d9363f267 100644 --- a/pandas/tests/plotting/test_datetimelike.py +++ b/pandas/tests/plotting/test_datetimelike.py @@ -223,7 +223,7 @@ def test_fake_inferred_business(self): ts = Series(lrange(len(rng)), rng) ts = ts[:3].append(ts[5:]) ax = ts.plot() - self.assertFalse(hasattr(ax, 'freq')) + assert not hasattr(ax, 'freq') @slow def test_plot_offset_freq(self): @@ -334,7 +334,7 @@ def test_nonzero_base(self): df = DataFrame(np.arange(24), index=idx) ax = df.plot() rs = ax.get_lines()[0].get_xdata() - self.assertFalse(Index(rs).is_normalized) + assert not Index(rs).is_normalized def test_dataframe(self): bts = DataFrame({'a': tm.makeTimeSeries()}) @@ -568,14 +568,14 @@ def test_secondary_y(self): ser2 = Series(np.random.randn(10)) ax = ser.plot(secondary_y=True) self.assertTrue(hasattr(ax, 'left_ax')) - self.assertFalse(hasattr(ax, 'right_ax')) + assert not hasattr(ax, 'right_ax') fig = ax.get_figure() axes = fig.get_axes() l = ax.get_lines()[0] xp = Series(l.get_ydata(), l.get_xdata()) assert_series_equal(ser, xp) self.assertEqual(ax.get_yaxis().get_ticks_position(), 'right') - self.assertFalse(axes[0].get_yaxis().get_visible()) + assert not axes[0].get_yaxis().get_visible() plt.close(fig) ax2 = ser2.plot() @@ -586,10 +586,10 @@ def test_secondary_y(self): ax = ser2.plot() ax2 = ser.plot(secondary_y=True) self.assertTrue(ax.get_yaxis().get_visible()) - self.assertFalse(hasattr(ax, 'left_ax')) + assert not hasattr(ax, 'left_ax') self.assertTrue(hasattr(ax, 'right_ax')) self.assertTrue(hasattr(ax2, 'left_ax')) - self.assertFalse(hasattr(ax2, 'right_ax')) + assert not hasattr(ax2, 'right_ax') @slow def test_secondary_y_ts(self): @@ -599,14 +599,14 @@ def test_secondary_y_ts(self): ser2 = Series(np.random.randn(10), idx) ax = ser.plot(secondary_y=True) self.assertTrue(hasattr(ax, 'left_ax')) - self.assertFalse(hasattr(ax, 'right_ax')) + assert not hasattr(ax, 'right_ax') fig = ax.get_figure() axes = fig.get_axes() l = ax.get_lines()[0] xp = Series(l.get_ydata(), l.get_xdata()).to_timestamp() assert_series_equal(ser, xp) self.assertEqual(ax.get_yaxis().get_ticks_position(), 'right') - self.assertFalse(axes[0].get_yaxis().get_visible()) + assert not axes[0].get_yaxis().get_visible() plt.close(fig) ax2 = ser2.plot() @@ -627,7 +627,7 @@ def test_secondary_kde(self): ser = Series(np.random.randn(10)) ax = ser.plot(secondary_y=True, kind='density') self.assertTrue(hasattr(ax, 'left_ax')) - self.assertFalse(hasattr(ax, 'right_ax')) + assert not hasattr(ax, 'right_ax') fig = ax.get_figure() axes = fig.get_axes() self.assertEqual(axes[1].get_yaxis().get_ticks_position(), 'right') @@ -684,7 +684,7 @@ def test_mixed_freq_irregular_first(self): s2 = s1[[0, 5, 10, 11, 12, 13, 14, 15]] s2.plot(style='g') ax = s1.plot() - self.assertFalse(hasattr(ax, 'freq')) + assert not hasattr(ax, 'freq') lines = ax.get_lines() x1 = lines[0].get_xdata() tm.assert_numpy_array_equal(x1, s2.index.asobject.values) @@ -716,7 +716,7 @@ def test_mixed_freq_irregular_first_df(self): s2 = s1.iloc[[0, 5, 10, 11, 12, 13, 14, 15], :] ax = s2.plot(style='g') ax = s1.plot(ax=ax) - self.assertFalse(hasattr(ax, 'freq')) + assert not hasattr(ax, 'freq') lines = ax.get_lines() x1 = lines[0].get_xdata() tm.assert_numpy_array_equal(x1, s2.index.asobject.values) @@ -1049,7 +1049,7 @@ def test_secondary_upsample(self): for l in ax.get_lines(): self.assertEqual(PeriodIndex(l.get_xdata()).freq, 'D') self.assertTrue(hasattr(ax, 'left_ax')) - self.assertFalse(hasattr(ax, 'right_ax')) + assert not hasattr(ax, 'right_ax') for l in ax.left_ax.get_lines(): self.assertEqual(PeriodIndex(l.get_xdata()).freq, 'D') diff --git a/pandas/tests/plotting/test_frame.py b/pandas/tests/plotting/test_frame.py index c72bce28b5862..c5b43cd1a300b 100644 --- a/pandas/tests/plotting/test_frame.py +++ b/pandas/tests/plotting/test_frame.py @@ -664,7 +664,7 @@ def test_line_lim(self): self._check_axes_shape(axes, axes_num=3, layout=(3, 1)) for ax in axes: self.assertTrue(hasattr(ax, 'left_ax')) - self.assertFalse(hasattr(ax, 'right_ax')) + assert not hasattr(ax, 'right_ax') xmin, xmax = ax.get_xlim() lines = ax.get_lines() self.assertEqual(xmin, lines[0].get_data()[0][0]) diff --git a/pandas/tests/plotting/test_hist_method.py b/pandas/tests/plotting/test_hist_method.py index 79d5f74e6ea06..a77c1edd258e3 100644 --- a/pandas/tests/plotting/test_hist_method.py +++ b/pandas/tests/plotting/test_hist_method.py @@ -154,7 +154,7 @@ def test_hist_df_legacy(self): with tm.assert_produces_warning(UserWarning): axes = _check_plot_works(df.hist, grid=False) self._check_axes_shape(axes, axes_num=3, layout=(2, 2)) - self.assertFalse(axes[1, 1].get_visible()) + assert not axes[1, 1].get_visible() df = DataFrame(randn(100, 1)) _check_plot_works(df.hist) @@ -398,8 +398,8 @@ def test_axis_share_x(self): self.assertTrue(ax2._shared_x_axes.joined(ax1, ax2)) # don't share y - self.assertFalse(ax1._shared_y_axes.joined(ax1, ax2)) - self.assertFalse(ax2._shared_y_axes.joined(ax1, ax2)) + assert not ax1._shared_y_axes.joined(ax1, ax2) + assert not ax2._shared_y_axes.joined(ax1, ax2) @slow def test_axis_share_y(self): @@ -411,8 +411,8 @@ def test_axis_share_y(self): self.assertTrue(ax2._shared_y_axes.joined(ax1, ax2)) # don't share x - self.assertFalse(ax1._shared_x_axes.joined(ax1, ax2)) - self.assertFalse(ax2._shared_x_axes.joined(ax1, ax2)) + assert not ax1._shared_x_axes.joined(ax1, ax2) + assert not ax2._shared_x_axes.joined(ax1, ax2) @slow def test_axis_share_xy(self): diff --git a/pandas/tests/plotting/test_series.py b/pandas/tests/plotting/test_series.py index 38ce5f44b812f..b84e50c4ec827 100644 --- a/pandas/tests/plotting/test_series.py +++ b/pandas/tests/plotting/test_series.py @@ -454,7 +454,7 @@ def test_hist_secondary_legend(self): # left axis must be invisible, right axis must be visible self._check_legend_labels(ax.left_ax, labels=['a (right)', 'b (right)']) - self.assertFalse(ax.left_ax.get_yaxis().get_visible()) + assert not ax.left_ax.get_yaxis().get_visible() self.assertTrue(ax.get_yaxis().get_visible()) tm.close() @@ -502,7 +502,7 @@ def test_df_series_secondary_legend(self): # left axis must be invisible and right axis must be visible expected = ['a (right)', 'b (right)', 'c (right)', 'x (right)'] self._check_legend_labels(ax.left_ax, labels=expected) - self.assertFalse(ax.left_ax.get_yaxis().get_visible()) + assert not ax.left_ax.get_yaxis().get_visible() self.assertTrue(ax.get_yaxis().get_visible()) tm.close() @@ -513,7 +513,7 @@ def test_df_series_secondary_legend(self): # left axis must be invisible and right axis must be visible expected = ['a (right)', 'b (right)', 'c (right)', 'x (right)'] self._check_legend_labels(ax.left_ax, expected) - self.assertFalse(ax.left_ax.get_yaxis().get_visible()) + assert not ax.left_ax.get_yaxis().get_visible() self.assertTrue(ax.get_yaxis().get_visible()) tm.close() @@ -524,7 +524,7 @@ def test_df_series_secondary_legend(self): # left axis must be invisible and right axis must be visible expected = ['a', 'b', 'c', 'x (right)'] self._check_legend_labels(ax.left_ax, expected) - self.assertFalse(ax.left_ax.get_yaxis().get_visible()) + assert not ax.left_ax.get_yaxis().get_visible() self.assertTrue(ax.get_yaxis().get_visible()) tm.close() diff --git a/pandas/tests/reshape/test_hashing.py b/pandas/tests/reshape/test_hashing.py index cba70bba6823f..4857d3ac8310b 100644 --- a/pandas/tests/reshape/test_hashing.py +++ b/pandas/tests/reshape/test_hashing.py @@ -67,7 +67,7 @@ def check_not_equal_with_index(self, obj): a = hash_pandas_object(obj, index=True) b = hash_pandas_object(obj, index=False) if len(obj): - self.assertFalse((a == b).all()) + assert not (a == b).all() def test_hash_tuples(self): tups = [(1, 'one'), (1, 'two'), (2, 'one')] @@ -240,13 +240,13 @@ def test_same_len_hash_collisions(self): length = 2**(l + 8) + 1 s = tm.rands_array(length, 2) result = hash_array(s, 'utf8') - self.assertFalse(result[0] == result[1]) + assert not result[0] == result[1] for l in range(8): length = 2**(l + 8) s = tm.rands_array(length, 2) result = hash_array(s, 'utf8') - self.assertFalse(result[0] == result[1]) + assert not result[0] == result[1] def test_hash_collisions(self): diff --git a/pandas/tests/reshape/test_merge.py b/pandas/tests/reshape/test_merge.py index 73d0346546b97..80056b973a2fc 100644 --- a/pandas/tests/reshape/test_merge.py +++ b/pandas/tests/reshape/test_merge.py @@ -790,8 +790,8 @@ def run_asserts(left, right): res = left.join(right, on=icols, how='left', sort=sort) self.assertTrue(len(left) < len(res) + 1) - self.assertFalse(res['4th'].isnull().any()) - self.assertFalse(res['5th'].isnull().any()) + assert not res['4th'].isnull().any() + assert not res['5th'].isnull().any() tm.assert_series_equal( res['4th'], - res['5th'], check_names=False) diff --git a/pandas/tests/reshape/test_merge_asof.py b/pandas/tests/reshape/test_merge_asof.py index 0b5b580563741..f2aef409324f8 100644 --- a/pandas/tests/reshape/test_merge_asof.py +++ b/pandas/tests/reshape/test_merge_asof.py @@ -531,8 +531,8 @@ def test_non_sorted(self): quotes = self.quotes.sort_values('time', ascending=False) # we require that we are already sorted on time & quotes - self.assertFalse(trades.time.is_monotonic) - self.assertFalse(quotes.time.is_monotonic) + assert not trades.time.is_monotonic + assert not quotes.time.is_monotonic with pytest.raises(ValueError): merge_asof(trades, quotes, on='time', @@ -540,7 +540,7 @@ def test_non_sorted(self): trades = self.trades.sort_values('time') self.assertTrue(trades.time.is_monotonic) - self.assertFalse(quotes.time.is_monotonic) + assert not quotes.time.is_monotonic with pytest.raises(ValueError): merge_asof(trades, quotes, on='time', diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py index f15616a16678f..416e729944d39 100644 --- a/pandas/tests/reshape/test_pivot.py +++ b/pandas/tests/reshape/test_pivot.py @@ -1494,7 +1494,7 @@ def test_isleapyear_deprecate(self): self.assertTrue(isleapyear(2000)) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): - self.assertFalse(isleapyear(2001)) + assert not isleapyear(2001) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): self.assertTrue(isleapyear(2004)) diff --git a/pandas/tests/scalar/test_period.py b/pandas/tests/scalar/test_period.py index b5c2439524e34..c8f3833c2c964 100644 --- a/pandas/tests/scalar/test_period.py +++ b/pandas/tests/scalar/test_period.py @@ -25,13 +25,13 @@ def test_is_leap_year(self): assert isinstance(p.is_leap_year, bool) p = Period('1999-01-01 00:00:00', freq=freq) - self.assertFalse(p.is_leap_year) + assert not p.is_leap_year p = Period('2004-01-01 00:00:00', freq=freq) self.assertTrue(p.is_leap_year) p = Period('2100-01-01 00:00:00', freq=freq) - self.assertFalse(p.is_leap_year) + assert not p.is_leap_year def test_quarterly_negative_ordinals(self): p = Period(ordinal=-1, freq='Q-DEC') diff --git a/pandas/tests/scalar/test_timedelta.py b/pandas/tests/scalar/test_timedelta.py index 86b02d20b6996..788c204ca3eb3 100644 --- a/pandas/tests/scalar/test_timedelta.py +++ b/pandas/tests/scalar/test_timedelta.py @@ -451,7 +451,7 @@ def test_contains(self): # GH 13603 td = to_timedelta(range(5), unit='d') + pd.offsets.Hour(1) for v in [pd.NaT, None, float('nan'), np.nan]: - self.assertFalse((v in td)) + assert not (v in td) td = to_timedelta([pd.NaT]) for v in [pd.NaT, None, float('nan'), np.nan]: @@ -658,7 +658,7 @@ def test_components(self): s[1] = np.nan result = s.dt.components - self.assertFalse(result.iloc[0].isnull().all()) + assert not result.iloc[0].isnull().all() self.assertTrue(result.iloc[1].isnull().all()) def test_isoformat(self): @@ -707,5 +707,5 @@ def test_ops_error_str(self): with pytest.raises(TypeError): l > r - self.assertFalse(l == r) + assert not l == r self.assertTrue(l != r) diff --git a/pandas/tests/scalar/test_timestamp.py b/pandas/tests/scalar/test_timestamp.py index bad0b697eef6c..cfc4cf93e720c 100644 --- a/pandas/tests/scalar/test_timestamp.py +++ b/pandas/tests/scalar/test_timestamp.py @@ -862,18 +862,18 @@ def test_comparison(self): val = Timestamp(stamp) self.assertEqual(val, val) - self.assertFalse(val != val) - self.assertFalse(val < val) + assert not val != val + assert not val < val self.assertTrue(val <= val) - self.assertFalse(val > val) + assert not val > val self.assertTrue(val >= val) other = datetime(2012, 5, 18) self.assertEqual(val, other) - self.assertFalse(val != other) - self.assertFalse(val < other) + assert not val != other + assert not val < other self.assertTrue(val <= other) - self.assertFalse(val > other) + assert not val > other self.assertTrue(val >= other) other = Timestamp(stamp + 100) @@ -889,14 +889,14 @@ def test_compare_invalid(self): # GH 8058 val = Timestamp('20130101 12:01:02') - self.assertFalse(val == 'foo') - self.assertFalse(val == 10.0) - self.assertFalse(val == 1) - self.assertFalse(val == long(1)) - self.assertFalse(val == []) - self.assertFalse(val == {'foo': 1}) - self.assertFalse(val == np.float64(1)) - self.assertFalse(val == np.int64(1)) + assert not val == 'foo' + assert not val == 10.0 + assert not val == 1 + assert not val == long(1) + assert not val == [] + assert not val == {'foo': 1} + assert not val == np.float64(1) + assert not val == np.int64(1) self.assertTrue(val != 'foo') self.assertTrue(val != 10.0) @@ -933,8 +933,8 @@ def test_cant_compare_tz_naive_w_aware(self): pytest.raises(Exception, a.__eq__, b.to_pydatetime()) pytest.raises(Exception, a.to_pydatetime().__eq__, b) else: - self.assertFalse(a == b.to_pydatetime()) - self.assertFalse(a.to_pydatetime() == b) + assert not a == b.to_pydatetime() + assert not a.to_pydatetime() == b def test_cant_compare_tz_naive_w_aware_explicit_pytz(self): tm._skip_if_no_pytz() @@ -956,8 +956,8 @@ def test_cant_compare_tz_naive_w_aware_explicit_pytz(self): pytest.raises(Exception, a.__eq__, b.to_pydatetime()) pytest.raises(Exception, a.to_pydatetime().__eq__, b) else: - self.assertFalse(a == b.to_pydatetime()) - self.assertFalse(a.to_pydatetime() == b) + assert not a == b.to_pydatetime() + assert not a.to_pydatetime() == b def test_cant_compare_tz_naive_w_aware_dateutil(self): tm._skip_if_no_dateutil() @@ -980,8 +980,8 @@ def test_cant_compare_tz_naive_w_aware_dateutil(self): pytest.raises(Exception, a.__eq__, b.to_pydatetime()) pytest.raises(Exception, a.to_pydatetime().__eq__, b) else: - self.assertFalse(a == b.to_pydatetime()) - self.assertFalse(a.to_pydatetime() == b) + assert not a == b.to_pydatetime() + assert not a.to_pydatetime() == b def test_delta_preserve_nanos(self): val = Timestamp(long(1337299200000000123)) @@ -1090,13 +1090,13 @@ def test_is_leap_year(self): assert isinstance(dt.is_leap_year, bool) dt = Timestamp('1999-01-01 00:00:00', tz=tz) - self.assertFalse(dt.is_leap_year) + assert not dt.is_leap_year dt = Timestamp('2004-01-01 00:00:00', tz=tz) self.assertTrue(dt.is_leap_year) dt = Timestamp('2100-01-01 00:00:00', tz=tz) - self.assertFalse(dt.is_leap_year) + assert not dt.is_leap_year class TestTimestampNsOperations(tm.TestCase): @@ -1383,9 +1383,9 @@ def test_timestamp_compare_with_early_datetime(self): # e.g. datetime.min stamp = Timestamp('2012-01-01') - self.assertFalse(stamp == datetime.min) - self.assertFalse(stamp == datetime(1600, 1, 1)) - self.assertFalse(stamp == datetime(2700, 1, 1)) + assert not stamp == datetime.min + assert not stamp == datetime(1600, 1, 1) + assert not stamp == datetime(2700, 1, 1) self.assertNotEqual(stamp, datetime.min) self.assertNotEqual(stamp, datetime(1600, 1, 1)) self.assertNotEqual(stamp, datetime(2700, 1, 1)) diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py index eb8a83bb85847..f5bccdd55e944 100644 --- a/pandas/tests/series/test_analytics.py +++ b/pandas/tests/series/test_analytics.py @@ -646,7 +646,7 @@ def test_prod_numpy16_bug(self): def test_all_any(self): ts = tm.makeTimeSeries() bool_series = ts > 0 - self.assertFalse(bool_series.all()) + assert not bool_series.all() self.assertTrue(bool_series.any()) # Alternative types, with implicit 'object' dtype. @@ -660,7 +660,7 @@ def test_all_any_params(self): self.assertTrue(s1.all(skipna=False)) # nan && True => True self.assertTrue(s1.all(skipna=True)) self.assertTrue(np.isnan(s2.any(skipna=False))) # nan || False => nan - self.assertFalse(s2.any(skipna=True)) + assert not s2.any(skipna=True) # Check level. s = pd.Series([False, False, True, True, False, True], @@ -699,7 +699,7 @@ def test_modulo(self): p = p.astype('float64') result = p['first'] % p['second'] result2 = p['second'] % p['first'] - self.assertFalse(np.array_equal(result, result2)) + assert not np.array_equal(result, result2) # GH 9144 s = Series([0, 1]) @@ -1362,14 +1362,14 @@ def test_searchsorted_sorter(self): def test_is_unique(self): # GH11946 s = Series(np.random.randint(0, 10, size=1000)) - self.assertFalse(s.is_unique) + assert not s.is_unique s = Series(np.arange(1000)) self.assertTrue(s.is_unique) def test_is_monotonic(self): s = Series(np.random.randint(0, 10, size=1000)) - self.assertFalse(s.is_monotonic) + assert not s.is_monotonic s = Series(np.arange(1000)) self.assertTrue(s.is_monotonic) self.assertTrue(s.is_monotonic_increasing) @@ -1380,7 +1380,7 @@ def test_is_monotonic(self): self.assertTrue(s.is_monotonic) self.assertTrue(s.is_monotonic_increasing) s = Series(list(reversed(s.tolist()))) - self.assertFalse(s.is_monotonic) + assert not s.is_monotonic self.assertTrue(s.is_monotonic_decreasing) def test_sort_index_level(self): diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py index 397058c4bb8ce..5b7ac9bc2b33c 100644 --- a/pandas/tests/series/test_api.py +++ b/pandas/tests/series/test_api.py @@ -216,7 +216,7 @@ def test_iteritems(self): self.assertEqual(val, self.ts[idx]) # assert is lazy (genrators don't define reverse, lists do) - self.assertFalse(hasattr(self.series.iteritems(), 'reverse')) + assert not hasattr(self.series.iteritems(), 'reverse') def test_raise_on_info(self): s = Series(np.random.randn(10)) @@ -239,7 +239,7 @@ def test_copy(self): if deep is None or deep is True: # Did not modify original Series self.assertTrue(np.isnan(s2[0])) - self.assertFalse(np.isnan(s[0])) + assert not np.isnan(s[0]) else: # we DID modify the original Series self.assertTrue(np.isnan(s2[0])) diff --git a/pandas/tests/series/test_asof.py b/pandas/tests/series/test_asof.py index 9c1e4626e1736..137390b6427eb 100644 --- a/pandas/tests/series/test_asof.py +++ b/pandas/tests/series/test_asof.py @@ -140,7 +140,7 @@ def test_errors(self): Timestamp('20130102')]) # non-monotonic - self.assertFalse(s.index.is_monotonic) + assert not s.index.is_monotonic with pytest.raises(ValueError): s.asof(s.index[0]) diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py index a870667ff3f96..b08653b0001ca 100644 --- a/pandas/tests/series/test_constructors.py +++ b/pandas/tests/series/test_constructors.py @@ -65,8 +65,8 @@ def test_constructor(self): self.assertEqual(mixed.dtype, np.object_) assert mixed[1] is np.NaN - self.assertFalse(self.empty.index.is_all_dates) - self.assertFalse(Series({}).index.is_all_dates) + assert not self.empty.index.is_all_dates + assert not Series({}).index.is_all_dates pytest.raises(Exception, Series, np.random.randn(3, 3), index=np.arange(3)) @@ -265,7 +265,7 @@ def test_constructor_copy(self): # changes to origin of copy does not affect the copy x[0] = 2. - self.assertFalse(x.equals(y)) + assert not x.equals(y) self.assertEqual(x[0], 2.) self.assertEqual(y[0], 1.) @@ -354,7 +354,7 @@ def test_constructor_dtype_datetime64(self): # in theory this should be all nulls, but since # we are not specifying a dtype is ambiguous s = Series(iNaT, index=lrange(5)) - self.assertFalse(isnull(s).all()) + assert not isnull(s).all() s = Series(nan, dtype='M8[ns]', index=lrange(5)) self.assertTrue(isnull(s).all()) diff --git a/pandas/tests/series/test_datetime_values.py b/pandas/tests/series/test_datetime_values.py index 74a4e37f0923a..c56a5baac12af 100644 --- a/pandas/tests/series/test_datetime_values.py +++ b/pandas/tests/series/test_datetime_values.py @@ -378,7 +378,7 @@ def test_dt_accessor_api(self): with tm.assert_raises_regex(AttributeError, "only use .dt accessor"): s.dt - self.assertFalse(hasattr(s, 'dt')) + assert not hasattr(s, 'dt') def test_sub_of_datetime_from_TimeSeries(self): from pandas.core.tools.timedeltas import to_timedelta diff --git a/pandas/tests/series/test_indexing.py b/pandas/tests/series/test_indexing.py index 6907cc194f0f0..601262df89260 100644 --- a/pandas/tests/series/test_indexing.py +++ b/pandas/tests/series/test_indexing.py @@ -728,7 +728,7 @@ def test_setitem(self): self.assertTrue(np.isnan(self.ts[6])) self.assertTrue(np.isnan(self.ts[2])) self.ts[np.isnan(self.ts)] = 5 - self.assertFalse(np.isnan(self.ts[2])) + assert not np.isnan(self.ts[2]) # caught this bug when writing tests series = Series(tm.makeIntIndex(20).astype(float), @@ -1514,21 +1514,21 @@ def test_where_numeric_with_string(self): s = pd.Series([1, 2, 3]) w = s.where(s > 1, 'X') - self.assertFalse(is_integer(w[0])) + assert not is_integer(w[0]) self.assertTrue(is_integer(w[1])) self.assertTrue(is_integer(w[2])) self.assertTrue(isinstance(w[0], str)) self.assertTrue(w.dtype == 'object') w = s.where(s > 1, ['X', 'Y', 'Z']) - self.assertFalse(is_integer(w[0])) + assert not is_integer(w[0]) self.assertTrue(is_integer(w[1])) self.assertTrue(is_integer(w[2])) self.assertTrue(isinstance(w[0], str)) self.assertTrue(w.dtype == 'object') w = s.where(s > 1, np.array(['X', 'Y', 'Z'])) - self.assertFalse(is_integer(w[0])) + assert not is_integer(w[0]) self.assertTrue(is_integer(w[1])) self.assertTrue(is_integer(w[2])) self.assertTrue(isinstance(w[0], str)) @@ -1716,7 +1716,7 @@ def test_underlying_data_conversion(self): def test_preserveRefs(self): seq = self.ts[[5, 10, 15]] seq[1] = np.NaN - self.assertFalse(np.isnan(self.ts[10])) + assert not np.isnan(self.ts[10]) def test_drop(self): @@ -1851,7 +1851,7 @@ def test_align_nocopy(self): a = self.ts.copy() ra, _ = a.align(b, join='left') ra[:5] = 5 - self.assertFalse((a[:5] == 5).any()) + assert not (a[:5] == 5).any() # do not copy a = self.ts.copy() @@ -1864,7 +1864,7 @@ def test_align_nocopy(self): b = self.ts[:5].copy() _, rb = a.align(b, join='right') rb[:3] = 5 - self.assertFalse((b[:3] == 5).any()) + assert not (b[:3] == 5).any() # do not copy a = self.ts.copy() @@ -1952,7 +1952,7 @@ def test_reindex(self): # return a copy the same index here result = self.ts.reindex() - self.assertFalse((result is self.ts)) + assert not (result is self.ts) def test_reindex_nan(self): ts = Series([2, 3, 5, 7], index=[1, 4, nan, 8]) @@ -1974,7 +1974,7 @@ def test_reindex_series_add_nat(self): mask = result.isnull() self.assertTrue(mask[-5:].all()) - self.assertFalse(mask[:-5].any()) + assert not mask[:-5].any() def test_reindex_with_datetimes(self): rng = date_range('1/1/2000', periods=20) @@ -2279,7 +2279,7 @@ def test_constructor(self): assert isinstance(self.dups.index, DatetimeIndex) def test_is_unique_monotonic(self): - self.assertFalse(self.dups.index.is_unique) + assert not self.dups.index.is_unique def test_index_unique(self): uniques = self.dups.index.unique() diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py index e7c1b22216dcb..53c8c518eb3eb 100644 --- a/pandas/tests/series/test_missing.py +++ b/pandas/tests/series/test_missing.py @@ -487,19 +487,19 @@ def test_timedelta64_nan(self): self.assertTrue(isnull(td1[0])) self.assertEqual(td1[0].value, iNaT) td1[0] = td[0] - self.assertFalse(isnull(td1[0])) + assert not isnull(td1[0]) td1[1] = iNaT self.assertTrue(isnull(td1[1])) self.assertEqual(td1[1].value, iNaT) td1[1] = td[1] - self.assertFalse(isnull(td1[1])) + assert not isnull(td1[1]) td1[2] = NaT self.assertTrue(isnull(td1[2])) self.assertEqual(td1[2].value, iNaT) td1[2] = td[2] - self.assertFalse(isnull(td1[2])) + assert not isnull(td1[2]) # boolean setting # this doesn't work, not sure numpy even supports it @@ -552,7 +552,7 @@ def test_dropna_no_nan(self): result = s.dropna() tm.assert_series_equal(result, s) - self.assertFalse(result is s) + assert result is not s s2 = s.copy() s2.dropna(inplace=True) diff --git a/pandas/tests/series/test_operators.py b/pandas/tests/series/test_operators.py index 89ed7975e8017..eb840faac05e0 100644 --- a/pandas/tests/series/test_operators.py +++ b/pandas/tests/series/test_operators.py @@ -122,7 +122,7 @@ def test_div(self): assert_series_equal(result, p['first'].astype('float64'), check_names=False) self.assertTrue(result.name is None) - self.assertFalse(np.array_equal(result, p['second'] / p['first'])) + assert not np.array_equal(result, p['second'] / p['first']) # inf signing s = Series([np.nan, 1., -1.]) diff --git a/pandas/tests/series/test_repr.py b/pandas/tests/series/test_repr.py index b4ad90f6f35af..c92a82e287120 100644 --- a/pandas/tests/series/test_repr.py +++ b/pandas/tests/series/test_repr.py @@ -103,9 +103,9 @@ def test_repr(self): assert "Name: 0" in rep_str ser = Series(["a\n\r\tb"], name="a\n\r\td", index=["a\n\r\tf"]) - self.assertFalse("\t" in repr(ser)) - self.assertFalse("\r" in repr(ser)) - self.assertFalse("a\n" in repr(ser)) + assert "\t" not in repr(ser) + assert "\r" not in repr(ser) + assert "a\n" not in repr(ser) # with empty series (#4651) s = Series([], dtype=np.int64, name='foo') diff --git a/pandas/tests/sparse/test_array.py b/pandas/tests/sparse/test_array.py index bb6ff7a0c728f..33df4b5e59bc9 100644 --- a/pandas/tests/sparse/test_array.py +++ b/pandas/tests/sparse/test_array.py @@ -299,7 +299,7 @@ def test_constructor_from_sparse(self): def test_constructor_copy(self): cp = SparseArray(self.arr, copy=True) cp.sp_values[:3] = 0 - self.assertFalse((self.arr.sp_values[:3] == 0).any()) + assert not (self.arr.sp_values[:3] == 0).any() not_copy = SparseArray(self.arr) not_copy.sp_values[:3] = 0 @@ -323,11 +323,11 @@ def test_constructor_bool(self): def test_constructor_bool_fill_value(self): arr = SparseArray([True, False, True], dtype=None) self.assertEqual(arr.dtype, np.bool) - self.assertFalse(arr.fill_value) + assert not arr.fill_value arr = SparseArray([True, False, True], dtype=np.bool) self.assertEqual(arr.dtype, np.bool) - self.assertFalse(arr.fill_value) + assert not arr.fill_value arr = SparseArray([True, False, True], dtype=np.bool, fill_value=True) self.assertEqual(arr.dtype, np.bool) @@ -352,7 +352,7 @@ def test_constructor_float32(self): def test_astype(self): res = self.arr.astype('f8') res.sp_values[:3] = 27 - self.assertFalse((self.arr.sp_values[:3] == 27).any()) + assert not (self.arr.sp_values[:3] == 27).any() msg = "unable to coerce current fill_value nan to int64 dtype" with tm.assert_raises_regex(ValueError, msg): diff --git a/pandas/tests/sparse/test_libsparse.py b/pandas/tests/sparse/test_libsparse.py index 63ed11845a896..55115f45ff740 100644 --- a/pandas/tests/sparse/test_libsparse.py +++ b/pandas/tests/sparse/test_libsparse.py @@ -437,7 +437,7 @@ def test_equals(self): index = BlockIndex(10, [0, 4], [2, 5]) self.assertTrue(index.equals(index)) - self.assertFalse(index.equals(BlockIndex(10, [0, 4], [2, 6]))) + assert not index.equals(BlockIndex(10, [0, 4], [2, 6])) def test_check_integrity(self): locs = [] @@ -535,7 +535,7 @@ def test_int_internal(self): def test_equals(self): index = IntIndex(10, [0, 1, 2, 3, 4]) self.assertTrue(index.equals(index)) - self.assertFalse(index.equals(IntIndex(10, [0, 1, 2, 3]))) + assert not index.equals(IntIndex(10, [0, 1, 2, 3])) def test_to_block_index(self): diff --git a/pandas/tests/test_base.py b/pandas/tests/test_base.py index e4f39197421a0..e058a62ea3089 100644 --- a/pandas/tests/test_base.py +++ b/pandas/tests/test_base.py @@ -277,8 +277,8 @@ def test_none_comparison(self): # noinspection PyComparisonWithNone result = o == None # noqa - self.assertFalse(result.iat[0]) - self.assertFalse(result.iat[1]) + assert not result.iat[0] + assert not result.iat[1] # noinspection PyComparisonWithNone result = o != None # noqa @@ -286,8 +286,8 @@ def test_none_comparison(self): self.assertTrue(result.iat[1]) result = None == o # noqa - self.assertFalse(result.iat[0]) - self.assertFalse(result.iat[1]) + assert not result.iat[0] + assert not result.iat[1] # this fails for numpy < 1.9 # and oddly for *some* platforms @@ -296,12 +296,12 @@ def test_none_comparison(self): # self.assertTrue(result.iat[1]) result = None > o - self.assertFalse(result.iat[0]) - self.assertFalse(result.iat[1]) + assert not result.iat[0] + assert not result.iat[1] result = o < None - self.assertFalse(result.iat[0]) - self.assertFalse(result.iat[1]) + assert not result.iat[0] + assert not result.iat[1] def test_ndarray_compat_properties(self): @@ -796,10 +796,10 @@ def test_duplicated_drop_duplicates_index(self): self.assertTrue(duplicated.dtype == bool) result = original.drop_duplicates() tm.assert_index_equal(result, original) - self.assertFalse(result is original) + assert result is not original # has_duplicates - self.assertFalse(original.has_duplicates) + assert not original.has_duplicates # create repeated values, 3rd and 5th values are duplicated idx = original[list(range(len(original))) + [5, 3]] @@ -843,7 +843,7 @@ def test_duplicated_drop_duplicates_index(self): tm.assert_series_equal(original.duplicated(), expected) result = original.drop_duplicates() tm.assert_series_equal(result, original) - self.assertFalse(result is original) + assert result is not original idx = original.index[list(range(len(original))) + [5, 3]] values = original._values[list(range(len(original))) + [5, 3]] @@ -907,7 +907,7 @@ def test_fillna(self): else: tm.assert_series_equal(o, result) # check shallow_copied - self.assertFalse(o is result) + assert o is not result for null_obj in [np.nan, None]: for orig in self.objs: @@ -941,7 +941,7 @@ def test_fillna(self): else: tm.assert_series_equal(result, expected) # check shallow_copied - self.assertFalse(o is result) + assert o is not result def test_memory_usage(self): for o in self.objs: diff --git a/pandas/tests/test_categorical.py b/pandas/tests/test_categorical.py index bbcd42b147654..252b32e264c1b 100644 --- a/pandas/tests/test_categorical.py +++ b/pandas/tests/test_categorical.py @@ -117,7 +117,7 @@ def test_constructor_unsortable(self): # it works! arr = np.array([1, 2, 3, datetime.now()], dtype='O') factor = Categorical(arr, ordered=False) - self.assertFalse(factor.ordered) + assert not factor.ordered # this however will raise as cannot be sorted pytest.raises( @@ -143,14 +143,14 @@ def test_is_equal_dtype(self): self.assertTrue(c1.is_dtype_equal(c1)) self.assertTrue(c2.is_dtype_equal(c2)) self.assertTrue(c3.is_dtype_equal(c3)) - self.assertFalse(c1.is_dtype_equal(c2)) - self.assertFalse(c1.is_dtype_equal(c3)) - self.assertFalse(c1.is_dtype_equal(Index(list('aabca')))) - self.assertFalse(c1.is_dtype_equal(c1.astype(object))) + assert not c1.is_dtype_equal(c2) + assert not c1.is_dtype_equal(c3) + assert not c1.is_dtype_equal(Index(list('aabca'))) + assert not c1.is_dtype_equal(c1.astype(object)) self.assertTrue(c1.is_dtype_equal(CategoricalIndex(c1))) - self.assertFalse(c1.is_dtype_equal( + assert not (c1.is_dtype_equal( CategoricalIndex(c1, categories=list('cab')))) - self.assertFalse(c1.is_dtype_equal(CategoricalIndex(c1, ordered=True))) + assert not c1.is_dtype_equal(CategoricalIndex(c1, ordered=True)) def test_constructor(self): @@ -175,7 +175,7 @@ def f(): # The default should be unordered c1 = Categorical(["a", "b", "c", "a"]) - self.assertFalse(c1.ordered) + assert not c1.ordered # Categorical as input c1 = Categorical(["a", "b", "c", "a"]) @@ -534,7 +534,7 @@ def f(): # Only categories with same ordering information can be compared cat_unorderd = cat.set_ordered(False) - self.assertFalse((cat > cat).any()) + assert not (cat > cat).any() def f(): cat > cat_unorderd @@ -788,9 +788,9 @@ def f(): def test_construction_with_ordered(self): # GH 9347, 9190 cat = Categorical([0, 1, 2]) - self.assertFalse(cat.ordered) + assert not cat.ordered cat = Categorical([0, 1, 2], ordered=False) - self.assertFalse(cat.ordered) + assert not cat.ordered cat = Categorical([0, 1, 2], ordered=True) self.assertTrue(cat.ordered) @@ -798,12 +798,12 @@ def test_ordered_api(self): # GH 9347 cat1 = pd.Categorical(["a", "c", "b"], ordered=False) tm.assert_index_equal(cat1.categories, Index(['a', 'b', 'c'])) - self.assertFalse(cat1.ordered) + assert not cat1.ordered cat2 = pd.Categorical(["a", "c", "b"], categories=['b', 'c', 'a'], ordered=False) tm.assert_index_equal(cat2.categories, Index(['b', 'c', 'a'])) - self.assertFalse(cat2.ordered) + assert not cat2.ordered cat3 = pd.Categorical(["a", "c", "b"], ordered=True) tm.assert_index_equal(cat3.categories, Index(['a', 'b', 'c'])) @@ -818,20 +818,20 @@ def test_set_ordered(self): cat = Categorical(["a", "b", "c", "a"], ordered=True) cat2 = cat.as_unordered() - self.assertFalse(cat2.ordered) + assert not cat2.ordered cat2 = cat.as_ordered() self.assertTrue(cat2.ordered) cat2.as_unordered(inplace=True) - self.assertFalse(cat2.ordered) + assert not cat2.ordered cat2.as_ordered(inplace=True) self.assertTrue(cat2.ordered) self.assertTrue(cat2.set_ordered(True).ordered) - self.assertFalse(cat2.set_ordered(False).ordered) + assert not cat2.set_ordered(False).ordered cat2.set_ordered(True, inplace=True) self.assertTrue(cat2.ordered) cat2.set_ordered(False, inplace=True) - self.assertFalse(cat2.ordered) + assert not cat2.ordered # removed in 0.19.0 msg = "can\'t set attribute" @@ -1876,7 +1876,7 @@ def test_sideeffects_free(self): # other one, IF you specify copy! cat = Categorical(["a", "b", "c", "a"]) s = pd.Series(cat, copy=True) - self.assertFalse(s.cat is cat) + assert s.cat is not cat s.cat.categories = [1, 2, 3] exp_s = np.array([1, 2, 3, 1], dtype=np.int64) exp_cat = np.array(["a", "b", "c", "a"], dtype=np.object_) @@ -3783,17 +3783,17 @@ def test_cat_equality(self): f = Categorical(list('acb')) # vs scalar - self.assertFalse((a == 'a').all()) + assert not (a == 'a').all() self.assertTrue(((a != 'a') == ~(a == 'a')).all()) - self.assertFalse(('a' == a).all()) + assert not ('a' == a).all() self.assertTrue((a == 'a')[0]) self.assertTrue(('a' == a)[0]) - self.assertFalse(('a' != a)[0]) + assert not ('a' != a)[0] # vs list-like self.assertTrue((a == a).all()) - self.assertFalse((a != a).all()) + assert not (a != a).all() self.assertTrue((a == list(a)).all()) self.assertTrue((a == b).all()) @@ -3801,16 +3801,16 @@ def test_cat_equality(self): self.assertTrue(((~(a == b)) == (a != b)).all()) self.assertTrue(((~(b == a)) == (b != a)).all()) - self.assertFalse((a == c).all()) - self.assertFalse((c == a).all()) - self.assertFalse((a == d).all()) - self.assertFalse((d == a).all()) + assert not (a == c).all() + assert not (c == a).all() + assert not (a == d).all() + assert not (d == a).all() # vs a cat-like self.assertTrue((a == e).all()) self.assertTrue((e == a).all()) - self.assertFalse((a == f).all()) - self.assertFalse((f == a).all()) + assert not (a == f).all() + assert not (f == a).all() self.assertTrue(((~(a == e) == (a != e)).all())) self.assertTrue(((~(e == a) == (e != a)).all())) @@ -4226,7 +4226,7 @@ def test_cat_accessor_api(self): with tm.assert_raises_regex(AttributeError, "only use .cat accessor"): invalid.cat - self.assertFalse(hasattr(invalid, 'cat')) + assert not hasattr(invalid, 'cat') def test_cat_accessor_no_new_attributes(self): # https://github.com/pandas-dev/pandas/issues/10673 @@ -4309,7 +4309,7 @@ def test_str_accessor_api_for_categorical(self): "Can only use .str " "accessor with string"): invalid.str - self.assertFalse(hasattr(invalid, 'str')) + assert not hasattr(invalid, 'str') def test_dt_accessor_api_for_categorical(self): # https://github.com/pandas-dev/pandas/issues/10661 @@ -4390,7 +4390,7 @@ def test_dt_accessor_api_for_categorical(self): with tm.assert_raises_regex( AttributeError, "Can only use .dt accessor with datetimelike"): invalid.dt - self.assertFalse(hasattr(invalid, 'str')) + assert not hasattr(invalid, 'str') def test_concat_categorical(self): # See GH 10177 diff --git a/pandas/tests/test_config.py b/pandas/tests/test_config.py index f260895e74dda..0e614fdbfe008 100644 --- a/pandas/tests/test_config.py +++ b/pandas/tests/test_config.py @@ -114,8 +114,7 @@ def test_describe_option(self): self.assertTrue( 'foo' in self.cf.describe_option('l', _print_desc=False)) # current value is reported - self.assertFalse( - 'bar' in self.cf.describe_option('l', _print_desc=False)) + assert 'bar' not in self.cf.describe_option('l', _print_desc=False) self.cf.set_option("l", "bar") self.assertTrue( 'bar' in self.cf.describe_option('l', _print_desc=False)) diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py index 14e08411fa106..782d2682145d8 100644 --- a/pandas/tests/test_expressions.py +++ b/pandas/tests/test_expressions.py @@ -254,17 +254,17 @@ def test_invalid(self): # no op result = expr._can_use_numexpr(operator.add, None, self.frame, self.frame, 'evaluate') - self.assertFalse(result) + assert not result # mixed result = expr._can_use_numexpr(operator.add, '+', self.mixed, self.frame, 'evaluate') - self.assertFalse(result) + assert not result # min elements result = expr._can_use_numexpr(operator.add, '+', self.frame2, self.frame2, 'evaluate') - self.assertFalse(result) + assert not result # ok, we only check on first part of expression result = expr._can_use_numexpr(operator.add, '+', self.frame, @@ -308,7 +308,7 @@ def testit(): result = expr._can_use_numexpr(op, op_str, f2, f2, 'evaluate') - self.assertFalse(result) + assert not result expr.set_use_numexpr(False) testit() @@ -349,7 +349,7 @@ def testit(): result = expr._can_use_numexpr(op, op_str, f21, f22, 'evaluate') - self.assertFalse(result) + assert not result expr.set_use_numexpr(False) testit() diff --git a/pandas/tests/test_lib.py b/pandas/tests/test_lib.py index 5c3e6adb48808..621f624c41a19 100644 --- a/pandas/tests/test_lib.py +++ b/pandas/tests/test_lib.py @@ -152,7 +152,7 @@ def test_maybe_indices_to_slice_both_edges(self): for case in [[4, 2, 0, -2], [2, 2, 1, 0], [0, 1, 2, 1]]: indices = np.array(case, dtype=np.int64) maybe_slice = lib.maybe_indices_to_slice(indices, len(target)) - self.assertFalse(isinstance(maybe_slice, slice)) + assert not isinstance(maybe_slice, slice) tm.assert_numpy_array_equal(maybe_slice, indices) tm.assert_numpy_array_equal(target[indices], target[maybe_slice]) diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py index f350ef4351585..668f5b2a5a962 100755 --- a/pandas/tests/test_multilevel.py +++ b/pandas/tests/test_multilevel.py @@ -876,7 +876,7 @@ def test_stack(self): # GH10417 def check(left, right): tm.assert_series_equal(left, right) - self.assertFalse(left.index.is_unique) + assert not left.index.is_unique li, ri = left.index, right.index tm.assert_index_equal(li, ri) @@ -1225,7 +1225,7 @@ def test_join(self): expected = self.frame.copy() expected.values[np.isnan(joined.values)] = np.nan - self.assertFalse(np.isnan(joined.values).all()) + assert not np.isnan(joined.values).all() # TODO what should join do with names ? tm.assert_frame_equal(joined, expected, check_names=False) @@ -1235,7 +1235,7 @@ def test_swaplevel(self): swapped2 = self.frame['A'].swaplevel(0) swapped3 = self.frame['A'].swaplevel(0, 1) swapped4 = self.frame['A'].swaplevel('first', 'second') - self.assertFalse(swapped.index.equals(self.frame.index)) + assert not swapped.index.equals(self.frame.index) tm.assert_series_equal(swapped, swapped2) tm.assert_series_equal(swapped, swapped3) tm.assert_series_equal(swapped, swapped4) @@ -1831,7 +1831,7 @@ def test_drop_level_nonunique_datetime(self): df['tstamp'] = idxdt df = df.set_index('tstamp', append=True) ts = pd.Timestamp('201603231600') - self.assertFalse(df.index.is_unique) + assert not df.index.is_unique result = df.drop(ts, level='tstamp') expected = df.loc[idx != 4] @@ -2430,11 +2430,11 @@ def test_is_lexsorted(self): index = MultiIndex(levels=levels, labels=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]]) - self.assertFalse(index.is_lexsorted()) + assert not index.is_lexsorted() index = MultiIndex(levels=levels, labels=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]]) - self.assertFalse(index.is_lexsorted()) + assert not index.is_lexsorted() self.assertEqual(index.lexsort_depth, 0) def test_getitem_multilevel_index_tuple_not_sorted(self): diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py index 1aad2f5224c0d..a108749db8e6a 100644 --- a/pandas/tests/test_nanops.py +++ b/pandas/tests/test_nanops.py @@ -659,7 +659,7 @@ def check_bool(self, func, value, correct, *args, **kwargs): if correct: self.assertTrue(res0) else: - self.assertFalse(res0) + assert not res0 except BaseException as exc: exc.args += ('dim: %s' % getattr(value, 'ndim', value), ) raise @@ -742,9 +742,9 @@ def test__bn_ok_dtype(self): self.assertTrue(nanops._bn_ok_dtype(self.arr_bool.dtype, 'test')) self.assertTrue(nanops._bn_ok_dtype(self.arr_str.dtype, 'test')) self.assertTrue(nanops._bn_ok_dtype(self.arr_utf.dtype, 'test')) - self.assertFalse(nanops._bn_ok_dtype(self.arr_date.dtype, 'test')) - self.assertFalse(nanops._bn_ok_dtype(self.arr_tdelta.dtype, 'test')) - self.assertFalse(nanops._bn_ok_dtype(self.arr_obj.dtype, 'test')) + assert not nanops._bn_ok_dtype(self.arr_date.dtype, 'test') + assert not nanops._bn_ok_dtype(self.arr_tdelta.dtype, 'test') + assert not nanops._bn_ok_dtype(self.arr_obj.dtype, 'test') class TestEnsureNumeric(tm.TestCase): diff --git a/pandas/tests/test_panel.py b/pandas/tests/test_panel.py index 322ea32a93562..802acc86d3359 100644 --- a/pandas/tests/test_panel.py +++ b/pandas/tests/test_panel.py @@ -1050,7 +1050,7 @@ def test_consolidate(self): self.assertTrue(self.panel._data.is_consolidated()) self.panel['foo'] = 1. - self.assertFalse(self.panel._data.is_consolidated()) + assert not self.panel._data.is_consolidated() panel = self.panel._consolidate() self.assertTrue(panel._data.is_consolidated()) @@ -1425,7 +1425,7 @@ def test_reindex(self): # this ok result = self.panel.reindex() assert_panel_equal(result, self.panel) - self.assertFalse(result is self.panel) + assert result is not self.panel # with filling smaller_major = self.panel.major_axis[::5] diff --git a/pandas/tests/test_panel4d.py b/pandas/tests/test_panel4d.py index 05b42cdf00e94..5b4f09009c9db 100644 --- a/pandas/tests/test_panel4d.py +++ b/pandas/tests/test_panel4d.py @@ -684,7 +684,7 @@ def test_consolidate(self): self.assertTrue(self.panel4d._data.is_consolidated()) self.panel4d['foo'] = 1. - self.assertFalse(self.panel4d._data.is_consolidated()) + assert not self.panel4d._data.is_consolidated() panel4d = self.panel4d._consolidate() self.assertTrue(panel4d._data.is_consolidated()) @@ -803,7 +803,7 @@ def test_reindex(self): # don't necessarily copy result = self.panel4d.reindex() assert_panel4d_equal(result, self.panel4d) - self.assertFalse(result is self.panel4d) + assert result is not self.panel4d # with filling smaller_major = self.panel4d.major_axis[::5] @@ -857,7 +857,7 @@ def test_sort_index(self): def test_fillna(self): with catch_warnings(record=True): - self.assertFalse(np.isfinite(self.panel4d.values).all()) + assert not np.isfinite(self.panel4d.values).all() filled = self.panel4d.fillna(0) self.assertTrue(np.isfinite(filled.values).all()) diff --git a/pandas/tests/test_resample.py b/pandas/tests/test_resample.py index f5309a985a499..42a6a2a784a0e 100644 --- a/pandas/tests/test_resample.py +++ b/pandas/tests/test_resample.py @@ -134,8 +134,8 @@ def f(): # masquerade as Series/DataFrame as needed for API compat self.assertTrue(isinstance(self.series.resample('H'), ABCSeries)) - self.assertFalse(isinstance(self.frame.resample('H'), ABCSeries)) - self.assertFalse(isinstance(self.series.resample('H'), ABCDataFrame)) + assert not isinstance(self.frame.resample('H'), ABCSeries) + assert not isinstance(self.series.resample('H'), ABCDataFrame) self.assertTrue(isinstance(self.frame.resample('H'), ABCDataFrame)) # bin numeric ops diff --git a/pandas/tests/test_strings.py b/pandas/tests/test_strings.py index db0c2fdc80fd2..45e8aa3a367db 100644 --- a/pandas/tests/test_strings.py +++ b/pandas/tests/test_strings.py @@ -32,7 +32,7 @@ def test_api(self): with tm.assert_raises_regex(AttributeError, "only use .str accessor"): invalid.str - self.assertFalse(hasattr(invalid, 'str')) + assert not hasattr(invalid, 'str') def test_iter(self): # GH3638 @@ -76,7 +76,7 @@ def test_iter_single_element(self): for i, s in enumerate(ds.str): pass - self.assertFalse(i) + assert not i assert_series_equal(ds, s) def test_iter_object_try_string(self): diff --git a/pandas/tests/test_window.py b/pandas/tests/test_window.py index adfecc90129e9..13d471f368693 100644 --- a/pandas/tests/test_window.py +++ b/pandas/tests/test_window.py @@ -1298,9 +1298,9 @@ def get_result(arr, window, min_periods=None, center=False): # min_periods is working correctly result = get_result(arr, 20, min_periods=15) self.assertTrue(np.isnan(result[23])) - self.assertFalse(np.isnan(result[24])) + assert not np.isnan(result[24]) - self.assertFalse(np.isnan(result[-6])) + assert not np.isnan(result[-6]) self.assertTrue(np.isnan(result[-5])) arr2 = randn(20) @@ -1660,18 +1660,18 @@ def _check_ew_ndarray(self, func, preserve_nan=False, name=None): # GH 7898 result = func(s, 50, min_periods=2) self.assertTrue(np.isnan(result.values[:11]).all()) - self.assertFalse(np.isnan(result.values[11:]).any()) + assert not np.isnan(result.values[11:]).any() for min_periods in (0, 1): result = func(s, 50, min_periods=min_periods) if func == mom.ewma: self.assertTrue(np.isnan(result.values[:10]).all()) - self.assertFalse(np.isnan(result.values[10:]).any()) + assert not np.isnan(result.values[10:]).any() else: # ewmstd, ewmvol, ewmvar (with bias=False) require at least two # values self.assertTrue(np.isnan(result.values[:11]).all()) - self.assertFalse(np.isnan(result.values[11:]).any()) + assert not np.isnan(result.values[11:]).any() # check series of length 0 result = func(Series([]), 50, min_periods=min_periods) @@ -2010,11 +2010,11 @@ def _non_null_values(x): # check that var(x), std(x), and cov(x) are all >= 0 var_x = var(x) std_x = std(x) - self.assertFalse((var_x < 0).any().any()) - self.assertFalse((std_x < 0).any().any()) + assert not (var_x < 0).any().any() + assert not (std_x < 0).any().any() if cov: cov_x_x = cov(x, x) - self.assertFalse((cov_x_x < 0).any().any()) + assert not (cov_x_x < 0).any().any() # check that var(x) == cov(x, x) assert_equal(var_x, cov_x_x) @@ -2029,7 +2029,7 @@ def _non_null_values(x): if is_constant: # check that variance of constant series is identically 0 - self.assertFalse((var_x > 0).any().any()) + assert not (var_x > 0).any().any() expected = x * np.nan expected[count_x >= max(min_periods, 1)] = 0. if var is var_unbiased: @@ -2466,7 +2466,7 @@ def func(A, B, com, **kwargs): result = func(A, B, 20, min_periods=5) self.assertTrue(np.isnan(result.values[:14]).all()) - self.assertFalse(np.isnan(result.values[14:]).any()) + assert not np.isnan(result.values[14:]).any() # GH 7898 for min_periods in (0, 1, 2): @@ -2474,7 +2474,7 @@ def func(A, B, com, **kwargs): # binary functions (ewmcov, ewmcorr) with bias=False require at # least two values self.assertTrue(np.isnan(result.values[:11]).all()) - self.assertFalse(np.isnan(result.values[11:]).any()) + assert not np.isnan(result.values[11:]).any() # check series of length 0 result = func(Series([]), Series([]), 50, min_periods=min_periods) @@ -2891,7 +2891,7 @@ def _check_expanding_ndarray(self, func, static_comp, has_min_periods=True, # min_periods is working correctly result = func(arr, min_periods=15) self.assertTrue(np.isnan(result[13])) - self.assertFalse(np.isnan(result[14])) + assert not np.isnan(result[14]) arr2 = randn(20) result = func(arr2, min_periods=5) @@ -3050,7 +3050,7 @@ def f(): pytest.raises(TypeError, f) g = self.frame.groupby('A') - self.assertFalse(g.mutated) + assert not g.mutated g = self.frame.groupby('A', mutated=True) self.assertTrue(g.mutated) @@ -3277,7 +3277,7 @@ def test_monotonic_on(self): # non-monotonic df.index = reversed(df.index.tolist()) - self.assertFalse(df.index.is_monotonic) + assert not df.index.is_monotonic with pytest.raises(ValueError): df.rolling('2s').sum() diff --git a/pandas/tests/tseries/test_offsets.py b/pandas/tests/tseries/test_offsets.py index cb3fc3b60226f..1332be2567b56 100644 --- a/pandas/tests/tseries/test_offsets.py +++ b/pandas/tests/tseries/test_offsets.py @@ -446,7 +446,7 @@ def test_onOffset(self): # when normalize=True, onOffset checks time is 00:00:00 offset_n = self._get_offset(offset, normalize=True) - self.assertFalse(offset_n.onOffset(dt)) + assert not offset_n.onOffset(dt) if offset in (BusinessHour, CustomBusinessHour): # In default BusinessHour (9:00-17:00), normalized time @@ -718,7 +718,7 @@ def test_offsets_compare_equal(self): # root cause of #456 offset1 = BDay() offset2 = BDay() - self.assertFalse(offset1 != offset2) + assert not offset1 != offset2 class TestBusinessHour(Base): @@ -1389,7 +1389,7 @@ def test_offsets_compare_equal(self): # root cause of #456 offset1 = self._offset() offset2 = self._offset() - self.assertFalse(offset1 != offset2) + assert not offset1 != offset2 def test_datetimeindex(self): idx1 = DatetimeIndex(start='2014-07-04 15:00', end='2014-07-08 10:00', @@ -1859,7 +1859,7 @@ def test_offsets_compare_equal(self): # root cause of #456 offset1 = CDay() offset2 = CDay() - self.assertFalse(offset1 != offset2) + assert not offset1 != offset2 def test_holidays(self): # Define a TradingDay offset @@ -1964,7 +1964,7 @@ def testMult2(self): def test_offsets_compare_equal(self): offset1 = self._object() offset2 = self._object() - self.assertFalse(offset1 != offset2) + assert not offset1 != offset2 def test_roundtrip_pickle(self): def _check_roundtrip(obj): @@ -2230,9 +2230,9 @@ def test_corner(self): def test_isAnchored(self): self.assertTrue(Week(weekday=0).isAnchored()) - self.assertFalse(Week().isAnchored()) - self.assertFalse(Week(2, weekday=2).isAnchored()) - self.assertFalse(Week(2).isAnchored()) + assert not Week().isAnchored() + assert not Week(2, weekday=2).isAnchored() + assert not Week(2).isAnchored() def test_offset(self): tests = [] @@ -2284,7 +2284,7 @@ def test_offsets_compare_equal(self): # root cause of #456 offset1 = Week() offset2 = Week() - self.assertFalse(offset1 != offset2) + assert not offset1 != offset2 class TestWeekOfMonth(Base): @@ -2507,7 +2507,7 @@ def test_offsets_compare_equal(self): # root cause of #456 offset1 = BMonthBegin() offset2 = BMonthBegin() - self.assertFalse(offset1 != offset2) + assert not offset1 != offset2 class TestBMonthEnd(Base): @@ -2570,7 +2570,7 @@ def test_offsets_compare_equal(self): # root cause of #456 offset1 = BMonthEnd() offset2 = BMonthEnd() - self.assertFalse(offset1 != offset2) + assert not offset1 != offset2 class TestMonthBegin(Base): @@ -3043,7 +3043,7 @@ def test_repr(self): def test_isAnchored(self): self.assertTrue(BQuarterBegin(startingMonth=1).isAnchored()) self.assertTrue(BQuarterBegin().isAnchored()) - self.assertFalse(BQuarterBegin(2, startingMonth=1).isAnchored()) + assert not BQuarterBegin(2, startingMonth=1).isAnchored() def test_offset(self): tests = [] @@ -3137,7 +3137,7 @@ def test_repr(self): def test_isAnchored(self): self.assertTrue(BQuarterEnd(startingMonth=1).isAnchored()) self.assertTrue(BQuarterEnd().isAnchored()) - self.assertFalse(BQuarterEnd(2, startingMonth=1).isAnchored()) + assert not BQuarterEnd(2, startingMonth=1).isAnchored() def test_offset(self): tests = [] @@ -3512,9 +3512,9 @@ def test_isAnchored(self): self.assertTrue( makeFY5253LastOfMonthQuarter(weekday=WeekDay.SAT, startingMonth=3, qtr_with_extra_week=4).isAnchored()) - self.assertFalse(makeFY5253LastOfMonthQuarter( + assert not makeFY5253LastOfMonthQuarter( 2, startingMonth=1, weekday=WeekDay.SAT, - qtr_with_extra_week=4).isAnchored()) + qtr_with_extra_week=4).isAnchored() def test_equality(self): self.assertEqual(makeFY5253LastOfMonthQuarter(startingMonth=1, @@ -3676,20 +3676,17 @@ def test_year_has_extra_week(self): .year_has_extra_week(datetime(2010, 12, 26))) # End of year before year with long Q1 - self.assertFalse( - makeFY5253LastOfMonthQuarter( - 1, startingMonth=12, weekday=WeekDay.SAT, - qtr_with_extra_week=1) - .year_has_extra_week(datetime(2010, 12, 25))) + assert not makeFY5253LastOfMonthQuarter( + 1, startingMonth=12, weekday=WeekDay.SAT, + qtr_with_extra_week=1).year_has_extra_week(datetime(2010, 12, 25)) for year in [x for x in range(1994, 2011 + 1) if x not in [2011, 2005, 2000, 1994]]: - self.assertFalse( - makeFY5253LastOfMonthQuarter( - 1, startingMonth=12, weekday=WeekDay.SAT, - qtr_with_extra_week=1) - .year_has_extra_week(datetime(year, 4, 2))) + assert not makeFY5253LastOfMonthQuarter( + 1, startingMonth=12, weekday=WeekDay.SAT, + qtr_with_extra_week=1).year_has_extra_week( + datetime(year, 4, 2)) # Other long years self.assertTrue( @@ -3825,7 +3822,7 @@ def test_repr(self): def test_isAnchored(self): self.assertTrue(QuarterBegin(startingMonth=1).isAnchored()) self.assertTrue(QuarterBegin().isAnchored()) - self.assertFalse(QuarterBegin(2, startingMonth=1).isAnchored()) + assert not QuarterBegin(2, startingMonth=1).isAnchored() def test_offset(self): tests = [] @@ -3903,7 +3900,7 @@ def test_repr(self): def test_isAnchored(self): self.assertTrue(QuarterEnd(startingMonth=1).isAnchored()) self.assertTrue(QuarterEnd().isAnchored()) - self.assertFalse(QuarterEnd(2, startingMonth=1).isAnchored()) + assert not QuarterEnd(2, startingMonth=1).isAnchored() def test_offset(self): tests = [] @@ -4527,7 +4524,7 @@ def test_tick_operators(self): def test_tick_offset(self): for t in self.ticks: - self.assertFalse(t().isAnchored()) + assert not t().isAnchored() def test_compare_ticks(self): for kls in self.ticks: @@ -4758,7 +4755,7 @@ def setUp(self): def run_X_index_creation(self, cls): inst1 = cls() if not inst1.isAnchored(): - self.assertFalse(inst1._should_cache(), cls) + assert not inst1._should_cache(), cls return self.assertTrue(inst1._should_cache(), cls) @@ -4768,13 +4765,13 @@ def run_X_index_creation(self, cls): self.assertTrue(cls() in _daterange_cache, cls) def test_should_cache_month_end(self): - self.assertFalse(MonthEnd()._should_cache()) + assert not MonthEnd()._should_cache() def test_should_cache_bmonth_end(self): - self.assertFalse(BusinessMonthEnd()._should_cache()) + assert not BusinessMonthEnd()._should_cache() def test_should_cache_week_month(self): - self.assertFalse(WeekOfMonth(weekday=1, week=2)._should_cache()) + assert not WeekOfMonth(weekday=1, week=2)._should_cache() def test_all_cacheableoffsets(self): for subclass in get_all_subclasses(CacheableOffset): @@ -4786,19 +4783,19 @@ def test_all_cacheableoffsets(self): def test_month_end_index_creation(self): DatetimeIndex(start=datetime(2013, 1, 31), end=datetime(2013, 3, 31), freq=MonthEnd(), normalize=True) - self.assertFalse(MonthEnd() in _daterange_cache) + assert not MonthEnd() in _daterange_cache def test_bmonth_end_index_creation(self): DatetimeIndex(start=datetime(2013, 1, 31), end=datetime(2013, 3, 29), freq=BusinessMonthEnd(), normalize=True) - self.assertFalse(BusinessMonthEnd() in _daterange_cache) + assert not BusinessMonthEnd() in _daterange_cache def test_week_of_month_index_creation(self): inst1 = WeekOfMonth(weekday=1, week=2) DatetimeIndex(start=datetime(2013, 1, 31), end=datetime(2013, 3, 29), freq=inst1, normalize=True) inst2 = WeekOfMonth(weekday=1, week=2) - self.assertFalse(inst2 in _daterange_cache) + assert inst2 not in _daterange_cache class TestReprNames(tm.TestCase): diff --git a/pandas/tests/tseries/test_timezones.py b/pandas/tests/tseries/test_timezones.py index 807d6866cbf74..65db858a6ccf1 100644 --- a/pandas/tests/tseries/test_timezones.py +++ b/pandas/tests/tseries/test_timezones.py @@ -1284,7 +1284,7 @@ def test_index_equals_with_tz(self): left = date_range('1/1/2011', periods=100, freq='H', tz='utc') right = date_range('1/1/2011', periods=100, freq='H', tz='US/Eastern') - self.assertFalse(left.equals(right)) + assert not left.equals(right) def test_tz_localize_naive(self): rng = date_range('1/1/2011', periods=100, freq='H') @@ -1627,7 +1627,7 @@ def test_normalize_tz(self): tm.assert_index_equal(result, expected) self.assertTrue(result.is_normalized) - self.assertFalse(rng.is_normalized) + assert not rng.is_normalized rng = date_range('1/1/2000 9:30', periods=10, freq='D', tz='UTC') @@ -1636,7 +1636,7 @@ def test_normalize_tz(self): tm.assert_index_equal(result, expected) self.assertTrue(result.is_normalized) - self.assertFalse(rng.is_normalized) + assert not rng.is_normalized from dateutil.tz import tzlocal rng = date_range('1/1/2000 9:30', periods=10, freq='D', tz=tzlocal()) @@ -1645,7 +1645,7 @@ def test_normalize_tz(self): tm.assert_index_equal(result, expected) self.assertTrue(result.is_normalized) - self.assertFalse(rng.is_normalized) + assert not rng.is_normalized def test_normalize_tz_local(self): # GH 13459 @@ -1665,7 +1665,7 @@ def test_normalize_tz_local(self): tm.assert_index_equal(result, expected) self.assertTrue(result.is_normalized) - self.assertFalse(rng.is_normalized) + assert not rng.is_normalized def test_tzaware_offset(self): dates = date_range('2012-11-01', periods=3, tz='US/Pacific')