demo + utils venv
This commit is contained in:
d3m1g0d
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,271 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# pylint: disable-msg=E1101,W0612
|
||||
|
||||
from copy import deepcopy
|
||||
from distutils.version import LooseVersion
|
||||
from operator import methodcaller
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from pandas.compat import range
|
||||
import pandas.util._test_decorators as td
|
||||
|
||||
import pandas as pd
|
||||
from pandas import DataFrame, MultiIndex, Series, date_range
|
||||
import pandas.util.testing as tm
|
||||
from pandas.util.testing import (
|
||||
assert_almost_equal, assert_frame_equal, assert_series_equal)
|
||||
|
||||
from .test_generic import Generic
|
||||
|
||||
try:
|
||||
import xarray
|
||||
_XARRAY_INSTALLED = True
|
||||
except ImportError:
|
||||
_XARRAY_INSTALLED = False
|
||||
|
||||
|
||||
class TestDataFrame(Generic):
|
||||
_typ = DataFrame
|
||||
_comparator = lambda self, x, y: assert_frame_equal(x, y)
|
||||
|
||||
def test_rename_mi(self):
|
||||
df = DataFrame([
|
||||
11, 21, 31
|
||||
], index=MultiIndex.from_tuples([("A", x) for x in ["a", "B", "c"]]))
|
||||
df.rename(str.lower)
|
||||
|
||||
def test_set_axis_name(self):
|
||||
df = pd.DataFrame([[1, 2], [3, 4]])
|
||||
funcs = ['_set_axis_name', 'rename_axis']
|
||||
for func in funcs:
|
||||
result = methodcaller(func, 'foo')(df)
|
||||
assert df.index.name is None
|
||||
assert result.index.name == 'foo'
|
||||
|
||||
result = methodcaller(func, 'cols', axis=1)(df)
|
||||
assert df.columns.name is None
|
||||
assert result.columns.name == 'cols'
|
||||
|
||||
def test_set_axis_name_mi(self):
|
||||
df = DataFrame(
|
||||
np.empty((3, 3)),
|
||||
index=MultiIndex.from_tuples([("A", x) for x in list('aBc')]),
|
||||
columns=MultiIndex.from_tuples([('C', x) for x in list('xyz')])
|
||||
)
|
||||
|
||||
level_names = ['L1', 'L2']
|
||||
funcs = ['_set_axis_name', 'rename_axis']
|
||||
for func in funcs:
|
||||
result = methodcaller(func, level_names)(df)
|
||||
assert result.index.names == level_names
|
||||
assert result.columns.names == [None, None]
|
||||
|
||||
result = methodcaller(func, level_names, axis=1)(df)
|
||||
assert result.columns.names == ["L1", "L2"]
|
||||
assert result.index.names == [None, None]
|
||||
|
||||
def test_nonzero_single_element(self):
|
||||
|
||||
# allow single item via bool method
|
||||
df = DataFrame([[True]])
|
||||
assert df.bool()
|
||||
|
||||
df = DataFrame([[False]])
|
||||
assert not df.bool()
|
||||
|
||||
df = DataFrame([[False, False]])
|
||||
with pytest.raises(ValueError):
|
||||
df.bool()
|
||||
with pytest.raises(ValueError):
|
||||
bool(df)
|
||||
|
||||
def test_get_numeric_data_preserve_dtype(self):
|
||||
|
||||
# get the numeric data
|
||||
o = DataFrame({'A': [1, '2', 3.]})
|
||||
result = o._get_numeric_data()
|
||||
expected = DataFrame(index=[0, 1, 2], dtype=object)
|
||||
self._compare(result, expected)
|
||||
|
||||
def test_metadata_propagation_indiv(self):
|
||||
|
||||
# groupby
|
||||
df = DataFrame(
|
||||
{'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
|
||||
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
|
||||
'C': np.random.randn(8),
|
||||
'D': np.random.randn(8)})
|
||||
result = df.groupby('A').sum()
|
||||
self.check_metadata(df, result)
|
||||
|
||||
# resample
|
||||
df = DataFrame(np.random.randn(1000, 2),
|
||||
index=date_range('20130101', periods=1000, freq='s'))
|
||||
result = df.resample('1T')
|
||||
self.check_metadata(df, result)
|
||||
|
||||
# merging with override
|
||||
# GH 6923
|
||||
_metadata = DataFrame._metadata
|
||||
_finalize = DataFrame.__finalize__
|
||||
|
||||
np.random.seed(10)
|
||||
df1 = DataFrame(np.random.randint(0, 4, (3, 2)), columns=['a', 'b'])
|
||||
df2 = DataFrame(np.random.randint(0, 4, (3, 2)), columns=['c', 'd'])
|
||||
DataFrame._metadata = ['filename']
|
||||
df1.filename = 'fname1.csv'
|
||||
df2.filename = 'fname2.csv'
|
||||
|
||||
def finalize(self, other, method=None, **kwargs):
|
||||
|
||||
for name in self._metadata:
|
||||
if method == 'merge':
|
||||
left, right = other.left, other.right
|
||||
value = getattr(left, name, '') + '|' + getattr(right,
|
||||
name, '')
|
||||
object.__setattr__(self, name, value)
|
||||
else:
|
||||
object.__setattr__(self, name, getattr(other, name, ''))
|
||||
|
||||
return self
|
||||
|
||||
DataFrame.__finalize__ = finalize
|
||||
result = df1.merge(df2, left_on=['a'], right_on=['c'], how='inner')
|
||||
assert result.filename == 'fname1.csv|fname2.csv'
|
||||
|
||||
# concat
|
||||
# GH 6927
|
||||
DataFrame._metadata = ['filename']
|
||||
df1 = DataFrame(np.random.randint(0, 4, (3, 2)), columns=list('ab'))
|
||||
df1.filename = 'foo'
|
||||
|
||||
def finalize(self, other, method=None, **kwargs):
|
||||
for name in self._metadata:
|
||||
if method == 'concat':
|
||||
value = '+'.join([getattr(
|
||||
o, name) for o in other.objs if getattr(o, name, None)
|
||||
])
|
||||
object.__setattr__(self, name, value)
|
||||
else:
|
||||
object.__setattr__(self, name, getattr(other, name, None))
|
||||
|
||||
return self
|
||||
|
||||
DataFrame.__finalize__ = finalize
|
||||
|
||||
result = pd.concat([df1, df1])
|
||||
assert result.filename == 'foo+foo'
|
||||
|
||||
# reset
|
||||
DataFrame._metadata = _metadata
|
||||
DataFrame.__finalize__ = _finalize
|
||||
|
||||
def test_set_attribute(self):
|
||||
# Test for consistent setattr behavior when an attribute and a column
|
||||
# have the same name (Issue #8994)
|
||||
df = DataFrame({'x': [1, 2, 3]})
|
||||
|
||||
df.y = 2
|
||||
df['y'] = [2, 4, 6]
|
||||
df.y = 5
|
||||
|
||||
assert df.y == 5
|
||||
assert_series_equal(df['y'], Series([2, 4, 6], name='y'))
|
||||
|
||||
@pytest.mark.skipif(not _XARRAY_INSTALLED or _XARRAY_INSTALLED and
|
||||
LooseVersion(xarray.__version__) <
|
||||
LooseVersion('0.10.0'),
|
||||
reason='xarray >= 0.10.0 required')
|
||||
@pytest.mark.parametrize(
|
||||
"index", ['FloatIndex', 'IntIndex',
|
||||
'StringIndex', 'UnicodeIndex',
|
||||
'DateIndex', 'PeriodIndex',
|
||||
'CategoricalIndex', 'TimedeltaIndex'])
|
||||
def test_to_xarray_index_types(self, index):
|
||||
from xarray import Dataset
|
||||
|
||||
index = getattr(tm, 'make{}'.format(index))
|
||||
df = DataFrame({'a': list('abc'),
|
||||
'b': list(range(1, 4)),
|
||||
'c': np.arange(3, 6).astype('u1'),
|
||||
'd': np.arange(4.0, 7.0, dtype='float64'),
|
||||
'e': [True, False, True],
|
||||
'f': pd.Categorical(list('abc')),
|
||||
'g': pd.date_range('20130101', periods=3),
|
||||
'h': pd.date_range('20130101',
|
||||
periods=3,
|
||||
tz='US/Eastern')}
|
||||
)
|
||||
|
||||
df.index = index(3)
|
||||
df.index.name = 'foo'
|
||||
df.columns.name = 'bar'
|
||||
result = df.to_xarray()
|
||||
assert result.dims['foo'] == 3
|
||||
assert len(result.coords) == 1
|
||||
assert len(result.data_vars) == 8
|
||||
assert_almost_equal(list(result.coords.keys()), ['foo'])
|
||||
assert isinstance(result, Dataset)
|
||||
|
||||
# idempotency
|
||||
# categoricals are not preserved
|
||||
# datetimes w/tz are not preserved
|
||||
# column names are lost
|
||||
expected = df.copy()
|
||||
expected['f'] = expected['f'].astype(object)
|
||||
expected['h'] = expected['h'].astype('datetime64[ns]')
|
||||
expected.columns.name = None
|
||||
assert_frame_equal(result.to_dataframe(), expected,
|
||||
check_index_type=False, check_categorical=False)
|
||||
|
||||
@td.skip_if_no('xarray', min_version='0.7.0')
|
||||
def test_to_xarray(self):
|
||||
from xarray import Dataset
|
||||
|
||||
df = DataFrame({'a': list('abc'),
|
||||
'b': list(range(1, 4)),
|
||||
'c': np.arange(3, 6).astype('u1'),
|
||||
'd': np.arange(4.0, 7.0, dtype='float64'),
|
||||
'e': [True, False, True],
|
||||
'f': pd.Categorical(list('abc')),
|
||||
'g': pd.date_range('20130101', periods=3),
|
||||
'h': pd.date_range('20130101',
|
||||
periods=3,
|
||||
tz='US/Eastern')}
|
||||
)
|
||||
|
||||
df.index.name = 'foo'
|
||||
result = df[0:0].to_xarray()
|
||||
assert result.dims['foo'] == 0
|
||||
assert isinstance(result, Dataset)
|
||||
|
||||
# available in 0.7.1
|
||||
# MultiIndex
|
||||
df.index = pd.MultiIndex.from_product([['a'], range(3)],
|
||||
names=['one', 'two'])
|
||||
result = df.to_xarray()
|
||||
assert result.dims['one'] == 1
|
||||
assert result.dims['two'] == 3
|
||||
assert len(result.coords) == 2
|
||||
assert len(result.data_vars) == 8
|
||||
assert_almost_equal(list(result.coords.keys()), ['one', 'two'])
|
||||
assert isinstance(result, Dataset)
|
||||
|
||||
result = result.to_dataframe()
|
||||
expected = df.copy()
|
||||
expected['f'] = expected['f'].astype(object)
|
||||
expected['h'] = expected['h'].astype('datetime64[ns]')
|
||||
expected.columns.name = None
|
||||
assert_frame_equal(result,
|
||||
expected,
|
||||
check_index_type=False)
|
||||
|
||||
def test_deepcopy_empty(self):
|
||||
# This test covers empty frame copying with non-empty column sets
|
||||
# as reported in issue GH15370
|
||||
empty_frame = DataFrame(data=[], index=[], columns=['A'])
|
||||
empty_frame_copy = deepcopy(empty_frame)
|
||||
|
||||
self._compare(empty_frame_copy, empty_frame)
|
||||
File diff suppressed because it is too large
Load Diff
+406
@@ -0,0 +1,406 @@
|
||||
import pytest
|
||||
|
||||
from pandas.core.dtypes.missing import array_equivalent
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
|
||||
|
||||
# Fixtures
|
||||
# ========
|
||||
@pytest.fixture
|
||||
def df():
|
||||
"""DataFrame with columns 'L1', 'L2', and 'L3' """
|
||||
return pd.DataFrame({'L1': [1, 2, 3],
|
||||
'L2': [11, 12, 13],
|
||||
'L3': ['A', 'B', 'C']})
|
||||
|
||||
|
||||
@pytest.fixture(params=[[], ['L1'], ['L1', 'L2'], ['L1', 'L2', 'L3']])
|
||||
def df_levels(request, df):
|
||||
"""DataFrame with columns or index levels 'L1', 'L2', and 'L3' """
|
||||
levels = request.param
|
||||
|
||||
if levels:
|
||||
df = df.set_index(levels)
|
||||
|
||||
return df
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def df_ambig(df):
|
||||
"""DataFrame with levels 'L1' and 'L2' and labels 'L1' and 'L3' """
|
||||
df = df.set_index(['L1', 'L2'])
|
||||
|
||||
df['L1'] = df['L3']
|
||||
|
||||
return df
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def df_duplabels(df):
|
||||
"""DataFrame with level 'L1' and labels 'L2', 'L3', and 'L2' """
|
||||
df = df.set_index(['L1'])
|
||||
df = pd.concat([df, df['L2']], axis=1)
|
||||
|
||||
return df
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def panel():
|
||||
with tm.assert_produces_warning(FutureWarning,
|
||||
check_stacklevel=False):
|
||||
return pd.Panel()
|
||||
|
||||
|
||||
# Test is label/level reference
|
||||
# =============================
|
||||
def get_labels_levels(df_levels):
|
||||
expected_labels = list(df_levels.columns)
|
||||
expected_levels = [name for name in df_levels.index.names
|
||||
if name is not None]
|
||||
return expected_labels, expected_levels
|
||||
|
||||
|
||||
def assert_label_reference(frame, labels, axis):
|
||||
for label in labels:
|
||||
assert frame._is_label_reference(label, axis=axis)
|
||||
assert not frame._is_level_reference(label, axis=axis)
|
||||
assert frame._is_label_or_level_reference(label, axis=axis)
|
||||
|
||||
|
||||
def assert_level_reference(frame, levels, axis):
|
||||
for level in levels:
|
||||
assert frame._is_level_reference(level, axis=axis)
|
||||
assert not frame._is_label_reference(level, axis=axis)
|
||||
assert frame._is_label_or_level_reference(level, axis=axis)
|
||||
|
||||
|
||||
# DataFrame
|
||||
# ---------
|
||||
def test_is_level_or_label_reference_df_simple(df_levels, axis):
|
||||
|
||||
# Compute expected labels and levels
|
||||
expected_labels, expected_levels = get_labels_levels(df_levels)
|
||||
|
||||
# Transpose frame if axis == 1
|
||||
if axis in {1, 'columns'}:
|
||||
df_levels = df_levels.T
|
||||
|
||||
# Perform checks
|
||||
assert_level_reference(df_levels, expected_levels, axis=axis)
|
||||
assert_label_reference(df_levels, expected_labels, axis=axis)
|
||||
|
||||
|
||||
def test_is_level_reference_df_ambig(df_ambig, axis):
|
||||
|
||||
# Transpose frame if axis == 1
|
||||
if axis in {1, 'columns'}:
|
||||
df_ambig = df_ambig.T
|
||||
|
||||
# df has both an on-axis level and off-axis label named L1
|
||||
# Therefore L1 should reference the label, not the level
|
||||
assert_label_reference(df_ambig, ['L1'], axis=axis)
|
||||
|
||||
# df has an on-axis level named L2 and it is not ambiguous
|
||||
# Therefore L2 is an level reference
|
||||
assert_level_reference(df_ambig, ['L2'], axis=axis)
|
||||
|
||||
# df has a column named L3 and it not an level reference
|
||||
assert_label_reference(df_ambig, ['L3'], axis=axis)
|
||||
|
||||
|
||||
# Series
|
||||
# ------
|
||||
def test_is_level_reference_series_simple_axis0(df):
|
||||
|
||||
# Make series with L1 as index
|
||||
s = df.set_index('L1').L2
|
||||
assert_level_reference(s, ['L1'], axis=0)
|
||||
assert not s._is_level_reference('L2')
|
||||
|
||||
# Make series with L1 and L2 as index
|
||||
s = df.set_index(['L1', 'L2']).L3
|
||||
assert_level_reference(s, ['L1', 'L2'], axis=0)
|
||||
assert not s._is_level_reference('L3')
|
||||
|
||||
|
||||
def test_is_level_reference_series_axis1_error(df):
|
||||
|
||||
# Make series with L1 as index
|
||||
s = df.set_index('L1').L2
|
||||
|
||||
with pytest.raises(ValueError, match="No axis named 1"):
|
||||
s._is_level_reference('L1', axis=1)
|
||||
|
||||
|
||||
# Panel
|
||||
# -----
|
||||
def test_is_level_reference_panel_error(panel):
|
||||
msg = ("_is_level_reference is not implemented for {type}"
|
||||
.format(type=type(panel)))
|
||||
|
||||
with pytest.raises(NotImplementedError, match=msg):
|
||||
panel._is_level_reference('L1', axis=0)
|
||||
|
||||
|
||||
def test_is_label_reference_panel_error(panel):
|
||||
msg = ("_is_label_reference is not implemented for {type}"
|
||||
.format(type=type(panel)))
|
||||
|
||||
with pytest.raises(NotImplementedError, match=msg):
|
||||
panel._is_label_reference('L1', axis=0)
|
||||
|
||||
|
||||
def test_is_label_or_level_reference_panel_error(panel):
|
||||
msg = ("_is_label_or_level_reference is not implemented for {type}"
|
||||
.format(type=type(panel)))
|
||||
|
||||
with pytest.raises(NotImplementedError, match=msg):
|
||||
panel._is_label_or_level_reference('L1', axis=0)
|
||||
|
||||
|
||||
# Test _check_label_or_level_ambiguity_df
|
||||
# =======================================
|
||||
|
||||
# DataFrame
|
||||
# ---------
|
||||
def test_check_label_or_level_ambiguity_df(df_ambig, axis):
|
||||
|
||||
# Transpose frame if axis == 1
|
||||
if axis in {1, "columns"}:
|
||||
df_ambig = df_ambig.T
|
||||
|
||||
if axis in {0, "index"}:
|
||||
msg = "'L1' is both an index level and a column label"
|
||||
else:
|
||||
msg = "'L1' is both a column level and an index label"
|
||||
|
||||
# df_ambig has both an on-axis level and off-axis label named L1
|
||||
# Therefore, L1 is ambiguous.
|
||||
with pytest.raises(ValueError, match=msg):
|
||||
df_ambig._check_label_or_level_ambiguity("L1", axis=axis)
|
||||
|
||||
# df_ambig has an on-axis level named L2,, and it is not ambiguous.
|
||||
df_ambig._check_label_or_level_ambiguity("L2", axis=axis)
|
||||
|
||||
# df_ambig has an off-axis label named L3, and it is not ambiguous
|
||||
assert not df_ambig._check_label_or_level_ambiguity("L3", axis=axis)
|
||||
|
||||
|
||||
# Series
|
||||
# ------
|
||||
def test_check_label_or_level_ambiguity_series(df):
|
||||
|
||||
# A series has no columns and therefore references are never ambiguous
|
||||
|
||||
# Make series with L1 as index
|
||||
s = df.set_index("L1").L2
|
||||
s._check_label_or_level_ambiguity("L1", axis=0)
|
||||
s._check_label_or_level_ambiguity("L2", axis=0)
|
||||
|
||||
# Make series with L1 and L2 as index
|
||||
s = df.set_index(["L1", "L2"]).L3
|
||||
s._check_label_or_level_ambiguity("L1", axis=0)
|
||||
s._check_label_or_level_ambiguity("L2", axis=0)
|
||||
s._check_label_or_level_ambiguity("L3", axis=0)
|
||||
|
||||
|
||||
def test_check_label_or_level_ambiguity_series_axis1_error(df):
|
||||
|
||||
# Make series with L1 as index
|
||||
s = df.set_index('L1').L2
|
||||
|
||||
with pytest.raises(ValueError, match="No axis named 1"):
|
||||
s._check_label_or_level_ambiguity('L1', axis=1)
|
||||
|
||||
|
||||
# Panel
|
||||
# -----
|
||||
def test_check_label_or_level_ambiguity_panel_error(panel):
|
||||
msg = ("_check_label_or_level_ambiguity is not implemented for {type}"
|
||||
.format(type=type(panel)))
|
||||
|
||||
with pytest.raises(NotImplementedError, match=msg):
|
||||
panel._check_label_or_level_ambiguity("L1", axis=0)
|
||||
|
||||
|
||||
# Test _get_label_or_level_values
|
||||
# ===============================
|
||||
def assert_label_values(frame, labels, axis):
|
||||
for label in labels:
|
||||
if axis in {0, 'index'}:
|
||||
expected = frame[label]._values
|
||||
else:
|
||||
expected = frame.loc[label]._values
|
||||
|
||||
result = frame._get_label_or_level_values(label, axis=axis)
|
||||
assert array_equivalent(expected, result)
|
||||
|
||||
|
||||
def assert_level_values(frame, levels, axis):
|
||||
for level in levels:
|
||||
if axis in {0, "index"}:
|
||||
expected = frame.index.get_level_values(level=level)._values
|
||||
else:
|
||||
expected = frame.columns.get_level_values(level=level)._values
|
||||
|
||||
result = frame._get_label_or_level_values(level, axis=axis)
|
||||
assert array_equivalent(expected, result)
|
||||
|
||||
|
||||
# DataFrame
|
||||
# ---------
|
||||
def test_get_label_or_level_values_df_simple(df_levels, axis):
|
||||
|
||||
# Compute expected labels and levels
|
||||
expected_labels, expected_levels = get_labels_levels(df_levels)
|
||||
|
||||
# Transpose frame if axis == 1
|
||||
if axis in {1, 'columns'}:
|
||||
df_levels = df_levels.T
|
||||
|
||||
# Perform checks
|
||||
assert_label_values(df_levels, expected_labels, axis=axis)
|
||||
assert_level_values(df_levels, expected_levels, axis=axis)
|
||||
|
||||
|
||||
def test_get_label_or_level_values_df_ambig(df_ambig, axis):
|
||||
|
||||
# Transpose frame if axis == 1
|
||||
if axis in {1, 'columns'}:
|
||||
df_ambig = df_ambig.T
|
||||
|
||||
# df has an on-axis level named L2, and it is not ambiguous.
|
||||
assert_level_values(df_ambig, ['L2'], axis=axis)
|
||||
|
||||
# df has an off-axis label named L3, and it is not ambiguous.
|
||||
assert_label_values(df_ambig, ['L3'], axis=axis)
|
||||
|
||||
|
||||
def test_get_label_or_level_values_df_duplabels(df_duplabels, axis):
|
||||
|
||||
# Transpose frame if axis == 1
|
||||
if axis in {1, 'columns'}:
|
||||
df_duplabels = df_duplabels.T
|
||||
|
||||
# df has unambiguous level 'L1'
|
||||
assert_level_values(df_duplabels, ['L1'], axis=axis)
|
||||
|
||||
# df has unique label 'L3'
|
||||
assert_label_values(df_duplabels, ['L3'], axis=axis)
|
||||
|
||||
# df has duplicate labels 'L2'
|
||||
if axis in {0, 'index'}:
|
||||
expected_msg = "The column label 'L2' is not unique"
|
||||
else:
|
||||
expected_msg = "The index label 'L2' is not unique"
|
||||
|
||||
with pytest.raises(ValueError, match=expected_msg):
|
||||
assert_label_values(df_duplabels, ['L2'], axis=axis)
|
||||
|
||||
|
||||
# Series
|
||||
# ------
|
||||
def test_get_label_or_level_values_series_axis0(df):
|
||||
|
||||
# Make series with L1 as index
|
||||
s = df.set_index('L1').L2
|
||||
assert_level_values(s, ['L1'], axis=0)
|
||||
|
||||
# Make series with L1 and L2 as index
|
||||
s = df.set_index(['L1', 'L2']).L3
|
||||
assert_level_values(s, ['L1', 'L2'], axis=0)
|
||||
|
||||
|
||||
def test_get_label_or_level_values_series_axis1_error(df):
|
||||
|
||||
# Make series with L1 as index
|
||||
s = df.set_index('L1').L2
|
||||
|
||||
with pytest.raises(ValueError, match="No axis named 1"):
|
||||
s._get_label_or_level_values('L1', axis=1)
|
||||
|
||||
|
||||
# Panel
|
||||
# -----
|
||||
def test_get_label_or_level_values_panel_error(panel):
|
||||
msg = ("_get_label_or_level_values is not implemented for {type}"
|
||||
.format(type=type(panel)))
|
||||
|
||||
with pytest.raises(NotImplementedError, match=msg):
|
||||
panel._get_label_or_level_values('L1', axis=0)
|
||||
|
||||
|
||||
# Test _drop_labels_or_levels
|
||||
# ===========================
|
||||
def assert_labels_dropped(frame, labels, axis):
|
||||
for label in labels:
|
||||
df_dropped = frame._drop_labels_or_levels(label, axis=axis)
|
||||
|
||||
if axis in {0, 'index'}:
|
||||
assert label in frame.columns
|
||||
assert label not in df_dropped.columns
|
||||
else:
|
||||
assert label in frame.index
|
||||
assert label not in df_dropped.index
|
||||
|
||||
|
||||
def assert_levels_dropped(frame, levels, axis):
|
||||
for level in levels:
|
||||
df_dropped = frame._drop_labels_or_levels(level, axis=axis)
|
||||
|
||||
if axis in {0, 'index'}:
|
||||
assert level in frame.index.names
|
||||
assert level not in df_dropped.index.names
|
||||
else:
|
||||
assert level in frame.columns.names
|
||||
assert level not in df_dropped.columns.names
|
||||
|
||||
|
||||
# DataFrame
|
||||
# ---------
|
||||
def test_drop_labels_or_levels_df(df_levels, axis):
|
||||
|
||||
# Compute expected labels and levels
|
||||
expected_labels, expected_levels = get_labels_levels(df_levels)
|
||||
|
||||
# Transpose frame if axis == 1
|
||||
if axis in {1, 'columns'}:
|
||||
df_levels = df_levels.T
|
||||
|
||||
# Perform checks
|
||||
assert_labels_dropped(df_levels, expected_labels, axis=axis)
|
||||
assert_levels_dropped(df_levels, expected_levels, axis=axis)
|
||||
|
||||
with pytest.raises(ValueError, match="not valid labels or levels"):
|
||||
df_levels._drop_labels_or_levels('L4', axis=axis)
|
||||
|
||||
|
||||
# Series
|
||||
# ------
|
||||
def test_drop_labels_or_levels_series(df):
|
||||
|
||||
# Make series with L1 as index
|
||||
s = df.set_index('L1').L2
|
||||
assert_levels_dropped(s, ['L1'], axis=0)
|
||||
|
||||
with pytest.raises(ValueError, match="not valid labels or levels"):
|
||||
s._drop_labels_or_levels('L4', axis=0)
|
||||
|
||||
# Make series with L1 and L2 as index
|
||||
s = df.set_index(['L1', 'L2']).L3
|
||||
assert_levels_dropped(s, ['L1', 'L2'], axis=0)
|
||||
|
||||
with pytest.raises(ValueError, match="not valid labels or levels"):
|
||||
s._drop_labels_or_levels('L4', axis=0)
|
||||
|
||||
|
||||
# Panel
|
||||
# -----
|
||||
def test_drop_labels_or_levels_panel_error(panel):
|
||||
msg = ("_drop_labels_or_levels is not implemented for {type}"
|
||||
.format(type=type(panel)))
|
||||
|
||||
with pytest.raises(NotImplementedError, match=msg):
|
||||
panel._drop_labels_or_levels('L1', axis=0)
|
||||
@@ -0,0 +1,59 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# pylint: disable-msg=E1101,W0612
|
||||
|
||||
from warnings import catch_warnings, simplefilter
|
||||
|
||||
import pandas.util._test_decorators as td
|
||||
|
||||
from pandas import Panel
|
||||
import pandas.util.testing as tm
|
||||
from pandas.util.testing import assert_almost_equal, assert_panel_equal
|
||||
|
||||
from .test_generic import Generic
|
||||
|
||||
|
||||
class TestPanel(Generic):
|
||||
_typ = Panel
|
||||
_comparator = lambda self, x, y: assert_panel_equal(x, y, by_blocks=True)
|
||||
|
||||
@td.skip_if_no('xarray', min_version='0.7.0')
|
||||
def test_to_xarray(self):
|
||||
from xarray import DataArray
|
||||
|
||||
with catch_warnings(record=True):
|
||||
simplefilter("ignore", FutureWarning)
|
||||
p = tm.makePanel()
|
||||
|
||||
result = p.to_xarray()
|
||||
assert isinstance(result, DataArray)
|
||||
assert len(result.coords) == 3
|
||||
assert_almost_equal(list(result.coords.keys()),
|
||||
['items', 'major_axis', 'minor_axis'])
|
||||
assert len(result.dims) == 3
|
||||
|
||||
# idempotency
|
||||
assert_panel_equal(result.to_pandas(), p)
|
||||
|
||||
|
||||
# run all the tests, but wrap each in a warning catcher
|
||||
for t in ['test_rename', 'test_get_numeric_data',
|
||||
'test_get_default', 'test_nonzero',
|
||||
'test_downcast', 'test_constructor_compound_dtypes',
|
||||
'test_head_tail',
|
||||
'test_size_compat', 'test_split_compat',
|
||||
'test_unexpected_keyword',
|
||||
'test_stat_unexpected_keyword', 'test_api_compat',
|
||||
'test_stat_non_defaults_args',
|
||||
'test_truncate_out_of_bounds',
|
||||
'test_metadata_propagation', 'test_copy_and_deepcopy',
|
||||
'test_pct_change', 'test_sample']:
|
||||
|
||||
def f():
|
||||
def tester(self):
|
||||
f = getattr(super(TestPanel, self), t)
|
||||
with catch_warnings(record=True):
|
||||
simplefilter("ignore", FutureWarning)
|
||||
f()
|
||||
return tester
|
||||
|
||||
setattr(TestPanel, t, f())
|
||||
@@ -0,0 +1,247 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# pylint: disable-msg=E1101,W0612
|
||||
|
||||
from distutils.version import LooseVersion
|
||||
from operator import methodcaller
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from pandas.compat import range
|
||||
import pandas.util._test_decorators as td
|
||||
|
||||
import pandas as pd
|
||||
from pandas import MultiIndex, Series, date_range
|
||||
import pandas.util.testing as tm
|
||||
from pandas.util.testing import assert_almost_equal, assert_series_equal
|
||||
|
||||
from .test_generic import Generic
|
||||
|
||||
try:
|
||||
import xarray
|
||||
_XARRAY_INSTALLED = True
|
||||
except ImportError:
|
||||
_XARRAY_INSTALLED = False
|
||||
|
||||
|
||||
class TestSeries(Generic):
|
||||
_typ = Series
|
||||
_comparator = lambda self, x, y: assert_series_equal(x, y)
|
||||
|
||||
def setup_method(self):
|
||||
self.ts = tm.makeTimeSeries() # Was at top level in test_series
|
||||
self.ts.name = 'ts'
|
||||
|
||||
self.series = tm.makeStringSeries()
|
||||
self.series.name = 'series'
|
||||
|
||||
def test_rename_mi(self):
|
||||
s = Series([11, 21, 31],
|
||||
index=MultiIndex.from_tuples(
|
||||
[("A", x) for x in ["a", "B", "c"]]))
|
||||
s.rename(str.lower)
|
||||
|
||||
def test_set_axis_name(self):
|
||||
s = Series([1, 2, 3], index=['a', 'b', 'c'])
|
||||
funcs = ['rename_axis', '_set_axis_name']
|
||||
name = 'foo'
|
||||
for func in funcs:
|
||||
result = methodcaller(func, name)(s)
|
||||
assert s.index.name is None
|
||||
assert result.index.name == name
|
||||
|
||||
def test_set_axis_name_mi(self):
|
||||
s = Series([11, 21, 31], index=MultiIndex.from_tuples(
|
||||
[("A", x) for x in ["a", "B", "c"]],
|
||||
names=['l1', 'l2'])
|
||||
)
|
||||
funcs = ['rename_axis', '_set_axis_name']
|
||||
for func in funcs:
|
||||
result = methodcaller(func, ['L1', 'L2'])(s)
|
||||
assert s.index.name is None
|
||||
assert s.index.names == ['l1', 'l2']
|
||||
assert result.index.name is None
|
||||
assert result.index.names, ['L1', 'L2']
|
||||
|
||||
def test_set_axis_name_raises(self):
|
||||
s = pd.Series([1])
|
||||
with pytest.raises(ValueError):
|
||||
s._set_axis_name(name='a', axis=1)
|
||||
|
||||
def test_get_numeric_data_preserve_dtype(self):
|
||||
|
||||
# get the numeric data
|
||||
o = Series([1, 2, 3])
|
||||
result = o._get_numeric_data()
|
||||
self._compare(result, o)
|
||||
|
||||
o = Series([1, '2', 3.])
|
||||
result = o._get_numeric_data()
|
||||
expected = Series([], dtype=object, index=pd.Index([], dtype=object))
|
||||
self._compare(result, expected)
|
||||
|
||||
o = Series([True, False, True])
|
||||
result = o._get_numeric_data()
|
||||
self._compare(result, o)
|
||||
|
||||
o = Series([True, False, True])
|
||||
result = o._get_bool_data()
|
||||
self._compare(result, o)
|
||||
|
||||
o = Series(date_range('20130101', periods=3))
|
||||
result = o._get_numeric_data()
|
||||
expected = Series([], dtype='M8[ns]', index=pd.Index([], dtype=object))
|
||||
self._compare(result, expected)
|
||||
|
||||
def test_nonzero_single_element(self):
|
||||
|
||||
# allow single item via bool method
|
||||
s = Series([True])
|
||||
assert s.bool()
|
||||
|
||||
s = Series([False])
|
||||
assert not s.bool()
|
||||
|
||||
# single item nan to raise
|
||||
for s in [Series([np.nan]), Series([pd.NaT]), Series([True]),
|
||||
Series([False])]:
|
||||
pytest.raises(ValueError, lambda: bool(s))
|
||||
|
||||
for s in [Series([np.nan]), Series([pd.NaT])]:
|
||||
pytest.raises(ValueError, lambda: s.bool())
|
||||
|
||||
# multiple bool are still an error
|
||||
for s in [Series([True, True]), Series([False, False])]:
|
||||
pytest.raises(ValueError, lambda: bool(s))
|
||||
pytest.raises(ValueError, lambda: s.bool())
|
||||
|
||||
# single non-bool are an error
|
||||
for s in [Series([1]), Series([0]), Series(['a']), Series([0.0])]:
|
||||
pytest.raises(ValueError, lambda: bool(s))
|
||||
pytest.raises(ValueError, lambda: s.bool())
|
||||
|
||||
def test_metadata_propagation_indiv(self):
|
||||
# check that the metadata matches up on the resulting ops
|
||||
|
||||
o = Series(range(3), range(3))
|
||||
o.name = 'foo'
|
||||
o2 = Series(range(3), range(3))
|
||||
o2.name = 'bar'
|
||||
|
||||
result = o.T
|
||||
self.check_metadata(o, result)
|
||||
|
||||
# resample
|
||||
ts = Series(np.random.rand(1000),
|
||||
index=date_range('20130101', periods=1000, freq='s'),
|
||||
name='foo')
|
||||
result = ts.resample('1T').mean()
|
||||
self.check_metadata(ts, result)
|
||||
|
||||
result = ts.resample('1T').min()
|
||||
self.check_metadata(ts, result)
|
||||
|
||||
result = ts.resample('1T').apply(lambda x: x.sum())
|
||||
self.check_metadata(ts, result)
|
||||
|
||||
_metadata = Series._metadata
|
||||
_finalize = Series.__finalize__
|
||||
Series._metadata = ['name', 'filename']
|
||||
o.filename = 'foo'
|
||||
o2.filename = 'bar'
|
||||
|
||||
def finalize(self, other, method=None, **kwargs):
|
||||
for name in self._metadata:
|
||||
if method == 'concat' and name == 'filename':
|
||||
value = '+'.join([getattr(
|
||||
o, name) for o in other.objs if getattr(o, name, None)
|
||||
])
|
||||
object.__setattr__(self, name, value)
|
||||
else:
|
||||
object.__setattr__(self, name, getattr(other, name, None))
|
||||
|
||||
return self
|
||||
|
||||
Series.__finalize__ = finalize
|
||||
|
||||
result = pd.concat([o, o2])
|
||||
assert result.filename == 'foo+bar'
|
||||
assert result.name is None
|
||||
|
||||
# reset
|
||||
Series._metadata = _metadata
|
||||
Series.__finalize__ = _finalize
|
||||
|
||||
@pytest.mark.skipif(not _XARRAY_INSTALLED or _XARRAY_INSTALLED and
|
||||
LooseVersion(xarray.__version__) <
|
||||
LooseVersion('0.10.0'),
|
||||
reason='xarray >= 0.10.0 required')
|
||||
@pytest.mark.parametrize(
|
||||
"index",
|
||||
['FloatIndex', 'IntIndex',
|
||||
'StringIndex', 'UnicodeIndex',
|
||||
'DateIndex', 'PeriodIndex',
|
||||
'TimedeltaIndex', 'CategoricalIndex'])
|
||||
def test_to_xarray_index_types(self, index):
|
||||
from xarray import DataArray
|
||||
|
||||
index = getattr(tm, 'make{}'.format(index))
|
||||
s = Series(range(6), index=index(6))
|
||||
s.index.name = 'foo'
|
||||
result = s.to_xarray()
|
||||
repr(result)
|
||||
assert len(result) == 6
|
||||
assert len(result.coords) == 1
|
||||
assert_almost_equal(list(result.coords.keys()), ['foo'])
|
||||
assert isinstance(result, DataArray)
|
||||
|
||||
# idempotency
|
||||
assert_series_equal(result.to_series(), s,
|
||||
check_index_type=False,
|
||||
check_categorical=True)
|
||||
|
||||
@td.skip_if_no('xarray', min_version='0.7.0')
|
||||
def test_to_xarray(self):
|
||||
from xarray import DataArray
|
||||
|
||||
s = Series([])
|
||||
s.index.name = 'foo'
|
||||
result = s.to_xarray()
|
||||
assert len(result) == 0
|
||||
assert len(result.coords) == 1
|
||||
assert_almost_equal(list(result.coords.keys()), ['foo'])
|
||||
assert isinstance(result, DataArray)
|
||||
|
||||
s = Series(range(6))
|
||||
s.index.name = 'foo'
|
||||
s.index = pd.MultiIndex.from_product([['a', 'b'], range(3)],
|
||||
names=['one', 'two'])
|
||||
result = s.to_xarray()
|
||||
assert len(result) == 2
|
||||
assert_almost_equal(list(result.coords.keys()), ['one', 'two'])
|
||||
assert isinstance(result, DataArray)
|
||||
assert_series_equal(result.to_series(), s)
|
||||
|
||||
def test_valid_deprecated(self):
|
||||
# GH18800
|
||||
with tm.assert_produces_warning(FutureWarning):
|
||||
pd.Series([]).valid()
|
||||
|
||||
@pytest.mark.parametrize("s", [
|
||||
Series([np.arange(5)]),
|
||||
pd.date_range('1/1/2011', periods=24, freq='H'),
|
||||
pd.Series(range(5), index=pd.date_range("2017", periods=5))
|
||||
])
|
||||
@pytest.mark.parametrize("shift_size", [0, 1, 2])
|
||||
def test_shift_always_copy(self, s, shift_size):
|
||||
# GH22397
|
||||
assert s.shift(shift_size) is not s
|
||||
|
||||
@pytest.mark.parametrize("move_by_freq", [
|
||||
pd.Timedelta('1D'),
|
||||
pd.Timedelta('1M'),
|
||||
])
|
||||
def test_datetime_shift_always_copy(self, move_by_freq):
|
||||
# GH22397
|
||||
s = pd.Series(range(5), index=pd.date_range("2017", periods=5))
|
||||
assert s.shift(freq=move_by_freq) is not s
|
||||
Reference in New Issue
Block a user