ENH: fix Series slicing on MultiIndex logic, get unit test suite to not error without LongPanel, still 6 test failures

Author: wesm

pandas/core/indexing.py

@@ -292,6 +292,10 @@ class _SeriesIndexer(_NDFrameIndexer):
 
     def __getitem__(self, key):
         ax = self.obj.index
+
+        if isinstance(key, slice):
+            key = self._convert_slice(key)
+
         if isinstance(ax, MultiIndex):
             try:
                 # key = ax.get_loc(key)
@@ -302,7 +306,7 @@ def __getitem__(self, key):
         if _isboolarr(key):
             self._check_boolean_key(key)
         elif isinstance(key, slice):
-            key = self._convert_slice(key)
+            pass
         elif _is_list_like(key):
             return self._get_list_like(key)
         return self._get_default(key)

pandas/core/panel.py

@@ -1160,18 +1160,6 @@ def _get_join_index(self, other, how):
 WidePanel = Panel
 LongPanel = DataFrame
 
-def long_swapaxes(frame):
-    """
-    Swap major and minor axes and reorder values to be grouped by
-    minor axis values
-
-    Returns
-    -------
-    DataFrame (new object)
-    """
-    return frame.swaplevel(0, 1, axis=0)
-
-
 def long_truncate(lp, before=None, after=None):
     """
     Slice panel between two major axis values, return complete DataFrame

pandas/stats/plm.py

@@ -10,7 +10,7 @@
 
 import numpy as np
 
-from pandas.core.panel import Panel, LongPanel
+from pandas.core.panel import Panel
 from pandas.core.frame import DataFrame
 from pandas.core.series import Series
 from pandas.core.sparse import SparsePanel
@@ -57,7 +57,7 @@ def log(self, msg):
             print msg
 
     def _prepare_data(self):
-        """Cleans and converts input data into LongPanel classes.
+        """Cleans and stacks input data into DataFrame objects
 
         If time effects is True, then we turn off intercepts and omit an item
         from every (entity and x) fixed effect.
@@ -77,8 +77,8 @@ def _prepare_data(self):
         x_filtered = self._add_dummies(x_filtered, cat_mapping)
 
         if self._x_effects:
-            x = x.filter(x.items - self._x_effects)
-            x_filtered = x_filtered.filter(x_filtered.items - self._x_effects)
+            x = x.drop(self._x_effects, axis=1)
+            x_filtered = x_filtered.drop(self._x_effects, axis=1)
 
         if self._time_effects:
             x_regressor = x.sub(x.mean(level=1), level=1)
@@ -115,7 +115,7 @@ def _filter_data(self):
         data = self._x_orig
         cat_mapping = {}
 
-        if isinstance(data, LongPanel):
+        if isinstance(data, DataFrame):
             data = data.to_panel()
         else:
             if isinstance(data, Panel):
@@ -208,26 +208,28 @@ def _add_entity_effects(self, panel):
         -------
         LongPanel
         """
+        from pandas.core.panel import make_axis_dummies
+
         if not self._entity_effects:
             return panel
 
         self.log('-- Adding entity fixed effect dummies')
 
-        dummies = panel.get_axis_dummies(axis='minor')
+        dummies = make_axis_dummies(panel, 'minor')
 
         if not self._use_all_dummies:
             if 'entity' in self._dropped_dummies:
                 to_exclude = str(self._dropped_dummies.get('entity'))
             else:
-                to_exclude = dummies.items[0]
+                to_exclude = dummies.columns[0]
 
-            if to_exclude not in dummies.items:
+            if to_exclude not in dummies.columns:
                 raise Exception('%s not in %s' % (to_exclude,
-                                                  dummies.items))
+                                                  dummies.columns))
 
             self.log('-- Excluding dummy for entity: %s' % to_exclude)
 
-            dummies = dummies.filter(dummies.items - [to_exclude])
+            dummies = dummies.filter(dummies.columns - [to_exclude])
 
         dummies = dummies.add_prefix('FE_')
         panel = panel.join(dummies)
@@ -242,6 +244,8 @@ def _add_categorical_dummies(self, panel, cat_mappings):
         -------
         LongPanel
         """
+        from pandas.core.panel import make_dummies
+
         if not self._x_effects:
             return panel
 
@@ -250,7 +254,7 @@ def _add_categorical_dummies(self, panel, cat_mappings):
         for effect in self._x_effects:
             self.log('-- Adding fixed effect dummies for %s' % effect)
 
-            dummies = panel.get_dummies(effect)
+            dummies = make_dummies(panel, effect)
 
             val_map = cat_mappings.get(effect)
             if val_map:
@@ -263,15 +267,15 @@ def _add_categorical_dummies(self, panel, cat_mappings):
                     if val_map:
                         mapped_name = val_map[to_exclude]
                 else:
-                    to_exclude = mapped_name = dummies.items[0]
+                    to_exclude = mapped_name = dummies.columns[0]
 
-                if mapped_name not in dummies.items: # pragma: no cover
+                if mapped_name not in dummies.columns: # pragma: no cover
                     raise Exception('%s not in %s' % (to_exclude,
-                                                      dummies.items))
+                                                      dummies.columns))
 
                 self.log('-- Excluding dummy for %s: %s' % (effect, to_exclude))
 
-                dummies = dummies.filter(dummies.items - [mapped_name])
+                dummies = dummies.filter(dummies.columns - [mapped_name])
                 dropped_dummy = True
 
             dummies = _convertDummies(dummies, cat_mappings.get(effect))
@@ -301,7 +305,7 @@ def _beta_raw(self):
 
     @cache_readonly
     def beta(self):
-        return Series(self._beta_raw, index=self._x.items)
+        return Series(self._beta_raw, index=self._x.columns)
 
     @cache_readonly
     def _df_model_raw(self):
@@ -402,9 +406,7 @@ def y_fitted(self):
     def _unstack_vector(self, vec, index=None):
         if index is None:
             index = self._y_trans.index
-        panel = LongPanel(vec.reshape((len(vec), 1)), index=index,
-                          columns=['dummy'])
-
+        panel = DataFrame(vec, index=index, columns=['dummy'])
         return panel.to_panel()['dummy']
 
     def _unstack_y(self, vec):
@@ -426,7 +428,7 @@ def _nobs(self):
 def _convertDummies(dummies, mapping):
     # cleans up the names of the generated dummies
     new_items = []
-    for item in dummies.items:
+    for item in dummies.columns:
         if not mapping:
             var = str(item)
             if isinstance(item, float):
@@ -437,7 +439,7 @@ def _convertDummies(dummies, mapping):
             # renames the dummies if a conversion dict is provided
             new_items.append(mapping[int(item)])
 
-    dummies = LongPanel(dummies.values, index=dummies.index,
+    dummies = DataFrame(dummies.values, index=dummies.index,
                         columns=new_items)
 
     return dummies
@@ -757,8 +759,8 @@ def _var_beta_panel(y, x, beta, xx, rmse, cluster_axis,
                           columns=['resid'])
 
         if cluster_axis == 1:
-            x = x.swapaxes()
-            resid = resid.swapaxes()
+            x = x.swaplevel(0, 1).sortlevel(0)
+            resid = resid.swaplevel(0, 1).sortlevel(0)
 
         m = group_agg(x.values * resid.values, x.index._bounds,
                       lambda x: np.sum(x, axis=0))

pandas/stats/tests/test_ols.py

@@ -392,18 +392,18 @@ def testFiltering(self):
         result = ols(y=self.panel_y2, x=self.panel_x2)
 
         x = result._x
-        index = [x.major_axis[i] for i in x.major_labels]
+        index = x.index.get_level_values(0)
         index = Index(sorted(set(index)))
         exp_index = Index([datetime(2000, 1, 1), datetime(2000, 1, 3)])
-        self.assertTrue(exp_index.equals(index))
+        self.assertTrue;(exp_index.equals(index))
 
-        index = [x.minor_axis[i] for i in x.minor_labels]
+        index = x.index.get_level_values(1)
         index = Index(sorted(set(index)))
         exp_index = Index(['A', 'B'])
         self.assertTrue(exp_index.equals(index))
 
         x = result._x_filtered
-        index = [x.major_axis[i] for i in x.major_labels]
+        index = x.index.get_level_values(0)
         index = Index(sorted(set(index)))
         exp_index = Index([datetime(2000, 1, 1),
                            datetime(2000, 1, 3),
@@ -424,7 +424,7 @@ def testFiltering(self):
                           [12, 21, 1]]
         assert_almost_equal(exp_x_filtered, result._x_filtered.values)
 
-        self.assertTrue(result._x_filtered.major_axis.equals(
+        self.assertTrue(result._x_filtered.index.levels[0].equals(
             result.y_fitted.index))
 
     def test_wls_panel(self):
@@ -500,7 +500,7 @@ def testWithXEffects(self):
         assert_almost_equal(result._x.values, exp_x)
 
         exp_index = Index(['x1_30', 'x1_9', 'x2', 'intercept'])
-        self.assertTrue(exp_index.equals(result._x.items))
+        self.assertTrue(exp_index.equals(result._x.columns))
 
         # _check_non_raw_results(result)
 
@@ -513,7 +513,7 @@ def testWithXEffectsAndDroppedDummies(self):
         assert_almost_equal(result._x.values, exp_x)
 
         exp_index = Index(['x1_6', 'x1_9', 'x2', 'intercept'])
-        self.assertTrue(exp_index.equals(result._x.items))
+        self.assertTrue(exp_index.equals(result._x.columns))
 
         # _check_non_raw_results(result)
 
@@ -526,7 +526,7 @@ def testWithXEffectsAndConversion(self):
         assert_almost_equal(result._x.values, exp_x)
 
         exp_index = Index(['x1_B', 'x1_C', 'x2_baz', 'x2_foo', 'intercept'])
-        self.assertTrue(exp_index.equals(result._x.items))
+        self.assertTrue(exp_index.equals(result._x.columns))
 
         # _check_non_raw_results(result)
 
@@ -540,7 +540,7 @@ def testWithXEffectsAndConversionAndDroppedDummies(self):
         assert_almost_equal(result._x.values, exp_x)
 
         exp_index = Index(['x1_B', 'x1_C', 'x2_bar', 'x2_baz', 'intercept'])
-        self.assertTrue(exp_index.equals(result._x.items))
+        self.assertTrue(exp_index.equals(result._x.columns))
 
         # _check_non_raw_results(result)
 

pandas/tests/test_multilevel.py

@@ -218,6 +218,23 @@ def test_getitem_toplevel(self):
         assert_frame_equal(result, expected)
         assert_frame_equal(result, result2)
 
+    def test_getitem_slice_integers(self):
+        index = MultiIndex(levels=[[0, 1, 2], [0, 2]],
+                           labels=[[0, 0, 1, 1, 2, 2],
+                                   [0, 1, 0, 1, 0, 1]])
+
+        frame =  DataFrame(np.random.randn(len(index), 4), index=index,
+                           columns=['a', 'b', 'c', 'd'])
+        res = frame.ix[1:2]
+        exp = frame[2:]
+        assert_frame_equal(res, exp)
+
+        series =  Series(np.random.randn(len(index)), index=index)
+
+        res = series.ix[1:2]
+        exp = series[2:]
+        assert_series_equal(res, exp)
+
     def test_getitem_int(self):
         levels = [[0, 1], [0, 1, 2]]
         labels = [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]