minor refactor of panel4d to use factory methods from panelnd

bug in _get_plane_axes definition in panelnd
updated to docs of panel4d to list currenctly disabled methods

Author: jreback

doc/source/dsintro.rst

@@ -814,7 +814,9 @@ containers.
 
 
 ``Panel4D`` is a sub-class of ``Panel``, so most methods that work on Panels are
-applicable to Panel4D.
+applicable to Panel4D. The following methods are disabled:
+
+  - ``join , to_frame , to_excel , to_sparse , groupby``
 
 Construction of Panel4D works in a very similar manner to a ``Panel``
 
@@ -897,7 +899,8 @@ Here we slice to a Panel4D.
     Panel5D = panelnd.create_nd_panel_factory(
         klass_name   = 'Panel5D', 
         axis_orders  = [ 'cool', 'labels','items','major_axis','minor_axis'], 
-        axis_slices  = { 'labels' : 'labels', 'items' : 'items', 'major_axis' : 'major_axis', 'minor_axis' : 'minor_axis' },
+        axis_slices  = { 'labels' : 'labels', 'items' : 'items', 
+	                 'major_axis' : 'major_axis', 'minor_axis' : 'minor_axis' },
         slicer       = Panel4D,
         axis_aliases = { 'major' : 'major_axis', 'minor' : 'minor_axis' },
         stat_axis    = 2)
@@ -911,6 +914,6 @@ Here we slice to a Panel4D.
     # transpose it
     p5d.transpose(1,2,3,4,0)
 
-    # look at the values & dim
-    p5d.values.shape
-    p5d.values.ndim
+    # look at the shape & dim
+    p5d.shape
+    p5d.ndim

doc/source/v0.10.0.txt

@@ -110,8 +110,8 @@ Updated PyTables Support
        import os
        os.remove('store.h5')
 
-NDim Panels (Experimental)
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+N Dimensional Panels (Experimental)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Adding experimental support for Panel4D and factory functions to create n-dimensional named panels.
 :ref:`Docs <dsintro-panel4d>` for NDim. Here is a taste of what to expect.

pandas/core/panel.py

@@ -495,9 +495,9 @@ def ix(self):
         return self._ix
 
     def _wrap_array(self, arr, axes, copy=False):
-        items, major, minor = axes
-        return self._constructor(arr, items=items, major_axis=major,
-                                 minor_axis=minor, copy=copy)
+        d    = dict([ (a,ax) for a,ax in zip(self._AXIS_ORDERS,axes) ])
+        d['copy'] = False
+        return self._constructor(arr, **d)
 
     fromDict = from_dict
 
@@ -1433,8 +1433,8 @@ def update(self, other, join='left', overwrite=True, filter_func=None,
             contain data in the same place.
         """
 
-        if not isinstance(other, Panel):
-            other = Panel(other)
+        if not isinstance(other, self._constructor):
+            other = self._constructor(other)
 
         other = other.reindex(items=self.items)
 

pandas/core/panel4d.py

@@ -1,112 +1,39 @@
 """ Panel4D: a 4-d dict like collection of panels """
 
 from pandas.core.panel import Panel
+from pandas.core import panelnd
 import pandas.lib as lib
 
+Panel4D = panelnd.create_nd_panel_factory(
+    klass_name   = 'Panel4D', 
+    axis_orders  = [ 'labels','items','major_axis','minor_axis'], 
+    axis_slices  = { 'labels' : 'labels', 'items' : 'items', 'major_axis' : 'major_axis', 'minor_axis' : 'minor_axis' },
+    slicer       = Panel,
+    axis_aliases = { 'major' : 'major_axis', 'minor' : 'minor_axis' },
+    stat_axis    = 2)
+
+
+
+def panel4d_init(self, data=None, labels=None, items=None, major_axis=None, minor_axis=None, copy=False, dtype=None):
+    """
+    Represents a 4 dimensonal structured
+    
+    Parameters
+    ----------
+    data : ndarray (labels x items x major x minor), or dict of Panels
+    
+    labels : Index or array-like : axis=0
+    items  : Index or array-like : axis=1
+    major_axis : Index or array-like: axis=2
+    minor_axis : Index or array-like: axis=3
+    
+    dtype : dtype, default None
+    Data type to force, otherwise infer
+    copy : boolean, default False
+    Copy data from inputs. Only affects DataFrame / 2d ndarray input
+    """
+    self._init_data( data=data, labels=labels, items=items, major_axis=major_axis, minor_axis=minor_axis,
+                     copy=copy, dtype=dtype)
+Panel4D.__init__ = panel4d_init
 
-class Panel4D(Panel):
-    _AXIS_ORDERS  = ['labels','items','major_axis','minor_axis']
-    _AXIS_NUMBERS = dict([ (a,i) for i, a in enumerate(_AXIS_ORDERS) ])
-    _AXIS_ALIASES = {
-        'major' : 'major_axis',
-        'minor' : 'minor_axis'
-    }
-    _AXIS_NAMES   = dict([ (i,a) for i, a in enumerate(_AXIS_ORDERS) ])
-    _AXIS_SLICEMAP = {
-        'items'      : 'items',
-        'major_axis' : 'major_axis',
-        'minor_axis' : 'minor_axis'
-        }
-    _AXIS_LEN     = len(_AXIS_ORDERS)
-
-    # major
-    _default_stat_axis = 2
-
-    # info axis
-    _het_axis = 0
-    _info_axis = _AXIS_ORDERS[_het_axis]
-
-    labels     = lib.AxisProperty(0)
-    items      = lib.AxisProperty(1)
-    major_axis = lib.AxisProperty(2)
-    minor_axis = lib.AxisProperty(3)
-
-    _constructor_sliced = Panel
-
-    def __init__(self, data=None, labels=None, items=None, major_axis=None, minor_axis=None, copy=False, dtype=None):
-        """
-        Represents a 4 dimensonal structured
-
-        Parameters
-        ----------
-        data : ndarray (labels x items x major x minor), or dict of Panels
-
-        labels : Index or array-like : axis=0
-        items  : Index or array-like : axis=1
-        major_axis : Index or array-like: axis=2
-        minor_axis : Index or array-like: axis=3
-
-        dtype : dtype, default None
-            Data type to force, otherwise infer
-        copy : boolean, default False
-            Copy data from inputs. Only affects DataFrame / 2d ndarray input
-        """
-        self._init_data( data=data, labels=labels, items=items, major_axis=major_axis, minor_axis=minor_axis,
-                         copy=copy, dtype=dtype)
-
-    def _get_plane_axes(self, axis):
-        axis = self._get_axis_name(axis)
-
-        if axis == 'major_axis':
-            items = self.labels
-            major = self.items
-            minor = self.minor_axis
-        elif axis == 'minor_axis':
-            items = self.labels
-            major = self.items
-            minor = self.major_axis
-        elif axis == 'items':
-            items = self.labels
-            major = self.major_axis
-            minor = self.minor_axis
-        elif axis == 'labels':
-            items = self.items
-            major = self.major_axis
-            minor = self.minor_axis
-
-        return items, major, minor
-
-    def _combine(self, other, func, axis=0):
-        if isinstance(other, Panel4D):
-            return self._combine_panel4d(other, func)
-        return super(Panel4D, self)._combine(other, func, axis=axis)
-
-    def _combine_panel4d(self, other, func):
-        labels = self.labels + other.labels
-        items  = self.items + other.items
-        major  = self.major_axis + other.major_axis
-        minor  = self.minor_axis + other.minor_axis
-
-        # could check that everything's the same size, but forget it
-        this = self.reindex(labels=labels, items=items, major=major, minor=minor)
-        other = other.reindex(labels=labels, items=items, major=major, minor=minor)
-
-        result_values = func(this.values, other.values)
-
-        return self._constructor(result_values, labels, items, major, minor)
-
-    def join(self, other, how='left', lsuffix='', rsuffix=''):
-        if isinstance(other, Panel4D):
-            join_major, join_minor = self._get_join_index(other, how)
-            this = self.reindex(major=join_major, minor=join_minor)
-            other = other.reindex(major=join_major, minor=join_minor)
-            merged_data = this._data.merge(other._data, lsuffix, rsuffix)
-            return self._constructor(merged_data)
-        return super(Panel4D, self).join(other=other,how=how,lsuffix=lsuffix,rsuffix=rsuffix)
-
-    ### remove operations ####
-    def to_frame(self, *args, **kwargs):
-        raise NotImplementedError
-    def to_excel(self, *args, **kwargs):
-        raise NotImplementedError
 

pandas/core/panelnd.py

@@ -46,7 +46,7 @@ def create_nd_panel_factory(klass_name, axis_orders, axis_slices, slicer, axis_a
     for i, a in enumerate(axis_orders):
         setattr(klass,a,lib.AxisProperty(i))
 
-    # define the __init__
+    #### define the methods ####
     def __init__(self, *args, **kwargs):
         if not (kwargs.get('data') or len(args)):
             raise Exception("must supply at least a data argument to [%s]" % klass_name)
@@ -57,27 +57,49 @@ def __init__(self, *args, **kwargs):
         self._init_data( *args, **kwargs)
     klass.__init__ = __init__
 
-    # define _get_place_axes
     def _get_plane_axes(self, axis):
+
         axis   = self._get_axis_name(axis)
         index  = self._AXIS_ORDERS.index(axis)
 
         planes = []
         if index:
             planes.extend(self._AXIS_ORDERS[0:index])
         if index != self._AXIS_LEN:
-            planes.extend(self._AXIS_ORDERS[index:])
-
-        return planes
-    klass._get_plane_axes
-
-    # remove these operations
-    def to_frame(self, *args, **kwargs):
-        raise NotImplementedError
-    klass.to_frame = to_frame
-    def to_excel(self, *args, **kwargs):
-        raise NotImplementedError
-    klass.to_excel = to_excel
+            planes.extend(self._AXIS_ORDERS[index+1:])
+
+        return [ getattr(self,p) for p in planes ]
+    klass._get_plane_axes = _get_plane_axes
+
+    def _combine(self, other, func, axis=0):
+        if isinstance(other, klass):
+            return self._combine_with_constructor(other, func)
+        return super(klass, self)._combine(other, func, axis=axis)
+    klass._combine = _combine
+
+    def _combine_with_constructor(self, other, func):
+
+        # combine labels to form new axes
+        new_axes = []
+        for a in self._AXIS_ORDERS:
+            new_axes.append(getattr(self,a) + getattr(other,a))
+
+        # reindex: could check that everything's the same size, but forget it
+        d = dict([ (a,ax) for a,ax in zip(self._AXIS_ORDERS,new_axes) ])
+        d['copy'] = False
+        this = self.reindex(**d)
+        other = other.reindex(**d)
+    
+        result_values = func(this.values, other.values)
+
+        return self._constructor(result_values, **d)
+    klass._combine_with_constructor = _combine_with_constructor
+
+    # set as NonImplemented operations which we don't support
+    for f in ['to_frame','to_excel','to_sparse','groupby','join','_get_join_index']:
+        def func(self, *args, **kwargs):
+            raise NotImplementedError
+        setattr(klass,f,func)
 
     return klass