clean up ASV code a bit

Author: topper-123

asv_bench/benchmarks/indexing_engines.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-import pandas.util.testing as tm
 from pandas._libs.index import (Int64Engine, Int32Engine,
                                 Int16Engine, Int8Engine,
                                 UInt64Engine, UInt32Engine,
@@ -32,10 +31,9 @@ def setup(self, engine, index_type):
         }[index_type]
 
         self.data = engine(lambda: array_, len(array_))
-        self.int_scalar = 2
 
     def time_get_loc(self, engine, index_type):
-        self.data.get_loc(self.int_scalar)
+        self.data.get_loc(2)
 
 
 class ObjectEngineIndexing(object):
@@ -57,7 +55,6 @@ def setup(self, engine, index_type):
         }[index_type]
 
         self.data = engine(lambda: array_, len(array_))
-        self.int_scalar = 'b'
 
     def time_get_loc(self, engine, index_type):
-        self.data.get_loc(self.int_scalar)
+        self.data.get_loc(2)

pandas/tests/indexes/conftest.py

@@ -54,7 +54,7 @@ def zero(request):
         'UInt64', 'UInt32', 'UInt16', 'UInt8',
         'Float64', 'Float32',
     ])
-def num_engine(request):
-    """Return the various numeric engines in pd._libs.index
+def numeric_indexing_engine(request):
+    """Return the various numeric indexing engines in pd._libs.index
     """
     return getattr(li, "{}Engine".format(request.param))

pandas/tests/indexes/test_category.py

@@ -1122,23 +1122,29 @@ def test_take_invalid_kwargs(self):
 
 class TestCategoricalIndexEngine(object):
 
-    @pytest.mark.parametrize('nbits', [8, 16, 32, 64])
-    def test_engine_type(self, nbits):
-        """Check that a CategoricalIndex has the correct engine type.
+    def setup_method(self):
+        self.n_categories = {np.int8: 1, np.int16: 129, np.int32: 32769}
+
+        self.engines = {np.int8: libindex.Int8Engine,
+                        np.int16: libindex.Int16Engine,
+                        np.int32: libindex.Int32Engine,
+                        np.int64: libindex.Int64Engine}
+
+    @pytest.mark.parametrize('dtype', [np.int8, np.int16, np.int32, np.int64])
+    def test_engine_type(self, dtype):
+        """
+        Check that a CategoricalIndex has the correct engine type.
         """
-        if nbits < 64:
-            ncategories = int(2 ** (nbits / 2) / 2 + 1)  # 129 if nbits==16 etc
-            index = CategoricalIndex(range(ncategories))
+        if dtype != np.int64:
+            n_categories = self.n_categories[dtype]
+            index = CategoricalIndex(np.arange(n_categories))
         else:
-            index = CategoricalIndex(['a', 'b', 'c'])
-            # having actual 2 ** (64 / 2) / 2 + 1 categories is too
+            # having actual (2 ** 32) + 1 distinct categories is too
             # memory-intensive, so we set codes.dtype manually
+            index = CategoricalIndex(['a', 'b', 'c'])
             index._values._codes = index._values._codes.astype('int64')
 
-        dtype = {8: np.int8, 16: np.int16,
-                 32: np.int32, 64: np.int64}[nbits]
-        engine = {8: libindex.Int8Engine, 16: libindex.Int16Engine,
-                  32: libindex.Int32Engine, 64: libindex.Int64Engine}[nbits]
+        engine = self.engines[dtype]
 
         assert isinstance(index._engine, engine)
-        assert issubclass(index.codes.dtype.type, dtype)
+        assert index.codes.dtype.type == dtype

pandas/tests/indexes/test_engine.py

@@ -10,9 +10,11 @@
 
 class TestNumericEngine(object):
 
-    @pytest.mark.parametrize('data', [[0, 1, 2]])
-    def test_engine_type(self, data, num_engine):
-        index = pd.Index(data, dtype=num_engine._dtype)
+    def setup_class(cls):
+        cls.data = [1, 2, 3]
+
+    def test_engine_type(self, numeric_indexing_engine):
+        index = pd.Index(self.data, dtype=numeric_indexing_engine._dtype)
         if issubclass(index.dtype.type, np.signedinteger):
             assert isinstance(index._engine, Int64Engine)
         elif issubclass(index.dtype.type, np.unsignedinteger):
@@ -22,34 +24,37 @@ def test_engine_type(self, data, num_engine):
         else:
             raise TypeError("unexpected dtype {}".format(index.dtype))
 
-    @pytest.mark.parametrize('data', [[0, 1, 2]])
-    def test_is_monotonic_ordered(self, data, num_engine):
-        codes = np.array(data, dtype=num_engine._dtype)
-        e = num_engine(lambda: codes, len(codes))
+    def test_is_monotonic_ordered(self, numeric_indexing_engine):
+        codes = np.array(self.data, dtype=numeric_indexing_engine._dtype)
+        e = numeric_indexing_engine(lambda: codes, len(codes))
+
         assert e.is_monotonic_increasing
         assert not e.is_monotonic_decreasing
 
         # reverse sort order
-        codes = np.array(list(reversed(data)), dtype=num_engine._dtype)
-        e = num_engine(lambda: codes, len(codes))
+        reversed_data = list(reversed(self.data))
+        codes = np.array(reversed_data, dtype=numeric_indexing_engine._dtype)
+        e = numeric_indexing_engine(lambda: codes, len(codes))
+
         assert not e.is_monotonic_increasing
         assert e.is_monotonic_decreasing
 
-    @pytest.mark.parametrize('data', [[1, 0, 2]])
-    def test_is_not_monotonic_ordered(self, data, num_engine):
-        codes = np.array(data, dtype=num_engine._dtype)
-        e = num_engine(lambda: codes, len(codes))
+    def test_is_not_monotonic_ordered(self, numeric_indexing_engine):
+        data = [1, 0, 2]
+        codes = np.array(data, dtype=numeric_indexing_engine._dtype)
+        e = numeric_indexing_engine(lambda: codes, len(codes))
+
         assert not e.is_monotonic_increasing
         assert not e.is_monotonic_decreasing
 
     @pytest.mark.parametrize('values, expected', [
         ([1, 2, 3], True),
         ([1, 1, 2], False),
     ])
-    def test_is_unique(self, values, expected, num_engine):
+    def test_is_unique(self, values, expected, numeric_indexing_engine):
+        codes = np.array(values, dtype=numeric_indexing_engine._dtype)
+        e = numeric_indexing_engine(lambda: codes, len(codes))
 
-        codes = np.array(values, dtype=num_engine._dtype)
-        e = num_engine(lambda: codes, len(codes))
         assert e.is_unique is expected
 
     @pytest.mark.parametrize('values, value, expected', [
@@ -59,9 +64,9 @@ def test_is_unique(self, values, expected, num_engine):
         ([1, 2, 2, 1], 2, np.array([False, True, True, False])),
         ([1, 3, 2], 2, 2),
     ])
-    def test_get_loc(self, values, value, expected, num_engine):
-        codes = np.array(values, dtype=num_engine._dtype)
-        e = num_engine(lambda: codes, len(codes))
+    def test_get_loc(self, values, value, expected, numeric_indexing_engine):
+        codes = np.array(values, dtype=numeric_indexing_engine._dtype)
+        e = numeric_indexing_engine(lambda: codes, len(codes))
         result = e.get_loc(value)
 
         if isinstance(expected, np.ndarray):
@@ -73,51 +78,55 @@ def test_get_loc(self, values, value, expected, num_engine):
         ([1, 2, 3], 4, KeyError),
         ([1, 2, 3], '4', KeyError),
     ])
-    def test_get_loc_raises(self, values, value, error, num_engine):
-        codes = np.array(values, dtype=num_engine._dtype)
-        e = num_engine(lambda: codes, len(codes))
+    def test_get_loc_raises(self, values, value, error,
+                            numeric_indexing_engine):
+        codes = np.array(values, dtype=numeric_indexing_engine._dtype)
+        e = numeric_indexing_engine(lambda: codes, len(codes))
         with pytest.raises(error):
             e.get_loc(value)
 
 
 class TestObjectEngine(object):
 
     def setup_class(cls):
+        cls.data = list('abc')
         cls.dtype = object
         cls.Engine = ObjectEngine
 
-    @pytest.mark.parametrize('data', [['a', 'b', 'c']])
-    def test_engine_type(self, data):
-        index = pd.Index(data)
+    def test_engine_type(self):
+        index = pd.Index(self.data)
         assert isinstance(index._engine, self.Engine)
 
-    @pytest.mark.parametrize('data', [['a', 'b', 'c']])
-    def test_is_monotonic_ordered(self, data):
-        codes = np.array(data, dtype=self.dtype)
+    def test_is_monotonic_ordered(self):
+        codes = np.array(self.data, dtype=self.dtype)
         e = self.Engine(lambda: codes, len(codes))
+
         assert e.is_monotonic_increasing
         assert not e.is_monotonic_decreasing
 
         # reverse sort order
-        codes = np.array(list(reversed(data)), dtype=self.dtype)
+        reversed_data = list(reversed(self.data))
+        codes = np.array(reversed_data, dtype=self.dtype)
         e = self.Engine(lambda: codes, len(codes))
+
         assert not e.is_monotonic_increasing
         assert e.is_monotonic_decreasing
 
-    @pytest.mark.parametrize('data', [['a', 'c', 'b']])
-    def test_is_not_monotonic_ordered(self, data):
-        codes = np.array(data, dtype=self.dtype)
+    def test_is_not_monotonic_ordered(self):
+        codes = np.array(list('cab'), dtype=self.dtype)
         e = self.Engine(lambda: codes, len(codes))
+
         assert not e.is_monotonic_increasing
         assert not e.is_monotonic_decreasing
 
     @pytest.mark.parametrize('values, expected', [
-        (['a', 'b', 'c'], True),
-        (['a', 'a', 'b'], False),
+        (list('abc'), True),
+        (list('aab'), False),
     ])
     def test_is_unique(self, values, expected):
         codes = np.array(values, dtype=self.dtype)
         e = self.Engine(lambda: codes, len(codes))
+
         assert e.is_unique is expected
 
     @pytest.mark.parametrize('values, value, expected', [