def test_constructor_resize(self): with catch_warnings(record=True): data = self.panel4d._data labels = self.panel4d.labels[:-1] items = self.panel4d.items[:-1] major = self.panel4d.major_axis[:-1] minor = self.panel4d.minor_axis[:-1] result = Panel4D(data, labels=labels, items=items, major_axis=major, minor_axis=minor) expected = self.panel4d.reindex(labels=labels, items=items, major=major, minor=minor) tm.assert_panel4d_equal(result, expected) result = Panel4D(data, items=items, major_axis=major) expected = self.panel4d.reindex(items=items, major=major) tm.assert_panel4d_equal(result, expected) result = Panel4D(data, items=items) expected = self.panel4d.reindex(items=items) tm.assert_panel4d_equal(result, expected) result = Panel4D(data, minor_axis=minor) expected = self.panel4d.reindex(minor=minor) tm.assert_panel4d_equal(result, expected)
def test_constructor_dict_mixed(self): with catch_warnings(record=True): data = dict((k, v.values) for k, v in self.panel4d.iteritems()) result = Panel4D(data) exp_major = Index(np.arange(len(self.panel4d.major_axis))) tm.assert_index_equal(result.major_axis, exp_major) result = Panel4D(data, labels=self.panel4d.labels, items=self.panel4d.items, major_axis=self.panel4d.major_axis, minor_axis=self.panel4d.minor_axis) tm.assert_panel4d_equal(result, self.panel4d) data['l2'] = self.panel4d['l2'] result = Panel4D(data) tm.assert_panel4d_equal(result, self.panel4d) # corner, blow up data['l2'] = data['l2']['ItemB'] pytest.raises(Exception, Panel4D, data) data['l2'] = self.panel4d['l2'].values[:, :, :-1] pytest.raises(Exception, Panel4D, data)
def test_constructor_dict_mixed(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): data = dict((k, v.values) for k, v in self.panel4d.iteritems()) result = Panel4D(data) exp_major = Index(np.arange(len(self.panel4d.major_axis))) self.assert_index_equal(result.major_axis, exp_major) result = Panel4D(data, labels=self.panel4d.labels, items=self.panel4d.items, major_axis=self.panel4d.major_axis, minor_axis=self.panel4d.minor_axis) assert_panel4d_equal(result, self.panel4d) data['l2'] = self.panel4d['l2'] result = Panel4D(data) assert_panel4d_equal(result, self.panel4d) # corner, blow up data['l2'] = data['l2']['ItemB'] self.assertRaises(Exception, Panel4D, data) data['l2'] = self.panel4d['l2'].values[:, :, :-1] self.assertRaises(Exception, Panel4D, data)
def test_update(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): p4d = Panel4D([[[[1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]], [[1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]]]]) other = Panel4D([[[[3.6, 2., np.nan]], [[np.nan, np.nan, 7]]]]) p4d.update(other) expected = Panel4D([[[[3.6, 2, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]], [[1.5, np.nan, 7], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]]]]) assert_panel4d_equal(p4d, expected)
def test_constructor_resize(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): data = self.panel4d._data labels = self.panel4d.labels[:-1] items = self.panel4d.items[:-1] major = self.panel4d.major_axis[:-1] minor = self.panel4d.minor_axis[:-1] result = Panel4D(data, labels=labels, items=items, major_axis=major, minor_axis=minor) expected = self.panel4d.reindex( labels=labels, items=items, major=major, minor=minor) assert_panel4d_equal(result, expected) result = Panel4D(data, items=items, major_axis=major) expected = self.panel4d.reindex(items=items, major=major) assert_panel4d_equal(result, expected) result = Panel4D(data, items=items) expected = self.panel4d.reindex(items=items) assert_panel4d_equal(result, expected) result = Panel4D(data, minor_axis=minor) expected = self.panel4d.reindex(minor=minor) assert_panel4d_equal(result, expected)
def test_update(self): with catch_warnings(record=True): p4d = Panel4D([[[[1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]], [[1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]]]]) other = Panel4D([[[[3.6, 2., np.nan]], [[np.nan, np.nan, 7]]]]) p4d.update(other) expected = Panel4D([[[[3.6, 2, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]], [[1.5, np.nan, 7], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]]]]) tm.assert_panel4d_equal(p4d, expected)
def test_update(self): p4d = Panel4D([[[[1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]], [[1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]]]]) other = Panel4D([[[[3.6, 2., np.nan]], [[np.nan, np.nan, 7]]]]) p4d.update(other) expected = Panel4D([[[[3.6, 2, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]], [[1.5, np.nan, 7], [1.5, np.nan, 3.], [1.5, np.nan, 3.], [1.5, np.nan, 3.]]]]) assert_panel4d_equal(p4d, expected)
def test_constructor_cast(self): zero_filled = self.panel4d.fillna(0) casted = Panel4D(zero_filled._data, dtype=int) casted2 = Panel4D(zero_filled.values, dtype=int) exp_values = zero_filled.values.astype(int) assert_almost_equal(casted.values, exp_values) assert_almost_equal(casted2.values, exp_values) # can't cast data = [[['foo', 'bar', 'baz']]] self.assertRaises(ValueError, Panel, data, dtype=float)
def test_ctor_dict(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): l1 = self.panel4d['l1'] l2 = self.panel4d['l2'] d = {'A': l1, 'B': l2.ix[['ItemB'], :, :]} panel4d = Panel4D(d) assert_panel_equal(panel4d['A'], self.panel4d['l1']) assert_frame_equal(panel4d.ix['B', 'ItemB', :, :], self.panel4d.ix['l2', ['ItemB'], :, :]['ItemB'])
def test_constructor_cast(self): with catch_warnings(record=True): zero_filled = self.panel4d.fillna(0) casted = Panel4D(zero_filled._data, dtype=int) casted2 = Panel4D(zero_filled.values, dtype=int) exp_values = zero_filled.values.astype(int) assert_almost_equal(casted.values, exp_values) assert_almost_equal(casted2.values, exp_values) casted = Panel4D(zero_filled._data, dtype=np.int32) casted2 = Panel4D(zero_filled.values, dtype=np.int32) exp_values = zero_filled.values.astype(np.int32) assert_almost_equal(casted.values, exp_values) assert_almost_equal(casted2.values, exp_values) # can't cast data = [[['foo', 'bar', 'baz']]] pytest.raises(ValueError, Panel, data, dtype=float)
def test_constructor_cast(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): zero_filled = self.panel4d.fillna(0) casted = Panel4D(zero_filled._data, dtype=int) casted2 = Panel4D(zero_filled.values, dtype=int) exp_values = zero_filled.values.astype(int) assert_almost_equal(casted.values, exp_values) assert_almost_equal(casted2.values, exp_values) casted = Panel4D(zero_filled._data, dtype=np.int32) casted2 = Panel4D(zero_filled.values, dtype=np.int32) exp_values = zero_filled.values.astype(np.int32) assert_almost_equal(casted.values, exp_values) assert_almost_equal(casted2.values, exp_values) # can't cast data = [[['foo', 'bar', 'baz']]] self.assertRaises(ValueError, Panel, data, dtype=float)
def test_ctor_dict(self): with catch_warnings(record=True): l1 = self.panel4d['l1'] l2 = self.panel4d['l2'] d = {'A': l1, 'B': l2.loc[['ItemB'], :, :]} panel4d = Panel4D(d) tm.assert_panel_equal(panel4d['A'], self.panel4d['l1']) tm.assert_frame_equal( panel4d.loc['B', 'ItemB', :, :], self.panel4d.loc['l2', ['ItemB'], :, :]['ItemB'])
def test_constructor(self): # with BlockManager panel4d = Panel4D(self.panel4d._data) self.assertIs(panel4d._data, self.panel4d._data) panel4d = Panel4D(self.panel4d._data, copy=True) self.assertIsNot(panel4d._data, self.panel4d._data) assert_panel4d_equal(panel4d, self.panel4d) # strings handled prop # panel4d = Panel4D([[['foo', 'foo', 'foo',], # ['foo', 'foo', 'foo']]]) # self.assertEqual(wp.values.dtype, np.object_) vals = self.panel4d.values # no copy panel4d = Panel4D(vals) self.assertIs(panel4d.values, vals) # copy panel4d = Panel4D(vals, copy=True) self.assertIsNot(panel4d.values, vals) # GH #8285, test when scalar data is used to construct a Panel4D # if dtype is not passed, it should be inferred value_and_dtype = [(1, 'int64'), (3.14, 'float64'), ('foo', np.object_)] for (val, dtype) in value_and_dtype: panel4d = Panel4D(val, labels=range(2), items=range(3), major_axis=range(4), minor_axis=range(5)) vals = np.empty((2, 3, 4, 5), dtype=dtype) vals.fill(val) assert_panel4d_equal(panel4d, Panel4D(vals, dtype=dtype)) # test the case when dtype is passed panel4d = Panel4D(1, labels=range(2), items=range(3), major_axis=range(4), minor_axis=range(5), dtype='float32') vals = np.empty((2, 3, 4, 5), dtype='float32') vals.fill(1) assert_panel4d_equal(panel4d, Panel4D(vals, dtype='float32'))
def test_constructor(self): # with BlockManager panel4d = Panel4D(self.panel4d._data) self.assert_(panel4d._data is self.panel4d._data) panel4d = Panel4D(self.panel4d._data, copy=True) self.assert_(panel4d._data is not self.panel4d._data) assert_panel4d_equal(panel4d, self.panel4d) # strings handled prop #panel4d = Panel4D([[['foo', 'foo', 'foo',], # ['foo', 'foo', 'foo']]]) #self.assert_(wp.values.dtype == np.object_) vals = self.panel4d.values # no copy panel4d = Panel4D(vals) self.assert_(panel4d.values is vals) # copy panel4d = Panel4D(vals, copy=True) self.assert_(panel4d.values is not vals)
def test_constructor_dict_mixed(self): data = dict((k, v.values) for k, v in self.panel4d.iterkv()) result = Panel4D(data) exp_major = Index(np.arange(len(self.panel4d.major_axis))) self.assert_(result.major_axis.equals(exp_major)) result = Panel4D(data, labels = self.panel4d.labels, items = self.panel4d.items, major_axis = self.panel4d.major_axis, minor_axis = self.panel4d.minor_axis) assert_panel4d_equal(result, self.panel4d) data['l2'] = self.panel4d['l2'] result = Panel4D(data) assert_panel4d_equal(result, self.panel4d) # corner, blow up data['l2'] = data['l2']['ItemB'] self.assertRaises(Exception, Panel4D, data) data['l2'] = self.panel4d['l2'].values[:, :, :-1] self.assertRaises(Exception, Panel4D, data)
def test_constructor(self): with catch_warnings(record=True): panel4d = Panel4D(self.panel4d._data) assert panel4d._data is self.panel4d._data panel4d = Panel4D(self.panel4d._data, copy=True) assert panel4d._data is not self.panel4d._data tm.assert_panel4d_equal(panel4d, self.panel4d) vals = self.panel4d.values # no copy panel4d = Panel4D(vals) assert panel4d.values is vals # copy panel4d = Panel4D(vals, copy=True) assert panel4d.values is not vals # GH #8285, test when scalar data is used to construct a Panel4D # if dtype is not passed, it should be inferred value_and_dtype = [(1, 'int64'), (3.14, 'float64'), ('foo', np.object_)] for (val, dtype) in value_and_dtype: panel4d = Panel4D(val, labels=range(2), items=range(3), major_axis=range(4), minor_axis=range(5)) vals = np.empty((2, 3, 4, 5), dtype=dtype) vals.fill(val) expected = Panel4D(vals, dtype=dtype) tm.assert_panel4d_equal(panel4d, expected) # test the case when dtype is passed panel4d = Panel4D(1, labels=range(2), items=range(3), major_axis=range(4), minor_axis=range(5), dtype='float32') vals = np.empty((2, 3, 4, 5), dtype='float32') vals.fill(1) expected = Panel4D(vals, dtype='float32') tm.assert_panel4d_equal(panel4d, expected)
def test_constructor(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): panel4d = Panel4D(self.panel4d._data) self.assertIs(panel4d._data, self.panel4d._data) panel4d = Panel4D(self.panel4d._data, copy=True) self.assertIsNot(panel4d._data, self.panel4d._data) assert_panel4d_equal(panel4d, self.panel4d) vals = self.panel4d.values # no copy panel4d = Panel4D(vals) self.assertIs(panel4d.values, vals) # copy panel4d = Panel4D(vals, copy=True) self.assertIsNot(panel4d.values, vals) # GH #8285, test when scalar data is used to construct a Panel4D # if dtype is not passed, it should be inferred value_and_dtype = [(1, 'int64'), (3.14, 'float64'), ('foo', np.object_)] for (val, dtype) in value_and_dtype: panel4d = Panel4D(val, labels=range(2), items=range(3), major_axis=range(4), minor_axis=range(5)) vals = np.empty((2, 3, 4, 5), dtype=dtype) vals.fill(val) expected = Panel4D(vals, dtype=dtype) assert_panel4d_equal(panel4d, expected) # test the case when dtype is passed panel4d = Panel4D(1, labels=range(2), items=range(3), major_axis=range(4), minor_axis=range(5), dtype='float32') vals = np.empty((2, 3, 4, 5), dtype='float32') vals.fill(1) expected = Panel4D(vals, dtype='float32') assert_panel4d_equal(panel4d, expected)
def test_ctor_dict(self): l1 = self.panel4d['l1'] l2 = self.panel4d['l2'] d = {'A' : l1, 'B' : l2.ix[['ItemB'],:,:] } #d2 = {'A' : itema._series, 'B' : itemb[5:]._series} #d3 = {'A' : DataFrame(itema._series), # 'B' : DataFrame(itemb[5:]._series)} panel4d = Panel4D(d) #wp2 = Panel.from_dict(d2) # nested Dict #wp3 = Panel.from_dict(d3) #self.assert_(wp.major_axis.equals(self.panel.major_axis)) assert_panel_equal(panel4d['A'], self.panel4d['l1']) assert_frame_equal(panel4d.ix['B','ItemB',:,:], self.panel4d.ix['l2',['ItemB'],:,:]['ItemB'])
def test_delitem_and_pop(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): expected = self.panel4d['l2'] result = self.panel4d.pop('l2') assert_panel_equal(expected, result) self.assertNotIn('l2', self.panel4d.labels) del self.panel4d['l3'] self.assertNotIn('l3', self.panel4d.labels) self.assertRaises(Exception, self.panel4d.__delitem__, 'l3') values = np.empty((4, 4, 4, 4)) values[0] = 0 values[1] = 1 values[2] = 2 values[3] = 3 panel4d = Panel4D(values, lrange(4), lrange(4), lrange(4), lrange(4)) # did we delete the right row? panel4dc = panel4d.copy() del panel4dc[0] assert_panel_equal(panel4dc[1], panel4d[1]) assert_panel_equal(panel4dc[2], panel4d[2]) assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[1] assert_panel_equal(panel4dc[0], panel4d[0]) assert_panel_equal(panel4dc[2], panel4d[2]) assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[2] assert_panel_equal(panel4dc[1], panel4d[1]) assert_panel_equal(panel4dc[0], panel4d[0]) assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[3] assert_panel_equal(panel4dc[1], panel4d[1]) assert_panel_equal(panel4dc[2], panel4d[2]) assert_panel_equal(panel4dc[0], panel4d[0])
def test_delitem_and_pop(self): with catch_warnings(record=True): expected = self.panel4d['l2'] result = self.panel4d.pop('l2') tm.assert_panel_equal(expected, result) assert 'l2' not in self.panel4d.labels del self.panel4d['l3'] assert 'l3' not in self.panel4d.labels pytest.raises(Exception, self.panel4d.__delitem__, 'l3') values = np.empty((4, 4, 4, 4)) values[0] = 0 values[1] = 1 values[2] = 2 values[3] = 3 panel4d = Panel4D(values, lrange(4), lrange(4), lrange(4), lrange(4)) # did we delete the right row? panel4dc = panel4d.copy() del panel4dc[0] tm.assert_panel_equal(panel4dc[1], panel4d[1]) tm.assert_panel_equal(panel4dc[2], panel4d[2]) tm.assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[1] tm.assert_panel_equal(panel4dc[0], panel4d[0]) tm.assert_panel_equal(panel4dc[2], panel4d[2]) tm.assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[2] tm.assert_panel_equal(panel4dc[1], panel4d[1]) tm.assert_panel_equal(panel4dc[0], panel4d[0]) tm.assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[3] tm.assert_panel_equal(panel4dc[1], panel4d[1]) tm.assert_panel_equal(panel4dc[2], panel4d[2]) tm.assert_panel_equal(panel4dc[0], panel4d[0])
def test_delitem_and_pop(self): expected = self.panel4d['l2'] result = self.panel4d.pop('l2') assert_panel_equal(expected, result) self.assert_('l2' not in self.panel4d.labels) del self.panel4d['l3'] self.assert_('l3' not in self.panel4d.labels) self.assertRaises(Exception, self.panel4d.__delitem__, 'l3') values = np.empty((4, 4, 4, 4)) values[0] = 0 values[1] = 1 values[2] = 2 values[3] = 3 panel4d = Panel4D(values, list(range(4)), list(range(4)), list(range(4)), list(range(4))) # did we delete the right row? panel4dc = panel4d.copy() del panel4dc[0] assert_panel_equal(panel4dc[1], panel4d[1]) assert_panel_equal(panel4dc[2], panel4d[2]) assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[1] assert_panel_equal(panel4dc[0], panel4d[0]) assert_panel_equal(panel4dc[2], panel4d[2]) assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[2] assert_panel_equal(panel4dc[1], panel4d[1]) assert_panel_equal(panel4dc[0], panel4d[0]) assert_panel_equal(panel4dc[3], panel4d[3]) panel4dc = panel4d.copy() del panel4dc[3] assert_panel_equal(panel4dc[1], panel4d[1]) assert_panel_equal(panel4dc[2], panel4d[2]) assert_panel_equal(panel4dc[0], panel4d[0])
def test_not_hashable(self): p4D_empty = Panel4D() self.assertRaises(TypeError, hash, p4D_empty) self.assertRaises(TypeError, hash, self.panel4d)
def test_repr_empty(self): empty = Panel4D() repr(empty)
def test_not_hashable(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): p4D_empty = Panel4D() self.assertRaises(TypeError, hash, p4D_empty) self.assertRaises(TypeError, hash, self.panel4d)
def test_repr_empty(self): with catch_warnings(record=True): empty = Panel4D() repr(empty)
def test_not_hashable(self): with catch_warnings(record=True): p4D_empty = Panel4D() pytest.raises(TypeError, hash, p4D_empty) pytest.raises(TypeError, hash, self.panel4d)
def test_repr_empty(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): empty = Panel4D() repr(empty)