CLN: split test_indexing.py

split to: test_ix, test_scalar, test_loc, test_iloc, test_partial

Author: jreback

pandas/tests/indexing/common.py

@@ -1,5 +1,262 @@
 """ common utilities """
 
+import itertools
+from warnings import catch_warnings
+import numpy as np
+
+from pandas.compat import lrange
+from pandas.types.common import is_scalar
+from pandas import Series, DataFrame, Panel, date_range, UInt64Index
+from pandas.util import testing as tm
+from pandas.formats.printing import pprint_thing
+
+_verbose = False
+
 
 def _mklbl(prefix, n):
     return ["%s%s" % (prefix, i) for i in range(n)]
+
+
+def _axify(obj, key, axis):
+    # create a tuple accessor
+    axes = [slice(None)] * obj.ndim
+    axes[axis] = key
+    return tuple(axes)
+
+
+class Base(object):
+    """ indexing comprehensive base class """
+
+    _objs = set(['series', 'frame', 'panel'])
+    _typs = set(['ints', 'uints', 'labels', 'mixed',
+                 'ts', 'floats', 'empty', 'ts_rev'])
+
+    def setUp(self):
+
+        self.series_ints = Series(np.random.rand(4), index=lrange(0, 8, 2))
+        self.frame_ints = DataFrame(np.random.randn(4, 4),
+                                    index=lrange(0, 8, 2),
+                                    columns=lrange(0, 12, 3))
+        self.panel_ints = Panel(np.random.rand(4, 4, 4),
+                                items=lrange(0, 8, 2),
+                                major_axis=lrange(0, 12, 3),
+                                minor_axis=lrange(0, 16, 4))
+
+        self.series_uints = Series(np.random.rand(4),
+                                   index=UInt64Index(lrange(0, 8, 2)))
+        self.frame_uints = DataFrame(np.random.randn(4, 4),
+                                     index=UInt64Index(lrange(0, 8, 2)),
+                                     columns=UInt64Index(lrange(0, 12, 3)))
+        self.panel_uints = Panel(np.random.rand(4, 4, 4),
+                                 items=UInt64Index(lrange(0, 8, 2)),
+                                 major_axis=UInt64Index(lrange(0, 12, 3)),
+                                 minor_axis=UInt64Index(lrange(0, 16, 4)))
+
+        self.series_labels = Series(np.random.randn(4), index=list('abcd'))
+        self.frame_labels = DataFrame(np.random.randn(4, 4),
+                                      index=list('abcd'), columns=list('ABCD'))
+        self.panel_labels = Panel(np.random.randn(4, 4, 4),
+                                  items=list('abcd'),
+                                  major_axis=list('ABCD'),
+                                  minor_axis=list('ZYXW'))
+
+        self.series_mixed = Series(np.random.randn(4), index=[2, 4, 'null', 8])
+        self.frame_mixed = DataFrame(np.random.randn(4, 4),
+                                     index=[2, 4, 'null', 8])
+        self.panel_mixed = Panel(np.random.randn(4, 4, 4),
+                                 items=[2, 4, 'null', 8])
+
+        self.series_ts = Series(np.random.randn(4),
+                                index=date_range('20130101', periods=4))
+        self.frame_ts = DataFrame(np.random.randn(4, 4),
+                                  index=date_range('20130101', periods=4))
+        self.panel_ts = Panel(np.random.randn(4, 4, 4),
+                              items=date_range('20130101', periods=4))
+
+        dates_rev = (date_range('20130101', periods=4)
+                     .sort_values(ascending=False))
+        self.series_ts_rev = Series(np.random.randn(4),
+                                    index=dates_rev)
+        self.frame_ts_rev = DataFrame(np.random.randn(4, 4),
+                                      index=dates_rev)
+        self.panel_ts_rev = Panel(np.random.randn(4, 4, 4),
+                                  items=dates_rev)
+
+        self.frame_empty = DataFrame({})
+        self.series_empty = Series({})
+        self.panel_empty = Panel({})
+
+        # form agglomerates
+        for o in self._objs:
+
+            d = dict()
+            for t in self._typs:
+                d[t] = getattr(self, '%s_%s' % (o, t), None)
+
+            setattr(self, o, d)
+
+    def generate_indices(self, f, values=False):
+        """ generate the indicies
+        if values is True , use the axis values
+        is False, use the range
+        """
+
+        axes = f.axes
+        if values:
+            axes = [lrange(len(a)) for a in axes]
+
+        return itertools.product(*axes)
+
+    def get_result(self, obj, method, key, axis):
+        """ return the result for this obj with this key and this axis """
+
+        if isinstance(key, dict):
+            key = key[axis]
+
+        # use an artifical conversion to map the key as integers to the labels
+        # so ix can work for comparisions
+        if method == 'indexer':
+            method = 'ix'
+            key = obj._get_axis(axis)[key]
+
+        # in case we actually want 0 index slicing
+        try:
+            with catch_warnings(record=True):
+                xp = getattr(obj, method).__getitem__(_axify(obj, key, axis))
+        except:
+            xp = getattr(obj, method).__getitem__(key)
+
+        return xp
+
+    def get_value(self, f, i, values=False):
+        """ return the value for the location i """
+
+        # check agains values
+        if values:
+            return f.values[i]
+
+        # this is equiv of f[col][row].....
+        # v = f
+        # for a in reversed(i):
+        #    v = v.__getitem__(a)
+        # return v
+        with catch_warnings(record=True):
+            return f.ix[i]
+
+    def check_values(self, f, func, values=False):
+
+        if f is None:
+            return
+        axes = f.axes
+        indicies = itertools.product(*axes)
+
+        for i in indicies:
+            result = getattr(f, func)[i]
+
+            # check agains values
+            if values:
+                expected = f.values[i]
+            else:
+                expected = f
+                for a in reversed(i):
+                    expected = expected.__getitem__(a)
+
+            tm.assert_almost_equal(result, expected)
+
+    def check_result(self, name, method1, key1, method2, key2, typs=None,
+                     objs=None, axes=None, fails=None):
+        def _eq(t, o, a, obj, k1, k2):
+            """ compare equal for these 2 keys """
+
+            if a is not None and a > obj.ndim - 1:
+                return
+
+            def _print(result, error=None):
+                if error is not None:
+                    error = str(error)
+                v = ("%-16.16s [%-16.16s]: [typ->%-8.8s,obj->%-8.8s,"
+                     "key1->(%-4.4s),key2->(%-4.4s),axis->%s] %s" %
+                     (name, result, t, o, method1, method2, a, error or ''))
+                if _verbose:
+                    pprint_thing(v)
+
+            try:
+                rs = getattr(obj, method1).__getitem__(_axify(obj, k1, a))
+
+                try:
+                    xp = self.get_result(obj, method2, k2, a)
+                except:
+                    result = 'no comp'
+                    _print(result)
+                    return
+
+                detail = None
+
+                try:
+                    if is_scalar(rs) and is_scalar(xp):
+                        self.assertEqual(rs, xp)
+                    elif xp.ndim == 1:
+                        tm.assert_series_equal(rs, xp)
+                    elif xp.ndim == 2:
+                        tm.assert_frame_equal(rs, xp)
+                    elif xp.ndim == 3:
+                        tm.assert_panel_equal(rs, xp)
+                    result = 'ok'
+                except AssertionError as e:
+                    detail = str(e)
+                    result = 'fail'
+
+                # reverse the checks
+                if fails is True:
+                    if result == 'fail':
+                        result = 'ok (fail)'
+
+                _print(result)
+                if not result.startswith('ok'):
+                    raise AssertionError(detail)
+
+            except AssertionError:
+                raise
+            except Exception as detail:
+
+                # if we are in fails, the ok, otherwise raise it
+                if fails is not None:
+                    if isinstance(detail, fails):
+                        result = 'ok (%s)' % type(detail).__name__
+                        _print(result)
+                        return
+
+                result = type(detail).__name__
+                raise AssertionError(_print(result, error=detail))
+
+        if typs is None:
+            typs = self._typs
+
+        if objs is None:
+            objs = self._objs
+
+        if axes is not None:
+            if not isinstance(axes, (tuple, list)):
+                axes = [axes]
+            else:
+                axes = list(axes)
+        else:
+            axes = [0, 1, 2]
+
+        # check
+        for o in objs:
+            if o not in self._objs:
+                continue
+
+            d = getattr(self, o)
+            for a in axes:
+                for t in typs:
+                    if t not in self._typs:
+                        continue
+
+                    obj = d[t]
+                    if obj is not None:
+                        obj = obj.copy()
+
+                        k2 = key2
+                        _eq(t, o, a, obj, key1, k2)

pandas/tests/indexing/test_chaining_and_caching.py

@@ -1,3 +1,5 @@
+from warnings import catch_warnings
+
 import numpy as np
 import pandas as pd
 from pandas.core import common as com
@@ -357,3 +359,76 @@ def test_detect_chained_assignment_warnings(self):
             with tm.assert_produces_warning(
                     expected_warning=com.SettingWithCopyWarning):
                 df.loc[0]['A'] = 111
+
+    def test_chained_getitem_with_lists(self):
+
+        # GH6394
+        # Regression in chained getitem indexing with embedded list-like from
+        # 0.12
+        def check(result, expected):
+            tm.assert_numpy_array_equal(result, expected)
+            tm.assertIsInstance(result, np.ndarray)
+
+        df = DataFrame({'A': 5 * [np.zeros(3)], 'B': 5 * [np.ones(3)]})
+        expected = df['A'].iloc[2]
+        result = df.loc[2, 'A']
+        check(result, expected)
+        result2 = df.iloc[2]['A']
+        check(result2, expected)
+        result3 = df['A'].loc[2]
+        check(result3, expected)
+        result4 = df['A'].iloc[2]
+        check(result4, expected)
+
+    def test_cache_updating(self):
+        # GH 4939, make sure to update the cache on setitem
+
+        df = tm.makeDataFrame()
+        df['A']  # cache series
+        with catch_warnings(record=True):
+            df.ix["Hello Friend"] = df.ix[0]
+        self.assertIn("Hello Friend", df['A'].index)
+        self.assertIn("Hello Friend", df['B'].index)
+
+        with catch_warnings(record=True):
+            panel = tm.makePanel()
+            panel.ix[0]  # get first item into cache
+            panel.ix[:, :, 'A+1'] = panel.ix[:, :, 'A'] + 1
+            self.assertIn("A+1", panel.ix[0].columns)
+            self.assertIn("A+1", panel.ix[1].columns)
+
+        # 5216
+        # make sure that we don't try to set a dead cache
+        a = np.random.rand(10, 3)
+        df = DataFrame(a, columns=['x', 'y', 'z'])
+        tuples = [(i, j) for i in range(5) for j in range(2)]
+        index = MultiIndex.from_tuples(tuples)
+        df.index = index
+
+        # setting via chained assignment
+        # but actually works, since everything is a view
+        df.loc[0]['z'].iloc[0] = 1.
+        result = df.loc[(0, 0), 'z']
+        self.assertEqual(result, 1)
+
+        # correct setting
+        df.loc[(0, 0), 'z'] = 2
+        result = df.loc[(0, 0), 'z']
+        self.assertEqual(result, 2)
+
+        # 10264
+        df = DataFrame(np.zeros((5, 5), dtype='int64'), columns=[
+                       'a', 'b', 'c', 'd', 'e'], index=range(5))
+        df['f'] = 0
+        df.f.values[3] = 1
+
+        # TODO(wesm): unused?
+        # y = df.iloc[np.arange(2, len(df))]
+
+        df.f.values[3] = 2
+        expected = DataFrame(np.zeros((5, 6), dtype='int64'), columns=[
+                             'a', 'b', 'c', 'd', 'e', 'f'], index=range(5))
+        expected.at[3, 'f'] = 2
+        tm.assert_frame_equal(df, expected)
+        expected = Series([0, 0, 0, 2, 0], name='f')
+        tm.assert_series_equal(df.f, expected)