def test_5d_construction(self):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name="Panel4D",
axis_orders=["labels1", "items", "major_axis", "minor_axis"],
axis_slices={"items": "items", "major_axis": "major_axis", "minor_axis": "minor_axis"},
slicer=Panel,
axis_aliases={"major": "major_axis", "minor": "minor_axis"},
stat_axis=2,
)
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel()))
# create a 5D
Panel5D = panelnd.create_nd_panel_factory(
klass_name="Panel5D",
axis_orders=["cool1", "labels1", "items", "major_axis", "minor_axis"],
axis_slices={
"labels1": "labels1",
"items": "items",
"major_axis": "major_axis",
"minor_axis": "minor_axis",
},
slicer=Panel4D,
axis_aliases={"major": "major_axis", "minor": "minor_axis"},
stat_axis=2,
)
p5d = Panel5D(dict(C1=p4d))
# slice back to 4d
results = p5d.ix["C1", :, :, 0:3, :]
expected = p4d.ix[:, :, 0:3, :]
assert_panel_equal(results["L1"], expected["L1"])
def test_5d_construction(self):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels1', 'items', 'major_axis', 'minor_axis'],
slices={'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel()))
# create a 5D
Panel5D = panelnd.create_nd_panel_factory(
klass_name='Panel5D',
orders=['cool1', 'labels1', 'items', 'major_axis',
'minor_axis'],
slices={'labels1': 'labels1', 'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel4D,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
p5d = Panel5D(dict(C1=p4d))
# slice back to 4d
results = p5d.ix['C1', :, :, 0:3, :]
expected = p4d.ix[:, :, 0:3, :]
assert_panel_equal(results['L1'], expected['L1'])
def test_5d_construction(self):
with catch_warnings(record=True):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels1', 'items', 'major_axis', 'minor_axis'],
slices={
'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'
},
slicer=Panel,
aliases={
'major': 'major_axis',
'minor': 'minor_axis'
},
stat_axis=2)
# deprecation GH13564
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel()))
# create a 5D
Panel5D = panelnd.create_nd_panel_factory(klass_name='Panel5D',
orders=[
'cool1', 'labels1',
'items',
'major_axis',
'minor_axis'
],
slices={
'labels1':
'labels1',
'items':
'items',
'major_axis':
'major_axis',
'minor_axis':
'minor_axis'
},
slicer=Panel4D,
aliases={
'major':
'major_axis',
'minor': 'minor_axis'
},
stat_axis=2)
# deprecation GH13564
p5d = Panel5D(dict(C1=p4d))
# slice back to 4d
results = p5d.iloc[p5d.cool1.get_loc('C1'), :, :, 0:3, :]
expected = p4d.iloc[:, :, 0:3, :]
assert_panel_equal(results['L1'], expected['L1'])
def test_5d_construction(self):
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels1', 'items', 'major_axis', 'minor_axis'],
slices={
'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'
},
slicer=Panel,
aliases={
'major': 'major_axis',
'minor': 'minor_axis'
},
stat_axis=2)
# deprecation GH13564
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel()))
# create a 5D
Panel5D = panelnd.create_nd_panel_factory(klass_name='Panel5D',
orders=[
'cool1', 'labels1',
'items',
'major_axis',
'minor_axis'
],
slices={
'labels1':
'labels1',
'items':
'items',
'major_axis':
'major_axis',
'minor_axis':
'minor_axis'
},
slicer=Panel4D,
aliases={
'major':
'major_axis',
'minor': 'minor_axis'
},
stat_axis=2)
# deprecation GH13564
p5d = Panel5D(dict(C1=p4d))
# slice back to 4d
results = p5d.ix['C1', :, :, 0:3, :]
expected = p4d.ix[:, :, 0:3, :]
assert_panel_equal(results['L1'], expected['L1'])
def create_5D_panel_from_dic(dic):
Panel5D = panelnd.create_nd_panel_factory(
klass_name = 'Panel5D',
orders = [ 'graphs', 'samplers','experiments','queries','features'],
slices = { 'samplers' : 'labels', 'experiments' : 'items', 'queries' : 'major_axis', 'features' : 'minor_axis' },
slicer = Panel4D,
aliases = { 'major' : 'major_axis', 'minor' : 'minor_axis' },
stat_axis = 2)
return Panel5D.from_dict(dic)
def create_graph_panel_from_dic(graph_dic):
GraphPanel= panelnd.create_nd_panel_factory(
klass_name = 'GraphPanel',
orders = ['samplers','experiments','queries','features'],
slices = { 'experiments' : 'items', 'queries' : 'major_axis', 'features' : 'minor_axis' },
slicer = pnd.Panel,
aliases = { 'major' : 'major_axis', 'minor' : 'minor_axis' },
stat_axis = 2)
return GraphPanel.from_dict(graph_dic)
def test_4d_construction(self):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name = 'Panel4D',
axis_orders = ['labels','items','major_axis','minor_axis'],
axis_slices = { 'items' : 'items', 'major_axis' : 'major_axis', 'minor_axis' : 'minor_axis' },
slicer = Panel,
axis_aliases = { 'major' : 'major_axis', 'minor' : 'minor_axis' },
stat_axis = 2)
p4d = Panel4D(dict(L1 = tm.makePanel(), L2 = tm.makePanel()))
def test_4d_construction_alt(self):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name="Panel4D",
axis_orders=["labels", "items", "major_axis", "minor_axis"],
axis_slices={"items": "items", "major_axis": "major_axis", "minor_axis": "minor_axis"},
slicer="Panel",
axis_aliases={"major": "major_axis", "minor": "minor_axis"},
stat_axis=2,
)
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel()))
def test_5d_construction(self):
with catch_warnings(record=True):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels1', 'items', 'major_axis', 'minor_axis'],
slices={'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
# deprecation GH13564
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel()))
# create a 5D
Panel5D = panelnd.create_nd_panel_factory(
klass_name='Panel5D',
orders=['cool1', 'labels1', 'items', 'major_axis',
'minor_axis'],
slices={'labels1': 'labels1', 'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel4D,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
# deprecation GH13564
p5d = Panel5D(dict(C1=p4d))
# slice back to 4d
results = p5d.iloc[p5d.cool1.get_loc('C1'), :, :, 0:3, :]
expected = p4d.iloc[:, :, 0:3, :]
assert_panel_equal(results['L1'], expected['L1'])
def test_4d_construction_alt(self):
with catch_warnings(record=True):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels', 'items', 'major_axis', 'minor_axis'],
slices={'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer='Panel',
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel())) # noqa
def test_5d_construction(self):
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels1', 'items', 'major_axis', 'minor_axis'],
slices={'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
# deprecation GH13564
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel()))
# create a 5D
Panel5D = panelnd.create_nd_panel_factory(
klass_name='Panel5D',
orders=['cool1', 'labels1', 'items', 'major_axis',
'minor_axis'],
slices={'labels1': 'labels1', 'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel4D,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
# deprecation GH13564
p5d = Panel5D(dict(C1=p4d))
# slice back to 4d
results = p5d.ix['C1', :, :, 0:3, :]
expected = p4d.ix[:, :, 0:3, :]
assert_panel_equal(results['L1'], expected['L1'])
def test_4d_construction_alt(self):
with catch_warnings(record=True):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels', 'items', 'major_axis', 'minor_axis'],
slices={'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer='Panel',
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel())) # noqa
def test_4d_construction_alt(self):
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels', 'items', 'major_axis', 'minor_axis'],
slices={'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer='Panel',
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2)
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel())) # noqa
def create_graph_panel_from_dic(graph_dic):
GraphPanel = panelnd.create_nd_panel_factory(
klass_name='GraphPanel',
orders=['samplers', 'experiments', 'queries', 'features'],
slices={
'experiments': 'items',
'queries': 'major_axis',
'features': 'minor_axis'
},
slicer=pnd.Panel,
aliases={
'major': 'major_axis',
'minor': 'minor_axis'
},
stat_axis=2)
return GraphPanel.from_dict(graph_dic)
def create_5D_panel_from_dic(dic):
Panel5D = panelnd.create_nd_panel_factory(
klass_name='Panel5D',
orders=['graphs', 'samplers', 'experiments', 'queries', 'features'],
slices={
'samplers': 'labels',
'experiments': 'items',
'queries': 'major_axis',
'features': 'minor_axis'
},
slicer=Panel4D,
aliases={
'major': 'major_axis',
'minor': 'minor_axis'
},
stat_axis=2)
return Panel5D.from_dict(dic)
def test_4d_construction_alt(self):
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
# create a 4D
Panel4D = panelnd.create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels', 'items', 'major_axis', 'minor_axis'],
slices={
'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'
},
slicer='Panel',
aliases={
'major': 'major_axis',
'minor': 'minor_axis'
},
stat_axis=2)
p4d = Panel4D(dict(L1=tm.makePanel(), L2=tm.makePanel())) # noqa
Panel4D = create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels', 'items', 'major_axis', 'minor_axis'],
slices={
'labels': 'labels',
'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'
},
slicer=Panel,
aliases={
'major': 'major_axis',
'minor': 'minor_axis'
},
stat_axis=2,
ns=dict(__doc__="""
Panel4D is a 4-Dimensional named container very much like a Panel, but
having 4 named dimensions. It is intended as a test bed for more
N-Dimensional named containers.
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
"""))
from pandas.core.panelnd import create_nd_panel_factory
from pandas.core.panel import Panel
Panel4D = create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels', 'items', 'major_axis', 'minor_axis'],
slices={'labels': 'labels', 'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2,
ns=dict(__doc__="""
Represents a 4 dimensional 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
""")
)
def panel4d_init(self, data=None, labels=None, items=None, major_axis=None,
""" Panel4D: a 4-d dict like collection of panels """
from pandas.core.panelnd import create_nd_panel_factory
from pandas.core.panel import Panel
Panel4D = 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
Panel4D = create_nd_panel_factory(klass_name='Panel4D',
orders=['labels', 'items', 'major_axis',
'minor_axis'],
slices={'labels': 'labels',
'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel,
aliases={'major': 'major_axis',
'minor': 'minor_axis'}, stat_axis=2,
ns=dict(__doc__="""
Panel4D is a 4-Dimensional named container very much like a Panel, but
having 4 named dimensions. It is intended as a test bed for more
N-Dimensional named containers.
.. deprecated:: 0.19.0
The recommended way to represent these types of n-dimensional data
are with the `xarray package <http://xarray.pydata.org/en/stable/>`__.
Pandas provides a `.to_xarray()` method to automate this conversion.
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
"""))
""" Panel4D: a 4-d dict like collection of panels """
from pandas.core.panelnd import create_nd_panel_factory
from pandas.core.panel import Panel
Panel4D = 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
from pandas.core.panel import Panel
Panel4D = create_nd_panel_factory(
klass_name='Panel4D',
orders=['labels', 'items', 'major_axis', 'minor_axis'],
slices={'labels': 'labels', 'items': 'items', 'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer=Panel,
aliases={'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis=2,
ns=dict(__doc__="""
Panel4D is a 4-Dimensional named container very much like a Panel, but
having 4 named dimensions. It is intended as a test bed for more
N-Dimensional named containers.
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
""")
)
Panel4D = 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,
ns=dict(__doc__= """
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
"""
)
)
from pandas.core import panelnd
from pandas.core.generic import NDFrame
import numpy as np
from pandas import DataFrame
""" Panel4D: a 4-d dict like collection of panels """
from pandas.core.panelnd import create_nd_panel_factory
from pandas.core.panel import Panel
PanelNew = create_nd_panel_factory(
klass_name = 'PanelNew',
orders = ['items', 'major_axis', 'minor_axis'],
slices = {'labels': 'labels', 'items': 'items',
'major_axis': 'major_axis',
'minor_axis': 'minor_axis'},
slicer = TimeSpectra,
aliases = {'major': 'major_axis', 'minor': 'minor_axis'},
stat_axis = 2)
PanelNew._setup_axes(axes = ['items', 'major_axis', 'minor_axis'],
info_axis = 0,
stat_axis = 1,
aliases = { 'major': 'major_axis',
'minor': 'minor_axis' },
slicers = { 'major_axis': 'index',
'minor_axis': 'columns' })
#def panel4d_init(self, data=None, labels=None, items=None, major_axis=None,
