TST: stricter monotonicity/uniqueness tests (part 2)

pandas/tests/indexes/common.py

@@ -353,8 +353,8 @@ def test_has_duplicates(self, indices):
             pytest.skip('Skip check for empty Index and MultiIndex')
 
         idx = self._holder([indices[0]] * 5)
-        assert not idx.is_unique
-        assert idx.has_duplicates
+        assert idx.is_unique is False
+        assert idx.has_duplicates is True
 
     @pytest.mark.parametrize('keep', ['first', 'last', False])
     def test_duplicated(self, indices, keep):
@@ -414,7 +414,7 @@ def test_get_unique_index(self, indices):
 
         # We test against `idx_unique`, so first we make sure it's unique
         # and doesn't contain nans.
-        assert idx_unique.is_unique
+        assert idx_unique.is_unique is True
         try:
             assert not idx_unique.hasnans
         except NotImplementedError:
@@ -438,7 +438,7 @@ def test_get_unique_index(self, indices):
         vals_unique = vals[:2]
         idx_nan = indices._shallow_copy(vals)
         idx_unique_nan = indices._shallow_copy(vals_unique)
-        assert idx_unique_nan.is_unique
+        assert idx_unique_nan.is_unique is True
 
         assert idx_nan.dtype == indices.dtype
         assert idx_unique_nan.dtype == indices.dtype

pandas/tests/indexes/interval/test_interval.py

@@ -243,108 +243,108 @@ def test_unique(self, closed):
         # unique non-overlapping
         idx = IntervalIndex.from_tuples(
             [(0, 1), (2, 3), (4, 5)], closed=closed)
-        assert idx.is_unique
+        assert idx.is_unique is True
 
         # unique overlapping - distinct endpoints
         idx = IntervalIndex.from_tuples([(0, 1), (0.5, 1.5)], closed=closed)
-        assert idx.is_unique
+        assert idx.is_unique is True
 
         # unique overlapping - shared endpoints
         idx = pd.IntervalIndex.from_tuples(
             [(1, 2), (1, 3), (2, 3)], closed=closed)
-        assert idx.is_unique
+        assert idx.is_unique is True
 
         # unique nested
         idx = IntervalIndex.from_tuples([(-1, 1), (-2, 2)], closed=closed)
-        assert idx.is_unique
+        assert idx.is_unique is True
 
         # duplicate
         idx = IntervalIndex.from_tuples(
             [(0, 1), (0, 1), (2, 3)], closed=closed)
-        assert not idx.is_unique
+        assert idx.is_unique is False
 
         # empty
         idx = IntervalIndex([], closed=closed)
-        assert idx.is_unique
+        assert idx.is_unique is True
 
     def test_monotonic(self, closed):
         # increasing non-overlapping
         idx = IntervalIndex.from_tuples(
             [(0, 1), (2, 3), (4, 5)], closed=closed)
-        assert idx.is_monotonic
-        assert idx._is_strictly_monotonic_increasing
-        assert not idx.is_monotonic_decreasing
-        assert not idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
 
         # decreasing non-overlapping
         idx = IntervalIndex.from_tuples(
             [(4, 5), (2, 3), (1, 2)], closed=closed)
-        assert not idx.is_monotonic
-        assert not idx._is_strictly_monotonic_increasing
-        assert idx.is_monotonic_decreasing
-        assert idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
 
         # unordered non-overlapping
         idx = IntervalIndex.from_tuples(
             [(0, 1), (4, 5), (2, 3)], closed=closed)
-        assert not idx.is_monotonic
-        assert not idx._is_strictly_monotonic_increasing
-        assert not idx.is_monotonic_decreasing
-        assert not idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
 
         # increasing overlapping
         idx = IntervalIndex.from_tuples(
             [(0, 2), (0.5, 2.5), (1, 3)], closed=closed)
-        assert idx.is_monotonic
-        assert idx._is_strictly_monotonic_increasing
-        assert not idx.is_monotonic_decreasing
-        assert not idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
 
         # decreasing overlapping
         idx = IntervalIndex.from_tuples(
             [(1, 3), (0.5, 2.5), (0, 2)], closed=closed)
-        assert not idx.is_monotonic
-        assert not idx._is_strictly_monotonic_increasing
-        assert idx.is_monotonic_decreasing
-        assert idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
 
         # unordered overlapping
         idx = IntervalIndex.from_tuples(
             [(0.5, 2.5), (0, 2), (1, 3)], closed=closed)
-        assert not idx.is_monotonic
-        assert not idx._is_strictly_monotonic_increasing
-        assert not idx.is_monotonic_decreasing
-        assert not idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
 
         # increasing overlapping shared endpoints
         idx = pd.IntervalIndex.from_tuples(
             [(1, 2), (1, 3), (2, 3)], closed=closed)
-        assert idx.is_monotonic
-        assert idx._is_strictly_monotonic_increasing
-        assert not idx.is_monotonic_decreasing
-        assert not idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is False
+        assert idx._is_strictly_monotonic_decreasing is False
 
         # decreasing overlapping shared endpoints
         idx = pd.IntervalIndex.from_tuples(
             [(2, 3), (1, 3), (1, 2)], closed=closed)
-        assert not idx.is_monotonic
-        assert not idx._is_strictly_monotonic_increasing
-        assert idx.is_monotonic_decreasing
-        assert idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is False
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
 
         # stationary
         idx = IntervalIndex.from_tuples([(0, 1), (0, 1)], closed=closed)
-        assert idx.is_monotonic
-        assert not idx._is_strictly_monotonic_increasing
-        assert idx.is_monotonic_decreasing
-        assert not idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is True
+        assert idx._is_strictly_monotonic_increasing is False
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is False
 
         # empty
         idx = IntervalIndex([], closed=closed)
-        assert idx.is_monotonic
-        assert idx._is_strictly_monotonic_increasing
-        assert idx.is_monotonic_decreasing
-        assert idx._is_strictly_monotonic_decreasing
+        assert idx.is_monotonic is True
+        assert idx._is_strictly_monotonic_increasing is True
+        assert idx.is_monotonic_decreasing is True
+        assert idx._is_strictly_monotonic_decreasing is True
 
     @pytest.mark.skip(reason='not a valid repr as we use interval notation')
     def test_repr(self):

pandas/tests/indexes/multi/test_duplicates.py

@@ -131,16 +131,16 @@ def test_duplicate_meta_data():
 
 def test_has_duplicates(idx, idx_dup):
     # see fixtures
-    assert idx.is_unique
-    assert not idx.has_duplicates
-    assert not idx_dup.is_unique
-    assert idx_dup.has_duplicates
+    assert idx.is_unique is True
+    assert idx.has_duplicates is False
+    assert idx_dup.is_unique is False
+    assert idx_dup.has_duplicates is True
 
     mi = MultiIndex(levels=[[0, 1], [0, 1, 2]],
                     labels=[[0, 0, 0, 0, 1, 1, 1],
                             [0, 1, 2, 0, 0, 1, 2]])
-    assert not mi.is_unique
-    assert mi.has_duplicates
+    assert mi.is_unique is False
+    assert mi.has_duplicates is True
 
 
 def test_has_duplicates_from_tuples():

pandas/tests/indexes/multi/test_integrity.py

@@ -110,7 +110,7 @@ def test_consistency():
     index = MultiIndex(levels=[major_axis, minor_axis],
                        labels=[major_labels, minor_labels])
 
-    assert not index.is_unique
+    assert index.is_unique is False
 
 
 def test_hash_collisions():

pandas/tests/indexing/test_loc.py

@@ -676,15 +676,15 @@ def gen_expected(df, mask):
                               df.take(mask[1:])])
 
         df = gen_test(900, 100)
-        assert not df.index.is_unique
+        assert df.index.is_unique is False
 
         mask = np.arange(100)
         result = df.loc[mask]
         expected = gen_expected(df, mask)
         tm.assert_frame_equal(result, expected)
 
         df = gen_test(900000, 100000)
-        assert not df.index.is_unique
+        assert df.index.is_unique is False
 
         mask = np.arange(100000)
         result = df.loc[mask]

pandas/tests/series/indexing/test_indexing.py

@@ -387,7 +387,7 @@ def test_set_value(test_data):
 def test_setslice(test_data):
     sl = test_data.ts[5:20]
     assert len(sl) == len(sl.index)
-    assert sl.index.is_unique
+    assert sl.index.is_unique is True
 
 
 # FutureWarning from NumPy about [slice(None, 5).

pandas/tests/series/test_duplicates.py

@@ -63,9 +63,9 @@ def test_unique_data_ownership():
 def test_is_unique():
     # GH11946
     s = Series(np.random.randint(0, 10, size=1000))
-    assert not s.is_unique
+    assert s.is_unique is False
     s = Series(np.arange(1000))
-    assert s.is_unique
+    assert s.is_unique is True
 
 
 def test_is_unique_class_ne(capsys):

pandas/tests/test_algos.py

@@ -1109,7 +1109,7 @@ def test_datetime_likes(self):
     def test_unique_index(self):
         cases = [Index([1, 2, 3]), pd.RangeIndex(0, 3)]
         for case in cases:
-            assert case.is_unique
+            assert case.is_unique is True
             tm.assert_numpy_array_equal(case.duplicated(),
                                         np.array([False, False, False]))
 

pandas/tests/test_multilevel.py

@@ -495,7 +495,7 @@ def test_xs_partial(self):
     def test_xs_with_duplicates(self):
         # Issue #13719
         df_dup = concat([self.frame] * 2)
-        assert not df_dup.index.is_unique
+        assert df_dup.index.is_unique is False
         expected = concat([self.frame.xs('one', level='second')] * 2)
         tm.assert_frame_equal(df_dup.xs('one', level='second'), expected)
         tm.assert_frame_equal(df_dup.xs(['one'], level=['second']), expected)
@@ -889,7 +889,7 @@ def test_stack(self):
         # GH10417
         def check(left, right):
             tm.assert_series_equal(left, right)
-            assert not left.index.is_unique
+            assert left.index.is_unique is False
             li, ri = left.index, right.index
             tm.assert_index_equal(li, ri)
 
@@ -1922,7 +1922,7 @@ def test_drop_level_nonunique_datetime(self):
         df['tstamp'] = idxdt
         df = df.set_index('tstamp', append=True)
         ts = Timestamp('201603231600')
-        assert not df.index.is_unique
+        assert df.index.is_unique is False
 
         result = df.drop(ts, level='tstamp')
         expected = df.loc[idx != 4]

pandas/tests/util/test_hashing.py

@@ -110,9 +110,9 @@ def test_hash_tuples_err(self, val):
     def test_multiindex_unique(self):
         mi = MultiIndex.from_tuples([(118, 472), (236, 118),
                                      (51, 204), (102, 51)])
-        assert mi.is_unique
+        assert mi.is_unique is True
         result = hash_pandas_object(mi)
-        assert result.is_unique
+        assert result.is_unique is True
 
     def test_multiindex_objects(self):
         mi = MultiIndex(levels=[['b', 'd', 'a'], [1, 2, 3]],