title stringlengths 1 185 | diff stringlengths 0 32.2M | body stringlengths 0 123k ⌀ | url stringlengths 57 58 | created_at stringlengths 20 20 | closed_at stringlengths 20 20 | merged_at stringlengths 20 20 ⌀ | updated_at stringlengths 20 20 |
|---|---|---|---|---|---|---|---|
BUG: Ignore versionadded directive when checking for periods at docstring end | diff --git a/pandas/tests/scripts/test_validate_docstrings.py b/pandas/tests/scripts/test_validate_docstrings.py
index 1d35d5d30bba3..8156db6902e20 100644
--- a/pandas/tests/scripts/test_validate_docstrings.py
+++ b/pandas/tests/scripts/test_validate_docstrings.py
@@ -193,6 +193,27 @@ def contains(self, pat, case=True, na=np.nan):
"""
pass
+ def mode(self, axis, numeric_only):
+ """
+ Ensure sphinx directives don't affect checks for trailing periods.
+
+ Parameters
+ ----------
+ axis : str
+ Sentence ending in period, followed by single directive.
+
+ .. versionchanged:: 0.1.2
+
+ numeric_only : boolean
+ Sentence ending in period, followed by multiple directives.
+
+ .. versionadded:: 0.1.2
+ .. deprecated:: 0.00.0
+ A multiline description,
+ which spans another line.
+ """
+ pass
+
class BadGenericDocStrings(object):
"""Everything here has a bad docstring
@@ -374,6 +395,31 @@ def no_description_period(self, kind):
Doesn't end with a dot
"""
+ def no_description_period_with_directive(self, kind):
+ """
+ Forgets to add a period, and also includes a directive.
+
+ Parameters
+ ----------
+ kind : str
+ Doesn't end with a dot
+
+ .. versionadded:: 0.00.0
+ """
+
+ def no_description_period_with_directives(self, kind):
+ """
+ Forgets to add a period, and also includes multiple directives.
+
+ Parameters
+ ----------
+ kind : str
+ Doesn't end with a dot
+
+ .. versionchanged:: 0.00.0
+ .. deprecated:: 0.00.0
+ """
+
def parameter_capitalization(self, kind):
"""
Forgets to capitalize the description.
@@ -495,7 +541,7 @@ def test_good_class(self):
@pytest.mark.parametrize("func", [
'plot', 'sample', 'random_letters', 'sample_values', 'head', 'head1',
- 'contains'])
+ 'contains', 'mode'])
def test_good_functions(self, func):
assert validate_one(self._import_path( # noqa: F821
klass='GoodDocStrings', func=func)) == 0
@@ -531,6 +577,8 @@ def test_bad_generic_functions(self, func):
'Parameter "kind: str" has no type')),
('BadParameters', 'no_description_period',
('Parameter "kind" description should finish with "."',)),
+ ('BadParameters', 'no_description_period_with_directive',
+ ('Parameter "kind" description should finish with "."',)),
('BadParameters', 'parameter_capitalization',
('Parameter "kind" description should start with a capital letter',)),
pytest.param('BadParameters', 'blank_lines', ('No error yet?',),
diff --git a/scripts/validate_docstrings.py b/scripts/validate_docstrings.py
index cdea2d8b83abd..83bb382480eaa 100755
--- a/scripts/validate_docstrings.py
+++ b/scripts/validate_docstrings.py
@@ -42,6 +42,7 @@
PRIVATE_CLASSES = ['NDFrame', 'IndexOpsMixin']
+DIRECTIVES = ['versionadded', 'versionchanged', 'deprecated']
def _load_obj(obj_name):
@@ -234,7 +235,14 @@ def parameter_type(self, param):
return self.doc_parameters[param][0]
def parameter_desc(self, param):
- return self.doc_parameters[param][1]
+ desc = self.doc_parameters[param][1]
+ # Find and strip out any sphinx directives
+ for directive in DIRECTIVES:
+ full_directive = '.. {}'.format(directive)
+ if full_directive in desc:
+ # Only retain any description before the directive
+ desc = desc[:desc.index(full_directive)]
+ return desc
@property
def see_also(self):
| Will ignore the `versionadded` directive when checking for `'.'` at the end of descriptions.
- [x] closes #22405
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22423 | 2018-08-19T18:52:41Z | 2018-08-23T16:04:04Z | 2018-08-23T16:04:04Z | 2018-08-23T17:57:57Z |
DOC: fix Dataframe.to_records examples | diff --git a/ci/doctests.sh b/ci/doctests.sh
index 04b3e14a7120a..fee33a0f93f40 100755
--- a/ci/doctests.sh
+++ b/ci/doctests.sh
@@ -21,7 +21,7 @@ if [ "$DOCTEST" ]; then
# DataFrame / Series docstrings
pytest --doctest-modules -v pandas/core/frame.py \
- -k"-assign -axes -combine -isin -itertuples -join -nlargest -nsmallest -nunique -pivot_table -quantile -query -reindex -reindex_axis -replace -round -set_index -stack -to_dict -to_records -to_stata -transform"
+ -k"-assign -axes -combine -isin -itertuples -join -nlargest -nsmallest -nunique -pivot_table -quantile -query -reindex -reindex_axis -replace -round -set_index -stack -to_dict -to_stata -transform"
if [ $? -ne "0" ]; then
RET=1
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 7a10fb1023806..409a722017e72 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1337,14 +1337,15 @@ def to_records(self, index=True, convert_datetime64=None):
"""
Convert DataFrame to a NumPy record array.
- Index will be put in the 'index' field of the record array if
+ Index will be included as the first field of the record array if
requested.
Parameters
----------
- index : boolean, default True
- Include index in resulting record array, stored in 'index' field.
- convert_datetime64 : boolean, default None
+ index : bool, default True
+ Include index in resulting record array, stored in 'index'
+ field or using the index label, if set.
+ convert_datetime64 : bool, default None
.. deprecated:: 0.23.0
Whether to convert the index to datetime.datetime if it is a
@@ -1352,7 +1353,9 @@ def to_records(self, index=True, convert_datetime64=None):
Returns
-------
- y : numpy.recarray
+ numpy.recarray
+ NumPy ndarray with the DataFrame labels as fields and each row
+ of the DataFrame as entries.
See Also
--------
@@ -1374,31 +1377,20 @@ def to_records(self, index=True, convert_datetime64=None):
rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
dtype=[('index', 'O'), ('A', '<i8'), ('B', '<f8')])
+ If the DataFrame index has no label then the recarray field name
+ is set to 'index'. If the index has a label then this is used as the
+ field name:
+
+ >>> df.index = df.index.rename("I")
+ >>> df.to_records()
+ rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
+ dtype=[('I', 'O'), ('A', '<i8'), ('B', '<f8')])
+
The index can be excluded from the record array:
>>> df.to_records(index=False)
rec.array([(1, 0.5 ), (2, 0.75)],
dtype=[('A', '<i8'), ('B', '<f8')])
-
- By default, timestamps are converted to `datetime.datetime`:
-
- >>> df.index = pd.date_range('2018-01-01 09:00', periods=2, freq='min')
- >>> df
- A B
- 2018-01-01 09:00:00 1 0.50
- 2018-01-01 09:01:00 2 0.75
- >>> df.to_records()
- rec.array([(datetime.datetime(2018, 1, 1, 9, 0), 1, 0.5 ),
- (datetime.datetime(2018, 1, 1, 9, 1), 2, 0.75)],
- dtype=[('index', 'O'), ('A', '<i8'), ('B', '<f8')])
-
- The timestamp conversion can be disabled so NumPy's datetime64
- data type is used instead:
-
- >>> df.to_records(convert_datetime64=False)
- rec.array([('2018-01-01T09:00:00.000000000', 1, 0.5 ),
- ('2018-01-01T09:01:00.000000000', 2, 0.75)],
- dtype=[('index', '<M8[ns]'), ('A', '<i8'), ('B', '<f8')])
"""
if convert_datetime64 is not None:
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
Fixed the examples of Dataframe.to_records related to timestamp conversion following the changes in default behaviour made in pull request #18902. As requested in issue #18160. | https://api.github.com/repos/pandas-dev/pandas/pulls/22419 | 2018-08-19T10:26:32Z | 2018-08-21T12:10:39Z | 2018-08-21T12:10:38Z | 2018-08-21T13:14:11Z |
Remove weird comment in parse_dates.py | diff --git a/pandas/tests/io/parser/parse_dates.py b/pandas/tests/io/parser/parse_dates.py
index 1bf055854de88..903439d2d2292 100644
--- a/pandas/tests/io/parser/parse_dates.py
+++ b/pandas/tests/io/parser/parse_dates.py
@@ -365,7 +365,7 @@ def test_parse_tz_aware(self):
assert stamp.minute == 39
try:
assert result.index.tz is pytz.utc
- except AssertionError: # hello Yaroslav
+ except AssertionError:
arr = result.index.to_pydatetime()
result = tools.to_datetime(arr, utc=True)[0]
assert stamp.minute == result.minute
| Was added back in #12915...not sure why I did that. 😕 | https://api.github.com/repos/pandas-dev/pandas/pulls/22418 | 2018-08-19T09:44:14Z | 2018-08-19T10:48:48Z | 2018-08-19T10:48:48Z | 2018-08-19T12:08:38Z |
DEPR: Rename reps to repeats in Series.repeat | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 8c528e9b2e9f0..b37261ea79f21 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -517,6 +517,7 @@ Removal of prior version deprecations/changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- The ``LongPanel`` and ``WidePanel`` classes have been removed (:issue:`10892`)
+- :meth:`Series.repeat` has renamed the ``reps`` argument to ``repeats`` (:issue:`14645`)
- Several private functions were removed from the (non-public) module ``pandas.core.common`` (:issue:`22001`)
- Removal of the previously deprecated module ``pandas.core.datetools`` (:issue:`14105`, :issue:`14094`)
-
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 2e6270e8739ae..66e572a3c8c59 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1011,7 +1011,6 @@ def _set_values(self, key, value):
self._data = self._data.setitem(indexer=key, value=value)
self._maybe_update_cacher()
- @deprecate_kwarg(old_arg_name='reps', new_arg_name='repeats')
def repeat(self, repeats, *args, **kwargs):
"""
Repeat elements of an Series. Refer to `numpy.ndarray.repeat`
diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py
index 0b6470fcd107d..3a8b84cd53087 100644
--- a/pandas/tests/series/test_analytics.py
+++ b/pandas/tests/series/test_analytics.py
@@ -1344,10 +1344,6 @@ def test_repeat(self):
exp = Series(s.values.repeat(5), index=s.index.values.repeat(5))
assert_series_equal(reps, exp)
- with tm.assert_produces_warning(FutureWarning):
- result = s.repeat(reps=5)
- assert_series_equal(result, exp)
-
to_rep = [2, 3, 4]
reps = s.repeat(to_rep)
exp = Series(s.values.repeat(to_rep),
| Title is self-explanatory.
xref #14645.
| https://api.github.com/repos/pandas-dev/pandas/pulls/22417 | 2018-08-19T07:17:57Z | 2018-08-20T10:37:44Z | 2018-08-20T10:37:43Z | 2018-08-20T18:12:23Z |
.ne fails if comparing a list of columns containing column name 'dtype' #22383 | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index ce629816a14c3..50387c3d98e8f 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1474,6 +1474,7 @@ Interval
Indexing
^^^^^^^^
+- Bug in :meth:`DataFrame.ne` fails if columns contain column name "dtype" (:issue:`22383`)
- The traceback from a ``KeyError`` when asking ``.loc`` for a single missing label is now shorter and more clear (:issue:`21557`)
- :class:`PeriodIndex` now emits a ``KeyError`` when a malformed string is looked up, which is consistent with the behavior of :class:`DatetimeIndex` (:issue:`22803`)
- When ``.ix`` is asked for a missing integer label in a :class:`MultiIndex` with a first level of integer type, it now raises a ``KeyError``, consistently with the case of a flat :class:`Int64Index`, rather than falling back to positional indexing (:issue:`21593`)
diff --git a/pandas/core/computation/expressions.py b/pandas/core/computation/expressions.py
index d44fae624a91c..a91ef7592a36d 100644
--- a/pandas/core/computation/expressions.py
+++ b/pandas/core/computation/expressions.py
@@ -10,6 +10,8 @@
import numpy as np
+from pandas.core.dtypes.generic import ABCDataFrame
+
import pandas.core.common as com
from pandas.core.computation.check import _NUMEXPR_INSTALLED
from pandas.core.config import get_option
@@ -160,12 +162,12 @@ def _where_numexpr(cond, a, b):
def _has_bool_dtype(x):
try:
- return x.dtype == bool
- except AttributeError:
- try:
+ if isinstance(x, ABCDataFrame):
return 'bool' in x.dtypes
- except AttributeError:
- return isinstance(x, (bool, np.bool_))
+ else:
+ return x.dtype == bool
+ except AttributeError:
+ return isinstance(x, (bool, np.bool_))
def _bool_arith_check(op_str, a, b, not_allowed=frozenset(('/', '//', '**')),
diff --git a/pandas/tests/test_expressions.py b/pandas/tests/test_expressions.py
index 4a61ce930cbab..cc5ae9b15ba9e 100644
--- a/pandas/tests/test_expressions.py
+++ b/pandas/tests/test_expressions.py
@@ -443,3 +443,19 @@ def test_bool_ops_warn_on_arithmetic(self):
r = f(df, True)
e = fe(df, True)
tm.assert_frame_equal(r, e)
+
+ @pytest.mark.parametrize("test_input,expected", [
+ (DataFrame([[0, 1, 2, 'aa'], [0, 1, 2, 'aa']],
+ columns=['a', 'b', 'c', 'dtype']),
+ DataFrame([[False, False], [False, False]],
+ columns=['a', 'dtype'])),
+ (DataFrame([[0, 3, 2, 'aa'], [0, 4, 2, 'aa'], [0, 1, 1, 'bb']],
+ columns=['a', 'b', 'c', 'dtype']),
+ DataFrame([[False, False], [False, False],
+ [False, False]], columns=['a', 'dtype'])),
+ ])
+ def test_bool_ops_column_name_dtype(self, test_input, expected):
+ # GH 22383 - .ne fails if columns containing column name 'dtype'
+ result = test_input.loc[:, ['a', 'dtype']].ne(
+ test_input.loc[:, ['a', 'dtype']])
+ assert_frame_equal(result, expected)
| hello, this is my first pr in open source.
so , i think some things have problem.
if this pr has problem , tell me. i will fix again.
this issue occur Dataframe has column defined 'dtype' when execute .ne function.
i asked some advice which way is more better.
i) when make dataframe instance column name is dtype, make exception.
ii) make exception in ne function.
i receive answer try first. so i try to modifiy _has_bool_dtype function.
- [x] closes #22383
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22416 | 2018-08-19T06:53:34Z | 2018-12-31T13:19:05Z | 2018-12-31T13:19:05Z | 2018-12-31T14:44:40Z |
DEPR: Error with ambiguous groupby strings | diff --git a/doc/source/groupby.rst b/doc/source/groupby.rst
index 45e449d081fb0..23d783ef832a9 100644
--- a/doc/source/groupby.rst
+++ b/doc/source/groupby.rst
@@ -106,9 +106,8 @@ consider the following ``DataFrame``:
.. versionadded:: 0.20
A string passed to ``groupby`` may refer to either a column or an index level.
- If a string matches both a column name and an index level name then a warning is
- issued and the column takes precedence. This will result in an ambiguity error
- in a future version.
+ If a string matches both a column name and an index level name, a
+ ``ValueError`` will be raised.
.. ipython:: python
diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 8c528e9b2e9f0..348f8f24b8574 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -519,6 +519,7 @@ Removal of prior version deprecations/changes
- The ``LongPanel`` and ``WidePanel`` classes have been removed (:issue:`10892`)
- Several private functions were removed from the (non-public) module ``pandas.core.common`` (:issue:`22001`)
- Removal of the previously deprecated module ``pandas.core.datetools`` (:issue:`14105`, :issue:`14094`)
+- Strings passed into :meth:`DataFrame.groupby` that refer to both column and index levels will raise a ``ValueError`` (:issue:`14432`)
-
.. _whatsnew_0240.performance:
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 7a10fb1023806..eaf890e96eac7 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -4401,7 +4401,6 @@ def sort_values(self, by, axis=0, ascending=True, inplace=False,
kind='quicksort', na_position='last'):
inplace = validate_bool_kwarg(inplace, 'inplace')
axis = self._get_axis_number(axis)
- stacklevel = 2 # Number of stack levels from df.sort_values
if not isinstance(by, list):
by = [by]
@@ -4413,8 +4412,7 @@ def sort_values(self, by, axis=0, ascending=True, inplace=False,
keys = []
for x in by:
- k = self._get_label_or_level_values(x, axis=axis,
- stacklevel=stacklevel)
+ k = self._get_label_or_level_values(x, axis=axis)
keys.append(k)
indexer = lexsort_indexer(keys, orders=ascending,
na_position=na_position)
@@ -4423,8 +4421,7 @@ def sort_values(self, by, axis=0, ascending=True, inplace=False,
from pandas.core.sorting import nargsort
by = by[0]
- k = self._get_label_or_level_values(by, axis=axis,
- stacklevel=stacklevel)
+ k = self._get_label_or_level_values(by, axis=axis)
if isinstance(ascending, (tuple, list)):
ascending = ascending[0]
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 9bdf34113ccf0..0e5204fcd6524 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1412,14 +1412,12 @@ def _is_label_or_level_reference(self, key, axis=0):
return (self._is_level_reference(key, axis=axis) or
self._is_label_reference(key, axis=axis))
- def _check_label_or_level_ambiguity(self, key, axis=0, stacklevel=1):
+ def _check_label_or_level_ambiguity(self, key, axis=0):
"""
- Check whether `key` matches both a level of the input `axis` and a
- label of the other axis and raise a ``FutureWarning`` if this is the
- case.
+ Check whether `key` is ambiguous.
- Note: This method will be altered to raise an ambiguity exception in
- a future version.
+ By ambiguous, we mean that it matches both a level of the input
+ `axis` and a label of the other axis.
Parameters
----------
@@ -1427,18 +1425,10 @@ def _check_label_or_level_ambiguity(self, key, axis=0, stacklevel=1):
label or level name
axis: int, default 0
Axis that levels are associated with (0 for index, 1 for columns)
- stacklevel: int, default 1
- Stack level used when a FutureWarning is raised (see below).
-
- Returns
- -------
- ambiguous: bool
Raises
------
- FutureWarning
- if `key` is ambiguous. This will become an ambiguity error in a
- future version
+ ValueError: `key` is ambiguous
"""
axis = self._get_axis_number(axis)
@@ -1464,21 +1454,15 @@ def _check_label_or_level_ambiguity(self, key, axis=0, stacklevel=1):
('an', 'index'))
msg = ("'{key}' is both {level_article} {level_type} level and "
- "{label_article} {label_type} label.\n"
- "Defaulting to {label_type}, but this will raise an "
- "ambiguity error in a future version"
+ "{label_article} {label_type} label, which is ambiguous."
).format(key=key,
level_article=level_article,
level_type=level_type,
label_article=label_article,
label_type=label_type)
+ raise ValueError(msg)
- warnings.warn(msg, FutureWarning, stacklevel=stacklevel + 1)
- return True
- else:
- return False
-
- def _get_label_or_level_values(self, key, axis=0, stacklevel=1):
+ def _get_label_or_level_values(self, key, axis=0):
"""
Return a 1-D array of values associated with `key`, a label or level
from the given `axis`.
@@ -1497,8 +1481,6 @@ def _get_label_or_level_values(self, key, axis=0, stacklevel=1):
Label or level name.
axis: int, default 0
Axis that levels are associated with (0 for index, 1 for columns)
- stacklevel: int, default 1
- Stack level used when a FutureWarning is raised (see below).
Returns
-------
@@ -1524,8 +1506,7 @@ def _get_label_or_level_values(self, key, axis=0, stacklevel=1):
.format(type=type(self)))
if self._is_label_reference(key, axis=axis):
- self._check_label_or_level_ambiguity(key, axis=axis,
- stacklevel=stacklevel + 1)
+ self._check_label_or_level_ambiguity(key, axis=axis)
values = self.xs(key, axis=other_axes[0])._values
elif self._is_level_reference(key, axis=axis):
values = self.axes[axis].get_level_values(key)._values
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 35d4a024a4e6c..e7144fb1d2932 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -571,9 +571,7 @@ def is_in_obj(gpr):
elif is_in_axis(gpr): # df.groupby('name')
if gpr in obj:
if validate:
- stacklevel = 5 # Number of stack levels from df.groupby
- obj._check_label_or_level_ambiguity(
- gpr, stacklevel=stacklevel)
+ obj._check_label_or_level_ambiguity(gpr)
in_axis, name, gpr = True, gpr, obj[gpr]
exclusions.append(name)
elif obj._is_level_reference(gpr):
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 3989c70c9d13f..c4305136accb1 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -811,7 +811,6 @@ def _get_merge_keys(self):
left_drop = []
left, right = self.left, self.right
- stacklevel = 5 # Number of stack levels from df.merge
is_lkey = lambda x: is_array_like(x) and len(x) == len(left)
is_rkey = lambda x: is_array_like(x) and len(x) == len(right)
@@ -837,8 +836,7 @@ def _get_merge_keys(self):
else:
if rk is not None:
right_keys.append(
- right._get_label_or_level_values(
- rk, stacklevel=stacklevel))
+ right._get_label_or_level_values(rk))
join_names.append(rk)
else:
# work-around for merge_asof(right_index=True)
@@ -848,8 +846,7 @@ def _get_merge_keys(self):
if not is_rkey(rk):
if rk is not None:
right_keys.append(
- right._get_label_or_level_values(
- rk, stacklevel=stacklevel))
+ right._get_label_or_level_values(rk))
else:
# work-around for merge_asof(right_index=True)
right_keys.append(right.index)
@@ -862,8 +859,7 @@ def _get_merge_keys(self):
else:
right_keys.append(rk)
if lk is not None:
- left_keys.append(left._get_label_or_level_values(
- lk, stacklevel=stacklevel))
+ left_keys.append(left._get_label_or_level_values(lk))
join_names.append(lk)
else:
# work-around for merge_asof(left_index=True)
@@ -875,8 +871,7 @@ def _get_merge_keys(self):
left_keys.append(k)
join_names.append(None)
else:
- left_keys.append(left._get_label_or_level_values(
- k, stacklevel=stacklevel))
+ left_keys.append(left._get_label_or_level_values(k))
join_names.append(k)
if isinstance(self.right.index, MultiIndex):
right_keys = [lev._values.take(lab)
@@ -890,8 +885,7 @@ def _get_merge_keys(self):
right_keys.append(k)
join_names.append(None)
else:
- right_keys.append(right._get_label_or_level_values(
- k, stacklevel=stacklevel))
+ right_keys.append(right._get_label_or_level_values(k))
join_names.append(k)
if isinstance(self.left.index, MultiIndex):
left_keys = [lev._values.take(lab)
diff --git a/pandas/tests/frame/test_sort_values_level_as_str.py b/pandas/tests/frame/test_sort_values_level_as_str.py
index 3b4eadfce81cd..2653cc77b27a4 100644
--- a/pandas/tests/frame/test_sort_values_level_as_str.py
+++ b/pandas/tests/frame/test_sort_values_level_as_str.py
@@ -1,7 +1,7 @@
import numpy as np
import pytest
-from pandas import DataFrame, Index
+from pandas import DataFrame
from pandas.errors import PerformanceWarning
from pandas.util import testing as tm
from pandas.util.testing import assert_frame_equal
@@ -93,34 +93,3 @@ def test_sort_column_level_and_index_label(
assert_frame_equal(result, expected)
else:
assert_frame_equal(result, expected)
-
-
-def test_sort_values_column_index_level_precedence():
- # GH 14353, when a string passed as the `by` parameter
- # matches a column and an index level the column takes
- # precedence
-
- # Construct DataFrame with index and column named 'idx'
- idx = Index(np.arange(1, 7), name='idx')
- df = DataFrame({'A': np.arange(11, 17),
- 'idx': np.arange(6, 0, -1)},
- index=idx)
-
- # Sorting by 'idx' should sort by the idx column and raise a
- # FutureWarning
- with tm.assert_produces_warning(FutureWarning):
- result = df.sort_values(by='idx')
-
- # This should be equivalent to sorting by the 'idx' index level in
- # descending order
- expected = df.sort_index(level='idx', ascending=False)
- assert_frame_equal(result, expected)
-
- # Perform same test with MultiIndex
- df_multi = df.set_index('A', append=True)
-
- with tm.assert_produces_warning(FutureWarning):
- result = df_multi.sort_values(by='idx')
-
- expected = df_multi.sort_index(level='idx', ascending=False)
- assert_frame_equal(result, expected)
diff --git a/pandas/tests/generic/test_label_or_level_utils.py b/pandas/tests/generic/test_label_or_level_utils.py
index 8e4d28fc796df..4d78270c856ae 100644
--- a/pandas/tests/generic/test_label_or_level_utils.py
+++ b/pandas/tests/generic/test_label_or_level_utils.py
@@ -166,31 +166,24 @@ def test_is_label_or_level_reference_panel_error(panel):
def test_check_label_or_level_ambiguity_df(df_ambig, axis):
# Transpose frame if axis == 1
- if axis in {1, 'columns'}:
+ if axis in {1, "columns"}:
df_ambig = df_ambig.T
- # df_ambig has both an on-axis level and off-axis label named L1
- # Therefore L1 is ambiguous
- with tm.assert_produces_warning(FutureWarning,
- clear=True) as w:
+ 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"
- assert df_ambig._check_label_or_level_ambiguity('L1', axis=axis)
- warning_msg = w[0].message.args[0]
- if axis in {0, 'index'}:
- assert warning_msg.startswith("'L1' is both an index level "
- "and a column label")
- else:
- assert warning_msg.startswith("'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 tm.assert_raises_regex(ValueError, 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
- # No warning should be raised
- with tm.assert_produces_warning(None):
- assert not df_ambig._check_label_or_level_ambiguity('L2', 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
- with tm.assert_produces_warning(None):
- assert not df_ambig._is_level_reference('L3', 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
@@ -200,17 +193,15 @@ 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
- with tm.assert_produces_warning(None):
- assert not s._check_label_or_level_ambiguity('L1', axis=0)
- assert not s._check_label_or_level_ambiguity('L2', axis=0)
+ 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
- with tm.assert_produces_warning(None):
- assert not s._check_label_or_level_ambiguity('L1', axis=0)
- assert not s._check_label_or_level_ambiguity('L2', axis=0)
- assert not s._check_label_or_level_ambiguity('L3', axis=0)
+ 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):
@@ -229,7 +220,7 @@ def test_check_label_or_level_ambiguity_panel_error(panel):
.format(type=type(panel)))
with tm.assert_raises_regex(NotImplementedError, msg):
- panel._check_label_or_level_ambiguity('L1', axis=0)
+ panel._check_label_or_level_ambiguity("L1", axis=0)
# Test _get_label_or_level_values
@@ -241,19 +232,16 @@ def assert_label_values(frame, labels, axis):
else:
expected = frame.loc[label]._values
- result = frame._get_label_or_level_values(label, axis=axis,
- stacklevel=2)
+ 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'}:
+ if axis in {0, "index"}:
expected = frame.index.get_level_values(level=level)._values
else:
- expected = (frame.columns
- .get_level_values(level=level)
- ._values)
+ expected = frame.columns.get_level_values(level=level)._values
result = frame._get_label_or_level_values(level, axis=axis)
assert array_equivalent(expected, result)
@@ -281,18 +269,11 @@ def test_get_label_or_level_values_df_ambig(df_ambig, axis):
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 is ambiguous but will default to label
- with tm.assert_produces_warning(FutureWarning):
- assert_label_values(df_ambig, ['L1'], axis=axis)
-
- # df has an on-axis level named L2 and it is not ambiguous
- with tm.assert_produces_warning(None):
- assert_level_values(df_ambig, ['L2'], axis=axis)
+ # 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
- with tm.assert_produces_warning(None):
- assert_label_values(df_ambig, ['L3'], 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):
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index d021396a7acb3..14a09b83e5b7c 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -568,18 +568,9 @@ def test_as_index():
'B': [101, 205]},
columns=['cat', 'A', 'B'])
- for name in [None, 'X', 'B', 'cat']:
+ for name in [None, 'X', 'B']:
df.index = Index(list("abc"), name=name)
-
- if name in group_columns and name in df.index.names:
- with tm.assert_produces_warning(FutureWarning,
- check_stacklevel=False):
- result = df.groupby(
- group_columns, as_index=False, observed=True).sum()
-
- else:
- result = df.groupby(
- group_columns, as_index=False, observed=True).sum()
+ result = df.groupby(group_columns, as_index=False, observed=True).sum()
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/groupby/test_index_as_string.py b/pandas/tests/groupby/test_index_as_string.py
index 9fe677664049e..6afa63c31e3b6 100644
--- a/pandas/tests/groupby/test_index_as_string.py
+++ b/pandas/tests/groupby/test_index_as_string.py
@@ -3,7 +3,6 @@
import numpy as np
from pandas.util.testing import assert_frame_equal, assert_series_equal
-import pandas.util.testing as tm
@pytest.fixture(params=[['inner'], ['inner', 'outer']])
@@ -67,50 +66,3 @@ def test_grouper_index_level_as_string_series(series, levels):
# Compute and check result
result = series.groupby(levels).mean()
assert_series_equal(result, expected)
-
-
-@pytest.mark.parametrize('key_strs,key_groupers,level_groupers', [
- ('inner', # Index name
- pd.Grouper(key='inner'),
- pd.Grouper(level='inner'),
- ),
- (['inner'], # List of index name
- [pd.Grouper(key='inner')],
- [pd.Grouper(level='inner')]
- ),
- (['B', 'inner'], # Column and index
- ['B', pd.Grouper(key='inner')],
- ['B', pd.Grouper(level='inner')]
- ),
- (['inner', 'B'], # Index and column
- [pd.Grouper(key='inner'), 'B'],
- [pd.Grouper(level='inner'), 'B'])])
-def test_grouper_column_index_level_precedence(frame,
- key_strs,
- key_groupers,
- level_groupers):
-
- # GH 5677, when a string passed as the `by` parameter
- # matches a column and an index level the column takes
- # precedence and a FutureWarning is raised
-
- # Add 'inner' column to frame
- # (frame already has an 'inner' index)
- frame['inner'] = [1, 1, 1, 1, 1, 1]
-
- # Performing a groupby with strings should produce warning
- with tm.assert_produces_warning(FutureWarning):
- result = frame.groupby(key_strs).mean()
-
- # Grouping with key Grouper should produce the same result and no warning
- with tm.assert_produces_warning(False):
- expected = frame.groupby(key_groupers).mean()
-
- assert_frame_equal(result, expected)
-
- # Grouping with level Grouper should produce a different result but
- # still no warning
- with tm.assert_produces_warning(False):
- not_expected = frame.groupby(level_groupers).mean()
-
- assert not result.index.equals(not_expected.index)
diff --git a/pandas/tests/reshape/merge/test_merge_index_as_string.py b/pandas/tests/reshape/merge/test_merge_index_as_string.py
index a27fcf41681e6..12d9483af8761 100644
--- a/pandas/tests/reshape/merge/test_merge_index_as_string.py
+++ b/pandas/tests/reshape/merge/test_merge_index_as_string.py
@@ -2,7 +2,6 @@
import pytest
from pandas import DataFrame
-from pandas.util import testing as tm
from pandas.util.testing import assert_frame_equal
@@ -176,38 +175,3 @@ def test_join_indexes_and_columns_on(df1, df2, left_index, join_type):
lsuffix='_x', rsuffix='_y')
assert_frame_equal(result, expected, check_like=True)
-
-
-def test_merge_index_column_precedence(df1, df2):
-
- # Construct left_df with both an index and a column named 'outer'.
- # We make this 'outer' column equal to the 'inner' column so that we
- # can verify that the correct values are used by the merge operation
- left_df = df1.set_index('outer')
- left_df['outer'] = left_df['inner']
-
- # Construct right_df with an index level named 'outer'
- right_df = df2.set_index('outer')
-
- # Construct expected result.
- # The 'outer' column from left_df is chosen and the resulting
- # frame has no index levels
- expected = (left_df.reset_index(level='outer', drop=True)
- .merge(right_df.reset_index(), on=['outer', 'inner']))
-
- # Merge left_df and right_df on 'outer' and 'inner'
- # 'outer' for left_df should refer to the 'outer' column, not the
- # 'outer' index level and a FutureWarning should be raised
- with tm.assert_produces_warning(FutureWarning):
- result = left_df.merge(right_df, on=['outer', 'inner'])
-
- # Check results
- assert_frame_equal(result, expected)
-
- # Perform the same using the left_on and right_on parameters
- with tm.assert_produces_warning(FutureWarning):
- result = left_df.merge(right_df,
- left_on=['outer', 'inner'],
- right_on=['outer', 'inner'])
-
- assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index e66758f58b1d4..1ee48d0120c7d 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -596,52 +596,6 @@ def _check_output(result, values_col, index=['A', 'B'],
totals = table.loc[('All', ''), item]
assert totals == self.data[item].mean()
- # issue number #8349: pivot_table with margins and dictionary aggfunc
- data = [
- {'JOB': 'Worker', 'NAME': 'Bob', 'YEAR': 2013,
- 'MONTH': 12, 'DAYS': 3, 'SALARY': 17},
- {'JOB': 'Employ', 'NAME':
- 'Mary', 'YEAR': 2013, 'MONTH': 12, 'DAYS': 5, 'SALARY': 23},
- {'JOB': 'Worker', 'NAME': 'Bob', 'YEAR': 2014,
- 'MONTH': 1, 'DAYS': 10, 'SALARY': 100},
- {'JOB': 'Worker', 'NAME': 'Bob', 'YEAR': 2014,
- 'MONTH': 1, 'DAYS': 11, 'SALARY': 110},
- {'JOB': 'Employ', 'NAME': 'Mary', 'YEAR': 2014,
- 'MONTH': 1, 'DAYS': 15, 'SALARY': 200},
- {'JOB': 'Worker', 'NAME': 'Bob', 'YEAR': 2014,
- 'MONTH': 2, 'DAYS': 8, 'SALARY': 80},
- {'JOB': 'Employ', 'NAME': 'Mary', 'YEAR': 2014,
- 'MONTH': 2, 'DAYS': 5, 'SALARY': 190},
- ]
-
- df = DataFrame(data)
-
- df = df.set_index(['JOB', 'NAME', 'YEAR', 'MONTH'], drop=False,
- append=False)
-
- with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
- result = df.pivot_table(index=['JOB', 'NAME'],
- columns=['YEAR', 'MONTH'],
- values=['DAYS', 'SALARY'],
- aggfunc={'DAYS': 'mean', 'SALARY': 'sum'},
- margins=True)
-
- with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
- expected = df.pivot_table(index=['JOB', 'NAME'],
- columns=['YEAR', 'MONTH'],
- values=['DAYS'],
- aggfunc='mean', margins=True)
-
- tm.assert_frame_equal(result['DAYS'], expected['DAYS'])
-
- with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
- expected = df.pivot_table(index=['JOB', 'NAME'],
- columns=['YEAR', 'MONTH'],
- values=['SALARY'],
- aggfunc='sum', margins=True)
-
- tm.assert_frame_equal(result['SALARY'], expected['SALARY'])
-
def test_margins_dtype(self):
# GH 17013
| Title is self-explanatory.
xref #14432. | https://api.github.com/repos/pandas-dev/pandas/pulls/22415 | 2018-08-19T06:53:09Z | 2018-08-22T12:38:58Z | 2018-08-22T12:38:58Z | 2018-08-25T09:12:00Z |
BLD: Install scripts tests only during inplace | diff --git a/pandas/tests/scripts/test_validate_docstrings.py b/pandas/tests/scripts/test_validate_docstrings.py
index 1d35d5d30bba3..cebcbf5a61465 100644
--- a/pandas/tests/scripts/test_validate_docstrings.py
+++ b/pandas/tests/scripts/test_validate_docstrings.py
@@ -448,22 +448,37 @@ class TestValidator(object):
@pytest.fixture(autouse=True, scope="class")
def import_scripts(self):
"""
- Because the scripts directory is above the top level pandas package
- we need to hack sys.path to know where to find that directory for
- import. The below traverses up the file system to find the scripts
- directory, adds to location to sys.path and imports the required
- module into the global namespace before as part of class setup,
- reverting those changes on teardown.
+ Import the validation scripts from the scripts directory.
+
+ Because the scripts directory is above the top level pandas package,
+ we need to modify `sys.path` so that Python knows where to find it.
+
+ The code below traverses up the file system to find the scripts
+ directory, adds the location to `sys.path`, and imports the required
+ module into the global namespace before as part of class setup.
+
+ During teardown, those changes are reverted.
"""
+
up = os.path.dirname
+ global_validate_one = "validate_one"
file_dir = up(os.path.abspath(__file__))
- script_dir = os.path.join(up(up(up(file_dir))), 'scripts')
+
+ script_dir = os.path.join(up(up(up(file_dir))), "scripts")
sys.path.append(script_dir)
- from validate_docstrings import validate_one
- globals()['validate_one'] = validate_one
+
+ try:
+ from validate_docstrings import validate_one
+ globals()[global_validate_one] = validate_one
+ except ImportError:
+ # Import will fail if the pandas installation is not inplace.
+ raise pytest.skip("pandas/scripts directory does not exist")
+
yield
+
+ # Teardown.
sys.path.pop()
- del globals()['validate_one']
+ del globals()[global_validate_one]
def _import_path(self, klass=None, func=None):
"""
| The `scripts` directory is not visible if the installation is not inplace.
Follow-up to #20061.
cc @WillAyd @datapythonista | https://api.github.com/repos/pandas-dev/pandas/pulls/22413 | 2018-08-19T00:31:45Z | 2018-08-21T10:14:33Z | 2018-08-21T10:14:33Z | 2018-08-22T06:47:18Z |
Changes to validate_docstring script to be able to check all docstrings at once | diff --git a/scripts/tests/test_validate_docstrings.py b/scripts/tests/test_validate_docstrings.py
index 00496f771570b..27c63e3ba3a79 100644
--- a/scripts/tests/test_validate_docstrings.py
+++ b/scripts/tests/test_validate_docstrings.py
@@ -1,5 +1,6 @@
import string
import random
+import io
import pytest
import numpy as np
@@ -531,28 +532,36 @@ def _import_path(self, klass=None, func=None):
@capture_stderr
def test_good_class(self):
- assert validate_one(self._import_path(
- klass='GoodDocStrings')) == 0
+ errors = validate_one(self._import_path(
+ klass='GoodDocStrings'))['errors']
+ assert isinstance(errors, list)
+ assert not errors
@capture_stderr
@pytest.mark.parametrize("func", [
'plot', 'sample', 'random_letters', 'sample_values', 'head', 'head1',
'contains', 'mode'])
def test_good_functions(self, func):
- assert validate_one(self._import_path(
- klass='GoodDocStrings', func=func)) == 0
+ errors = validate_one(self._import_path(
+ klass='GoodDocStrings', func=func))['errors']
+ assert isinstance(errors, list)
+ assert not errors
@capture_stderr
def test_bad_class(self):
- assert validate_one(self._import_path(
- klass='BadGenericDocStrings')) > 0
+ errors = validate_one(self._import_path(
+ klass='BadGenericDocStrings'))['errors']
+ assert isinstance(errors, list)
+ assert errors
@capture_stderr
@pytest.mark.parametrize("func", [
'func', 'astype', 'astype1', 'astype2', 'astype3', 'plot', 'method'])
def test_bad_generic_functions(self, func):
- assert validate_one(self._import_path( # noqa:F821
- klass='BadGenericDocStrings', func=func)) > 0
+ errors = validate_one(self._import_path( # noqa:F821
+ klass='BadGenericDocStrings', func=func))['errors']
+ assert isinstance(errors, list)
+ assert errors
@pytest.mark.parametrize("klass,func,msgs", [
# Summary tests
@@ -594,7 +603,82 @@ def test_bad_generic_functions(self, func):
marks=pytest.mark.xfail)
])
def test_bad_examples(self, capsys, klass, func, msgs):
- validate_one(self._import_path(klass=klass, func=func)) # noqa:F821
- err = capsys.readouterr().err
+ result = validate_one(self._import_path(klass=klass, func=func)) # noqa:F821
for msg in msgs:
- assert msg in err
+ assert msg in ' '.join(result['errors'])
+
+
+class ApiItems(object):
+ @property
+ def api_doc(self):
+ return io.StringIO('''
+.. currentmodule:: itertools
+
+Itertools
+---------
+
+Infinite
+~~~~~~~~
+
+.. autosummary::
+
+ cycle
+ count
+
+Finite
+~~~~~~
+
+.. autosummary::
+
+ chain
+
+.. currentmodule:: random
+
+Random
+------
+
+All
+~~~
+
+.. autosummary::
+
+ seed
+ randint
+''')
+
+ @pytest.mark.parametrize('idx,name', [(0, 'itertools.cycle'),
+ (1, 'itertools.count'),
+ (2, 'itertools.chain'),
+ (3, 'random.seed'),
+ (4, 'random.randint')])
+ def test_item_name(self, idx, name):
+ result = list(validate_docstrings.get_api_items(self.api_doc))
+ assert result[idx][0] == name
+
+ @pytest.mark.parametrize('idx,func', [(0, 'cycle'),
+ (1, 'count'),
+ (2, 'chain'),
+ (3, 'seed'),
+ (4, 'randint')])
+ def test_item_function(self, idx, func):
+ result = list(validate_docstrings.get_api_items(self.api_doc))
+ assert callable(result[idx][1])
+ assert result[idx][1].__name__ == func
+
+ @pytest.mark.parametrize('idx,section', [(0, 'Itertools'),
+ (1, 'Itertools'),
+ (2, 'Itertools'),
+ (3, 'Random'),
+ (4, 'Random')])
+ def test_item_section(self, idx, section):
+ result = list(validate_docstrings.get_api_items(self.api_doc))
+ assert result[idx][2] == section
+
+ @pytest.mark.parametrize('idx,subsection', [(0, 'Infinite'),
+ (1, 'Infinite'),
+ (2, 'Finite'),
+ (3, 'All'),
+ (4, 'All')])
+ def test_item_subsection(self, idx, subsection):
+ result = list(validate_docstrings.get_api_items(self.api_doc))
+ assert result[idx][3] == subsection
diff --git a/scripts/validate_docstrings.py b/scripts/validate_docstrings.py
index 790a62b53845b..6588522331433 100755
--- a/scripts/validate_docstrings.py
+++ b/scripts/validate_docstrings.py
@@ -15,7 +15,7 @@
"""
import os
import sys
-import csv
+import json
import re
import functools
import collections
@@ -45,86 +45,188 @@
DIRECTIVES = ['versionadded', 'versionchanged', 'deprecated']
-def _load_obj(obj_name):
- for maxsplit in range(1, obj_name.count('.') + 1):
- # TODO when py3 only replace by: module, *func_parts = ...
- func_name_split = obj_name.rsplit('.', maxsplit)
- module = func_name_split[0]
- func_parts = func_name_split[1:]
- try:
- obj = importlib.import_module(module)
- except ImportError:
- pass
- else:
- continue
+def get_api_items(api_doc_fd):
+ """
+ Yield information about all public API items.
- if 'module' not in locals():
- raise ImportError('No module can be imported '
- 'from "{}"'.format(obj_name))
+ Parse api.rst file from the documentation, and extract all the functions,
+ methods, classes, attributes... This should include all pandas public API.
+
+ Parameters
+ ----------
+ api_doc_fd : file descriptor
+ A file descriptor of the API documentation page, containing the table
+ of contents with all the public API.
+
+ Yields
+ ------
+ name : str
+ The name of the object (e.g. 'pandas.Series.str.upper).
+ func : function
+ The object itself. In most cases this will be a function or method,
+ but it can also be classes, properties, cython objects...
+ section : str
+ The name of the section in the API page where the object item is
+ located.
+ subsection : str
+ The name of the subsection in the API page where the object item is
+ located.
+ """
+ previous_line = current_section = current_subsection = ''
+ position = None
+ for line in api_doc_fd:
+ line = line.strip()
+ if len(line) == len(previous_line):
+ if set(line) == set('-'):
+ current_section = previous_line
+ continue
+ if set(line) == set('~'):
+ current_subsection = previous_line
+ continue
- for part in func_parts:
- obj = getattr(obj, part)
- return obj
+ if line.startswith('.. currentmodule::'):
+ current_module = line.replace('.. currentmodule::', '').strip()
+ continue
+ if line == '.. autosummary::':
+ position = 'autosummary'
+ continue
-def _to_original_callable(obj):
- while True:
- if inspect.isfunction(obj) or inspect.isclass(obj):
- f = inspect.getfile(obj)
- if f.startswith('<') and f.endswith('>'):
- return None
- return obj
- if inspect.ismethod(obj):
- obj = obj.__func__
- elif isinstance(obj, functools.partial):
- obj = obj.func
- elif isinstance(obj, property):
- obj = obj.fget
- else:
- return None
+ if position == 'autosummary':
+ if line == '':
+ position = 'items'
+ continue
+ if position == 'items':
+ if line == '':
+ position = None
+ continue
+ item = line.strip()
+ func = importlib.import_module(current_module)
+ for part in item.split('.'):
+ func = getattr(func, part)
-def _output_header(title, width=80, char='#'):
- full_line = char * width
- side_len = (width - len(title) - 2) // 2
- adj = '' if len(title) % 2 == 0 else ' '
- title_line = '{side} {title}{adj} {side}'.format(side=char * side_len,
- title=title,
- adj=adj)
+ yield ('.'.join([current_module, item]), func,
+ current_section, current_subsection)
- return '\n{full_line}\n{title_line}\n{full_line}\n\n'.format(
- full_line=full_line, title_line=title_line)
+ previous_line = line
class Docstring(object):
- def __init__(self, method_name, method_obj):
- self.method_name = method_name
- self.method_obj = method_obj
- self.raw_doc = method_obj.__doc__ or ''
- self.clean_doc = pydoc.getdoc(self.method_obj)
+ def __init__(self, name):
+ self.name = name
+ obj = self._load_obj(name)
+ self.obj = obj
+ self.code_obj = self._to_original_callable(obj)
+ self.raw_doc = obj.__doc__ or ''
+ self.clean_doc = pydoc.getdoc(obj)
self.doc = NumpyDocString(self.clean_doc)
def __len__(self):
return len(self.raw_doc)
+ @staticmethod
+ def _load_obj(name):
+ """
+ Import Python object from its name as string.
+
+ Parameters
+ ----------
+ name : str
+ Object name to import (e.g. pandas.Series.str.upper)
+
+ Returns
+ -------
+ object
+ Python object that can be a class, method, function...
+
+ Examples
+ --------
+ >>> Docstring._load_obj('pandas.Series')
+ <class 'pandas.core.series.Series'>
+ """
+ for maxsplit in range(1, name.count('.') + 1):
+ # TODO when py3 only replace by: module, *func_parts = ...
+ func_name_split = name.rsplit('.', maxsplit)
+ module = func_name_split[0]
+ func_parts = func_name_split[1:]
+ try:
+ obj = importlib.import_module(module)
+ except ImportError:
+ pass
+ else:
+ continue
+
+ if 'module' not in locals():
+ raise ImportError('No module can be imported '
+ 'from "{}"'.format(name))
+
+ for part in func_parts:
+ obj = getattr(obj, part)
+ return obj
+
+ @staticmethod
+ def _to_original_callable(obj):
+ """
+ Find the Python object that contains the source code ot the object.
+
+ This is useful to find the place in the source code (file and line
+ number) where a docstring is defined. It does not currently work for
+ all cases, but it should help find some (properties...).
+ """
+ while True:
+ if inspect.isfunction(obj) or inspect.isclass(obj):
+ f = inspect.getfile(obj)
+ if f.startswith('<') and f.endswith('>'):
+ return None
+ return obj
+ if inspect.ismethod(obj):
+ obj = obj.__func__
+ elif isinstance(obj, functools.partial):
+ obj = obj.func
+ elif isinstance(obj, property):
+ obj = obj.fget
+ else:
+ return None
+
+ @property
+ def type(self):
+ return type(self.obj).__name__
+
@property
def is_function_or_method(self):
# TODO(py27): remove ismethod
- return (inspect.isfunction(self.method_obj)
- or inspect.ismethod(self.method_obj))
+ return (inspect.isfunction(self.obj)
+ or inspect.ismethod(self.obj))
@property
def source_file_name(self):
- fname = inspect.getsourcefile(self.method_obj)
- if fname:
- fname = os.path.relpath(fname, BASE_PATH)
- return fname
+ """
+ File name where the object is implemented (e.g. pandas/core/frame.py).
+ """
+ try:
+ fname = inspect.getsourcefile(self.code_obj)
+ except TypeError:
+ # In some cases the object is something complex like a cython
+ # object that can't be easily introspected. An it's better to
+ # return the source code file of the object as None, than crash
+ pass
+ else:
+ if fname:
+ fname = os.path.relpath(fname, BASE_PATH)
+ return fname
@property
def source_file_def_line(self):
+ """
+ Number of line where the object is defined in its file.
+ """
try:
- return inspect.getsourcelines(self.method_obj)[-1]
- except OSError:
+ return inspect.getsourcelines(self.code_obj)[-1]
+ except (OSError, TypeError):
+ # In some cases the object is something complex like a cython
+ # object that can't be easily introspected. An it's better to
+ # return the line number as None, than crash
pass
@property
@@ -187,14 +289,14 @@ def doc_parameters(self):
@property
def signature_parameters(self):
- if inspect.isclass(self.method_obj):
- if hasattr(self.method_obj, '_accessors') and (
- self.method_name.split('.')[-1] in
- self.method_obj._accessors):
+ if inspect.isclass(self.obj):
+ if hasattr(self.obj, '_accessors') and (
+ self.name.split('.')[-1] in
+ self.obj._accessors):
# accessor classes have a signature but don't want to show this
return tuple()
try:
- sig = signature(self.method_obj)
+ sig = signature(self.obj)
except (TypeError, ValueError):
# Some objects, mainly in C extensions do not support introspection
# of the signature
@@ -266,7 +368,10 @@ def yields(self):
@property
def method_source(self):
- return inspect.getsource(self.method_obj)
+ try:
+ return inspect.getsource(self.obj)
+ except TypeError:
+ return ''
@property
def first_line_ends_in_dot(self):
@@ -276,9 +381,9 @@ def first_line_ends_in_dot(self):
@property
def deprecated(self):
pattern = re.compile('.. deprecated:: ')
- return (self.method_name.startswith('pandas.Panel') or
- bool(pattern.search(self.summary)) or
- bool(pattern.search(self.extended_summary)))
+ return (self.name.startswith('pandas.Panel')
+ or bool(pattern.search(self.summary))
+ or bool(pattern.search(self.extended_summary)))
@property
def mentioned_private_classes(self):
@@ -291,121 +396,13 @@ def examples_errors(self):
runner = doctest.DocTestRunner(optionflags=flags)
context = {'np': numpy, 'pd': pandas}
error_msgs = ''
- for test in finder.find(self.raw_doc, self.method_name, globs=context):
+ for test in finder.find(self.raw_doc, self.name, globs=context):
f = StringIO()
runner.run(test, out=f.write)
error_msgs += f.getvalue()
return error_msgs
-def get_api_items():
- api_fname = os.path.join(BASE_PATH, 'doc', 'source', 'api.rst')
-
- previous_line = current_section = current_subsection = ''
- position = None
- with open(api_fname) as f:
- for line in f:
- line = line.strip()
- if len(line) == len(previous_line):
- if set(line) == set('-'):
- current_section = previous_line
- continue
- if set(line) == set('~'):
- current_subsection = previous_line
- continue
-
- if line.startswith('.. currentmodule::'):
- current_module = line.replace('.. currentmodule::', '').strip()
- continue
-
- if line == '.. autosummary::':
- position = 'autosummary'
- continue
-
- if position == 'autosummary':
- if line == '':
- position = 'items'
- continue
-
- if position == 'items':
- if line == '':
- position = None
- continue
- item = line.strip()
- func = importlib.import_module(current_module)
- for part in item.split('.'):
- func = getattr(func, part)
-
- yield ('.'.join([current_module, item]), func,
- current_section, current_subsection)
-
- previous_line = line
-
-
-def _csv_row(func_name, func_obj, section, subsection, in_api, seen={}):
- obj_type = type(func_obj).__name__
- original_callable = _to_original_callable(func_obj)
- if original_callable is None:
- return [func_name, obj_type] + [''] * 12, ''
- else:
- doc = Docstring(func_name, original_callable)
- key = doc.source_file_name, doc.source_file_def_line
- shared_code = seen.get(key, '')
- return [func_name,
- obj_type,
- in_api,
- int(doc.deprecated),
- section,
- subsection,
- doc.source_file_name,
- doc.source_file_def_line,
- doc.github_url,
- int(bool(doc.summary)),
- int(bool(doc.extended_summary)),
- int(doc.correct_parameters),
- int(bool(doc.examples)),
- shared_code], key
-
-
-def validate_all():
- writer = csv.writer(sys.stdout)
- cols = ('Function or method',
- 'Type',
- 'In API doc',
- 'Is deprecated',
- 'Section',
- 'Subsection',
- 'File',
- 'Code line',
- 'GitHub link',
- 'Has summary',
- 'Has extended summary',
- 'Parameters ok',
- 'Has examples',
- 'Shared code with')
- writer.writerow(cols)
- seen = {}
- api_items = list(get_api_items())
- for func_name, func, section, subsection in api_items:
- row, key = _csv_row(func_name, func, section, subsection,
- in_api=1, seen=seen)
- seen[key] = func_name
- writer.writerow(row)
-
- api_item_names = set(list(zip(*api_items))[0])
- for class_ in (pandas.Series, pandas.DataFrame, pandas.Panel):
- for member in inspect.getmembers(class_):
- func_name = 'pandas.{}.{}'.format(class_.__name__, member[0])
- if (not member[0].startswith('_') and
- func_name not in api_item_names):
- func = _load_obj(func_name)
- row, key = _csv_row(func_name, func, section='', subsection='',
- in_api=0)
- writer.writerow(row)
-
- return 0
-
-
def validate_one(func_name):
"""
Validate the docstring for the given func_name
@@ -413,18 +410,15 @@ def validate_one(func_name):
Parameters
----------
func_name : function
- Function whose docstring will be evaluated
+ Function whose docstring will be evaluated (e.g. pandas.read_csv).
Returns
-------
- int
- The number of errors found in the `func_name` docstring
+ dict
+ A dictionary containing all the information obtained from validating
+ the docstring.
"""
- func_obj = _load_obj(func_name)
- doc = Docstring(func_name, func_obj)
-
- sys.stderr.write(_output_header('Docstring ({})'.format(func_name)))
- sys.stderr.write('{}\n'.format(doc.clean_doc))
+ doc = Docstring(func_name)
errs = []
wrns = []
@@ -449,8 +443,10 @@ def validate_one(func_name):
errs.append('Summary does not start with a capital letter')
if doc.summary[-1] != '.':
errs.append('Summary does not end with a period')
- if (doc.is_function_or_method and
- doc.summary.split(' ')[0][-1] == 's'):
+ if doc.summary != doc.summary.lstrip():
+ errs.append('Summary contains heading whitespaces.')
+ elif (doc.is_function_or_method
+ and doc.summary.split(' ')[0][-1] == 's'):
errs.append('Summary must start with infinitive verb, '
'not third person (e.g. use "Generate" instead of '
'"Generates")')
@@ -517,42 +513,109 @@ def validate_one(func_name):
if examples_errs:
errs.append('Examples do not pass tests')
- sys.stderr.write(_output_header('Validation'))
- if errs:
- sys.stderr.write('Errors found:\n')
- for err in errs:
- sys.stderr.write('\t{}\n'.format(err))
- if wrns:
- sys.stderr.write('Warnings found:\n')
- for wrn in wrns:
- sys.stderr.write('\t{}\n'.format(wrn))
+ return {'type': doc.type,
+ 'docstring': doc.clean_doc,
+ 'deprecated': doc.deprecated,
+ 'file': doc.source_file_name,
+ 'file_line': doc.source_file_def_line,
+ 'github_link': doc.github_url,
+ 'errors': errs,
+ 'warnings': wrns,
+ 'examples_errors': examples_errs}
- if not errs:
- sys.stderr.write('Docstring for "{}" correct. :)\n'.format(func_name))
- if examples_errs:
- sys.stderr.write(_output_header('Doctests'))
- sys.stderr.write(examples_errs)
+def validate_all():
+ """
+ Execute the validation of all docstrings, and return a dict with the
+ results.
+
+ Returns
+ -------
+ dict
+ A dictionary with an item for every function/method... containing
+ all the validation information.
+ """
+ result = {}
+ seen = {}
+
+ # functions from the API docs
+ api_doc_fname = os.path.join(BASE_PATH, 'doc', 'source', 'api.rst')
+ with open(api_doc_fname) as f:
+ api_items = list(get_api_items(f))
+ for func_name, func_obj, section, subsection in api_items:
+ doc_info = validate_one(func_name)
+ result[func_name] = doc_info
- return len(errs)
+ shared_code_key = doc_info['file'], doc_info['file_line']
+ shared_code = seen.get(shared_code_key, '')
+ result[func_name].update({'in_api': True,
+ 'section': section,
+ 'subsection': subsection,
+ 'shared_code_with': shared_code})
+ seen[shared_code_key] = func_name
-def main(function):
- if function is None:
- return validate_all()
+ # functions from introspecting Series, DataFrame and Panel
+ api_item_names = set(list(zip(*api_items))[0])
+ for class_ in (pandas.Series, pandas.DataFrame, pandas.Panel):
+ for member in inspect.getmembers(class_):
+ func_name = 'pandas.{}.{}'.format(class_.__name__, member[0])
+ if (not member[0].startswith('_')
+ and func_name not in api_item_names):
+ doc_info = validate_one(func_name)
+ result[func_name] = doc_info
+ result[func_name]['in_api'] = False
+
+ return result
+
+
+def main(func_name, fd):
+ def header(title, width=80, char='#'):
+ full_line = char * width
+ side_len = (width - len(title) - 2) // 2
+ adj = '' if len(title) % 2 == 0 else ' '
+ title_line = '{side} {title}{adj} {side}'.format(side=char * side_len,
+ title=title,
+ adj=adj)
+
+ return '\n{full_line}\n{title_line}\n{full_line}\n\n'.format(
+ full_line=full_line, title_line=title_line)
+
+ if func_name is None:
+ json_doc = validate_all()
+ fd.write(json.dumps(json_doc))
else:
- return validate_one(function)
+ doc_info = validate_one(func_name)
+
+ fd.write(header('Docstring ({})'.format(func_name)))
+ fd.write('{}\n'.format(doc_info['docstring']))
+ fd.write(header('Validation'))
+ if doc_info['errors']:
+ fd.write('Errors found:\n')
+ for err in doc_info['errors']:
+ fd.write('\t{}\n'.format(err))
+ if doc_info['warnings']:
+ fd.write('Warnings found:\n')
+ for wrn in doc_info['warnings']:
+ fd.write('\t{}\n'.format(wrn))
+
+ if not doc_info['errors']:
+ fd.write('Docstring for "{}" correct. :)\n'.format(func_name))
+
+ if doc_info['examples_errors']:
+ fd.write(header('Doctests'))
+ fd.write(doc_info['examples_errors'])
if __name__ == '__main__':
+ func_help = ('function or method to validate (e.g. pandas.DataFrame.head) '
+ 'if not provided, all docstrings are validated and returned '
+ 'as JSON')
argparser = argparse.ArgumentParser(
description='validate pandas docstrings')
argparser.add_argument('function',
nargs='?',
default=None,
- help=('function or method to validate '
- '(e.g. pandas.DataFrame.head) '
- 'if not provided, all docstrings '
- 'are validated'))
+ help=func_help)
args = argparser.parse_args()
- sys.exit(main(args.function))
+ sys.exit(main(args.function, sys.stdout))
| - [ ] closes #xxxx
- [X] tests added / passed
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
This PR includes two main changes:
1. When calling the `scripts/validate_docstrings.py` script without parameters, it returns a JSON with the validation of all docstrings.
2. Refactoring the structure of the code, mainly to be able to implement 1.
The previous behavior when calling the script with parameters was to generate a csv with basic information about each docstring (not the full validation, but basic things like whether sections existed, or the file where the function is defined).
The main change is that `validate_one()` now returns the results as Python objects, instead of printing directly to the console. Few other changes to make the code cleaner are implemented (mainly moving `_load_obj` and `_original_callable` inside the `Docstring` class.
| https://api.github.com/repos/pandas-dev/pandas/pulls/22408 | 2018-08-18T13:28:48Z | 2018-10-13T18:20:49Z | 2018-10-13T18:20:49Z | 2018-10-13T18:43:10Z |
CLN: dedent else part of Series._get_with | diff --git a/pandas/core/series.py b/pandas/core/series.py
index 4b92c6a029254..91be06dac0b47 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -829,47 +829,46 @@ def _get_with(self, key):
elif isinstance(key, ABCDataFrame):
raise TypeError('Indexing a Series with DataFrame is not '
'supported, use the appropriate DataFrame column')
- else:
- if isinstance(key, tuple):
- try:
- return self._get_values_tuple(key)
- except Exception:
- if len(key) == 1:
- key = key[0]
- if isinstance(key, slice):
- return self._get_values(key)
- raise
+ elif isinstance(key, tuple):
+ try:
+ return self._get_values_tuple(key)
+ except Exception:
+ if len(key) == 1:
+ key = key[0]
+ if isinstance(key, slice):
+ return self._get_values(key)
+ raise
- # pragma: no cover
- if not isinstance(key, (list, np.ndarray, Series, Index)):
- key = list(key)
+ # pragma: no cover
+ if not isinstance(key, (list, np.ndarray, Series, Index)):
+ key = list(key)
- if isinstance(key, Index):
- key_type = key.inferred_type
- else:
- key_type = lib.infer_dtype(key)
+ if isinstance(key, Index):
+ key_type = key.inferred_type
+ else:
+ key_type = lib.infer_dtype(key)
- if key_type == 'integer':
- if self.index.is_integer() or self.index.is_floating():
- return self.loc[key]
- else:
- return self._get_values(key)
- elif key_type == 'boolean':
- return self._get_values(key)
+ if key_type == 'integer':
+ if self.index.is_integer() or self.index.is_floating():
+ return self.loc[key]
else:
- try:
- # handle the dup indexing case (GH 4246)
- if isinstance(key, (list, tuple)):
- return self.loc[key]
+ return self._get_values(key)
+ elif key_type == 'boolean':
+ return self._get_values(key)
- return self.reindex(key)
- except Exception:
- # [slice(0, 5, None)] will break if you convert to ndarray,
- # e.g. as requested by np.median
- # hack
- if isinstance(key[0], slice):
- return self._get_values(key)
- raise
+ try:
+ # handle the dup indexing case (GH 4246)
+ if isinstance(key, (list, tuple)):
+ return self.loc[key]
+
+ return self.reindex(key)
+ except Exception:
+ # [slice(0, 5, None)] will break if you convert to ndarray,
+ # e.g. as requested by np.median
+ # hack
+ if isinstance(key[0], slice):
+ return self._get_values(key)
+ raise
def _get_values_tuple(self, key):
# mpl hackaround
| - [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
There is a gigantic and unneeded ``else`` clause in ``Series._get_with`` and it makes the code hard to read.
This PR removes the else clause and dedents its content one level. This helps readability.
| https://api.github.com/repos/pandas-dev/pandas/pulls/22406 | 2018-08-17T22:16:15Z | 2018-08-20T10:41:54Z | 2018-08-20T10:41:54Z | 2018-10-27T08:19:10Z |
Updating `DataFrame.mode` docstring. | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 81d5c112885ec..b7c21b0f64a97 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7248,38 +7248,82 @@ def _get_agg_axis(self, axis_num):
def mode(self, axis=0, numeric_only=False, dropna=True):
"""
- Gets the mode(s) of each element along the axis selected. Adds a row
- for each mode per label, fills in gaps with nan.
+ Get the mode(s) of each element along the selected axis.
- Note that there could be multiple values returned for the selected
- axis (when more than one item share the maximum frequency), which is
- the reason why a dataframe is returned. If you want to impute missing
- values with the mode in a dataframe ``df``, you can just do this:
- ``df.fillna(df.mode().iloc[0])``
+ The mode of a set of values is the value that appears most often.
+ It can be multiple values.
Parameters
----------
axis : {0 or 'index', 1 or 'columns'}, default 0
+ The axis to iterate over while searching for the mode:
+
* 0 or 'index' : get mode of each column
* 1 or 'columns' : get mode of each row
- numeric_only : boolean, default False
- if True, only apply to numeric columns
- dropna : boolean, default True
+ numeric_only : bool, default False
+ If True, only apply to numeric columns.
+ dropna : bool, default True
Don't consider counts of NaN/NaT.
.. versionadded:: 0.24.0
Returns
-------
- modes : DataFrame (sorted)
+ DataFrame
+ The modes of each column or row.
+
+ See Also
+ --------
+ Series.mode : Return the highest frequency value in a Series.
+ Series.value_counts : Return the counts of values in a Series.
Examples
--------
- >>> df = pd.DataFrame({'A': [1, 2, 1, 2, 1, 2, 3]})
+ >>> df = pd.DataFrame([('bird', 2, 2),
+ ... ('mammal', 4, np.nan),
+ ... ('arthropod', 8, 0),
+ ... ('bird', 2, np.nan)],
+ ... index=('falcon', 'horse', 'spider', 'ostrich'),
+ ... columns=('species', 'legs', 'wings'))
+ >>> df
+ species legs wings
+ falcon bird 2 2.0
+ horse mammal 4 NaN
+ spider arthropod 8 0.0
+ ostrich bird 2 NaN
+
+ By default, missing values are not considered, and the mode of wings
+ are both 0 and 2. The second row of species and legs contains ``NaN``,
+ because they have only one mode, but the DataFrame has two rows.
+
>>> df.mode()
- A
- 0 1
- 1 2
+ species legs wings
+ 0 bird 2.0 0.0
+ 1 NaN NaN 2.0
+
+ Setting ``dropna=False`` ``NaN`` values are considered and they can be
+ the mode (like for wings).
+
+ >>> df.mode(dropna=False)
+ species legs wings
+ 0 bird 2 NaN
+
+ Setting ``numeric_only=True``, only the mode of numeric columns is
+ computed, and columns of other types are ignored.
+
+ >>> df.mode(numeric_only=True)
+ legs wings
+ 0 2.0 0.0
+ 1 NaN 2.0
+
+ To compute the mode over columns and not rows, use the axis parameter:
+
+ >>> df.mode(axis='columns', numeric_only=True)
+ 0 1
+ falcon 2.0 NaN
+ horse 4.0 NaN
+ spider 0.0 8.0
+ ostrich 2.0 NaN
"""
data = self if not numeric_only else self._get_numeric_data()
| Supersedes #20241 (source branch does not exist anymore). | https://api.github.com/repos/pandas-dev/pandas/pulls/22404 | 2018-08-17T20:31:39Z | 2018-09-30T04:22:37Z | 2018-09-30T04:22:37Z | 2018-09-30T04:22:37Z |
Bug in DataFrame.drop_duplicates for empty DataFrame throws error | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index cf12759c051fc..9a77e3accb3dc 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -711,7 +711,7 @@ Reshaping
- Bug in :func:`get_dummies` with Unicode attributes in Python 2 (:issue:`22084`)
- Bug in :meth:`DataFrame.replace` raises ``RecursionError`` when replacing empty lists (:issue:`22083`)
- Bug in :meth:`Series.replace` and meth:`DataFrame.replace` when dict is used as the `to_replace` value and one key in the dict is is another key's value, the results were inconsistent between using integer key and using string key (:issue:`20656`)
--
+- Bug in :meth:`DataFrame.drop_duplicates` for empty ``DataFrame`` which incorrectly raises an error (:issue:`20516`)
Build Changes
^^^^^^^^^^^^^
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 78ad9728800d6..0e1463693a7fc 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -4335,6 +4335,9 @@ def drop_duplicates(self, subset=None, keep='first', inplace=False):
-------
deduplicated : DataFrame
"""
+ if self.empty:
+ return self.copy()
+
inplace = validate_bool_kwarg(inplace, 'inplace')
duplicated = self.duplicated(subset, keep=keep)
@@ -4369,6 +4372,9 @@ def duplicated(self, subset=None, keep='first'):
from pandas.core.sorting import get_group_index
from pandas._libs.hashtable import duplicated_int64, _SIZE_HINT_LIMIT
+ if self.empty:
+ return Series()
+
def f(vals):
labels, shape = algorithms.factorize(
vals, size_hint=min(len(self), _SIZE_HINT_LIMIT))
diff --git a/pandas/tests/frame/test_duplicates.py b/pandas/tests/frame/test_duplicates.py
index 940692ec5b46a..3478d66b919a6 100644
--- a/pandas/tests/frame/test_duplicates.py
+++ b/pandas/tests/frame/test_duplicates.py
@@ -263,6 +263,23 @@ def test_drop_duplicates_tuple():
tm.assert_frame_equal(result, expected)
+@pytest.mark.parametrize('df', [
+ DataFrame(),
+ DataFrame(columns=[]),
+ DataFrame(columns=['A', 'B', 'C']),
+ DataFrame(index=[]),
+ DataFrame(index=['A', 'B', 'C'])
+])
+def test_drop_duplicates_empty(df):
+ # GH 20516
+ result = df.drop_duplicates()
+ tm.assert_frame_equal(result, df)
+
+ result = df.copy()
+ result.drop_duplicates(inplace=True)
+ tm.assert_frame_equal(result, df)
+
+
def test_drop_duplicates_NA():
# none
df = DataFrame({'A': [None, None, 'foo', 'bar',
| - [x] closes #20516
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry | https://api.github.com/repos/pandas-dev/pandas/pulls/22394 | 2018-08-17T02:56:14Z | 2018-08-23T13:13:24Z | 2018-08-23T13:13:24Z | 2018-08-23T13:25:40Z |
Fix arithmetic errors with timedelta64 dtypes | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 317b8b8878308..e87e2d356d393 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -581,12 +581,14 @@ Datetimelike
- Bug in :class:`DataFrame` comparisons against ``Timestamp``-like objects failing to raise ``TypeError`` for inequality checks with mismatched types (:issue:`8932`,:issue:`22163`)
- Bug in :class:`DataFrame` with mixed dtypes including ``datetime64[ns]`` incorrectly raising ``TypeError`` on equality comparisons (:issue:`13128`,:issue:`22163`)
- Bug in :meth:`DataFrame.eq` comparison against ``NaT`` incorrectly returning ``True`` or ``NaN`` (:issue:`15697`,:issue:`22163`)
-- Bug in :class:`DataFrame` with ``timedelta64[ns]`` dtype division by ``Timedelta``-like scalar incorrectly returning ``timedelta64[ns]`` dtype instead of ``float64`` dtype (:issue:`20088`,:issue:`22163`)
--
Timedelta
^^^^^^^^^
-
+- Bug in :class:`DataFrame` with ``timedelta64[ns]`` dtype division by ``Timedelta``-like scalar incorrectly returning ``timedelta64[ns]`` dtype instead of ``float64`` dtype (:issue:`20088`,:issue:`22163`)
+- Bug in adding a :class:`Index` with object dtype to a :class:`Series` with ``timedelta64[ns]`` dtype incorrectly raising (:issue:`22390`)
+- Bug in multiplying a :class:`Series` with numeric dtype against a ``timedelta`` object (:issue:`22390`)
+- Bug in :class:`Series` with numeric dtype when adding or subtracting an an array or ``Series`` with ``timedelta64`` dtype (:issue:`22390`)
+- Bug in :class:`Index` with numeric dtype when multiplying or dividing an array with dtype ``timedelta64`` (:issue:`22390`)
-
-
-
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 34cfa0b23f082..2a0f164887543 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -122,6 +122,14 @@ def index_arithmetic_method(self, other):
elif isinstance(other, ABCTimedeltaIndex):
# Defer to subclass implementation
return NotImplemented
+ elif isinstance(other, np.ndarray) and is_timedelta64_dtype(other):
+ # GH#22390; wrap in Series for op, this will in turn wrap in
+ # TimedeltaIndex, but will correctly raise TypeError instead of
+ # NullFrequencyError for add/sub ops
+ from pandas import Series
+ other = Series(other)
+ out = op(self, other)
+ return Index(out, name=self.name)
other = self._validate_for_numeric_binop(other, op)
@@ -2689,6 +2697,8 @@ def argsort(self, *args, **kwargs):
return result.argsort(*args, **kwargs)
def __add__(self, other):
+ if isinstance(other, (ABCSeries, ABCDataFrame)):
+ return NotImplemented
return Index(np.array(self) + other)
def __radd__(self, other):
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 939ec0b79ac6b..981bfddeadac1 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -8,6 +8,7 @@
from pandas.core.dtypes.common import (
is_integer,
is_scalar,
+ is_timedelta64_dtype,
is_int64_dtype)
from pandas.core.dtypes.generic import ABCSeries, ABCTimedeltaIndex
@@ -596,6 +597,9 @@ def _evaluate_numeric_binop(self, other):
# GH#19333 is_integer evaluated True on timedelta64,
# so we need to catch these explicitly
return op(self._int64index, other)
+ elif is_timedelta64_dtype(other):
+ # Must be an np.ndarray; GH#22390
+ return op(self._int64index, other)
other = self._validate_for_numeric_binop(other, op)
attrs = self._get_attributes_dict()
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index ddd82de2da5fc..b25809bf074f7 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -107,6 +107,37 @@ def _maybe_match_name(a, b):
return None
+def maybe_upcast_for_op(obj):
+ """
+ Cast non-pandas objects to pandas types to unify behavior of arithmetic
+ and comparison operations.
+
+ Parameters
+ ----------
+ obj: object
+
+ Returns
+ -------
+ out : object
+
+ Notes
+ -----
+ Be careful to call this *after* determining the `name` attribute to be
+ attached to the result of the arithmetic operation.
+ """
+ if type(obj) is datetime.timedelta:
+ # GH#22390 cast up to Timedelta to rely on Timedelta
+ # implementation; otherwise operation against numeric-dtype
+ # raises TypeError
+ return pd.Timedelta(obj)
+ elif isinstance(obj, np.ndarray) and is_timedelta64_dtype(obj):
+ # GH#22390 Unfortunately we need to special-case right-hand
+ # timedelta64 dtypes because numpy casts integer dtypes to
+ # timedelta64 when operating with timedelta64
+ return pd.TimedeltaIndex(obj)
+ return obj
+
+
# -----------------------------------------------------------------------------
# Reversed Operations not available in the stdlib operator module.
# Defining these instead of using lambdas allows us to reference them by name.
@@ -1222,6 +1253,7 @@ def wrapper(left, right):
left, right = _align_method_SERIES(left, right)
res_name = get_op_result_name(left, right)
+ right = maybe_upcast_for_op(right)
if is_categorical_dtype(left):
raise TypeError("{typ} cannot perform the operation "
@@ -1244,6 +1276,16 @@ def wrapper(left, right):
index=left.index, name=res_name,
dtype=result.dtype)
+ elif is_timedelta64_dtype(right) and not is_scalar(right):
+ # i.e. exclude np.timedelta64 object
+ # Note: we cannot use dispatch_to_index_op because
+ # that may incorrectly raise TypeError when we
+ # should get NullFrequencyError
+ result = op(pd.Index(left), right)
+ return construct_result(left, result,
+ index=left.index, name=res_name,
+ dtype=result.dtype)
+
lvalues = left.values
rvalues = right
if isinstance(rvalues, ABCSeries):
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index 85a0a8dffc55f..9ede1a62aaf2e 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -2,7 +2,6 @@
# Arithmetc tests for DataFrame/Series/Index/Array classes that should
# behave identically.
# Specifically for numeric dtypes
-from datetime import timedelta
from decimal import Decimal
import operator
from collections import Iterable
@@ -47,7 +46,61 @@ def test_operator_series_comparison_zerorank(self):
# ------------------------------------------------------------------
# Numeric dtypes Arithmetic with Timedelta Scalar
-class TestNumericArraylikeArithmeticWithTimedeltaScalar(object):
+class TestNumericArraylikeArithmeticWithTimedeltaLike(object):
+
+ # TODO: also check name retentention
+ @pytest.mark.parametrize('box_cls', [np.array, pd.Index, pd.Series])
+ @pytest.mark.parametrize('left', [
+ pd.RangeIndex(10, 40, 10)] + [cls([10, 20, 30], dtype=dtype)
+ for dtype in ['i1', 'i2', 'i4', 'i8',
+ 'u1', 'u2', 'u4', 'u8',
+ 'f2', 'f4', 'f8']
+ for cls in [pd.Series, pd.Index]],
+ ids=lambda x: type(x).__name__ + str(x.dtype))
+ def test_mul_td64arr(self, left, box_cls):
+ # GH#22390
+ right = np.array([1, 2, 3], dtype='m8[s]')
+ right = box_cls(right)
+
+ expected = pd.TimedeltaIndex(['10s', '40s', '90s'])
+ if isinstance(left, pd.Series) or box_cls is pd.Series:
+ expected = pd.Series(expected)
+
+ result = left * right
+ tm.assert_equal(result, expected)
+
+ result = right * left
+ tm.assert_equal(result, expected)
+
+ # TODO: also check name retentention
+ @pytest.mark.parametrize('box_cls', [np.array, pd.Index, pd.Series])
+ @pytest.mark.parametrize('left', [
+ pd.RangeIndex(10, 40, 10)] + [cls([10, 20, 30], dtype=dtype)
+ for dtype in ['i1', 'i2', 'i4', 'i8',
+ 'u1', 'u2', 'u4', 'u8',
+ 'f2', 'f4', 'f8']
+ for cls in [pd.Series, pd.Index]],
+ ids=lambda x: type(x).__name__ + str(x.dtype))
+ def test_div_td64arr(self, left, box_cls):
+ # GH#22390
+ right = np.array([10, 40, 90], dtype='m8[s]')
+ right = box_cls(right)
+
+ expected = pd.TimedeltaIndex(['1s', '2s', '3s'])
+ if isinstance(left, pd.Series) or box_cls is pd.Series:
+ expected = pd.Series(expected)
+
+ result = right / left
+ tm.assert_equal(result, expected)
+
+ result = right // left
+ tm.assert_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ left / right
+
+ with pytest.raises(TypeError):
+ left // right
# TODO: de-duplicate with test_numeric_arr_mul_tdscalar
def test_ops_series(self):
@@ -71,11 +124,6 @@ def test_ops_series(self):
ids=lambda x: type(x).__name__)
def test_numeric_arr_mul_tdscalar(self, scalar_td, index, box):
# GH#19333
-
- if (box in [Series, pd.DataFrame] and
- type(scalar_td) is timedelta and index.dtype == 'f8'):
- raise pytest.xfail(reason="Cannot multiply timedelta by float")
-
expected = pd.timedelta_range('1 days', '10 days')
index = tm.box_expected(index, box)
@@ -99,12 +147,6 @@ def test_numeric_arr_mul_tdscalar(self, scalar_td, index, box):
Timedelta(days=1).to_pytimedelta()],
ids=lambda x: type(x).__name__)
def test_numeric_arr_rdiv_tdscalar(self, scalar_td, index, box):
-
- if box is Series and type(scalar_td) is timedelta:
- raise pytest.xfail(reason="TODO: Figure out why this case fails")
- if box is pd.DataFrame and isinstance(scalar_td, timedelta):
- raise pytest.xfail(reason="TODO: Figure out why this case fails")
-
expected = TimedeltaIndex(['1 Day', '12 Hours'])
index = tm.box_expected(index, box)
diff --git a/pandas/tests/test_arithmetic.py b/pandas/tests/test_arithmetic.py
index ae067faba7929..def7a8be95fc8 100644
--- a/pandas/tests/test_arithmetic.py
+++ b/pandas/tests/test_arithmetic.py
@@ -573,19 +573,8 @@ def test_td64arr_add_int_series_invalid(self, box, tdser):
with pytest.raises(err):
tdser + Series([2, 3, 4])
- @pytest.mark.parametrize('box', [
- pd.Index,
- pytest.param(Series,
- marks=pytest.mark.xfail(reason="GH#19123 integer "
- "interpreted as "
- "nanoseconds",
- strict=True)),
- pytest.param(pd.DataFrame,
- marks=pytest.mark.xfail(reason="Attempts to broadcast "
- "incorrectly",
- strict=True, raises=ValueError))
- ], ids=lambda x: x.__name__)
- def test_td64arr_radd_int_series_invalid(self, box, tdser):
+ def test_td64arr_radd_int_series_invalid(self, box_df_fail, tdser):
+ box = box_df_fail # Tries to broadcast incorrectly
tdser = tm.box_expected(tdser, box)
err = TypeError if box is not pd.Index else NullFrequencyError
with pytest.raises(err):
@@ -605,11 +594,11 @@ def test_td64arr_sub_int_series_invalid(self, box, tdser):
with pytest.raises(err):
tdser - Series([2, 3, 4])
- @pytest.mark.xfail(reason='GH#19123 integer interpreted as nanoseconds',
- strict=True)
- def test_td64arr_rsub_int_series_invalid(self, box, tdser):
+ def test_td64arr_rsub_int_series_invalid(self, box_df_fail, tdser):
+ box = box_df_fail # Tries to broadcast incorrectly
tdser = tm.box_expected(tdser, box)
- with pytest.raises(TypeError):
+ err = TypeError if box is not pd.Index else NullFrequencyError
+ with pytest.raises(err):
Series([2, 3, 4]) - tdser
@pytest.mark.parametrize('box', [
@@ -671,14 +660,6 @@ def test_td64arr_add_sub_numeric_scalar_invalid(self, box, scalar, tdser):
with pytest.raises(err):
scalar - tdser
- @pytest.mark.parametrize('box', [
- pd.Index,
- Series,
- pytest.param(pd.DataFrame,
- marks=pytest.mark.xfail(reason="Tries to broadcast "
- "incorrectly",
- strict=True, raises=ValueError))
- ], ids=lambda x: x.__name__)
@pytest.mark.parametrize('dtype', ['int64', 'int32', 'int16',
'uint64', 'uint32', 'uint16', 'uint8',
'float64', 'float32', 'float16'])
@@ -688,10 +669,9 @@ def test_td64arr_add_sub_numeric_scalar_invalid(self, box, scalar, tdser):
Series([1, 2, 3])
# TODO: Add DataFrame in here?
], ids=lambda x: type(x).__name__)
- def test_td64arr_add_sub_numeric_arr_invalid(self, box, vec, dtype, tdser):
- if type(vec) is Series and not dtype.startswith('float'):
- pytest.xfail(reason='GH#19123 integer interpreted as nanos')
-
+ def test_td64arr_add_sub_numeric_arr_invalid(self, box_df_fail, vec,
+ dtype, tdser):
+ box = box_df_fail # tries to broadcast incorrectly
tdser = tm.box_expected(tdser, box)
err = TypeError
if box is pd.Index and not dtype.startswith('float'):
@@ -865,9 +845,6 @@ def test_td64arr_sub_NaT(self, box):
def test_td64arr_add_timedeltalike(self, delta, box):
# only test adding/sub offsets as + is now numeric
- if box is pd.DataFrame and isinstance(delta, pd.DateOffset):
- pytest.xfail(reason="Returns object dtype instead of m8[ns]")
-
rng = timedelta_range('1 days', '10 days')
expected = timedelta_range('1 days 02:00:00', '10 days 02:00:00',
freq='D')
@@ -879,9 +856,6 @@ def test_td64arr_add_timedeltalike(self, delta, box):
def test_td64arr_sub_timedeltalike(self, delta, box):
# only test adding/sub offsets as - is now numeric
- if box is pd.DataFrame and isinstance(delta, pd.DateOffset):
- pytest.xfail(reason="Returns object dtype instead of m8[ns]")
-
rng = timedelta_range('1 days', '10 days')
expected = timedelta_range('0 days 22:00:00', '9 days 22:00:00')
@@ -929,11 +903,7 @@ def test_timedelta64_operations_with_DateOffset(self):
@pytest.mark.parametrize('box', [
pd.Index,
- pytest.param(Series,
- marks=pytest.mark.xfail(reason="Index fails to return "
- "NotImplemented on "
- "reverse op",
- strict=True)),
+ Series,
pytest.param(pd.DataFrame,
marks=pytest.mark.xfail(reason="Tries to broadcast "
"incorrectly",
@@ -1021,23 +991,12 @@ def test_td64arr_sub_offset_array(self, box_df_fail):
res = tdi - other
tm.assert_equal(res, expected)
- @pytest.mark.parametrize('box', [
- pd.Index,
- pytest.param(Series,
- marks=pytest.mark.xfail(reason="object dtype Series "
- "fails to return "
- "NotImplemented",
- strict=True, raises=TypeError)),
- pytest.param(pd.DataFrame,
- marks=pytest.mark.xfail(reason="tries to broadcast "
- "incorrectly",
- strict=True, raises=ValueError))
- ], ids=lambda x: x.__name__)
@pytest.mark.parametrize('names', [(None, None, None),
('foo', 'bar', None),
('foo', 'foo', 'foo')])
- def test_td64arr_with_offset_series(self, names, box):
+ def test_td64arr_with_offset_series(self, names, box_df_fail):
# GH#18849
+ box = box_df_fail # tries to broadcast incorrectly
box2 = Series if box is pd.Index else box
tdi = TimedeltaIndex(['1 days 00:00:00', '3 days 04:00:00'],
@@ -1132,9 +1091,6 @@ def test_td64arr_mul_int(self, box):
tm.assert_equal(result, idx)
def test_td64arr_mul_tdlike_scalar_raises(self, delta, box):
- if box is pd.DataFrame and not isinstance(delta, pd.DateOffset):
- pytest.xfail(reason="returns m8[ns] instead of raising")
-
rng = timedelta_range('1 days', '10 days', name='foo')
rng = tm.box_expected(rng, box)
with pytest.raises(TypeError):
| Kind of surprising, but I don't see any Issues for these bugs. Might be because many of them were found after parametrizing arithmetic tests, so instead of Issues we had xfails.
xref #20088
xref #22163
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22390 | 2018-08-16T20:35:04Z | 2018-08-23T10:37:07Z | 2018-08-23T10:37:07Z | 2018-08-23T15:46:31Z |
Support NDFrame.shift with EAs | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index d7feb6e547b22..a0f12179970c4 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -445,6 +445,7 @@ ExtensionType Changes
- Added ``ExtensionDtype._is_numeric`` for controlling whether an extension dtype is considered numeric (:issue:`22290`).
- The ``ExtensionArray`` constructor, ``_from_sequence`` now take the keyword arg ``copy=False`` (:issue:`21185`)
- Bug in :meth:`Series.get` for ``Series`` using ``ExtensionArray`` and integer index (:issue:`21257`)
+- :meth:`~Series.shift` now dispatches to :meth:`ExtensionArray.shift` (:issue:`22386`)
- :meth:`Series.combine()` works correctly with :class:`~pandas.api.extensions.ExtensionArray` inside of :class:`Series` (:issue:`20825`)
- :meth:`Series.combine()` with scalar argument now works for any function type (:issue:`21248`)
- :meth:`Series.astype` and :meth:`DataFrame.astype` now dispatch to :meth:`ExtensionArray.astype` (:issue:`21185:`).
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index cb82625e818a1..7bf13fb2fecc0 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -59,6 +59,10 @@ class ExtensionArray(object):
* factorize / _values_for_factorize
* argsort / _values_for_argsort
+ The remaining methods implemented on this class should be performant,
+ as they only compose abstract methods. Still, a more efficient
+ implementation may be available, and these methods can be overridden.
+
This class does not inherit from 'abc.ABCMeta' for performance reasons.
Methods and properties required by the interface raise
``pandas.errors.AbstractMethodError`` and no ``register`` method is
@@ -400,6 +404,40 @@ def dropna(self):
return self[~self.isna()]
+ def shift(self, periods=1):
+ # type: (int) -> ExtensionArray
+ """
+ Shift values by desired number.
+
+ Newly introduced missing values are filled with
+ ``self.dtype.na_value``.
+
+ .. versionadded:: 0.24.0
+
+ Parameters
+ ----------
+ periods : int, default 1
+ The number of periods to shift. Negative values are allowed
+ for shifting backwards.
+
+ Returns
+ -------
+ shifted : ExtensionArray
+ """
+ # Note: this implementation assumes that `self.dtype.na_value` can be
+ # stored in an instance of your ExtensionArray with `self.dtype`.
+ if periods == 0:
+ return self.copy()
+ empty = self._from_sequence([self.dtype.na_value] * abs(periods),
+ dtype=self.dtype)
+ if periods > 0:
+ a = empty
+ b = self[:-periods]
+ else:
+ a = self[abs(periods):]
+ b = empty
+ return self._concat_same_type([a, b])
+
def unique(self):
"""Compute the ExtensionArray of unique values.
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 57d09ff33d8b4..e735b35653cd4 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -2068,6 +2068,18 @@ def interpolate(self, method='pad', axis=0, inplace=False, limit=None,
limit=limit),
placement=self.mgr_locs)
+ def shift(self, periods, axis=0, mgr=None):
+ """
+ Shift the block by `periods`.
+
+ Dispatches to underlying ExtensionArray and re-boxes in an
+ ExtensionBlock.
+ """
+ # type: (int, Optional[BlockPlacement]) -> List[ExtensionBlock]
+ return [self.make_block_same_class(self.values.shift(periods=periods),
+ placement=self.mgr_locs,
+ ndim=self.ndim)]
+
class NumericBlock(Block):
__slots__ = ()
@@ -2691,10 +2703,6 @@ def _try_coerce_result(self, result):
return result
- def shift(self, periods, axis=0, mgr=None):
- return self.make_block_same_class(values=self.values.shift(periods),
- placement=self.mgr_locs)
-
def to_dense(self):
# Categorical.get_values returns a DatetimeIndex for datetime
# categories, so we can't simply use `np.asarray(self.values)` like
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index c660687f16590..c8656808739c4 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -138,3 +138,28 @@ def test_combine_add(self, data_repeated):
expected = pd.Series(
orig_data1._from_sequence([a + val for a in list(orig_data1)]))
self.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('frame', [True, False])
+ @pytest.mark.parametrize('periods, indices', [
+ (-2, [2, 3, 4, -1, -1]),
+ (0, [0, 1, 2, 3, 4]),
+ (2, [-1, -1, 0, 1, 2]),
+ ])
+ def test_container_shift(self, data, frame, periods, indices):
+ # https://github.com/pandas-dev/pandas/issues/22386
+ subset = data[:5]
+ data = pd.Series(subset, name='A')
+ expected = pd.Series(subset.take(indices, allow_fill=True), name='A')
+
+ if frame:
+ result = data.to_frame(name='A').assign(B=1).shift(periods)
+ expected = pd.concat([
+ expected,
+ pd.Series([1] * 5, name='B').shift(periods)
+ ], axis=1)
+ compare = self.assert_frame_equal
+ else:
+ result = data.shift(periods)
+ compare = self.assert_series_equal
+
+ compare(result, expected)
| Uses take internally.
Closes https://github.com/pandas-dev/pandas/issues/22386
One question: do we want to add `shift` to the interface, and dispatch to that? This just does the right thing at the block level, by writing a `shift` that'll work with an ExtensionArray.
CategoricalBlock still overrides `.shift` to call `Categorical.shift`, which uses a slightly faster implementation based around the codes and `np.roll` (~1.5-2x faster based on microbenchmarks)`.
We could add move `ExtensionBlock.shift `to `ExtensionArray.shift`, and just call that from ExtensionBlock. Then we can delete CategoricalBlock.shift.
I'm 50/50 on whether it's worth adding to the interface. | https://api.github.com/repos/pandas-dev/pandas/pulls/22387 | 2018-08-16T16:06:27Z | 2018-08-23T10:38:31Z | 2018-08-23T10:38:31Z | 2018-08-23T10:38:34Z |
BUG: fix read_csv to parse timezone correctly | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index d7feb6e547b22..d09c9a4cd6a3d 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -676,6 +676,7 @@ I/O
- :func:`read_html()` no longer ignores all-whitespace ``<tr>`` within ``<thead>`` when considering the ``skiprows`` and ``header`` arguments. Previously, users had to decrease their ``header`` and ``skiprows`` values on such tables to work around the issue. (:issue:`21641`)
- :func:`read_excel()` will correctly show the deprecation warning for previously deprecated ``sheetname`` (:issue:`17994`)
+- :func:`read_csv()` will correctly parse timezone-aware datetimes (:issue:`22256`)
-
Plotting
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 4b3fa08e5e4af..08fb0172adcff 100755
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -1620,7 +1620,6 @@ def _infer_types(self, values, na_values, try_num_bool=True):
converted : ndarray
na_count : int
"""
-
na_count = 0
if issubclass(values.dtype.type, (np.number, np.bool_)):
mask = algorithms.isin(values, list(na_values))
@@ -1633,20 +1632,22 @@ def _infer_types(self, values, na_values, try_num_bool=True):
if try_num_bool:
try:
- result = lib.maybe_convert_numeric(values, na_values, False)
+ result = lib.maybe_convert_numeric(np.asarray(values),
+ na_values, False)
na_count = isna(result).sum()
except Exception:
result = values
if values.dtype == np.object_:
- na_count = parsers.sanitize_objects(result, na_values,
- False)
+ na_count = parsers.sanitize_objects(np.asarray(result),
+ na_values, False)
else:
result = values
if values.dtype == np.object_:
- na_count = parsers.sanitize_objects(values, na_values, False)
+ na_count = parsers.sanitize_objects(np.asarray(values),
+ na_values, False)
if result.dtype == np.object_ and try_num_bool:
- result = libops.maybe_convert_bool(values,
+ result = libops.maybe_convert_bool(np.asarray(values),
true_values=self.true_values,
false_values=self.false_values)
@@ -3033,7 +3034,7 @@ def converter(*date_cols):
return tools.to_datetime(
ensure_object(strs),
utc=None,
- box=False,
+ box=True,
dayfirst=dayfirst,
errors='ignore',
infer_datetime_format=infer_datetime_format
diff --git a/pandas/tests/io/parser/parse_dates.py b/pandas/tests/io/parser/parse_dates.py
index 903439d2d2292..ae3c806ac1c8e 100644
--- a/pandas/tests/io/parser/parse_dates.py
+++ b/pandas/tests/io/parser/parse_dates.py
@@ -13,9 +13,9 @@
from pandas._libs.tslibs import parsing
from pandas._libs.tslib import Timestamp
+import pytz
import pandas as pd
import pandas.io.parsers as parsers
-import pandas.core.tools.datetimes as tools
import pandas.util.testing as tm
import pandas.io.date_converters as conv
@@ -356,21 +356,13 @@ def test_parse_dates_custom_euroformat(self):
def test_parse_tz_aware(self):
# See gh-1693
- import pytz
data = StringIO("Date,x\n2012-06-13T01:39:00Z,0.5")
# it works
result = self.read_csv(data, index_col=0, parse_dates=True)
stamp = result.index[0]
assert stamp.minute == 39
- try:
- assert result.index.tz is pytz.utc
- except AssertionError:
- arr = result.index.to_pydatetime()
- result = tools.to_datetime(arr, utc=True)[0]
- assert stamp.minute == result.minute
- assert stamp.hour == result.hour
- assert stamp.day == result.day
+ assert result.index.tz is pytz.utc
def test_multiple_date_cols_index(self):
data = """
@@ -674,3 +666,19 @@ def test_parse_date_float(self, data, expected, parse_dates):
# (i.e. float precision should remain unchanged).
result = self.read_csv(StringIO(data), parse_dates=parse_dates)
tm.assert_frame_equal(result, expected)
+
+ def test_parse_timezone(self):
+ # gh-22256
+ data = """dt,val
+ 2018-01-04 09:01:00+09:00,23350
+ 2018-01-04 09:02:00+09:00,23400
+ 2018-01-04 09:03:00+09:00,23400
+ 2018-01-04 09:04:00+09:00,23400
+ 2018-01-04 09:05:00+09:00,23400"""
+ parsed = self.read_csv(StringIO(data), parse_dates=['dt'])
+ dti = pd.DatetimeIndex(start='2018-01-04 09:01:00',
+ end='2018-01-04 09:05:00', freq='1min',
+ tz=pytz.FixedOffset(540))
+ expected_data = {'dt': dti, 'val': [23350, 23400, 23400, 23400, 23400]}
+ expected = DataFrame(expected_data)
+ tm.assert_frame_equal(parsed, expected)
| Use `box=True` for `to_datetime()`, and adjust downstream processing to the change.
- [x] closes #22256
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22380 | 2018-08-16T03:26:31Z | 2018-08-22T10:27:16Z | 2018-08-22T10:27:16Z | 2018-08-22T10:28:26Z |
Fix and test scalar extension dtype op corner case | diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index 10418ccbb1f64..ddd82de2da5fc 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -1228,8 +1228,8 @@ def wrapper(left, right):
"{op}".format(typ=type(left).__name__, op=str_rep))
elif (is_extension_array_dtype(left) or
- is_extension_array_dtype(right)):
- # TODO: should this include `not is_scalar(right)`?
+ (is_extension_array_dtype(right) and not is_scalar(right))):
+ # GH#22378 disallow scalar to exclude e.g. "category", "Int64"
return dispatch_to_extension_op(op, left, right)
elif is_datetime64_dtype(left) or is_datetime64tz_dtype(left):
diff --git a/pandas/tests/arithmetic/test_object.py b/pandas/tests/arithmetic/test_object.py
index c02c3becbd556..2c1cc83c09f88 100644
--- a/pandas/tests/arithmetic/test_object.py
+++ b/pandas/tests/arithmetic/test_object.py
@@ -73,6 +73,22 @@ def test_more_na_comparisons(self, dtype):
class TestArithmetic(object):
+ @pytest.mark.parametrize("op", [operator.add, ops.radd])
+ @pytest.mark.parametrize("other", ["category", "Int64"])
+ def test_add_extension_scalar(self, other, box, op):
+ # GH#22378
+ # Check that scalars satisfying is_extension_array_dtype(obj)
+ # do not incorrectly try to dispatch to an ExtensionArray operation
+
+ arr = pd.Series(['a', 'b', 'c'])
+ expected = pd.Series([op(x, other) for x in arr])
+
+ arr = tm.box_expected(arr, box)
+ expected = tm.box_expected(expected, box)
+
+ result = op(arr, other)
+ tm.assert_equal(result, expected)
+
@pytest.mark.parametrize('box', [
pytest.param(pd.Index,
marks=pytest.mark.xfail(reason="Does not mask nulls",
| Fixes the following behavior in master:
```
ser = pd.Series(['a', 'b', 'c'])
>>> ser + "category"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "pandas/core/ops.py", line 1233, in wrapper
return dispatch_to_extension_op(op, left, right)
File "pandas/core/ops.py", line 1163, in dispatch_to_extension_op
res_values = op(new_left, new_right)
TypeError: can only concatenate list (not "str") to list
>>> ser + "Int64"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "pandas/core/ops.py", line 1233, in wrapper
return dispatch_to_extension_op(op, left, right)
File "pandas/core/ops.py", line 1163, in dispatch_to_extension_op
res_values = op(new_left, new_right)
TypeError: can only concatenate list (not "str") to list
```
and the same for the reversed ops. | https://api.github.com/repos/pandas-dev/pandas/pulls/22378 | 2018-08-16T02:04:00Z | 2018-08-18T07:52:15Z | 2018-08-18T07:52:15Z | 2020-04-05T17:38:47Z |
BUG: Fix DataFrame.apply for string arg with additional args (#22376) | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 0de9bebd68045..b83208ef497d3 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -634,6 +634,7 @@ Numeric
a ``TypeError`` was wrongly raised. For all three methods such calculation are now done correctly. (:issue:`16679`).
- Bug in :class:`Series` comparison against datetime-like scalars and arrays (:issue:`22074`)
- Bug in :class:`DataFrame` multiplication between boolean dtype and integer returning ``object`` dtype instead of integer dtype (:issue:`22047`,:issue:`22163`)
+- Bug in :meth:`DataFrame.apply` where, when supplied with a string argument and additional positional or keyword arguments (e.g. ``df.apply('sum', min_count=1)``), a ``TypeError`` was wrongly raised (:issue:`22376`)
-
Strings
diff --git a/pandas/core/apply.py b/pandas/core/apply.py
index 989becbf133ca..40cd952a62138 100644
--- a/pandas/core/apply.py
+++ b/pandas/core/apply.py
@@ -71,7 +71,9 @@ def __init__(self, obj, func, broadcast, raw, reduce, result_type,
self.result_type = result_type
# curry if needed
- if kwds or args and not isinstance(func, np.ufunc):
+ if ((kwds or args) and
+ not isinstance(func, (np.ufunc, compat.string_types))):
+
def f(x):
return func(x, *args, **kwds)
else:
diff --git a/pandas/tests/frame/test_apply.py b/pandas/tests/frame/test_apply.py
index f18163d51c721..8beab3fb816df 100644
--- a/pandas/tests/frame/test_apply.py
+++ b/pandas/tests/frame/test_apply.py
@@ -120,14 +120,17 @@ def test_apply_standard_nonunique(self):
rs = df.T.apply(lambda s: s[0], axis=0)
assert_series_equal(rs, xp)
- @pytest.mark.parametrize('arg', ['sum', 'mean', 'min', 'max', 'std'])
- def test_with_string_args(self, arg):
- result = self.frame.apply(arg)
- expected = getattr(self.frame, arg)()
- tm.assert_series_equal(result, expected)
-
- result = self.frame.apply(arg, axis=1)
- expected = getattr(self.frame, arg)(axis=1)
+ @pytest.mark.parametrize('func', ['sum', 'mean', 'min', 'max', 'std'])
+ @pytest.mark.parametrize('args,kwds', [
+ pytest.param([], {}, id='no_args_or_kwds'),
+ pytest.param([1], {}, id='axis_from_args'),
+ pytest.param([], {'axis': 1}, id='axis_from_kwds'),
+ pytest.param([], {'numeric_only': True}, id='optional_kwds'),
+ pytest.param([1, None], {'numeric_only': True}, id='args_and_kwds')
+ ])
+ def test_apply_with_string_funcs(self, func, args, kwds):
+ result = self.frame.apply(func, *args, **kwds)
+ expected = getattr(self.frame, func)(*args, **kwds)
tm.assert_series_equal(result, expected)
def test_apply_broadcast_deprecated(self):
| - [x] closes #22376
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry | https://api.github.com/repos/pandas-dev/pandas/pulls/22377 | 2018-08-16T00:26:04Z | 2018-08-23T10:42:56Z | 2018-08-23T10:42:55Z | 2018-08-23T10:42:59Z |
ENH: Enable DataFrame.corrwith to compute rank correlations | diff --git a/asv_bench/benchmarks/stat_ops.py b/asv_bench/benchmarks/stat_ops.py
index 500e4d74d4c4f..7fdc713f076ed 100644
--- a/asv_bench/benchmarks/stat_ops.py
+++ b/asv_bench/benchmarks/stat_ops.py
@@ -106,6 +106,7 @@ def setup(self, method, use_bottleneck):
from pandas.core import nanops
nanops._USE_BOTTLENECK = use_bottleneck
self.df = pd.DataFrame(np.random.randn(1000, 30))
+ self.df2 = pd.DataFrame(np.random.randn(1000, 30))
self.s = pd.Series(np.random.randn(1000))
self.s2 = pd.Series(np.random.randn(1000))
@@ -115,6 +116,12 @@ def time_corr(self, method, use_bottleneck):
def time_corr_series(self, method, use_bottleneck):
self.s.corr(self.s2, method=method)
+ def time_corrwith_cols(self, method, use_bottleneck):
+ self.df.corrwith(self.df2, method=method)
+
+ def time_corrwith_rows(self, method, use_bottleneck):
+ self.df.corrwith(self.df2, axis=1, method=method)
+
class Covariance(object):
diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 29ab51c582a97..04c5207f6ae40 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -413,6 +413,7 @@ Other Enhancements
- The ``scatter_matrix``, ``andrews_curves``, ``parallel_coordinates``, ``lag_plot``, ``autocorrelation_plot``, ``bootstrap_plot``, and ``radviz`` plots from the ``pandas.plotting`` module are now accessible from calling :meth:`DataFrame.plot` (:issue:`11978`)
- :class:`IntervalIndex` has gained the :attr:`~IntervalIndex.is_overlapping` attribute to indicate if the ``IntervalIndex`` contains any overlapping intervals (:issue:`23309`)
- :func:`pandas.DataFrame.to_sql` has gained the ``method`` argument to control SQL insertion clause. See the :ref:`insertion method <io.sql.method>` section in the documentation. (:issue:`8953`)
+- :meth:`DataFrame.corrwith` now supports Spearman's rank correlation, Kendall's tau as well as callable correlation methods. (:issue:`21925`)
.. _whatsnew_0240.api_breaking:
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index a34a34186cf45..2fe18339de791 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -6868,6 +6868,11 @@ def corr(self, method='pearson', min_periods=1):
dogs cats
dogs 1.0 0.3
cats 0.3 1.0
+
+ See Also
+ -------
+ DataFrame.corrwith
+ Series.corr
"""
numeric_df = self._get_numeric_data()
cols = numeric_df.columns
@@ -7021,10 +7026,11 @@ def cov(self, min_periods=None):
return self._constructor(baseCov, index=idx, columns=cols)
- def corrwith(self, other, axis=0, drop=False):
+ def corrwith(self, other, axis=0, drop=False, method='pearson'):
"""
- Compute pairwise correlation between rows or columns of two DataFrame
- objects.
+ Compute pairwise correlation between rows or columns of DataFrame
+ with rows or columns of Series or DataFrame. DataFrames are first
+ aligned along both axes before computing the correlations.
Parameters
----------
@@ -7032,43 +7038,77 @@ def corrwith(self, other, axis=0, drop=False):
axis : {0 or 'index', 1 or 'columns'}, default 0
0 or 'index' to compute column-wise, 1 or 'columns' for row-wise
drop : boolean, default False
- Drop missing indices from result, default returns union of all
+ Drop missing indices from result
+ method : {'pearson', 'kendall', 'spearman'} or callable
+ * pearson : standard correlation coefficient
+ * kendall : Kendall Tau correlation coefficient
+ * spearman : Spearman rank correlation
+ * callable: callable with input two 1d ndarrays
+ and returning a float
+
+ .. versionadded:: 0.24.0
Returns
-------
correls : Series
+
+ See Also
+ -------
+ DataFrame.corr
"""
axis = self._get_axis_number(axis)
this = self._get_numeric_data()
if isinstance(other, Series):
- return this.apply(other.corr, axis=axis)
+ return this.apply(lambda x: other.corr(x, method=method),
+ axis=axis)
other = other._get_numeric_data()
-
left, right = this.align(other, join='inner', copy=False)
- # mask missing values
- left = left + right * 0
- right = right + left * 0
-
if axis == 1:
left = left.T
right = right.T
- # demeaned data
- ldem = left - left.mean()
- rdem = right - right.mean()
+ if method == 'pearson':
+ # mask missing values
+ left = left + right * 0
+ right = right + left * 0
+
+ # demeaned data
+ ldem = left - left.mean()
+ rdem = right - right.mean()
- num = (ldem * rdem).sum()
- dom = (left.count() - 1) * left.std() * right.std()
+ num = (ldem * rdem).sum()
+ dom = (left.count() - 1) * left.std() * right.std()
- correl = num / dom
+ correl = num / dom
+
+ elif method in ['kendall', 'spearman'] or callable(method):
+ def c(x):
+ return nanops.nancorr(x[0], x[1], method=method)
+
+ correl = Series(map(c,
+ zip(left.values.T, right.values.T)),
+ index=left.columns)
+
+ else:
+ raise ValueError("Invalid method {method} was passed, "
+ "valid methods are: 'pearson', 'kendall', "
+ "'spearman', or callable".
+ format(method=method))
if not drop:
+ # Find non-matching labels along the given axis
+ # and append missing correlations (GH 22375)
raxis = 1 if axis == 0 else 0
- result_index = this._get_axis(raxis).union(other._get_axis(raxis))
- correl = correl.reindex(result_index)
+ result_index = (this._get_axis(raxis).
+ union(other._get_axis(raxis)))
+ idx_diff = result_index.difference(correl.index)
+
+ if len(idx_diff) > 0:
+ correl = correl.append(Series([np.nan] * len(idx_diff),
+ index=idx_diff))
return correl
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 6f68828b94a84..ea24a50e82cbc 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -466,6 +466,32 @@ def test_corrwith_mixed_dtypes(self):
expected = pd.Series(data=corrs, index=['a', 'b'])
tm.assert_series_equal(result, expected)
+ def test_corrwith_dup_cols(self):
+ # GH 21925
+ df1 = pd.DataFrame(np.vstack([np.arange(10)] * 3).T)
+ df2 = df1.copy()
+ df2 = pd.concat((df2, df2[0]), axis=1)
+
+ result = df1.corrwith(df2)
+ expected = pd.Series(np.ones(4), index=[0, 0, 1, 2])
+ tm.assert_series_equal(result, expected)
+
+ @td.skip_if_no_scipy
+ def test_corrwith_spearman(self):
+ # GH 21925
+ df = pd.DataFrame(np.random.random(size=(100, 3)))
+ result = df.corrwith(df**2, method="spearman")
+ expected = Series(np.ones(len(result)))
+ tm.assert_series_equal(result, expected)
+
+ @td.skip_if_no_scipy
+ def test_corrwith_kendall(self):
+ # GH 21925
+ df = pd.DataFrame(np.random.random(size=(100, 3)))
+ result = df.corrwith(df**2, method="kendall")
+ expected = Series(np.ones(len(result)))
+ tm.assert_series_equal(result, expected)
+
def test_bool_describe_in_mixed_frame(self):
df = DataFrame({
'string_data': ['a', 'b', 'c', 'd', 'e'],
| This PR is to enable `DataFrame.corrwith` to calculate rank correlations in addition to Pearson's correlation (and should hopefully be fully backwards compatible), as well as clarifying functionality in the docstring . An error message is generated if the user specifies a form of correlation that isn't implemented. Tests were added for the new behavior.
closes #22328
closes #21925 | https://api.github.com/repos/pandas-dev/pandas/pulls/22375 | 2018-08-16T00:14:57Z | 2018-12-31T13:17:55Z | 2018-12-31T13:17:54Z | 2018-12-31T15:50:50Z |
[CLN] remove last cython: nprofile comments | diff --git a/pandas/_libs/algos.pyx b/pandas/_libs/algos.pyx
index 124792638e3df..908bf59987527 100644
--- a/pandas/_libs/algos.pyx
+++ b/pandas/_libs/algos.pyx
@@ -1,4 +1,4 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
cimport cython
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index 5681d01c6bb25..077ef925a8321 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
cimport cython
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/hashing.pyx b/pandas/_libs/hashing.pyx
index a9775d3950187..65fdeb8e33efd 100644
--- a/pandas/_libs/hashing.pyx
+++ b/pandas/_libs/hashing.pyx
@@ -1,4 +1,4 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
# Translated from the reference implementation
# at https://github.com/veorq/SipHash
diff --git a/pandas/_libs/hashtable.pyx b/pandas/_libs/hashtable.pyx
index b9a72a0c8285f..2ced98198afc6 100644
--- a/pandas/_libs/hashtable.pyx
+++ b/pandas/_libs/hashtable.pyx
@@ -1,4 +1,4 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
cimport cython
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 5918560cf1436..4965469d05276 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -1,4 +1,4 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
from datetime import datetime, timedelta, date
cimport cython
diff --git a/pandas/_libs/indexing.pyx b/pandas/_libs/indexing.pyx
index c680706b7b2d2..af6e00bad7f6b 100644
--- a/pandas/_libs/indexing.pyx
+++ b/pandas/_libs/indexing.pyx
@@ -1,4 +1,5 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
+
cdef class _NDFrameIndexerBase:
"""
diff --git a/pandas/_libs/join.pyx b/pandas/_libs/join.pyx
index 27d2a639d13e6..ebb7bd40694ec 100644
--- a/pandas/_libs/join.pyx
+++ b/pandas/_libs/join.pyx
@@ -1,4 +1,4 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
cimport cython
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/khash.pxd b/pandas/_libs/khash.pxd
index 4c00e273b33b7..971a45e365586 100644
--- a/pandas/_libs/khash.pxd
+++ b/pandas/_libs/khash.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cpython cimport PyObject
from numpy cimport int64_t, uint64_t, int32_t, uint32_t, float64_t
diff --git a/pandas/_libs/missing.pxd b/pandas/_libs/missing.pxd
index b90975df8e247..2c1f13eeb5dff 100644
--- a/pandas/_libs/missing.pxd
+++ b/pandas/_libs/missing.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from tslibs.nattype cimport is_null_datetimelike
diff --git a/pandas/_libs/missing.pyx b/pandas/_libs/missing.pyx
index e9c3cf12eb328..c787cc61e8773 100644
--- a/pandas/_libs/missing.pyx
+++ b/pandas/_libs/missing.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cpython cimport PyFloat_Check, PyComplex_Check
diff --git a/pandas/_libs/reduction.pyx b/pandas/_libs/reduction.pyx
index 3588ac14c87d1..2ccb58dd67014 100644
--- a/pandas/_libs/reduction.pyx
+++ b/pandas/_libs/reduction.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from distutils.version import LooseVersion
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/reshape.pyx b/pandas/_libs/reshape.pyx
index 4fd1fd0f37b1d..8d7e314517ed8 100644
--- a/pandas/_libs/reshape.pyx
+++ b/pandas/_libs/reshape.pyx
@@ -1,4 +1,4 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
cimport cython
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/skiplist.pxd b/pandas/_libs/skiplist.pxd
index 78f206962bcfc..a273d2c445d18 100644
--- a/pandas/_libs/skiplist.pxd
+++ b/pandas/_libs/skiplist.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index 04e039a9fc2c9..7b938d0279a7c 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cython cimport Py_ssize_t
from cpython cimport PyFloat_Check, PyUnicode_Check
diff --git a/pandas/_libs/tslibs/ccalendar.pxd b/pandas/_libs/tslibs/ccalendar.pxd
index 04fb6eaf49c84..08f539a70a7ed 100644
--- a/pandas/_libs/tslibs/ccalendar.pxd
+++ b/pandas/_libs/tslibs/ccalendar.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/tslibs/ccalendar.pyx b/pandas/_libs/tslibs/ccalendar.pyx
index 12d35f7ce2f58..ec54c023290b3 100644
--- a/pandas/_libs/tslibs/ccalendar.pyx
+++ b/pandas/_libs/tslibs/ccalendar.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
# cython: boundscheck=False
"""
Cython implementations of functions resembling the stdlib calendar module
diff --git a/pandas/_libs/tslibs/conversion.pxd b/pandas/_libs/tslibs/conversion.pxd
index 96e4676fe91c0..4eb93c35b4afc 100644
--- a/pandas/_libs/tslibs/conversion.pxd
+++ b/pandas/_libs/tslibs/conversion.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cpython.datetime cimport datetime, tzinfo
diff --git a/pandas/_libs/tslibs/conversion.pyx b/pandas/_libs/tslibs/conversion.pyx
index 74a9823a85016..fe664cf03b0b9 100644
--- a/pandas/_libs/tslibs/conversion.pyx
+++ b/pandas/_libs/tslibs/conversion.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
cimport cython
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/tslibs/fields.pyx b/pandas/_libs/tslibs/fields.pyx
index 96f023f7fdafe..9cbad8acabff1 100644
--- a/pandas/_libs/tslibs/fields.pyx
+++ b/pandas/_libs/tslibs/fields.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
"""
Functions for accessing attributes of Timestamp/datetime64/datetime-like
objects and arrays
diff --git a/pandas/_libs/tslibs/frequencies.pxd b/pandas/_libs/tslibs/frequencies.pxd
index 98d600c540ace..4e7949e55c836 100644
--- a/pandas/_libs/tslibs/frequencies.pxd
+++ b/pandas/_libs/tslibs/frequencies.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
cpdef object get_rule_month(object source, object default=*)
diff --git a/pandas/_libs/tslibs/nattype.pxd b/pandas/_libs/tslibs/nattype.pxd
index 24ce797575b2a..382ac9d323918 100644
--- a/pandas/_libs/tslibs/nattype.pxd
+++ b/pandas/_libs/tslibs/nattype.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from numpy cimport int64_t
cdef int64_t NPY_NAT
diff --git a/pandas/_libs/tslibs/nattype.pyx b/pandas/_libs/tslibs/nattype.pyx
index 25b1572cfe52f..08d9128ff660c 100644
--- a/pandas/_libs/tslibs/nattype.pyx
+++ b/pandas/_libs/tslibs/nattype.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cpython cimport (
PyFloat_Check, PyComplex_Check,
diff --git a/pandas/_libs/tslibs/np_datetime.pxd b/pandas/_libs/tslibs/np_datetime.pxd
index c3d229d4e5006..803c8cb18e3d5 100644
--- a/pandas/_libs/tslibs/np_datetime.pxd
+++ b/pandas/_libs/tslibs/np_datetime.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cpython.datetime cimport date, datetime
diff --git a/pandas/_libs/tslibs/np_datetime.pyx b/pandas/_libs/tslibs/np_datetime.pyx
index a0099837e876a..f0aa6389fba56 100644
--- a/pandas/_libs/tslibs/np_datetime.pyx
+++ b/pandas/_libs/tslibs/np_datetime.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cpython cimport (Py_EQ, Py_NE, Py_GE, Py_GT, Py_LT, Py_LE,
PyUnicode_Check, PyUnicode_AsASCIIString)
diff --git a/pandas/_libs/tslibs/timedeltas.pxd b/pandas/_libs/tslibs/timedeltas.pxd
index ef9fd3207e5f0..eda4418902513 100644
--- a/pandas/_libs/tslibs/timedeltas.pxd
+++ b/pandas/_libs/tslibs/timedeltas.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from numpy cimport int64_t
diff --git a/pandas/_libs/tslibs/timedeltas.pyx b/pandas/_libs/tslibs/timedeltas.pyx
index c32ad2f4d599c..b84c1a753215a 100644
--- a/pandas/_libs/tslibs/timedeltas.pyx
+++ b/pandas/_libs/tslibs/timedeltas.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
import collections
import textwrap
import warnings
diff --git a/pandas/_libs/tslibs/timestamps.pxd b/pandas/_libs/tslibs/timestamps.pxd
index e9e484c715f9a..d6b649becc479 100644
--- a/pandas/_libs/tslibs/timestamps.pxd
+++ b/pandas/_libs/tslibs/timestamps.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from numpy cimport int64_t
from np_datetime cimport npy_datetimestruct
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index 67420fda8aa51..3ab1396c0fe38 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
import warnings
from cpython cimport (PyObject_RichCompareBool, PyObject_RichCompare,
diff --git a/pandas/_libs/tslibs/timezones.pxd b/pandas/_libs/tslibs/timezones.pxd
index 67353f3eec614..e8a10a0728212 100644
--- a/pandas/_libs/tslibs/timezones.pxd
+++ b/pandas/_libs/tslibs/timezones.pxd
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
cdef bint is_utc(object tz)
cdef bint is_tzlocal(object tz)
diff --git a/pandas/_libs/tslibs/timezones.pyx b/pandas/_libs/tslibs/timezones.pyx
index a787452d90c07..4d87a37866c49 100644
--- a/pandas/_libs/tslibs/timezones.pyx
+++ b/pandas/_libs/tslibs/timezones.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/window.pyx b/pandas/_libs/window.pyx
index efc8a02014bc0..c43750c754209 100644
--- a/pandas/_libs/window.pyx
+++ b/pandas/_libs/window.pyx
@@ -1,4 +1,4 @@
-# cython: profile=False
+# -*- coding: utf-8 -*-
# cython: boundscheck=False, wraparound=False, cdivision=True
cimport cython
| Separates out parts of #22287 to troubleshoot persistent Travis failures. | https://api.github.com/repos/pandas-dev/pandas/pulls/22371 | 2018-08-15T16:47:17Z | 2018-08-16T10:08:10Z | 2018-08-16T10:08:10Z | 2020-04-05T17:40:23Z |
DOC: edit docstring example to prevent segfault (#21824) | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b35bc8325d560..78ad9728800d6 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -6896,21 +6896,21 @@ def count(self, axis=0, level=None, numeric_only=False):
Constructing DataFrame from a dictionary:
>>> df = pd.DataFrame({"Person":
- ... ["John", "Myla", None, "John", "Myla"],
+ ... ["John", "Myla", "Lewis", "John", "Myla"],
... "Age": [24., np.nan, 21., 33, 26],
... "Single": [False, True, True, True, False]})
>>> df
Person Age Single
0 John 24.0 False
1 Myla NaN True
- 2 None 21.0 True
+ 2 Lewis 21.0 True
3 John 33.0 True
4 Myla 26.0 False
Notice the uncounted NA values:
>>> df.count()
- Person 4
+ Person 5
Age 4
Single 5
dtype: int64
@@ -6920,7 +6920,7 @@ def count(self, axis=0, level=None, numeric_only=False):
>>> df.count(axis='columns')
0 3
1 2
- 2 2
+ 2 3
3 3
4 3
dtype: int64
@@ -6931,7 +6931,9 @@ def count(self, axis=0, level=None, numeric_only=False):
Age
Person
John 2
+ Lewis 1
Myla 1
+
"""
axis = self._get_axis_number(axis)
if level is not None:
| See https://github.com/pandas-dev/pandas/issues/21824 for the segfault description, changing the example so running the doctests will work: https://github.com/pandas-dev/pandas/pull/19952 | https://api.github.com/repos/pandas-dev/pandas/pulls/22368 | 2018-08-15T13:49:58Z | 2018-08-15T16:09:51Z | 2018-08-15T16:09:51Z | 2018-08-15T16:11:16Z |
Resampler.__iter__() not working | diff --git a/doc/source/groupby.rst b/doc/source/groupby.rst
index 45e449d081fb0..00f2735f76552 100644
--- a/doc/source/groupby.rst
+++ b/doc/source/groupby.rst
@@ -389,7 +389,7 @@ This is mainly syntactic sugar for the alternative and much more verbose:
Additionally this method avoids recomputing the internal grouping information
derived from the passed key.
-.. _groupby.iterating:
+.. _groupby.iterating-label:
Iterating through groups
------------------------
@@ -415,8 +415,7 @@ In the case of grouping by multiple keys, the group name will be a tuple:
...: print(group)
...:
-It's standard Python-fu but remember you can unpack the tuple in the for loop
-statement if you wish: ``for (k1, k2), group in grouped:``.
+See :ref:`timeseries.iterating-label`.
Selecting a group
-----------------
diff --git a/doc/source/timeseries.rst b/doc/source/timeseries.rst
index b7771436f8e55..a287557297cc9 100644
--- a/doc/source/timeseries.rst
+++ b/doc/source/timeseries.rst
@@ -703,6 +703,24 @@ regularity will result in a ``DatetimeIndex``, although frequency is lost:
ts2[[0, 2, 6]].index
+.. _timeseries.iterating-label:
+
+Iterating through groups
+------------------------
+
+With the :ref:`Resampler` object in hand, iterating through the grouped data is very
+natural and functions similarly to :py:func:`itertools.groupby`:
+
+.. ipython:: python
+
+ resampled = df.resample('H')
+
+ for name, group in resampled:
+ print(name)
+ print(group)
+
+See :ref:`groupby.iterating-label`.
+
.. _timeseries.components:
Time/Date Components
diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 9b70bda82e247..40f9aa947eced 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -182,6 +182,7 @@ Other Enhancements
- :func:`to_timedelta` now supports iso-formated timedelta strings (:issue:`21877`)
- :class:`Series` and :class:`DataFrame` now support :class:`Iterable` in constructor (:issue:`2193`)
- :class:`DatetimeIndex` gained :attr:`DatetimeIndex.timetz` attribute. Returns local time with timezone information. (:issue:`21358`)
+- :class:`Resampler` now is iterable like :class:`GroupBy` (:issue:`15314`).
.. _whatsnew_0240.api_breaking:
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 4a3625b2d7a2d..b9194443c3033 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -97,6 +97,23 @@ def __getattr__(self, attr):
return object.__getattribute__(self, attr)
+ def __iter__(self):
+ """
+ Resampler iterator
+
+ Returns
+ -------
+ Generator yielding sequence of (name, subsetted object)
+ for each group
+
+ See Also
+ --------
+ GroupBy.__iter__
+
+ """
+ self._set_binner()
+ return super(Resampler, self).__iter__()
+
@property
def obj(self):
return self.groupby.obj
diff --git a/pandas/tests/test_resample.py b/pandas/tests/test_resample.py
index d11077668359b..48b37e5da62ae 100644
--- a/pandas/tests/test_resample.py
+++ b/pandas/tests/test_resample.py
@@ -771,6 +771,17 @@ def test_apply_to_empty_series(self):
assert_series_equal(result, expected, check_dtype=False)
+ def test_resampler_is_iterable(self):
+ # GH 15314
+ series = self.create_series()
+ freq = 'H'
+ tg = TimeGrouper(freq, convention='start')
+ grouped = series.groupby(tg)
+ resampled = series.resample(freq)
+ for (rk, rv), (gk, gv) in zip(resampled, grouped):
+ assert rk == gk
+ assert_series_equal(rv, gv)
+
class TestDatetimeIndex(Base):
_index_factory = lambda x: date_range
| - [x] closes #15314
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22365 | 2018-08-15T10:39:14Z | 2018-08-22T10:35:33Z | 2018-08-22T10:35:32Z | 2018-08-22T10:35:36Z |
DOC: update doc-string in Index.rename | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index bfa669a0ca164..7237b7754b09e 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1278,39 +1278,52 @@ def _set_names(self, values, level=None):
def set_names(self, names, level=None, inplace=False):
"""
- Set new names on index. Defaults to returning new index.
+ Set Index or MultiIndex name.
+
+ Able to set new names partially and by level.
Parameters
----------
- names : str or sequence
- name(s) to set
- level : int, level name, or sequence of int/level names (default None)
- If the index is a MultiIndex (hierarchical), level(s) to set (None
- for all levels). Otherwise level must be None
- inplace : bool
- if True, mutates in place
+ names : label or list of label
+ Name(s) to set.
+ level : int, label or list of int or label, optional
+ If the index is a MultiIndex, level(s) to set (None for all
+ levels). Otherwise level must be None.
+ inplace : bool, default False
+ Modifies the object directly, instead of creating a new Index or
+ MultiIndex.
Returns
-------
- new index (of same type and class...etc) [if inplace, returns None]
+ Index
+ The same type as the caller or None if inplace is True.
+
+ See Also
+ --------
+ Index.rename : Able to set new names without level.
Examples
--------
- >>> pd.Index([1, 2, 3, 4]).set_names('foo')
- Int64Index([1, 2, 3, 4], dtype='int64', name='foo')
- >>> pd.Index([1, 2, 3, 4]).set_names(['foo'])
- Int64Index([1, 2, 3, 4], dtype='int64', name='foo')
- >>> idx = pd.MultiIndex.from_tuples([(1, u'one'), (1, u'two'),
- (2, u'one'), (2, u'two')],
- names=['foo', 'bar'])
- >>> idx.set_names(['baz', 'quz'])
- MultiIndex(levels=[[1, 2], [u'one', u'two']],
- labels=[[0, 0, 1, 1], [0, 1, 0, 1]],
- names=[u'baz', u'quz'])
- >>> idx.set_names('baz', level=0)
- MultiIndex(levels=[[1, 2], [u'one', u'two']],
- labels=[[0, 0, 1, 1], [0, 1, 0, 1]],
- names=[u'baz', u'bar'])
+ >>> idx = pd.Index([1, 2, 3, 4])
+ >>> idx
+ Int64Index([1, 2, 3, 4], dtype='int64')
+ >>> idx.set_names('quarter')
+ Int64Index([1, 2, 3, 4], dtype='int64', name='quarter')
+
+ >>> idx = pd.MultiIndex.from_product([['python', 'cobra'],
+ ... [2018, 2019]])
+ >>> idx
+ MultiIndex(levels=[['cobra', 'python'], [2018, 2019]],
+ labels=[[1, 1, 0, 0], [0, 1, 0, 1]])
+ >>> idx.set_names(['kind', 'year'], inplace=True)
+ >>> idx
+ MultiIndex(levels=[['cobra', 'python'], [2018, 2019]],
+ labels=[[1, 1, 0, 0], [0, 1, 0, 1]],
+ names=['kind', 'year'])
+ >>> idx.set_names('species', level=0)
+ MultiIndex(levels=[['cobra', 'python'], [2018, 2019]],
+ labels=[[1, 1, 0, 0], [0, 1, 0, 1]],
+ names=['species', 'year'])
"""
from .multi import MultiIndex
@@ -1319,7 +1332,8 @@ def set_names(self, names, level=None, inplace=False):
if level is not None and not is_list_like(level) and is_list_like(
names):
- raise TypeError("Names must be a string")
+ msg = "Names must be a string when a single level is provided."
+ raise TypeError(msg)
if not is_list_like(names) and level is None and self.nlevels > 1:
raise TypeError("Must pass list-like as `names`.")
@@ -1339,18 +1353,48 @@ def set_names(self, names, level=None, inplace=False):
def rename(self, name, inplace=False):
"""
- Set new names on index. Defaults to returning new index.
+ Alter Index or MultiIndex name.
+
+ Able to set new names without level. Defaults to returning new index.
+ Length of names must match number of levels in MultiIndex.
Parameters
----------
- name : str or list
- name to set
- inplace : bool
- if True, mutates in place
+ name : label or list of labels
+ Name(s) to set.
+ inplace : boolean, default False
+ Modifies the object directly, instead of creating a new Index or
+ MultiIndex.
Returns
-------
- new index (of same type and class...etc) [if inplace, returns None]
+ Index
+ The same type as the caller or None if inplace is True.
+
+ See Also
+ --------
+ Index.set_names : Able to set new names partially and by level.
+
+ Examples
+ --------
+ >>> idx = pd.Index(['A', 'C', 'A', 'B'], name='score')
+ >>> idx.rename('grade')
+ Index(['A', 'C', 'A', 'B'], dtype='object', name='grade')
+
+ >>> idx = pd.MultiIndex.from_product([['python', 'cobra'],
+ ... [2018, 2019]],
+ ... names=['kind', 'year'])
+ >>> idx
+ MultiIndex(levels=[['cobra', 'python'], [2018, 2019]],
+ labels=[[1, 1, 0, 0], [0, 1, 0, 1]],
+ names=['kind', 'year'])
+ >>> idx.rename(['species', 'year'])
+ MultiIndex(levels=[['cobra', 'python'], [2018, 2019]],
+ labels=[[1, 1, 0, 0], [0, 1, 0, 1]],
+ names=['species', 'year'])
+ >>> idx.rename('species')
+ Traceback (most recent call last):
+ TypeError: Must pass list-like as `names`.
"""
return self.set_names([name], inplace=inplace)
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index 30be5b546f7c7..99ab54a83636c 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -360,7 +360,7 @@ def test_set_levels_labels_names_bad_input(idx):
with tm.assert_raises_regex(ValueError, 'Length of names'):
idx.set_names(names[0], level=[0, 1])
- with tm.assert_raises_regex(TypeError, 'string'):
+ with tm.assert_raises_regex(TypeError, 'Names must be a'):
idx.set_names(names, level=0)
| updated doc-strings with examples
- [x] closes #20787
- N/A tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- N/A whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22363 | 2018-08-15T09:02:50Z | 2018-08-19T10:00:46Z | 2018-08-19T10:00:45Z | 2018-08-19T10:01:25Z |
DOC: Expose ExcelWriter as part of the Generated API | diff --git a/doc/source/api.rst b/doc/source/api.rst
index 551b3eff10fa0..d2bc11adc4d11 100644
--- a/doc/source/api.rst
+++ b/doc/source/api.rst
@@ -61,6 +61,12 @@ Excel
read_excel
ExcelFile.parse
+.. autosummary::
+ :toctree: generated/
+ :template: autosummary/class_without_autosummary.rst
+
+ ExcelWriter
+
JSON
~~~~
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 9bdf34113ccf0..2034fd4996566 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1924,11 +1924,17 @@ def _repr_latex_(self):
If you wish to write to more than one sheet in the workbook, it is
necessary to specify an ExcelWriter object:
- >>> writer = pd.ExcelWriter('output2.xlsx', engine='xlsxwriter')
- >>> df1.to_excel(writer, sheet_name='Sheet1')
>>> df2 = df1.copy()
- >>> df2.to_excel(writer, sheet_name='Sheet2')
- >>> writer.save()
+ >>> with pd.ExcelWriter('output.xlsx') as writer:
+ ... df1.to_excel(writer, sheet_name='Sheet_name_1')
+ ... df2.to_excel(writer, sheet_name='Sheet_name_2')
+
+ To set the library that is used to write the Excel file,
+ you can pass the `engine` keyword (the default engine is
+ automatically chosen depending on the file extension):
+
+ >>> df1.to_excel('output1.xlsx', engine='xlsxwriter')
+
"""
def to_json(self, path_or_buf=None, orient=None, date_format=None,
diff --git a/pandas/io/excel.py b/pandas/io/excel.py
index e2db6643c5ef0..00b4c704c681b 100644
--- a/pandas/io/excel.py
+++ b/pandas/io/excel.py
@@ -824,8 +824,43 @@ class ExcelWriter(object):
Notes
-----
+ None of the methods and properties are considered public.
+
For compatibility with CSV writers, ExcelWriter serializes lists
and dicts to strings before writing.
+
+ Examples
+ --------
+ Default usage:
+
+ >>> with ExcelWriter('path_to_file.xlsx') as writer:
+ ... df.to_excel(writer)
+
+ To write to separate sheets in a single file:
+
+ >>> with ExcelWriter('path_to_file.xlsx') as writer:
+ ... df1.to_excel(writer, sheet_name='Sheet1')
+ ... df2.to_excel(writer, sheet_name='Sheet2')
+
+ You can set the date format or datetime format:
+
+ >>> with ExcelWriter('path_to_file.xlsx',
+ date_format='YYYY-MM-DD',
+ datetime_format='YYYY-MM-DD HH:MM:SS') as writer:
+ ... df.to_excel(writer)
+
+ You can also append to an existing Excel file:
+
+ >>> with ExcelWriter('path_to_file.xlsx', mode='a') as writer:
+ ... df.to_excel(writer, sheet_name='Sheet3')
+
+ Attributes
+ ----------
+ None
+
+ Methods
+ -------
+ None
"""
# Defining an ExcelWriter implementation (see abstract methods for more...)
| - [x] closes #21835
- N/A tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- N/A whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22359 | 2018-08-15T07:26:58Z | 2018-09-18T12:54:32Z | 2018-09-18T12:54:31Z | 2018-09-18T14:51:08Z |
Fix index locator cast bool key to float. | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index b37261ea79f21..39eae9643b6b4 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -655,6 +655,7 @@ Indexing
- Fixed ``DataFrame[np.nan]`` when columns are non-unique (:issue:`21428`)
- Bug when indexing :class:`DatetimeIndex` with nanosecond resolution dates and timezones (:issue:`11679`)
- Bug where indexing with a Numpy array containing negative values would mutate the indexer (:issue:`21867`)
+- ``Float64Index.get_loc`` now raises ``KeyError`` when boolean key passed. (:issue:`19087`)
Missing
^^^^^^^
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index ea392d0b93377..e0627432cbc2e 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -403,7 +403,7 @@ def __contains__(self, other):
@Appender(_index_shared_docs['get_loc'])
def get_loc(self, key, method=None, tolerance=None):
try:
- if np.all(np.isnan(key)):
+ if np.all(np.isnan(key)) or is_bool(key):
nan_idxs = self._nan_idxs
try:
return nan_idxs.item()
diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py
index b6d61187a3fc3..c8aa7f8fd50fd 100644
--- a/pandas/tests/indexes/test_numeric.py
+++ b/pandas/tests/indexes/test_numeric.py
@@ -289,6 +289,8 @@ def test_get_loc(self):
pytest.raises(KeyError, idx.get_loc, 1.5)
pytest.raises(KeyError, idx.get_loc, 1.5, method='pad',
tolerance=0.1)
+ pytest.raises(KeyError, idx.get_loc, True)
+ pytest.raises(KeyError, idx.get_loc, False)
with tm.assert_raises_regex(ValueError, 'must be numeric'):
idx.get_loc(1.4, method='nearest', tolerance='foo')
| - closes #19087
| https://api.github.com/repos/pandas-dev/pandas/pulls/22357 | 2018-08-15T05:05:13Z | 2018-08-22T10:31:00Z | 2018-08-22T10:31:00Z | 2018-08-22T10:31:06Z |
Grab timezones appropriately in timetz test | diff --git a/pandas/tests/series/test_datetime_values.py b/pandas/tests/series/test_datetime_values.py
index 06eb525bbac56..b9eaa76cbe068 100644
--- a/pandas/tests/series/test_datetime_values.py
+++ b/pandas/tests/series/test_datetime_values.py
@@ -15,8 +15,7 @@
date_range, period_range, timedelta_range,
PeriodIndex, DatetimeIndex, TimedeltaIndex)
import pandas.core.common as com
-
-import dateutil
+from pandas._libs.tslibs.timezones import maybe_get_tz
from pandas.util.testing import assert_series_equal
import pandas.util.testing as tm
@@ -464,10 +463,7 @@ def test_datetime_understood(self):
def test_dt_timetz_accessor(self, tz_naive_fixture):
# GH21358
- if tz_naive_fixture is not None:
- tz = dateutil.tz.gettz(tz_naive_fixture)
- else:
- tz = None
+ tz = maybe_get_tz(tz_naive_fixture)
dtindex = pd.DatetimeIndex(['2014-04-04 23:56', '2014-07-18 21:24',
'2015-11-22 22:14'], tz=tz)
| - [x] closes #22337
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff` | https://api.github.com/repos/pandas-dev/pandas/pulls/22354 | 2018-08-14T23:29:46Z | 2018-08-16T10:32:32Z | 2018-08-16T10:32:32Z | 2018-08-16T16:54:39Z |
Drop redundant TestLocale | diff --git a/pandas/tests/util/test_testing.py b/pandas/tests/util/test_testing.py
index dee01ab6efff6..da84973274933 100644
--- a/pandas/tests/util/test_testing.py
+++ b/pandas/tests/util/test_testing.py
@@ -848,18 +848,6 @@ def test_RNGContext(self):
assert np.random.randn() == expected0
-class TestLocale(object):
-
- def test_locale(self):
- if sys.platform == 'win32':
- pytest.skip(
- "skipping on win platforms as locale not available")
-
- # GH9744
- locales = tm.get_locales()
- assert len(locales) >= 1
-
-
def test_datapath_missing(datapath, request):
if not request.config.getoption("--strict-data-files"):
pytest.skip("Need to set '--strict-data-files'")
diff --git a/pandas/tests/util/test_util.py b/pandas/tests/util/test_util.py
index c049dfc874940..6552655110557 100644
--- a/pandas/tests/util/test_util.py
+++ b/pandas/tests/util/test_util.py
@@ -455,6 +455,7 @@ def mockgetlocale():
def test_get_locales(self):
# all systems should have at least a single locale
+ # GH9744
assert len(tm.get_locales()) > 0
def test_get_locales_prefix(self):
| We have the `TestLocaleUtils` class in `tests/util/test_util.py`
https://github.com/pandas-dev/pandas/blob/master/pandas/tests/util/test_util.py#L421
which is more comprehensive and includes `test_get_locales` which is functionally identical.
- [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22349 | 2018-08-14T17:31:41Z | 2018-08-16T10:43:03Z | 2018-08-16T10:43:03Z | 2018-08-17T12:27:31Z |
API: ExtensionDtype._is_numeric | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index a018b4997bf7d..d7feb6e547b22 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -442,6 +442,7 @@ ExtensionType Changes
- ``ExtensionArray`` has gained the abstract methods ``.dropna()`` (:issue:`21185`)
- ``ExtensionDtype`` has gained the ability to instantiate from string dtypes, e.g. ``decimal`` would instantiate a registered ``DecimalDtype``; furthermore
the ``ExtensionDtype`` has gained the method ``construct_array_type`` (:issue:`21185`)
+- Added ``ExtensionDtype._is_numeric`` for controlling whether an extension dtype is considered numeric (:issue:`22290`).
- The ``ExtensionArray`` constructor, ``_from_sequence`` now take the keyword arg ``copy=False`` (:issue:`21185`)
- Bug in :meth:`Series.get` for ``Series`` using ``ExtensionArray`` and integer index (:issue:`21257`)
- :meth:`Series.combine()` works correctly with :class:`~pandas.api.extensions.ExtensionArray` inside of :class:`Series` (:issue:`20825`)
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index a1ce3541bd5d4..3dffabbe473d3 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -47,6 +47,10 @@ def is_signed_integer(self):
def is_unsigned_integer(self):
return self.kind == 'u'
+ @property
+ def _is_numeric(self):
+ return True
+
@cache_readonly
def numpy_dtype(self):
""" Return an instance of our numpy dtype """
diff --git a/pandas/core/dtypes/base.py b/pandas/core/dtypes/base.py
index 5f405e0d10657..1ecb6234ad2d9 100644
--- a/pandas/core/dtypes/base.py
+++ b/pandas/core/dtypes/base.py
@@ -94,6 +94,18 @@ def is_dtype(cls, dtype):
except TypeError:
return False
+ @property
+ def _is_numeric(self):
+ # type: () -> bool
+ """
+ Whether columns with this dtype should be considered numeric.
+
+ By default ExtensionDtypes are assumed to be non-numeric.
+ They'll be excluded from operations that exclude non-numeric
+ columns, like (groupby) reductions, plotting, etc.
+ """
+ return False
+
class ExtensionDtype(_DtypeOpsMixin):
"""A custom data type, to be paired with an ExtensionArray.
@@ -109,6 +121,11 @@ class ExtensionDtype(_DtypeOpsMixin):
* name
* construct_from_string
+ The following attributes influence the behavior of the dtype in
+ pandas operations
+
+ * _is_numeric
+
Optionally one can override construct_array_type for construction
with the name of this dtype via the Registry
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 0bfc7650a24aa..57d09ff33d8b4 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -665,7 +665,7 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
pass
newb = make_block(values, placement=self.mgr_locs,
- klass=klass)
+ klass=klass, ndim=self.ndim)
except:
if errors == 'raise':
raise
@@ -1950,6 +1950,10 @@ def is_view(self):
"""Extension arrays are never treated as views."""
return False
+ @property
+ def is_numeric(self):
+ return self.values.dtype._is_numeric
+
def setitem(self, indexer, value, mgr=None):
"""Set the value inplace, returning a same-typed block.
diff --git a/pandas/tests/extension/base/groupby.py b/pandas/tests/extension/base/groupby.py
index a29ef2a509a63..174997c7d51e1 100644
--- a/pandas/tests/extension/base/groupby.py
+++ b/pandas/tests/extension/base/groupby.py
@@ -67,3 +67,16 @@ def test_groupby_extension_apply(self, data_for_grouping, op):
df.groupby("B").A.apply(op)
df.groupby("A").apply(op)
df.groupby("A").B.apply(op)
+
+ def test_in_numeric_groupby(self, data_for_grouping):
+ df = pd.DataFrame({"A": [1, 1, 2, 2, 3, 3, 1, 4],
+ "B": data_for_grouping,
+ "C": [1, 1, 1, 1, 1, 1, 1, 1]})
+ result = df.groupby("A").sum().columns
+
+ if data_for_grouping.dtype._is_numeric:
+ expected = pd.Index(['B', 'C'])
+ else:
+ expected = pd.Index(['C'])
+
+ tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/extension/base/interface.py b/pandas/tests/extension/base/interface.py
index 69de0e1900831..99c3b92541cbd 100644
--- a/pandas/tests/extension/base/interface.py
+++ b/pandas/tests/extension/base/interface.py
@@ -67,3 +67,7 @@ def test_no_values_attribute(self, data):
# code, disallowing this for now until solved
assert not hasattr(data, 'values')
assert not hasattr(data, '_values')
+
+ def test_is_numeric_honored(self, data):
+ result = pd.Series(data)
+ assert result._data.blocks[0].is_numeric is data.dtype._is_numeric
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index f3475dead2418..387942234e6fd 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -44,6 +44,10 @@ def construct_from_string(cls, string):
raise TypeError("Cannot construct a '{}' from "
"'{}'".format(cls, string))
+ @property
+ def _is_numeric(self):
+ return True
+
class DecimalArray(ExtensionArray, ExtensionScalarOpsMixin):
diff --git a/pandas/tests/extension/integer/test_integer.py b/pandas/tests/extension/integer/test_integer.py
index e7f49c99d9f95..f1c833a68c66c 100644
--- a/pandas/tests/extension/integer/test_integer.py
+++ b/pandas/tests/extension/integer/test_integer.py
@@ -766,6 +766,22 @@ def test_cross_type_arithmetic():
tm.assert_series_equal(result, expected)
+def test_groupby_mean_included():
+ df = pd.DataFrame({
+ "A": ['a', 'b', 'b'],
+ "B": [1, None, 3],
+ "C": IntegerArray([1, None, 3], dtype='Int64'),
+ })
+
+ result = df.groupby("A").sum()
+ # TODO(#22346): preserve Int64 dtype
+ expected = pd.DataFrame({
+ "B": np.array([1.0, 3.0]),
+ "C": np.array([1, 3], dtype="int64")
+ }, index=pd.Index(['a', 'b'], name='A'))
+ tm.assert_frame_equal(result, expected)
+
+
def test_astype_nansafe():
# https://github.com/pandas-dev/pandas/pull/22343
arr = IntegerArray([np.nan, 1, 2], dtype="Int8")
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index 8e012922d25f1..d096daaa0b664 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -11,7 +11,8 @@
import numpy as np
from pandas import (DataFrame, Series, Timestamp, date_range, compat,
- option_context)
+ option_context, Categorical)
+from pandas.core.arrays import IntegerArray, IntervalArray
from pandas.compat import StringIO
import pandas as pd
@@ -436,6 +437,17 @@ def test_get_numeric_data(self):
expected = df
assert_frame_equal(result, expected)
+ def test_get_numeric_data_extension_dtype(self):
+ # GH 22290
+ df = DataFrame({
+ 'A': IntegerArray([-10, np.nan, 0, 10, 20, 30], dtype='Int64'),
+ 'B': Categorical(list('abcabc')),
+ 'C': IntegerArray([0, 1, 2, 3, np.nan, 5], dtype='UInt8'),
+ 'D': IntervalArray.from_breaks(range(7))})
+ result = df._get_numeric_data()
+ expected = df.loc[:, ['A', 'C']]
+ assert_frame_equal(result, expected)
+
def test_convert_objects(self):
oops = self.mixed_frame.T.T
| closes #22290
split from https://github.com/pandas-dev/pandas/pull/22325
It's not clear what else we should be testing, since I'm not sure what all uses `Block.is_numeric`.
cc @jschendel | https://api.github.com/repos/pandas-dev/pandas/pulls/22345 | 2018-08-14T15:37:19Z | 2018-08-20T11:18:11Z | 2018-08-20T11:18:11Z | 2018-08-20T14:02:54Z |
[CLN] Make more of numpy_helper unnecessary | diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 5918560cf1436..2fed95ff9ba3e 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -319,15 +319,14 @@ cdef class IndexEngine:
# form the set of the results (like ismember)
members = np.empty(n, dtype=np.uint8)
for i in range(n):
- val = util.get_value_1d(values, i)
+ val = values[i]
if val in stargets:
if val not in d:
d[val] = []
d[val].append(i)
for i in range(n_t):
-
- val = util.get_value_1d(targets, i)
+ val = targets[i]
# found
if val in d:
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index e05905ab63624..654e7eaf92ff0 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -1153,7 +1153,7 @@ def infer_dtype(object value, bint skipna=False):
# try to use a valid value
for i in range(n):
- val = util.get_value_1d(values, i)
+ val = values[i]
# do not use is_nul_datetimelike to keep
# np.datetime64('nat') and np.timedelta64('nat')
@@ -1240,7 +1240,7 @@ def infer_dtype(object value, bint skipna=False):
return 'interval'
for i in range(n):
- val = util.get_value_1d(values, i)
+ val = values[i]
if (util.is_integer_object(val) and
not util.is_timedelta64_object(val) and
not util.is_datetime64_object(val)):
@@ -2255,7 +2255,7 @@ def fast_multiget(dict mapping, ndarray keys, default=np.nan):
keys = getattr(keys, 'values', keys)
for i in range(n):
- val = util.get_value_1d(keys, i)
+ val = keys[i]
if val in mapping:
output[i] = mapping[val]
else:
diff --git a/pandas/_libs/src/numpy_helper.h b/pandas/_libs/src/numpy_helper.h
index d44334906901a..d9d0fb74da73c 100644
--- a/pandas/_libs/src/numpy_helper.h
+++ b/pandas/_libs/src/numpy_helper.h
@@ -28,20 +28,4 @@ PANDAS_INLINE PyObject* get_value_1d(PyArrayObject* ap, Py_ssize_t i) {
return PyArray_Scalar(item, PyArray_DESCR(ap), (PyObject*)ap);
}
-// returns ASCII or UTF8 (py3) view on python str
-// python object owns memory, should not be freed
-PANDAS_INLINE const char* get_c_string(PyObject* obj) {
-#if PY_VERSION_HEX >= 0x03000000
- return PyUnicode_AsUTF8(obj);
-#else
- return PyString_AsString(obj);
-#endif
-}
-
-void set_array_not_contiguous(PyArrayObject* ao) {
- // Numpy>=1.8-compliant equivalent to:
- // ao->flags &= ~(NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS);
- PyArray_CLEARFLAGS(ao, (NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS));
-}
-
#endif // PANDAS__LIBS_SRC_NUMPY_HELPER_H_
diff --git a/pandas/_libs/util.pxd b/pandas/_libs/util.pxd
index 31843a755e7b1..25d20c930cf08 100644
--- a/pandas/_libs/util.pxd
+++ b/pandas/_libs/util.pxd
@@ -5,13 +5,34 @@ from cython cimport Py_ssize_t
cimport numpy as cnp
from numpy cimport ndarray
+cdef extern from "numpy/ndarraytypes.h":
+ void PyArray_CLEARFLAGS(ndarray arr, int flags) nogil
+
+
+cdef extern from "numpy/arrayobject.h":
+ enum:
+ NPY_ARRAY_C_CONTIGUOUS
+ NPY_ARRAY_F_CONTIGUOUS
+
+
+cdef extern from *:
+ """
+ // returns ASCII or UTF8 (py3) view on python str
+ // python object owns memory, should not be freed
+ static const char* get_c_string(PyObject* obj) {
+ #if PY_VERSION_HEX >= 0x03000000
+ return PyUnicode_AsUTF8(obj);
+ #else
+ return PyString_AsString(obj);
+ #endif
+ }
+ """
+ const char *get_c_string(object) except NULL
-cdef extern from "src/numpy_helper.h":
- void set_array_not_contiguous(ndarray ao)
+cdef extern from "src/numpy_helper.h":
int assign_value_1d(ndarray, Py_ssize_t, object) except -1
object get_value_1d(ndarray, Py_ssize_t)
- const char *get_c_string(object) except NULL
cdef extern from "src/headers/stdint.h":
@@ -44,6 +65,13 @@ ctypedef fused numeric:
cnp.float64_t
+cdef inline void set_array_not_contiguous(ndarray ao) nogil:
+ # Numpy>=1.8-compliant equivalent to:
+ # ao->flags &= ~(NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS);
+ PyArray_CLEARFLAGS(ao,
+ (NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS))
+
+
cdef inline object get_value_at(ndarray arr, object loc):
cdef:
Py_ssize_t i, sz
| https://api.github.com/repos/pandas-dev/pandas/pulls/22344 | 2018-08-14T15:26:50Z | 2018-08-16T10:46:59Z | 2018-08-16T10:46:59Z | 2018-08-16T16:14:43Z | |
API: dispatch to EA.astype | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index cf12759c051fc..65494c7a789e2 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -446,7 +446,7 @@ ExtensionType Changes
- Bug in :meth:`Series.get` for ``Series`` using ``ExtensionArray`` and integer index (:issue:`21257`)
- :meth:`Series.combine()` works correctly with :class:`~pandas.api.extensions.ExtensionArray` inside of :class:`Series` (:issue:`20825`)
- :meth:`Series.combine()` with scalar argument now works for any function type (:issue:`21248`)
--
+- :meth:`Series.astype` and :meth:`DataFrame.astype` now dispatch to :meth:`ExtensionArray.astype` (:issue:`21185:`).
.. _whatsnew_0240.api.incompatibilities:
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index c126117060c3d..eef6a756e2bc9 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -8,6 +8,7 @@
from pandas.compat import u, range
from pandas.compat import set_function_name
+from pandas.core.dtypes.cast import astype_nansafe
from pandas.core.dtypes.generic import ABCSeries, ABCIndexClass
from pandas.core.dtypes.common import (
is_integer, is_scalar, is_float,
@@ -391,7 +392,7 @@ def astype(self, dtype, copy=True):
# coerce
data = self._coerce_to_ndarray()
- return data.astype(dtype=dtype, copy=False)
+ return astype_nansafe(data, dtype, copy=None)
@property
def _ndarray_values(self):
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 3971e90e64a14..410e061c895db 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -647,7 +647,16 @@ def conv(r, dtype):
def astype_nansafe(arr, dtype, copy=True):
""" return a view if copy is False, but
- need to be very careful as the result shape could change! """
+ need to be very careful as the result shape could change!
+
+ Parameters
+ ----------
+ arr : ndarray
+ dtype : np.dtype
+ copy : bool, default True
+ If False, a view will be attempted but may fail, if
+ e.g. the itemsizes don't align.
+ """
# dispatch on extension dtype if needed
if is_extension_array_dtype(dtype):
@@ -733,8 +742,10 @@ def astype_nansafe(arr, dtype, copy=True):
FutureWarning, stacklevel=5)
dtype = np.dtype(dtype.name + "[ns]")
- if copy:
+ if copy or is_object_dtype(arr) or is_object_dtype(dtype):
+ # Explicit copy, or required since NumPy can't view from / to object.
return arr.astype(dtype, copy=True)
+
return arr.view(dtype)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index f0635014b166b..0bfc7650a24aa 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -637,22 +637,25 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
# force the copy here
if values is None:
- if issubclass(dtype.type,
- (compat.text_type, compat.string_types)):
+ if self.is_extension:
+ values = self.values.astype(dtype)
+ else:
+ if issubclass(dtype.type,
+ (compat.text_type, compat.string_types)):
- # use native type formatting for datetime/tz/timedelta
- if self.is_datelike:
- values = self.to_native_types()
+ # use native type formatting for datetime/tz/timedelta
+ if self.is_datelike:
+ values = self.to_native_types()
- # astype formatting
- else:
- values = self.get_values()
+ # astype formatting
+ else:
+ values = self.get_values()
- else:
- values = self.get_values(dtype=dtype)
+ else:
+ values = self.get_values(dtype=dtype)
- # _astype_nansafe works fine with 1-d only
- values = astype_nansafe(values.ravel(), dtype, copy=True)
+ # _astype_nansafe works fine with 1-d only
+ values = astype_nansafe(values.ravel(), dtype, copy=True)
# TODO(extension)
# should we make this attribute?
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index 108b8874b3ac5..f3475dead2418 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -15,6 +15,17 @@ class DecimalDtype(ExtensionDtype):
name = 'decimal'
na_value = decimal.Decimal('NaN')
+ def __init__(self, context=None):
+ self.context = context or decimal.getcontext()
+
+ def __eq__(self, other):
+ if isinstance(other, type(self)):
+ return self.context == other.context
+ return super(DecimalDtype, self).__eq__(other)
+
+ def __repr__(self):
+ return 'DecimalDtype(context={})'.format(self.context)
+
@classmethod
def construct_array_type(cls):
"""Return the array type associated with this dtype
@@ -35,13 +46,12 @@ def construct_from_string(cls, string):
class DecimalArray(ExtensionArray, ExtensionScalarOpsMixin):
- dtype = DecimalDtype()
- def __init__(self, values, dtype=None, copy=False):
+ def __init__(self, values, dtype=None, copy=False, context=None):
for val in values:
- if not isinstance(val, self.dtype.type):
+ if not isinstance(val, decimal.Decimal):
raise TypeError("All values must be of type " +
- str(self.dtype.type))
+ str(decimal.Decimal))
values = np.asarray(values, dtype=object)
self._data = values
@@ -51,6 +61,11 @@ def __init__(self, values, dtype=None, copy=False):
# those aliases are currently not working due to assumptions
# in internal code (GH-20735)
# self._values = self.values = self.data
+ self._dtype = DecimalDtype(context)
+
+ @property
+ def dtype(self):
+ return self._dtype
@classmethod
def _from_sequence(cls, scalars, dtype=None, copy=False):
@@ -82,6 +97,11 @@ def copy(self, deep=False):
return type(self)(self._data.copy())
return type(self)(self)
+ def astype(self, dtype, copy=True):
+ if isinstance(dtype, type(self.dtype)):
+ return type(self)(self._data, context=dtype.context)
+ return super(DecimalArray, self).astype(dtype, copy)
+
def __setitem__(self, key, value):
if pd.api.types.is_list_like(value):
value = [decimal.Decimal(v) for v in value]
diff --git a/pandas/tests/extension/decimal/test_decimal.py b/pandas/tests/extension/decimal/test_decimal.py
index bc7237f263b1d..04e855242b5e6 100644
--- a/pandas/tests/extension/decimal/test_decimal.py
+++ b/pandas/tests/extension/decimal/test_decimal.py
@@ -205,6 +205,27 @@ def test_dataframe_constructor_with_dtype():
tm.assert_frame_equal(result, expected)
+@pytest.mark.parametrize("frame", [True, False])
+def test_astype_dispatches(frame):
+ # This is a dtype-specific test that ensures Series[decimal].astype
+ # gets all the way through to ExtensionArray.astype
+ # Designing a reliable smoke test that works for arbitrary data types
+ # is difficult.
+ data = pd.Series(DecimalArray([decimal.Decimal(2)]), name='a')
+ ctx = decimal.Context()
+ ctx.prec = 5
+
+ if frame:
+ data = data.to_frame()
+
+ result = data.astype(DecimalDtype(ctx))
+
+ if frame:
+ result = result['a']
+
+ assert result.dtype.context.prec == ctx.prec
+
+
class TestArithmeticOps(BaseDecimal, base.BaseArithmeticOpsTests):
def check_opname(self, s, op_name, other, exc=None):
diff --git a/pandas/tests/extension/integer/test_integer.py b/pandas/tests/extension/integer/test_integer.py
index 5e0f5bf0a5dcf..55451da8f7eed 100644
--- a/pandas/tests/extension/integer/test_integer.py
+++ b/pandas/tests/extension/integer/test_integer.py
@@ -697,6 +697,15 @@ def test_cross_type_arithmetic():
tm.assert_series_equal(result, expected)
+def test_astype_nansafe():
+ # https://github.com/pandas-dev/pandas/pull/22343
+ arr = IntegerArray([np.nan, 1, 2], dtype="Int8")
+
+ with tm.assert_raises_regex(
+ ValueError, 'cannot convert float NaN to integer'):
+ arr.astype('uint32')
+
+
# TODO(jreback) - these need testing / are broken
# shift
| Closes https://github.com/pandas-dev/pandas/issues/21296
split from https://github.com/pandas-dev/pandas/pull/22325
Note that this is just a partial fix to get sparse working. We have some issues:
for better or worse, categorical is still special cased. `Series[EA].astype('category')` will not yet dispatch to `EA.astype`. That's good non-pandas EAs won't have to worry about specially handling categorical. It's bad, since it's a special case.
And that's the second issue, in general, how should we handle astyping from EA1 -> EA2? In principle, we always have `ndarray[object]` as the lowest common denominator. So something like `EA2(EA.astype(object))` may work. But that won't necessarily be efficient. I'm not sure what's best here.
cc @xhochy | https://api.github.com/repos/pandas-dev/pandas/pulls/22343 | 2018-08-14T14:32:39Z | 2018-08-20T11:07:36Z | 2018-08-20T11:07:35Z | 2018-08-20T12:12:22Z |
BUG: Interval scalar arithmetic operations reset closed | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 9b70bda82e247..75c2a8acdc859 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -600,7 +600,7 @@ Interval
- Bug in the :class:`IntervalIndex` constructor where the ``closed`` parameter did not always override the inferred ``closed`` (:issue:`19370`)
- Bug in the ``IntervalIndex`` repr where a trailing comma was missing after the list of intervals (:issue:`20611`)
--
+- Bug in :class:`Interval` where scalar arithmetic operations did not retain the ``closed`` value (:issue:`22313`)
-
Indexing
diff --git a/pandas/_libs/interval.pyx b/pandas/_libs/interval.pyx
index 22153b58cc49b..5ae20a27c2381 100644
--- a/pandas/_libs/interval.pyx
+++ b/pandas/_libs/interval.pyx
@@ -326,36 +326,37 @@ cdef class Interval(IntervalMixin):
def __add__(self, y):
if isinstance(y, numbers.Number):
- return Interval(self.left + y, self.right + y)
+ return Interval(self.left + y, self.right + y, closed=self.closed)
elif isinstance(y, Interval) and isinstance(self, numbers.Number):
- return Interval(y.left + self, y.right + self)
+ return Interval(y.left + self, y.right + self, closed=y.closed)
return NotImplemented
def __sub__(self, y):
if isinstance(y, numbers.Number):
- return Interval(self.left - y, self.right - y)
+ return Interval(self.left - y, self.right - y, closed=self.closed)
return NotImplemented
def __mul__(self, y):
if isinstance(y, numbers.Number):
- return Interval(self.left * y, self.right * y)
+ return Interval(self.left * y, self.right * y, closed=self.closed)
elif isinstance(y, Interval) and isinstance(self, numbers.Number):
- return Interval(y.left * self, y.right * self)
+ return Interval(y.left * self, y.right * self, closed=y.closed)
return NotImplemented
def __div__(self, y):
if isinstance(y, numbers.Number):
- return Interval(self.left / y, self.right / y)
+ return Interval(self.left / y, self.right / y, closed=self.closed)
return NotImplemented
def __truediv__(self, y):
if isinstance(y, numbers.Number):
- return Interval(self.left / y, self.right / y)
+ return Interval(self.left / y, self.right / y, closed=self.closed)
return NotImplemented
def __floordiv__(self, y):
if isinstance(y, numbers.Number):
- return Interval(self.left // y, self.right // y)
+ return Interval(
+ self.left // y, self.right // y, closed=self.closed)
return NotImplemented
diff --git a/pandas/tests/scalar/interval/test_interval.py b/pandas/tests/scalar/interval/test_interval.py
index c9e6e84d226a8..8d17989ebc7b1 100644
--- a/pandas/tests/scalar/interval/test_interval.py
+++ b/pandas/tests/scalar/interval/test_interval.py
@@ -109,79 +109,103 @@ def test_length_errors(self, left, right):
with tm.assert_raises_regex(TypeError, msg):
iv.length
- def test_math_add(self, interval):
- expected = Interval(1, 2)
- actual = interval + 1
- assert expected == actual
+ def test_math_add(self, closed):
+ interval = Interval(0, 1, closed=closed)
+ expected = Interval(1, 2, closed=closed)
- expected = Interval(1, 2)
- actual = 1 + interval
- assert expected == actual
+ result = interval + 1
+ assert result == expected
+
+ result = 1 + interval
+ assert result == expected
- actual = interval
- actual += 1
- assert expected == actual
+ result = interval
+ result += 1
+ assert result == expected
msg = r"unsupported operand type\(s\) for \+"
with tm.assert_raises_regex(TypeError, msg):
- interval + Interval(1, 2)
+ interval + interval
with tm.assert_raises_regex(TypeError, msg):
interval + 'foo'
- def test_math_sub(self, interval):
- expected = Interval(-1, 0)
- actual = interval - 1
- assert expected == actual
+ def test_math_sub(self, closed):
+ interval = Interval(0, 1, closed=closed)
+ expected = Interval(-1, 0, closed=closed)
+
+ result = interval - 1
+ assert result == expected
- actual = interval
- actual -= 1
- assert expected == actual
+ result = interval
+ result -= 1
+ assert result == expected
msg = r"unsupported operand type\(s\) for -"
with tm.assert_raises_regex(TypeError, msg):
- interval - Interval(1, 2)
+ interval - interval
with tm.assert_raises_regex(TypeError, msg):
interval - 'foo'
- def test_math_mult(self, interval):
- expected = Interval(0, 2)
- actual = interval * 2
- assert expected == actual
+ def test_math_mult(self, closed):
+ interval = Interval(0, 1, closed=closed)
+ expected = Interval(0, 2, closed=closed)
+
+ result = interval * 2
+ assert result == expected
- expected = Interval(0, 2)
- actual = 2 * interval
- assert expected == actual
+ result = 2 * interval
+ assert result == expected
- actual = interval
- actual *= 2
- assert expected == actual
+ result = interval
+ result *= 2
+ assert result == expected
msg = r"unsupported operand type\(s\) for \*"
with tm.assert_raises_regex(TypeError, msg):
- interval * Interval(1, 2)
+ interval * interval
msg = r"can\'t multiply sequence by non-int"
with tm.assert_raises_regex(TypeError, msg):
interval * 'foo'
- def test_math_div(self, interval):
- expected = Interval(0, 0.5)
- actual = interval / 2.0
- assert expected == actual
+ def test_math_div(self, closed):
+ interval = Interval(0, 1, closed=closed)
+ expected = Interval(0, 0.5, closed=closed)
- actual = interval
- actual /= 2.0
- assert expected == actual
+ result = interval / 2.0
+ assert result == expected
+
+ result = interval
+ result /= 2.0
+ assert result == expected
msg = r"unsupported operand type\(s\) for /"
with tm.assert_raises_regex(TypeError, msg):
- interval / Interval(1, 2)
+ interval / interval
with tm.assert_raises_regex(TypeError, msg):
interval / 'foo'
+ def test_math_floordiv(self, closed):
+ interval = Interval(1, 2, closed=closed)
+ expected = Interval(0, 1, closed=closed)
+
+ result = interval // 2
+ assert result == expected
+
+ result = interval
+ result //= 2
+ assert result == expected
+
+ msg = r"unsupported operand type\(s\) for //"
+ with tm.assert_raises_regex(TypeError, msg):
+ interval // interval
+
+ with tm.assert_raises_regex(TypeError, msg):
+ interval // 'foo'
+
def test_constructor_errors(self):
msg = "invalid option for 'closed': foo"
with tm.assert_raises_regex(ValueError, msg):
| - [X] closes #22313
- [X] tests added / passed
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [X] whatsnew entry
Including this with 0.24.0 for the time being; I think this would be easy to backport into 0.23.5 since this looks to be disjoint from the other interval related changes but thought it best to play it safe. | https://api.github.com/repos/pandas-dev/pandas/pulls/22331 | 2018-08-14T04:24:22Z | 2018-08-14T14:28:28Z | 2018-08-14T14:28:28Z | 2018-08-14T14:28:57Z |
CLN: de-duplicate index validation code | diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 293f067810f27..b7a1471ae5a9e 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -50,23 +50,7 @@ cpdef get_value_at(ndarray arr, object loc, object tz=None):
cpdef object get_value_box(ndarray arr, object loc):
- cdef:
- Py_ssize_t i, sz
-
- if util.is_float_object(loc):
- casted = int(loc)
- if casted == loc:
- loc = casted
- i = <Py_ssize_t> loc
- sz = cnp.PyArray_SIZE(arr)
-
- if i < 0 and sz > 0:
- i += sz
-
- if i >= sz or sz == 0 or i < 0:
- raise IndexError('index out of bounds')
-
- return get_value_at(arr, i, tz=None)
+ return get_value_at(arr, loc, tz=None)
# Don't populate hash tables in monotonic indexes larger than this
diff --git a/pandas/_libs/util.pxd b/pandas/_libs/util.pxd
index 25d20c930cf08..e78f132ada2ca 100644
--- a/pandas/_libs/util.pxd
+++ b/pandas/_libs/util.pxd
@@ -72,23 +72,50 @@ cdef inline void set_array_not_contiguous(ndarray ao) nogil:
(NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS))
-cdef inline object get_value_at(ndarray arr, object loc):
+cdef inline Py_ssize_t validate_indexer(ndarray arr, object loc) except -1:
+ """
+ Cast the given indexer `loc` to an integer. If it is negative, i.e. a
+ python-style indexing-from-the-end indexer, translate it to a
+ from-the-front indexer. Raise if this is not possible.
+
+ Parameters
+ ----------
+ arr : ndarray
+ loc : object
+
+ Returns
+ -------
+ idx : Py_ssize_t
+
+ Raises
+ ------
+ IndexError
+ """
cdef:
- Py_ssize_t i, sz
+ Py_ssize_t idx, size
int casted
if is_float_object(loc):
casted = int(loc)
if casted == loc:
loc = casted
- i = <Py_ssize_t> loc
- sz = cnp.PyArray_SIZE(arr)
- if i < 0 and sz > 0:
- i += sz
- elif i >= sz or sz == 0:
+ idx = <Py_ssize_t>loc
+ size = cnp.PyArray_SIZE(arr)
+
+ if idx < 0 and size > 0:
+ idx += size
+ if idx >= size or size == 0 or idx < 0:
raise IndexError('index out of bounds')
+ return idx
+
+
+cdef inline object get_value_at(ndarray arr, object loc):
+ cdef:
+ Py_ssize_t i
+
+ i = validate_indexer(arr, loc)
return get_value_1d(arr, i)
@@ -99,19 +126,9 @@ cdef inline set_value_at_unsafe(ndarray arr, object loc, object value):
flag above the loop and then eschew the check on each iteration.
"""
cdef:
- Py_ssize_t i, sz
- if is_float_object(loc):
- casted = int(loc)
- if casted == loc:
- loc = casted
- i = <Py_ssize_t> loc
- sz = cnp.PyArray_SIZE(arr)
-
- if i < 0:
- i += sz
- elif i >= sz:
- raise IndexError('index out of bounds')
+ Py_ssize_t i
+ i = validate_indexer(arr, loc)
assign_value_1d(arr, i, value)
| There are currently 3 nearly-identical versions of this code. I'm pretty sure the strictest one is the most-correct, so that is made into the only one. | https://api.github.com/repos/pandas-dev/pandas/pulls/22329 | 2018-08-14T01:43:07Z | 2018-08-22T10:37:56Z | 2018-08-22T10:37:56Z | 2018-08-22T13:47:40Z |
CLN: Parameterize test case | diff --git a/pandas/tests/scalar/timestamp/test_unary_ops.py b/pandas/tests/scalar/timestamp/test_unary_ops.py
index 9f000a6f22cd6..bf41840c58ded 100644
--- a/pandas/tests/scalar/timestamp/test_unary_ops.py
+++ b/pandas/tests/scalar/timestamp/test_unary_ops.py
@@ -19,26 +19,19 @@ class TestTimestampUnaryOps(object):
# --------------------------------------------------------------
# Timestamp.round
-
- def test_round_day_naive(self):
- dt = Timestamp('20130101 09:10:11')
- result = dt.round('D')
- expected = Timestamp('20130101')
- assert result == expected
-
- dt = Timestamp('20130101 19:10:11')
- result = dt.round('D')
- expected = Timestamp('20130102')
- assert result == expected
-
- dt = Timestamp('20130201 12:00:00')
- result = dt.round('D')
- expected = Timestamp('20130202')
- assert result == expected
-
- dt = Timestamp('20130104 12:00:00')
- result = dt.round('D')
- expected = Timestamp('20130105')
+ @pytest.mark.parametrize('timestamp, freq, expected', [
+ ('20130101 09:10:11', 'D', '20130101'),
+ ('20130101 19:10:11', 'D', '20130102'),
+ ('20130201 12:00:00', 'D', '20130202'),
+ ('20130104 12:00:00', 'D', '20130105'),
+ ('2000-01-05 05:09:15.13', 'D', '2000-01-05 00:00:00'),
+ ('2000-01-05 05:09:15.13', 'H', '2000-01-05 05:00:00'),
+ ('2000-01-05 05:09:15.13', 'S', '2000-01-05 05:09:15')
+ ])
+ def test_round_frequencies(self, timestamp, freq, expected):
+ dt = Timestamp(timestamp)
+ result = dt.round(freq)
+ expected = Timestamp(expected)
assert result == expected
def test_round_tzaware(self):
@@ -85,16 +78,6 @@ def test_round_invalid_arg(self):
with tm.assert_raises_regex(ValueError, INVALID_FREQ_ERR_MSG):
stamp.round('foo')
- @pytest.mark.parametrize('freq, expected', [
- ('D', Timestamp('2000-01-05 00:00:00')),
- ('H', Timestamp('2000-01-05 05:00:00')),
- ('S', Timestamp('2000-01-05 05:09:15'))])
- def test_round_frequencies(self, freq, expected):
- stamp = Timestamp('2000-01-05 05:09:15.13')
-
- result = stamp.round(freq=freq)
- assert result == expected
-
@pytest.mark.parametrize('test_input, rounder, freq, expected', [
('2117-01-01 00:00:45', 'floor', '15s', '2117-01-01 00:00:45'),
('2117-01-01 00:00:45', 'ceil', '15s', '2117-01-01 00:00:45'),
| - [y] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
| https://api.github.com/repos/pandas-dev/pandas/pulls/22327 | 2018-08-13T23:07:19Z | 2018-08-14T10:08:58Z | 2018-08-14T10:08:58Z | 2018-08-14T10:09:01Z |
SparseArray is an ExtensionArray | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index a05ef67a7238f..67b166db89647 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -380,6 +380,37 @@ is the case with :attr:`Period.end_time`, for example
p.end_time
+.. _whatsnew_0240.api_breaking.sparse_values:
+
+Sparse Data Structure Refactor
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``SparseArray``, the array backing ``SparseSeries`` and the columns in a ``SparseDataFrame``,
+is now an extension array (:issue:`21978`, :issue:`19056`, :issue:`22835`).
+To conform to this interface and for consistency with the rest of pandas, some API breaking
+changes were made:
+
+- ``SparseArray`` is no longer a subclass of :class:`numpy.ndarray`. To convert a SparseArray to a NumPy array, use :meth:`numpy.asarray`.
+- ``SparseArray.dtype`` and ``SparseSeries.dtype`` are now instances of :class:`SparseDtype`, rather than ``np.dtype``. Access the underlying dtype with ``SparseDtype.subtype``.
+- :meth:`numpy.asarray(sparse_array)` now returns a dense array with all the values, not just the non-fill-value values (:issue:`14167`)
+- ``SparseArray.take`` now matches the API of :meth:`pandas.api.extensions.ExtensionArray.take` (:issue:`19506`):
+
+ * The default value of ``allow_fill`` has changed from ``False`` to ``True``.
+ * The ``out`` and ``mode`` parameters are now longer accepted (previously, this raised if they were specified).
+ * Passing a scalar for ``indices`` is no longer allowed.
+
+- The result of concatenating a mix of sparse and dense Series is a Series with sparse values, rather than a ``SparseSeries``.
+- ``SparseDataFrame.combine`` and ``DataFrame.combine_first`` no longer supports combining a sparse column with a dense column while preserving the sparse subtype. The result will be an object-dtype SparseArray.
+- Setting :attr:`SparseArray.fill_value` to a fill value with a different dtype is now allowed.
+
+
+Some new warnings are issued for operations that require or are likely to materialize a large dense array:
+
+- A :class:`errors.PerformanceWarning` is issued when using fillna with a ``method``, as a dense array is constructed to create the filled array. Filling with a ``value`` is the efficient way to fill a sparse array.
+- A :class:`errors.PerformanceWarning` is now issued when concatenating sparse Series with differing fill values. The fill value from the first sparse array continues to be used.
+
+In addition to these API breaking changes, many :ref:`performance improvements and bug fixes have been made <whatsnew_0240.bug_fixes.sparse>`.
+
.. _whatsnew_0240.api_breaking.frame_to_dict_index_orient:
Raise ValueError in ``DataFrame.to_dict(orient='index')``
@@ -573,6 +604,7 @@ update the ``ExtensionDtype._metadata`` tuple to match the signature of your
- Added :meth:`pandas.api.types.register_extension_dtype` to register an extension type with pandas (:issue:`22664`)
- Series backed by an ``ExtensionArray`` now work with :func:`util.hash_pandas_object` (:issue:`23066`)
- Updated the ``.type`` attribute for ``PeriodDtype``, ``DatetimeTZDtype``, and ``IntervalDtype`` to be instances of the dtype (``Period``, ``Timestamp``, and ``Interval`` respectively) (:issue:`22938`)
+- :func:`ExtensionArray.isna` is allowed to return an ``ExtensionArray`` (:issue:`22325`).
- Support for reduction operations such as ``sum``, ``mean`` via opt-in base class method override (:issue:`22762`)
.. _whatsnew_0240.api.incompatibilities:
@@ -655,6 +687,7 @@ Other API Changes
- :class:`pandas.io.formats.style.Styler` supports a ``number-format`` property when using :meth:`~pandas.io.formats.style.Styler.to_excel` (:issue:`22015`)
- :meth:`DataFrame.corr` and :meth:`Series.corr` now raise a ``ValueError`` along with a helpful error message instead of a ``KeyError`` when supplied with an invalid method (:issue:`22298`)
- :meth:`shift` will now always return a copy, instead of the previous behaviour of returning self when shifting by 0 (:issue:`22397`)
+- Slicing a single row of a DataFrame with multiple ExtensionArrays of the same type now preserves the dtype, rather than coercing to object (:issue:`22784`)
.. _whatsnew_0240.deprecations:
@@ -896,13 +929,6 @@ Groupby/Resample/Rolling
- :func:`RollingGroupby.agg` and :func:`ExpandingGroupby.agg` now support multiple aggregation functions as parameters (:issue:`15072`)
- Bug in :meth:`DataFrame.resample` and :meth:`Series.resample` when resampling by a weekly offset (``'W'``) across a DST transition (:issue:`9119`, :issue:`21459`)
-Sparse
-^^^^^^
-
--
--
--
-
Reshaping
^^^^^^^^^
@@ -921,6 +947,19 @@ Reshaping
- Bug in :func:`merge_asof` when merging on float values within defined tolerance (:issue:`22981`)
- Bug in :func:`pandas.concat` when concatenating a multicolumn DataFrame with tz-aware data against a DataFrame with a different number of columns (:issue`22796`)
+.. _whatsnew_0240.bug_fixes.sparse:
+
+Sparse
+^^^^^^
+
+- Updating a boolean, datetime, or timedelta column to be Sparse now works (:issue:`22367`)
+- Bug in :meth:`Series.to_sparse` with Series already holding sparse data not constructing properly (:issue:`22389`)
+- Providing a ``sparse_index`` to the SparseArray constructor no longer defaults the na-value to ``np.nan`` for all dtypes. The correct na_value for ``data.dtype`` is now used.
+- Bug in ``SparseArray.nbytes`` under-reporting its memory usage by not including the size of its sparse index.
+- Improved performance of :meth:`Series.shift` for non-NA ``fill_value``, as values are no longer converted to a dense array.
+- Bug in ``DataFrame.groupby`` not including ``fill_value`` in the groups for non-NA ``fill_value`` when grouping by a sparse column (:issue:`5078`)
+- Bug in unary inversion operator (``~``) on a ``SparseSeries`` with boolean values. The performance of this has also been improved (:issue:`22835`)
+
Build Changes
^^^^^^^^^^^^^
diff --git a/pandas/_libs/sparse.pyx b/pandas/_libs/sparse.pyx
index d852711d3b707..6b6c442632e4c 100644
--- a/pandas/_libs/sparse.pyx
+++ b/pandas/_libs/sparse.pyx
@@ -68,6 +68,10 @@ cdef class IntIndex(SparseIndex):
output += 'Indices: %s\n' % repr(self.indices)
return output
+ @property
+ def nbytes(self):
+ return self.indices.nbytes
+
def check_integrity(self):
"""
Checks the following:
@@ -359,6 +363,10 @@ cdef class BlockIndex(SparseIndex):
return output
+ @property
+ def nbytes(self):
+ return self.blocs.nbytes + self.blengths.nbytes
+
@property
def ngaps(self):
return self.length - self.npoints
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index ef7e25033f24e..b745569d5bd76 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -287,10 +287,25 @@ def astype(self, dtype, copy=True):
return np.array(self, dtype=dtype, copy=copy)
def isna(self):
- # type: () -> np.ndarray
- """Boolean NumPy array indicating if each value is missing.
+ # type: () -> Union[ExtensionArray, np.ndarray]
+ """
+ A 1-D array indicating if each value is missing.
+
+ Returns
+ -------
+ na_values : Union[np.ndarray, ExtensionArray]
+ In most cases, this should return a NumPy ndarray. For
+ exceptional cases like ``SparseArray``, where returning
+ an ndarray would be expensive, an ExtensionArray may be
+ returned.
+
+ Notes
+ -----
+ If returning an ExtensionArray, then
- This should return a 1-D array the same length as 'self'.
+ * ``na_values._is_boolean`` should be True
+ * `na_values` should implement :func:`ExtensionArray._reduce`
+ * ``na_values.any`` and ``na_values.all`` should be implemented
"""
raise AbstractMethodError(self)
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 14e47936e1b50..8bbaabe8c08af 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -14,7 +14,9 @@
from pandas import compat
from pandas.compat import iteritems, PY36, OrderedDict
-from pandas.core.dtypes.generic import ABCSeries, ABCIndex, ABCIndexClass
+from pandas.core.dtypes.generic import (
+ ABCSeries, ABCIndex, ABCIndexClass
+)
from pandas.core.dtypes.common import (
is_integer, is_bool_dtype, is_extension_array_dtype, is_array_like
)
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index a9fc9d13d4ab3..7a4e7022f7819 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -12,6 +12,7 @@
PeriodDtype, IntervalDtype,
PandasExtensionDtype, ExtensionDtype,
_pandas_registry)
+from pandas.core.sparse.dtype import SparseDtype
from pandas.core.dtypes.generic import (
ABCCategorical, ABCPeriodIndex, ABCDatetimeIndex, ABCSeries,
ABCSparseArray, ABCSparseSeries, ABCCategoricalIndex, ABCIndexClass,
@@ -180,8 +181,10 @@ def is_sparse(arr):
>>> is_sparse(bsr_matrix([1, 2, 3]))
False
"""
+ from pandas.core.sparse.dtype import SparseDtype
- return isinstance(arr, (ABCSparseArray, ABCSparseSeries))
+ dtype = getattr(arr, 'dtype', arr)
+ return isinstance(dtype, SparseDtype)
def is_scipy_sparse(arr):
@@ -1643,8 +1646,9 @@ def is_bool_dtype(arr_or_dtype):
True
>>> is_bool_dtype(pd.Categorical([True, False]))
True
+ >>> is_bool_dtype(pd.SparseArray([True, False]))
+ True
"""
-
if arr_or_dtype is None:
return False
try:
@@ -1751,6 +1755,8 @@ def is_extension_array_dtype(arr_or_dtype):
array interface. In pandas, this includes:
* Categorical
+ * Sparse
+ * Interval
Third-party libraries may implement arrays or types satisfying
this interface as well.
@@ -1873,7 +1879,8 @@ def _get_dtype(arr_or_dtype):
return PeriodDtype.construct_from_string(arr_or_dtype)
elif is_interval_dtype(arr_or_dtype):
return IntervalDtype.construct_from_string(arr_or_dtype)
- elif isinstance(arr_or_dtype, (ABCCategorical, ABCCategoricalIndex)):
+ elif isinstance(arr_or_dtype, (ABCCategorical, ABCCategoricalIndex,
+ ABCSparseArray, ABCSparseSeries)):
return arr_or_dtype.dtype
if hasattr(arr_or_dtype, 'dtype'):
@@ -1921,6 +1928,10 @@ def _get_dtype_type(arr_or_dtype):
elif is_interval_dtype(arr_or_dtype):
return Interval
return _get_dtype_type(np.dtype(arr_or_dtype))
+ elif isinstance(arr_or_dtype, (ABCSparseSeries, ABCSparseArray,
+ SparseDtype)):
+ dtype = getattr(arr_or_dtype, 'dtype', arr_or_dtype)
+ return dtype.type
try:
return arr_or_dtype.dtype.type
except AttributeError:
diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index c1aab961dcc9f..ac824708245d2 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -93,11 +93,13 @@ def _get_series_result_type(result, objs=None):
def _get_frame_result_type(result, objs):
"""
return appropriate class of DataFrame-like concat
- if all blocks are SparseBlock, return SparseDataFrame
+ if all blocks are sparse, return SparseDataFrame
otherwise, return 1st obj
"""
- if result.blocks and all(b.is_sparse for b in result.blocks):
+ if (result.blocks and (
+ all(is_sparse(b) for b in result.blocks) or
+ all(isinstance(obj, ABCSparseDataFrame) for obj in objs))):
from pandas.core.sparse.api import SparseDataFrame
return SparseDataFrame
else:
@@ -554,61 +556,23 @@ def _concat_sparse(to_concat, axis=0, typs=None):
a single array, preserving the combined dtypes
"""
- from pandas.core.sparse.array import SparseArray, _make_index
+ from pandas.core.sparse.array import SparseArray
- def convert_sparse(x, axis):
- # coerce to native type
- if isinstance(x, SparseArray):
- x = x.get_values()
- else:
- x = np.asarray(x)
- x = x.ravel()
- if axis > 0:
- x = np.atleast_2d(x)
- return x
+ fill_values = [x.fill_value for x in to_concat
+ if isinstance(x, SparseArray)]
- if typs is None:
- typs = get_dtype_kinds(to_concat)
+ if len(set(fill_values)) > 1:
+ raise ValueError("Cannot concatenate SparseArrays with different "
+ "fill values")
- if len(typs) == 1:
- # concat input as it is if all inputs are sparse
- # and have the same fill_value
- fill_values = {c.fill_value for c in to_concat}
- if len(fill_values) == 1:
- sp_values = [c.sp_values for c in to_concat]
- indexes = [c.sp_index.to_int_index() for c in to_concat]
-
- indices = []
- loc = 0
- for idx in indexes:
- indices.append(idx.indices + loc)
- loc += idx.length
- sp_values = np.concatenate(sp_values)
- indices = np.concatenate(indices)
- sp_index = _make_index(loc, indices, kind=to_concat[0].sp_index)
-
- return SparseArray(sp_values, sparse_index=sp_index,
- fill_value=to_concat[0].fill_value)
-
- # input may be sparse / dense mixed and may have different fill_value
- # input must contain sparse at least 1
- sparses = [c for c in to_concat if is_sparse(c)]
- fill_values = [c.fill_value for c in sparses]
- sp_indexes = [c.sp_index for c in sparses]
-
- # densify and regular concat
- to_concat = [convert_sparse(x, axis) for x in to_concat]
- result = np.concatenate(to_concat, axis=axis)
-
- if not len(typs - {'sparse', 'f', 'i'}):
- # sparsify if inputs are sparse and dense numerics
- # first sparse input's fill_value and SparseIndex is used
- result = SparseArray(result.ravel(), fill_value=fill_values[0],
- kind=sp_indexes[0])
- else:
- # coerce to object if needed
- result = result.astype('object')
- return result
+ fill_value = fill_values[0]
+
+ # TODO: Fix join unit generation so we aren't passed this.
+ to_concat = [x if isinstance(x, SparseArray)
+ else SparseArray(x.squeeze(), fill_value=fill_value)
+ for x in to_concat]
+
+ return SparseArray._concat_same_type(to_concat)
def _concat_rangeindex_same_dtype(indexes):
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index 66998aa6866f6..e48d09ae9a96a 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -499,6 +499,19 @@ def na_value_for_dtype(dtype, compat=True):
Returns
-------
np.dtype or a pandas dtype
+
+ Examples
+ --------
+ >>> na_value_for_dtype(np.dtype('int64'))
+ 0
+ >>> na_value_for_dtype(np.dtype('int64'), compat=False)
+ nan
+ >>> na_value_for_dtype(np.dtype('float64'))
+ nan
+ >>> na_value_for_dtype(np.dtype('bool'))
+ False
+ >>> na_value_for_dtype(np.dtype('datetime64[ns]'))
+ NaT
"""
dtype = pandas_dtype(dtype)
diff --git a/pandas/core/internals/__init__.py b/pandas/core/internals/__init__.py
index 22caa577c2891..7d6aa6a42efc2 100644
--- a/pandas/core/internals/__init__.py
+++ b/pandas/core/internals/__init__.py
@@ -5,7 +5,7 @@
make_block, # io.pytables, io.packers
FloatBlock, IntBlock, ComplexBlock, BoolBlock, ObjectBlock,
TimeDeltaBlock, DatetimeBlock, DatetimeTZBlock,
- CategoricalBlock, ExtensionBlock, SparseBlock, ScalarBlock,
+ CategoricalBlock, ExtensionBlock, ScalarBlock,
Block)
from .managers import ( # noqa:F401
BlockManager, SingleBlockManager,
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 93930fd844b95..214fcb097f736 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -24,7 +24,7 @@
is_integer,
is_dtype_equal,
is_timedelta64_dtype,
- is_datetime64_dtype, is_datetimetz, is_sparse,
+ is_datetime64_dtype, is_datetimetz,
is_categorical, is_categorical_dtype,
is_integer_dtype,
is_datetime64tz_dtype,
@@ -65,7 +65,6 @@
from pandas.core.base import PandasObject
from pandas.core.arrays import Categorical
-from pandas.core.sparse.array import SparseArray
from pandas.core.indexes.datetimes import DatetimeIndex
from pandas.core.indexes.timedeltas import TimedeltaIndex
@@ -344,7 +343,11 @@ def dtype(self):
@property
def ftype(self):
- return "{dtype}:{ftype}".format(dtype=self.dtype, ftype=self._ftype)
+ if getattr(self.values, '_pandas_ftype', False):
+ dtype = self.dtype.subtype
+ else:
+ dtype = self.dtype
+ return "{dtype}:{ftype}".format(dtype=dtype, ftype=self._ftype)
def merge(self, other):
return _merge_blocks([self, other])
@@ -623,7 +626,6 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
# convert dtypes if needed
dtype = pandas_dtype(dtype)
-
# astype processing
if is_dtype_equal(self.dtype, dtype):
if copy:
@@ -633,6 +635,9 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
if klass is None:
if dtype == np.object_:
klass = ObjectBlock
+ elif is_extension_array_dtype(dtype):
+ klass = ExtensionBlock
+
try:
# force the copy here
if values is None:
@@ -1615,6 +1620,12 @@ def quantile(self, qs, interpolation='linear', axis=0, mgr=None):
values, _, _, _ = self._try_coerce_args(values, values)
def _nanpercentile1D(values, mask, q, **kw):
+ # mask is Union[ExtensionArray, ndarray]
+ # we convert to an ndarray for NumPy 1.9 compat, which didn't
+ # treat boolean-like arrays as boolean. This conversion would have
+ # been done inside ndarray.__getitem__ anyway, since values is
+ # an ndarray at this point.
+ mask = np.asarray(mask)
values = values[~mask]
if len(values) == 0:
@@ -2080,6 +2091,10 @@ def shift(self, periods, axis=0, mgr=None):
placement=self.mgr_locs,
ndim=self.ndim)]
+ @property
+ def _ftype(self):
+ return getattr(self.values, '_pandas_ftype', Block._ftype)
+
class NumericBlock(Block):
__slots__ = ()
@@ -2300,7 +2315,8 @@ def _try_coerce_result(self, result):
return result
def should_store(self, value):
- return issubclass(value.dtype.type, np.timedelta64)
+ return (issubclass(value.dtype.type, np.timedelta64) and
+ not is_extension_array_dtype(value))
def to_native_types(self, slicer=None, na_rep=None, quoting=None,
**kwargs):
@@ -2339,7 +2355,8 @@ def _can_hold_element(self, element):
return isinstance(element, (bool, np.bool_))
def should_store(self, value):
- return issubclass(value.dtype.type, np.bool_)
+ return (issubclass(value.dtype.type, np.bool_) and not
+ is_extension_array_dtype(value))
def replace(self, to_replace, value, inplace=False, filter=None,
regex=False, convert=True, mgr=None):
@@ -2877,7 +2894,8 @@ def to_native_types(self, slicer=None, na_rep=None, date_format=None,
def should_store(self, value):
return (issubclass(value.dtype.type, np.datetime64) and
- not is_datetimetz(value))
+ not is_datetimetz(value) and
+ not is_extension_array_dtype(value))
def set(self, locs, values, check=False):
"""
@@ -3104,164 +3122,6 @@ def concat_same_type(self, to_concat, placement=None):
values, placement=placement or slice(0, len(values), 1))
-class SparseBlock(NonConsolidatableMixIn, Block):
- """ implement as a list of sparse arrays of the same dtype """
- __slots__ = ()
- is_sparse = True
- is_numeric = True
- _box_to_block_values = False
- _can_hold_na = True
- _ftype = 'sparse'
- _concatenator = staticmethod(_concat._concat_sparse)
-
- def __init__(self, values, placement, ndim=None):
- # Ensure that we have the underlying SparseArray here...
- if isinstance(values, ABCSeries):
- values = values.values
- assert isinstance(values, SparseArray)
- super(SparseBlock, self).__init__(values, placement, ndim=ndim)
-
- @property
- def _holder(self):
- return SparseArray
-
- @property
- def shape(self):
- return (len(self.mgr_locs), self.sp_index.length)
-
- @property
- def fill_value(self):
- # return np.nan
- return self.values.fill_value
-
- @fill_value.setter
- def fill_value(self, v):
- self.values.fill_value = v
-
- def to_dense(self):
- return self.values.to_dense().view()
-
- @property
- def sp_values(self):
- return self.values.sp_values
-
- @sp_values.setter
- def sp_values(self, v):
- # reset the sparse values
- self.values = SparseArray(v, sparse_index=self.sp_index,
- kind=self.kind, dtype=v.dtype,
- fill_value=self.values.fill_value,
- copy=False)
-
- @property
- def sp_index(self):
- return self.values.sp_index
-
- @property
- def kind(self):
- return self.values.kind
-
- def _astype(self, dtype, copy=False, errors='raise', values=None,
- klass=None, mgr=None, **kwargs):
- if values is None:
- values = self.values
- values = values.astype(dtype, copy=copy)
- return self.make_block_same_class(values=values,
- placement=self.mgr_locs)
-
- def __len__(self):
- try:
- return self.sp_index.length
- except AttributeError:
- return 0
-
- def copy(self, deep=True, mgr=None):
- return self.make_block_same_class(values=self.values,
- sparse_index=self.sp_index,
- kind=self.kind, copy=deep,
- placement=self.mgr_locs)
-
- def make_block_same_class(self, values, placement, sparse_index=None,
- kind=None, dtype=None, fill_value=None,
- copy=False, ndim=None):
- """ return a new block """
- if dtype is None:
- dtype = values.dtype
- if fill_value is None and not isinstance(values, SparseArray):
- fill_value = self.values.fill_value
-
- # if not isinstance(values, SparseArray) and values.ndim != self.ndim:
- # raise ValueError("ndim mismatch")
-
- if values.ndim == 2:
- nitems = values.shape[0]
-
- if nitems == 0:
- # kludgy, but SparseBlocks cannot handle slices, where the
- # output is 0-item, so let's convert it to a dense block: it
- # won't take space since there's 0 items, plus it will preserve
- # the dtype.
- return self.make_block(np.empty(values.shape, dtype=dtype),
- placement)
- elif nitems > 1:
- raise ValueError("Only 1-item 2d sparse blocks are supported")
- else:
- values = values.reshape(values.shape[1])
-
- new_values = SparseArray(values, sparse_index=sparse_index,
- kind=kind or self.kind, dtype=dtype,
- fill_value=fill_value, copy=copy)
- return self.make_block(new_values,
- placement=placement)
-
- def interpolate(self, method='pad', axis=0, inplace=False, limit=None,
- fill_value=None, **kwargs):
-
- values = missing.interpolate_2d(self.values.to_dense(), method, axis,
- limit, fill_value)
- return self.make_block_same_class(values=values,
- placement=self.mgr_locs)
-
- def fillna(self, value, limit=None, inplace=False, downcast=None,
- mgr=None):
- # we may need to upcast our fill to match our dtype
- if limit is not None:
- raise NotImplementedError("specifying a limit for 'fillna' has "
- "not been implemented yet")
- values = self.values if inplace else self.values.copy()
- values = values.fillna(value, downcast=downcast)
- return [self.make_block_same_class(values=values,
- placement=self.mgr_locs)]
-
- def shift(self, periods, axis=0, mgr=None):
- """ shift the block by periods """
- N = len(self.values.T)
- indexer = np.zeros(N, dtype=int)
- if periods > 0:
- indexer[periods:] = np.arange(N - periods)
- else:
- indexer[:periods] = np.arange(-periods, N)
- new_values = self.values.to_dense().take(indexer)
- # convert integer to float if necessary. need to do a lot more than
- # that, handle boolean etc also
- new_values, fill_value = maybe_upcast(new_values)
- if periods > 0:
- new_values[:periods] = fill_value
- else:
- new_values[periods:] = fill_value
- return [self.make_block_same_class(new_values,
- placement=self.mgr_locs)]
-
- def sparse_reindex(self, new_index):
- """ sparse reindex and return a new block
- current reindex only works for float64 dtype! """
- values = self.values
- values = values.sp_index.to_int_index().reindex(
- values.sp_values.astype('float64'), values.fill_value, new_index)
- return self.make_block_same_class(values, sparse_index=new_index,
- placement=self.mgr_locs)
-
-
# -----------------------------------------------------------------
# Constructor Helpers
@@ -3281,8 +3141,10 @@ def get_block_type(values, dtype=None):
dtype = dtype or values.dtype
vtype = dtype.type
- if is_sparse(values):
- cls = SparseBlock
+ if is_categorical(values):
+ cls = CategoricalBlock
+ elif is_extension_array_dtype(values):
+ cls = ExtensionBlock
elif issubclass(vtype, np.floating):
cls = FloatBlock
elif issubclass(vtype, np.timedelta64):
@@ -3290,10 +3152,6 @@ def get_block_type(values, dtype=None):
cls = TimeDeltaBlock
elif issubclass(vtype, np.complexfloating):
cls = ComplexBlock
- elif is_categorical(values):
- cls = CategoricalBlock
- elif is_extension_array_dtype(values):
- cls = ExtensionBlock
elif issubclass(vtype, np.datetime64):
assert not is_datetimetz(values)
cls = DatetimeBlock
@@ -3350,7 +3208,11 @@ def _block_shape(values, ndim=1, shape=None):
if values.ndim < ndim:
if shape is None:
shape = values.shape
- values = values.reshape(tuple((1, ) + shape))
+ if not is_extension_array_dtype(values):
+ # TODO: https://github.com/pandas-dev/pandas/issues/23023
+ # block.shape is incorrect for "2D" ExtensionArrays
+ # We can't, and don't need to, reshape.
+ values = values.reshape(tuple((1, ) + shape))
return values
diff --git a/pandas/core/internals/concat.py b/pandas/core/internals/concat.py
index 1fc9d961285be..dfb7408384038 100644
--- a/pandas/core/internals/concat.py
+++ b/pandas/core/internals/concat.py
@@ -14,6 +14,7 @@
is_datetime64_dtype, is_datetimetz,
is_categorical_dtype,
is_float_dtype, is_numeric_dtype,
+ is_sparse,
_get_dtype)
from pandas.core.dtypes.cast import maybe_promote
import pandas.core.dtypes.concat as _concat
@@ -150,11 +151,8 @@ def is_na(self):
values = self.block.values
if self.block.is_categorical:
values_flat = values.categories
- elif self.block.is_sparse:
- # fill_value is not NaN and have holes
- if not values._null_fill_value and values.sp_index.ngaps > 0:
- return False
- values_flat = values.ravel(order='K')
+ elif is_sparse(self.block.values.dtype):
+ return False
elif self.block.is_extension:
values_flat = values
else:
@@ -272,7 +270,6 @@ def get_empty_dtype_and_na(join_units):
dtype
na
"""
-
if len(join_units) == 1:
blk = join_units[0].block
if blk is None:
@@ -310,6 +307,8 @@ def get_empty_dtype_and_na(join_units):
upcast_cls = 'datetime'
elif is_timedelta64_dtype(dtype):
upcast_cls = 'timedelta'
+ elif is_sparse(dtype):
+ upcast_cls = dtype.subtype.name
elif is_float_dtype(dtype) or is_numeric_dtype(dtype):
upcast_cls = dtype.name
else:
@@ -344,14 +343,19 @@ def get_empty_dtype_and_na(join_units):
elif 'timedelta' in upcast_classes:
return np.dtype('m8[ns]'), tslibs.iNaT
else: # pragma
- g = np.find_common_type(upcast_classes, [])
- if is_float_dtype(g):
- return g, g.type(np.nan)
- elif is_numeric_dtype(g):
- if has_none_blocks:
- return np.float64, np.nan
- else:
- return g, None
+ try:
+ g = np.find_common_type(upcast_classes, [])
+ except TypeError:
+ # At least one is an ExtensionArray
+ return np.dtype(np.object_), np.nan
+ else:
+ if is_float_dtype(g):
+ return g, g.type(np.nan)
+ elif is_numeric_dtype(g):
+ if has_none_blocks:
+ return np.float64, np.nan
+ else:
+ return g, None
msg = "invalid dtype determination in get_concat_dtype"
raise AssertionError(msg)
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 2f29f1ae2509f..3667d7c5e39dc 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -37,7 +37,7 @@
from pandas.io.formats.printing import pprint_thing
from .blocks import (
- Block, DatetimeTZBlock, CategoricalBlock, ExtensionBlock, SparseBlock,
+ Block, DatetimeTZBlock, CategoricalBlock, ExtensionBlock,
_extend_blocks, _merge_blocks, _safe_reshape,
make_block, get_block_type)
from .concat import ( # all for concatenate_block_managers
@@ -737,7 +737,6 @@ def copy(self, deep=True, mgr=None):
-------
copy : BlockManager
"""
-
# this preserves the notion of view copying of axes
if deep:
if deep == 'all':
@@ -786,11 +785,14 @@ def _interleave(self):
Return ndarray from blocks with specified item order
Items must be contained in the blocks
"""
+ from pandas.core.dtypes.common import is_sparse
dtype = _interleaved_dtype(self.blocks)
- if is_extension_array_dtype(dtype):
- # TODO: https://github.com/pandas-dev/pandas/issues/22791
- # Give EAs some input on what happens here. Sparse needs this.
+ # TODO: https://github.com/pandas-dev/pandas/issues/22791
+ # Give EAs some input on what happens here. Sparse needs this.
+ if is_sparse(dtype):
+ dtype = dtype.subtype
+ elif is_extension_array_dtype(dtype):
dtype = 'object'
result = np.empty(self.shape, dtype=dtype)
@@ -1834,7 +1836,7 @@ def _sparse_blockify(tuples, dtype=None):
new_blocks = []
for i, names, array in tuples:
array = _maybe_to_sparse(array)
- block = make_block(array, klass=SparseBlock, placement=[i])
+ block = make_block(array, placement=[i])
new_blocks.append(block)
return new_blocks
@@ -2044,10 +2046,9 @@ def concatenate_block_managers(mgrs_indexers, axes, concat_axis, copy):
copy : bool
"""
- concat_plan = combine_concat_plans(
- [get_mgr_concatenation_plan(mgr, indexers)
- for mgr, indexers in mgrs_indexers], concat_axis)
-
+ concat_plans = [get_mgr_concatenation_plan(mgr, indexers)
+ for mgr, indexers in mgrs_indexers]
+ concat_plan = combine_concat_plans(concat_plans, concat_axis)
blocks = []
for placement, join_units in concat_plan:
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index 20559bca9caed..640b2812d3e85 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -2066,16 +2066,19 @@ def _cast_sparse_series_op(left, right, opname):
left : SparseArray
right : SparseArray
"""
+ from pandas.core.sparse.api import SparseDtype
+
opname = opname.strip('_')
+ # TODO: This should be moved to the array?
if is_integer_dtype(left) and is_integer_dtype(right):
# series coerces to float64 if result should have NaN/inf
if opname in ('floordiv', 'mod') and (right.values == 0).any():
- left = left.astype(np.float64)
- right = right.astype(np.float64)
+ left = left.astype(SparseDtype(np.float64, left.fill_value))
+ right = right.astype(SparseDtype(np.float64, right.fill_value))
elif opname in ('rfloordiv', 'rmod') and (left.values == 0).any():
- left = left.astype(np.float64)
- right = right.astype(np.float64)
+ left = left.astype(SparseDtype(np.float64, left.fill_value))
+ right = right.astype(SparseDtype(np.float64, right.fill_value))
return left, right
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index 495e59d0882de..7bee1ba0e2eb2 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -10,6 +10,7 @@
from pandas.core.dtypes.common import (
ensure_platform_int,
is_list_like, is_bool_dtype,
+ is_extension_array_dtype,
needs_i8_conversion, is_sparse, is_object_dtype)
from pandas.core.dtypes.cast import maybe_promote
from pandas.core.dtypes.missing import notna
@@ -427,7 +428,6 @@ def stack(frame, level=-1, dropna=True):
-------
stacked : Series
"""
-
def factorize(index):
if index.is_unique:
return index, np.arange(len(index))
@@ -461,7 +461,25 @@ def factorize(index):
names=[frame.index.name, frame.columns.name],
verify_integrity=False)
- new_values = frame.values.ravel()
+ if frame._is_homogeneous_type:
+ # For homogeneous EAs, frame.values will coerce to object. So
+ # we concatenate instead.
+ dtypes = list(frame.dtypes.values)
+ dtype = dtypes[0]
+
+ if is_extension_array_dtype(dtype):
+ arr = dtype.construct_array_type()
+ new_values = arr._concat_same_type([
+ col for _, col in frame.iteritems()
+ ])
+ else:
+ # homogeneous, non-EA
+ new_values = frame.values.ravel()
+
+ else:
+ # non-homogeneous
+ new_values = frame.values.ravel()
+
if dropna:
mask = notna(new_values)
new_values = new_values[mask]
diff --git a/pandas/core/series.py b/pandas/core/series.py
index bff0f9fe25532..4f6bca93d377b 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -35,7 +35,8 @@
ensure_platform_int,
pandas_dtype)
from pandas.core.dtypes.generic import (
- ABCSparseArray, ABCDataFrame, ABCIndexClass)
+ ABCSparseArray, ABCDataFrame, ABCIndexClass,
+ ABCSeries, ABCSparseSeries)
from pandas.core.dtypes.cast import (
maybe_upcast, infer_dtype_from_scalar,
maybe_convert_platform,
@@ -210,7 +211,7 @@ def __init__(self, data=None, index=None, dtype=None, name=None,
elif isinstance(data, np.ndarray):
pass
- elif isinstance(data, Series):
+ elif isinstance(data, (ABCSeries, ABCSparseSeries)):
if name is None:
name = data.name
if index is None:
@@ -661,7 +662,8 @@ def __array_prepare__(self, result, context=None):
"""
# nice error message for non-ufunc types
- if context is not None and not isinstance(self._values, np.ndarray):
+ if (context is not None and
+ not isinstance(self._values, (np.ndarray, ABCSparseArray))):
obj = context[1][0]
raise TypeError("{obj} with dtype {dtype} cannot perform "
"the numpy op {op}".format(
@@ -1380,9 +1382,14 @@ def to_sparse(self, kind='block', fill_value=None):
-------
sp : SparseSeries
"""
+ # TODO: deprecate
from pandas.core.sparse.series import SparseSeries
- return SparseSeries(self, kind=kind,
- fill_value=fill_value).__finalize__(self)
+ from pandas.core.sparse.array import SparseArray
+
+ values = SparseArray(self, kind=kind, fill_value=fill_value)
+ return SparseSeries(
+ values, index=self.index, name=self.name
+ ).__finalize__(self)
def _set_name(self, name, inplace=False):
"""
@@ -4259,8 +4266,7 @@ def _try_cast(arr, take_fast_path):
elif is_extension_array_dtype(dtype):
# create an extension array from its dtype
array_type = dtype.construct_array_type()._from_sequence
- subarr = array_type(subarr, dtype=dtype, copy=copy)
-
+ subarr = array_type(arr, dtype=dtype, copy=copy)
elif dtype is not None and raise_cast_failure:
raise
else:
diff --git a/pandas/core/sparse/api.py b/pandas/core/sparse/api.py
index 85941e6923338..0fb0396e34669 100644
--- a/pandas/core/sparse/api.py
+++ b/pandas/core/sparse/api.py
@@ -3,3 +3,4 @@
from pandas.core.sparse.array import SparseArray
from pandas.core.sparse.series import SparseSeries
from pandas.core.sparse.frame import SparseDataFrame
+from pandas.core.sparse.dtype import SparseDtype
diff --git a/pandas/core/sparse/array.py b/pandas/core/sparse/array.py
index 186a2490a5f2e..15b5118db2230 100644
--- a/pandas/core/sparse/array.py
+++ b/pandas/core/sparse/array.py
@@ -4,67 +4,115 @@
from __future__ import division
# pylint: disable=E1101,E1103,W0231
+import operator
+import numbers
import numpy as np
import warnings
import pandas as pd
-from pandas.core.base import PandasObject, IndexOpsMixin
+from pandas.core.base import PandasObject
from pandas import compat
-from pandas.compat import range, PYPY
+from pandas.errors import PerformanceWarning
from pandas.compat.numpy import function as nv
-from pandas.core.dtypes.generic import ABCSparseSeries
+from pandas.core.arrays.base import ExtensionArray, ExtensionOpsMixin
+import pandas.core.common as com
+from pandas.core.dtypes.generic import (
+ ABCSparseSeries, ABCSeries, ABCIndexClass
+)
from pandas.core.dtypes.common import (
- ensure_platform_int,
- is_float, is_integer,
+ is_datetime64_any_dtype,
+ is_integer,
is_object_dtype,
- is_integer_dtype,
+ is_array_like,
+ pandas_dtype,
is_bool_dtype,
is_list_like,
is_string_dtype,
is_scalar, is_dtype_equal)
from pandas.core.dtypes.cast import (
- maybe_convert_platform, maybe_promote,
+ maybe_convert_platform,
astype_nansafe, find_common_type, infer_dtype_from_scalar,
construct_1d_arraylike_from_scalar)
from pandas.core.dtypes.missing import isna, notna, na_value_for_dtype
+from pandas.core.missing import interpolate_2d
import pandas._libs.sparse as splib
-import pandas._libs.lib as lib
-from pandas._libs.sparse import SparseIndex, BlockIndex, IntIndex
+from pandas._libs.sparse import BlockIndex, IntIndex
from pandas._libs import index as libindex
+from pandas._libs import lib
import pandas.core.algorithms as algos
-import pandas.core.ops as ops
import pandas.io.formats.printing as printing
-from pandas.util._decorators import Appender
-from pandas.core.indexes.base import _index_shared_docs
+
+from pandas.core.sparse.dtype import SparseDtype
_sparray_doc_kwargs = dict(klass='SparseArray')
def _get_fill(arr):
- # coerce fill_value to arr dtype if possible
- # int64 SparseArray can have NaN as fill_value if there is no missing
+ # type: (SparseArray) -> ndarray
+ """
+ Create a 0-dim ndarray containing the fill value
+
+ Parameters
+ ----------
+ arr : SparseArray
+
+ Returns
+ -------
+ fill_value : ndarray
+ 0-dim ndarray with just the fill value.
+
+ Notes
+ -----
+ coerce fill_value to arr dtype if possible
+ int64 SparseArray can have NaN as fill_value if there is no missing
+ """
try:
- return np.asarray(arr.fill_value, dtype=arr.dtype)
+ return np.asarray(arr.fill_value, dtype=arr.dtype.subtype)
except ValueError:
return np.asarray(arr.fill_value)
def _sparse_array_op(left, right, op, name):
+ """
+ Perform a binary operation between two arrays.
+
+ Parameters
+ ----------
+ left : Union[SparseArray, ndarray]
+ right : Union[SparseArray, ndarray]
+ op : Callable
+ The binary operation to perform
+ name str
+ Name of the callable.
+
+ Returns
+ -------
+ SparseArray
+ """
+ # type: (SparseArray, SparseArray, Callable, str) -> Any
if name.startswith('__'):
# For lookups in _libs.sparse we need non-dunder op name
name = name[2:-2]
# dtype used to find corresponding sparse method
- if not is_dtype_equal(left.dtype, right.dtype):
- dtype = find_common_type([left.dtype, right.dtype])
- left = left.astype(dtype)
- right = right.astype(dtype)
+ ltype = left.dtype.subtype
+ rtype = right.dtype.subtype
+
+ if not is_dtype_equal(ltype, rtype):
+ subtype = find_common_type([ltype, rtype])
+ ltype = SparseDtype(subtype, left.fill_value)
+ rtype = SparseDtype(subtype, right.fill_value)
+
+ # TODO(GH-23092): pass copy=False. Need to fix astype_nansafe
+ left = left.astype(ltype)
+ right = right.astype(rtype)
+ dtype = ltype.subtype
else:
- dtype = left.dtype
+ dtype = ltype
# dtype the result must have
result_dtype = None
@@ -100,10 +148,11 @@ def _sparse_array_op(left, right, op, name):
right_sp_values = right.sp_values
sparse_op = getattr(splib, opname)
+
with np.errstate(all='ignore'):
- result, index, fill = sparse_op(left_sp_values, left.sp_index,
- left.fill_value, right_sp_values,
- right.sp_index, right.fill_value)
+ result, index, fill = sparse_op(
+ left_sp_values, left.sp_index, left.fill_value,
+ right_sp_values, right.sp_index, right.fill_value)
if result_dtype is None:
result_dtype = result.dtype
@@ -120,319 +169,506 @@ def _wrap_result(name, data, sparse_index, fill_value, dtype=None):
if name in ('eq', 'ne', 'lt', 'gt', 'le', 'ge'):
dtype = np.bool
+ fill_value = lib.item_from_zerodim(fill_value)
+
if is_bool_dtype(dtype):
# fill_value may be np.bool_
fill_value = bool(fill_value)
- return SparseArray(data, sparse_index=sparse_index,
- fill_value=fill_value, dtype=dtype)
+ return SparseArray(data,
+ sparse_index=sparse_index,
+ fill_value=fill_value,
+ dtype=dtype)
+
+
+class SparseArray(PandasObject, ExtensionArray, ExtensionOpsMixin):
+ """
+ An ExtensionArray for storing sparse data.
+ .. versionchanged:: 0.24.0
-class SparseArray(PandasObject, np.ndarray):
- """Data structure for labeled, sparse floating point 1-D data
+ Implements the ExtensionArray interface.
Parameters
----------
- data : {array-like (1-D), Series, SparseSeries, dict}
- kind : {'block', 'integer'}
- fill_value : float
- Code for missing value. Defaults depends on dtype.
- 0 for int dtype, False for bool dtype, and NaN for other dtypes
- sparse_index : {BlockIndex, IntIndex}, optional
- Only if you have one. Mainly used internally
-
- Notes
- -----
- SparseArray objects are immutable via the typical Python means. If you
- must change values, convert to dense, make your changes, then convert back
- to sparse
+ data : array-like
+ A dense array of values to store in the SparseArray. This may contain
+ `fill_value`.
+ sparse_index : SparseIndex, optional
+ index : Index
+ fill_value : scalar, optional
+ Elements in `data` that are `fill_value` are not stored in the
+ SparseArray. For memory savings, this should be the most common value
+ in `data`. By default, `fill_value` depends on the dtype of `data`:
+
+ =========== ==========
+ data.dtype na_value
+ =========== ==========
+ float ``np.nan``
+ int ``0``
+ bool False
+ datetime64 ``pd.NaT``
+ timedelta64 ``pd.NaT``
+ =========== ==========
+
+ The fill value is potentiall specified in three ways. In order of
+ precedence, these are
+
+ 1. The `fill_value` argument
+ 2. ``dtype.fill_value`` if `fill_value` is None and `dtype` is
+ a ``SparseDtype``
+ 3. ``data.dtype.fill_value`` if `fill_value` is None and `dtype`
+ is not a ``SparseDtype`` and `data` is a ``SparseArray``.
+
+
+ kind : {'integer', 'block'}, default 'integer'
+ The type of storage for sparse locations.
+
+ * 'block': Stores a `block` and `block_length` for each
+ contiguous *span* of sparse values. This is best when
+ sparse data tends to be clumped together, with large
+ regsions of ``fill-value`` values between sparse values.
+ * 'integer': uses an integer to store the location of
+ each sparse value.
+
+ dtype : np.dtype or SparseDtype, optional
+ The dtype to use for the SparseArray. For numpy dtypes, this
+ determines the dtype of ``self.sp_values``. For SparseDtype,
+ this determines ``self.sp_values`` and ``self.fill_value``.
+ copy : bool, default False
+ Whether to explicitly copy the incoming `data` array.
"""
+
__array_priority__ = 15
- _typ = 'array'
- _subtyp = 'sparse_array'
+ _pandas_ftype = 'sparse'
+ _subtyp = 'sparse_array' # register ABCSparseArray
- sp_index = None
- fill_value = None
+ def __init__(self, data, sparse_index=None, index=None, fill_value=None,
+ kind='integer', dtype=None, copy=False):
+ from pandas.core.internals import SingleBlockManager
- def __new__(cls, data, sparse_index=None, index=None, kind='integer',
- fill_value=None, dtype=None, copy=False):
+ if isinstance(data, SingleBlockManager):
+ data = data.internal_values()
+
+ if fill_value is None and isinstance(dtype, SparseDtype):
+ fill_value = dtype.fill_value
+
+ if isinstance(data, (type(self), ABCSparseSeries)):
+ # disable normal inference on dtype, sparse_index, & fill_value
+ if sparse_index is None:
+ sparse_index = data.sp_index
+ if fill_value is None:
+ fill_value = data.fill_value
+ if dtype is None:
+ dtype = data.dtype
+ # TODO: make kind=None, and use data.kind?
+ data = data.sp_values
+
+ # Handle use-provided dtype
+ if isinstance(dtype, compat.string_types):
+ # Two options: dtype='int', regular numpy dtype
+ # or dtype='Sparse[int]', a sparse dtype
+ try:
+ dtype = SparseDtype.construct_from_string(dtype)
+ except TypeError:
+ dtype = pandas_dtype(dtype)
+
+ if isinstance(dtype, SparseDtype):
+ if fill_value is None:
+ fill_value = dtype.fill_value
+ dtype = dtype.subtype
+
+ if index is not None and not is_scalar(data):
+ raise Exception("must only pass scalars with an index ")
+
+ if is_scalar(data):
+ if index is not None:
+ if data is None:
+ data = np.nan
+
+ if index is not None:
+ npoints = len(index)
+ elif sparse_index is None:
+ npoints = 1
+ else:
+ npoints = sparse_index.length
- if index is not None:
- if data is None:
- data = np.nan
- if not is_scalar(data):
- raise Exception("must only pass scalars with an index ")
dtype = infer_dtype_from_scalar(data)[0]
data = construct_1d_arraylike_from_scalar(
- data, len(index), dtype)
-
- if isinstance(data, ABCSparseSeries):
- data = data.values
- is_sparse_array = isinstance(data, SparseArray)
+ data, npoints, dtype
+ )
if dtype is not None:
- dtype = np.dtype(dtype)
+ dtype = pandas_dtype(dtype)
+
+ # TODO: disentangle the fill_value dtype inference from
+ # dtype inference
+ if data is None:
+ # XXX: What should the empty dtype be? Object or float?
+ data = np.array([], dtype=dtype)
+
+ if not is_array_like(data):
+ try:
+ # probably shared code in sanitize_series
+ from pandas.core.series import _sanitize_array
+ data = _sanitize_array(data, index=None)
+ except ValueError:
+ # NumPy may raise a ValueError on data like [1, []]
+ # we retry with object dtype here.
+ if dtype is None:
+ dtype = object
+ data = np.atleast_1d(np.asarray(data, dtype=dtype))
+ else:
+ raise
- if is_sparse_array:
- sparse_index = data.sp_index
- values = data.sp_values
- fill_value = data.fill_value
- else:
- # array-like
- if sparse_index is None:
- if dtype is not None:
- data = np.asarray(data, dtype=dtype)
- res = make_sparse(data, kind=kind, fill_value=fill_value)
- values, sparse_index, fill_value = res
- else:
- values = _sanitize_values(data)
- if len(values) != sparse_index.npoints:
- raise AssertionError("Non array-like type {type} must "
- "have the same length as the index"
- .format(type=type(values)))
- # Create array, do *not* copy data by default
if copy:
- subarr = np.array(values, dtype=dtype, copy=True)
- else:
- subarr = np.asarray(values, dtype=dtype)
- # Change the class of the array to be the subclass type.
- return cls._simple_new(subarr, sparse_index, fill_value)
-
- @classmethod
- def _simple_new(cls, data, sp_index, fill_value):
- if not isinstance(sp_index, SparseIndex):
- # caller must pass SparseIndex
- raise ValueError('sp_index must be a SparseIndex')
+ # TODO: avoid double copy when dtype forces cast.
+ data = data.copy()
if fill_value is None:
- if sp_index.ngaps > 0:
- # has missing hole
+ fill_value_dtype = data.dtype if dtype is None else dtype
+ if fill_value_dtype is None:
fill_value = np.nan
else:
- fill_value = na_value_for_dtype(data.dtype)
+ fill_value = na_value_for_dtype(fill_value_dtype)
+
+ if isinstance(data, type(self)) and sparse_index is None:
+ sparse_index = data._sparse_index
+ sparse_values = np.asarray(data.sp_values, dtype=dtype)
+ elif sparse_index is None:
+ sparse_values, sparse_index, fill_value = make_sparse(
+ data, kind=kind, fill_value=fill_value, dtype=dtype
+ )
+ else:
+ sparse_values = np.asarray(data, dtype=dtype)
+ if len(sparse_values) != sparse_index.npoints:
+ raise AssertionError("Non array-like type {type} must "
+ "have the same length as the index"
+ .format(type=type(sparse_values)))
+ self._sparse_index = sparse_index
+ self._sparse_values = sparse_values
+ self._dtype = SparseDtype(sparse_values.dtype, fill_value)
- if (is_integer_dtype(data) and is_float(fill_value) and
- sp_index.ngaps > 0):
- # if float fill_value is being included in dense repr,
- # convert values to float
- data = data.astype(float)
+ @classmethod
+ def _simple_new(cls, sparse_array, sparse_index, dtype):
+ # type: (np.ndarray, SparseIndex, SparseDtype) -> 'SparseArray'
+ new = cls([])
+ new._sparse_index = sparse_index
+ new._sparse_values = sparse_array
+ new._dtype = dtype
+ return new
+
+ def __array__(self, dtype=None, copy=True):
+ fill_value = self.fill_value
+
+ if self.sp_index.ngaps == 0:
+ # Compat for na dtype and int values.
+ return self.sp_values
+ if dtype is None:
+ # Can NumPy represent this type?
+ # If not, `np.result_type` will raise. We catch that
+ # and return object.
+ if is_datetime64_any_dtype(self.sp_values.dtype):
+ # However, we *do* special-case the common case of
+ # a datetime64 with pandas NaT.
+ if fill_value is pd.NaT:
+ # Can't put pd.NaT in a datetime64[ns]
+ fill_value = np.datetime64('NaT')
+ try:
+ dtype = np.result_type(self.sp_values.dtype, fill_value)
+ except TypeError:
+ dtype = object
+
+ out = np.full(self.shape, fill_value, dtype=dtype)
+ out[self.sp_index.to_int_index().indices] = self.sp_values
+ return out
- result = data.view(cls)
+ def __setitem__(self, key, value):
+ # I suppose we could allow setting of non-fill_value elements.
+ msg = "SparseArray does not support item assignment via setitem"
+ raise TypeError(msg)
- if not isinstance(sp_index, SparseIndex):
- # caller must pass SparseIndex
- raise ValueError('sp_index must be a SparseIndex')
+ @classmethod
+ def _from_sequence(cls, scalars, dtype=None, copy=False):
+ return cls(scalars, dtype=dtype)
- result.sp_index = sp_index
- result._fill_value = fill_value
- return result
+ @classmethod
+ def _from_factorized(cls, values, original):
+ return cls(values, dtype=original.dtype)
+ # ------------------------------------------------------------------------
+ # Data
+ # ------------------------------------------------------------------------
@property
- def _constructor(self):
- return lambda x: SparseArray(x, fill_value=self.fill_value,
- kind=self.kind)
+ def sp_index(self):
+ return self._sparse_index
@property
- def kind(self):
- if isinstance(self.sp_index, BlockIndex):
- return 'block'
- elif isinstance(self.sp_index, IntIndex):
- return 'integer'
+ def sp_values(self):
+ return self._sparse_values
- @Appender(IndexOpsMixin.memory_usage.__doc__)
- def memory_usage(self, deep=False):
- values = self.sp_values
+ @property
+ def dtype(self):
+ return self._dtype
- v = values.nbytes
+ @property
+ def fill_value(self):
+ """
+ Elements in `data` that are `fill_value` are not stored.
- if deep and is_object_dtype(self) and not PYPY:
- v += lib.memory_usage_of_objects(values)
+ For memory savings, this should be the most common value in the array.
+ """
+ return self.dtype.fill_value
- return v
+ @fill_value.setter
+ def fill_value(self, value):
+ self._dtype = SparseDtype(self.dtype.subtype, value)
- def __array_wrap__(self, out_arr, context=None):
+ @property
+ def kind(self):
+ """
+ The kind of sparse index for this array. One of {'integer', 'block'}.
"""
- NumPy calls this method when ufunc is applied
+ if isinstance(self.sp_index, IntIndex):
+ return 'integer'
+ else:
+ return 'block'
- Parameters
- ----------
+ @property
+ def _valid_sp_values(self):
+ sp_vals = self.sp_values
+ mask = notna(sp_vals)
+ return sp_vals[mask]
- out_arr : ndarray
- ufunc result (note that ufunc is only applied to sp_values)
- context : tuple of 3 elements (ufunc, signature, domain)
- for example, following is a context when np.sin is applied to
- SparseArray,
+ def __len__(self):
+ return self.sp_index.length
- (<ufunc 'sin'>, (SparseArray,), 0))
+ @property
+ def _null_fill_value(self):
+ return self._dtype._is_na_fill_value
- See http://docs.scipy.org/doc/numpy/user/basics.subclassing.html
- """
- if isinstance(context, tuple) and len(context) == 3:
- ufunc, args, domain = context
- # to apply ufunc only to fill_value (to avoid recursive call)
- args = [getattr(a, 'fill_value', a) for a in args]
- with np.errstate(all='ignore'):
- fill_value = ufunc(self.fill_value, *args[1:])
+ def _fill_value_matches(self, fill_value):
+ if self._null_fill_value:
+ return pd.isna(fill_value)
else:
- fill_value = self.fill_value
+ return self.fill_value == fill_value
- return self._simple_new(out_arr, sp_index=self.sp_index,
- fill_value=fill_value)
+ @property
+ def nbytes(self):
+ return self.sp_values.nbytes + self.sp_index.nbytes
- def __array_finalize__(self, obj):
+ @property
+ def values(self):
"""
- Gets called after any ufunc or other array operations, necessary
- to pass on the index.
+ Dense values
"""
- self.sp_index = getattr(obj, 'sp_index', None)
- self._fill_value = getattr(obj, 'fill_value', None)
+ return self.to_dense()
- def __reduce__(self):
- """Necessary for making this object picklable"""
- object_state = list(np.ndarray.__reduce__(self))
- subclass_state = self.fill_value, self.sp_index
- object_state[2] = self.sp_values.__reduce__()[2]
- object_state[2] = (object_state[2], subclass_state)
- return tuple(object_state)
+ def isna(self):
+ from pandas import isna
+ # If null fill value, we want SparseDtype[bool, true]
+ # to preserve the same memory usage.
+ dtype = SparseDtype(bool, self._null_fill_value)
+ return type(self)._simple_new(isna(self.sp_values),
+ self.sp_index, dtype)
- def __setstate__(self, state):
- """Necessary for making this object picklable"""
- nd_state, own_state = state
- np.ndarray.__setstate__(self, nd_state)
+ def fillna(self, value=None, method=None, limit=None):
+ """
+ Fill missing values with `value`.
- fill_value, sp_index = own_state[:2]
- self.sp_index = sp_index
- self._fill_value = fill_value
+ Parameters
+ ----------
+ value : scalar, optional
+ method : str, optional
- def __len__(self):
- try:
- return self.sp_index.length
- except AttributeError:
- return 0
+ .. warning::
- def __unicode__(self):
- return '{self}\nFill: {fill}\n{index}'.format(
- self=printing.pprint_thing(self),
- fill=printing.pprint_thing(self.fill_value),
- index=printing.pprint_thing(self.sp_index))
+ Using 'method' will result in high memory use,
+ as all `fill_value` methods will be converted to
+ an in-memory ndarray
- def disable(self, other):
- raise NotImplementedError('inplace binary ops not supported')
- # Inplace operators
- __iadd__ = disable
- __isub__ = disable
- __imul__ = disable
- __itruediv__ = disable
- __ifloordiv__ = disable
- __ipow__ = disable
+ limit : int, optional
- # Python 2 division operators
- if not compat.PY3:
- __idiv__ = disable
+ Returns
+ -------
+ SparseArray
- @property
- def values(self):
- """
- Dense values
+ Notes
+ -----
+ When `value` is specified, the result's ``fill_value`` depends on
+ ``self.fill_value``. The goal is to maintain low-memory use.
+
+ If ``self.fill_value`` is NA, the result dtype will be
+ ``SparseDtype(self.dtype, fill_value=value)``. This will preserve
+ amount of memory used before and after filling.
+
+ When ``self.fill_value`` is not NA, the result dtype will be
+ ``self.dtype``. Again, this preserves the amount of memory used.
"""
- output = np.empty(len(self), dtype=self.dtype)
- int_index = self.sp_index.to_int_index()
- output.fill(self.fill_value)
- output.put(int_index.indices, self)
- return output
+ if ((method is None and value is None) or
+ (method is not None and value is not None)):
+ raise ValueError("Must specify one of 'method' or 'value'.")
- @property
- def shape(self):
- return (len(self),)
+ elif method is not None:
+ msg = "fillna with 'method' requires high memory usage."
+ warnings.warn(msg, PerformanceWarning)
+ filled = interpolate_2d(np.asarray(self), method=method,
+ limit=limit)
+ return type(self)(filled, fill_value=self.fill_value)
- @property
- def sp_values(self):
- # caching not an option, leaks memory
- return self.view(np.ndarray)
+ else:
+ new_values = np.where(isna(self.sp_values), value, self.sp_values)
- @property
- def fill_value(self):
- return self._fill_value
+ if self._null_fill_value:
+ # This is essentially just updating the dtype.
+ new_dtype = SparseDtype(self.dtype.subtype, fill_value=value)
+ else:
+ new_dtype = self.dtype
- @fill_value.setter
- def fill_value(self, value):
- if not is_scalar(value):
- raise ValueError('fill_value must be a scalar')
- # if the specified value triggers type promotion, raise ValueError
- new_dtype, fill_value = maybe_promote(self.dtype, value)
- if is_dtype_equal(self.dtype, new_dtype):
- self._fill_value = fill_value
+ return self._simple_new(new_values, self._sparse_index, new_dtype)
+
+ def shift(self, periods=1):
+
+ if periods == 0:
+ return self.copy()
+
+ subtype = np.result_type(np.nan, self.dtype.subtype)
+
+ if subtype != self.dtype.subtype:
+ # just coerce up front
+ arr = self.astype(SparseDtype(subtype, self.fill_value))
else:
- msg = 'unable to set fill_value {fill} to {dtype} dtype'
- raise ValueError(msg.format(fill=value, dtype=self.dtype))
+ arr = self
- def get_values(self, fill=None):
- """ return a dense representation """
- return self.to_dense(fill=fill)
+ empty = self._from_sequence([self.dtype.na_value] * abs(periods),
+ dtype=arr.dtype)
+ if periods > 0:
+ a = empty
+ b = arr[:-periods]
+ else:
+ a = arr[abs(periods):]
+ b = empty
+ return arr._concat_same_type([a, b])
- def to_dense(self, fill=None):
+ def _first_fill_value_loc(self):
"""
- Convert SparseArray to a NumPy array.
+ Get the location of the first missing value.
+
+ Returns
+ -------
+ int
+ """
+ if len(self) == 0 or self.sp_index.npoints == len(self):
+ return -1
+
+ indices = self.sp_index.to_int_index().indices
+ if indices[0] > 0:
+ return 0
+
+ diff = indices[1:] - indices[:-1]
+ return np.searchsorted(diff, 2) + 1
+
+ def unique(self):
+ uniques = list(pd.unique(self.sp_values))
+ fill_loc = self._first_fill_value_loc()
+ if fill_loc >= 0:
+ uniques.insert(fill_loc, self.fill_value)
+ return type(self)._from_sequence(uniques, dtype=self.dtype)
+
+ def _values_for_factorize(self):
+ # Still override this for hash_pandas_object
+ return np.asarray(self), self.fill_value
+
+ def factorize(self, na_sentinel=-1):
+ # Currently, ExtensionArray.factorize -> Tuple[ndarray, EA]
+ # The sparsity on this is backwards from what Sparse would want. Want
+ # ExtensionArray.factorize -> Tuple[EA, EA]
+ # Given that we have to return a dense array of labels, why bother
+ # implementing an efficient factorize?
+ labels, uniques = pd.factorize(np.asarray(self),
+ na_sentinel=na_sentinel)
+ uniques = SparseArray(uniques, dtype=self.dtype)
+ return labels, uniques
+
+ def value_counts(self, dropna=True):
+ """
+ Returns a Series containing counts of unique values.
Parameters
----------
- fill: float, default None
- .. deprecated:: 0.20.0
- This argument is not respected by this function.
+ dropna : boolean, default True
+ Don't include counts of NaN, even if NaN is in sp_values.
Returns
-------
- arr : NumPy array
+ counts : Series
"""
- if fill is not None:
- warnings.warn(("The 'fill' parameter has been deprecated and "
- "will be removed in a future version."),
- FutureWarning, stacklevel=2)
- return self.values
+ keys, counts = algos._value_counts_arraylike(self.sp_values,
+ dropna=dropna)
+ fcounts = self.sp_index.ngaps
+ if fcounts > 0:
+ if self._null_fill_value and dropna:
+ pass
+ else:
+ if self._null_fill_value:
+ mask = pd.isna(keys)
+ else:
+ mask = keys == self.fill_value
- def __iter__(self):
- if np.issubdtype(self.dtype, np.floating):
- boxer = float
- elif np.issubdtype(self.dtype, np.integer):
- boxer = int
- else:
- boxer = lambda x: x
+ if mask.any():
+ counts[mask] += fcounts
+ else:
+ keys = np.insert(keys, 0, self.fill_value)
+ counts = np.insert(counts, 0, fcounts)
- for i in range(len(self)):
- r = self._get_val_at(i)
+ if not isinstance(keys, pd.Index):
+ keys = pd.Index(keys)
+ result = pd.Series(counts, index=keys)
+ return result
- # box em
- yield boxer(r)
+ # --------
+ # Indexing
+ # --------
def __getitem__(self, key):
- """
-
- """
+ if isinstance(key, tuple):
+ if len(key) > 1:
+ raise IndexError("too many indices for array.")
+ key = key[0]
if is_integer(key):
return self._get_val_at(key)
elif isinstance(key, tuple):
data_slice = self.values[key]
+ elif isinstance(key, slice):
+ # special case to preserve dtypes
+ if key == slice(None):
+ return self.copy()
+ # TODO: this logic is surely elsewhere
+ # TODO: this could be more efficient
+ indices = np.arange(len(self), dtype=np.int32)[key]
+ return self.take(indices)
else:
+ # TODO: I think we can avoid densifying when masking a
+ # boolean SparseArray with another. Need to look at the
+ # key's fill_value for True / False, and then do an intersection
+ # on the indicies of the sp_values.
if isinstance(key, SparseArray):
if is_bool_dtype(key):
key = key.to_dense()
else:
key = np.asarray(key)
- if hasattr(key, '__len__') and len(self) != len(key):
+ if com.is_bool_indexer(key) and len(self) == len(key):
+ # TODO(numpy 1.11): Remove this asarray.
+ # Old NumPy didn't treat array-like as boolean masks.
+ key = np.asarray(key)
+ return self.take(np.arange(len(key), dtype=np.int32)[key])
+ elif hasattr(key, '__len__'):
return self.take(key)
else:
- data_slice = self.values[key]
-
- return self._constructor(data_slice)
+ raise ValueError("Cannot slice with '{}'".format(key))
- def __getslice__(self, i, j):
- if i < 0:
- i = 0
- if j < 0:
- j = 0
- slobj = slice(i, j)
- return self.__getitem__(slobj)
+ return type(self)(data_slice, kind=self.kind)
def _get_val_at(self, loc):
n = len(self)
@@ -446,161 +682,399 @@ def _get_val_at(self, loc):
if sp_loc == -1:
return self.fill_value
else:
- # libindex.get_value_at will end up calling __getitem__,
- # so to avoid recursing we need to unwrap `self` so the
- # ndarray.__getitem__ implementation is called.
- return libindex.get_value_at(np.asarray(self), sp_loc)
-
- @Appender(_index_shared_docs['take'] % _sparray_doc_kwargs)
- def take(self, indices, axis=0, allow_fill=True,
- fill_value=None, **kwargs):
- """
- Sparse-compatible version of ndarray.take
+ return libindex.get_value_at(self.sp_values, sp_loc)
+
+ def take(self, indices, allow_fill=False, fill_value=None):
+ if is_scalar(indices):
+ raise ValueError("'indices' must be an array, not a "
+ "scalar '{}'.".format(indices))
+ indices = np.asarray(indices, dtype=np.int32)
+
+ if indices.size == 0:
+ result = []
+ kwargs = {'dtype': self.dtype}
+ elif allow_fill:
+ result = self._take_with_fill(indices, fill_value=fill_value)
+ kwargs = {}
+ else:
+ result = self._take_without_fill(indices)
+ kwargs = {'dtype': self.dtype}
- Returns
- -------
- taken : ndarray
- """
- nv.validate_take(tuple(), kwargs)
+ return type(self)(result, fill_value=self.fill_value, kind=self.kind,
+ **kwargs)
- if axis:
- raise ValueError("axis must be 0, input was {axis}"
- .format(axis=axis))
+ def _take_with_fill(self, indices, fill_value=None):
+ if fill_value is None:
+ fill_value = self.dtype.na_value
+
+ if indices.min() < -1:
+ raise ValueError("Invalid value in 'indices'. Must be between -1 "
+ "and the length of the array.")
+
+ if indices.max() >= len(self):
+ raise IndexError("out of bounds value in 'indices'.")
+
+ if len(self) == 0:
+ # Empty... Allow taking only if all empty
+ if (indices == -1).all():
+ dtype = np.result_type(self.sp_values, fill_value)
+ taken = np.empty_like(indices, dtype=dtype)
+ taken.fill(fill_value)
+ return taken
+ else:
+ raise IndexError('cannot do a non-empty take from an empty '
+ 'axes.')
- if is_integer(indices):
- # return scalar
- return self[indices]
+ sp_indexer = self.sp_index.lookup_array(indices)
- indices = ensure_platform_int(indices)
- n = len(self)
- if allow_fill and fill_value is not None:
- # allow -1 to indicate self.fill_value,
- # self.fill_value may not be NaN
- if (indices < -1).any():
- msg = ('When allow_fill=True and fill_value is not None, '
- 'all indices must be >= -1')
- raise ValueError(msg)
- elif (n <= indices).any():
- msg = 'index is out of bounds for size {size}'.format(size=n)
- raise IndexError(msg)
+ if self.sp_index.npoints == 0:
+ # Avoid taking from the empty self.sp_values
+ taken = np.full(sp_indexer.shape, fill_value=fill_value,
+ dtype=np.result_type(fill_value))
else:
- if ((indices < -n) | (n <= indices)).any():
- msg = 'index is out of bounds for size {size}'.format(size=n)
- raise IndexError(msg)
-
- indices = indices.astype(np.int32)
- if not (allow_fill and fill_value is not None):
- indices = indices.copy()
- indices[indices < 0] += n
-
- locs = self.sp_index.lookup_array(indices)
- indexer = np.arange(len(locs), dtype=np.int32)
- mask = locs != -1
- if mask.any():
- indexer = indexer[mask]
- new_values = self.sp_values.take(locs[mask])
- else:
- indexer = np.empty(shape=(0, ), dtype=np.int32)
- new_values = np.empty(shape=(0, ), dtype=self.sp_values.dtype)
+ taken = self.sp_values.take(sp_indexer)
- sp_index = _make_index(len(indices), indexer, kind=self.sp_index)
- return self._simple_new(new_values, sp_index, self.fill_value)
+ # sp_indexer may be -1 for two reasons
+ # 1.) we took for an index of -1 (new)
+ # 2.) we took a value that was self.fill_value (old)
+ new_fill_indices = indices == -1
+ old_fill_indices = (sp_indexer == -1) & ~new_fill_indices
- def __setitem__(self, key, value):
- # if is_integer(key):
- # self.values[key] = value
- # else:
- # raise Exception("SparseArray does not support setting non-scalars
- # via setitem")
- raise TypeError(
- "SparseArray does not support item assignment via setitem")
-
- def __setslice__(self, i, j, value):
- if i < 0:
- i = 0
- if j < 0:
- j = 0
- slobj = slice(i, j) # noqa
-
- # if not is_scalar(value):
- # raise Exception("SparseArray does not support setting non-scalars
- # via slices")
-
- # x = self.values
- # x[slobj] = value
- # self.values = x
- raise TypeError("SparseArray does not support item assignment via "
- "slices")
+ # Fill in two steps.
+ # Old fill values
+ # New fill values
+ # potentially coercing to a new dtype at each stage.
- def astype(self, dtype=None, copy=True):
- dtype = np.dtype(dtype)
- sp_values = astype_nansafe(self.sp_values, dtype, copy=copy)
- try:
- if is_bool_dtype(dtype):
- # to avoid np.bool_ dtype
- fill_value = bool(self.fill_value)
+ m0 = sp_indexer[old_fill_indices] < 0
+ m1 = sp_indexer[new_fill_indices] < 0
+
+ result_type = taken.dtype
+
+ if m0.any():
+ result_type = np.result_type(result_type, self.fill_value)
+ taken = taken.astype(result_type)
+ taken[old_fill_indices] = self.fill_value
+
+ if m1.any():
+ result_type = np.result_type(result_type, fill_value)
+ taken = taken.astype(result_type)
+ taken[new_fill_indices] = fill_value
+
+ return taken
+
+ def _take_without_fill(self, indices):
+ to_shift = indices < 0
+ indices = indices.copy()
+
+ n = len(self)
+
+ if (indices.max() >= n) or (indices.min() < -n):
+ if n == 0:
+ raise IndexError("cannot do a non-empty take from an "
+ "empty axes.")
else:
- fill_value = dtype.type(self.fill_value)
- except ValueError:
- msg = 'unable to coerce current fill_value {fill} to {dtype} dtype'
- raise ValueError(msg.format(fill=self.fill_value, dtype=dtype))
- return self._simple_new(sp_values, self.sp_index,
- fill_value=fill_value)
-
- def copy(self, deep=True):
- """
- Make a copy of the SparseArray. Only the actual sparse values need to
- be copied.
- """
+ raise IndexError("out of bounds value in 'indices'.")
+
+ if to_shift.any():
+ indices[to_shift] += n
+
+ if self.sp_index.npoints == 0:
+ # edge case in take...
+ # I think just return
+ out = np.full(indices.shape, self.fill_value,
+ dtype=np.result_type(self.fill_value))
+ arr, sp_index, fill_value = make_sparse(out,
+ fill_value=self.fill_value)
+ return type(self)(arr, sparse_index=sp_index,
+ fill_value=fill_value)
+
+ sp_indexer = self.sp_index.lookup_array(indices)
+ taken = self.sp_values.take(sp_indexer)
+ fillable = (sp_indexer < 0)
+
+ if fillable.any():
+ # TODO: may need to coerce array to fill value
+ result_type = np.result_type(taken, self.fill_value)
+ taken = taken.astype(result_type)
+ taken[fillable] = self.fill_value
+
+ return taken
+
+ def copy(self, deep=False):
if deep:
values = self.sp_values.copy()
else:
values = self.sp_values
- return SparseArray(values, sparse_index=self.sp_index,
- dtype=self.dtype, fill_value=self.fill_value)
- def count(self):
+ return self._simple_new(values, self.sp_index, self.dtype)
+
+ @classmethod
+ def _concat_same_type(cls, to_concat):
+ fill_values = [x.fill_value for x in to_concat]
+
+ fill_value = fill_values[0]
+
+ if len(set(fill_values)) > 1:
+ warnings.warn("Concatenating sparse arrays with multiple fill "
+ "values: '{}'. Picking the first and "
+ "converting the rest.".format(fill_values),
+ PerformanceWarning,
+ stacklevel=6)
+ keep = to_concat[0]
+ to_concat2 = [keep]
+
+ for arr in to_concat[1:]:
+ to_concat2.append(cls(np.asarray(arr), fill_value=fill_value))
+
+ to_concat = to_concat2
+
+ values = []
+ length = 0
+
+ if to_concat:
+ sp_kind = to_concat[0].kind
+ else:
+ sp_kind = 'integer'
+
+ if sp_kind == 'integer':
+ indices = []
+
+ for arr in to_concat:
+ idx = arr.sp_index.to_int_index().indices.copy()
+ idx += length # TODO: wraparound
+ length += arr.sp_index.length
+
+ values.append(arr.sp_values)
+ indices.append(idx)
+
+ data = np.concatenate(values)
+ indices = np.concatenate(indices)
+ sp_index = IntIndex(length, indices)
+
+ else:
+ # when concatentating block indices, we don't claim that you'll
+ # get an identical index as concating the values and then
+ # creating a new index. We don't want to spend the time trying
+ # to merge blocks across arrays in `to_concat`, so the resulting
+ # BlockIndex may have more blocs.
+ blengths = []
+ blocs = []
+
+ for arr in to_concat:
+ idx = arr.sp_index.to_block_index()
+
+ values.append(arr.sp_values)
+ blocs.append(idx.blocs.copy() + length)
+ blengths.append(idx.blengths)
+ length += arr.sp_index.length
+
+ data = np.concatenate(values)
+ blocs = np.concatenate(blocs)
+ blengths = np.concatenate(blengths)
+
+ sp_index = BlockIndex(length, blocs, blengths)
+
+ return cls(data, sparse_index=sp_index, fill_value=fill_value)
+
+ def astype(self, dtype=None, copy=True):
"""
- Compute sum of non-NA/null observations in SparseArray. If the
- fill_value is not NaN, the "sparse" locations will be included in the
- observation count.
+ Change the dtype of a SparseArray.
+
+ The output will always be a SparseArray. To convert to a dense
+ ndarray with a certain dtype, use :meth:`numpy.asarray`.
+
+ Parameters
+ ----------
+ dtype : np.dtype or ExtensionDtype
+ For SparseDtype, this changes the dtype of
+ ``self.sp_values`` and the ``self.fill_value``.
+
+ For other dtypes, this only changes the dtype of
+ ``self.sp_values``.
+
+ copy : bool, default True
+ Whether to ensure a copy is made, even if not necessary.
Returns
-------
- nobs : int
+ SparseArray
+
+ Examples
+ --------
+ >>> arr = SparseArray([0, 0, 1, 2])
+ >>> arr
+ [0, 0, 1, 2]
+ Fill: 0
+ IntIndex
+ Indices: array([2, 3], dtype=int32)
+
+ >>> arr.astype(np.dtype('int32'))
+ [0, 0, 1, 2]
+ Fill: 0
+ IntIndex
+ Indices: array([2, 3], dtype=int32)
+
+ Using a NumPy dtype with a different kind (e.g. float) will coerce
+ just ``self.sp_values``.
+
+ >>> arr.astype(np.dtype('float64'))
+ ... # doctest: +NORMALIZE_WHITESPACE
+ [0, 0, 1.0, 2.0]
+ Fill: 0
+ IntIndex
+ Indices: array([2, 3], dtype=int32)
+
+ Use a SparseDtype if you wish to be change the fill value as well.
+
+ >>> arr.astype(SparseDtype("float64", fill_value=np.nan))
+ ... # doctest: +NORMALIZE_WHITESPACE
+ [nan, nan, 1.0, 2.0]
+ Fill: nan
+ IntIndex
+ Indices: array([2, 3], dtype=int32)
"""
- sp_values = self.sp_values
- valid_spvals = np.isfinite(sp_values).sum()
- if self._null_fill_value:
- return valid_spvals
+ dtype = pandas_dtype(dtype)
+
+ if not isinstance(dtype, SparseDtype):
+ dtype = SparseDtype(dtype, fill_value=self.fill_value)
+
+ sp_values = astype_nansafe(self.sp_values,
+ dtype.subtype,
+ copy=copy)
+ if sp_values is self.sp_values and copy:
+ sp_values = sp_values.copy()
+
+ return self._simple_new(sp_values,
+ self.sp_index,
+ dtype)
+
+ def map(self, mapper):
+ """
+ Map categories using input correspondence (dict, Series, or function).
+
+ Parameters
+ ----------
+ mapper : dict, Series, callable
+ The correspondence from old values to new.
+
+ Returns
+ -------
+ SparseArray
+ The output array will have the same density as the input.
+ The output fill value will be the result of applying the
+ mapping to ``self.fill_value``
+
+ Examples
+ --------
+ >>> arr = pd.SparseArray([0, 1, 2])
+ >>> arr.apply(lambda x: x + 10)
+ [10, 11, 12]
+ Fill: 10
+ IntIndex
+ Indices: array([1, 2], dtype=int32)
+
+ >>> arr.apply({0: 10, 1: 11, 2: 12})
+ [10, 11, 12]
+ Fill: 10
+ IntIndex
+ Indices: array([1, 2], dtype=int32)
+
+ >>> arr.apply(pd.Series([10, 11, 12], index=[0, 1, 2]))
+ [10, 11, 12]
+ Fill: 10
+ IntIndex
+ Indices: array([1, 2], dtype=int32)
+ """
+ # this is used in apply.
+ # We get hit since we're an "is_extension_type" but regular extension
+ # types are not hit. This may be worth adding to the interface.
+ if isinstance(mapper, ABCSeries):
+ mapper = mapper.to_dict()
+
+ if isinstance(mapper, compat.Mapping):
+ fill_value = mapper.get(self.fill_value, self.fill_value)
+ sp_values = [mapper.get(x, None) for x in self.sp_values]
else:
- return valid_spvals + self.sp_index.ngaps
+ fill_value = mapper(self.fill_value)
+ sp_values = [mapper(x) for x in self.sp_values]
- @property
- def _null_fill_value(self):
- return isna(self.fill_value)
+ return type(self)(sp_values, sparse_index=self.sp_index,
+ fill_value=fill_value)
- @property
- def _valid_sp_values(self):
- sp_vals = self.sp_values
- mask = notna(sp_vals)
- return sp_vals[mask]
+ def get_values(self, fill=None):
+ """ return a dense representation """
+ # TODO: deprecate for to_dense?
+ return self.to_dense(fill=fill)
- @Appender(_index_shared_docs['fillna'] % _sparray_doc_kwargs)
- def fillna(self, value, downcast=None):
- if downcast is not None:
- raise NotImplementedError
+ def to_dense(self, fill=None):
+ """
+ Convert SparseArray to a NumPy array.
- if issubclass(self.dtype.type, np.floating):
- value = float(value)
+ Parameters
+ ----------
+ fill: float, default None
+ .. deprecated:: 0.20.0
+ This argument is not respected by this function.
- new_values = np.where(isna(self.sp_values), value, self.sp_values)
- fill_value = value if self._null_fill_value else self.fill_value
+ Returns
+ -------
+ arr : NumPy array
+ """
+ if fill is not None:
+ warnings.warn(("The 'fill' parameter has been deprecated and "
+ "will be removed in a future version."),
+ FutureWarning, stacklevel=2)
+ return np.asarray(self, dtype=self.sp_values.dtype)
+
+ # ------------------------------------------------------------------------
+ # IO
+ # ------------------------------------------------------------------------
+ def __setstate__(self, state):
+ """Necessary for making this object picklable"""
+ if isinstance(state, tuple):
+ # Compat for pandas < 0.24.0
+ nd_state, (fill_value, sp_index) = state
+ sparse_values = np.array([])
+ sparse_values.__setstate__(nd_state)
+
+ self._sparse_values = sparse_values
+ self._sparse_index = sp_index
+ self._dtype = SparseDtype(sparse_values.dtype, fill_value)
+ else:
+ self.__dict__.update(state)
- return self._simple_new(new_values, self.sp_index,
- fill_value=fill_value)
+ def nonzero(self):
+ if self.fill_value == 0:
+ return self.sp_index.to_int_index().indices,
+ else:
+ return self.sp_index.to_int_index().indices[self.sp_values != 0],
+
+ # ------------------------------------------------------------------------
+ # Reductions
+ # ------------------------------------------------------------------------
+
+ def _reduce(self, name, skipna=True, **kwargs):
+ method = getattr(self, name, None)
- def all(self, axis=0, *args, **kwargs):
+ if method is None:
+ raise TypeError("cannot perform {name} with type {dtype}".format(
+ name=name, dtype=self.dtype))
+
+ if skipna:
+ arr = self
+ else:
+ arr = self.dropna()
+
+ # we don't support these kwargs.
+ # They should only be present when called via pandas, so do it here.
+ # instead of in `any` / `all` (which will raise if they're present,
+ # thanks to nv.validate
+ kwargs.pop('filter_type', None)
+ kwargs.pop('numeric_only', None)
+ kwargs.pop('op', None)
+ return getattr(arr, name)(**kwargs)
+
+ def all(self, axis=None, *args, **kwargs):
"""
Tests whether all elements evaluate True
@@ -640,7 +1114,7 @@ def any(self, axis=0, *args, **kwargs):
if len(values) != len(self) and np.any(self.fill_value):
return True
- return values.any()
+ return values.any().item()
def sum(self, axis=0, *args, **kwargs):
"""
@@ -707,41 +1181,204 @@ def mean(self, axis=0, *args, **kwargs):
nsparse = self.sp_index.ngaps
return (sp_sum + self.fill_value * nsparse) / (ct + nsparse)
- def value_counts(self, dropna=True):
- """
- Returns a Series containing counts of unique values.
+ def transpose(self, *axes):
+ """Returns the SparseArray."""
+ return self
- Parameters
- ----------
- dropna : boolean, default True
- Don't include counts of NaN, even if NaN is in sp_values.
+ @property
+ def T(self):
+ """Returns the SparseArray."""
+ return self
+
+ # ------------------------------------------------------------------------
+ # Ufuncs
+ # ------------------------------------------------------------------------
+
+ def __array_wrap__(self, array, context=None):
+ from pandas.core.dtypes.generic import ABCSparseSeries
+
+ ufunc, inputs, _ = context
+ inputs = tuple(x.values if isinstance(x, ABCSparseSeries) else x
+ for x in inputs)
+ return self.__array_ufunc__(ufunc, '__call__', *inputs)
+
+ _HANDLED_TYPES = (np.ndarray, numbers.Number)
+
+ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+ out = kwargs.get('out', ())
+
+ for x in inputs + out:
+ if not isinstance(x, self._HANDLED_TYPES + (SparseArray,)):
+ return NotImplemented
+
+ special = {'add', 'sub', 'mul', 'pow', 'mod', 'floordiv', 'truediv',
+ 'divmod', 'eq', 'ne', 'lt', 'gt', 'le', 'ge', 'remainder'}
+ if compat.PY2:
+ special.add('div')
+ aliases = {
+ 'subtract': 'sub',
+ 'multiply': 'mul',
+ 'floor_divide': 'floordiv',
+ 'true_divide': 'truediv',
+ 'power': 'pow',
+ 'remainder': 'mod',
+ 'divide': 'div',
+ }
+ op_name = ufunc.__name__
+ op_name = aliases.get(op_name, op_name)
+
+ if op_name in special and kwargs.get('out') is None:
+ if isinstance(inputs[0], type(self)):
+ return getattr(self, '__{}__'.format(op_name))(inputs[1])
+ else:
+ return getattr(self, '__r{}__'.format(op_name))(inputs[0])
+
+ if len(inputs) == 1:
+ # No alignment necessary.
+ sp_values = getattr(ufunc, method)(self.sp_values, **kwargs)
+ fill_value = getattr(ufunc, method)(self.fill_value, **kwargs)
+ return self._simple_new(sp_values,
+ self.sp_index,
+ SparseDtype(sp_values.dtype, fill_value))
+
+ result = getattr(ufunc, method)(*[np.asarray(x) for x in inputs],
+ **kwargs)
+ if out:
+ if len(out) == 1:
+ out = out[0]
+ return out
+
+ if type(result) is tuple:
+ return tuple(type(self)(x) for x in result)
+ elif method == 'at':
+ # no return value
+ return None
+ else:
+ return type(self)(result)
+
+ def __abs__(self):
+ return np.abs(self)
+
+ # ------------------------------------------------------------------------
+ # Ops
+ # ------------------------------------------------------------------------
+
+ @classmethod
+ def _create_unary_method(cls, op):
+ def sparse_unary_method(self):
+ fill_value = op(np.array(self.fill_value)).item()
+ values = op(self.sp_values)
+ dtype = SparseDtype(values.dtype, fill_value)
+ return cls._simple_new(values, self.sp_index, dtype)
+
+ name = '__{name}__'.format(name=op.__name__)
+ return compat.set_function_name(sparse_unary_method, name, cls)
+
+ @classmethod
+ def _create_arithmetic_method(cls, op):
+ def sparse_arithmetic_method(self, other):
+ op_name = op.__name__
+
+ if isinstance(other, (ABCSeries, ABCIndexClass)):
+ other = getattr(other, 'values', other)
+
+ if isinstance(other, SparseArray):
+ return _sparse_array_op(self, other, op, op_name)
+
+ elif is_scalar(other):
+ with np.errstate(all='ignore'):
+ fill = op(_get_fill(self), np.asarray(other))
+ result = op(self.sp_values, other)
+
+ if op_name == 'divmod':
+ left, right = result
+ lfill, rfill = fill
+ return (_wrap_result(op_name, left, self.sp_index, lfill),
+ _wrap_result(op_name, right, self.sp_index, rfill))
+
+ return _wrap_result(op_name, result, self.sp_index, fill)
- Returns
- -------
- counts : Series
- """
- keys, counts = algos._value_counts_arraylike(self.sp_values,
- dropna=dropna)
- fcounts = self.sp_index.ngaps
- if fcounts > 0:
- if self._null_fill_value and dropna:
- pass
else:
- if self._null_fill_value:
- mask = pd.isna(keys)
- else:
- mask = keys == self.fill_value
+ other = np.asarray(other)
+ with np.errstate(all='ignore'):
+ # TODO: delete sparse stuff in core/ops.py
+ # TODO: look into _wrap_result
+ if len(self) != len(other):
+ raise AssertionError(
+ ("length mismatch: {self} vs. {other}".format(
+ self=len(self), other=len(other))))
+ if not isinstance(other, SparseArray):
+ dtype = getattr(other, 'dtype', None)
+ other = SparseArray(other, fill_value=self.fill_value,
+ dtype=dtype)
+ return _sparse_array_op(self, other, op, op_name)
+
+ name = '__{name}__'.format(name=op.__name__)
+ return compat.set_function_name(sparse_arithmetic_method, name, cls)
- if mask.any():
- counts[mask] += fcounts
- else:
- keys = np.insert(keys, 0, self.fill_value)
- counts = np.insert(counts, 0, fcounts)
+ @classmethod
+ def _create_comparison_method(cls, op):
+ def cmp_method(self, other):
+ op_name = op.__name__
+
+ if op_name in {'and_', 'or_'}:
+ op_name = op_name[:-1]
+
+ if isinstance(other, (ABCSeries, ABCIndexClass)):
+ other = getattr(other, 'values', other)
+
+ if not is_scalar(other) and not isinstance(other, type(self)):
+ # convert list-like to ndarary
+ other = np.asarray(other)
+
+ if isinstance(other, np.ndarray):
+ # TODO: make this more flexible than just ndarray...
+ if len(self) != len(other):
+ raise AssertionError("length mismatch: {self} vs. {other}"
+ .format(self=len(self),
+ other=len(other)))
+ other = SparseArray(other, fill_value=self.fill_value)
+
+ if isinstance(other, SparseArray):
+ return _sparse_array_op(self, other, op, op_name)
+ else:
+ with np.errstate(all='ignore'):
+ fill_value = op(self.fill_value, other)
+ result = op(self.sp_values, other)
- if not isinstance(keys, pd.Index):
- keys = pd.Index(keys)
- result = pd.Series(counts, index=keys)
- return result
+ return type(self)(result,
+ sparse_index=self.sp_index,
+ fill_value=fill_value,
+ dtype=np.bool_)
+
+ name = '__{name}__'.format(name=op.__name__)
+ return compat.set_function_name(cmp_method, name, cls)
+
+ @classmethod
+ def _add_unary_ops(cls):
+ cls.__pos__ = cls._create_unary_method(operator.pos)
+ cls.__neg__ = cls._create_unary_method(operator.neg)
+ cls.__invert__ = cls._create_unary_method(operator.invert)
+
+ @classmethod
+ def _add_comparison_ops(cls):
+ cls.__and__ = cls._create_comparison_method(operator.and_)
+ cls.__or__ = cls._create_comparison_method(operator.or_)
+ super(SparseArray, cls)._add_comparison_ops()
+
+ # ----------
+ # Formatting
+ # -----------
+ def __unicode__(self):
+ return '{self}\nFill: {fill}\n{index}'.format(
+ self=printing.pprint_thing(self),
+ fill=printing.pprint_thing(self.fill_value),
+ index=printing.pprint_thing(self.sp_index))
+
+
+SparseArray._add_arithmetic_ops()
+SparseArray._add_comparison_ops()
+SparseArray._add_unary_ops()
def _maybe_to_dense(obj):
@@ -785,7 +1422,7 @@ def _sanitize_values(arr):
return arr
-def make_sparse(arr, kind='block', fill_value=None):
+def make_sparse(arr, kind='block', fill_value=None, dtype=None, copy=False):
"""
Convert ndarray to sparse format
@@ -794,10 +1431,12 @@ def make_sparse(arr, kind='block', fill_value=None):
arr : ndarray
kind : {'block', 'integer'}
fill_value : NaN or another value
+ dtype : np.dtype, optional
+ copy : bool, default False
Returns
-------
- (sparse_values, index) : (ndarray, SparseIndex)
+ (sparse_values, index, fill_value) : (ndarray, SparseIndex, Scalar)
"""
arr = _sanitize_values(arr)
@@ -826,7 +1465,7 @@ def make_sparse(arr, kind='block', fill_value=None):
mask = arr != fill_value
length = len(arr)
- if length != mask.size:
+ if length != len(mask):
# the arr is a SparseArray
indices = mask.sp_index.indices
else:
@@ -834,6 +1473,9 @@ def make_sparse(arr, kind='block', fill_value=None):
index = _make_index(length, indices, kind)
sparsified_values = arr[mask]
+ if dtype is not None:
+ sparsified_values = astype_nansafe(sparsified_values, dtype=dtype)
+ # TODO: copy
return sparsified_values, index, fill_value
@@ -847,6 +1489,3 @@ def _make_index(length, indices, kind):
else: # pragma: no cover
raise ValueError('must be block or integer type')
return index
-
-
-ops.add_special_arithmetic_methods(SparseArray)
diff --git a/pandas/core/sparse/dtype.py b/pandas/core/sparse/dtype.py
new file mode 100644
index 0000000000000..7f99bf8b58847
--- /dev/null
+++ b/pandas/core/sparse/dtype.py
@@ -0,0 +1,249 @@
+import re
+
+import numpy as np
+
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.dtypes import register_extension_dtype
+from pandas import compat
+
+
+@register_extension_dtype
+class SparseDtype(ExtensionDtype):
+ """
+ Dtype for data stored in :class:`SparseArray`.
+
+ This dtype implements the pandas ExtensionDtype interface.
+
+ .. versionadded:: 0.24.0
+
+ Parameters
+ ----------
+ dtype : str, ExtensionDtype, numpy.dtype, type, default numpy.float64
+ The dtype of the underlying array storing the non-fill value values.
+ fill_value : scalar, optional.
+ The scalar value not stored in the SparseArray. By default, this
+ depends on `dtype`.
+
+ ========== ==========
+ dtype na_value
+ ========== ==========
+ float ``np.nan``
+ int ``0``
+ bool ``False``
+ datetime64 ``pd.NaT``
+ timedelta64 ``pd.NaT``
+ ========== ==========
+
+ The default value may be overridden by specifying a `fill_value`.
+ """
+ # We include `_is_na_fill_value` in the metadata to avoid hash collisions
+ # between SparseDtype(float, 0.0) and SparseDtype(float, nan).
+ # Without is_na_fill_value in the comparison, those would be equal since
+ # hash(nan) is (sometimes?) 0.
+ _metadata = ('_dtype', '_fill_value', '_is_na_fill_value')
+
+ def __init__(self, dtype=np.float64, fill_value=None):
+ # type: (Union[str, np.dtype, 'ExtensionDtype', type], Any) -> None
+ from pandas.core.dtypes.missing import na_value_for_dtype
+ from pandas.core.dtypes.common import (
+ pandas_dtype, is_string_dtype, is_scalar
+ )
+
+ if isinstance(dtype, type(self)):
+ if fill_value is None:
+ fill_value = dtype.fill_value
+ dtype = dtype.subtype
+
+ dtype = pandas_dtype(dtype)
+ if is_string_dtype(dtype):
+ dtype = np.dtype('object')
+
+ if fill_value is None:
+ fill_value = na_value_for_dtype(dtype)
+
+ if not is_scalar(fill_value):
+ raise ValueError("fill_value must be a scalar. Got {} "
+ "instead".format(fill_value))
+ self._dtype = dtype
+ self._fill_value = fill_value
+
+ def __hash__(self):
+ # Python3 doesn't inherit __hash__ when a base class overrides
+ # __eq__, so we explicitly do it here.
+ return super(SparseDtype, self).__hash__()
+
+ def __eq__(self, other):
+ # We have to override __eq__ to handle NA values in _metadata.
+ # The base class does simple == checks, which fail for NA.
+ if isinstance(other, compat.string_types):
+ try:
+ other = self.construct_from_string(other)
+ except TypeError:
+ return False
+
+ if isinstance(other, type(self)):
+ subtype = self.subtype == other.subtype
+ if self._is_na_fill_value:
+ # this case is complicated by two things:
+ # SparseDtype(float, float(nan)) == SparseDtype(float, np.nan)
+ # SparseDtype(float, np.nan) != SparseDtype(float, pd.NaT)
+ # i.e. we want to treat any floating-point NaN as equal, but
+ # not a floating-point NaN and a datetime NaT.
+ fill_value = (
+ other._is_na_fill_value and
+ isinstance(self.fill_value, type(other.fill_value)) or
+ isinstance(other.fill_value, type(self.fill_value))
+ )
+ else:
+ fill_value = self.fill_value == other.fill_value
+
+ return subtype and fill_value
+ return False
+
+ @property
+ def fill_value(self):
+ """
+ The fill value of the array.
+
+ Converting the SparseArray to a dense ndarray will fill the
+ array with this value.
+
+ .. warning::
+
+ It's possible to end up with a SparseArray that has ``fill_value``
+ values in ``sp_values``. This can occur, for example, when setting
+ ``SparseArray.fill_value`` directly.
+ """
+ return self._fill_value
+
+ @property
+ def _is_na_fill_value(self):
+ from pandas.core.dtypes.missing import isna
+ return isna(self.fill_value)
+
+ @property
+ def _is_numeric(self):
+ from pandas.core.dtypes.common import is_object_dtype
+ return not is_object_dtype(self.subtype)
+
+ @property
+ def _is_boolean(self):
+ from pandas.core.dtypes.common import is_bool_dtype
+ return is_bool_dtype(self.subtype)
+
+ @property
+ def kind(self):
+ return self.subtype.kind
+
+ @property
+ def type(self):
+ return self.subtype.type
+
+ @property
+ def subtype(self):
+ return self._dtype
+
+ @property
+ def name(self):
+ return 'Sparse[{}, {}]'.format(self.subtype.name, self.fill_value)
+
+ def __repr__(self):
+ return self.name
+
+ @classmethod
+ def construct_array_type(cls):
+ from .array import SparseArray
+ return SparseArray
+
+ @classmethod
+ def construct_from_string(cls, string):
+ """
+ Construct a SparseDtype from a string form.
+
+ Parameters
+ ----------
+ string : str
+ Can take the following forms.
+
+ string dtype
+ ================ ============================
+ 'int' SparseDtype[np.int64, 0]
+ 'Sparse' SparseDtype[np.float64, nan]
+ 'Sparse[int]' SparseDtype[np.int64, 0]
+ 'Sparse[int, 0]' SparseDtype[np.int64, 0]
+ ================ ============================
+
+ It is not possible to specify non-default fill values
+ with a string. An argument like ``'Sparse[int, 1]'``
+ will raise a ``TypeError`` because the default fill value
+ for integers is 0.
+
+ Returns
+ -------
+ SparseDtype
+ """
+ msg = "Could not construct SparseDtype from '{}'".format(string)
+ if string.startswith("Sparse"):
+ try:
+ sub_type, has_fill_value = cls._parse_subtype(string)
+ result = SparseDtype(sub_type)
+ except Exception:
+ raise TypeError(msg)
+ else:
+ msg = ("Could not construct SparseDtype from '{}'.\n\nIt "
+ "looks like the fill_value in the string is not "
+ "the default for the dtype. Non-default fill_values "
+ "are not supported. Use the 'SparseDtype()' "
+ "constructor instead.")
+ if has_fill_value and str(result) != string:
+ raise TypeError(msg.format(string))
+ return result
+ else:
+ raise TypeError(msg)
+
+ @staticmethod
+ def _parse_subtype(dtype):
+ """
+ Parse a string to get the subtype
+
+ Parameters
+ ----------
+ dtype : str
+ A string like
+
+ * Sparse[subtype]
+ * Sparse[subtype, fill_value]
+
+ Returns
+ -------
+ subtype : str
+
+ Raises
+ ------
+ ValueError
+ When the subtype cannot be extracted.
+ """
+ xpr = re.compile(
+ r"Sparse\[(?P<subtype>[^,]*)(, )?(?P<fill_value>.*?)?\]$"
+ )
+ m = xpr.match(dtype)
+ has_fill_value = False
+ if m:
+ subtype = m.groupdict()['subtype']
+ has_fill_value = m.groupdict()['fill_value'] or has_fill_value
+ elif dtype == "Sparse":
+ subtype = 'float64'
+ else:
+ raise ValueError("Cannot parse {}".format(dtype))
+ return subtype, has_fill_value
+
+ @classmethod
+ def is_dtype(cls, dtype):
+ dtype = getattr(dtype, 'dtype', dtype)
+ if (isinstance(dtype, compat.string_types) and
+ dtype.startswith("Sparse")):
+ sub_type, _ = cls._parse_subtype(dtype)
+ dtype = np.dtype(sub_type)
+ elif isinstance(dtype, cls):
+ return True
+ return isinstance(dtype, np.dtype) or dtype == 'Sparse'
diff --git a/pandas/core/sparse/frame.py b/pandas/core/sparse/frame.py
index 58e3001bcfe6a..36b6ea089f459 100644
--- a/pandas/core/sparse/frame.py
+++ b/pandas/core/sparse/frame.py
@@ -23,6 +23,7 @@
create_block_manager_from_arrays)
import pandas.core.generic as generic
from pandas.core.sparse.series import SparseSeries, SparseArray
+from pandas.core.sparse.dtype import SparseDtype
from pandas._libs.sparse import BlockIndex, get_blocks
from pandas.util._decorators import Appender
import pandas.core.ops as ops
@@ -169,14 +170,21 @@ def sp_maker(x):
v = [v.get(i, np.nan) for i in index]
v = sp_maker(v)
+
+ if index is not None and len(v) != len(index):
+ msg = "Length of passed values is {}, index implies {}"
+ raise ValueError(msg.format(len(v), len(index)))
sdict[k] = v
- # TODO: figure out how to handle this case, all nan's?
- # add in any other columns we want to have (completeness)
- nan_arr = np.empty(len(index), dtype='float64')
- nan_arr.fill(np.nan)
- nan_arr = sp_maker(nan_arr)
- sdict.update((c, nan_arr) for c in columns if c not in sdict)
+ if len(columns.difference(sdict)):
+ # TODO: figure out how to handle this case, all nan's?
+ # add in any other columns we want to have (completeness)
+ nan_arr = np.empty(len(index), dtype='float64')
+ nan_arr.fill(np.nan)
+ nan_arr = SparseArray(nan_arr, kind=self._default_kind,
+ fill_value=self._default_fill_value,
+ copy=False)
+ sdict.update((c, nan_arr) for c in columns if c not in sdict)
return to_manager(sdict, columns, index)
@@ -260,6 +268,9 @@ def to_coo(self):
raise ImportError('Scipy is not installed')
dtype = find_common_type(self.dtypes)
+ if isinstance(dtype, SparseDtype):
+ dtype = dtype.subtype
+
cols, rows, datas = [], [], []
for col, name in enumerate(self):
s = self[name]
diff --git a/pandas/core/sparse/series.py b/pandas/core/sparse/series.py
index 97cd3a0a1fb6a..eebf26bbb9708 100644
--- a/pandas/core/sparse/series.py
+++ b/pandas/core/sparse/series.py
@@ -8,22 +8,25 @@
import numpy as np
import warnings
-from pandas.core.dtypes.missing import isna, notna
+from pandas.core.dtypes.common import (
+ is_scalar,
+)
+from pandas.core.dtypes.missing import isna, notna, is_integer
+from pandas import compat
from pandas.compat.numpy import function as nv
-from pandas.core.index import Index, ensure_index, InvalidIndexError
+from pandas.core.index import Index
from pandas.core.series import Series
+from pandas.core.dtypes.generic import ABCSeries, ABCSparseSeries
from pandas.core.internals import SingleBlockManager
from pandas.core import generic
-import pandas.core.common as com
-import pandas.core.indexes.base as ibase
import pandas.core.ops as ops
import pandas._libs.index as libindex
from pandas.util._decorators import Appender, Substitution
from pandas.core.sparse.array import (
- make_sparse, SparseArray,
- _make_index)
+ SparseArray,
+)
from pandas._libs.sparse import BlockIndex, IntIndex
import pandas._libs.sparse as splib
@@ -65,142 +68,114 @@ class SparseSeries(Series):
def __init__(self, data=None, index=None, sparse_index=None, kind='block',
fill_value=None, name=None, dtype=None, copy=False,
fastpath=False):
+ # TODO: Most of this should be refactored and shared with Series
+ # 1. BlockManager -> array
+ # 2. Series.index, Series.name, index, name reconciliation
+ # 3. Implicit reindexing
+ # 4. Implicit broadcasting
+ # 5. Dict construction
+ if data is None:
+ data = []
+ elif isinstance(data, SingleBlockManager):
+ index = data.index
+ data = data.blocks[0].values
+ elif isinstance(data, (ABCSeries, ABCSparseSeries)):
+ index = data.index if index is None else index
+ dtype = data.dtype if dtype is None else dtype
+ name = data.name if name is None else name
+
+ if index is not None:
+ data = data.reindex(index)
+
+ elif isinstance(data, compat.Mapping):
+ data, index = Series()._init_dict(data, index=index)
+
+ elif is_scalar(data) and index is not None:
+ data = np.full(len(index), fill_value=data)
+
+ super(SparseSeries, self).__init__(
+ SparseArray(data,
+ sparse_index=sparse_index,
+ kind=kind,
+ dtype=dtype,
+ fill_value=fill_value,
+ copy=copy),
+ index=index, name=name,
+ copy=False, fastpath=fastpath
+ )
+
+ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+ # avoid infinite recursion for other SparseSeries inputs
+ inputs = tuple(
+ x.values if isinstance(x, type(self)) else x
+ for x in inputs
+ )
+ result = self.values.__array_ufunc__(ufunc, method, *inputs, **kwargs)
+ return self._constructor(result, index=self.index,
+ sparse_index=self.sp_index,
+ fill_value=result.fill_value,
+ copy=False).__finalize__(self)
- # we are called internally, so short-circuit
- if fastpath:
-
- # data is an ndarray, index is defined
-
- if not isinstance(data, SingleBlockManager):
- data = SingleBlockManager(data, index, fastpath=True)
- if copy:
- data = data.copy()
-
- else:
-
- if data is None:
- data = []
-
- if isinstance(data, Series) and name is None:
- name = data.name
-
- if isinstance(data, SparseArray):
- if index is not None:
- assert (len(index) == len(data))
- sparse_index = data.sp_index
- if fill_value is None:
- fill_value = data.fill_value
-
- data = np.asarray(data)
-
- elif isinstance(data, SparseSeries):
- if index is None:
- index = data.index.view()
- if fill_value is None:
- fill_value = data.fill_value
- # extract the SingleBlockManager
- data = data._data
-
- elif isinstance(data, (Series, dict)):
- data = Series(data, index=index)
- index = data.index.view()
-
- res = make_sparse(data, kind=kind, fill_value=fill_value)
- data, sparse_index, fill_value = res
-
- elif isinstance(data, (tuple, list, np.ndarray)):
- # array-like
- if sparse_index is None:
- res = make_sparse(data, kind=kind, fill_value=fill_value)
- data, sparse_index, fill_value = res
- else:
- assert (len(data) == sparse_index.npoints)
-
- elif isinstance(data, SingleBlockManager):
- if dtype is not None:
- data = data.astype(dtype)
- if index is None:
- index = data.index.view()
- elif not data.index.equals(index) or copy: # pragma: no cover
- # GH#19275 SingleBlockManager input should only be called
- # internally
- raise AssertionError('Cannot pass both SingleBlockManager '
- '`data` argument and a different '
- '`index` argument. `copy` must '
- 'be False.')
-
- else:
- length = len(index)
-
- if data == fill_value or (isna(data) and isna(fill_value)):
- if kind == 'block':
- sparse_index = BlockIndex(length, [], [])
- else:
- sparse_index = IntIndex(length, [])
- data = np.array([])
-
- else:
- if kind == 'block':
- locs, lens = ([0], [length]) if length else ([], [])
- sparse_index = BlockIndex(length, locs, lens)
- else:
- sparse_index = IntIndex(length, index)
- v = data
- data = np.empty(length)
- data.fill(v)
-
- if index is None:
- index = ibase.default_index(sparse_index.length)
- index = ensure_index(index)
-
- # create/copy the manager
- if isinstance(data, SingleBlockManager):
-
- if copy:
- data = data.copy()
- else:
-
- # create a sparse array
- if not isinstance(data, SparseArray):
- data = SparseArray(data, sparse_index=sparse_index,
- fill_value=fill_value, dtype=dtype,
- copy=copy)
-
- data = SingleBlockManager(data, index)
+ def __array_wrap__(self, result, context=None):
+ """
+ Gets called prior to a ufunc (and after)
- generic.NDFrame.__init__(self, data)
+ See SparseArray.__array_wrap__ for detail.
+ """
+ result = self.values.__array_wrap__(result, context=context)
+ return self._constructor(result, index=self.index,
+ sparse_index=self.sp_index,
+ fill_value=result.fill_value,
+ copy=False).__finalize__(self)
- self.index = index
- self.name = name
+ def __array_finalize__(self, obj):
+ """
+ Gets called after any ufunc or other array operations, necessary
+ to pass on the index.
+ """
+ self.name = getattr(obj, 'name', None)
+ self.fill_value = getattr(obj, 'fill_value', None)
- @property
- def values(self):
- """ return the array """
- return self.block.values
+ # unary ops
+ # TODO: See if this can be shared
+ def __pos__(self):
+ result = self.values.__pos__()
+ return self._constructor(result, index=self.index,
+ sparse_index=self.sp_index,
+ fill_value=result.fill_value,
+ copy=False).__finalize__(self)
- def __array__(self, result=None):
- """ the array interface, return my values """
- return self.block.values
+ def __neg__(self):
+ result = self.values.__neg__()
+ return self._constructor(result, index=self.index,
+ sparse_index=self.sp_index,
+ fill_value=result.fill_value,
+ copy=False).__finalize__(self)
- def get_values(self):
- """ same as values """
- return self.block.to_dense().view()
+ def __invert__(self):
+ result = self.values.__invert__()
+ return self._constructor(result, index=self.index,
+ sparse_index=self.sp_index,
+ fill_value=result.fill_value,
+ copy=False).__finalize__(self)
@property
def block(self):
+ warnings.warn("SparseSeries.block is deprecated.", FutureWarning,
+ stacklevel=2)
return self._data._block
@property
def fill_value(self):
- return self.block.fill_value
+ return self.values.fill_value
@fill_value.setter
def fill_value(self, v):
- self.block.fill_value = v
+ self.values.fill_value = v
@property
def sp_index(self):
- return self.block.sp_index
+ return self.values.sp_index
@property
def sp_values(self):
@@ -250,13 +225,6 @@ def as_sparse_array(self, kind=None, fill_value=None, copy=False):
return SparseArray(self.values, sparse_index=self.sp_index,
fill_value=fill_value, kind=kind, copy=copy)
- def __len__(self):
- return len(self.block)
-
- @property
- def shape(self):
- return self._data.shape
-
def __unicode__(self):
# currently, unicode is same as repr...fixes infinite loop
series_rep = Series.__unicode__(self)
@@ -264,33 +232,6 @@ def __unicode__(self):
index=self.sp_index)
return rep
- def __array_wrap__(self, result, context=None):
- """
- Gets called prior to a ufunc (and after)
-
- See SparseArray.__array_wrap__ for detail.
- """
- if isinstance(context, tuple) and len(context) == 3:
- ufunc, args, domain = context
- args = [getattr(a, 'fill_value', a) for a in args]
- with np.errstate(all='ignore'):
- fill_value = ufunc(self.fill_value, *args[1:])
- else:
- fill_value = self.fill_value
-
- return self._constructor(result, index=self.index,
- sparse_index=self.sp_index,
- fill_value=fill_value,
- copy=False).__finalize__(self)
-
- def __array_finalize__(self, obj):
- """
- Gets called after any ufunc or other array operations, necessary
- to pass on the index.
- """
- self.name = getattr(obj, 'name', None)
- self.fill_value = getattr(obj, 'fill_value', None)
-
def _reduce(self, op, name, axis=0, skipna=True, numeric_only=None,
filter_type=None, **kwds):
""" perform a reduction operation """
@@ -326,10 +267,6 @@ def _unpickle_series_compat(self, state):
self._set_axis(0, index)
self.name = name
- def __iter__(self):
- """ forward to the array """
- return iter(self.values)
-
def _set_subtyp(self, is_all_dates):
if is_all_dates:
object.__setattr__(self, '_subtyp', 'sparse_time_series')
@@ -356,31 +293,15 @@ def _ixs(self, i, axis=0):
def _get_val_at(self, loc):
""" forward to the array """
- return self.block.values._get_val_at(loc)
+ return self.values._get_val_at(loc)
def __getitem__(self, key):
- try:
- return self.index.get_value(self, key)
-
- except InvalidIndexError:
- pass
- except KeyError:
- if isinstance(key, (int, np.integer)):
- return self._get_val_at(key)
- elif key is Ellipsis:
- return self
- raise Exception('Requested index not in this series!')
-
- except TypeError:
- # Could not hash item, must be array-like?
- pass
-
- key = com.values_from_object(key)
- if self.index.nlevels > 1 and isinstance(key, tuple):
- # to handle MultiIndex labels
- key = self.index.get_loc(key)
- return self._constructor(self.values[key],
- index=self.index[key]).__finalize__(self)
+ # TODO: Document difference from Series.__getitem__, deprecate,
+ # and remove!
+ if is_integer(key) and key not in self.index:
+ return self._get_val_at(key)
+ else:
+ return super(SparseSeries, self).__getitem__(key)
def _get_values(self, indexer):
try:
@@ -556,18 +477,19 @@ def copy(self, deep=True):
Make a copy of the SparseSeries. Only the actual sparse values need to
be copied
"""
- new_data = self._data
- if deep:
- new_data = self._data.copy()
-
+ # TODO: https://github.com/pandas-dev/pandas/issues/22314
+ # We skip the block manager till that is resolved.
+ new_data = self.values.copy(deep=deep)
return self._constructor(new_data, sparse_index=self.sp_index,
- fill_value=self.fill_value).__finalize__(self)
+ fill_value=self.fill_value,
+ index=self.index.copy(),
+ name=self.name).__finalize__(self)
@Substitution(**_shared_doc_kwargs)
@Appender(generic.NDFrame.reindex.__doc__)
def reindex(self, index=None, method=None, copy=True, limit=None,
**kwargs):
-
+ # TODO: remove?
return super(SparseSeries, self).reindex(index=index, method=method,
copy=copy, limit=limit,
**kwargs)
@@ -585,28 +507,14 @@ def sparse_reindex(self, new_index):
reindexed : SparseSeries
"""
if not isinstance(new_index, splib.SparseIndex):
- raise TypeError('new index must be a SparseIndex')
-
- block = self.block.sparse_reindex(new_index)
- new_data = SingleBlockManager(block, self.index)
- return self._constructor(new_data, index=self.index,
- sparse_index=new_index,
- fill_value=self.fill_value).__finalize__(self)
-
- @Appender(generic.NDFrame.take.__doc__)
- def take(self, indices, axis=0, convert=None, *args, **kwargs):
- if convert is not None:
- msg = ("The 'convert' parameter is deprecated "
- "and will be removed in a future version.")
- warnings.warn(msg, FutureWarning, stacklevel=2)
- else:
- convert = True
-
- nv.validate_take_with_convert(convert, args, kwargs)
- new_values = SparseArray.take(self.values, indices)
- new_index = self.index.take(indices)
- return self._constructor(new_values,
- index=new_index).__finalize__(self)
+ raise TypeError("new index must be a SparseIndex")
+ values = self.values
+ values = values.sp_index.to_int_index().reindex(
+ values.sp_values.astype('float64'), values.fill_value, new_index)
+ values = SparseArray(values,
+ sparse_index=new_index,
+ fill_value=self.values.fill_value)
+ return self._constructor(values, index=self.index).__finalize__(self)
def cumsum(self, axis=0, *args, **kwargs):
"""
@@ -635,12 +543,14 @@ def cumsum(self, axis=0, *args, **kwargs):
new_array, index=self.index,
sparse_index=new_array.sp_index).__finalize__(self)
+ # TODO: SparseSeries.isna is Sparse, while Series.isna is dense
@Appender(generic._shared_docs['isna'] % _shared_doc_kwargs)
def isna(self):
arr = SparseArray(isna(self.values.sp_values),
sparse_index=self.values.sp_index,
fill_value=isna(self.fill_value))
return self._constructor(arr, index=self.index).__finalize__(self)
+
isnull = isna
@Appender(generic._shared_docs['notna'] % _shared_doc_kwargs)
@@ -668,35 +578,6 @@ def dropna(self, axis=0, inplace=False, **kwargs):
dense_valid = dense_valid[dense_valid != self.fill_value]
return dense_valid.to_sparse(fill_value=self.fill_value)
- @Appender(generic._shared_docs['shift'] % _shared_doc_kwargs)
- def shift(self, periods, freq=None, axis=0):
- if periods == 0:
- return self.copy()
-
- # no special handling of fill values yet
- if not isna(self.fill_value):
- shifted = self.to_dense().shift(periods, freq=freq,
- axis=axis)
- return shifted.to_sparse(fill_value=self.fill_value,
- kind=self.kind)
-
- if freq is not None:
- return self._constructor(
- self.sp_values, sparse_index=self.sp_index,
- index=self.index.shift(periods, freq),
- fill_value=self.fill_value).__finalize__(self)
-
- int_index = self.sp_index.to_int_index()
- new_indices = int_index.indices + periods
- start, end = new_indices.searchsorted([0, int_index.length])
-
- new_indices = new_indices[start:end]
- new_sp_index = _make_index(len(self), new_indices, self.sp_index)
-
- arr = self.values._simple_new(self.sp_values[start:end].copy(),
- new_sp_index, fill_value=np.nan)
- return self._constructor(arr, index=self.index).__finalize__(self)
-
def combine_first(self, other):
"""
Combine Series values, choosing the calling Series's values
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index 4033d46e161ad..1a234cdfe3518 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -44,7 +44,7 @@ class TestPDApi(Base):
'DatetimeIndex', 'ExcelFile', 'ExcelWriter', 'Float64Index',
'Grouper', 'HDFStore', 'Index', 'Int64Index', 'MultiIndex',
'Period', 'PeriodIndex', 'RangeIndex', 'UInt64Index',
- 'Series', 'SparseArray', 'SparseDataFrame',
+ 'Series', 'SparseArray', 'SparseDataFrame', 'SparseDtype',
'SparseSeries', 'Timedelta',
'TimedeltaIndex', 'Timestamp', 'Interval', 'IntervalIndex']
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index 882b2c156478a..b5353e34a2311 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -6,6 +6,7 @@
from pandas.core.dtypes.dtypes import (DatetimeTZDtype, PeriodDtype,
CategoricalDtype, IntervalDtype)
+from pandas.core.sparse.api import SparseDtype
import pandas.core.dtypes.common as com
import pandas.util.testing as tm
@@ -569,8 +570,8 @@ def test_is_offsetlike():
(pd.DatetimeIndex([1, 2]).dtype, np.dtype('=M8[ns]')),
('<M8[ns]', np.dtype('<M8[ns]')),
('datetime64[ns, Europe/London]', DatetimeTZDtype('ns', 'Europe/London')),
- (pd.SparseSeries([1, 2], dtype='int32'), np.dtype('int32')),
- (pd.SparseSeries([1, 2], dtype='int32').dtype, np.dtype('int32')),
+ (pd.SparseSeries([1, 2], dtype='int32'), SparseDtype('int32')),
+ (pd.SparseSeries([1, 2], dtype='int32').dtype, SparseDtype('int32')),
(PeriodDtype(freq='D'), PeriodDtype(freq='D')),
('period[D]', PeriodDtype(freq='D')),
(IntervalDtype(), IntervalDtype()),
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index 7e95b076a8a66..c53c2e5059cde 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -17,7 +17,10 @@
is_dtype_equal, is_datetime64_ns_dtype,
is_datetime64_dtype, is_interval_dtype,
is_datetime64_any_dtype, is_string_dtype,
- _coerce_to_dtype, is_bool_dtype)
+ _coerce_to_dtype,
+ is_bool_dtype,
+)
+from pandas.core.sparse.api import SparseDtype
import pandas.util.testing as tm
@@ -817,6 +820,24 @@ def test_pandas_registry_find(dtype, expected):
assert _pandas_registry.find(dtype) == expected
+@pytest.mark.parametrize('dtype, expected', [
+ (str, False),
+ (int, False),
+ (bool, True),
+ (np.bool, True),
+ (np.array(['a', 'b']), False),
+ (pd.Series([1, 2]), False),
+ (np.array([True, False]), True),
+ (pd.Series([True, False]), True),
+ (pd.SparseSeries([True, False]), True),
+ (pd.SparseArray([True, False]), True),
+ (SparseDtype(bool), True)
+])
+def test_is_bool_dtype(dtype, expected):
+ result = is_bool_dtype(dtype)
+ assert result is expected
+
+
@pytest.mark.parametrize("check", [
is_categorical_dtype,
is_datetime64tz_dtype,
diff --git a/pandas/tests/extension/arrow/bool.py b/pandas/tests/extension/arrow/bool.py
index a9da25cdd2755..d595879e3cb7d 100644
--- a/pandas/tests/extension/arrow/bool.py
+++ b/pandas/tests/extension/arrow/bool.py
@@ -67,7 +67,11 @@ def _from_sequence(cls, scalars, dtype=None, copy=False):
return cls.from_scalars(scalars)
def __getitem__(self, item):
- return self._data.to_pandas()[item]
+ if pd.api.types.is_scalar(item):
+ return self._data.to_pandas()[item]
+ else:
+ vals = self._data.to_pandas()[item]
+ return type(self).from_scalars(vals)
def __len__(self):
return len(self._data)
@@ -83,7 +87,8 @@ def nbytes(self):
if x is not None)
def isna(self):
- return pd.isna(self._data.to_pandas())
+ nas = pd.isna(self._data.to_pandas())
+ return type(self).from_scalars(nas)
def take(self, indices, allow_fill=False, fill_value=None):
data = self._data.to_pandas()
@@ -106,3 +111,26 @@ def _concat_same_type(cls, to_concat):
for x in to_concat))
arr = pa.chunked_array(chunks)
return cls(arr)
+
+ def __invert__(self):
+ return type(self).from_scalars(
+ ~self._data.to_pandas()
+ )
+
+ def _reduce(self, method, skipna=True, **kwargs):
+ if skipna:
+ arr = self[~self.isna()]
+ else:
+ arr = self
+
+ try:
+ op = getattr(arr, method)
+ except AttributeError:
+ raise TypeError
+ return op(**kwargs)
+
+ def any(self, axis=0, out=None):
+ return self._data.to_pandas().any()
+
+ def all(self, axis=0, out=None):
+ return self._data.to_pandas().all()
diff --git a/pandas/tests/extension/arrow/test_bool.py b/pandas/tests/extension/arrow/test_bool.py
index 12c37d1fdf895..5a01533cfc564 100644
--- a/pandas/tests/extension/arrow/test_bool.py
+++ b/pandas/tests/extension/arrow/test_bool.py
@@ -20,6 +20,11 @@ def data():
dtype=bool))
+@pytest.fixture
+def data_missing():
+ return ArrowBoolArray.from_scalars([None, True])
+
+
class BaseArrowTests(object):
pass
@@ -40,6 +45,11 @@ def test_from_dtype(self, data):
class TestReduce(base.BaseNoReduceTests):
+ def test_reduce_series_boolean(self):
+ pass
+
+
+class TestReduceBoolean(base.BaseBooleanReduceTests):
pass
diff --git a/pandas/tests/extension/base/interface.py b/pandas/tests/extension/base/interface.py
index 99c3b92541cbd..91b1b87a9d7ea 100644
--- a/pandas/tests/extension/base/interface.py
+++ b/pandas/tests/extension/base/interface.py
@@ -71,3 +71,16 @@ def test_no_values_attribute(self, data):
def test_is_numeric_honored(self, data):
result = pd.Series(data)
assert result._data.blocks[0].is_numeric is data.dtype._is_numeric
+
+ def test_isna_extension_array(self, data_missing):
+ # If your `isna` returns an ExtensionArray, you must also implement
+ # _reduce. At the *very* least, you must implement any and all
+ na = data_missing.isna()
+ if is_extension_array_dtype(na):
+ assert na._reduce('any')
+ assert na.any()
+
+ assert not na._reduce('all')
+ assert not na.all()
+
+ assert na.dtype._is_boolean
diff --git a/pandas/tests/extension/base/ops.py b/pandas/tests/extension/base/ops.py
index 36696bc292162..9c1cfcdfeacc3 100644
--- a/pandas/tests/extension/base/ops.py
+++ b/pandas/tests/extension/base/ops.py
@@ -20,7 +20,7 @@ def get_op_from_name(self, op_name):
return op
- def check_opname(self, s, op_name, other, exc=NotImplementedError):
+ def check_opname(self, s, op_name, other, exc=Exception):
op = self.get_op_from_name(op_name)
self._check_op(s, op, other, op_name, exc)
@@ -34,7 +34,7 @@ def _check_op(self, s, op, other, op_name, exc=NotImplementedError):
with pytest.raises(exc):
op(s, other)
- def _check_divmod_op(self, s, op, other, exc=NotImplementedError):
+ def _check_divmod_op(self, s, op, other, exc=Exception):
# divmod has multiple return values, so check separatly
if exc is None:
result_div, result_mod = op(s, other)
@@ -50,13 +50,26 @@ def _check_divmod_op(self, s, op, other, exc=NotImplementedError):
class BaseArithmeticOpsTests(BaseOpsUtil):
- """Various Series and DataFrame arithmetic ops methods."""
+ """Various Series and DataFrame arithmetic ops methods.
+
+ Subclasses supporting various ops should set the class variables
+ to indicate that they support ops of that kind
+
+ * series_scalar_exc = TypeError
+ * frame_scalar_exc = TypeError
+ * series_array_exc = TypeError
+ * divmod_exc = TypeError
+ """
+ series_scalar_exc = TypeError
+ frame_scalar_exc = TypeError
+ series_array_exc = TypeError
+ divmod_exc = TypeError
def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
# series & scalar
op_name = all_arithmetic_operators
s = pd.Series(data)
- self.check_opname(s, op_name, s.iloc[0], exc=TypeError)
+ self.check_opname(s, op_name, s.iloc[0], exc=self.series_scalar_exc)
@pytest.mark.xfail(run=False, reason="_reduce needs implementation",
strict=True)
@@ -64,19 +77,19 @@ def test_arith_frame_with_scalar(self, data, all_arithmetic_operators):
# frame & scalar
op_name = all_arithmetic_operators
df = pd.DataFrame({'A': data})
- self.check_opname(df, op_name, data[0], exc=TypeError)
+ self.check_opname(df, op_name, data[0], exc=self.frame_scalar_exc)
def test_arith_series_with_array(self, data, all_arithmetic_operators):
# ndarray & other series
op_name = all_arithmetic_operators
s = pd.Series(data)
self.check_opname(s, op_name, pd.Series([s.iloc[0]] * len(s)),
- exc=TypeError)
+ exc=self.series_array_exc)
def test_divmod(self, data):
s = pd.Series(data)
- self._check_divmod_op(s, divmod, 1, exc=TypeError)
- self._check_divmod_op(1, ops.rdivmod, s, exc=TypeError)
+ self._check_divmod_op(s, divmod, 1, exc=self.divmod_exc)
+ self._check_divmod_op(1, ops.rdivmod, s, exc=self.divmod_exc)
def test_divmod_series_array(self, data):
s = pd.Series(data)
diff --git a/pandas/tests/extension/base/reshaping.py b/pandas/tests/extension/base/reshaping.py
index 0340289e0b674..7f13c2cd67373 100644
--- a/pandas/tests/extension/base/reshaping.py
+++ b/pandas/tests/extension/base/reshaping.py
@@ -46,8 +46,7 @@ def test_concat_mixed_dtypes(self, data):
df1 = pd.DataFrame({'A': data[:3]})
df2 = pd.DataFrame({"A": [1, 2, 3]})
df3 = pd.DataFrame({"A": ['a', 'b', 'c']}).astype('category')
- df4 = pd.DataFrame({"A": pd.SparseArray([1, 2, 3])})
- dfs = [df1, df2, df3, df4]
+ dfs = [df1, df2, df3]
# dataframes
result = pd.concat(dfs)
diff --git a/pandas/tests/extension/test_sparse.py b/pandas/tests/extension/test_sparse.py
new file mode 100644
index 0000000000000..11bf1cb6e9f05
--- /dev/null
+++ b/pandas/tests/extension/test_sparse.py
@@ -0,0 +1,295 @@
+import pytest
+import pandas as pd
+import numpy as np
+
+from pandas.core.sparse.dtype import SparseDtype
+from pandas import SparseArray
+from pandas.errors import PerformanceWarning
+from pandas.tests.extension import base
+import pandas.util.testing as tm
+
+
+def make_data(fill_value):
+ if np.isnan(fill_value):
+ data = np.random.uniform(size=100)
+ else:
+ data = np.random.randint(0, 100, size=100)
+
+ data[2::3] = fill_value
+ return data
+
+
+@pytest.fixture
+def dtype():
+ return SparseDtype()
+
+
+@pytest.fixture(params=[0, np.nan])
+def data(request):
+ """Length-100 PeriodArray for semantics test."""
+ res = SparseArray(make_data(request.param),
+ fill_value=request.param)
+ return res
+
+
+@pytest.fixture(params=[0, np.nan])
+def data_missing(request):
+ """Length 2 array with [NA, Valid]"""
+ return SparseArray([np.nan, 1], fill_value=request.param)
+
+
+@pytest.fixture(params=[0, np.nan])
+def data_repeated(request):
+ """Return different versions of data for count times"""
+ def gen(count):
+ for _ in range(count):
+ yield SparseArray(make_data(request.param),
+ fill_value=request.param)
+ yield gen
+
+
+@pytest.fixture(params=[0, np.nan])
+def data_for_sorting(request):
+ return SparseArray([2, 3, 1], fill_value=request.param)
+
+
+@pytest.fixture(params=[0, np.nan])
+def data_missing_for_sorting(request):
+ return SparseArray([2, np.nan, 1], fill_value=request.param)
+
+
+@pytest.fixture
+def na_value():
+ return np.nan
+
+
+@pytest.fixture
+def na_cmp():
+ return lambda left, right: pd.isna(left) and pd.isna(right)
+
+
+@pytest.fixture(params=[0, np.nan])
+def data_for_grouping(request):
+ return SparseArray([1, 1, np.nan, np.nan, 2, 2, 1, 3],
+ fill_value=request.param)
+
+
+class BaseSparseTests(object):
+
+ def _check_unsupported(self, data):
+ if data.dtype == SparseDtype(int, 0):
+ pytest.skip("Can't store nan in int array.")
+
+
+class TestDtype(BaseSparseTests, base.BaseDtypeTests):
+
+ def test_array_type_with_arg(self, data, dtype):
+ assert dtype.construct_array_type() is SparseArray
+
+
+class TestInterface(BaseSparseTests, base.BaseInterfaceTests):
+ def test_no_values_attribute(self, data):
+ pytest.skip("We have values")
+
+
+class TestConstructors(BaseSparseTests, base.BaseConstructorsTests):
+ pass
+
+
+class TestReshaping(BaseSparseTests, base.BaseReshapingTests):
+
+ def test_concat_mixed_dtypes(self, data):
+ # https://github.com/pandas-dev/pandas/issues/20762
+ # This should be the same, aside from concat([sparse, float])
+ df1 = pd.DataFrame({'A': data[:3]})
+ df2 = pd.DataFrame({"A": [1, 2, 3]})
+ df3 = pd.DataFrame({"A": ['a', 'b', 'c']}).astype('category')
+ dfs = [df1, df2, df3]
+
+ # dataframes
+ result = pd.concat(dfs)
+ expected = pd.concat([x.apply(lambda s: np.asarray(s).astype(object))
+ for x in dfs])
+ self.assert_frame_equal(result, expected)
+
+ def test_concat_columns(self, data, na_value):
+ self._check_unsupported(data)
+ super(TestReshaping, self).test_concat_columns(data, na_value)
+
+ def test_align(self, data, na_value):
+ self._check_unsupported(data)
+ super(TestReshaping, self).test_align(data, na_value)
+
+ def test_align_frame(self, data, na_value):
+ self._check_unsupported(data)
+ super(TestReshaping, self).test_align_frame(data, na_value)
+
+ def test_align_series_frame(self, data, na_value):
+ self._check_unsupported(data)
+ super(TestReshaping, self).test_align_series_frame(data, na_value)
+
+ def test_merge(self, data, na_value):
+ self._check_unsupported(data)
+ super(TestReshaping, self).test_merge(data, na_value)
+
+
+class TestGetitem(BaseSparseTests, base.BaseGetitemTests):
+
+ def test_get(self, data):
+ s = pd.Series(data, index=[2 * i for i in range(len(data))])
+ if np.isnan(s.values.fill_value):
+ assert np.isnan(s.get(4)) and np.isnan(s.iloc[2])
+ else:
+ assert s.get(4) == s.iloc[2]
+ assert s.get(2) == s.iloc[1]
+
+ def test_reindex(self, data, na_value):
+ self._check_unsupported(data)
+ super(TestGetitem, self).test_reindex(data, na_value)
+
+
+# Skipping TestSetitem, since we don't implement it.
+
+class TestMissing(BaseSparseTests, base.BaseMissingTests):
+
+ def test_isna(self, data_missing):
+ expected_dtype = SparseDtype(bool,
+ pd.isna(data_missing.dtype.fill_value))
+ expected = SparseArray([True, False], dtype=expected_dtype)
+
+ result = pd.isna(data_missing)
+ self.assert_equal(result, expected)
+
+ result = pd.Series(data_missing).isna()
+ expected = pd.Series(expected)
+ self.assert_series_equal(result, expected)
+
+ # GH 21189
+ result = pd.Series(data_missing).drop([0, 1]).isna()
+ expected = pd.Series([], dtype=expected_dtype)
+ self.assert_series_equal(result, expected)
+
+ def test_fillna_limit_pad(self, data_missing):
+ with tm.assert_produces_warning(PerformanceWarning):
+ super(TestMissing, self).test_fillna_limit_pad(data_missing)
+
+ def test_fillna_limit_backfill(self, data_missing):
+ with tm.assert_produces_warning(PerformanceWarning):
+ super(TestMissing, self).test_fillna_limit_backfill(data_missing)
+
+ def test_fillna_series_method(self, data_missing):
+ with tm.assert_produces_warning(PerformanceWarning):
+ super(TestMissing, self).test_fillna_limit_backfill(data_missing)
+
+ @pytest.mark.skip(reason="Unsupported")
+ def test_fillna_series(self):
+ # this one looks doable.
+ pass
+
+ def test_fillna_frame(self, data_missing):
+ # Have to override to specify that fill_value will change.
+ fill_value = data_missing[1]
+
+ result = pd.DataFrame({
+ "A": data_missing,
+ "B": [1, 2]
+ }).fillna(fill_value)
+
+ if pd.isna(data_missing.fill_value):
+ dtype = SparseDtype(data_missing.dtype, fill_value)
+ else:
+ dtype = data_missing.dtype
+
+ expected = pd.DataFrame({
+ "A": data_missing._from_sequence([fill_value, fill_value],
+ dtype=dtype),
+ "B": [1, 2],
+ })
+
+ self.assert_frame_equal(result, expected)
+
+
+class TestMethods(BaseSparseTests, base.BaseMethodsTests):
+
+ def test_combine_le(self, data_repeated):
+ # We return a Series[SparseArray].__le__ returns a
+ # Series[Sparse[bool]]
+ # rather than Series[bool]
+ orig_data1, orig_data2 = data_repeated(2)
+ s1 = pd.Series(orig_data1)
+ s2 = pd.Series(orig_data2)
+ result = s1.combine(s2, lambda x1, x2: x1 <= x2)
+ expected = pd.Series(pd.SparseArray([
+ a <= b for (a, b) in
+ zip(list(orig_data1), list(orig_data2))
+ ], fill_value=False))
+ self.assert_series_equal(result, expected)
+
+ val = s1.iloc[0]
+ result = s1.combine(val, lambda x1, x2: x1 <= x2)
+ expected = pd.Series(pd.SparseArray([
+ a <= val for a in list(orig_data1)
+ ], fill_value=False))
+ self.assert_series_equal(result, expected)
+
+
+class TestCasting(BaseSparseTests, base.BaseCastingTests):
+ pass
+
+
+class TestArithmeticOps(BaseSparseTests, base.BaseArithmeticOpsTests):
+ series_scalar_exc = None
+ frame_scalar_exc = None
+ divmod_exc = None
+ series_array_exc = None
+
+ def _skip_if_different_combine(self, data):
+ if data.fill_value == 0:
+ # arith ops call on dtype.fill_value so that the sparsity
+ # is maintained. Combine can't be called on a dtype in
+ # general, so we can't make the expected. This is tested elsewhere
+ raise pytest.skip("Incorrected expected from Series.combine")
+
+ def test_error(self, data, all_arithmetic_operators):
+ pass
+
+ def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
+ self._skip_if_different_combine(data)
+ super(TestArithmeticOps, self).test_arith_series_with_scalar(
+ data,
+ all_arithmetic_operators
+ )
+
+ def test_arith_series_with_array(self, data, all_arithmetic_operators):
+ self._skip_if_different_combine(data)
+ super(TestArithmeticOps, self).test_arith_series_with_array(
+ data,
+ all_arithmetic_operators
+ )
+
+
+class TestComparisonOps(BaseSparseTests, base.BaseComparisonOpsTests):
+
+ def _compare_other(self, s, data, op_name, other):
+ op = self.get_op_from_name(op_name)
+
+ # array
+ result = pd.Series(op(data, other))
+ # hard to test the fill value, since we don't know what expected
+ # is in general.
+ # Rely on tests in `tests/sparse` to validate that.
+ assert isinstance(result.dtype, SparseDtype)
+ assert result.dtype.subtype == np.dtype('bool')
+
+ with np.errstate(all='ignore'):
+ expected = pd.Series(
+ pd.SparseArray(op(np.asarray(data), np.asarray(other)),
+ fill_value=result.values.fill_value)
+ )
+
+ tm.assert_series_equal(result, expected)
+
+ # series
+ s = pd.Series(data)
+ result = op(s, other)
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index 4b4296e4abc16..d6d932d235eec 100644
--- a/pandas/tests/frame/test_api.py
+++ b/pandas/tests/frame/test_api.py
@@ -402,7 +402,10 @@ def test_with_datetimelikes(self):
t = df.T
result = t.get_dtype_counts()
- expected = Series({'object': 10})
+ if self.klass is DataFrame:
+ expected = Series({'object': 10})
+ else:
+ expected = Series({'Sparse[object, nan]': 10})
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py
index 2b93af357481a..fe2d14458c197 100644
--- a/pandas/tests/frame/test_indexing.py
+++ b/pandas/tests/frame/test_indexing.py
@@ -2290,7 +2290,7 @@ def test_setitem_with_unaligned_sparse_value(self):
sp_series = (pd.Series([0, 0, 1], index=[2, 1, 0])
.to_sparse(fill_value=0))
df['new_column'] = sp_series
- exp = pd.Series([1, 0, 0], name='new_column')
+ exp = pd.SparseSeries([1, 0, 0], name='new_column')
assert_series_equal(df['new_column'], exp)
def test_setitem_with_unaligned_tz_aware_datetime_column(self):
diff --git a/pandas/tests/frame/test_subclass.py b/pandas/tests/frame/test_subclass.py
index 07289d897be62..f6980a8585436 100644
--- a/pandas/tests/frame/test_subclass.py
+++ b/pandas/tests/frame/test_subclass.py
@@ -235,10 +235,12 @@ def test_subclass_sparse_slice(self):
tm.assert_sp_series_equal(ssdf.loc[1],
tm.SubclassedSparseSeries(rows[1]),
- check_names=False)
+ check_names=False,
+ check_kind=False)
tm.assert_sp_series_equal(ssdf.iloc[1],
tm.SubclassedSparseSeries(rows[1]),
- check_names=False)
+ check_names=False,
+ check_kind=False)
def test_subclass_sparse_transpose(self):
ossdf = tm.SubclassedSparseDataFrame([[1, 2, 3],
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 86251ad7529d5..b6a83b786bab2 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -845,23 +845,18 @@ class TestIndexing(object):
MANAGERS = [
create_single_mgr('f8', N),
create_single_mgr('i8', N),
- # create_single_mgr('sparse', N),
- create_single_mgr('sparse_na', N),
# 2-dim
create_mgr('a,b,c,d,e,f: f8', item_shape=(N,)),
create_mgr('a,b,c,d,e,f: i8', item_shape=(N,)),
create_mgr('a,b: f8; c,d: i8; e,f: string', item_shape=(N,)),
create_mgr('a,b: f8; c,d: i8; e,f: f8', item_shape=(N,)),
- # create_mgr('a: sparse', item_shape=(N,)),
- create_mgr('a: sparse_na', item_shape=(N,)),
# 3-dim
create_mgr('a,b,c,d,e,f: f8', item_shape=(N, N)),
create_mgr('a,b,c,d,e,f: i8', item_shape=(N, N)),
create_mgr('a,b: f8; c,d: i8; e,f: string', item_shape=(N, N)),
create_mgr('a,b: f8; c,d: i8; e,f: f8', item_shape=(N, N)),
- # create_mgr('a: sparse', item_shape=(1, N)),
]
# MANAGERS = [MANAGERS[6]]
diff --git a/pandas/tests/reshape/test_reshape.py b/pandas/tests/reshape/test_reshape.py
index ed9ad06a9b371..d8b3d9588f2f1 100644
--- a/pandas/tests/reshape/test_reshape.py
+++ b/pandas/tests/reshape/test_reshape.py
@@ -5,6 +5,7 @@
from collections import OrderedDict
from pandas import DataFrame, Series
+from pandas.core.sparse.api import SparseDtype, SparseArray
import pandas as pd
from numpy import nan
@@ -54,13 +55,22 @@ def test_basic(self, sparse, dtype):
'c': [0, 0, 1]},
dtype=self.effective_dtype(dtype))
result = get_dummies(s_list, sparse=sparse, dtype=dtype)
- assert_frame_equal(result, expected)
+ if sparse:
+ tm.assert_sp_frame_equal(result,
+ expected.to_sparse(kind='integer',
+ fill_value=0))
+ else:
+ assert_frame_equal(result, expected)
result = get_dummies(s_series, sparse=sparse, dtype=dtype)
+ if sparse:
+ expected = expected.to_sparse(kind='integer', fill_value=0)
assert_frame_equal(result, expected)
expected.index = list('ABC')
result = get_dummies(s_series_index, sparse=sparse, dtype=dtype)
+ if sparse:
+ expected.to_sparse(kind='integer', fill_value=0)
assert_frame_equal(result, expected)
def test_basic_types(self, sparse, dtype):
@@ -90,11 +100,17 @@ def test_basic_types(self, sparse, dtype):
result = get_dummies(s_df, columns=s_df.columns,
sparse=sparse, dtype=dtype)
- tm.assert_series_equal(result.get_dtype_counts(),
- Series({dtype.name: 8}))
+ if sparse:
+ dtype_name = 'Sparse[{}, 0]'.format(
+ self.effective_dtype(dtype).name
+ )
+ else:
+ dtype_name = self.effective_dtype(dtype).name
+
+ expected = Series({dtype_name: 8})
+ tm.assert_series_equal(result.get_dtype_counts(), expected)
result = get_dummies(s_df, columns=['a'], sparse=sparse, dtype=dtype)
- dtype_name = self.effective_dtype(dtype).name
expected_counts = {'int64': 1, 'object': 1}
expected_counts[dtype_name] = 3 + expected_counts.get(dtype_name, 0)
@@ -158,7 +174,11 @@ def test_unicode(self, sparse):
exp = DataFrame({'letter_e': [1, 0, 0],
u('letter_%s') % eacute: [0, 1, 1]},
dtype=np.uint8)
- assert_frame_equal(res, exp)
+ if sparse:
+ tm.assert_sp_frame_equal(res, exp.to_sparse(fill_value=0,
+ kind='integer'))
+ else:
+ assert_frame_equal(res, exp)
def test_dataframe_dummies_all_obj(self, df, sparse):
df = df[['A', 'B']]
@@ -168,17 +188,31 @@ def test_dataframe_dummies_all_obj(self, df, sparse):
'B_b': [1, 1, 0],
'B_c': [0, 0, 1]},
dtype=np.uint8)
- assert_frame_equal(result, expected)
+ if sparse:
+ expected = pd.SparseDataFrame({
+ "A_a": pd.SparseArray([1, 0, 1], dtype='uint8'),
+ "A_b": pd.SparseArray([0, 1, 0], dtype='uint8'),
+ "B_b": pd.SparseArray([1, 1, 0], dtype='uint8'),
+ "B_c": pd.SparseArray([0, 0, 1], dtype='uint8'),
+ })
+
+ tm.assert_sp_frame_equal(result, expected)
+ else:
+ assert_frame_equal(result, expected)
def test_dataframe_dummies_mix_default(self, df, sparse, dtype):
result = get_dummies(df, sparse=sparse, dtype=dtype)
+ if sparse:
+ arr = SparseArray
+ typ = SparseDtype(dtype, 0)
+ else:
+ arr = np.array
+ typ = dtype
expected = DataFrame({'C': [1, 2, 3],
- 'A_a': [1, 0, 1],
- 'A_b': [0, 1, 0],
- 'B_b': [1, 1, 0],
- 'B_c': [0, 0, 1]})
- cols = ['A_a', 'A_b', 'B_b', 'B_c']
- expected[cols] = expected[cols].astype(dtype)
+ 'A_a': arr([1, 0, 1], dtype=typ),
+ 'A_b': arr([0, 1, 0], dtype=typ),
+ 'B_b': arr([1, 1, 0], dtype=typ),
+ 'B_c': arr([0, 0, 1], dtype=typ)})
expected = expected[['C', 'A_a', 'A_b', 'B_b', 'B_c']]
assert_frame_equal(result, expected)
@@ -192,8 +226,11 @@ def test_dataframe_dummies_prefix_list(self, df, sparse):
'from_B_c': [0, 0, 1]},
dtype=np.uint8)
expected[['C']] = df[['C']]
- expected = expected[['C', 'from_A_a', 'from_A_b',
- 'from_B_b', 'from_B_c']]
+ cols = ['from_A_a', 'from_A_b', 'from_B_b', 'from_B_c']
+ expected = expected[['C'] + cols]
+
+ typ = pd.SparseArray if sparse else pd.Series
+ expected[cols] = expected[cols].apply(lambda x: typ(x))
assert_frame_equal(result, expected)
def test_dataframe_dummies_prefix_str(self, df, sparse):
@@ -206,6 +243,17 @@ def test_dataframe_dummies_prefix_str(self, df, sparse):
columns=['C'] + bad_columns,
dtype=np.uint8)
expected = expected.astype({"C": np.int64})
+ if sparse:
+ # work around astyping & assigning with duplicate columns
+ # https://github.com/pandas-dev/pandas/issues/14427
+ expected = pd.concat([
+ pd.Series([1, 2, 3], name='C'),
+ pd.Series([1, 0, 1], name='bad_a', dtype='Sparse[uint8]'),
+ pd.Series([0, 1, 0], name='bad_b', dtype='Sparse[uint8]'),
+ pd.Series([1, 1, 0], name='bad_b', dtype='Sparse[uint8]'),
+ pd.Series([0, 0, 1], name='bad_c', dtype='Sparse[uint8]'),
+ ], axis=1)
+
assert_frame_equal(result, expected)
def test_dataframe_dummies_subset(self, df, sparse):
@@ -216,6 +264,9 @@ def test_dataframe_dummies_subset(self, df, sparse):
'from_A_a': [1, 0, 1],
'from_A_b': [0, 1, 0]}, dtype=np.uint8)
expected[['C']] = df[['C']]
+ if sparse:
+ cols = ['from_A_a', 'from_A_b']
+ expected[cols] = expected[cols].apply(lambda x: pd.SparseSeries(x))
assert_frame_equal(result, expected)
def test_dataframe_dummies_prefix_sep(self, df, sparse):
@@ -228,6 +279,10 @@ def test_dataframe_dummies_prefix_sep(self, df, sparse):
dtype=np.uint8)
expected[['C']] = df[['C']]
expected = expected[['C', 'A..a', 'A..b', 'B..b', 'B..c']]
+ if sparse:
+ cols = ['A..a', 'A..b', 'B..b', 'B..c']
+ expected[cols] = expected[cols].apply(lambda x: pd.SparseSeries(x))
+
assert_frame_equal(result, expected)
result = get_dummies(df, prefix_sep=['..', '__'], sparse=sparse)
@@ -261,23 +316,34 @@ def test_dataframe_dummies_prefix_dict(self, sparse):
columns = ['from_A_a', 'from_A_b', 'from_B_b', 'from_B_c']
expected[columns] = expected[columns].astype(np.uint8)
+ if sparse:
+ expected[columns] = expected[columns].apply(
+ lambda x: pd.SparseSeries(x)
+ )
+
assert_frame_equal(result, expected)
def test_dataframe_dummies_with_na(self, df, sparse, dtype):
df.loc[3, :] = [np.nan, np.nan, np.nan]
result = get_dummies(df, dummy_na=True,
sparse=sparse, dtype=dtype).sort_index(axis=1)
+
+ if sparse:
+ arr = SparseArray
+ typ = SparseDtype(dtype, 0)
+ else:
+ arr = np.array
+ typ = dtype
+
expected = DataFrame({'C': [1, 2, 3, np.nan],
- 'A_a': [1, 0, 1, 0],
- 'A_b': [0, 1, 0, 0],
- 'A_nan': [0, 0, 0, 1],
- 'B_b': [1, 1, 0, 0],
- 'B_c': [0, 0, 1, 0],
- 'B_nan': [0, 0, 0, 1]}).sort_index(axis=1)
+ 'A_a': arr([1, 0, 1, 0], dtype=typ),
+ 'A_b': arr([0, 1, 0, 0], dtype=typ),
+ 'A_nan': arr([0, 0, 0, 1], dtype=typ),
+ 'B_b': arr([1, 1, 0, 0], dtype=typ),
+ 'B_c': arr([0, 0, 1, 0], dtype=typ),
+ 'B_nan': arr([0, 0, 0, 1], dtype=typ)
+ }).sort_index(axis=1)
- e_dtype = self.effective_dtype(dtype)
- columns = ['A_a', 'A_b', 'A_nan', 'B_b', 'B_c', 'B_nan']
- expected[columns] = expected[columns].astype(e_dtype)
assert_frame_equal(result, expected)
result = get_dummies(df, dummy_na=False, sparse=sparse, dtype=dtype)
@@ -287,18 +353,22 @@ def test_dataframe_dummies_with_na(self, df, sparse, dtype):
def test_dataframe_dummies_with_categorical(self, df, sparse, dtype):
df['cat'] = pd.Categorical(['x', 'y', 'y'])
result = get_dummies(df, sparse=sparse, dtype=dtype).sort_index(axis=1)
+ if sparse:
+ arr = SparseArray
+ typ = SparseDtype(dtype, 0)
+ else:
+ arr = np.array
+ typ = dtype
+
expected = DataFrame({'C': [1, 2, 3],
- 'A_a': [1, 0, 1],
- 'A_b': [0, 1, 0],
- 'B_b': [1, 1, 0],
- 'B_c': [0, 0, 1],
- 'cat_x': [1, 0, 0],
- 'cat_y': [0, 1, 1]}).sort_index(axis=1)
+ 'A_a': arr([1, 0, 1], dtype=typ),
+ 'A_b': arr([0, 1, 0], dtype=typ),
+ 'B_b': arr([1, 1, 0], dtype=typ),
+ 'B_c': arr([0, 0, 1], dtype=typ),
+ 'cat_x': arr([1, 0, 0], dtype=typ),
+ 'cat_y': arr([0, 1, 1], dtype=typ)
+ }).sort_index(axis=1)
- columns = ['A_a', 'A_b', 'B_b', 'B_c', 'cat_x', 'cat_y']
- effective_dtype = self.effective_dtype(dtype)
- expected[columns] = expected[columns].astype(effective_dtype)
- expected.sort_index(axis=1)
assert_frame_equal(result, expected)
@pytest.mark.parametrize('get_dummies_kwargs,expected', [
@@ -331,6 +401,8 @@ def test_basic_drop_first(self, sparse):
dtype=np.uint8)
result = get_dummies(s_list, drop_first=True, sparse=sparse)
+ if sparse:
+ expected = expected.to_sparse(fill_value=0, kind='integer')
assert_frame_equal(result, expected)
result = get_dummies(s_series, drop_first=True, sparse=sparse)
@@ -363,6 +435,9 @@ def test_basic_drop_first_NA(self, sparse):
s_NA = ['a', 'b', np.nan]
res = get_dummies(s_NA, drop_first=True, sparse=sparse)
exp = DataFrame({'b': [0, 1, 0]}, dtype=np.uint8)
+ if sparse:
+ exp = exp.to_sparse(fill_value=0, kind='integer')
+
assert_frame_equal(res, exp)
res_na = get_dummies(s_NA, dummy_na=True, drop_first=True,
@@ -371,6 +446,8 @@ def test_basic_drop_first_NA(self, sparse):
{'b': [0, 1, 0],
nan: [0, 0, 1]},
dtype=np.uint8).reindex(['b', nan], axis=1)
+ if sparse:
+ exp_na = exp_na.to_sparse(fill_value=0, kind='integer')
assert_frame_equal(res_na, exp_na)
res_just_na = get_dummies([nan], dummy_na=True, drop_first=True,
@@ -384,6 +461,8 @@ def test_dataframe_dummies_drop_first(self, df, sparse):
expected = DataFrame({'A_b': [0, 1, 0],
'B_c': [0, 0, 1]},
dtype=np.uint8)
+ if sparse:
+ expected = expected.to_sparse(fill_value=0, kind='integer')
assert_frame_equal(result, expected)
def test_dataframe_dummies_drop_first_with_categorical(
@@ -397,6 +476,9 @@ def test_dataframe_dummies_drop_first_with_categorical(
cols = ['A_b', 'B_c', 'cat_y']
expected[cols] = expected[cols].astype(np.uint8)
expected = expected[['C', 'A_b', 'B_c', 'cat_y']]
+ if sparse:
+ for col in cols:
+ expected[col] = pd.SparseSeries(expected[col])
assert_frame_equal(result, expected)
def test_dataframe_dummies_drop_first_with_na(self, df, sparse):
@@ -411,6 +493,10 @@ def test_dataframe_dummies_drop_first_with_na(self, df, sparse):
cols = ['A_b', 'A_nan', 'B_c', 'B_nan']
expected[cols] = expected[cols].astype(np.uint8)
expected = expected.sort_index(axis=1)
+ if sparse:
+ for col in cols:
+ expected[col] = pd.SparseSeries(expected[col])
+
assert_frame_equal(result, expected)
result = get_dummies(df, dummy_na=False, drop_first=True,
diff --git a/pandas/tests/series/test_combine_concat.py b/pandas/tests/series/test_combine_concat.py
index 8b021ab81ff81..f27600d830a93 100644
--- a/pandas/tests/series/test_combine_concat.py
+++ b/pandas/tests/series/test_combine_concat.py
@@ -214,20 +214,23 @@ def test_concat_empty_series_dtypes(self):
Series(dtype='object')]).dtype == 'object'
# sparse
+ # TODO: move?
result = pd.concat([Series(dtype='float64').to_sparse(), Series(
dtype='float64').to_sparse()])
- assert result.dtype == np.float64
+ assert result.dtype == 'Sparse[float64]'
assert result.ftype == 'float64:sparse'
result = pd.concat([Series(dtype='float64').to_sparse(), Series(
dtype='float64')])
- assert result.dtype == np.float64
+ # TODO: release-note: concat sparse dtype
+ assert result.dtype == pd.core.sparse.dtype.SparseDtype(np.float64)
assert result.ftype == 'float64:sparse'
result = pd.concat([Series(dtype='float64').to_sparse(), Series(
dtype='object')])
- assert result.dtype == np.object_
- assert result.ftype == 'object:dense'
+ # TODO: release-note: concat sparse dtype
+ assert result.dtype == pd.core.sparse.dtype.SparseDtype('object')
+ assert result.ftype == 'object:sparse'
def test_combine_first_dt64(self):
from pandas.core.tools.datetimes import to_datetime
diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py
index b3f105ee5cb67..dcc4845f274ba 100644
--- a/pandas/tests/series/test_missing.py
+++ b/pandas/tests/series/test_missing.py
@@ -20,6 +20,7 @@
from pandas.util.testing import assert_series_equal, assert_frame_equal
import pandas.util.testing as tm
import pandas.util._test_decorators as td
+from pandas.errors import PerformanceWarning
try:
import scipy
@@ -773,16 +774,21 @@ def test_sparse_series_fillna_limit(self):
s = Series(np.random.randn(10), index=index)
ss = s[:2].reindex(index).to_sparse()
- result = ss.fillna(method='pad', limit=5)
- expected = ss.fillna(method='pad', limit=5)
+ # TODO: what is this test doing? why are result an expected
+ # the same call to fillna?
+ with tm.assert_produces_warning(PerformanceWarning):
+ # TODO: release-note fillna performance warning
+ result = ss.fillna(method='pad', limit=5)
+ expected = ss.fillna(method='pad', limit=5)
expected = expected.to_dense()
expected[-3:] = np.nan
expected = expected.to_sparse()
assert_series_equal(result, expected)
ss = s[-2:].reindex(index).to_sparse()
- result = ss.fillna(method='backfill', limit=5)
- expected = ss.fillna(method='backfill')
+ with tm.assert_produces_warning(PerformanceWarning):
+ result = ss.fillna(method='backfill', limit=5)
+ expected = ss.fillna(method='backfill')
expected = expected.to_dense()
expected[:3] = np.nan
expected = expected.to_sparse()
@@ -794,14 +800,16 @@ def test_sparse_series_pad_backfill_limit(self):
s = s.to_sparse()
result = s[:2].reindex(index, method='pad', limit=5)
- expected = s[:2].reindex(index).fillna(method='pad')
+ with tm.assert_produces_warning(PerformanceWarning):
+ expected = s[:2].reindex(index).fillna(method='pad')
expected = expected.to_dense()
expected[-3:] = np.nan
expected = expected.to_sparse()
assert_series_equal(result, expected)
result = s[-2:].reindex(index, method='backfill', limit=5)
- expected = s[-2:].reindex(index).fillna(method='backfill')
+ with tm.assert_produces_warning(PerformanceWarning):
+ expected = s[-2:].reindex(index).fillna(method='backfill')
expected = expected.to_dense()
expected[:3] = np.nan
expected = expected.to_sparse()
diff --git a/pandas/tests/series/test_quantile.py b/pandas/tests/series/test_quantile.py
index df8799cf5c900..fc6226c92d8fe 100644
--- a/pandas/tests/series/test_quantile.py
+++ b/pandas/tests/series/test_quantile.py
@@ -152,6 +152,16 @@ def test_quantile_nat(self):
res = Series([pd.NaT, pd.NaT]).quantile([0.5])
tm.assert_series_equal(res, pd.Series([pd.NaT], index=[0.5]))
+ @pytest.mark.parametrize('values, dtype', [
+ ([0, 0, 0, 1, 2, 3], 'Sparse[int]'),
+ ([0., None, 1., 2.], 'Sparse[float]'),
+ ])
+ def test_quantile_sparse(self, values, dtype):
+ ser = pd.Series(values, dtype=dtype)
+ result = ser.quantile([0.5])
+ expected = pd.Series(np.asarray(ser)).quantile([0.5])
+ tm.assert_series_equal(result, expected)
+
def test_quantile_empty(self):
# floats
diff --git a/pandas/tests/series/test_subclass.py b/pandas/tests/series/test_subclass.py
index 60afaa3b821e1..d539dfa456740 100644
--- a/pandas/tests/series/test_subclass.py
+++ b/pandas/tests/series/test_subclass.py
@@ -1,8 +1,8 @@
# coding=utf-8
# pylint: disable-msg=E1101,W0612
-
import numpy as np
import pandas as pd
+from pandas.core.sparse.dtype import SparseDtype
import pandas.util.testing as tm
@@ -47,29 +47,29 @@ def test_subclass_sparse_slice(self):
s = tm.SubclassedSparseSeries([1, 2, 3, 4, 5])
exp = tm.SubclassedSparseSeries([2, 3, 4], index=[1, 2, 3])
tm.assert_sp_series_equal(s.loc[1:3], exp)
- assert s.loc[1:3].dtype == np.int64
+ assert s.loc[1:3].dtype == SparseDtype(np.int64)
exp = tm.SubclassedSparseSeries([2, 3], index=[1, 2])
tm.assert_sp_series_equal(s.iloc[1:3], exp)
- assert s.iloc[1:3].dtype == np.int64
+ assert s.iloc[1:3].dtype == SparseDtype(np.int64)
exp = tm.SubclassedSparseSeries([2, 3], index=[1, 2])
tm.assert_sp_series_equal(s[1:3], exp)
- assert s[1:3].dtype == np.int64
+ assert s[1:3].dtype == SparseDtype(np.int64)
# float64
s = tm.SubclassedSparseSeries([1., 2., 3., 4., 5.])
exp = tm.SubclassedSparseSeries([2., 3., 4.], index=[1, 2, 3])
tm.assert_sp_series_equal(s.loc[1:3], exp)
- assert s.loc[1:3].dtype == np.float64
+ assert s.loc[1:3].dtype == SparseDtype(np.float64)
exp = tm.SubclassedSparseSeries([2., 3.], index=[1, 2])
tm.assert_sp_series_equal(s.iloc[1:3], exp)
- assert s.iloc[1:3].dtype == np.float64
+ assert s.iloc[1:3].dtype == SparseDtype(np.float64)
exp = tm.SubclassedSparseSeries([2., 3.], index=[1, 2])
tm.assert_sp_series_equal(s[1:3], exp)
- assert s[1:3].dtype == np.float64
+ assert s[1:3].dtype == SparseDtype(np.float64)
def test_subclass_sparse_addition(self):
s1 = tm.SubclassedSparseSeries([1, 3, 5])
@@ -83,25 +83,25 @@ def test_subclass_sparse_addition(self):
tm.assert_sp_series_equal(s1 + s2, exp)
def test_subclass_sparse_to_frame(self):
- s = tm.SubclassedSparseSeries([1, 2], index=list('abcd'), name='xxx')
+ s = tm.SubclassedSparseSeries([1, 2], index=list('ab'), name='xxx')
res = s.to_frame()
exp_arr = pd.SparseArray([1, 2], dtype=np.int64, kind='block',
fill_value=0)
exp = tm.SubclassedSparseDataFrame({'xxx': exp_arr},
- index=list('abcd'),
+ index=list('ab'),
default_fill_value=0)
tm.assert_sp_frame_equal(res, exp)
# create from int dict
res = tm.SubclassedSparseDataFrame({'xxx': [1, 2]},
- index=list('abcd'),
+ index=list('ab'),
default_fill_value=0)
tm.assert_sp_frame_equal(res, exp)
- s = tm.SubclassedSparseSeries([1.1, 2.1], index=list('abcd'),
+ s = tm.SubclassedSparseSeries([1.1, 2.1], index=list('ab'),
name='xxx')
res = s.to_frame()
exp = tm.SubclassedSparseDataFrame({'xxx': [1.1, 2.1]},
- index=list('abcd'))
+ index=list('ab'))
tm.assert_sp_frame_equal(res, exp)
diff --git a/pandas/tests/sparse/frame/test_apply.py b/pandas/tests/sparse/frame/test_apply.py
index 07e4b1bf7c913..2d7a537f0fb3b 100644
--- a/pandas/tests/sparse/frame/test_apply.py
+++ b/pandas/tests/sparse/frame/test_apply.py
@@ -1,6 +1,7 @@
import pytest
import numpy as np
from pandas import SparseDataFrame, DataFrame, Series, bdate_range
+from pandas.core.sparse.api import SparseDtype
from pandas.core import nanops
from pandas.util import testing as tm
@@ -51,7 +52,7 @@ def test_apply(frame):
applied = frame.apply(np.sum)
tm.assert_series_equal(applied,
- frame.to_dense().apply(nanops.nansum))
+ frame.to_dense().apply(nanops.nansum).to_sparse())
def test_apply_fill(fill_frame):
@@ -71,7 +72,7 @@ def test_apply_nonuq():
exp = orig.apply(lambda s: s[0], axis=1)
# dtype must be kept
- assert res.dtype == np.int64
+ assert res.dtype == SparseDtype(np.int64)
# ToDo: apply must return subclassed dtype
assert isinstance(res, Series)
diff --git a/pandas/tests/sparse/frame/test_frame.py b/pandas/tests/sparse/frame/test_frame.py
index 5e5a341ca76d6..03143488c3874 100644
--- a/pandas/tests/sparse/frame/test_frame.py
+++ b/pandas/tests/sparse/frame/test_frame.py
@@ -8,6 +8,7 @@
import pandas as pd
from pandas import Series, DataFrame, bdate_range, Panel
+from pandas.errors import PerformanceWarning
from pandas.core.indexes.datetimes import DatetimeIndex
from pandas.tseries.offsets import BDay
from pandas.util import testing as tm
@@ -16,7 +17,9 @@
from pandas.core.sparse import frame as spf
from pandas._libs.sparse import BlockIndex, IntIndex
-from pandas.core.sparse.api import SparseSeries, SparseDataFrame, SparseArray
+from pandas.core.sparse.api import (
+ SparseSeries, SparseDataFrame, SparseArray, SparseDtype
+)
from pandas.tests.frame.test_api import SharedWithSparse
@@ -27,6 +30,23 @@ class TestSparseDataFrame(SharedWithSparse):
_assert_frame_equal = staticmethod(tm.assert_sp_frame_equal)
_assert_series_equal = staticmethod(tm.assert_sp_series_equal)
+ def test_iterrows(self, float_frame, float_string_frame):
+ # Same as parent, but we don't ensure the sparse kind is the same.
+ for k, v in float_frame.iterrows():
+ exp = float_frame.loc[k]
+ tm.assert_sp_series_equal(v, exp, check_kind=False)
+
+ for k, v in float_string_frame.iterrows():
+ exp = float_string_frame.loc[k]
+ tm.assert_sp_series_equal(v, exp, check_kind=False)
+
+ def test_itertuples(self, float_frame):
+ for i, tup in enumerate(float_frame.itertuples()):
+ s = self.klass._constructor_sliced(tup[1:])
+ s.name = tup[0]
+ expected = float_frame.iloc[i, :].reset_index(drop=True)
+ tm.assert_sp_series_equal(s, expected, check_kind=False)
+
def test_fill_value_when_combine_const(self):
# GH12723
dat = np.array([0, 1, np.nan, 3, 4, 5], dtype='float')
@@ -66,8 +86,11 @@ def test_constructor(self, float_frame, float_frame_int_kind,
# constructed zframe from matrix above
assert float_frame_fill0['A'].fill_value == 0
- tm.assert_numpy_array_equal(pd.SparseArray([1., 2., 3., 4., 5., 6.]),
- float_frame_fill0['A'].values)
+ # XXX: changed asarray
+ expected = pd.SparseArray([0, 0, 0, 0, 1., 2., 3., 4., 5., 6.],
+ fill_value=0, kind='block')
+ tm.assert_sp_array_equal(expected,
+ float_frame_fill0['A'].values)
tm.assert_numpy_array_equal(np.array([0., 0., 0., 0., 1., 2.,
3., 4., 5., 6.]),
float_frame_fill0['A'].to_dense().values)
@@ -203,23 +226,23 @@ class Unknown(object):
def test_constructor_preserve_attr(self):
# GH 13866
arr = pd.SparseArray([1, 0, 3, 0], dtype=np.int64, fill_value=0)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64)
assert arr.fill_value == 0
df = pd.SparseDataFrame({'x': arr})
- assert df['x'].dtype == np.int64
+ assert df['x'].dtype == SparseDtype(np.int64)
assert df['x'].fill_value == 0
s = pd.SparseSeries(arr, name='x')
- assert s.dtype == np.int64
+ assert s.dtype == SparseDtype(np.int64)
assert s.fill_value == 0
df = pd.SparseDataFrame(s)
- assert df['x'].dtype == np.int64
+ assert df['x'].dtype == SparseDtype(np.int64)
assert df['x'].fill_value == 0
df = pd.SparseDataFrame({'x': s})
- assert df['x'].dtype == np.int64
+ assert df['x'].dtype == SparseDtype(np.int64)
assert df['x'].fill_value == 0
def test_constructor_nan_dataframe(self):
@@ -255,7 +278,7 @@ def test_dtypes(self):
sdf = df.to_sparse()
result = sdf.get_dtype_counts()
- expected = Series({'float64': 4})
+ expected = Series({'Sparse[float64, nan]': 4})
tm.assert_series_equal(result, expected)
def test_shape(self, float_frame, float_frame_int_kind,
@@ -547,6 +570,20 @@ def _check_frame(frame, orig):
_check_frame(float_frame_fill0, float_frame_fill0_dense)
_check_frame(float_frame_fill2, float_frame_fill2_dense)
+ @pytest.mark.parametrize('values', [
+ [True, False],
+ [0, 1],
+ [1, None],
+ ['a', 'b'],
+ [pd.Timestamp('2017'), pd.NaT],
+ [pd.Timedelta('10s'), pd.NaT],
+ ])
+ def test_setitem_more(self, values):
+ df = pd.DataFrame({"A": values})
+ df['A'] = pd.SparseArray(values)
+ expected = pd.DataFrame({'A': pd.SparseArray(values)})
+ tm.assert_frame_equal(df, expected)
+
def test_setitem_corner(self, float_frame):
float_frame['a'] = float_frame['B']
tm.assert_sp_series_equal(float_frame['a'], float_frame['B'],
@@ -599,6 +636,11 @@ def test_set_index(self, float_frame):
pytest.raises(Exception, setattr, float_frame, 'index',
float_frame.index[:-1])
+ def test_ctor_reindex(self):
+ idx = pd.Index([0, 1, 2, 3])
+ with tm.assert_raises_regex(ValueError, ''):
+ pd.SparseDataFrame({"A": [1, 2]}, index=idx)
+
def test_append(self, float_frame):
a = float_frame[:5]
b = float_frame[5:]
@@ -631,43 +673,43 @@ def test_append(self, float_frame):
with tm.assert_produces_warning(None):
appended = a.append(b, sort=True)
- tm.assert_sp_frame_equal(appended, expected[['A', 'B', 'C', 'D']])
+ tm.assert_sp_frame_equal(appended, expected[['A', 'B', 'C', 'D']],
+ consolidate_block_indices=True,
+ check_kind=False)
def test_astype(self):
sparse = pd.SparseDataFrame({'A': SparseArray([1, 2, 3, 4],
dtype=np.int64),
'B': SparseArray([4, 5, 6, 7],
dtype=np.int64)})
- assert sparse['A'].dtype == np.int64
- assert sparse['B'].dtype == np.int64
+ assert sparse['A'].dtype == SparseDtype(np.int64)
+ assert sparse['B'].dtype == SparseDtype(np.int64)
+ # retain fill_value
res = sparse.astype(np.float64)
exp = pd.SparseDataFrame({'A': SparseArray([1., 2., 3., 4.],
- fill_value=0.),
+ fill_value=0,
+ kind='integer'),
'B': SparseArray([4., 5., 6., 7.],
- fill_value=0.)},
+ fill_value=0,
+ kind='integer')},
default_fill_value=np.nan)
tm.assert_sp_frame_equal(res, exp)
- assert res['A'].dtype == np.float64
- assert res['B'].dtype == np.float64
+ assert res['A'].dtype == SparseDtype(np.float64, 0)
+ assert res['B'].dtype == SparseDtype(np.float64, 0)
- sparse = pd.SparseDataFrame({'A': SparseArray([0, 2, 0, 4],
- dtype=np.int64),
- 'B': SparseArray([0, 5, 0, 7],
- dtype=np.int64)},
- default_fill_value=0)
- assert sparse['A'].dtype == np.int64
- assert sparse['B'].dtype == np.int64
-
- res = sparse.astype(np.float64)
- exp = pd.SparseDataFrame({'A': SparseArray([0., 2., 0., 4.],
- fill_value=0.),
- 'B': SparseArray([0., 5., 0., 7.],
- fill_value=0.)},
- default_fill_value=0.)
+ # update fill_value
+ res = sparse.astype(SparseDtype(np.float64, np.nan))
+ exp = pd.SparseDataFrame({'A': SparseArray([1., 2., 3., 4.],
+ fill_value=np.nan,
+ kind='integer'),
+ 'B': SparseArray([4., 5., 6., 7.],
+ fill_value=np.nan,
+ kind='integer')},
+ default_fill_value=np.nan)
tm.assert_sp_frame_equal(res, exp)
- assert res['A'].dtype == np.float64
- assert res['B'].dtype == np.float64
+ assert res['A'].dtype == SparseDtype(np.float64, np.nan)
+ assert res['B'].dtype == SparseDtype(np.float64, np.nan)
def test_astype_bool(self):
sparse = pd.SparseDataFrame({'A': SparseArray([0, 2, 0, 4],
@@ -677,20 +719,22 @@ def test_astype_bool(self):
fill_value=0,
dtype=np.int64)},
default_fill_value=0)
- assert sparse['A'].dtype == np.int64
- assert sparse['B'].dtype == np.int64
+ assert sparse['A'].dtype == SparseDtype(np.int64)
+ assert sparse['B'].dtype == SparseDtype(np.int64)
- res = sparse.astype(bool)
+ res = sparse.astype(SparseDtype(bool, False))
exp = pd.SparseDataFrame({'A': SparseArray([False, True, False, True],
dtype=np.bool,
- fill_value=False),
+ fill_value=False,
+ kind='integer'),
'B': SparseArray([False, True, False, True],
dtype=np.bool,
- fill_value=False)},
+ fill_value=False,
+ kind='integer')},
default_fill_value=False)
tm.assert_sp_frame_equal(res, exp)
- assert res['A'].dtype == np.bool
- assert res['B'].dtype == np.bool
+ assert res['A'].dtype == SparseDtype(np.bool)
+ assert res['B'].dtype == SparseDtype(np.bool)
def test_fillna(self, float_frame_fill0, float_frame_fill0_dense):
df = float_frame_fill0.reindex(lrange(5))
@@ -737,7 +781,8 @@ def test_sparse_frame_pad_backfill_limit(self):
result = sdf[:2].reindex(index, method='pad', limit=5)
- expected = sdf[:2].reindex(index).fillna(method='pad')
+ with tm.assert_produces_warning(PerformanceWarning):
+ expected = sdf[:2].reindex(index).fillna(method='pad')
expected = expected.to_dense()
expected.values[-3:] = np.nan
expected = expected.to_sparse()
@@ -745,7 +790,8 @@ def test_sparse_frame_pad_backfill_limit(self):
result = sdf[-2:].reindex(index, method='backfill', limit=5)
- expected = sdf[-2:].reindex(index).fillna(method='backfill')
+ with tm.assert_produces_warning(PerformanceWarning):
+ expected = sdf[-2:].reindex(index).fillna(method='backfill')
expected = expected.to_dense()
expected.values[:3] = np.nan
expected = expected.to_sparse()
@@ -757,18 +803,22 @@ def test_sparse_frame_fillna_limit(self):
sdf = df.to_sparse()
result = sdf[:2].reindex(index)
- result = result.fillna(method='pad', limit=5)
+ with tm.assert_produces_warning(PerformanceWarning):
+ result = result.fillna(method='pad', limit=5)
- expected = sdf[:2].reindex(index).fillna(method='pad')
+ with tm.assert_produces_warning(PerformanceWarning):
+ expected = sdf[:2].reindex(index).fillna(method='pad')
expected = expected.to_dense()
expected.values[-3:] = np.nan
expected = expected.to_sparse()
tm.assert_frame_equal(result, expected)
result = sdf[-2:].reindex(index)
- result = result.fillna(method='backfill', limit=5)
+ with tm.assert_produces_warning(PerformanceWarning):
+ result = result.fillna(method='backfill', limit=5)
- expected = sdf[-2:].reindex(index).fillna(method='backfill')
+ with tm.assert_produces_warning(PerformanceWarning):
+ expected = sdf[-2:].reindex(index).fillna(method='backfill')
expected = expected.to_dense()
expected.values[:3] = np.nan
expected = expected.to_sparse()
@@ -792,7 +842,8 @@ def test_rename(self, float_frame):
def test_corr(self, float_frame):
res = float_frame.corr()
- tm.assert_frame_equal(res, float_frame.to_dense().corr())
+ # XXX: this stays sparse
+ tm.assert_frame_equal(res, float_frame.to_dense().corr().to_sparse())
def test_describe(self, float_frame):
float_frame['foo'] = np.nan
@@ -962,7 +1013,8 @@ def test_to_dense(self, float_frame, float_frame_int_kind,
float_frame_fill2, float_frame_fill2_dense):
def _check(frame, orig):
dense_dm = frame.to_dense()
- tm.assert_frame_equal(frame, dense_dm)
+ # Sparse[float] != float
+ tm.assert_frame_equal(frame, dense_dm, check_dtype=False)
tm.assert_frame_equal(dense_dm, orig, check_dtype=False)
_check(float_frame, float_frame_dense)
@@ -1021,11 +1073,11 @@ def _check(frame, orig):
shifted = frame.shift(1)
exp = orig.shift(1)
- tm.assert_frame_equal(shifted, exp)
+ tm.assert_frame_equal(shifted.to_dense(), exp)
shifted = frame.shift(-2)
exp = orig.shift(-2)
- tm.assert_frame_equal(shifted, exp)
+ tm.assert_frame_equal(shifted.to_dense(), exp)
shifted = frame.shift(2, freq='B')
exp = orig.shift(2, freq='B')
@@ -1048,13 +1100,13 @@ def test_count(self, float_frame):
dense_result = float_frame.to_dense().count()
result = float_frame.count()
- tm.assert_series_equal(result, dense_result)
+ tm.assert_series_equal(result.to_dense(), dense_result)
result = float_frame.count(axis=None)
- tm.assert_series_equal(result, dense_result)
+ tm.assert_series_equal(result.to_dense(), dense_result)
result = float_frame.count(axis=0)
- tm.assert_series_equal(result, dense_result)
+ tm.assert_series_equal(result.to_dense(), dense_result)
result = float_frame.count(axis=1)
dense_result = float_frame.to_dense().count(axis=1)
@@ -1074,12 +1126,23 @@ def test_combine_first(self, float_frame):
df = float_frame
result = df[::2].combine_first(df)
- result2 = df[::2].combine_first(df.to_dense())
expected = df[::2].to_dense().combine_first(df.to_dense())
expected = expected.to_sparse(fill_value=df.default_fill_value)
- tm.assert_sp_frame_equal(result, result2)
+ tm.assert_sp_frame_equal(result, expected)
+
+ @pytest.mark.xfail(reason="No longer supported.", strict=True)
+ def test_combine_first_with_dense(self):
+ # We could support this if we allow
+ # pd.core.dtypes.cast.find_common_type to special case SparseDtype
+ # but I don't think that's worth it.
+ df = self.frame
+
+ result = df[::2].combine_first(df.to_dense())
+ expected = df[::2].to_dense().combine_first(df.to_dense())
+ expected = expected.to_sparse(fill_value=df.default_fill_value)
+
tm.assert_sp_frame_equal(result, expected)
def test_combine_add(self, float_frame):
@@ -1121,8 +1184,8 @@ def test_as_blocks(self):
with tm.assert_produces_warning(FutureWarning,
check_stacklevel=False):
df_blocks = df.blocks
- assert list(df_blocks.keys()) == ['float64']
- tm.assert_frame_equal(df_blocks['float64'], df)
+ assert list(df_blocks.keys()) == ['Sparse[float64, nan]']
+ tm.assert_frame_equal(df_blocks['Sparse[float64, nan]'], df)
@pytest.mark.xfail(reason='nan column names in _init_dict problematic '
'(GH#16894)',
diff --git a/pandas/tests/sparse/frame/test_to_from_scipy.py b/pandas/tests/sparse/frame/test_to_from_scipy.py
index a7f64bbe9a49f..1a10ff83d3097 100644
--- a/pandas/tests/sparse/frame/test_to_from_scipy.py
+++ b/pandas/tests/sparse/frame/test_to_from_scipy.py
@@ -2,13 +2,11 @@
import numpy as np
from pandas.util import testing as tm
from pandas import SparseDataFrame, SparseSeries
+from pandas.core.sparse.api import SparseDtype
from distutils.version import LooseVersion
from pandas.core.dtypes.common import (
is_bool_dtype,
- is_float_dtype,
- is_object_dtype,
- is_float)
-
+)
scipy = pytest.importorskip('scipy')
ignore_matrix_warning = pytest.mark.filterwarnings(
@@ -57,13 +55,10 @@ def test_from_to_scipy(spmatrix, index, columns, fill_value, dtype):
assert dict(sdf.to_coo().todok()) == dict(spm.todok())
# Ensure dtype is preserved if possible
- was_upcast = ((fill_value is None or is_float(fill_value)) and
- not is_object_dtype(dtype) and
- not is_float_dtype(dtype))
- res_dtype = (bool if is_bool_dtype(dtype) else
- float if was_upcast else
- dtype)
- tm.assert_contains_all(sdf.dtypes, {np.dtype(res_dtype)})
+ # XXX: verify this
+ res_dtype = bool if is_bool_dtype(dtype) else dtype
+ tm.assert_contains_all(sdf.dtypes.apply(lambda dtype: dtype.subtype),
+ {np.dtype(res_dtype)})
assert sdf.to_coo().dtype == res_dtype
# However, adding a str column results in an upcast to object
@@ -108,7 +103,7 @@ def test_from_to_scipy_object(spmatrix, fill_value):
fill_value if fill_value is not None else np.nan)
# Assert frame is as expected
- sdf_obj = sdf.astype(object)
+ sdf_obj = sdf.astype(SparseDtype(object, fill_value))
tm.assert_sp_frame_equal(sdf_obj, expected)
tm.assert_frame_equal(sdf_obj.to_dense(), expected.to_dense())
@@ -117,7 +112,8 @@ def test_from_to_scipy_object(spmatrix, fill_value):
# Ensure dtype is preserved if possible
res_dtype = object
- tm.assert_contains_all(sdf.dtypes, {np.dtype(res_dtype)})
+ tm.assert_contains_all(sdf.dtypes.apply(lambda dtype: dtype.subtype),
+ {np.dtype(res_dtype)})
assert sdf.to_coo().dtype == res_dtype
diff --git a/pandas/tests/sparse/series/test_series.py b/pandas/tests/sparse/series/test_series.py
index 5b50606bf37bd..a1ec8314841e3 100644
--- a/pandas/tests/sparse/series/test_series.py
+++ b/pandas/tests/sparse/series/test_series.py
@@ -11,12 +11,14 @@
from pandas import (Series, DataFrame, bdate_range,
isna, compat, _np_version_under1p12)
+from pandas.errors import PerformanceWarning
from pandas.tseries.offsets import BDay
import pandas.util.testing as tm
import pandas.util._test_decorators as td
from pandas.compat import range, PY36
from pandas.core.reshape.util import cartesian_product
+from pandas.core.sparse.api import SparseDtype
import pandas.core.sparse.frame as spf
from pandas._libs.sparse import BlockIndex, IntIndex
@@ -126,23 +128,23 @@ def test_constructor_dict_order(self):
def test_constructor_dtype(self):
arr = SparseSeries([np.nan, 1, 2, np.nan])
- assert arr.dtype == np.float64
+ assert arr.dtype == SparseDtype(np.float64)
assert np.isnan(arr.fill_value)
arr = SparseSeries([np.nan, 1, 2, np.nan], fill_value=0)
- assert arr.dtype == np.float64
+ assert arr.dtype == SparseDtype(np.float64, 0)
assert arr.fill_value == 0
arr = SparseSeries([0, 1, 2, 4], dtype=np.int64, fill_value=np.nan)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64, np.nan)
assert np.isnan(arr.fill_value)
arr = SparseSeries([0, 1, 2, 4], dtype=np.int64)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64, 0)
assert arr.fill_value == 0
arr = SparseSeries([0, 1, 2, 4], fill_value=0, dtype=np.int64)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64, 0)
assert arr.fill_value == 0
def test_iteration_and_str(self):
@@ -171,11 +173,11 @@ def test_construct_DataFrame_with_sp_series(self):
def test_constructor_preserve_attr(self):
arr = pd.SparseArray([1, 0, 3, 0], dtype=np.int64, fill_value=0)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64)
assert arr.fill_value == 0
s = pd.SparseSeries(arr, name='x')
- assert s.dtype == np.int64
+ assert s.dtype == SparseDtype(np.int64)
assert s.fill_value == 0
def test_series_density(self):
@@ -353,7 +355,7 @@ def test_copy_astype(self):
cop = self.bseries.astype(np.float64)
assert cop is not self.bseries
assert cop.sp_index is self.bseries.sp_index
- assert cop.dtype == np.float64
+ assert cop.dtype == SparseDtype(np.float64)
cop2 = self.iseries.copy()
@@ -390,8 +392,12 @@ def test_shape(self):
assert self.ziseries2.shape == (15, )
def test_astype(self):
- with pytest.raises(ValueError):
- self.bseries.astype(np.int64)
+ result = self.bseries.astype(SparseDtype(np.int64, 0))
+ expected = (self.bseries.to_dense()
+ .fillna(0)
+ .astype(np.int64)
+ .to_sparse(fill_value=0))
+ tm.assert_sp_series_equal(result, expected)
def test_astype_all(self):
orig = pd.Series(np.array([1, 2, 3]))
@@ -400,8 +406,9 @@ def test_astype_all(self):
types = [np.float64, np.float32, np.int64,
np.int32, np.int16, np.int8]
for typ in types:
- res = s.astype(typ)
- assert res.dtype == typ
+ dtype = SparseDtype(typ)
+ res = s.astype(dtype)
+ assert res.dtype == dtype
tm.assert_series_equal(res.to_dense(), orig.astype(typ))
def test_kind(self):
@@ -537,9 +544,10 @@ def _compare(idx):
[0, len(self.bseries) + 1])
# Corner case
+ # XXX: changed test. Why wsa this considered a corner case?
sp = SparseSeries(np.ones(10) * nan)
exp = pd.Series(np.repeat(nan, 5))
- tm.assert_series_equal(sp.take([0, 1, 2, 3, 4]), exp)
+ tm.assert_series_equal(sp.take([0, 1, 2, 3, 4]), exp.to_sparse())
with tm.assert_produces_warning(FutureWarning):
sp.take([1, 5], convert=True)
@@ -637,6 +645,32 @@ def _check_inplace_op(iop, op):
_check_inplace_op(getattr(operator, "i%s" % op),
getattr(operator, op))
+ @pytest.mark.parametrize("values, op, fill_value", [
+ ([True, False, False, True], operator.invert, True),
+ ([True, False, False, True], operator.invert, False),
+ ([0, 1, 2, 3], operator.pos, 0),
+ ([0, 1, 2, 3], operator.neg, 0),
+ ([0, np.nan, 2, 3], operator.pos, np.nan),
+ ([0, np.nan, 2, 3], operator.neg, np.nan),
+ ])
+ def test_unary_operators(self, values, op, fill_value):
+ # https://github.com/pandas-dev/pandas/issues/22835
+ values = np.asarray(values)
+ if op is operator.invert:
+ new_fill_value = not fill_value
+ else:
+ new_fill_value = op(fill_value)
+ s = SparseSeries(values,
+ fill_value=fill_value,
+ index=['a', 'b', 'c', 'd'],
+ name='name')
+ result = op(s)
+ expected = SparseSeries(op(values),
+ fill_value=new_fill_value,
+ index=['a', 'b', 'c', 'd'],
+ name='name')
+ tm.assert_sp_series_equal(result, expected)
+
def test_abs(self):
s = SparseSeries([1, 2, -3], name='x')
expected = SparseSeries([1, 2, 3], name='x')
@@ -875,7 +909,7 @@ def test_shift(self):
series = SparseSeries([nan, 1., 2., 3., nan, nan], index=np.arange(6))
shifted = series.shift(0)
- assert shifted is not series
+ # assert shifted is not series
tm.assert_sp_series_equal(shifted, series)
f = lambda s: s.shift(1)
@@ -897,10 +931,14 @@ def test_shift_nan(self):
orig = pd.Series([np.nan, 2, np.nan, 4, 0, np.nan, 0])
sparse = orig.to_sparse()
- tm.assert_sp_series_equal(sparse.shift(0), orig.shift(0).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(1), orig.shift(1).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(2), orig.shift(2).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(3), orig.shift(3).to_sparse())
+ tm.assert_sp_series_equal(sparse.shift(0), orig.shift(0).to_sparse(),
+ check_kind=False)
+ tm.assert_sp_series_equal(sparse.shift(1), orig.shift(1).to_sparse(),
+ check_kind=False)
+ tm.assert_sp_series_equal(sparse.shift(2), orig.shift(2).to_sparse(),
+ check_kind=False)
+ tm.assert_sp_series_equal(sparse.shift(3), orig.shift(3).to_sparse(),
+ check_kind=False)
tm.assert_sp_series_equal(sparse.shift(-1), orig.shift(-1).to_sparse())
tm.assert_sp_series_equal(sparse.shift(-2), orig.shift(-2).to_sparse())
@@ -908,23 +946,32 @@ def test_shift_nan(self):
tm.assert_sp_series_equal(sparse.shift(-4), orig.shift(-4).to_sparse())
sparse = orig.to_sparse(fill_value=0)
- tm.assert_sp_series_equal(sparse.shift(0),
- orig.shift(0).to_sparse(fill_value=0))
+ tm.assert_sp_series_equal(
+ sparse.shift(0),
+ orig.shift(0).to_sparse(fill_value=sparse.fill_value)
+ )
tm.assert_sp_series_equal(sparse.shift(1),
- orig.shift(1).to_sparse(fill_value=0))
+ orig.shift(1).to_sparse(fill_value=0),
+ check_kind=False)
tm.assert_sp_series_equal(sparse.shift(2),
- orig.shift(2).to_sparse(fill_value=0))
+ orig.shift(2).to_sparse(fill_value=0),
+ check_kind=False)
tm.assert_sp_series_equal(sparse.shift(3),
- orig.shift(3).to_sparse(fill_value=0))
+ orig.shift(3).to_sparse(fill_value=0),
+ check_kind=False)
tm.assert_sp_series_equal(sparse.shift(-1),
- orig.shift(-1).to_sparse(fill_value=0))
+ orig.shift(-1).to_sparse(fill_value=0),
+ check_kind=False)
tm.assert_sp_series_equal(sparse.shift(-2),
- orig.shift(-2).to_sparse(fill_value=0))
+ orig.shift(-2).to_sparse(fill_value=0),
+ check_kind=False)
tm.assert_sp_series_equal(sparse.shift(-3),
- orig.shift(-3).to_sparse(fill_value=0))
+ orig.shift(-3).to_sparse(fill_value=0),
+ check_kind=False)
tm.assert_sp_series_equal(sparse.shift(-4),
- orig.shift(-4).to_sparse(fill_value=0))
+ orig.shift(-4).to_sparse(fill_value=0),
+ check_kind=False)
def test_shift_dtype(self):
# GH 12908
@@ -937,39 +984,47 @@ def test_shift_dtype(self):
tm.assert_sp_series_equal(sparse.shift(0),
orig.shift(0).to_sparse(fill_value=np.nan))
# shift(1) or more span changes dtype to float64
- tm.assert_sp_series_equal(sparse.shift(1), orig.shift(1).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(2), orig.shift(2).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(3), orig.shift(3).to_sparse())
+ # XXX: SparseSeries doesn't need to shift dtype here.
+ # Do we want to astype in shift, for backwards compat?
+ # If not, document it.
+ tm.assert_sp_series_equal(sparse.shift(1).astype('f8'),
+ orig.shift(1).to_sparse(kind='integer'))
+ tm.assert_sp_series_equal(sparse.shift(2).astype('f8'),
+ orig.shift(2).to_sparse(kind='integer'))
+ tm.assert_sp_series_equal(sparse.shift(3).astype('f8'),
+ orig.shift(3).to_sparse(kind='integer'))
+
+ tm.assert_sp_series_equal(sparse.shift(-1).astype('f8'),
+ orig.shift(-1).to_sparse(),
+ check_kind=False)
+ tm.assert_sp_series_equal(sparse.shift(-2).astype('f8'),
+ orig.shift(-2).to_sparse(),
+ check_kind=False)
+ tm.assert_sp_series_equal(sparse.shift(-3).astype('f8'),
+ orig.shift(-3).to_sparse(),
+ check_kind=False)
+ tm.assert_sp_series_equal(sparse.shift(-4).astype('f8'),
+ orig.shift(-4).to_sparse(),
+ check_kind=False)
+
+ @pytest.mark.parametrize("fill_value", [
+ 0,
+ 1,
+ np.nan
+ ])
+ @pytest.mark.parametrize("periods", [0, 1, 2, 3, -1, -2, -3, -4])
+ def test_shift_dtype_fill_value(self, fill_value, periods):
+ # GH 12908
+ orig = pd.Series([1, 0, 0, 4], dtype=np.dtype('int64'))
- tm.assert_sp_series_equal(sparse.shift(-1), orig.shift(-1).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(-2), orig.shift(-2).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(-3), orig.shift(-3).to_sparse())
- tm.assert_sp_series_equal(sparse.shift(-4), orig.shift(-4).to_sparse())
+ sparse = orig.to_sparse(fill_value=fill_value)
- def test_shift_dtype_fill_value(self):
- # GH 12908
- orig = pd.Series([1, 0, 0, 4], dtype=np.int64)
-
- for v in [0, 1, np.nan]:
- sparse = orig.to_sparse(fill_value=v)
-
- tm.assert_sp_series_equal(sparse.shift(0),
- orig.shift(0).to_sparse(fill_value=v))
- tm.assert_sp_series_equal(sparse.shift(1),
- orig.shift(1).to_sparse(fill_value=v))
- tm.assert_sp_series_equal(sparse.shift(2),
- orig.shift(2).to_sparse(fill_value=v))
- tm.assert_sp_series_equal(sparse.shift(3),
- orig.shift(3).to_sparse(fill_value=v))
-
- tm.assert_sp_series_equal(sparse.shift(-1),
- orig.shift(-1).to_sparse(fill_value=v))
- tm.assert_sp_series_equal(sparse.shift(-2),
- orig.shift(-2).to_sparse(fill_value=v))
- tm.assert_sp_series_equal(sparse.shift(-3),
- orig.shift(-3).to_sparse(fill_value=v))
- tm.assert_sp_series_equal(sparse.shift(-4),
- orig.shift(-4).to_sparse(fill_value=v))
+ result = sparse.shift(periods)
+ expected = orig.shift(periods).to_sparse(fill_value=fill_value)
+
+ tm.assert_sp_series_equal(result, expected,
+ check_kind=False,
+ consolidate_block_indices=True)
def test_combine_first(self):
s = self.bseries
@@ -986,7 +1041,7 @@ def test_combine_first(self):
@pytest.mark.parametrize('deep', [True, False])
@pytest.mark.parametrize('fill_value', [0, 1, np.nan, None])
def test_memory_usage_deep(self, deep, fill_value):
- values = [0, 1, np.nan, None]
+ values = [1.0] + [fill_value] * 20
sparse_series = SparseSeries(values, fill_value=fill_value)
dense_series = Series(values)
sparse_usage = sparse_series.memory_usage(deep=deep)
@@ -1182,7 +1237,8 @@ def test_concat(self):
res = pd.concat([sparse1, sparse2])
exp = pd.concat([pd.Series(val1), pd.Series(val2)])
exp = pd.SparseSeries(exp, fill_value=0, kind=kind)
- tm.assert_sp_series_equal(res, exp)
+ tm.assert_sp_series_equal(res, exp,
+ consolidate_block_indices=True)
def test_concat_axis1(self):
val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
@@ -1205,12 +1261,14 @@ def test_concat_different_fill(self):
sparse1 = pd.SparseSeries(val1, name='x', kind=kind)
sparse2 = pd.SparseSeries(val2, name='y', kind=kind, fill_value=0)
- res = pd.concat([sparse1, sparse2])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse1, sparse2])
exp = pd.concat([pd.Series(val1), pd.Series(val2)])
exp = pd.SparseSeries(exp, kind=kind)
tm.assert_sp_series_equal(res, exp)
- res = pd.concat([sparse2, sparse1])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse2, sparse1])
exp = pd.concat([pd.Series(val2), pd.Series(val1)])
exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
tm.assert_sp_series_equal(res, exp)
@@ -1235,12 +1293,14 @@ def test_concat_different_kind(self):
sparse1 = pd.SparseSeries(val1, name='x', kind='integer')
sparse2 = pd.SparseSeries(val2, name='y', kind='block', fill_value=0)
- res = pd.concat([sparse1, sparse2])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse1, sparse2])
exp = pd.concat([pd.Series(val1), pd.Series(val2)])
exp = pd.SparseSeries(exp, kind='integer')
tm.assert_sp_series_equal(res, exp)
- res = pd.concat([sparse2, sparse1])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse2, sparse1])
exp = pd.concat([pd.Series(val2), pd.Series(val1)])
exp = pd.SparseSeries(exp, kind='block', fill_value=0)
tm.assert_sp_series_equal(res, exp)
@@ -1261,21 +1321,21 @@ def test_concat_sparse_dense(self):
res = pd.concat([dense, sparse, dense])
exp = pd.concat([dense, pd.Series(val1), dense])
- exp = pd.SparseSeries(exp, kind=kind)
- tm.assert_sp_series_equal(res, exp)
+ exp = exp.astype("Sparse")
+ tm.assert_series_equal(res, exp)
sparse = pd.SparseSeries(val1, name='x', kind=kind, fill_value=0)
dense = pd.Series(val2, name='y')
res = pd.concat([sparse, dense])
exp = pd.concat([pd.Series(val1), dense])
- exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
- tm.assert_sp_series_equal(res, exp)
+ exp = exp.astype(SparseDtype(exp.dtype, 0))
+ tm.assert_series_equal(res, exp)
res = pd.concat([dense, sparse, dense])
exp = pd.concat([dense, pd.Series(val1), dense])
- exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
- tm.assert_sp_series_equal(res, exp)
+ exp = exp.astype(SparseDtype(exp.dtype, 0))
+ tm.assert_series_equal(res, exp)
def test_value_counts(self):
vals = [1, 2, nan, 0, nan, 1, 2, nan, nan, 1, 2, 0, 1, 1]
@@ -1390,7 +1450,7 @@ def test_cumsum(self):
tm.assert_sp_series_equal(result, expected)
result = self.zbseries.cumsum()
- expected = self.zbseries.to_dense().cumsum()
+ expected = self.zbseries.to_dense().cumsum().to_sparse()
tm.assert_series_equal(result, expected)
axis = 1 # Series is 1-D, so only axis = 0 is valid.
@@ -1404,7 +1464,7 @@ def test_numpy_cumsum(self):
tm.assert_sp_series_equal(result, expected)
result = np.cumsum(self.zbseries)
- expected = self.zbseries.to_dense().cumsum()
+ expected = self.zbseries.to_dense().cumsum().to_sparse()
tm.assert_series_equal(result, expected)
msg = "the 'dtype' parameter is not supported"
@@ -1459,3 +1519,23 @@ def test_constructor_dict_datetime64_index(datetime_type):
expected = SparseSeries(values, map(pd.Timestamp, dates))
tm.assert_sp_series_equal(result, expected)
+
+
+def test_to_sparse():
+ # https://github.com/pandas-dev/pandas/issues/22389
+ arr = pd.SparseArray([1, 2, None, 3])
+ result = pd.Series(arr).to_sparse()
+ assert len(result) == 4
+ tm.assert_sp_array_equal(result.values, arr, check_kind=False)
+
+
+def test_constructor_mismatched_raises():
+ msg = "Length of passed values is 2, index implies 3"
+ with tm.assert_raises_regex(ValueError, msg):
+ SparseSeries([1, 2], index=[1, 2, 3])
+
+
+def test_block_deprecated():
+ s = SparseSeries([1])
+ with tm.assert_produces_warning(FutureWarning):
+ s.block
diff --git a/pandas/tests/sparse/test_arithmetics.py b/pandas/tests/sparse/test_arithmetics.py
index f023cd0003910..388411f909bac 100644
--- a/pandas/tests/sparse/test_arithmetics.py
+++ b/pandas/tests/sparse/test_arithmetics.py
@@ -1,6 +1,10 @@
+import operator
+
import numpy as np
+import pytest
import pandas as pd
import pandas.util.testing as tm
+from pandas.core.sparse.api import SparseDtype
class TestSparseArrayArithmetics(object):
@@ -31,7 +35,8 @@ def _check_numeric_ops(self, a, b, a_dense, b_dense):
self._assert((b / a).to_dense(), b_dense * 1.0 / a_dense)
# ToDo: FIXME in GH 13843
- if not (self._base == pd.Series and a.dtype == 'int64'):
+ if not (self._base == pd.Series and
+ a.dtype.subtype == np.dtype('int64')):
self._assert((a // b).to_dense(), a_dense // b_dense)
self._assert((b // a).to_dense(), b_dense // a_dense)
@@ -56,7 +61,8 @@ def _check_numeric_ops(self, a, b, a_dense, b_dense):
self._assert((b_dense / a).to_dense(), b_dense * 1.0 / a_dense)
# ToDo: FIXME in GH 13843
- if not (self._base == pd.Series and a.dtype == 'int64'):
+ if not (self._base == pd.Series and
+ a.dtype.subtype == np.dtype('int64')):
self._assert((a // b_dense).to_dense(), a_dense // b_dense)
self._assert((b_dense // a).to_dense(), b_dense // a_dense)
@@ -68,7 +74,8 @@ def _check_numeric_ops(self, a, b, a_dense, b_dense):
def _check_bool_result(self, res):
assert isinstance(res, self._klass)
- assert res.dtype == np.bool
+ assert isinstance(res.dtype, SparseDtype)
+ assert res.dtype.subtype == np.bool
assert isinstance(res.fill_value, bool)
def _check_comparison_ops(self, a, b, a_dense, b_dense):
@@ -274,30 +281,30 @@ def test_int_array(self):
for kind in ['integer', 'block']:
a = self._klass(values, dtype=dtype, kind=kind)
- assert a.dtype == dtype
+ assert a.dtype == SparseDtype(dtype)
b = self._klass(rvalues, dtype=dtype, kind=kind)
- assert b.dtype == dtype
+ assert b.dtype == SparseDtype(dtype)
self._check_numeric_ops(a, b, values, rvalues)
self._check_numeric_ops(a, b * 0, values, rvalues * 0)
a = self._klass(values, fill_value=0, dtype=dtype, kind=kind)
- assert a.dtype == dtype
+ assert a.dtype == SparseDtype(dtype)
b = self._klass(rvalues, dtype=dtype, kind=kind)
- assert b.dtype == dtype
+ assert b.dtype == SparseDtype(dtype)
self._check_numeric_ops(a, b, values, rvalues)
a = self._klass(values, fill_value=0, dtype=dtype, kind=kind)
- assert a.dtype == dtype
+ assert a.dtype == SparseDtype(dtype)
b = self._klass(rvalues, fill_value=0, dtype=dtype, kind=kind)
- assert b.dtype == dtype
+ assert b.dtype == SparseDtype(dtype)
self._check_numeric_ops(a, b, values, rvalues)
a = self._klass(values, fill_value=1, dtype=dtype, kind=kind)
- assert a.dtype == dtype
+ assert a.dtype == SparseDtype(dtype, fill_value=1)
b = self._klass(rvalues, fill_value=2, dtype=dtype, kind=kind)
- assert b.dtype == dtype
+ assert b.dtype == SparseDtype(dtype, fill_value=2)
self._check_numeric_ops(a, b, values, rvalues)
def test_int_array_comparison(self):
@@ -364,24 +371,24 @@ def test_mixed_array_float_int(self):
for kind in ['integer', 'block']:
a = self._klass(values, kind=kind)
b = self._klass(rvalues, kind=kind)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype)
self._check_numeric_ops(a, b, values, rvalues)
self._check_numeric_ops(a, b * 0, values, rvalues * 0)
a = self._klass(values, kind=kind, fill_value=0)
b = self._klass(rvalues, kind=kind)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype)
self._check_numeric_ops(a, b, values, rvalues)
a = self._klass(values, kind=kind, fill_value=0)
b = self._klass(rvalues, kind=kind, fill_value=0)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype)
self._check_numeric_ops(a, b, values, rvalues)
a = self._klass(values, kind=kind, fill_value=1)
b = self._klass(rvalues, kind=kind, fill_value=2)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype, fill_value=2)
self._check_numeric_ops(a, b, values, rvalues)
def test_mixed_array_comparison(self):
@@ -394,24 +401,24 @@ def test_mixed_array_comparison(self):
for kind in ['integer', 'block']:
a = self._klass(values, kind=kind)
b = self._klass(rvalues, kind=kind)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype)
self._check_comparison_ops(a, b, values, rvalues)
self._check_comparison_ops(a, b * 0, values, rvalues * 0)
a = self._klass(values, kind=kind, fill_value=0)
b = self._klass(rvalues, kind=kind)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype)
self._check_comparison_ops(a, b, values, rvalues)
a = self._klass(values, kind=kind, fill_value=0)
b = self._klass(rvalues, kind=kind, fill_value=0)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype)
self._check_comparison_ops(a, b, values, rvalues)
a = self._klass(values, kind=kind, fill_value=1)
b = self._klass(rvalues, kind=kind, fill_value=2)
- assert b.dtype == rdtype
+ assert b.dtype == SparseDtype(rdtype, fill_value=2)
self._check_comparison_ops(a, b, values, rvalues)
@@ -449,3 +456,82 @@ def test_alignment(self):
sb = pd.SparseSeries(np.arange(4), index=[10, 11, 12, 13],
dtype=np.int64, fill_value=np.nan)
self._check_numeric_ops(sa, sb, da, db)
+
+
+@pytest.mark.parametrize("op", [
+ operator.eq,
+ operator.add,
+])
+def test_with_list(op):
+ arr = pd.SparseArray([0, 1], fill_value=0)
+ result = op(arr, [0, 1])
+ expected = op(arr, pd.SparseArray([0, 1]))
+ tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize('ufunc', [
+ np.abs, np.exp,
+])
+@pytest.mark.parametrize('arr', [
+ pd.SparseArray([0, 0, -1, 1]),
+ pd.SparseArray([None, None, -1, 1]),
+])
+def test_ufuncs(ufunc, arr):
+ result = ufunc(arr)
+ fill_value = ufunc(arr.fill_value)
+ expected = pd.SparseArray(ufunc(np.asarray(arr)), fill_value=fill_value)
+ tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("a, b", [
+ (pd.SparseArray([0, 0, 0]), np.array([0, 1, 2])),
+ (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+ (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+ (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+ (pd.SparseArray([0, 0, 0], fill_value=1), np.array([0, 1, 2])),
+])
+@pytest.mark.parametrize("ufunc", [
+ np.add,
+ np.greater,
+])
+def test_binary_ufuncs(ufunc, a, b):
+ # can't say anything about fill value here.
+ result = ufunc(a, b)
+ expected = ufunc(np.asarray(a), np.asarray(b))
+ assert isinstance(result, pd.SparseArray)
+ tm.assert_numpy_array_equal(np.asarray(result), expected)
+
+
+def test_ndarray_inplace():
+ sparray = pd.SparseArray([0, 2, 0, 0])
+ ndarray = np.array([0, 1, 2, 3])
+ ndarray += sparray
+ expected = np.array([0, 3, 2, 3])
+ tm.assert_numpy_array_equal(ndarray, expected)
+
+
+def test_sparray_inplace():
+ sparray = pd.SparseArray([0, 2, 0, 0])
+ ndarray = np.array([0, 1, 2, 3])
+ sparray += ndarray
+ expected = pd.SparseArray([0, 3, 2, 3], fill_value=0)
+ tm.assert_sp_array_equal(sparray, expected)
+
+
+@pytest.mark.parametrize("fill_value", [True, False])
+def test_invert(fill_value):
+ arr = np.array([True, False, False, True])
+ sparray = pd.SparseArray(arr, fill_value=fill_value)
+ result = ~sparray
+ expected = pd.SparseArray(~arr, fill_value=not fill_value)
+ tm.assert_sp_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("fill_value", [0, np.nan])
+@pytest.mark.parametrize("op", [operator.pos, operator.neg])
+def test_unary_op(op, fill_value):
+ arr = np.array([0, 1, np.nan, 2])
+ sparray = pd.SparseArray(arr, fill_value=fill_value)
+ result = op(sparray)
+ expected = pd.SparseArray(op(arr), fill_value=op(fill_value))
+ tm.assert_sp_array_equal(result, expected)
diff --git a/pandas/tests/sparse/test_array.py b/pandas/tests/sparse/test_array.py
index 2790464e2f811..0257d996228df 100644
--- a/pandas/tests/sparse/test_array.py
+++ b/pandas/tests/sparse/test_array.py
@@ -7,11 +7,13 @@
from numpy import nan
import numpy as np
+import pandas as pd
-from pandas.core.sparse.api import SparseArray, SparseSeries
+from pandas.core.sparse.api import SparseArray, SparseSeries, SparseDtype
from pandas._libs.sparse import IntIndex
from pandas.util.testing import assert_almost_equal
import pandas.util.testing as tm
+import pandas.util._test_decorators as td
@pytest.fixture(params=["integer", "block"])
@@ -28,72 +30,98 @@ def setup_method(self, method):
def test_constructor_dtype(self):
arr = SparseArray([np.nan, 1, 2, np.nan])
- assert arr.dtype == np.float64
+ assert arr.dtype == SparseDtype(np.float64, np.nan)
+ assert arr.dtype.subtype == np.float64
assert np.isnan(arr.fill_value)
arr = SparseArray([np.nan, 1, 2, np.nan], fill_value=0)
- assert arr.dtype == np.float64
+ assert arr.dtype == SparseDtype(np.float64, 0)
assert arr.fill_value == 0
arr = SparseArray([0, 1, 2, 4], dtype=np.float64)
- assert arr.dtype == np.float64
+ assert arr.dtype == SparseDtype(np.float64, np.nan)
assert np.isnan(arr.fill_value)
arr = SparseArray([0, 1, 2, 4], dtype=np.int64)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64, 0)
assert arr.fill_value == 0
arr = SparseArray([0, 1, 2, 4], fill_value=0, dtype=np.int64)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64, 0)
assert arr.fill_value == 0
arr = SparseArray([0, 1, 2, 4], dtype=None)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64, 0)
assert arr.fill_value == 0
arr = SparseArray([0, 1, 2, 4], fill_value=0, dtype=None)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64, 0)
assert arr.fill_value == 0
+ def test_constructor_dtype_str(self):
+ result = SparseArray([1, 2, 3], dtype='int')
+ expected = SparseArray([1, 2, 3], dtype=int)
+ tm.assert_sp_array_equal(result, expected)
+
+ def test_constructor_sparse_dtype(self):
+ result = SparseArray([1, 0, 0, 1], dtype=SparseDtype('int64', -1))
+ expected = SparseArray([1, 0, 0, 1], fill_value=-1, dtype=np.int64)
+ tm.assert_sp_array_equal(result, expected)
+ assert result.sp_values.dtype == np.dtype('int64')
+
+ def test_constructor_sparse_dtype_str(self):
+ result = SparseArray([1, 0, 0, 1], dtype='Sparse[int32]')
+ expected = SparseArray([1, 0, 0, 1], dtype=np.int32)
+ tm.assert_sp_array_equal(result, expected)
+ assert result.sp_values.dtype == np.dtype('int32')
+
def test_constructor_object_dtype(self):
# GH 11856
arr = SparseArray(['A', 'A', np.nan, 'B'], dtype=np.object)
- assert arr.dtype == np.object
+ assert arr.dtype == SparseDtype(np.object)
assert np.isnan(arr.fill_value)
arr = SparseArray(['A', 'A', np.nan, 'B'], dtype=np.object,
fill_value='A')
- assert arr.dtype == np.object
+ assert arr.dtype == SparseDtype(np.object, 'A')
assert arr.fill_value == 'A'
# GH 17574
data = [False, 0, 100.0, 0.0]
arr = SparseArray(data, dtype=np.object, fill_value=False)
- assert arr.dtype == np.object
+ assert arr.dtype == SparseDtype(np.object, False)
assert arr.fill_value is False
arr_expected = np.array(data, dtype=np.object)
it = (type(x) == type(y) and x == y for x, y in zip(arr, arr_expected))
assert np.fromiter(it, dtype=np.bool).all()
+ @pytest.mark.parametrize("dtype", [SparseDtype(int, 0), int])
+ def test_constructor_na_dtype(self, dtype):
+ with tm.assert_raises_regex(ValueError, "Cannot convert"):
+ SparseArray([0, 1, np.nan], dtype=dtype)
+
def test_constructor_spindex_dtype(self):
arr = SparseArray(data=[1, 2], sparse_index=IntIndex(4, [1, 2]))
- tm.assert_sp_array_equal(arr, SparseArray([np.nan, 1, 2, np.nan]))
- assert arr.dtype == np.float64
- assert np.isnan(arr.fill_value)
+ # XXX: Behavior change: specifying SparseIndex no longer changes the
+ # fill_value
+ expected = SparseArray([0, 1, 2, 0], kind='integer')
+ tm.assert_sp_array_equal(arr, expected)
+ assert arr.dtype == SparseDtype(np.int64)
+ assert arr.fill_value == 0
arr = SparseArray(data=[1, 2, 3],
sparse_index=IntIndex(4, [1, 2, 3]),
dtype=np.int64, fill_value=0)
exp = SparseArray([0, 1, 2, 3], dtype=np.int64, fill_value=0)
tm.assert_sp_array_equal(arr, exp)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64)
assert arr.fill_value == 0
arr = SparseArray(data=[1, 2], sparse_index=IntIndex(4, [1, 2]),
fill_value=0, dtype=np.int64)
exp = SparseArray([0, 1, 2, 0], fill_value=0, dtype=np.int64)
tm.assert_sp_array_equal(arr, exp)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64)
assert arr.fill_value == 0
arr = SparseArray(data=[1, 2, 3],
@@ -101,28 +129,53 @@ def test_constructor_spindex_dtype(self):
dtype=None, fill_value=0)
exp = SparseArray([0, 1, 2, 3], dtype=None)
tm.assert_sp_array_equal(arr, exp)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64)
assert arr.fill_value == 0
+ @pytest.mark.parametrize("sparse_index", [
+ None, IntIndex(1, [0]),
+ ])
+ def test_constructor_spindex_dtype_scalar(self, sparse_index):
# scalar input
+ arr = SparseArray(data=1, sparse_index=sparse_index, dtype=None)
+ exp = SparseArray([1], dtype=None)
+ tm.assert_sp_array_equal(arr, exp)
+ assert arr.dtype == SparseDtype(np.int64)
+ assert arr.fill_value == 0
+
arr = SparseArray(data=1, sparse_index=IntIndex(1, [0]), dtype=None)
exp = SparseArray([1], dtype=None)
tm.assert_sp_array_equal(arr, exp)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64)
assert arr.fill_value == 0
+ def test_constructor_spindex_dtype_scalar_broadcasts(self):
arr = SparseArray(data=[1, 2], sparse_index=IntIndex(4, [1, 2]),
fill_value=0, dtype=None)
exp = SparseArray([0, 1, 2, 0], fill_value=0, dtype=None)
tm.assert_sp_array_equal(arr, exp)
- assert arr.dtype == np.int64
+ assert arr.dtype == SparseDtype(np.int64)
assert arr.fill_value == 0
+ @pytest.mark.parametrize('data, fill_value', [
+ (np.array([1, 2]), 0),
+ (np.array([1.0, 2.0]), np.nan),
+ ([True, False], False),
+ ([pd.Timestamp('2017-01-01')], pd.NaT),
+ ])
+ def test_constructor_inferred_fill_value(self, data, fill_value):
+ result = SparseArray(data).fill_value
+
+ if pd.isna(fill_value):
+ assert pd.isna(result)
+ else:
+ assert result == fill_value
+
@pytest.mark.parametrize('scalar,dtype', [
- (False, bool),
- (0.0, 'float64'),
- (1, 'int64'),
- ('z', 'object')])
+ (False, SparseDtype(bool, False)),
+ (0.0, SparseDtype('float64', 0)),
+ (1, SparseDtype('int64', 1)),
+ ('z', SparseDtype('object', 'z'))])
def test_scalar_with_index_infer_dtype(self, scalar, dtype):
# GH 19163
arr = SparseArray(scalar, index=[1, 2, 3], fill_value=scalar)
@@ -175,13 +228,12 @@ def test_get_item(self):
tm.assert_raises_regex(IndexError, errmsg, lambda: self.arr[-11])
assert self.arr[-1] == self.arr[len(self.arr) - 1]
- def test_take(self):
- assert np.isnan(self.arr.take(0))
- assert np.isscalar(self.arr.take(2))
-
- assert self.arr.take(2) == np.take(self.arr_data, 2)
- assert self.arr.take(6) == np.take(self.arr_data, 6)
+ def test_take_scalar_raises(self):
+ msg = "'indices' must be an array, not a scalar '2'."
+ with tm.assert_raises_regex(ValueError, msg):
+ self.arr.take(2)
+ def test_take(self):
exp = SparseArray(np.take(self.arr_data, [2, 3]))
tm.assert_sp_array_equal(self.arr.take([2, 3]), exp)
@@ -207,21 +259,7 @@ def test_take_negative(self):
def test_bad_take(self):
tm.assert_raises_regex(
- IndexError, "bounds", lambda: self.arr.take(11))
- pytest.raises(IndexError, lambda: self.arr.take(-11))
-
- def test_take_invalid_kwargs(self):
- msg = r"take\(\) got an unexpected keyword argument 'foo'"
- tm.assert_raises_regex(TypeError, msg, self.arr.take,
- [2, 3], foo=2)
-
- msg = "the 'out' parameter is not supported"
- tm.assert_raises_regex(ValueError, msg, self.arr.take,
- [2, 3], out=self.arr)
-
- msg = "the 'mode' parameter is not supported"
- tm.assert_raises_regex(ValueError, msg, self.arr.take,
- [2, 3], mode='clip')
+ IndexError, "bounds", lambda: self.arr.take([11]))
def test_take_filling(self):
# similar tests as GH 12631
@@ -230,8 +268,8 @@ def test_take_filling(self):
expected = SparseArray([np.nan, np.nan, 4])
tm.assert_sp_array_equal(result, expected)
- # fill_value
- result = sparse.take(np.array([1, 0, -1]), fill_value=True)
+ # XXX: test change: fill_value=True -> allow_fill=True
+ result = sparse.take(np.array([1, 0, -1]), allow_fill=True)
expected = SparseArray([np.nan, np.nan, np.nan])
tm.assert_sp_array_equal(result, expected)
@@ -241,19 +279,18 @@ def test_take_filling(self):
expected = SparseArray([np.nan, np.nan, 4])
tm.assert_sp_array_equal(result, expected)
- msg = ('When allow_fill=True and fill_value is not None, '
- 'all indices must be >= -1')
+ msg = ("Invalid value in 'indices'")
with tm.assert_raises_regex(ValueError, msg):
- sparse.take(np.array([1, 0, -2]), fill_value=True)
+ sparse.take(np.array([1, 0, -2]), allow_fill=True)
with tm.assert_raises_regex(ValueError, msg):
- sparse.take(np.array([1, 0, -5]), fill_value=True)
+ sparse.take(np.array([1, 0, -5]), allow_fill=True)
with pytest.raises(IndexError):
sparse.take(np.array([1, -6]))
with pytest.raises(IndexError):
sparse.take(np.array([1, 5]))
with pytest.raises(IndexError):
- sparse.take(np.array([1, 5]), fill_value=True)
+ sparse.take(np.array([1, 5]), allow_fill=True)
def test_take_filling_fill_value(self):
# same tests as GH 12631
@@ -263,8 +300,11 @@ def test_take_filling_fill_value(self):
tm.assert_sp_array_equal(result, expected)
# fill_value
- result = sparse.take(np.array([1, 0, -1]), fill_value=True)
- expected = SparseArray([0, np.nan, 0], fill_value=0)
+ result = sparse.take(np.array([1, 0, -1]), allow_fill=True)
+ # XXX: behavior change.
+ # the old way of filling self.fill_value doesn't follow EA rules.
+ # It's supposed to be self.dtype.na_value (nan in this case)
+ expected = SparseArray([0, np.nan, np.nan], fill_value=0)
tm.assert_sp_array_equal(result, expected)
# allow_fill=False
@@ -273,12 +313,11 @@ def test_take_filling_fill_value(self):
expected = SparseArray([0, np.nan, 4], fill_value=0)
tm.assert_sp_array_equal(result, expected)
- msg = ('When allow_fill=True and fill_value is not None, '
- 'all indices must be >= -1')
+ msg = ("Invalid value in 'indices'.")
with tm.assert_raises_regex(ValueError, msg):
- sparse.take(np.array([1, 0, -2]), fill_value=True)
+ sparse.take(np.array([1, 0, -2]), allow_fill=True)
with tm.assert_raises_regex(ValueError, msg):
- sparse.take(np.array([1, 0, -5]), fill_value=True)
+ sparse.take(np.array([1, 0, -5]), allow_fill=True)
with pytest.raises(IndexError):
sparse.take(np.array([1, -6]))
@@ -289,12 +328,13 @@ def test_take_filling_fill_value(self):
def test_take_filling_all_nan(self):
sparse = SparseArray([np.nan, np.nan, np.nan, np.nan, np.nan])
+ # XXX: did the default kind from take change?
result = sparse.take(np.array([1, 0, -1]))
- expected = SparseArray([np.nan, np.nan, np.nan])
+ expected = SparseArray([np.nan, np.nan, np.nan], kind='block')
tm.assert_sp_array_equal(result, expected)
result = sparse.take(np.array([1, 0, -1]), fill_value=True)
- expected = SparseArray([np.nan, np.nan, np.nan])
+ expected = SparseArray([np.nan, np.nan, np.nan], kind='block')
tm.assert_sp_array_equal(result, expected)
with pytest.raises(IndexError):
@@ -337,9 +377,10 @@ def test_constructor_bool(self):
data = np.array([False, False, True, True, False, False])
arr = SparseArray(data, fill_value=False, dtype=bool)
- assert arr.dtype == bool
+ assert arr.dtype == SparseDtype(bool)
tm.assert_numpy_array_equal(arr.sp_values, np.array([True, True]))
- tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
+ # Behavior change: np.asarray densifies.
+ # tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
tm.assert_numpy_array_equal(arr.sp_index.indices,
np.array([2, 3], np.int32))
@@ -349,15 +390,15 @@ def test_constructor_bool(self):
def test_constructor_bool_fill_value(self):
arr = SparseArray([True, False, True], dtype=None)
- assert arr.dtype == np.bool
+ assert arr.dtype == SparseDtype(np.bool)
assert not arr.fill_value
arr = SparseArray([True, False, True], dtype=np.bool)
- assert arr.dtype == np.bool
+ assert arr.dtype == SparseDtype(np.bool)
assert not arr.fill_value
arr = SparseArray([True, False, True], dtype=np.bool, fill_value=True)
- assert arr.dtype == np.bool
+ assert arr.dtype == SparseDtype(np.bool, True)
assert arr.fill_value
def test_constructor_float32(self):
@@ -365,10 +406,11 @@ def test_constructor_float32(self):
data = np.array([1., np.nan, 3], dtype=np.float32)
arr = SparseArray(data, dtype=np.float32)
- assert arr.dtype == np.float32
+ assert arr.dtype == SparseDtype(np.float32)
tm.assert_numpy_array_equal(arr.sp_values,
np.array([1, 3], dtype=np.float32))
- tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
+ # Behavior change: np.asarray densifies.
+ # tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
tm.assert_numpy_array_equal(arr.sp_index.indices,
np.array([0, 2], dtype=np.int32))
@@ -377,33 +419,54 @@ def test_constructor_float32(self):
tm.assert_numpy_array_equal(dense, data)
def test_astype(self):
- res = self.arr.astype('f8')
- res.sp_values[:3] = 27
- assert not (self.arr.sp_values[:3] == 27).any()
+ # float -> float
+ arr = SparseArray([None, None, 0, 2])
+ result = arr.astype("Sparse[float32]")
+ expected = SparseArray([None, None, 0, 2], dtype=np.dtype('float32'))
+ tm.assert_sp_array_equal(result, expected)
- msg = "unable to coerce current fill_value nan to int64 dtype"
- with tm.assert_raises_regex(ValueError, msg):
- self.arr.astype('i8')
+ dtype = SparseDtype("float64", fill_value=0)
+ result = arr.astype(dtype)
+ expected = SparseArray._simple_new(np.array([0., 2.],
+ dtype=dtype.subtype),
+ IntIndex(4, [2, 3]),
+ dtype)
+ tm.assert_sp_array_equal(result, expected)
- arr = SparseArray([0, np.nan, 0, 1])
- with tm.assert_raises_regex(ValueError, msg):
- arr.astype('i8')
+ dtype = SparseDtype("int64", 0)
+ result = arr.astype(dtype)
+ expected = SparseArray._simple_new(np.array([0, 2], dtype=np.int64),
+ IntIndex(4, [2, 3]),
+ dtype)
+ tm.assert_sp_array_equal(result, expected)
arr = SparseArray([0, np.nan, 0, 1], fill_value=0)
- msg = 'Cannot convert non-finite values \\(NA or inf\\) to integer'
- with tm.assert_raises_regex(ValueError, msg):
- arr.astype('i8')
+ with tm.assert_raises_regex(ValueError, 'NA'):
+ arr.astype('Sparse[i8]')
+
+ def test_astype_bool(self):
+ a = pd.SparseArray([1, 0, 0, 1], dtype=SparseDtype(int, 0))
+ result = a.astype(bool)
+ expected = SparseArray([True, 0, 0, True],
+ dtype=SparseDtype(bool, 0))
+ tm.assert_sp_array_equal(result, expected)
+
+ # update fill value
+ result = a.astype(SparseDtype(bool, False))
+ expected = SparseArray([True, False, False, True],
+ dtype=SparseDtype(bool, False))
+ tm.assert_sp_array_equal(result, expected)
def test_astype_all(self, any_real_dtype):
vals = np.array([1, 2, 3])
arr = SparseArray(vals, fill_value=1)
- typ = np.dtype(any_real_dtype).type
-
+ typ = np.dtype(any_real_dtype)
res = arr.astype(typ)
- assert res.dtype == typ
+ assert res.dtype == SparseDtype(typ, 1)
assert res.sp_values.dtype == typ
- tm.assert_numpy_array_equal(res.values, vals.astype(typ))
+ tm.assert_numpy_array_equal(np.asarray(res.values),
+ vals.astype(typ))
def test_set_fill_value(self):
arr = SparseArray([1., np.nan, 2.], fill_value=np.nan)
@@ -414,27 +477,33 @@ def test_set_fill_value(self):
arr.fill_value = 2
assert arr.fill_value == 2
+ # XXX: this seems fine? You can construct an integer
+ # sparsearray with NaN fill value, why not update one?
# coerces to int
- msg = "unable to set fill_value 3\\.1 to int64 dtype"
- with tm.assert_raises_regex(ValueError, msg):
- arr.fill_value = 3.1
-
- msg = "unable to set fill_value nan to int64 dtype"
- with tm.assert_raises_regex(ValueError, msg):
- arr.fill_value = np.nan
+ # msg = "unable to set fill_value 3\\.1 to int64 dtype"
+ # with tm.assert_raises_regex(ValueError, msg):
+ arr.fill_value = 3.1
+ assert arr.fill_value == 3.1
+
+ # msg = "unable to set fill_value nan to int64 dtype"
+ # with tm.assert_raises_regex(ValueError, msg):
+ arr.fill_value = np.nan
+ assert np.isnan(arr.fill_value)
arr = SparseArray([True, False, True], fill_value=False, dtype=np.bool)
arr.fill_value = True
assert arr.fill_value
# coerces to bool
- msg = "unable to set fill_value 0 to bool dtype"
- with tm.assert_raises_regex(ValueError, msg):
- arr.fill_value = 0
+ # msg = "unable to set fill_value 0 to bool dtype"
+ # with tm.assert_raises_regex(ValueError, msg):
+ arr.fill_value = 0
+ assert arr.fill_value == 0
- msg = "unable to set fill_value nan to bool dtype"
- with tm.assert_raises_regex(ValueError, msg):
- arr.fill_value = np.nan
+ # msg = "unable to set fill_value nan to bool dtype"
+ # with tm.assert_raises_regex(ValueError, msg):
+ arr.fill_value = np.nan
+ assert np.isnan(arr.fill_value)
@pytest.mark.parametrize("val", [[1, 2, 3], np.array([1, 2]), (1, 2, 3)])
def test_set_fill_invalid_non_scalar(self, val):
@@ -446,19 +515,12 @@ def test_set_fill_invalid_non_scalar(self, val):
def test_copy_shallow(self):
arr2 = self.arr.copy(deep=False)
-
- def _get_base(values):
- base = values.base
- while base.base is not None:
- base = base.base
- return base
-
- assert (_get_base(arr2) is _get_base(self.arr))
+ assert arr2.sp_values is self.arr.sp_values
+ assert arr2.sp_index is self.arr.sp_index
def test_values_asarray(self):
assert_almost_equal(self.arr.values, self.arr_data)
assert_almost_equal(self.arr.to_dense(), self.arr_data)
- assert_almost_equal(self.arr.sp_values, np.asarray(self.arr))
@pytest.mark.parametrize('data,shape,dtype', [
([0, 0, 0, 0, 0], (5,), None),
@@ -506,6 +568,12 @@ def _checkit(i):
_checkit(i)
_checkit(-i)
+ def test_getitem_arraylike_mask(self):
+ arr = SparseArray([0, 1, 2])
+ result = arr[[True, False, True]]
+ expected = SparseArray([0, 2])
+ tm.assert_sp_array_equal(result, expected)
+
def test_getslice(self):
result = self.arr[:-3]
exp = SparseArray(self.arr.values[:-3])
@@ -544,6 +612,11 @@ def test_getslice_tuple(self):
# check numpy compat
dense[4:, :]
+ def test_boolean_slice_empty(self):
+ arr = pd.SparseArray([0, 1, 2])
+ res = arr[[False, False, False]]
+ assert res.dtype == arr.dtype
+
@pytest.mark.parametrize("op", ["add", "sub", "mul",
"truediv", "floordiv", "pow"])
def test_binary_operators(self, op):
@@ -584,32 +657,16 @@ def _check_op(op, first, second):
try:
exp = op(first.values, 4)
exp_fv = op(first.fill_value, 4)
- assert_almost_equal(res4.fill_value, exp_fv)
- assert_almost_equal(res4.values, exp)
except ValueError:
pass
+ else:
+ assert_almost_equal(res4.fill_value, exp_fv)
+ assert_almost_equal(res4.values, exp)
with np.errstate(all="ignore"):
for first_arr, second_arr in [(arr1, arr2), (farr1, farr2)]:
_check_op(op, first_arr, second_arr)
- @pytest.mark.parametrize("op", ["iadd", "isub", "imul",
- "ifloordiv", "ipow",
- "itruediv"])
- def test_binary_operators_not_implemented(self, op):
- data1 = np.random.randn(20)
- data2 = np.random.randn(20)
-
- data1[::2] = np.nan
- data2[::3] = np.nan
-
- arr1 = SparseArray(data1)
- arr2 = SparseArray(data2)
-
- with np.errstate(all="ignore"):
- with pytest.raises(NotImplementedError):
- getattr(operator, op)(arr1, arr2)
-
def test_pickle(self):
def _check_roundtrip(obj):
unpickled = tm.round_trip_pickle(obj)
@@ -668,13 +725,13 @@ def test_fillna(self):
# int dtype shouldn't have missing. No changes.
s = SparseArray([0, 0, 0, 0])
- assert s.dtype == np.int64
+ assert s.dtype == SparseDtype(np.int64)
assert s.fill_value == 0
res = s.fillna(-1)
tm.assert_sp_array_equal(res, s)
s = SparseArray([0, 0, 0, 0], fill_value=0)
- assert s.dtype == np.int64
+ assert s.dtype == SparseDtype(np.int64)
assert s.fill_value == 0
res = s.fillna(-1)
exp = SparseArray([0, 0, 0, 0], fill_value=0)
@@ -683,7 +740,7 @@ def test_fillna(self):
# fill_value can be nan if there is no missing hole.
# only fill_value will be changed
s = SparseArray([0, 0, 0, 0], fill_value=np.nan)
- assert s.dtype == np.int64
+ assert s.dtype == SparseDtype(np.int64, fill_value=np.nan)
assert np.isnan(s.fill_value)
res = s.fillna(-1)
exp = SparseArray([0, 0, 0, 0], fill_value=-1)
@@ -730,6 +787,7 @@ def test_all(self, data, pos, neg):
([1, 2, 1], 1, 0),
([1.0, 2.0, 1.0], 1.0, 0.0)
])
+ @td.skip_if_np_lt_115 # prior didn't dispatch
def test_numpy_all(self, data, pos, neg):
# GH 17570
out = np.all(SparseArray(data))
@@ -745,9 +803,10 @@ def test_numpy_all(self, data, pos, neg):
out = np.all(SparseArray(data, fill_value=pos))
assert not out
- msg = "the 'out' parameter is not supported"
+ # raises with a different message on py2.
+ msg = "the \'out\' parameter is not supported"
tm.assert_raises_regex(ValueError, msg, np.all,
- SparseArray(data), out=out)
+ SparseArray(data), out=np.array([]))
@pytest.mark.parametrize('data,pos,neg', [
([False, True, False], True, False),
@@ -774,6 +833,7 @@ def test_any(self, data, pos, neg):
([0, 2, 0], 2, 0),
([0.0, 2.0, 0.0], 2.0, 0.0)
])
+ @td.skip_if_np_lt_115 # prior didn't dispatch
def test_numpy_any(self, data, pos, neg):
# GH 17570
out = np.any(SparseArray(data))
@@ -789,7 +849,7 @@ def test_numpy_any(self, data, pos, neg):
out = np.any(SparseArray(data, fill_value=pos))
assert not out
- msg = "the 'out' parameter is not supported"
+ msg = "the \'out\' parameter is not supported"
tm.assert_raises_regex(ValueError, msg, np.any,
SparseArray(data), out=out)
@@ -928,3 +988,104 @@ def test_ufunc_args(self):
sparse = SparseArray([1, -1, 0, -2], fill_value=0)
result = SparseArray([2, 0, 1, -1], fill_value=1)
tm.assert_sp_array_equal(np.add(sparse, 1), result)
+
+ def test_nbytes_integer(self):
+ arr = SparseArray([1, 0, 0, 0, 2], kind='integer')
+ result = arr.nbytes
+ # (2 * 8) + 2 * 4
+ assert result == 24
+
+ def test_nbytes_block(self):
+ arr = SparseArray([1, 2, 0, 0, 0], kind='block')
+ result = arr.nbytes
+ # (2 * 8) + 4 + 4
+ # sp_values, blocs, blenghts
+ assert result == 24
+
+ def test_asarray_datetime64(self):
+ s = pd.SparseArray(
+ pd.to_datetime(['2012', None, None, '2013'])
+ )
+ np.asarray(s)
+
+
+def test_setting_fill_value_fillna_still_works():
+ # This is why letting users update fill_value / dtype is bad
+ # astype has the same problem.
+ arr = SparseArray([1., np.nan, 1.0], fill_value=0.0)
+ arr.fill_value = np.nan
+ result = arr.isna()
+ # Can't do direct comparison, since the sp_index will be different
+ # So let's convert to ndarray and check there.
+ result = np.asarray(result)
+
+ expected = np.array([False, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+
+def test_setting_fill_value_updates():
+ arr = SparseArray([0.0, np.nan], fill_value=0)
+ arr.fill_value = np.nan
+ # use private constructor to get the index right
+ # otherwise both nans would be un-stored.
+ expected = SparseArray._simple_new(
+ sparse_array=np.array([np.nan]),
+ sparse_index=IntIndex(2, [1]),
+ dtype=SparseDtype(float, np.nan),
+ )
+ tm.assert_sp_array_equal(arr, expected)
+
+
+@pytest.mark.parametrize("arr, loc", [
+ ([None, 1, 2], 0),
+ ([0, None, 2], 1),
+ ([0, 1, None], 2),
+ ([0, 1, 1, None, None], 3),
+ ([1, 1, 1, 2], -1),
+ ([], -1),
+])
+def test_first_fill_value_loc(arr, loc):
+ result = SparseArray(arr)._first_fill_value_loc()
+ assert result == loc
+
+
+@pytest.mark.parametrize('arr', [
+ [1, 2, np.nan, np.nan],
+ [1, np.nan, 2, np.nan],
+ [1, 2, np.nan],
+])
+@pytest.mark.parametrize("fill_value", [
+ np.nan, 0, 1
+])
+def test_unique_na_fill(arr, fill_value):
+ a = pd.SparseArray(arr, fill_value=fill_value).unique()
+ b = pd.Series(arr).unique()
+ assert isinstance(a, SparseArray)
+ a = np.asarray(a)
+ tm.assert_numpy_array_equal(a, b)
+
+
+def test_map():
+ arr = SparseArray([0, 1, 2])
+ expected = SparseArray([10, 11, 12], fill_value=10)
+
+ # dict
+ result = arr.map({0: 10, 1: 11, 2: 12})
+ tm.assert_sp_array_equal(result, expected)
+
+ # series
+ result = arr.map(pd.Series({0: 10, 1: 11, 2: 12}))
+ tm.assert_sp_array_equal(result, expected)
+
+ # function
+ result = arr.map(pd.Series({0: 10, 1: 11, 2: 12}))
+ expected = SparseArray([10, 11, 12], fill_value=10)
+ tm.assert_sp_array_equal(result, expected)
+
+
+def test_map_missing():
+ arr = SparseArray([0, 1, 2])
+ expected = SparseArray([10, 11, None], fill_value=10)
+
+ result = arr.map({0: 10, 1: 11})
+ tm.assert_sp_array_equal(result, expected)
diff --git a/pandas/tests/sparse/test_combine_concat.py b/pandas/tests/sparse/test_combine_concat.py
index 9e392457edbc3..92483f1e7511e 100644
--- a/pandas/tests/sparse/test_combine_concat.py
+++ b/pandas/tests/sparse/test_combine_concat.py
@@ -4,31 +4,61 @@
import numpy as np
import pandas as pd
import pandas.util.testing as tm
+from pandas.errors import PerformanceWarning
import itertools
+class TestSparseArrayConcat(object):
+ @pytest.mark.parametrize('kind', ['integer', 'block'])
+ def test_basic(self, kind):
+ a = pd.SparseArray([1, 0, 0, 2], kind=kind)
+ b = pd.SparseArray([1, 0, 2, 2], kind=kind)
+
+ result = pd.SparseArray._concat_same_type([a, b])
+ # Can't make any assertions about the sparse index itself
+ # since we aren't don't merge sparse blocs across arrays
+ # in to_concat
+ expected = np.array([1, 2, 1, 2, 2], dtype='int64')
+ tm.assert_numpy_array_equal(result.sp_values, expected)
+ assert result.kind == kind
+
+ @pytest.mark.parametrize('kind', ['integer', 'block'])
+ def test_uses_first_kind(self, kind):
+ other = 'integer' if kind == 'block' else 'block'
+ a = pd.SparseArray([1, 0, 0, 2], kind=kind)
+ b = pd.SparseArray([1, 0, 2, 2], kind=other)
+
+ result = pd.SparseArray._concat_same_type([a, b])
+ expected = np.array([1, 2, 1, 2, 2], dtype='int64')
+ tm.assert_numpy_array_equal(result.sp_values, expected)
+ assert result.kind == kind
+
+
class TestSparseSeriesConcat(object):
- def test_concat(self):
+ @pytest.mark.parametrize('kind', [
+ 'integer',
+ 'block',
+ ])
+ def test_concat(self, kind):
val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
val2 = np.array([3, np.nan, 4, 0, 0])
- for kind in ['integer', 'block']:
- sparse1 = pd.SparseSeries(val1, name='x', kind=kind)
- sparse2 = pd.SparseSeries(val2, name='y', kind=kind)
+ sparse1 = pd.SparseSeries(val1, name='x', kind=kind)
+ sparse2 = pd.SparseSeries(val2, name='y', kind=kind)
- res = pd.concat([sparse1, sparse2])
- exp = pd.concat([pd.Series(val1), pd.Series(val2)])
- exp = pd.SparseSeries(exp, kind=kind)
- tm.assert_sp_series_equal(res, exp)
+ res = pd.concat([sparse1, sparse2])
+ exp = pd.concat([pd.Series(val1), pd.Series(val2)])
+ exp = pd.SparseSeries(exp, kind=kind)
+ tm.assert_sp_series_equal(res, exp, consolidate_block_indices=True)
- sparse1 = pd.SparseSeries(val1, fill_value=0, name='x', kind=kind)
- sparse2 = pd.SparseSeries(val2, fill_value=0, name='y', kind=kind)
+ sparse1 = pd.SparseSeries(val1, fill_value=0, name='x', kind=kind)
+ sparse2 = pd.SparseSeries(val2, fill_value=0, name='y', kind=kind)
- res = pd.concat([sparse1, sparse2])
- exp = pd.concat([pd.Series(val1), pd.Series(val2)])
- exp = pd.SparseSeries(exp, fill_value=0, kind=kind)
- tm.assert_sp_series_equal(res, exp)
+ res = pd.concat([sparse1, sparse2])
+ exp = pd.concat([pd.Series(val1), pd.Series(val2)])
+ exp = pd.SparseSeries(exp, fill_value=0, kind=kind)
+ tm.assert_sp_series_equal(res, exp, consolidate_block_indices=True)
def test_concat_axis1(self):
val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
@@ -41,7 +71,7 @@ def test_concat_axis1(self):
exp = pd.concat([pd.Series(val1, name='x'),
pd.Series(val2, name='y')], axis=1)
exp = pd.SparseDataFrame(exp)
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
def test_concat_different_fill(self):
val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
@@ -51,12 +81,16 @@ def test_concat_different_fill(self):
sparse1 = pd.SparseSeries(val1, name='x', kind=kind)
sparse2 = pd.SparseSeries(val2, name='y', kind=kind, fill_value=0)
- res = pd.concat([sparse1, sparse2])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse1, sparse2])
+
exp = pd.concat([pd.Series(val1), pd.Series(val2)])
exp = pd.SparseSeries(exp, kind=kind)
tm.assert_sp_series_equal(res, exp)
- res = pd.concat([sparse2, sparse1])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse2, sparse1])
+
exp = pd.concat([pd.Series(val2), pd.Series(val1)])
exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
tm.assert_sp_series_equal(res, exp)
@@ -79,49 +113,66 @@ def test_concat_different_kind(self):
val2 = np.array([3, np.nan, 4, 0, 0])
sparse1 = pd.SparseSeries(val1, name='x', kind='integer')
- sparse2 = pd.SparseSeries(val2, name='y', kind='block', fill_value=0)
+ sparse2 = pd.SparseSeries(val2, name='y', kind='block')
res = pd.concat([sparse1, sparse2])
exp = pd.concat([pd.Series(val1), pd.Series(val2)])
- exp = pd.SparseSeries(exp, kind='integer')
+ exp = pd.SparseSeries(exp, kind=sparse1.kind)
tm.assert_sp_series_equal(res, exp)
res = pd.concat([sparse2, sparse1])
exp = pd.concat([pd.Series(val2), pd.Series(val1)])
- exp = pd.SparseSeries(exp, kind='block', fill_value=0)
- tm.assert_sp_series_equal(res, exp)
-
- def test_concat_sparse_dense(self):
+ exp = pd.SparseSeries(exp, kind=sparse2.kind)
+ tm.assert_sp_series_equal(res, exp, consolidate_block_indices=True)
+
+ @pytest.mark.parametrize('kind', [
+ 'integer',
+ 'block',
+ ])
+ def test_concat_sparse_dense(self, kind):
# use first input's fill_value
val1 = np.array([1, 2, np.nan, np.nan, 0, np.nan])
val2 = np.array([3, np.nan, 4, 0, 0])
- for kind in ['integer', 'block']:
- sparse = pd.SparseSeries(val1, name='x', kind=kind)
- dense = pd.Series(val2, name='y')
-
- res = pd.concat([sparse, dense])
- exp = pd.concat([pd.Series(val1), dense])
- exp = pd.SparseSeries(exp, kind=kind)
- tm.assert_sp_series_equal(res, exp)
-
- res = pd.concat([dense, sparse, dense])
- exp = pd.concat([dense, pd.Series(val1), dense])
- exp = pd.SparseSeries(exp, kind=kind)
- tm.assert_sp_series_equal(res, exp)
-
- sparse = pd.SparseSeries(val1, name='x', kind=kind, fill_value=0)
- dense = pd.Series(val2, name='y')
+ sparse = pd.SparseSeries(val1, name='x', kind=kind)
+ dense = pd.Series(val2, name='y')
- res = pd.concat([sparse, dense])
- exp = pd.concat([pd.Series(val1), dense])
- exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
- tm.assert_sp_series_equal(res, exp)
+ res = pd.concat([sparse, dense])
+ exp = pd.SparseSeries(pd.concat([pd.Series(val1), dense]), kind=kind)
+ tm.assert_sp_series_equal(res, exp)
- res = pd.concat([dense, sparse, dense])
- exp = pd.concat([dense, pd.Series(val1), dense])
- exp = pd.SparseSeries(exp, kind=kind, fill_value=0)
- tm.assert_sp_series_equal(res, exp)
+ res = pd.concat([dense, sparse, dense])
+ exp = pd.concat([dense, pd.Series(val1), dense])
+ # XXX: changed from SparseSeries to Series[sparse]
+ exp = pd.Series(
+ pd.SparseArray(exp, kind=kind),
+ index=exp.index,
+ name=exp.name,
+ )
+ tm.assert_series_equal(res, exp)
+
+ sparse = pd.SparseSeries(val1, name='x', kind=kind, fill_value=0)
+ dense = pd.Series(val2, name='y')
+
+ res = pd.concat([sparse, dense])
+ # XXX: changed from SparseSeries to Series[sparse]
+ exp = pd.concat([pd.Series(val1), dense])
+ exp = pd.Series(
+ pd.SparseArray(exp, kind=kind, fill_value=0),
+ index=exp.index,
+ name=exp.name,
+ )
+ tm.assert_series_equal(res, exp)
+
+ res = pd.concat([dense, sparse, dense])
+ exp = pd.concat([dense, pd.Series(val1), dense])
+ # XXX: changed from SparseSeries to Series[sparse]
+ exp = pd.Series(
+ pd.SparseArray(exp, kind=kind, fill_value=0),
+ index=exp.index,
+ name=exp.name,
+ )
+ tm.assert_series_equal(res, exp)
class TestSparseDataFrameConcat(object):
@@ -150,19 +201,19 @@ def test_concat(self):
res = pd.concat([sparse, sparse])
exp = pd.concat([self.dense1, self.dense1]).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
res = pd.concat([sparse2, sparse2])
exp = pd.concat([self.dense2, self.dense2]).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
res = pd.concat([sparse, sparse2])
exp = pd.concat([self.dense1, self.dense2]).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
res = pd.concat([sparse2, sparse])
exp = pd.concat([self.dense2, self.dense1]).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
# fill_value = 0
sparse = self.dense1.to_sparse(fill_value=0)
@@ -171,36 +222,38 @@ def test_concat(self):
res = pd.concat([sparse, sparse])
exp = pd.concat([self.dense1, self.dense1]).to_sparse(fill_value=0)
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
res = pd.concat([sparse2, sparse2])
exp = pd.concat([self.dense2, self.dense2]).to_sparse(fill_value=0)
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
res = pd.concat([sparse, sparse2])
exp = pd.concat([self.dense1, self.dense2]).to_sparse(fill_value=0)
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
res = pd.concat([sparse2, sparse])
exp = pd.concat([self.dense2, self.dense1]).to_sparse(fill_value=0)
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
def test_concat_different_fill_value(self):
# 1st fill_value will be used
sparse = self.dense1.to_sparse()
sparse2 = self.dense2.to_sparse(fill_value=0)
- res = pd.concat([sparse, sparse2])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse, sparse2])
exp = pd.concat([self.dense1, self.dense2]).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
- res = pd.concat([sparse2, sparse])
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pd.concat([sparse2, sparse])
exp = pd.concat([self.dense2, self.dense1]).to_sparse(fill_value=0)
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True)
def test_concat_different_columns_sort_warns(self):
sparse = self.dense1.to_sparse()
@@ -212,7 +265,7 @@ def test_concat_different_columns_sort_warns(self):
exp = pd.concat([self.dense1, self.dense3])
exp = exp.to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, check_kind=False)
def test_concat_different_columns(self):
# fill_value = np.nan
@@ -221,14 +274,24 @@ def test_concat_different_columns(self):
res = pd.concat([sparse, sparse3], sort=True)
exp = pd.concat([self.dense1, self.dense3], sort=True).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, check_kind=False)
res = pd.concat([sparse3, sparse], sort=True)
exp = pd.concat([self.dense3, self.dense1], sort=True).to_sparse()
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
-
- # fill_value = 0
+ tm.assert_sp_frame_equal(res, exp, check_kind=False)
+
+ def test_concat_bug(self):
+ from pandas.core.sparse.api import SparseDtype
+ x = pd.SparseDataFrame({"A": pd.SparseArray([np.nan, np.nan],
+ fill_value=0)})
+ y = pd.SparseDataFrame({"B": []})
+ res = pd.concat([x, y], sort=False)[['A']]
+ exp = pd.DataFrame({"A": pd.SparseArray([np.nan, np.nan],
+ dtype=SparseDtype(float, 0))})
+ tm.assert_frame_equal(res, exp)
+
+ def test_concat_different_columns_buggy(self):
sparse = self.dense1.to_sparse(fill_value=0)
sparse3 = self.dense3.to_sparse(fill_value=0)
@@ -236,13 +299,16 @@ def test_concat_different_columns(self):
exp = (pd.concat([self.dense1, self.dense3], sort=True)
.to_sparse(fill_value=0))
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+
+ tm.assert_sp_frame_equal(res, exp, check_kind=False,
+ consolidate_block_indices=True)
res = pd.concat([sparse3, sparse], sort=True)
exp = (pd.concat([self.dense3, self.dense1], sort=True)
.to_sparse(fill_value=0))
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, check_kind=False,
+ consolidate_block_indices=True)
# different fill values
sparse = self.dense1.to_sparse()
@@ -266,11 +332,11 @@ def test_concat_series(self):
for col in ['A', 'D']:
res = pd.concat([sparse, sparse2[col]])
exp = pd.concat([self.dense1, self.dense2[col]]).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, check_kind=False)
res = pd.concat([sparse2[col], sparse])
exp = pd.concat([self.dense2[col], self.dense1]).to_sparse()
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, check_kind=False)
# fill_value = 0
sparse = self.dense1.to_sparse(fill_value=0)
@@ -281,13 +347,16 @@ def test_concat_series(self):
exp = pd.concat([self.dense1,
self.dense2[col]]).to_sparse(fill_value=0)
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, check_kind=False,
+ consolidate_block_indices=True)
res = pd.concat([sparse2[col], sparse])
exp = pd.concat([self.dense2[col],
self.dense1]).to_sparse(fill_value=0)
+ exp['C'] = res['C']
exp._default_fill_value = np.nan
- tm.assert_sp_frame_equal(res, exp)
+ tm.assert_sp_frame_equal(res, exp, consolidate_block_indices=True,
+ check_kind=False)
def test_concat_axis1(self):
# fill_value = np.nan
@@ -358,8 +427,11 @@ def test_concat_sparse_dense_rows(self, fill_value, sparse_idx, dense_idx):
itertools.product([None, 0, 1, np.nan],
[0, 1],
[1, 0]))
+ @pytest.mark.xfail(reason="The iloc fails and I can't make expected",
+ strict=False)
def test_concat_sparse_dense_cols(self, fill_value, sparse_idx, dense_idx):
# See GH16874, GH18914 and #18686 for why this should be a DataFrame
+ from pandas.core.dtypes.common import is_sparse
frames = [self.dense1, self.dense3]
@@ -371,6 +443,10 @@ def test_concat_sparse_dense_cols(self, fill_value, sparse_idx, dense_idx):
for _ in range(2):
res = pd.concat(sparse_frame, axis=1)
exp = pd.concat(dense_frame, axis=1)
+ cols = [i for (i, x) in enumerate(res.dtypes) if is_sparse(x)]
+
+ for col in cols:
+ exp.iloc[:, col] = exp.iloc[:, col].astype("Sparse")
for column in frames[dense_idx].columns:
if dense_idx == sparse_idx:
diff --git a/pandas/tests/sparse/test_dtype.py b/pandas/tests/sparse/test_dtype.py
new file mode 100644
index 0000000000000..0dcfc3ae79b0f
--- /dev/null
+++ b/pandas/tests/sparse/test_dtype.py
@@ -0,0 +1,142 @@
+import pytest
+import numpy as np
+
+import pandas as pd
+import pandas.util.testing as tm
+from pandas.core.sparse.api import SparseDtype
+
+
+@pytest.mark.parametrize("dtype, fill_value", [
+ ('int', 0),
+ ('float', np.nan),
+ ('bool', False),
+ ('object', np.nan),
+ ('datetime64[ns]', pd.NaT),
+ ('timedelta64[ns]', pd.NaT),
+])
+def test_inferred_dtype(dtype, fill_value):
+ sparse_dtype = SparseDtype(dtype)
+ result = sparse_dtype.fill_value
+ if pd.isna(fill_value):
+ assert pd.isna(result) and type(result) == type(fill_value)
+ else:
+ assert result == fill_value
+
+
+def test_from_sparse_dtype():
+ dtype = SparseDtype('float', 0)
+ result = SparseDtype(dtype)
+ assert result.fill_value == 0
+
+
+def test_from_sparse_dtype_fill_value():
+ dtype = SparseDtype('int', 1)
+ result = SparseDtype(dtype, fill_value=2)
+ expected = SparseDtype('int', 2)
+ assert result == expected
+
+
+@pytest.mark.parametrize('dtype, fill_value', [
+ ('int', None),
+ ('float', None),
+ ('bool', None),
+ ('object', None),
+ ('datetime64[ns]', None),
+ ('timedelta64[ns]', None),
+ ('int', np.nan),
+ ('float', 0),
+])
+def test_equal(dtype, fill_value):
+ a = SparseDtype(dtype, fill_value)
+ b = SparseDtype(dtype, fill_value)
+ assert a == b
+ assert b == a
+
+
+def test_nans_equal():
+ a = SparseDtype(float, float('nan'))
+ b = SparseDtype(float, np.nan)
+ assert a == b
+ assert b == a
+
+
+@pytest.mark.parametrize('a, b', [
+ (SparseDtype('float64'), SparseDtype('float32')),
+ (SparseDtype('float64'), SparseDtype('float64', 0)),
+ (SparseDtype('float64'), SparseDtype('datetime64[ns]', np.nan)),
+ (SparseDtype(int, pd.NaT), SparseDtype(float, pd.NaT)),
+ (SparseDtype('float64'), np.dtype('float64')),
+])
+def test_not_equal(a, b):
+ assert a != b
+
+
+def test_construct_from_string_raises():
+ with pytest.raises(TypeError):
+ SparseDtype.construct_from_string('not a dtype')
+
+
+@pytest.mark.parametrize("dtype, expected", [
+ (SparseDtype(int), True),
+ (SparseDtype(float), True),
+ (SparseDtype(bool), True),
+ (SparseDtype(object), False),
+ (SparseDtype(str), False),
+])
+def test_is_numeric(dtype, expected):
+ assert dtype._is_numeric is expected
+
+
+def test_str_uses_object():
+ result = SparseDtype(str).subtype
+ assert result == np.dtype('object')
+
+
+@pytest.mark.parametrize("string, expected", [
+ ('Sparse[float64]', SparseDtype(np.dtype('float64'))),
+ ('Sparse[float32]', SparseDtype(np.dtype('float32'))),
+ ('Sparse[int]', SparseDtype(np.dtype('int'))),
+ ('Sparse[str]', SparseDtype(np.dtype('str'))),
+ ('Sparse[datetime64[ns]]', SparseDtype(np.dtype('datetime64[ns]'))),
+ ("Sparse", SparseDtype(np.dtype("float"), np.nan))
+])
+def test_construct_from_string(string, expected):
+ result = SparseDtype.construct_from_string(string)
+ assert result == expected
+
+
+@pytest.mark.parametrize("a, b, expected", [
+ (SparseDtype(float, 0.0), SparseDtype(np.dtype('float'), 0.0), True),
+ (SparseDtype(int, 0), SparseDtype(int, 0), True),
+ (SparseDtype(float, float('nan')), SparseDtype(float, np.nan), True),
+ (SparseDtype(float, 0), SparseDtype(float, np.nan), False),
+ (SparseDtype(int, 0.0), SparseDtype(float, 0.0), False),
+])
+def test_hash_equal(a, b, expected):
+ result = a == b
+ assert result is expected
+
+ result = hash(a) == hash(b)
+ assert result is expected
+
+
+@pytest.mark.parametrize('string, expected', [
+ ('Sparse[int]', 'int'),
+ ('Sparse[int, 0]', 'int'),
+ ('Sparse[int64]', 'int64'),
+ ('Sparse[int64, 0]', 'int64'),
+ ('Sparse[datetime64[ns], 0]', 'datetime64[ns]'),
+])
+def test_parse_subtype(string, expected):
+ subtype, _ = SparseDtype._parse_subtype(string)
+ assert subtype == expected
+
+
+@pytest.mark.parametrize("string", [
+ "Sparse[int, 1]",
+ "Sparse[float, 0.0]",
+ "Sparse[bool, True]",
+])
+def test_construct_from_string_fill_value_raises(string):
+ with tm.assert_raises_regex(TypeError, 'fill_value in the string is not'):
+ SparseDtype.construct_from_string(string)
diff --git a/pandas/tests/sparse/test_format.py b/pandas/tests/sparse/test_format.py
index d983bd209085a..4186f579f62f5 100644
--- a/pandas/tests/sparse/test_format.py
+++ b/pandas/tests/sparse/test_format.py
@@ -24,16 +24,20 @@ def test_sparse_max_row(self):
result = repr(s)
dfm = self.dtype_format_for_platform
exp = ("0 1.0\n1 NaN\n2 NaN\n3 3.0\n"
- "4 NaN\ndtype: float64\nBlockIndex\n"
+ "4 NaN\ndtype: Sparse[float64, nan]\nBlockIndex\n"
"Block locations: array([0, 3]{0})\n"
"Block lengths: array([1, 1]{0})".format(dfm))
assert result == exp
+ def test_sparsea_max_row_truncated(self):
+ s = pd.Series([1, np.nan, np.nan, 3, np.nan]).to_sparse()
+ dfm = self.dtype_format_for_platform
+
with option_context("display.max_rows", 3):
# GH 10560
result = repr(s)
exp = ("0 1.0\n ... \n4 NaN\n"
- "Length: 5, dtype: float64\nBlockIndex\n"
+ "Length: 5, dtype: Sparse[float64, nan]\nBlockIndex\n"
"Block locations: array([0, 3]{0})\n"
"Block lengths: array([1, 1]{0})".format(dfm))
assert result == exp
@@ -47,7 +51,7 @@ def test_sparse_mi_max_row(self):
dfm = self.dtype_format_for_platform
exp = ("A 0 1.0\n 1 NaN\nB 0 NaN\n"
"C 0 3.0\n 1 NaN\n 2 NaN\n"
- "dtype: float64\nBlockIndex\n"
+ "dtype: Sparse[float64, nan]\nBlockIndex\n"
"Block locations: array([0, 3]{0})\n"
"Block lengths: array([1, 1]{0})".format(dfm))
assert result == exp
@@ -57,7 +61,7 @@ def test_sparse_mi_max_row(self):
# GH 13144
result = repr(s)
exp = ("A 0 1.0\n ... \nC 2 NaN\n"
- "dtype: float64\nBlockIndex\n"
+ "dtype: Sparse[float64, nan]\nBlockIndex\n"
"Block locations: array([0, 3]{0})\n"
"Block lengths: array([1, 1]{0})".format(dfm))
assert result == exp
@@ -70,7 +74,7 @@ def test_sparse_bool(self):
dtype = '' if use_32bit_repr else ', dtype=int32'
exp = ("0 True\n1 False\n2 False\n"
"3 True\n4 False\n5 False\n"
- "dtype: bool\nBlockIndex\n"
+ "dtype: Sparse[bool, False]\nBlockIndex\n"
"Block locations: array([0, 3]{0})\n"
"Block lengths: array([1, 1]{0})".format(dtype))
assert result == exp
@@ -78,7 +82,7 @@ def test_sparse_bool(self):
with option_context("display.max_rows", 3):
result = repr(s)
exp = ("0 True\n ... \n5 False\n"
- "Length: 6, dtype: bool\nBlockIndex\n"
+ "Length: 6, dtype: Sparse[bool, False]\nBlockIndex\n"
"Block locations: array([0, 3]{0})\n"
"Block lengths: array([1, 1]{0})".format(dtype))
assert result == exp
@@ -90,7 +94,7 @@ def test_sparse_int(self):
result = repr(s)
dtype = '' if use_32bit_repr else ', dtype=int32'
exp = ("0 0\n1 1\n2 0\n3 0\n4 1\n"
- "5 0\ndtype: int64\nBlockIndex\n"
+ "5 0\ndtype: Sparse[int64, False]\nBlockIndex\n"
"Block locations: array([1, 4]{0})\n"
"Block lengths: array([1, 1]{0})".format(dtype))
assert result == exp
@@ -99,7 +103,7 @@ def test_sparse_int(self):
"display.show_dimensions", False):
result = repr(s)
exp = ("0 0\n ..\n5 0\n"
- "dtype: int64\nBlockIndex\n"
+ "dtype: Sparse[int64, False]\nBlockIndex\n"
"Block locations: array([1, 4]{0})\n"
"Block lengths: array([1, 1]{0})".format(dtype))
assert result == exp
diff --git a/pandas/tests/sparse/test_groupby.py b/pandas/tests/sparse/test_groupby.py
index c9049ed9743dd..1d2129312fb1b 100644
--- a/pandas/tests/sparse/test_groupby.py
+++ b/pandas/tests/sparse/test_groupby.py
@@ -1,5 +1,7 @@
# -*- coding: utf-8 -*-
import numpy as np
+import pytest
+
import pandas as pd
import pandas.util.testing as tm
@@ -22,12 +24,13 @@ def test_first_last_nth(self):
sparse_grouped = self.sparse.groupby('A')
dense_grouped = self.dense.groupby('A')
+ # TODO: shouldn't these all be spares or not?
tm.assert_frame_equal(sparse_grouped.first(),
dense_grouped.first())
tm.assert_frame_equal(sparse_grouped.last(),
dense_grouped.last())
tm.assert_frame_equal(sparse_grouped.nth(1),
- dense_grouped.nth(1))
+ dense_grouped.nth(1).to_sparse())
def test_aggfuncs(self):
sparse_grouped = self.sparse.groupby('A')
@@ -42,3 +45,15 @@ def test_aggfuncs(self):
tm.assert_frame_equal(sparse_grouped.count(),
dense_grouped.count())
+
+
+@pytest.mark.parametrize("fill_value", [0, np.nan])
+def test_groupby_includes_fill_value(fill_value):
+ # https://github.com/pandas-dev/pandas/issues/5078
+ df = pd.DataFrame({'a': [fill_value, 1, fill_value, fill_value],
+ 'b': [fill_value, 1, fill_value, fill_value]})
+ sdf = df.to_sparse(fill_value=fill_value)
+ result = sdf.groupby('a').sum()
+ expected = df.groupby('a').sum()
+ tm.assert_frame_equal(result, expected,
+ check_index_type=False)
diff --git a/pandas/tests/sparse/test_indexing.py b/pandas/tests/sparse/test_indexing.py
index 37a287af71451..7c7e450c966bf 100644
--- a/pandas/tests/sparse/test_indexing.py
+++ b/pandas/tests/sparse/test_indexing.py
@@ -4,6 +4,7 @@
import numpy as np
import pandas as pd
import pandas.util.testing as tm
+from pandas.core.sparse.api import SparseDtype
class TestSparseSeriesIndexing(object):
@@ -53,14 +54,14 @@ def test_getitem_int_dtype(self):
res = s[::2]
exp = pd.SparseSeries([0, 2, 4, 6], index=[0, 2, 4, 6], name='xxx')
tm.assert_sp_series_equal(res, exp)
- assert res.dtype == np.int64
+ assert res.dtype == SparseDtype(np.int64)
s = pd.SparseSeries([0, 1, 2, 3, 4, 5, 6], fill_value=0, name='xxx')
res = s[::2]
exp = pd.SparseSeries([0, 2, 4, 6], index=[0, 2, 4, 6],
fill_value=0, name='xxx')
tm.assert_sp_series_equal(res, exp)
- assert res.dtype == np.int64
+ assert res.dtype == SparseDtype(np.int64)
def test_getitem_fill_value(self):
orig = pd.Series([1, np.nan, 0, 3, 0])
@@ -393,6 +394,10 @@ def test_fill_value_reindex(self):
index=list('ABCDE'))
sparse = orig.to_sparse(fill_value=0)
+ def test_fill_value_reindex_coerces_float_int(self):
+ orig = pd.Series([1, np.nan, 0, 3, 0], index=list('ABCDE'))
+ sparse = orig.to_sparse(fill_value=0)
+
res = sparse.reindex(['A', 'E', 'C', 'D'])
exp = orig.reindex(['A', 'E', 'C', 'D']).to_sparse(fill_value=0)
tm.assert_sp_series_equal(res, exp)
@@ -429,12 +434,16 @@ def tests_indexing_with_sparse(self):
dtype=bool)
tm.assert_sp_array_equal(pd.SparseArray([1, 3], kind=kind),
- arr[indexer])
+ arr[indexer],)
s = pd.SparseSeries(arr, index=['a', 'b', 'c'],
dtype=np.float64)
- exp = pd.SparseSeries([1, 3], index=['a', 'c'],
- dtype=np.float64, kind=kind)
+
+ exp = pd.SparseSeries(
+ [1, 3], index=['a', 'c'],
+ dtype=SparseDtype(np.float64, s.fill_value),
+ kind=kind
+ )
tm.assert_sp_series_equal(s[indexer], exp)
tm.assert_sp_series_equal(s.loc[indexer], exp)
tm.assert_sp_series_equal(s.iloc[indexer], exp)
@@ -623,6 +632,10 @@ def test_getitem_fill_value(self):
columns=list('xyz'))
sparse = orig.to_sparse(fill_value=0)
+ result = sparse[['z']]
+ expected = orig[['z']].to_sparse(fill_value=0)
+ tm.assert_sp_frame_equal(result, expected, check_fill_value=False)
+
tm.assert_sp_series_equal(sparse['y'],
orig['y'].to_sparse(fill_value=0))
@@ -654,12 +667,17 @@ def test_loc(self):
assert np.isnan(sparse.loc[1, 'z'])
assert sparse.loc[2, 'z'] == 4
- tm.assert_sp_series_equal(sparse.loc[0], orig.loc[0].to_sparse())
- tm.assert_sp_series_equal(sparse.loc[1], orig.loc[1].to_sparse())
+ # have to specify `kind='integer'`, since we construct a
+ # new SparseArray here, and the default sparse type is
+ # integer there, but block in SparseSeries
+ tm.assert_sp_series_equal(sparse.loc[0],
+ orig.loc[0].to_sparse(kind='integer'))
+ tm.assert_sp_series_equal(sparse.loc[1],
+ orig.loc[1].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.loc[2, :],
- orig.loc[2, :].to_sparse())
+ orig.loc[2, :].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.loc[2, :],
- orig.loc[2, :].to_sparse())
+ orig.loc[2, :].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.loc[:, 'y'],
orig.loc[:, 'y'].to_sparse())
tm.assert_sp_series_equal(sparse.loc[:, 'y'],
@@ -711,12 +729,14 @@ def test_loc_index(self):
assert np.isnan(sparse.loc['b', 'z'])
assert sparse.loc['c', 'z'] == 4
- tm.assert_sp_series_equal(sparse.loc['a'], orig.loc['a'].to_sparse())
- tm.assert_sp_series_equal(sparse.loc['b'], orig.loc['b'].to_sparse())
+ tm.assert_sp_series_equal(sparse.loc['a'],
+ orig.loc['a'].to_sparse(kind='integer'))
+ tm.assert_sp_series_equal(sparse.loc['b'],
+ orig.loc['b'].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.loc['b', :],
- orig.loc['b', :].to_sparse())
+ orig.loc['b', :].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.loc['b', :],
- orig.loc['b', :].to_sparse())
+ orig.loc['b', :].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.loc[:, 'z'],
orig.loc[:, 'z'].to_sparse())
@@ -770,12 +790,14 @@ def test_iloc(self):
assert sparse.iloc[1, 1] == 3
assert np.isnan(sparse.iloc[2, 0])
- tm.assert_sp_series_equal(sparse.iloc[0], orig.loc[0].to_sparse())
- tm.assert_sp_series_equal(sparse.iloc[1], orig.loc[1].to_sparse())
+ tm.assert_sp_series_equal(sparse.iloc[0],
+ orig.loc[0].to_sparse(kind='integer'))
+ tm.assert_sp_series_equal(sparse.iloc[1],
+ orig.loc[1].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.iloc[2, :],
- orig.iloc[2, :].to_sparse())
+ orig.iloc[2, :].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.iloc[2, :],
- orig.iloc[2, :].to_sparse())
+ orig.iloc[2, :].to_sparse(kind='integer'))
tm.assert_sp_series_equal(sparse.iloc[:, 1],
orig.iloc[:, 1].to_sparse())
tm.assert_sp_series_equal(sparse.iloc[:, 1],
@@ -949,7 +971,8 @@ def test_reindex_fill_value(self):
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]],
- index=list('ABCD'), columns=list('xyz'))
+ index=list('ABCD'), columns=list('xyz'),
+ dtype=np.int)
sparse = orig.to_sparse(fill_value=0)
res = sparse.reindex(['A', 'C', 'B'])
@@ -977,7 +1000,7 @@ def setup_method(self, method):
def test_frame_basic_dtypes(self):
for _, row in self.sdf.iterrows():
- assert row.dtype == object
+ assert row.dtype == SparseDtype(object)
tm.assert_sp_series_equal(self.sdf['string'], self.string_series,
check_names=False)
tm.assert_sp_series_equal(self.sdf['int'], self.int_series,
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index c6ab24403d58d..5d7b23894e745 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -160,7 +160,6 @@ def decorated_func(func):
skip_if_no_mpl = pytest.mark.skipif(_skip_if_no_mpl(),
reason="Missing matplotlib dependency")
-
skip_if_np_lt_115 = pytest.mark.skipif(_np_version_under1p15,
reason="NumPy 1.15 or greater required")
skip_if_mpl = pytest.mark.skipif(not _skip_if_no_mpl(),
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index 4e01e0feb004c..a89de74875ee5 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -1169,12 +1169,13 @@ def assert_extension_array_equal(left, right):
"""
assert isinstance(left, ExtensionArray)
assert left.dtype == right.dtype
- left_na = left.isna()
- right_na = right.isna()
+ left_na = np.asarray(left.isna())
+ right_na = np.asarray(right.isna())
+
assert_numpy_array_equal(left_na, right_na)
- left_valid = left[~left_na].astype(object)
- right_valid = right[~right_na].astype(object)
+ left_valid = np.asarray(left[~left_na].astype(object))
+ right_valid = np.asarray(right[~right_na].astype(object))
assert_numpy_array_equal(left_valid, right_valid)
@@ -1568,7 +1569,9 @@ def box_expected(expected, box_cls):
# Sparse
-def assert_sp_array_equal(left, right, check_dtype=True):
+def assert_sp_array_equal(left, right, check_dtype=True, check_kind=True,
+ check_fill_value=True,
+ consolidate_block_indices=False):
"""Check that the left and right SparseArray are equal.
Parameters
@@ -1577,6 +1580,16 @@ def assert_sp_array_equal(left, right, check_dtype=True):
right : SparseArray
check_dtype : bool, default True
Whether to check the data dtype is identical.
+ check_kind : bool, default True
+ Whether to just the kind of the sparse index for each column.
+ check_fill_value : bool, default True
+ Whether to check that left.fill_value matches right.fill_value
+ consolidate_block_indices : bool, default False
+ Whether to consolidate contiguous blocks for sparse arrays with
+ a BlockIndex. Some operations, e.g. concat, will end up with
+ block indices that could be consolidated. Setting this to true will
+ create a new BlockIndex for that array, with consolidated
+ block indices.
"""
_check_isinstance(left, right, pd.SparseArray)
@@ -1588,11 +1601,27 @@ def assert_sp_array_equal(left, right, check_dtype=True):
assert isinstance(left.sp_index, pd._libs.sparse.SparseIndex)
assert isinstance(right.sp_index, pd._libs.sparse.SparseIndex)
- if not left.sp_index.equals(right.sp_index):
+ if not check_kind:
+ left_index = left.sp_index.to_block_index()
+ right_index = right.sp_index.to_block_index()
+ else:
+ left_index = left.sp_index
+ right_index = right.sp_index
+
+ if consolidate_block_indices and left.kind == 'block':
+ # we'll probably remove this hack...
+ left_index = left_index.to_int_index().to_block_index()
+ right_index = right_index.to_int_index().to_block_index()
+
+ if not left_index.equals(right_index):
raise_assert_detail('SparseArray.index', 'index are not equal',
- left.sp_index, right.sp_index)
+ left_index, right_index)
+ else:
+ # Just ensure a
+ pass
- assert_attr_equal('fill_value', left, right)
+ if check_fill_value:
+ assert_attr_equal('fill_value', left, right)
if check_dtype:
assert_attr_equal('dtype', left, right)
assert_numpy_array_equal(left.values, right.values,
@@ -1601,6 +1630,9 @@ def assert_sp_array_equal(left, right, check_dtype=True):
def assert_sp_series_equal(left, right, check_dtype=True, exact_indices=True,
check_series_type=True, check_names=True,
+ check_kind=True,
+ check_fill_value=True,
+ consolidate_block_indices=False,
obj='SparseSeries'):
"""Check that the left and right SparseSeries are equal.
@@ -1615,6 +1647,16 @@ def assert_sp_series_equal(left, right, check_dtype=True, exact_indices=True,
Whether to check the SparseSeries class is identical.
check_names : bool, default True
Whether to check the SparseSeries name attribute.
+ check_kind : bool, default True
+ Whether to just the kind of the sparse index for each column.
+ check_fill_value : bool, default True
+ Whether to check that left.fill_value matches right.fill_value
+ consolidate_block_indices : bool, default False
+ Whether to consolidate contiguous blocks for sparse arrays with
+ a BlockIndex. Some operations, e.g. concat, will end up with
+ block indices that could be consolidated. Setting this to true will
+ create a new BlockIndex for that array, with consolidated
+ block indices.
obj : str, default 'SparseSeries'
Specify the object name being compared, internally used to show
the appropriate assertion message.
@@ -1627,18 +1669,25 @@ def assert_sp_series_equal(left, right, check_dtype=True, exact_indices=True,
assert_index_equal(left.index, right.index,
obj='{obj}.index'.format(obj=obj))
- assert_sp_array_equal(left.block.values, right.block.values)
+ assert_sp_array_equal(left.values, right.values,
+ check_kind=check_kind,
+ check_fill_value=check_fill_value,
+ consolidate_block_indices=consolidate_block_indices)
if check_names:
assert_attr_equal('name', left, right)
if check_dtype:
assert_attr_equal('dtype', left, right)
- assert_numpy_array_equal(left.values, right.values)
+ assert_numpy_array_equal(np.asarray(left.values),
+ np.asarray(right.values))
def assert_sp_frame_equal(left, right, check_dtype=True, exact_indices=True,
- check_frame_type=True, obj='SparseDataFrame'):
+ check_frame_type=True, check_kind=True,
+ check_fill_value=True,
+ consolidate_block_indices=False,
+ obj='SparseDataFrame'):
"""Check that the left and right SparseDataFrame are equal.
Parameters
@@ -1652,6 +1701,16 @@ def assert_sp_frame_equal(left, right, check_dtype=True, exact_indices=True,
otherwise just compare dense representations.
check_frame_type : bool, default True
Whether to check the SparseDataFrame class is identical.
+ check_kind : bool, default True
+ Whether to just the kind of the sparse index for each column.
+ check_fill_value : bool, default True
+ Whether to check that left.fill_value matches right.fill_value
+ consolidate_block_indices : bool, default False
+ Whether to consolidate contiguous blocks for sparse arrays with
+ a BlockIndex. Some operations, e.g. concat, will end up with
+ block indices that could be consolidated. Setting this to true will
+ create a new BlockIndex for that array, with consolidated
+ block indices.
obj : str, default 'SparseDataFrame'
Specify the object name being compared, internally used to show
the appropriate assertion message.
@@ -1666,19 +1725,25 @@ def assert_sp_frame_equal(left, right, check_dtype=True, exact_indices=True,
assert_index_equal(left.columns, right.columns,
obj='{obj}.columns'.format(obj=obj))
+ if check_fill_value:
+ assert_attr_equal('default_fill_value', left, right, obj=obj)
+
for col, series in compat.iteritems(left):
assert (col in right)
# trade-off?
if exact_indices:
- assert_sp_series_equal(series, right[col],
- check_dtype=check_dtype)
+ assert_sp_series_equal(
+ series, right[col],
+ check_dtype=check_dtype,
+ check_kind=check_kind,
+ check_fill_value=check_fill_value,
+ consolidate_block_indices=consolidate_block_indices
+ )
else:
assert_series_equal(series.to_dense(), right[col].to_dense(),
check_dtype=check_dtype)
- assert_attr_equal('default_fill_value', left, right, obj=obj)
-
# do I care?
# assert(left.default_kind == right.default_kind)
| Closes #21978
Closes #19506
Closes https://github.com/pandas-dev/pandas/issues/22835
High-level summary: SparseArray is an ExtensionArray. It's no longer an ndarray subclass. The actual data model hasn't changed at all, it's still an array and a `sparse_index`. Only now the sparse values are `self.sparse_values`, rather than `self`.
This isn't really close to being ready yet. I'm going to go through and self-review a bunch of things right now, will call out for others' opinions in specific places.
API discussions:
- [x] Why is the default kind inconsistent between SparseSeries and SparseArray?
- Possibly get rid of block in a future PR
- [x] Should `.astype(np_dtype)` be sparse or dense?
- sparse
- [x] What should the inferred type of an empty SparseArray be? `SparseArray([]).dtype`? NumPy defaults to float (`Sparse[float64]`), pandas typically uses object (`Sparse[object]`)
- sparse
- [x] Policy for warning when converting to dense (e.g. https://github.com/pandas-dev/pandas/pull/22325/files#diff-71caf9627e9687e837e4b1f86ecc6271R390). In the past, pandas would coerce to an ndarray all over the place. Now we at least have a *chance* of knowing when we're doing a bad thing, and warning about it.
- warn when it's implicit | https://api.github.com/repos/pandas-dev/pandas/pulls/22325 | 2018-08-13T20:02:46Z | 2018-10-13T11:37:14Z | 2018-10-13T11:37:13Z | 2021-11-30T15:01:35Z |
CLN: Remove variable assignment on CI script | diff --git a/ci/print_skipped.py b/ci/print_skipped.py
index dd2180f6eeb19..67bc7b556cd43 100755
--- a/ci/print_skipped.py
+++ b/ci/print_skipped.py
@@ -10,7 +10,7 @@ def parse_results(filename):
root = tree.getroot()
skipped = []
- current_class = old_class = ''
+ current_class = ''
i = 1
assert i - 1 == len(skipped)
for el in root.findall('testcase'):
@@ -24,7 +24,9 @@ def parse_results(filename):
out = ''
if old_class != current_class:
ndigits = int(math.log(i, 10) + 1)
- out += ('-' * (len(name + msg) + 4 + ndigits) + '\n') # 4 for : + space + # + space
+
+ # 4 for : + space + # + space
+ out += ('-' * (len(name + msg) + 4 + ndigits) + '\n')
out += '#{i} {name}: {msg}'.format(i=i, name=name, msg=msg)
skipped.append(out)
i += 1
| Looks to me like this variable assignment is not required since on line 19 `old_class = current_class` | https://api.github.com/repos/pandas-dev/pandas/pulls/22322 | 2018-08-13T19:49:26Z | 2018-08-14T00:05:41Z | 2018-08-14T00:05:41Z | 2018-08-26T18:38:16Z |
CLN: Remove unused method | diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 37f4415776b83..5b2e3a76adf05 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -752,11 +752,6 @@ def _constructor(self):
def inferred_type(self):
return 'mixed'
- @staticmethod
- def _from_elements(values, labels=None, levels=None, names=None,
- sortorder=None):
- return MultiIndex(levels, labels, names, sortorder=sortorder)
-
def _get_level_number(self, level):
count = self.names.count(level)
if (count > 1) and not is_integer(level):
| - [y] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
This method isn't used anywhere in the codebase, good to delete? | https://api.github.com/repos/pandas-dev/pandas/pulls/22321 | 2018-08-13T19:45:35Z | 2018-08-14T10:10:05Z | 2018-08-14T10:10:05Z | 2018-08-14T10:10:10Z |
Bump pytest | diff --git a/ci/environment-dev.yaml b/ci/environment-dev.yaml
index 8d516a6214f95..f66a831aae0f5 100644
--- a/ci/environment-dev.yaml
+++ b/ci/environment-dev.yaml
@@ -8,7 +8,7 @@ dependencies:
- flake8
- flake8-comprehensions
- moto
- - pytest>=3.1
+ - pytest>=3.6
- python-dateutil>=2.5.0
- python=3
- pytz
diff --git a/ci/requirements_dev.txt b/ci/requirements_dev.txt
index c89aae8f2ffca..a50a4dcd63508 100644
--- a/ci/requirements_dev.txt
+++ b/ci/requirements_dev.txt
@@ -5,7 +5,7 @@ NumPy
flake8
flake8-comprehensions
moto
-pytest>=3.1
+pytest>=3.6
python-dateutil>=2.5.0
pytz
setuptools>=24.2.0
diff --git a/doc/source/contributing.rst b/doc/source/contributing.rst
index ff06d024740bf..2ab78734f78a5 100644
--- a/doc/source/contributing.rst
+++ b/doc/source/contributing.rst
@@ -652,13 +652,13 @@ Adding tests is one of the most common requests after code is pushed to *pandas*
it is worth getting in the habit of writing tests ahead of time so this is never an issue.
Like many packages, *pandas* uses `pytest
-<http://doc.pytest.org/en/latest/>`_ and the convenient
+<http://docs.pytest.org/en/latest/>`_ and the convenient
extensions in `numpy.testing
<http://docs.scipy.org/doc/numpy/reference/routines.testing.html>`_.
.. note::
- The earliest supported pytest version is 3.1.0.
+ The earliest supported pytest version is 3.6.0.
Writing tests
~~~~~~~~~~~~~
@@ -702,7 +702,7 @@ Transitioning to ``pytest``
class TestReallyCoolFeature(object):
....
-Going forward, we are moving to a more *functional* style using the `pytest <http://doc.pytest.org/en/latest/>`__ framework, which offers a richer testing
+Going forward, we are moving to a more *functional* style using the `pytest <http://docs.pytest.org/en/latest/>`__ framework, which offers a richer testing
framework that will facilitate testing and developing. Thus, instead of writing test classes, we will write test functions like this:
.. code-block:: python
@@ -766,7 +766,7 @@ A test run of this yields
((pandas) bash-3.2$ pytest test_cool_feature.py -v
=========================== test session starts ===========================
- platform darwin -- Python 3.6.2, pytest-3.2.1, py-1.4.31, pluggy-0.4.0
+ platform darwin -- Python 3.6.2, pytest-3.6.0, py-1.4.31, pluggy-0.4.0
collected 11 items
tester.py::test_dtypes[int8] PASSED
@@ -788,7 +788,7 @@ Tests that we have ``parametrized`` are now accessible via the test name, for ex
((pandas) bash-3.2$ pytest test_cool_feature.py -v -k int8
=========================== test session starts ===========================
- platform darwin -- Python 3.6.2, pytest-3.2.1, py-1.4.31, pluggy-0.4.0
+ platform darwin -- Python 3.6.2, pytest-3.6.0, py-1.4.31, pluggy-0.4.0
collected 11 items
test_cool_feature.py::test_dtypes[int8] PASSED
@@ -837,7 +837,7 @@ On Windows, one can type::
This can significantly reduce the time it takes to locally run tests before
submitting a pull request.
-For more, see the `pytest <http://doc.pytest.org/en/latest/>`_ documentation.
+For more, see the `pytest <http://docs.pytest.org/en/latest/>`_ documentation.
.. versionadded:: 0.20.0
diff --git a/doc/source/install.rst b/doc/source/install.rst
index eb837547037db..08be1960eb957 100644
--- a/doc/source/install.rst
+++ b/doc/source/install.rst
@@ -202,7 +202,7 @@ pandas is equipped with an exhaustive set of unit tests, covering about 97% of
the code base as of this writing. To run it on your machine to verify that
everything is working (and that you have all of the dependencies, soft and hard,
installed), make sure you have `pytest
-<http://doc.pytest.org/en/latest/>`__ and run:
+<http://docs.pytest.org/en/latest/>`__ >= 3.6 and run:
::
@@ -210,7 +210,7 @@ installed), make sure you have `pytest
>>> pd.test()
running: pytest --skip-slow --skip-network C:\Users\TP\Anaconda3\envs\py36\lib\site-packages\pandas
============================= test session starts =============================
- platform win32 -- Python 3.6.2, pytest-3.2.1, py-1.4.34, pluggy-0.4.0
+ platform win32 -- Python 3.6.2, pytest-3.6.0, py-1.4.34, pluggy-0.4.0
rootdir: C:\Users\TP\Documents\Python\pandasdev\pandas, inifile: setup.cfg
collected 12145 items / 3 skipped
diff --git a/doc/source/whatsnew/v0.23.5.txt b/doc/source/whatsnew/v0.23.5.txt
index 88ea7a6caecfc..2a1172c8050ad 100644
--- a/doc/source/whatsnew/v0.23.5.txt
+++ b/doc/source/whatsnew/v0.23.5.txt
@@ -26,6 +26,11 @@ Fixed Regressions
-
-
+
+Development
+~~~~~~~~~~~
+- The minimum required pytest version has been increased to 3.6 (:issue:`22319`)
+
.. _whatsnew_0235.bug_fixes:
Bug Fixes
diff --git a/setup.cfg b/setup.cfg
index d00d527da49e2..96f447e90cd58 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -31,6 +31,7 @@ split_penalty_after_opening_bracket = 1000000
split_penalty_logical_operator = 30
[tool:pytest]
+minversion = 3.6
testpaths = pandas
markers =
single: mark a test as single cpu only
| - [X] closes #22319
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
@TomAugspurger | https://api.github.com/repos/pandas-dev/pandas/pulls/22320 | 2018-08-13T19:26:18Z | 2018-08-16T10:54:19Z | 2018-08-16T10:54:18Z | 2019-02-28T07:23:23Z |
DEPR: join_axes-kwarg in pd.concat | diff --git a/doc/source/user_guide/merging.rst b/doc/source/user_guide/merging.rst
index 43d44ff30c64a..6e63e672bb968 100644
--- a/doc/source/user_guide/merging.rst
+++ b/doc/source/user_guide/merging.rst
@@ -70,9 +70,8 @@ some configurable handling of "what to do with the other axes":
::
- pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
- keys=None, levels=None, names=None, verify_integrity=False,
- copy=True)
+ pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None,
+ levels=None, names=None, verify_integrity=False, copy=True)
* ``objs`` : a sequence or mapping of Series or DataFrame objects. If a
dict is passed, the sorted keys will be used as the `keys` argument, unless
@@ -87,8 +86,6 @@ some configurable handling of "what to do with the other axes":
n - 1. This is useful if you are concatenating objects where the
concatenation axis does not have meaningful indexing information. Note
the index values on the other axes are still respected in the join.
-* ``join_axes`` : list of Index objects. Specific indexes to use for the other
- n - 1 axes instead of performing inner/outer set logic.
* ``keys`` : sequence, default None. Construct hierarchical index using the
passed keys as the outermost level. If multiple levels passed, should
contain tuples.
@@ -147,12 +144,11 @@ Set logic on the other axes
When gluing together multiple DataFrames, you have a choice of how to handle
the other axes (other than the one being concatenated). This can be done in
-the following three ways:
+the following two ways:
* Take the union of them all, ``join='outer'``. This is the default
option as it results in zero information loss.
* Take the intersection, ``join='inner'``.
-* Use a specific index, as passed to the ``join_axes`` argument.
Here is an example of each of these methods. First, the default ``join='outer'``
behavior:
@@ -202,7 +198,13 @@ DataFrame:
.. ipython:: python
- result = pd.concat([df1, df4], axis=1, join_axes=[df1.index])
+ result = pd.concat([df1, df4], axis=1).reindex(df1.index)
+
+Similarly, we could index before the concatenation:
+
+.. ipython:: python
+
+ pd.concat([df1, df4.reindex(df1.index)], axis=1)
.. ipython:: python
:suppress:
diff --git a/doc/source/whatsnew/v0.25.0.rst b/doc/source/whatsnew/v0.25.0.rst
index e9d23cfd8efc1..713bae34d31dd 100644
--- a/doc/source/whatsnew/v0.25.0.rst
+++ b/doc/source/whatsnew/v0.25.0.rst
@@ -744,6 +744,7 @@ Other deprecations
- The deprecated ``.ix[]`` indexer now raises a more visible ``FutureWarning`` instead of ``DeprecationWarning`` (:issue:`26438`).
- Deprecated the ``units=M`` (months) and ``units=Y`` (year) parameters for ``units`` of :func:`pandas.to_timedelta`, :func:`pandas.Timedelta` and :func:`pandas.TimedeltaIndex` (:issue:`16344`)
+- :meth:`pandas.concat` has deprecated the ``join_axes``-keyword. Instead, use :meth:`DataFrame.reindex` or :meth:`DataFrame.reindex_like` on the result or on the inputs (:issue:`21951`)
- The :attr:`SparseArray.values` attribute is deprecated. You can use ``np.asarray(...)`` or
the :meth:`SparseArray.to_dense` method instead (:issue:`26421`).
- The functions :func:`pandas.to_datetime` and :func:`pandas.to_timedelta` have deprecated the ``box`` keyword. Instead, use :meth:`to_numpy` or :meth:`Timestamp.to_datetime64` or :meth:`Timedelta.to_timedelta64`. (:issue:`24416`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 3ff3fff22f4f0..0e7bb1211fb65 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -6806,12 +6806,12 @@ def _join_compat(self, other, on=None, how='left', lsuffix='', rsuffix='',
# join indexes only using concat
if can_concat:
if how == 'left':
- how = 'outer'
- join_axes = [self.index]
+ res = concat(frames, axis=1, join='outer',
+ verify_integrity=True)
+ return res.reindex(self.index, copy=False)
else:
- join_axes = None
- return concat(frames, axis=1, join=how, join_axes=join_axes,
- verify_integrity=True)
+ return concat(frames, axis=1, join=how,
+ verify_integrity=True)
joined = frames[0]
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 822428c6787be..00429c31ee70b 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -9706,7 +9706,8 @@ def describe_1d(data):
if name not in names:
names.append(name)
- d = pd.concat(ldesc, join_axes=pd.Index([names]), axis=1)
+ d = pd.concat([x.reindex(names, copy=False) for x in ldesc],
+ axis=1, sort=False)
d.columns = data.columns.copy()
return d
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 210e82837118c..9e7dcafc0b1a4 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -562,8 +562,10 @@ def _transform_general(self, func, *args, **kwargs):
applied.append(res)
concat_index = obj.columns if self.axis == 0 else obj.index
- concatenated = concat(applied, join_axes=[concat_index],
- axis=self.axis, verify_integrity=False)
+ other_axis = 1 if self.axis == 0 else 0 # switches between 0 & 1
+ concatenated = concat(applied, axis=self.axis, verify_integrity=False)
+ concatenated = concatenated.reindex(concat_index, axis=other_axis,
+ copy=False)
return self._set_result_index_ordered(concatenated)
@Substitution(klass='DataFrame', selected='')
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index 4523a6ad48f19..d4272cf6e406d 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -2,6 +2,8 @@
concat routines
"""
+import warnings
+
import numpy as np
import pandas.core.dtypes.concat as _concat
@@ -44,8 +46,11 @@ def concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
join : {'inner', 'outer'}, default 'outer'
How to handle indexes on other axis (or axes).
join_axes : list of Index objects
+ .. deprecated:: 0.25.0
+
Specific indexes to use for the other n - 1 axes instead of performing
- inner/outer set logic.
+ inner/outer set logic. Use .reindex() before or after concatenation
+ as a replacement.
ignore_index : bool, default False
If True, do not use the index values along the concatenation axis. The
resulting axis will be labeled 0, ..., n - 1. This is useful if you are
@@ -221,11 +226,11 @@ def concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
...
ValueError: Indexes have overlapping values: ['a']
"""
- op = _Concatenator(objs, axis=axis, join_axes=join_axes,
- ignore_index=ignore_index, join=join,
- keys=keys, levels=levels, names=names,
- verify_integrity=verify_integrity,
+ op = _Concatenator(objs, axis=axis, ignore_index=ignore_index, join=join,
+ join_axes=join_axes, keys=keys, levels=levels,
+ names=names, verify_integrity=verify_integrity,
copy=copy, sort=sort)
+
return op.get_result()
@@ -234,10 +239,9 @@ class _Concatenator:
Orchestrates a concatenation operation for BlockManagers
"""
- def __init__(self, objs, axis=0, join='outer', join_axes=None,
- keys=None, levels=None, names=None,
- ignore_index=False, verify_integrity=False, copy=True,
- sort=False):
+ def __init__(self, objs, axis=0, join='outer', join_axes=None, keys=None,
+ levels=None, names=None, ignore_index=False,
+ verify_integrity=False, copy=True, sort=False):
if isinstance(objs, (NDFrame, str)):
raise TypeError('first argument must be an iterable of pandas '
'objects, you passed an object of type '
@@ -310,9 +314,7 @@ def __init__(self, objs, axis=0, join='outer', join_axes=None,
if sum(obj.shape) > 0 or isinstance(obj, Series)]
if (len(non_empties) and (keys is None and names is None and
- levels is None and
- join_axes is None and
- not self.intersect)):
+ levels is None and not self.intersect)):
objs = non_empties
sample = objs[0]
@@ -446,7 +448,14 @@ def _get_new_axes(self):
if i == self.axis:
continue
new_axes[i] = self._get_comb_axis(i)
+
else:
+ # GH 21951
+ warnings.warn(
+ 'The join_axes-keyword is deprecated. Use .reindex or '
+ '.reindex_like on the result to achieve the same '
+ 'functionality.', FutureWarning, stacklevel=4)
+
if len(self.join_axes) != ndim - 1:
raise AssertionError("length of join_axes must be equal "
"to {length}".format(length=ndim - 1))
diff --git a/pandas/tests/reshape/test_concat.py b/pandas/tests/reshape/test_concat.py
index 74ede682dfb5f..031f3abf31b16 100644
--- a/pandas/tests/reshape/test_concat.py
+++ b/pandas/tests/reshape/test_concat.py
@@ -722,6 +722,26 @@ def test_concat_categorical_empty(self):
tm.assert_series_equal(pd.concat([s2, s1], ignore_index=True), exp)
tm.assert_series_equal(s2.append(s1, ignore_index=True), exp)
+ def test_concat_join_axes_deprecated(self, axis):
+ # GH21951
+ one = pd.DataFrame([[0., 1.], [2., 3.]], columns=list('ab'))
+ two = pd.DataFrame([[10., 11.], [12., 13.]], index=[1, 2],
+ columns=list('bc'))
+
+ expected = pd.concat([one, two],
+ axis=1, sort=False).reindex(index=two.index)
+ with tm.assert_produces_warning(expected_warning=FutureWarning):
+ result = pd.concat([one, two],
+ axis=1, sort=False, join_axes=[two.index])
+ tm.assert_frame_equal(result, expected)
+
+ expected = pd.concat([one, two],
+ axis=0, sort=False).reindex(columns=two.columns)
+ with tm.assert_produces_warning(expected_warning=FutureWarning):
+ result = pd.concat([one, two],
+ axis=0, sort=False, join_axes=[two.columns])
+ tm.assert_frame_equal(result, expected)
+
class TestAppend:
| - [x] closes #21951
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22318 | 2018-08-13T19:22:29Z | 2019-07-03T11:32:54Z | 2019-07-03T11:32:54Z | 2019-07-31T13:32:50Z |
DOC/DEPR: clarify argmin/argmax deprecation message | diff --git a/pandas/core/series.py b/pandas/core/series.py
index b84179875db1f..d80a9a0fc52f4 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1807,16 +1807,22 @@ def idxmax(self, axis=0, skipna=True, *args, **kwargs):
argmin = deprecate(
'argmin', idxmin, '0.21.0',
msg=dedent("""\
- 'argmin' is deprecated, use 'idxmin' instead. The behavior of 'argmin'
- will be corrected to return the positional minimum in the future.
- Use 'series.values.argmin' to get the position of the minimum row.""")
+ The current behaviour of 'Series.argmin' is deprecated, use 'idxmin'
+ instead.
+ The behavior of 'argmin' will be corrected to return the positional
+ minimum in the future. For now, use 'series.values.argmin' or
+ 'np.argmin(np.array(values))' to get the position of the minimum
+ row.""")
)
argmax = deprecate(
'argmax', idxmax, '0.21.0',
msg=dedent("""\
- 'argmax' is deprecated, use 'idxmax' instead. The behavior of 'argmax'
- will be corrected to return the positional maximum in the future.
- Use 'series.values.argmax' to get the position of the maximum row.""")
+ The current behaviour of 'Series.argmax' is deprecated, use 'idxmax'
+ instead.
+ The behavior of 'argmax' will be corrected to return the positional
+ maximum in the future. For now, use 'series.values.argmax' or
+ 'np.argmax(np.array(values))' to get the position of the maximum
+ row.""")
)
def round(self, decimals=0, *args, **kwargs):
| Attempt to better phrase the message, xref https://github.com/pandas-dev/pandas/issues/16830#issuecomment-412211029 | https://api.github.com/repos/pandas-dev/pandas/pulls/22310 | 2018-08-13T12:26:08Z | 2018-08-13T16:33:45Z | 2018-08-13T16:33:45Z | 2018-08-14T08:45:43Z |
BUG: Fix float formatting when a string is passed as float_format arg | diff --git a/doc/source/whatsnew/v0.24.0.rst b/doc/source/whatsnew/v0.24.0.rst
index 4ff3cc728f7f7..0fad0dc65edaa 100644
--- a/doc/source/whatsnew/v0.24.0.rst
+++ b/doc/source/whatsnew/v0.24.0.rst
@@ -1395,6 +1395,7 @@ Notice how we now instead output ``np.nan`` itself instead of a stringified form
- Bug in :meth:`read_excel()` in which extraneous header names were extracted, even though none were specified (:issue:`11733`)
- Bug in :meth:`read_excel()` in which ``index_col=None`` was not being respected and parsing index columns anyway (:issue:`20480`)
- Bug in :meth:`read_excel()` in which ``usecols`` was not being validated for proper column names when passed in as a string (:issue:`20480`)
+- :func:`DataFrame.to_string()`, :func:`DataFrame.to_html()`, :func:`DataFrame.to_latex()` will correctly format output when a string is passed as the ``float_format`` argument (:issue:`21625`, :issue:`22270`)
Plotting
^^^^^^^^
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index c777b89eeaf12..4c08ee89c33df 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -960,6 +960,8 @@ def __init__(self, *args, **kwargs):
# float_format is expected to be a string
# formatter should be used to pass a function
if self.float_format is not None and self.formatter is None:
+ # GH21625, GH22270
+ self.fixed_width = False
if callable(self.float_format):
self.formatter = self.float_format
self.float_format = None
diff --git a/pandas/tests/io/formats/data/gh21625_expected_output.html b/pandas/tests/io/formats/data/gh21625_expected_output.html
new file mode 100644
index 0000000000000..a87e4ca301d9d
--- /dev/null
+++ b/pandas/tests/io/formats/data/gh21625_expected_output.html
@@ -0,0 +1,14 @@
+<table border="1" class="dataframe">
+ <thead>
+ <tr style="text-align: right;">
+ <th></th>
+ <th>x</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <th>0</th>
+ <td>0.200</td>
+ </tr>
+ </tbody>
+</table>
\ No newline at end of file
diff --git a/pandas/tests/io/formats/data/gh22270_expected_output.html b/pandas/tests/io/formats/data/gh22270_expected_output.html
new file mode 100644
index 0000000000000..6694c43dc9e68
--- /dev/null
+++ b/pandas/tests/io/formats/data/gh22270_expected_output.html
@@ -0,0 +1,14 @@
+<table border="1" class="dataframe">
+ <thead>
+ <tr style="text-align: right;">
+ <th></th>
+ <th>x</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <th>0</th>
+ <td>100</td>
+ </tr>
+ </tbody>
+</table>
\ No newline at end of file
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 7d26ea05b514a..b974415ffb029 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -1359,6 +1359,18 @@ def test_to_string_float_formatting(self):
'1 2.512000e-01')
assert df_s == expected
+ def test_to_string_float_format_no_fixed_width(self):
+
+ # GH 21625
+ df = DataFrame({'x': [0.19999]})
+ expected = ' x\n0 0.200'
+ assert df.to_string(float_format='%.3f') == expected
+
+ # GH 22270
+ df = DataFrame({'x': [100.0]})
+ expected = ' x\n0 100'
+ assert df.to_string(float_format='%.0f') == expected
+
def test_to_string_small_float_values(self):
df = DataFrame({'a': [1.5, 1e-17, -5.5e-7]})
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index 0da48f60f1b51..882a629b5b706 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -465,3 +465,15 @@ def test_to_html_with_id(self):
name='myindexname'))
result = df.to_html(index_names=False, table_id="TEST_ID")
assert ' id="TEST_ID"' in result
+
+ def test_to_html_float_format_no_fixed_width(self, datapath):
+
+ # GH 21625
+ df = DataFrame({'x': [0.19999]})
+ expected = expected_html(datapath, 'gh21625_expected_output')
+ assert df.to_html(float_format='%.3f') == expected
+
+ # GH 22270
+ df = DataFrame({'x': [100.0]})
+ expected = expected_html(datapath, 'gh22270_expected_output')
+ assert df.to_html(float_format='%.0f') == expected
diff --git a/pandas/tests/io/formats/test_to_latex.py b/pandas/tests/io/formats/test_to_latex.py
index 73517890565c7..f55fa289ea085 100644
--- a/pandas/tests/io/formats/test_to_latex.py
+++ b/pandas/tests/io/formats/test_to_latex.py
@@ -708,3 +708,29 @@ def test_to_latex_multiindex_empty_name(self):
\end{tabular}
"""
assert observed == expected
+
+ def test_to_latex_float_format_no_fixed_width(self):
+
+ # GH 21625
+ df = DataFrame({'x': [0.19999]})
+ expected = r"""\begin{tabular}{lr}
+\toprule
+{} & x \\
+\midrule
+0 & 0.200 \\
+\bottomrule
+\end{tabular}
+"""
+ assert df.to_latex(float_format='%.3f') == expected
+
+ # GH 22270
+ df = DataFrame({'x': [100.0]})
+ expected = r"""\begin{tabular}{lr}
+\toprule
+{} & x \\
+\midrule
+0 & 100 \\
+\bottomrule
+\end{tabular}
+"""
+ assert df.to_latex(float_format='%.0f') == expected
| closes #21625
closes #22270.
If a string `float_format` argument is passed by the user to `to_string`, `to_latex`, `to_html`, etc, then disable fixed width, so that now e.g.
```python
df.to_string(float_format='%.3f')
```
will give the same result as
```python
df.to_string(float_format=lambda x: '%.3f' % x)
```
- [x] closes #21625 and #22270
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22308 | 2018-08-13T10:05:39Z | 2018-11-26T13:59:23Z | 2018-11-26T13:59:22Z | 2018-11-26T14:21:49Z |
DOC: fixes to DataFrame.plot.area docstring | diff --git a/pandas/plotting/_core.py b/pandas/plotting/_core.py
index 85b2738e572b6..4fa3b51c60ee4 100644
--- a/pandas/plotting/_core.py
+++ b/pandas/plotting/_core.py
@@ -3385,25 +3385,13 @@ def area(self, x=None, y=None, **kwds):
.. plot::
:context: close-figs
- >>> df = pd.DataFrame({
- ... 'sales': [3, 2, 3, 9, 10, 6],
- ... 'signups': [5, 5, 6, 12, 14, 13],
- ... 'visits': [20, 42, 28, 62, 81, 50],
- ... }, index=pd.date_range(start='2018/01/01', end='2018/07/01',
- ... freq='M'))
>>> ax = df.plot.area(stacked=False)
- Draw an area plot for each metric:
+ Draw an area plot for a single column:
.. plot::
:context: close-figs
- >>> df = pd.DataFrame({
- ... 'sales': [3, 2, 3, 9, 10, 6],
- ... 'signups': [5, 5, 6, 12, 14, 13],
- ... 'visits': [20, 42, 28, 62, 81, 50],
- ... }, index=pd.date_range(start='2018/01/01', end='2018/07/01',
- ... freq='M'))
>>> ax = df.plot.area(y='sales')
Draw with a different `x`:
@@ -3414,9 +3402,8 @@ def area(self, x=None, y=None, **kwds):
>>> df = pd.DataFrame({
... 'sales': [3, 2, 3],
... 'visits': [20, 42, 28],
- ... 'day': ['Monday', 'Tuesday', 'Wednesday'],
- ... }, index=pd.date_range(start='2018/01/01', end='2018/07/01',
- ... freq='M'))
+ ... 'day': [1, 2, 3],
+ ... })
>>> ax = df.plot.area(x='day')
"""
return self(kind='area', x=x, y=y, **kwds)
| Follow-up on https://github.com/pandas-dev/pandas/pull/20170 | https://api.github.com/repos/pandas-dev/pandas/pulls/22307 | 2018-08-13T09:57:28Z | 2018-08-14T08:46:43Z | 2018-08-14T08:46:43Z | 2018-08-14T08:46:46Z |
ENH: add quantile method to resample | diff --git a/doc/source/api.rst b/doc/source/api.rst
index 551b3eff10fa0..77d37ec2a7b2e 100644
--- a/doc/source/api.rst
+++ b/doc/source/api.rst
@@ -2352,6 +2352,7 @@ Computations / Descriptive Stats
Resampler.std
Resampler.sum
Resampler.var
+ Resampler.quantile
Style
-----
diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 9e1d2487b00fe..a3d4a95a7d01a 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -183,6 +183,7 @@ Other Enhancements
- :class:`Series` and :class:`DataFrame` now support :class:`Iterable` in constructor (:issue:`2193`)
- :class:`DatetimeIndex` gained :attr:`DatetimeIndex.timetz` attribute. Returns local time with timezone information. (:issue:`21358`)
- :class:`Resampler` now is iterable like :class:`GroupBy` (:issue:`15314`).
+- :ref:`Series.resample` and :ref:`DataFrame.resample` have gained the :meth:`Resampler.quantile` (:issue:`15023`).
.. _whatsnew_0240.api_breaking:
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 3f84fa0f0670e..61dadd833be35 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -1168,7 +1168,12 @@ def var(self, ddof=1, *args, **kwargs):
"""
nv.validate_groupby_func('var', args, kwargs)
if ddof == 1:
- return self._cython_agg_general('var', **kwargs)
+ try:
+ return self._cython_agg_general('var', **kwargs)
+ except Exception:
+ f = lambda x: x.var(ddof=ddof, **kwargs)
+ with _group_selection_context(self):
+ return self._python_agg_general(f)
else:
f = lambda x: x.var(ddof=ddof, **kwargs)
with _group_selection_context(self):
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index b9194443c3033..3d749848afdad 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -766,6 +766,24 @@ def size(self):
result = pd.Series([], index=result.index, dtype='int64')
return result
+ def quantile(self, q=0.5, **kwargs):
+ """
+ Return value at the given quantile.
+
+ .. versionadded:: 0.24.0
+
+ Parameters
+ ----------
+ q : float or array-like, default 0.5 (50% quantile)
+
+ See Also
+ --------
+ Series.quantile
+ DataFrame.quantile
+ DataFrameGroupBy.quantile
+ """
+ return self._downsample('quantile', q=q, **kwargs)
+
# downsample methods
for method in ['sum', 'prod']:
@@ -1060,7 +1078,8 @@ def _downsample(self, how, **kwargs):
if is_subperiod(ax.freq, self.freq):
# Downsampling
- return self._groupby_and_aggregate(how, grouper=self.grouper)
+ return self._groupby_and_aggregate(how, grouper=self.grouper,
+ **kwargs)
elif is_superperiod(ax.freq, self.freq):
if how == 'ohlc':
# GH #13083
diff --git a/pandas/tests/test_resample.py b/pandas/tests/test_resample.py
index 48b37e5da62ae..b80c041a7e69f 100644
--- a/pandas/tests/test_resample.py
+++ b/pandas/tests/test_resample.py
@@ -41,7 +41,7 @@
# The various methods we support
downsample_methods = ['min', 'max', 'first', 'last', 'sum', 'mean', 'sem',
- 'median', 'prod', 'var', 'ohlc']
+ 'median', 'prod', 'var', 'ohlc', 'quantile']
upsample_methods = ['count', 'size']
series_methods = ['nunique']
resample_methods = downsample_methods + upsample_methods + series_methods
@@ -782,6 +782,15 @@ def test_resampler_is_iterable(self):
assert rk == gk
assert_series_equal(rv, gv)
+ def test_resample_quantile(self):
+ # GH 15023
+ s = self.create_series()
+ q = 0.75
+ freq = 'H'
+ result = s.resample(freq).quantile(q)
+ expected = s.resample(freq).agg(lambda x: x.quantile(q))
+ tm.assert_series_equal(result, expected)
+
class TestDatetimeIndex(Base):
_index_factory = lambda x: date_range
| - [x] closes #15023
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22304 | 2018-08-13T07:28:02Z | 2018-08-22T12:27:04Z | 2018-08-22T12:27:03Z | 2018-08-22T12:27:10Z |
DOC fix parenthesis placement in style docs | diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 808b6979b235e..4d68971bf0ef6 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -577,7 +577,7 @@ def apply(self, func, axis=0, subset=None, **kwargs):
-----
The output shape of ``func`` should match the input, i.e. if
``x`` is the input row, column, or table (depending on ``axis``),
- then ``func(x.shape) == x.shape`` should be true.
+ then ``func(x).shape == x.shape`` should be true.
This is similar to ``DataFrame.apply``, except that ``axis=None``
applies the function to the entire DataFrame at once,
| https://api.github.com/repos/pandas-dev/pandas/pulls/22301 | 2018-08-13T05:47:35Z | 2018-08-13T05:57:51Z | 2018-08-13T05:57:51Z | 2018-08-13T09:50:25Z | |
Use a more helpful error message for invalid correlation methods in DataFrame.corr | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 9b70bda82e247..b30b2c885be40 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -468,6 +468,7 @@ Other API Changes
- :meth:`PeriodIndex.tz_convert` and :meth:`PeriodIndex.tz_localize` have been removed (:issue:`21781`)
- :class:`Index` subtraction will attempt to operate element-wise instead of raising ``TypeError`` (:issue:`19369`)
- :class:`pandas.io.formats.style.Styler` supports a ``number-format`` property when using :meth:`~pandas.io.formats.style.Styler.to_excel` (:issue:`22015`)
+- :meth:`DataFrame.corr` and :meth:`Series.corr` now raise a ``ValueError`` along with a helpful error message instead of a ``KeyError`` when supplied with an invalid method (:issue:`22298`)
.. _whatsnew_0240.deprecations:
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 700562386c838..42a6795935cdc 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -6658,7 +6658,7 @@ def corr(self, method='pearson', min_periods=1):
elif method == 'spearman':
correl = libalgos.nancorr_spearman(ensure_float64(mat),
minp=min_periods)
- else:
+ elif method == 'kendall':
if min_periods is None:
min_periods = 1
mat = ensure_float64(mat).T
@@ -6682,6 +6682,10 @@ def corr(self, method='pearson', min_periods=1):
c = corrf(ac, bc)
correl[i, j] = c
correl[j, i] = c
+ else:
+ raise ValueError("method must be either 'pearson', "
+ "'spearman', or 'kendall', '{method}' "
+ "was supplied".format(method=method))
return self._constructor(correl, index=idx, columns=cols)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 4b4fccccda4a0..8bf87e0ede664 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1931,8 +1931,14 @@ def corr(self, other, method='pearson', min_periods=None):
this, other = self.align(other, join='inner', copy=False)
if len(this) == 0:
return np.nan
- return nanops.nancorr(this.values, other.values, method=method,
- min_periods=min_periods)
+
+ if method in ['pearson', 'spearman', 'kendall']:
+ return nanops.nancorr(this.values, other.values, method=method,
+ min_periods=min_periods)
+
+ raise ValueError("method must be either 'pearson', "
+ "'spearman', or 'kendall', '{method}' "
+ "was supplied".format(method=method))
def cov(self, other, min_periods=None):
"""
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index f72cf8cdaafe9..f06c8336373ca 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -130,6 +130,14 @@ def test_corr_cov_independent_index_column(self):
assert result.index is not result.columns
assert result.index.equals(result.columns)
+ def test_corr_invalid_method(self):
+ # GH PR #22298
+ df = pd.DataFrame(np.random.normal(size=(10, 2)))
+ msg = ("method must be either 'pearson', 'spearman', "
+ "or 'kendall'")
+ with tm.assert_raises_regex(ValueError, msg):
+ df.corr(method="____")
+
def test_cov(self):
# min_periods no NAs (corner case)
expected = self.frame.cov()
diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py
index 09e89115e120e..dccc12643a6ad 100644
--- a/pandas/tests/series/test_analytics.py
+++ b/pandas/tests/series/test_analytics.py
@@ -778,6 +778,15 @@ def test_corr_rank(self):
tm.assert_almost_equal(A.corr(B, method='kendall'), kexp)
tm.assert_almost_equal(A.corr(B, method='spearman'), sexp)
+ def test_corr_invalid_method(self):
+ # GH PR #22298
+ s1 = pd.Series(np.random.randn(10))
+ s2 = pd.Series(np.random.randn(10))
+ msg = ("method must be either 'pearson', 'spearman', "
+ "or 'kendall'")
+ with tm.assert_raises_regex(ValueError, msg):
+ s1.corr(s2, method="____")
+
def test_cov(self):
# full overlap
tm.assert_almost_equal(self.ts.cov(self.ts), self.ts.std() ** 2)
| `DataFrame.corr` currently returns a `KeyError` for invalid correlation methods. The proposed change would instead return a `ValueError` with an error message reminding the user of the valid correlation methods.
```
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.normal(size=(10, 3)))
df.corr(method="turkey")
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/22298 | 2018-08-12T23:53:02Z | 2018-08-18T19:48:01Z | 2018-08-18T19:48:01Z | 2018-08-18T19:53:34Z |
BUG: don't mangle NaN-float-values and pd.NaT (GH 22295) | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 649629714c3b1..ff9661bcd37fc 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -720,13 +720,16 @@ Indexing
- Bug where mixed indexes wouldn't allow integers for ``.at`` (:issue:`19860`)
- ``Float64Index.get_loc`` now raises ``KeyError`` when boolean key passed. (:issue:`19087`)
- Bug in :meth:`DataFrame.loc` when indexing with an :class:`IntervalIndex` (:issue:`19977`)
+- :class:`Index` no longer mangles ``None``, ``NaN`` and ``NaT``, i.e. they are treated as three different keys. However, for numeric Index all three are still coerced to a ``NaN`` (:issue:`22332`)
Missing
^^^^^^^
- Bug in :func:`DataFrame.fillna` where a ``ValueError`` would raise when one column contained a ``datetime64[ns, tz]`` dtype (:issue:`15522`)
- Bug in :func:`Series.hasnans` that could be incorrectly cached and return incorrect answers if null elements are introduced after an initial call (:issue:`19700`)
-- :func:`Series.isin` now treats all nans as equal also for ``np.object``-dtype. This behavior is consistent with the behavior for float64 (:issue:`22119`)
+- :func:`Series.isin` now treats all NaN-floats as equal also for `np.object`-dtype. This behavior is consistent with the behavior for float64 (:issue:`22119`)
+- :func:`unique` no longer mangles NaN-floats and the ``NaT``-object for `np.object`-dtype, i.e. ``NaT`` is no longer coerced to a NaN-value and is treated as a different entity. (:issue:`22295`)
+
MultiIndex
^^^^^^^^^^
diff --git a/pandas/_libs/hashtable_class_helper.pxi.in b/pandas/_libs/hashtable_class_helper.pxi.in
index 550cabd5e3192..f294fd141a9f1 100644
--- a/pandas/_libs/hashtable_class_helper.pxi.in
+++ b/pandas/_libs/hashtable_class_helper.pxi.in
@@ -470,7 +470,6 @@ cdef class {{name}}HashTable(HashTable):
int ret = 0
{{dtype}}_t val
khiter_t k
- bint seen_na = 0
{{name}}Vector uniques = {{name}}Vector()
{{name}}VectorData *ud
@@ -479,22 +478,6 @@ cdef class {{name}}HashTable(HashTable):
with nogil:
for i in range(n):
val = values[i]
- {{if float_group}}
- if val == val:
- k = kh_get_{{dtype}}(self.table, val)
- if k == self.table.n_buckets:
- kh_put_{{dtype}}(self.table, val, &ret)
- if needs_resize(ud):
- with gil:
- uniques.resize()
- append_data_{{dtype}}(ud, val)
- elif not seen_na:
- seen_na = 1
- if needs_resize(ud):
- with gil:
- uniques.resize()
- append_data_{{dtype}}(ud, NAN)
- {{else}}
k = kh_get_{{dtype}}(self.table, val)
if k == self.table.n_buckets:
kh_put_{{dtype}}(self.table, val, &ret)
@@ -502,7 +485,6 @@ cdef class {{name}}HashTable(HashTable):
with gil:
uniques.resize()
append_data_{{dtype}}(ud, val)
- {{endif}}
return uniques.to_array()
{{endfor}}
@@ -747,9 +729,6 @@ cdef class StringHashTable(HashTable):
return np.asarray(labels)
-na_sentinel = object
-
-
cdef class PyObjectHashTable(HashTable):
def __init__(self, size_hint=1):
@@ -767,8 +746,7 @@ cdef class PyObjectHashTable(HashTable):
def __contains__(self, object key):
cdef khiter_t k
hash(key)
- if key != key or key is None:
- key = na_sentinel
+
k = kh_get_pymap(self.table, <PyObject*>key)
return k != self.table.n_buckets
@@ -780,8 +758,7 @@ cdef class PyObjectHashTable(HashTable):
cpdef get_item(self, object val):
cdef khiter_t k
- if val != val or val is None:
- val = na_sentinel
+
k = kh_get_pymap(self.table, <PyObject*>val)
if k != self.table.n_buckets:
return self.table.vals[k]
@@ -795,8 +772,7 @@ cdef class PyObjectHashTable(HashTable):
char* buf
hash(key)
- if key != key or key is None:
- key = na_sentinel
+
k = kh_put_pymap(self.table, <PyObject*>key, &ret)
# self.table.keys[k] = key
if kh_exist_pymap(self.table, k):
@@ -814,8 +790,6 @@ cdef class PyObjectHashTable(HashTable):
for i in range(n):
val = values[i]
hash(val)
- if val != val or val is None:
- val = na_sentinel
k = kh_put_pymap(self.table, <PyObject*>val, &ret)
self.table.vals[k] = i
@@ -831,8 +805,6 @@ cdef class PyObjectHashTable(HashTable):
for i in range(n):
val = values[i]
hash(val)
- if val != val or val is None:
- val = na_sentinel
k = kh_get_pymap(self.table, <PyObject*>val)
if k != self.table.n_buckets:
@@ -849,24 +821,14 @@ cdef class PyObjectHashTable(HashTable):
object val
khiter_t k
ObjectVector uniques = ObjectVector()
- bint seen_na = 0
for i in range(n):
val = values[i]
hash(val)
-
- # `val is None` below is exception to prevent mangling of None and
- # other NA values; note however that other NA values (ex: pd.NaT
- # and np.nan) will still get mangled, so many not be a permanent
- # solution; see GH 20866
- if not checknull(val) or val is None:
- k = kh_get_pymap(self.table, <PyObject*>val)
- if k == self.table.n_buckets:
- kh_put_pymap(self.table, <PyObject*>val, &ret)
- uniques.append(val)
- elif not seen_na:
- seen_na = 1
- uniques.append(nan)
+ k = kh_get_pymap(self.table, <PyObject*>val)
+ if k == self.table.n_buckets:
+ kh_put_pymap(self.table, <PyObject*>val, &ret)
+ uniques.append(val)
return uniques.to_array()
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 28c24fc8c0640..621de3ffd4b12 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -286,6 +286,18 @@ def nulls_fixture(request):
nulls_fixture2 = nulls_fixture # Generate cartesian product of nulls_fixture
+@pytest.fixture(params=[None, np.nan, pd.NaT])
+def unique_nulls_fixture(request):
+ """
+ Fixture for each null type in pandas, each null type exactly once
+ """
+ return request.param
+
+
+# Generate cartesian product of unique_nulls_fixture:
+unique_nulls_fixture2 = unique_nulls_fixture
+
+
TIMEZONES = [None, 'UTC', 'US/Eastern', 'Asia/Tokyo', 'dateutil/US/Pacific',
'dateutil/Asia/Singapore']
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index ca381160de0df..487d3975a6219 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -3109,7 +3109,6 @@ def get_loc(self, key, method=None, tolerance=None):
return self._engine.get_loc(key)
except KeyError:
return self._engine.get_loc(self._maybe_cast_indexer(key))
-
indexer = self.get_indexer([key], method=method, tolerance=tolerance)
if indexer.ndim > 1 or indexer.size > 1:
raise TypeError('get_loc requires scalar valued input')
@@ -4475,10 +4474,6 @@ def insert(self, loc, item):
-------
new_index : Index
"""
- if is_scalar(item) and isna(item):
- # GH 18295
- item = self._na_value
-
_self = np.asarray(self)
item = self._coerce_scalar_to_index(item)._ndarray_values
idx = np.concatenate((_self[:loc], item, _self[loc:]))
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index e0627432cbc2e..8d616468a87d9 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -9,6 +9,7 @@
is_bool,
is_bool_dtype,
is_scalar)
+from pandas.core.dtypes.missing import isna
from pandas import compat
from pandas.core import algorithms
@@ -114,6 +115,13 @@ def is_all_dates(self):
"""
return False
+ @Appender(Index.insert.__doc__)
+ def insert(self, loc, item):
+ # treat NA values as nans:
+ if is_scalar(item) and isna(item):
+ item = self._na_value
+ return super(NumericIndex, self).insert(loc, item)
+
_num_index_shared_docs['class_descr'] = """
Immutable ndarray implementing an ordered, sliceable set. The basic object
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 755b3cc7f1dca..eab04419fe939 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -560,8 +560,9 @@ def test_insert(self):
tm.assert_index_equal(Index(['a']), null_index.insert(0, 'a'))
def test_insert_missing(self, nulls_fixture):
- # GH 18295 (test missing)
- expected = Index(['a', np.nan, 'b', 'c'])
+ # GH 22295
+ # test there is no mangling of NA values
+ expected = Index(['a', nulls_fixture, 'b', 'c'])
result = Index(list('abc')).insert(1, nulls_fixture)
tm.assert_index_equal(result, expected)
@@ -1364,6 +1365,21 @@ def test_get_indexer_numeric_index_boolean_target(self):
expected = np.array([-1, -1, -1], dtype=np.intp)
tm.assert_numpy_array_equal(result, expected)
+ def test_get_indexer_with_NA_values(self, unique_nulls_fixture,
+ unique_nulls_fixture2):
+ # GH 22332
+ # check pairwise, that no pair of na values
+ # is mangled
+ if unique_nulls_fixture is unique_nulls_fixture2:
+ return # skip it, values are not unique
+ arr = np.array([unique_nulls_fixture,
+ unique_nulls_fixture2], dtype=np.object)
+ index = pd.Index(arr, dtype=np.object)
+ result = index.get_indexer([unique_nulls_fixture,
+ unique_nulls_fixture2, 'Unknown'])
+ expected = np.array([0, 1, -1], dtype=np.int64)
+ tm.assert_numpy_array_equal(result, expected)
+
@pytest.mark.parametrize("method", [None, 'pad', 'backfill', 'nearest'])
def test_get_loc(self, method):
index = pd.Index([0, 1, 2])
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 64d2e155aa9a9..b2ddbf715b480 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -520,6 +520,36 @@ def test_different_nans(self):
expected = np.array([np.nan])
tm.assert_numpy_array_equal(result, expected)
+ def test_first_nan_kept(self):
+ # GH 22295
+ # create different nans from bit-patterns:
+ bits_for_nan1 = 0xfff8000000000001
+ bits_for_nan2 = 0x7ff8000000000001
+ NAN1 = struct.unpack("d", struct.pack("=Q", bits_for_nan1))[0]
+ NAN2 = struct.unpack("d", struct.pack("=Q", bits_for_nan2))[0]
+ assert NAN1 != NAN1
+ assert NAN2 != NAN2
+ for el_type in [np.float64, np.object]:
+ a = np.array([NAN1, NAN2], dtype=el_type)
+ result = pd.unique(a)
+ assert result.size == 1
+ # use bit patterns to identify which nan was kept:
+ result_nan_bits = struct.unpack("=Q",
+ struct.pack("d", result[0]))[0]
+ assert result_nan_bits == bits_for_nan1
+
+ def test_do_not_mangle_na_values(self, unique_nulls_fixture,
+ unique_nulls_fixture2):
+ # GH 22295
+ if unique_nulls_fixture is unique_nulls_fixture2:
+ return # skip it, values not unique
+ a = np.array([unique_nulls_fixture,
+ unique_nulls_fixture2], dtype=np.object)
+ result = pd.unique(a)
+ assert result.size == 2
+ assert a[0] is unique_nulls_fixture
+ assert a[1] is unique_nulls_fixture2
+
class TestIsin(object):
| it is more or less the clean-up after PR #21904 and PR #22207, the underlying hash-map handles all cases correctly out-of-the box and thus no special handling is needed.
As a collateral, the mangling of NaNs and NaT is fixed.
- [x] closes #22295
- [x] closes #22332
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22296 | 2018-08-12T20:10:14Z | 2018-09-18T12:51:16Z | 2018-09-18T12:51:16Z | 2018-09-19T11:00:36Z |
TST: Add test of DataFrame.xs() with duplicates (#13719) | diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index dcfeab55f94fc..ecd0af9c13d34 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -10,7 +10,8 @@
import numpy as np
from pandas.core.index import Index, MultiIndex
-from pandas import Panel, DataFrame, Series, notna, isna, Timestamp, read_csv
+from pandas import (Panel, DataFrame, Series, notna, isna, Timestamp, concat,
+ read_csv)
from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype
import pandas.core.common as com
@@ -486,6 +487,14 @@ def test_xs_partial(self):
expected = df.loc['foo', 'one']
tm.assert_frame_equal(result, expected)
+ def test_xs_with_duplicates(self):
+ # Issue #13719
+ df_dup = concat([self.frame] * 2)
+ assert not df_dup.index.is_unique
+ expected = concat([self.frame.xs('one', level='second')] * 2)
+ tm.assert_frame_equal(df_dup.xs('one', level='second'), expected)
+ tm.assert_frame_equal(df_dup.xs(['one'], level=['second']), expected)
+
def test_xs_level(self):
result = self.frame.xs('two', level='second')
expected = self.frame[self.frame.index.get_level_values(1) == 'two']
| Added tests of DataFrame.xs() method for multilevel index containing duplicates. The underlying bug reported in #13719 was fixed previously, but was not covered by specific unit tests.
- [ ] closes #13719
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22294 | 2018-08-12T16:35:54Z | 2018-09-15T12:37:25Z | 2018-09-15T12:37:25Z | 2018-09-15T15:42:02Z |
Bug: Logical operator of Series with Index (#22092) | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 649629714c3b1..a8204ffb356a5 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -796,7 +796,8 @@ Other
- :meth:`~pandas.io.formats.style.Styler.background_gradient` now takes a ``text_color_threshold`` parameter to automatically lighten the text color based on the luminance of the background color. This improves readability with dark background colors without the need to limit the background colormap range. (:issue:`21258`)
- Require at least 0.28.2 version of ``cython`` to support read-only memoryviews (:issue:`21688`)
- :meth:`~pandas.io.formats.style.Styler.background_gradient` now also supports tablewise application (in addition to rowwise and columnwise) with ``axis=None`` (:issue:`15204`)
-- :meth:`~pandas.io.formats.style.Styler.bar` now also supports tablewise application (in addition to rowwise and columnwise) with ``axis=None`` and setting clipping range with ``vmin`` and ``vmax``. ``NaN`` values are also handled properly. (:issue:`21548`, :issue:`21526`)
+- :meth:`~pandas.io.formats.style.Styler.bar` now also supports tablewise application (in addition to rowwise and columnwise) with ``axis=None`` and setting clipping range with ``vmin`` and ``vmax`` (:issue:`21548` and :issue:`21526`). ``NaN`` values are also handled properly.
+- Logical operations ``&, |, ^`` between :class:`Series` and :class:`Index` will no longer raise ``ValueError`` (:issue:`22092`)
-
-
-
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index ca9c2528f0aef..a7fc2839ea101 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -1533,7 +1533,7 @@ def na_op(x, y):
if isinstance(y, list):
y = construct_1d_object_array_from_listlike(y)
- if isinstance(y, (np.ndarray, ABCSeries)):
+ if isinstance(y, (np.ndarray, ABCSeries, ABCIndexClass)):
if (is_bool_dtype(x.dtype) and is_bool_dtype(y.dtype)):
result = op(x, y) # when would this be hit?
else:
diff --git a/pandas/tests/series/test_operators.py b/pandas/tests/series/test_operators.py
index 5e5e9c0895ccf..615f0c9247bd8 100644
--- a/pandas/tests/series/test_operators.py
+++ b/pandas/tests/series/test_operators.py
@@ -425,6 +425,30 @@ def test_comparison_flex_alignment_fill(self):
exp = pd.Series([True, True, False, False], index=list('abcd'))
assert_series_equal(left.gt(right, fill_value=0), exp)
+ def test_logical_ops_with_index(self):
+ # GH22092
+ ser = Series([True, True, False, False])
+ idx1 = Index([True, False, True, False])
+ idx2 = Index([1, 0, 1, 0])
+
+ expected = Series([True, False, False, False])
+ result1 = ser & idx1
+ assert_series_equal(result1, expected)
+ result2 = ser & idx2
+ assert_series_equal(result2, expected)
+
+ expected = Series([True, True, True, False])
+ result1 = ser | idx1
+ assert_series_equal(result1, expected)
+ result2 = ser | idx2
+ assert_series_equal(result2, expected)
+
+ expected = Series([False, True, True, False])
+ result1 = ser ^ idx1
+ assert_series_equal(result1, expected)
+ result2 = ser ^ idx2
+ assert_series_equal(result2, expected)
+
def test_ne(self):
ts = Series([3, 4, 5, 6, 7], [3, 4, 5, 6, 7], dtype=float)
expected = [True, True, False, True, True]
| - [ ] closes #22092
- [ ] 1 test added for &, | and ^ logical operator of series
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22293 | 2018-08-12T14:15:20Z | 2018-09-18T13:54:15Z | 2018-09-18T13:54:15Z | 2018-09-18T13:54:15Z |
API: Add CalendarDay ('CD') offset | diff --git a/doc/source/timeseries.rst b/doc/source/timeseries.rst
index f5d1007dfbbbb..5dfac98d069e7 100644
--- a/doc/source/timeseries.rst
+++ b/doc/source/timeseries.rst
@@ -369,7 +369,7 @@ In practice this becomes very cumbersome because we often need a very long
index with a large number of timestamps. If we need timestamps on a regular
frequency, we can use the :func:`date_range` and :func:`bdate_range` functions
to create a ``DatetimeIndex``. The default frequency for ``date_range`` is a
-**calendar day** while the default for ``bdate_range`` is a **business day**:
+**day** while the default for ``bdate_range`` is a **business day**:
.. ipython:: python
@@ -886,6 +886,27 @@ normalized after the function is applied.
hour.apply(pd.Timestamp('2014-01-01 23:00'))
+.. _timeseries.dayvscalendarday:
+
+Day vs. CalendarDay
+~~~~~~~~~~~~~~~~~~~
+
+:class:`Day` (``'D'``) is a timedelta-like offset that respects absolute time
+arithmetic and is an alias for 24 :class:`Hour`. This offset is the default
+argument to many pandas time related function like :func:`date_range` and :func:`timedelta_range`.
+
+:class:`CalendarDay` (``'CD'``) is a relativedelta-like offset that respects
+calendar time arithmetic. :class:`CalendarDay` is useful preserving calendar day
+semantics with date times with have day light savings transitions, i.e. :class:`CalendarDay`
+will preserve the hour before the day light savings transition.
+
+.. ipython:: python
+
+ ts = pd.Timestamp('2016-10-30 00:00:00', tz='Europe/Helsinki')
+ ts + pd.offsets.Day(1)
+ ts + pd.offsets.CalendarDay(1)
+
+
Parametric Offsets
~~~~~~~~~~~~~~~~~~
@@ -1176,7 +1197,8 @@ frequencies. We will refer to these aliases as *offset aliases*.
"B", "business day frequency"
"C", "custom business day frequency"
- "D", "calendar day frequency"
+ "D", "day frequency"
+ "CD", "calendar day frequency"
"W", "weekly frequency"
"M", "month end frequency"
"SM", "semi-month end frequency (15th and end of month)"
diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 1979bde796452..4df951ca2c3aa 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -285,6 +285,46 @@ that the dates have been converted to UTC
.. ipython:: python
pd.to_datetime(["2015-11-18 15:30:00+05:30", "2015-11-18 16:30:00+06:30"], utc=True)
+.. _whatsnew_0240.api_breaking.calendarday:
+
+CalendarDay Offset
+^^^^^^^^^^^^^^^^^^
+
+:class:`Day` and associated frequency alias ``'D'`` were documented to represent
+a calendar day; however, arithmetic and operations with :class:`Day` sometimes
+respected absolute time instead (i.e. ``Day(n)`` and acted identically to ``Timedelta(days=n)``).
+
+*Previous Behavior*:
+
+.. code-block:: ipython
+
+
+ In [2]: ts = pd.Timestamp('2016-10-30 00:00:00', tz='Europe/Helsinki')
+
+ # Respects calendar arithmetic
+ In [3]: pd.date_range(start=ts, freq='D', periods=3)
+ Out[3]:
+ DatetimeIndex(['2016-10-30 00:00:00+03:00', '2016-10-31 00:00:00+02:00',
+ '2016-11-01 00:00:00+02:00'],
+ dtype='datetime64[ns, Europe/Helsinki]', freq='D')
+
+ # Respects absolute arithmetic
+ In [4]: ts + pd.tseries.frequencies.to_offset('D')
+ Out[4]: Timestamp('2016-10-30 23:00:00+0200', tz='Europe/Helsinki')
+
+:class:`CalendarDay` and associated frequency alias ``'CD'`` are now available
+and respect calendar day arithmetic while :class:`Day` and frequency alias ``'D'``
+will now respect absolute time (:issue:`22274`, :issue:`20596`, :issue:`16980`, :issue:`8774`)
+See the :ref:`documentation here <timeseries.dayvscalendarday>` for more information.
+
+Addition with :class:`CalendarDay` across a daylight savings time transition:
+
+.. ipython:: python
+
+ ts = pd.Timestamp('2016-10-30 00:00:00', tz='Europe/Helsinki')
+ ts + pd.offsets.Day(1)
+ ts + pd.offsets.CalendarDay(1)
+
.. _whatsnew_0240.api_breaking.period_end_time:
Time values in ``dt.end_time`` and ``to_timestamp(how='end')``
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 484eb430c82b1..466cfb296094c 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -32,7 +32,7 @@
from pandas.core import ops
from pandas.tseries.frequencies import to_offset
-from pandas.tseries.offsets import Tick, Day, generate_range
+from pandas.tseries.offsets import Tick, generate_range
from pandas.core.arrays import datetimelike as dtl
@@ -239,56 +239,33 @@ def _generate_range(cls, start, end, periods, freq, tz=None,
start, end, _normalized = _maybe_normalize_endpoints(start, end,
normalize)
- tz, inferred_tz = _infer_tz_from_endpoints(start, end, tz)
-
- if hasattr(freq, 'delta') and freq != Day():
- # sub-Day Tick
- if inferred_tz is None and tz is not None:
- # naive dates
- if start is not None and start.tz is None:
- start = start.tz_localize(tz, ambiguous=False)
-
- if end is not None and end.tz is None:
- end = end.tz_localize(tz, ambiguous=False)
-
- if start and end:
- if start.tz is None and end.tz is not None:
- start = start.tz_localize(end.tz, ambiguous=False)
-
- if end.tz is None and start.tz is not None:
- end = end.tz_localize(start.tz, ambiguous=False)
-
+ tz, _ = _infer_tz_from_endpoints(start, end, tz)
+
+ if tz is not None:
+ # Localize the start and end arguments
+ start = _maybe_localize_point(
+ start, getattr(start, 'tz', None), start, freq, tz
+ )
+ end = _maybe_localize_point(
+ end, getattr(end, 'tz', None), end, freq, tz
+ )
+ if start and end:
+ # Make sure start and end have the same tz
+ start = _maybe_localize_point(
+ start, start.tz, end.tz, freq, tz
+ )
+ end = _maybe_localize_point(
+ end, end.tz, start.tz, freq, tz
+ )
+ if freq is not None:
if cls._use_cached_range(freq, _normalized, start, end):
+ # Currently always False; never hit
+ # Should be reimplemented as apart of GH 17914
index = cls._cached_range(start, end, periods=periods,
freq=freq)
else:
index = _generate_regular_range(cls, start, end, periods, freq)
- else:
-
- if tz is not None:
- # naive dates
- if start is not None and start.tz is not None:
- start = start.replace(tzinfo=None)
-
- if end is not None and end.tz is not None:
- end = end.replace(tzinfo=None)
-
- if start and end:
- if start.tz is None and end.tz is not None:
- end = end.replace(tzinfo=None)
-
- if end.tz is None and start.tz is not None:
- start = start.replace(tzinfo=None)
-
- if freq is not None:
- if cls._use_cached_range(freq, _normalized, start, end):
- index = cls._cached_range(start, end, periods=periods,
- freq=freq)
- else:
- index = _generate_regular_range(cls, start, end,
- periods, freq)
-
if tz is not None and getattr(index, 'tz', None) is None:
arr = conversion.tz_localize_to_utc(
ensure_int64(index.values),
@@ -302,12 +279,12 @@ def _generate_range(cls, start, end, periods, freq, tz=None,
start = start.tz_localize(tz).asm8
if end is not None:
end = end.tz_localize(tz).asm8
- else:
- # Create a linearly spaced date_range in local time
- start = start.tz_localize(tz)
- end = end.tz_localize(tz)
- arr = np.linspace(start.value, end.value, periods)
- index = cls._simple_new(arr.astype('M8[ns]'), freq=None, tz=tz)
+ else:
+ # Create a linearly spaced date_range in local time
+ arr = np.linspace(start.value, end.value, periods)
+ index = cls._simple_new(
+ arr.astype('M8[ns]', copy=False), freq=None, tz=tz
+ )
if not left_closed and len(index) and index[0] == start:
index = index[1:]
@@ -1256,10 +1233,10 @@ def _generate_regular_range(cls, start, end, periods, freq):
data = cls._simple_new(data.view(_NS_DTYPE), None, tz=tz)
else:
tz = None
+ # start and end should have the same timezone by this point
if isinstance(start, Timestamp):
tz = start.tz
-
- if isinstance(end, Timestamp):
+ elif isinstance(end, Timestamp):
tz = end.tz
xdr = generate_range(start=start, end=end,
@@ -1330,3 +1307,32 @@ def _maybe_normalize_endpoints(start, end, normalize):
_normalized = _normalized and end.time() == _midnight
return start, end, _normalized
+
+
+def _maybe_localize_point(ts, is_none, is_not_none, freq, tz):
+ """
+ Localize a start or end Timestamp to the timezone of the corresponding
+ start or end Timestamp
+
+ Parameters
+ ----------
+ ts : start or end Timestamp to potentially localize
+ is_none : argument that should be None
+ is_not_none : argument that should not be None
+ freq : Tick, DateOffset, or None
+ tz : str, timezone object or None
+
+ Returns
+ -------
+ ts : Timestamp
+ """
+ # Make sure start and end are timezone localized if:
+ # 1) freq = a Timedelta-like frequency (Tick)
+ # 2) freq = None i.e. generating a linspaced range
+ if isinstance(freq, Tick) or freq is None:
+ localize_args = {'tz': tz, 'ambiguous': False}
+ else:
+ localize_args = {'tz': None}
+ if is_none is None and is_not_none is not None:
+ ts = ts.tz_localize(**localize_args)
+ return ts
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 019aad4941d26..629660c899a3f 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -385,7 +385,10 @@ def _generate_range(cls, start, end, periods, name=None, freq=None,
@classmethod
def _use_cached_range(cls, freq, _normalized, start, end):
- return _use_cached_range(freq, _normalized, start, end)
+ # Note: This always returns False
+ return (freq._should_cache() and
+ not (freq._normalize_cache and not _normalized) and
+ _naive_in_cache_range(start, end))
def _convert_for_op(self, value):
""" Convert value to be insertable to ndarray """
@@ -1580,7 +1583,7 @@ def date_range(start=None, end=None, periods=None, freq=None, tz=None,
Right bound for generating dates.
periods : integer, optional
Number of periods to generate.
- freq : str or DateOffset, default 'D' (calendar daily)
+ freq : str or DateOffset, default 'D'
Frequency strings can have multiples, e.g. '5H'. See
:ref:`here <timeseries.offset_aliases>` for a list of
frequency aliases.
@@ -1861,17 +1864,7 @@ def _naive_in_cache_range(start, end):
else:
if start.tzinfo is not None or end.tzinfo is not None:
return False
- return _in_range(start, end, _CACHE_START, _CACHE_END)
-
-
-def _in_range(start, end, rng_start, rng_end):
- return start > rng_start and end < rng_end
-
-
-def _use_cached_range(freq, _normalized, start, end):
- return (freq._should_cache() and
- not (freq._normalize_cache and not _normalized) and
- _naive_in_cache_range(start, end))
+ return start > _CACHE_START and end < _CACHE_END
def _time_to_micros(time):
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 364eea8fb8a3a..4b125580bd7e0 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -1052,7 +1052,7 @@ def interval_range(start=None, end=None, periods=None, freq=None,
freq : numeric, string, or DateOffset, default None
The length of each interval. Must be consistent with the type of start
and end, e.g. 2 for numeric, or '5H' for datetime-like. Default is 1
- for numeric and 'D' (calendar daily) for datetime-like.
+ for numeric and 'D' for datetime-like.
name : string, default None
Name of the resulting IntervalIndex
closed : {'left', 'right', 'both', 'neither'}, default 'right'
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 32aa89010b206..3a68c6c26a974 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -840,7 +840,7 @@ def period_range(start=None, end=None, periods=None, freq='D', name=None):
Right bound for generating periods
periods : integer, default None
Number of periods to generate
- freq : string or DateOffset, default 'D' (calendar daily)
+ freq : string or DateOffset, default 'D'
Frequency alias
name : string, default None
Name of the resulting PeriodIndex
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 9f14d4cfd5863..063b578e512de 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -737,7 +737,7 @@ def timedelta_range(start=None, end=None, periods=None, freq=None,
Right bound for generating timedeltas
periods : integer, default None
Number of periods to generate
- freq : string or DateOffset, default 'D' (calendar daily)
+ freq : string or DateOffset, default 'D'
Frequency strings can have multiples, e.g. '5H'
name : string, default None
Name of the resulting TimedeltaIndex
diff --git a/pandas/tests/indexes/datetimes/test_astype.py b/pandas/tests/indexes/datetimes/test_astype.py
index 64b8f48f6a4e1..78b669de95598 100644
--- a/pandas/tests/indexes/datetimes/test_astype.py
+++ b/pandas/tests/indexes/datetimes/test_astype.py
@@ -259,88 +259,18 @@ def test_to_period_microsecond(self):
assert period[0] == Period('2007-01-01 10:11:12.123456Z', 'U')
assert period[1] == Period('2007-01-01 10:11:13.789123Z', 'U')
- def test_to_period_tz_pytz(self):
- from pytz import utc as UTC
-
- xp = date_range('1/1/2000', '4/1/2000').to_period()
-
- ts = date_range('1/1/2000', '4/1/2000', tz='US/Eastern')
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- ts = date_range('1/1/2000', '4/1/2000', tz=UTC)
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- ts = date_range('1/1/2000', '4/1/2000', tz=tzlocal())
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- def test_to_period_tz_explicit_pytz(self):
- xp = date_range('1/1/2000', '4/1/2000').to_period()
-
- ts = date_range('1/1/2000', '4/1/2000', tz=pytz.timezone('US/Eastern'))
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- ts = date_range('1/1/2000', '4/1/2000', tz=pytz.utc)
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- ts = date_range('1/1/2000', '4/1/2000', tz=tzlocal())
-
+ @pytest.mark.parametrize('tz', [
+ 'US/Eastern', pytz.utc, tzlocal(), 'dateutil/US/Eastern',
+ dateutil.tz.tzutc()])
+ def test_to_period_tz(self, tz):
+ ts = date_range('1/1/2000', '2/1/2000', tz=tz)
result = ts.to_period()[0]
expected = ts[0].to_period()
-
assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- def test_to_period_tz_dateutil(self):
- xp = date_range('1/1/2000', '4/1/2000').to_period()
- ts = date_range('1/1/2000', '4/1/2000', tz='dateutil/US/Eastern')
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- ts = date_range('1/1/2000', '4/1/2000', tz=dateutil.tz.tzutc())
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
-
- ts = date_range('1/1/2000', '4/1/2000', tz=tzlocal())
-
- result = ts.to_period()[0]
- expected = ts[0].to_period()
-
- assert result == expected
- tm.assert_index_equal(ts.to_period(), xp)
+ expected = date_range('1/1/2000', '2/1/2000').to_period()
+ result = ts.to_period()
+ tm.assert_index_equal(result, expected)
def test_to_period_nofreq(self):
idx = DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-04'])
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 22fb8b2942bea..e0caf671fc390 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -336,28 +336,28 @@ def test_range_tz_pytz(self):
assert dr[0] == start
assert dr[2] == end
- def test_range_tz_dst_straddle_pytz(self):
- tz = timezone('US/Eastern')
- dates = [(tz.localize(datetime(2014, 3, 6)),
- tz.localize(datetime(2014, 3, 12))),
- (tz.localize(datetime(2013, 11, 1)),
- tz.localize(datetime(2013, 11, 6)))]
- for (start, end) in dates:
- dr = date_range(start, end, freq='D')
- assert dr[0] == start
- assert dr[-1] == end
- assert np.all(dr.hour == 0)
-
- dr = date_range(start, end, freq='D', tz='US/Eastern')
- assert dr[0] == start
- assert dr[-1] == end
- assert np.all(dr.hour == 0)
-
- dr = date_range(start.replace(tzinfo=None), end.replace(
- tzinfo=None), freq='D', tz='US/Eastern')
- assert dr[0] == start
- assert dr[-1] == end
- assert np.all(dr.hour == 0)
+ @pytest.mark.parametrize('start, end', [
+ [Timestamp(datetime(2014, 3, 6), tz='US/Eastern'),
+ Timestamp(datetime(2014, 3, 12), tz='US/Eastern')],
+ [Timestamp(datetime(2013, 11, 1), tz='US/Eastern'),
+ Timestamp(datetime(2013, 11, 6), tz='US/Eastern')]
+ ])
+ def test_range_tz_dst_straddle_pytz(self, start, end):
+ dr = date_range(start, end, freq='CD')
+ assert dr[0] == start
+ assert dr[-1] == end
+ assert np.all(dr.hour == 0)
+
+ dr = date_range(start, end, freq='CD', tz='US/Eastern')
+ assert dr[0] == start
+ assert dr[-1] == end
+ assert np.all(dr.hour == 0)
+
+ dr = date_range(start.replace(tzinfo=None), end.replace(
+ tzinfo=None), freq='CD', tz='US/Eastern')
+ assert dr[0] == start
+ assert dr[-1] == end
+ assert np.all(dr.hour == 0)
def test_range_tz_dateutil(self):
# see gh-2906
@@ -578,6 +578,14 @@ def test_mismatching_tz_raises_err(self, start, end):
with pytest.raises(TypeError):
pd.DatetimeIndex(start, end, freq=BDay())
+ def test_CalendarDay_range_with_dst_crossing(self):
+ # GH 20596
+ result = date_range('2018-10-23', '2018-11-06', freq='7CD',
+ tz='Europe/Paris')
+ expected = date_range('2018-10-23', '2018-11-06',
+ freq=pd.DateOffset(days=7), tz='Europe/Paris')
+ tm.assert_index_equal(result, expected)
+
class TestBusinessDateRange(object):
@@ -772,7 +780,8 @@ def test_cdaterange_weekmask_and_holidays(self):
holidays=['2013-05-01'])
@pytest.mark.parametrize('freq', [freq for freq in prefix_mapping
- if freq.startswith('C')])
+ if freq.startswith('C')
+ and freq != 'CD']) # CalendarDay
def test_all_custom_freq(self, freq):
# should not raise
bdate_range(START, END, freq=freq, weekmask='Mon Wed Fri',
diff --git a/pandas/tests/indexes/datetimes/test_timezones.py b/pandas/tests/indexes/datetimes/test_timezones.py
index 95531b2d7a7ae..dc01f7ccbd496 100644
--- a/pandas/tests/indexes/datetimes/test_timezones.py
+++ b/pandas/tests/indexes/datetimes/test_timezones.py
@@ -429,24 +429,24 @@ def test_dti_tz_localize_utc_conversion(self, tz):
with pytest.raises(pytz.NonExistentTimeError):
rng.tz_localize(tz)
- def test_dti_tz_localize_roundtrip(self, tz_aware_fixture):
+ @pytest.mark.parametrize('idx', [
+ date_range(start='2014-01-01', end='2014-12-31', freq='M'),
+ date_range(start='2014-01-01', end='2014-12-31', freq='CD'),
+ date_range(start='2014-01-01', end='2014-03-01', freq='H'),
+ date_range(start='2014-08-01', end='2014-10-31', freq='T')
+ ])
+ def test_dti_tz_localize_roundtrip(self, tz_aware_fixture, idx):
tz = tz_aware_fixture
+ localized = idx.tz_localize(tz)
+ expected = date_range(start=idx[0], end=idx[-1], freq=idx.freq,
+ tz=tz)
+ tm.assert_index_equal(localized, expected)
+ with pytest.raises(TypeError):
+ localized.tz_localize(tz)
- idx1 = date_range(start='2014-01-01', end='2014-12-31', freq='M')
- idx2 = date_range(start='2014-01-01', end='2014-12-31', freq='D')
- idx3 = date_range(start='2014-01-01', end='2014-03-01', freq='H')
- idx4 = date_range(start='2014-08-01', end='2014-10-31', freq='T')
- for idx in [idx1, idx2, idx3, idx4]:
- localized = idx.tz_localize(tz)
- expected = date_range(start=idx[0], end=idx[-1], freq=idx.freq,
- tz=tz)
- tm.assert_index_equal(localized, expected)
- with pytest.raises(TypeError):
- localized.tz_localize(tz)
-
- reset = localized.tz_localize(None)
- tm.assert_index_equal(reset, idx)
- assert reset.tzinfo is None
+ reset = localized.tz_localize(None)
+ tm.assert_index_equal(reset, idx)
+ assert reset.tzinfo is None
def test_dti_tz_localize_naive(self):
rng = date_range('1/1/2011', periods=100, freq='H')
@@ -1033,7 +1033,9 @@ def test_date_range_span_dst_transition(self, tzstr):
assert (dr.hour == 0).all()
dr = date_range('2012-11-02', periods=10, tz=tzstr)
- assert (dr.hour == 0).all()
+ result = dr.hour
+ expected = Index([0, 0, 0, 23, 23, 23, 23, 23, 23, 23])
+ tm.assert_index_equal(result, expected)
@pytest.mark.parametrize('tzstr', ['US/Eastern', 'dateutil/US/Eastern'])
def test_date_range_timezone_str_argument(self, tzstr):
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta_range.py b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
index 87dff74cd04d7..1d10e63363cc8 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta_range.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta_range.py
@@ -48,6 +48,10 @@ def test_timedelta_range(self):
result = df.loc['0s':, :]
tm.assert_frame_equal(expected, result)
+ with pytest.raises(ValueError):
+ # GH 22274: CalendarDay is a relative time measurement
+ timedelta_range('1day', freq='CD', periods=2)
+
@pytest.mark.parametrize('periods, freq', [
(3, '2D'), (5, 'D'), (6, '19H12T'), (7, '16H'), (9, '12H')])
def test_linspace_behavior(self, periods, freq):
diff --git a/pandas/tests/series/test_timezones.py b/pandas/tests/series/test_timezones.py
index d59e7fd445f17..472b2c5644fa5 100644
--- a/pandas/tests/series/test_timezones.py
+++ b/pandas/tests/series/test_timezones.py
@@ -302,7 +302,7 @@ def test_getitem_pydatetime_tz(self, tzstr):
def test_series_truncate_datetimeindex_tz(self):
# GH 9243
- idx = date_range('4/1/2005', '4/30/2005', freq='D', tz='US/Pacific')
+ idx = date_range('4/1/2005', '4/30/2005', freq='CD', tz='US/Pacific')
s = Series(range(len(idx)), index=idx)
result = s.truncate(datetime(2005, 4, 2), datetime(2005, 4, 4))
expected = Series([1, 2, 3], index=idx[1:4])
diff --git a/pandas/tests/test_resample.py b/pandas/tests/test_resample.py
index 530a683c02f9d..669fa9742a705 100644
--- a/pandas/tests/test_resample.py
+++ b/pandas/tests/test_resample.py
@@ -2038,7 +2038,7 @@ def test_resample_dst_anchor(self):
# 5172
dti = DatetimeIndex([datetime(2012, 11, 4, 23)], tz='US/Eastern')
df = DataFrame([5], index=dti)
- assert_frame_equal(df.resample(rule='D').sum(),
+ assert_frame_equal(df.resample(rule='CD').sum(),
DataFrame([5], index=df.index.normalize()))
df.resample(rule='MS').sum()
assert_frame_equal(
@@ -2092,14 +2092,14 @@ def test_resample_dst_anchor(self):
df_daily = df['10/26/2013':'10/29/2013']
assert_frame_equal(
- df_daily.resample("D").agg({"a": "min", "b": "max", "c": "count"})
+ df_daily.resample("CD").agg({"a": "min", "b": "max", "c": "count"})
[["a", "b", "c"]],
DataFrame({"a": [1248, 1296, 1346, 1394],
"b": [1295, 1345, 1393, 1441],
"c": [48, 50, 48, 48]},
index=date_range('10/26/2013', '10/29/2013',
- freq='D', tz='Europe/Paris')),
- 'D Frequency')
+ freq='CD', tz='Europe/Paris')),
+ 'CD Frequency')
def test_downsample_across_dst(self):
# GH 8531
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index e95f1ba11ad5c..f9f5fc2484bda 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -2,6 +2,7 @@
from datetime import date, datetime, timedelta
import pytest
+import pytz
from pandas.compat import range
from pandas import compat
@@ -16,6 +17,7 @@
from pandas.tseries.frequencies import _offset_map, get_offset
from pandas.core.indexes.datetimes import (
_to_m8, DatetimeIndex, _daterange_cache)
+from pandas.core.indexes.timedeltas import TimedeltaIndex
import pandas._libs.tslibs.offsets as liboffsets
from pandas._libs.tslibs.offsets import CacheableOffset
from pandas.tseries.offsets import (BDay, CDay, BQuarterEnd, BMonthEnd,
@@ -28,11 +30,12 @@
YearEnd, Day,
QuarterEnd, BusinessMonthEnd, FY5253,
Nano, Easter, FY5253Quarter,
- LastWeekOfMonth, Tick)
+ LastWeekOfMonth, Tick, CalendarDay)
import pandas.tseries.offsets as offsets
from pandas.io.pickle import read_pickle
from pandas._libs.tslibs import timezones
from pandas._libs.tslib import NaT, Timestamp
+from pandas._libs.tslibs.timedeltas import Timedelta
import pandas._libs.tslib as tslib
import pandas.util.testing as tm
from pandas.tseries.holiday import USFederalHolidayCalendar
@@ -192,6 +195,7 @@ class TestCommon(Base):
# are applied to 2011/01/01 09:00 (Saturday)
# used for .apply and .rollforward
expecteds = {'Day': Timestamp('2011-01-02 09:00:00'),
+ 'CalendarDay': Timestamp('2011-01-02 09:00:00'),
'DateOffset': Timestamp('2011-01-02 09:00:00'),
'BusinessDay': Timestamp('2011-01-03 09:00:00'),
'CustomBusinessDay': Timestamp('2011-01-03 09:00:00'),
@@ -360,7 +364,7 @@ def test_rollforward(self, offset_types):
# result will not be changed if the target is on the offset
no_changes = ['Day', 'MonthBegin', 'SemiMonthBegin', 'YearBegin',
'Week', 'Hour', 'Minute', 'Second', 'Milli', 'Micro',
- 'Nano', 'DateOffset']
+ 'Nano', 'DateOffset', 'CalendarDay']
for n in no_changes:
expecteds[n] = Timestamp('2011/01/01 09:00')
@@ -373,6 +377,7 @@ def test_rollforward(self, offset_types):
norm_expected[k] = Timestamp(norm_expected[k].date())
normalized = {'Day': Timestamp('2011-01-02 00:00:00'),
+ 'CalendarDay': Timestamp('2011-01-02 00:00:00'),
'DateOffset': Timestamp('2011-01-02 00:00:00'),
'MonthBegin': Timestamp('2011-02-01 00:00:00'),
'SemiMonthBegin': Timestamp('2011-01-15 00:00:00'),
@@ -425,7 +430,7 @@ def test_rollback(self, offset_types):
# result will not be changed if the target is on the offset
for n in ['Day', 'MonthBegin', 'SemiMonthBegin', 'YearBegin', 'Week',
'Hour', 'Minute', 'Second', 'Milli', 'Micro', 'Nano',
- 'DateOffset']:
+ 'DateOffset', 'CalendarDay']:
expecteds[n] = Timestamp('2011/01/01 09:00')
# but be changed when normalize=True
@@ -434,6 +439,7 @@ def test_rollback(self, offset_types):
norm_expected[k] = Timestamp(norm_expected[k].date())
normalized = {'Day': Timestamp('2010-12-31 00:00:00'),
+ 'CalendarDay': Timestamp('2010-12-31 00:00:00'),
'DateOffset': Timestamp('2010-12-31 00:00:00'),
'MonthBegin': Timestamp('2010-12-01 00:00:00'),
'SemiMonthBegin': Timestamp('2010-12-15 00:00:00'),
@@ -3174,3 +3180,71 @@ def test_last_week_of_month_on_offset():
slow = (ts + offset) - offset == ts
fast = offset.onOffset(ts)
assert fast == slow
+
+
+class TestCalendarDay(object):
+
+ def test_add_across_dst_scalar(self):
+ # GH 22274
+ ts = Timestamp('2016-10-30 00:00:00+0300', tz='Europe/Helsinki')
+ expected = Timestamp('2016-10-31 00:00:00+0200', tz='Europe/Helsinki')
+ result = ts + CalendarDay(1)
+ assert result == expected
+
+ result = result - CalendarDay(1)
+ assert result == ts
+
+ @pytest.mark.parametrize('box', [DatetimeIndex, Series])
+ def test_add_across_dst_array(self, box):
+ # GH 22274
+ ts = Timestamp('2016-10-30 00:00:00+0300', tz='Europe/Helsinki')
+ expected = Timestamp('2016-10-31 00:00:00+0200', tz='Europe/Helsinki')
+ arr = box([ts])
+ expected = box([expected])
+ result = arr + CalendarDay(1)
+ tm.assert_equal(result, expected)
+
+ result = result - CalendarDay(1)
+ tm.assert_equal(arr, result)
+
+ @pytest.mark.parametrize('arg', [
+ Timestamp("2018-11-03 01:00:00", tz='US/Pacific'),
+ DatetimeIndex([Timestamp("2018-11-03 01:00:00", tz='US/Pacific')])
+ ])
+ def test_raises_AmbiguousTimeError(self, arg):
+ # GH 22274
+ with pytest.raises(pytz.AmbiguousTimeError):
+ arg + CalendarDay(1)
+
+ @pytest.mark.parametrize('arg', [
+ Timestamp("2019-03-09 02:00:00", tz='US/Pacific'),
+ DatetimeIndex([Timestamp("2019-03-09 02:00:00", tz='US/Pacific')])
+ ])
+ def test_raises_NonExistentTimeError(self, arg):
+ # GH 22274
+ with pytest.raises(pytz.NonExistentTimeError):
+ arg + CalendarDay(1)
+
+ @pytest.mark.parametrize('arg, exp', [
+ [1, 2],
+ [-1, 0],
+ [-5, -4]
+ ])
+ def test_arithmetic(self, arg, exp):
+ # GH 22274
+ result = CalendarDay(1) + CalendarDay(arg)
+ expected = CalendarDay(exp)
+ assert result == expected
+
+ @pytest.mark.parametrize('arg', [
+ timedelta(1),
+ Day(1),
+ Timedelta(1),
+ TimedeltaIndex([timedelta(1)])
+ ])
+ def test_invalid_arithmetic(self, arg):
+ # GH 22274
+ # CalendarDay (relative time) cannot be added to Timedelta-like objects
+ # (absolute time)
+ with pytest.raises(TypeError):
+ CalendarDay(1) + arg
diff --git a/pandas/tests/tseries/offsets/test_ticks.py b/pandas/tests/tseries/offsets/test_ticks.py
index 914d61a18ee11..369c0971f1e9a 100644
--- a/pandas/tests/tseries/offsets/test_ticks.py
+++ b/pandas/tests/tseries/offsets/test_ticks.py
@@ -10,7 +10,8 @@
from pandas import Timedelta, Timestamp
from pandas.tseries import offsets
-from pandas.tseries.offsets import Hour, Minute, Second, Milli, Micro, Nano
+from pandas.tseries.offsets import (Day, Hour, Minute, Second, Milli, Micro,
+ Nano)
from .common import assert_offset_equal
@@ -211,6 +212,13 @@ def test_Nanosecond():
assert Micro(5) + Nano(1) == Nano(5001)
+def test_Day_equals_24_Hours():
+ ts = Timestamp('2016-10-30 00:00:00+0300', tz='Europe/Helsinki')
+ result = ts + Day(1)
+ expected = ts + Hour(24)
+ assert result == expected
+
+
@pytest.mark.parametrize('kls, expected',
[(Hour, Timedelta(hours=5)),
(Minute, Timedelta(hours=2, minutes=3)),
diff --git a/pandas/tseries/offsets.py b/pandas/tseries/offsets.py
index c74b7454a67e3..d4a8211c17b87 100644
--- a/pandas/tseries/offsets.py
+++ b/pandas/tseries/offsets.py
@@ -41,7 +41,7 @@
'LastWeekOfMonth', 'FY5253Quarter', 'FY5253',
'Week', 'WeekOfMonth', 'Easter',
'Hour', 'Minute', 'Second', 'Milli', 'Micro', 'Nano',
- 'DateOffset']
+ 'DateOffset', 'CalendarDay']
# convert to/from datetime/timestamp to allow invalid Timestamp ranges to
# pass thru
@@ -2123,6 +2123,54 @@ def onOffset(self, dt):
return False
return date(dt.year, dt.month, dt.day) == easter(dt.year)
+
+class CalendarDay(SingleConstructorOffset):
+ """
+ Calendar day offset. Respects calendar arithmetic as opposed to Day which
+ respects absolute time.
+ """
+ _adjust_dst = True
+ _inc = Timedelta(days=1)
+ _prefix = 'CD'
+ _attributes = frozenset(['n', 'normalize'])
+
+ def __init__(self, n=1, normalize=False):
+ BaseOffset.__init__(self, n, normalize)
+
+ @apply_wraps
+ def apply(self, other):
+ """
+ Apply scalar arithmetic with CalendarDay offset. Incoming datetime
+ objects can be tz-aware or naive.
+ """
+ if type(other) == type(self):
+ # Add other CalendarDays
+ return type(self)(self.n + other.n, normalize=self.normalize)
+ tzinfo = getattr(other, 'tzinfo', None)
+ if tzinfo is not None:
+ other = other.replace(tzinfo=None)
+
+ other = other + self.n * self._inc
+
+ if tzinfo is not None:
+ # This can raise a AmbiguousTimeError or NonExistentTimeError
+ other = conversion.localize_pydatetime(other, tzinfo)
+
+ try:
+ return as_timestamp(other)
+ except TypeError:
+ raise TypeError("Cannot perform arithmetic between {other} and "
+ "CalendarDay".format(other=type(other)))
+
+ @apply_index_wraps
+ def apply_index(self, i):
+ """
+ Apply the CalendarDay offset to a DatetimeIndex. Incoming DatetimeIndex
+ objects are assumed to be tz_naive
+ """
+ return i + self.n * self._inc
+
+
# ---------------------------------------------------------------------
# Ticks
@@ -2310,7 +2358,8 @@ def generate_range(start=None, end=None, periods=None,
----------
start : datetime (default None)
end : datetime (default None)
- periods : int, optional
+ periods : int, (default None)
+ offset : DateOffset, (default BDay())
time_rule : (legacy) name of DateOffset object to be used, optional
Corresponds with names expected by tseries.frequencies.get_offset
@@ -2406,4 +2455,5 @@ def generate_range(start=None, end=None, periods=None,
WeekOfMonth, # 'WOM'
FY5253,
FY5253Quarter,
+ CalendarDay # 'CD'
]}
| - [x] closes #22274
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Adds `CalendarDay` and `'CD'` offset and alias respectively and changes `Day` (`'D'`) in `date_range` to respect calendar day.
With regards to `CalendarDay` added tests for:
- `CalendarDay` arithmetic with itself, datetimes, and timedeltas (which should raise)
- `'CD'` with use in `date_range` and `timedelta_range` (which should raise)
- resampling with `'CD'`
Also refactored `_generate_range ` for `date_range` since we no longer have to check for `Day`
| https://api.github.com/repos/pandas-dev/pandas/pulls/22288 | 2018-08-12T00:26:27Z | 2018-09-07T12:08:14Z | 2018-09-07T12:08:14Z | 2022-05-19T03:03:08Z |
[CLN] More Misc Cleanups in _libs | diff --git a/pandas/_libs/algos.pxd b/pandas/_libs/algos.pxd
index a535872ff7279..0888cf3c85f2f 100644
--- a/pandas/_libs/algos.pxd
+++ b/pandas/_libs/algos.pxd
@@ -1,10 +1,12 @@
from util cimport numeric
-from numpy cimport float64_t, double_t
+
cpdef numeric kth_smallest(numeric[:] a, Py_ssize_t k) nogil
+
cdef inline Py_ssize_t swap(numeric *a, numeric *b) nogil:
- cdef numeric t
+ cdef:
+ numeric t
# cython doesn't allow pointer dereference so use array syntax
t = a[0]
@@ -12,6 +14,7 @@ cdef inline Py_ssize_t swap(numeric *a, numeric *b) nogil:
b[0] = t
return 0
+
cdef enum TiebreakEnumType:
TIEBREAK_AVERAGE
TIEBREAK_MIN,
diff --git a/pandas/_libs/algos.pyx b/pandas/_libs/algos.pyx
index 124792638e3df..30279615758e0 100644
--- a/pandas/_libs/algos.pyx
+++ b/pandas/_libs/algos.pyx
@@ -45,7 +45,7 @@ tiebreakers = {
}
-cdef inline are_diff(object left, object right):
+cdef inline bint are_diff(object left, object right):
try:
return fabs(left - right) > FP_ERR
except TypeError:
diff --git a/pandas/_libs/algos_common_helper.pxi.in b/pandas/_libs/algos_common_helper.pxi.in
index 97b7196da80bb..42dda15ea2cbb 100644
--- a/pandas/_libs/algos_common_helper.pxi.in
+++ b/pandas/_libs/algos_common_helper.pxi.in
@@ -68,12 +68,12 @@ cpdef map_indices_{{name}}(ndarray[{{c_type}}] index):
@cython.boundscheck(False)
@cython.wraparound(False)
-def pad_{{name}}(ndarray[{{c_type}}] old, ndarray[{{c_type}}] new,
- limit=None):
- cdef Py_ssize_t i, j, nleft, nright
- cdef ndarray[int64_t, ndim=1] indexer
- cdef {{c_type}} cur, next
- cdef int lim, fill_count = 0
+def pad_{{name}}(ndarray[{{c_type}}] old, ndarray[{{c_type}}] new, limit=None):
+ cdef:
+ Py_ssize_t i, j, nleft, nright
+ ndarray[int64_t, ndim=1] indexer
+ {{c_type}} cur, next
+ int lim, fill_count = 0
nleft = len(old)
nright = len(new)
@@ -135,9 +135,10 @@ def pad_{{name}}(ndarray[{{c_type}}] old, ndarray[{{c_type}}] new,
def pad_inplace_{{name}}(ndarray[{{c_type}}] values,
ndarray[uint8_t, cast=True] mask,
limit=None):
- cdef Py_ssize_t i, N
- cdef {{c_type}} val
- cdef int lim, fill_count = 0
+ cdef:
+ Py_ssize_t i, N
+ {{c_type}} val
+ int lim, fill_count = 0
N = len(values)
@@ -171,9 +172,10 @@ def pad_inplace_{{name}}(ndarray[{{c_type}}] values,
def pad_2d_inplace_{{name}}(ndarray[{{c_type}}, ndim=2] values,
ndarray[uint8_t, ndim=2] mask,
limit=None):
- cdef Py_ssize_t i, j, N, K
- cdef {{c_type}} val
- cdef int lim, fill_count = 0
+ cdef:
+ Py_ssize_t i, j, N, K
+ {{c_type}} val
+ int lim, fill_count = 0
K, N = (<object> values).shape
@@ -233,10 +235,11 @@ D
@cython.wraparound(False)
def backfill_{{name}}(ndarray[{{c_type}}] old, ndarray[{{c_type}}] new,
limit=None):
- cdef Py_ssize_t i, j, nleft, nright
- cdef ndarray[int64_t, ndim=1] indexer
- cdef {{c_type}} cur, prev
- cdef int lim, fill_count = 0
+ cdef:
+ Py_ssize_t i, j, nleft, nright
+ ndarray[int64_t, ndim=1] indexer
+ {{c_type}} cur, prev
+ int lim, fill_count = 0
nleft = len(old)
nright = len(new)
@@ -299,9 +302,10 @@ def backfill_{{name}}(ndarray[{{c_type}}] old, ndarray[{{c_type}}] new,
def backfill_inplace_{{name}}(ndarray[{{c_type}}] values,
ndarray[uint8_t, cast=True] mask,
limit=None):
- cdef Py_ssize_t i, N
- cdef {{c_type}} val
- cdef int lim, fill_count = 0
+ cdef:
+ Py_ssize_t i, N
+ {{c_type}} val
+ int lim, fill_count = 0
N = len(values)
@@ -335,9 +339,10 @@ def backfill_inplace_{{name}}(ndarray[{{c_type}}] values,
def backfill_2d_inplace_{{name}}(ndarray[{{c_type}}, ndim=2] values,
ndarray[uint8_t, ndim=2] mask,
limit=None):
- cdef Py_ssize_t i, j, N, K
- cdef {{c_type}} val
- cdef int lim, fill_count = 0
+ cdef:
+ Py_ssize_t i, j, N, K
+ {{c_type}} val
+ int lim, fill_count = 0
K, N = (<object> values).shape
@@ -428,10 +433,10 @@ def is_monotonic_{{name}}(ndarray[{{c_type}}] arr, bint timelike):
@cython.wraparound(False)
@cython.boundscheck(False)
def arrmap_{{name}}(ndarray[{{c_type}}] index, object func):
- cdef Py_ssize_t length = index.shape[0]
- cdef Py_ssize_t i = 0
-
- cdef ndarray[object] result = np.empty(length, dtype=np.object_)
+ cdef:
+ Py_ssize_t length = index.shape[0]
+ Py_ssize_t i = 0
+ ndarray[object] result = np.empty(length, dtype=np.object_)
from pandas._libs.lib import maybe_convert_objects
@@ -535,6 +540,7 @@ def put2d_{{name}}_{{dest_type}}(ndarray[{{c_type}}, ndim=2, cast=True] values,
cdef int PLATFORM_INT = (<ndarray> np.arange(0, dtype=np.intp)).descr.type_num
+
cpdef ensure_platform_int(object arr):
# GH3033, GH1392
# platform int is the size of the int pointer, e.g. np.intp
@@ -546,6 +552,7 @@ cpdef ensure_platform_int(object arr):
else:
return np.array(arr, dtype=np.intp)
+
cpdef ensure_object(object arr):
if util.is_array(arr):
if (<ndarray> arr).descr.type_num == NPY_OBJECT:
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index 5681d01c6bb25..5ffd3fc45460e 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -28,9 +28,10 @@ cdef double nan = NaN
cdef inline float64_t median_linear(float64_t* a, int n) nogil:
- cdef int i, j, na_count = 0
- cdef float64_t result
- cdef float64_t* tmp
+ cdef:
+ int i, j, na_count = 0
+ float64_t result
+ float64_t* tmp
if n == 0:
return NaN
@@ -319,7 +320,7 @@ def group_fillna_indexer(ndarray[int64_t] out, ndarray[int64_t] labels,
# If we move to the next group, reset
# the fill_idx and counter
- if i == N - 1 or labels[idx] != labels[sorted_labels[i+1]]:
+ if i == N - 1 or labels[idx] != labels[sorted_labels[i + 1]]:
curr_fill_idx = -1
filled_vals = 0
diff --git a/pandas/_libs/hashing.pyx b/pandas/_libs/hashing.pyx
index a9775d3950187..a758be6557206 100644
--- a/pandas/_libs/hashing.pyx
+++ b/pandas/_libs/hashing.pyx
@@ -48,9 +48,8 @@ def hash_object_array(object[:] arr, object key, object encoding='utf8'):
k = <bytes>key.encode(encoding)
kb = <uint8_t *>k
if len(k) != 16:
- raise ValueError(
- 'key should be a 16-byte string encoded, got {!r} (len {})'.format(
- k, len(k)))
+ raise ValueError("key should be a 16-byte string encoded, "
+ "got {key} (len {klen})".format(key=k, klen=len(k)))
n = len(arr)
@@ -70,8 +69,9 @@ def hash_object_array(object[:] arr, object key, object encoding='utf8'):
data = <bytes>str(val).encode(encoding)
else:
- raise TypeError("{} of type {} is not a valid type for hashing, "
- "must be string or null".format(val, type(val)))
+ raise TypeError("{val} of type {typ} is not a valid type "
+ "for hashing, must be string or null"
+ .format(val=val, typ=type(val)))
l = len(data)
lens[i] = l
@@ -134,9 +134,9 @@ cdef inline void _sipround(uint64_t* v0, uint64_t* v1,
cpdef uint64_t siphash(bytes data, bytes key) except? 0:
if len(key) != 16:
- raise ValueError(
- 'key should be a 16-byte bytestring, got {!r} (len {})'.format(
- key, len(key)))
+ raise ValueError("key should be a 16-byte bytestring, "
+ "got {key} (len {klen})"
+ .format(key=key, klen=len(key)))
return low_level_siphash(data, len(data), key)
diff --git a/pandas/_libs/hashtable_class_helper.pxi.in b/pandas/_libs/hashtable_class_helper.pxi.in
index 7f4a2eeafeea2..550cabd5e3192 100644
--- a/pandas/_libs/hashtable_class_helper.pxi.in
+++ b/pandas/_libs/hashtable_class_helper.pxi.in
@@ -115,7 +115,8 @@ cdef class {{name}}Vector:
if needs_resize(self.data):
if self.external_view_exists:
- raise ValueError("external reference but Vector.resize() needed")
+ raise ValueError("external reference but "
+ "Vector.resize() needed")
self.resize()
append_data_{{dtype}}(self.data, x)
@@ -194,6 +195,7 @@ cdef class StringVector:
for i in range(len(x)):
self.append(x[i])
+
cdef class ObjectVector:
cdef:
@@ -215,7 +217,8 @@ cdef class ObjectVector:
cdef inline append(self, object o):
if self.n == self.m:
if self.external_view_exists:
- raise ValueError("external reference but Vector.resize() needed")
+ raise ValueError("external reference but "
+ "Vector.resize() needed")
self.m = max(self.m * 2, _INIT_VEC_CAP)
self.ao.resize(self.m, refcheck=False)
self.data = <PyObject**> self.ao.data
@@ -405,8 +408,9 @@ cdef class {{name}}HashTable(HashTable):
if needs_resize(ud):
with gil:
if uniques.external_view_exists:
- raise ValueError("external reference to uniques held, "
- "but Vector.resize() needed")
+ raise ValueError("external reference to "
+ "uniques held, but "
+ "Vector.resize() needed")
uniques.resize()
append_data_{{dtype}}(ud, val)
labels[i] = count
@@ -742,8 +746,10 @@ cdef class StringHashTable(HashTable):
return np.asarray(labels)
+
na_sentinel = object
+
cdef class PyObjectHashTable(HashTable):
def __init__(self, size_hint=1):
diff --git a/pandas/_libs/hashtable_func_helper.pxi.in b/pandas/_libs/hashtable_func_helper.pxi.in
index f5cd8d05650a8..45a69b613f698 100644
--- a/pandas/_libs/hashtable_func_helper.pxi.in
+++ b/pandas/_libs/hashtable_func_helper.pxi.in
@@ -273,7 +273,6 @@ def ismember_{{dtype}}({{scalar}}[:] arr, {{scalar}}[:] values):
{{endfor}}
-
#----------------------------------------------------------------------
# Mode Computations
#----------------------------------------------------------------------
diff --git a/pandas/_libs/reduction.pyx b/pandas/_libs/reduction.pyx
index 3588ac14c87d1..59aca2a72a7ae 100644
--- a/pandas/_libs/reduction.pyx
+++ b/pandas/_libs/reduction.pyx
@@ -25,7 +25,7 @@ is_numpy_prior_1_6_2 = LooseVersion(np.__version__) < '1.6.2'
cdef _get_result_array(object obj, Py_ssize_t size, Py_ssize_t cnt):
if (util.is_array(obj) or
- isinstance(obj, list) and len(obj) == cnt or
+ (isinstance(obj, list) and len(obj) == cnt) or
getattr(obj, 'shape', None) == (cnt,)):
raise ValueError('function does not reduce')
diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index 04e039a9fc2c9..9e2e0b2fddce1 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -62,12 +62,14 @@ cdef inline object create_datetime_from_ts(
return datetime(dts.year, dts.month, dts.day, dts.hour,
dts.min, dts.sec, dts.us, tz)
+
cdef inline object create_date_from_ts(
int64_t value, npy_datetimestruct dts,
object tz, object freq):
""" convenience routine to construct a datetime.date from its parts """
return date(dts.year, dts.month, dts.day)
+
cdef inline object create_time_from_ts(
int64_t value, npy_datetimestruct dts,
object tz, object freq):
@@ -351,8 +353,8 @@ cpdef array_with_unit_to_datetime(ndarray values, unit, errors='coerce'):
if ((fvalues < _NS_LOWER_BOUND).any()
or (fvalues > _NS_UPPER_BOUND).any()):
- raise OutOfBoundsDatetime(
- "cannot convert input with unit '{0}'".format(unit))
+ raise OutOfBoundsDatetime("cannot convert input with unit "
+ "'{unit}'".format(unit=unit))
result = (iresult * m).astype('M8[ns]')
iresult = result.view('i8')
iresult[mask] = iNaT
@@ -378,8 +380,8 @@ cpdef array_with_unit_to_datetime(ndarray values, unit, errors='coerce'):
except OverflowError:
if is_raise:
raise OutOfBoundsDatetime(
- "cannot convert input {0} with the unit "
- "'{1}'".format(val, unit))
+ "cannot convert input {val} with the unit "
+ "'{unit}'".format(val=val, unit=unit))
elif is_ignore:
raise AssertionError
iresult[i] = NPY_NAT
@@ -394,16 +396,16 @@ cpdef array_with_unit_to_datetime(ndarray values, unit, errors='coerce'):
except ValueError:
if is_raise:
raise ValueError(
- "non convertible value {0} with the unit "
- "'{1}'".format(val, unit))
+ "non convertible value {val} with the unit "
+ "'{unit}'".format(val=val, unit=unit))
elif is_ignore:
raise AssertionError
iresult[i] = NPY_NAT
except:
if is_raise:
raise OutOfBoundsDatetime(
- "cannot convert input {0} with the unit "
- "'{1}'".format(val, unit))
+ "cannot convert input {val} with the unit "
+ "'{unit}'".format(val=val, unit=unit))
elif is_ignore:
raise AssertionError
iresult[i] = NPY_NAT
@@ -696,8 +698,8 @@ cpdef array_to_datetime(ndarray[object] values, errors='raise',
if is_coerce:
iresult[i] = NPY_NAT
else:
- raise TypeError("{0} is not convertible to datetime"
- .format(type(val)))
+ raise TypeError("{typ} is not convertible to datetime"
+ .format(typ=type(val)))
if seen_datetime and seen_integer:
# we have mixed datetimes & integers
diff --git a/pandas/_libs/tslibs/timezones.pxd b/pandas/_libs/tslibs/timezones.pxd
index 67353f3eec614..420d4ddd6eedd 100644
--- a/pandas/_libs/tslibs/timezones.pxd
+++ b/pandas/_libs/tslibs/timezones.pxd
@@ -11,7 +11,7 @@ cpdef bint tz_compare(object start, object end)
cpdef object get_timezone(object tz)
cpdef object maybe_get_tz(object tz)
-cpdef get_utcoffset(tzinfo, obj)
+cdef get_utcoffset(tzinfo, obj)
cdef bint is_fixed_offset(object tz)
cdef object get_dst_info(object tz)
diff --git a/pandas/_libs/tslibs/timezones.pyx b/pandas/_libs/tslibs/timezones.pyx
index a787452d90c07..dadf44d3c289d 100644
--- a/pandas/_libs/tslibs/timezones.pyx
+++ b/pandas/_libs/tslibs/timezones.pyx
@@ -150,7 +150,7 @@ cdef inline object tz_cache_key(object tz):
# UTC Offsets
-cpdef get_utcoffset(tzinfo, obj):
+cdef get_utcoffset(tzinfo, obj):
try:
return tzinfo._utcoffset
except AttributeError:
@@ -187,7 +187,7 @@ cdef object get_utc_trans_times_from_dateutil_tz(object tz):
return new_trans
-cpdef int64_t[:] unbox_utcoffsets(object transinfo):
+cdef int64_t[:] unbox_utcoffsets(object transinfo):
cdef:
Py_ssize_t i, sz
int64_t[:] arr
diff --git a/pandas/_libs/window.pyx b/pandas/_libs/window.pyx
index efc8a02014bc0..29bc06edc7ea6 100644
--- a/pandas/_libs/window.pyx
+++ b/pandas/_libs/window.pyx
@@ -609,12 +609,12 @@ def roll_mean(ndarray[double_t] input, int64_t win, int64_t minp,
else:
with nogil:
- for i from 0 <= i < minp - 1:
+ for i in range(minp - 1):
val = input[i]
add_mean(val, &nobs, &sum_x, &neg_ct)
output[i] = NaN
- for i from minp - 1 <= i < N:
+ for i in range(minp - 1, N):
val = input[i]
add_mean(val, &nobs, &sum_x, &neg_ct)
@@ -747,7 +747,7 @@ def roll_var(ndarray[double_t] input, int64_t win, int64_t minp,
# Over the first window, observations can only be added, never
# removed
- for i from 0 <= i < win:
+ for i in range(win):
add_var(input[i], &nobs, &mean_x, &ssqdm_x)
output[i] = calc_var(minp, ddof, nobs, ssqdm_x)
@@ -756,7 +756,7 @@ def roll_var(ndarray[double_t] input, int64_t win, int64_t minp,
# After the first window, observations can both be added and
# removed
- for i from win <= i < N:
+ for i in range(win, N):
val = input[i]
prev = input[i - win]
@@ -816,6 +816,7 @@ cdef inline double calc_skew(int64_t minp, int64_t nobs, double x, double xx,
return result
+
cdef inline void add_skew(double val, int64_t *nobs, double *x, double *xx,
double *xxx) nogil:
""" add a value from the skew calc """
@@ -829,6 +830,7 @@ cdef inline void add_skew(double val, int64_t *nobs, double *x, double *xx,
xx[0] = xx[0] + val * val
xxx[0] = xxx[0] + val * val * val
+
cdef inline void remove_skew(double val, int64_t *nobs, double *x, double *xx,
double *xxx) nogil:
""" remove a value from the skew calc """
@@ -896,12 +898,12 @@ def roll_skew(ndarray[double_t] input, int64_t win, int64_t minp,
else:
with nogil:
- for i from 0 <= i < minp - 1:
+ for i in range(minp - 1):
val = input[i]
add_skew(val, &nobs, &x, &xx, &xxx)
output[i] = NaN
- for i from minp - 1 <= i < N:
+ for i in range(minp - 1, N):
val = input[i]
add_skew(val, &nobs, &x, &xx, &xxx)
@@ -951,6 +953,7 @@ cdef inline double calc_kurt(int64_t minp, int64_t nobs, double x, double xx,
return result
+
cdef inline void add_kurt(double val, int64_t *nobs, double *x, double *xx,
double *xxx, double *xxxx) nogil:
""" add a value from the kurotic calc """
@@ -965,6 +968,7 @@ cdef inline void add_kurt(double val, int64_t *nobs, double *x, double *xx,
xxx[0] = xxx[0] + val * val * val
xxxx[0] = xxxx[0] + val * val * val * val
+
cdef inline void remove_kurt(double val, int64_t *nobs, double *x, double *xx,
double *xxx, double *xxxx) nogil:
""" remove a value from the kurotic calc """
@@ -1031,11 +1035,11 @@ def roll_kurt(ndarray[double_t] input, int64_t win, int64_t minp,
with nogil:
- for i from 0 <= i < minp - 1:
+ for i in range(minp - 1):
add_kurt(input[i], &nobs, &x, &xx, &xxx, &xxxx)
output[i] = NaN
- for i from minp - 1 <= i < N:
+ for i in range(minp - 1, N):
add_kurt(input[i], &nobs, &x, &xx, &xxx, &xxxx)
if i > win - 1:
@@ -1589,7 +1593,7 @@ def roll_generic(object obj,
elif not raw:
# series
- for i from 0 <= i < N:
+ for i in range(N):
if counts[i] >= minp:
sl = slice(int_max(i + offset - win + 1, 0),
int_min(i + offset + 1, N))
@@ -1652,7 +1656,7 @@ def roll_window(ndarray[float64_t, ndim=1, cast=True] input,
minp = _check_minp(len(weights), minp, in_n)
if avg:
- for win_i from 0 <= win_i < win_n:
+ for win_i in range(win_n):
val_win = weights[win_i]
if val_win != val_win:
continue
@@ -1664,7 +1668,7 @@ def roll_window(ndarray[float64_t, ndim=1, cast=True] input,
counts[in_i + (win_n - win_i) - 1] += 1
tot_wgt[in_i + (win_n - win_i) - 1] += val_win
- for in_i from 0 <= in_i < in_n:
+ for in_i in range(in_n):
c = counts[in_i]
if c < minp:
output[in_i] = NaN
@@ -1676,7 +1680,7 @@ def roll_window(ndarray[float64_t, ndim=1, cast=True] input,
output[in_i] /= tot_wgt[in_i]
else:
- for win_i from 0 <= win_i < win_n:
+ for win_i in range(win_n):
val_win = weights[win_i]
if val_win != val_win:
continue
@@ -1688,7 +1692,7 @@ def roll_window(ndarray[float64_t, ndim=1, cast=True] input,
output[in_i + (win_n - win_i) - 1] += val_in * val_win
counts[in_i + (win_n - win_i) - 1] += 1
- for in_i from 0 <= in_i < in_n:
+ for in_i in range(in_n):
c = counts[in_i]
if c < minp:
output[in_i] = NaN
@@ -1699,14 +1703,13 @@ def roll_window(ndarray[float64_t, ndim=1, cast=True] input,
# Exponentially weighted moving average
-def ewma(ndarray[double_t] input, double_t com, int adjust, int ignore_na,
- int minp):
+def ewma(double_t[:] vals, double_t com, int adjust, int ignore_na, int minp):
"""
Compute exponentially-weighted moving average using center-of-mass.
Parameters
----------
- input : ndarray (float64 type)
+ vals : ndarray (float64 type)
com : float64
adjust: int
ignore_na: int
@@ -1717,28 +1720,29 @@ def ewma(ndarray[double_t] input, double_t com, int adjust, int ignore_na,
y : ndarray
"""
- cdef Py_ssize_t N = len(input)
- cdef ndarray[double_t] output = np.empty(N, dtype=float)
+ cdef:
+ Py_ssize_t N = len(vals)
+ ndarray[double_t] output = np.empty(N, dtype=float)
+ double alpha, old_wt_factor, new_wt, weighted_avg, old_wt, cur
+ Py_ssize_t i, nobs
+
if N == 0:
return output
minp = max(minp, 1)
- cdef double alpha, old_wt_factor, new_wt, weighted_avg, old_wt, cur
- cdef Py_ssize_t i, nobs
-
alpha = 1. / (1. + com)
old_wt_factor = 1. - alpha
new_wt = 1. if adjust else alpha
- weighted_avg = input[0]
+ weighted_avg = vals[0]
is_observation = (weighted_avg == weighted_avg)
nobs = int(is_observation)
output[0] = weighted_avg if (nobs >= minp) else NaN
old_wt = 1.
- for i from 1 <= i < N:
- cur = input[i]
+ for i in range(1, N):
+ cur = vals[i]
is_observation = (cur == cur)
nobs += int(is_observation)
if weighted_avg == weighted_avg:
@@ -1767,7 +1771,7 @@ def ewma(ndarray[double_t] input, double_t com, int adjust, int ignore_na,
# Exponentially weighted moving covariance
-def ewmcov(ndarray[double_t] input_x, ndarray[double_t] input_y,
+def ewmcov(double_t[:] input_x, double_t[:] input_y,
double_t com, int adjust, int ignore_na, int minp, int bias):
"""
Compute exponentially-weighted moving variance using center-of-mass.
@@ -1787,20 +1791,23 @@ def ewmcov(ndarray[double_t] input_x, ndarray[double_t] input_y,
y : ndarray
"""
- cdef Py_ssize_t N = len(input_x)
+ cdef:
+ Py_ssize_t N = len(input_x)
+ double alpha, old_wt_factor, new_wt, mean_x, mean_y, cov
+ double sum_wt, sum_wt2, old_wt, cur_x, cur_y, old_mean_x, old_mean_y
+ Py_ssize_t i, nobs
+ ndarray[double_t] output
+
if len(input_y) != N:
raise ValueError("arrays are of different lengths "
- "(%d and %d)" % (N, len(input_y)))
- cdef ndarray[double_t] output = np.empty(N, dtype=float)
+ "({N} and {len_y})".format(N=N, len_y=len(input_y)))
+
+ output = np.empty(N, dtype=float)
if N == 0:
return output
minp = max(minp, 1)
- cdef double alpha, old_wt_factor, new_wt, mean_x, mean_y, cov
- cdef double sum_wt, sum_wt2, old_wt, cur_x, cur_y, old_mean_x, old_mean_y
- cdef Py_ssize_t i, nobs
-
alpha = 1. / (1. + com)
old_wt_factor = 1. - alpha
new_wt = 1. if adjust else alpha
@@ -1818,7 +1825,7 @@ def ewmcov(ndarray[double_t] input_x, ndarray[double_t] input_y,
sum_wt2 = 1.
old_wt = 1.
- for i from 1 <= i < N:
+ for i in range(1, N):
cur_x = input_x[i]
cur_y = input_y[i]
is_observation = ((cur_x == cur_x) and (cur_y == cur_y))
| cpdef --> cdef in a few cases
modernize string formatting
modernize for loop syntax
Should be orthogonal to other outstanding PR(s) | https://api.github.com/repos/pandas-dev/pandas/pulls/22287 | 2018-08-11T22:49:06Z | 2018-08-20T11:13:10Z | 2018-08-20T11:13:10Z | 2018-08-24T04:07:19Z |
[PERF] use numexpr in dispatch_to_series | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 4faf4e88e5a3c..251bc6587872d 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -4837,15 +4837,23 @@ def _arith_op(left, right):
copy=False)
def _combine_match_index(self, other, func, level=None):
+ assert isinstance(other, Series)
left, right = self.align(other, join='outer', axis=0, level=level,
copy=False)
assert left.index.equals(right.index)
- new_data = func(left.values.T, right.values).T
- return self._constructor(new_data,
- index=left.index, columns=self.columns,
- copy=False)
+
+ if left._is_mixed_type or right._is_mixed_type:
+ # operate column-wise; avoid costly object-casting in `.values`
+ return ops.dispatch_to_series(left, right, func)
+ else:
+ # fastpath --> operate directly on values
+ new_data = func(left.values.T, right.values).T
+ return self._constructor(new_data,
+ index=left.index, columns=self.columns,
+ copy=False)
def _combine_match_columns(self, other, func, level=None, try_cast=True):
+ assert isinstance(other, Series)
left, right = self.align(other, join='outer', axis=1, level=level,
copy=False)
assert left.columns.equals(right.index)
@@ -4864,21 +4872,6 @@ def _combine_const(self, other, func, errors='raise', try_cast=True):
try_cast=try_cast)
return self._constructor(new_data)
- def _compare_frame(self, other, func, str_rep):
- # compare_frame assumes self._indexed_same(other)
-
- import pandas.core.computation.expressions as expressions
-
- def _compare(a, b):
- return {i: func(a.iloc[:, i], b.iloc[:, i])
- for i in range(len(a.columns))}
-
- new_data = expressions.evaluate(_compare, str_rep, self, other)
- result = self._constructor(data=new_data, index=self.index,
- copy=False)
- result.columns = self.columns
- return result
-
def combine(self, other, func, fill_value=None, overwrite=True):
"""
Perform column-wise combine with another DataFrame based on a
diff --git a/pandas/core/ops.py b/pandas/core/ops.py
index a86e57fd8876d..ca9c2528f0aef 100644
--- a/pandas/core/ops.py
+++ b/pandas/core/ops.py
@@ -1621,7 +1621,7 @@ def flex_wrapper(self, other, level=None, fill_value=None, axis=0):
# -----------------------------------------------------------------------------
# DataFrame
-def dispatch_to_series(left, right, func):
+def dispatch_to_series(left, right, func, str_rep=None):
"""
Evaluate the frame operation func(left, right) by evaluating
column-by-column, dispatching to the Series implementation.
@@ -1631,6 +1631,7 @@ def dispatch_to_series(left, right, func):
left : DataFrame
right : scalar or DataFrame
func : arithmetic or comparison operator
+ str_rep : str or None, default None
Returns
-------
@@ -1638,17 +1639,34 @@ def dispatch_to_series(left, right, func):
"""
# Note: we use iloc to access columns for compat with cases
# with non-unique columns.
+ import pandas.core.computation.expressions as expressions
+
right = lib.item_from_zerodim(right)
if lib.is_scalar(right):
- new_data = {i: func(left.iloc[:, i], right)
- for i in range(len(left.columns))}
+
+ def column_op(a, b):
+ return {i: func(a.iloc[:, i], b)
+ for i in range(len(a.columns))}
+
elif isinstance(right, ABCDataFrame):
assert right._indexed_same(left)
- new_data = {i: func(left.iloc[:, i], right.iloc[:, i])
- for i in range(len(left.columns))}
+
+ def column_op(a, b):
+ return {i: func(a.iloc[:, i], b.iloc[:, i])
+ for i in range(len(a.columns))}
+
+ elif isinstance(right, ABCSeries):
+ assert right.index.equals(left.index) # Handle other cases later
+
+ def column_op(a, b):
+ return {i: func(a.iloc[:, i], b)
+ for i in range(len(a.columns))}
+
else:
# Remaining cases have less-obvious dispatch rules
- raise NotImplementedError
+ raise NotImplementedError(right)
+
+ new_data = expressions.evaluate(column_op, str_rep, left, right)
result = left._constructor(new_data, index=left.index, copy=False)
# Pin columns instead of passing to constructor for compat with
@@ -1818,7 +1836,7 @@ def f(self, other, axis=default_axis, level=None):
if not self._indexed_same(other):
self, other = self.align(other, 'outer',
level=level, copy=False)
- return self._compare_frame(other, na_op, str_rep)
+ return dispatch_to_series(self, other, na_op, str_rep)
elif isinstance(other, ABCSeries):
return _combine_series_frame(self, other, na_op,
@@ -1843,7 +1861,7 @@ def f(self, other):
if not self._indexed_same(other):
raise ValueError('Can only compare identically-labeled '
'DataFrame objects')
- return self._compare_frame(other, func, str_rep)
+ return dispatch_to_series(self, other, func, str_rep)
elif isinstance(other, ABCSeries):
return _combine_series_frame(self, other, func,
| Also avoid copy/cast in mixed-dtype case for `_combine_match_index`
Lets us use `dispatch_to_series` and get rid of `DataFrame._compare_frame`.
```
asv continuous -f 1.1 -E virtualenv master HEAD -b binary_ops
[...]
before after ratio
[03707400] [0cf9fa00]
- 105.09ms 94.39ms 0.90 binary_ops.Ops.time_frame_multi_and(True, 'default')
- 11.67ms 10.41ms 0.89 binary_ops.Ops.time_frame_mult(True, 1)
- 32.72ms 29.03ms 0.89 binary_ops.Timeseries.time_timestamp_ops_diff(None)
- 34.11ms 29.24ms 0.86 binary_ops.Ops.time_frame_mult(True, 'default')
- 20.06ms 15.78ms 0.79 binary_ops.Ops.time_frame_comparison(True, 'default')
- 37.93ms 28.27ms 0.75 binary_ops.AddOverflowArray.time_add_overflow_arr_mask_nan
asv continuous -f 1.1 -E virtualenv master HEAD -b binary_ops
[...]
before after ratio
[03707400] [0cf9fa00]
+ 34.44ms 45.40ms 1.32 binary_ops.Ops2.time_frame_int_div_by_zero
+ 32.34ms 42.38ms 1.31 binary_ops.Ops2.time_frame_float_mod
+ 11.65ms 15.03ms 1.29 binary_ops.Ops.time_frame_mult(False, 'default')
+ 8.01ms 9.76ms 1.22 binary_ops.Timeseries.time_series_timestamp_compare('US/Eastern')
+ 48.31ms 58.72ms 1.22 binary_ops.Ops2.time_frame_int_mod
+ 7.36ms 8.41ms 1.14 binary_ops.Timeseries.time_timestamp_series_compare('US/Eastern')
+ 7.11ms 8.09ms 1.14 binary_ops.Timeseries.time_series_timestamp_compare(None)
+ 67.32ms 76.35ms 1.13 binary_ops.Ops2.time_frame_float_div
+ 30.83ms 34.92ms 1.13 binary_ops.Timeseries.time_timestamp_ops_diff_with_shift(None)
+ 7.12ms 8.06ms 1.13 binary_ops.Timeseries.time_timestamp_series_compare(None)
+ 104.54ms 116.93ms 1.12 binary_ops.Ops2.time_frame_float_floor_by_zero
+ 32.93ms 36.62ms 1.11 binary_ops.Timeseries.time_timestamp_ops_diff(None)
+ 40.88ms 45.45ms 1.11 binary_ops.Timeseries.time_timestamp_ops_diff_with_shift('US/Eastern')
- 122.79ms 111.19ms 0.91 binary_ops.Ops.time_frame_comparison(False, 1)
- 11.82ms 10.58ms 0.89 binary_ops.Ops.time_frame_add(True, 1)
- 25.92ms 22.90ms 0.88 binary_ops.AddOverflowArray.time_add_overflow_b_mask_nan
- 11.36ms 9.82ms 0.86 binary_ops.Ops.time_frame_add(False, 1)
- 10.63ms 8.88ms 0.84 binary_ops.AddOverflowScalar.time_add_overflow_scalar(0)
- 10.50ms 8.62ms 0.82 binary_ops.AddOverflowScalar.time_add_overflow_scalar(1)
- 11.55ms 9.43ms 0.82 binary_ops.Ops.time_frame_add(False, 'default')
- 10.47ms 8.41ms 0.80 binary_ops.AddOverflowScalar.time_add_overflow_scalar(-1)
- 28.92ms 22.54ms 0.78 binary_ops.AddOverflowArray.time_add_overflow_both_arg_nan
- 15.50ms 11.39ms 0.73 binary_ops.AddOverflowArray.time_add_overflow_arr_rev
- 43.70ms 25.47ms 0.58 binary_ops.AddOverflowArray.time_add_overflow_arr_mask_nan
asv continuous -f 1.1 -E virtualenv master HEAD -b binary_ops
[...]
before after ratio
[03707400] [0cf9fa00]
+ 6.10ms 6.87ms 1.13 binary_ops.AddOverflowScalar.time_add_overflow_scalar(-1)
- 5.14ms 4.59ms 0.89 binary_ops.Ops.time_frame_comparison(True, 1)
- 4.80ms 4.21ms 0.88 binary_ops.Timeseries.time_series_timestamp_compare(None)
- 4.81ms 4.17ms 0.87 binary_ops.Timeseries.time_timestamp_series_compare('US/Eastern')
- 22.17ms 19.05ms 0.86 binary_ops.Timeseries.time_timestamp_ops_diff(None)
- 21.63ms 18.29ms 0.85 binary_ops.Timeseries.time_timestamp_ops_diff_with_shift(None)
- 5.23ms 4.42ms 0.85 binary_ops.Timeseries.time_timestamp_series_compare(None)
- 52.74ms 42.41ms 0.80 binary_ops.Ops.time_frame_multi_and(False, 1)
asv continuous -f 1.1 -E virtualenv master HEAD -b binary_ops
[...]
before after ratio
[03707400] [0cf9fa00]
- 4.85ms 4.40ms 0.91 binary_ops.Timeseries.time_series_timestamp_compare(None)
- 17.56ms 15.43ms 0.88 binary_ops.AddOverflowArray.time_add_overflow_arr_mask_nan
- 29.55ms 25.75ms 0.87 binary_ops.Timeseries.time_timestamp_ops_diff_with_shift('US/Eastern')
- 5.33ms 4.59ms 0.86 binary_ops.Timeseries.time_timestamp_series_compare(None)
- 68.42ms 58.38ms 0.85 binary_ops.Ops2.time_frame_float_floor_by_zero
- 5.05ms 4.23ms 0.84 binary_ops.Timeseries.time_series_timestamp_compare('US/Eastern')
- 22.39ms 18.35ms 0.82 binary_ops.Ops2.time_frame_float_mod
- 79.24ms 63.43ms 0.80 binary_ops.Ops.time_frame_comparison(False, 1)
- 5.38ms 4.18ms 0.78 binary_ops.Timeseries.time_timestamp_series_compare('US/Eastern')
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/22284 | 2018-08-11T18:58:40Z | 2018-09-08T02:42:47Z | 2018-09-08T02:42:47Z | 2018-09-08T03:11:27Z |
[CLN] More cython cleanups, with bonus type annotations | diff --git a/pandas/_libs/algos_common_helper.pxi.in b/pandas/_libs/algos_common_helper.pxi.in
index 1efef480f3a29..ed4c0e4c59609 100644
--- a/pandas/_libs/algos_common_helper.pxi.in
+++ b/pandas/_libs/algos_common_helper.pxi.in
@@ -45,7 +45,7 @@ def get_dispatch(dtypes):
@cython.wraparound(False)
@cython.boundscheck(False)
-cpdef map_indices_{{name}}(ndarray[{{c_type}}] index):
+def map_indices_{{name}}(ndarray[{{c_type}}] index):
"""
Produce a dict mapping the values of the input array to their respective
locations.
@@ -542,7 +542,7 @@ def put2d_{{name}}_{{dest_type}}(ndarray[{{c_type}}, ndim=2, cast=True] values,
cdef int PLATFORM_INT = (<ndarray> np.arange(0, dtype=np.intp)).descr.type_num
-cpdef ensure_platform_int(object arr):
+def ensure_platform_int(object arr):
# GH3033, GH1392
# platform int is the size of the int pointer, e.g. np.intp
if util.is_array(arr):
@@ -554,7 +554,7 @@ cpdef ensure_platform_int(object arr):
return np.array(arr, dtype=np.intp)
-cpdef ensure_object(object arr):
+def ensure_object(object arr):
if util.is_array(arr):
if (<ndarray> arr).descr.type_num == NPY_OBJECT:
return arr
@@ -587,7 +587,7 @@ def get_dispatch(dtypes):
{{for name, c_type, dtype in get_dispatch(dtypes)}}
-cpdef ensure_{{name}}(object arr, copy=True):
+def ensure_{{name}}(object arr, copy=True):
if util.is_array(arr):
if (<ndarray> arr).descr.type_num == NPY_{{c_type}}:
return arr
diff --git a/pandas/_libs/groupby.pyx b/pandas/_libs/groupby.pyx
index d8feda9ef27ef..d683c93c9b32e 100644
--- a/pandas/_libs/groupby.pyx
+++ b/pandas/_libs/groupby.pyx
@@ -67,6 +67,7 @@ cdef inline float64_t median_linear(float64_t* a, int n) nogil:
return result
+# TODO: Is this redundant with algos.kth_smallest?
cdef inline float64_t kth_smallest_c(float64_t* a,
Py_ssize_t k,
Py_ssize_t n) nogil:
diff --git a/pandas/_libs/hashing.pyx b/pandas/_libs/hashing.pyx
index 557e3e34aee25..88b4d97de492c 100644
--- a/pandas/_libs/hashing.pyx
+++ b/pandas/_libs/hashing.pyx
@@ -132,6 +132,7 @@ cdef inline void _sipround(uint64_t* v0, uint64_t* v1,
v2[0] = _rotl(v2[0], 32)
+# TODO: This appears unused; remove?
cpdef uint64_t siphash(bytes data, bytes key) except? 0:
if len(key) != 16:
raise ValueError("key should be a 16-byte bytestring, "
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 9c906a00bd4fe..d5846f2b42378 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -49,7 +49,7 @@ cpdef get_value_at(ndarray arr, object loc, object tz=None):
return util.get_value_at(arr, loc)
-cpdef object get_value_box(ndarray arr, object loc):
+def get_value_box(arr: ndarray, loc: object) -> object:
return get_value_at(arr, loc, tz=None)
diff --git a/pandas/_libs/internals.pyx b/pandas/_libs/internals.pyx
index 97cc7f96cb24f..996570dae3302 100644
--- a/pandas/_libs/internals.pyx
+++ b/pandas/_libs/internals.pyx
@@ -184,7 +184,7 @@ cdef class BlockPlacement:
return self._as_slice
-cpdef slice_canonize(slice s):
+cdef slice_canonize(slice s):
"""
Convert slice to canonical bounded form.
"""
@@ -255,7 +255,7 @@ cpdef Py_ssize_t slice_len(
return length
-cpdef slice_get_indices_ex(slice slc, Py_ssize_t objlen=PY_SSIZE_T_MAX):
+cdef slice_get_indices_ex(slice slc, Py_ssize_t objlen=PY_SSIZE_T_MAX):
"""
Get (start, stop, step, length) tuple for a slice.
diff --git a/pandas/_libs/interval.pyx b/pandas/_libs/interval.pyx
index 5ae20a27c2381..d8e2e8eb4b4ea 100644
--- a/pandas/_libs/interval.pyx
+++ b/pandas/_libs/interval.pyx
@@ -362,8 +362,8 @@ cdef class Interval(IntervalMixin):
@cython.wraparound(False)
@cython.boundscheck(False)
-cpdef intervals_to_interval_bounds(ndarray intervals,
- bint validate_closed=True):
+def intervals_to_interval_bounds(ndarray intervals,
+ bint validate_closed=True):
"""
Parameters
----------
@@ -415,4 +415,5 @@ cpdef intervals_to_interval_bounds(ndarray intervals,
return left, right, closed
+
include "intervaltree.pxi"
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index a6078da28a3ba..6b425d7022ecd 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -107,7 +107,7 @@ def memory_usage_of_objects(object[:] arr):
# ----------------------------------------------------------------------
-cpdef bint is_scalar(object val):
+def is_scalar(val: object) -> bint:
"""
Return True if given value is scalar.
@@ -137,7 +137,7 @@ cpdef bint is_scalar(object val):
or util.is_period_object(val)
or is_decimal(val)
or is_interval(val)
- or is_offset(val))
+ or util.is_offset_object(val))
def item_from_zerodim(object val):
@@ -457,7 +457,7 @@ def maybe_booleans_to_slice(ndarray[uint8_t] mask):
@cython.wraparound(False)
@cython.boundscheck(False)
-cpdef bint array_equivalent_object(object[:] left, object[:] right):
+def array_equivalent_object(left: object[:], right: object[:]) -> bint:
""" perform an element by element comparion on 1-d object arrays
taking into account nan positions """
cdef:
@@ -497,7 +497,7 @@ def astype_intsafe(ndarray[object] arr, new_dtype):
return result
-cpdef ndarray[object] astype_unicode(ndarray arr):
+def astype_unicode(arr: ndarray) -> ndarray[object]:
cdef:
Py_ssize_t i, n = arr.size
ndarray[object] result = np.empty(n, dtype=object)
@@ -508,7 +508,7 @@ cpdef ndarray[object] astype_unicode(ndarray arr):
return result
-cpdef ndarray[object] astype_str(ndarray arr):
+def astype_str(arr: ndarray) -> ndarray[object]:
cdef:
Py_ssize_t i, n = arr.size
ndarray[object] result = np.empty(n, dtype=object)
@@ -791,19 +791,19 @@ def indices_fast(object index, ndarray[int64_t] labels, list keys,
# core.common import for fast inference checks
-cpdef bint is_float(object obj):
+def is_float(obj: object) -> bint:
return util.is_float_object(obj)
-cpdef bint is_integer(object obj):
+def is_integer(obj: object) -> bint:
return util.is_integer_object(obj)
-cpdef bint is_bool(object obj):
+def is_bool(obj: object) -> bint:
return util.is_bool_object(obj)
-cpdef bint is_complex(object obj):
+def is_complex(obj: object) -> bint:
return util.is_complex_object(obj)
@@ -815,15 +815,11 @@ cpdef bint is_interval(object obj):
return getattr(obj, '_typ', '_typ') == 'interval'
-cpdef bint is_period(object val):
+def is_period(val: object) -> bint:
""" Return a boolean if this is a Period object """
return util.is_period_object(val)
-cdef inline bint is_offset(object val):
- return getattr(val, '_typ', '_typ') == 'dateoffset'
-
-
_TYPE_MAP = {
'categorical': 'categorical',
'category': 'categorical',
@@ -1225,7 +1221,7 @@ def infer_dtype(object value, bint skipna=False):
if is_bytes_array(values, skipna=skipna):
return 'bytes'
- elif is_period(val):
+ elif util.is_period_object(val):
if is_period_array(values):
return 'period'
@@ -1243,7 +1239,7 @@ def infer_dtype(object value, bint skipna=False):
return 'mixed'
-cpdef object infer_datetimelike_array(object arr):
+def infer_datetimelike_array(arr: object) -> object:
"""
infer if we have a datetime or timedelta array
- date: we have *only* date and maybe strings, nulls
@@ -1580,7 +1576,7 @@ cpdef bint is_datetime64_array(ndarray values):
return validator.validate(values)
-cpdef bint is_datetime_with_singletz_array(ndarray values):
+def is_datetime_with_singletz_array(values: ndarray) -> bint:
"""
Check values have the same tzinfo attribute.
Doesn't check values are datetime-like types.
@@ -1616,7 +1612,8 @@ cdef class TimedeltaValidator(TemporalValidator):
return is_null_timedelta64(value)
-cpdef bint is_timedelta_array(ndarray values):
+# TODO: Not used outside of tests; remove?
+def is_timedelta_array(values: ndarray) -> bint:
cdef:
TimedeltaValidator validator = TimedeltaValidator(len(values),
skipna=True)
@@ -1628,7 +1625,8 @@ cdef class Timedelta64Validator(TimedeltaValidator):
return util.is_timedelta64_object(value)
-cpdef bint is_timedelta64_array(ndarray values):
+# TODO: Not used outside of tests; remove?
+def is_timedelta64_array(values: ndarray) -> bint:
cdef:
Timedelta64Validator validator = Timedelta64Validator(len(values),
skipna=True)
@@ -1672,7 +1670,7 @@ cpdef bint is_time_array(ndarray values, bint skipna=False):
cdef class PeriodValidator(TemporalValidator):
cdef inline bint is_value_typed(self, object value) except -1:
- return is_period(value)
+ return util.is_period_object(value)
cdef inline bint is_valid_null(self, object value) except -1:
return is_null_period(value)
diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index bdd279b19208b..93fae695d51fd 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -300,7 +300,7 @@ def format_array_from_datetime(ndarray[int64_t] values, object tz=None,
return result
-cpdef array_with_unit_to_datetime(ndarray values, unit, errors='coerce'):
+def array_with_unit_to_datetime(ndarray values, unit, errors='coerce'):
"""
convert the ndarray according to the unit
if errors:
diff --git a/pandas/_libs/writers.pyx b/pandas/_libs/writers.pyx
index 796f4b754857e..8e55ffad8d231 100644
--- a/pandas/_libs/writers.pyx
+++ b/pandas/_libs/writers.pyx
@@ -3,8 +3,7 @@
cimport cython
from cython cimport Py_ssize_t
-from cpython cimport (PyString_Check, PyBytes_Check, PyUnicode_Check,
- PyBytes_GET_SIZE, PyUnicode_GET_SIZE)
+from cpython cimport PyBytes_GET_SIZE, PyUnicode_GET_SIZE
try:
from cpython cimport PyString_GET_SIZE
@@ -124,7 +123,7 @@ def convert_json_to_lines(object arr):
# stata, pytables
@cython.boundscheck(False)
@cython.wraparound(False)
-cpdef Py_ssize_t max_len_string_array(pandas_string[:] arr):
+def max_len_string_array(pandas_string[:] arr) -> Py_ssize_t:
""" return the maximum size of elements in a 1-dim string array """
cdef:
Py_ssize_t i, m = 0, l = 0, length = arr.shape[0]
@@ -132,11 +131,11 @@ cpdef Py_ssize_t max_len_string_array(pandas_string[:] arr):
for i in range(length):
v = arr[i]
- if PyString_Check(v):
+ if isinstance(v, str):
l = PyString_GET_SIZE(v)
- elif PyBytes_Check(v):
+ elif isinstance(v, bytes):
l = PyBytes_GET_SIZE(v)
- elif PyUnicode_Check(v):
+ elif isinstance(v, unicode):
l = PyUnicode_GET_SIZE(v)
if l > m:
| A few places where string formatting is modernized
Removed remaining `# cython: profile=False` comments
The main (and possible controversial) thing done here is changing some functions to use type-hint syntax. The affected functions are all currently `cpdef`, but are never used in cython, so _should_ only be `def`. But cython's syntax does not allow for specifying a return type in `def` functions, so this is the cleanest way to remove unnecessary `cpdef` without losing typing. (some discussion of this occurred in #22180) | https://api.github.com/repos/pandas-dev/pandas/pulls/22283 | 2018-08-11T16:31:16Z | 2018-09-08T02:45:30Z | 2018-09-08T02:45:30Z | 2018-09-08T03:10:34Z |
Add initial property-based tests using Hypothesis | diff --git a/.gitignore b/.gitignore
index 96b1f945870de..a59f2843c365a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -62,6 +62,8 @@ dist
coverage.xml
coverage_html_report
*.pytest_cache
+# hypothesis test database
+.hypothesis/
# OS generated files #
######################
diff --git a/ci/appveyor-27.yaml b/ci/appveyor-27.yaml
index 114dcfb0c6440..6843c82236a35 100644
--- a/ci/appveyor-27.yaml
+++ b/ci/appveyor-27.yaml
@@ -28,3 +28,4 @@ dependencies:
- pytest
- pytest-xdist
- moto
+ - hypothesis>=3.58.0
diff --git a/ci/appveyor-36.yaml b/ci/appveyor-36.yaml
index 63e45d0544ad9..47b14221bb34b 100644
--- a/ci/appveyor-36.yaml
+++ b/ci/appveyor-36.yaml
@@ -25,3 +25,4 @@ dependencies:
- cython>=0.28.2
- pytest
- pytest-xdist
+ - hypothesis>=3.58.0
diff --git a/ci/check_imports.py b/ci/check_imports.py
index 3f09290f8c375..19e48b659617f 100644
--- a/ci/check_imports.py
+++ b/ci/check_imports.py
@@ -9,6 +9,7 @@
'html5lib',
'ipython',
'jinja2'
+ 'hypothesis',
'lxml',
'numexpr',
'openpyxl',
diff --git a/ci/circle-27-compat.yaml b/ci/circle-27-compat.yaml
index 5e9842f4742c5..5dee6b0c8ed07 100644
--- a/ci/circle-27-compat.yaml
+++ b/ci/circle-27-compat.yaml
@@ -26,3 +26,4 @@ dependencies:
- html5lib==1.0b2
- beautifulsoup4==4.2.1
- pymysql==0.6.0
+ - hypothesis>=3.58.0
diff --git a/ci/circle-35-ascii.yaml b/ci/circle-35-ascii.yaml
index 745678791458d..281ed59e2deff 100644
--- a/ci/circle-35-ascii.yaml
+++ b/ci/circle-35-ascii.yaml
@@ -11,3 +11,5 @@ dependencies:
# universal
- pytest
- pytest-xdist
+ - pip:
+ - hypothesis>=3.58.0
diff --git a/ci/circle-36-locale.yaml b/ci/circle-36-locale.yaml
index 091a5a637becd..59c8818eaef1e 100644
--- a/ci/circle-36-locale.yaml
+++ b/ci/circle-36-locale.yaml
@@ -31,3 +31,5 @@ dependencies:
- pytest
- pytest-xdist
- moto
+ - pip:
+ - hypothesis>=3.58.0
diff --git a/ci/circle-36-locale_slow.yaml b/ci/circle-36-locale_slow.yaml
index 649f93f7aa427..7e40bd1a9979e 100644
--- a/ci/circle-36-locale_slow.yaml
+++ b/ci/circle-36-locale_slow.yaml
@@ -32,3 +32,5 @@ dependencies:
- pytest
- pytest-xdist
- moto
+ - pip:
+ - hypothesis>=3.58.0
diff --git a/ci/environment-dev.yaml b/ci/environment-dev.yaml
index f66a831aae0f5..f3323face4144 100644
--- a/ci/environment-dev.yaml
+++ b/ci/environment-dev.yaml
@@ -7,6 +7,7 @@ dependencies:
- NumPy
- flake8
- flake8-comprehensions
+ - hypothesis>=3.58.0
- moto
- pytest>=3.6
- python-dateutil>=2.5.0
diff --git a/ci/requirements_dev.txt b/ci/requirements_dev.txt
index a50a4dcd63508..68fffe5d0df09 100644
--- a/ci/requirements_dev.txt
+++ b/ci/requirements_dev.txt
@@ -4,6 +4,7 @@ Cython>=0.28.2
NumPy
flake8
flake8-comprehensions
+hypothesis>=3.58.0
moto
pytest>=3.6
python-dateutil>=2.5.0
diff --git a/ci/travis-27-locale.yaml b/ci/travis-27-locale.yaml
index 73ab424329463..aca65f27d4187 100644
--- a/ci/travis-27-locale.yaml
+++ b/ci/travis-27-locale.yaml
@@ -22,6 +22,7 @@ dependencies:
# universal
- pytest
- pytest-xdist
+ - hypothesis>=3.58.0
- pip:
- html5lib==1.0b2
- beautifulsoup4==4.2.1
diff --git a/ci/travis-27.yaml b/ci/travis-27.yaml
index 9c0347de9adfb..a921bcb46dba4 100644
--- a/ci/travis-27.yaml
+++ b/ci/travis-27.yaml
@@ -45,6 +45,7 @@ dependencies:
- pytest
- pytest-xdist
- moto
+ - hypothesis>=3.58.0
- pip:
- backports.lzma
- cpplint
diff --git a/ci/travis-35-osx.yaml b/ci/travis-35-osx.yaml
index fff7acc64d537..797682bec7208 100644
--- a/ci/travis-35-osx.yaml
+++ b/ci/travis-35-osx.yaml
@@ -25,3 +25,4 @@ dependencies:
- pytest-xdist
- pip:
- python-dateutil==2.5.3
+ - hypothesis>=3.58.0
diff --git a/ci/travis-36-doc.yaml b/ci/travis-36-doc.yaml
index abb0426dbe08e..9cbc46d0a70d7 100644
--- a/ci/travis-36-doc.yaml
+++ b/ci/travis-36-doc.yaml
@@ -10,6 +10,7 @@ dependencies:
- fastparquet
- feather-format
- html5lib
+ - hypothesis>=3.58.0
- ipykernel
- ipython
- ipywidgets
diff --git a/ci/travis-36-numpydev.yaml b/ci/travis-36-numpydev.yaml
index 038c6537622dd..aba28634edd0d 100644
--- a/ci/travis-36-numpydev.yaml
+++ b/ci/travis-36-numpydev.yaml
@@ -8,6 +8,7 @@ dependencies:
# universal
- pytest
- pytest-xdist
+ - hypothesis>=3.58.0
- pip:
- "git+git://github.com/dateutil/dateutil.git"
- "-f https://7933911d6844c6c53a7d-47bd50c35cd79bd838daf386af554a83.ssl.cf2.rackcdn.com"
diff --git a/ci/travis-36-slow.yaml b/ci/travis-36-slow.yaml
index f6738e3837186..3157ecac3a902 100644
--- a/ci/travis-36-slow.yaml
+++ b/ci/travis-36-slow.yaml
@@ -28,3 +28,4 @@ dependencies:
- pytest
- pytest-xdist
- moto
+ - hypothesis>=3.58.0
diff --git a/ci/travis-36.yaml b/ci/travis-36.yaml
index 7eceba76cab96..990ad0fe87dd6 100644
--- a/ci/travis-36.yaml
+++ b/ci/travis-36.yaml
@@ -41,6 +41,7 @@ dependencies:
- pytest-xdist
- pytest-cov
- moto
+ - hypothesis>=3.58.0
- pip:
- brotlipy
- coverage
diff --git a/ci/travis-37.yaml b/ci/travis-37.yaml
index 1dc2930bf7287..4f2138d8555e3 100644
--- a/ci/travis-37.yaml
+++ b/ci/travis-37.yaml
@@ -12,3 +12,4 @@ dependencies:
- pytz
- pytest
- pytest-xdist
+ - hypothesis>=3.58.0
diff --git a/doc/source/contributing.rst b/doc/source/contributing.rst
index 625df2806add7..60bfd07961b38 100644
--- a/doc/source/contributing.rst
+++ b/doc/source/contributing.rst
@@ -820,6 +820,46 @@ Tests that we have ``parametrized`` are now accessible via the test name, for ex
test_cool_feature.py::test_series[int8] PASSED
+.. _using-hypothesis:
+
+Using ``hypothesis``
+~~~~~~~~~~~~~~~~~~~~
+
+Hypothesis is a library for property-based testing. Instead of explicitly
+parametrizing a test, you can describe *all* valid inputs and let Hypothesis
+try to find a failing input. Even better, no matter how many random examples
+it tries, Hypothesis always reports a single minimal counterexample to your
+assertions - often an example that you would never have thought to test.
+
+See `Getting Started with Hypothesis <https://hypothesis.works/articles/getting-started-with-hypothesis/>`_
+for more of an introduction, then `refer to the Hypothesis documentation
+for details <https://hypothesis.readthedocs.io/en/latest/index.html>`_.
+
+.. code-block:: python
+
+ import json
+ from hypothesis import given, strategies as st
+
+ any_json_value = st.deferred(lambda: st.one_of(
+ st.none(), st.booleans(), st.floats(allow_nan=False), st.text(),
+ st.lists(any_json_value), st.dictionaries(st.text(), any_json_value)
+ ))
+
+ @given(value=any_json_value)
+ def test_json_roundtrip(value):
+ result = json.loads(json.dumps(value))
+ assert value == result
+
+This test shows off several useful features of Hypothesis, as well as
+demonstrating a good use-case: checking properties that should hold over
+a large or complicated domain of inputs.
+
+To keep the Pandas test suite running quickly, parametrized tests are
+preferred if the inputs or logic are simple, with Hypothesis tests reserved
+for cases with complex logic or where there are too many combinations of
+options or subtle interactions to test (or think of!) all of them.
+
+
Running the test suite
----------------------
diff --git a/doc/source/install.rst b/doc/source/install.rst
index 08be1960eb957..4640da8b8239a 100644
--- a/doc/source/install.rst
+++ b/doc/source/install.rst
@@ -202,7 +202,8 @@ pandas is equipped with an exhaustive set of unit tests, covering about 97% of
the code base as of this writing. To run it on your machine to verify that
everything is working (and that you have all of the dependencies, soft and hard,
installed), make sure you have `pytest
-<http://docs.pytest.org/en/latest/>`__ >= 3.6 and run:
+<http://docs.pytest.org/en/latest/>`__ >= 3.6 and `Hypothesis
+<https://hypothesis.readthedocs.io/>`__ >= 3.58, then run:
::
diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 32085332caf40..3e22084d98234 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -729,6 +729,7 @@ Build Changes
^^^^^^^^^^^^^
- Building pandas for development now requires ``cython >= 0.28.2`` (:issue:`21688`)
+- Testing pandas now requires ``hypothesis>=3.58`` (:issue:22280). You can find `the Hypothesis docs here <https://hypothesis.readthedocs.io/en/latest/index.html>`_, and a pandas-specific introduction :ref:`in the contributing guide <using-hypothesis>` .
-
Other
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 94c07bc09267f..a49bab31f0bc8 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -450,3 +450,37 @@ def mock():
return importlib.import_module("unittest.mock")
else:
return pytest.importorskip("mock")
+
+
+# ----------------------------------------------------------------
+# Global setup for tests using Hypothesis
+
+from hypothesis import strategies as st
+
+# Registering these strategies makes them globally available via st.from_type,
+# which is use for offsets in tests/tseries/offsets/test_offsets_properties.py
+for name in 'MonthBegin MonthEnd BMonthBegin BMonthEnd'.split():
+ cls = getattr(pd.tseries.offsets, name)
+ st.register_type_strategy(cls, st.builds(
+ cls,
+ n=st.integers(-99, 99),
+ normalize=st.booleans(),
+ ))
+
+for name in 'YearBegin YearEnd BYearBegin BYearEnd'.split():
+ cls = getattr(pd.tseries.offsets, name)
+ st.register_type_strategy(cls, st.builds(
+ cls,
+ n=st.integers(-5, 5),
+ normalize=st.booleans(),
+ month=st.integers(min_value=1, max_value=12),
+ ))
+
+for name in 'QuarterBegin QuarterEnd BQuarterBegin BQuarterEnd'.split():
+ cls = getattr(pd.tseries.offsets, name)
+ st.register_type_strategy(cls, st.builds(
+ cls,
+ n=st.integers(-24, 24),
+ normalize=st.booleans(),
+ startingMonth=st.integers(min_value=1, max_value=12)
+ ))
diff --git a/pandas/tests/tseries/offsets/test_offsets_properties.py b/pandas/tests/tseries/offsets/test_offsets_properties.py
new file mode 100644
index 0000000000000..f19066ba76b20
--- /dev/null
+++ b/pandas/tests/tseries/offsets/test_offsets_properties.py
@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""
+Behavioral based tests for offsets and date_range.
+
+This file is adapted from https://github.com/pandas-dev/pandas/pull/18761 -
+which was more ambitious but less idiomatic in its use of Hypothesis.
+
+You may wish to consult the previous version for inspiration on further
+tests, or when trying to pin down the bugs exposed by the tests below.
+"""
+
+import pytest
+from hypothesis import given, assume, strategies as st
+from hypothesis.extra.pytz import timezones as pytz_timezones
+from hypothesis.extra.dateutil import timezones as dateutil_timezones
+
+import pandas as pd
+
+from pandas.tseries.offsets import (
+ MonthEnd, MonthBegin, BMonthEnd, BMonthBegin,
+ QuarterEnd, QuarterBegin, BQuarterEnd, BQuarterBegin,
+ YearEnd, YearBegin, BYearEnd, BYearBegin,
+)
+
+# ----------------------------------------------------------------
+# Helpers for generating random data
+
+gen_date_range = st.builds(
+ pd.date_range,
+ start=st.datetimes(
+ # TODO: Choose the min/max values more systematically
+ min_value=pd.Timestamp(1900, 1, 1).to_pydatetime(),
+ max_value=pd.Timestamp(2100, 1, 1).to_pydatetime()
+ ),
+ periods=st.integers(min_value=2, max_value=100),
+ freq=st.sampled_from('Y Q M D H T s ms us ns'.split()),
+ tz=st.one_of(st.none(), dateutil_timezones(), pytz_timezones()),
+)
+
+gen_random_datetime = st.datetimes(
+ min_value=pd.Timestamp.min.to_pydatetime(),
+ max_value=pd.Timestamp.max.to_pydatetime(),
+ timezones=st.one_of(st.none(), dateutil_timezones(), pytz_timezones())
+)
+
+# The strategy for each type is registered in conftest.py, as they don't carry
+# enough runtime information (e.g. type hints) to infer how to build them.
+gen_yqm_offset = st.one_of(*map(st.from_type, [
+ MonthBegin, MonthEnd, BMonthBegin, BMonthEnd,
+ QuarterBegin, QuarterEnd, BQuarterBegin, BQuarterEnd,
+ YearBegin, YearEnd, BYearBegin, BYearEnd
+]))
+
+
+# ----------------------------------------------------------------
+# Offset-specific behaviour tests
+
+
+# Based on CI runs: Always passes on OSX, fails on Linux, sometimes on Windows
+@pytest.mark.xfail(strict=False, reason='inconsistent between OSs, Pythons')
+@given(gen_random_datetime, gen_yqm_offset)
+def test_on_offset_implementations(dt, offset):
+ assume(not offset.normalize)
+ # check that the class-specific implementations of onOffset match
+ # the general case definition:
+ # (dt + offset) - offset == dt
+ compare = (dt + offset) - offset
+ assert offset.onOffset(dt) == (compare == dt)
+
+
+@pytest.mark.xfail(strict=True)
+@given(gen_yqm_offset, gen_date_range)
+def test_apply_index_implementations(offset, rng):
+ # offset.apply_index(dti)[i] should match dti[i] + offset
+ assume(offset.n != 0) # TODO: test for that case separately
+
+ # rng = pd.date_range(start='1/1/2000', periods=100000, freq='T')
+ ser = pd.Series(rng)
+
+ res = rng + offset
+ res_v2 = offset.apply_index(rng)
+ assert (res == res_v2).all()
+
+ assert res[0] == rng[0] + offset
+ assert res[-1] == rng[-1] + offset
+ res2 = ser + offset
+ # apply_index is only for indexes, not series, so no res2_v2
+ assert res2.iloc[0] == ser.iloc[0] + offset
+ assert res2.iloc[-1] == ser.iloc[-1] + offset
+ # TODO: Check randomly assorted entries, not just first/last
+
+
+@pytest.mark.xfail(strict=True)
+@given(gen_yqm_offset)
+def test_shift_across_dst(offset):
+ # GH#18319 check that 1) timezone is correctly normalized and
+ # 2) that hour is not incorrectly changed by this normalization
+ # Note that dti includes a transition across DST boundary
+ dti = pd.date_range(start='2017-10-30 12:00:00', end='2017-11-06',
+ freq='D', tz='US/Eastern')
+ assert (dti.hour == 12).all() # we haven't screwed up yet
+
+ res = dti + offset
+ assert (res.hour == 12).all()
diff --git a/pandas/tests/tseries/offsets/test_ticks.py b/pandas/tests/tseries/offsets/test_ticks.py
index 24033d4ff6cbd..914d61a18ee11 100644
--- a/pandas/tests/tseries/offsets/test_ticks.py
+++ b/pandas/tests/tseries/offsets/test_ticks.py
@@ -6,6 +6,7 @@
import pytest
import numpy as np
+from hypothesis import given, assume, example, strategies as st
from pandas import Timedelta, Timestamp
from pandas.tseries import offsets
@@ -35,6 +36,45 @@ def test_delta_to_tick():
assert (tick == offsets.Day(3))
+@pytest.mark.parametrize('cls', tick_classes)
+@example(n=2, m=3)
+@example(n=800, m=300)
+@example(n=1000, m=5)
+@given(n=st.integers(-999, 999), m=st.integers(-999, 999))
+def test_tick_add_sub(cls, n, m):
+ # For all Tick subclasses and all integers n, m, we should have
+ # tick(n) + tick(m) == tick(n+m)
+ # tick(n) - tick(m) == tick(n-m)
+ left = cls(n)
+ right = cls(m)
+ expected = cls(n + m)
+
+ assert left + right == expected
+ assert left.apply(right) == expected
+
+ expected = cls(n - m)
+ assert left - right == expected
+
+
+@pytest.mark.parametrize('cls', tick_classes)
+@example(n=2, m=3)
+@given(n=st.integers(-999, 999), m=st.integers(-999, 999))
+def test_tick_equality(cls, n, m):
+ assume(m != n)
+ # tick == tock iff tick.n == tock.n
+ left = cls(n)
+ right = cls(m)
+ assert left != right
+ assert not (left == right)
+
+ right = cls(n)
+ assert left == right
+ assert not (left != right)
+
+ if n != 0:
+ assert cls(n) != cls(-n)
+
+
# ---------------------------------------------------------------------
@@ -200,21 +240,8 @@ def test_tick_zero(cls1, cls2):
@pytest.mark.parametrize('cls', tick_classes)
def test_tick_equalities(cls):
- assert cls(3) == cls(3)
assert cls() == cls(1)
- # not equals
- assert cls(3) != cls(2)
- assert cls(3) != cls(-3)
-
-
-@pytest.mark.parametrize('cls', tick_classes)
-def test_tick_operators(cls):
- assert cls(3) + cls(2) == cls(5)
- assert cls(3) - cls(2) == cls(1)
- assert cls(800) + cls(300) == cls(1100)
- assert cls(1000) - cls(5) == cls(995)
-
@pytest.mark.parametrize('cls', tick_classes)
def test_tick_offset(cls):
@@ -226,11 +253,9 @@ def test_compare_ticks(cls):
three = cls(3)
four = cls(4)
- # TODO: WTF? What is this range(10) supposed to do?
- for _ in range(10):
- assert three < cls(4)
- assert cls(3) < four
- assert four > cls(3)
- assert cls(4) > three
- assert cls(3) == cls(3)
- assert cls(3) != cls(4)
+ assert three < cls(4)
+ assert cls(3) < four
+ assert four > cls(3)
+ assert cls(4) > three
+ assert cls(3) == cls(3)
+ assert cls(3) != cls(4)
diff --git a/pandas/util/_tester.py b/pandas/util/_tester.py
index d18467f17ec5b..aad2f00fa0478 100644
--- a/pandas/util/_tester.py
+++ b/pandas/util/_tester.py
@@ -12,6 +12,10 @@ def test(extra_args=None):
import pytest
except ImportError:
raise ImportError("Need pytest>=3.0 to run tests")
+ try:
+ import hypothesis # noqa
+ except ImportError:
+ raise ImportError("Need hypothesis>=3.58 to run tests")
cmd = ['--skip-slow', '--skip-network']
if extra_args:
if not isinstance(extra_args, list):
| This pull request has no features or bugfixes for Pandas itself (though it does have a whatsnew entry for contributors), but adds support for and actually adds a few tests using Hypothesis. The new section of the contributing guide below should explain what this means and why it's desirable. There are basically three contributions here:
1. Contributor documentation and all the dependency setup to support Hypothesis tests in CI.
2. A pleasantly concise pair of passing tests in `test_ticks.py`.
3. Three *failing* tests in `test_offsets_properties.py` based on #18761 by @jbrockmendel. I've made these idiomatic from the Hypothesis side, but while it seems likely that at least `test_on_offset_implementations` might be finding real bugs fixing them is beyond me at the moment. I thought it worth including them anyway, with an `xfail` decorator.
Future work on Hypothesis tests could focus on such fruitful areas as round-tripping data via any of the serialisation formats Pandas offers (I tried to write a demo of this and couldn't get it to pass), or the melt and merge tests that @TomAugspurger mentioned.
Closes #17978, after which more specific issues could be opened with suggested tests. | https://api.github.com/repos/pandas-dev/pandas/pulls/22280 | 2018-08-11T13:04:53Z | 2018-08-25T02:05:41Z | 2018-08-25T02:05:40Z | 2018-08-28T00:05:08Z |
Added table as Allowed `orient` Value in to_json Docs(#22272) | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 08d9191d72a8a..ac7278953e658 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1952,13 +1952,13 @@ def to_json(self, path_or_buf=None, orient=None, date_format=None,
* Series
- default is 'index'
- - allowed values are: {'split','records','index'}
+ - allowed values are: {'split','records','index','table'}
* DataFrame
- default is 'columns'
- allowed values are:
- {'split','records','index','columns','values'}
+ {'split','records','index','columns','values','table'}
* The format of the JSON string
| - [x] closes #22272
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22277 | 2018-08-11T00:50:32Z | 2018-08-11T01:37:09Z | 2018-08-11T01:37:09Z | 2018-08-11T01:37:15Z |
Replace tar_csv.tar.gz with gzipped tar | diff --git a/pandas/tests/io/parser/data/tar_csv.tar.gz b/pandas/tests/io/parser/data/tar_csv.tar.gz
index b5a0f3e1b5805..80505d345f1e2 100644
Binary files a/pandas/tests/io/parser/data/tar_csv.tar.gz and b/pandas/tests/io/parser/data/tar_csv.tar.gz differ
| tar was not compressed previously
| https://api.github.com/repos/pandas-dev/pandas/pulls/22269 | 2018-08-10T10:36:39Z | 2018-08-17T11:17:54Z | 2018-08-17T11:17:54Z | 2018-08-17T12:25:54Z |
Continue Collecting Arithmetic Tests | diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index 77e8da6c44af2..a27199b58cf5e 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -5,6 +5,7 @@
import operator
from datetime import datetime, timedelta
import warnings
+from itertools import product, starmap
import numpy as np
import pytest
@@ -64,6 +65,32 @@ def test_tz_aware_scalar_comparison(self, timestamps):
class TestDatetime64SeriesComparison(object):
+ # TODO: moved from tests.series.test_operators; needs cleanup
+ def test_comparison_invalid(self):
+ # GH#4968
+ # invalid date/int comparisons
+ ser = Series(range(5))
+ ser2 = Series(pd.date_range('20010101', periods=5))
+
+ for (x, y) in [(ser, ser2), (ser2, ser)]:
+
+ result = x == y
+ expected = Series([False] * 5)
+ tm.assert_series_equal(result, expected)
+
+ result = x != y
+ expected = Series([True] * 5)
+ tm.assert_series_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ x >= y
+ with pytest.raises(TypeError):
+ x > y
+ with pytest.raises(TypeError):
+ x < y
+ with pytest.raises(TypeError):
+ x <= y
+
@pytest.mark.parametrize('data', [
[Timestamp('2011-01-01'), NaT, Timestamp('2011-01-03')],
[Timedelta('1 days'), NaT, Timedelta('3 days')],
@@ -1360,7 +1387,95 @@ def test_dti_sub_pi(self, dti_freq, pi_freq, op, box):
with pytest.raises(TypeError):
op(dti, pi)
- # -------------------------------------------------------------
+ # -------------------------------------------------------------------
+ # TODO: Most of this block is moved from series or frame tests, needs
+ # cleanup, box-parametrization, and de-duplication
+
+ @pytest.mark.parametrize('op', [operator.add, operator.sub])
+ def test_timedelta64_equal_timedelta_supported_ops(self, op):
+ ser = Series([Timestamp('20130301'),
+ Timestamp('20130228 23:00:00'),
+ Timestamp('20130228 22:00:00'),
+ Timestamp('20130228 21:00:00')])
+
+ intervals = ['D', 'h', 'm', 's', 'us']
+
+ # TODO: unused
+ # npy16_mappings = {'D': 24 * 60 * 60 * 1000000,
+ # 'h': 60 * 60 * 1000000,
+ # 'm': 60 * 1000000,
+ # 's': 1000000,
+ # 'us': 1}
+
+ def timedelta64(*args):
+ return sum(starmap(np.timedelta64, zip(args, intervals)))
+
+ for d, h, m, s, us in product(*([range(2)] * 5)):
+ nptd = timedelta64(d, h, m, s, us)
+ pytd = timedelta(days=d, hours=h, minutes=m, seconds=s,
+ microseconds=us)
+ lhs = op(ser, nptd)
+ rhs = op(ser, pytd)
+
+ tm.assert_series_equal(lhs, rhs)
+
+ def test_ops_nat_mixed_datetime64_timedelta64(self):
+ # GH#11349
+ timedelta_series = Series([NaT, Timedelta('1s')])
+ datetime_series = Series([NaT, Timestamp('19900315')])
+ nat_series_dtype_timedelta = Series([NaT, NaT],
+ dtype='timedelta64[ns]')
+ nat_series_dtype_timestamp = Series([NaT, NaT], dtype='datetime64[ns]')
+ single_nat_dtype_datetime = Series([NaT], dtype='datetime64[ns]')
+ single_nat_dtype_timedelta = Series([NaT], dtype='timedelta64[ns]')
+
+ # subtraction
+ tm.assert_series_equal(datetime_series - single_nat_dtype_datetime,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(datetime_series - single_nat_dtype_timedelta,
+ nat_series_dtype_timestamp)
+ tm.assert_series_equal(-single_nat_dtype_timedelta + datetime_series,
+ nat_series_dtype_timestamp)
+
+ # without a Series wrapping the NaT, it is ambiguous
+ # whether it is a datetime64 or timedelta64
+ # defaults to interpreting it as timedelta64
+ tm.assert_series_equal(nat_series_dtype_timestamp -
+ single_nat_dtype_datetime,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(nat_series_dtype_timestamp -
+ single_nat_dtype_timedelta,
+ nat_series_dtype_timestamp)
+ tm.assert_series_equal(-single_nat_dtype_timedelta +
+ nat_series_dtype_timestamp,
+ nat_series_dtype_timestamp)
+
+ with pytest.raises(TypeError):
+ timedelta_series - single_nat_dtype_datetime
+
+ # addition
+ tm.assert_series_equal(nat_series_dtype_timestamp +
+ single_nat_dtype_timedelta,
+ nat_series_dtype_timestamp)
+ tm.assert_series_equal(single_nat_dtype_timedelta +
+ nat_series_dtype_timestamp,
+ nat_series_dtype_timestamp)
+
+ tm.assert_series_equal(nat_series_dtype_timestamp +
+ single_nat_dtype_timedelta,
+ nat_series_dtype_timestamp)
+ tm.assert_series_equal(single_nat_dtype_timedelta +
+ nat_series_dtype_timestamp,
+ nat_series_dtype_timestamp)
+
+ tm.assert_series_equal(nat_series_dtype_timedelta +
+ single_nat_dtype_datetime,
+ nat_series_dtype_timestamp)
+ tm.assert_series_equal(single_nat_dtype_datetime +
+ nat_series_dtype_timedelta,
+ nat_series_dtype_timestamp)
def test_ufunc_coercions(self):
idx = date_range('2011-01-01', periods=3, freq='2D', name='x')
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index 44aaba2885bf7..71742d428ea3e 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -4,6 +4,8 @@
# Specifically for numeric dtypes
from datetime import timedelta
from decimal import Decimal
+import operator
+from collections import Iterable
import pytest
import numpy as np
@@ -12,6 +14,7 @@
import pandas.util.testing as tm
from pandas.compat import PY3
+from pandas.core import ops
from pandas import Timedelta, Series, Index, TimedeltaIndex
@@ -382,17 +385,12 @@ def test_div_int(self, idx):
expected = Index(idx.values / 2)
tm.assert_index_equal(result, expected)
- def test_mul_int(self, idx):
- result = idx * 1
- tm.assert_index_equal(result, idx)
+ @pytest.mark.parametrize('op', [operator.mul, ops.rmul, operator.floordiv])
+ def test_mul_int_identity(self, op, idx, box):
+ idx = tm.box_expected(idx, box)
- def test_rmul_int(self, idx):
- result = 1 * idx
- tm.assert_index_equal(result, idx)
-
- def test_floordiv_int(self, idx):
- result = idx // 1
- tm.assert_index_equal(result, idx)
+ result = op(idx, 1)
+ tm.assert_equal(result, idx)
def test_mul_int_array(self, idx):
didx = idx * idx
@@ -434,22 +432,26 @@ def test_mul_size_mismatch_raises(self, idx):
with pytest.raises(ValueError):
idx * np.array([1, 2])
- def test_pow_float(self, idx):
+ @pytest.mark.parametrize('op', [operator.pow, ops.rpow])
+ def test_pow_float(self, op, idx, box):
# test power calculations both ways, GH#14973
- expected = pd.Float64Index(idx.values**2.0)
- result = idx**2.0
- tm.assert_index_equal(result, expected)
+ expected = pd.Float64Index(op(idx.values, 2.0))
- def test_rpow_float(self, idx):
- # test power calculations both ways, GH#14973
- expected = pd.Float64Index(2.0**idx.values)
- result = 2.0**idx
- tm.assert_index_equal(result, expected)
+ idx = tm.box_expected(idx, box)
+ expected = tm.box_expected(expected, box)
+
+ result = op(idx, 2.0)
+ tm.assert_equal(result, expected)
- def test_modulo(self, idx):
+ def test_modulo(self, idx, box):
# GH#9244
expected = Index(idx.values % 2)
- tm.assert_index_equal(idx % 2, expected)
+
+ idx = tm.box_expected(idx, box)
+ expected = tm.box_expected(expected, box)
+
+ result = idx % 2
+ tm.assert_equal(result, expected)
def test_divmod(self, idx):
result = divmod(idx, 2)
@@ -479,56 +481,282 @@ def test_divmod_series(self, idx):
for r, e in zip(result, expected):
tm.assert_series_equal(r, e)
+ @pytest.mark.parametrize('other', [np.nan, 7, -23, 2.718, -3.14, np.inf])
+ def test_ops_np_scalar(self, other):
+ vals = np.random.randn(5, 3)
+ f = lambda x: pd.DataFrame(x, index=list('ABCDE'),
+ columns=['jim', 'joe', 'jolie'])
+
+ df = f(vals)
+
+ tm.assert_frame_equal(df / np.array(other), f(vals / other))
+ tm.assert_frame_equal(np.array(other) * df, f(vals * other))
+ tm.assert_frame_equal(df + np.array(other), f(vals + other))
+ tm.assert_frame_equal(np.array(other) - df, f(other - vals))
+
+ # TODO: This came from series.test.test_operators, needs cleanup
+ def test_operators_frame(self):
+ # rpow does not work with DataFrame
+ ts = tm.makeTimeSeries()
+ ts.name = 'ts'
+
+ df = pd.DataFrame({'A': ts})
+
+ tm.assert_series_equal(ts + ts, ts + df['A'],
+ check_names=False)
+ tm.assert_series_equal(ts ** ts, ts ** df['A'],
+ check_names=False)
+ tm.assert_series_equal(ts < ts, ts < df['A'],
+ check_names=False)
+ tm.assert_series_equal(ts / ts, ts / df['A'],
+ check_names=False)
+
class TestAdditionSubtraction(object):
# __add__, __sub__, __radd__, __rsub__, __iadd__, __isub__
# for non-timestamp/timedelta/period dtypes
- pass
+
+ # TODO: This came from series.test.test_operators, needs cleanup
+ def test_arith_ops_df_compat(self):
+ # GH#1134
+ s1 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
+ s2 = pd.Series([2, 2, 2], index=list('ABD'), name='x')
+
+ exp = pd.Series([3.0, 4.0, np.nan, np.nan],
+ index=list('ABCD'), name='x')
+ tm.assert_series_equal(s1 + s2, exp)
+ tm.assert_series_equal(s2 + s1, exp)
+
+ exp = pd.DataFrame({'x': [3.0, 4.0, np.nan, np.nan]},
+ index=list('ABCD'))
+ tm.assert_frame_equal(s1.to_frame() + s2.to_frame(), exp)
+ tm.assert_frame_equal(s2.to_frame() + s1.to_frame(), exp)
+
+ # different length
+ s3 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
+ s4 = pd.Series([2, 2, 2, 2], index=list('ABCD'), name='x')
+
+ exp = pd.Series([3, 4, 5, np.nan],
+ index=list('ABCD'), name='x')
+ tm.assert_series_equal(s3 + s4, exp)
+ tm.assert_series_equal(s4 + s3, exp)
+
+ exp = pd.DataFrame({'x': [3, 4, 5, np.nan]},
+ index=list('ABCD'))
+ tm.assert_frame_equal(s3.to_frame() + s4.to_frame(), exp)
+ tm.assert_frame_equal(s4.to_frame() + s3.to_frame(), exp)
+
+ # TODO: This came from series.test.test_operators, needs cleanup
+ def test_series_frame_radd_bug(self):
+ # GH#353
+ vals = pd.Series(tm.rands_array(5, 10))
+ result = 'foo_' + vals
+ expected = vals.map(lambda x: 'foo_' + x)
+ tm.assert_series_equal(result, expected)
+
+ frame = pd.DataFrame({'vals': vals})
+ result = 'foo_' + frame
+ expected = pd.DataFrame({'vals': vals.map(lambda x: 'foo_' + x)})
+ tm.assert_frame_equal(result, expected)
+
+ ts = tm.makeTimeSeries()
+ ts.name = 'ts'
+
+ # really raise this time
+ now = pd.Timestamp.now().to_pydatetime()
+ with pytest.raises(TypeError):
+ now + ts
+
+ with pytest.raises(TypeError):
+ ts + now
+
+ # TODO: This came from series.test.test_operators, needs cleanup
+ def test_datetime64_with_index(self):
+ # arithmetic integer ops with an index
+ ser = pd.Series(np.random.randn(5))
+ expected = ser - ser.index.to_series()
+ result = ser - ser.index
+ tm.assert_series_equal(result, expected)
+
+ # GH#4629
+ # arithmetic datetime64 ops with an index
+ ser = pd.Series(pd.date_range('20130101', periods=5),
+ index=pd.date_range('20130101', periods=5))
+ expected = ser - ser.index.to_series()
+ result = ser - ser.index
+ tm.assert_series_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ # GH#18850
+ result = ser - ser.index.to_period()
+
+ df = pd.DataFrame(np.random.randn(5, 2),
+ index=pd.date_range('20130101', periods=5))
+ df['date'] = pd.Timestamp('20130102')
+ df['expected'] = df['date'] - df.index.to_series()
+ df['result'] = df['date'] - df.index
+ tm.assert_series_equal(df['result'], df['expected'], check_names=False)
+
+ # TODO: taken from tests.frame.test_operators, needs cleanup
+ def test_frame_operators(self):
+ seriesd = tm.getSeriesData()
+ frame = pd.DataFrame(seriesd)
+ frame2 = pd.DataFrame(seriesd, columns=['D', 'C', 'B', 'A'])
+
+ garbage = np.random.random(4)
+ colSeries = pd.Series(garbage, index=np.array(frame.columns))
+
+ idSum = frame + frame
+ seriesSum = frame + colSeries
+
+ for col, series in idSum.items():
+ for idx, val in series.items():
+ origVal = frame[col][idx] * 2
+ if not np.isnan(val):
+ assert val == origVal
+ else:
+ assert np.isnan(origVal)
+
+ for col, series in seriesSum.items():
+ for idx, val in series.items():
+ origVal = frame[col][idx] + colSeries[col]
+ if not np.isnan(val):
+ assert val == origVal
+ else:
+ assert np.isnan(origVal)
+
+ added = frame2 + frame2
+ expected = frame2 * 2
+ tm.assert_frame_equal(added, expected)
+
+ df = pd.DataFrame({'a': ['a', None, 'b']})
+ tm.assert_frame_equal(df + df,
+ pd.DataFrame({'a': ['aa', np.nan, 'bb']}))
+
+ # Test for issue #10181
+ for dtype in ('float', 'int64'):
+ frames = [
+ pd.DataFrame(dtype=dtype),
+ pd.DataFrame(columns=['A'], dtype=dtype),
+ pd.DataFrame(index=[0], dtype=dtype),
+ ]
+ for df in frames:
+ assert (df + df).equals(df)
+ tm.assert_frame_equal(df + df, df)
+
+ # TODO: taken from tests.series.test_operators; needs cleanup
+ def test_series_operators(self):
+ def _check_op(series, other, op, pos_only=False, check_dtype=True):
+ left = np.abs(series) if pos_only else series
+ right = np.abs(other) if pos_only else other
+
+ cython_or_numpy = op(left, right)
+ python = left.combine(right, op)
+ tm.assert_series_equal(cython_or_numpy, python,
+ check_dtype=check_dtype)
+
+ def check(series, other):
+ simple_ops = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'mod']
+
+ for opname in simple_ops:
+ _check_op(series, other, getattr(operator, opname))
+
+ _check_op(series, other, operator.pow, pos_only=True)
+
+ _check_op(series, other, lambda x, y: operator.add(y, x))
+ _check_op(series, other, lambda x, y: operator.sub(y, x))
+ _check_op(series, other, lambda x, y: operator.truediv(y, x))
+ _check_op(series, other, lambda x, y: operator.floordiv(y, x))
+ _check_op(series, other, lambda x, y: operator.mul(y, x))
+ _check_op(series, other, lambda x, y: operator.pow(y, x),
+ pos_only=True)
+ _check_op(series, other, lambda x, y: operator.mod(y, x))
+
+ tser = tm.makeTimeSeries().rename('ts')
+ check(tser, tser * 2)
+ check(tser, tser * 0)
+ check(tser, tser[::2])
+ check(tser, 5)
+
+ def check_comparators(series, other, check_dtype=True):
+ _check_op(series, other, operator.gt, check_dtype=check_dtype)
+ _check_op(series, other, operator.ge, check_dtype=check_dtype)
+ _check_op(series, other, operator.eq, check_dtype=check_dtype)
+ _check_op(series, other, operator.lt, check_dtype=check_dtype)
+ _check_op(series, other, operator.le, check_dtype=check_dtype)
+
+ check_comparators(tser, 5)
+ check_comparators(tser, tser + 1, check_dtype=False)
+
+ # TODO: taken from tests.series.test_operators; needs cleanup
+ def test_divmod(self):
+ def check(series, other):
+ results = divmod(series, other)
+ if isinstance(other, Iterable) and len(series) != len(other):
+ # if the lengths don't match, this is the test where we use
+ # `tser[::2]`. Pad every other value in `other_np` with nan.
+ other_np = []
+ for n in other:
+ other_np.append(n)
+ other_np.append(np.nan)
+ else:
+ other_np = other
+ other_np = np.asarray(other_np)
+ with np.errstate(all='ignore'):
+ expecteds = divmod(series.values, np.asarray(other_np))
+
+ for result, expected in zip(results, expecteds):
+ # check the values, name, and index separately
+ tm.assert_almost_equal(np.asarray(result), expected)
+
+ assert result.name == series.name
+ tm.assert_index_equal(result.index, series.index)
+
+ tser = tm.makeTimeSeries().rename('ts')
+ check(tser, tser * 2)
+ check(tser, tser * 0)
+ check(tser, tser[::2])
+ check(tser, 5)
class TestObjectDtypeEquivalence(object):
# Tests that arithmetic operations match operations executed elementwise
@pytest.mark.parametrize('dtype', [None, object])
- def test_series_with_dtype_radd_nan(self, dtype):
+ def test_numarr_with_dtype_add_nan(self, dtype, box):
ser = pd.Series([1, 2, 3], dtype=dtype)
expected = pd.Series([np.nan, np.nan, np.nan], dtype=dtype)
+ ser = tm.box_expected(ser, box)
+ expected = tm.box_expected(expected, box)
+
result = np.nan + ser
- tm.assert_series_equal(result, expected)
+ tm.assert_equal(result, expected)
result = ser + np.nan
- tm.assert_series_equal(result, expected)
+ tm.assert_equal(result, expected)
@pytest.mark.parametrize('dtype', [None, object])
- def test_series_with_dtype_radd_int(self, dtype):
+ def test_numarr_with_dtype_add_int(self, dtype, box):
ser = pd.Series([1, 2, 3], dtype=dtype)
expected = pd.Series([2, 3, 4], dtype=dtype)
+ ser = tm.box_expected(ser, box)
+ expected = tm.box_expected(expected, box)
+
result = 1 + ser
- tm.assert_series_equal(result, expected)
+ tm.assert_equal(result, expected)
result = ser + 1
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_df_with_dtype_radd_nan(self, dtype):
- df = pd.DataFrame([1, 2, 3], dtype=dtype)
- expected = pd.DataFrame([np.nan, np.nan, np.nan], dtype=dtype)
-
- result = np.nan + df
- tm.assert_frame_equal(result, expected)
-
- result = df + np.nan
- tm.assert_frame_equal(result, expected)
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_df_with_dtype_radd_int(self, dtype):
- df = pd.DataFrame([1, 2, 3], dtype=dtype)
- expected = pd.DataFrame([2, 3, 4], dtype=dtype)
+ tm.assert_equal(result, expected)
- result = 1 + df
- tm.assert_frame_equal(result, expected)
+ # TODO: moved from tests.series.test_operators; needs cleanup
+ @pytest.mark.parametrize('op', [operator.add, operator.sub, operator.mul,
+ operator.truediv, operator.floordiv])
+ def test_operators_reverse_object(self, op):
+ # GH#56
+ arr = pd.Series(np.random.randn(10), index=np.arange(10), dtype=object)
- result = df + 1
- tm.assert_frame_equal(result, expected)
+ result = op(1., arr)
+ expected = op(1., arr.astype(float))
+ tm.assert_series_equal(result.astype(float), expected)
diff --git a/pandas/tests/arithmetic/test_object.py b/pandas/tests/arithmetic/test_object.py
index e27ba6af39b90..c02c3becbd556 100644
--- a/pandas/tests/arithmetic/test_object.py
+++ b/pandas/tests/arithmetic/test_object.py
@@ -2,12 +2,14 @@
# Arithmetc tests for DataFrame/Series/Index/Array classes that should
# behave identically.
# Specifically for object dtype
+import operator
import pytest
import numpy as np
import pandas as pd
import pandas.util.testing as tm
+from pandas.core import ops
from pandas import Series, Timestamp
@@ -17,6 +19,18 @@
class TestObjectComparisons(object):
+ def test_comparison_object_numeric_nas(self):
+ ser = Series(np.random.randn(10), dtype=object)
+ shifted = ser.shift(2)
+
+ ops = ['lt', 'le', 'gt', 'ge', 'eq', 'ne']
+ for op in ops:
+ func = getattr(operator, op)
+
+ result = func(ser, shifted)
+ expected = func(ser.astype(float), shifted.astype(float))
+ tm.assert_series_equal(result, expected)
+
def test_object_comparisons(self):
ser = Series(['a', 'b', np.nan, 'c', 'a'])
@@ -58,32 +72,40 @@ def test_more_na_comparisons(self, dtype):
# Arithmetic
class TestArithmetic(object):
- def test_df_radd_str(self):
- df = pd.DataFrame(['x', np.nan, 'x'])
-
- expected = pd.DataFrame(['ax', np.nan, 'ax'])
- result = 'a' + df
- tm.assert_frame_equal(result, expected)
- expected = pd.DataFrame(['xa', np.nan, 'xa'])
- result = df + 'a'
- tm.assert_frame_equal(result, expected)
-
- def test_series_radd_str(self):
+ @pytest.mark.parametrize('box', [
+ pytest.param(pd.Index,
+ marks=pytest.mark.xfail(reason="Does not mask nulls",
+ strict=True, raises=TypeError)),
+ pd.Series,
+ pd.DataFrame
+ ], ids=lambda x: x.__name__)
+ def test_objarr_add_str(self, box):
+ ser = pd.Series(['x', np.nan, 'x'])
+ expected = pd.Series(['xa', np.nan, 'xa'])
+
+ ser = tm.box_expected(ser, box)
+ expected = tm.box_expected(expected, box)
+
+ result = ser + 'a'
+ tm.assert_equal(result, expected)
+
+ @pytest.mark.parametrize('box', [
+ pytest.param(pd.Index,
+ marks=pytest.mark.xfail(reason="Does not mask nulls",
+ strict=True, raises=TypeError)),
+ pd.Series,
+ pd.DataFrame
+ ], ids=lambda x: x.__name__)
+ def test_objarr_radd_str(self, box):
ser = pd.Series(['x', np.nan, 'x'])
- tm.assert_series_equal('a' + ser, pd.Series(['ax', np.nan, 'ax']))
- tm.assert_series_equal(ser + 'a', pd.Series(['xa', np.nan, 'xa']))
+ expected = pd.Series(['ax', np.nan, 'ax'])
- @pytest.mark.parametrize('data', [
- [1, 2, 3],
- [1.1, 2.2, 3.3],
- [pd.Timestamp('2011-01-01'), pd.Timestamp('2011-01-02'), pd.NaT],
- ['x', 'y', 1]])
- @pytest.mark.parametrize('dtype', [None, object])
- def test_df_radd_str_invalid(self, dtype, data):
- df = pd.DataFrame(data, dtype=dtype)
- with pytest.raises(TypeError):
- 'foo_' + df
+ ser = tm.box_expected(ser, box)
+ expected = tm.box_expected(expected, box)
+
+ result = 'a' + ser
+ tm.assert_equal(result, expected)
@pytest.mark.parametrize('data', [
[1, 2, 3],
@@ -91,21 +113,54 @@ def test_df_radd_str_invalid(self, dtype, data):
[Timestamp('2011-01-01'), Timestamp('2011-01-02'), pd.NaT],
['x', 'y', 1]])
@pytest.mark.parametrize('dtype', [None, object])
- def test_series_radd_str_invalid(self, dtype, data):
+ def test_objarr_radd_str_invalid(self, dtype, data, box):
ser = Series(data, dtype=dtype)
+
+ ser = tm.box_expected(ser, box)
with pytest.raises(TypeError):
'foo_' + ser
- # TODO: parametrize, better name
- def test_object_ser_add_invalid(self):
+ @pytest.mark.parametrize('op', [operator.add, ops.radd,
+ operator.sub, ops.rsub])
+ def test_objarr_add_invalid(self, op, box):
# invalid ops
+ if box is pd.DataFrame and op is ops.radd:
+ pytest.xfail(reason="DataFrame op incorrectly casts the np.array"
+ "case to M8[ns]")
+
obj_ser = tm.makeObjectSeries()
obj_ser.name = 'objects'
+
+ obj_ser = tm.box_expected(obj_ser, box)
with pytest.raises(Exception):
- obj_ser + 1
- with pytest.raises(Exception):
- obj_ser + np.array(1, dtype=np.int64)
- with pytest.raises(Exception):
- obj_ser - 1
+ op(obj_ser, 1)
with pytest.raises(Exception):
- obj_ser - np.array(1, dtype=np.int64)
+ op(obj_ser, np.array(1, dtype=np.int64))
+
+ # TODO: Moved from tests.series.test_operators; needs cleanup
+ def test_operators_na_handling(self):
+ ser = Series(['foo', 'bar', 'baz', np.nan])
+ result = 'prefix_' + ser
+ expected = pd.Series(['prefix_foo', 'prefix_bar',
+ 'prefix_baz', np.nan])
+ tm.assert_series_equal(result, expected)
+
+ result = ser + '_suffix'
+ expected = pd.Series(['foo_suffix', 'bar_suffix',
+ 'baz_suffix', np.nan])
+ tm.assert_series_equal(result, expected)
+
+ # TODO: parametrize over box
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_series_with_dtype_radd_timedelta(self, dtype):
+ # note this test is _not_ aimed at timedelta64-dtyped Series
+ ser = pd.Series([pd.Timedelta('1 days'), pd.Timedelta('2 days'),
+ pd.Timedelta('3 days')], dtype=dtype)
+ expected = pd.Series([pd.Timedelta('4 days'), pd.Timedelta('5 days'),
+ pd.Timedelta('6 days')])
+
+ result = pd.Timedelta('3 days') + ser
+ tm.assert_series_equal(result, expected)
+
+ result = ser + pd.Timedelta('3 days')
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 1c677cebd3bb0..9a17dc580ff6c 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -1,12 +1,17 @@
# -*- coding: utf-8 -*-
+import operator
+
import pytest
import numpy as np
-from pandas.compat import range
+from pandas.compat import range, PY3
+import pandas.io.formats.printing as printing
import pandas as pd
import pandas.util.testing as tm
+from pandas.tests.frame.common import _check_mixed_float, _check_mixed_int
+
# -------------------------------------------------------------------
# Comparisons
@@ -78,3 +83,171 @@ def test_df_add_flex_filled_mixed_dtypes(self):
dtype='datetime64[ns]'),
'B': ser * 2})
tm.assert_frame_equal(result, expected)
+
+ def test_arith_flex_frame(self):
+ seriesd = tm.getSeriesData()
+ frame = pd.DataFrame(seriesd).copy()
+
+ mixed_float = pd.DataFrame({'A': frame['A'].copy().astype('float32'),
+ 'B': frame['B'].copy().astype('float32'),
+ 'C': frame['C'].copy().astype('float16'),
+ 'D': frame['D'].copy().astype('float64')})
+
+ intframe = pd.DataFrame({k: v.astype(int)
+ for k, v in seriesd.items()})
+ mixed_int = pd.DataFrame({'A': intframe['A'].copy().astype('int32'),
+ 'B': np.ones(len(intframe), dtype='uint64'),
+ 'C': intframe['C'].copy().astype('uint8'),
+ 'D': intframe['D'].copy().astype('int64')})
+
+ # force these all to int64 to avoid platform testing issues
+ intframe = pd.DataFrame({c: s for c, s in intframe.items()},
+ dtype=np.int64)
+
+ ops = ['add', 'sub', 'mul', 'div', 'truediv', 'pow', 'floordiv', 'mod']
+ if not PY3:
+ aliases = {}
+ else:
+ aliases = {'div': 'truediv'}
+
+ for op in ops:
+ try:
+ alias = aliases.get(op, op)
+ f = getattr(operator, alias)
+ result = getattr(frame, op)(2 * frame)
+ exp = f(frame, 2 * frame)
+ tm.assert_frame_equal(result, exp)
+
+ # vs mix float
+ result = getattr(mixed_float, op)(2 * mixed_float)
+ exp = f(mixed_float, 2 * mixed_float)
+ tm.assert_frame_equal(result, exp)
+ _check_mixed_float(result, dtype=dict(C=None))
+
+ # vs mix int
+ if op in ['add', 'sub', 'mul']:
+ result = getattr(mixed_int, op)(2 + mixed_int)
+ exp = f(mixed_int, 2 + mixed_int)
+
+ # no overflow in the uint
+ dtype = None
+ if op in ['sub']:
+ dtype = dict(B='uint64', C=None)
+ elif op in ['add', 'mul']:
+ dtype = dict(C=None)
+ tm.assert_frame_equal(result, exp)
+ _check_mixed_int(result, dtype=dtype)
+
+ # rops
+ r_f = lambda x, y: f(y, x)
+ result = getattr(frame, 'r' + op)(2 * frame)
+ exp = r_f(frame, 2 * frame)
+ tm.assert_frame_equal(result, exp)
+
+ # vs mix float
+ result = getattr(mixed_float, op)(2 * mixed_float)
+ exp = f(mixed_float, 2 * mixed_float)
+ tm.assert_frame_equal(result, exp)
+ _check_mixed_float(result, dtype=dict(C=None))
+
+ result = getattr(intframe, op)(2 * intframe)
+ exp = f(intframe, 2 * intframe)
+ tm.assert_frame_equal(result, exp)
+
+ # vs mix int
+ if op in ['add', 'sub', 'mul']:
+ result = getattr(mixed_int, op)(2 + mixed_int)
+ exp = f(mixed_int, 2 + mixed_int)
+
+ # no overflow in the uint
+ dtype = None
+ if op in ['sub']:
+ dtype = dict(B='uint64', C=None)
+ elif op in ['add', 'mul']:
+ dtype = dict(C=None)
+ tm.assert_frame_equal(result, exp)
+ _check_mixed_int(result, dtype=dtype)
+ except:
+ printing.pprint_thing("Failing operation %r" % op)
+ raise
+
+ # ndim >= 3
+ ndim_5 = np.ones(frame.shape + (3, 4, 5))
+ msg = "Unable to coerce to Series/DataFrame"
+ with tm.assert_raises_regex(ValueError, msg):
+ f(frame, ndim_5)
+
+ with tm.assert_raises_regex(ValueError, msg):
+ getattr(frame, op)(ndim_5)
+
+ # res_add = frame.add(frame)
+ # res_sub = frame.sub(frame)
+ # res_mul = frame.mul(frame)
+ # res_div = frame.div(2 * frame)
+
+ # tm.assert_frame_equal(res_add, frame + frame)
+ # tm.assert_frame_equal(res_sub, frame - frame)
+ # tm.assert_frame_equal(res_mul, frame * frame)
+ # tm.assert_frame_equal(res_div, frame / (2 * frame))
+
+ const_add = frame.add(1)
+ tm.assert_frame_equal(const_add, frame + 1)
+
+ # corner cases
+ result = frame.add(frame[:0])
+ tm.assert_frame_equal(result, frame * np.nan)
+
+ result = frame[:0].add(frame)
+ tm.assert_frame_equal(result, frame * np.nan)
+ with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
+ frame.add(frame.iloc[0], fill_value=3)
+ with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
+ frame.add(frame.iloc[0], axis='index', fill_value=3)
+
+ def test_arith_flex_series(self):
+ arr = np.array([[1., 2., 3.],
+ [4., 5., 6.],
+ [7., 8., 9.]])
+ df = pd.DataFrame(arr, columns=['one', 'two', 'three'],
+ index=['a', 'b', 'c'])
+
+ row = df.xs('a')
+ col = df['two']
+ # after arithmetic refactor, add truediv here
+ ops = ['add', 'sub', 'mul', 'mod']
+ for op in ops:
+ f = getattr(df, op)
+ op = getattr(operator, op)
+ tm.assert_frame_equal(f(row), op(df, row))
+ tm.assert_frame_equal(f(col, axis=0), op(df.T, col).T)
+
+ # special case for some reason
+ tm.assert_frame_equal(df.add(row, axis=None), df + row)
+
+ # cases which will be refactored after big arithmetic refactor
+ tm.assert_frame_equal(df.div(row), df / row)
+ tm.assert_frame_equal(df.div(col, axis=0), (df.T / col).T)
+
+ # broadcasting issue in GH#7325
+ df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='int64')
+ expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
+ result = df.div(df[0], axis='index')
+ tm.assert_frame_equal(result, expected)
+
+ df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='float64')
+ expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
+ result = df.div(df[0], axis='index')
+ tm.assert_frame_equal(result, expected)
+
+ def test_arith_flex_zero_len_raises(self):
+ # GH#19522 passing fill_value to frame flex arith methods should
+ # raise even in the zero-length special cases
+ ser_len0 = pd.Series([])
+ df_len0 = pd.DataFrame([], columns=['A', 'B'])
+ df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B'])
+
+ with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
+ df.add(ser_len0, fill_value='E')
+
+ with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
+ df_len0.sub(df['A'], axis=None, fill_value=3)
diff --git a/pandas/tests/frame/test_operators.py b/pandas/tests/frame/test_operators.py
index a11d673fd5d7f..2fc59c5003a4d 100644
--- a/pandas/tests/frame/test_operators.py
+++ b/pandas/tests/frame/test_operators.py
@@ -8,7 +8,7 @@
import pytest
-from numpy import nan, random
+from numpy import nan
import numpy as np
from pandas.compat import range
@@ -16,7 +16,6 @@
from pandas import (DataFrame, Series, MultiIndex, Timestamp,
date_range)
import pandas.core.common as com
-import pandas.io.formats.printing as printing
import pandas as pd
from pandas.util.testing import (assert_numpy_array_equal,
@@ -25,66 +24,11 @@
import pandas.util.testing as tm
-from pandas.tests.frame.common import (TestData, _check_mixed_float,
- _check_mixed_int)
+from pandas.tests.frame.common import TestData, _check_mixed_float
class TestDataFrameOperators(TestData):
- def test_operators(self):
- garbage = random.random(4)
- colSeries = Series(garbage, index=np.array(self.frame.columns))
-
- idSum = self.frame + self.frame
- seriesSum = self.frame + colSeries
-
- for col, series in compat.iteritems(idSum):
- for idx, val in compat.iteritems(series):
- origVal = self.frame[col][idx] * 2
- if not np.isnan(val):
- assert val == origVal
- else:
- assert np.isnan(origVal)
-
- for col, series in compat.iteritems(seriesSum):
- for idx, val in compat.iteritems(series):
- origVal = self.frame[col][idx] + colSeries[col]
- if not np.isnan(val):
- assert val == origVal
- else:
- assert np.isnan(origVal)
-
- added = self.frame2 + self.frame2
- expected = self.frame2 * 2
- assert_frame_equal(added, expected)
-
- df = DataFrame({'a': ['a', None, 'b']})
- assert_frame_equal(df + df, DataFrame({'a': ['aa', np.nan, 'bb']}))
-
- # Test for issue #10181
- for dtype in ('float', 'int64'):
- frames = [
- DataFrame(dtype=dtype),
- DataFrame(columns=['A'], dtype=dtype),
- DataFrame(index=[0], dtype=dtype),
- ]
- for df in frames:
- assert (df + df).equals(df)
- assert_frame_equal(df + df, df)
-
- @pytest.mark.parametrize('other', [nan, 7, -23, 2.718, -3.14, np.inf])
- def test_ops_np_scalar(self, other):
- vals = np.random.randn(5, 3)
- f = lambda x: DataFrame(x, index=list('ABCDE'),
- columns=['jim', 'joe', 'jolie'])
-
- df = f(vals)
-
- assert_frame_equal(df / np.array(other), f(vals / other))
- assert_frame_equal(np.array(other) * df, f(vals * other))
- assert_frame_equal(df + np.array(other), f(vals + other))
- assert_frame_equal(np.array(other) - df, f(other - vals))
-
def test_operators_boolean(self):
# GH 5808
@@ -347,122 +291,6 @@ def test_pos_raises(self, df):
with pytest.raises(TypeError):
(+ df['a'])
- def test_arith_flex_frame(self):
- ops = ['add', 'sub', 'mul', 'div', 'truediv', 'pow', 'floordiv', 'mod']
- if not compat.PY3:
- aliases = {}
- else:
- aliases = {'div': 'truediv'}
-
- for op in ops:
- try:
- alias = aliases.get(op, op)
- f = getattr(operator, alias)
- result = getattr(self.frame, op)(2 * self.frame)
- exp = f(self.frame, 2 * self.frame)
- assert_frame_equal(result, exp)
-
- # vs mix float
- result = getattr(self.mixed_float, op)(2 * self.mixed_float)
- exp = f(self.mixed_float, 2 * self.mixed_float)
- assert_frame_equal(result, exp)
- _check_mixed_float(result, dtype=dict(C=None))
-
- # vs mix int
- if op in ['add', 'sub', 'mul']:
- result = getattr(self.mixed_int, op)(2 + self.mixed_int)
- exp = f(self.mixed_int, 2 + self.mixed_int)
-
- # no overflow in the uint
- dtype = None
- if op in ['sub']:
- dtype = dict(B='uint64', C=None)
- elif op in ['add', 'mul']:
- dtype = dict(C=None)
- assert_frame_equal(result, exp)
- _check_mixed_int(result, dtype=dtype)
-
- # rops
- r_f = lambda x, y: f(y, x)
- result = getattr(self.frame, 'r' + op)(2 * self.frame)
- exp = r_f(self.frame, 2 * self.frame)
- assert_frame_equal(result, exp)
-
- # vs mix float
- result = getattr(self.mixed_float, op)(
- 2 * self.mixed_float)
- exp = f(self.mixed_float, 2 * self.mixed_float)
- assert_frame_equal(result, exp)
- _check_mixed_float(result, dtype=dict(C=None))
-
- result = getattr(self.intframe, op)(2 * self.intframe)
- exp = f(self.intframe, 2 * self.intframe)
- assert_frame_equal(result, exp)
-
- # vs mix int
- if op in ['add', 'sub', 'mul']:
- result = getattr(self.mixed_int, op)(
- 2 + self.mixed_int)
- exp = f(self.mixed_int, 2 + self.mixed_int)
-
- # no overflow in the uint
- dtype = None
- if op in ['sub']:
- dtype = dict(B='uint64', C=None)
- elif op in ['add', 'mul']:
- dtype = dict(C=None)
- assert_frame_equal(result, exp)
- _check_mixed_int(result, dtype=dtype)
- except:
- printing.pprint_thing("Failing operation %r" % op)
- raise
-
- # ndim >= 3
- ndim_5 = np.ones(self.frame.shape + (3, 4, 5))
- msg = "Unable to coerce to Series/DataFrame"
- with tm.assert_raises_regex(ValueError, msg):
- f(self.frame, ndim_5)
-
- with tm.assert_raises_regex(ValueError, msg):
- getattr(self.frame, op)(ndim_5)
-
- # res_add = self.frame.add(self.frame)
- # res_sub = self.frame.sub(self.frame)
- # res_mul = self.frame.mul(self.frame)
- # res_div = self.frame.div(2 * self.frame)
-
- # assert_frame_equal(res_add, self.frame + self.frame)
- # assert_frame_equal(res_sub, self.frame - self.frame)
- # assert_frame_equal(res_mul, self.frame * self.frame)
- # assert_frame_equal(res_div, self.frame / (2 * self.frame))
-
- const_add = self.frame.add(1)
- assert_frame_equal(const_add, self.frame + 1)
-
- # corner cases
- result = self.frame.add(self.frame[:0])
- assert_frame_equal(result, self.frame * np.nan)
-
- result = self.frame[:0].add(self.frame)
- assert_frame_equal(result, self.frame * np.nan)
- with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
- self.frame.add(self.frame.iloc[0], fill_value=3)
- with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
- self.frame.add(self.frame.iloc[0], axis='index', fill_value=3)
-
- def test_arith_flex_zero_len_raises(self):
- # GH#19522 passing fill_value to frame flex arith methods should
- # raise even in the zero-length special cases
- ser_len0 = pd.Series([])
- df_len0 = pd.DataFrame([], columns=['A', 'B'])
- df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B'])
-
- with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
- df.add(ser_len0, fill_value='E')
-
- with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
- df_len0.sub(df['A'], axis=None, fill_value=3)
-
def test_binary_ops_align(self):
# test aligning binary ops
@@ -690,37 +518,6 @@ def test_dti_tz_convert_to_utc(self):
exp = DataFrame({'A': [np.nan, 3, np.nan]}, index=base)
assert_frame_equal(df1 + df2, exp)
- def test_arith_flex_series(self):
- df = self.simple
-
- row = df.xs('a')
- col = df['two']
- # after arithmetic refactor, add truediv here
- ops = ['add', 'sub', 'mul', 'mod']
- for op in ops:
- f = getattr(df, op)
- op = getattr(operator, op)
- assert_frame_equal(f(row), op(df, row))
- assert_frame_equal(f(col, axis=0), op(df.T, col).T)
-
- # special case for some reason
- assert_frame_equal(df.add(row, axis=None), df + row)
-
- # cases which will be refactored after big arithmetic refactor
- assert_frame_equal(df.div(row), df / row)
- assert_frame_equal(df.div(col, axis=0), (df.T / col).T)
-
- # broadcasting issue in GH7325
- df = DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='int64')
- expected = DataFrame([[nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
- result = df.div(df[0], axis='index')
- assert_frame_equal(result, expected)
-
- df = DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='float64')
- expected = DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
- result = df.div(df[0], axis='index')
- assert_frame_equal(result, expected)
-
def test_arith_non_pandas_object(self):
df = self.simple
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 15b30ec2c774a..41064b84abc36 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-from datetime import timedelta
import operator
import numpy as np
@@ -75,33 +74,3 @@ def test_ser_cmp_result_names(self, names, op):
ser = Series(cidx).rename(names[1])
result = op(ser, cidx)
assert result.name == names[2]
-
-
-class TestTimedeltaSeriesComparisons(object):
- def test_compare_timedelta_series(self):
- # regresssion test for GH5963
- s = pd.Series([timedelta(days=1), timedelta(days=2)])
- actual = s > timedelta(days=1)
- expected = pd.Series([False, True])
- tm.assert_series_equal(actual, expected)
-
-
-# ------------------------------------------------------------------
-# Arithmetic
-
-class TestSeriesArithmetic(object):
- # Standard, numeric, or otherwise not-Timestamp/Timedelta/Period dtypes
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_series_with_dtype_radd_timedelta(self, dtype):
- # note this test is _not_ aimed at timedelta64-dtyped Series
- ser = pd.Series([pd.Timedelta('1 days'), pd.Timedelta('2 days'),
- pd.Timedelta('3 days')], dtype=dtype)
- expected = pd.Series([pd.Timedelta('4 days'), pd.Timedelta('5 days'),
- pd.Timedelta('6 days')])
-
- result = pd.Timedelta('3 days') + ser
- tm.assert_series_equal(result, expected)
-
- result = ser + pd.Timedelta('3 days')
- tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_operators.py b/pandas/tests/series/test_operators.py
index c5d8d93bd768b..5e5e9c0895ccf 100644
--- a/pandas/tests/series/test_operators.py
+++ b/pandas/tests/series/test_operators.py
@@ -3,10 +3,8 @@
import pytest
-from collections import Iterable
from datetime import datetime, timedelta
import operator
-from itertools import product, starmap
from numpy import nan
import numpy as np
@@ -15,13 +13,12 @@
from pandas import (Index, Series, DataFrame, isna, bdate_range,
NaT, date_range, timedelta_range, Categorical)
from pandas.core.indexes.datetimes import Timestamp
-from pandas.core.indexes.timedeltas import Timedelta
import pandas.core.nanops as nanops
-from pandas.compat import range, zip
+from pandas.compat import range
from pandas import compat
from pandas.util.testing import (assert_series_equal, assert_almost_equal,
- assert_frame_equal, assert_index_equal)
+ assert_frame_equal)
import pandas.util.testing as tm
from .common import TestData
@@ -182,39 +179,6 @@ def test_bool_operators_with_nas(self, bool_op):
expected[mask] = False
assert_series_equal(result, expected)
- def test_comparison_object_numeric_nas(self):
- ser = Series(np.random.randn(10), dtype=object)
- shifted = ser.shift(2)
-
- ops = ['lt', 'le', 'gt', 'ge', 'eq', 'ne']
- for op in ops:
- func = getattr(operator, op)
-
- result = func(ser, shifted)
- expected = func(ser.astype(float), shifted.astype(float))
- assert_series_equal(result, expected)
-
- def test_comparison_invalid(self):
- # GH4968
- # invalid date/int comparisons
- s = Series(range(5))
- s2 = Series(date_range('20010101', periods=5))
-
- for (x, y) in [(s, s2), (s2, s)]:
-
- result = x == y
- expected = Series([False] * 5)
- assert_series_equal(result, expected)
-
- result = x != y
- expected = Series([True] * 5)
- assert_series_equal(result, expected)
-
- pytest.raises(TypeError, lambda: x >= y)
- pytest.raises(TypeError, lambda: x > y)
- pytest.raises(TypeError, lambda: x < y)
- pytest.raises(TypeError, lambda: x <= y)
-
def test_unequal_categorical_comparison_raises_type_error(self):
# unequal comparison should raise for unordered cats
cat = Series(Categorical(list("abc")))
@@ -498,158 +462,6 @@ def test_comp_ops_df_compat(self):
left.to_frame() < right.to_frame()
-class TestTimedeltaSeriesArithmetic(object):
-
- def test_operators_timedelta64(self):
- # series ops
- v1 = date_range('2012-1-1', periods=3, freq='D')
- v2 = date_range('2012-1-2', periods=3, freq='D')
- rs = Series(v2) - Series(v1)
- xp = Series(1e9 * 3600 * 24,
- rs.index).astype('int64').astype('timedelta64[ns]')
- assert_series_equal(rs, xp)
- assert rs.dtype == 'timedelta64[ns]'
-
- df = DataFrame(dict(A=v1))
- td = Series([timedelta(days=i) for i in range(3)])
- assert td.dtype == 'timedelta64[ns]'
-
- # series on the rhs
- result = df['A'] - df['A'].shift()
- assert result.dtype == 'timedelta64[ns]'
-
- result = df['A'] + td
- assert result.dtype == 'M8[ns]'
-
- # scalar Timestamp on rhs
- maxa = df['A'].max()
- assert isinstance(maxa, Timestamp)
-
- resultb = df['A'] - df['A'].max()
- assert resultb.dtype == 'timedelta64[ns]'
-
- # timestamp on lhs
- result = resultb + df['A']
- values = [Timestamp('20111230'), Timestamp('20120101'),
- Timestamp('20120103')]
- expected = Series(values, name='A')
- assert_series_equal(result, expected)
-
- # datetimes on rhs
- result = df['A'] - datetime(2001, 1, 1)
- expected = Series(
- [timedelta(days=4017 + i) for i in range(3)], name='A')
- assert_series_equal(result, expected)
- assert result.dtype == 'm8[ns]'
-
- d = datetime(2001, 1, 1, 3, 4)
- resulta = df['A'] - d
- assert resulta.dtype == 'm8[ns]'
-
- # roundtrip
- resultb = resulta + d
- assert_series_equal(df['A'], resultb)
-
- # timedeltas on rhs
- td = timedelta(days=1)
- resulta = df['A'] + td
- resultb = resulta - td
- assert_series_equal(resultb, df['A'])
- assert resultb.dtype == 'M8[ns]'
-
- # roundtrip
- td = timedelta(minutes=5, seconds=3)
- resulta = df['A'] + td
- resultb = resulta - td
- assert_series_equal(df['A'], resultb)
- assert resultb.dtype == 'M8[ns]'
-
- # inplace
- value = rs[2] + np.timedelta64(timedelta(minutes=5, seconds=1))
- rs[2] += np.timedelta64(timedelta(minutes=5, seconds=1))
- assert rs[2] == value
-
- def test_timedelta64_ops_nat(self):
- # GH 11349
- timedelta_series = Series([NaT, Timedelta('1s')])
- nat_series_dtype_timedelta = Series([NaT, NaT],
- dtype='timedelta64[ns]')
- single_nat_dtype_timedelta = Series([NaT], dtype='timedelta64[ns]')
-
- # subtraction
- assert_series_equal(timedelta_series - NaT,
- nat_series_dtype_timedelta)
- assert_series_equal(-NaT + timedelta_series,
- nat_series_dtype_timedelta)
-
- assert_series_equal(timedelta_series - single_nat_dtype_timedelta,
- nat_series_dtype_timedelta)
- assert_series_equal(-single_nat_dtype_timedelta + timedelta_series,
- nat_series_dtype_timedelta)
-
- # addition
- assert_series_equal(nat_series_dtype_timedelta + NaT,
- nat_series_dtype_timedelta)
- assert_series_equal(NaT + nat_series_dtype_timedelta,
- nat_series_dtype_timedelta)
-
- assert_series_equal(nat_series_dtype_timedelta +
- single_nat_dtype_timedelta,
- nat_series_dtype_timedelta)
- assert_series_equal(single_nat_dtype_timedelta +
- nat_series_dtype_timedelta,
- nat_series_dtype_timedelta)
-
- assert_series_equal(timedelta_series + NaT,
- nat_series_dtype_timedelta)
- assert_series_equal(NaT + timedelta_series,
- nat_series_dtype_timedelta)
-
- assert_series_equal(timedelta_series + single_nat_dtype_timedelta,
- nat_series_dtype_timedelta)
- assert_series_equal(single_nat_dtype_timedelta + timedelta_series,
- nat_series_dtype_timedelta)
-
- assert_series_equal(nat_series_dtype_timedelta + NaT,
- nat_series_dtype_timedelta)
- assert_series_equal(NaT + nat_series_dtype_timedelta,
- nat_series_dtype_timedelta)
-
- assert_series_equal(nat_series_dtype_timedelta +
- single_nat_dtype_timedelta,
- nat_series_dtype_timedelta)
- assert_series_equal(single_nat_dtype_timedelta +
- nat_series_dtype_timedelta,
- nat_series_dtype_timedelta)
-
- # multiplication
- assert_series_equal(nat_series_dtype_timedelta * 1.0,
- nat_series_dtype_timedelta)
- assert_series_equal(1.0 * nat_series_dtype_timedelta,
- nat_series_dtype_timedelta)
-
- assert_series_equal(timedelta_series * 1, timedelta_series)
- assert_series_equal(1 * timedelta_series, timedelta_series)
-
- assert_series_equal(timedelta_series * 1.5,
- Series([NaT, Timedelta('1.5s')]))
- assert_series_equal(1.5 * timedelta_series,
- Series([NaT, Timedelta('1.5s')]))
-
- assert_series_equal(timedelta_series * nan,
- nat_series_dtype_timedelta)
- assert_series_equal(nan * timedelta_series,
- nat_series_dtype_timedelta)
-
- # division
- assert_series_equal(timedelta_series / 2,
- Series([NaT, Timedelta('0.5s')]))
- assert_series_equal(timedelta_series / 2.0,
- Series([NaT, Timedelta('0.5s')]))
- assert_series_equal(timedelta_series / nan,
- nat_series_dtype_timedelta)
-
-
class TestDatetimeSeriesArithmetic(object):
def test_operators_datetimelike_invalid(self, all_arithmetic_operators):
@@ -739,8 +551,10 @@ class TestSeriesOperators(TestData):
'truediv', 'div', 'pow'])
def test_op_method(self, opname, ts):
# check that Series.{opname} behaves like Series.__{opname}__,
- series = ts[0](self.ts)
- other = ts[1](self.ts)
+ tser = tm.makeTimeSeries().rename('ts')
+
+ series = ts[0](tser)
+ other = ts[1](tser)
check_reverse = ts[2]
if opname == 'div' and compat.PY3:
@@ -768,188 +582,11 @@ def test_neg(self):
def test_invert(self):
assert_series_equal(-(self.series < 0), ~(self.series < 0))
- def test_operators(self):
- def _check_op(series, other, op, pos_only=False,
- check_dtype=True):
- left = np.abs(series) if pos_only else series
- right = np.abs(other) if pos_only else other
-
- cython_or_numpy = op(left, right)
- python = left.combine(right, op)
- assert_series_equal(cython_or_numpy, python,
- check_dtype=check_dtype)
-
- def check(series, other):
- simple_ops = ['add', 'sub', 'mul', 'truediv', 'floordiv', 'mod']
-
- for opname in simple_ops:
- _check_op(series, other, getattr(operator, opname))
-
- _check_op(series, other, operator.pow, pos_only=True)
-
- _check_op(series, other, lambda x, y: operator.add(y, x))
- _check_op(series, other, lambda x, y: operator.sub(y, x))
- _check_op(series, other, lambda x, y: operator.truediv(y, x))
- _check_op(series, other, lambda x, y: operator.floordiv(y, x))
- _check_op(series, other, lambda x, y: operator.mul(y, x))
- _check_op(series, other, lambda x, y: operator.pow(y, x),
- pos_only=True)
- _check_op(series, other, lambda x, y: operator.mod(y, x))
-
- check(self.ts, self.ts * 2)
- check(self.ts, self.ts * 0)
- check(self.ts, self.ts[::2])
- check(self.ts, 5)
-
- def check_comparators(series, other, check_dtype=True):
- _check_op(series, other, operator.gt, check_dtype=check_dtype)
- _check_op(series, other, operator.ge, check_dtype=check_dtype)
- _check_op(series, other, operator.eq, check_dtype=check_dtype)
- _check_op(series, other, operator.lt, check_dtype=check_dtype)
- _check_op(series, other, operator.le, check_dtype=check_dtype)
-
- check_comparators(self.ts, 5)
- check_comparators(self.ts, self.ts + 1, check_dtype=False)
-
- def test_divmod(self):
- def check(series, other):
- results = divmod(series, other)
- if isinstance(other, Iterable) and len(series) != len(other):
- # if the lengths don't match, this is the test where we use
- # `self.ts[::2]`. Pad every other value in `other_np` with nan.
- other_np = []
- for n in other:
- other_np.append(n)
- other_np.append(np.nan)
- else:
- other_np = other
- other_np = np.asarray(other_np)
- with np.errstate(all='ignore'):
- expecteds = divmod(series.values, np.asarray(other_np))
-
- for result, expected in zip(results, expecteds):
- # check the values, name, and index separately
- assert_almost_equal(np.asarray(result), expected)
-
- assert result.name == series.name
- assert_index_equal(result.index, series.index)
-
- check(self.ts, self.ts * 2)
- check(self.ts, self.ts * 0)
- check(self.ts, self.ts[::2])
- check(self.ts, 5)
-
def test_operators_empty_int_corner(self):
s1 = Series([], [], dtype=np.int32)
s2 = Series({'x': 0.})
assert_series_equal(s1 * s2, Series([np.nan], index=['x']))
- @pytest.mark.parametrize("m", [1, 3, 10])
- @pytest.mark.parametrize("unit", ['D', 'h', 'm', 's', 'ms', 'us', 'ns'])
- def test_timedelta64_conversions(self, m, unit):
-
- startdate = Series(date_range('2013-01-01', '2013-01-03'))
- enddate = Series(date_range('2013-03-01', '2013-03-03'))
-
- s1 = enddate - startdate
- s1[2] = np.nan
-
- # op
- expected = s1.apply(lambda x: x / np.timedelta64(m, unit))
- result = s1 / np.timedelta64(m, unit)
- assert_series_equal(result, expected)
-
- # reverse op
- expected = s1.apply(
- lambda x: Timedelta(np.timedelta64(m, unit)) / x)
- result = np.timedelta64(m, unit) / s1
- assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('op', [operator.add, operator.sub])
- def test_timedelta64_equal_timedelta_supported_ops(self, op):
- ser = Series([Timestamp('20130301'), Timestamp('20130228 23:00:00'),
- Timestamp('20130228 22:00:00'),
- Timestamp('20130228 21:00:00')])
-
- intervals = 'D', 'h', 'm', 's', 'us'
-
- # TODO: unused
- # npy16_mappings = {'D': 24 * 60 * 60 * 1000000,
- # 'h': 60 * 60 * 1000000,
- # 'm': 60 * 1000000,
- # 's': 1000000,
- # 'us': 1}
-
- def timedelta64(*args):
- return sum(starmap(np.timedelta64, zip(args, intervals)))
-
- for d, h, m, s, us in product(*([range(2)] * 5)):
- nptd = timedelta64(d, h, m, s, us)
- pytd = timedelta(days=d, hours=h, minutes=m, seconds=s,
- microseconds=us)
- lhs = op(ser, nptd)
- rhs = op(ser, pytd)
-
- assert_series_equal(lhs, rhs)
-
- def test_ops_nat_mixed_datetime64_timedelta64(self):
- # GH 11349
- timedelta_series = Series([NaT, Timedelta('1s')])
- datetime_series = Series([NaT, Timestamp('19900315')])
- nat_series_dtype_timedelta = Series([NaT, NaT],
- dtype='timedelta64[ns]')
- nat_series_dtype_timestamp = Series([NaT, NaT], dtype='datetime64[ns]')
- single_nat_dtype_datetime = Series([NaT], dtype='datetime64[ns]')
- single_nat_dtype_timedelta = Series([NaT], dtype='timedelta64[ns]')
-
- # subtraction
- assert_series_equal(datetime_series - single_nat_dtype_datetime,
- nat_series_dtype_timedelta)
-
- assert_series_equal(datetime_series - single_nat_dtype_timedelta,
- nat_series_dtype_timestamp)
- assert_series_equal(-single_nat_dtype_timedelta + datetime_series,
- nat_series_dtype_timestamp)
-
- # without a Series wrapping the NaT, it is ambiguous
- # whether it is a datetime64 or timedelta64
- # defaults to interpreting it as timedelta64
- assert_series_equal(nat_series_dtype_timestamp -
- single_nat_dtype_datetime,
- nat_series_dtype_timedelta)
-
- assert_series_equal(nat_series_dtype_timestamp -
- single_nat_dtype_timedelta,
- nat_series_dtype_timestamp)
- assert_series_equal(-single_nat_dtype_timedelta +
- nat_series_dtype_timestamp,
- nat_series_dtype_timestamp)
-
- with pytest.raises(TypeError):
- timedelta_series - single_nat_dtype_datetime
-
- # addition
- assert_series_equal(nat_series_dtype_timestamp +
- single_nat_dtype_timedelta,
- nat_series_dtype_timestamp)
- assert_series_equal(single_nat_dtype_timedelta +
- nat_series_dtype_timestamp,
- nat_series_dtype_timestamp)
-
- assert_series_equal(nat_series_dtype_timestamp +
- single_nat_dtype_timedelta,
- nat_series_dtype_timestamp)
- assert_series_equal(single_nat_dtype_timedelta +
- nat_series_dtype_timestamp,
- nat_series_dtype_timestamp)
-
- assert_series_equal(nat_series_dtype_timedelta +
- single_nat_dtype_datetime,
- nat_series_dtype_timestamp)
- assert_series_equal(single_nat_dtype_datetime +
- nat_series_dtype_timedelta,
- nat_series_dtype_timestamp)
-
def test_ops_datetimelike_align(self):
# GH 7500
# datetimelike ops need to align
@@ -1136,16 +773,6 @@ def test_operators_corner(self):
index=self.ts.index[:-5], name='ts')
tm.assert_series_equal(added[:-5], expected)
- @pytest.mark.parametrize('op', [operator.add, operator.sub, operator.mul,
- operator.truediv, operator.floordiv])
- def test_operators_reverse_object(self, op):
- # GH 56
- arr = Series(np.random.randn(10), index=np.arange(10), dtype=object)
-
- result = op(1., arr)
- expected = op(1., arr.astype(float))
- assert_series_equal(result.astype(float), expected)
-
pairings = []
for op in ['add', 'sub', 'mul', 'pow', 'truediv', 'floordiv']:
fv = 0
@@ -1214,41 +841,6 @@ def test_operators_na_handling(self):
assert isna(result[0])
assert isna(result2[0])
- s = Series(['foo', 'bar', 'baz', np.nan])
- result = 'prefix_' + s
- expected = Series(['prefix_foo', 'prefix_bar', 'prefix_baz', np.nan])
- assert_series_equal(result, expected)
-
- result = s + '_suffix'
- expected = Series(['foo_suffix', 'bar_suffix', 'baz_suffix', np.nan])
- assert_series_equal(result, expected)
-
- def test_datetime64_with_index(self):
- # arithmetic integer ops with an index
- ser = Series(np.random.randn(5))
- expected = ser - ser.index.to_series()
- result = ser - ser.index
- assert_series_equal(result, expected)
-
- # GH 4629
- # arithmetic datetime64 ops with an index
- ser = Series(date_range('20130101', periods=5),
- index=date_range('20130101', periods=5))
- expected = ser - ser.index.to_series()
- result = ser - ser.index
- assert_series_equal(result, expected)
-
- with pytest.raises(TypeError):
- # GH#18850
- result = ser - ser.index.to_period()
-
- df = DataFrame(np.random.randn(5, 2),
- index=date_range('20130101', periods=5))
- df['date'] = Timestamp('20130102')
- df['expected'] = df['date'] - df.index.to_series()
- df['result'] = df['date'] - df.index
- assert_series_equal(df['result'], df['expected'], check_names=False)
-
def test_op_duplicate_index(self):
# GH14227
s1 = Series([1, 2], index=[1, 1])
@@ -1306,43 +898,6 @@ def test_idxminmax_with_inf(self):
class TestSeriesOperationsDataFrameCompat(object):
- def test_operators_frame(self):
- # rpow does not work with DataFrame
- ts = tm.makeTimeSeries()
- ts.name = 'ts'
-
- df = DataFrame({'A': ts})
-
- assert_series_equal(ts + ts, ts + df['A'],
- check_names=False)
- assert_series_equal(ts ** ts, ts ** df['A'],
- check_names=False)
- assert_series_equal(ts < ts, ts < df['A'],
- check_names=False)
- assert_series_equal(ts / ts, ts / df['A'],
- check_names=False)
-
- def test_series_frame_radd_bug(self):
- # GH#353
- vals = Series(tm.rands_array(5, 10))
- result = 'foo_' + vals
- expected = vals.map(lambda x: 'foo_' + x)
- assert_series_equal(result, expected)
-
- frame = DataFrame({'vals': vals})
- result = 'foo_' + frame
- expected = DataFrame({'vals': vals.map(lambda x: 'foo_' + x)})
- assert_frame_equal(result, expected)
-
- ts = tm.makeTimeSeries()
- ts.name = 'ts'
-
- # really raise this time
- with pytest.raises(TypeError):
- datetime.now() + ts
-
- with pytest.raises(TypeError):
- ts + datetime.now()
def test_bool_ops_df_compat(self):
# GH 1134
@@ -1401,32 +956,3 @@ def test_bool_ops_df_compat(self):
index=list('ABCD'))
assert_frame_equal(s3.to_frame() | s4.to_frame(), exp)
assert_frame_equal(s4.to_frame() | s3.to_frame(), exp)
-
- def test_arith_ops_df_compat(self):
- # GH#1134
- s1 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
- s2 = pd.Series([2, 2, 2], index=list('ABD'), name='x')
-
- exp = pd.Series([3.0, 4.0, np.nan, np.nan],
- index=list('ABCD'), name='x')
- assert_series_equal(s1 + s2, exp)
- assert_series_equal(s2 + s1, exp)
-
- exp = pd.DataFrame({'x': [3.0, 4.0, np.nan, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s1.to_frame() + s2.to_frame(), exp)
- assert_frame_equal(s2.to_frame() + s1.to_frame(), exp)
-
- # different length
- s3 = pd.Series([1, 2, 3], index=list('ABC'), name='x')
- s4 = pd.Series([2, 2, 2, 2], index=list('ABCD'), name='x')
-
- exp = pd.Series([3, 4, 5, np.nan],
- index=list('ABCD'), name='x')
- assert_series_equal(s3 + s4, exp)
- assert_series_equal(s4 + s3, exp)
-
- exp = pd.DataFrame({'x': [3, 4, 5, np.nan]},
- index=list('ABCD'))
- assert_frame_equal(s3.to_frame() + s4.to_frame(), exp)
- assert_frame_equal(s4.to_frame() + s3.to_frame(), exp)
diff --git a/pandas/tests/test_arithmetic.py b/pandas/tests/test_arithmetic.py
index c4bc9c71927fb..30d69e243c446 100644
--- a/pandas/tests/test_arithmetic.py
+++ b/pandas/tests/test_arithmetic.py
@@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
# Arithmetc tests for DataFrame/Series/Index/Array classes that should
# behave identically.
-from datetime import timedelta
+from datetime import datetime, timedelta
import operator
import pytest
@@ -15,7 +15,8 @@
from pandas._libs.tslibs import IncompatibleFrequency
from pandas import (
timedelta_range,
- Timedelta, Timestamp, NaT, Series, TimedeltaIndex, DatetimeIndex)
+ Timedelta, Timestamp, NaT, Series, TimedeltaIndex, DatetimeIndex,
+ DataFrame)
# ------------------------------------------------------------------
@@ -78,6 +79,13 @@ def box_df_fail(request):
class TestTimedelta64ArrayComparisons(object):
# TODO: All of these need to be parametrized over box
+ def test_compare_timedelta_series(self):
+ # regresssion test for GH5963
+ s = pd.Series([timedelta(days=1), timedelta(days=2)])
+ actual = s > timedelta(days=1)
+ expected = pd.Series([False, True])
+ tm.assert_series_equal(actual, expected)
+
def test_tdi_cmp_str_invalid(self):
# GH#13624
tdi = TimedeltaIndex(['1 day', '2 days'])
@@ -242,6 +250,157 @@ def test_tdi_add_overflow(self):
class TestTimedeltaArraylikeAddSubOps(object):
# Tests for timedelta64[ns] __add__, __sub__, __radd__, __rsub__
+ # TODO: moved from tests.series.test_operators, needs splitting, cleanup,
+ # de-duplication, box-parametrization...
+ def test_operators_timedelta64(self):
+ # series ops
+ v1 = pd.date_range('2012-1-1', periods=3, freq='D')
+ v2 = pd.date_range('2012-1-2', periods=3, freq='D')
+ rs = Series(v2) - Series(v1)
+ xp = Series(1e9 * 3600 * 24,
+ rs.index).astype('int64').astype('timedelta64[ns]')
+ tm.assert_series_equal(rs, xp)
+ assert rs.dtype == 'timedelta64[ns]'
+
+ df = DataFrame(dict(A=v1))
+ td = Series([timedelta(days=i) for i in range(3)])
+ assert td.dtype == 'timedelta64[ns]'
+
+ # series on the rhs
+ result = df['A'] - df['A'].shift()
+ assert result.dtype == 'timedelta64[ns]'
+
+ result = df['A'] + td
+ assert result.dtype == 'M8[ns]'
+
+ # scalar Timestamp on rhs
+ maxa = df['A'].max()
+ assert isinstance(maxa, Timestamp)
+
+ resultb = df['A'] - df['A'].max()
+ assert resultb.dtype == 'timedelta64[ns]'
+
+ # timestamp on lhs
+ result = resultb + df['A']
+ values = [Timestamp('20111230'), Timestamp('20120101'),
+ Timestamp('20120103')]
+ expected = Series(values, name='A')
+ tm.assert_series_equal(result, expected)
+
+ # datetimes on rhs
+ result = df['A'] - datetime(2001, 1, 1)
+ expected = Series(
+ [timedelta(days=4017 + i) for i in range(3)], name='A')
+ tm.assert_series_equal(result, expected)
+ assert result.dtype == 'm8[ns]'
+
+ d = datetime(2001, 1, 1, 3, 4)
+ resulta = df['A'] - d
+ assert resulta.dtype == 'm8[ns]'
+
+ # roundtrip
+ resultb = resulta + d
+ tm.assert_series_equal(df['A'], resultb)
+
+ # timedeltas on rhs
+ td = timedelta(days=1)
+ resulta = df['A'] + td
+ resultb = resulta - td
+ tm.assert_series_equal(resultb, df['A'])
+ assert resultb.dtype == 'M8[ns]'
+
+ # roundtrip
+ td = timedelta(minutes=5, seconds=3)
+ resulta = df['A'] + td
+ resultb = resulta - td
+ tm.assert_series_equal(df['A'], resultb)
+ assert resultb.dtype == 'M8[ns]'
+
+ # inplace
+ value = rs[2] + np.timedelta64(timedelta(minutes=5, seconds=1))
+ rs[2] += np.timedelta64(timedelta(minutes=5, seconds=1))
+ assert rs[2] == value
+
+ def test_timedelta64_ops_nat(self):
+ # GH 11349
+ timedelta_series = Series([NaT, Timedelta('1s')])
+ nat_series_dtype_timedelta = Series([NaT, NaT],
+ dtype='timedelta64[ns]')
+ single_nat_dtype_timedelta = Series([NaT], dtype='timedelta64[ns]')
+
+ # subtraction
+ tm.assert_series_equal(timedelta_series - NaT,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(-NaT + timedelta_series,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(timedelta_series - single_nat_dtype_timedelta,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(-single_nat_dtype_timedelta + timedelta_series,
+ nat_series_dtype_timedelta)
+
+ # addition
+ tm.assert_series_equal(nat_series_dtype_timedelta + NaT,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(NaT + nat_series_dtype_timedelta,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(nat_series_dtype_timedelta +
+ single_nat_dtype_timedelta,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(single_nat_dtype_timedelta +
+ nat_series_dtype_timedelta,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(timedelta_series + NaT,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(NaT + timedelta_series,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(timedelta_series + single_nat_dtype_timedelta,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(single_nat_dtype_timedelta + timedelta_series,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(nat_series_dtype_timedelta + NaT,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(NaT + nat_series_dtype_timedelta,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(nat_series_dtype_timedelta +
+ single_nat_dtype_timedelta,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(single_nat_dtype_timedelta +
+ nat_series_dtype_timedelta,
+ nat_series_dtype_timedelta)
+
+ # multiplication
+ tm.assert_series_equal(nat_series_dtype_timedelta * 1.0,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(1.0 * nat_series_dtype_timedelta,
+ nat_series_dtype_timedelta)
+
+ tm.assert_series_equal(timedelta_series * 1, timedelta_series)
+ tm.assert_series_equal(1 * timedelta_series, timedelta_series)
+
+ tm.assert_series_equal(timedelta_series * 1.5,
+ Series([NaT, Timedelta('1.5s')]))
+ tm.assert_series_equal(1.5 * timedelta_series,
+ Series([NaT, Timedelta('1.5s')]))
+
+ tm.assert_series_equal(timedelta_series * np.nan,
+ nat_series_dtype_timedelta)
+ tm.assert_series_equal(np.nan * timedelta_series,
+ nat_series_dtype_timedelta)
+
+ # division
+ tm.assert_series_equal(timedelta_series / 2,
+ Series([NaT, Timedelta('0.5s')]))
+ tm.assert_series_equal(timedelta_series / 2.0,
+ Series([NaT, Timedelta('0.5s')]))
+ tm.assert_series_equal(timedelta_series / np.nan,
+ nat_series_dtype_timedelta)
+
# -------------------------------------------------------------
# Invalid Operations
@@ -967,6 +1126,27 @@ class TestTimedeltaArraylikeMulDivOps(object):
# Tests for timedelta64[ns]
# __mul__, __rmul__, __div__, __rdiv__, __floordiv__, __rfloordiv__
+ # TODO: Moved from tests.series.test_operators; needs cleanup
+ @pytest.mark.parametrize("m", [1, 3, 10])
+ @pytest.mark.parametrize("unit", ['D', 'h', 'm', 's', 'ms', 'us', 'ns'])
+ def test_timedelta64_conversions(self, m, unit):
+ startdate = Series(pd.date_range('2013-01-01', '2013-01-03'))
+ enddate = Series(pd.date_range('2013-03-01', '2013-03-03'))
+
+ ser = enddate - startdate
+ ser[2] = np.nan
+
+ # op
+ expected = Series([x / np.timedelta64(m, unit) for x in ser])
+ result = ser / np.timedelta64(m, unit)
+ tm.assert_series_equal(result, expected)
+
+ # reverse op
+ expected = Series([Timedelta(np.timedelta64(m, unit)) / x
+ for x in ser])
+ result = np.timedelta64(m, unit) / ser
+ tm.assert_series_equal(result, expected)
+
# ------------------------------------------------------------------
# Multiplication
# organized with scalar others first, then array-like
| A small amount of cleanup/parametrization, but mostly moving tests ~unchanged.
A few tests in tests.frame.test_operators are moved to tests.frame.test_arithmetic.
In a bunch of cases I'm trying to not move things that will cause merge conflicts with #22163; will get those in an upcoming pass. | https://api.github.com/repos/pandas-dev/pandas/pulls/22267 | 2018-08-09T19:35:04Z | 2018-08-10T09:58:21Z | 2018-08-10T09:58:21Z | 2018-08-10T17:21:13Z |
ENH: Add support for excluding the index from Parquet files (GH20768) | diff --git a/doc/source/io.rst b/doc/source/io.rst
index c2c8c1c17700f..cb22bb9198e25 100644
--- a/doc/source/io.rst
+++ b/doc/source/io.rst
@@ -4570,6 +4570,9 @@ dtypes, including extension dtypes such as datetime with tz.
Several caveats.
* Duplicate column names and non-string columns names are not supported.
+* The ``pyarrow`` engine always writes the index to the output, but ``fastparquet`` only writes non-default
+ indexes. This extra column can cause problems for non-Pandas consumers that are not expecting it. You can
+ force including or omitting indexes with the ``index`` argument, regardless of the underlying engine.
* Index level names, if specified, must be strings.
* Categorical dtypes can be serialized to parquet, but will de-serialize as ``object`` dtype.
* Non supported types include ``Period`` and actual Python object types. These will raise a helpful error message
@@ -4633,6 +4636,41 @@ Read only certain columns of a parquet file.
os.remove('example_pa.parquet')
os.remove('example_fp.parquet')
+
+Handling Indexes
+''''''''''''''''
+
+Serializing a ``DataFrame`` to parquet may include the implicit index as one or
+more columns in the output file. Thus, this code:
+
+.. ipython:: python
+
+ df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
+ df.to_parquet('test.parquet', engine='pyarrow')
+
+creates a parquet file with *three* columns if you use ``pyarrow`` for serialization:
+``a``, ``b``, and ``__index_level_0__``. If you're using ``fastparquet``, the
+index `may or may not <https://fastparquet.readthedocs.io/en/latest/api.html#fastparquet.write>`_
+be written to the file.
+
+This unexpected extra column causes some databases like Amazon Redshift to reject
+the file, because that column doesn't exist in the target table.
+
+If you want to omit a dataframe's indexes when writing, pass ``index=False`` to
+:func:`~pandas.DataFrame.to_parquet`:
+
+.. ipython:: python
+
+ df.to_parquet('test.parquet', index=False)
+
+This creates a parquet file with just the two expected columns, ``a`` and ``b``.
+If your ``DataFrame`` has a custom index, you won't get it back when you load
+this file into a ``DataFrame``.
+
+Passing ``index=True`` will *always* write the index, even if that's not the
+underlying engine's default behavior.
+
+
.. _io.sql:
SQL Queries
diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 9e2c20c78f489..fc594a2e8de2f 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -17,6 +17,10 @@ New features
- ``ExcelWriter`` now accepts ``mode`` as a keyword argument, enabling append to existing workbooks when using the ``openpyxl`` engine (:issue:`3441`)
+- :func:`DataFrame.to_parquet` now accepts ``index`` as an argument, allowing
+the user to override the engine's default behavior to include or omit the
+dataframe's indexes from the resulting Parquet file. (:issue:`20768`)
+
.. _whatsnew_0240.enhancements.extension_array_operators:
``ExtensionArray`` operator support
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index bb221ced9e6bd..770eca2210138 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1874,7 +1874,7 @@ def to_feather(self, fname):
to_feather(self, fname)
def to_parquet(self, fname, engine='auto', compression='snappy',
- **kwargs):
+ index=None, **kwargs):
"""
Write a DataFrame to the binary parquet format.
@@ -1896,6 +1896,13 @@ def to_parquet(self, fname, engine='auto', compression='snappy',
'pyarrow' is unavailable.
compression : {'snappy', 'gzip', 'brotli', None}, default 'snappy'
Name of the compression to use. Use ``None`` for no compression.
+ index : bool, default None
+ If ``True``, include the dataframe's index(es) in the file output.
+ If ``False``, they will not be written to the file. If ``None``,
+ the behavior depends on the chosen engine.
+
+ .. versionadded:: 0.24.0
+
**kwargs
Additional arguments passed to the parquet library. See
:ref:`pandas io <io.parquet>` for more details.
@@ -1924,7 +1931,7 @@ def to_parquet(self, fname, engine='auto', compression='snappy',
"""
from pandas.io.parquet import to_parquet
to_parquet(self, fname, engine,
- compression=compression, **kwargs)
+ compression=compression, index=index, **kwargs)
@Substitution(header='Write out the column names. If a list of strings '
'is given, it is assumed to be aliases for the '
diff --git a/pandas/io/parquet.py b/pandas/io/parquet.py
index a99014f07a6b3..6ab56c68a510a 100644
--- a/pandas/io/parquet.py
+++ b/pandas/io/parquet.py
@@ -103,19 +103,27 @@ def __init__(self):
self.api = pyarrow
def write(self, df, path, compression='snappy',
- coerce_timestamps='ms', **kwargs):
+ coerce_timestamps='ms', index=None, **kwargs):
self.validate_dataframe(df)
- if self._pyarrow_lt_070:
+
+ # Only validate the index if we're writing it.
+ if self._pyarrow_lt_070 and index is not False:
self._validate_write_lt_070(df)
path, _, _, _ = get_filepath_or_buffer(path, mode='wb')
+ if index is None:
+ from_pandas_kwargs = {}
+ else:
+ from_pandas_kwargs = {'preserve_index': index}
+
if self._pyarrow_lt_060:
- table = self.api.Table.from_pandas(df, timestamps_to_ms=True)
+ table = self.api.Table.from_pandas(df, timestamps_to_ms=True,
+ **from_pandas_kwargs)
self.api.parquet.write_table(
table, path, compression=compression, **kwargs)
else:
- table = self.api.Table.from_pandas(df)
+ table = self.api.Table.from_pandas(df, **from_pandas_kwargs)
self.api.parquet.write_table(
table, path, compression=compression,
coerce_timestamps=coerce_timestamps, **kwargs)
@@ -197,7 +205,7 @@ def __init__(self):
)
self.api = fastparquet
- def write(self, df, path, compression='snappy', **kwargs):
+ def write(self, df, path, compression='snappy', index=None, **kwargs):
self.validate_dataframe(df)
# thriftpy/protocol/compact.py:339:
# DeprecationWarning: tostring() is deprecated.
@@ -214,8 +222,8 @@ def write(self, df, path, compression='snappy', **kwargs):
path, _, _, _ = get_filepath_or_buffer(path)
with catch_warnings(record=True):
- self.api.write(path, df,
- compression=compression, **kwargs)
+ self.api.write(path, df, compression=compression,
+ write_index=index, **kwargs)
def read(self, path, columns=None, **kwargs):
if is_s3_url(path):
@@ -234,7 +242,8 @@ def read(self, path, columns=None, **kwargs):
return parquet_file.to_pandas(columns=columns, **kwargs)
-def to_parquet(df, path, engine='auto', compression='snappy', **kwargs):
+def to_parquet(df, path, engine='auto', compression='snappy', index=None,
+ **kwargs):
"""
Write a DataFrame to the parquet format.
@@ -250,11 +259,17 @@ def to_parquet(df, path, engine='auto', compression='snappy', **kwargs):
'pyarrow' is unavailable.
compression : {'snappy', 'gzip', 'brotli', None}, default 'snappy'
Name of the compression to use. Use ``None`` for no compression.
+ index : bool, default None
+ If ``True``, include the dataframe's index(es) in the file output. If
+ ``False``, they will not be written to the file. If ``None``, the
+ engine's default behavior will be used.
+
+ .. versionadded 0.24.0
kwargs
Additional keyword arguments passed to the engine
"""
impl = get_engine(engine)
- return impl.write(df, path, compression=compression, **kwargs)
+ return impl.write(df, path, compression=compression, index=index, **kwargs)
def read_parquet(path, engine='auto', columns=None, **kwargs):
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index fefbe8afb59cb..ab7f04ad86ffc 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -368,6 +368,40 @@ def test_multiindex_with_columns(self, pa_ge_070):
check_round_trip(df, engine, read_kwargs={'columns': ['A', 'B']},
expected=df[['A', 'B']])
+ def test_write_ignoring_index(self, engine):
+ # ENH 20768
+ # Ensure index=False omits the index from the written Parquet file.
+ df = pd.DataFrame({'a': [1, 2, 3], 'b': ['q', 'r', 's']})
+
+ write_kwargs = {
+ 'compression': None,
+ 'index': False,
+ }
+
+ # Because we're dropping the index, we expect the loaded dataframe to
+ # have the default integer index.
+ expected = df.reset_index(drop=True)
+
+ check_round_trip(df, engine, write_kwargs=write_kwargs,
+ expected=expected)
+
+ # Ignore custom index
+ df = pd.DataFrame({'a': [1, 2, 3], 'b': ['q', 'r', 's']},
+ index=['zyx', 'wvu', 'tsr'])
+
+ check_round_trip(df, engine, write_kwargs=write_kwargs,
+ expected=expected)
+
+ # Ignore multi-indexes as well.
+ arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
+ ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
+ df = pd.DataFrame({'one': [i for i in range(8)],
+ 'two': [-i for i in range(8)]}, index=arrays)
+
+ expected = df.reset_index(drop=True)
+ check_round_trip(df, engine, write_kwargs=write_kwargs,
+ expected=expected)
+
class TestParquetPyArrow(Base):
| - [x] closes #20768
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry | https://api.github.com/repos/pandas-dev/pandas/pulls/22266 | 2018-08-09T19:32:05Z | 2018-09-21T08:18:02Z | 2018-09-21T08:18:00Z | 2018-09-21T21:16:52Z |
DEPR: list-likes of list-likes in str.cat | diff --git a/doc/source/text.rst b/doc/source/text.rst
index 0081b592f91bf..61583a179e572 100644
--- a/doc/source/text.rst
+++ b/doc/source/text.rst
@@ -306,7 +306,7 @@ The same alignment can be used when ``others`` is a ``DataFrame``:
Concatenating a Series and many objects into a Series
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-All one-dimensional list-likes can be arbitrarily combined in a list-like container (including iterators, ``dict``-views, etc.):
+All one-dimensional list-likes can be combined in a list-like container (including iterators, ``dict``-views, etc.):
.. ipython:: python
diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index 3e22084d98234..99e44c54c44cb 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -507,13 +507,15 @@ Other API Changes
Deprecations
~~~~~~~~~~~~
-- :meth:`DataFrame.to_stata`, :meth:`read_stata`, :class:`StataReader` and :class:`StataWriter` have deprecated the ``encoding`` argument. The encoding of a Stata dta file is determined by the file type and cannot be changed (:issue:`21244`).
-- :meth:`MultiIndex.to_hierarchical` is deprecated and will be removed in a future version (:issue:`21613`)
+- :meth:`DataFrame.to_stata`, :meth:`read_stata`, :class:`StataReader` and :class:`StataWriter` have deprecated the ``encoding`` argument. The encoding of a Stata dta file is determined by the file type and cannot be changed (:issue:`21244`)
+- :meth:`MultiIndex.to_hierarchical` is deprecated and will be removed in a future version (:issue:`21613`)
- :meth:`Series.ptp` is deprecated. Use ``numpy.ptp`` instead (:issue:`21614`)
- :meth:`Series.compress` is deprecated. Use ``Series[condition]`` instead (:issue:`18262`)
- The signature of :meth:`Series.to_csv` has been uniformed to that of doc:meth:`DataFrame.to_csv`: the name of the first argument is now 'path_or_buf', the order of subsequent arguments has changed, the 'header' argument now defaults to True. (:issue:`19715`)
- :meth:`Categorical.from_codes` has deprecated providing float values for the ``codes`` argument. (:issue:`21767`)
- :func:`pandas.read_table` is deprecated. Instead, use :func:`pandas.read_csv` passing ``sep='\t'`` if necessary (:issue:`21948`)
+- :meth:`Series.str.cat` has deprecated using arbitrary list-likes *within* list-likes. A list-like container may still contain
+ many ``Series``, ``Index`` or 1-dimensional ``np.ndarray``, or alternatively, only scalar values. (:issue:`21950`)
.. _whatsnew_0240.prior_deprecations:
diff --git a/pandas/core/strings.py b/pandas/core/strings.py
index 07e744a6284ef..e455c751057d1 100644
--- a/pandas/core/strings.py
+++ b/pandas/core/strings.py
@@ -1930,8 +1930,8 @@ def _get_series_list(self, others, ignore_index=False):
Parameters
----------
- others : Series, DataFrame, np.ndarray, list-like or list-like of
- objects that are either Series, np.ndarray (1-dim) or list-like
+ others : Series, Index, DataFrame, np.ndarray, list-like or list-like
+ of objects that are Series, Index or np.ndarray (1-dim)
ignore_index : boolean, default False
Determines whether to forcefully align others with index of caller
@@ -1941,7 +1941,7 @@ def _get_series_list(self, others, ignore_index=False):
boolean whether FutureWarning should be raised)
"""
- # once str.cat defaults to alignment, this function can be simplified;
+ # Once str.cat defaults to alignment, this function can be simplified;
# will not need `ignore_index` and the second boolean output anymore
from pandas import Index, Series, DataFrame
@@ -1986,11 +1986,20 @@ def _get_series_list(self, others, ignore_index=False):
# either one-dimensional list-likes or scalars
if all(is_list_like(x) for x in others):
los = []
- warn = False
+ join_warn = False
+ depr_warn = False
# iterate through list and append list of series for each
# element (which we check to be one-dimensional and non-nested)
while others:
nxt = others.pop(0) # nxt is guaranteed list-like by above
+
+ # GH 21950 - DeprecationWarning
+ # only allowing Series/Index/np.ndarray[1-dim] will greatly
+ # simply this function post-deprecation.
+ if not (isinstance(nxt, (Series, Index)) or
+ (isinstance(nxt, np.ndarray) and nxt.ndim == 1)):
+ depr_warn = True
+
if not isinstance(nxt, (DataFrame, Series,
Index, np.ndarray)):
# safety for non-persistent list-likes (e.g. iterators)
@@ -2013,8 +2022,14 @@ def _get_series_list(self, others, ignore_index=False):
nxt, wnx = self._get_series_list(nxt,
ignore_index=ignore_index)
los = los + nxt
- warn = warn or wnx
- return (los, warn)
+ join_warn = join_warn or wnx
+
+ if depr_warn:
+ warnings.warn('list-likes other than Series, Index, or '
+ 'np.ndarray WITHIN another list-like are '
+ 'deprecated and will be removed in a future '
+ 'version.', FutureWarning, stacklevel=3)
+ return (los, join_warn)
elif all(not is_list_like(x) for x in others):
return ([Series(others, index=idx)], False)
raise TypeError(err_msg)
@@ -2037,8 +2052,8 @@ def cat(self, others=None, sep=None, na_rep=None, join=None):
Series/Index/DataFrame) if `join` is not None.
If others is a list-like that contains a combination of Series,
- np.ndarray (1-dim) or list-like, then all elements will be unpacked
- and must satisfy the above criteria individually.
+ Index or np.ndarray (1-dim), then all elements will be unpacked and
+ must satisfy the above criteria individually.
If others is None, the method returns the concatenation of all
strings in the calling Series/Index.
diff --git a/pandas/tests/test_strings.py b/pandas/tests/test_strings.py
index 9d008dfd25c90..ab508174fa4a9 100644
--- a/pandas/tests/test_strings.py
+++ b/pandas/tests/test_strings.py
@@ -313,7 +313,9 @@ def test_str_cat_mixed_inputs(self, series_or_index):
assert_series_or_index_equal(s.str.cat([tt, s]), exp)
# Series/Index with list of list-likes
- assert_series_or_index_equal(s.str.cat([t.values, list(s)]), exp)
+ with tm.assert_produces_warning(expected_warning=FutureWarning):
+ # nested lists will be deprecated
+ assert_series_or_index_equal(s.str.cat([t.values, list(s)]), exp)
# Series/Index with mixed list of Series/list-like
# s as Series has same index as t -> no warning
@@ -327,7 +329,10 @@ def test_str_cat_mixed_inputs(self, series_or_index):
assert_series_or_index_equal(s.str.cat([tt, s.values]), exp)
# Series/Index with iterator of list-likes
- assert_series_or_index_equal(s.str.cat(iter([t.values, list(s)])), exp)
+ with tm.assert_produces_warning(expected_warning=FutureWarning):
+ # nested list-likes will be deprecated
+ assert_series_or_index_equal(s.str.cat(iter([t.values, list(s)])),
+ exp)
# errors for incorrect lengths
rgx = 'All arrays must be same length, except.*'
@@ -348,11 +353,11 @@ def test_str_cat_mixed_inputs(self, series_or_index):
# list of list-likes
with tm.assert_raises_regex(ValueError, rgx):
- s.str.cat([z.values, list(s)])
+ s.str.cat([z.values, s.values])
# mixed list of Series/list-like
with tm.assert_raises_regex(ValueError, rgx):
- s.str.cat([z, list(s)])
+ s.str.cat([z, s.values])
# errors for incorrect arguments in list-like
rgx = 'others must be Series, Index, DataFrame,.*'
@@ -423,11 +428,15 @@ def test_str_cat_align_mixed_inputs(self, join):
e = concat([t, s], axis=1, join=(join if join == 'inner' else 'outer'))
sa, ea = s.align(e, join=join)
exp = exp_outer.loc[ea.index]
- tm.assert_series_equal(s.str.cat([t, u], join=join, na_rep='-'), exp)
+
+ with tm.assert_produces_warning(expected_warning=FutureWarning):
+ # nested lists will be deprecated
+ tm.assert_series_equal(s.str.cat([t, u], join=join, na_rep='-'),
+ exp)
# errors for incorrect lengths
rgx = 'If `others` contains arrays or lists.*'
- z = ['1', '2', '3']
+ z = Series(['1', '2', '3']).values
# unindexed object of wrong length
with tm.assert_raises_regex(ValueError, rgx):
@@ -442,8 +451,8 @@ def test_str_cat_special_cases(self):
t = Series(['d', 'a', 'e', 'b'], index=[3, 0, 4, 1])
# iterator of elements with different types
- exp = Series(['aaA', 'bbB', 'c-C', 'ddD', '-e-'])
- tm.assert_series_equal(s.str.cat(iter([t, ['A', 'B', 'C', 'D']]),
+ exp = Series(['aaa', 'bbb', 'c-c', 'ddd', '-e-'])
+ tm.assert_series_equal(s.str.cat(iter([t, s.values]),
join='outer', na_rep='-'), exp)
# right-align with different indexes in others
| - [x] closes #21950
- [x] tests modified / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
As mentioned in #21950, my suggestion is to modify the allowed combinations (as of v0.23) as follows:
```
Type of "others" | action | comment
---------------------------------------------------------------------
list-like of strings | keep | as before; mimics behavior elsewhere,
cf.: pd.Series(range(3)) + [2,4,6]
Series | keep |
np.ndarray (1-dim) | keep |
DataFrame | keep | sequential concatenation
np.ndarray (2-dim) | keep | sequential concatenation
list-like of
Series/Index/np.ndarray (1-dim) | keep | sequential concatenation
list-like containing list-likes (1-dim)
other than Series/Index/np.ndarray | DEPR | sequential concatenation
```
In other words, if the user wants sequential concatenation, there are many possibilities available, and list-of-lists does not have to be one of them, IMO. This would substantially simplify (post-deprecation) the code for `str.cat._get_series_list`:
```
def _get_series_list(self, others):
"""
Auxiliary function for :meth:`str.cat`. Turn potentially mixed input
into a list of Series (elements without an index must match the length
of the calling Series/Index).
Parameters
----------
others : Series, DataFrame, np.ndarray, list-like or list-like of
objects that are either Series, Index or np.ndarray (1-dim)
Returns
-------
list : others transformed into list of Series
"""
from pandas import Index, Series, DataFrame
# self._orig is either Series or Index
idx = self._orig if isinstance(self._orig, Index) else self._orig.index
# Generally speaking, all objects without an index inherit the index
# `idx` of the calling Series/Index - i.e. must have matching length.
# Objects with an index (i.e. Series/Index/DataFrame) keep their own.
if isinstance(others, Series):
return [others]
elif isinstance(others, Index):
return [Series(others.values, index=others)]
elif isinstance(others, DataFrame):
return [others[x] for x in others]
elif isinstance(others, np.ndarray) and others.ndim == 2:
others = DataFrame(others, index=idx)
return [others[x] for x in others]
elif is_list_like(others):
others = list(others) # ensure iterators do not get read twice etc
# in case of list-like `others`, all elements must be
# either Series/Index/np.ndarray (1-dim)...
if all(isinstance(x, (Series, Index))
or (isinstance(x, np.ndarray) and x.ndim == 1) for x in others):
los = []
while others: # iterate through list and append each element
los = los + self._get_series_list(others.pop(0))
return los
# ... or just strings
elif all(not is_list_like(x) for x in others):
return [Series(others, index=idx)]
raise TypeError('others must be Series, Index, DataFrame, np.ndarrary or '
'list-like (either containing only strings or containing '
'only objects of type Series/Index/np.ndarray[1-dim])')
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/22264 | 2018-08-09T18:14:53Z | 2018-08-31T10:25:40Z | 2018-08-31T10:25:40Z | 2018-09-04T23:11:55Z |
Unable to pass additional arguments to resample().apply() | diff --git a/doc/source/whatsnew/v0.24.0.txt b/doc/source/whatsnew/v0.24.0.txt
index d7feb6e547b22..83f88e2c23f62 100644
--- a/doc/source/whatsnew/v0.24.0.txt
+++ b/doc/source/whatsnew/v0.24.0.txt
@@ -693,7 +693,7 @@ Groupby/Resample/Rolling
``SeriesGroupBy`` when the grouping variable only contains NaNs and numpy version < 1.13 (:issue:`21956`).
- Multiple bugs in :func:`pandas.core.Rolling.min` with ``closed='left'` and a
datetime-like index leading to incorrect results and also segfault. (:issue:`21704`)
--
+- Bug in :meth:`Resampler.apply` when passing postiional arguments to applied func (:issue:`14615`).
Sparse
^^^^^^
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 4a3625b2d7a2d..3b70112b8ad00 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -234,12 +234,15 @@ def pipe(self, func, *args, **kwargs):
klass='DataFrame',
versionadded='',
axis=''))
- def aggregate(self, arg, *args, **kwargs):
+ def aggregate(self, func, *args, **kwargs):
self._set_binner()
- result, how = self._aggregate(arg, *args, **kwargs)
+ result, how = self._aggregate(func, *args, **kwargs)
if result is None:
- result = self._groupby_and_aggregate(arg,
+ how = func
+ grouper = None
+ result = self._groupby_and_aggregate(how,
+ grouper,
*args,
**kwargs)
@@ -852,7 +855,7 @@ def __init__(self, obj, *args, **kwargs):
self._groupby.grouper.mutated = True
self.groupby = copy.copy(parent.groupby)
- def _apply(self, f, **kwargs):
+ def _apply(self, f, grouper=None, *args, **kwargs):
"""
dispatch to _upsample; we are stripping all of the _upsample kwargs and
performing the original function call on the grouped object
@@ -864,7 +867,7 @@ def func(x):
if isinstance(f, compat.string_types):
return getattr(x, f)(**kwargs)
- return x.apply(f, **kwargs)
+ return x.apply(f, *args, **kwargs)
result = self._groupby.apply(func)
return self._wrap_result(result)
diff --git a/pandas/tests/test_resample.py b/pandas/tests/test_resample.py
index d11077668359b..3310c97e06e3d 100644
--- a/pandas/tests/test_resample.py
+++ b/pandas/tests/test_resample.py
@@ -2165,6 +2165,28 @@ def test_resample_datetime_values(self):
res = df['timestamp'].resample('2D').first()
tm.assert_series_equal(res, exp)
+ def test_resample_apply_with_additional_args(self):
+ # GH 14615
+ def f(data, add_arg):
+ return np.mean(data) * add_arg
+
+ multiplier = 10
+ result = self.series.resample('D').apply(f, multiplier)
+ expected = self.series.resample('D').mean().multiply(multiplier)
+ tm.assert_series_equal(result, expected)
+
+ # Testing as kwarg
+ result = self.series.resample('D').apply(f, add_arg=multiplier)
+ expected = self.series.resample('D').mean().multiply(multiplier)
+ tm.assert_series_equal(result, expected)
+
+ # Testing dataframe
+ df = pd.DataFrame({"A": 1, "B": 2},
+ index=pd.date_range('2017', periods=10))
+ result = df.groupby("A").resample("D").agg(f, multiplier)
+ expected = df.groupby("A").resample('D').mean().multiply(multiplier)
+ assert_frame_equal(result, expected)
+
class TestPeriodIndex(Base):
_index_factory = lambda x: period_range
| - [x] closes #14615
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
There is flake8 warning ^ but it is not related with my changes. | https://api.github.com/repos/pandas-dev/pandas/pulls/22261 | 2018-08-09T11:48:09Z | 2018-08-22T12:24:24Z | 2018-08-22T12:24:24Z | 2018-08-22T12:24:32Z |
Backport PR #22169 on branch 0.23.x | diff --git a/doc/source/whatsnew/v0.23.5.txt b/doc/source/whatsnew/v0.23.5.txt
index ee0ee4259f86d..6a36adb915b3c 100644
--- a/doc/source/whatsnew/v0.23.5.txt
+++ b/doc/source/whatsnew/v0.23.5.txt
@@ -37,3 +37,7 @@ Bug Fixes
-
-
+
+**I/O**
+
+- Bug in :func:`read_csv` that caused it to raise ``OverflowError`` when trying to use 'inf' as ``na_value`` with integer index column (:issue:`17128`)
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index bcde32696c1ff..9d8d208d2d5c1 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -95,7 +95,7 @@ def _ensure_data(values, dtype=None):
values = _ensure_float64(values)
return values, 'float64', 'float64'
- except (TypeError, ValueError):
+ except (TypeError, ValueError, OverflowError):
# if we are trying to coerce to a dtype
# and it is incompat this will fall thru to here
return _ensure_object(values), 'object', 'object'
@@ -429,7 +429,7 @@ def isin(comps, values):
values = values.astype('int64', copy=False)
comps = comps.astype('int64', copy=False)
f = lambda x, y: htable.ismember_int64(x, y)
- except (TypeError, ValueError):
+ except (TypeError, ValueError, OverflowError):
values = values.astype(object)
comps = comps.astype(object)
diff --git a/pandas/tests/io/parser/na_values.py b/pandas/tests/io/parser/na_values.py
index d2c3f82e95c4d..cc224efd533b7 100644
--- a/pandas/tests/io/parser/na_values.py
+++ b/pandas/tests/io/parser/na_values.py
@@ -369,3 +369,14 @@ def test_no_na_filter_on_index(self):
expected = DataFrame({"a": [1, 4], "c": [3, 6]},
index=Index([np.nan, 5.0], name="b"))
tm.assert_frame_equal(out, expected)
+
+ def test_inf_na_values_with_int_index(self):
+ # see gh-17128
+ data = "idx,col1,col2\n1,3,4\n2,inf,-inf"
+
+ # Don't fail with OverflowError with infs and integer index column
+ out = self.read_csv(StringIO(data), index_col=[0],
+ na_values=['inf', '-inf'])
+ expected = DataFrame({"col1": [3, np.nan], "col2": [4, np.nan]},
+ index=Index([1, 2], name="idx"))
+ tm.assert_frame_equal(out, expected)
| Backport PR #22169: BUG: Fix using "inf"/"-inf" in na_values for csv with int index column | https://api.github.com/repos/pandas-dev/pandas/pulls/22259 | 2018-08-09T10:38:22Z | 2018-08-09T14:45:12Z | 2018-08-09T14:45:12Z | 2018-08-09T14:45:13Z |
Backport PR #22253 on branch 0.23.x | diff --git a/doc/source/whatsnew/v0.23.5.txt b/doc/source/whatsnew/v0.23.5.txt
index ee0ee4259f86d..4b478bba7d972 100644
--- a/doc/source/whatsnew/v0.23.5.txt
+++ b/doc/source/whatsnew/v0.23.5.txt
@@ -30,7 +30,7 @@ Bug Fixes
**Groupby/Resample/Rolling**
--
+- Bug in :meth:`DataFrame.resample` when resampling ``NaT`` in ``TimeDeltaIndex`` (:issue:`13223`).
-
**Missing**
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 0707cc756682e..e6b9f88c52cd7 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -1383,8 +1383,7 @@ def _get_time_delta_bins(self, ax):
data=[], freq=self.freq, name=ax.name)
return binner, [], labels
- start = ax[0]
- end = ax[-1]
+ start, end = ax.min(), ax.max()
labels = binner = TimedeltaIndex(start=start,
end=end,
freq=self.freq,
diff --git a/pandas/tests/test_resample.py b/pandas/tests/test_resample.py
index c1257cce9a9a4..bcc50a25623a1 100644
--- a/pandas/tests/test_resample.py
+++ b/pandas/tests/test_resample.py
@@ -2870,6 +2870,16 @@ def test_asfreq_bug(self):
freq='1T'))
assert_frame_equal(result, expected)
+ def test_resample_with_nat(self):
+ # GH 13223
+ index = pd.to_timedelta(['0s', pd.NaT, '2s'])
+ result = DataFrame({'value': [2, 3, 5]}, index).resample('1s').mean()
+ expected = DataFrame({'value': [2.5, np.nan, 5.0]},
+ index=timedelta_range('0 day',
+ periods=3,
+ freq='1S'))
+ assert_frame_equal(result, expected)
+
class TestResamplerGrouper(object):
| Backport PR #22253: Resampling with NaT in TimedeltaIndex raises MemoryError | https://api.github.com/repos/pandas-dev/pandas/pulls/22258 | 2018-08-09T10:33:55Z | 2018-08-09T14:45:30Z | 2018-08-09T14:45:29Z | 2018-08-09T14:45:30Z |
Implement arithmetic.test_numeric and arithmetic.test_object | diff --git a/pandas/tests/arithmetic/conftest.py b/pandas/tests/arithmetic/conftest.py
index 1e25d4a5224ee..844472b8bcf0d 100644
--- a/pandas/tests/arithmetic/conftest.py
+++ b/pandas/tests/arithmetic/conftest.py
@@ -4,6 +4,8 @@
import numpy as np
import pandas as pd
+from pandas.compat import long
+
@pytest.fixture(params=[1, np.array(1, dtype=np.int64)])
def one(request):
@@ -11,6 +13,40 @@ def one(request):
return request.param
+zeros = [box_cls([0] * 5, dtype=dtype)
+ for box_cls in [pd.Index, np.array]
+ for dtype in [np.int64, np.uint64, np.float64]]
+zeros.extend([np.array(0, dtype=dtype)
+ for dtype in [np.int64, np.uint64, np.float64]])
+zeros.extend([0, 0.0, long(0)])
+
+
+@pytest.fixture(params=zeros)
+def zero(request):
+ # For testing division by (or of) zero for Index with length 5, this
+ # gives several scalar-zeros and length-5 vector-zeros
+ return request.param
+
+
+@pytest.fixture(params=[pd.Float64Index(np.arange(5, dtype='float64')),
+ pd.Int64Index(np.arange(5, dtype='int64')),
+ pd.UInt64Index(np.arange(5, dtype='uint64'))],
+ ids=lambda x: type(x).__name__)
+def idx(request):
+ return request.param
+
+
+@pytest.fixture(params=[pd.Timedelta('5m4s').to_pytimedelta(),
+ pd.Timedelta('5m4s'),
+ pd.Timedelta('5m4s').to_timedelta64()],
+ ids=lambda x: type(x).__name__)
+def scalar_td(request):
+ """
+ Several variants of Timedelta scalars representing 5 minutes and 4 seconds
+ """
+ return request.param
+
+
# ------------------------------------------------------------------
@pytest.fixture(params=[pd.Index, pd.Series, pd.DataFrame],
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index b09d3c3183803..77e8da6c44af2 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -8,6 +8,7 @@
import numpy as np
import pytest
+import pytz
import pandas as pd
import pandas.util.testing as tm
@@ -21,7 +22,7 @@
from pandas.core import ops
from pandas import (
- Timestamp, Timedelta, Period, Series, date_range,
+ Timestamp, Timedelta, Period, Series, date_range, NaT,
DatetimeIndex, TimedeltaIndex)
@@ -63,6 +64,47 @@ def test_tz_aware_scalar_comparison(self, timestamps):
class TestDatetime64SeriesComparison(object):
+ @pytest.mark.parametrize('data', [
+ [Timestamp('2011-01-01'), NaT, Timestamp('2011-01-03')],
+ [Timedelta('1 days'), NaT, Timedelta('3 days')],
+ [Period('2011-01', freq='M'), NaT, Period('2011-03', freq='M')]
+ ])
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_nat_comparisons_scalar(self, dtype, data):
+ left = Series(data, dtype=dtype)
+
+ expected = Series([False, False, False])
+ tm.assert_series_equal(left == NaT, expected)
+ tm.assert_series_equal(NaT == left, expected)
+
+ expected = Series([True, True, True])
+ tm.assert_series_equal(left != NaT, expected)
+ tm.assert_series_equal(NaT != left, expected)
+
+ expected = Series([False, False, False])
+ tm.assert_series_equal(left < NaT, expected)
+ tm.assert_series_equal(NaT > left, expected)
+ tm.assert_series_equal(left <= NaT, expected)
+ tm.assert_series_equal(NaT >= left, expected)
+
+ tm.assert_series_equal(left > NaT, expected)
+ tm.assert_series_equal(NaT < left, expected)
+ tm.assert_series_equal(left >= NaT, expected)
+ tm.assert_series_equal(NaT <= left, expected)
+
+ def test_series_comparison_scalars(self):
+ series = Series(date_range('1/1/2000', periods=10))
+
+ val = datetime(2000, 1, 4)
+ result = series > val
+ expected = Series([x > val for x in series])
+ tm.assert_series_equal(result, expected)
+
+ val = series[5]
+ result = series > val
+ expected = Series([x > val for x in series])
+ tm.assert_series_equal(result, expected)
+
def test_dt64_ser_cmp_date_warning(self):
# https://github.com/pandas-dev/pandas/issues/21359
# Remove this test and enble invalid test below
@@ -585,6 +627,7 @@ def test_df_sub_datetime64_not_ns(self):
class TestTimestampSeriesArithmetic(object):
+
def test_timestamp_sub_series(self):
ser = pd.Series(pd.date_range('2014-03-17', periods=2, freq='D',
tz='US/Eastern'))
@@ -602,6 +645,312 @@ def test_dt64ser_sub_datetime_dtype(self):
result = pd.to_timedelta(np.abs(ser - dt))
assert result.dtype == 'timedelta64[ns]'
+ # -------------------------------------------------------------
+ # TODO: This next block of tests came from tests.series.test_operators,
+ # needs to be de-duplicated and parametrized over `box` classes
+
+ @pytest.mark.parametrize(
+ 'box, assert_func',
+ [(Series, tm.assert_series_equal),
+ (pd.Index, tm.assert_index_equal)])
+ def test_sub_datetime64_not_ns(self, box, assert_func):
+ # GH#7996
+ dt64 = np.datetime64('2013-01-01')
+ assert dt64.dtype == 'datetime64[D]'
+
+ obj = box(date_range('20130101', periods=3))
+ res = obj - dt64
+ expected = box([Timedelta(days=0), Timedelta(days=1),
+ Timedelta(days=2)])
+ assert_func(res, expected)
+
+ res = dt64 - obj
+ assert_func(res, -expected)
+
+ def test_sub_single_tz(self):
+ # GH12290
+ s1 = Series([pd.Timestamp('2016-02-10', tz='America/Sao_Paulo')])
+ s2 = Series([pd.Timestamp('2016-02-08', tz='America/Sao_Paulo')])
+ result = s1 - s2
+ expected = Series([Timedelta('2days')])
+ tm.assert_series_equal(result, expected)
+ result = s2 - s1
+ expected = Series([Timedelta('-2days')])
+ tm.assert_series_equal(result, expected)
+
+ def test_dt64tz_series_sub_dtitz(self):
+ # GH#19071 subtracting tzaware DatetimeIndex from tzaware Series
+ # (with same tz) raises, fixed by #19024
+ dti = pd.date_range('1999-09-30', periods=10, tz='US/Pacific')
+ ser = pd.Series(dti)
+ expected = pd.Series(pd.TimedeltaIndex(['0days'] * 10))
+
+ res = dti - ser
+ tm.assert_series_equal(res, expected)
+ res = ser - dti
+ tm.assert_series_equal(res, expected)
+
+ def test_sub_datetime_compat(self):
+ # see gh-14088
+ s = Series([datetime(2016, 8, 23, 12, tzinfo=pytz.utc), pd.NaT])
+ dt = datetime(2016, 8, 22, 12, tzinfo=pytz.utc)
+ exp = Series([Timedelta('1 days'), pd.NaT])
+ tm.assert_series_equal(s - dt, exp)
+ tm.assert_series_equal(s - Timestamp(dt), exp)
+
+ def test_dt64_series_addsub_timedelta(self):
+ # scalar timedeltas/np.timedelta64 objects
+ # operate with np.timedelta64 correctly
+ s = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
+
+ result = s + np.timedelta64(1, 's')
+ result2 = np.timedelta64(1, 's') + s
+ expected = Series([Timestamp('20130101 9:01:01'),
+ Timestamp('20130101 9:02:01')])
+ tm.assert_series_equal(result, expected)
+ tm.assert_series_equal(result2, expected)
+
+ result = s + np.timedelta64(5, 'ms')
+ result2 = np.timedelta64(5, 'ms') + s
+ expected = Series([Timestamp('20130101 9:01:00.005'),
+ Timestamp('20130101 9:02:00.005')])
+ tm.assert_series_equal(result, expected)
+ tm.assert_series_equal(result2, expected)
+
+ def test_dt64_series_add_tick_DateOffset(self):
+ # GH 4532
+ # operate with pd.offsets
+ ser = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
+ expected = Series([Timestamp('20130101 9:01:05'),
+ Timestamp('20130101 9:02:05')])
+
+ result = ser + pd.offsets.Second(5)
+ tm.assert_series_equal(result, expected)
+
+ result2 = pd.offsets.Second(5) + ser
+ tm.assert_series_equal(result2, expected)
+
+ def test_dt64_series_sub_tick_DateOffset(self):
+ # GH 4532
+ # operate with pd.offsets
+ ser = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
+ expected = Series([Timestamp('20130101 9:00:55'),
+ Timestamp('20130101 9:01:55')])
+
+ result = ser - pd.offsets.Second(5)
+ tm.assert_series_equal(result, expected)
+
+ result2 = -pd.offsets.Second(5) + ser
+ tm.assert_series_equal(result2, expected)
+
+ with pytest.raises(TypeError):
+ pd.offsets.Second(5) - ser
+
+ @pytest.mark.parametrize('cls_name', ['Day', 'Hour', 'Minute', 'Second',
+ 'Milli', 'Micro', 'Nano'])
+ def test_dt64_series_add_tick_DateOffset_smoke(self, cls_name):
+ # GH 4532
+ # smoke tests for valid DateOffsets
+ ser = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
+
+ offset_cls = getattr(pd.offsets, cls_name)
+ ser + offset_cls(5)
+ offset_cls(5) + ser
+
+ def test_dt64_series_add_mixed_tick_DateOffset(self):
+ # GH 4532
+ # operate with pd.offsets
+ s = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
+
+ result = s + pd.offsets.Milli(5)
+ result2 = pd.offsets.Milli(5) + s
+ expected = Series([Timestamp('20130101 9:01:00.005'),
+ Timestamp('20130101 9:02:00.005')])
+ tm.assert_series_equal(result, expected)
+ tm.assert_series_equal(result2, expected)
+
+ result = s + pd.offsets.Minute(5) + pd.offsets.Milli(5)
+ expected = Series([Timestamp('20130101 9:06:00.005'),
+ Timestamp('20130101 9:07:00.005')])
+ tm.assert_series_equal(result, expected)
+
+ def test_dt64_series_sub_NaT(self):
+ # GH#18808
+ dti = pd.DatetimeIndex([pd.NaT, pd.Timestamp('19900315')])
+ ser = pd.Series(dti)
+ res = ser - pd.NaT
+ expected = pd.Series([pd.NaT, pd.NaT], dtype='timedelta64[ns]')
+ tm.assert_series_equal(res, expected)
+
+ dti_tz = dti.tz_localize('Asia/Tokyo')
+ ser_tz = pd.Series(dti_tz)
+ res = ser_tz - pd.NaT
+ expected = pd.Series([pd.NaT, pd.NaT], dtype='timedelta64[ns]')
+ tm.assert_series_equal(res, expected)
+
+ def test_dt64_series_arith_overflow(self):
+ # GH#12534, fixed by #19024
+ dt = pd.Timestamp('1700-01-31')
+ td = pd.Timedelta('20000 Days')
+ dti = pd.date_range('1949-09-30', freq='100Y', periods=4)
+ ser = pd.Series(dti)
+ with pytest.raises(OverflowError):
+ ser - dt
+ with pytest.raises(OverflowError):
+ dt - ser
+ with pytest.raises(OverflowError):
+ ser + td
+ with pytest.raises(OverflowError):
+ td + ser
+
+ ser.iloc[-1] = pd.NaT
+ expected = pd.Series(['2004-10-03', '2104-10-04', '2204-10-04', 'NaT'],
+ dtype='datetime64[ns]')
+ res = ser + td
+ tm.assert_series_equal(res, expected)
+ res = td + ser
+ tm.assert_series_equal(res, expected)
+
+ ser.iloc[1:] = pd.NaT
+ expected = pd.Series(['91279 Days', 'NaT', 'NaT', 'NaT'],
+ dtype='timedelta64[ns]')
+ res = ser - dt
+ tm.assert_series_equal(res, expected)
+ res = dt - ser
+ tm.assert_series_equal(res, -expected)
+
+ def test_datetime64_ops_nat(self):
+ # GH 11349
+ datetime_series = Series([NaT, Timestamp('19900315')])
+ nat_series_dtype_timestamp = Series([NaT, NaT], dtype='datetime64[ns]')
+ single_nat_dtype_datetime = Series([NaT], dtype='datetime64[ns]')
+
+ # subtraction
+ tm.assert_series_equal(-NaT + datetime_series,
+ nat_series_dtype_timestamp)
+ with pytest.raises(TypeError):
+ -single_nat_dtype_datetime + datetime_series
+
+ tm.assert_series_equal(-NaT + nat_series_dtype_timestamp,
+ nat_series_dtype_timestamp)
+ with pytest.raises(TypeError):
+ -single_nat_dtype_datetime + nat_series_dtype_timestamp
+
+ # addition
+ tm.assert_series_equal(nat_series_dtype_timestamp + NaT,
+ nat_series_dtype_timestamp)
+ tm.assert_series_equal(NaT + nat_series_dtype_timestamp,
+ nat_series_dtype_timestamp)
+
+ tm.assert_series_equal(nat_series_dtype_timestamp + NaT,
+ nat_series_dtype_timestamp)
+ tm.assert_series_equal(NaT + nat_series_dtype_timestamp,
+ nat_series_dtype_timestamp)
+
+ # -------------------------------------------------------------
+ # Invalid Operations
+ # TODO: this block also needs to be de-duplicated and parametrized
+
+ @pytest.mark.parametrize('dt64_series', [
+ Series([Timestamp('19900315'), Timestamp('19900315')]),
+ Series([pd.NaT, Timestamp('19900315')]),
+ Series([pd.NaT, pd.NaT], dtype='datetime64[ns]')])
+ @pytest.mark.parametrize('one', [1, 1.0, np.array(1)])
+ def test_dt64_mul_div_numeric_invalid(self, one, dt64_series):
+ # multiplication
+ with pytest.raises(TypeError):
+ dt64_series * one
+ with pytest.raises(TypeError):
+ one * dt64_series
+
+ # division
+ with pytest.raises(TypeError):
+ dt64_series / one
+ with pytest.raises(TypeError):
+ one / dt64_series
+
+ @pytest.mark.parametrize('op', ['__add__', '__radd__',
+ '__sub__', '__rsub__'])
+ @pytest.mark.parametrize('tz', [None, 'Asia/Tokyo'])
+ def test_dt64_series_add_intlike(self, tz, op):
+ # GH#19123
+ dti = pd.DatetimeIndex(['2016-01-02', '2016-02-03', 'NaT'], tz=tz)
+ ser = Series(dti)
+
+ other = Series([20, 30, 40], dtype='uint8')
+
+ pytest.raises(TypeError, getattr(ser, op), 1)
+
+ pytest.raises(TypeError, getattr(ser, op), other)
+
+ pytest.raises(TypeError, getattr(ser, op), other.values)
+
+ pytest.raises(TypeError, getattr(ser, op), pd.Index(other))
+
+ # -------------------------------------------------------------
+ # Timezone-Centric Tests
+
+ def test_operators_datetimelike_with_timezones(self):
+ tz = 'US/Eastern'
+ dt1 = Series(date_range('2000-01-01 09:00:00', periods=5,
+ tz=tz), name='foo')
+ dt2 = dt1.copy()
+ dt2.iloc[2] = np.nan
+
+ td1 = Series(pd.timedelta_range('1 days 1 min', periods=5, freq='H'))
+ td2 = td1.copy()
+ td2.iloc[1] = np.nan
+
+ result = dt1 + td1[0]
+ exp = (dt1.dt.tz_localize(None) + td1[0]).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ result = dt2 + td2[0]
+ exp = (dt2.dt.tz_localize(None) + td2[0]).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ # odd numpy behavior with scalar timedeltas
+ result = td1[0] + dt1
+ exp = (dt1.dt.tz_localize(None) + td1[0]).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ result = td2[0] + dt2
+ exp = (dt2.dt.tz_localize(None) + td2[0]).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ result = dt1 - td1[0]
+ exp = (dt1.dt.tz_localize(None) - td1[0]).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+ with pytest.raises(TypeError):
+ td1[0] - dt1
+
+ result = dt2 - td2[0]
+ exp = (dt2.dt.tz_localize(None) - td2[0]).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+ with pytest.raises(TypeError):
+ td2[0] - dt2
+
+ result = dt1 + td1
+ exp = (dt1.dt.tz_localize(None) + td1).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ result = dt2 + td2
+ exp = (dt2.dt.tz_localize(None) + td2).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ result = dt1 - td1
+ exp = (dt1.dt.tz_localize(None) - td1).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ result = dt2 - td2
+ exp = (dt2.dt.tz_localize(None) - td2).dt.tz_localize(tz)
+ tm.assert_series_equal(result, exp)
+
+ with pytest.raises(TypeError):
+ td1 - dt1
+ with pytest.raises(TypeError):
+ td2 - dt2
+
class TestDatetimeIndexArithmetic(object):
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
new file mode 100644
index 0000000000000..44aaba2885bf7
--- /dev/null
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -0,0 +1,534 @@
+# -*- coding: utf-8 -*-
+# Arithmetc tests for DataFrame/Series/Index/Array classes that should
+# behave identically.
+# Specifically for numeric dtypes
+from datetime import timedelta
+from decimal import Decimal
+
+import pytest
+import numpy as np
+
+import pandas as pd
+import pandas.util.testing as tm
+
+from pandas.compat import PY3
+from pandas import Timedelta, Series, Index, TimedeltaIndex
+
+
+@pytest.fixture(params=[pd.Float64Index(np.arange(5, dtype='float64')),
+ pd.UInt64Index(np.arange(5, dtype='uint64')),
+ pd.Int64Index(np.arange(5, dtype='int64')),
+ pd.RangeIndex(5)],
+ ids=lambda x: type(x).__name__)
+def idx(request):
+ return request.param
+
+
+# ------------------------------------------------------------------
+# Comparisons
+
+class TestNumericComparisons(object):
+ def test_operator_series_comparison_zerorank(self):
+ # GH#13006
+ result = np.float64(0) > pd.Series([1, 2, 3])
+ expected = 0.0 > pd.Series([1, 2, 3])
+ tm.assert_series_equal(result, expected)
+ result = pd.Series([1, 2, 3]) < np.float64(0)
+ expected = pd.Series([1, 2, 3]) < 0.0
+ tm.assert_series_equal(result, expected)
+ result = np.array([0, 1, 2])[0] > pd.Series([0, 1, 2])
+ expected = 0.0 > pd.Series([1, 2, 3])
+ tm.assert_series_equal(result, expected)
+
+
+# ------------------------------------------------------------------
+# Numeric dtypes Arithmetic with Timedelta Scalar
+
+class TestNumericArraylikeArithmeticWithTimedeltaScalar(object):
+
+ # TODO: de-duplicate with test_numeric_arr_mul_tdscalar
+ def test_ops_series(self):
+ # regression test for G#H8813
+ td = Timedelta('1 day')
+ other = pd.Series([1, 2])
+ expected = pd.Series(pd.to_timedelta(['1 day', '2 days']))
+ tm.assert_series_equal(expected, td * other)
+ tm.assert_series_equal(expected, other * td)
+
+ @pytest.mark.parametrize('box', [
+ pd.Index,
+ Series,
+ pytest.param(pd.DataFrame,
+ marks=pytest.mark.xfail(reason="block.eval incorrect",
+ strict=True))
+ ])
+ @pytest.mark.parametrize('index', [
+ pd.Int64Index(range(1, 11)),
+ pd.UInt64Index(range(1, 11)),
+ pd.Float64Index(range(1, 11)),
+ pd.RangeIndex(1, 11)],
+ ids=lambda x: type(x).__name__)
+ @pytest.mark.parametrize('scalar_td', [
+ Timedelta(days=1),
+ Timedelta(days=1).to_timedelta64(),
+ Timedelta(days=1).to_pytimedelta()],
+ ids=lambda x: type(x).__name__)
+ def test_numeric_arr_mul_tdscalar(self, scalar_td, index, box):
+ # GH#19333
+
+ if (box is Series and
+ type(scalar_td) is timedelta and index.dtype == 'f8'):
+ raise pytest.xfail(reason="Cannot multiply timedelta by float")
+
+ expected = pd.timedelta_range('1 days', '10 days')
+
+ index = tm.box_expected(index, box)
+ expected = tm.box_expected(expected, box)
+
+ result = index * scalar_td
+ tm.assert_equal(result, expected)
+
+ commute = scalar_td * index
+ tm.assert_equal(commute, expected)
+
+ @pytest.mark.parametrize('index', [
+ pd.Int64Index(range(1, 3)),
+ pd.UInt64Index(range(1, 3)),
+ pd.Float64Index(range(1, 3)),
+ pd.RangeIndex(1, 3)],
+ ids=lambda x: type(x).__name__)
+ @pytest.mark.parametrize('scalar_td', [
+ Timedelta(days=1),
+ Timedelta(days=1).to_timedelta64(),
+ Timedelta(days=1).to_pytimedelta()],
+ ids=lambda x: type(x).__name__)
+ def test_numeric_arr_rdiv_tdscalar(self, scalar_td, index, box):
+
+ if box is Series and type(scalar_td) is timedelta:
+ raise pytest.xfail(reason="TODO: Figure out why this case fails")
+ if box is pd.DataFrame and isinstance(scalar_td, timedelta):
+ raise pytest.xfail(reason="TODO: Figure out why this case fails")
+
+ expected = TimedeltaIndex(['1 Day', '12 Hours'])
+
+ index = tm.box_expected(index, box)
+ expected = tm.box_expected(expected, box)
+
+ result = scalar_td / index
+ tm.assert_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ index / scalar_td
+
+
+# ------------------------------------------------------------------
+# Arithmetic
+
+class TestDivisionByZero(object):
+
+ def test_div_zero(self, zero, idx):
+ expected = pd.Index([np.nan, np.inf, np.inf, np.inf, np.inf],
+ dtype=np.float64)
+ result = idx / zero
+ tm.assert_index_equal(result, expected)
+ ser_compat = Series(idx).astype('i8') / np.array(zero).astype('i8')
+ tm.assert_series_equal(ser_compat, Series(result))
+
+ def test_floordiv_zero(self, zero, idx):
+ expected = pd.Index([np.nan, np.inf, np.inf, np.inf, np.inf],
+ dtype=np.float64)
+
+ result = idx // zero
+ tm.assert_index_equal(result, expected)
+ ser_compat = Series(idx).astype('i8') // np.array(zero).astype('i8')
+ tm.assert_series_equal(ser_compat, Series(result))
+
+ def test_mod_zero(self, zero, idx):
+ expected = pd.Index([np.nan, np.nan, np.nan, np.nan, np.nan],
+ dtype=np.float64)
+ result = idx % zero
+ tm.assert_index_equal(result, expected)
+ ser_compat = Series(idx).astype('i8') % np.array(zero).astype('i8')
+ tm.assert_series_equal(ser_compat, Series(result))
+
+ def test_divmod_zero(self, zero, idx):
+
+ exleft = pd.Index([np.nan, np.inf, np.inf, np.inf, np.inf],
+ dtype=np.float64)
+ exright = pd.Index([np.nan, np.nan, np.nan, np.nan, np.nan],
+ dtype=np.float64)
+
+ result = divmod(idx, zero)
+ tm.assert_index_equal(result[0], exleft)
+ tm.assert_index_equal(result[1], exright)
+
+ # ------------------------------------------------------------------
+
+ @pytest.mark.parametrize('dtype2', [
+ np.int64, np.int32, np.int16, np.int8,
+ np.float64, np.float32, np.float16,
+ np.uint64, np.uint32, np.uint16, np.uint8])
+ @pytest.mark.parametrize('dtype1', [np.int64, np.float64, np.uint64])
+ def test_ser_div_ser(self, dtype1, dtype2):
+ # no longer do integer div for any ops, but deal with the 0's
+ first = Series([3, 4, 5, 8], name='first').astype(dtype1)
+ second = Series([0, 0, 0, 3], name='second').astype(dtype2)
+
+ with np.errstate(all='ignore'):
+ expected = Series(first.values.astype(np.float64) / second.values,
+ dtype='float64', name=None)
+ expected.iloc[0:3] = np.inf
+
+ result = first / second
+ tm.assert_series_equal(result, expected)
+ assert not result.equals(second / first)
+
+ def test_rdiv_zero_compat(self):
+ # GH#8674
+ zero_array = np.array([0] * 5)
+ data = np.random.randn(5)
+ expected = Series([0.] * 5)
+
+ result = zero_array / Series(data)
+ tm.assert_series_equal(result, expected)
+
+ result = Series(zero_array) / data
+ tm.assert_series_equal(result, expected)
+
+ result = Series(zero_array) / Series(data)
+ tm.assert_series_equal(result, expected)
+
+ def test_div_zero_inf_signs(self):
+ # GH#9144, inf signing
+ ser = Series([-1, 0, 1], name='first')
+ expected = Series([-np.inf, np.nan, np.inf], name='first')
+
+ result = ser / 0
+ tm.assert_series_equal(result, expected)
+
+ def test_rdiv_zero(self):
+ # GH#9144
+ ser = Series([-1, 0, 1], name='first')
+ expected = Series([0.0, np.nan, 0.0], name='first')
+
+ result = 0 / ser
+ tm.assert_series_equal(result, expected)
+
+ def test_floordiv_div(self):
+ # GH#9144
+ ser = Series([-1, 0, 1], name='first')
+
+ result = ser // 0
+ expected = Series([-np.inf, np.nan, np.inf], name='first')
+ tm.assert_series_equal(result, expected)
+
+ def test_df_div_zero_df(self):
+ # integer div, but deal with the 0's (GH#9144)
+ df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
+ result = df / df
+
+ first = pd.Series([1.0, 1.0, 1.0, 1.0])
+ second = pd.Series([np.nan, np.nan, np.nan, 1])
+ expected = pd.DataFrame({'first': first, 'second': second})
+ tm.assert_frame_equal(result, expected)
+
+ def test_df_div_zero_array(self):
+ # integer div, but deal with the 0's (GH#9144)
+ df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
+
+ first = pd.Series([1.0, 1.0, 1.0, 1.0])
+ second = pd.Series([np.nan, np.nan, np.nan, 1])
+ expected = pd.DataFrame({'first': first, 'second': second})
+
+ with np.errstate(all='ignore'):
+ arr = df.values.astype('float') / df.values
+ result = pd.DataFrame(arr, index=df.index,
+ columns=df.columns)
+ tm.assert_frame_equal(result, expected)
+
+ def test_df_div_zero_int(self):
+ # integer div, but deal with the 0's (GH#9144)
+ df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
+
+ result = df / 0
+ expected = pd.DataFrame(np.inf, index=df.index, columns=df.columns)
+ expected.iloc[0:3, 1] = np.nan
+ tm.assert_frame_equal(result, expected)
+
+ # numpy has a slightly different (wrong) treatment
+ with np.errstate(all='ignore'):
+ arr = df.values.astype('float64') / 0
+ result2 = pd.DataFrame(arr, index=df.index,
+ columns=df.columns)
+ tm.assert_frame_equal(result2, expected)
+
+ def test_df_div_zero_series_does_not_commute(self):
+ # integer div, but deal with the 0's (GH#9144)
+ df = pd.DataFrame(np.random.randn(10, 5))
+ ser = df[0]
+ res = ser / df
+ res2 = df / ser
+ assert not res.fillna(0).equals(res2.fillna(0))
+
+ # ------------------------------------------------------------------
+ # Mod By Zero
+
+ def test_df_mod_zero_df(self):
+ # GH#3590, modulo as ints
+ df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
+
+ # this is technically wrong, as the integer portion is coerced to float
+ # ###
+ first = pd.Series([0, 0, 0, 0], dtype='float64')
+ second = pd.Series([np.nan, np.nan, np.nan, 0])
+ expected = pd.DataFrame({'first': first, 'second': second})
+ result = df % df
+ tm.assert_frame_equal(result, expected)
+
+ def test_df_mod_zero_array(self):
+ # GH#3590, modulo as ints
+ df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
+
+ # this is technically wrong, as the integer portion is coerced to float
+ # ###
+ first = pd.Series([0, 0, 0, 0], dtype='float64')
+ second = pd.Series([np.nan, np.nan, np.nan, 0])
+ expected = pd.DataFrame({'first': first, 'second': second})
+
+ # numpy has a slightly different (wrong) treatment
+ with np.errstate(all='ignore'):
+ arr = df.values % df.values
+ result2 = pd.DataFrame(arr, index=df.index,
+ columns=df.columns, dtype='float64')
+ result2.iloc[0:3, 1] = np.nan
+ tm.assert_frame_equal(result2, expected)
+
+ def test_df_mod_zero_int(self):
+ # GH#3590, modulo as ints
+ df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
+
+ result = df % 0
+ expected = pd.DataFrame(np.nan, index=df.index, columns=df.columns)
+ tm.assert_frame_equal(result, expected)
+
+ # numpy has a slightly different (wrong) treatment
+ with np.errstate(all='ignore'):
+ arr = df.values.astype('float64') % 0
+ result2 = pd.DataFrame(arr, index=df.index, columns=df.columns)
+ tm.assert_frame_equal(result2, expected)
+
+ def test_df_mod_zero_series_does_not_commute(self):
+ # GH#3590, modulo as ints
+ # not commutative with series
+ df = pd.DataFrame(np.random.randn(10, 5))
+ ser = df[0]
+ res = ser % df
+ res2 = df % ser
+ assert not res.fillna(0).equals(res2.fillna(0))
+
+
+class TestMultiplicationDivision(object):
+ # __mul__, __rmul__, __div__, __rdiv__, __floordiv__, __rfloordiv__
+ # for non-timestamp/timedelta/period dtypes
+
+ @pytest.mark.parametrize('box', [
+ pytest.param(pd.Index,
+ marks=pytest.mark.xfail(reason="Index.__div__ always "
+ "raises",
+ raises=TypeError, strict=True)),
+ pd.Series,
+ pd.DataFrame
+ ], ids=lambda x: x.__name__)
+ def test_divide_decimal(self, box):
+ # resolves issue GH#9787
+ ser = Series([Decimal(10)])
+ expected = Series([Decimal(5)])
+
+ ser = tm.box_expected(ser, box)
+ expected = tm.box_expected(expected, box)
+
+ result = ser / Decimal(2)
+
+ tm.assert_equal(result, expected)
+
+ result = ser // Decimal(2)
+ tm.assert_equal(result, expected)
+
+ def test_div_equiv_binop(self):
+ # Test Series.div as well as Series.__div__
+ # float/integer issue
+ # GH#7785
+ first = Series([1, 0], name='first')
+ second = Series([-0.01, -0.02], name='second')
+ expected = Series([-0.01, -np.inf])
+
+ result = second.div(first)
+ tm.assert_series_equal(result, expected, check_names=False)
+
+ result = second / first
+ tm.assert_series_equal(result, expected)
+
+ def test_div_int(self, idx):
+ # truediv under PY3
+ result = idx / 1
+ expected = idx
+ if PY3:
+ expected = expected.astype('float64')
+ tm.assert_index_equal(result, expected)
+
+ result = idx / 2
+ if PY3:
+ expected = expected.astype('float64')
+ expected = Index(idx.values / 2)
+ tm.assert_index_equal(result, expected)
+
+ def test_mul_int(self, idx):
+ result = idx * 1
+ tm.assert_index_equal(result, idx)
+
+ def test_rmul_int(self, idx):
+ result = 1 * idx
+ tm.assert_index_equal(result, idx)
+
+ def test_floordiv_int(self, idx):
+ result = idx // 1
+ tm.assert_index_equal(result, idx)
+
+ def test_mul_int_array(self, idx):
+ didx = idx * idx
+
+ result = idx * np.array(5, dtype='int64')
+ tm.assert_index_equal(result, idx * 5)
+
+ arr_dtype = 'uint64' if isinstance(idx, pd.UInt64Index) else 'int64'
+ result = idx * np.arange(5, dtype=arr_dtype)
+ tm.assert_index_equal(result, didx)
+
+ def test_mul_int_series(self, idx):
+ didx = idx * idx
+
+ arr_dtype = 'uint64' if isinstance(idx, pd.UInt64Index) else 'int64'
+ result = idx * Series(np.arange(5, dtype=arr_dtype))
+ tm.assert_series_equal(result, Series(didx))
+
+ def test_mul_float_series(self, idx):
+ rng5 = np.arange(5, dtype='float64')
+
+ result = idx * Series(rng5 + 0.1)
+ expected = Series(rng5 * (rng5 + 0.1))
+ tm.assert_series_equal(result, expected)
+
+ def test_mul_index(self, idx):
+ # in general not true for RangeIndex
+ if not isinstance(idx, pd.RangeIndex):
+ result = idx * idx
+ tm.assert_index_equal(result, idx ** 2)
+
+ def test_mul_datelike_raises(self, idx):
+ with pytest.raises(TypeError):
+ idx * pd.date_range('20130101', periods=5)
+
+ def test_mul_size_mismatch_raises(self, idx):
+ with pytest.raises(ValueError):
+ idx * idx[0:3]
+ with pytest.raises(ValueError):
+ idx * np.array([1, 2])
+
+ def test_pow_float(self, idx):
+ # test power calculations both ways, GH#14973
+ expected = pd.Float64Index(idx.values**2.0)
+ result = idx**2.0
+ tm.assert_index_equal(result, expected)
+
+ def test_rpow_float(self, idx):
+ # test power calculations both ways, GH#14973
+ expected = pd.Float64Index(2.0**idx.values)
+ result = 2.0**idx
+ tm.assert_index_equal(result, expected)
+
+ def test_modulo(self, idx):
+ # GH#9244
+ expected = Index(idx.values % 2)
+ tm.assert_index_equal(idx % 2, expected)
+
+ def test_divmod(self, idx):
+ result = divmod(idx, 2)
+ with np.errstate(all='ignore'):
+ div, mod = divmod(idx.values, 2)
+ expected = Index(div), Index(mod)
+ for r, e in zip(result, expected):
+ tm.assert_index_equal(r, e)
+
+ other = np.ones(idx.values.shape, dtype=idx.values.dtype) * 2
+ result = divmod(idx, other)
+ with np.errstate(all='ignore'):
+ div, mod = divmod(idx.values, other)
+ expected = Index(div), Index(mod)
+ for r, e in zip(result, expected):
+ tm.assert_index_equal(r, e)
+
+ @pytest.mark.xfail(reason='GH#19252 Series has no __rdivmod__',
+ strict=True)
+ def test_divmod_series(self, idx):
+ other = np.ones(idx.values.shape, dtype=idx.values.dtype) * 2
+ result = divmod(idx, Series(other))
+ with np.errstate(all='ignore'):
+ div, mod = divmod(idx.values, other)
+ expected = Series(div), Series(mod)
+
+ for r, e in zip(result, expected):
+ tm.assert_series_equal(r, e)
+
+
+class TestAdditionSubtraction(object):
+ # __add__, __sub__, __radd__, __rsub__, __iadd__, __isub__
+ # for non-timestamp/timedelta/period dtypes
+ pass
+
+
+class TestObjectDtypeEquivalence(object):
+ # Tests that arithmetic operations match operations executed elementwise
+
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_series_with_dtype_radd_nan(self, dtype):
+ ser = pd.Series([1, 2, 3], dtype=dtype)
+ expected = pd.Series([np.nan, np.nan, np.nan], dtype=dtype)
+
+ result = np.nan + ser
+ tm.assert_series_equal(result, expected)
+
+ result = ser + np.nan
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_series_with_dtype_radd_int(self, dtype):
+ ser = pd.Series([1, 2, 3], dtype=dtype)
+ expected = pd.Series([2, 3, 4], dtype=dtype)
+
+ result = 1 + ser
+ tm.assert_series_equal(result, expected)
+
+ result = ser + 1
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_df_with_dtype_radd_nan(self, dtype):
+ df = pd.DataFrame([1, 2, 3], dtype=dtype)
+ expected = pd.DataFrame([np.nan, np.nan, np.nan], dtype=dtype)
+
+ result = np.nan + df
+ tm.assert_frame_equal(result, expected)
+
+ result = df + np.nan
+ tm.assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_df_with_dtype_radd_int(self, dtype):
+ df = pd.DataFrame([1, 2, 3], dtype=dtype)
+ expected = pd.DataFrame([2, 3, 4], dtype=dtype)
+
+ result = 1 + df
+ tm.assert_frame_equal(result, expected)
+
+ result = df + 1
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/arithmetic/test_object.py b/pandas/tests/arithmetic/test_object.py
new file mode 100644
index 0000000000000..e27ba6af39b90
--- /dev/null
+++ b/pandas/tests/arithmetic/test_object.py
@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+# Arithmetc tests for DataFrame/Series/Index/Array classes that should
+# behave identically.
+# Specifically for object dtype
+
+import pytest
+import numpy as np
+
+import pandas as pd
+import pandas.util.testing as tm
+
+from pandas import Series, Timestamp
+
+
+# ------------------------------------------------------------------
+# Comparisons
+
+class TestObjectComparisons(object):
+
+ def test_object_comparisons(self):
+ ser = Series(['a', 'b', np.nan, 'c', 'a'])
+
+ result = ser == 'a'
+ expected = Series([True, False, False, False, True])
+ tm.assert_series_equal(result, expected)
+
+ result = ser < 'a'
+ expected = Series([False, False, False, False, False])
+ tm.assert_series_equal(result, expected)
+
+ result = ser != 'a'
+ expected = -(ser == 'a')
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_more_na_comparisons(self, dtype):
+ left = Series(['a', np.nan, 'c'], dtype=dtype)
+ right = Series(['a', np.nan, 'd'], dtype=dtype)
+
+ result = left == right
+ expected = Series([True, False, False])
+ tm.assert_series_equal(result, expected)
+
+ result = left != right
+ expected = Series([False, True, True])
+ tm.assert_series_equal(result, expected)
+
+ result = left == np.nan
+ expected = Series([False, False, False])
+ tm.assert_series_equal(result, expected)
+
+ result = left != np.nan
+ expected = Series([True, True, True])
+ tm.assert_series_equal(result, expected)
+
+
+# ------------------------------------------------------------------
+# Arithmetic
+
+class TestArithmetic(object):
+ def test_df_radd_str(self):
+ df = pd.DataFrame(['x', np.nan, 'x'])
+
+ expected = pd.DataFrame(['ax', np.nan, 'ax'])
+ result = 'a' + df
+ tm.assert_frame_equal(result, expected)
+
+ expected = pd.DataFrame(['xa', np.nan, 'xa'])
+ result = df + 'a'
+ tm.assert_frame_equal(result, expected)
+
+ def test_series_radd_str(self):
+ ser = pd.Series(['x', np.nan, 'x'])
+ tm.assert_series_equal('a' + ser, pd.Series(['ax', np.nan, 'ax']))
+ tm.assert_series_equal(ser + 'a', pd.Series(['xa', np.nan, 'xa']))
+
+ @pytest.mark.parametrize('data', [
+ [1, 2, 3],
+ [1.1, 2.2, 3.3],
+ [pd.Timestamp('2011-01-01'), pd.Timestamp('2011-01-02'), pd.NaT],
+ ['x', 'y', 1]])
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_df_radd_str_invalid(self, dtype, data):
+ df = pd.DataFrame(data, dtype=dtype)
+ with pytest.raises(TypeError):
+ 'foo_' + df
+
+ @pytest.mark.parametrize('data', [
+ [1, 2, 3],
+ [1.1, 2.2, 3.3],
+ [Timestamp('2011-01-01'), Timestamp('2011-01-02'), pd.NaT],
+ ['x', 'y', 1]])
+ @pytest.mark.parametrize('dtype', [None, object])
+ def test_series_radd_str_invalid(self, dtype, data):
+ ser = Series(data, dtype=dtype)
+ with pytest.raises(TypeError):
+ 'foo_' + ser
+
+ # TODO: parametrize, better name
+ def test_object_ser_add_invalid(self):
+ # invalid ops
+ obj_ser = tm.makeObjectSeries()
+ obj_ser.name = 'objects'
+ with pytest.raises(Exception):
+ obj_ser + 1
+ with pytest.raises(Exception):
+ obj_ser + np.array(1, dtype=np.int64)
+ with pytest.raises(Exception):
+ obj_ser - 1
+ with pytest.raises(Exception):
+ obj_ser - np.array(1, dtype=np.int64)
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 20c547382ad57..1c677cebd3bb0 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -78,40 +78,3 @@ def test_df_add_flex_filled_mixed_dtypes(self):
dtype='datetime64[ns]'),
'B': ser * 2})
tm.assert_frame_equal(result, expected)
-
-
-class TestFrameArithmetic(object):
-
- @pytest.mark.parametrize('data', [
- [1, 2, 3],
- [1.1, 2.2, 3.3],
- [pd.Timestamp('2011-01-01'), pd.Timestamp('2011-01-02'), pd.NaT],
- ['x', 'y', 1]])
- @pytest.mark.parametrize('dtype', [None, object])
- def test_df_radd_str_invalid(self, dtype, data):
- df = pd.DataFrame(data, dtype=dtype)
- with pytest.raises(TypeError):
- 'foo_' + df
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_df_with_dtype_radd_int(self, dtype):
- df = pd.DataFrame([1, 2, 3], dtype=dtype)
- expected = pd.DataFrame([2, 3, 4], dtype=dtype)
- result = 1 + df
- tm.assert_frame_equal(result, expected)
- result = df + 1
- tm.assert_frame_equal(result, expected)
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_df_with_dtype_radd_nan(self, dtype):
- df = pd.DataFrame([1, 2, 3], dtype=dtype)
- expected = pd.DataFrame([np.nan, np.nan, np.nan], dtype=dtype)
- result = np.nan + df
- tm.assert_frame_equal(result, expected)
- result = df + np.nan
- tm.assert_frame_equal(result, expected)
-
- def test_df_radd_str(self):
- df = pd.DataFrame(['x', np.nan, 'x'])
- tm.assert_frame_equal('a' + df, pd.DataFrame(['ax', np.nan, 'ax']))
- tm.assert_frame_equal(df + 'a', pd.DataFrame(['xa', np.nan, 'xa']))
diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py
index 32edb2591b735..b6d61187a3fc3 100644
--- a/pandas/tests/indexes/test_numeric.py
+++ b/pandas/tests/indexes/test_numeric.py
@@ -3,12 +3,12 @@
import pytest
from datetime import datetime
-from pandas.compat import range, PY3
+from pandas.compat import range
import numpy as np
-from pandas import (date_range, Series, Index, Float64Index,
- Int64Index, UInt64Index, RangeIndex)
+from pandas import (Series, Index, Float64Index,
+ Int64Index, UInt64Index)
import pandas.util.testing as tm
@@ -18,14 +18,6 @@
from pandas.tests.indexes.common import Base
-def full_like(array, value):
- """Compatibility for numpy<1.8.0
- """
- ret = np.empty(array.shape, dtype=np.array(value).dtype)
- ret.fill(value)
- return ret
-
-
class Numeric(Base):
def test_can_hold_identifiers(self):
@@ -36,133 +28,6 @@ def test_can_hold_identifiers(self):
def test_numeric_compat(self):
pass # override Base method
- def test_mul_int(self):
- idx = self.create_index()
- result = idx * 1
- tm.assert_index_equal(result, idx)
-
- def test_rmul_int(self):
- idx = self.create_index()
-
- result = 1 * idx
- tm.assert_index_equal(result, idx)
-
- def test_div_int(self):
- idx = self.create_index()
-
- # truediv under PY3
- result = idx / 1
- expected = idx
- if PY3:
- expected = expected.astype('float64')
- tm.assert_index_equal(result, expected)
-
- result = idx / 2
- if PY3:
- expected = expected.astype('float64')
- expected = Index(idx.values / 2)
- tm.assert_index_equal(result, expected)
-
- def test_floordiv_int(self):
- idx = self.create_index()
-
- result = idx // 1
- tm.assert_index_equal(result, idx)
-
- def test_mul_int_array(self):
- idx = self.create_index()
- didx = idx * idx
-
- result = idx * np.array(5, dtype='int64')
- tm.assert_index_equal(result, idx * 5)
-
- arr_dtype = 'uint64' if isinstance(idx, UInt64Index) else 'int64'
- result = idx * np.arange(5, dtype=arr_dtype)
- tm.assert_index_equal(result, didx)
-
- def test_mul_int_series(self):
- idx = self.create_index()
- didx = idx * idx
-
- arr_dtype = 'uint64' if isinstance(idx, UInt64Index) else 'int64'
- result = idx * Series(np.arange(5, dtype=arr_dtype))
- tm.assert_series_equal(result, Series(didx))
-
- def test_mul_float_series(self):
- idx = self.create_index()
- rng5 = np.arange(5, dtype='float64')
-
- result = idx * Series(rng5 + 0.1)
- expected = Series(rng5 * (rng5 + 0.1))
- tm.assert_series_equal(result, expected)
-
- def test_mul_index(self):
- idx = self.create_index()
-
- # in general not true for RangeIndex
- if not isinstance(idx, RangeIndex):
- result = idx * idx
- tm.assert_index_equal(result, idx ** 2)
-
- def test_mul_datelike_raises(self):
- idx = self.create_index()
- with pytest.raises(TypeError):
- idx * date_range('20130101', periods=5)
-
- def test_mul_size_mismatch_raises(self):
- idx = self.create_index()
-
- with pytest.raises(ValueError):
- idx * idx[0:3]
- with pytest.raises(ValueError):
- idx * np.array([1, 2])
-
- def test_divmod(self):
- idx = self.create_index()
-
- result = divmod(idx, 2)
- with np.errstate(all='ignore'):
- div, mod = divmod(idx.values, 2)
- expected = Index(div), Index(mod)
- for r, e in zip(result, expected):
- tm.assert_index_equal(r, e)
-
- result = divmod(idx, full_like(idx.values, 2))
- with np.errstate(all='ignore'):
- div, mod = divmod(idx.values, full_like(idx.values, 2))
- expected = Index(div), Index(mod)
- for r, e in zip(result, expected):
- tm.assert_index_equal(r, e)
-
- def test_pow_float(self):
- # test power calculations both ways, GH 14973
- idx = self.create_index()
-
- expected = pd.Float64Index(idx.values**2.0)
- result = idx**2.0
- tm.assert_index_equal(result, expected)
-
- def test_rpow_float(self):
- # test power calculations both ways, GH 14973
- idx = self.create_index()
-
- expected = pd.Float64Index(2.0**idx.values)
- result = 2.0**idx
- tm.assert_index_equal(result, expected)
-
- @pytest.mark.xfail(reason='GH#19252 Series has no __rdivmod__',
- strict=True)
- def test_divmod_series(self):
- idx = self.create_index()
-
- result = divmod(idx, Series(full_like(idx.values, 2)))
- with np.errstate(all='ignore'):
- div, mod = divmod(idx.values, full_like(idx.values, 2))
- expected = Series(div), Series(mod)
-
- for r, e in zip(result, expected):
- tm.assert_series_equal(r, e)
-
def test_explicit_conversions(self):
# GH 8608
@@ -218,12 +83,6 @@ def test_index_groupby(self):
ex_keys[1]: idx[[1, 4]]}
tm.assert_dict_equal(idx.groupby(to_groupby), expected)
- def test_modulo(self):
- # GH 9244
- index = self.create_index()
- expected = Index(index.values % 2)
- tm.assert_index_equal(index % 2, expected)
-
@pytest.mark.parametrize('klass', [list, tuple, np.array, Series])
def test_where(self, klass):
i = self.create_index()
diff --git a/pandas/tests/indexes/timedeltas/test_arithmetic.py b/pandas/tests/indexes/timedeltas/test_arithmetic.py
index e60705075267f..21d895fa59021 100644
--- a/pandas/tests/indexes/timedeltas/test_arithmetic.py
+++ b/pandas/tests/indexes/timedeltas/test_arithmetic.py
@@ -8,7 +8,7 @@
import pandas as pd
import pandas.util.testing as tm
from pandas import (DatetimeIndex, TimedeltaIndex, Int64Index,
- to_timedelta, timedelta_range, date_range,
+ timedelta_range, date_range,
Series,
Timestamp, Timedelta)
from pandas.errors import NullFrequencyError
@@ -27,103 +27,6 @@ def freq(request):
return request.param
-class TestTimedeltaIndexComparisons(object):
- def test_tdi_cmp_str_invalid(self):
- # GH 13624
- tdi = TimedeltaIndex(['1 day', '2 days'])
-
- for left, right in [(tdi, 'a'), ('a', tdi)]:
- with pytest.raises(TypeError):
- left > right
-
- with pytest.raises(TypeError):
- left == right
-
- with pytest.raises(TypeError):
- left != right
-
- def test_comparisons_coverage(self):
- rng = timedelta_range('1 days', periods=10)
-
- result = rng < rng[3]
- exp = np.array([True, True, True] + [False] * 7)
- tm.assert_numpy_array_equal(result, exp)
-
- # raise TypeError for now
- pytest.raises(TypeError, rng.__lt__, rng[3].value)
-
- result = rng == list(rng)
- exp = rng == rng
- tm.assert_numpy_array_equal(result, exp)
-
- def test_comp_nat(self):
- left = pd.TimedeltaIndex([pd.Timedelta('1 days'), pd.NaT,
- pd.Timedelta('3 days')])
- right = pd.TimedeltaIndex([pd.NaT, pd.NaT, pd.Timedelta('3 days')])
-
- for lhs, rhs in [(left, right),
- (left.astype(object), right.astype(object))]:
- result = rhs == lhs
- expected = np.array([False, False, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = rhs != lhs
- expected = np.array([True, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- expected = np.array([False, False, False])
- tm.assert_numpy_array_equal(lhs == pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT == rhs, expected)
-
- expected = np.array([True, True, True])
- tm.assert_numpy_array_equal(lhs != pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT != lhs, expected)
-
- expected = np.array([False, False, False])
- tm.assert_numpy_array_equal(lhs < pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT > lhs, expected)
-
- def test_comparisons_nat(self):
- tdidx1 = pd.TimedeltaIndex(['1 day', pd.NaT, '1 day 00:00:01', pd.NaT,
- '1 day 00:00:01', '5 day 00:00:03'])
- tdidx2 = pd.TimedeltaIndex(['2 day', '2 day', pd.NaT, pd.NaT,
- '1 day 00:00:02', '5 days 00:00:03'])
- tdarr = np.array([np.timedelta64(2, 'D'),
- np.timedelta64(2, 'D'), np.timedelta64('nat'),
- np.timedelta64('nat'),
- np.timedelta64(1, 'D') + np.timedelta64(2, 's'),
- np.timedelta64(5, 'D') + np.timedelta64(3, 's')])
-
- cases = [(tdidx1, tdidx2), (tdidx1, tdarr)]
-
- # Check pd.NaT is handles as the same as np.nan
- for idx1, idx2 in cases:
-
- result = idx1 < idx2
- expected = np.array([True, False, False, False, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx2 > idx1
- expected = np.array([True, False, False, False, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 <= idx2
- expected = np.array([True, False, False, False, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx2 >= idx1
- expected = np.array([True, False, False, False, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 == idx2
- expected = np.array([False, False, False, False, False, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 != idx2
- expected = np.array([True, True, True, True, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
-
class TestTimedeltaIndexArithmetic(object):
# Addition and Subtraction Operations
@@ -527,14 +430,6 @@ def test_ops_ndarray(self):
if LooseVersion(np.__version__) >= LooseVersion('1.8'):
tm.assert_numpy_array_equal(other - td, expected)
- def test_ops_series(self):
- # regression test for GH8813
- td = Timedelta('1 day')
- other = pd.Series([1, 2])
- expected = pd.Series(pd.to_timedelta(['1 day', '2 days']))
- tm.assert_series_equal(expected, td * other)
- tm.assert_series_equal(expected, other * td)
-
def test_ops_series_object(self):
# GH 13043
s = pd.Series([pd.Timestamp('2015-01-01', tz='US/Eastern'),
@@ -656,62 +551,6 @@ def test_timedelta_ops_with_missing_values(self):
actual = df1 - pd.NaT
tm.assert_frame_equal(actual, dfn)
- def test_add_overflow(self):
- # see gh-14068
- msg = "too (big|large) to convert"
- with tm.assert_raises_regex(OverflowError, msg):
- to_timedelta(106580, 'D') + Timestamp('2000')
- with tm.assert_raises_regex(OverflowError, msg):
- Timestamp('2000') + to_timedelta(106580, 'D')
-
- _NaT = int(pd.NaT) + 1
- msg = "Overflow in int64 addition"
- with tm.assert_raises_regex(OverflowError, msg):
- to_timedelta([106580], 'D') + Timestamp('2000')
- with tm.assert_raises_regex(OverflowError, msg):
- Timestamp('2000') + to_timedelta([106580], 'D')
- with tm.assert_raises_regex(OverflowError, msg):
- to_timedelta([_NaT]) - Timedelta('1 days')
- with tm.assert_raises_regex(OverflowError, msg):
- to_timedelta(['5 days', _NaT]) - Timedelta('1 days')
- with tm.assert_raises_regex(OverflowError, msg):
- (to_timedelta([_NaT, '5 days', '1 hours']) -
- to_timedelta(['7 seconds', _NaT, '4 hours']))
-
- # These should not overflow!
- exp = TimedeltaIndex([pd.NaT])
- result = to_timedelta([pd.NaT]) - Timedelta('1 days')
- tm.assert_index_equal(result, exp)
-
- exp = TimedeltaIndex(['4 days', pd.NaT])
- result = to_timedelta(['5 days', pd.NaT]) - Timedelta('1 days')
- tm.assert_index_equal(result, exp)
-
- exp = TimedeltaIndex([pd.NaT, pd.NaT, '5 hours'])
- result = (to_timedelta([pd.NaT, '5 days', '1 hours']) +
- to_timedelta(['7 seconds', pd.NaT, '4 hours']))
- tm.assert_index_equal(result, exp)
-
- def test_timedeltaindex_add_timestamp_nat_masking(self):
- # GH17991 checking for overflow-masking with NaT
- tdinat = pd.to_timedelta(['24658 days 11:15:00', 'NaT'])
-
- tsneg = Timestamp('1950-01-01')
- ts_neg_variants = [tsneg,
- tsneg.to_pydatetime(),
- tsneg.to_datetime64().astype('datetime64[ns]'),
- tsneg.to_datetime64().astype('datetime64[D]')]
-
- tspos = Timestamp('1980-01-01')
- ts_pos_variants = [tspos,
- tspos.to_pydatetime(),
- tspos.to_datetime64().astype('datetime64[ns]'),
- tspos.to_datetime64().astype('datetime64[D]')]
-
- for variant in ts_neg_variants + ts_pos_variants:
- res = tdinat + variant
- assert res[1] is pd.NaT
-
def test_tdi_ops_attributes(self):
rng = timedelta_range('2 days', periods=5, freq='2D', name='x')
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 9ec9cbd8e1b89..15b30ec2c774a 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -1,12 +1,11 @@
# -*- coding: utf-8 -*-
from datetime import timedelta
import operator
-from decimal import Decimal
import numpy as np
import pytest
-from pandas import Series, Timestamp
+from pandas import Series
import pandas as pd
import pandas.util.testing as tm
@@ -90,92 +89,8 @@ def test_compare_timedelta_series(self):
# ------------------------------------------------------------------
# Arithmetic
-class TestSeriesDivision(object):
- # __div__, __rdiv__, __floordiv__, __rfloordiv__
- # for non-timestamp/timedelta/period dtypes
-
- def test_divide_decimal(self):
- # resolves issue GH#9787
- expected = Series([Decimal(5)])
-
- ser = Series([Decimal(10)])
- result = ser / Decimal(2)
-
- tm.assert_series_equal(result, expected)
-
- ser = Series([Decimal(10)])
- result = ser // Decimal(2)
-
- tm.assert_series_equal(result, expected)
-
- def test_div_equiv_binop(self):
- # Test Series.div as well as Series.__div__
- # float/integer issue
- # GH#7785
- first = Series([1, 0], name='first')
- second = Series([-0.01, -0.02], name='second')
- expected = Series([-0.01, -np.inf])
-
- result = second.div(first)
- tm.assert_series_equal(result, expected, check_names=False)
-
- result = second / first
- tm.assert_series_equal(result, expected)
-
-
class TestSeriesArithmetic(object):
# Standard, numeric, or otherwise not-Timestamp/Timedelta/Period dtypes
- @pytest.mark.parametrize('data', [
- [1, 2, 3],
- [1.1, 2.2, 3.3],
- [Timestamp('2011-01-01'), Timestamp('2011-01-02'), pd.NaT],
- ['x', 'y', 1]])
- @pytest.mark.parametrize('dtype', [None, object])
- def test_series_radd_str_invalid(self, dtype, data):
- ser = Series(data, dtype=dtype)
- with pytest.raises(TypeError):
- 'foo_' + ser
-
- # TODO: parametrize, better name
- def test_object_ser_add_invalid(self):
- # invalid ops
- obj_ser = tm.makeObjectSeries()
- obj_ser.name = 'objects'
- with pytest.raises(Exception):
- obj_ser + 1
- with pytest.raises(Exception):
- obj_ser + np.array(1, dtype=np.int64)
- with pytest.raises(Exception):
- obj_ser - 1
- with pytest.raises(Exception):
- obj_ser - np.array(1, dtype=np.int64)
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_series_with_dtype_radd_nan(self, dtype):
- ser = pd.Series([1, 2, 3], dtype=dtype)
- expected = pd.Series([np.nan, np.nan, np.nan], dtype=dtype)
-
- result = np.nan + ser
- tm.assert_series_equal(result, expected)
-
- result = ser + np.nan
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize('dtype', [None, object])
- def test_series_with_dtype_radd_int(self, dtype):
- ser = pd.Series([1, 2, 3], dtype=dtype)
- expected = pd.Series([2, 3, 4], dtype=dtype)
-
- result = 1 + ser
- tm.assert_series_equal(result, expected)
-
- result = ser + 1
- tm.assert_series_equal(result, expected)
-
- def test_series_radd_str(self):
- ser = pd.Series(['x', np.nan, 'x'])
- tm.assert_series_equal('a' + ser, pd.Series(['ax', np.nan, 'ax']))
- tm.assert_series_equal(ser + 'a', pd.Series(['xa', np.nan, 'xa']))
@pytest.mark.parametrize('dtype', [None, object])
def test_series_with_dtype_radd_timedelta(self, dtype):
diff --git a/pandas/tests/series/test_operators.py b/pandas/tests/series/test_operators.py
index df52b4cabc77c..c5d8d93bd768b 100644
--- a/pandas/tests/series/test_operators.py
+++ b/pandas/tests/series/test_operators.py
@@ -2,7 +2,6 @@
# pylint: disable-msg=E1101,W0612
import pytest
-import pytz
from collections import Iterable
from datetime import datetime, timedelta
@@ -19,7 +18,6 @@
from pandas.core.indexes.timedeltas import Timedelta
import pandas.core.nanops as nanops
-from pandas.errors import PerformanceWarning
from pandas.compat import range, zip
from pandas import compat
from pandas.util.testing import (assert_series_equal, assert_almost_equal,
@@ -30,19 +28,6 @@
class TestSeriesComparisons(object):
- def test_series_comparison_scalars(self):
- series = Series(date_range('1/1/2000', periods=10))
-
- val = datetime(2000, 1, 4)
- result = series > val
- expected = Series([x > val for x in series])
- tm.assert_series_equal(result, expected)
-
- val = series[5]
- result = series > val
- expected = Series([x > val for x in series])
- tm.assert_series_equal(result, expected)
-
def test_comparisons(self):
left = np.random.randn(10)
right = np.random.randn(10)
@@ -63,33 +48,6 @@ def test_comparisons(self):
assert_series_equal(s == s2, exp)
assert_series_equal(s2 == s, exp)
- def test_operator_series_comparison_zerorank(self):
- # GH 13006
- result = np.float64(0) > pd.Series([1, 2, 3])
- expected = 0.0 > pd.Series([1, 2, 3])
- tm.assert_series_equal(result, expected)
- result = pd.Series([1, 2, 3]) < np.float64(0)
- expected = pd.Series([1, 2, 3]) < 0.0
- tm.assert_series_equal(result, expected)
- result = np.array([0, 1, 2])[0] > pd.Series([0, 1, 2])
- expected = 0.0 > pd.Series([1, 2, 3])
- tm.assert_series_equal(result, expected)
-
- def test_object_comparisons(self):
- s = Series(['a', 'b', np.nan, 'c', 'a'])
-
- result = s == 'a'
- expected = Series([True, False, False, False, True])
- assert_series_equal(result, expected)
-
- result = s < 'a'
- expected = Series([False, False, False, False, False])
- assert_series_equal(result, expected)
-
- result = s != 'a'
- expected = -(s == 'a')
- assert_series_equal(result, expected)
-
def test_categorical_comparisons(self):
# GH 8938
# allow equality comparisons
@@ -284,27 +242,6 @@ def test_unequal_categorical_comparison_raises_type_error(self):
tm.assert_series_equal(cat == "d", Series([False, False, False]))
tm.assert_series_equal(cat != "d", Series([True, True, True]))
- @pytest.mark.parametrize('dtype', [None, object])
- def test_more_na_comparisons(self, dtype):
- left = Series(['a', np.nan, 'c'], dtype=dtype)
- right = Series(['a', np.nan, 'd'], dtype=dtype)
-
- result = left == right
- expected = Series([True, False, False])
- assert_series_equal(result, expected)
-
- result = left != right
- expected = Series([False, True, True])
- assert_series_equal(result, expected)
-
- result = left == np.nan
- expected = Series([False, False, False])
- assert_series_equal(result, expected)
-
- result = left != np.nan
- expected = Series([True, True, True])
- assert_series_equal(result, expected)
-
@pytest.mark.parametrize('pair', [
([pd.Timestamp('2011-01-01'), NaT, pd.Timestamp('2011-01-03')],
[NaT, NaT, pd.Timestamp('2011-01-03')]),
@@ -345,34 +282,6 @@ def test_nat_comparisons(self, dtype, box, reverse, pair):
expected = Series([False, False, True])
assert_series_equal(left <= right, expected)
- @pytest.mark.parametrize('data', [
- [pd.Timestamp('2011-01-01'), NaT, pd.Timestamp('2011-01-03')],
- [pd.Timedelta('1 days'), NaT, pd.Timedelta('3 days')],
- [pd.Period('2011-01', freq='M'), NaT, pd.Period('2011-03', freq='M')]
- ])
- @pytest.mark.parametrize('dtype', [None, object])
- def test_nat_comparisons_scalar(self, dtype, data):
- left = Series(data, dtype=dtype)
-
- expected = Series([False, False, False])
- assert_series_equal(left == pd.NaT, expected)
- assert_series_equal(pd.NaT == left, expected)
-
- expected = Series([True, True, True])
- assert_series_equal(left != pd.NaT, expected)
- assert_series_equal(pd.NaT != left, expected)
-
- expected = Series([False, False, False])
- assert_series_equal(left < pd.NaT, expected)
- assert_series_equal(pd.NaT > left, expected)
- assert_series_equal(left <= pd.NaT, expected)
- assert_series_equal(pd.NaT >= left, expected)
-
- assert_series_equal(left > pd.NaT, expected)
- assert_series_equal(pd.NaT < left, expected)
- assert_series_equal(left >= pd.NaT, expected)
- assert_series_equal(pd.NaT <= left, expected)
-
def test_comparison_different_length(self):
a = Series(['a', 'b', 'c'])
b = Series(['b', 'a'])
@@ -591,73 +500,6 @@ def test_comp_ops_df_compat(self):
class TestTimedeltaSeriesArithmetic(object):
- def test_timedelta64_operations_with_DateOffset(self):
- # GH 10699
- td = Series([timedelta(minutes=5, seconds=3)] * 3)
- result = td + pd.offsets.Minute(1)
- expected = Series([timedelta(minutes=6, seconds=3)] * 3)
- assert_series_equal(result, expected)
-
- result = td - pd.offsets.Minute(1)
- expected = Series([timedelta(minutes=4, seconds=3)] * 3)
- assert_series_equal(result, expected)
-
- with tm.assert_produces_warning(PerformanceWarning):
- result = td + Series([pd.offsets.Minute(1), pd.offsets.Second(3),
- pd.offsets.Hour(2)])
- expected = Series([timedelta(minutes=6, seconds=3), timedelta(
- minutes=5, seconds=6), timedelta(hours=2, minutes=5, seconds=3)])
- assert_series_equal(result, expected)
-
- result = td + pd.offsets.Minute(1) + pd.offsets.Second(12)
- expected = Series([timedelta(minutes=6, seconds=15)] * 3)
- assert_series_equal(result, expected)
-
- # valid DateOffsets
- for do in ['Hour', 'Minute', 'Second', 'Day', 'Micro', 'Milli',
- 'Nano']:
- op = getattr(pd.offsets, do)
- td + op(5)
- op(5) + td
- td - op(5)
- op(5) - td
-
- def test_timedelta64_operations_with_timedeltas(self):
- # td operate with td
- td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
- td2 = timedelta(minutes=5, seconds=4)
- result = td1 - td2
- expected = (Series([timedelta(seconds=0)] * 3) -
- Series([timedelta(seconds=1)] * 3))
- assert result.dtype == 'm8[ns]'
- assert_series_equal(result, expected)
-
- result2 = td2 - td1
- expected = (Series([timedelta(seconds=1)] * 3) -
- Series([timedelta(seconds=0)] * 3))
- assert_series_equal(result2, expected)
-
- # roundtrip
- assert_series_equal(result + td2, td1)
-
- # Now again, using pd.to_timedelta, which should build
- # a Series or a scalar, depending on input.
- td1 = Series(pd.to_timedelta(['00:05:03'] * 3))
- td2 = pd.to_timedelta('00:05:04')
- result = td1 - td2
- expected = (Series([timedelta(seconds=0)] * 3) -
- Series([timedelta(seconds=1)] * 3))
- assert result.dtype == 'm8[ns]'
- assert_series_equal(result, expected)
-
- result2 = td2 - td1
- expected = (Series([timedelta(seconds=1)] * 3) -
- Series([timedelta(seconds=0)] * 3))
- assert_series_equal(result2, expected)
-
- # roundtrip
- assert_series_equal(result + td2, td1)
-
def test_operators_timedelta64(self):
# series ops
v1 = date_range('2012-1-1', periods=3, freq='D')
@@ -807,40 +649,8 @@ def test_timedelta64_ops_nat(self):
assert_series_equal(timedelta_series / nan,
nat_series_dtype_timedelta)
- @pytest.mark.parametrize('scalar_td', [timedelta(minutes=5, seconds=4),
- Timedelta(minutes=5, seconds=4),
- Timedelta('5m4s').to_timedelta64()])
- def test_operators_timedelta64_with_timedelta(self, scalar_td):
- # smoke tests
- td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
- td1.iloc[2] = np.nan
-
- td1 + scalar_td
- scalar_td + td1
- td1 - scalar_td
- scalar_td - td1
- td1 / scalar_td
- scalar_td / td1
-
class TestDatetimeSeriesArithmetic(object):
- @pytest.mark.parametrize(
- 'box, assert_func',
- [(Series, tm.assert_series_equal),
- (pd.Index, tm.assert_index_equal)])
- def test_sub_datetime64_not_ns(self, box, assert_func):
- # GH#7996
- dt64 = np.datetime64('2013-01-01')
- assert dt64.dtype == 'datetime64[D]'
-
- obj = box(date_range('20130101', periods=3))
- res = obj - dt64
- expected = box([Timedelta(days=0), Timedelta(days=1),
- Timedelta(days=2)])
- assert_func(res, expected)
-
- res = dt64 - obj
- assert_func(res, -expected)
def test_operators_datetimelike_invalid(self, all_arithmetic_operators):
# these are all TypeEror ops
@@ -913,283 +723,6 @@ def test_operators_datetimelike(self):
td1 + dt1
dt1 + td1
- def test_operators_datetimelike_with_timezones(self):
-
- tz = 'US/Eastern'
- dt1 = Series(date_range('2000-01-01 09:00:00', periods=5,
- tz=tz), name='foo')
- dt2 = dt1.copy()
- dt2.iloc[2] = np.nan
-
- td1 = Series(timedelta_range('1 days 1 min', periods=5, freq='H'))
- td2 = td1.copy()
- td2.iloc[1] = np.nan
-
- result = dt1 + td1[0]
- exp = (dt1.dt.tz_localize(None) + td1[0]).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- result = dt2 + td2[0]
- exp = (dt2.dt.tz_localize(None) + td2[0]).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- # odd numpy behavior with scalar timedeltas
- result = td1[0] + dt1
- exp = (dt1.dt.tz_localize(None) + td1[0]).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- result = td2[0] + dt2
- exp = (dt2.dt.tz_localize(None) + td2[0]).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- result = dt1 - td1[0]
- exp = (dt1.dt.tz_localize(None) - td1[0]).dt.tz_localize(tz)
- assert_series_equal(result, exp)
- with pytest.raises(TypeError):
- td1[0] - dt1
-
- result = dt2 - td2[0]
- exp = (dt2.dt.tz_localize(None) - td2[0]).dt.tz_localize(tz)
- assert_series_equal(result, exp)
- with pytest.raises(TypeError):
- td2[0] - dt2
-
- result = dt1 + td1
- exp = (dt1.dt.tz_localize(None) + td1).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- result = dt2 + td2
- exp = (dt2.dt.tz_localize(None) + td2).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- result = dt1 - td1
- exp = (dt1.dt.tz_localize(None) - td1).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- result = dt2 - td2
- exp = (dt2.dt.tz_localize(None) - td2).dt.tz_localize(tz)
- assert_series_equal(result, exp)
-
- with pytest.raises(TypeError):
- td1 - dt1
- with pytest.raises(TypeError):
- td2 - dt2
-
- def test_sub_single_tz(self):
- # GH12290
- s1 = Series([pd.Timestamp('2016-02-10', tz='America/Sao_Paulo')])
- s2 = Series([pd.Timestamp('2016-02-08', tz='America/Sao_Paulo')])
- result = s1 - s2
- expected = Series([Timedelta('2days')])
- assert_series_equal(result, expected)
- result = s2 - s1
- expected = Series([Timedelta('-2days')])
- assert_series_equal(result, expected)
-
- def test_dt64tz_series_sub_dtitz(self):
- # GH#19071 subtracting tzaware DatetimeIndex from tzaware Series
- # (with same tz) raises, fixed by #19024
- dti = pd.date_range('1999-09-30', periods=10, tz='US/Pacific')
- ser = pd.Series(dti)
- expected = pd.Series(pd.TimedeltaIndex(['0days'] * 10))
-
- res = dti - ser
- tm.assert_series_equal(res, expected)
- res = ser - dti
- tm.assert_series_equal(res, expected)
-
- def test_sub_datetime_compat(self):
- # see gh-14088
- s = Series([datetime(2016, 8, 23, 12, tzinfo=pytz.utc), pd.NaT])
- dt = datetime(2016, 8, 22, 12, tzinfo=pytz.utc)
- exp = Series([Timedelta('1 days'), pd.NaT])
- assert_series_equal(s - dt, exp)
- assert_series_equal(s - Timestamp(dt), exp)
-
- def test_dt64_series_with_timedelta(self):
- # scalar timedeltas/np.timedelta64 objects
- # operate with np.timedelta64 correctly
- s = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
-
- result = s + np.timedelta64(1, 's')
- result2 = np.timedelta64(1, 's') + s
- expected = Series([Timestamp('20130101 9:01:01'),
- Timestamp('20130101 9:02:01')])
- assert_series_equal(result, expected)
- assert_series_equal(result2, expected)
-
- result = s + np.timedelta64(5, 'ms')
- result2 = np.timedelta64(5, 'ms') + s
- expected = Series([Timestamp('20130101 9:01:00.005'),
- Timestamp('20130101 9:02:00.005')])
- assert_series_equal(result, expected)
- assert_series_equal(result2, expected)
-
- def test_dt64_series_add_tick_DateOffset(self):
- # GH 4532
- # operate with pd.offsets
- ser = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
- expected = Series([Timestamp('20130101 9:01:05'),
- Timestamp('20130101 9:02:05')])
-
- result = ser + pd.offsets.Second(5)
- assert_series_equal(result, expected)
-
- result2 = pd.offsets.Second(5) + ser
- assert_series_equal(result2, expected)
-
- def test_dt64_series_sub_tick_DateOffset(self):
- # GH 4532
- # operate with pd.offsets
- ser = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
- expected = Series([Timestamp('20130101 9:00:55'),
- Timestamp('20130101 9:01:55')])
-
- result = ser - pd.offsets.Second(5)
- assert_series_equal(result, expected)
-
- result2 = -pd.offsets.Second(5) + ser
- assert_series_equal(result2, expected)
-
- with pytest.raises(TypeError):
- pd.offsets.Second(5) - ser
-
- @pytest.mark.parametrize('cls_name', ['Day', 'Hour', 'Minute', 'Second',
- 'Milli', 'Micro', 'Nano'])
- def test_dt64_series_with_tick_DateOffset_smoke(self, cls_name):
- # GH 4532
- # smoke tests for valid DateOffsets
- ser = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
-
- offset_cls = getattr(pd.offsets, cls_name)
- ser + offset_cls(5)
- offset_cls(5) + ser
-
- def test_dt64_series_add_mixed_tick_DateOffset(self):
- # GH 4532
- # operate with pd.offsets
- s = Series([Timestamp('20130101 9:01'), Timestamp('20130101 9:02')])
-
- result = s + pd.offsets.Milli(5)
- result2 = pd.offsets.Milli(5) + s
- expected = Series([Timestamp('20130101 9:01:00.005'),
- Timestamp('20130101 9:02:00.005')])
- assert_series_equal(result, expected)
- assert_series_equal(result2, expected)
-
- result = s + pd.offsets.Minute(5) + pd.offsets.Milli(5)
- expected = Series([Timestamp('20130101 9:06:00.005'),
- Timestamp('20130101 9:07:00.005')])
- assert_series_equal(result, expected)
-
- def test_dt64_series_sub_NaT(self):
- # GH#18808
- dti = pd.DatetimeIndex([pd.NaT, pd.Timestamp('19900315')])
- ser = pd.Series(dti)
- res = ser - pd.NaT
- expected = pd.Series([pd.NaT, pd.NaT], dtype='timedelta64[ns]')
- tm.assert_series_equal(res, expected)
-
- dti_tz = dti.tz_localize('Asia/Tokyo')
- ser_tz = pd.Series(dti_tz)
- res = ser_tz - pd.NaT
- expected = pd.Series([pd.NaT, pd.NaT], dtype='timedelta64[ns]')
- tm.assert_series_equal(res, expected)
-
- def test_datetime64_ops_nat(self):
- # GH 11349
- datetime_series = Series([NaT, Timestamp('19900315')])
- nat_series_dtype_timestamp = Series([NaT, NaT], dtype='datetime64[ns]')
- single_nat_dtype_datetime = Series([NaT], dtype='datetime64[ns]')
-
- # subtraction
- assert_series_equal(-NaT + datetime_series, nat_series_dtype_timestamp)
- with pytest.raises(TypeError):
- -single_nat_dtype_datetime + datetime_series
-
- assert_series_equal(-NaT + nat_series_dtype_timestamp,
- nat_series_dtype_timestamp)
- with pytest.raises(TypeError):
- -single_nat_dtype_datetime + nat_series_dtype_timestamp
-
- # addition
- assert_series_equal(nat_series_dtype_timestamp + NaT,
- nat_series_dtype_timestamp)
- assert_series_equal(NaT + nat_series_dtype_timestamp,
- nat_series_dtype_timestamp)
-
- assert_series_equal(nat_series_dtype_timestamp + NaT,
- nat_series_dtype_timestamp)
- assert_series_equal(NaT + nat_series_dtype_timestamp,
- nat_series_dtype_timestamp)
-
- @pytest.mark.parametrize('dt64_series', [
- Series([Timestamp('19900315'), Timestamp('19900315')]),
- Series([NaT, Timestamp('19900315')]),
- Series([NaT, NaT], dtype='datetime64[ns]')])
- @pytest.mark.parametrize('one', [1, 1.0, np.array(1)])
- def test_dt64_mul_div_numeric_invalid(self, one, dt64_series):
- # multiplication
- with pytest.raises(TypeError):
- dt64_series * one
- with pytest.raises(TypeError):
- one * dt64_series
-
- # division
- with pytest.raises(TypeError):
- dt64_series / one
- with pytest.raises(TypeError):
- one / dt64_series
-
- def test_dt64_series_arith_overflow(self):
- # GH#12534, fixed by #19024
- dt = pd.Timestamp('1700-01-31')
- td = pd.Timedelta('20000 Days')
- dti = pd.date_range('1949-09-30', freq='100Y', periods=4)
- ser = pd.Series(dti)
- with pytest.raises(OverflowError):
- ser - dt
- with pytest.raises(OverflowError):
- dt - ser
- with pytest.raises(OverflowError):
- ser + td
- with pytest.raises(OverflowError):
- td + ser
-
- ser.iloc[-1] = pd.NaT
- expected = pd.Series(['2004-10-03', '2104-10-04', '2204-10-04', 'NaT'],
- dtype='datetime64[ns]')
- res = ser + td
- tm.assert_series_equal(res, expected)
- res = td + ser
- tm.assert_series_equal(res, expected)
-
- ser.iloc[1:] = pd.NaT
- expected = pd.Series(['91279 Days', 'NaT', 'NaT', 'NaT'],
- dtype='timedelta64[ns]')
- res = ser - dt
- tm.assert_series_equal(res, expected)
- res = dt - ser
- tm.assert_series_equal(res, -expected)
-
- @pytest.mark.parametrize('op', ['__add__', '__radd__',
- '__sub__', '__rsub__'])
- @pytest.mark.parametrize('tz', [None, 'Asia/Tokyo'])
- def test_dt64_series_add_intlike(self, tz, op):
- # GH#19123
- dti = pd.DatetimeIndex(['2016-01-02', '2016-02-03', 'NaT'], tz=tz)
- ser = Series(dti)
-
- other = Series([20, 30, 40], dtype='uint8')
-
- pytest.raises(TypeError, getattr(ser, op), 1)
-
- pytest.raises(TypeError, getattr(ser, op), other)
-
- pytest.raises(TypeError, getattr(ser, op), other.values)
-
- pytest.raises(TypeError, getattr(ser, op), pd.Index(other))
-
class TestSeriesOperators(TestData):
@pytest.mark.parametrize(
diff --git a/pandas/tests/test_arithmetic.py b/pandas/tests/test_arithmetic.py
index 0d62a5db581fe..c4bc9c71927fb 100644
--- a/pandas/tests/test_arithmetic.py
+++ b/pandas/tests/test_arithmetic.py
@@ -10,7 +10,6 @@
import pandas as pd
import pandas.util.testing as tm
-from pandas.compat import long
from pandas.core import ops
from pandas.errors import NullFrequencyError, PerformanceWarning
from pandas._libs.tslibs import IncompatibleFrequency
@@ -74,79 +73,172 @@ def box_df_fail(request):
# ------------------------------------------------------------------
-# Numeric dtypes Arithmetic with Timedelta Scalar
+# Timedelta64[ns] dtype Comparisons
-class TestNumericArraylikeArithmeticWithTimedeltaScalar(object):
+class TestTimedelta64ArrayComparisons(object):
+ # TODO: All of these need to be parametrized over box
- @pytest.mark.parametrize('box', [
- pd.Index,
- Series,
- pytest.param(pd.DataFrame,
- marks=pytest.mark.xfail(reason="block.eval incorrect",
- strict=True))
- ])
- @pytest.mark.parametrize('index', [
- pd.Int64Index(range(1, 11)),
- pd.UInt64Index(range(1, 11)),
- pd.Float64Index(range(1, 11)),
- pd.RangeIndex(1, 11)],
- ids=lambda x: type(x).__name__)
- @pytest.mark.parametrize('scalar_td', [
- Timedelta(days=1),
- Timedelta(days=1).to_timedelta64(),
- Timedelta(days=1).to_pytimedelta()],
- ids=lambda x: type(x).__name__)
- def test_numeric_arr_mul_tdscalar(self, scalar_td, index, box):
- # GH#19333
+ def test_tdi_cmp_str_invalid(self):
+ # GH#13624
+ tdi = TimedeltaIndex(['1 day', '2 days'])
- if (box is Series and
- type(scalar_td) is timedelta and index.dtype == 'f8'):
- raise pytest.xfail(reason="Cannot multiply timedelta by float")
+ for left, right in [(tdi, 'a'), ('a', tdi)]:
+ with pytest.raises(TypeError):
+ left > right
- expected = timedelta_range('1 days', '10 days')
+ with pytest.raises(TypeError):
+ left == right
- index = tm.box_expected(index, box)
- expected = tm.box_expected(expected, box)
+ with pytest.raises(TypeError):
+ left != right
- result = index * scalar_td
- tm.assert_equal(result, expected)
+ def test_comp_nat(self):
+ left = pd.TimedeltaIndex([pd.Timedelta('1 days'), pd.NaT,
+ pd.Timedelta('3 days')])
+ right = pd.TimedeltaIndex([pd.NaT, pd.NaT, pd.Timedelta('3 days')])
- commute = scalar_td * index
- tm.assert_equal(commute, expected)
+ for lhs, rhs in [(left, right),
+ (left.astype(object), right.astype(object))]:
+ result = rhs == lhs
+ expected = np.array([False, False, True])
+ tm.assert_numpy_array_equal(result, expected)
- @pytest.mark.parametrize('index', [
- pd.Int64Index(range(1, 3)),
- pd.UInt64Index(range(1, 3)),
- pd.Float64Index(range(1, 3)),
- pd.RangeIndex(1, 3)],
- ids=lambda x: type(x).__name__)
- @pytest.mark.parametrize('scalar_td', [
- Timedelta(days=1),
- Timedelta(days=1).to_timedelta64(),
- Timedelta(days=1).to_pytimedelta()],
- ids=lambda x: type(x).__name__)
- def test_numeric_arr_rdiv_tdscalar(self, scalar_td, index, box):
+ result = rhs != lhs
+ expected = np.array([True, True, False])
+ tm.assert_numpy_array_equal(result, expected)
- if box is Series and type(scalar_td) is timedelta:
- raise pytest.xfail(reason="TODO: Figure out why this case fails")
- if box is pd.DataFrame and isinstance(scalar_td, timedelta):
- raise pytest.xfail(reason="TODO: Figure out why this case fails")
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(lhs == pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT == rhs, expected)
- expected = TimedeltaIndex(['1 Day', '12 Hours'])
+ expected = np.array([True, True, True])
+ tm.assert_numpy_array_equal(lhs != pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT != lhs, expected)
- index = tm.box_expected(index, box)
- expected = tm.box_expected(expected, box)
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(lhs < pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT > lhs, expected)
- result = scalar_td / index
- tm.assert_equal(result, expected)
+ def test_comparisons_nat(self):
+ tdidx1 = pd.TimedeltaIndex(['1 day', pd.NaT, '1 day 00:00:01', pd.NaT,
+ '1 day 00:00:01', '5 day 00:00:03'])
+ tdidx2 = pd.TimedeltaIndex(['2 day', '2 day', pd.NaT, pd.NaT,
+ '1 day 00:00:02', '5 days 00:00:03'])
+ tdarr = np.array([np.timedelta64(2, 'D'),
+ np.timedelta64(2, 'D'), np.timedelta64('nat'),
+ np.timedelta64('nat'),
+ np.timedelta64(1, 'D') + np.timedelta64(2, 's'),
+ np.timedelta64(5, 'D') + np.timedelta64(3, 's')])
+
+ cases = [(tdidx1, tdidx2), (tdidx1, tdarr)]
+
+ # Check pd.NaT is handles as the same as np.nan
+ for idx1, idx2 in cases:
+
+ result = idx1 < idx2
+ expected = np.array([True, False, False, False, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx2 > idx1
+ expected = np.array([True, False, False, False, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 <= idx2
+ expected = np.array([True, False, False, False, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+ result = idx2 >= idx1
+ expected = np.array([True, False, False, False, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 == idx2
+ expected = np.array([False, False, False, False, False, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 != idx2
+ expected = np.array([True, True, True, True, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ # TODO: better name
+ def test_comparisons_coverage(self):
+ rng = timedelta_range('1 days', periods=10)
+
+ result = rng < rng[3]
+ expected = np.array([True, True, True] + [False] * 7)
+ tm.assert_numpy_array_equal(result, expected)
+
+ # raise TypeError for now
with pytest.raises(TypeError):
- index / scalar_td
+ rng < rng[3].value
+
+ result = rng == list(rng)
+ exp = rng == rng
+ tm.assert_numpy_array_equal(result, exp)
# ------------------------------------------------------------------
# Timedelta64[ns] dtype Arithmetic Operations
+class TestAddSubNaTMasking(object):
+ # TODO: parametrize over boxes
+
+ def test_tdi_add_timestamp_nat_masking(self):
+ # GH#17991 checking for overflow-masking with NaT
+ tdinat = pd.to_timedelta(['24658 days 11:15:00', 'NaT'])
+
+ tsneg = Timestamp('1950-01-01')
+ ts_neg_variants = [tsneg,
+ tsneg.to_pydatetime(),
+ tsneg.to_datetime64().astype('datetime64[ns]'),
+ tsneg.to_datetime64().astype('datetime64[D]')]
+
+ tspos = Timestamp('1980-01-01')
+ ts_pos_variants = [tspos,
+ tspos.to_pydatetime(),
+ tspos.to_datetime64().astype('datetime64[ns]'),
+ tspos.to_datetime64().astype('datetime64[D]')]
+
+ for variant in ts_neg_variants + ts_pos_variants:
+ res = tdinat + variant
+ assert res[1] is pd.NaT
+
+ def test_tdi_add_overflow(self):
+ # See GH#14068
+ msg = "too (big|large) to convert"
+ with tm.assert_raises_regex(OverflowError, msg):
+ pd.to_timedelta(106580, 'D') + Timestamp('2000')
+ with tm.assert_raises_regex(OverflowError, msg):
+ Timestamp('2000') + pd.to_timedelta(106580, 'D')
+
+ _NaT = int(pd.NaT) + 1
+ msg = "Overflow in int64 addition"
+ with tm.assert_raises_regex(OverflowError, msg):
+ pd.to_timedelta([106580], 'D') + Timestamp('2000')
+ with tm.assert_raises_regex(OverflowError, msg):
+ Timestamp('2000') + pd.to_timedelta([106580], 'D')
+ with tm.assert_raises_regex(OverflowError, msg):
+ pd.to_timedelta([_NaT]) - Timedelta('1 days')
+ with tm.assert_raises_regex(OverflowError, msg):
+ pd.to_timedelta(['5 days', _NaT]) - Timedelta('1 days')
+ with tm.assert_raises_regex(OverflowError, msg):
+ (pd.to_timedelta([_NaT, '5 days', '1 hours']) -
+ pd.to_timedelta(['7 seconds', _NaT, '4 hours']))
+
+ # These should not overflow!
+ exp = TimedeltaIndex([pd.NaT])
+ result = pd.to_timedelta([pd.NaT]) - Timedelta('1 days')
+ tm.assert_index_equal(result, exp)
+
+ exp = TimedeltaIndex(['4 days', pd.NaT])
+ result = pd.to_timedelta(['5 days', pd.NaT]) - Timedelta('1 days')
+ tm.assert_index_equal(result, exp)
+
+ exp = TimedeltaIndex([pd.NaT, pd.NaT, '5 hours'])
+ result = (pd.to_timedelta([pd.NaT, '5 days', '1 hours']) +
+ pd.to_timedelta(['7 seconds', pd.NaT, '4 hours']))
+ tm.assert_index_equal(result, exp)
+
+
class TestTimedeltaArraylikeAddSubOps(object):
# Tests for timedelta64[ns] __add__, __sub__, __radd__, __rsub__
@@ -490,6 +582,59 @@ def test_td64arr_add_sub_numeric_arr_invalid(self, box, vec, dtype, tdser):
# ------------------------------------------------------------------
# Operations with timedelta-like others
+ # TODO: this was taken from tests.series.test_ops; de-duplicate
+ @pytest.mark.parametrize('scalar_td', [timedelta(minutes=5, seconds=4),
+ Timedelta(minutes=5, seconds=4),
+ Timedelta('5m4s').to_timedelta64()])
+ def test_operators_timedelta64_with_timedelta(self, scalar_td):
+ # smoke tests
+ td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
+ td1.iloc[2] = np.nan
+
+ td1 + scalar_td
+ scalar_td + td1
+ td1 - scalar_td
+ scalar_td - td1
+ td1 / scalar_td
+ scalar_td / td1
+
+ # TODO: this was taken from tests.series.test_ops; de-duplicate
+ def test_timedelta64_operations_with_timedeltas(self):
+ # td operate with td
+ td1 = Series([timedelta(minutes=5, seconds=3)] * 3)
+ td2 = timedelta(minutes=5, seconds=4)
+ result = td1 - td2
+ expected = (Series([timedelta(seconds=0)] * 3) -
+ Series([timedelta(seconds=1)] * 3))
+ assert result.dtype == 'm8[ns]'
+ tm.assert_series_equal(result, expected)
+
+ result2 = td2 - td1
+ expected = (Series([timedelta(seconds=1)] * 3) -
+ Series([timedelta(seconds=0)] * 3))
+ tm.assert_series_equal(result2, expected)
+
+ # roundtrip
+ tm.assert_series_equal(result + td2, td1)
+
+ # Now again, using pd.to_timedelta, which should build
+ # a Series or a scalar, depending on input.
+ td1 = Series(pd.to_timedelta(['00:05:03'] * 3))
+ td2 = pd.to_timedelta('00:05:04')
+ result = td1 - td2
+ expected = (Series([timedelta(seconds=0)] * 3) -
+ Series([timedelta(seconds=1)] * 3))
+ assert result.dtype == 'm8[ns]'
+ tm.assert_series_equal(result, expected)
+
+ result2 = td2 - td1
+ expected = (Series([timedelta(seconds=1)] * 3) -
+ Series([timedelta(seconds=0)] * 3))
+ tm.assert_series_equal(result2, expected)
+
+ # roundtrip
+ tm.assert_series_equal(result + td2, td1)
+
def test_td64arr_add_td64_array(self, box_df_fail):
box = box_df_fail # DataFrame tries to broadcast incorrectly
@@ -620,6 +765,39 @@ def test_td64arr_sub_timedeltalike(self, delta, box):
# ------------------------------------------------------------------
# __add__/__sub__ with DateOffsets and arrays of DateOffsets
+ # TODO: this was taken from tests.series.test_operators; de-duplicate
+ def test_timedelta64_operations_with_DateOffset(self):
+ # GH#10699
+ td = Series([timedelta(minutes=5, seconds=3)] * 3)
+ result = td + pd.offsets.Minute(1)
+ expected = Series([timedelta(minutes=6, seconds=3)] * 3)
+ tm.assert_series_equal(result, expected)
+
+ result = td - pd.offsets.Minute(1)
+ expected = Series([timedelta(minutes=4, seconds=3)] * 3)
+ tm.assert_series_equal(result, expected)
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ result = td + Series([pd.offsets.Minute(1), pd.offsets.Second(3),
+ pd.offsets.Hour(2)])
+ expected = Series([timedelta(minutes=6, seconds=3),
+ timedelta(minutes=5, seconds=6),
+ timedelta(hours=2, minutes=5, seconds=3)])
+ tm.assert_series_equal(result, expected)
+
+ result = td + pd.offsets.Minute(1) + pd.offsets.Second(12)
+ expected = Series([timedelta(minutes=6, seconds=15)] * 3)
+ tm.assert_series_equal(result, expected)
+
+ # valid DateOffsets
+ for do in ['Hour', 'Minute', 'Second', 'Day', 'Micro', 'Milli',
+ 'Nano']:
+ op = getattr(pd.offsets, do)
+ td + op(5)
+ op(5) + td
+ td - op(5)
+ op(5) - td
+
@pytest.mark.parametrize('box', [
pd.Index,
pytest.param(Series,
@@ -1281,231 +1459,3 @@ def test_td64arr_pow_invalid(self, scalar_td, box):
with tm.assert_raises_regex(TypeError, pattern):
td1 ** scalar_td
-
-
-# ------------------------------------------------------------------
-
-@pytest.fixture(params=[pd.Float64Index(np.arange(5, dtype='float64')),
- pd.Int64Index(np.arange(5, dtype='int64')),
- pd.UInt64Index(np.arange(5, dtype='uint64'))],
- ids=lambda x: type(x).__name__)
-def idx(request):
- return request.param
-
-
-zeros = [box_cls([0] * 5, dtype=dtype)
- for box_cls in [pd.Index, np.array]
- for dtype in [np.int64, np.uint64, np.float64]]
-zeros.extend([np.array(0, dtype=dtype)
- for dtype in [np.int64, np.uint64, np.float64]])
-zeros.extend([0, 0.0, long(0)])
-
-
-@pytest.fixture(params=zeros)
-def zero(request):
- # For testing division by (or of) zero for Index with length 5, this
- # gives several scalar-zeros and length-5 vector-zeros
- return request.param
-
-
-class TestDivisionByZero(object):
-
- def test_div_zero(self, zero, idx):
- expected = pd.Index([np.nan, np.inf, np.inf, np.inf, np.inf],
- dtype=np.float64)
- result = idx / zero
- tm.assert_index_equal(result, expected)
- ser_compat = Series(idx).astype('i8') / np.array(zero).astype('i8')
- tm.assert_series_equal(ser_compat, Series(result))
-
- def test_floordiv_zero(self, zero, idx):
- expected = pd.Index([np.nan, np.inf, np.inf, np.inf, np.inf],
- dtype=np.float64)
-
- result = idx // zero
- tm.assert_index_equal(result, expected)
- ser_compat = Series(idx).astype('i8') // np.array(zero).astype('i8')
- tm.assert_series_equal(ser_compat, Series(result))
-
- def test_mod_zero(self, zero, idx):
- expected = pd.Index([np.nan, np.nan, np.nan, np.nan, np.nan],
- dtype=np.float64)
- result = idx % zero
- tm.assert_index_equal(result, expected)
- ser_compat = Series(idx).astype('i8') % np.array(zero).astype('i8')
- tm.assert_series_equal(ser_compat, Series(result))
-
- def test_divmod_zero(self, zero, idx):
-
- exleft = pd.Index([np.nan, np.inf, np.inf, np.inf, np.inf],
- dtype=np.float64)
- exright = pd.Index([np.nan, np.nan, np.nan, np.nan, np.nan],
- dtype=np.float64)
-
- result = divmod(idx, zero)
- tm.assert_index_equal(result[0], exleft)
- tm.assert_index_equal(result[1], exright)
-
- # ------------------------------------------------------------------
-
- @pytest.mark.parametrize('dtype2', [
- np.int64, np.int32, np.int16, np.int8,
- np.float64, np.float32, np.float16,
- np.uint64, np.uint32, np.uint16, np.uint8])
- @pytest.mark.parametrize('dtype1', [np.int64, np.float64, np.uint64])
- def test_ser_div_ser(self, dtype1, dtype2):
- # no longer do integer div for any ops, but deal with the 0's
- first = Series([3, 4, 5, 8], name='first').astype(dtype1)
- second = Series([0, 0, 0, 3], name='second').astype(dtype2)
-
- with np.errstate(all='ignore'):
- expected = Series(first.values.astype(np.float64) / second.values,
- dtype='float64', name=None)
- expected.iloc[0:3] = np.inf
-
- result = first / second
- tm.assert_series_equal(result, expected)
- assert not result.equals(second / first)
-
- def test_rdiv_zero_compat(self):
- # GH#8674
- zero_array = np.array([0] * 5)
- data = np.random.randn(5)
- expected = Series([0.] * 5)
-
- result = zero_array / Series(data)
- tm.assert_series_equal(result, expected)
-
- result = Series(zero_array) / data
- tm.assert_series_equal(result, expected)
-
- result = Series(zero_array) / Series(data)
- tm.assert_series_equal(result, expected)
-
- def test_div_zero_inf_signs(self):
- # GH#9144, inf signing
- ser = Series([-1, 0, 1], name='first')
- expected = Series([-np.inf, np.nan, np.inf], name='first')
-
- result = ser / 0
- tm.assert_series_equal(result, expected)
-
- def test_rdiv_zero(self):
- # GH#9144
- ser = Series([-1, 0, 1], name='first')
- expected = Series([0.0, np.nan, 0.0], name='first')
-
- result = 0 / ser
- tm.assert_series_equal(result, expected)
-
- def test_floordiv_div(self):
- # GH#9144
- ser = Series([-1, 0, 1], name='first')
-
- result = ser // 0
- expected = Series([-np.inf, np.nan, np.inf], name='first')
- tm.assert_series_equal(result, expected)
-
- def test_df_div_zero_df(self):
- # integer div, but deal with the 0's (GH#9144)
- df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
- result = df / df
-
- first = pd.Series([1.0, 1.0, 1.0, 1.0])
- second = pd.Series([np.nan, np.nan, np.nan, 1])
- expected = pd.DataFrame({'first': first, 'second': second})
- tm.assert_frame_equal(result, expected)
-
- def test_df_div_zero_array(self):
- # integer div, but deal with the 0's (GH#9144)
- df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
-
- first = pd.Series([1.0, 1.0, 1.0, 1.0])
- second = pd.Series([np.nan, np.nan, np.nan, 1])
- expected = pd.DataFrame({'first': first, 'second': second})
-
- with np.errstate(all='ignore'):
- arr = df.values.astype('float') / df.values
- result = pd.DataFrame(arr, index=df.index,
- columns=df.columns)
- tm.assert_frame_equal(result, expected)
-
- def test_df_div_zero_int(self):
- # integer div, but deal with the 0's (GH#9144)
- df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
-
- result = df / 0
- expected = pd.DataFrame(np.inf, index=df.index, columns=df.columns)
- expected.iloc[0:3, 1] = np.nan
- tm.assert_frame_equal(result, expected)
-
- # numpy has a slightly different (wrong) treatment
- with np.errstate(all='ignore'):
- arr = df.values.astype('float64') / 0
- result2 = pd.DataFrame(arr, index=df.index,
- columns=df.columns)
- tm.assert_frame_equal(result2, expected)
-
- def test_df_div_zero_series_does_not_commute(self):
- # integer div, but deal with the 0's (GH#9144)
- df = pd.DataFrame(np.random.randn(10, 5))
- ser = df[0]
- res = ser / df
- res2 = df / ser
- assert not res.fillna(0).equals(res2.fillna(0))
-
- # ------------------------------------------------------------------
- # Mod By Zero
-
- def test_df_mod_zero_df(self):
- # GH#3590, modulo as ints
- df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
-
- # this is technically wrong, as the integer portion is coerced to float
- # ###
- first = pd.Series([0, 0, 0, 0], dtype='float64')
- second = pd.Series([np.nan, np.nan, np.nan, 0])
- expected = pd.DataFrame({'first': first, 'second': second})
- result = df % df
- tm.assert_frame_equal(result, expected)
-
- def test_df_mod_zero_array(self):
- # GH#3590, modulo as ints
- df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
-
- # this is technically wrong, as the integer portion is coerced to float
- # ###
- first = pd.Series([0, 0, 0, 0], dtype='float64')
- second = pd.Series([np.nan, np.nan, np.nan, 0])
- expected = pd.DataFrame({'first': first, 'second': second})
-
- # numpy has a slightly different (wrong) treatment
- with np.errstate(all='ignore'):
- arr = df.values % df.values
- result2 = pd.DataFrame(arr, index=df.index,
- columns=df.columns, dtype='float64')
- result2.iloc[0:3, 1] = np.nan
- tm.assert_frame_equal(result2, expected)
-
- def test_df_mod_zero_int(self):
- # GH#3590, modulo as ints
- df = pd.DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
-
- result = df % 0
- expected = pd.DataFrame(np.nan, index=df.index, columns=df.columns)
- tm.assert_frame_equal(result, expected)
-
- # numpy has a slightly different (wrong) treatment
- with np.errstate(all='ignore'):
- arr = df.values.astype('float64') % 0
- result2 = pd.DataFrame(arr, index=df.index, columns=df.columns)
- tm.assert_frame_equal(result2, expected)
-
- def test_df_mod_zero_series_does_not_commute(self):
- # GH#3590, modulo as ints
- # not commutative with series
- df = pd.DataFrame(np.random.randn(10, 5))
- ser = df[0]
- res = ser % df
- res2 = df % ser
- assert not res.fillna(0).equals(res2.fillna(0))
| Also move a bunch more dt64 and td64 tests that have been hiding. For the most part this doesn't do any of the parametrizing over box-classes; that and a bunch of de-duplication are for the next pass. | https://api.github.com/repos/pandas-dev/pandas/pulls/22254 | 2018-08-08T22:32:26Z | 2018-08-09T10:31:38Z | 2018-08-09T10:31:38Z | 2018-08-09T15:57:45Z |
Resampling with NaT in TimedeltaIndex raises MemoryError | diff --git a/doc/source/whatsnew/v0.23.5.txt b/doc/source/whatsnew/v0.23.5.txt
index 916a246355b5f..f9247bc04a96e 100644
--- a/doc/source/whatsnew/v0.23.5.txt
+++ b/doc/source/whatsnew/v0.23.5.txt
@@ -33,7 +33,7 @@ Bug Fixes
**Groupby/Resample/Rolling**
--
+- Bug in :meth:`DataFrame.resample` when resampling ``NaT`` in ``TimeDeltaIndex`` (:issue:`13223`).
-
**Missing**
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 08bfec89a22a8..4a3625b2d7a2d 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -1383,8 +1383,7 @@ def _get_time_delta_bins(self, ax):
data=[], freq=self.freq, name=ax.name)
return binner, [], labels
- start = ax[0]
- end = ax[-1]
+ start, end = ax.min(), ax.max()
labels = binner = TimedeltaIndex(start=start,
end=end,
freq=self.freq,
diff --git a/pandas/tests/test_resample.py b/pandas/tests/test_resample.py
index de4dc2bcf25a4..d11077668359b 100644
--- a/pandas/tests/test_resample.py
+++ b/pandas/tests/test_resample.py
@@ -2887,6 +2887,16 @@ def test_asfreq_bug(self):
freq='1T'))
assert_frame_equal(result, expected)
+ def test_resample_with_nat(self):
+ # GH 13223
+ index = pd.to_timedelta(['0s', pd.NaT, '2s'])
+ result = DataFrame({'value': [2, 3, 5]}, index).resample('1s').mean()
+ expected = DataFrame({'value': [2.5, np.nan, 5.0]},
+ index=timedelta_range('0 day',
+ periods=3,
+ freq='1S'))
+ assert_frame_equal(result, expected)
+
class TestResamplerGrouper(object):
| - [x] closes #13223
- [x] tests added / passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22253 | 2018-08-08T19:05:53Z | 2018-08-09T10:33:35Z | 2018-08-09T10:33:34Z | 2018-08-09T10:33:35Z |
DOC: Add missing question mark in README | diff --git a/README.md b/README.md
index 3c8fe57400099..3dde5e5e2a76e 100644
--- a/README.md
+++ b/README.md
@@ -89,7 +89,7 @@
-## What is it
+## What is it?
**pandas** is a Python package providing fast, flexible, and expressive data
structures designed to make working with "relational" or "labeled" data both
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22251 | 2018-08-08T18:16:37Z | 2018-08-09T04:38:38Z | 2018-08-09T04:38:38Z | 2018-08-09T07:10:34Z |
DOC: Fix dateutil link in install instructions | diff --git a/doc/source/install.rst b/doc/source/install.rst
index 087bca0d5cd3c..eb837547037db 100644
--- a/doc/source/install.rst
+++ b/doc/source/install.rst
@@ -225,7 +225,7 @@ Dependencies
* `setuptools <https://setuptools.readthedocs.io/en/latest/>`__: 24.2.0 or higher
* `NumPy <http://www.numpy.org>`__: 1.9.0 or higher
-* `python-dateutil <//https://dateutil.readthedocs.io/en/stable/>`__: 2.5.0 or higher
+* `python-dateutil <https://dateutil.readthedocs.io/en/stable/>`__: 2.5.0 or higher
* `pytz <http://pytz.sourceforge.net/>`__
.. _install.recommended_dependencies:
| This should be a rather straightforward review. :) Some errant slashes were preventing the python-dateutil link from working. | https://api.github.com/repos/pandas-dev/pandas/pulls/22249 | 2018-08-08T16:24:00Z | 2018-08-08T16:26:45Z | 2018-08-08T16:26:45Z | 2018-08-08T18:32:42Z |
CLN: remove redundant call to ensure_index | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 8205d3df377f5..638129291b495 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7616,7 +7616,7 @@ def _arrays_to_mgr(arrays, arr_names, index, columns, dtype=None):
arrays = _homogenize(arrays, index, dtype)
# from BlockManager perspective
- axes = [ensure_index(columns), ensure_index(index)]
+ axes = [ensure_index(columns), index]
return create_block_manager_from_arrays(arrays, arr_names, axes)
| - [x] tests passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
Small followup to #22232
| https://api.github.com/repos/pandas-dev/pandas/pulls/22245 | 2018-08-08T11:45:01Z | 2018-08-09T00:17:42Z | 2018-08-09T00:17:42Z | 2018-08-09T05:46:51Z |
Collect datetime64 and PeriodDtype arithmetic tests | diff --git a/pandas/tests/arithmetic/__init__.py b/pandas/tests/arithmetic/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/pandas/tests/arithmetic/conftest.py b/pandas/tests/arithmetic/conftest.py
new file mode 100644
index 0000000000000..1e25d4a5224ee
--- /dev/null
+++ b/pandas/tests/arithmetic/conftest.py
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+import numpy as np
+import pandas as pd
+
+
+@pytest.fixture(params=[1, np.array(1, dtype=np.int64)])
+def one(request):
+ # zero-dim integer array behaves like an integer
+ return request.param
+
+
+# ------------------------------------------------------------------
+
+@pytest.fixture(params=[pd.Index, pd.Series, pd.DataFrame],
+ ids=lambda x: x.__name__)
+def box(request):
+ """
+ Several array-like containers that should have effectively identical
+ behavior with respect to arithmetic operations.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[
+ pd.Index,
+ pd.Series,
+ pytest.param(pd.DataFrame,
+ marks=pytest.mark.xfail(reason="Tries to broadcast "
+ "incorrectly",
+ strict=True, raises=ValueError))
+], ids=lambda x: x.__name__)
+def box_df_broadcast_failure(request):
+ """
+ Fixture equivalent to `box` but with the common failing case where
+ the DataFrame operation tries to broadcast incorrectly.
+ """
+ return request.param
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
new file mode 100644
index 0000000000000..b09d3c3183803
--- /dev/null
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -0,0 +1,1386 @@
+# -*- coding: utf-8 -*-
+# Arithmetc tests for DataFrame/Series/Index/Array classes that should
+# behave identically.
+# Specifically for datetime64 and datetime64tz dtypes
+import operator
+from datetime import datetime, timedelta
+import warnings
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas.util.testing as tm
+
+from pandas.compat.numpy import np_datetime64_compat
+from pandas.errors import PerformanceWarning, NullFrequencyError
+
+from pandas._libs.tslibs.conversion import localize_pydatetime
+from pandas._libs.tslibs.offsets import shift_months
+
+from pandas.core import ops
+
+from pandas import (
+ Timestamp, Timedelta, Period, Series, date_range,
+ DatetimeIndex, TimedeltaIndex)
+
+
+# ------------------------------------------------------------------
+# Fixtures
+
+@pytest.fixture(params=[pd.offsets.Hour(2), timedelta(hours=2),
+ np.timedelta64(2, 'h'), Timedelta(hours=2)],
+ ids=str)
+def delta(request):
+ # Several ways of representing two hours
+ return request.param
+
+
+@pytest.fixture(
+ params=[
+ datetime(2011, 1, 1),
+ DatetimeIndex(['2011-01-01', '2011-01-02']),
+ DatetimeIndex(['2011-01-01', '2011-01-02']).tz_localize('US/Eastern'),
+ np.datetime64('2011-01-01'),
+ Timestamp('2011-01-01')],
+ ids=lambda x: type(x).__name__)
+def addend(request):
+ return request.param
+
+
+# ------------------------------------------------------------------
+# Comparisons
+
+class TestDatetime64DataFrameComparison(object):
+ @pytest.mark.parametrize('timestamps', [
+ [pd.Timestamp('2012-01-01 13:00:00+00:00')] * 2,
+ [pd.Timestamp('2012-01-01 13:00:00')] * 2])
+ def test_tz_aware_scalar_comparison(self, timestamps):
+ # GH#15966
+ df = pd.DataFrame({'test': timestamps})
+ expected = pd.DataFrame({'test': [False, False]})
+ tm.assert_frame_equal(df == -1, expected)
+
+
+class TestDatetime64SeriesComparison(object):
+ def test_dt64_ser_cmp_date_warning(self):
+ # https://github.com/pandas-dev/pandas/issues/21359
+ # Remove this test and enble invalid test below
+ ser = pd.Series(pd.date_range('20010101', periods=10), name='dates')
+ date = ser.iloc[0].to_pydatetime().date()
+
+ with tm.assert_produces_warning(FutureWarning) as m:
+ result = ser == date
+ expected = pd.Series([True] + [False] * 9, name='dates')
+ tm.assert_series_equal(result, expected)
+ assert "Comparing Series of datetimes " in str(m[0].message)
+ assert "will not compare equal" in str(m[0].message)
+
+ with tm.assert_produces_warning(FutureWarning) as m:
+ result = ser != date
+ tm.assert_series_equal(result, ~expected)
+ assert "will not compare equal" in str(m[0].message)
+
+ with tm.assert_produces_warning(FutureWarning) as m:
+ result = ser <= date
+ tm.assert_series_equal(result, expected)
+ assert "a TypeError will be raised" in str(m[0].message)
+
+ with tm.assert_produces_warning(FutureWarning) as m:
+ result = ser < date
+ tm.assert_series_equal(result, pd.Series([False] * 10, name='dates'))
+ assert "a TypeError will be raised" in str(m[0].message)
+
+ with tm.assert_produces_warning(FutureWarning) as m:
+ result = ser >= date
+ tm.assert_series_equal(result, pd.Series([True] * 10, name='dates'))
+ assert "a TypeError will be raised" in str(m[0].message)
+
+ with tm.assert_produces_warning(FutureWarning) as m:
+ result = ser > date
+ tm.assert_series_equal(result, pd.Series([False] + [True] * 9,
+ name='dates'))
+ assert "a TypeError will be raised" in str(m[0].message)
+
+ @pytest.mark.skip(reason="GH#21359")
+ def test_dt64ser_cmp_date_invalid(self):
+ # GH#19800 datetime.date comparison raises to
+ # match DatetimeIndex/Timestamp. This also matches the behavior
+ # of stdlib datetime.datetime
+ ser = pd.Series(pd.date_range('20010101', periods=10), name='dates')
+ date = ser.iloc[0].to_pydatetime().date()
+ assert not (ser == date).any()
+ assert (ser != date).all()
+ with pytest.raises(TypeError):
+ ser > date
+ with pytest.raises(TypeError):
+ ser < date
+ with pytest.raises(TypeError):
+ ser >= date
+ with pytest.raises(TypeError):
+ ser <= date
+
+ def test_dt64ser_cmp_period_scalar(self):
+ ser = Series(pd.period_range('2000-01-01', periods=10, freq='D'))
+ val = Period('2000-01-04', freq='D')
+ result = ser > val
+ expected = Series([x > val for x in ser])
+ tm.assert_series_equal(result, expected)
+
+ val = ser[5]
+ result = ser > val
+ expected = Series([x > val for x in ser])
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize("left,right", [
+ ("lt", "gt"),
+ ("le", "ge"),
+ ("eq", "eq"),
+ ("ne", "ne"),
+ ])
+ def test_timestamp_compare_series(self, left, right):
+ # see gh-4982
+ # Make sure we can compare Timestamps on the right AND left hand side.
+ ser = pd.Series(pd.date_range("20010101", periods=10), name="dates")
+ s_nat = ser.copy(deep=True)
+
+ ser[0] = pd.Timestamp("nat")
+ ser[3] = pd.Timestamp("nat")
+
+ left_f = getattr(operator, left)
+ right_f = getattr(operator, right)
+
+ # No NaT
+ expected = left_f(ser, pd.Timestamp("20010109"))
+ result = right_f(pd.Timestamp("20010109"), ser)
+ tm.assert_series_equal(result, expected)
+
+ # NaT
+ expected = left_f(ser, pd.Timestamp("nat"))
+ result = right_f(pd.Timestamp("nat"), ser)
+ tm.assert_series_equal(result, expected)
+
+ # Compare to Timestamp with series containing NaT
+ expected = left_f(s_nat, pd.Timestamp("20010109"))
+ result = right_f(pd.Timestamp("20010109"), s_nat)
+ tm.assert_series_equal(result, expected)
+
+ # Compare to NaT with series containing NaT
+ expected = left_f(s_nat, pd.Timestamp("nat"))
+ result = right_f(pd.Timestamp("nat"), s_nat)
+ tm.assert_series_equal(result, expected)
+
+ def test_timestamp_equality(self):
+ # GH#11034
+ ser = pd.Series([pd.Timestamp('2000-01-29 01:59:00'), 'NaT'])
+ result = ser != ser
+ tm.assert_series_equal(result, pd.Series([False, True]))
+ result = ser != ser[0]
+ tm.assert_series_equal(result, pd.Series([False, True]))
+ result = ser != ser[1]
+ tm.assert_series_equal(result, pd.Series([True, True]))
+
+ result = ser == ser
+ tm.assert_series_equal(result, pd.Series([True, False]))
+ result = ser == ser[0]
+ tm.assert_series_equal(result, pd.Series([True, False]))
+ result = ser == ser[1]
+ tm.assert_series_equal(result, pd.Series([False, False]))
+
+
+class TestDatetimeIndexComparisons(object):
+ @pytest.mark.parametrize('other', [datetime(2016, 1, 1),
+ Timestamp('2016-01-01'),
+ np.datetime64('2016-01-01')])
+ def test_dti_cmp_datetimelike(self, other, tz_naive_fixture):
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=2, tz=tz)
+ if tz is not None:
+ if isinstance(other, np.datetime64):
+ # no tzaware version available
+ return
+ other = localize_pydatetime(other, dti.tzinfo)
+
+ result = dti == other
+ expected = np.array([True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = dti > other
+ expected = np.array([False, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = dti >= other
+ expected = np.array([True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = dti < other
+ expected = np.array([False, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = dti <= other
+ expected = np.array([True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ def dti_cmp_non_datetime(self, tz_naive_fixture):
+ # GH#19301 by convention datetime.date is not considered comparable
+ # to Timestamp or DatetimeIndex. This may change in the future.
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=2, tz=tz)
+
+ other = datetime(2016, 1, 1).date()
+ assert not (dti == other).any()
+ assert (dti != other).all()
+ with pytest.raises(TypeError):
+ dti < other
+ with pytest.raises(TypeError):
+ dti <= other
+ with pytest.raises(TypeError):
+ dti > other
+ with pytest.raises(TypeError):
+ dti >= other
+
+ @pytest.mark.parametrize('other', [None, np.nan, pd.NaT])
+ def test_dti_eq_null_scalar(self, other, tz_naive_fixture):
+ # GH#19301
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=2, tz=tz)
+ assert not (dti == other).any()
+
+ @pytest.mark.parametrize('other', [None, np.nan, pd.NaT])
+ def test_dti_ne_null_scalar(self, other, tz_naive_fixture):
+ # GH#19301
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=2, tz=tz)
+ assert (dti != other).all()
+
+ @pytest.mark.parametrize('other', [None, np.nan])
+ def test_dti_cmp_null_scalar_inequality(self, tz_naive_fixture, other):
+ # GH#19301
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=2, tz=tz)
+
+ with pytest.raises(TypeError):
+ dti < other
+ with pytest.raises(TypeError):
+ dti <= other
+ with pytest.raises(TypeError):
+ dti > other
+ with pytest.raises(TypeError):
+ dti >= other
+
+ def test_dti_cmp_nat(self):
+ left = pd.DatetimeIndex([pd.Timestamp('2011-01-01'), pd.NaT,
+ pd.Timestamp('2011-01-03')])
+ right = pd.DatetimeIndex([pd.NaT, pd.NaT, pd.Timestamp('2011-01-03')])
+
+ for lhs, rhs in [(left, right),
+ (left.astype(object), right.astype(object))]:
+ result = rhs == lhs
+ expected = np.array([False, False, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = lhs != rhs
+ expected = np.array([True, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(lhs == pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT == rhs, expected)
+
+ expected = np.array([True, True, True])
+ tm.assert_numpy_array_equal(lhs != pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT != lhs, expected)
+
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(lhs < pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT > lhs, expected)
+
+ def test_dti_cmp_nat_behaves_like_float_cmp_nan(self):
+ fidx1 = pd.Index([1.0, np.nan, 3.0, np.nan, 5.0, 7.0])
+ fidx2 = pd.Index([2.0, 3.0, np.nan, np.nan, 6.0, 7.0])
+
+ didx1 = pd.DatetimeIndex(['2014-01-01', pd.NaT, '2014-03-01', pd.NaT,
+ '2014-05-01', '2014-07-01'])
+ didx2 = pd.DatetimeIndex(['2014-02-01', '2014-03-01', pd.NaT, pd.NaT,
+ '2014-06-01', '2014-07-01'])
+ darr = np.array([np_datetime64_compat('2014-02-01 00:00Z'),
+ np_datetime64_compat('2014-03-01 00:00Z'),
+ np_datetime64_compat('nat'), np.datetime64('nat'),
+ np_datetime64_compat('2014-06-01 00:00Z'),
+ np_datetime64_compat('2014-07-01 00:00Z')])
+
+ cases = [(fidx1, fidx2), (didx1, didx2), (didx1, darr)]
+
+ # Check pd.NaT is handles as the same as np.nan
+ with tm.assert_produces_warning(None):
+ for idx1, idx2 in cases:
+
+ result = idx1 < idx2
+ expected = np.array([True, False, False, False, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx2 > idx1
+ expected = np.array([True, False, False, False, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 <= idx2
+ expected = np.array([True, False, False, False, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx2 >= idx1
+ expected = np.array([True, False, False, False, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 == idx2
+ expected = np.array([False, False, False, False, False, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 != idx2
+ expected = np.array([True, True, True, True, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ with tm.assert_produces_warning(None):
+ for idx1, val in [(fidx1, np.nan), (didx1, pd.NaT)]:
+ result = idx1 < val
+ expected = np.array([False, False, False, False, False, False])
+ tm.assert_numpy_array_equal(result, expected)
+ result = idx1 > val
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 <= val
+ tm.assert_numpy_array_equal(result, expected)
+ result = idx1 >= val
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 == val
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 != val
+ expected = np.array([True, True, True, True, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ # Check pd.NaT is handles as the same as np.nan
+ with tm.assert_produces_warning(None):
+ for idx1, val in [(fidx1, 3), (didx1, datetime(2014, 3, 1))]:
+ result = idx1 < val
+ expected = np.array([True, False, False, False, False, False])
+ tm.assert_numpy_array_equal(result, expected)
+ result = idx1 > val
+ expected = np.array([False, False, False, False, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 <= val
+ expected = np.array([True, False, True, False, False, False])
+ tm.assert_numpy_array_equal(result, expected)
+ result = idx1 >= val
+ expected = np.array([False, False, True, False, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 == val
+ expected = np.array([False, False, True, False, False, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = idx1 != val
+ expected = np.array([True, True, False, True, True, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ @pytest.mark.parametrize('op', [operator.eq, operator.ne,
+ operator.gt, operator.ge,
+ operator.lt, operator.le])
+ def test_comparison_tzawareness_compat(self, op):
+ # GH#18162
+ dr = pd.date_range('2016-01-01', periods=6)
+ dz = dr.tz_localize('US/Pacific')
+
+ with pytest.raises(TypeError):
+ op(dr, dz)
+ with pytest.raises(TypeError):
+ op(dr, list(dz))
+ with pytest.raises(TypeError):
+ op(dz, dr)
+ with pytest.raises(TypeError):
+ op(dz, list(dr))
+
+ # Check that there isn't a problem aware-aware and naive-naive do not
+ # raise
+ assert (dr == dr).all()
+ assert (dr == list(dr)).all()
+ assert (dz == dz).all()
+ assert (dz == list(dz)).all()
+
+ # Check comparisons against scalar Timestamps
+ ts = pd.Timestamp('2000-03-14 01:59')
+ ts_tz = pd.Timestamp('2000-03-14 01:59', tz='Europe/Amsterdam')
+
+ assert (dr > ts).all()
+ with pytest.raises(TypeError):
+ op(dr, ts_tz)
+
+ assert (dz > ts_tz).all()
+ with pytest.raises(TypeError):
+ op(dz, ts)
+
+ # GH#12601: Check comparison against Timestamps and DatetimeIndex
+ with pytest.raises(TypeError):
+ op(ts, dz)
+
+ @pytest.mark.parametrize('op', [operator.eq, operator.ne,
+ operator.gt, operator.ge,
+ operator.lt, operator.le])
+ @pytest.mark.parametrize('other', [datetime(2016, 1, 1),
+ Timestamp('2016-01-01'),
+ np.datetime64('2016-01-01')])
+ def test_scalar_comparison_tzawareness(self, op, other, tz_aware_fixture):
+ tz = tz_aware_fixture
+ dti = pd.date_range('2016-01-01', periods=2, tz=tz)
+ with pytest.raises(TypeError):
+ op(dti, other)
+ with pytest.raises(TypeError):
+ op(other, dti)
+
+ @pytest.mark.parametrize('op', [operator.eq, operator.ne,
+ operator.gt, operator.ge,
+ operator.lt, operator.le])
+ def test_nat_comparison_tzawareness(self, op):
+ # GH#19276
+ # tzaware DatetimeIndex should not raise when compared to NaT
+ dti = pd.DatetimeIndex(['2014-01-01', pd.NaT, '2014-03-01', pd.NaT,
+ '2014-05-01', '2014-07-01'])
+ expected = np.array([op == operator.ne] * len(dti))
+ result = op(dti, pd.NaT)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = op(dti.tz_localize('US/Pacific'), pd.NaT)
+ tm.assert_numpy_array_equal(result, expected)
+
+ def test_dti_cmp_str(self, tz_naive_fixture):
+ # GH#22074
+ # regardless of tz, we expect these comparisons are valid
+ tz = tz_naive_fixture
+ rng = date_range('1/1/2000', periods=10, tz=tz)
+ other = '1/1/2000'
+
+ result = rng == other
+ expected = np.array([True] + [False] * 9)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = rng != other
+ expected = np.array([False] + [True] * 9)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = rng < other
+ expected = np.array([False] * 10)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = rng <= other
+ expected = np.array([True] + [False] * 9)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = rng > other
+ expected = np.array([False] + [True] * 9)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = rng >= other
+ expected = np.array([True] * 10)
+ tm.assert_numpy_array_equal(result, expected)
+
+ @pytest.mark.parametrize('other', ['foo', 99, 4.0,
+ object(), timedelta(days=2)])
+ def test_dti_cmp_scalar_invalid(self, other, tz_naive_fixture):
+ # GH#22074
+ tz = tz_naive_fixture
+ rng = date_range('1/1/2000', periods=10, tz=tz)
+
+ result = rng == other
+ expected = np.array([False] * 10)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = rng != other
+ expected = np.array([True] * 10)
+ tm.assert_numpy_array_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ rng < other
+ with pytest.raises(TypeError):
+ rng <= other
+ with pytest.raises(TypeError):
+ rng > other
+ with pytest.raises(TypeError):
+ rng >= other
+
+ def test_dti_cmp_list(self):
+ rng = date_range('1/1/2000', periods=10)
+
+ result = rng == list(rng)
+ expected = rng == rng
+ tm.assert_numpy_array_equal(result, expected)
+
+ @pytest.mark.parametrize('other', [
+ pd.timedelta_range('1D', periods=10),
+ pd.timedelta_range('1D', periods=10).to_series(),
+ pd.timedelta_range('1D', periods=10).asi8.view('m8[ns]')
+ ], ids=lambda x: type(x).__name__)
+ def test_dti_cmp_tdi_tzawareness(self, other):
+ # GH#22074
+ # reversion test that we _don't_ call _assert_tzawareness_compat
+ # when comparing against TimedeltaIndex
+ dti = date_range('2000-01-01', periods=10, tz='Asia/Tokyo')
+
+ result = dti == other
+ expected = np.array([False] * 10)
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = dti != other
+ expected = np.array([True] * 10)
+ tm.assert_numpy_array_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ dti < other
+ with pytest.raises(TypeError):
+ dti <= other
+ with pytest.raises(TypeError):
+ dti > other
+ with pytest.raises(TypeError):
+ dti >= other
+
+ def test_dti_cmp_object_dtype(self):
+ # GH#22074
+ dti = date_range('2000-01-01', periods=10, tz='Asia/Tokyo')
+
+ other = dti.astype('O')
+
+ result = dti == other
+ expected = np.array([True] * 10)
+ tm.assert_numpy_array_equal(result, expected)
+
+ other = dti.tz_localize(None)
+ with pytest.raises(TypeError):
+ # tzawareness failure
+ dti != other
+
+ other = np.array(list(dti[:5]) + [Timedelta(days=1)] * 5)
+ result = dti == other
+ expected = np.array([True] * 5 + [False] * 5)
+ tm.assert_numpy_array_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ dti >= other
+
+
+# ------------------------------------------------------------------
+# Arithmetic
+
+class TestFrameArithmetic(object):
+
+ @pytest.mark.xfail(reason='GH#7996 datetime64 units not converted to nano',
+ strict=True)
+ def test_df_sub_datetime64_not_ns(self):
+ df = pd.DataFrame(pd.date_range('20130101', periods=3))
+ dt64 = np.datetime64('2013-01-01')
+ assert dt64.dtype == 'datetime64[D]'
+ res = df - dt64
+ expected = pd.DataFrame([pd.Timedelta(days=0), pd.Timedelta(days=1),
+ pd.Timedelta(days=2)])
+ tm.assert_frame_equal(res, expected)
+
+
+class TestTimestampSeriesArithmetic(object):
+ def test_timestamp_sub_series(self):
+ ser = pd.Series(pd.date_range('2014-03-17', periods=2, freq='D',
+ tz='US/Eastern'))
+ ts = ser[0]
+
+ delta_series = pd.Series([np.timedelta64(0, 'D'),
+ np.timedelta64(1, 'D')])
+ tm.assert_series_equal(ser - ts, delta_series)
+ tm.assert_series_equal(ts - ser, -delta_series)
+
+ def test_dt64ser_sub_datetime_dtype(self):
+ ts = Timestamp(datetime(1993, 1, 7, 13, 30, 00))
+ dt = datetime(1993, 6, 22, 13, 30)
+ ser = Series([ts])
+ result = pd.to_timedelta(np.abs(ser - dt))
+ assert result.dtype == 'timedelta64[ns]'
+
+
+class TestDatetimeIndexArithmetic(object):
+
+ # -------------------------------------------------------------
+ # Invalid Operations
+
+ @pytest.mark.parametrize('other', [3.14, np.array([2.0, 3.0])])
+ @pytest.mark.parametrize('op', [operator.add, ops.radd,
+ operator.sub, ops.rsub])
+ def test_dti_add_sub_float(self, op, other):
+ dti = DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D')
+ with pytest.raises(TypeError):
+ op(dti, other)
+
+ def test_dti_add_timestamp_raises(self):
+ idx = DatetimeIndex(['2011-01-01', '2011-01-02'])
+ msg = "cannot add DatetimeIndex and Timestamp"
+ with tm.assert_raises_regex(TypeError, msg):
+ idx + Timestamp('2011-01-01')
+
+ def test_dti_radd_timestamp_raises(self):
+ idx = DatetimeIndex(['2011-01-01', '2011-01-02'])
+ msg = "cannot add DatetimeIndex and Timestamp"
+ with tm.assert_raises_regex(TypeError, msg):
+ Timestamp('2011-01-01') + idx
+
+ # -------------------------------------------------------------
+ # Binary operations DatetimeIndex and int
+
+ def test_dti_add_int(self, tz_naive_fixture, one):
+ # Variants of `one` for #19012
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01 09:00', freq='H',
+ periods=10, tz=tz)
+ result = rng + one
+ expected = pd.date_range('2000-01-01 10:00', freq='H',
+ periods=10, tz=tz)
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_iadd_int(self, tz_naive_fixture, one):
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01 09:00', freq='H',
+ periods=10, tz=tz)
+ expected = pd.date_range('2000-01-01 10:00', freq='H',
+ periods=10, tz=tz)
+ rng += one
+ tm.assert_index_equal(rng, expected)
+
+ def test_dti_sub_int(self, tz_naive_fixture, one):
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01 09:00', freq='H',
+ periods=10, tz=tz)
+ result = rng - one
+ expected = pd.date_range('2000-01-01 08:00', freq='H',
+ periods=10, tz=tz)
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_isub_int(self, tz_naive_fixture, one):
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01 09:00', freq='H',
+ periods=10, tz=tz)
+ expected = pd.date_range('2000-01-01 08:00', freq='H',
+ periods=10, tz=tz)
+ rng -= one
+ tm.assert_index_equal(rng, expected)
+
+ # -------------------------------------------------------------
+ # __add__/__sub__ with integer arrays
+
+ @pytest.mark.parametrize('freq', ['H', 'D'])
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_dti_add_intarray_tick(self, box, freq):
+ # GH#19959
+ dti = pd.date_range('2016-01-01', periods=2, freq=freq)
+ other = box([4, -1])
+ expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))])
+ result = dti + other
+ tm.assert_index_equal(result, expected)
+ result = other + dti
+ tm.assert_index_equal(result, expected)
+
+ @pytest.mark.parametrize('freq', ['W', 'M', 'MS', 'Q'])
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_dti_add_intarray_non_tick(self, box, freq):
+ # GH#19959
+ dti = pd.date_range('2016-01-01', periods=2, freq=freq)
+ other = box([4, -1])
+ expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))])
+ with tm.assert_produces_warning(PerformanceWarning):
+ result = dti + other
+ tm.assert_index_equal(result, expected)
+ with tm.assert_produces_warning(PerformanceWarning):
+ result = other + dti
+ tm.assert_index_equal(result, expected)
+
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_dti_add_intarray_no_freq(self, box):
+ # GH#19959
+ dti = pd.DatetimeIndex(['2016-01-01', 'NaT', '2017-04-05 06:07:08'])
+ other = box([9, 4, -1])
+ with pytest.raises(NullFrequencyError):
+ dti + other
+ with pytest.raises(NullFrequencyError):
+ other + dti
+ with pytest.raises(NullFrequencyError):
+ dti - other
+ with pytest.raises(TypeError):
+ other - dti
+
+ # -------------------------------------------------------------
+ # Binary operations DatetimeIndex and timedelta-like
+
+ def test_dti_add_timedeltalike(self, tz_naive_fixture, delta):
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
+ result = rng + delta
+ expected = pd.date_range('2000-01-01 02:00',
+ '2000-02-01 02:00', tz=tz)
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_iadd_timedeltalike(self, tz_naive_fixture, delta):
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
+ expected = pd.date_range('2000-01-01 02:00',
+ '2000-02-01 02:00', tz=tz)
+ rng += delta
+ tm.assert_index_equal(rng, expected)
+
+ def test_dti_sub_timedeltalike(self, tz_naive_fixture, delta):
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
+ expected = pd.date_range('1999-12-31 22:00',
+ '2000-01-31 22:00', tz=tz)
+ result = rng - delta
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_isub_timedeltalike(self, tz_naive_fixture, delta):
+ tz = tz_naive_fixture
+ rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
+ expected = pd.date_range('1999-12-31 22:00',
+ '2000-01-31 22:00', tz=tz)
+ rng -= delta
+ tm.assert_index_equal(rng, expected)
+
+ # -------------------------------------------------------------
+ # Binary operations DatetimeIndex and TimedeltaIndex/array
+ def test_dti_add_tdi(self, tz_naive_fixture):
+ # GH#17558
+ tz = tz_naive_fixture
+ dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ tdi = pd.timedelta_range('0 days', periods=10)
+ expected = pd.date_range('2017-01-01', periods=10, tz=tz)
+
+ # add with TimdeltaIndex
+ result = dti + tdi
+ tm.assert_index_equal(result, expected)
+
+ result = tdi + dti
+ tm.assert_index_equal(result, expected)
+
+ # add with timedelta64 array
+ result = dti + tdi.values
+ tm.assert_index_equal(result, expected)
+
+ result = tdi.values + dti
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_iadd_tdi(self, tz_naive_fixture):
+ # GH#17558
+ tz = tz_naive_fixture
+ dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ tdi = pd.timedelta_range('0 days', periods=10)
+ expected = pd.date_range('2017-01-01', periods=10, tz=tz)
+
+ # iadd with TimdeltaIndex
+ result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ result += tdi
+ tm.assert_index_equal(result, expected)
+
+ result = pd.timedelta_range('0 days', periods=10)
+ result += dti
+ tm.assert_index_equal(result, expected)
+
+ # iadd with timedelta64 array
+ result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ result += tdi.values
+ tm.assert_index_equal(result, expected)
+
+ result = pd.timedelta_range('0 days', periods=10)
+ result += dti
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_sub_tdi(self, tz_naive_fixture):
+ # GH#17558
+ tz = tz_naive_fixture
+ dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ tdi = pd.timedelta_range('0 days', periods=10)
+ expected = pd.date_range('2017-01-01', periods=10, tz=tz, freq='-1D')
+
+ # sub with TimedeltaIndex
+ result = dti - tdi
+ tm.assert_index_equal(result, expected)
+
+ msg = 'cannot subtract .*TimedeltaIndex'
+ with tm.assert_raises_regex(TypeError, msg):
+ tdi - dti
+
+ # sub with timedelta64 array
+ result = dti - tdi.values
+ tm.assert_index_equal(result, expected)
+
+ msg = 'cannot subtract DatetimeIndex from'
+ with tm.assert_raises_regex(TypeError, msg):
+ tdi.values - dti
+
+ def test_dti_isub_tdi(self, tz_naive_fixture):
+ # GH#17558
+ tz = tz_naive_fixture
+ dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ tdi = pd.timedelta_range('0 days', periods=10)
+ expected = pd.date_range('2017-01-01', periods=10, tz=tz, freq='-1D')
+
+ # isub with TimedeltaIndex
+ result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ result -= tdi
+ tm.assert_index_equal(result, expected)
+
+ msg = 'cannot subtract .*TimedeltaIndex'
+ with tm.assert_raises_regex(TypeError, msg):
+ tdi -= dti
+
+ # isub with timedelta64 array
+ result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
+ result -= tdi.values
+ tm.assert_index_equal(result, expected)
+
+ msg = '|'.join(['cannot perform __neg__ with this index type:',
+ 'ufunc subtract cannot use operands with types',
+ 'cannot subtract DatetimeIndex from'])
+ with tm.assert_raises_regex(TypeError, msg):
+ tdi.values -= dti
+
+ # -------------------------------------------------------------
+ # Binary Operations DatetimeIndex and datetime-like
+ # TODO: A couple other tests belong in this section. Move them in
+ # A PR where there isn't already a giant diff.
+
+ def test_add_datetimelike_and_dti(self, addend):
+ # GH#9631
+ dti = DatetimeIndex(['2011-01-01', '2011-01-02'])
+ msg = 'cannot add DatetimeIndex and {0}'.format(
+ type(addend).__name__)
+ with tm.assert_raises_regex(TypeError, msg):
+ dti + addend
+ with tm.assert_raises_regex(TypeError, msg):
+ addend + dti
+
+ def test_add_datetimelike_and_dti_tz(self, addend):
+ # GH#9631
+ dti_tz = DatetimeIndex(['2011-01-01',
+ '2011-01-02']).tz_localize('US/Eastern')
+ msg = 'cannot add DatetimeIndex and {0}'.format(
+ type(addend).__name__)
+ with tm.assert_raises_regex(TypeError, msg):
+ dti_tz + addend
+ with tm.assert_raises_regex(TypeError, msg):
+ addend + dti_tz
+
+ # -------------------------------------------------------------
+ # __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
+
+ def test_dti_add_dt64_array_raises(self, tz_naive_fixture):
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ dtarr = dti.values
+
+ with pytest.raises(TypeError):
+ dti + dtarr
+ with pytest.raises(TypeError):
+ dtarr + dti
+
+ def test_dti_sub_dt64_array_naive(self):
+ dti = pd.date_range('2016-01-01', periods=3, tz=None)
+ dtarr = dti.values
+
+ expected = dti - dti
+ result = dti - dtarr
+ tm.assert_index_equal(result, expected)
+ result = dtarr - dti
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_sub_dt64_array_aware_raises(self, tz_naive_fixture):
+ tz = tz_naive_fixture
+ if tz is None:
+ return
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ dtarr = dti.values
+
+ with pytest.raises(TypeError):
+ dti - dtarr
+ with pytest.raises(TypeError):
+ dtarr - dti
+
+ def test_dti_add_td64_array(self, tz_naive_fixture):
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ tdi = pd.TimedeltaIndex(['-1 Day', '-1 Day', '-1 Day'])
+ tdarr = tdi.values
+
+ expected = dti + tdi
+ result = dti + tdarr
+ tm.assert_index_equal(result, expected)
+ result = tdarr + dti
+ tm.assert_index_equal(result, expected)
+
+ def test_dti_sub_td64_array(self, tz_naive_fixture):
+ tz = tz_naive_fixture
+ dti = pd.date_range('2016-01-01', periods=3, tz=tz)
+ tdi = pd.TimedeltaIndex(['-1 Day', '-1 Day', '-1 Day'])
+ tdarr = tdi.values
+
+ expected = dti - tdi
+ result = dti - tdarr
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ tdarr - dti
+
+ # -------------------------------------------------------------
+
+ def test_sub_dti_dti(self):
+ # previously performed setop (deprecated in 0.16.0), now changed to
+ # return subtraction -> TimeDeltaIndex (GH ...)
+
+ dti = date_range('20130101', periods=3)
+ dti_tz = date_range('20130101', periods=3).tz_localize('US/Eastern')
+ dti_tz2 = date_range('20130101', periods=3).tz_localize('UTC')
+ expected = TimedeltaIndex([0, 0, 0])
+
+ result = dti - dti
+ tm.assert_index_equal(result, expected)
+
+ result = dti_tz - dti_tz
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ dti_tz - dti
+
+ with pytest.raises(TypeError):
+ dti - dti_tz
+
+ with pytest.raises(TypeError):
+ dti_tz - dti_tz2
+
+ # isub
+ dti -= dti
+ tm.assert_index_equal(dti, expected)
+
+ # different length raises ValueError
+ dti1 = date_range('20130101', periods=3)
+ dti2 = date_range('20130101', periods=4)
+ with pytest.raises(ValueError):
+ dti1 - dti2
+
+ # NaN propagation
+ dti1 = DatetimeIndex(['2012-01-01', np.nan, '2012-01-03'])
+ dti2 = DatetimeIndex(['2012-01-02', '2012-01-03', np.nan])
+ expected = TimedeltaIndex(['1 days', np.nan, np.nan])
+ result = dti2 - dti1
+ tm.assert_index_equal(result, expected)
+
+ @pytest.mark.parametrize('freq', [None, 'D'])
+ def test_sub_period(self, freq, box):
+ # GH#13078
+ # not supported, check TypeError
+ p = pd.Period('2011-01-01', freq='D')
+
+ idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq)
+ idx = tm.box_expected(idx, box)
+
+ with pytest.raises(TypeError):
+ idx - p
+
+ with pytest.raises(TypeError):
+ p - idx
+
+ @pytest.mark.parametrize('box', [
+ pd.Index,
+ pd.Series,
+ pytest.param(pd.DataFrame,
+ marks=pytest.mark.xfail(reason="Tries to broadcast "
+ "incorrectly",
+ strict=True,
+ raises=ValueError))
+ ], ids=lambda x: x.__name__)
+ @pytest.mark.parametrize('op', [operator.add, ops.radd,
+ operator.sub, ops.rsub])
+ @pytest.mark.parametrize('pi_freq', ['D', 'W', 'Q', 'H'])
+ @pytest.mark.parametrize('dti_freq', [None, 'D'])
+ def test_dti_sub_pi(self, dti_freq, pi_freq, op, box):
+ # GH#20049 subtracting PeriodIndex should raise TypeError
+ dti = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=dti_freq)
+ pi = dti.to_period(pi_freq)
+
+ dti = tm.box_expected(dti, box)
+ # TODO: Also box pi?
+ with pytest.raises(TypeError):
+ op(dti, pi)
+
+ # -------------------------------------------------------------
+
+ def test_ufunc_coercions(self):
+ idx = date_range('2011-01-01', periods=3, freq='2D', name='x')
+
+ delta = np.timedelta64(1, 'D')
+ for result in [idx + delta, np.add(idx, delta)]:
+ assert isinstance(result, DatetimeIndex)
+ exp = date_range('2011-01-02', periods=3, freq='2D', name='x')
+ tm.assert_index_equal(result, exp)
+ assert result.freq == '2D'
+
+ for result in [idx - delta, np.subtract(idx, delta)]:
+ assert isinstance(result, DatetimeIndex)
+ exp = date_range('2010-12-31', periods=3, freq='2D', name='x')
+ tm.assert_index_equal(result, exp)
+ assert result.freq == '2D'
+
+ delta = np.array([np.timedelta64(1, 'D'), np.timedelta64(2, 'D'),
+ np.timedelta64(3, 'D')])
+ for result in [idx + delta, np.add(idx, delta)]:
+ assert isinstance(result, DatetimeIndex)
+ exp = DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-08'],
+ freq='3D', name='x')
+ tm.assert_index_equal(result, exp)
+ assert result.freq == '3D'
+
+ for result in [idx - delta, np.subtract(idx, delta)]:
+ assert isinstance(result, DatetimeIndex)
+ exp = DatetimeIndex(['2010-12-31', '2011-01-01', '2011-01-02'],
+ freq='D', name='x')
+ tm.assert_index_equal(result, exp)
+ assert result.freq == 'D'
+
+ def test_datetimeindex_sub_timestamp_overflow(self):
+ dtimax = pd.to_datetime(['now', pd.Timestamp.max])
+ dtimin = pd.to_datetime(['now', pd.Timestamp.min])
+
+ tsneg = Timestamp('1950-01-01')
+ ts_neg_variants = [tsneg,
+ tsneg.to_pydatetime(),
+ tsneg.to_datetime64().astype('datetime64[ns]'),
+ tsneg.to_datetime64().astype('datetime64[D]')]
+
+ tspos = Timestamp('1980-01-01')
+ ts_pos_variants = [tspos,
+ tspos.to_pydatetime(),
+ tspos.to_datetime64().astype('datetime64[ns]'),
+ tspos.to_datetime64().astype('datetime64[D]')]
+
+ for variant in ts_neg_variants:
+ with pytest.raises(OverflowError):
+ dtimax - variant
+
+ expected = pd.Timestamp.max.value - tspos.value
+ for variant in ts_pos_variants:
+ res = dtimax - variant
+ assert res[1].value == expected
+
+ expected = pd.Timestamp.min.value - tsneg.value
+ for variant in ts_neg_variants:
+ res = dtimin - variant
+ assert res[1].value == expected
+
+ for variant in ts_pos_variants:
+ with pytest.raises(OverflowError):
+ dtimin - variant
+
+ @pytest.mark.parametrize('names', [('foo', None, None),
+ ('baz', 'bar', None),
+ ('bar', 'bar', 'bar')])
+ @pytest.mark.parametrize('tz', [None, 'America/Chicago'])
+ def test_dti_add_series(self, tz, names):
+ # GH#13905
+ index = DatetimeIndex(['2016-06-28 05:30', '2016-06-28 05:31'],
+ tz=tz, name=names[0])
+ ser = Series([Timedelta(seconds=5)] * 2,
+ index=index, name=names[1])
+ expected = Series(index + Timedelta(seconds=5),
+ index=index, name=names[2])
+
+ # passing name arg isn't enough when names[2] is None
+ expected.name = names[2]
+ assert expected.dtype == index.dtype
+ result = ser + index
+ tm.assert_series_equal(result, expected)
+ result2 = index + ser
+ tm.assert_series_equal(result2, expected)
+
+ expected = index + Timedelta(seconds=5)
+ result3 = ser.values + index
+ tm.assert_index_equal(result3, expected)
+ result4 = index + ser.values
+ tm.assert_index_equal(result4, expected)
+
+ def test_dti_add_offset_array(self, tz_naive_fixture):
+ # GH#18849
+ tz = tz_naive_fixture
+ dti = pd.date_range('2017-01-01', periods=2, tz=tz)
+ other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = dti + other
+ expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))],
+ name=dti.name, freq='infer')
+ tm.assert_index_equal(res, expected)
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res2 = other + dti
+ tm.assert_index_equal(res2, expected)
+
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('foo', 'bar', None),
+ ('foo', 'foo', 'foo')])
+ def test_dti_add_offset_index(self, tz_naive_fixture, names):
+ # GH#18849, GH#19744
+ tz = tz_naive_fixture
+ dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
+ other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
+ name=names[1])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = dti + other
+ expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))],
+ name=names[2], freq='infer')
+ tm.assert_index_equal(res, expected)
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res2 = other + dti
+ tm.assert_index_equal(res2, expected)
+
+ def test_dti_sub_offset_array(self, tz_naive_fixture):
+ # GH#18824
+ tz = tz_naive_fixture
+ dti = pd.date_range('2017-01-01', periods=2, tz=tz)
+ other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = dti - other
+ expected = DatetimeIndex([dti[n] - other[n] for n in range(len(dti))],
+ name=dti.name, freq='infer')
+ tm.assert_index_equal(res, expected)
+
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('foo', 'bar', None),
+ ('foo', 'foo', 'foo')])
+ def test_dti_sub_offset_index(self, tz_naive_fixture, names):
+ # GH#18824, GH#19744
+ tz = tz_naive_fixture
+ dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
+ other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
+ name=names[1])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = dti - other
+ expected = DatetimeIndex([dti[n] - other[n] for n in range(len(dti))],
+ name=names[2], freq='infer')
+ tm.assert_index_equal(res, expected)
+
+ @pytest.mark.parametrize('names', [(None, None, None),
+ ('foo', 'bar', None),
+ ('foo', 'foo', 'foo')])
+ def test_dti_with_offset_series(self, tz_naive_fixture, names):
+ # GH#18849
+ tz = tz_naive_fixture
+ dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
+ other = Series([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
+ name=names[1])
+
+ expected_add = Series([dti[n] + other[n] for n in range(len(dti))],
+ name=names[2])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = dti + other
+ tm.assert_series_equal(res, expected_add)
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res2 = other + dti
+ tm.assert_series_equal(res2, expected_add)
+
+ expected_sub = Series([dti[n] - other[n] for n in range(len(dti))],
+ name=names[2])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res3 = dti - other
+ tm.assert_series_equal(res3, expected_sub)
+
+ @pytest.mark.parametrize('box', [
+ pd.Index,
+ pd.Series,
+ pytest.param(pd.DataFrame,
+ marks=pytest.mark.xfail(reason="Returns object dtype",
+ strict=True))
+ ], ids=lambda x: x.__name__)
+ def test_dti_add_offset_tzaware(self, tz_aware_fixture, box):
+ timezone = tz_aware_fixture
+ if timezone == 'US/Pacific':
+ dates = date_range('2012-11-01', periods=3, tz=timezone)
+ offset = dates + pd.offsets.Hour(5)
+ assert dates[0] + pd.offsets.Hour(5) == offset[0]
+
+ dates = date_range('2010-11-01 00:00',
+ periods=3, tz=timezone, freq='H')
+ expected = DatetimeIndex(['2010-11-01 05:00', '2010-11-01 06:00',
+ '2010-11-01 07:00'], freq='H', tz=timezone)
+
+ dates = tm.box_expected(dates, box)
+ expected = tm.box_expected(expected, box)
+
+ # TODO: parametrize over the scalar being added? radd? sub?
+ offset = dates + pd.offsets.Hour(5)
+ tm.assert_equal(offset, expected)
+ offset = dates + np.timedelta64(5, 'h')
+ tm.assert_equal(offset, expected)
+ offset = dates + timedelta(hours=5)
+ tm.assert_equal(offset, expected)
+
+
+@pytest.mark.parametrize('klass,assert_func', [
+ (Series, tm.assert_series_equal),
+ (DatetimeIndex, tm.assert_index_equal)])
+def test_dt64_with_offset_array(klass, assert_func):
+ # GH#10699
+ # array of offsets
+ box = Series if klass is Series else pd.Index
+ with tm.assert_produces_warning(PerformanceWarning):
+ s = klass([Timestamp('2000-1-1'), Timestamp('2000-2-1')])
+ result = s + box([pd.offsets.DateOffset(years=1),
+ pd.offsets.MonthEnd()])
+ exp = klass([Timestamp('2001-1-1'), Timestamp('2000-2-29')])
+ assert_func(result, exp)
+
+ # same offset
+ result = s + box([pd.offsets.DateOffset(years=1),
+ pd.offsets.DateOffset(years=1)])
+ exp = klass([Timestamp('2001-1-1'), Timestamp('2001-2-1')])
+ assert_func(result, exp)
+
+
+@pytest.mark.parametrize('klass,assert_func', [
+ (Series, tm.assert_series_equal),
+ (DatetimeIndex, tm.assert_index_equal)])
+def test_dt64_with_DateOffsets_relativedelta(klass, assert_func):
+ # GH#10699
+ vec = klass([Timestamp('2000-01-05 00:15:00'),
+ Timestamp('2000-01-31 00:23:00'),
+ Timestamp('2000-01-01'),
+ Timestamp('2000-03-31'),
+ Timestamp('2000-02-29'),
+ Timestamp('2000-12-31'),
+ Timestamp('2000-05-15'),
+ Timestamp('2001-06-15')])
+
+ # DateOffset relativedelta fastpath
+ relative_kwargs = [('years', 2), ('months', 5), ('days', 3),
+ ('hours', 5), ('minutes', 10), ('seconds', 2),
+ ('microseconds', 5)]
+ for i, kwd in enumerate(relative_kwargs):
+ op = pd.DateOffset(**dict([kwd]))
+ assert_func(klass([x + op for x in vec]), vec + op)
+ assert_func(klass([x - op for x in vec]), vec - op)
+ op = pd.DateOffset(**dict(relative_kwargs[:i + 1]))
+ assert_func(klass([x + op for x in vec]), vec + op)
+ assert_func(klass([x - op for x in vec]), vec - op)
+
+
+@pytest.mark.parametrize('cls_and_kwargs', [
+ 'YearBegin', ('YearBegin', {'month': 5}),
+ 'YearEnd', ('YearEnd', {'month': 5}),
+ 'MonthBegin', 'MonthEnd',
+ 'SemiMonthEnd', 'SemiMonthBegin',
+ 'Week', ('Week', {'weekday': 3}),
+ 'BusinessDay', 'BDay', 'QuarterEnd', 'QuarterBegin',
+ 'CustomBusinessDay', 'CDay', 'CBMonthEnd',
+ 'CBMonthBegin', 'BMonthBegin', 'BMonthEnd',
+ 'BusinessHour', 'BYearBegin', 'BYearEnd',
+ 'BQuarterBegin', ('LastWeekOfMonth', {'weekday': 2}),
+ ('FY5253Quarter', {'qtr_with_extra_week': 1,
+ 'startingMonth': 1,
+ 'weekday': 2,
+ 'variation': 'nearest'}),
+ ('FY5253', {'weekday': 0, 'startingMonth': 2, 'variation': 'nearest'}),
+ ('WeekOfMonth', {'weekday': 2, 'week': 2}),
+ 'Easter', ('DateOffset', {'day': 4}),
+ ('DateOffset', {'month': 5})])
+@pytest.mark.parametrize('normalize', [True, False])
+@pytest.mark.parametrize('klass,assert_func', [
+ (Series, tm.assert_series_equal),
+ (DatetimeIndex, tm.assert_index_equal)])
+def test_dt64_with_DateOffsets(klass, assert_func, normalize, cls_and_kwargs):
+ # GH#10699
+ # assert these are equal on a piecewise basis
+ vec = klass([Timestamp('2000-01-05 00:15:00'),
+ Timestamp('2000-01-31 00:23:00'),
+ Timestamp('2000-01-01'),
+ Timestamp('2000-03-31'),
+ Timestamp('2000-02-29'),
+ Timestamp('2000-12-31'),
+ Timestamp('2000-05-15'),
+ Timestamp('2001-06-15')])
+
+ if isinstance(cls_and_kwargs, tuple):
+ # If cls_name param is a tuple, then 2nd entry is kwargs for
+ # the offset constructor
+ cls_name, kwargs = cls_and_kwargs
+ else:
+ cls_name = cls_and_kwargs
+ kwargs = {}
+
+ offset_cls = getattr(pd.offsets, cls_name)
+
+ with warnings.catch_warnings(record=True):
+ for n in [0, 5]:
+ if (cls_name in ['WeekOfMonth', 'LastWeekOfMonth',
+ 'FY5253Quarter', 'FY5253'] and n == 0):
+ # passing n = 0 is invalid for these offset classes
+ continue
+
+ offset = offset_cls(n, normalize=normalize, **kwargs)
+ assert_func(klass([x + offset for x in vec]), vec + offset)
+ assert_func(klass([x - offset for x in vec]), vec - offset)
+ assert_func(klass([offset + x for x in vec]), offset + vec)
+
+
+@pytest.mark.parametrize('klass,assert_func', zip([Series, DatetimeIndex],
+ [tm.assert_series_equal,
+ tm.assert_index_equal]))
+def test_datetime64_with_DateOffset(klass, assert_func):
+ # GH#10699
+ s = klass(date_range('2000-01-01', '2000-01-31'), name='a')
+ result = s + pd.DateOffset(years=1)
+ result2 = pd.DateOffset(years=1) + s
+ exp = klass(date_range('2001-01-01', '2001-01-31'), name='a')
+ assert_func(result, exp)
+ assert_func(result2, exp)
+
+ result = s - pd.DateOffset(years=1)
+ exp = klass(date_range('1999-01-01', '1999-01-31'), name='a')
+ assert_func(result, exp)
+
+ s = klass([Timestamp('2000-01-15 00:15:00', tz='US/Central'),
+ pd.Timestamp('2000-02-15', tz='US/Central')], name='a')
+ result = s + pd.offsets.Day()
+ result2 = pd.offsets.Day() + s
+ exp = klass([Timestamp('2000-01-16 00:15:00', tz='US/Central'),
+ Timestamp('2000-02-16', tz='US/Central')], name='a')
+ assert_func(result, exp)
+ assert_func(result2, exp)
+
+ s = klass([Timestamp('2000-01-15 00:15:00', tz='US/Central'),
+ pd.Timestamp('2000-02-15', tz='US/Central')], name='a')
+ result = s + pd.offsets.MonthEnd()
+ result2 = pd.offsets.MonthEnd() + s
+ exp = klass([Timestamp('2000-01-31 00:15:00', tz='US/Central'),
+ Timestamp('2000-02-29', tz='US/Central')], name='a')
+ assert_func(result, exp)
+ assert_func(result2, exp)
+
+
+@pytest.mark.parametrize('years', [-1, 0, 1])
+@pytest.mark.parametrize('months', [-2, 0, 2])
+def test_shift_months(years, months):
+ dti = DatetimeIndex([Timestamp('2000-01-05 00:15:00'),
+ Timestamp('2000-01-31 00:23:00'),
+ Timestamp('2000-01-01'),
+ Timestamp('2000-02-29'),
+ Timestamp('2000-12-31')])
+ actual = DatetimeIndex(shift_months(dti.asi8, years * 12 + months))
+
+ raw = [x + pd.offsets.DateOffset(years=years, months=months)
+ for x in dti]
+ expected = DatetimeIndex(raw)
+ tm.assert_index_equal(actual, expected)
diff --git a/pandas/tests/arithmetic/test_period.py b/pandas/tests/arithmetic/test_period.py
new file mode 100644
index 0000000000000..92123bf48bb47
--- /dev/null
+++ b/pandas/tests/arithmetic/test_period.py
@@ -0,0 +1,1057 @@
+# -*- coding: utf-8 -*-
+# Arithmetc tests for DataFrame/Series/Index/Array classes that should
+# behave identically.
+# Specifically for Period dtype
+import operator
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas.util.testing as tm
+
+from pandas.errors import PerformanceWarning
+from pandas._libs.tslibs.period import IncompatibleFrequency
+
+import pandas.core.indexes.period as period
+from pandas.core import ops
+from pandas import (
+ Period, PeriodIndex, period_range, Timedelta, Series,
+ _np_version_under1p10)
+
+
+# ------------------------------------------------------------------
+# Fixtures
+
+_common_mismatch = [pd.offsets.YearBegin(2),
+ pd.offsets.MonthBegin(1),
+ pd.offsets.Minute()]
+
+
+@pytest.fixture(params=[timedelta(minutes=30),
+ np.timedelta64(30, 's'),
+ Timedelta(seconds=30)] + _common_mismatch)
+def not_hourly(request):
+ """
+ Several timedelta-like and DateOffset instances that are _not_
+ compatible with Hourly frequencies.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[np.timedelta64(4, 'h'),
+ timedelta(hours=23),
+ Timedelta('23:00:00')] + _common_mismatch)
+def not_daily(request):
+ """
+ Several timedelta-like and DateOffset instances that are _not_
+ compatible with Daily frequencies.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[np.timedelta64(365, 'D'),
+ timedelta(365),
+ Timedelta(days=365)] + _common_mismatch)
+def mismatched(request):
+ """
+ Several timedelta-like and DateOffset instances that are _not_
+ compatible with Monthly or Annual frequencies.
+ """
+ return request.param
+
+
+@pytest.fixture(params=[pd.offsets.Day(3),
+ timedelta(days=3),
+ np.timedelta64(3, 'D'),
+ pd.offsets.Hour(72),
+ timedelta(minutes=60 * 24 * 3),
+ np.timedelta64(72, 'h'),
+ Timedelta('72:00:00')])
+def three_days(request):
+ """
+ Several timedelta-like and DateOffset objects that each represent
+ a 3-day timedelta
+ """
+ return request.param
+
+
+@pytest.fixture(params=[pd.offsets.Hour(2),
+ timedelta(hours=2),
+ np.timedelta64(2, 'h'),
+ pd.offsets.Minute(120),
+ timedelta(minutes=120),
+ np.timedelta64(120, 'm')])
+def two_hours(request):
+ """
+ Several timedelta-like and DateOffset objects that each represent
+ a 2-hour timedelta
+ """
+ return request.param
+
+
+# ------------------------------------------------------------------
+# Comparisons
+
+class TestPeriodIndexComparisons(object):
+ def test_pi_cmp_period(self):
+ idx = period_range('2007-01', periods=20, freq='M')
+
+ result = idx < idx[10]
+ exp = idx.values < idx.values[10]
+ tm.assert_numpy_array_equal(result, exp)
+
+ @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
+ def test_pi_cmp_pi(self, freq):
+ base = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
+ freq=freq)
+ per = Period('2011-02', freq=freq)
+
+ exp = np.array([False, True, False, False])
+ tm.assert_numpy_array_equal(base == per, exp)
+ tm.assert_numpy_array_equal(per == base, exp)
+
+ exp = np.array([True, False, True, True])
+ tm.assert_numpy_array_equal(base != per, exp)
+ tm.assert_numpy_array_equal(per != base, exp)
+
+ exp = np.array([False, False, True, True])
+ tm.assert_numpy_array_equal(base > per, exp)
+ tm.assert_numpy_array_equal(per < base, exp)
+
+ exp = np.array([True, False, False, False])
+ tm.assert_numpy_array_equal(base < per, exp)
+ tm.assert_numpy_array_equal(per > base, exp)
+
+ exp = np.array([False, True, True, True])
+ tm.assert_numpy_array_equal(base >= per, exp)
+ tm.assert_numpy_array_equal(per <= base, exp)
+
+ exp = np.array([True, True, False, False])
+ tm.assert_numpy_array_equal(base <= per, exp)
+ tm.assert_numpy_array_equal(per >= base, exp)
+
+ idx = PeriodIndex(['2011-02', '2011-01', '2011-03', '2011-05'],
+ freq=freq)
+
+ exp = np.array([False, False, True, False])
+ tm.assert_numpy_array_equal(base == idx, exp)
+
+ exp = np.array([True, True, False, True])
+ tm.assert_numpy_array_equal(base != idx, exp)
+
+ exp = np.array([False, True, False, False])
+ tm.assert_numpy_array_equal(base > idx, exp)
+
+ exp = np.array([True, False, False, True])
+ tm.assert_numpy_array_equal(base < idx, exp)
+
+ exp = np.array([False, True, True, False])
+ tm.assert_numpy_array_equal(base >= idx, exp)
+
+ exp = np.array([True, False, True, True])
+ tm.assert_numpy_array_equal(base <= idx, exp)
+
+ @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
+ def test_pi_cmp_pi_mismatched_freq_raises(self, freq):
+ # different base freq
+ base = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
+ freq=freq)
+
+ msg = "Input has different freq=A-DEC from PeriodIndex"
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ base <= Period('2011', freq='A')
+
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ Period('2011', freq='A') >= base
+
+ idx = PeriodIndex(['2011', '2012', '2013', '2014'], freq='A')
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ base <= idx
+
+ # Different frequency
+ msg = "Input has different freq=4M from PeriodIndex"
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ base <= Period('2011', freq='4M')
+
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ Period('2011', freq='4M') >= base
+
+ idx = PeriodIndex(['2011', '2012', '2013', '2014'], freq='4M')
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ base <= idx
+
+ @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
+ def test_pi_cmp_nat(self, freq):
+ idx1 = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-05'], freq=freq)
+
+ result = idx1 > Period('2011-02', freq=freq)
+ exp = np.array([False, False, False, True])
+ tm.assert_numpy_array_equal(result, exp)
+ result = Period('2011-02', freq=freq) < idx1
+ tm.assert_numpy_array_equal(result, exp)
+
+ result = idx1 == Period('NaT', freq=freq)
+ exp = np.array([False, False, False, False])
+ tm.assert_numpy_array_equal(result, exp)
+ result = Period('NaT', freq=freq) == idx1
+ tm.assert_numpy_array_equal(result, exp)
+
+ result = idx1 != Period('NaT', freq=freq)
+ exp = np.array([True, True, True, True])
+ tm.assert_numpy_array_equal(result, exp)
+ result = Period('NaT', freq=freq) != idx1
+ tm.assert_numpy_array_equal(result, exp)
+
+ idx2 = PeriodIndex(['2011-02', '2011-01', '2011-04', 'NaT'], freq=freq)
+ result = idx1 < idx2
+ exp = np.array([True, False, False, False])
+ tm.assert_numpy_array_equal(result, exp)
+
+ result = idx1 == idx2
+ exp = np.array([False, False, False, False])
+ tm.assert_numpy_array_equal(result, exp)
+
+ result = idx1 != idx2
+ exp = np.array([True, True, True, True])
+ tm.assert_numpy_array_equal(result, exp)
+
+ result = idx1 == idx1
+ exp = np.array([True, True, False, True])
+ tm.assert_numpy_array_equal(result, exp)
+
+ result = idx1 != idx1
+ exp = np.array([False, False, True, False])
+ tm.assert_numpy_array_equal(result, exp)
+
+ @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
+ def test_pi_cmp_nat_mismatched_freq_raises(self, freq):
+ idx1 = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-05'], freq=freq)
+
+ diff = PeriodIndex(['2011-02', '2011-01', '2011-04', 'NaT'], freq='4M')
+ msg = "Input has different freq=4M from PeriodIndex"
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ idx1 > diff
+
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ idx1 == diff
+
+ # TODO: De-duplicate with test_pi_cmp_nat
+ @pytest.mark.parametrize('dtype', [object, None])
+ def test_comp_nat(self, dtype):
+ left = pd.PeriodIndex([pd.Period('2011-01-01'), pd.NaT,
+ pd.Period('2011-01-03')])
+ right = pd.PeriodIndex([pd.NaT, pd.NaT, pd.Period('2011-01-03')])
+
+ if dtype is not None:
+ left = left.astype(dtype)
+ right = right.astype(dtype)
+
+ result = left == right
+ expected = np.array([False, False, True])
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = left != right
+ expected = np.array([True, True, False])
+ tm.assert_numpy_array_equal(result, expected)
+
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(left == pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT == right, expected)
+
+ expected = np.array([True, True, True])
+ tm.assert_numpy_array_equal(left != pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT != left, expected)
+
+ expected = np.array([False, False, False])
+ tm.assert_numpy_array_equal(left < pd.NaT, expected)
+ tm.assert_numpy_array_equal(pd.NaT > left, expected)
+
+
+class TestPeriodSeriesComparisons(object):
+ @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
+ def test_cmp_series_period_scalar(self, freq):
+ # GH 13200
+ base = Series([Period(x, freq=freq) for x in
+ ['2011-01', '2011-02', '2011-03', '2011-04']])
+ p = Period('2011-02', freq=freq)
+
+ exp = Series([False, True, False, False])
+ tm.assert_series_equal(base == p, exp)
+ tm.assert_series_equal(p == base, exp)
+
+ exp = Series([True, False, True, True])
+ tm.assert_series_equal(base != p, exp)
+ tm.assert_series_equal(p != base, exp)
+
+ exp = Series([False, False, True, True])
+ tm.assert_series_equal(base > p, exp)
+ tm.assert_series_equal(p < base, exp)
+
+ exp = Series([True, False, False, False])
+ tm.assert_series_equal(base < p, exp)
+ tm.assert_series_equal(p > base, exp)
+
+ exp = Series([False, True, True, True])
+ tm.assert_series_equal(base >= p, exp)
+ tm.assert_series_equal(p <= base, exp)
+
+ exp = Series([True, True, False, False])
+ tm.assert_series_equal(base <= p, exp)
+ tm.assert_series_equal(p >= base, exp)
+
+ # different base freq
+ msg = "Input has different freq=A-DEC from Period"
+ with tm.assert_raises_regex(IncompatibleFrequency, msg):
+ base <= Period('2011', freq='A')
+
+ with tm.assert_raises_regex(IncompatibleFrequency, msg):
+ Period('2011', freq='A') >= base
+
+ @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
+ def test_cmp_series_period_series(self, freq):
+ # GH#13200
+ base = Series([Period(x, freq=freq) for x in
+ ['2011-01', '2011-02', '2011-03', '2011-04']])
+
+ ser = Series([Period(x, freq=freq) for x in
+ ['2011-02', '2011-01', '2011-03', '2011-05']])
+
+ exp = Series([False, False, True, False])
+ tm.assert_series_equal(base == ser, exp)
+
+ exp = Series([True, True, False, True])
+ tm.assert_series_equal(base != ser, exp)
+
+ exp = Series([False, True, False, False])
+ tm.assert_series_equal(base > ser, exp)
+
+ exp = Series([True, False, False, True])
+ tm.assert_series_equal(base < ser, exp)
+
+ exp = Series([False, True, True, False])
+ tm.assert_series_equal(base >= ser, exp)
+
+ exp = Series([True, False, True, True])
+ tm.assert_series_equal(base <= ser, exp)
+
+ ser2 = Series([Period(x, freq='A') for x in
+ ['2011', '2011', '2011', '2011']])
+
+ # different base freq
+ msg = "Input has different freq=A-DEC from Period"
+ with tm.assert_raises_regex(IncompatibleFrequency, msg):
+ base <= ser2
+
+ def test_cmp_series_period_series_mixed_freq(self):
+ # GH#13200
+ base = Series([Period('2011', freq='A'),
+ Period('2011-02', freq='M'),
+ Period('2013', freq='A'),
+ Period('2011-04', freq='M')])
+
+ ser = Series([Period('2012', freq='A'),
+ Period('2011-01', freq='M'),
+ Period('2013', freq='A'),
+ Period('2011-05', freq='M')])
+
+ exp = Series([False, False, True, False])
+ tm.assert_series_equal(base == ser, exp)
+
+ exp = Series([True, True, False, True])
+ tm.assert_series_equal(base != ser, exp)
+
+ exp = Series([False, True, False, False])
+ tm.assert_series_equal(base > ser, exp)
+
+ exp = Series([True, False, False, True])
+ tm.assert_series_equal(base < ser, exp)
+
+ exp = Series([False, True, True, False])
+ tm.assert_series_equal(base >= ser, exp)
+
+ exp = Series([True, False, True, True])
+ tm.assert_series_equal(base <= ser, exp)
+
+
+# ------------------------------------------------------------------
+# Arithmetic
+
+class TestPeriodFrameArithmetic(object):
+
+ def test_ops_frame_period(self):
+ # GH#13043
+ df = pd.DataFrame({'A': [pd.Period('2015-01', freq='M'),
+ pd.Period('2015-02', freq='M')],
+ 'B': [pd.Period('2014-01', freq='M'),
+ pd.Period('2014-02', freq='M')]})
+ assert df['A'].dtype == object
+ assert df['B'].dtype == object
+
+ p = pd.Period('2015-03', freq='M')
+ off = p.freq
+ # dtype will be object because of original dtype
+ exp = pd.DataFrame({'A': np.array([2 * off, 1 * off], dtype=object),
+ 'B': np.array([14 * off, 13 * off], dtype=object)})
+ tm.assert_frame_equal(p - df, exp)
+ tm.assert_frame_equal(df - p, -1 * exp)
+
+ df2 = pd.DataFrame({'A': [pd.Period('2015-05', freq='M'),
+ pd.Period('2015-06', freq='M')],
+ 'B': [pd.Period('2015-05', freq='M'),
+ pd.Period('2015-06', freq='M')]})
+ assert df2['A'].dtype == object
+ assert df2['B'].dtype == object
+
+ exp = pd.DataFrame({'A': np.array([4 * off, 4 * off], dtype=object),
+ 'B': np.array([16 * off, 16 * off], dtype=object)})
+ tm.assert_frame_equal(df2 - df, exp)
+ tm.assert_frame_equal(df - df2, -1 * exp)
+
+
+class TestPeriodIndexArithmetic(object):
+ # ---------------------------------------------------------------
+ # __add__/__sub__ with PeriodIndex
+ # PeriodIndex + other is defined for integers and timedelta-like others
+ # PeriodIndex - other is defined for integers, timedelta-like others,
+ # and PeriodIndex (with matching freq)
+
+ def test_parr_add_iadd_parr_raises(self, box_df_broadcast_failure):
+ box = box_df_broadcast_failure
+
+ rng = pd.period_range('1/1/2000', freq='D', periods=5)
+ other = pd.period_range('1/6/2000', freq='D', periods=5)
+ # TODO: parametrize over boxes for other?
+
+ rng = tm.box_expected(rng, box)
+ # An earlier implementation of PeriodIndex addition performed
+ # a set operation (union). This has since been changed to
+ # raise a TypeError. See GH#14164 and GH#13077 for historical
+ # reference.
+ with pytest.raises(TypeError):
+ rng + other
+
+ with pytest.raises(TypeError):
+ rng += other
+
+ def test_pi_sub_isub_pi(self):
+ # GH#20049
+ # For historical reference see GH#14164, GH#13077.
+ # PeriodIndex subtraction originally performed set difference,
+ # then changed to raise TypeError before being implemented in GH#20049
+ rng = pd.period_range('1/1/2000', freq='D', periods=5)
+ other = pd.period_range('1/6/2000', freq='D', periods=5)
+
+ off = rng.freq
+ expected = pd.Index([-5 * off] * 5)
+ result = rng - other
+ tm.assert_index_equal(result, expected)
+
+ rng -= other
+ tm.assert_index_equal(rng, expected)
+
+ def test_pi_sub_pi_with_nat(self):
+ rng = pd.period_range('1/1/2000', freq='D', periods=5)
+ other = rng[1:].insert(0, pd.NaT)
+ assert other[1:].equals(rng[1:])
+
+ result = rng - other
+ off = rng.freq
+ expected = pd.Index([pd.NaT, 0 * off, 0 * off, 0 * off, 0 * off])
+ tm.assert_index_equal(result, expected)
+
+ def test_parr_sub_pi_mismatched_freq(self, box_df_broadcast_failure):
+ box = box_df_broadcast_failure
+
+ rng = pd.period_range('1/1/2000', freq='D', periods=5)
+ other = pd.period_range('1/6/2000', freq='H', periods=5)
+ # TODO: parametrize over boxes for other?
+
+ rng = tm.box_expected(rng, box)
+ with pytest.raises(period.IncompatibleFrequency):
+ rng - other
+
+ # -------------------------------------------------------------
+ # Invalid Operations
+
+ @pytest.mark.parametrize('other', [3.14, np.array([2.0, 3.0])])
+ @pytest.mark.parametrize('op', [operator.add, ops.radd,
+ operator.sub, ops.rsub])
+ def test_pi_add_sub_float(self, op, other):
+ dti = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D')
+ pi = dti.to_period('D')
+ with pytest.raises(TypeError):
+ op(pi, other)
+
+ # -----------------------------------------------------------------
+ # __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
+
+ def test_pi_add_sub_dt64_array_raises(self):
+ rng = pd.period_range('1/1/2000', freq='D', periods=3)
+ dti = pd.date_range('2016-01-01', periods=3)
+ dtarr = dti.values
+
+ with pytest.raises(TypeError):
+ rng + dtarr
+ with pytest.raises(TypeError):
+ dtarr + rng
+
+ with pytest.raises(TypeError):
+ rng - dtarr
+ with pytest.raises(TypeError):
+ dtarr - rng
+
+ def test_pi_add_sub_td64_array_non_tick_raises(self):
+ rng = pd.period_range('1/1/2000', freq='Q', periods=3)
+ tdi = pd.TimedeltaIndex(['-1 Day', '-1 Day', '-1 Day'])
+ tdarr = tdi.values
+
+ with pytest.raises(period.IncompatibleFrequency):
+ rng + tdarr
+ with pytest.raises(period.IncompatibleFrequency):
+ tdarr + rng
+
+ with pytest.raises(period.IncompatibleFrequency):
+ rng - tdarr
+ with pytest.raises(period.IncompatibleFrequency):
+ tdarr - rng
+
+ @pytest.mark.xfail(reason='op with TimedeltaIndex raises, with ndarray OK',
+ strict=True)
+ def test_pi_add_sub_td64_array_tick(self):
+ rng = pd.period_range('1/1/2000', freq='Q', periods=3)
+ tdi = pd.TimedeltaIndex(['-1 Day', '-1 Day', '-1 Day'])
+ tdarr = tdi.values
+
+ expected = rng + tdi
+ result = rng + tdarr
+ tm.assert_index_equal(result, expected)
+ result = tdarr + rng
+ tm.assert_index_equal(result, expected)
+
+ expected = rng - tdi
+ result = rng - tdarr
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ tdarr - rng
+
+ # -----------------------------------------------------------------
+ # operations with array/Index of DateOffset objects
+
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_pi_add_offset_array(self, box):
+ # GH#18849
+ pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
+ offs = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
+ pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
+ expected = pd.PeriodIndex([pd.Period('2015Q2'), pd.Period('2015Q4')])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pi + offs
+ tm.assert_index_equal(res, expected)
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res2 = offs + pi
+ tm.assert_index_equal(res2, expected)
+
+ unanchored = np.array([pd.offsets.Hour(n=1),
+ pd.offsets.Minute(n=-2)])
+ # addition/subtraction ops with incompatible offsets should issue
+ # a PerformanceWarning and _then_ raise a TypeError.
+ with pytest.raises(period.IncompatibleFrequency):
+ with tm.assert_produces_warning(PerformanceWarning):
+ pi + unanchored
+ with pytest.raises(period.IncompatibleFrequency):
+ with tm.assert_produces_warning(PerformanceWarning):
+ unanchored + pi
+
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_pi_sub_offset_array(self, box):
+ # GH#18824
+ pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
+ other = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
+ pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
+
+ expected = PeriodIndex([pi[n] - other[n] for n in range(len(pi))])
+
+ with tm.assert_produces_warning(PerformanceWarning):
+ res = pi - other
+ tm.assert_index_equal(res, expected)
+
+ anchored = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
+
+ # addition/subtraction ops with anchored offsets should issue
+ # a PerformanceWarning and _then_ raise a TypeError.
+ with pytest.raises(period.IncompatibleFrequency):
+ with tm.assert_produces_warning(PerformanceWarning):
+ pi - anchored
+ with pytest.raises(period.IncompatibleFrequency):
+ with tm.assert_produces_warning(PerformanceWarning):
+ anchored - pi
+
+ def test_pi_add_iadd_int(self, one):
+ # Variants of `one` for #19012
+ rng = pd.period_range('2000-01-01 09:00', freq='H', periods=10)
+ result = rng + one
+ expected = pd.period_range('2000-01-01 10:00', freq='H', periods=10)
+ tm.assert_index_equal(result, expected)
+ rng += one
+ tm.assert_index_equal(rng, expected)
+
+ def test_pi_sub_isub_int(self, one):
+ """
+ PeriodIndex.__sub__ and __isub__ with several representations of
+ the integer 1, e.g. int, long, np.int64, np.uint8, ...
+ """
+ rng = pd.period_range('2000-01-01 09:00', freq='H', periods=10)
+ result = rng - one
+ expected = pd.period_range('2000-01-01 08:00', freq='H', periods=10)
+ tm.assert_index_equal(result, expected)
+ rng -= one
+ tm.assert_index_equal(rng, expected)
+
+ @pytest.mark.parametrize('five', [5, np.array(5, dtype=np.int64)])
+ def test_pi_sub_intlike(self, five):
+ rng = period_range('2007-01', periods=50)
+
+ result = rng - five
+ exp = rng + (-five)
+ tm.assert_index_equal(result, exp)
+
+ def test_pi_sub_isub_offset(self):
+ # offset
+ # DateOffset
+ rng = pd.period_range('2014', '2024', freq='A')
+ result = rng - pd.offsets.YearEnd(5)
+ expected = pd.period_range('2009', '2019', freq='A')
+ tm.assert_index_equal(result, expected)
+ rng -= pd.offsets.YearEnd(5)
+ tm.assert_index_equal(rng, expected)
+
+ rng = pd.period_range('2014-01', '2016-12', freq='M')
+ result = rng - pd.offsets.MonthEnd(5)
+ expected = pd.period_range('2013-08', '2016-07', freq='M')
+ tm.assert_index_equal(result, expected)
+
+ rng -= pd.offsets.MonthEnd(5)
+ tm.assert_index_equal(rng, expected)
+
+ # ---------------------------------------------------------------
+ # __add__/__sub__ with integer arrays
+
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ @pytest.mark.parametrize('op', [operator.add, ops.radd])
+ def test_pi_add_intarray(self, box, op):
+ # GH#19959
+ pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('NaT')])
+ other = box([4, -1])
+ result = op(pi, other)
+ expected = pd.PeriodIndex([pd.Period('2016Q1'), pd.Period('NaT')])
+ tm.assert_index_equal(result, expected)
+
+ @pytest.mark.parametrize('box', [np.array, pd.Index])
+ def test_pi_sub_intarray(self, box):
+ # GH#19959
+ pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('NaT')])
+ other = box([4, -1])
+ result = pi - other
+ expected = pd.PeriodIndex([pd.Period('2014Q1'), pd.Period('NaT')])
+ tm.assert_index_equal(result, expected)
+
+ with pytest.raises(TypeError):
+ other - pi
+
+ # ---------------------------------------------------------------
+ # Timedelta-like (timedelta, timedelta64, Timedelta, Tick)
+ # TODO: Some of these are misnomers because of non-Tick DateOffsets
+
+ def test_pi_add_iadd_timedeltalike_daily(self, three_days):
+ # Tick
+ other = three_days
+ rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
+ expected = pd.period_range('2014-05-04', '2014-05-18', freq='D')
+
+ result = rng + other
+ tm.assert_index_equal(result, expected)
+
+ rng += other
+ tm.assert_index_equal(rng, expected)
+
+ def test_pi_sub_isub_timedeltalike_daily(self, three_days):
+ # Tick-like 3 Days
+ other = three_days
+ rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
+ expected = pd.period_range('2014-04-28', '2014-05-12', freq='D')
+
+ result = rng - other
+ tm.assert_index_equal(result, expected)
+
+ rng -= other
+ tm.assert_index_equal(rng, expected)
+
+ def test_pi_add_iadd_timedeltalike_freq_mismatch_daily(self, not_daily):
+ other = not_daily
+ rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
+ msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng + other
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng += other
+
+ def test_pi_sub_timedeltalike_freq_mismatch_daily(self, not_daily):
+ other = not_daily
+ rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
+ msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng - other
+
+ def test_pi_add_iadd_timedeltalike_hourly(self, two_hours):
+ other = two_hours
+ rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
+ expected = pd.period_range('2014-01-01 12:00', '2014-01-05 12:00',
+ freq='H')
+
+ result = rng + other
+ tm.assert_index_equal(result, expected)
+
+ rng += other
+ tm.assert_index_equal(rng, expected)
+
+ def test_pi_add_timedeltalike_mismatched_freq_hourly(self, not_hourly):
+ other = not_hourly
+ rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
+ msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=H\\)'
+
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng + other
+
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng += other
+
+ def test_pi_sub_isub_timedeltalike_hourly(self, two_hours):
+ other = two_hours
+ rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
+ expected = pd.period_range('2014-01-01 08:00', '2014-01-05 08:00',
+ freq='H')
+
+ result = rng - other
+ tm.assert_index_equal(result, expected)
+
+ rng -= other
+ tm.assert_index_equal(rng, expected)
+
+ def test_add_iadd_timedeltalike_annual(self):
+ # offset
+ # DateOffset
+ rng = pd.period_range('2014', '2024', freq='A')
+ result = rng + pd.offsets.YearEnd(5)
+ expected = pd.period_range('2019', '2029', freq='A')
+ tm.assert_index_equal(result, expected)
+ rng += pd.offsets.YearEnd(5)
+ tm.assert_index_equal(rng, expected)
+
+ def test_pi_add_iadd_timedeltalike_freq_mismatch_annual(self, mismatched):
+ other = mismatched
+ rng = pd.period_range('2014', '2024', freq='A')
+ msg = ('Input has different freq(=.+)? '
+ 'from PeriodIndex\\(freq=A-DEC\\)')
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng + other
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng += other
+
+ def test_pi_sub_isub_timedeltalike_freq_mismatch_annual(self, mismatched):
+ other = mismatched
+ rng = pd.period_range('2014', '2024', freq='A')
+ msg = ('Input has different freq(=.+)? '
+ 'from PeriodIndex\\(freq=A-DEC\\)')
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng - other
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng -= other
+
+ def test_pi_add_iadd_timedeltalike_M(self):
+ rng = pd.period_range('2014-01', '2016-12', freq='M')
+ expected = pd.period_range('2014-06', '2017-05', freq='M')
+
+ result = rng + pd.offsets.MonthEnd(5)
+ tm.assert_index_equal(result, expected)
+
+ rng += pd.offsets.MonthEnd(5)
+ tm.assert_index_equal(rng, expected)
+
+ def test_pi_add_iadd_timedeltalike_freq_mismatch_monthly(self, mismatched):
+ other = mismatched
+ rng = pd.period_range('2014-01', '2016-12', freq='M')
+ msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng + other
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng += other
+
+ def test_pi_sub_isub_timedeltalike_freq_mismatch_monthly(self, mismatched):
+ other = mismatched
+ rng = pd.period_range('2014-01', '2016-12', freq='M')
+ msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng - other
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ rng -= other
+
+
+class TestPeriodSeriesArithmetic(object):
+ def test_ops_series_timedelta(self):
+ # GH 13043
+ ser = pd.Series([pd.Period('2015-01-01', freq='D'),
+ pd.Period('2015-01-02', freq='D')], name='xxx')
+ assert ser.dtype == object
+
+ expected = pd.Series([pd.Period('2015-01-02', freq='D'),
+ pd.Period('2015-01-03', freq='D')], name='xxx')
+
+ result = ser + pd.Timedelta('1 days')
+ tm.assert_series_equal(result, expected)
+
+ result = pd.Timedelta('1 days') + ser
+ tm.assert_series_equal(result, expected)
+
+ result = ser + pd.tseries.offsets.Day()
+ tm.assert_series_equal(result, expected)
+
+ result = pd.tseries.offsets.Day() + ser
+ tm.assert_series_equal(result, expected)
+
+ def test_ops_series_period(self):
+ # GH 13043
+ ser = pd.Series([pd.Period('2015-01-01', freq='D'),
+ pd.Period('2015-01-02', freq='D')], name='xxx')
+ assert ser.dtype == object
+
+ per = pd.Period('2015-01-10', freq='D')
+ off = per.freq
+ # dtype will be object because of original dtype
+ expected = pd.Series([9 * off, 8 * off], name='xxx', dtype=object)
+ tm.assert_series_equal(per - ser, expected)
+ tm.assert_series_equal(ser - per, -1 * expected)
+
+ s2 = pd.Series([pd.Period('2015-01-05', freq='D'),
+ pd.Period('2015-01-04', freq='D')], name='xxx')
+ assert s2.dtype == object
+
+ expected = pd.Series([4 * off, 2 * off], name='xxx', dtype=object)
+ tm.assert_series_equal(s2 - ser, expected)
+ tm.assert_series_equal(ser - s2, -1 * expected)
+
+
+class TestPeriodIndexSeriesMethods(object):
+ """ Test PeriodIndex and Period Series Ops consistency """
+
+ def _check(self, values, func, expected):
+ idx = pd.PeriodIndex(values)
+ result = func(idx)
+ if isinstance(expected, pd.Index):
+ tm.assert_index_equal(result, expected)
+ else:
+ # comp op results in bool
+ tm.assert_numpy_array_equal(result, expected)
+
+ ser = pd.Series(values)
+ result = func(ser)
+
+ exp = pd.Series(expected, name=values.name)
+ tm.assert_series_equal(result, exp)
+
+ def test_pi_ops(self):
+ idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
+ freq='M', name='idx')
+
+ expected = PeriodIndex(['2011-03', '2011-04', '2011-05', '2011-06'],
+ freq='M', name='idx')
+ self._check(idx, lambda x: x + 2, expected)
+ self._check(idx, lambda x: 2 + x, expected)
+
+ self._check(idx + 2, lambda x: x - 2, idx)
+ result = idx - Period('2011-01', freq='M')
+ off = idx.freq
+ exp = pd.Index([0 * off, 1 * off, 2 * off, 3 * off], name='idx')
+ tm.assert_index_equal(result, exp)
+
+ result = Period('2011-01', freq='M') - idx
+ exp = pd.Index([0 * off, -1 * off, -2 * off, -3 * off], name='idx')
+ tm.assert_index_equal(result, exp)
+
+ @pytest.mark.parametrize('ng', ["str", 1.5])
+ def test_pi_ops_errors(self, ng):
+ idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
+ freq='M', name='idx')
+ ser = pd.Series(idx)
+
+ msg = r"unsupported operand type\(s\)"
+
+ for obj in [idx, ser]:
+ with tm.assert_raises_regex(TypeError, msg):
+ obj + ng
+
+ with pytest.raises(TypeError):
+ # error message differs between PY2 and 3
+ ng + obj
+
+ with tm.assert_raises_regex(TypeError, msg):
+ obj - ng
+
+ with pytest.raises(TypeError):
+ np.add(obj, ng)
+
+ if _np_version_under1p10:
+ assert np.add(ng, obj) is NotImplemented
+ else:
+ with pytest.raises(TypeError):
+ np.add(ng, obj)
+
+ with pytest.raises(TypeError):
+ np.subtract(obj, ng)
+
+ if _np_version_under1p10:
+ assert np.subtract(ng, obj) is NotImplemented
+ else:
+ with pytest.raises(TypeError):
+ np.subtract(ng, obj)
+
+ def test_pi_ops_nat(self):
+ idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
+ freq='M', name='idx')
+ expected = PeriodIndex(['2011-03', '2011-04', 'NaT', '2011-06'],
+ freq='M', name='idx')
+ self._check(idx, lambda x: x + 2, expected)
+ self._check(idx, lambda x: 2 + x, expected)
+ self._check(idx, lambda x: np.add(x, 2), expected)
+
+ self._check(idx + 2, lambda x: x - 2, idx)
+ self._check(idx + 2, lambda x: np.subtract(x, 2), idx)
+
+ # freq with mult
+ idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
+ freq='2M', name='idx')
+ expected = PeriodIndex(['2011-07', '2011-08', 'NaT', '2011-10'],
+ freq='2M', name='idx')
+ self._check(idx, lambda x: x + 3, expected)
+ self._check(idx, lambda x: 3 + x, expected)
+ self._check(idx, lambda x: np.add(x, 3), expected)
+
+ self._check(idx + 3, lambda x: x - 3, idx)
+ self._check(idx + 3, lambda x: np.subtract(x, 3), idx)
+
+ def test_pi_ops_array_int(self):
+ idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
+ freq='M', name='idx')
+ f = lambda x: x + np.array([1, 2, 3, 4])
+ exp = PeriodIndex(['2011-02', '2011-04', 'NaT', '2011-08'],
+ freq='M', name='idx')
+ self._check(idx, f, exp)
+
+ f = lambda x: np.add(x, np.array([4, -1, 1, 2]))
+ exp = PeriodIndex(['2011-05', '2011-01', 'NaT', '2011-06'],
+ freq='M', name='idx')
+ self._check(idx, f, exp)
+
+ f = lambda x: x - np.array([1, 2, 3, 4])
+ exp = PeriodIndex(['2010-12', '2010-12', 'NaT', '2010-12'],
+ freq='M', name='idx')
+ self._check(idx, f, exp)
+
+ f = lambda x: np.subtract(x, np.array([3, 2, 3, -2]))
+ exp = PeriodIndex(['2010-10', '2010-12', 'NaT', '2011-06'],
+ freq='M', name='idx')
+ self._check(idx, f, exp)
+
+ def test_pi_ops_offset(self):
+ idx = PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01',
+ '2011-04-01'], freq='D', name='idx')
+ f = lambda x: x + pd.offsets.Day()
+ exp = PeriodIndex(['2011-01-02', '2011-02-02', '2011-03-02',
+ '2011-04-02'], freq='D', name='idx')
+ self._check(idx, f, exp)
+
+ f = lambda x: x + pd.offsets.Day(2)
+ exp = PeriodIndex(['2011-01-03', '2011-02-03', '2011-03-03',
+ '2011-04-03'], freq='D', name='idx')
+ self._check(idx, f, exp)
+
+ f = lambda x: x - pd.offsets.Day(2)
+ exp = PeriodIndex(['2010-12-30', '2011-01-30', '2011-02-27',
+ '2011-03-30'], freq='D', name='idx')
+ self._check(idx, f, exp)
+
+ def test_pi_offset_errors(self):
+ idx = PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01',
+ '2011-04-01'], freq='D', name='idx')
+ ser = pd.Series(idx)
+
+ # Series op is applied per Period instance, thus error is raised
+ # from Period
+ msg_idx = r"Input has different freq from PeriodIndex\(freq=D\)"
+ msg_s = r"Input cannot be converted to Period\(freq=D\)"
+ for obj, msg in [(idx, msg_idx), (ser, msg_s)]:
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ obj + pd.offsets.Hour(2)
+
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ pd.offsets.Hour(2) + obj
+
+ with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
+ obj - pd.offsets.Hour(2)
+
+ def test_pi_sub_period(self):
+ # GH 13071
+ idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
+ freq='M', name='idx')
+
+ result = idx - pd.Period('2012-01', freq='M')
+ off = idx.freq
+ exp = pd.Index([-12 * off, -11 * off, -10 * off, -9 * off], name='idx')
+ tm.assert_index_equal(result, exp)
+
+ result = np.subtract(idx, pd.Period('2012-01', freq='M'))
+ tm.assert_index_equal(result, exp)
+
+ result = pd.Period('2012-01', freq='M') - idx
+ exp = pd.Index([12 * off, 11 * off, 10 * off, 9 * off], name='idx')
+ tm.assert_index_equal(result, exp)
+
+ result = np.subtract(pd.Period('2012-01', freq='M'), idx)
+ if _np_version_under1p10:
+ assert result is NotImplemented
+ else:
+ tm.assert_index_equal(result, exp)
+
+ exp = pd.TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name='idx')
+ tm.assert_index_equal(idx - pd.Period('NaT', freq='M'), exp)
+ tm.assert_index_equal(pd.Period('NaT', freq='M') - idx, exp)
+
+ def test_pi_sub_pdnat(self):
+ # GH 13071
+ idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
+ freq='M', name='idx')
+ exp = pd.TimedeltaIndex([pd.NaT] * 4, name='idx')
+ tm.assert_index_equal(pd.NaT - idx, exp)
+ tm.assert_index_equal(idx - pd.NaT, exp)
+
+ def test_pi_sub_period_nat(self):
+ # GH 13071
+ idx = PeriodIndex(['2011-01', 'NaT', '2011-03', '2011-04'],
+ freq='M', name='idx')
+
+ result = idx - pd.Period('2012-01', freq='M')
+ off = idx.freq
+ exp = pd.Index([-12 * off, pd.NaT, -10 * off, -9 * off], name='idx')
+ tm.assert_index_equal(result, exp)
+
+ result = pd.Period('2012-01', freq='M') - idx
+ exp = pd.Index([12 * off, pd.NaT, 10 * off, 9 * off], name='idx')
+ tm.assert_index_equal(result, exp)
+
+ exp = pd.TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name='idx')
+ tm.assert_index_equal(idx - pd.Period('NaT', freq='M'), exp)
+ tm.assert_index_equal(pd.Period('NaT', freq='M') - idx, exp)
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 8d52bc9532136..20c547382ad57 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -59,15 +59,6 @@ def test_df_flex_cmp_constant_return_types_empty(self, opname):
result = getattr(empty, opname)(const).get_dtype_counts()
tm.assert_series_equal(result, pd.Series([2], ['bool']))
- @pytest.mark.parametrize('timestamps', [
- [pd.Timestamp('2012-01-01 13:00:00+00:00')] * 2,
- [pd.Timestamp('2012-01-01 13:00:00')] * 2])
- def test_tz_aware_scalar_comparison(self, timestamps):
- # Test for issue #15966
- df = pd.DataFrame({'test': timestamps})
- expected = pd.DataFrame({'test': [False, False]})
- tm.assert_frame_equal(df == -1, expected)
-
# -------------------------------------------------------------------
# Arithmetic
@@ -91,17 +82,6 @@ def test_df_add_flex_filled_mixed_dtypes(self):
class TestFrameArithmetic(object):
- @pytest.mark.xfail(reason='GH#7996 datetime64 units not converted to nano',
- strict=True)
- def test_df_sub_datetime64_not_ns(self):
- df = pd.DataFrame(pd.date_range('20130101', periods=3))
- dt64 = np.datetime64('2013-01-01')
- assert dt64.dtype == 'datetime64[D]'
- res = df - dt64
- expected = pd.DataFrame([pd.Timedelta(days=0), pd.Timedelta(days=1),
- pd.Timedelta(days=2)])
- tm.assert_frame_equal(res, expected)
-
@pytest.mark.parametrize('data', [
[1, 2, 3],
[1.1, 2.2, 3.3],
@@ -135,35 +115,3 @@ def test_df_radd_str(self):
df = pd.DataFrame(['x', np.nan, 'x'])
tm.assert_frame_equal('a' + df, pd.DataFrame(['ax', np.nan, 'ax']))
tm.assert_frame_equal(df + 'a', pd.DataFrame(['xa', np.nan, 'xa']))
-
-
-class TestPeriodFrameArithmetic(object):
-
- def test_ops_frame_period(self):
- # GH 13043
- df = pd.DataFrame({'A': [pd.Period('2015-01', freq='M'),
- pd.Period('2015-02', freq='M')],
- 'B': [pd.Period('2014-01', freq='M'),
- pd.Period('2014-02', freq='M')]})
- assert df['A'].dtype == object
- assert df['B'].dtype == object
-
- p = pd.Period('2015-03', freq='M')
- off = p.freq
- # dtype will be object because of original dtype
- exp = pd.DataFrame({'A': np.array([2 * off, 1 * off], dtype=object),
- 'B': np.array([14 * off, 13 * off], dtype=object)})
- tm.assert_frame_equal(p - df, exp)
- tm.assert_frame_equal(df - p, -1 * exp)
-
- df2 = pd.DataFrame({'A': [pd.Period('2015-05', freq='M'),
- pd.Period('2015-06', freq='M')],
- 'B': [pd.Period('2015-05', freq='M'),
- pd.Period('2015-06', freq='M')]})
- assert df2['A'].dtype == object
- assert df2['B'].dtype == object
-
- exp = pd.DataFrame({'A': np.array([4 * off, 4 * off], dtype=object),
- 'B': np.array([16 * off, 16 * off], dtype=object)})
- tm.assert_frame_equal(df2 - df, exp)
- tm.assert_frame_equal(df - df2, -1 * exp)
diff --git a/pandas/tests/indexes/datetimes/test_arithmetic.py b/pandas/tests/indexes/datetimes/test_arithmetic.py
index f54cb32b0a036..4feed589f5961 100644
--- a/pandas/tests/indexes/datetimes/test_arithmetic.py
+++ b/pandas/tests/indexes/datetimes/test_arithmetic.py
@@ -1,531 +1,17 @@
# -*- coding: utf-8 -*-
-import warnings
-from datetime import datetime, timedelta
-import operator
+from datetime import datetime
import pytest
import pytz
-import numpy as np
import pandas as pd
-from pandas.compat.numpy import np_datetime64_compat
import pandas.util.testing as tm
-from pandas.errors import PerformanceWarning, NullFrequencyError
-from pandas import (Timestamp, Timedelta, Series,
- DatetimeIndex, TimedeltaIndex,
- date_range)
-from pandas.core import ops
-from pandas._libs.tslibs.conversion import localize_pydatetime
-from pandas._libs.tslibs.offsets import shift_months
-
-
-@pytest.fixture(params=[pd.offsets.Hour(2), timedelta(hours=2),
- np.timedelta64(2, 'h'), Timedelta(hours=2)],
- ids=str)
-def delta(request):
- # Several ways of representing two hours
- return request.param
-
-
-@pytest.fixture(
- params=[
- datetime(2011, 1, 1),
- DatetimeIndex(['2011-01-01', '2011-01-02']),
- DatetimeIndex(['2011-01-01', '2011-01-02']).tz_localize('US/Eastern'),
- np.datetime64('2011-01-01'),
- Timestamp('2011-01-01')],
- ids=lambda x: type(x).__name__)
-def addend(request):
- return request.param
-
-
-class TestDatetimeIndexComparisons(object):
- @pytest.mark.parametrize('other', [datetime(2016, 1, 1),
- Timestamp('2016-01-01'),
- np.datetime64('2016-01-01')])
- def test_dti_cmp_datetimelike(self, other, tz_naive_fixture):
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=2, tz=tz)
- if tz is not None:
- if isinstance(other, np.datetime64):
- # no tzaware version available
- return
- other = localize_pydatetime(other, dti.tzinfo)
-
- result = dti == other
- expected = np.array([True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- result = dti > other
- expected = np.array([False, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = dti >= other
- expected = np.array([True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = dti < other
- expected = np.array([False, False])
- tm.assert_numpy_array_equal(result, expected)
-
- result = dti <= other
- expected = np.array([True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- def dti_cmp_non_datetime(self, tz_naive_fixture):
- # GH#19301 by convention datetime.date is not considered comparable
- # to Timestamp or DatetimeIndex. This may change in the future.
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=2, tz=tz)
-
- other = datetime(2016, 1, 1).date()
- assert not (dti == other).any()
- assert (dti != other).all()
- with pytest.raises(TypeError):
- dti < other
- with pytest.raises(TypeError):
- dti <= other
- with pytest.raises(TypeError):
- dti > other
- with pytest.raises(TypeError):
- dti >= other
-
- @pytest.mark.parametrize('other', [None, np.nan, pd.NaT])
- def test_dti_eq_null_scalar(self, other, tz_naive_fixture):
- # GH#19301
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=2, tz=tz)
- assert not (dti == other).any()
-
- @pytest.mark.parametrize('other', [None, np.nan, pd.NaT])
- def test_dti_ne_null_scalar(self, other, tz_naive_fixture):
- # GH#19301
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=2, tz=tz)
- assert (dti != other).all()
-
- @pytest.mark.parametrize('other', [None, np.nan])
- def test_dti_cmp_null_scalar_inequality(self, tz_naive_fixture, other):
- # GH#19301
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=2, tz=tz)
-
- with pytest.raises(TypeError):
- dti < other
- with pytest.raises(TypeError):
- dti <= other
- with pytest.raises(TypeError):
- dti > other
- with pytest.raises(TypeError):
- dti >= other
-
- def test_dti_cmp_nat(self):
- left = pd.DatetimeIndex([pd.Timestamp('2011-01-01'), pd.NaT,
- pd.Timestamp('2011-01-03')])
- right = pd.DatetimeIndex([pd.NaT, pd.NaT, pd.Timestamp('2011-01-03')])
-
- for lhs, rhs in [(left, right),
- (left.astype(object), right.astype(object))]:
- result = rhs == lhs
- expected = np.array([False, False, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = lhs != rhs
- expected = np.array([True, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- expected = np.array([False, False, False])
- tm.assert_numpy_array_equal(lhs == pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT == rhs, expected)
-
- expected = np.array([True, True, True])
- tm.assert_numpy_array_equal(lhs != pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT != lhs, expected)
-
- expected = np.array([False, False, False])
- tm.assert_numpy_array_equal(lhs < pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT > lhs, expected)
-
- def test_dti_cmp_nat_behaves_like_float_cmp_nan(self):
- fidx1 = pd.Index([1.0, np.nan, 3.0, np.nan, 5.0, 7.0])
- fidx2 = pd.Index([2.0, 3.0, np.nan, np.nan, 6.0, 7.0])
-
- didx1 = pd.DatetimeIndex(['2014-01-01', pd.NaT, '2014-03-01', pd.NaT,
- '2014-05-01', '2014-07-01'])
- didx2 = pd.DatetimeIndex(['2014-02-01', '2014-03-01', pd.NaT, pd.NaT,
- '2014-06-01', '2014-07-01'])
- darr = np.array([np_datetime64_compat('2014-02-01 00:00Z'),
- np_datetime64_compat('2014-03-01 00:00Z'),
- np_datetime64_compat('nat'), np.datetime64('nat'),
- np_datetime64_compat('2014-06-01 00:00Z'),
- np_datetime64_compat('2014-07-01 00:00Z')])
-
- cases = [(fidx1, fidx2), (didx1, didx2), (didx1, darr)]
-
- # Check pd.NaT is handles as the same as np.nan
- with tm.assert_produces_warning(None):
- for idx1, idx2 in cases:
-
- result = idx1 < idx2
- expected = np.array([True, False, False, False, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx2 > idx1
- expected = np.array([True, False, False, False, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 <= idx2
- expected = np.array([True, False, False, False, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx2 >= idx1
- expected = np.array([True, False, False, False, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 == idx2
- expected = np.array([False, False, False, False, False, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 != idx2
- expected = np.array([True, True, True, True, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- with tm.assert_produces_warning(None):
- for idx1, val in [(fidx1, np.nan), (didx1, pd.NaT)]:
- result = idx1 < val
- expected = np.array([False, False, False, False, False, False])
- tm.assert_numpy_array_equal(result, expected)
- result = idx1 > val
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 <= val
- tm.assert_numpy_array_equal(result, expected)
- result = idx1 >= val
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 == val
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 != val
- expected = np.array([True, True, True, True, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- # Check pd.NaT is handles as the same as np.nan
- with tm.assert_produces_warning(None):
- for idx1, val in [(fidx1, 3), (didx1, datetime(2014, 3, 1))]:
- result = idx1 < val
- expected = np.array([True, False, False, False, False, False])
- tm.assert_numpy_array_equal(result, expected)
- result = idx1 > val
- expected = np.array([False, False, False, False, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 <= val
- expected = np.array([True, False, True, False, False, False])
- tm.assert_numpy_array_equal(result, expected)
- result = idx1 >= val
- expected = np.array([False, False, True, False, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 == val
- expected = np.array([False, False, True, False, False, False])
- tm.assert_numpy_array_equal(result, expected)
-
- result = idx1 != val
- expected = np.array([True, True, False, True, True, True])
- tm.assert_numpy_array_equal(result, expected)
-
- @pytest.mark.parametrize('op', [operator.eq, operator.ne,
- operator.gt, operator.ge,
- operator.lt, operator.le])
- def test_comparison_tzawareness_compat(self, op):
- # GH#18162
- dr = pd.date_range('2016-01-01', periods=6)
- dz = dr.tz_localize('US/Pacific')
-
- with pytest.raises(TypeError):
- op(dr, dz)
- with pytest.raises(TypeError):
- op(dr, list(dz))
- with pytest.raises(TypeError):
- op(dz, dr)
- with pytest.raises(TypeError):
- op(dz, list(dr))
-
- # Check that there isn't a problem aware-aware and naive-naive do not
- # raise
- assert (dr == dr).all()
- assert (dr == list(dr)).all()
- assert (dz == dz).all()
- assert (dz == list(dz)).all()
-
- # Check comparisons against scalar Timestamps
- ts = pd.Timestamp('2000-03-14 01:59')
- ts_tz = pd.Timestamp('2000-03-14 01:59', tz='Europe/Amsterdam')
-
- assert (dr > ts).all()
- with pytest.raises(TypeError):
- op(dr, ts_tz)
-
- assert (dz > ts_tz).all()
- with pytest.raises(TypeError):
- op(dz, ts)
-
- # GH 12601: Check comparison against Timestamps and DatetimeIndex
- with pytest.raises(TypeError):
- op(ts, dz)
-
- @pytest.mark.parametrize('op', [operator.eq, operator.ne,
- operator.gt, operator.ge,
- operator.lt, operator.le])
- @pytest.mark.parametrize('other', [datetime(2016, 1, 1),
- Timestamp('2016-01-01'),
- np.datetime64('2016-01-01')])
- def test_scalar_comparison_tzawareness(self, op, other, tz_aware_fixture):
- tz = tz_aware_fixture
- dti = pd.date_range('2016-01-01', periods=2, tz=tz)
- with pytest.raises(TypeError):
- op(dti, other)
- with pytest.raises(TypeError):
- op(other, dti)
-
- @pytest.mark.parametrize('op', [operator.eq, operator.ne,
- operator.gt, operator.ge,
- operator.lt, operator.le])
- def test_nat_comparison_tzawareness(self, op):
- # GH#19276
- # tzaware DatetimeIndex should not raise when compared to NaT
- dti = pd.DatetimeIndex(['2014-01-01', pd.NaT, '2014-03-01', pd.NaT,
- '2014-05-01', '2014-07-01'])
- expected = np.array([op == operator.ne] * len(dti))
- result = op(dti, pd.NaT)
- tm.assert_numpy_array_equal(result, expected)
-
- result = op(dti.tz_localize('US/Pacific'), pd.NaT)
- tm.assert_numpy_array_equal(result, expected)
-
- def test_dti_cmp_str(self, tz_naive_fixture):
- # GH#22074
- # regardless of tz, we expect these comparisons are valid
- tz = tz_naive_fixture
- rng = date_range('1/1/2000', periods=10, tz=tz)
- other = '1/1/2000'
-
- result = rng == other
- expected = np.array([True] + [False] * 9)
- tm.assert_numpy_array_equal(result, expected)
-
- result = rng != other
- expected = np.array([False] + [True] * 9)
- tm.assert_numpy_array_equal(result, expected)
-
- result = rng < other
- expected = np.array([False] * 10)
- tm.assert_numpy_array_equal(result, expected)
-
- result = rng <= other
- expected = np.array([True] + [False] * 9)
- tm.assert_numpy_array_equal(result, expected)
-
- result = rng > other
- expected = np.array([False] + [True] * 9)
- tm.assert_numpy_array_equal(result, expected)
-
- result = rng >= other
- expected = np.array([True] * 10)
- tm.assert_numpy_array_equal(result, expected)
-
- @pytest.mark.parametrize('other', ['foo', 99, 4.0,
- object(), timedelta(days=2)])
- def test_dti_cmp_scalar_invalid(self, other, tz_naive_fixture):
- # GH#22074
- tz = tz_naive_fixture
- rng = date_range('1/1/2000', periods=10, tz=tz)
-
- result = rng == other
- expected = np.array([False] * 10)
- tm.assert_numpy_array_equal(result, expected)
-
- result = rng != other
- expected = np.array([True] * 10)
- tm.assert_numpy_array_equal(result, expected)
-
- with pytest.raises(TypeError):
- rng < other
- with pytest.raises(TypeError):
- rng <= other
- with pytest.raises(TypeError):
- rng > other
- with pytest.raises(TypeError):
- rng >= other
-
- def test_dti_cmp_list(self):
- rng = date_range('1/1/2000', periods=10)
-
- result = rng == list(rng)
- expected = rng == rng
- tm.assert_numpy_array_equal(result, expected)
-
- @pytest.mark.parametrize('other', [
- pd.timedelta_range('1D', periods=10),
- pd.timedelta_range('1D', periods=10).to_series(),
- pd.timedelta_range('1D', periods=10).asi8.view('m8[ns]')
- ], ids=lambda x: type(x).__name__)
- def test_dti_cmp_tdi_tzawareness(self, other):
- # GH#22074
- # reversion test that we _don't_ call _assert_tzawareness_compat
- # when comparing against TimedeltaIndex
- dti = date_range('2000-01-01', periods=10, tz='Asia/Tokyo')
-
- result = dti == other
- expected = np.array([False] * 10)
- tm.assert_numpy_array_equal(result, expected)
-
- result = dti != other
- expected = np.array([True] * 10)
- tm.assert_numpy_array_equal(result, expected)
-
- with pytest.raises(TypeError):
- dti < other
- with pytest.raises(TypeError):
- dti <= other
- with pytest.raises(TypeError):
- dti > other
- with pytest.raises(TypeError):
- dti >= other
-
- def test_dti_cmp_object_dtype(self):
- # GH#22074
- dti = date_range('2000-01-01', periods=10, tz='Asia/Tokyo')
-
- other = dti.astype('O')
-
- result = dti == other
- expected = np.array([True] * 10)
- tm.assert_numpy_array_equal(result, expected)
-
- other = dti.tz_localize(None)
- with pytest.raises(TypeError):
- # tzawareness failure
- dti != other
-
- other = np.array(list(dti[:5]) + [Timedelta(days=1)] * 5)
- result = dti == other
- expected = np.array([True] * 5 + [False] * 5)
- tm.assert_numpy_array_equal(result, expected)
-
- with pytest.raises(TypeError):
- dti >= other
+from pandas.errors import NullFrequencyError
+from pandas import Series, DatetimeIndex, date_range
class TestDatetimeIndexArithmetic(object):
- # -------------------------------------------------------------
- # Invalid Operations
-
- @pytest.mark.parametrize('other', [3.14, np.array([2.0, 3.0])])
- @pytest.mark.parametrize('op', [operator.add, ops.radd,
- operator.sub, ops.rsub])
- def test_dti_add_sub_float(self, op, other):
- dti = DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D')
- with pytest.raises(TypeError):
- op(dti, other)
-
- def test_dti_add_timestamp_raises(self):
- idx = DatetimeIndex(['2011-01-01', '2011-01-02'])
- msg = "cannot add DatetimeIndex and Timestamp"
- with tm.assert_raises_regex(TypeError, msg):
- idx + Timestamp('2011-01-01')
-
- def test_dti_radd_timestamp_raises(self):
- idx = DatetimeIndex(['2011-01-01', '2011-01-02'])
- msg = "cannot add DatetimeIndex and Timestamp"
- with tm.assert_raises_regex(TypeError, msg):
- Timestamp('2011-01-01') + idx
-
- # -------------------------------------------------------------
- # Binary operations DatetimeIndex and int
-
- def test_dti_add_int(self, tz_naive_fixture, one):
- # Variants of `one` for #19012
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01 09:00', freq='H',
- periods=10, tz=tz)
- result = rng + one
- expected = pd.date_range('2000-01-01 10:00', freq='H',
- periods=10, tz=tz)
- tm.assert_index_equal(result, expected)
-
- def test_dti_iadd_int(self, tz_naive_fixture, one):
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01 09:00', freq='H',
- periods=10, tz=tz)
- expected = pd.date_range('2000-01-01 10:00', freq='H',
- periods=10, tz=tz)
- rng += one
- tm.assert_index_equal(rng, expected)
-
- def test_dti_sub_int(self, tz_naive_fixture, one):
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01 09:00', freq='H',
- periods=10, tz=tz)
- result = rng - one
- expected = pd.date_range('2000-01-01 08:00', freq='H',
- periods=10, tz=tz)
- tm.assert_index_equal(result, expected)
-
- def test_dti_isub_int(self, tz_naive_fixture, one):
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01 09:00', freq='H',
- periods=10, tz=tz)
- expected = pd.date_range('2000-01-01 08:00', freq='H',
- periods=10, tz=tz)
- rng -= one
- tm.assert_index_equal(rng, expected)
-
- # -------------------------------------------------------------
- # __add__/__sub__ with integer arrays
-
- @pytest.mark.parametrize('freq', ['H', 'D'])
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_dti_add_intarray_tick(self, box, freq):
- # GH#19959
- dti = pd.date_range('2016-01-01', periods=2, freq=freq)
- other = box([4, -1])
- expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))])
- result = dti + other
- tm.assert_index_equal(result, expected)
- result = other + dti
- tm.assert_index_equal(result, expected)
-
- @pytest.mark.parametrize('freq', ['W', 'M', 'MS', 'Q'])
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_dti_add_intarray_non_tick(self, box, freq):
- # GH#19959
- dti = pd.date_range('2016-01-01', periods=2, freq=freq)
- other = box([4, -1])
- expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))])
- with tm.assert_produces_warning(PerformanceWarning):
- result = dti + other
- tm.assert_index_equal(result, expected)
- with tm.assert_produces_warning(PerformanceWarning):
- result = other + dti
- tm.assert_index_equal(result, expected)
-
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_dti_add_intarray_no_freq(self, box):
- # GH#19959
- dti = pd.DatetimeIndex(['2016-01-01', 'NaT', '2017-04-05 06:07:08'])
- other = box([9, 4, -1])
- with pytest.raises(NullFrequencyError):
- dti + other
- with pytest.raises(NullFrequencyError):
- other + dti
- with pytest.raises(NullFrequencyError):
- dti - other
- with pytest.raises(TypeError):
- other - dti
-
# -------------------------------------------------------------
# DatetimeIndex.shift is used in integer addition
@@ -614,651 +100,3 @@ def test_dti_shift_near_midnight(self, shift, result_time):
result = s.shift(shift, freq='H')
expected = Series(1, index=DatetimeIndex([result_time], tz='EST'))
tm.assert_series_equal(result, expected)
-
- # -------------------------------------------------------------
- # Binary operations DatetimeIndex and timedelta-like
-
- def test_dti_add_timedeltalike(self, tz_naive_fixture, delta):
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
- result = rng + delta
- expected = pd.date_range('2000-01-01 02:00',
- '2000-02-01 02:00', tz=tz)
- tm.assert_index_equal(result, expected)
-
- def test_dti_iadd_timedeltalike(self, tz_naive_fixture, delta):
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
- expected = pd.date_range('2000-01-01 02:00',
- '2000-02-01 02:00', tz=tz)
- rng += delta
- tm.assert_index_equal(rng, expected)
-
- def test_dti_sub_timedeltalike(self, tz_naive_fixture, delta):
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
- expected = pd.date_range('1999-12-31 22:00',
- '2000-01-31 22:00', tz=tz)
- result = rng - delta
- tm.assert_index_equal(result, expected)
-
- def test_dti_isub_timedeltalike(self, tz_naive_fixture, delta):
- tz = tz_naive_fixture
- rng = pd.date_range('2000-01-01', '2000-02-01', tz=tz)
- expected = pd.date_range('1999-12-31 22:00',
- '2000-01-31 22:00', tz=tz)
- rng -= delta
- tm.assert_index_equal(rng, expected)
-
- # -------------------------------------------------------------
- # Binary operations DatetimeIndex and TimedeltaIndex/array
- def test_dti_add_tdi(self, tz_naive_fixture):
- # GH 17558
- tz = tz_naive_fixture
- dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- tdi = pd.timedelta_range('0 days', periods=10)
- expected = pd.date_range('2017-01-01', periods=10, tz=tz)
-
- # add with TimdeltaIndex
- result = dti + tdi
- tm.assert_index_equal(result, expected)
-
- result = tdi + dti
- tm.assert_index_equal(result, expected)
-
- # add with timedelta64 array
- result = dti + tdi.values
- tm.assert_index_equal(result, expected)
-
- result = tdi.values + dti
- tm.assert_index_equal(result, expected)
-
- def test_dti_iadd_tdi(self, tz_naive_fixture):
- # GH 17558
- tz = tz_naive_fixture
- dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- tdi = pd.timedelta_range('0 days', periods=10)
- expected = pd.date_range('2017-01-01', periods=10, tz=tz)
-
- # iadd with TimdeltaIndex
- result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- result += tdi
- tm.assert_index_equal(result, expected)
-
- result = pd.timedelta_range('0 days', periods=10)
- result += dti
- tm.assert_index_equal(result, expected)
-
- # iadd with timedelta64 array
- result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- result += tdi.values
- tm.assert_index_equal(result, expected)
-
- result = pd.timedelta_range('0 days', periods=10)
- result += dti
- tm.assert_index_equal(result, expected)
-
- def test_dti_sub_tdi(self, tz_naive_fixture):
- # GH 17558
- tz = tz_naive_fixture
- dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- tdi = pd.timedelta_range('0 days', periods=10)
- expected = pd.date_range('2017-01-01', periods=10, tz=tz, freq='-1D')
-
- # sub with TimedeltaIndex
- result = dti - tdi
- tm.assert_index_equal(result, expected)
-
- msg = 'cannot subtract .*TimedeltaIndex'
- with tm.assert_raises_regex(TypeError, msg):
- tdi - dti
-
- # sub with timedelta64 array
- result = dti - tdi.values
- tm.assert_index_equal(result, expected)
-
- msg = 'cannot subtract DatetimeIndex from'
- with tm.assert_raises_regex(TypeError, msg):
- tdi.values - dti
-
- def test_dti_isub_tdi(self, tz_naive_fixture):
- # GH 17558
- tz = tz_naive_fixture
- dti = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- tdi = pd.timedelta_range('0 days', periods=10)
- expected = pd.date_range('2017-01-01', periods=10, tz=tz, freq='-1D')
-
- # isub with TimedeltaIndex
- result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- result -= tdi
- tm.assert_index_equal(result, expected)
-
- msg = 'cannot subtract .*TimedeltaIndex'
- with tm.assert_raises_regex(TypeError, msg):
- tdi -= dti
-
- # isub with timedelta64 array
- result = DatetimeIndex([Timestamp('2017-01-01', tz=tz)] * 10)
- result -= tdi.values
- tm.assert_index_equal(result, expected)
-
- msg = '|'.join(['cannot perform __neg__ with this index type:',
- 'ufunc subtract cannot use operands with types',
- 'cannot subtract DatetimeIndex from'])
- with tm.assert_raises_regex(TypeError, msg):
- tdi.values -= dti
-
- # -------------------------------------------------------------
- # Binary Operations DatetimeIndex and datetime-like
- # TODO: A couple other tests belong in this section. Move them in
- # A PR where there isn't already a giant diff.
-
- def test_add_datetimelike_and_dti(self, addend):
- # GH#9631
- dti = DatetimeIndex(['2011-01-01', '2011-01-02'])
- msg = 'cannot add DatetimeIndex and {0}'.format(
- type(addend).__name__)
- with tm.assert_raises_regex(TypeError, msg):
- dti + addend
- with tm.assert_raises_regex(TypeError, msg):
- addend + dti
-
- def test_add_datetimelike_and_dti_tz(self, addend):
- # GH#9631
- dti_tz = DatetimeIndex(['2011-01-01',
- '2011-01-02']).tz_localize('US/Eastern')
- msg = 'cannot add DatetimeIndex and {0}'.format(
- type(addend).__name__)
- with tm.assert_raises_regex(TypeError, msg):
- dti_tz + addend
- with tm.assert_raises_regex(TypeError, msg):
- addend + dti_tz
-
- # -------------------------------------------------------------
- # __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
-
- def test_dti_add_dt64_array_raises(self, tz_naive_fixture):
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=3, tz=tz)
- dtarr = dti.values
-
- with pytest.raises(TypeError):
- dti + dtarr
- with pytest.raises(TypeError):
- dtarr + dti
-
- def test_dti_sub_dt64_array_naive(self):
- dti = pd.date_range('2016-01-01', periods=3, tz=None)
- dtarr = dti.values
-
- expected = dti - dti
- result = dti - dtarr
- tm.assert_index_equal(result, expected)
- result = dtarr - dti
- tm.assert_index_equal(result, expected)
-
- def test_dti_sub_dt64_array_aware_raises(self, tz_naive_fixture):
- tz = tz_naive_fixture
- if tz is None:
- return
- dti = pd.date_range('2016-01-01', periods=3, tz=tz)
- dtarr = dti.values
-
- with pytest.raises(TypeError):
- dti - dtarr
- with pytest.raises(TypeError):
- dtarr - dti
-
- def test_dti_add_td64_array(self, tz_naive_fixture):
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=3, tz=tz)
- tdi = dti - dti.shift(1)
- tdarr = tdi.values
-
- expected = dti + tdi
- result = dti + tdarr
- tm.assert_index_equal(result, expected)
- result = tdarr + dti
- tm.assert_index_equal(result, expected)
-
- def test_dti_sub_td64_array(self, tz_naive_fixture):
- tz = tz_naive_fixture
- dti = pd.date_range('2016-01-01', periods=3, tz=tz)
- tdi = dti - dti.shift(1)
- tdarr = tdi.values
-
- expected = dti - tdi
- result = dti - tdarr
- tm.assert_index_equal(result, expected)
-
- with pytest.raises(TypeError):
- tdarr - dti
-
- # -------------------------------------------------------------
-
- def test_sub_dti_dti(self):
- # previously performed setop (deprecated in 0.16.0), now changed to
- # return subtraction -> TimeDeltaIndex (GH ...)
-
- dti = date_range('20130101', periods=3)
- dti_tz = date_range('20130101', periods=3).tz_localize('US/Eastern')
- dti_tz2 = date_range('20130101', periods=3).tz_localize('UTC')
- expected = TimedeltaIndex([0, 0, 0])
-
- result = dti - dti
- tm.assert_index_equal(result, expected)
-
- result = dti_tz - dti_tz
- tm.assert_index_equal(result, expected)
-
- with pytest.raises(TypeError):
- dti_tz - dti
-
- with pytest.raises(TypeError):
- dti - dti_tz
-
- with pytest.raises(TypeError):
- dti_tz - dti_tz2
-
- # isub
- dti -= dti
- tm.assert_index_equal(dti, expected)
-
- # different length raises ValueError
- dti1 = date_range('20130101', periods=3)
- dti2 = date_range('20130101', periods=4)
- with pytest.raises(ValueError):
- dti1 - dti2
-
- # NaN propagation
- dti1 = DatetimeIndex(['2012-01-01', np.nan, '2012-01-03'])
- dti2 = DatetimeIndex(['2012-01-02', '2012-01-03', np.nan])
- expected = TimedeltaIndex(['1 days', np.nan, np.nan])
- result = dti2 - dti1
- tm.assert_index_equal(result, expected)
-
- @pytest.mark.parametrize('freq', [None, 'D'])
- def test_sub_period(self, freq):
- # GH#13078
- # not supported, check TypeError
- p = pd.Period('2011-01-01', freq='D')
-
- idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq)
-
- with pytest.raises(TypeError):
- idx - p
-
- with pytest.raises(TypeError):
- p - idx
-
- @pytest.mark.parametrize('op', [operator.add, ops.radd,
- operator.sub, ops.rsub])
- @pytest.mark.parametrize('pi_freq', ['D', 'W', 'Q', 'H'])
- @pytest.mark.parametrize('dti_freq', [None, 'D'])
- def test_dti_sub_pi(self, dti_freq, pi_freq, op):
- # GH#20049 subtracting PeriodIndex should raise TypeError
- dti = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=dti_freq)
- pi = dti.to_period(pi_freq)
- with pytest.raises(TypeError):
- op(dti, pi)
-
- def test_ufunc_coercions(self):
- idx = date_range('2011-01-01', periods=3, freq='2D', name='x')
-
- delta = np.timedelta64(1, 'D')
- for result in [idx + delta, np.add(idx, delta)]:
- assert isinstance(result, DatetimeIndex)
- exp = date_range('2011-01-02', periods=3, freq='2D', name='x')
- tm.assert_index_equal(result, exp)
- assert result.freq == '2D'
-
- for result in [idx - delta, np.subtract(idx, delta)]:
- assert isinstance(result, DatetimeIndex)
- exp = date_range('2010-12-31', periods=3, freq='2D', name='x')
- tm.assert_index_equal(result, exp)
- assert result.freq == '2D'
-
- delta = np.array([np.timedelta64(1, 'D'), np.timedelta64(2, 'D'),
- np.timedelta64(3, 'D')])
- for result in [idx + delta, np.add(idx, delta)]:
- assert isinstance(result, DatetimeIndex)
- exp = DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-08'],
- freq='3D', name='x')
- tm.assert_index_equal(result, exp)
- assert result.freq == '3D'
-
- for result in [idx - delta, np.subtract(idx, delta)]:
- assert isinstance(result, DatetimeIndex)
- exp = DatetimeIndex(['2010-12-31', '2011-01-01', '2011-01-02'],
- freq='D', name='x')
- tm.assert_index_equal(result, exp)
- assert result.freq == 'D'
-
- def test_datetimeindex_sub_timestamp_overflow(self):
- dtimax = pd.to_datetime(['now', pd.Timestamp.max])
- dtimin = pd.to_datetime(['now', pd.Timestamp.min])
-
- tsneg = Timestamp('1950-01-01')
- ts_neg_variants = [tsneg,
- tsneg.to_pydatetime(),
- tsneg.to_datetime64().astype('datetime64[ns]'),
- tsneg.to_datetime64().astype('datetime64[D]')]
-
- tspos = Timestamp('1980-01-01')
- ts_pos_variants = [tspos,
- tspos.to_pydatetime(),
- tspos.to_datetime64().astype('datetime64[ns]'),
- tspos.to_datetime64().astype('datetime64[D]')]
-
- for variant in ts_neg_variants:
- with pytest.raises(OverflowError):
- dtimax - variant
-
- expected = pd.Timestamp.max.value - tspos.value
- for variant in ts_pos_variants:
- res = dtimax - variant
- assert res[1].value == expected
-
- expected = pd.Timestamp.min.value - tsneg.value
- for variant in ts_neg_variants:
- res = dtimin - variant
- assert res[1].value == expected
-
- for variant in ts_pos_variants:
- with pytest.raises(OverflowError):
- dtimin - variant
-
- @pytest.mark.parametrize('names', [('foo', None, None),
- ('baz', 'bar', None),
- ('bar', 'bar', 'bar')])
- @pytest.mark.parametrize('tz', [None, 'America/Chicago'])
- def test_dti_add_series(self, tz, names):
- # GH#13905
- index = DatetimeIndex(['2016-06-28 05:30', '2016-06-28 05:31'],
- tz=tz, name=names[0])
- ser = Series([Timedelta(seconds=5)] * 2,
- index=index, name=names[1])
- expected = Series(index + Timedelta(seconds=5),
- index=index, name=names[2])
-
- # passing name arg isn't enough when names[2] is None
- expected.name = names[2]
- assert expected.dtype == index.dtype
- result = ser + index
- tm.assert_series_equal(result, expected)
- result2 = index + ser
- tm.assert_series_equal(result2, expected)
-
- expected = index + Timedelta(seconds=5)
- result3 = ser.values + index
- tm.assert_index_equal(result3, expected)
- result4 = index + ser.values
- tm.assert_index_equal(result4, expected)
-
- def test_dti_add_offset_array(self, tz_naive_fixture):
- # GH#18849
- tz = tz_naive_fixture
- dti = pd.date_range('2017-01-01', periods=2, tz=tz)
- other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res = dti + other
- expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))],
- name=dti.name, freq='infer')
- tm.assert_index_equal(res, expected)
-
- with tm.assert_produces_warning(PerformanceWarning):
- res2 = other + dti
- tm.assert_index_equal(res2, expected)
-
- @pytest.mark.parametrize('names', [(None, None, None),
- ('foo', 'bar', None),
- ('foo', 'foo', 'foo')])
- def test_dti_add_offset_index(self, tz_naive_fixture, names):
- # GH#18849, GH#19744
- tz = tz_naive_fixture
- dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
- other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
- name=names[1])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res = dti + other
- expected = DatetimeIndex([dti[n] + other[n] for n in range(len(dti))],
- name=names[2], freq='infer')
- tm.assert_index_equal(res, expected)
-
- with tm.assert_produces_warning(PerformanceWarning):
- res2 = other + dti
- tm.assert_index_equal(res2, expected)
-
- def test_dti_sub_offset_array(self, tz_naive_fixture):
- # GH#18824
- tz = tz_naive_fixture
- dti = pd.date_range('2017-01-01', periods=2, tz=tz)
- other = np.array([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res = dti - other
- expected = DatetimeIndex([dti[n] - other[n] for n in range(len(dti))],
- name=dti.name, freq='infer')
- tm.assert_index_equal(res, expected)
-
- @pytest.mark.parametrize('names', [(None, None, None),
- ('foo', 'bar', None),
- ('foo', 'foo', 'foo')])
- def test_dti_sub_offset_index(self, tz_naive_fixture, names):
- # GH#18824, GH#19744
- tz = tz_naive_fixture
- dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
- other = pd.Index([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
- name=names[1])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res = dti - other
- expected = DatetimeIndex([dti[n] - other[n] for n in range(len(dti))],
- name=names[2], freq='infer')
- tm.assert_index_equal(res, expected)
-
- @pytest.mark.parametrize('names', [(None, None, None),
- ('foo', 'bar', None),
- ('foo', 'foo', 'foo')])
- def test_dti_with_offset_series(self, tz_naive_fixture, names):
- # GH#18849
- tz = tz_naive_fixture
- dti = pd.date_range('2017-01-01', periods=2, tz=tz, name=names[0])
- other = Series([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)],
- name=names[1])
-
- expected_add = Series([dti[n] + other[n] for n in range(len(dti))],
- name=names[2])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res = dti + other
- tm.assert_series_equal(res, expected_add)
-
- with tm.assert_produces_warning(PerformanceWarning):
- res2 = other + dti
- tm.assert_series_equal(res2, expected_add)
-
- expected_sub = Series([dti[n] - other[n] for n in range(len(dti))],
- name=names[2])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res3 = dti - other
- tm.assert_series_equal(res3, expected_sub)
-
- def test_dti_add_offset_tzaware(self, tz_aware_fixture):
- timezone = tz_aware_fixture
- if timezone == 'US/Pacific':
- dates = date_range('2012-11-01', periods=3, tz=timezone)
- offset = dates + pd.offsets.Hour(5)
- assert dates[0] + pd.offsets.Hour(5) == offset[0]
-
- dates = date_range('2010-11-01 00:00',
- periods=3, tz=timezone, freq='H')
- expected = DatetimeIndex(['2010-11-01 05:00', '2010-11-01 06:00',
- '2010-11-01 07:00'], freq='H', tz=timezone)
-
- offset = dates + pd.offsets.Hour(5)
- tm.assert_index_equal(offset, expected)
- offset = dates + np.timedelta64(5, 'h')
- tm.assert_index_equal(offset, expected)
- offset = dates + timedelta(hours=5)
- tm.assert_index_equal(offset, expected)
-
-
-@pytest.mark.parametrize('klass,assert_func', [
- (Series, tm.assert_series_equal),
- (DatetimeIndex, tm.assert_index_equal)])
-def test_dt64_with_offset_array(klass, assert_func):
- # GH#10699
- # array of offsets
- box = Series if klass is Series else pd.Index
- with tm.assert_produces_warning(PerformanceWarning):
- s = klass([Timestamp('2000-1-1'), Timestamp('2000-2-1')])
- result = s + box([pd.offsets.DateOffset(years=1),
- pd.offsets.MonthEnd()])
- exp = klass([Timestamp('2001-1-1'), Timestamp('2000-2-29')])
- assert_func(result, exp)
-
- # same offset
- result = s + box([pd.offsets.DateOffset(years=1),
- pd.offsets.DateOffset(years=1)])
- exp = klass([Timestamp('2001-1-1'), Timestamp('2001-2-1')])
- assert_func(result, exp)
-
-
-@pytest.mark.parametrize('klass,assert_func', [
- (Series, tm.assert_series_equal),
- (DatetimeIndex, tm.assert_index_equal)])
-def test_dt64_with_DateOffsets_relativedelta(klass, assert_func):
- # GH#10699
- vec = klass([Timestamp('2000-01-05 00:15:00'),
- Timestamp('2000-01-31 00:23:00'),
- Timestamp('2000-01-01'),
- Timestamp('2000-03-31'),
- Timestamp('2000-02-29'),
- Timestamp('2000-12-31'),
- Timestamp('2000-05-15'),
- Timestamp('2001-06-15')])
-
- # DateOffset relativedelta fastpath
- relative_kwargs = [('years', 2), ('months', 5), ('days', 3),
- ('hours', 5), ('minutes', 10), ('seconds', 2),
- ('microseconds', 5)]
- for i, kwd in enumerate(relative_kwargs):
- op = pd.DateOffset(**dict([kwd]))
- assert_func(klass([x + op for x in vec]), vec + op)
- assert_func(klass([x - op for x in vec]), vec - op)
- op = pd.DateOffset(**dict(relative_kwargs[:i + 1]))
- assert_func(klass([x + op for x in vec]), vec + op)
- assert_func(klass([x - op for x in vec]), vec - op)
-
-
-@pytest.mark.parametrize('cls_and_kwargs', [
- 'YearBegin', ('YearBegin', {'month': 5}),
- 'YearEnd', ('YearEnd', {'month': 5}),
- 'MonthBegin', 'MonthEnd',
- 'SemiMonthEnd', 'SemiMonthBegin',
- 'Week', ('Week', {'weekday': 3}),
- 'BusinessDay', 'BDay', 'QuarterEnd', 'QuarterBegin',
- 'CustomBusinessDay', 'CDay', 'CBMonthEnd',
- 'CBMonthBegin', 'BMonthBegin', 'BMonthEnd',
- 'BusinessHour', 'BYearBegin', 'BYearEnd',
- 'BQuarterBegin', ('LastWeekOfMonth', {'weekday': 2}),
- ('FY5253Quarter', {'qtr_with_extra_week': 1,
- 'startingMonth': 1,
- 'weekday': 2,
- 'variation': 'nearest'}),
- ('FY5253', {'weekday': 0, 'startingMonth': 2, 'variation': 'nearest'}),
- ('WeekOfMonth', {'weekday': 2, 'week': 2}),
- 'Easter', ('DateOffset', {'day': 4}),
- ('DateOffset', {'month': 5})])
-@pytest.mark.parametrize('normalize', [True, False])
-@pytest.mark.parametrize('klass,assert_func', [
- (Series, tm.assert_series_equal),
- (DatetimeIndex, tm.assert_index_equal)])
-def test_dt64_with_DateOffsets(klass, assert_func, normalize, cls_and_kwargs):
- # GH#10699
- # assert these are equal on a piecewise basis
- vec = klass([Timestamp('2000-01-05 00:15:00'),
- Timestamp('2000-01-31 00:23:00'),
- Timestamp('2000-01-01'),
- Timestamp('2000-03-31'),
- Timestamp('2000-02-29'),
- Timestamp('2000-12-31'),
- Timestamp('2000-05-15'),
- Timestamp('2001-06-15')])
-
- if isinstance(cls_and_kwargs, tuple):
- # If cls_name param is a tuple, then 2nd entry is kwargs for
- # the offset constructor
- cls_name, kwargs = cls_and_kwargs
- else:
- cls_name = cls_and_kwargs
- kwargs = {}
-
- offset_cls = getattr(pd.offsets, cls_name)
-
- with warnings.catch_warnings(record=True):
- for n in [0, 5]:
- if (cls_name in ['WeekOfMonth', 'LastWeekOfMonth',
- 'FY5253Quarter', 'FY5253'] and n == 0):
- # passing n = 0 is invalid for these offset classes
- continue
-
- offset = offset_cls(n, normalize=normalize, **kwargs)
- assert_func(klass([x + offset for x in vec]), vec + offset)
- assert_func(klass([x - offset for x in vec]), vec - offset)
- assert_func(klass([offset + x for x in vec]), offset + vec)
-
-
-# GH 10699
-@pytest.mark.parametrize('klass,assert_func', zip([Series, DatetimeIndex],
- [tm.assert_series_equal,
- tm.assert_index_equal]))
-def test_datetime64_with_DateOffset(klass, assert_func):
- s = klass(date_range('2000-01-01', '2000-01-31'), name='a')
- result = s + pd.DateOffset(years=1)
- result2 = pd.DateOffset(years=1) + s
- exp = klass(date_range('2001-01-01', '2001-01-31'), name='a')
- assert_func(result, exp)
- assert_func(result2, exp)
-
- result = s - pd.DateOffset(years=1)
- exp = klass(date_range('1999-01-01', '1999-01-31'), name='a')
- assert_func(result, exp)
-
- s = klass([Timestamp('2000-01-15 00:15:00', tz='US/Central'),
- pd.Timestamp('2000-02-15', tz='US/Central')], name='a')
- result = s + pd.offsets.Day()
- result2 = pd.offsets.Day() + s
- exp = klass([Timestamp('2000-01-16 00:15:00', tz='US/Central'),
- Timestamp('2000-02-16', tz='US/Central')], name='a')
- assert_func(result, exp)
- assert_func(result2, exp)
-
- s = klass([Timestamp('2000-01-15 00:15:00', tz='US/Central'),
- pd.Timestamp('2000-02-15', tz='US/Central')], name='a')
- result = s + pd.offsets.MonthEnd()
- result2 = pd.offsets.MonthEnd() + s
- exp = klass([Timestamp('2000-01-31 00:15:00', tz='US/Central'),
- Timestamp('2000-02-29', tz='US/Central')], name='a')
- assert_func(result, exp)
- assert_func(result2, exp)
-
-
-@pytest.mark.parametrize('years', [-1, 0, 1])
-@pytest.mark.parametrize('months', [-2, 0, 2])
-def test_shift_months(years, months):
- s = DatetimeIndex([Timestamp('2000-01-05 00:15:00'),
- Timestamp('2000-01-31 00:23:00'),
- Timestamp('2000-01-01'),
- Timestamp('2000-02-29'),
- Timestamp('2000-12-31')])
- actual = DatetimeIndex(shift_months(s.asi8, years * 12 + months))
-
- raw = [x + pd.offsets.DateOffset(years=years, months=months)
- for x in s]
- expected = DatetimeIndex(raw)
- tm.assert_index_equal(actual, expected)
diff --git a/pandas/tests/indexes/period/test_arithmetic.py b/pandas/tests/indexes/period/test_arithmetic.py
index d7dbb1423a9a3..3380a1ebc58dc 100644
--- a/pandas/tests/indexes/period/test_arithmetic.py
+++ b/pandas/tests/indexes/period/test_arithmetic.py
@@ -1,645 +1,14 @@
# -*- coding: utf-8 -*-
-from datetime import timedelta
-import operator
import pytest
import numpy as np
import pandas as pd
import pandas.util.testing as tm
-from pandas import (Timedelta,
- period_range, Period, PeriodIndex,
- _np_version_under1p10)
-import pandas.core.indexes.period as period
-from pandas.core import ops
-from pandas.errors import PerformanceWarning
-
-
-_common_mismatch = [pd.offsets.YearBegin(2),
- pd.offsets.MonthBegin(1),
- pd.offsets.Minute()]
-
-
-@pytest.fixture(params=[timedelta(minutes=30),
- np.timedelta64(30, 's'),
- Timedelta(seconds=30)] + _common_mismatch)
-def not_hourly(request):
- """
- Several timedelta-like and DateOffset instances that are _not_
- compatible with Hourly frequencies.
- """
- return request.param
-
-
-@pytest.fixture(params=[np.timedelta64(4, 'h'),
- timedelta(hours=23),
- Timedelta('23:00:00')] + _common_mismatch)
-def not_daily(request):
- """
- Several timedelta-like and DateOffset instances that are _not_
- compatible with Daily frequencies.
- """
- return request.param
-
-
-@pytest.fixture(params=[np.timedelta64(365, 'D'),
- timedelta(365),
- Timedelta(days=365)] + _common_mismatch)
-def mismatched(request):
- """
- Several timedelta-like and DateOffset instances that are _not_
- compatible with Monthly or Annual frequencies.
- """
- return request.param
-
-
-@pytest.fixture(params=[pd.offsets.Day(3),
- timedelta(days=3),
- np.timedelta64(3, 'D'),
- pd.offsets.Hour(72),
- timedelta(minutes=60 * 24 * 3),
- np.timedelta64(72, 'h'),
- Timedelta('72:00:00')])
-def three_days(request):
- """
- Several timedelta-like and DateOffset objects that each represent
- a 3-day timedelta
- """
- return request.param
-
-
-@pytest.fixture(params=[pd.offsets.Hour(2),
- timedelta(hours=2),
- np.timedelta64(2, 'h'),
- pd.offsets.Minute(120),
- timedelta(minutes=120),
- np.timedelta64(120, 'm')])
-def two_hours(request):
- """
- Several timedelta-like and DateOffset objects that each represent
- a 2-hour timedelta
- """
- return request.param
-
-
-class TestPeriodIndexComparisons(object):
- def test_pi_cmp_period(self):
- idx = period_range('2007-01', periods=20, freq='M')
-
- result = idx < idx[10]
- exp = idx.values < idx.values[10]
- tm.assert_numpy_array_equal(result, exp)
-
- @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
- def test_pi_cmp_pi(self, freq):
- base = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
- freq=freq)
- per = Period('2011-02', freq=freq)
-
- exp = np.array([False, True, False, False])
- tm.assert_numpy_array_equal(base == per, exp)
- tm.assert_numpy_array_equal(per == base, exp)
-
- exp = np.array([True, False, True, True])
- tm.assert_numpy_array_equal(base != per, exp)
- tm.assert_numpy_array_equal(per != base, exp)
-
- exp = np.array([False, False, True, True])
- tm.assert_numpy_array_equal(base > per, exp)
- tm.assert_numpy_array_equal(per < base, exp)
-
- exp = np.array([True, False, False, False])
- tm.assert_numpy_array_equal(base < per, exp)
- tm.assert_numpy_array_equal(per > base, exp)
-
- exp = np.array([False, True, True, True])
- tm.assert_numpy_array_equal(base >= per, exp)
- tm.assert_numpy_array_equal(per <= base, exp)
-
- exp = np.array([True, True, False, False])
- tm.assert_numpy_array_equal(base <= per, exp)
- tm.assert_numpy_array_equal(per >= base, exp)
-
- idx = PeriodIndex(['2011-02', '2011-01', '2011-03', '2011-05'],
- freq=freq)
-
- exp = np.array([False, False, True, False])
- tm.assert_numpy_array_equal(base == idx, exp)
-
- exp = np.array([True, True, False, True])
- tm.assert_numpy_array_equal(base != idx, exp)
-
- exp = np.array([False, True, False, False])
- tm.assert_numpy_array_equal(base > idx, exp)
-
- exp = np.array([True, False, False, True])
- tm.assert_numpy_array_equal(base < idx, exp)
-
- exp = np.array([False, True, True, False])
- tm.assert_numpy_array_equal(base >= idx, exp)
-
- exp = np.array([True, False, True, True])
- tm.assert_numpy_array_equal(base <= idx, exp)
-
- @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
- def test_pi_cmp_pi_mismatched_freq_raises(self, freq):
- # different base freq
- base = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
- freq=freq)
-
- msg = "Input has different freq=A-DEC from PeriodIndex"
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- base <= Period('2011', freq='A')
-
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- Period('2011', freq='A') >= base
-
- idx = PeriodIndex(['2011', '2012', '2013', '2014'], freq='A')
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- base <= idx
-
- # Different frequency
- msg = "Input has different freq=4M from PeriodIndex"
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- base <= Period('2011', freq='4M')
-
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- Period('2011', freq='4M') >= base
-
- idx = PeriodIndex(['2011', '2012', '2013', '2014'], freq='4M')
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- base <= idx
-
- @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
- def test_pi_cmp_nat(self, freq):
- idx1 = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-05'], freq=freq)
-
- result = idx1 > Period('2011-02', freq=freq)
- exp = np.array([False, False, False, True])
- tm.assert_numpy_array_equal(result, exp)
- result = Period('2011-02', freq=freq) < idx1
- tm.assert_numpy_array_equal(result, exp)
-
- result = idx1 == Period('NaT', freq=freq)
- exp = np.array([False, False, False, False])
- tm.assert_numpy_array_equal(result, exp)
- result = Period('NaT', freq=freq) == idx1
- tm.assert_numpy_array_equal(result, exp)
-
- result = idx1 != Period('NaT', freq=freq)
- exp = np.array([True, True, True, True])
- tm.assert_numpy_array_equal(result, exp)
- result = Period('NaT', freq=freq) != idx1
- tm.assert_numpy_array_equal(result, exp)
-
- idx2 = PeriodIndex(['2011-02', '2011-01', '2011-04', 'NaT'], freq=freq)
- result = idx1 < idx2
- exp = np.array([True, False, False, False])
- tm.assert_numpy_array_equal(result, exp)
-
- result = idx1 == idx2
- exp = np.array([False, False, False, False])
- tm.assert_numpy_array_equal(result, exp)
-
- result = idx1 != idx2
- exp = np.array([True, True, True, True])
- tm.assert_numpy_array_equal(result, exp)
-
- result = idx1 == idx1
- exp = np.array([True, True, False, True])
- tm.assert_numpy_array_equal(result, exp)
-
- result = idx1 != idx1
- exp = np.array([False, False, True, False])
- tm.assert_numpy_array_equal(result, exp)
-
- @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
- def test_pi_cmp_nat_mismatched_freq_raises(self, freq):
- idx1 = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-05'], freq=freq)
-
- diff = PeriodIndex(['2011-02', '2011-01', '2011-04', 'NaT'], freq='4M')
- msg = "Input has different freq=4M from PeriodIndex"
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- idx1 > diff
-
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- idx1 == diff
-
- # TODO: De-duplicate with test_pi_cmp_nat
- @pytest.mark.parametrize('dtype', [object, None])
- def test_comp_nat(self, dtype):
- left = pd.PeriodIndex([pd.Period('2011-01-01'), pd.NaT,
- pd.Period('2011-01-03')])
- right = pd.PeriodIndex([pd.NaT, pd.NaT, pd.Period('2011-01-03')])
-
- if dtype is not None:
- left = left.astype(dtype)
- right = right.astype(dtype)
-
- result = left == right
- expected = np.array([False, False, True])
- tm.assert_numpy_array_equal(result, expected)
-
- result = left != right
- expected = np.array([True, True, False])
- tm.assert_numpy_array_equal(result, expected)
-
- expected = np.array([False, False, False])
- tm.assert_numpy_array_equal(left == pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT == right, expected)
-
- expected = np.array([True, True, True])
- tm.assert_numpy_array_equal(left != pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT != left, expected)
-
- expected = np.array([False, False, False])
- tm.assert_numpy_array_equal(left < pd.NaT, expected)
- tm.assert_numpy_array_equal(pd.NaT > left, expected)
+from pandas import PeriodIndex
class TestPeriodIndexArithmetic(object):
- # ---------------------------------------------------------------
- # __add__/__sub__ with PeriodIndex
- # PeriodIndex + other is defined for integers and timedelta-like others
- # PeriodIndex - other is defined for integers, timedelta-like others,
- # and PeriodIndex (with matching freq)
-
- def test_pi_add_iadd_pi_raises(self):
- rng = pd.period_range('1/1/2000', freq='D', periods=5)
- other = pd.period_range('1/6/2000', freq='D', periods=5)
-
- # An earlier implementation of PeriodIndex addition performed
- # a set operation (union). This has since been changed to
- # raise a TypeError. See GH#14164 and GH#13077 for historical
- # reference.
- with pytest.raises(TypeError):
- rng + other
-
- with pytest.raises(TypeError):
- rng += other
-
- def test_pi_sub_isub_pi(self):
- # GH#20049
- # For historical reference see GH#14164, GH#13077.
- # PeriodIndex subtraction originally performed set difference,
- # then changed to raise TypeError before being implemented in GH#20049
- rng = pd.period_range('1/1/2000', freq='D', periods=5)
- other = pd.period_range('1/6/2000', freq='D', periods=5)
-
- off = rng.freq
- expected = pd.Index([-5 * off] * 5)
- result = rng - other
- tm.assert_index_equal(result, expected)
-
- rng -= other
- tm.assert_index_equal(rng, expected)
-
- def test_pi_sub_pi_with_nat(self):
- rng = pd.period_range('1/1/2000', freq='D', periods=5)
- other = rng[1:].insert(0, pd.NaT)
- assert other[1:].equals(rng[1:])
-
- result = rng - other
- off = rng.freq
- expected = pd.Index([pd.NaT, 0 * off, 0 * off, 0 * off, 0 * off])
- tm.assert_index_equal(result, expected)
-
- def test_pi_sub_pi_mismatched_freq(self):
- rng = pd.period_range('1/1/2000', freq='D', periods=5)
- other = pd.period_range('1/6/2000', freq='H', periods=5)
- with pytest.raises(period.IncompatibleFrequency):
- rng - other
-
- # -------------------------------------------------------------
- # Invalid Operations
-
- @pytest.mark.parametrize('other', [3.14, np.array([2.0, 3.0])])
- @pytest.mark.parametrize('op', [operator.add, ops.radd,
- operator.sub, ops.rsub])
- def test_pi_add_sub_float(self, op, other):
- dti = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D')
- pi = dti.to_period('D')
- with pytest.raises(TypeError):
- op(pi, other)
-
- # -----------------------------------------------------------------
- # __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
-
- def test_pi_add_sub_dt64_array_raises(self):
- rng = pd.period_range('1/1/2000', freq='D', periods=3)
- dti = pd.date_range('2016-01-01', periods=3)
- dtarr = dti.values
-
- with pytest.raises(TypeError):
- rng + dtarr
- with pytest.raises(TypeError):
- dtarr + rng
-
- with pytest.raises(TypeError):
- rng - dtarr
- with pytest.raises(TypeError):
- dtarr - rng
-
- def test_pi_add_sub_td64_array_non_tick_raises(self):
- rng = pd.period_range('1/1/2000', freq='Q', periods=3)
- dti = pd.date_range('2016-01-01', periods=3)
- tdi = dti - dti.shift(1)
- tdarr = tdi.values
-
- with pytest.raises(period.IncompatibleFrequency):
- rng + tdarr
- with pytest.raises(period.IncompatibleFrequency):
- tdarr + rng
-
- with pytest.raises(period.IncompatibleFrequency):
- rng - tdarr
- with pytest.raises(period.IncompatibleFrequency):
- tdarr - rng
-
- @pytest.mark.xfail(reason='op with TimedeltaIndex raises, with ndarray OK',
- strict=True)
- def test_pi_add_sub_td64_array_tick(self):
- rng = pd.period_range('1/1/2000', freq='Q', periods=3)
- dti = pd.date_range('2016-01-01', periods=3)
- tdi = dti - dti.shift(1)
- tdarr = tdi.values
-
- expected = rng + tdi
- result = rng + tdarr
- tm.assert_index_equal(result, expected)
- result = tdarr + rng
- tm.assert_index_equal(result, expected)
-
- expected = rng - tdi
- result = rng - tdarr
- tm.assert_index_equal(result, expected)
-
- with pytest.raises(TypeError):
- tdarr - rng
-
- # -----------------------------------------------------------------
- # operations with array/Index of DateOffset objects
-
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_pi_add_offset_array(self, box):
- # GH#18849
- pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
- offs = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
- pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
- expected = pd.PeriodIndex([pd.Period('2015Q2'), pd.Period('2015Q4')])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res = pi + offs
- tm.assert_index_equal(res, expected)
-
- with tm.assert_produces_warning(PerformanceWarning):
- res2 = offs + pi
- tm.assert_index_equal(res2, expected)
-
- unanchored = np.array([pd.offsets.Hour(n=1),
- pd.offsets.Minute(n=-2)])
- # addition/subtraction ops with incompatible offsets should issue
- # a PerformanceWarning and _then_ raise a TypeError.
- with pytest.raises(period.IncompatibleFrequency):
- with tm.assert_produces_warning(PerformanceWarning):
- pi + unanchored
- with pytest.raises(period.IncompatibleFrequency):
- with tm.assert_produces_warning(PerformanceWarning):
- unanchored + pi
-
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_pi_sub_offset_array(self, box):
- # GH#18824
- pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
- other = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
- pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
-
- expected = PeriodIndex([pi[n] - other[n] for n in range(len(pi))])
-
- with tm.assert_produces_warning(PerformanceWarning):
- res = pi - other
- tm.assert_index_equal(res, expected)
-
- anchored = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
-
- # addition/subtraction ops with anchored offsets should issue
- # a PerformanceWarning and _then_ raise a TypeError.
- with pytest.raises(period.IncompatibleFrequency):
- with tm.assert_produces_warning(PerformanceWarning):
- pi - anchored
- with pytest.raises(period.IncompatibleFrequency):
- with tm.assert_produces_warning(PerformanceWarning):
- anchored - pi
-
- def test_pi_add_iadd_int(self, one):
- # Variants of `one` for #19012
- rng = pd.period_range('2000-01-01 09:00', freq='H', periods=10)
- result = rng + one
- expected = pd.period_range('2000-01-01 10:00', freq='H', periods=10)
- tm.assert_index_equal(result, expected)
- rng += one
- tm.assert_index_equal(rng, expected)
-
- def test_pi_sub_isub_int(self, one):
- """
- PeriodIndex.__sub__ and __isub__ with several representations of
- the integer 1, e.g. int, long, np.int64, np.uint8, ...
- """
- rng = pd.period_range('2000-01-01 09:00', freq='H', periods=10)
- result = rng - one
- expected = pd.period_range('2000-01-01 08:00', freq='H', periods=10)
- tm.assert_index_equal(result, expected)
- rng -= one
- tm.assert_index_equal(rng, expected)
-
- @pytest.mark.parametrize('five', [5, np.array(5, dtype=np.int64)])
- def test_pi_sub_intlike(self, five):
- rng = period_range('2007-01', periods=50)
-
- result = rng - five
- exp = rng + (-five)
- tm.assert_index_equal(result, exp)
-
- def test_pi_sub_isub_offset(self):
- # offset
- # DateOffset
- rng = pd.period_range('2014', '2024', freq='A')
- result = rng - pd.offsets.YearEnd(5)
- expected = pd.period_range('2009', '2019', freq='A')
- tm.assert_index_equal(result, expected)
- rng -= pd.offsets.YearEnd(5)
- tm.assert_index_equal(rng, expected)
-
- rng = pd.period_range('2014-01', '2016-12', freq='M')
- result = rng - pd.offsets.MonthEnd(5)
- expected = pd.period_range('2013-08', '2016-07', freq='M')
- tm.assert_index_equal(result, expected)
-
- rng -= pd.offsets.MonthEnd(5)
- tm.assert_index_equal(rng, expected)
-
- # ---------------------------------------------------------------
- # __add__/__sub__ with integer arrays
-
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- @pytest.mark.parametrize('op', [operator.add, ops.radd])
- def test_pi_add_intarray(self, box, op):
- # GH#19959
- pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('NaT')])
- other = box([4, -1])
- result = op(pi, other)
- expected = pd.PeriodIndex([pd.Period('2016Q1'), pd.Period('NaT')])
- tm.assert_index_equal(result, expected)
-
- @pytest.mark.parametrize('box', [np.array, pd.Index])
- def test_pi_sub_intarray(self, box):
- # GH#19959
- pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('NaT')])
- other = box([4, -1])
- result = pi - other
- expected = pd.PeriodIndex([pd.Period('2014Q1'), pd.Period('NaT')])
- tm.assert_index_equal(result, expected)
-
- with pytest.raises(TypeError):
- other - pi
-
- # ---------------------------------------------------------------
- # Timedelta-like (timedelta, timedelta64, Timedelta, Tick)
- # TODO: Some of these are misnomers because of non-Tick DateOffsets
-
- def test_pi_add_iadd_timedeltalike_daily(self, three_days):
- # Tick
- other = three_days
- rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
- expected = pd.period_range('2014-05-04', '2014-05-18', freq='D')
-
- result = rng + other
- tm.assert_index_equal(result, expected)
-
- rng += other
- tm.assert_index_equal(rng, expected)
-
- def test_pi_sub_isub_timedeltalike_daily(self, three_days):
- # Tick-like 3 Days
- other = three_days
- rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
- expected = pd.period_range('2014-04-28', '2014-05-12', freq='D')
-
- result = rng - other
- tm.assert_index_equal(result, expected)
-
- rng -= other
- tm.assert_index_equal(rng, expected)
-
- def test_pi_add_iadd_timedeltalike_freq_mismatch_daily(self, not_daily):
- other = not_daily
- rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
- msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng + other
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng += other
-
- def test_pi_sub_timedeltalike_freq_mismatch_daily(self, not_daily):
- other = not_daily
- rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
- msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng - other
-
- def test_pi_add_iadd_timedeltalike_hourly(self, two_hours):
- other = two_hours
- rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
- expected = pd.period_range('2014-01-01 12:00', '2014-01-05 12:00',
- freq='H')
-
- result = rng + other
- tm.assert_index_equal(result, expected)
-
- rng += other
- tm.assert_index_equal(rng, expected)
-
- def test_pi_add_timedeltalike_mismatched_freq_hourly(self, not_hourly):
- other = not_hourly
- rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
- msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=H\\)'
-
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng + other
-
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng += other
-
- def test_pi_sub_isub_timedeltalike_hourly(self, two_hours):
- other = two_hours
- rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
- expected = pd.period_range('2014-01-01 08:00', '2014-01-05 08:00',
- freq='H')
-
- result = rng - other
- tm.assert_index_equal(result, expected)
-
- rng -= other
- tm.assert_index_equal(rng, expected)
-
- def test_add_iadd_timedeltalike_annual(self):
- # offset
- # DateOffset
- rng = pd.period_range('2014', '2024', freq='A')
- result = rng + pd.offsets.YearEnd(5)
- expected = pd.period_range('2019', '2029', freq='A')
- tm.assert_index_equal(result, expected)
- rng += pd.offsets.YearEnd(5)
- tm.assert_index_equal(rng, expected)
-
- def test_pi_add_iadd_timedeltalike_freq_mismatch_annual(self, mismatched):
- other = mismatched
- rng = pd.period_range('2014', '2024', freq='A')
- msg = ('Input has different freq(=.+)? '
- 'from PeriodIndex\\(freq=A-DEC\\)')
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng + other
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng += other
-
- def test_pi_sub_isub_timedeltalike_freq_mismatch_annual(self, mismatched):
- other = mismatched
- rng = pd.period_range('2014', '2024', freq='A')
- msg = ('Input has different freq(=.+)? '
- 'from PeriodIndex\\(freq=A-DEC\\)')
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng - other
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng -= other
-
- def test_pi_add_iadd_timedeltalike_M(self):
- rng = pd.period_range('2014-01', '2016-12', freq='M')
- expected = pd.period_range('2014-06', '2017-05', freq='M')
-
- result = rng + pd.offsets.MonthEnd(5)
- tm.assert_index_equal(result, expected)
-
- rng += pd.offsets.MonthEnd(5)
- tm.assert_index_equal(rng, expected)
-
- def test_pi_add_iadd_timedeltalike_freq_mismatch_monthly(self, mismatched):
- other = mismatched
- rng = pd.period_range('2014-01', '2016-12', freq='M')
- msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng + other
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng += other
-
- def test_pi_sub_isub_timedeltalike_freq_mismatch_monthly(self, mismatched):
- other = mismatched
- rng = pd.period_range('2014-01', '2016-12', freq='M')
- msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng - other
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- rng -= other
-
# ---------------------------------------------------------------
# PeriodIndex.shift is used by __add__ and __sub__
@@ -728,215 +97,3 @@ def test_shift_gh8083(self):
expected = PeriodIndex(['2013-01-02', '2013-01-03', '2013-01-04',
'2013-01-05', '2013-01-06'], freq='D')
tm.assert_index_equal(result, expected)
-
-
-class TestPeriodIndexSeriesMethods(object):
- """ Test PeriodIndex and Period Series Ops consistency """
-
- def _check(self, values, func, expected):
- idx = pd.PeriodIndex(values)
- result = func(idx)
- if isinstance(expected, pd.Index):
- tm.assert_index_equal(result, expected)
- else:
- # comp op results in bool
- tm.assert_numpy_array_equal(result, expected)
-
- ser = pd.Series(values)
- result = func(ser)
-
- exp = pd.Series(expected, name=values.name)
- tm.assert_series_equal(result, exp)
-
- def test_pi_ops(self):
- idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
- freq='M', name='idx')
-
- expected = PeriodIndex(['2011-03', '2011-04', '2011-05', '2011-06'],
- freq='M', name='idx')
- self._check(idx, lambda x: x + 2, expected)
- self._check(idx, lambda x: 2 + x, expected)
-
- self._check(idx + 2, lambda x: x - 2, idx)
- result = idx - Period('2011-01', freq='M')
- off = idx.freq
- exp = pd.Index([0 * off, 1 * off, 2 * off, 3 * off], name='idx')
- tm.assert_index_equal(result, exp)
-
- result = Period('2011-01', freq='M') - idx
- exp = pd.Index([0 * off, -1 * off, -2 * off, -3 * off], name='idx')
- tm.assert_index_equal(result, exp)
-
- @pytest.mark.parametrize('ng', ["str", 1.5])
- def test_pi_ops_errors(self, ng):
- idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
- freq='M', name='idx')
- ser = pd.Series(idx)
-
- msg = r"unsupported operand type\(s\)"
-
- for obj in [idx, ser]:
- with tm.assert_raises_regex(TypeError, msg):
- obj + ng
-
- with pytest.raises(TypeError):
- # error message differs between PY2 and 3
- ng + obj
-
- with tm.assert_raises_regex(TypeError, msg):
- obj - ng
-
- with pytest.raises(TypeError):
- np.add(obj, ng)
-
- if _np_version_under1p10:
- assert np.add(ng, obj) is NotImplemented
- else:
- with pytest.raises(TypeError):
- np.add(ng, obj)
-
- with pytest.raises(TypeError):
- np.subtract(obj, ng)
-
- if _np_version_under1p10:
- assert np.subtract(ng, obj) is NotImplemented
- else:
- with pytest.raises(TypeError):
- np.subtract(ng, obj)
-
- def test_pi_ops_nat(self):
- idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
- freq='M', name='idx')
- expected = PeriodIndex(['2011-03', '2011-04', 'NaT', '2011-06'],
- freq='M', name='idx')
- self._check(idx, lambda x: x + 2, expected)
- self._check(idx, lambda x: 2 + x, expected)
- self._check(idx, lambda x: np.add(x, 2), expected)
-
- self._check(idx + 2, lambda x: x - 2, idx)
- self._check(idx + 2, lambda x: np.subtract(x, 2), idx)
-
- # freq with mult
- idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
- freq='2M', name='idx')
- expected = PeriodIndex(['2011-07', '2011-08', 'NaT', '2011-10'],
- freq='2M', name='idx')
- self._check(idx, lambda x: x + 3, expected)
- self._check(idx, lambda x: 3 + x, expected)
- self._check(idx, lambda x: np.add(x, 3), expected)
-
- self._check(idx + 3, lambda x: x - 3, idx)
- self._check(idx + 3, lambda x: np.subtract(x, 3), idx)
-
- def test_pi_ops_array_int(self):
- idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
- freq='M', name='idx')
- f = lambda x: x + np.array([1, 2, 3, 4])
- exp = PeriodIndex(['2011-02', '2011-04', 'NaT', '2011-08'],
- freq='M', name='idx')
- self._check(idx, f, exp)
-
- f = lambda x: np.add(x, np.array([4, -1, 1, 2]))
- exp = PeriodIndex(['2011-05', '2011-01', 'NaT', '2011-06'],
- freq='M', name='idx')
- self._check(idx, f, exp)
-
- f = lambda x: x - np.array([1, 2, 3, 4])
- exp = PeriodIndex(['2010-12', '2010-12', 'NaT', '2010-12'],
- freq='M', name='idx')
- self._check(idx, f, exp)
-
- f = lambda x: np.subtract(x, np.array([3, 2, 3, -2]))
- exp = PeriodIndex(['2010-10', '2010-12', 'NaT', '2011-06'],
- freq='M', name='idx')
- self._check(idx, f, exp)
-
- def test_pi_ops_offset(self):
- idx = PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01',
- '2011-04-01'], freq='D', name='idx')
- f = lambda x: x + pd.offsets.Day()
- exp = PeriodIndex(['2011-01-02', '2011-02-02', '2011-03-02',
- '2011-04-02'], freq='D', name='idx')
- self._check(idx, f, exp)
-
- f = lambda x: x + pd.offsets.Day(2)
- exp = PeriodIndex(['2011-01-03', '2011-02-03', '2011-03-03',
- '2011-04-03'], freq='D', name='idx')
- self._check(idx, f, exp)
-
- f = lambda x: x - pd.offsets.Day(2)
- exp = PeriodIndex(['2010-12-30', '2011-01-30', '2011-02-27',
- '2011-03-30'], freq='D', name='idx')
- self._check(idx, f, exp)
-
- def test_pi_offset_errors(self):
- idx = PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01',
- '2011-04-01'], freq='D', name='idx')
- ser = pd.Series(idx)
-
- # Series op is applied per Period instance, thus error is raised
- # from Period
- msg_idx = r"Input has different freq from PeriodIndex\(freq=D\)"
- msg_s = r"Input cannot be converted to Period\(freq=D\)"
- for obj, msg in [(idx, msg_idx), (ser, msg_s)]:
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- obj + pd.offsets.Hour(2)
-
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- pd.offsets.Hour(2) + obj
-
- with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
- obj - pd.offsets.Hour(2)
-
- def test_pi_sub_period(self):
- # GH 13071
- idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
- freq='M', name='idx')
-
- result = idx - pd.Period('2012-01', freq='M')
- off = idx.freq
- exp = pd.Index([-12 * off, -11 * off, -10 * off, -9 * off], name='idx')
- tm.assert_index_equal(result, exp)
-
- result = np.subtract(idx, pd.Period('2012-01', freq='M'))
- tm.assert_index_equal(result, exp)
-
- result = pd.Period('2012-01', freq='M') - idx
- exp = pd.Index([12 * off, 11 * off, 10 * off, 9 * off], name='idx')
- tm.assert_index_equal(result, exp)
-
- result = np.subtract(pd.Period('2012-01', freq='M'), idx)
- if _np_version_under1p10:
- assert result is NotImplemented
- else:
- tm.assert_index_equal(result, exp)
-
- exp = pd.TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name='idx')
- tm.assert_index_equal(idx - pd.Period('NaT', freq='M'), exp)
- tm.assert_index_equal(pd.Period('NaT', freq='M') - idx, exp)
-
- def test_pi_sub_pdnat(self):
- # GH 13071
- idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
- freq='M', name='idx')
- exp = pd.TimedeltaIndex([pd.NaT] * 4, name='idx')
- tm.assert_index_equal(pd.NaT - idx, exp)
- tm.assert_index_equal(idx - pd.NaT, exp)
-
- def test_pi_sub_period_nat(self):
- # GH 13071
- idx = PeriodIndex(['2011-01', 'NaT', '2011-03', '2011-04'],
- freq='M', name='idx')
-
- result = idx - pd.Period('2012-01', freq='M')
- off = idx.freq
- exp = pd.Index([-12 * off, pd.NaT, -10 * off, -9 * off], name='idx')
- tm.assert_index_equal(result, exp)
-
- result = pd.Period('2012-01', freq='M') - idx
- exp = pd.Index([12 * off, pd.NaT, 10 * off, 9 * off], name='idx')
- tm.assert_index_equal(result, exp)
-
- exp = pd.TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name='idx')
- tm.assert_index_equal(idx - pd.Period('NaT', freq='M'), exp)
- tm.assert_index_equal(pd.Period('NaT', freq='M') - idx, exp)
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 1413e01000ec5..9ec9cbd8e1b89 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -1,13 +1,12 @@
# -*- coding: utf-8 -*-
-from datetime import datetime, timedelta
+from datetime import timedelta
import operator
from decimal import Decimal
import numpy as np
import pytest
-from pandas import Series, Timestamp, Period
-from pandas._libs.tslibs.period import IncompatibleFrequency
+from pandas import Series, Timestamp
import pandas as pd
import pandas.util.testing as tm
@@ -79,132 +78,6 @@ def test_ser_cmp_result_names(self, names, op):
assert result.name == names[2]
-class TestTimestampSeriesComparison(object):
- def test_dt64_ser_cmp_date_warning(self):
- # https://github.com/pandas-dev/pandas/issues/21359
- # Remove this test and enble invalid test below
- ser = pd.Series(pd.date_range('20010101', periods=10), name='dates')
- date = ser.iloc[0].to_pydatetime().date()
-
- with tm.assert_produces_warning(FutureWarning) as m:
- result = ser == date
- expected = pd.Series([True] + [False] * 9, name='dates')
- tm.assert_series_equal(result, expected)
- assert "Comparing Series of datetimes " in str(m[0].message)
- assert "will not compare equal" in str(m[0].message)
-
- with tm.assert_produces_warning(FutureWarning) as m:
- result = ser != date
- tm.assert_series_equal(result, ~expected)
- assert "will not compare equal" in str(m[0].message)
-
- with tm.assert_produces_warning(FutureWarning) as m:
- result = ser <= date
- tm.assert_series_equal(result, expected)
- assert "a TypeError will be raised" in str(m[0].message)
-
- with tm.assert_produces_warning(FutureWarning) as m:
- result = ser < date
- tm.assert_series_equal(result, pd.Series([False] * 10, name='dates'))
- assert "a TypeError will be raised" in str(m[0].message)
-
- with tm.assert_produces_warning(FutureWarning) as m:
- result = ser >= date
- tm.assert_series_equal(result, pd.Series([True] * 10, name='dates'))
- assert "a TypeError will be raised" in str(m[0].message)
-
- with tm.assert_produces_warning(FutureWarning) as m:
- result = ser > date
- tm.assert_series_equal(result, pd.Series([False] + [True] * 9,
- name='dates'))
- assert "a TypeError will be raised" in str(m[0].message)
-
- @pytest.mark.skip(reason="GH-21359")
- def test_dt64ser_cmp_date_invalid(self):
- # GH#19800 datetime.date comparison raises to
- # match DatetimeIndex/Timestamp. This also matches the behavior
- # of stdlib datetime.datetime
- ser = pd.Series(pd.date_range('20010101', periods=10), name='dates')
- date = ser.iloc[0].to_pydatetime().date()
- assert not (ser == date).any()
- assert (ser != date).all()
- with pytest.raises(TypeError):
- ser > date
- with pytest.raises(TypeError):
- ser < date
- with pytest.raises(TypeError):
- ser >= date
- with pytest.raises(TypeError):
- ser <= date
-
- def test_dt64ser_cmp_period_scalar(self):
- ser = Series(pd.period_range('2000-01-01', periods=10, freq='D'))
- val = Period('2000-01-04', freq='D')
- result = ser > val
- expected = Series([x > val for x in ser])
- tm.assert_series_equal(result, expected)
-
- val = ser[5]
- result = ser > val
- expected = Series([x > val for x in ser])
- tm.assert_series_equal(result, expected)
-
- @pytest.mark.parametrize("left,right", [
- ("lt", "gt"),
- ("le", "ge"),
- ("eq", "eq"),
- ("ne", "ne"),
- ])
- def test_timestamp_compare_series(self, left, right):
- # see gh-4982
- # Make sure we can compare Timestamps on the right AND left hand side.
- ser = pd.Series(pd.date_range("20010101", periods=10), name="dates")
- s_nat = ser.copy(deep=True)
-
- ser[0] = pd.Timestamp("nat")
- ser[3] = pd.Timestamp("nat")
-
- left_f = getattr(operator, left)
- right_f = getattr(operator, right)
-
- # No NaT
- expected = left_f(ser, pd.Timestamp("20010109"))
- result = right_f(pd.Timestamp("20010109"), ser)
- tm.assert_series_equal(result, expected)
-
- # NaT
- expected = left_f(ser, pd.Timestamp("nat"))
- result = right_f(pd.Timestamp("nat"), ser)
- tm.assert_series_equal(result, expected)
-
- # Compare to Timestamp with series containing NaT
- expected = left_f(s_nat, pd.Timestamp("20010109"))
- result = right_f(pd.Timestamp("20010109"), s_nat)
- tm.assert_series_equal(result, expected)
-
- # Compare to NaT with series containing NaT
- expected = left_f(s_nat, pd.Timestamp("nat"))
- result = right_f(pd.Timestamp("nat"), s_nat)
- tm.assert_series_equal(result, expected)
-
- def test_timestamp_equality(self):
- # GH#11034
- ser = pd.Series([pd.Timestamp('2000-01-29 01:59:00'), 'NaT'])
- result = ser != ser
- tm.assert_series_equal(result, pd.Series([False, True]))
- result = ser != ser[0]
- tm.assert_series_equal(result, pd.Series([False, True]))
- result = ser != ser[1]
- tm.assert_series_equal(result, pd.Series([True, True]))
-
- result = ser == ser
- tm.assert_series_equal(result, pd.Series([True, False]))
- result = ser == ser[0]
- tm.assert_series_equal(result, pd.Series([True, False]))
- result = ser == ser[1]
- tm.assert_series_equal(result, pd.Series([False, False]))
-
-
class TestTimedeltaSeriesComparisons(object):
def test_compare_timedelta_series(self):
# regresssion test for GH5963
@@ -214,112 +87,6 @@ def test_compare_timedelta_series(self):
tm.assert_series_equal(actual, expected)
-class TestPeriodSeriesComparisons(object):
- @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
- def test_cmp_series_period_scalar(self, freq):
- # GH 13200
- base = Series([Period(x, freq=freq) for x in
- ['2011-01', '2011-02', '2011-03', '2011-04']])
- p = Period('2011-02', freq=freq)
-
- exp = Series([False, True, False, False])
- tm.assert_series_equal(base == p, exp)
- tm.assert_series_equal(p == base, exp)
-
- exp = Series([True, False, True, True])
- tm.assert_series_equal(base != p, exp)
- tm.assert_series_equal(p != base, exp)
-
- exp = Series([False, False, True, True])
- tm.assert_series_equal(base > p, exp)
- tm.assert_series_equal(p < base, exp)
-
- exp = Series([True, False, False, False])
- tm.assert_series_equal(base < p, exp)
- tm.assert_series_equal(p > base, exp)
-
- exp = Series([False, True, True, True])
- tm.assert_series_equal(base >= p, exp)
- tm.assert_series_equal(p <= base, exp)
-
- exp = Series([True, True, False, False])
- tm.assert_series_equal(base <= p, exp)
- tm.assert_series_equal(p >= base, exp)
-
- # different base freq
- msg = "Input has different freq=A-DEC from Period"
- with tm.assert_raises_regex(IncompatibleFrequency, msg):
- base <= Period('2011', freq='A')
-
- with tm.assert_raises_regex(IncompatibleFrequency, msg):
- Period('2011', freq='A') >= base
-
- @pytest.mark.parametrize('freq', ['M', '2M', '3M'])
- def test_cmp_series_period_series(self, freq):
- # GH#13200
- base = Series([Period(x, freq=freq) for x in
- ['2011-01', '2011-02', '2011-03', '2011-04']])
-
- ser = Series([Period(x, freq=freq) for x in
- ['2011-02', '2011-01', '2011-03', '2011-05']])
-
- exp = Series([False, False, True, False])
- tm.assert_series_equal(base == ser, exp)
-
- exp = Series([True, True, False, True])
- tm.assert_series_equal(base != ser, exp)
-
- exp = Series([False, True, False, False])
- tm.assert_series_equal(base > ser, exp)
-
- exp = Series([True, False, False, True])
- tm.assert_series_equal(base < ser, exp)
-
- exp = Series([False, True, True, False])
- tm.assert_series_equal(base >= ser, exp)
-
- exp = Series([True, False, True, True])
- tm.assert_series_equal(base <= ser, exp)
-
- ser2 = Series([Period(x, freq='A') for x in
- ['2011', '2011', '2011', '2011']])
-
- # different base freq
- msg = "Input has different freq=A-DEC from Period"
- with tm.assert_raises_regex(IncompatibleFrequency, msg):
- base <= ser2
-
- def test_cmp_series_period_series_mixed_freq(self):
- # GH#13200
- base = Series([Period('2011', freq='A'),
- Period('2011-02', freq='M'),
- Period('2013', freq='A'),
- Period('2011-04', freq='M')])
-
- ser = Series([Period('2012', freq='A'),
- Period('2011-01', freq='M'),
- Period('2013', freq='A'),
- Period('2011-05', freq='M')])
-
- exp = Series([False, False, True, False])
- tm.assert_series_equal(base == ser, exp)
-
- exp = Series([True, True, False, True])
- tm.assert_series_equal(base != ser, exp)
-
- exp = Series([False, True, False, False])
- tm.assert_series_equal(base > ser, exp)
-
- exp = Series([True, False, False, True])
- tm.assert_series_equal(base < ser, exp)
-
- exp = Series([False, True, True, False])
- tm.assert_series_equal(base >= ser, exp)
-
- exp = Series([True, False, True, True])
- tm.assert_series_equal(base <= ser, exp)
-
-
# ------------------------------------------------------------------
# Arithmetic
@@ -423,66 +190,3 @@ def test_series_with_dtype_radd_timedelta(self, dtype):
result = ser + pd.Timedelta('3 days')
tm.assert_series_equal(result, expected)
-
-
-class TestPeriodSeriesArithmetic(object):
- def test_ops_series_timedelta(self):
- # GH 13043
- ser = pd.Series([pd.Period('2015-01-01', freq='D'),
- pd.Period('2015-01-02', freq='D')], name='xxx')
- assert ser.dtype == object
-
- expected = pd.Series([pd.Period('2015-01-02', freq='D'),
- pd.Period('2015-01-03', freq='D')], name='xxx')
-
- result = ser + pd.Timedelta('1 days')
- tm.assert_series_equal(result, expected)
-
- result = pd.Timedelta('1 days') + ser
- tm.assert_series_equal(result, expected)
-
- result = ser + pd.tseries.offsets.Day()
- tm.assert_series_equal(result, expected)
-
- result = pd.tseries.offsets.Day() + ser
- tm.assert_series_equal(result, expected)
-
- def test_ops_series_period(self):
- # GH 13043
- ser = pd.Series([pd.Period('2015-01-01', freq='D'),
- pd.Period('2015-01-02', freq='D')], name='xxx')
- assert ser.dtype == object
-
- per = pd.Period('2015-01-10', freq='D')
- off = per.freq
- # dtype will be object because of original dtype
- expected = pd.Series([9 * off, 8 * off], name='xxx', dtype=object)
- tm.assert_series_equal(per - ser, expected)
- tm.assert_series_equal(ser - per, -1 * expected)
-
- s2 = pd.Series([pd.Period('2015-01-05', freq='D'),
- pd.Period('2015-01-04', freq='D')], name='xxx')
- assert s2.dtype == object
-
- expected = pd.Series([4 * off, 2 * off], name='xxx', dtype=object)
- tm.assert_series_equal(s2 - ser, expected)
- tm.assert_series_equal(ser - s2, -1 * expected)
-
-
-class TestTimestampSeriesArithmetic(object):
- def test_timestamp_sub_series(self):
- ser = pd.Series(pd.date_range('2014-03-17', periods=2, freq='D',
- tz='US/Eastern'))
- ts = ser[0]
-
- delta_series = pd.Series([np.timedelta64(0, 'D'),
- np.timedelta64(1, 'D')])
- tm.assert_series_equal(ser - ts, delta_series)
- tm.assert_series_equal(ts - ser, -delta_series)
-
- def test_dt64ser_sub_datetime_dtype(self):
- ts = Timestamp(datetime(1993, 1, 7, 13, 30, 00))
- dt = datetime(1993, 6, 22, 13, 30)
- ser = Series([ts])
- result = pd.to_timedelta(np.abs(ser - dt))
- assert result.dtype == 'timedelta64[ns]'
| As suggested, these are split by dtype in a new tests/arithmetic directory.
Started parametrizing a few of these over `box` classes, but for the most part this is just collecting tests from their existing locations. There is going to be a lot of parametrization and de-duplication coming up.
Holding off on moving the existing timedelta64-dtype tests until #22163 is handled to avoid merge conflict. | https://api.github.com/repos/pandas-dev/pandas/pulls/22237 | 2018-08-07T23:11:39Z | 2018-08-08T10:06:54Z | 2018-08-08T10:06:54Z | 2018-08-08T15:48:16Z |
TST/CLN: break up & parametrize tests for df.set_index | diff --git a/pandas/tests/frame/conftest.py b/pandas/tests/frame/conftest.py
new file mode 100644
index 0000000000000..fdedb93835d75
--- /dev/null
+++ b/pandas/tests/frame/conftest.py
@@ -0,0 +1,191 @@
+import pytest
+
+import numpy as np
+
+from pandas import compat
+import pandas.util.testing as tm
+from pandas import DataFrame, date_range, NaT
+
+
+@pytest.fixture
+def float_frame():
+ """
+ Fixture for DataFrame of floats with index of unique strings
+
+ Columns are ['A', 'B', 'C', 'D'].
+ """
+ return DataFrame(tm.getSeriesData())
+
+
+@pytest.fixture
+def float_frame2():
+ """
+ Fixture for DataFrame of floats with index of unique strings
+
+ Columns are ['D', 'C', 'B', 'A']
+ """
+ return DataFrame(tm.getSeriesData(), columns=['D', 'C', 'B', 'A'])
+
+
+@pytest.fixture
+def int_frame():
+ """
+ Fixture for DataFrame of ints with index of unique strings
+
+ Columns are ['A', 'B', 'C', 'D']
+ """
+ df = DataFrame({k: v.astype(int)
+ for k, v in compat.iteritems(tm.getSeriesData())})
+ # force these all to int64 to avoid platform testing issues
+ return DataFrame({c: s for c, s in compat.iteritems(df)}, dtype=np.int64)
+
+
+@pytest.fixture
+def datetime_frame():
+ """
+ Fixture for DataFrame of floats with DatetimeIndex
+
+ Columns are ['A', 'B', 'C', 'D']
+ """
+ return DataFrame(tm.getTimeSeriesData())
+
+
+@pytest.fixture
+def float_string_frame():
+ """
+ Fixture for DataFrame of floats and strings with index of unique strings
+
+ Columns are ['A', 'B', 'C', 'D', 'foo'].
+ """
+ df = DataFrame(tm.getSeriesData())
+ df['foo'] = 'bar'
+ return df
+
+
+@pytest.fixture
+def mixed_float_frame():
+ """
+ Fixture for DataFrame of different float types with index of unique strings
+
+ Columns are ['A', 'B', 'C', 'D'].
+ """
+ df = DataFrame(tm.getSeriesData())
+ df.A = df.A.astype('float16')
+ df.B = df.B.astype('float32')
+ df.C = df.C.astype('float64')
+ return df
+
+
+@pytest.fixture
+def mixed_float_frame2():
+ """
+ Fixture for DataFrame of different float types with index of unique strings
+
+ Columns are ['A', 'B', 'C', 'D'].
+ """
+ df = DataFrame(tm.getSeriesData())
+ df.D = df.D.astype('float16')
+ df.C = df.C.astype('float32')
+ df.B = df.B.astype('float64')
+ return df
+
+
+@pytest.fixture
+def mixed_int_frame():
+ """
+ Fixture for DataFrame of different int types with index of unique strings
+
+ Columns are ['A', 'B', 'C', 'D'].
+ """
+ df = DataFrame({k: v.astype(int)
+ for k, v in compat.iteritems(tm.getSeriesData())})
+ df.A = df.A.astype('uint8')
+ df.B = df.B.astype('int32')
+ df.C = df.C.astype('int64')
+ df.D = np.ones(len(df.D), dtype='uint64')
+ return df
+
+
+@pytest.fixture
+def mixed_type_frame():
+ """
+ Fixture for DataFrame of float/int/string columns with RangeIndex
+
+ Columns are ['a', 'b', 'c', 'float32', 'int32'].
+ """
+ return DataFrame({'a': 1., 'b': 2, 'c': 'foo',
+ 'float32': np.array([1.] * 10, dtype='float32'),
+ 'int32': np.array([1] * 10, dtype='int32')},
+ index=np.arange(10))
+
+
+@pytest.fixture
+def timezone_frame():
+ """
+ Fixture for DataFrame of date_range Series with different time zones
+
+ Columns are ['A', 'B', 'C']; some entries are missing
+ """
+ df = DataFrame({'A': date_range('20130101', periods=3),
+ 'B': date_range('20130101', periods=3,
+ tz='US/Eastern'),
+ 'C': date_range('20130101', periods=3,
+ tz='CET')})
+ df.iloc[1, 1] = NaT
+ df.iloc[1, 2] = NaT
+ return df
+
+
+@pytest.fixture
+def empty_frame():
+ """
+ Fixture for empty DataFrame
+ """
+ return DataFrame({})
+
+
+@pytest.fixture
+def datetime_series():
+ """
+ Fixture for Series of floats with DatetimeIndex
+ """
+ return tm.makeTimeSeries(nper=30)
+
+
+@pytest.fixture
+def datetime_series_short():
+ """
+ Fixture for Series of floats with DatetimeIndex
+ """
+ return tm.makeTimeSeries(nper=30)[5:]
+
+
+@pytest.fixture
+def simple_frame():
+ """
+ Fixture for simple 3x3 DataFrame
+
+ Columns are ['one', 'two', 'three'], index is ['a', 'b', 'c'].
+ """
+ arr = np.array([[1., 2., 3.],
+ [4., 5., 6.],
+ [7., 8., 9.]])
+
+ return DataFrame(arr, columns=['one', 'two', 'three'],
+ index=['a', 'b', 'c'])
+
+
+@pytest.fixture
+def frame_of_index_cols():
+ """
+ Fixture for DataFrame of columns that can be used for indexing
+
+ Columns are ['A', 'B', 'C', 'D', 'E']; 'A' & 'B' contain duplicates (but
+ are jointly unique), the rest are unique.
+ """
+ df = DataFrame({'A': ['foo', 'foo', 'foo', 'bar', 'bar'],
+ 'B': ['one', 'two', 'three', 'one', 'two'],
+ 'C': ['a', 'b', 'c', 'd', 'e'],
+ 'D': np.random.randn(5),
+ 'E': np.random.randn(5)})
+ return df
diff --git a/pandas/tests/frame/test_alter_axes.py b/pandas/tests/frame/test_alter_axes.py
index 4f95eb3fe7b47..4e61c9c62266d 100644
--- a/pandas/tests/frame/test_alter_axes.py
+++ b/pandas/tests/frame/test_alter_axes.py
@@ -10,213 +10,251 @@
import numpy as np
from pandas.compat import lrange, PY2
-from pandas import (DataFrame, Series, Index, MultiIndex,
- RangeIndex, date_range, IntervalIndex,
- to_datetime)
+from pandas import (DataFrame, Series, Index, MultiIndex, RangeIndex,
+ IntervalIndex, DatetimeIndex, Categorical, cut,
+ Timestamp, date_range, to_datetime)
from pandas.core.dtypes.common import (
is_object_dtype,
is_categorical_dtype,
is_interval_dtype)
-import pandas as pd
-
-from pandas.util.testing import assert_series_equal, assert_frame_equal
import pandas.util.testing as tm
-from pandas.tests.frame.common import TestData
+class TestDataFrameAlterAxes():
+
+ def test_set_index_directly(self, float_string_frame):
+ df = float_string_frame
+ idx = Index(np.arange(len(df))[::-1])
-class TestDataFrameAlterAxes(TestData):
+ df.index = idx
+ tm.assert_index_equal(df.index, idx)
+ with tm.assert_raises_regex(ValueError, 'Length mismatch'):
+ df.index = idx[::2]
- def test_set_index(self):
- idx = Index(np.arange(len(self.mixed_frame)))
+ def test_set_index(self, float_string_frame):
+ df = float_string_frame
+ idx = Index(np.arange(len(df))[::-1])
- # cache it
- _ = self.mixed_frame['foo'] # noqa
- self.mixed_frame.index = idx
- assert self.mixed_frame['foo'].index is idx
+ df = df.set_index(idx)
+ tm.assert_index_equal(df.index, idx)
with tm.assert_raises_regex(ValueError, 'Length mismatch'):
- self.mixed_frame.index = idx[::2]
+ df.set_index(idx[::2])
def test_set_index_cast(self):
-
# issue casting an index then set_index
df = DataFrame({'A': [1.1, 2.2, 3.3], 'B': [5.0, 6.1, 7.2]},
index=[2010, 2011, 2012])
- expected = df.loc[2010]
- new_index = df.index.astype(np.int32)
- df.index = new_index
- result = df.loc[2010]
- assert_series_equal(result, expected)
-
- def test_set_index2(self):
- df = DataFrame({'A': ['foo', 'foo', 'foo', 'bar', 'bar'],
- 'B': ['one', 'two', 'three', 'one', 'two'],
- 'C': ['a', 'b', 'c', 'd', 'e'],
- 'D': np.random.randn(5),
- 'E': np.random.randn(5)})
-
- # new object, single-column
- result = df.set_index('C')
- result_nodrop = df.set_index('C', drop=False)
-
- index = Index(df['C'], name='C')
-
- expected = df.loc[:, ['A', 'B', 'D', 'E']]
- expected.index = index
-
- expected_nodrop = df.copy()
- expected_nodrop.index = index
-
- assert_frame_equal(result, expected)
- assert_frame_equal(result_nodrop, expected_nodrop)
- assert result.index.name == index.name
-
- # inplace, single
- df2 = df.copy()
-
- df2.set_index('C', inplace=True)
-
- assert_frame_equal(df2, expected)
-
- df3 = df.copy()
- df3.set_index('C', drop=False, inplace=True)
-
- assert_frame_equal(df3, expected_nodrop)
-
- # create new object, multi-column
- result = df.set_index(['A', 'B'])
- result_nodrop = df.set_index(['A', 'B'], drop=False)
-
- index = MultiIndex.from_arrays([df['A'], df['B']], names=['A', 'B'])
+ df2 = df.set_index(df.index.astype(np.int32))
+ tm.assert_frame_equal(df, df2)
+
+ # A has duplicate values, C does not
+ @pytest.mark.parametrize('keys', ['A', 'C', ['A', 'B']])
+ @pytest.mark.parametrize('inplace', [True, False])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_drop_inplace(self, frame_of_index_cols,
+ drop, inplace, keys):
+ df = frame_of_index_cols
+
+ if isinstance(keys, list):
+ idx = MultiIndex.from_arrays([df[x] for x in keys], names=keys)
+ else:
+ idx = Index(df[keys], name=keys)
+ expected = df.drop(keys, axis=1) if drop else df
+ expected.index = idx
+
+ if inplace:
+ result = df.copy()
+ result.set_index(keys, drop=drop, inplace=True)
+ else:
+ result = df.set_index(keys, drop=drop)
+
+ tm.assert_frame_equal(result, expected)
+
+ # A has duplicate values, C does not
+ @pytest.mark.parametrize('keys', ['A', 'C', ['A', 'B']])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_append(self, frame_of_index_cols, drop, keys):
+ df = frame_of_index_cols
+
+ keys = keys if isinstance(keys, list) else [keys]
+ idx = MultiIndex.from_arrays([df.index] + [df[x] for x in keys],
+ names=[None] + keys)
+ expected = df.drop(keys, axis=1) if drop else df.copy()
+ expected.index = idx
+
+ result = df.set_index(keys, drop=drop, append=True)
+
+ tm.assert_frame_equal(result, expected)
+
+ # A has duplicate values, C does not
+ @pytest.mark.parametrize('keys', ['A', 'C', ['A', 'B']])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_append_to_multiindex(self, frame_of_index_cols,
+ drop, keys):
+ # append to existing multiindex
+ df = frame_of_index_cols.set_index(['D'], drop=drop, append=True)
- expected = df.loc[:, ['C', 'D', 'E']]
- expected.index = index
+ keys = keys if isinstance(keys, list) else [keys]
+ expected = frame_of_index_cols.set_index(['D'] + keys,
+ drop=drop, append=True)
- expected_nodrop = df.copy()
- expected_nodrop.index = index
+ result = df.set_index(keys, drop=drop, append=True)
- assert_frame_equal(result, expected)
- assert_frame_equal(result_nodrop, expected_nodrop)
- assert result.index.names == index.names
+ tm.assert_frame_equal(result, expected)
- # inplace
- df2 = df.copy()
- df2.set_index(['A', 'B'], inplace=True)
- assert_frame_equal(df2, expected)
+ def test_set_index_after_mutation(self):
+ # GH1590
+ df = DataFrame({'val': [0, 1, 2], 'key': ['a', 'b', 'c']})
+ expected = DataFrame({'val': [1, 2]},
+ Index(['b', 'c'], name='key'))
- df3 = df.copy()
- df3.set_index(['A', 'B'], drop=False, inplace=True)
- assert_frame_equal(df3, expected_nodrop)
+ df2 = df.loc[df.index.map(lambda indx: indx >= 1)]
+ result = df2.set_index('key')
+ tm.assert_frame_equal(result, expected)
+
+ # MultiIndex constructor does not work directly on Series -> lambda
+ # also test index name if append=True (name is duplicate here for B)
+ @pytest.mark.parametrize('box', [Series, Index, np.array,
+ lambda x: MultiIndex.from_arrays([x])])
+ @pytest.mark.parametrize('append, index_name', [(True, None),
+ (True, 'B'), (True, 'test'), (False, None)])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_pass_single_array(self, frame_of_index_cols,
+ drop, append, index_name, box):
+ df = frame_of_index_cols
+ df.index.name = index_name
+
+ key = box(df['B'])
+ # np.array and list "forget" the name of B
+ name = [None if box in [np.array, list] else 'B']
+
+ result = df.set_index(key, drop=drop, append=append)
+
+ # only valid column keys are dropped
+ # since B is always passed as array above, nothing is dropped
+ expected = df.set_index(['B'], drop=False, append=append)
+ expected.index.names = [index_name] + name if append else name
+
+ tm.assert_frame_equal(result, expected)
+
+ # MultiIndex constructor does not work directly on Series -> lambda
+ # also test index name if append=True (name is duplicate here for A & B)
+ @pytest.mark.parametrize('box', [Series, Index, np.array, list,
+ lambda x: MultiIndex.from_arrays([x])])
+ @pytest.mark.parametrize('append, index_name',
+ [(True, None), (True, 'A'), (True, 'B'),
+ (True, 'test'), (False, None)])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_pass_arrays(self, frame_of_index_cols,
+ drop, append, index_name, box):
+ df = frame_of_index_cols
+ df.index.name = index_name
+
+ keys = ['A', box(df['B'])]
+ # np.array and list "forget" the name of B
+ names = ['A', None if box in [np.array, list] else 'B']
+
+ result = df.set_index(keys, drop=drop, append=append)
+
+ # only valid column keys are dropped
+ # since B is always passed as array above, only A is dropped, if at all
+ expected = df.set_index(['A', 'B'], drop=False, append=append)
+ expected = expected.drop('A', axis=1) if drop else expected
+ expected.index.names = [index_name] + names if append else names
+
+ tm.assert_frame_equal(result, expected)
+
+ # MultiIndex constructor does not work directly on Series -> lambda
+ # We also emulate a "constructor" for the label -> lambda
+ # also test index name if append=True (name is duplicate here for A)
+ @pytest.mark.parametrize('box2', [Series, Index, np.array, list,
+ lambda x: MultiIndex.from_arrays([x]),
+ lambda x: x.name])
+ @pytest.mark.parametrize('box1', [Series, Index, np.array, list,
+ lambda x: MultiIndex.from_arrays([x]),
+ lambda x: x.name])
+ @pytest.mark.parametrize('append, index_name', [(True, None),
+ (True, 'A'), (True, 'test'), (False, None)])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_pass_arrays_duplicate(self, frame_of_index_cols, drop,
+ append, index_name, box1, box2):
+ df = frame_of_index_cols
+ df.index.name = index_name
+
+ keys = [box1(df['A']), box2(df['A'])]
+
+ # == gives ambiguous Boolean for Series
+ if drop and keys[0] is 'A' and keys[1] is 'A':
+ with tm.assert_raises_regex(KeyError, '.*'):
+ df.set_index(keys, drop=drop, append=append)
+ else:
+ result = df.set_index(keys, drop=drop, append=append)
+
+ # to test against already-tested behavior, we add sequentially,
+ # hence second append always True; must wrap in list, otherwise
+ # list-box will be illegal
+ expected = df.set_index([keys[0]], drop=drop, append=append)
+ expected = expected.set_index([keys[1]], drop=drop, append=True)
+
+ tm.assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize('append', [True, False])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_pass_multiindex(self, frame_of_index_cols,
+ drop, append):
+ df = frame_of_index_cols
+ keys = MultiIndex.from_arrays([df['A'], df['B']], names=['A', 'B'])
+
+ result = df.set_index(keys, drop=drop, append=append)
+
+ # setting with a MultiIndex will never drop columns
+ expected = df.set_index(['A', 'B'], drop=False, append=append)
+
+ tm.assert_frame_equal(result, expected)
+
+ def test_set_index_verify_integrity(self, frame_of_index_cols):
+ df = frame_of_index_cols
- # corner case
with tm.assert_raises_regex(ValueError,
'Index has duplicate keys'):
df.set_index('A', verify_integrity=True)
-
- # append
- result = df.set_index(['A', 'B'], append=True)
- xp = df.reset_index().set_index(['index', 'A', 'B'])
- xp.index.names = [None, 'A', 'B']
- assert_frame_equal(result, xp)
-
- # append to existing multiindex
- rdf = df.set_index(['A'], append=True)
- rdf = rdf.set_index(['B', 'C'], append=True)
- expected = df.set_index(['A', 'B', 'C'], append=True)
- assert_frame_equal(rdf, expected)
-
- # Series
- result = df.set_index(df.C)
- assert result.index.name == 'C'
-
- @pytest.mark.parametrize(
- 'level', ['a', pd.Series(range(0, 8, 2), name='a')])
- def test_set_index_duplicate_names(self, level):
- # GH18872 - GH19029
- df = pd.DataFrame(np.arange(8).reshape(4, 2), columns=['a', 'b'])
-
- # Pass an existing level name:
- df.index.name = 'a'
- expected = pd.MultiIndex.from_tuples([(0, 0), (1, 2), (2, 4), (3, 6)],
- names=['a', 'a'])
- result = df.set_index(level, append=True)
- tm.assert_index_equal(result.index, expected)
- result = df.set_index([level], append=True)
- tm.assert_index_equal(result.index, expected)
-
- # Pass twice the same level name (only works with passing actual data)
- if isinstance(level, pd.Series):
- result = df.set_index([level, level])
- expected = pd.MultiIndex.from_tuples(
- [(0, 0), (2, 2), (4, 4), (6, 6)], names=['a', 'a'])
- tm.assert_index_equal(result.index, expected)
-
- def test_set_index_nonuniq(self):
- df = DataFrame({'A': ['foo', 'foo', 'foo', 'bar', 'bar'],
- 'B': ['one', 'two', 'three', 'one', 'two'],
- 'C': ['a', 'b', 'c', 'd', 'e'],
- 'D': np.random.randn(5),
- 'E': np.random.randn(5)})
+ # with MultiIndex
with tm.assert_raises_regex(ValueError,
'Index has duplicate keys'):
- df.set_index('A', verify_integrity=True, inplace=True)
- assert 'A' in df
-
- def test_set_index_bug(self):
- # GH1590
- df = DataFrame({'val': [0, 1, 2], 'key': ['a', 'b', 'c']})
- xp = DataFrame({'val': [1, 2]},
- Index(['b', 'c'], name='key'))
-
- df2 = df.loc[df.index.map(lambda indx: indx >= 1)]
- rs = df2.set_index('key')
- assert_frame_equal(rs, xp)
+ df.set_index([df['A'], df['A']], verify_integrity=True)
- def test_set_index_pass_arrays(self):
- 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)})
+ @pytest.mark.parametrize('append', [True, False])
+ @pytest.mark.parametrize('drop', [True, False])
+ def test_set_index_raise(self, frame_of_index_cols, drop, append):
+ df = frame_of_index_cols
- # multiple columns
- result = df.set_index(['A', df['B'].values], drop=False)
- expected = df.set_index(['A', 'B'], drop=False)
+ with tm.assert_raises_regex(KeyError, '.*'): # column names are A-E
+ df.set_index(['foo', 'bar', 'baz'], drop=drop, append=append)
- # TODO should set_index check_names ?
- assert_frame_equal(result, expected, check_names=False)
+ # non-existent key in list with arrays
+ with tm.assert_raises_regex(KeyError, '.*'):
+ df.set_index([df['A'], df['B'], 'X'], drop=drop, append=append)
def test_construction_with_categorical_index(self):
-
ci = tm.makeCategoricalIndex(10)
+ ci.name = 'B'
# with Categorical
df = DataFrame({'A': np.random.randn(10),
'B': ci.values})
idf = df.set_index('B')
- str(idf)
- tm.assert_index_equal(idf.index, ci, check_names=False)
- assert idf.index.name == 'B'
+ tm.assert_index_equal(idf.index, ci)
# from a CategoricalIndex
df = DataFrame({'A': np.random.randn(10),
'B': ci})
idf = df.set_index('B')
- str(idf)
- tm.assert_index_equal(idf.index, ci, check_names=False)
- assert idf.index.name == 'B'
-
- idf = df.set_index('B').reset_index().set_index('B')
- str(idf)
- tm.assert_index_equal(idf.index, ci, check_names=False)
- assert idf.index.name == 'B'
+ tm.assert_index_equal(idf.index, ci)
- new_df = idf.reset_index()
- new_df.index = df.B
- tm.assert_index_equal(new_df.index, ci, check_names=False)
- assert idf.index.name == 'B'
+ # round-trip
+ idf = idf.reset_index().set_index('B')
+ tm.assert_index_equal(idf.index, ci)
def test_set_index_cast_datetimeindex(self):
df = DataFrame({'A': [datetime(2000, 1, 1) + timedelta(i)
@@ -224,48 +262,46 @@ def test_set_index_cast_datetimeindex(self):
'B': np.random.randn(1000)})
idf = df.set_index('A')
- assert isinstance(idf.index, pd.DatetimeIndex)
+ assert isinstance(idf.index, DatetimeIndex)
+ def test_convert_dti_to_series(self):
# don't cast a DatetimeIndex WITH a tz, leave as object
# GH 6032
- i = (pd.DatetimeIndex(
- to_datetime(['2013-1-1 13:00',
- '2013-1-2 14:00'], errors="raise"))
- .tz_localize('US/Pacific'))
+ idx = DatetimeIndex(to_datetime(['2013-1-1 13:00',
+ '2013-1-2 14:00']),
+ name='B').tz_localize('US/Pacific')
df = DataFrame(np.random.randn(2, 1), columns=['A'])
- expected = Series(np.array([pd.Timestamp('2013-01-01 13:00:00-0800',
- tz='US/Pacific'),
- pd.Timestamp('2013-01-02 14:00:00-0800',
- tz='US/Pacific')],
- dtype="object"))
+ expected = Series(np.array([Timestamp('2013-01-01 13:00:00-0800',
+ tz='US/Pacific'),
+ Timestamp('2013-01-02 14:00:00-0800',
+ tz='US/Pacific')],
+ dtype="object"), name='B')
# convert index to series
- result = Series(i)
- assert_series_equal(result, expected)
+ result = Series(idx)
+ tm.assert_series_equal(result, expected)
- # assignt to frame
- df['B'] = i
+ # assign to frame
+ df['B'] = idx
result = df['B']
- assert_series_equal(result, expected, check_names=False)
- assert result.name == 'B'
+ tm.assert_series_equal(result, expected)
- # keep the timezone
- result = i.to_series(keep_tz=True)
- assert_series_equal(result.reset_index(drop=True), expected)
+ # convert to series while keeping the timezone
+ result = idx.to_series(keep_tz=True, index=[0, 1])
+ tm.assert_series_equal(result, expected)
# convert to utc
- df['C'] = i.to_series().reset_index(drop=True)
- result = df['C']
- comp = pd.DatetimeIndex(expected.values)
- comp = comp.tz_localize(None)
- tm.assert_numpy_array_equal(result.values, comp.values)
+ df['B'] = idx.to_series(index=[0, 1])
+ result = df['B']
+ comp = Series(DatetimeIndex(expected.values).tz_localize(None),
+ name='B')
+ tm.assert_series_equal(result, comp)
# list of datetimes with a tz
- df['D'] = i.to_pydatetime()
- result = df['D']
- assert_series_equal(result, expected, check_names=False)
- assert result.name == 'D'
+ df['B'] = idx.to_pydatetime()
+ result = df['B']
+ tm.assert_series_equal(result, expected)
# GH 6785
# set the index manually
@@ -275,96 +311,97 @@ def test_set_index_cast_datetimeindex(self):
expected = df.set_index('ts')
df.index = df['ts']
df.pop('ts')
- assert_frame_equal(df, expected)
+ tm.assert_frame_equal(df, expected)
def test_reset_index_tz(self, tz_aware_fixture):
# GH 3950
# reset_index with single level
tz = tz_aware_fixture
- idx = pd.date_range('1/1/2011', periods=5,
- freq='D', tz=tz, name='idx')
- df = pd.DataFrame(
- {'a': range(5), 'b': ['A', 'B', 'C', 'D', 'E']}, index=idx)
-
- expected = pd.DataFrame({'idx': [datetime(2011, 1, 1),
- datetime(2011, 1, 2),
- datetime(2011, 1, 3),
- datetime(2011, 1, 4),
- datetime(2011, 1, 5)],
- 'a': range(5),
- 'b': ['A', 'B', 'C', 'D', 'E']},
- columns=['idx', 'a', 'b'])
- expected['idx'] = expected['idx'].apply(
- lambda d: pd.Timestamp(d, tz=tz))
- assert_frame_equal(df.reset_index(), expected)
+ idx = date_range('1/1/2011', periods=5,
+ freq='D', tz=tz, name='idx')
+ df = DataFrame({'a': range(5), 'b': ['A', 'B', 'C', 'D', 'E']},
+ index=idx)
+
+ expected = DataFrame({'idx': [datetime(2011, 1, 1),
+ datetime(2011, 1, 2),
+ datetime(2011, 1, 3),
+ datetime(2011, 1, 4),
+ datetime(2011, 1, 5)],
+ 'a': range(5),
+ 'b': ['A', 'B', 'C', 'D', 'E']},
+ columns=['idx', 'a', 'b'])
+ expected['idx'] = expected['idx'].apply(lambda d: Timestamp(d, tz=tz))
+ tm.assert_frame_equal(df.reset_index(), expected)
def test_set_index_timezone(self):
# GH 12358
# tz-aware Series should retain the tz
- i = pd.to_datetime(["2014-01-01 10:10:10"],
- utc=True).tz_convert('Europe/Rome')
- df = DataFrame({'i': i})
- assert df.set_index(i).index[0].hour == 11
- assert pd.DatetimeIndex(pd.Series(df.i))[0].hour == 11
- assert df.set_index(df.i).index[0].hour == 11
+ idx = to_datetime(["2014-01-01 10:10:10"],
+ utc=True).tz_convert('Europe/Rome')
+ df = DataFrame({'A': idx})
+ assert df.set_index(idx).index[0].hour == 11
+ assert DatetimeIndex(Series(df.A))[0].hour == 11
+ assert df.set_index(df.A).index[0].hour == 11
def test_set_index_dst(self):
- di = pd.date_range('2006-10-29 00:00:00', periods=3,
- freq='H', tz='US/Pacific')
+ di = date_range('2006-10-29 00:00:00', periods=3,
+ freq='H', tz='US/Pacific')
- df = pd.DataFrame(data={'a': [0, 1, 2], 'b': [3, 4, 5]},
- index=di).reset_index()
+ df = DataFrame(data={'a': [0, 1, 2], 'b': [3, 4, 5]},
+ index=di).reset_index()
# single level
res = df.set_index('index')
- exp = pd.DataFrame(data={'a': [0, 1, 2], 'b': [3, 4, 5]},
- index=pd.Index(di, name='index'))
+ exp = DataFrame(data={'a': [0, 1, 2], 'b': [3, 4, 5]},
+ index=Index(di, name='index'))
tm.assert_frame_equal(res, exp)
# GH 12920
res = df.set_index(['index', 'a'])
- exp_index = pd.MultiIndex.from_arrays([di, [0, 1, 2]],
- names=['index', 'a'])
- exp = pd.DataFrame({'b': [3, 4, 5]}, index=exp_index)
+ exp_index = MultiIndex.from_arrays([di, [0, 1, 2]],
+ names=['index', 'a'])
+ exp = DataFrame({'b': [3, 4, 5]}, index=exp_index)
tm.assert_frame_equal(res, exp)
def test_reset_index_with_intervals(self):
- idx = pd.IntervalIndex.from_breaks(np.arange(11), name='x')
- original = pd.DataFrame({'x': idx, 'y': np.arange(10)})[['x', 'y']]
+ idx = IntervalIndex.from_breaks(np.arange(11), name='x')
+ original = DataFrame({'x': idx, 'y': np.arange(10)})[['x', 'y']]
result = original.set_index('x')
- expected = pd.DataFrame({'y': np.arange(10)}, index=idx)
- assert_frame_equal(result, expected)
+ expected = DataFrame({'y': np.arange(10)}, index=idx)
+ tm.assert_frame_equal(result, expected)
result2 = result.reset_index()
- assert_frame_equal(result2, original)
+ tm.assert_frame_equal(result2, original)
def test_set_index_multiindexcolumns(self):
columns = MultiIndex.from_tuples([('foo', 1), ('foo', 2), ('bar', 1)])
df = DataFrame(np.random.randn(3, 3), columns=columns)
- rs = df.set_index(df.columns[0])
- xp = df.iloc[:, 1:]
- xp.index = df.iloc[:, 0].values
- xp.index.names = [df.columns[0]]
- assert_frame_equal(rs, xp)
+ result = df.set_index(df.columns[0])
+ expected = df.iloc[:, 1:]
+ expected.index = df.iloc[:, 0].values
+ expected.index.names = [df.columns[0]]
+ tm.assert_frame_equal(result, expected)
def test_set_index_empty_column(self):
- # #1971
+ # GH 1971
df = DataFrame([
- dict(a=1, p=0),
- dict(a=2, m=10),
- dict(a=3, m=11, p=20),
- dict(a=4, m=12, p=21)
+ {'a': 1, 'p': 0},
+ {'a': 2, 'm': 10},
+ {'a': 3, 'm': 11, 'p': 20},
+ {'a': 4, 'm': 12, 'p': 21}
], columns=('a', 'm', 'p', 'x'))
- # it works!
result = df.set_index(['a', 'x'])
- repr(result)
-
- def test_set_columns(self):
- cols = Index(np.arange(len(self.mixed_frame.columns)))
- self.mixed_frame.columns = cols
+ expected = df[['m', 'p']]
+ expected.index = MultiIndex.from_arrays([df['a'], df['x']],
+ names=['a', 'x'])
+ tm.assert_frame_equal(result, expected)
+
+ def test_set_columns(self, float_string_frame):
+ cols = Index(np.arange(len(float_string_frame.columns)))
+ float_string_frame.columns = cols
with tm.assert_raises_regex(ValueError, 'Length mismatch'):
- self.mixed_frame.columns = cols[::2]
+ float_string_frame.columns = cols[::2]
def test_dti_set_index_reindex(self):
# GH 6631
@@ -377,7 +414,7 @@ def test_dti_set_index_reindex(self):
df = df.reindex(idx2)
tm.assert_index_equal(df.index, idx2)
- # 11314
+ # GH 11314
# with tz
index = date_range(datetime(2015, 10, 1),
datetime(2015, 10, 1, 23),
@@ -387,14 +424,12 @@ def test_dti_set_index_reindex(self):
datetime(2015, 10, 2, 23),
freq='H', tz='US/Eastern')
- # TODO: unused?
- result = df.set_index(new_index) # noqa
-
- assert new_index.freq == index.freq
+ result = df.set_index(new_index)
+ assert result.index.freq == index.freq
# Renaming
- def test_rename(self):
+ def test_rename(self, float_frame):
mapping = {
'A': 'a',
'B': 'b',
@@ -402,12 +437,12 @@ def test_rename(self):
'D': 'd'
}
- renamed = self.frame.rename(columns=mapping)
- renamed2 = self.frame.rename(columns=str.lower)
+ renamed = float_frame.rename(columns=mapping)
+ renamed2 = float_frame.rename(columns=str.lower)
- assert_frame_equal(renamed, renamed2)
- assert_frame_equal(renamed2.rename(columns=str.upper),
- self.frame, check_names=False)
+ tm.assert_frame_equal(renamed, renamed2)
+ tm.assert_frame_equal(renamed2.rename(columns=str.upper),
+ float_frame, check_names=False)
# index
data = {
@@ -417,52 +452,49 @@ def test_rename(self):
# gets sorted alphabetical
df = DataFrame(data)
renamed = df.rename(index={'foo': 'bar', 'bar': 'foo'})
- tm.assert_index_equal(renamed.index, pd.Index(['foo', 'bar']))
+ tm.assert_index_equal(renamed.index, Index(['foo', 'bar']))
renamed = df.rename(index=str.upper)
- tm.assert_index_equal(renamed.index, pd.Index(['BAR', 'FOO']))
+ tm.assert_index_equal(renamed.index, Index(['BAR', 'FOO']))
# have to pass something
- pytest.raises(TypeError, self.frame.rename)
+ pytest.raises(TypeError, float_frame.rename)
# partial columns
- renamed = self.frame.rename(columns={'C': 'foo', 'D': 'bar'})
- tm.assert_index_equal(renamed.columns,
- pd.Index(['A', 'B', 'foo', 'bar']))
+ renamed = float_frame.rename(columns={'C': 'foo', 'D': 'bar'})
+ tm.assert_index_equal(renamed.columns, Index(['A', 'B', 'foo', 'bar']))
# other axis
- renamed = self.frame.T.rename(index={'C': 'foo', 'D': 'bar'})
- tm.assert_index_equal(renamed.index,
- pd.Index(['A', 'B', 'foo', 'bar']))
+ renamed = float_frame.T.rename(index={'C': 'foo', 'D': 'bar'})
+ tm.assert_index_equal(renamed.index, Index(['A', 'B', 'foo', 'bar']))
# index with name
index = Index(['foo', 'bar'], name='name')
renamer = DataFrame(data, index=index)
renamed = renamer.rename(index={'foo': 'bar', 'bar': 'foo'})
tm.assert_index_equal(renamed.index,
- pd.Index(['bar', 'foo'], name='name'))
+ Index(['bar', 'foo'], name='name'))
assert renamed.index.name == renamer.index.name
- def test_rename_axis_inplace(self):
+ def test_rename_axis_inplace(self, float_frame):
# GH 15704
- frame = self.frame.copy()
- expected = frame.rename_axis('foo')
- result = frame.copy()
+ expected = float_frame.rename_axis('foo')
+ result = float_frame.copy()
no_return = result.rename_axis('foo', inplace=True)
assert no_return is None
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
- expected = frame.rename_axis('bar', axis=1)
- result = frame.copy()
+ expected = float_frame.rename_axis('bar', axis=1)
+ result = float_frame.copy()
no_return = result.rename_axis('bar', axis=1, inplace=True)
assert no_return is None
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
def test_rename_axis_warns(self):
# https://github.com/pandas-dev/pandas/issues/17833
- df = pd.DataFrame({"A": [1, 2], "B": [1, 2]})
+ df = DataFrame({"A": [1, 2], "B": [1, 2]})
with tm.assert_produces_warning(FutureWarning) as w:
df.rename_axis(id, axis=0)
assert 'rename' in str(w[0].message)
@@ -554,23 +586,23 @@ def test_rename_multiindex(self):
level=0)
tm.assert_index_equal(renamed.index, new_index)
- def test_rename_nocopy(self):
- renamed = self.frame.rename(columns={'C': 'foo'}, copy=False)
+ def test_rename_nocopy(self, float_frame):
+ renamed = float_frame.rename(columns={'C': 'foo'}, copy=False)
renamed['foo'] = 1.
- assert (self.frame['C'] == 1.).all()
+ assert (float_frame['C'] == 1.).all()
- def test_rename_inplace(self):
- self.frame.rename(columns={'C': 'foo'})
- assert 'C' in self.frame
- assert 'foo' not in self.frame
+ def test_rename_inplace(self, float_frame):
+ float_frame.rename(columns={'C': 'foo'})
+ assert 'C' in float_frame
+ assert 'foo' not in float_frame
- c_id = id(self.frame['C'])
- frame = self.frame.copy()
- frame.rename(columns={'C': 'foo'}, inplace=True)
+ c_id = id(float_frame['C'])
+ float_frame = float_frame.copy()
+ float_frame.rename(columns={'C': 'foo'}, inplace=True)
- assert 'C' not in frame
- assert 'foo' in frame
- assert id(frame['foo']) != c_id
+ assert 'C' not in float_frame
+ assert 'foo' in float_frame
+ assert id(float_frame['foo']) != c_id
def test_rename_bug(self):
# GH 5344
@@ -585,7 +617,7 @@ def test_rename_bug(self):
[('foo', 'bah'), ('bar', 'bas')],
names=['a', 'b']),
columns=['2001-01-01'])
- assert_frame_equal(df, expected)
+ tm.assert_frame_equal(df, expected)
def test_rename_bug2(self):
# GH 19497
@@ -596,7 +628,7 @@ def test_rename_bug2(self):
df = df.rename({(1, 1): (5, 4)}, axis="index")
expected = DataFrame(data=np.arange(3), index=[(0, 0), (5, 4), (2, 2)],
columns=["a"])
- assert_frame_equal(df, expected)
+ tm.assert_frame_equal(df, expected)
def test_reorder_levels(self):
index = MultiIndex(levels=[['bar'], ['one', 'two', 'three'], [0, 1]],
@@ -608,11 +640,11 @@ def test_reorder_levels(self):
# no change, position
result = df.reorder_levels([0, 1, 2])
- assert_frame_equal(df, result)
+ tm.assert_frame_equal(df, result)
# no change, labels
result = df.reorder_levels(['L0', 'L1', 'L2'])
- assert_frame_equal(df, result)
+ tm.assert_frame_equal(df, result)
# rotate, position
result = df.reorder_levels([1, 2, 0])
@@ -623,7 +655,7 @@ def test_reorder_levels(self):
names=['L1', 'L2', 'L0'])
expected = DataFrame({'A': np.arange(6), 'B': np.arange(6)},
index=e_idx)
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.reorder_levels([0, 0, 0])
e_idx = MultiIndex(levels=[['bar'], ['bar'], ['bar']],
@@ -633,13 +665,13 @@ def test_reorder_levels(self):
names=['L0', 'L0', 'L0'])
expected = DataFrame({'A': np.arange(6), 'B': np.arange(6)},
index=e_idx)
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.reorder_levels(['L0', 'L0', 'L0'])
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
- def test_reset_index(self):
- stacked = self.frame.stack()[::2]
+ def test_reset_index(self, float_frame):
+ stacked = float_frame.stack()[::2]
stacked = DataFrame({'foo': stacked, 'bar': stacked})
names = ['first', 'second']
@@ -659,63 +691,62 @@ def test_reset_index(self):
check_names=False)
# default name assigned
- rdf = self.frame.reset_index()
- exp = pd.Series(self.frame.index.values, name='index')
+ rdf = float_frame.reset_index()
+ exp = Series(float_frame.index.values, name='index')
tm.assert_series_equal(rdf['index'], exp)
# default name assigned, corner case
- df = self.frame.copy()
+ df = float_frame.copy()
df['index'] = 'foo'
rdf = df.reset_index()
- exp = pd.Series(self.frame.index.values, name='level_0')
+ exp = Series(float_frame.index.values, name='level_0')
tm.assert_series_equal(rdf['level_0'], exp)
# but this is ok
- self.frame.index.name = 'index'
- deleveled = self.frame.reset_index()
- tm.assert_series_equal(deleveled['index'],
- pd.Series(self.frame.index))
+ float_frame.index.name = 'index'
+ deleveled = float_frame.reset_index()
+ tm.assert_series_equal(deleveled['index'], Series(float_frame.index))
tm.assert_index_equal(deleveled.index,
- pd.Index(np.arange(len(deleveled))))
+ Index(np.arange(len(deleveled))))
# preserve column names
- self.frame.columns.name = 'columns'
- resetted = self.frame.reset_index()
+ float_frame.columns.name = 'columns'
+ resetted = float_frame.reset_index()
assert resetted.columns.name == 'columns'
# only remove certain columns
- frame = self.frame.reset_index().set_index(['index', 'A', 'B'])
- rs = frame.reset_index(['A', 'B'])
+ df = float_frame.reset_index().set_index(['index', 'A', 'B'])
+ rs = df.reset_index(['A', 'B'])
# TODO should reset_index check_names ?
- assert_frame_equal(rs, self.frame, check_names=False)
+ tm.assert_frame_equal(rs, float_frame, check_names=False)
- rs = frame.reset_index(['index', 'A', 'B'])
- assert_frame_equal(rs, self.frame.reset_index(), check_names=False)
+ rs = df.reset_index(['index', 'A', 'B'])
+ tm.assert_frame_equal(rs, float_frame.reset_index(), check_names=False)
- rs = frame.reset_index(['index', 'A', 'B'])
- assert_frame_equal(rs, self.frame.reset_index(), check_names=False)
+ rs = df.reset_index(['index', 'A', 'B'])
+ tm.assert_frame_equal(rs, float_frame.reset_index(), check_names=False)
- rs = frame.reset_index('A')
- xp = self.frame.reset_index().set_index(['index', 'B'])
- assert_frame_equal(rs, xp, check_names=False)
+ rs = df.reset_index('A')
+ xp = float_frame.reset_index().set_index(['index', 'B'])
+ tm.assert_frame_equal(rs, xp, check_names=False)
# test resetting in place
- df = self.frame.copy()
- resetted = self.frame.reset_index()
+ df = float_frame.copy()
+ resetted = float_frame.reset_index()
df.reset_index(inplace=True)
- assert_frame_equal(df, resetted, check_names=False)
+ tm.assert_frame_equal(df, resetted, check_names=False)
- frame = self.frame.reset_index().set_index(['index', 'A', 'B'])
- rs = frame.reset_index('A', drop=True)
- xp = self.frame.copy()
+ df = float_frame.reset_index().set_index(['index', 'A', 'B'])
+ rs = df.reset_index('A', drop=True)
+ xp = float_frame.copy()
del xp['A']
xp = xp.set_index(['B'], append=True)
- assert_frame_equal(rs, xp, check_names=False)
+ tm.assert_frame_equal(rs, xp, check_names=False)
def test_reset_index_level(self):
- df = pd.DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]],
- columns=['A', 'B', 'C', 'D'])
+ df = DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]],
+ columns=['A', 'B', 'C', 'D'])
for levels in ['A', 'B'], [0, 1]:
# With MultiIndex
@@ -772,17 +803,17 @@ def test_reset_index_multiindex_col(self):
rs = df.reset_index()
xp = DataFrame(full, columns=[['a', 'b', 'b', 'c'],
['', 'mean', 'median', 'mean']])
- assert_frame_equal(rs, xp)
+ tm.assert_frame_equal(rs, xp)
rs = df.reset_index(col_fill=None)
xp = DataFrame(full, columns=[['a', 'b', 'b', 'c'],
['a', 'mean', 'median', 'mean']])
- assert_frame_equal(rs, xp)
+ tm.assert_frame_equal(rs, xp)
rs = df.reset_index(col_level=1, col_fill='blah')
xp = DataFrame(full, columns=[['blah', 'b', 'b', 'c'],
['a', 'mean', 'median', 'mean']])
- assert_frame_equal(rs, xp)
+ tm.assert_frame_equal(rs, xp)
df = DataFrame(vals,
MultiIndex.from_arrays([[0, 1, 2], ['x', 'y', 'z']],
@@ -792,73 +823,73 @@ def test_reset_index_multiindex_col(self):
xp = DataFrame(full, Index([0, 1, 2], name='d'),
columns=[['a', 'b', 'b', 'c'],
['', 'mean', 'median', 'mean']])
- assert_frame_equal(rs, xp)
+ tm.assert_frame_equal(rs, xp)
rs = df.reset_index('a', col_fill=None)
xp = DataFrame(full, Index(lrange(3), name='d'),
columns=[['a', 'b', 'b', 'c'],
['a', 'mean', 'median', 'mean']])
- assert_frame_equal(rs, xp)
+ tm.assert_frame_equal(rs, xp)
rs = df.reset_index('a', col_fill='blah', col_level=1)
xp = DataFrame(full, Index(lrange(3), name='d'),
columns=[['blah', 'b', 'b', 'c'],
['a', 'mean', 'median', 'mean']])
- assert_frame_equal(rs, xp)
+ tm.assert_frame_equal(rs, xp)
def test_reset_index_multiindex_nan(self):
# GH6322, testing reset_index on MultiIndexes
# when we have a nan or all nan
- df = pd.DataFrame({'A': ['a', 'b', 'c'],
- 'B': [0, 1, np.nan],
- 'C': np.random.rand(3)})
+ df = DataFrame({'A': ['a', 'b', 'c'],
+ 'B': [0, 1, np.nan],
+ 'C': np.random.rand(3)})
rs = df.set_index(['A', 'B']).reset_index()
- assert_frame_equal(rs, df)
+ tm.assert_frame_equal(rs, df)
- df = pd.DataFrame({'A': [np.nan, 'b', 'c'],
- 'B': [0, 1, 2],
- 'C': np.random.rand(3)})
+ df = DataFrame({'A': [np.nan, 'b', 'c'],
+ 'B': [0, 1, 2],
+ 'C': np.random.rand(3)})
rs = df.set_index(['A', 'B']).reset_index()
- assert_frame_equal(rs, df)
+ tm.assert_frame_equal(rs, df)
- df = pd.DataFrame({'A': ['a', 'b', 'c'],
- 'B': [0, 1, 2],
- 'C': [np.nan, 1.1, 2.2]})
+ df = DataFrame({'A': ['a', 'b', 'c'],
+ 'B': [0, 1, 2],
+ 'C': [np.nan, 1.1, 2.2]})
rs = df.set_index(['A', 'B']).reset_index()
- assert_frame_equal(rs, df)
+ tm.assert_frame_equal(rs, df)
- df = pd.DataFrame({'A': ['a', 'b', 'c'],
- 'B': [np.nan, np.nan, np.nan],
- 'C': np.random.rand(3)})
+ df = DataFrame({'A': ['a', 'b', 'c'],
+ 'B': [np.nan, np.nan, np.nan],
+ 'C': np.random.rand(3)})
rs = df.set_index(['A', 'B']).reset_index()
- assert_frame_equal(rs, df)
+ tm.assert_frame_equal(rs, df)
def test_reset_index_with_datetimeindex_cols(self):
# GH5818
#
- df = pd.DataFrame([[1, 2], [3, 4]],
- columns=pd.date_range('1/1/2013', '1/2/2013'),
- index=['A', 'B'])
+ df = DataFrame([[1, 2], [3, 4]],
+ columns=date_range('1/1/2013', '1/2/2013'),
+ index=['A', 'B'])
result = df.reset_index()
- expected = pd.DataFrame([['A', 1, 2], ['B', 3, 4]],
- columns=['index', datetime(2013, 1, 1),
- datetime(2013, 1, 2)])
- assert_frame_equal(result, expected)
+ expected = DataFrame([['A', 1, 2], ['B', 3, 4]],
+ columns=['index', datetime(2013, 1, 1),
+ datetime(2013, 1, 2)])
+ tm.assert_frame_equal(result, expected)
def test_reset_index_range(self):
# GH 12071
- df = pd.DataFrame([[0, 0], [1, 1]], columns=['A', 'B'],
- index=RangeIndex(stop=2))
+ df = DataFrame([[0, 0], [1, 1]], columns=['A', 'B'],
+ index=RangeIndex(stop=2))
result = df.reset_index()
assert isinstance(result.index, RangeIndex)
- expected = pd.DataFrame([[0, 0, 0], [1, 1, 1]],
- columns=['index', 'A', 'B'],
- index=RangeIndex(stop=2))
- assert_frame_equal(result, expected)
+ expected = DataFrame([[0, 0, 0], [1, 1, 1]],
+ columns=['index', 'A', 'B'],
+ index=RangeIndex(stop=2))
+ tm.assert_frame_equal(result, expected)
def test_set_index_names(self):
- df = pd.util.testing.makeDataFrame()
+ df = tm.makeDataFrame()
df.index.name = 'name'
assert df.set_index(df.index).index.names == ['name']
@@ -886,63 +917,63 @@ def test_set_index_names(self):
# Check equality
tm.assert_index_equal(df.set_index([df.index, idx2]).index, mi2)
- def test_rename_objects(self):
- renamed = self.mixed_frame.rename(columns=str.upper)
+ def test_rename_objects(self, float_string_frame):
+ renamed = float_string_frame.rename(columns=str.upper)
assert 'FOO' in renamed
assert 'foo' not in renamed
def test_rename_axis_style(self):
# https://github.com/pandas-dev/pandas/issues/12392
- df = pd.DataFrame({"A": [1, 2], "B": [1, 2]}, index=['X', 'Y'])
- expected = pd.DataFrame({"a": [1, 2], "b": [1, 2]}, index=['X', 'Y'])
+ df = DataFrame({"A": [1, 2], "B": [1, 2]}, index=['X', 'Y'])
+ expected = DataFrame({"a": [1, 2], "b": [1, 2]}, index=['X', 'Y'])
result = df.rename(str.lower, axis=1)
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.rename(str.lower, axis='columns')
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.rename({"A": 'a', 'B': 'b'}, axis=1)
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.rename({"A": 'a', 'B': 'b'}, axis='columns')
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
# Index
- expected = pd.DataFrame({"A": [1, 2], "B": [1, 2]}, index=['x', 'y'])
+ expected = DataFrame({"A": [1, 2], "B": [1, 2]}, index=['x', 'y'])
result = df.rename(str.lower, axis=0)
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.rename(str.lower, axis='index')
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.rename({'X': 'x', 'Y': 'y'}, axis=0)
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.rename({'X': 'x', 'Y': 'y'}, axis='index')
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
result = df.rename(mapper=str.lower, axis='index')
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
def test_rename_mapper_multi(self):
- df = pd.DataFrame({"A": ['a', 'b'], "B": ['c', 'd'],
- 'C': [1, 2]}).set_index(["A", "B"])
+ df = DataFrame({"A": ['a', 'b'], "B": ['c', 'd'],
+ 'C': [1, 2]}).set_index(["A", "B"])
result = df.rename(str.upper)
expected = df.rename(index=str.upper)
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
def test_rename_positional_named(self):
# https://github.com/pandas-dev/pandas/issues/12392
- df = pd.DataFrame({"a": [1, 2], "b": [1, 2]}, index=['X', 'Y'])
+ df = DataFrame({"a": [1, 2], "b": [1, 2]}, index=['X', 'Y'])
result = df.rename(str.lower, columns=str.upper)
- expected = pd.DataFrame({"A": [1, 2], "B": [1, 2]}, index=['x', 'y'])
- assert_frame_equal(result, expected)
+ expected = DataFrame({"A": [1, 2], "B": [1, 2]}, index=['x', 'y'])
+ tm.assert_frame_equal(result, expected)
def test_rename_axis_style_raises(self):
# https://github.com/pandas-dev/pandas/issues/12392
- df = pd.DataFrame({"A": [1, 2], "B": [1, 2]}, index=['0', '1'])
+ df = DataFrame({"A": [1, 2], "B": [1, 2]}, index=['0', '1'])
# Named target and axis
with tm.assert_raises_regex(TypeError, None):
@@ -1000,41 +1031,42 @@ def test_reindex_api_equivalence(self):
tm.assert_frame_equal(res1, res)
def test_rename_positional(self):
- df = pd.DataFrame(columns=['A', 'B'])
+ df = DataFrame(columns=['A', 'B'])
with tm.assert_produces_warning(FutureWarning) as rec:
result = df.rename(None, str.lower)
- expected = pd.DataFrame(columns=['a', 'b'])
- assert_frame_equal(result, expected)
+ expected = DataFrame(columns=['a', 'b'])
+ tm.assert_frame_equal(result, expected)
assert len(rec) == 1
message = str(rec[0].message)
assert 'rename' in message
assert 'Use named arguments' in message
- def test_assign_columns(self):
- self.frame['hi'] = 'there'
+ def test_assign_columns(self, float_frame):
+ float_frame['hi'] = 'there'
- frame = self.frame.copy()
- frame.columns = ['foo', 'bar', 'baz', 'quux', 'foo2']
- assert_series_equal(self.frame['C'], frame['baz'], check_names=False)
- assert_series_equal(self.frame['hi'], frame['foo2'], check_names=False)
+ df = float_frame.copy()
+ df.columns = ['foo', 'bar', 'baz', 'quux', 'foo2']
+ tm.assert_series_equal(float_frame['C'], df['baz'], check_names=False)
+ tm.assert_series_equal(float_frame['hi'], df['foo2'],
+ check_names=False)
def test_set_index_preserve_categorical_dtype(self):
# GH13743, GH13854
df = DataFrame({'A': [1, 2, 1, 1, 2],
'B': [10, 16, 22, 28, 34],
- 'C1': pd.Categorical(list("abaab"),
- categories=list("bac"),
- ordered=False),
- 'C2': pd.Categorical(list("abaab"),
- categories=list("bac"),
- ordered=True)})
+ 'C1': Categorical(list("abaab"),
+ categories=list("bac"),
+ ordered=False),
+ 'C2': Categorical(list("abaab"),
+ categories=list("bac"),
+ ordered=True)})
for cols in ['C1', 'C2', ['A', 'C1'], ['A', 'C2'], ['C1', 'C2']]:
result = df.set_index(cols).reset_index()
result = result.reindex(columns=df.columns)
tm.assert_frame_equal(result, df)
def test_ambiguous_warns(self):
- df = pd.DataFrame({"A": [1, 2]})
+ df = DataFrame({"A": [1, 2]})
with tm.assert_produces_warning(FutureWarning):
df.rename(id, id)
@@ -1043,14 +1075,14 @@ def test_ambiguous_warns(self):
@pytest.mark.skipif(PY2, reason="inspect.signature")
def test_rename_signature(self):
- sig = inspect.signature(pd.DataFrame.rename)
+ sig = inspect.signature(DataFrame.rename)
parameters = set(sig.parameters)
assert parameters == {"self", "mapper", "index", "columns", "axis",
"inplace", "copy", "level"}
@pytest.mark.skipif(PY2, reason="inspect.signature")
def test_reindex_signature(self):
- sig = inspect.signature(pd.DataFrame.reindex)
+ sig = inspect.signature(DataFrame.reindex)
parameters = set(sig.parameters)
assert parameters == {"self", "labels", "index", "columns", "axis",
"limit", "copy", "level", "method",
@@ -1058,25 +1090,25 @@ def test_reindex_signature(self):
def test_droplevel(self):
# GH20342
- df = pd.DataFrame([
+ df = DataFrame([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
])
df = df.set_index([0, 1]).rename_axis(['a', 'b'])
- df.columns = pd.MultiIndex.from_tuples([('c', 'e'), ('d', 'f')],
- names=['level_1', 'level_2'])
+ df.columns = MultiIndex.from_tuples([('c', 'e'), ('d', 'f')],
+ names=['level_1', 'level_2'])
# test that dropping of a level in index works
expected = df.reset_index('a', drop=True)
result = df.droplevel('a', axis='index')
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
# test that dropping of a level in columns works
expected = df.copy()
- expected.columns = pd.Index(['c', 'd'], name='level_1')
+ expected.columns = Index(['c', 'd'], name='level_1')
result = df.droplevel('level_2', axis='columns')
- assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
class TestIntervalIndex(object):
@@ -1084,7 +1116,7 @@ class TestIntervalIndex(object):
def test_setitem(self):
df = DataFrame({'A': range(10)})
- s = pd.cut(df.A, 5)
+ s = cut(df.A, 5)
assert isinstance(s.cat.categories, IntervalIndex)
# B & D end up as Categoricals
@@ -1122,7 +1154,7 @@ def test_setitem(self):
def test_set_reset_index(self):
df = DataFrame({'A': range(10)})
- s = pd.cut(df.A, 5)
+ s = cut(df.A, 5)
df['B'] = s
df = df.set_index('B')
| While working on #22225 I had the strong urge to clean up the tests for `df.set_index` (to be able to work off of them for `series.set_index`)
Since the diff is pretty busted, here's a description. In `tests/frame/test_alter_axes.py`, I did:
- externalised an often-used df as a fixture
- broke up `test_set_index2` into several pieces
- renamed `test_set_index_bug` to `test_set_index_after_mutation` (following corresponding GH issue)
- renamed `test_set_index_nonuniq` to `test_set_index_verify_integrity` (also added a MI-case)
- strongly parametrized `test_set_index_pass_arrays` and `test_set_index_duplicate_names`, including several combinations and cases that were not tested before
- replaced everything `pd.` with direct imports (best practice according to review in #21899):
> don’t import pd, directly import instead
- replaced `assert_series_equal` etc. with `tm.assert_series_equal` (best practice according to review in #21899):
> use tm; don’t import assert_series_equal
- cleaned up the other tests a bit too, including several open TODOs and getting rid of the `check_names=False` in several cases.
I also added better warnings in case there are duplicate column labels in `keys`, and some corresponding tests. | https://api.github.com/repos/pandas-dev/pandas/pulls/22236 | 2018-08-07T22:41:48Z | 2018-09-15T22:50:55Z | 2018-09-15T22:50:55Z | 2018-09-16T21:12:21Z |
Assorted _libs cleanups | diff --git a/pandas/_libs/algos_common_helper.pxi.in b/pandas/_libs/algos_common_helper.pxi.in
index 0d3f6664da9e3..97b7196da80bb 100644
--- a/pandas/_libs/algos_common_helper.pxi.in
+++ b/pandas/_libs/algos_common_helper.pxi.in
@@ -523,7 +523,7 @@ def put2d_{{name}}_{{dest_type}}(ndarray[{{c_type}}, ndim=2, cast=True] values,
Py_ssize_t i, j, k
k = len(values)
- for j from 0 <= j < k:
+ for j in range(k):
i = indexer[j]
out[i] = values[j, loc]
diff --git a/pandas/_libs/algos_take_helper.pxi.in b/pandas/_libs/algos_take_helper.pxi.in
index 71bb1bb4fe9be..0e69324acd341 100644
--- a/pandas/_libs/algos_take_helper.pxi.in
+++ b/pandas/_libs/algos_take_helper.pxi.in
@@ -46,7 +46,7 @@ def get_dispatch(dtypes):
fv = fill_value
%(nogil_str)s
- %(tab)sfor i from 0 <= i < n:
+ %(tab)sfor i in range(n):
%(tab)s idx = indexer[i]
%(tab)s if idx == -1:
%(tab)s out[i] = fv
@@ -74,10 +74,10 @@ def get_dispatch(dtypes):
values.strides[1] == sizeof(%(c_type_out)s) and
sizeof(%(c_type_out)s) * n >= 256):
- for i from 0 <= i < n:
+ for i in range(n):
idx = indexer[i]
if idx == -1:
- for j from 0 <= j < k:
+ for j in range(k):
out[i, j] = fv
else:
v = &values[idx, 0]
@@ -85,13 +85,13 @@ def get_dispatch(dtypes):
memmove(o, v, <size_t>(sizeof(%(c_type_out)s) * k))
return
- for i from 0 <= i < n:
+ for i in range(n):
idx = indexer[i]
if idx == -1:
- for j from 0 <= j < k:
+ for j in range(k):
out[i, j] = fv
else:
- for j from 0 <= j < k:
+ for j in range(k):
out[i, j] = %(preval)svalues[idx, j]%(postval)s
"""
@@ -108,8 +108,8 @@ def get_dispatch(dtypes):
fv = fill_value
- for i from 0 <= i < n:
- for j from 0 <= j < k:
+ for i in range(n):
+ for j in range(k):
idx = indexer[j]
if idx == -1:
out[i, j] = fv
@@ -246,13 +246,13 @@ def take_2d_multi_{{name}}_{{dest}}(ndarray[{{c_type_in}}, ndim=2] values,
k = len(idx1)
fv = fill_value
- for i from 0 <= i < n:
+ for i in range(n):
idx = idx0[i]
if idx == -1:
- for j from 0 <= j < k:
+ for j in range(k):
out[i, j] = fv
else:
- for j from 0 <= j < k:
+ for j in range(k):
if idx1[j] == -1:
out[i, j] = fv
else:
diff --git a/pandas/_libs/hashtable_func_helper.pxi.in b/pandas/_libs/hashtable_func_helper.pxi.in
index 521e564447c59..5aea0c65d6dd0 100644
--- a/pandas/_libs/hashtable_func_helper.pxi.in
+++ b/pandas/_libs/hashtable_func_helper.pxi.in
@@ -161,18 +161,18 @@ def duplicated_{{dtype}}({{scalar}}[:] values, object keep='first'):
{{endif}}
elif keep == 'first':
{{if dtype == 'object'}}
- for i from 0 <= i < n:
+ for i in range(n):
kh_put_{{ttype}}(table, <PyObject*> values[i], &ret)
out[i] = ret == 0
{{else}}
with nogil:
- for i from 0 <= i < n:
+ for i in range(n):
kh_put_{{ttype}}(table, values[i], &ret)
out[i] = ret == 0
{{endif}}
else:
{{if dtype == 'object'}}
- for i from 0 <= i < n:
+ for i in range(n):
value = values[i]
k = kh_get_{{ttype}}(table, <PyObject*> value)
if k != table.n_buckets:
@@ -185,7 +185,7 @@ def duplicated_{{dtype}}({{scalar}}[:] values, object keep='first'):
out[i] = 0
{{else}}
with nogil:
- for i from 0 <= i < n:
+ for i in range(n):
value = values[i]
k = kh_get_{{ttype}}(table, value)
if k != table.n_buckets:
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 89a96342a414b..e05905ab63624 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -78,29 +78,30 @@ cdef bint PY2 = sys.version_info[0] == 2
cdef double nan = <double>np.NaN
-def values_from_object(object o):
+def values_from_object(object obj):
""" return my values or the object if we are say an ndarray """
- cdef f
+ cdef func # TODO: Does declaring this without a type accomplish anything?
- f = getattr(o, 'get_values', None)
- if f is not None:
- o = f()
+ func = getattr(obj, 'get_values', None)
+ if func is not None:
+ obj = func()
- return o
+ return obj
@cython.wraparound(False)
@cython.boundscheck(False)
-def memory_usage_of_objects(ndarray[object, ndim=1] arr):
+def memory_usage_of_objects(object[:] arr):
""" return the memory usage of an object array in bytes,
does not include the actual bytes of the pointers """
- cdef Py_ssize_t i, n
- cdef int64_t s = 0
+ cdef:
+ Py_ssize_t i, n
+ int64_t size = 0
n = len(arr)
for i in range(n):
- s += arr[i].__sizeof__()
- return s
+ size += arr[i].__sizeof__()
+ return size
# ----------------------------------------------------------------------
diff --git a/pandas/_libs/ops.pyx b/pandas/_libs/ops.pyx
index ec9d8304f9243..a194f1588e231 100644
--- a/pandas/_libs/ops.pyx
+++ b/pandas/_libs/ops.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
import operator
from cpython cimport (PyFloat_Check, PyBool_Check,
@@ -21,7 +20,7 @@ from missing cimport checknull
@cython.wraparound(False)
@cython.boundscheck(False)
-def scalar_compare(ndarray[object] values, object val, object op):
+def scalar_compare(object[:] values, object val, object op):
"""
Compare each element of `values` array with the scalar `val`, with
the comparison operation described by `op`.
@@ -73,7 +72,7 @@ def scalar_compare(ndarray[object] values, object val, object op):
else:
try:
result[i] = PyObject_RichCompareBool(x, val, flag)
- except (TypeError):
+ except TypeError:
result[i] = True
elif flag == Py_EQ:
for i in range(n):
@@ -85,7 +84,7 @@ def scalar_compare(ndarray[object] values, object val, object op):
else:
try:
result[i] = PyObject_RichCompareBool(x, val, flag)
- except (TypeError):
+ except TypeError:
result[i] = False
else:
@@ -103,7 +102,7 @@ def scalar_compare(ndarray[object] values, object val, object op):
@cython.wraparound(False)
@cython.boundscheck(False)
-def vec_compare(ndarray[object] left, ndarray[object] right, object op):
+def vec_compare(object[:] left, object[:] right, object op):
"""
Compare the elements of `left` with the elements of `right` pointwise,
with the comparison operation described by `op`.
@@ -126,8 +125,8 @@ def vec_compare(ndarray[object] left, ndarray[object] right, object op):
int flag
if n != len(right):
- raise ValueError('Arrays were different lengths: %d vs %d'
- % (n, len(right)))
+ raise ValueError('Arrays were different lengths: {n} vs {nright}'
+ .format(n=n, nright=len(right)))
if op is operator.lt:
flag = Py_LT
@@ -170,7 +169,7 @@ def vec_compare(ndarray[object] left, ndarray[object] right, object op):
@cython.wraparound(False)
@cython.boundscheck(False)
-def scalar_binop(ndarray[object] values, object val, object op):
+def scalar_binop(object[:] values, object val, object op):
"""
Apply the given binary operator `op` between each element of the array
`values` and the scalar `val`.
@@ -187,13 +186,13 @@ def scalar_binop(ndarray[object] values, object val, object op):
"""
cdef:
Py_ssize_t i, n = len(values)
- ndarray[object] result
+ object[:] result
object x
result = np.empty(n, dtype=object)
if val is None or is_nan(val):
- result.fill(val)
- return result
+ result[:] = val
+ return result.base # `.base` to access underlying np.ndarray
for i in range(n):
x = values[i]
@@ -202,12 +201,12 @@ def scalar_binop(ndarray[object] values, object val, object op):
else:
result[i] = op(x, val)
- return maybe_convert_bool(result)
+ return maybe_convert_bool(result.base)
@cython.wraparound(False)
@cython.boundscheck(False)
-def vec_binop(ndarray[object] left, ndarray[object] right, object op):
+def vec_binop(object[:] left, object[:] right, object op):
"""
Apply the given binary operator `op` pointwise to the elements of
arrays `left` and `right`.
@@ -224,11 +223,11 @@ def vec_binop(ndarray[object] left, ndarray[object] right, object op):
"""
cdef:
Py_ssize_t i, n = len(left)
- ndarray[object] result
+ object[:] result
if n != len(right):
- raise ValueError('Arrays were different lengths: %d vs %d'
- % (n, len(right)))
+ raise ValueError('Arrays were different lengths: {n} vs {nright}'
+ .format(n=n, nright=len(right)))
result = np.empty(n, dtype=object)
@@ -245,7 +244,7 @@ def vec_binop(ndarray[object] left, ndarray[object] right, object op):
else:
raise
- return maybe_convert_bool(result)
+ return maybe_convert_bool(result.base) # `.base` to access np.ndarray
def maybe_convert_bool(ndarray[object] arr,
@@ -270,7 +269,7 @@ def maybe_convert_bool(ndarray[object] arr,
if false_values is not None:
false_vals = false_vals | set(false_values)
- for i from 0 <= i < n:
+ for i in range(n):
val = arr[i]
if PyBool_Check(val):
diff --git a/pandas/_libs/sparse.pyx b/pandas/_libs/sparse.pyx
index 2abd270652433..7f5990ce5d65c 100644
--- a/pandas/_libs/sparse.pyx
+++ b/pandas/_libs/sparse.pyx
@@ -148,7 +148,7 @@ cdef class IntIndex(SparseIndex):
new_indices = np.empty(min(
len(xindices), len(yindices)), dtype=np.int32)
- for xi from 0 <= xi < self.npoints:
+ for xi in range(self.npoints):
xind = xindices[xi]
while yi < y.npoints and yindices[yi] < xind:
@@ -292,7 +292,7 @@ cpdef get_blocks(ndarray[int32_t, ndim=1] indices):
# TODO: two-pass algorithm faster?
prev = block = indices[0]
- for i from 1 <= i < npoints:
+ for i in range(1, npoints):
cur = indices[i]
if cur - prev > 1:
# new block
@@ -383,21 +383,22 @@ cdef class BlockIndex(SparseIndex):
if len(blocs) != len(blengths):
raise ValueError('block bound arrays must be same length')
- for i from 0 <= i < self.nblocks:
+ for i in range(self.nblocks):
if i > 0:
if blocs[i] <= blocs[i - 1]:
raise ValueError('Locations not in ascending order')
if i < self.nblocks - 1:
if blocs[i] + blengths[i] > blocs[i + 1]:
- raise ValueError('Block %d overlaps' % i)
+ raise ValueError('Block {idx} overlaps'.format(idx=i))
else:
if blocs[i] + blengths[i] > self.length:
- raise ValueError('Block %d extends beyond end' % i)
+ raise ValueError('Block {idx} extends beyond end'
+ .format(idx=i))
# no zero-length blocks
if blengths[i] == 0:
- raise ValueError('Zero-length block %d' % i)
+ raise ValueError('Zero-length block {idx}'.format(idx=i))
def equals(self, other):
if not isinstance(other, BlockIndex):
@@ -422,10 +423,10 @@ cdef class BlockIndex(SparseIndex):
indices = np.empty(self.npoints, dtype=np.int32)
- for b from 0 <= b < self.nblocks:
+ for b in range(self.nblocks):
offset = self.locbuf[b]
- for j from 0 <= j < self.lenbuf[b]:
+ for j in range(self.lenbuf[b]):
indices[i] = offset + j
i += 1
@@ -551,7 +552,7 @@ cdef class BlockIndex(SparseIndex):
return -1
cum_len = 0
- for i from 0 <= i < self.nblocks:
+ for i in range(self.nblocks):
if index >= locs[i] and index < locs[i] + lens[i]:
return cum_len + index - locs[i]
cum_len += lens[i]
@@ -579,11 +580,11 @@ cdef class BlockIndex(SparseIndex):
if self.npoints == 0:
return results
- for i from 0 <= i < n:
+ for i in range(n):
ind_val = indexer[i]
if not (ind_val < 0 or self.length <= ind_val):
cum_len = 0
- for j from 0 <= j < self.nblocks:
+ for j in range(self.nblocks):
if ind_val >= locs[j] and ind_val < locs[j] + lens[j]:
results[i] = cum_len + ind_val - locs[j]
cum_len += lens[j]
@@ -824,7 +825,7 @@ def get_reindexer(ndarray[object, ndim=1] values, dict index_map):
# out = np.empty(length, dtype=np.float64)
-# for i from 0 <= i < length:
+# for i in range(length):
# if indexer[i] == -1:
# pass
diff --git a/pandas/_libs/sparse_op_helper.pxi.in b/pandas/_libs/sparse_op_helper.pxi.in
index d1d9a6f02a72c..2843a3cf7dd28 100644
--- a/pandas/_libs/sparse_op_helper.pxi.in
+++ b/pandas/_libs/sparse_op_helper.pxi.in
@@ -190,7 +190,7 @@ cdef inline tuple block_op_{{opname}}_{{dtype}}(ndarray x_,
# Wow, what a hack job. Need to do something about this
# walk the two SparseVectors, adding matched locations...
- for out_i from 0 <= out_i < out_index.npoints:
+ for out_i in range(out_index.npoints):
if yblock == yindex.nblocks:
# use y fill value
out[out_i] = {{(opname, 'x[xi]', 'yfill', dtype) | get_op}}
@@ -286,7 +286,7 @@ cdef inline tuple int_op_{{opname}}_{{dtype}}(ndarray x_, IntIndex xindex,
out_indices = out_index.indices
# walk the two SparseVectors, adding matched locations...
- for out_i from 0 <= out_i < out_index.npoints:
+ for out_i in range(out_index.npoints):
if xi == xindex.npoints:
# use x fill value
out[out_i] = {{(opname, 'xfill', 'y[yi]', dtype) | get_op}}
diff --git a/pandas/_libs/src/compat_helper.h b/pandas/_libs/src/compat_helper.h
index 116cd91070a60..462f53392adee 100644
--- a/pandas/_libs/src/compat_helper.h
+++ b/pandas/_libs/src/compat_helper.h
@@ -11,7 +11,7 @@ The full license is in the LICENSE file, distributed with this software.
#define PANDAS__LIBS_SRC_COMPAT_HELPER_H_
#include "Python.h"
-#include "helper.h"
+#include "inline_helper.h"
/*
PySlice_GetIndicesEx changes signature in PY3
diff --git a/pandas/_libs/src/helper.h b/pandas/_libs/src/inline_helper.h
similarity index 80%
rename from pandas/_libs/src/helper.h
rename to pandas/_libs/src/inline_helper.h
index 26b4d033b963b..397ec8e7b2cb8 100644
--- a/pandas/_libs/src/helper.h
+++ b/pandas/_libs/src/inline_helper.h
@@ -7,8 +7,8 @@ Distributed under the terms of the BSD Simplified License.
The full license is in the LICENSE file, distributed with this software.
*/
-#ifndef PANDAS__LIBS_SRC_HELPER_H_
-#define PANDAS__LIBS_SRC_HELPER_H_
+#ifndef PANDAS__LIBS_SRC_INLINE_HELPER_H_
+#define PANDAS__LIBS_SRC_INLINE_HELPER_H_
#ifndef PANDAS_INLINE
#if defined(__GNUC__)
@@ -22,4 +22,4 @@ The full license is in the LICENSE file, distributed with this software.
#endif
#endif
-#endif // PANDAS__LIBS_SRC_HELPER_H_
+#endif // PANDAS__LIBS_SRC_INLINE_HELPER_H_
diff --git a/pandas/_libs/src/klib/khash.h b/pandas/_libs/src/klib/khash.h
index 869607a44c001..77ec519cc24da 100644
--- a/pandas/_libs/src/klib/khash.h
+++ b/pandas/_libs/src/klib/khash.h
@@ -112,6 +112,7 @@ int main() {
#include <stdlib.h>
#include <string.h>
#include <limits.h>
+#include "../inline_helper.h"
#if UINT_MAX == 0xffffffffu
@@ -130,18 +131,6 @@ typedef signed long long khint64_t;
typedef double khfloat64_t;
-#ifndef PANDAS_INLINE
- #if defined(__GNUC__)
- #define PANDAS_INLINE static __inline__
- #elif defined(_MSC_VER)
- #define PANDAS_INLINE static __inline
- #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
- #define PANDAS_INLINE static inline
- #else
- #define PANDAS_INLINE
- #endif
-#endif
-
typedef khint32_t khint_t;
typedef khint_t khiter_t;
diff --git a/pandas/_libs/src/numpy_helper.h b/pandas/_libs/src/numpy_helper.h
index 753cba6ce62aa..d44334906901a 100644
--- a/pandas/_libs/src/numpy_helper.h
+++ b/pandas/_libs/src/numpy_helper.h
@@ -11,7 +11,7 @@ The full license is in the LICENSE file, distributed with this software.
#define PANDAS__LIBS_SRC_NUMPY_HELPER_H_
#include "Python.h"
-#include "helper.h"
+#include "inline_helper.h"
#include "numpy/arrayobject.h"
#include "numpy/arrayscalars.h"
diff --git a/pandas/_libs/src/parse_helper.h b/pandas/_libs/src/parse_helper.h
index d17d9166ea3ee..4f9f825b15ffe 100644
--- a/pandas/_libs/src/parse_helper.h
+++ b/pandas/_libs/src/parse_helper.h
@@ -12,7 +12,7 @@ The full license is in the LICENSE file, distributed with this software.
#include <errno.h>
#include <float.h>
-#include "helper.h"
+#include "inline_helper.h"
#include "headers/portable.h"
static double xstrtod(const char *p, char **q, char decimal, char sci,
diff --git a/pandas/_libs/src/parser/tokenizer.c b/pandas/_libs/src/parser/tokenizer.c
index a18d12616a802..da0a9f7498aa8 100644
--- a/pandas/_libs/src/parser/tokenizer.c
+++ b/pandas/_libs/src/parser/tokenizer.c
@@ -363,7 +363,7 @@ static int push_char(parser_t *self, char c) {
return 0;
}
-int P_INLINE end_field(parser_t *self) {
+int PANDAS_INLINE end_field(parser_t *self) {
// XXX cruft
if (self->words_len >= self->words_cap) {
TRACE(
@@ -1381,11 +1381,11 @@ int tokenize_all_rows(parser_t *self) {
return status;
}
-P_INLINE void uppercase(char *p) {
+PANDAS_INLINE void uppercase(char *p) {
for (; *p; ++p) *p = toupper(*p);
}
-int P_INLINE to_longlong(char *item, long long *p_value) {
+int PANDAS_INLINE to_longlong(char *item, long long *p_value) {
char *p_end;
// Try integer conversion. We explicitly give the base to be 10. If
diff --git a/pandas/_libs/src/parser/tokenizer.h b/pandas/_libs/src/parser/tokenizer.h
index 63baf91e3c136..9fc3593aaaf5b 100644
--- a/pandas/_libs/src/parser/tokenizer.h
+++ b/pandas/_libs/src/parser/tokenizer.h
@@ -27,6 +27,7 @@ See LICENSE for the license
#define ERROR_INVALID_CHARS 3
#include "../headers/stdint.h"
+#include "../inline_helper.h"
#include "khash.h"
@@ -38,17 +39,6 @@ See LICENSE for the license
#define REACHED_EOF 1
#define CALLING_READ_FAILED 2
-#ifndef P_INLINE
-#if defined(__GNUC__)
-#define P_INLINE static __inline__
-#elif defined(_MSC_VER)
-#define P_INLINE
-#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#define P_INLINE static inline
-#else
-#define P_INLINE
-#endif
-#endif
#if defined(_MSC_VER)
#define strtoll _strtoi64
diff --git a/pandas/_libs/src/skiplist.h b/pandas/_libs/src/skiplist.h
index f9527e72f577e..60c1a56727777 100644
--- a/pandas/_libs/src/skiplist.h
+++ b/pandas/_libs/src/skiplist.h
@@ -20,18 +20,7 @@ Python recipe (http://rhettinger.wordpress.com/2010/02/06/lost-knowledge/)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-
-#ifndef PANDAS_INLINE
-#if defined(__GNUC__)
-#define PANDAS_INLINE static __inline__
-#elif defined(_MSC_VER)
-#define PANDAS_INLINE static __inline
-#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#define PANDAS_INLINE static inline
-#else
-#define PANDAS_INLINE
-#endif
-#endif
+#include "inline_helper.h"
PANDAS_INLINE float __skiplist_nanf(void) {
const union {
diff --git a/pandas/_libs/tslibs/frequencies.pyx b/pandas/_libs/tslibs/frequencies.pyx
index 7e9e8b720872d..70a3f3f410636 100644
--- a/pandas/_libs/tslibs/frequencies.pyx
+++ b/pandas/_libs/tslibs/frequencies.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
import re
cimport numpy as cnp
diff --git a/pandas/_libs/tslibs/np_datetime.pxd b/pandas/_libs/tslibs/np_datetime.pxd
index a585259286a58..c3d229d4e5006 100644
--- a/pandas/_libs/tslibs/np_datetime.pxd
+++ b/pandas/_libs/tslibs/np_datetime.pxd
@@ -46,7 +46,7 @@ cdef extern from "numpy/ndarraytypes.h":
NPY_FR_fs
NPY_FR_as
-cdef extern from "../src/datetime/np_datetime.h":
+cdef extern from "src/datetime/np_datetime.h":
ctypedef struct pandas_timedeltastruct:
int64_t days
int32_t hrs, min, sec, ms, us, ns, seconds, microseconds, nanoseconds
diff --git a/pandas/_libs/tslibs/np_datetime.pyx b/pandas/_libs/tslibs/np_datetime.pyx
index 76838c7a23b24..a0099837e876a 100644
--- a/pandas/_libs/tslibs/np_datetime.pyx
+++ b/pandas/_libs/tslibs/np_datetime.pyx
@@ -15,7 +15,7 @@ PyDateTime_IMPORT
from numpy cimport int64_t
-cdef extern from "../src/datetime/np_datetime.h":
+cdef extern from "src/datetime/np_datetime.h":
int cmp_npy_datetimestruct(npy_datetimestruct *a,
npy_datetimestruct *b)
@@ -33,7 +33,7 @@ cdef extern from "../src/datetime/np_datetime.h":
npy_datetimestruct _NS_MIN_DTS, _NS_MAX_DTS
-cdef extern from "../src/datetime/np_datetime_strings.h":
+cdef extern from "src/datetime/np_datetime_strings.h":
int parse_iso_8601_datetime(char *str, int len,
npy_datetimestruct *out,
int *out_local, int *out_tzoffset)
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 7a279a41709ec..8c53fabffdbeb 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
cimport cython
from cython cimport Py_ssize_t
@@ -31,17 +30,6 @@ from np_datetime cimport (npy_datetimestruct,
# Constants
-class WeekDay(object):
- # TODO: Remove: This is not used outside of tests
- MON = 0
- TUE = 1
- WED = 2
- THU = 3
- FRI = 4
- SAT = 5
- SUN = 6
-
-
_offset_to_period_map = {
'WEEKDAY': 'D',
'EOM': 'M',
diff --git a/pandas/_libs/tslibs/parsing.pyx b/pandas/_libs/tslibs/parsing.pyx
index 61fb48c6913d3..6ee6c4b9d9026 100644
--- a/pandas/_libs/tslibs/parsing.pyx
+++ b/pandas/_libs/tslibs/parsing.pyx
@@ -1,25 +1,22 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
"""
Parsing functions for datetime and datetime-like strings.
"""
import sys
import re
+import time
-from cython cimport Py_ssize_t
-
+from cython import Py_ssize_t
from cpython.datetime cimport datetime
-import time
+
import numpy as np
# Avoid import from outside _libs
if sys.version_info.major == 2:
- string_types = basestring
from StringIO import StringIO
else:
- string_types = str
from io import StringIO
@@ -113,7 +110,9 @@ def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
-------
datetime, datetime/dateutil.parser._result, str
"""
- if not isinstance(arg, string_types):
+ if not isinstance(arg, (str, unicode)):
+ # Note: cython recognizes `unicode` in both py2/py3, optimizes
+ # this check into a C call.
return arg
if getattr(freq, "_typ", None) == "dateoffset":
@@ -132,15 +131,22 @@ def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
return res
-def parse_datetime_string_with_reso(date_string, freq=None, dayfirst=False,
- yearfirst=False, **kwargs):
+cdef parse_datetime_string_with_reso(date_string, freq=None, dayfirst=False,
+ yearfirst=False):
"""parse datetime string, only returns datetime
Returns
-------
- datetime
+ parsed : datetime
+ parsed2 : datetime/dateutil.parser._result
+ reso : str
+ inferred resolution
+
+ Raises
+ ------
+ ValueError : preliminary check suggests string is not datetime
+ DateParseError : error within dateutil
"""
-
cdef:
object parsed, reso
@@ -156,12 +162,13 @@ def parse_datetime_string_with_reso(date_string, freq=None, dayfirst=False,
try:
parsed, reso = dateutil_parse(date_string, _DEFAULT_DATETIME,
- dayfirst=dayfirst, yearfirst=yearfirst)
+ dayfirst=dayfirst, yearfirst=yearfirst,
+ ignoretz=False, tzinfos=None)
except Exception as e:
# TODO: allow raise of errors within instead
raise DateParseError(e)
if parsed is None:
- raise DateParseError("Could not parse %s" % date_string)
+ raise DateParseError("Could not parse {dstr}".format(dstr=date_string))
return parsed, parsed, reso
@@ -190,7 +197,7 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
int year, quarter = -1, month, mnum, date_len
# special handling for possibilities eg, 2Q2005, 2Q05, 2005Q1, 05Q1
- assert isinstance(date_string, string_types)
+ assert isinstance(date_string, (str, unicode))
# len(date_string) == 0
# should be NaT???
@@ -243,8 +250,8 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
if not (1 <= quarter <= 4):
msg = ('Incorrect quarterly string is given, quarter must be '
- 'between 1 and 4: {0}')
- raise DateParseError(msg.format(date_string))
+ 'between 1 and 4: {dstr}')
+ raise DateParseError(msg.format(dstr=date_string))
if freq is not None:
# hack attack, #1228
@@ -252,7 +259,7 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
mnum = MONTH_NUMBERS[_get_rule_month(freq)] + 1
except (KeyError, ValueError):
msg = ('Unable to retrieve month information from given '
- 'freq: {0}').format(freq)
+ 'freq: {freq}'.format(freq=freq))
raise DateParseError(msg)
month = (mnum + (quarter - 1) * 3) % 12 + 1
@@ -289,8 +296,8 @@ cdef inline object _parse_dateabbr_string(object date_string, object default,
raise ValueError('Unable to parse {0}'.format(date_string))
-def dateutil_parse(object timestr, object default, ignoretz=False,
- tzinfos=None, **kwargs):
+cdef dateutil_parse(object timestr, object default, ignoretz=False,
+ tzinfos=None, dayfirst=None, yearfirst=None):
""" lifted from dateutil to get resolution"""
cdef:
@@ -299,15 +306,15 @@ def dateutil_parse(object timestr, object default, ignoretz=False,
dict repl = {}
fobj = StringIO(str(timestr))
- res = DEFAULTPARSER._parse(fobj, **kwargs)
+ res = DEFAULTPARSER._parse(fobj, dayfirst=dayfirst, yearfirst=yearfirst)
# dateutil 2.2 compat
if isinstance(res, tuple): # PyTuple_Check
res, _ = res
if res is None:
- msg = "Unknown datetime string format, unable to parse: {0}"
- raise ValueError(msg.format(timestr))
+ msg = "Unknown datetime string format, unable to parse: {timestr}"
+ raise ValueError(msg.format(timestr=timestr))
for attr in ["year", "month", "day", "hour",
"minute", "second", "microsecond"]:
@@ -317,8 +324,8 @@ def dateutil_parse(object timestr, object default, ignoretz=False,
reso = attr
if reso is None:
- msg = "Unable to parse datetime string: {0}"
- raise ValueError(msg.format(timestr))
+ msg = "Unable to parse datetime string: {timestr}"
+ raise ValueError(msg.format(timestr=timestr))
if reso == 'microsecond':
if repl['microsecond'] == 0:
@@ -337,7 +344,7 @@ def dateutil_parse(object timestr, object default, ignoretz=False,
tzdata = tzinfos.get(res.tzname)
if isinstance(tzdata, datetime.tzinfo):
tzinfo = tzdata
- elif isinstance(tzdata, string_types):
+ elif isinstance(tzdata, (str, unicode)):
tzinfo = _dateutil_tzstr(tzdata)
elif isinstance(tzdata, int):
tzinfo = tzoffset(res.tzname, tzdata)
@@ -575,7 +582,7 @@ def _guess_datetime_format(dt_str, dayfirst=False, dt_str_parse=du_parse,
if dt_str_parse is None or dt_str_split is None:
return None
- if not isinstance(dt_str, string_types):
+ if not isinstance(dt_str, (str, unicode)):
return None
day_attribute_and_format = (('day',), '%d', 2)
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index 65b37759ce9ce..f68b6d8fdef57 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -26,12 +26,12 @@ from np_datetime cimport (npy_datetimestruct, dtstruct_to_dt64,
pandas_datetime_to_datetimestruct,
NPY_DATETIMEUNIT, NPY_FR_D)
-cdef extern from "../src/datetime/np_datetime.h":
+cdef extern from "src/datetime/np_datetime.h":
int64_t npy_datetimestruct_to_datetime(NPY_DATETIMEUNIT fr,
npy_datetimestruct *d) nogil
cimport util
-from util cimport is_period_object, is_string_object, INT32_MIN
+from util cimport is_period_object, is_string_object
from timestamps import Timestamp
from timezones cimport is_utc, is_tzlocal, get_dst_info
@@ -53,6 +53,8 @@ from offsets cimport to_offset
from offsets import _Tick
cdef bint PY2 = str == bytes
+cdef enum:
+ INT32_MIN = -2147483648
ctypedef struct asfreq_info:
@@ -67,60 +69,24 @@ ctypedef int64_t (*freq_conv_func)(int64_t, asfreq_info*) nogil
cdef extern from *:
"""
/*** FREQUENCY CONSTANTS ***/
+ // See frequencies.pyx for more detailed variants
#define FR_ANN 1000 /* Annual */
- #define FR_ANNDEC FR_ANN /* Annual - December year end*/
- #define FR_ANNJAN 1001 /* Annual - January year end*/
- #define FR_ANNFEB 1002 /* Annual - February year end*/
- #define FR_ANNMAR 1003 /* Annual - March year end*/
- #define FR_ANNAPR 1004 /* Annual - April year end*/
- #define FR_ANNMAY 1005 /* Annual - May year end*/
- #define FR_ANNJUN 1006 /* Annual - June year end*/
- #define FR_ANNJUL 1007 /* Annual - July year end*/
- #define FR_ANNAUG 1008 /* Annual - August year end*/
- #define FR_ANNSEP 1009 /* Annual - September year end*/
- #define FR_ANNOCT 1010 /* Annual - October year end*/
- #define FR_ANNNOV 1011 /* Annual - November year end*/
-
- /* The standard quarterly frequencies with various fiscal year ends
- eg, Q42005 for Q@OCT runs Aug 1, 2005 to Oct 31, 2005 */
#define FR_QTR 2000 /* Quarterly - December year end (default Q) */
- #define FR_QTRDEC FR_QTR /* Quarterly - December year end */
- #define FR_QTRJAN 2001 /* Quarterly - January year end */
- #define FR_QTRFEB 2002 /* Quarterly - February year end */
- #define FR_QTRMAR 2003 /* Quarterly - March year end */
- #define FR_QTRAPR 2004 /* Quarterly - April year end */
- #define FR_QTRMAY 2005 /* Quarterly - May year end */
- #define FR_QTRJUN 2006 /* Quarterly - June year end */
- #define FR_QTRJUL 2007 /* Quarterly - July year end */
- #define FR_QTRAUG 2008 /* Quarterly - August year end */
- #define FR_QTRSEP 2009 /* Quarterly - September year end */
- #define FR_QTROCT 2010 /* Quarterly - October year end */
- #define FR_QTRNOV 2011 /* Quarterly - November year end */
-
- #define FR_MTH 3000 /* Monthly */
-
- #define FR_WK 4000 /* Weekly */
- #define FR_WKSUN FR_WK /* Weekly - Sunday end of week */
- #define FR_WKMON 4001 /* Weekly - Monday end of week */
- #define FR_WKTUE 4002 /* Weekly - Tuesday end of week */
- #define FR_WKWED 4003 /* Weekly - Wednesday end of week */
- #define FR_WKTHU 4004 /* Weekly - Thursday end of week */
- #define FR_WKFRI 4005 /* Weekly - Friday end of week */
- #define FR_WKSAT 4006 /* Weekly - Saturday end of week */
-
- #define FR_BUS 5000 /* Business days */
- #define FR_DAY 6000 /* Daily */
- #define FR_HR 7000 /* Hourly */
- #define FR_MIN 8000 /* Minutely */
- #define FR_SEC 9000 /* Secondly */
- #define FR_MS 10000 /* Millisecondly */
- #define FR_US 11000 /* Microsecondly */
- #define FR_NS 12000 /* Nanosecondly */
-
- #define FR_UND -10000 /* Undefined */
-
- static int64_t daytime_conversion_factor_matrix[7][7] = {
+ #define FR_MTH 3000 /* Monthly */
+ #define FR_WK 4000 /* Weekly */
+ #define FR_BUS 5000 /* Business days */
+ #define FR_DAY 6000 /* Daily */
+ #define FR_HR 7000 /* Hourly */
+ #define FR_MIN 8000 /* Minutely */
+ #define FR_SEC 9000 /* Secondly */
+ #define FR_MS 10000 /* Millisecondly */
+ #define FR_US 11000 /* Microsecondly */
+ #define FR_NS 12000 /* Nanosecondly */
+ #define FR_UND -10000 /* Undefined */
+
+ // must use npy typedef b/c int64_t is aliased in cython-generated c
+ static npy_int64 daytime_conversion_factor_matrix[7][7] = {
{1, 24, 1440, 86400, 86400000, 86400000000, 86400000000000},
{0, 1, 60, 3600, 3600000, 3600000000, 3600000000000},
{0, 0, 1, 60, 60000, 60000000, 60000000000},
@@ -128,26 +94,9 @@ cdef extern from *:
{0, 0, 0, 0, 1, 1000, 1000000},
{0, 0, 0, 0, 0, 1, 1000},
{0, 0, 0, 0, 0, 0, 1}};
-
- int max_value(int a, int b) { return a > b ? a : b; }
-
- static int min_value(int a, int b) { return a < b ? a : b; }
-
- npy_int64 get_daytime_conversion_factor(int from_index, int to_index) {
- int row = min_value(from_index, to_index);
- int col = max_value(from_index, to_index);
- // row or col < 6 means frequency strictly lower than Daily, which
- // do not use daytime_conversion_factors
- if (row < 6) {
- return 0;
- } else if (col < 6) {
- return 0;
- }
- return daytime_conversion_factor_matrix[row - 6][col - 6];
- }
"""
- int64_t get_daytime_conversion_factor(int from_index, int to_index) nogil
- int max_value(int left, int right) nogil
+ int64_t daytime_conversion_factor_matrix[7][7]
+ # TODO: Can we get these frequencies from frequencies.FreqGroup?
int FR_ANN
int FR_QTR
int FR_MTH
@@ -163,6 +112,31 @@ cdef extern from *:
int FR_UND
+cdef int max_value(int left, int right) nogil:
+ if left > right:
+ return left
+ return right
+
+
+cdef int min_value(int left, int right) nogil:
+ if left < right:
+ return left
+ return right
+
+
+cdef int64_t get_daytime_conversion_factor(int from_index, int to_index) nogil:
+ cdef:
+ int row = min_value(from_index, to_index)
+ int col = max_value(from_index, to_index)
+ # row or col < 6 means frequency strictly lower than Daily, which
+ # do not use daytime_conversion_factors
+ if row < 6:
+ return 0
+ elif col < 6:
+ return 0
+ return daytime_conversion_factor_matrix[row - 6][col - 6]
+
+
cdef int64_t nofunc(int64_t ordinal, asfreq_info *af_info):
return np.iinfo(np.int32).min
@@ -1250,7 +1224,7 @@ def period_format(int64_t value, int freq, object fmt=None):
elif freq_group == 12000: # NANOSEC
fmt = b'%Y-%m-%d %H:%M:%S.%n'
else:
- raise ValueError('Unknown freq: %d' % freq)
+ raise ValueError('Unknown freq: {freq}'.format(freq=freq))
return _period_strftime(value, freq, fmt)
@@ -1415,7 +1389,7 @@ def get_period_field_arr(int code, int64_t[:] arr, int freq):
func = _get_accessor_func(code)
if func is NULL:
- raise ValueError('Unrecognized period code: %d' % code)
+ raise ValueError('Unrecognized period code: {code}'.format(code=code))
sz = len(arr)
out = np.empty(sz, dtype=np.int64)
@@ -1597,7 +1571,8 @@ cdef class _Period(object):
if freq.n <= 0:
raise ValueError('Frequency must be positive, because it'
- ' represents span: {0}'.format(freq.freqstr))
+ ' represents span: {freqstr}'
+ .format(freqstr=freq.freqstr))
return freq
@@ -1629,8 +1604,9 @@ cdef class _Period(object):
return NotImplemented
elif op == Py_NE:
return NotImplemented
- raise TypeError('Cannot compare type %r with type %r' %
- (type(self).__name__, type(other).__name__))
+ raise TypeError('Cannot compare type {cls} with type {typ}'
+ .format(cls=type(self).__name__,
+ typ=type(other).__name__))
def __hash__(self):
return hash((self.ordinal, self.freqstr))
@@ -2428,8 +2404,8 @@ class Period(_Period):
freq = cls._maybe_convert_freq(freq)
if ordinal is not None and value is not None:
- raise ValueError(("Only value or ordinal but not both should be "
- "given but not both"))
+ raise ValueError("Only value or ordinal but not both should be "
+ "given but not both")
elif ordinal is not None:
if not util.is_integer_object(ordinal):
raise ValueError("Ordinal must be an integer")
@@ -2481,7 +2457,8 @@ class Period(_Period):
freq = Resolution.get_freq(reso)
except KeyError:
raise ValueError(
- "Invalid frequency or could not infer: %s" % reso)
+ "Invalid frequency or could not infer: {reso}"
+ .format(reso=reso))
elif isinstance(value, datetime):
dt = value
diff --git a/pandas/_libs/tslibs/resolution.pyx b/pandas/_libs/tslibs/resolution.pyx
index 83be739a6ae0a..4e3350395400c 100644
--- a/pandas/_libs/tslibs/resolution.pyx
+++ b/pandas/_libs/tslibs/resolution.pyx
@@ -1,5 +1,4 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
from cython cimport Py_ssize_t
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime.c b/pandas/_libs/tslibs/src/datetime/np_datetime.c
index 659afd152106d..866c9ca9d3ac7 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime.c
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime.c
@@ -50,18 +50,6 @@ int is_leapyear(npy_int64 year) {
((year % 100) != 0 || (year % 400) == 0);
}
-/*
- * Sakamoto's method, from wikipedia
- */
-int dayofweek(int y, int m, int d) {
- int day;
- static const int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
- y -= m < 3;
- day = (y + y / 4 - y / 100 + y / 400 + t[m - 1] + d) % 7;
- // convert to python day
- return (day + 6) % 7;
-}
-
/*
* Adjusts a datetimestruct based on a minutes offset. Assumes
* the current values are valid.g
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime.h b/pandas/_libs/tslibs/src/datetime/np_datetime.h
index 3974d5083f51b..549d38409ca83 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime.h
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime.h
@@ -48,8 +48,6 @@ void pandas_timedelta_to_timedeltastruct(npy_timedelta val,
NPY_DATETIMEUNIT fr,
pandas_timedeltastruct *result);
-int dayofweek(int y, int m, int d);
-
extern const int days_per_month_table[2][12];
// stuff numpy-derived code needs in header
diff --git a/pandas/_libs/tslibs/strptime.pyx b/pandas/_libs/tslibs/strptime.pyx
index 8e7c55051a3c0..d472320cfdb12 100644
--- a/pandas/_libs/tslibs/strptime.pyx
+++ b/pandas/_libs/tslibs/strptime.pyx
@@ -1,11 +1,11 @@
# -*- coding: utf-8 -*-
-# cython: profile=False
"""Strptime-related classes and functions.
"""
import time
import locale
import calendar
import re
+from datetime import date as datetime_date
# Python 2 vs Python 3
@@ -20,14 +20,14 @@ except:
except:
from _dummy_thread import allocate_lock as _thread_allocate_lock
-import pytz
-
from cython cimport Py_ssize_t
+
+import pytz
+
import numpy as np
from numpy cimport int64_t
-from datetime import date as datetime_date
from np_datetime cimport (check_dts_bounds,
dtstruct_to_dt64, npy_datetimestruct)
diff --git a/pandas/_libs/tslibs/timedeltas.pxd b/pandas/_libs/tslibs/timedeltas.pxd
index 2413c281e0a52..ef9fd3207e5f0 100644
--- a/pandas/_libs/tslibs/timedeltas.pxd
+++ b/pandas/_libs/tslibs/timedeltas.pxd
@@ -1,8 +1,6 @@
# -*- coding: utf-8 -*-
# cython: profile=False
-from cpython.datetime cimport timedelta
-
from numpy cimport int64_t
# Exposed for tslib, not intended for outside use.
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index eb5c0076a868a..67420fda8aa51 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -17,8 +17,7 @@ from cpython.datetime cimport (datetime,
PyDateTime_IMPORT
from util cimport (is_datetime64_object, is_timedelta64_object,
- is_integer_object, is_string_object, is_array,
- INT64_MAX)
+ is_integer_object, is_string_object, is_array)
cimport ccalendar
from conversion import tz_localize_to_utc, normalize_i8_timestamps
@@ -1103,7 +1102,7 @@ class Timestamp(_Timestamp):
# Add the min and max fields at the class level
-cdef int64_t _NS_UPPER_BOUND = INT64_MAX
+cdef int64_t _NS_UPPER_BOUND = np.iinfo(np.int64).max
# the smallest value we could actually represent is
# INT64_MIN + 1 == -9223372036854775807
# but to allow overflow free conversion with a microsecond resolution
diff --git a/pandas/_libs/tslibs/util.pxd b/pandas/_libs/tslibs/util.pxd
index 0470202ee7d98..0ba61fcc58f46 100644
--- a/pandas/_libs/tslibs/util.pxd
+++ b/pandas/_libs/tslibs/util.pxd
@@ -24,10 +24,10 @@ cdef extern from "Python.h":
bint PyComplex_Check(object obj) nogil
bint PyObject_TypeCheck(object obj, PyTypeObject* type) nogil
+from numpy cimport int64_t
cdef extern from "numpy/arrayobject.h":
PyTypeObject PyFloatingArrType_Type
- ctypedef signed long long int64_t
int _import_array() except -1
cdef extern from "numpy/ndarrayobject.h":
@@ -43,21 +43,6 @@ cdef extern from "numpy/npy_common.h":
int64_t NPY_MIN_INT64
-cdef extern from "../src/headers/stdint.h":
- enum: UINT8_MAX
- enum: UINT16_MAX
- enum: UINT32_MAX
- enum: UINT64_MAX
- enum: INT8_MIN
- enum: INT8_MAX
- enum: INT16_MIN
- enum: INT16_MAX
- enum: INT32_MAX
- enum: INT32_MIN
- enum: INT64_MAX
- enum: INT64_MIN
-
-
cdef inline int64_t get_nat():
return NPY_MIN_INT64
diff --git a/pandas/_libs/util.pxd b/pandas/_libs/util.pxd
index 134f34330d8aa..31843a755e7b1 100644
--- a/pandas/_libs/util.pxd
+++ b/pandas/_libs/util.pxd
@@ -14,6 +14,21 @@ cdef extern from "src/numpy_helper.h":
const char *get_c_string(object) except NULL
+cdef extern from "src/headers/stdint.h":
+ enum: UINT8_MAX
+ enum: UINT16_MAX
+ enum: UINT32_MAX
+ enum: UINT64_MAX
+ enum: INT8_MIN
+ enum: INT8_MAX
+ enum: INT16_MIN
+ enum: INT16_MAX
+ enum: INT32_MAX
+ enum: INT32_MIN
+ enum: INT64_MAX
+ enum: INT64_MIN
+
+
ctypedef fused numeric:
cnp.int8_t
cnp.int16_t
diff --git a/pandas/tests/tseries/offsets/test_fiscal.py b/pandas/tests/tseries/offsets/test_fiscal.py
index ccd418a69c827..223298dc42544 100644
--- a/pandas/tests/tseries/offsets/test_fiscal.py
+++ b/pandas/tests/tseries/offsets/test_fiscal.py
@@ -13,10 +13,9 @@
from pandas.tseries.frequencies import get_offset
from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
from pandas.tseries.offsets import FY5253Quarter, FY5253
-from pandas._libs.tslibs.offsets import WeekDay
from .common import assert_offset_equal, assert_onOffset
-from .test_offsets import Base
+from .test_offsets import Base, WeekDay
def makeFY5253LastOfMonthQuarter(*args, **kwds):
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index 57b9a281ac0eb..e95f1ba11ad5c 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -17,7 +17,7 @@
from pandas.core.indexes.datetimes import (
_to_m8, DatetimeIndex, _daterange_cache)
import pandas._libs.tslibs.offsets as liboffsets
-from pandas._libs.tslibs.offsets import WeekDay, CacheableOffset
+from pandas._libs.tslibs.offsets import CacheableOffset
from pandas.tseries.offsets import (BDay, CDay, BQuarterEnd, BMonthEnd,
BusinessHour, WeekOfMonth, CBMonthEnd,
CustomBusinessHour,
@@ -39,6 +39,18 @@
from .common import assert_offset_equal, assert_onOffset
+
+class WeekDay(object):
+ # TODO: Remove: This is not used outside of tests
+ MON = 0
+ TUE = 1
+ WED = 2
+ THU = 3
+ FRI = 4
+ SAT = 5
+ SUN = 6
+
+
####
# Misc function tests
####
| Modernize for-loop syntax
Modernize string formatting
Use memoryviews in a few places
Docstrings, change a couple of funcs in tslibs.parsing to cdef
Follow-up cleanup in tslibs.period
Move some unneeded stuff out of tslibs.util to wrap up the self-contained goal.
| https://api.github.com/repos/pandas-dev/pandas/pulls/22235 | 2018-08-07T22:11:28Z | 2018-08-10T07:55:29Z | 2018-08-10T07:55:29Z | 2018-08-10T17:21:04Z |
Added whatsnew for v0.23.5 | diff --git a/doc/source/whatsnew/v0.23.5.txt b/doc/source/whatsnew/v0.23.5.txt
new file mode 100644
index 0000000000000..ee0ee4259f86d
--- /dev/null
+++ b/doc/source/whatsnew/v0.23.5.txt
@@ -0,0 +1,39 @@
+.. _whatsnew_0235:
+
+v0.23.5 (TBD 0, 2018)
+---------------------
+
+This is a minor bug-fix release in the 0.23.x series and includes some small regression fixes
+and bug fixes. We recommend that all users upgrade to this version.
+
+.. warning::
+
+ Starting January 1, 2019, pandas feature releases will support Python 3 only.
+ See :ref:`install.dropping-27` for more.
+
+.. contents:: What's new in v0.23.5
+ :local:
+ :backlinks: none
+
+.. _whatsnew_0235.fixed_regressions:
+
+Fixed Regressions
+~~~~~~~~~~~~~~~~~
+
+-
+-
+
+.. _whatsnew_0235.bug_fixes:
+
+Bug Fixes
+~~~~~~~~~
+
+**Groupby/Resample/Rolling**
+
+-
+-
+
+**Missing**
+
+-
+-
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/22233 | 2018-08-07T16:22:52Z | 2018-08-07T16:23:03Z | 2018-08-07T16:23:03Z | 2018-08-07T17:45:03Z |
BUG: Fix DataFrame construction regression | diff --git a/doc/source/whatsnew/v0.23.5.txt b/doc/source/whatsnew/v0.23.5.txt
index ee0ee4259f86d..916a246355b5f 100644
--- a/doc/source/whatsnew/v0.23.5.txt
+++ b/doc/source/whatsnew/v0.23.5.txt
@@ -20,6 +20,9 @@ and bug fixes. We recommend that all users upgrade to this version.
Fixed Regressions
~~~~~~~~~~~~~~~~~
+- Constructing a DataFrame with an index argument that wasn't already an
+ instance of :class:`~pandas.core.Index` was broken in `4efb39f
+ <https://github.com/pandas-dev/pandas/commit/4efb39f01f5880122fa38d91e12d217ef70fad9e>`_ (:issue:`22227`).
-
-
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index cb251d4648925..a9f0e6c20ef8f 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7630,6 +7630,8 @@ def _arrays_to_mgr(arrays, arr_names, index, columns, dtype=None):
# figure out the index, if necessary
if index is None:
index = extract_index(arrays)
+ else:
+ index = ensure_index(index)
# don't force copy because getting jammed in an ndarray anyway
arrays = _homogenize(arrays, index, dtype)
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 4426d4ba8ead1..6c84beb64e196 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2240,3 +2240,16 @@ def test_frame_timeseries_column(self):
Timestamp('20130101T10:01:00', tz='US/Eastern'),
Timestamp('20130101T10:02:00', tz='US/Eastern')]})
tm.assert_frame_equal(result, expected)
+
+ def test_nested_dict_construction(self):
+ # GH22227
+ columns = ['Nevada', 'Ohio']
+ pop = {'Nevada': {2001: 2.4, 2002: 2.9},
+ 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
+ result = pd.DataFrame(pop, index=[2001, 2002, 2003], columns=columns)
+ expected = pd.DataFrame(
+ [(2.4, 1.7), (2.9, 3.6), (np.nan, np.nan)],
+ columns=columns,
+ index=pd.Index([2001, 2002, 2003])
+ )
+ tm.assert_frame_equal(result, expected)
| - [x] closes #22227
- [x] tests added
- [x] tests passed
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry | https://api.github.com/repos/pandas-dev/pandas/pulls/22232 | 2018-08-07T15:32:11Z | 2018-08-08T10:30:07Z | 2018-08-08T10:30:07Z | 2019-03-11T19:15:32Z |
REGR: changed behavior in series[period].mask(foo, bar, inplace=True) | diff --git a/doc/source/whatsnew/v1.4.1.rst b/doc/source/whatsnew/v1.4.1.rst
index f321aabc0a8a5..48b62637c26b1 100644
--- a/doc/source/whatsnew/v1.4.1.rst
+++ b/doc/source/whatsnew/v1.4.1.rst
@@ -14,7 +14,7 @@ including other versions of pandas.
Fixed regressions
~~~~~~~~~~~~~~~~~
--
+- Regression in :meth:`Series.mask` with ``inplace=True`` and ``PeriodDtype`` and an incompatible ``other`` coercing to a common dtype instead of raising (:issue:`45546`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 733211a671137..3d4f53530b89c 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1417,8 +1417,6 @@ def where(self, other, cond) -> list[Block]:
# isinstance(values, NDArrayBackedExtensionArray)
if isinstance(self.dtype, PeriodDtype):
# TODO: don't special-case
- # Note: this is the main place where the fallback logic
- # is different from EABackedBlock.putmask.
raise
blk = self.coerce_to_target_dtype(other)
nbs = blk.where(other, cond)
@@ -1459,6 +1457,9 @@ def putmask(self, mask, new) -> list[Block]:
elif isinstance(self, NDArrayBackedExtensionBlock):
# NB: not (yet) the same as
# isinstance(values, NDArrayBackedExtensionArray)
+ if isinstance(self.dtype, PeriodDtype):
+ # TODO: don't special-case
+ raise
blk = self.coerce_to_target_dtype(new)
return blk.putmask(mask, new)
diff --git a/pandas/tests/frame/indexing/test_where.py b/pandas/tests/frame/indexing/test_where.py
index 794153040273e..399318a6d6118 100644
--- a/pandas/tests/frame/indexing/test_where.py
+++ b/pandas/tests/frame/indexing/test_where.py
@@ -899,6 +899,9 @@ def test_where_period_invalid_na(frame_or_series, as_cat, request):
with pytest.raises(TypeError, match=msg):
obj.mask(mask, tdnat)
+ with pytest.raises(TypeError, match=msg):
+ obj.mask(mask, tdnat, inplace=True)
+
def test_where_nullable_invalid_na(frame_or_series, any_numeric_ea_dtype):
# GH#44697
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [x] whatsnew entry
Behavior change in 1.4rc was undocumented. | https://api.github.com/repos/pandas-dev/pandas/pulls/45546 | 2022-01-22T01:58:35Z | 2022-01-23T00:06:14Z | 2022-01-23T00:06:14Z | 2022-01-23T00:11:43Z |
Backport PR #45489 on branch 1.4.x (Bug tojson memleak) | diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 327432de0a3f7..363d4b57544a9 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -966,6 +966,7 @@ I/O
- Bug in :func:`read_json` raising ``ValueError`` when attempting to parse json strings containing "://" (:issue:`36271`)
- Bug in :func:`read_csv` when ``engine="c"`` and ``encoding_errors=None`` which caused a segfault (:issue:`45180`)
- Bug in :func:`read_csv` an invalid value of ``usecols`` leading to an unclosed file handle (:issue:`45384`)
+- Bug in :meth:`DataFrame.to_json` fix memory leak (:issue:`43877`)
Period
^^^^^^
diff --git a/pandas/_libs/src/ujson/python/objToJSON.c b/pandas/_libs/src/ujson/python/objToJSON.c
index 06c3d823f72d2..c4609992342c3 100644
--- a/pandas/_libs/src/ujson/python/objToJSON.c
+++ b/pandas/_libs/src/ujson/python/objToJSON.c
@@ -228,6 +228,7 @@ static PyObject *get_values(PyObject *obj) {
PyErr_Clear();
} else if (PyObject_HasAttrString(values, "__array__")) {
// We may have gotten a Categorical or Sparse array so call np.array
+ Py_DECREF(values);
values = PyObject_CallMethod(values, "__array__", NULL);
} else if (!PyArray_CheckExact(values)) {
// Didn't get a numpy array, so keep trying
| Backport PR #45489: Bug tojson memleak | https://api.github.com/repos/pandas-dev/pandas/pulls/45545 | 2022-01-22T01:23:17Z | 2022-01-22T09:04:11Z | 2022-01-22T09:04:11Z | 2022-01-22T09:04:12Z |
Backport PR #45519 on branch 1.4.x (EA interface: rename ExtensionArray._hasnans to ._hasna) | diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index c16c404d56295..d955d8e583f1c 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -427,7 +427,7 @@ def __contains__(self, item: object) -> bool | np.bool_:
if not self._can_hold_na:
return False
elif item is self.dtype.na_value or isinstance(item, self.dtype.type):
- return self._hasnans
+ return self._hasna
else:
return False
else:
@@ -606,7 +606,7 @@ def isna(self) -> np.ndarray | ExtensionArraySupportsAnyAll:
raise AbstractMethodError(self)
@property
- def _hasnans(self) -> bool:
+ def _hasna(self) -> bool:
# GH#22680
"""
Equivalent to `self.isna().any()`.
@@ -698,7 +698,7 @@ def argmin(self, skipna: bool = True) -> int:
ExtensionArray.argmax
"""
validate_bool_kwarg(skipna, "skipna")
- if not skipna and self._hasnans:
+ if not skipna and self._hasna:
raise NotImplementedError
return nargminmax(self, "argmin")
@@ -722,7 +722,7 @@ def argmax(self, skipna: bool = True) -> int:
ExtensionArray.argmin
"""
validate_bool_kwarg(skipna, "skipna")
- if not skipna and self._hasnans:
+ if not skipna and self._hasna:
raise NotImplementedError
return nargminmax(self, "argmax")
@@ -1534,6 +1534,9 @@ def _empty(cls, shape: Shape, dtype: ExtensionDtype):
ExtensionDtype.empty
ExtensionDtype.empty is the 'official' public version of this API.
"""
+ # Implementer note: while ExtensionDtype.empty is the public way to
+ # call this method, it is still required to implement this `_empty`
+ # method as well (it is called internally in pandas)
obj = cls._from_sequence([], dtype=dtype)
taker = np.broadcast_to(np.intp(-1), shape)
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index c752e0ddca88e..c845d9c8cdbde 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -841,7 +841,7 @@ def _isnan(self) -> npt.NDArray[np.bool_]:
return self.asi8 == iNaT
@property # NB: override with cache_readonly in immutable subclasses
- def _hasnans(self) -> bool:
+ def _hasna(self) -> bool:
"""
return if I have any nans; enables various perf speedups
"""
@@ -866,7 +866,7 @@ def _maybe_mask_results(
This is an internal routine.
"""
- if self._hasnans:
+ if self._hasna:
if convert:
result = result.astype(convert)
if fill_value is None:
@@ -1125,7 +1125,7 @@ def _add_timedelta_arraylike(self, other):
new_values = checked_add_with_arr(
self_i8, other_i8, arr_mask=self._isnan, b_mask=other._isnan
)
- if self._hasnans or other._hasnans:
+ if self._hasna or other._hasna:
mask = self._isnan | other._isnan
np.putmask(new_values, mask, iNaT)
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 03808b214b048..00d5f113e16e0 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -738,7 +738,7 @@ def _sub_datetime_arraylike(self, other):
other_i8 = other.asi8
arr_mask = self._isnan | other._isnan
new_values = checked_add_with_arr(self_i8, -other_i8, arr_mask=arr_mask)
- if self._hasnans or other._hasnans:
+ if self._hasna or other._hasna:
np.putmask(new_values, arr_mask, iNaT)
return new_values.view("timedelta64[ns]")
@@ -1356,7 +1356,7 @@ def isocalendar(self) -> DataFrame:
iso_calendar_df = DataFrame(
sarray, columns=["year", "week", "day"], dtype="UInt32"
)
- if self._hasnans:
+ if self._hasna:
iso_calendar_df.iloc[self._isnan] = None
return iso_calendar_df
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 487b51735bd4e..04cc70b7efa6a 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -548,7 +548,7 @@ def _time_shift(self, periods: int, freq=None) -> PeriodArray:
f"{type(self).__name__}._time_shift"
)
values = self.asi8 + periods * self.freq.n
- if self._hasnans:
+ if self._hasna:
values[self._isnan] = iNaT
return type(self)(values, freq=self.freq)
@@ -618,7 +618,7 @@ def asfreq(self, freq=None, how: str = "E") -> PeriodArray:
new_data = period_asfreq_arr(ordinal, base1, base2, end)
- if self._hasnans:
+ if self._hasna:
new_data[self._isnan] = iNaT
return type(self)(new_data, freq=freq)
@@ -645,7 +645,7 @@ def _format_native_types(
else:
formatter = lambda dt: str(dt)
- if self._hasnans:
+ if self._hasna:
mask = self._isnan
values[mask] = na_rep
imask = ~mask
@@ -712,7 +712,7 @@ def _sub_period(self, other):
new_data = asi8 - other.ordinal
new_data = np.array([self.freq * x for x in new_data])
- if self._hasnans:
+ if self._hasna:
new_data[self._isnan] = NaT
return new_data
@@ -739,7 +739,7 @@ def _sub_period_array(self, other):
)
new_values = np.array([self.freq.base * x for x in new_values])
- if self._hasnans or other._hasnans:
+ if self._hasna or other._hasna:
mask = self._isnan | other._isnan
new_values[mask] = NaT
return new_values
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 79387cc2584da..6ea24359c01b1 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -82,7 +82,7 @@ def _field_accessor(name: str, alias: str, docstring: str):
def f(self) -> np.ndarray:
values = self.asi8
result = get_timedelta_field(values, alias)
- if self._hasnans:
+ if self._hasna:
result = self._maybe_mask_results(
result, fill_value=None, convert="float64"
)
@@ -911,7 +911,7 @@ def components(self) -> DataFrame:
"microseconds",
"nanoseconds",
]
- hasnans = self._hasnans
+ hasnans = self._hasna
if hasnans:
def f(x):
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 589b92f392ca8..8e94d72752b33 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -96,7 +96,7 @@ class DatetimeIndexOpsMixin(NDArrayBackedExtensionIndex):
hasnans = cast(
bool,
cache_readonly(
- DatetimeLikeArrayMixin._hasnans.fget # type: ignore[attr-defined]
+ DatetimeLikeArrayMixin._hasna.fget # type: ignore[attr-defined]
),
)
diff --git a/pandas/tests/extension/base/constructors.py b/pandas/tests/extension/base/constructors.py
index c86054aed7e4d..b9f8f8512a995 100644
--- a/pandas/tests/extension/base/constructors.py
+++ b/pandas/tests/extension/base/constructors.py
@@ -135,3 +135,8 @@ def test_empty(self, dtype):
assert isinstance(result2, cls)
assert result2.dtype == dtype
assert result2.shape == (4,)
+
+ result2 = dtype.empty(4)
+ assert isinstance(result2, cls)
+ assert result2.dtype == dtype
+ assert result2.shape == (4,)
| Backport PR #45519 | https://api.github.com/repos/pandas-dev/pandas/pulls/45543 | 2022-01-21T22:27:41Z | 2022-01-22T01:22:30Z | 2022-01-22T01:22:30Z | 2022-01-22T09:26:46Z |
Backport PR #45483 on branch 1.4.x (Rename to main) | diff --git a/doc/source/getting_started/comparison/comparison_with_sql.rst b/doc/source/getting_started/comparison/comparison_with_sql.rst
index 0596687b4d15e..0a891a4c6d2d7 100644
--- a/doc/source/getting_started/comparison/comparison_with_sql.rst
+++ b/doc/source/getting_started/comparison/comparison_with_sql.rst
@@ -18,7 +18,7 @@ structure.
url = (
"https://raw.github.com/pandas-dev"
- "/pandas/master/pandas/tests/io/data/csv/tips.csv"
+ "/pandas/main/pandas/tests/io/data/csv/tips.csv"
)
tips = pd.read_csv(url)
tips
diff --git a/pandas/_version.py b/pandas/_version.py
index fbec4a694d721..923b268919671 100644
--- a/pandas/_version.py
+++ b/pandas/_version.py
@@ -199,7 +199,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
# refs/heads/ and refs/tags/ prefixes that would let us distinguish
# between branches and tags. By ignoring refnames without digits, we
# filter out many common branch names like "release" and
- # "stabilization", as well as "HEAD" and "master".
+ # "stabilization", as well as "HEAD" and "main".
tags = {r for r in refs if re.search(r"\d", r)}
if verbose:
print("discarding '%s', no digits" % ",".join(refs - tags))
diff --git a/pandas/tests/io/test_html.py b/pandas/tests/io/test_html.py
index 3aac7e95e6591..9c978623d4fb6 100644
--- a/pandas/tests/io/test_html.py
+++ b/pandas/tests/io/test_html.py
@@ -171,7 +171,7 @@ def test_banklist_url(self):
@tm.network
def test_spam_url(self):
url = (
- "https://raw.githubusercontent.com/pandas-dev/pandas/master/"
+ "https://raw.githubusercontent.com/pandas-dev/pandas/main/"
"pandas/tests/io/data/html/spam.html"
)
df1 = self.read_html(url, match=".*Water.*")
| Backport PR #45483: Rename to main | https://api.github.com/repos/pandas-dev/pandas/pulls/45542 | 2022-01-21T21:41:46Z | 2022-01-22T00:08:02Z | 2022-01-22T00:08:02Z | 2022-01-22T00:08:03Z |
Backport PR #45524 on branch 1.4.x (REGR: fix period dtype <-> arrow roundtrip for pyarrow < 4) | diff --git a/pandas/core/internals/api.py b/pandas/core/internals/api.py
index 537ae8f2a4320..371f1e2443b36 100644
--- a/pandas/core/internals/api.py
+++ b/pandas/core/internals/api.py
@@ -24,6 +24,7 @@
from pandas.core.internals.blocks import (
Block,
DatetimeTZBlock,
+ ExtensionBlock,
check_ndim,
ensure_block_shape,
extract_pandas_array,
@@ -51,6 +52,12 @@ def make_block(
values, dtype = extract_pandas_array(values, dtype, ndim)
+ if klass is ExtensionBlock and is_period_dtype(values.dtype):
+ # GH-44681 changed PeriodArray to be stored in the 2D
+ # NDArrayBackedExtensionBlock instead of ExtensionBlock
+ # -> still allow ExtensionBlock to be passed in this case for back compat
+ klass = None
+
if klass is None:
dtype = dtype or values.dtype
klass = get_block_type(dtype)
diff --git a/pandas/tests/arrays/period/test_arrow_compat.py b/pandas/tests/arrays/period/test_arrow_compat.py
index bc557f2e119d5..560299a4a47f5 100644
--- a/pandas/tests/arrays/period/test_arrow_compat.py
+++ b/pandas/tests/arrays/period/test_arrow_compat.py
@@ -1,7 +1,5 @@
import pytest
-from pandas.compat import pa_version_under4p0
-
from pandas.core.dtypes.dtypes import PeriodDtype
import pandas as pd
@@ -71,9 +69,6 @@ def test_arrow_array_missing():
assert result.storage.equals(expected)
-@pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow incorrectly uses pandas internals API"
-)
def test_arrow_table_roundtrip():
from pandas.core.arrays._arrow_utils import ArrowPeriodType
@@ -93,9 +88,6 @@ def test_arrow_table_roundtrip():
tm.assert_frame_equal(result, expected)
-@pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow incorrectly uses pandas internals API"
-)
def test_arrow_load_from_zero_chunks():
# GH-41040
@@ -114,9 +106,6 @@ def test_arrow_load_from_zero_chunks():
tm.assert_frame_equal(result, df)
-@pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow incorrectly uses pandas internals API"
-)
def test_arrow_table_roundtrip_without_metadata():
arr = PeriodArray([1, 2, 3], freq="H")
arr[1] = pd.NaT
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index 4fcb43c1c3e47..df858070f698a 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -2,8 +2,6 @@
import numpy as np
import pytest
-from pandas.compat.pyarrow import pa_version_under4p0
-
import pandas as pd
import pandas._testing as tm
@@ -87,11 +85,7 @@ def test_basic(self):
),
}
)
- if not pa_version_under4p0:
- # older pyarrow incorrectly uses pandas internal API, so
- # constructs invalid Block
- df["periods"] = pd.period_range("2013", freq="M", periods=3)
-
+ df["periods"] = pd.period_range("2013", freq="M", periods=3)
df["timedeltas"] = pd.timedelta_range("1 day", periods=3)
df["intervals"] = pd.interval_range(0, 3, 3)
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index decdf02dd3072..b60ff00f9d59e 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -15,7 +15,6 @@
from pandas.compat.pyarrow import (
pa_version_under2p0,
- pa_version_under4p0,
pa_version_under5p0,
pa_version_under6p0,
)
@@ -652,13 +651,7 @@ def test_use_nullable_dtypes(self, engine, request):
"object",
"datetime64[ns, UTC]",
"float",
- pytest.param(
- "period[D]",
- marks=pytest.mark.xfail(
- pa_version_under4p0,
- reason="pyarrow uses pandas internal API incorrectly",
- ),
- ),
+ "period[D]",
"Float64",
"string",
],
@@ -897,9 +890,6 @@ def test_pyarrow_backed_string_array(self, pa, string_storage):
check_round_trip(df, pa, expected=df.astype(f"string[{string_storage}]"))
@td.skip_if_no("pyarrow")
- @pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow uses pandas internal API incorrectly"
- )
def test_additional_extension_types(self, pa):
# test additional ExtensionArrays that are supported through the
# __arrow_array__ protocol + by defining a custom ExtensionType
| Backport PR #45524: REGR: fix period dtype <-> arrow roundtrip for pyarrow < 4 | https://api.github.com/repos/pandas-dev/pandas/pulls/45541 | 2022-01-21T21:33:45Z | 2022-01-22T00:07:51Z | 2022-01-22T00:07:51Z | 2022-01-22T00:07:51Z |
Backport PR #45536 on branch 1.4.x (DOC: tidy 1.4.0 release notes (2)) | diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 4e5369072e116..327432de0a3f7 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -92,7 +92,7 @@ Styler
- Styling and formatting of indexes has been added, with :meth:`.Styler.apply_index`, :meth:`.Styler.applymap_index` and :meth:`.Styler.format_index`. These mirror the signature of the methods already used to style and format data values, and work with both HTML, LaTeX and Excel format (:issue:`41893`, :issue:`43101`, :issue:`41993`, :issue:`41995`)
- The new method :meth:`.Styler.hide` deprecates :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` (:issue:`43758`)
- - The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
+ - The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of Index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
- The :meth:`.Styler.export` and :meth:`.Styler.use` have been updated to address all of the added functionality from v1.2.0 and v1.3.0 (:issue:`40675`)
- Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax`` (:issue:`41395`)
- Validation of certain keyword arguments, e.g. ``caption`` (:issue:`43368`)
@@ -110,7 +110,7 @@ There are also some LaTeX specific enhancements:
- :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`)
- Naive sparsification is now possible for LaTeX without the necessity of including the multirow package (:issue:`43369`)
- - *cline* support has been added for MultiIndex row sparsification through a keyword argument (:issue:`45138`)
+ - *cline* support has been added for :class:`MultiIndex` row sparsification through a keyword argument (:issue:`45138`)
.. _whatsnew_140.enhancements.pyarrow_csv_engine:
@@ -342,11 +342,11 @@ Now null-values are no longer mangled.
.. _whatsnew_140.notable_bug_fixes.read_csv_mangle_dup_cols:
-mangle_dupe_cols in read_csv no longer renaming unique columns conflicting with target names
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+mangle_dupe_cols in read_csv no longer renames unique columns conflicting with target names
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:func:`read_csv` no longer renaming unique cols, which conflict with the target
-names of duplicated columns. Already existing columns are jumped, e.g. the next
+:func:`read_csv` no longer renames unique column labels which conflict with the target
+names of duplicated columns. Already existing columns are skipped, i.e. the next
available index is used for the target column name (:issue:`14704`).
.. ipython:: python
@@ -526,6 +526,8 @@ still work, but are not considered supported.
+-----------------+-----------------+---------+
| openpyxl | 3.0.3 | X |
+-----------------+-----------------+---------+
+| pandas-gbq | 0.14.0 | X |
++-----------------+-----------------+---------+
| pyarrow | 1.0.1 | X |
+-----------------+-----------------+---------+
| pymysql | 0.10.1 | X |
@@ -548,8 +550,6 @@ still work, but are not considered supported.
+-----------------+-----------------+---------+
| xlwt | 1.3.0 | |
+-----------------+-----------------+---------+
-| pandas-gbq | 0.14.0 | X |
-+-----------------+-----------------+---------+
See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
@@ -557,7 +557,7 @@ See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for mor
Other API changes
^^^^^^^^^^^^^^^^^
-- :meth:`Index.get_indexer_for` no longer accepts keyword arguments (other than 'target'); in the past these would be silently ignored if the index was not unique (:issue:`42310`)
+- :meth:`Index.get_indexer_for` no longer accepts keyword arguments (other than ``target``); in the past these would be silently ignored if the index was not unique (:issue:`42310`)
- Change in the position of the ``min_rows`` argument in :meth:`DataFrame.to_string` due to change in the docstring (:issue:`44304`)
- Reduction operations for :class:`DataFrame` or :class:`Series` now raising a ``ValueError`` when ``None`` is passed for ``skipna`` (:issue:`44178`)
- :func:`read_csv` and :func:`read_html` no longer raising an error when one of the header rows consists only of ``Unnamed:`` columns (:issue:`13054`)
@@ -573,7 +573,6 @@ Other API changes
- "Thanksgiving" is now "Thanksgiving Day"
- "Christmas" is now "Christmas Day"
- Added "Juneteenth National Independence Day"
--
.. ---------------------------------------------------------------------------
@@ -687,27 +686,27 @@ Other Deprecations
- Deprecated ``method`` argument in :meth:`Index.get_loc`, use ``index.get_indexer([label], method=...)`` instead (:issue:`42269`)
- Deprecated treating integer keys in :meth:`Series.__setitem__` as positional when the index is a :class:`Float64Index` not containing the key, a :class:`IntervalIndex` with no entries containing the key, or a :class:`MultiIndex` with leading :class:`Float64Index` level not containing the key (:issue:`33469`)
- Deprecated treating ``numpy.datetime64`` objects as UTC times when passed to the :class:`Timestamp` constructor along with a timezone. In a future version, these will be treated as wall-times. To retain the old behavior, use ``Timestamp(dt64).tz_localize("UTC").tz_convert(tz)`` (:issue:`24559`)
-- Deprecated ignoring missing labels when indexing with a sequence of labels on a level of a MultiIndex (:issue:`42351`)
-- Creating an empty Series without a dtype will now raise a more visible ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`30017`)
-- Deprecated the 'kind' argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, :meth:`Index.slice_locs`; in a future version passing 'kind' will raise (:issue:`42857`)
+- Deprecated ignoring missing labels when indexing with a sequence of labels on a level of a :class:`MultiIndex` (:issue:`42351`)
+- Creating an empty :class:`Series` without a ``dtype`` will now raise a more visible ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`30017`)
+- Deprecated the ``kind`` argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, and :meth:`Index.slice_locs`; in a future version passing ``kind`` will raise (:issue:`42857`)
- Deprecated dropping of nuisance columns in :class:`Rolling`, :class:`Expanding`, and :class:`EWM` aggregations (:issue:`42738`)
-- Deprecated :meth:`Index.reindex` with a non-unique index (:issue:`42568`)
+- Deprecated :meth:`Index.reindex` with a non-unique :class:`Index` (:issue:`42568`)
- Deprecated :meth:`.Styler.render` in favor of :meth:`.Styler.to_html` (:issue:`42140`)
- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favor of :meth:`.Styler.hide` (:issue:`43758`)
- Deprecated passing in a string column label into ``times`` in :meth:`DataFrame.ewm` (:issue:`43265`)
-- Deprecated the 'include_start' and 'include_end' arguments in :meth:`DataFrame.between_time`; in a future version passing 'include_start' or 'include_end' will raise (:issue:`40245`)
-- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the DataFrame afterwards with ``.squeeze("columns")`` instead (:issue:`43242`)
+- Deprecated the ``include_start`` and ``include_end`` arguments in :meth:`DataFrame.between_time`; in a future version passing ``include_start`` or ``include_end`` will raise (:issue:`40245`)
+- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the :class:`DataFrame` afterwards with ``.squeeze("columns")`` instead (:issue:`43242`)
- Deprecated the ``index`` argument to :class:`SparseArray` construction (:issue:`23089`)
- Deprecated the ``closed`` argument in :meth:`date_range` and :meth:`bdate_range` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)
- Deprecated :meth:`.Rolling.validate`, :meth:`.Expanding.validate`, and :meth:`.ExponentialMovingWindow.validate` (:issue:`43665`)
- Deprecated silent dropping of columns that raised a ``TypeError`` in :class:`Series.transform` and :class:`DataFrame.transform` when used with a dictionary (:issue:`43740`)
- Deprecated silent dropping of columns that raised a ``TypeError``, ``DataError``, and some cases of ``ValueError`` in :meth:`Series.aggregate`, :meth:`DataFrame.aggregate`, :meth:`Series.groupby.aggregate`, and :meth:`DataFrame.groupby.aggregate` when used with a list (:issue:`43740`)
- Deprecated casting behavior when setting timezone-aware value(s) into a timezone-aware :class:`Series` or :class:`DataFrame` column when the timezones do not match. Previously this cast to object dtype. In a future version, the values being inserted will be converted to the series or column's existing timezone (:issue:`37605`)
-- Deprecated casting behavior when passing an item with mismatched-timezone to :meth:`DatetimeIndex.insert`, :meth:`DatetimeIndex.putmask`, :meth:`DatetimeIndex.where` :meth:`DatetimeIndex.fillna`, :meth:`Series.mask`, :meth:`Series.where`, :meth:`Series.fillna`, :meth:`Series.shift`, :meth:`Series.replace`, :meth:`Series.reindex` (and :class:`DataFrame` column analogues). In the past this has cast to object dtype. In a future version, these will cast the passed item to the index or series's timezone (:issue:`37605`,:issue:`44940`)
+- Deprecated casting behavior when passing an item with mismatched-timezone to :meth:`DatetimeIndex.insert`, :meth:`DatetimeIndex.putmask`, :meth:`DatetimeIndex.where` :meth:`DatetimeIndex.fillna`, :meth:`Series.mask`, :meth:`Series.where`, :meth:`Series.fillna`, :meth:`Series.shift`, :meth:`Series.replace`, :meth:`Series.reindex` (and :class:`DataFrame` column analogues). In the past this has cast to object ``dtype``. In a future version, these will cast the passed item to the index or series's timezone (:issue:`37605`, :issue:`44940`)
- Deprecated the ``prefix`` keyword argument in :func:`read_csv` and :func:`read_table`, in a future version the argument will be removed (:issue:`43396`)
-- Deprecated passing non boolean argument to sort in :func:`concat` (:issue:`41518`)
-- Deprecated passing arguments as positional for :func:`read_fwf` other than ``filepath_or_buffer`` (:issue:`41485`):
-- Deprecated passing arguments as positional for :func:`read_xml` other than ``path_or_buffer`` (:issue:`45133`):
+- Deprecated passing non boolean argument to ``sort`` in :func:`concat` (:issue:`41518`)
+- Deprecated passing arguments as positional for :func:`read_fwf` other than ``filepath_or_buffer`` (:issue:`41485`)
+- Deprecated passing arguments as positional for :func:`read_xml` other than ``path_or_buffer`` (:issue:`45133`)
- Deprecated passing ``skipna=None`` for :meth:`DataFrame.mad` and :meth:`Series.mad`, pass ``skipna=True`` instead (:issue:`44580`)
- Deprecated the behavior of :func:`to_datetime` with the string "now" with ``utc=False``; in a future version this will match ``Timestamp("now")``, which in turn matches :meth:`Timestamp.now` returning the local time (:issue:`18705`)
- Deprecated :meth:`DateOffset.apply`, use ``offset + other`` instead (:issue:`44522`)
@@ -749,7 +748,7 @@ Performance improvements
- Performance improvement in :meth:`Series.sparse.to_coo` (:issue:`42880`)
- Performance improvement in indexing with a :class:`UInt64Index` (:issue:`43862`)
- Performance improvement in indexing with a :class:`Float64Index` (:issue:`43705`)
-- Performance improvement in indexing with a non-unique Index (:issue:`43792`)
+- Performance improvement in indexing with a non-unique :class:`Index` (:issue:`43792`)
- Performance improvement in indexing with a listlike indexer on a :class:`MultiIndex` (:issue:`43370`)
- Performance improvement in indexing with a :class:`MultiIndex` indexer on another :class:`MultiIndex` (:issue:`43370`)
- Performance improvement in :meth:`GroupBy.quantile` (:issue:`43469`, :issue:`43725`)
@@ -808,9 +807,9 @@ Datetimelike
- :func:`to_datetime` would silently swap ``MM/DD/YYYY`` and ``DD/MM/YYYY`` formats if the given ``dayfirst`` option could not be respected - now, a warning is raised in the case of delimited date strings (e.g. ``31-12-2012``) (:issue:`12585`)
- Bug in :meth:`date_range` and :meth:`bdate_range` do not return right bound when ``start`` = ``end`` and set is closed on one side (:issue:`43394`)
- Bug in inplace addition and subtraction of :class:`DatetimeIndex` or :class:`TimedeltaIndex` with :class:`DatetimeArray` or :class:`TimedeltaArray` (:issue:`43904`)
-- Bug in in calling ``np.isnan``, ``np.isfinite``, or ``np.isinf`` on a timezone-aware :class:`DatetimeIndex` incorrectly raising ``TypeError`` (:issue:`43917`)
+- Bug in calling ``np.isnan``, ``np.isfinite``, or ``np.isinf`` on a timezone-aware :class:`DatetimeIndex` incorrectly raising ``TypeError`` (:issue:`43917`)
- Bug in constructing a :class:`Series` from datetime-like strings with mixed timezones incorrectly partially-inferring datetime values (:issue:`40111`)
-- Bug in addition with a :class:`Tick` object and a ``np.timedelta64`` object incorrectly raising instead of returning :class:`Timedelta` (:issue:`44474`)
+- Bug in addition of a :class:`Tick` object and a ``np.timedelta64`` object incorrectly raising instead of returning :class:`Timedelta` (:issue:`44474`)
- ``np.maximum.reduce`` and ``np.minimum.reduce`` now correctly return :class:`Timestamp` and :class:`Timedelta` objects when operating on :class:`Series`, :class:`DataFrame`, or :class:`Index` with ``datetime64[ns]`` or ``timedelta64[ns]`` dtype (:issue:`43923`)
- Bug in adding a ``np.timedelta64`` object to a :class:`BusinessDay` or :class:`CustomBusinessDay` object incorrectly raising (:issue:`44532`)
- Bug in :meth:`Index.insert` for inserting ``np.datetime64``, ``np.timedelta64`` or ``tuple`` into :class:`Index` with ``dtype='object'`` with negative loc adding ``None`` and replacing existing value (:issue:`44509`)
@@ -852,7 +851,7 @@ Conversion
- Bug in :class:`Series` constructor returning 0 for missing values with dtype ``int64`` and ``False`` for dtype ``bool`` (:issue:`43017`, :issue:`43018`)
- Bug in constructing a :class:`DataFrame` from a :class:`PandasArray` containing :class:`Series` objects behaving differently than an equivalent ``np.ndarray`` (:issue:`43986`)
- Bug in :class:`IntegerDtype` not allowing coercion from string dtype (:issue:`25472`)
-- Bug in :func:`to_datetime` with ``arg:xr.DataArray`` and ``unit="ns"`` specified raises TypeError (:issue:`44053`)
+- Bug in :func:`to_datetime` with ``arg:xr.DataArray`` and ``unit="ns"`` specified raises ``TypeError`` (:issue:`44053`)
- Bug in :meth:`DataFrame.convert_dtypes` not returning the correct type when a subclass does not overload :meth:`_constructor_sliced` (:issue:`43201`)
- Bug in :meth:`DataFrame.astype` not propagating ``attrs`` from the original :class:`DataFrame` (:issue:`44414`)
- Bug in :meth:`DataFrame.convert_dtypes` result losing ``columns.names`` (:issue:`41435`)
@@ -861,7 +860,7 @@ Conversion
Strings
^^^^^^^
-- Fixed bug in checking for ``string[pyarrow]`` dtype incorrectly raising an ImportError when pyarrow is not installed (:issue:`44276`)
+- Bug in checking for ``string[pyarrow]`` dtype incorrectly raising an ``ImportError`` when pyarrow is not installed (:issue:`44276`)
Interval
^^^^^^^^
@@ -869,16 +868,16 @@ Interval
Indexing
^^^^^^^^
-- Bug in :meth:`Series.rename` when index in Series is MultiIndex and level in rename is provided (:issue:`43659`)
-- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's Index has a length greater than one but only one unique value (:issue:`42365`)
+- Bug in :meth:`Series.rename` with :class:`MultiIndex` and ``level`` is provided (:issue:`43659`)
+- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's :class:`Index` has a length greater than one but only one unique value (:issue:`42365`)
- Bug in :meth:`Series.loc` and :meth:`DataFrame.loc` with a :class:`MultiIndex` when indexing with a tuple in which one of the levels is also a tuple (:issue:`27591`)
-- Bug in :meth:`Series.loc` when with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
+- Bug in :meth:`Series.loc` with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
- Bug in indexing on a :class:`Series` or :class:`DataFrame` with a :class:`DatetimeIndex` when passing a string, the return type depended on whether the index was monotonic (:issue:`24892`)
- Bug in indexing on a :class:`MultiIndex` failing to drop scalar levels when the indexer is a tuple containing a datetime-like string (:issue:`42476`)
- Bug in :meth:`DataFrame.sort_values` and :meth:`Series.sort_values` when passing an ascending value, failed to raise or incorrectly raising ``ValueError`` (:issue:`41634`)
- Bug in updating values of :class:`pandas.Series` using boolean index, created by using :meth:`pandas.DataFrame.pop` (:issue:`42530`)
- Bug in :meth:`Index.get_indexer_non_unique` when index contains multiple ``np.nan`` (:issue:`35392`)
-- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a dataframe (:issue:`42826`)
+- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a :class:`DataFrame` (:issue:`42826`)
- Bug in :meth:`DataFrame.drop` where the error message did not show missing labels with commas when raising ``KeyError`` (:issue:`42881`)
- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed (:issue:`22435`)
- Bug in :meth:`DataFrame.nlargest` and :meth:`Series.nlargest` where sorted result did not count indexes containing ``np.nan`` (:issue:`28984`)
@@ -903,12 +902,12 @@ Indexing
- Bug in :meth:`IntervalIndex.get_indexer_non_unique` not handling targets of ``dtype`` 'object' with NaNs correctly (:issue:`44482`)
- Fixed regression where a single column ``np.matrix`` was no longer coerced to a 1d ``np.ndarray`` when added to a :class:`DataFrame` (:issue:`42376`)
- Bug in :meth:`Series.__getitem__` with a :class:`CategoricalIndex` of integers treating lists of integers as positional indexers, inconsistent with the behavior with a single scalar integer (:issue:`15470`, :issue:`14865`)
-- Bug in :meth:`Series.__setitem__` when setting floats or integers into integer-dtype series failing to upcast when necessary to retain precision (:issue:`45121`)
+- Bug in :meth:`Series.__setitem__` when setting floats or integers into integer-dtype :class:`Series` failing to upcast when necessary to retain precision (:issue:`45121`)
- Bug in :meth:`DataFrame.iloc.__setitem__` ignores axis argument (:issue:`45032`)
Missing
^^^^^^^
-- Bug in :meth:`DataFrame.fillna` with limit and no method ignores axis='columns' or ``axis = 1`` (:issue:`40989`, :issue:`17399`)
+- Bug in :meth:`DataFrame.fillna` with ``limit`` and no ``method`` ignores ``axis='columns'`` or ``axis = 1`` (:issue:`40989`, :issue:`17399`)
- Bug in :meth:`DataFrame.fillna` not replacing missing values when using a dict-like ``value`` and duplicate column names (:issue:`43476`)
- Bug in constructing a :class:`DataFrame` with a dictionary ``np.datetime64`` as a value and ``dtype='timedelta64[ns]'``, or vice-versa, incorrectly casting instead of raising (:issue:`44428`)
- Bug in :meth:`Series.interpolate` and :meth:`DataFrame.interpolate` with ``inplace=True`` not writing to the underlying array(s) in-place (:issue:`44749`)
@@ -933,24 +932,24 @@ I/O
- Bug in :func:`read_fwf`, where difference in lengths of ``colspecs`` and ``names`` was not raising ``ValueError`` (:issue:`40830`)
- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serializing plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
- Column headers are dropped when constructing a :class:`DataFrame` from a sqlalchemy's ``Row`` object (:issue:`40682`)
-- Bug in unpickling a :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
-- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raising uncontrolled ``IndexError`` (:issue:`43102`)
+- Bug in unpickling an :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
+- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raised ``IndexError`` (:issue:`43102`)
- Bug in :func:`read_csv` raising ``ParserError`` when reading file in chunks and some chunk blocks have fewer columns than header for ``engine="c"`` (:issue:`21211`)
- Bug in :func:`read_csv`, changed exception class when expecting a file path name or file-like object from ``OSError`` to ``TypeError`` (:issue:`43366`)
- Bug in :func:`read_csv` and :func:`read_fwf` ignoring all ``skiprows`` except first when ``nrows`` is specified for ``engine='python'`` (:issue:`44021`, :issue:`10261`)
- Bug in :func:`read_csv` keeping the original column in object format when ``keep_date_col=True`` is set (:issue:`13378`)
- Bug in :func:`read_json` not handling non-numpy dtypes correctly (especially ``category``) (:issue:`21892`, :issue:`33205`)
- Bug in :func:`json_normalize` where multi-character ``sep`` parameter is incorrectly prefixed to every key (:issue:`43831`)
-- Bug in :func:`json_normalize` where reading data with missing multi-level metadata would not respect errors="ignore" (:issue:`44312`)
+- Bug in :func:`json_normalize` where reading data with missing multi-level metadata would not respect ``errors="ignore"`` (:issue:`44312`)
- Bug in :func:`read_csv` used second row to guess implicit index if ``header`` was set to ``None`` for ``engine="python"`` (:issue:`22144`)
- Bug in :func:`read_csv` not recognizing bad lines when ``names`` were given for ``engine="c"`` (:issue:`22144`)
- Bug in :func:`read_csv` with :code:`float_precision="round_trip"` which did not skip initial/trailing whitespace (:issue:`43713`)
- Bug when Python is built without the lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used (:issue:`43495`)
- Bug in :func:`read_csv` not applying dtype for ``index_col`` (:issue:`9435`)
- Bug in dumping/loading a :class:`DataFrame` with ``yaml.dump(frame)`` (:issue:`42748`)
-- Bug in :func:`read_csv` raising ``ValueError`` when names was longer than header but equal to data rows for ``engine="python"`` (:issue:`38453`)
+- Bug in :func:`read_csv` raising ``ValueError`` when ``names`` was longer than ``header`` but equal to data rows for ``engine="python"`` (:issue:`38453`)
- Bug in :class:`ExcelWriter`, where ``engine_kwargs`` were not passed through to all engines (:issue:`43442`)
-- Bug in :func:`read_csv` raising ``ValueError`` when ``parse_dates`` was used with ``MultiIndex`` columns (:issue:`8991`)
+- Bug in :func:`read_csv` raising ``ValueError`` when ``parse_dates`` was used with :class:`MultiIndex` columns (:issue:`8991`)
- Bug in :func:`read_csv` not raising an ``ValueError`` when ``\n`` was specified as ``delimiter`` or ``sep`` which conflicts with ``lineterminator`` (:issue:`43528`)
- Bug in :func:`to_csv` converting datetimes in categorical :class:`Series` to integers (:issue:`40754`)
- Bug in :func:`read_csv` converting columns to numeric after date parsing failed (:issue:`11019`)
@@ -982,12 +981,12 @@ Plotting
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
-- Fixed bug in :meth:`SeriesGroupBy.apply` where passing an unrecognized string argument failed to raise ``TypeError`` when the underlying ``Series`` is empty (:issue:`42021`)
+- Bug in :meth:`SeriesGroupBy.apply` where passing an unrecognized string argument failed to raise ``TypeError`` when the underlying ``Series`` is empty (:issue:`42021`)
- Bug in :meth:`Series.rolling.apply`, :meth:`DataFrame.rolling.apply`, :meth:`Series.expanding.apply` and :meth:`DataFrame.expanding.apply` with ``engine="numba"`` where ``*args`` were being cached with the user passed function (:issue:`42287`)
- Bug in :meth:`GroupBy.max` and :meth:`GroupBy.min` with nullable integer dtypes losing precision (:issue:`41743`)
- Bug in :meth:`DataFrame.groupby.rolling.var` would calculate the rolling variance only on the first group (:issue:`42442`)
-- Bug in :meth:`GroupBy.shift` that would return the grouping columns if ``fill_value`` was not None (:issue:`41556`)
-- Bug in :meth:`SeriesGroupBy.nlargest` and :meth:`SeriesGroupBy.nsmallest` would have an inconsistent index when the input Series was sorted and ``n`` was greater than or equal to all group sizes (:issue:`15272`, :issue:`16345`, :issue:`29129`)
+- Bug in :meth:`GroupBy.shift` that would return the grouping columns if ``fill_value`` was not ``None`` (:issue:`41556`)
+- Bug in :meth:`SeriesGroupBy.nlargest` and :meth:`SeriesGroupBy.nsmallest` would have an inconsistent index when the input :class:`Series` was sorted and ``n`` was greater than or equal to all group sizes (:issue:`15272`, :issue:`16345`, :issue:`29129`)
- Bug in :meth:`pandas.DataFrame.ewm`, where non-float64 dtypes were silently failing (:issue:`42452`)
- Bug in :meth:`pandas.DataFrame.rolling` operation along rows (``axis=1``) incorrectly omits columns containing ``float16`` and ``float32`` (:issue:`41779`)
- Bug in :meth:`Resampler.aggregate` did not allow the use of Named Aggregation (:issue:`32803`)
@@ -996,37 +995,37 @@ Groupby/resample/rolling
- Bug in :meth:`DataFrame.groupby.rolling` when specifying ``on`` and calling ``__getitem__`` would subsequently return incorrect results (:issue:`43355`)
- Bug in :meth:`GroupBy.apply` with time-based :class:`Grouper` objects incorrectly raising ``ValueError`` in corner cases where the grouping vector contains a ``NaT`` (:issue:`43500`, :issue:`43515`)
- Bug in :meth:`GroupBy.mean` failing with ``complex`` dtype (:issue:`43701`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not calculating window bounds correctly for the first row when ``center=True`` and index is decreasing (:issue:`43927`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` for centered datetimelike windows with uneven nanosecond (:issue:`43997`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not calculating window bounds correctly for the first row when ``center=True`` and index is decreasing (:issue:`43927`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` for centered datetimelike windows with uneven nanosecond (:issue:`43997`)
- Bug in :meth:`GroupBy.mean` raising ``KeyError`` when column was selected at least twice (:issue:`44924`)
- Bug in :meth:`GroupBy.nth` failing on ``axis=1`` (:issue:`43926`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not respecting right bound on centered datetime-like windows, if the index contain duplicates (:issue:`3944`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not respecting right bound on centered datetime-like windows, if the index contain duplicates (:issue:`3944`)
- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` when using a :class:`pandas.api.indexers.BaseIndexer` subclass that returned unequal start and end arrays would segfault instead of raising a ``ValueError`` (:issue:`44470`)
-- Bug in :meth:`Groupby.nunique` not respecting ``observed=True`` for Categorical grouping columns (:issue:`45128`)
+- Bug in :meth:`Groupby.nunique` not respecting ``observed=True`` for ``categorical`` grouping columns (:issue:`45128`)
- Bug in :meth:`GroupBy.head` and :meth:`GroupBy.tail` not dropping groups with ``NaN`` when ``dropna=True`` (:issue:`45089`)
-- Fixed bug in :meth:`GroupBy.__iter__` after selecting a subset of columns in a :class:`GroupBy` object, which returned all columns instead of the chosen subset (:issue:`44821`)
+- Bug in :meth:`GroupBy.__iter__` after selecting a subset of columns in a :class:`GroupBy` object, which returned all columns instead of the chosen subset (:issue:`44821`)
- Bug in :meth:`Groupby.rolling` when non-monotonic data passed, fails to correctly raise ``ValueError`` (:issue:`43909`)
-- Fixed bug where grouping by a :class:`Series` that has a categorical data type and length unequal to the axis of grouping raised ``ValueError`` (:issue:`44179`)
+- Bug where grouping by a :class:`Series` that has a ``categorical`` data type and length unequal to the axis of grouping raised ``ValueError`` (:issue:`44179`)
Reshaping
^^^^^^^^^
- Improved error message when creating a :class:`DataFrame` column from a multi-dimensional :class:`numpy.ndarray` (:issue:`42463`)
-- :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
+- Bug in :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42185`, :issue:`42425`)
- Bug in :meth:`DataFrame.append` failing to retain dtypes when appended columns do not match (:issue:`43392`)
- Bug in :func:`concat` of ``bool`` and ``boolean`` dtypes resulting in ``object`` dtype instead of ``boolean`` dtype (:issue:`42800`)
-- Bug in :func:`crosstab` when inputs are categorical Series, there are categories that are not present in one or both of the Series, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
+- Bug in :func:`crosstab` when inputs are categorical :class:`Series`, there are categories that are not present in one or both of the :class:`Series`, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
- Bug in :func:`concat` would fail when the ``objs`` argument all had the same index and the ``keys`` argument contained duplicates (:issue:`43595`)
- Bug in :func:`concat` which ignored the ``sort`` parameter (:issue:`43375`)
-- Fixed bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
+- Bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
- Bug in :func:`crosstab` would fail when inputs are lists or tuples (:issue:`44076`)
- Bug in :meth:`DataFrame.append` failing to retain ``index.name`` when appending a list of :class:`Series` objects (:issue:`44109`)
- Fixed metadata propagation in :meth:`Dataframe.apply` method, consequently fixing the same issue for :meth:`Dataframe.transform`, :meth:`Dataframe.nunique` and :meth:`Dataframe.mode` (:issue:`28283`)
-- Bug in :func:`concat` casting levels of :class:`MultiIndex` to float if the only consist of missing values (:issue:`44900`)
+- Bug in :func:`concat` casting levels of :class:`MultiIndex` to float if all levels only consist of missing values (:issue:`44900`)
- Bug in :meth:`DataFrame.stack` with ``ExtensionDtype`` columns incorrectly raising (:issue:`43561`)
- Bug in :func:`merge` raising ``KeyError`` when joining over differently named indexes with on keywords (:issue:`45094`)
- Bug in :meth:`Series.unstack` with object doing unwanted type inference on resulting columns (:issue:`44595`)
-- Bug in :class:`MultiIndex` failing join operations with overlapping ``IntervalIndex`` levels (:issue:`44096`)
+- Bug in :meth:`MultiIndex.join()` with overlapping ``IntervalIndex`` levels (:issue:`44096`)
- Bug in :meth:`DataFrame.replace` and :meth:`Series.replace` results is different ``dtype`` based on ``regex`` parameter (:issue:`44864`)
- Bug in :meth:`DataFrame.pivot` with ``index=None`` when the :class:`DataFrame` index was a :class:`MultiIndex` (:issue:`23955`)
@@ -1045,24 +1044,24 @@ ExtensionArray
- NumPy ufuncs ``np.abs``, ``np.positive``, ``np.negative`` now correctly preserve dtype when called on ExtensionArrays that implement ``__abs__, __pos__, __neg__``, respectively. In particular this is fixed for :class:`TimedeltaArray` (:issue:`43899`, :issue:`23316`)
- NumPy ufuncs ``np.minimum.reduce`` ``np.maximum.reduce``, ``np.add.reduce``, and ``np.prod.reduce`` now work correctly instead of raising ``NotImplementedError`` on :class:`Series` with ``IntegerDtype`` or ``FloatDtype`` (:issue:`43923`, :issue:`44793`)
- NumPy ufuncs with ``out`` keyword are now supported by arrays with ``IntegerDtype`` and ``FloatingDtype`` (:issue:`45122`)
-- Avoid raising ``PerformanceWarning`` about fragmented DataFrame when using many columns with an extension dtype (:issue:`44098`)
+- Avoid raising ``PerformanceWarning`` about fragmented :class:`DataFrame` when using many columns with an extension dtype (:issue:`44098`)
- Bug in :class:`IntegerArray` and :class:`FloatingArray` construction incorrectly coercing mismatched NA values (e.g. ``np.timedelta64("NaT")``) to numeric NA (:issue:`44514`)
- Bug in :meth:`BooleanArray.__eq__` and :meth:`BooleanArray.__ne__` raising ``TypeError`` on comparison with an incompatible type (like a string). This caused :meth:`DataFrame.replace` to sometimes raise a ``TypeError`` if a nullable boolean column was included (:issue:`44499`)
- Bug in :func:`array` incorrectly raising when passed a ``ndarray`` with ``float16`` dtype (:issue:`44715`)
- Bug in calling ``np.sqrt`` on :class:`BooleanArray` returning a malformed :class:`FloatingArray` (:issue:`44715`)
-- Bug in :meth:`Series.where` with ``ExtensionDtype`` when ``other`` is a NA scalar incompatible with the series dtype (e.g. ``NaT`` with a numeric dtype) incorrectly casting to a compatible NA value (:issue:`44697`)
-- Fixed bug in :meth:`Series.replace` where explicitly passing ``value=None`` is treated as if no ``value`` was passed, and ``None`` not being in the result (:issue:`36984`, :issue:`19998`)
-- Fixed bug in :meth:`Series.replace` with unwanted downcasting being done in no-op replacements (:issue:`44498`)
-- Fixed bug in :meth:`Series.replace` with ``FloatDtype``, ``string[python]``, or ``string[pyarrow]`` dtype not being preserved when possible (:issue:`33484`, :issue:`40732`, :issue:`31644`, :issue:`41215`, :issue:`25438`)
+- Bug in :meth:`Series.where` with ``ExtensionDtype`` when ``other`` is a NA scalar incompatible with the :class:`Series` dtype (e.g. ``NaT`` with a numeric dtype) incorrectly casting to a compatible NA value (:issue:`44697`)
+- Bug in :meth:`Series.replace` where explicitly passing ``value=None`` is treated as if no ``value`` was passed, and ``None`` not being in the result (:issue:`36984`, :issue:`19998`)
+- Bug in :meth:`Series.replace` with unwanted downcasting being done in no-op replacements (:issue:`44498`)
+- Bug in :meth:`Series.replace` with ``FloatDtype``, ``string[python]``, or ``string[pyarrow]`` dtype not being preserved when possible (:issue:`33484`, :issue:`40732`, :issue:`31644`, :issue:`41215`, :issue:`25438`)
Styler
^^^^^^
-- Minor bug in :class:`.Styler` where the ``uuid`` at initialization maintained a floating underscore (:issue:`43037`)
+- Bug in :class:`.Styler` where the ``uuid`` at initialization maintained a floating underscore (:issue:`43037`)
- Bug in :meth:`.Styler.to_html` where the ``Styler`` object was updated if the ``to_html`` method was called with some args (:issue:`43034`)
- Bug in :meth:`.Styler.copy` where ``uuid`` was not previously copied (:issue:`40675`)
-- Bug in :meth:`Styler.apply` where functions which returned Series objects were not correctly handled in terms of aligning their index labels (:issue:`13657`, :issue:`42014`)
-- Bug when rendering an empty DataFrame with a named index (:issue:`43305`).
-- Bug when rendering a single level MultiIndex (:issue:`43383`).
+- Bug in :meth:`Styler.apply` where functions which returned :class:`Series` objects were not correctly handled in terms of aligning their index labels (:issue:`13657`, :issue:`42014`)
+- Bug when rendering an empty :class:`DataFrame` with a named :class:`Index` (:issue:`43305`)
+- Bug when rendering a single level :class:`MultiIndex` (:issue:`43383`)
- Bug when combining non-sparse rendering and :meth:`.Styler.hide_columns` or :meth:`.Styler.hide_index` (:issue:`43464`)
- Bug setting a table style when using multiple selectors in :class:`.Styler` (:issue:`44011`)
- Bugs where row trimming and column trimming failed to reflect hidden rows (:issue:`43703`, :issue:`44247`)
| Backport PR #45536: DOC: tidy 1.4.0 release notes (2) | https://api.github.com/repos/pandas-dev/pandas/pulls/45540 | 2022-01-21T21:33:10Z | 2022-01-21T22:45:31Z | 2022-01-21T22:45:31Z | 2022-01-21T22:45:31Z |
Bug: Resample ignoring closed=right for TimedeltaIndex | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 1ae76984484af..9756ae7adf930 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -241,7 +241,7 @@ Plotting
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
--
+- Bug in :meth:`DataFrame.resample` ignoring ``closed="right"`` on :class:`TimedeltaIndex` (:issue:`45414`)
-
Reshaping
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index e0b9eac618bc9..53d75255da536 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -1702,12 +1702,19 @@ def _get_time_delta_bins(self, ax: TimedeltaIndex):
return binner, [], labels
start, end = ax.min(), ax.max()
+
+ if self.closed == "right":
+ end += self.freq
+
labels = binner = timedelta_range(
start=start, end=end, freq=self.freq, name=ax.name
)
- end_stamps = labels + self.freq
- bins = ax.searchsorted(end_stamps, side="left")
+ end_stamps = labels
+ if self.closed == "left":
+ end_stamps += self.freq
+
+ bins = ax.searchsorted(end_stamps, side=self.closed)
if self.offset:
# GH 10530 & 31809
diff --git a/pandas/tests/resample/test_timedelta.py b/pandas/tests/resample/test_timedelta.py
index d55dbfca9ebdf..ad1c361373189 100644
--- a/pandas/tests/resample/test_timedelta.py
+++ b/pandas/tests/resample/test_timedelta.py
@@ -191,3 +191,17 @@ def test_resample_quantile_timedelta():
index=pd.date_range("20200101", periods=2, tz="UTC", freq="2D"),
)
tm.assert_frame_equal(result, expected)
+
+
+def test_resample_closed_right():
+ # GH#45414
+ idx = pd.Index([pd.Timedelta(seconds=120 + i * 30) for i in range(10)])
+ ser = Series(range(10), index=idx)
+ result = ser.resample("T", closed="right", label="right").sum()
+ expected = Series(
+ [0, 3, 7, 11, 15, 9],
+ index=pd.TimedeltaIndex(
+ [pd.Timedelta(seconds=120 + i * 60) for i in range(6)], freq="T"
+ ),
+ )
+ tm.assert_series_equal(result, expected)
| - [x] closes #45414
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/45539 | 2022-01-21T20:57:54Z | 2022-01-22T17:28:32Z | 2022-01-22T17:28:31Z | 2022-01-22T19:04:00Z |
Backport PR #45219 on branch 1.4.x (MISC: Check that min versions are aligned in CI and import_optional_dependency) | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 854b7b2e4fe63..5232b76a6388d 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -181,3 +181,8 @@ repos:
entry: 'pg8000'
files: ^ci/deps
types: [yaml]
+ - id: validate-min-versions-in-sync
+ name: Check minimum version of dependencies are aligned
+ entry: python scripts/validate_min_versions_in_sync.py
+ language: python
+ files: ^(ci/deps/actions-.*-minimum_versions\.yaml|pandas/compat/_optional\.py)$
diff --git a/ci/deps/actions-38-minimum_versions.yaml b/ci/deps/actions-38-minimum_versions.yaml
index 8505dad542239..467402bb6ef7f 100644
--- a/ci/deps/actions-38-minimum_versions.yaml
+++ b/ci/deps/actions-38-minimum_versions.yaml
@@ -32,14 +32,14 @@ dependencies:
- matplotlib=3.3.2
- numba=0.50.1
- numexpr=2.7.1
- - openpyxl=3.0.3
- odfpy=1.4.1
+ - openpyxl=3.0.3
- pandas-gbq=0.14.0
- psycopg2=2.8.4
- pymysql=0.10.1
- pytables=3.6.1
- pyarrow=1.0.1
- - pyreadstat
+ - pyreadstat=1.1.0
- pyxlsb=1.0.6
- s3fs=0.4.0
- scipy=1.4.1
diff --git a/doc/source/getting_started/install.rst b/doc/source/getting_started/install.rst
index 1cc74eeddbddb..df9c258f4aa6d 100644
--- a/doc/source/getting_started/install.rst
+++ b/doc/source/getting_started/install.rst
@@ -361,7 +361,7 @@ blosc 1.20.1 Compression for HDF5
zlib Compression for HDF5
fastparquet 0.4.0 Parquet reading / writing
pyarrow 1.0.1 Parquet, ORC, and feather reading / writing
-pyreadstat SPSS files (.sav) reading
+pyreadstat 1.1.0 SPSS files (.sav) reading
========================= ================== =============================================================
.. _install.warn_orc:
diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index a2be663504abe..a26bc94ab883e 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -11,17 +11,24 @@
VERSIONS = {
"bs4": "4.8.2",
+ "blosc": "1.20.1",
"bottleneck": "1.3.1",
- "fsspec": "0.7.4",
"fastparquet": "0.4.0",
+ "fsspec": "0.7.4",
+ "html5lib": "1.1",
"gcsfs": "0.6.0",
+ "jinja2": "2.11",
"lxml.etree": "4.5.0",
"matplotlib": "3.3.2",
+ "numba": "0.50.1",
"numexpr": "2.7.1",
"odfpy": "1.4.1",
"openpyxl": "3.0.3",
"pandas_gbq": "0.14.0",
+ "psycopg2": "2.8.4", # (dt dec pq3 ext lo64)
+ "pymysql": "0.10.1",
"pyarrow": "1.0.1",
+ "pyreadstat": "1.1.0",
"pytest": "6.0",
"pyxlsb": "1.0.6",
"s3fs": "0.4.0",
@@ -33,7 +40,6 @@
"xlrd": "2.0.1",
"xlwt": "1.3.0",
"xlsxwriter": "1.2.2",
- "numba": "0.50.1",
"zstandard": "0.15.2",
}
@@ -46,6 +52,7 @@
"lxml.etree": "lxml",
"odf": "odfpy",
"pandas_gbq": "pandas-gbq",
+ "tables": "pytables",
"sqlalchemy": "SQLAlchemy",
"jinja2": "Jinja2",
}
@@ -59,6 +66,9 @@ def get_version(module: types.ModuleType) -> str:
if version is None:
raise ImportError(f"Can't determine version for {module.__name__}")
+ if module.__name__ == "psycopg2":
+ # psycopg2 appends " (dt dec pq3 ext lo64)" to it's version
+ version = version.split()[0]
return version
diff --git a/scripts/validate_min_versions_in_sync.py b/scripts/validate_min_versions_in_sync.py
new file mode 100755
index 0000000000000..4dbf6a4cdcef8
--- /dev/null
+++ b/scripts/validate_min_versions_in_sync.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+Check pandas required and optional dependencies are synced across:
+
+ci/deps/actions-.*-minimum_versions.yaml
+pandas/compat/_optional.py
+
+TODO: doc/source/getting_started/install.rst
+
+This is meant to be run as a pre-commit hook - to run it manually, you can do:
+
+ pre-commit run validate-min-versions-in-sync --all-files
+"""
+from __future__ import annotations
+
+import pathlib
+import sys
+
+DOC_PATH = pathlib.Path("doc/source/getting_started/install.rst").resolve()
+CI_PATH = next(
+ pathlib.Path("ci/deps").absolute().glob("actions-*-minimum_versions.yaml")
+)
+CODE_PATH = pathlib.Path("pandas/compat/_optional.py").resolve()
+# pandas package is not available
+# in pre-commit environment
+sys.path.append("pandas/compat")
+sys.path.append("pandas/util")
+import version
+
+sys.modules["pandas.util.version"] = version
+import _optional
+
+
+def get_versions_from_code() -> dict[str, str]:
+ install_map = _optional.INSTALL_MAPPING
+ versions = _optional.VERSIONS
+ return {
+ install_map.get(k, k).casefold(): v
+ for k, v in versions.items()
+ if k != "pytest"
+ }
+
+
+def get_versions_from_ci(content: list[str]) -> tuple[dict[str, str], dict[str, str]]:
+ # Don't parse with pyyaml because it ignores comments we're looking for
+ seen_required = False
+ seen_optional = False
+ required_deps = {}
+ optional_deps = {}
+ for line in content:
+ if "# required dependencies" in line:
+ seen_required = True
+ elif "# optional dependencies" in line:
+ seen_optional = True
+ elif seen_required and line.strip():
+ package, version = line.strip().split("=")
+ package = package[2:]
+ if not seen_optional:
+ required_deps[package] = version
+ else:
+ optional_deps[package] = version
+ return required_deps, optional_deps
+
+
+def main():
+ with open(CI_PATH, encoding="utf-8") as f:
+ _, ci_optional = get_versions_from_ci(f.readlines())
+ code_optional = get_versions_from_code()
+ diff = set(ci_optional.items()).symmetric_difference(code_optional.items())
+ if diff:
+ sys.stdout.write(
+ f"The follow minimum version differences were found between "
+ f"{CI_PATH} and {CODE_PATH}. Please ensure these are aligned: "
+ f"{diff}\n"
+ )
+ sys.exit(1)
+ sys.exit(0)
+
+
+if __name__ == "__main__":
+ main()
| Backport PR #45219: MISC: Check that min versions are aligned in CI and import_optional_dependency | https://api.github.com/repos/pandas-dev/pandas/pulls/45537 | 2022-01-21T19:09:51Z | 2022-01-21T20:10:38Z | 2022-01-21T20:10:38Z | 2022-01-21T20:10:38Z |
DOC: tidy 1.4.0 release notes (2) | diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 4e5369072e116..327432de0a3f7 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -92,7 +92,7 @@ Styler
- Styling and formatting of indexes has been added, with :meth:`.Styler.apply_index`, :meth:`.Styler.applymap_index` and :meth:`.Styler.format_index`. These mirror the signature of the methods already used to style and format data values, and work with both HTML, LaTeX and Excel format (:issue:`41893`, :issue:`43101`, :issue:`41993`, :issue:`41995`)
- The new method :meth:`.Styler.hide` deprecates :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` (:issue:`43758`)
- - The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
+ - The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of Index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
- The :meth:`.Styler.export` and :meth:`.Styler.use` have been updated to address all of the added functionality from v1.2.0 and v1.3.0 (:issue:`40675`)
- Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax`` (:issue:`41395`)
- Validation of certain keyword arguments, e.g. ``caption`` (:issue:`43368`)
@@ -110,7 +110,7 @@ There are also some LaTeX specific enhancements:
- :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`)
- Naive sparsification is now possible for LaTeX without the necessity of including the multirow package (:issue:`43369`)
- - *cline* support has been added for MultiIndex row sparsification through a keyword argument (:issue:`45138`)
+ - *cline* support has been added for :class:`MultiIndex` row sparsification through a keyword argument (:issue:`45138`)
.. _whatsnew_140.enhancements.pyarrow_csv_engine:
@@ -342,11 +342,11 @@ Now null-values are no longer mangled.
.. _whatsnew_140.notable_bug_fixes.read_csv_mangle_dup_cols:
-mangle_dupe_cols in read_csv no longer renaming unique columns conflicting with target names
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+mangle_dupe_cols in read_csv no longer renames unique columns conflicting with target names
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:func:`read_csv` no longer renaming unique cols, which conflict with the target
-names of duplicated columns. Already existing columns are jumped, e.g. the next
+:func:`read_csv` no longer renames unique column labels which conflict with the target
+names of duplicated columns. Already existing columns are skipped, i.e. the next
available index is used for the target column name (:issue:`14704`).
.. ipython:: python
@@ -526,6 +526,8 @@ still work, but are not considered supported.
+-----------------+-----------------+---------+
| openpyxl | 3.0.3 | X |
+-----------------+-----------------+---------+
+| pandas-gbq | 0.14.0 | X |
++-----------------+-----------------+---------+
| pyarrow | 1.0.1 | X |
+-----------------+-----------------+---------+
| pymysql | 0.10.1 | X |
@@ -548,8 +550,6 @@ still work, but are not considered supported.
+-----------------+-----------------+---------+
| xlwt | 1.3.0 | |
+-----------------+-----------------+---------+
-| pandas-gbq | 0.14.0 | X |
-+-----------------+-----------------+---------+
See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
@@ -557,7 +557,7 @@ See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for mor
Other API changes
^^^^^^^^^^^^^^^^^
-- :meth:`Index.get_indexer_for` no longer accepts keyword arguments (other than 'target'); in the past these would be silently ignored if the index was not unique (:issue:`42310`)
+- :meth:`Index.get_indexer_for` no longer accepts keyword arguments (other than ``target``); in the past these would be silently ignored if the index was not unique (:issue:`42310`)
- Change in the position of the ``min_rows`` argument in :meth:`DataFrame.to_string` due to change in the docstring (:issue:`44304`)
- Reduction operations for :class:`DataFrame` or :class:`Series` now raising a ``ValueError`` when ``None`` is passed for ``skipna`` (:issue:`44178`)
- :func:`read_csv` and :func:`read_html` no longer raising an error when one of the header rows consists only of ``Unnamed:`` columns (:issue:`13054`)
@@ -573,7 +573,6 @@ Other API changes
- "Thanksgiving" is now "Thanksgiving Day"
- "Christmas" is now "Christmas Day"
- Added "Juneteenth National Independence Day"
--
.. ---------------------------------------------------------------------------
@@ -687,27 +686,27 @@ Other Deprecations
- Deprecated ``method`` argument in :meth:`Index.get_loc`, use ``index.get_indexer([label], method=...)`` instead (:issue:`42269`)
- Deprecated treating integer keys in :meth:`Series.__setitem__` as positional when the index is a :class:`Float64Index` not containing the key, a :class:`IntervalIndex` with no entries containing the key, or a :class:`MultiIndex` with leading :class:`Float64Index` level not containing the key (:issue:`33469`)
- Deprecated treating ``numpy.datetime64`` objects as UTC times when passed to the :class:`Timestamp` constructor along with a timezone. In a future version, these will be treated as wall-times. To retain the old behavior, use ``Timestamp(dt64).tz_localize("UTC").tz_convert(tz)`` (:issue:`24559`)
-- Deprecated ignoring missing labels when indexing with a sequence of labels on a level of a MultiIndex (:issue:`42351`)
-- Creating an empty Series without a dtype will now raise a more visible ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`30017`)
-- Deprecated the 'kind' argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, :meth:`Index.slice_locs`; in a future version passing 'kind' will raise (:issue:`42857`)
+- Deprecated ignoring missing labels when indexing with a sequence of labels on a level of a :class:`MultiIndex` (:issue:`42351`)
+- Creating an empty :class:`Series` without a ``dtype`` will now raise a more visible ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`30017`)
+- Deprecated the ``kind`` argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, and :meth:`Index.slice_locs`; in a future version passing ``kind`` will raise (:issue:`42857`)
- Deprecated dropping of nuisance columns in :class:`Rolling`, :class:`Expanding`, and :class:`EWM` aggregations (:issue:`42738`)
-- Deprecated :meth:`Index.reindex` with a non-unique index (:issue:`42568`)
+- Deprecated :meth:`Index.reindex` with a non-unique :class:`Index` (:issue:`42568`)
- Deprecated :meth:`.Styler.render` in favor of :meth:`.Styler.to_html` (:issue:`42140`)
- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favor of :meth:`.Styler.hide` (:issue:`43758`)
- Deprecated passing in a string column label into ``times`` in :meth:`DataFrame.ewm` (:issue:`43265`)
-- Deprecated the 'include_start' and 'include_end' arguments in :meth:`DataFrame.between_time`; in a future version passing 'include_start' or 'include_end' will raise (:issue:`40245`)
-- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the DataFrame afterwards with ``.squeeze("columns")`` instead (:issue:`43242`)
+- Deprecated the ``include_start`` and ``include_end`` arguments in :meth:`DataFrame.between_time`; in a future version passing ``include_start`` or ``include_end`` will raise (:issue:`40245`)
+- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the :class:`DataFrame` afterwards with ``.squeeze("columns")`` instead (:issue:`43242`)
- Deprecated the ``index`` argument to :class:`SparseArray` construction (:issue:`23089`)
- Deprecated the ``closed`` argument in :meth:`date_range` and :meth:`bdate_range` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)
- Deprecated :meth:`.Rolling.validate`, :meth:`.Expanding.validate`, and :meth:`.ExponentialMovingWindow.validate` (:issue:`43665`)
- Deprecated silent dropping of columns that raised a ``TypeError`` in :class:`Series.transform` and :class:`DataFrame.transform` when used with a dictionary (:issue:`43740`)
- Deprecated silent dropping of columns that raised a ``TypeError``, ``DataError``, and some cases of ``ValueError`` in :meth:`Series.aggregate`, :meth:`DataFrame.aggregate`, :meth:`Series.groupby.aggregate`, and :meth:`DataFrame.groupby.aggregate` when used with a list (:issue:`43740`)
- Deprecated casting behavior when setting timezone-aware value(s) into a timezone-aware :class:`Series` or :class:`DataFrame` column when the timezones do not match. Previously this cast to object dtype. In a future version, the values being inserted will be converted to the series or column's existing timezone (:issue:`37605`)
-- Deprecated casting behavior when passing an item with mismatched-timezone to :meth:`DatetimeIndex.insert`, :meth:`DatetimeIndex.putmask`, :meth:`DatetimeIndex.where` :meth:`DatetimeIndex.fillna`, :meth:`Series.mask`, :meth:`Series.where`, :meth:`Series.fillna`, :meth:`Series.shift`, :meth:`Series.replace`, :meth:`Series.reindex` (and :class:`DataFrame` column analogues). In the past this has cast to object dtype. In a future version, these will cast the passed item to the index or series's timezone (:issue:`37605`,:issue:`44940`)
+- Deprecated casting behavior when passing an item with mismatched-timezone to :meth:`DatetimeIndex.insert`, :meth:`DatetimeIndex.putmask`, :meth:`DatetimeIndex.where` :meth:`DatetimeIndex.fillna`, :meth:`Series.mask`, :meth:`Series.where`, :meth:`Series.fillna`, :meth:`Series.shift`, :meth:`Series.replace`, :meth:`Series.reindex` (and :class:`DataFrame` column analogues). In the past this has cast to object ``dtype``. In a future version, these will cast the passed item to the index or series's timezone (:issue:`37605`, :issue:`44940`)
- Deprecated the ``prefix`` keyword argument in :func:`read_csv` and :func:`read_table`, in a future version the argument will be removed (:issue:`43396`)
-- Deprecated passing non boolean argument to sort in :func:`concat` (:issue:`41518`)
-- Deprecated passing arguments as positional for :func:`read_fwf` other than ``filepath_or_buffer`` (:issue:`41485`):
-- Deprecated passing arguments as positional for :func:`read_xml` other than ``path_or_buffer`` (:issue:`45133`):
+- Deprecated passing non boolean argument to ``sort`` in :func:`concat` (:issue:`41518`)
+- Deprecated passing arguments as positional for :func:`read_fwf` other than ``filepath_or_buffer`` (:issue:`41485`)
+- Deprecated passing arguments as positional for :func:`read_xml` other than ``path_or_buffer`` (:issue:`45133`)
- Deprecated passing ``skipna=None`` for :meth:`DataFrame.mad` and :meth:`Series.mad`, pass ``skipna=True`` instead (:issue:`44580`)
- Deprecated the behavior of :func:`to_datetime` with the string "now" with ``utc=False``; in a future version this will match ``Timestamp("now")``, which in turn matches :meth:`Timestamp.now` returning the local time (:issue:`18705`)
- Deprecated :meth:`DateOffset.apply`, use ``offset + other`` instead (:issue:`44522`)
@@ -749,7 +748,7 @@ Performance improvements
- Performance improvement in :meth:`Series.sparse.to_coo` (:issue:`42880`)
- Performance improvement in indexing with a :class:`UInt64Index` (:issue:`43862`)
- Performance improvement in indexing with a :class:`Float64Index` (:issue:`43705`)
-- Performance improvement in indexing with a non-unique Index (:issue:`43792`)
+- Performance improvement in indexing with a non-unique :class:`Index` (:issue:`43792`)
- Performance improvement in indexing with a listlike indexer on a :class:`MultiIndex` (:issue:`43370`)
- Performance improvement in indexing with a :class:`MultiIndex` indexer on another :class:`MultiIndex` (:issue:`43370`)
- Performance improvement in :meth:`GroupBy.quantile` (:issue:`43469`, :issue:`43725`)
@@ -808,9 +807,9 @@ Datetimelike
- :func:`to_datetime` would silently swap ``MM/DD/YYYY`` and ``DD/MM/YYYY`` formats if the given ``dayfirst`` option could not be respected - now, a warning is raised in the case of delimited date strings (e.g. ``31-12-2012``) (:issue:`12585`)
- Bug in :meth:`date_range` and :meth:`bdate_range` do not return right bound when ``start`` = ``end`` and set is closed on one side (:issue:`43394`)
- Bug in inplace addition and subtraction of :class:`DatetimeIndex` or :class:`TimedeltaIndex` with :class:`DatetimeArray` or :class:`TimedeltaArray` (:issue:`43904`)
-- Bug in in calling ``np.isnan``, ``np.isfinite``, or ``np.isinf`` on a timezone-aware :class:`DatetimeIndex` incorrectly raising ``TypeError`` (:issue:`43917`)
+- Bug in calling ``np.isnan``, ``np.isfinite``, or ``np.isinf`` on a timezone-aware :class:`DatetimeIndex` incorrectly raising ``TypeError`` (:issue:`43917`)
- Bug in constructing a :class:`Series` from datetime-like strings with mixed timezones incorrectly partially-inferring datetime values (:issue:`40111`)
-- Bug in addition with a :class:`Tick` object and a ``np.timedelta64`` object incorrectly raising instead of returning :class:`Timedelta` (:issue:`44474`)
+- Bug in addition of a :class:`Tick` object and a ``np.timedelta64`` object incorrectly raising instead of returning :class:`Timedelta` (:issue:`44474`)
- ``np.maximum.reduce`` and ``np.minimum.reduce`` now correctly return :class:`Timestamp` and :class:`Timedelta` objects when operating on :class:`Series`, :class:`DataFrame`, or :class:`Index` with ``datetime64[ns]`` or ``timedelta64[ns]`` dtype (:issue:`43923`)
- Bug in adding a ``np.timedelta64`` object to a :class:`BusinessDay` or :class:`CustomBusinessDay` object incorrectly raising (:issue:`44532`)
- Bug in :meth:`Index.insert` for inserting ``np.datetime64``, ``np.timedelta64`` or ``tuple`` into :class:`Index` with ``dtype='object'`` with negative loc adding ``None`` and replacing existing value (:issue:`44509`)
@@ -852,7 +851,7 @@ Conversion
- Bug in :class:`Series` constructor returning 0 for missing values with dtype ``int64`` and ``False`` for dtype ``bool`` (:issue:`43017`, :issue:`43018`)
- Bug in constructing a :class:`DataFrame` from a :class:`PandasArray` containing :class:`Series` objects behaving differently than an equivalent ``np.ndarray`` (:issue:`43986`)
- Bug in :class:`IntegerDtype` not allowing coercion from string dtype (:issue:`25472`)
-- Bug in :func:`to_datetime` with ``arg:xr.DataArray`` and ``unit="ns"`` specified raises TypeError (:issue:`44053`)
+- Bug in :func:`to_datetime` with ``arg:xr.DataArray`` and ``unit="ns"`` specified raises ``TypeError`` (:issue:`44053`)
- Bug in :meth:`DataFrame.convert_dtypes` not returning the correct type when a subclass does not overload :meth:`_constructor_sliced` (:issue:`43201`)
- Bug in :meth:`DataFrame.astype` not propagating ``attrs`` from the original :class:`DataFrame` (:issue:`44414`)
- Bug in :meth:`DataFrame.convert_dtypes` result losing ``columns.names`` (:issue:`41435`)
@@ -861,7 +860,7 @@ Conversion
Strings
^^^^^^^
-- Fixed bug in checking for ``string[pyarrow]`` dtype incorrectly raising an ImportError when pyarrow is not installed (:issue:`44276`)
+- Bug in checking for ``string[pyarrow]`` dtype incorrectly raising an ``ImportError`` when pyarrow is not installed (:issue:`44276`)
Interval
^^^^^^^^
@@ -869,16 +868,16 @@ Interval
Indexing
^^^^^^^^
-- Bug in :meth:`Series.rename` when index in Series is MultiIndex and level in rename is provided (:issue:`43659`)
-- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's Index has a length greater than one but only one unique value (:issue:`42365`)
+- Bug in :meth:`Series.rename` with :class:`MultiIndex` and ``level`` is provided (:issue:`43659`)
+- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's :class:`Index` has a length greater than one but only one unique value (:issue:`42365`)
- Bug in :meth:`Series.loc` and :meth:`DataFrame.loc` with a :class:`MultiIndex` when indexing with a tuple in which one of the levels is also a tuple (:issue:`27591`)
-- Bug in :meth:`Series.loc` when with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
+- Bug in :meth:`Series.loc` with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
- Bug in indexing on a :class:`Series` or :class:`DataFrame` with a :class:`DatetimeIndex` when passing a string, the return type depended on whether the index was monotonic (:issue:`24892`)
- Bug in indexing on a :class:`MultiIndex` failing to drop scalar levels when the indexer is a tuple containing a datetime-like string (:issue:`42476`)
- Bug in :meth:`DataFrame.sort_values` and :meth:`Series.sort_values` when passing an ascending value, failed to raise or incorrectly raising ``ValueError`` (:issue:`41634`)
- Bug in updating values of :class:`pandas.Series` using boolean index, created by using :meth:`pandas.DataFrame.pop` (:issue:`42530`)
- Bug in :meth:`Index.get_indexer_non_unique` when index contains multiple ``np.nan`` (:issue:`35392`)
-- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a dataframe (:issue:`42826`)
+- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a :class:`DataFrame` (:issue:`42826`)
- Bug in :meth:`DataFrame.drop` where the error message did not show missing labels with commas when raising ``KeyError`` (:issue:`42881`)
- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed (:issue:`22435`)
- Bug in :meth:`DataFrame.nlargest` and :meth:`Series.nlargest` where sorted result did not count indexes containing ``np.nan`` (:issue:`28984`)
@@ -903,12 +902,12 @@ Indexing
- Bug in :meth:`IntervalIndex.get_indexer_non_unique` not handling targets of ``dtype`` 'object' with NaNs correctly (:issue:`44482`)
- Fixed regression where a single column ``np.matrix`` was no longer coerced to a 1d ``np.ndarray`` when added to a :class:`DataFrame` (:issue:`42376`)
- Bug in :meth:`Series.__getitem__` with a :class:`CategoricalIndex` of integers treating lists of integers as positional indexers, inconsistent with the behavior with a single scalar integer (:issue:`15470`, :issue:`14865`)
-- Bug in :meth:`Series.__setitem__` when setting floats or integers into integer-dtype series failing to upcast when necessary to retain precision (:issue:`45121`)
+- Bug in :meth:`Series.__setitem__` when setting floats or integers into integer-dtype :class:`Series` failing to upcast when necessary to retain precision (:issue:`45121`)
- Bug in :meth:`DataFrame.iloc.__setitem__` ignores axis argument (:issue:`45032`)
Missing
^^^^^^^
-- Bug in :meth:`DataFrame.fillna` with limit and no method ignores axis='columns' or ``axis = 1`` (:issue:`40989`, :issue:`17399`)
+- Bug in :meth:`DataFrame.fillna` with ``limit`` and no ``method`` ignores ``axis='columns'`` or ``axis = 1`` (:issue:`40989`, :issue:`17399`)
- Bug in :meth:`DataFrame.fillna` not replacing missing values when using a dict-like ``value`` and duplicate column names (:issue:`43476`)
- Bug in constructing a :class:`DataFrame` with a dictionary ``np.datetime64`` as a value and ``dtype='timedelta64[ns]'``, or vice-versa, incorrectly casting instead of raising (:issue:`44428`)
- Bug in :meth:`Series.interpolate` and :meth:`DataFrame.interpolate` with ``inplace=True`` not writing to the underlying array(s) in-place (:issue:`44749`)
@@ -933,24 +932,24 @@ I/O
- Bug in :func:`read_fwf`, where difference in lengths of ``colspecs`` and ``names`` was not raising ``ValueError`` (:issue:`40830`)
- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serializing plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
- Column headers are dropped when constructing a :class:`DataFrame` from a sqlalchemy's ``Row`` object (:issue:`40682`)
-- Bug in unpickling a :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
-- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raising uncontrolled ``IndexError`` (:issue:`43102`)
+- Bug in unpickling an :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
+- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raised ``IndexError`` (:issue:`43102`)
- Bug in :func:`read_csv` raising ``ParserError`` when reading file in chunks and some chunk blocks have fewer columns than header for ``engine="c"`` (:issue:`21211`)
- Bug in :func:`read_csv`, changed exception class when expecting a file path name or file-like object from ``OSError`` to ``TypeError`` (:issue:`43366`)
- Bug in :func:`read_csv` and :func:`read_fwf` ignoring all ``skiprows`` except first when ``nrows`` is specified for ``engine='python'`` (:issue:`44021`, :issue:`10261`)
- Bug in :func:`read_csv` keeping the original column in object format when ``keep_date_col=True`` is set (:issue:`13378`)
- Bug in :func:`read_json` not handling non-numpy dtypes correctly (especially ``category``) (:issue:`21892`, :issue:`33205`)
- Bug in :func:`json_normalize` where multi-character ``sep`` parameter is incorrectly prefixed to every key (:issue:`43831`)
-- Bug in :func:`json_normalize` where reading data with missing multi-level metadata would not respect errors="ignore" (:issue:`44312`)
+- Bug in :func:`json_normalize` where reading data with missing multi-level metadata would not respect ``errors="ignore"`` (:issue:`44312`)
- Bug in :func:`read_csv` used second row to guess implicit index if ``header`` was set to ``None`` for ``engine="python"`` (:issue:`22144`)
- Bug in :func:`read_csv` not recognizing bad lines when ``names`` were given for ``engine="c"`` (:issue:`22144`)
- Bug in :func:`read_csv` with :code:`float_precision="round_trip"` which did not skip initial/trailing whitespace (:issue:`43713`)
- Bug when Python is built without the lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used (:issue:`43495`)
- Bug in :func:`read_csv` not applying dtype for ``index_col`` (:issue:`9435`)
- Bug in dumping/loading a :class:`DataFrame` with ``yaml.dump(frame)`` (:issue:`42748`)
-- Bug in :func:`read_csv` raising ``ValueError`` when names was longer than header but equal to data rows for ``engine="python"`` (:issue:`38453`)
+- Bug in :func:`read_csv` raising ``ValueError`` when ``names`` was longer than ``header`` but equal to data rows for ``engine="python"`` (:issue:`38453`)
- Bug in :class:`ExcelWriter`, where ``engine_kwargs`` were not passed through to all engines (:issue:`43442`)
-- Bug in :func:`read_csv` raising ``ValueError`` when ``parse_dates`` was used with ``MultiIndex`` columns (:issue:`8991`)
+- Bug in :func:`read_csv` raising ``ValueError`` when ``parse_dates`` was used with :class:`MultiIndex` columns (:issue:`8991`)
- Bug in :func:`read_csv` not raising an ``ValueError`` when ``\n`` was specified as ``delimiter`` or ``sep`` which conflicts with ``lineterminator`` (:issue:`43528`)
- Bug in :func:`to_csv` converting datetimes in categorical :class:`Series` to integers (:issue:`40754`)
- Bug in :func:`read_csv` converting columns to numeric after date parsing failed (:issue:`11019`)
@@ -982,12 +981,12 @@ Plotting
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
-- Fixed bug in :meth:`SeriesGroupBy.apply` where passing an unrecognized string argument failed to raise ``TypeError`` when the underlying ``Series`` is empty (:issue:`42021`)
+- Bug in :meth:`SeriesGroupBy.apply` where passing an unrecognized string argument failed to raise ``TypeError`` when the underlying ``Series`` is empty (:issue:`42021`)
- Bug in :meth:`Series.rolling.apply`, :meth:`DataFrame.rolling.apply`, :meth:`Series.expanding.apply` and :meth:`DataFrame.expanding.apply` with ``engine="numba"`` where ``*args`` were being cached with the user passed function (:issue:`42287`)
- Bug in :meth:`GroupBy.max` and :meth:`GroupBy.min` with nullable integer dtypes losing precision (:issue:`41743`)
- Bug in :meth:`DataFrame.groupby.rolling.var` would calculate the rolling variance only on the first group (:issue:`42442`)
-- Bug in :meth:`GroupBy.shift` that would return the grouping columns if ``fill_value`` was not None (:issue:`41556`)
-- Bug in :meth:`SeriesGroupBy.nlargest` and :meth:`SeriesGroupBy.nsmallest` would have an inconsistent index when the input Series was sorted and ``n`` was greater than or equal to all group sizes (:issue:`15272`, :issue:`16345`, :issue:`29129`)
+- Bug in :meth:`GroupBy.shift` that would return the grouping columns if ``fill_value`` was not ``None`` (:issue:`41556`)
+- Bug in :meth:`SeriesGroupBy.nlargest` and :meth:`SeriesGroupBy.nsmallest` would have an inconsistent index when the input :class:`Series` was sorted and ``n`` was greater than or equal to all group sizes (:issue:`15272`, :issue:`16345`, :issue:`29129`)
- Bug in :meth:`pandas.DataFrame.ewm`, where non-float64 dtypes were silently failing (:issue:`42452`)
- Bug in :meth:`pandas.DataFrame.rolling` operation along rows (``axis=1``) incorrectly omits columns containing ``float16`` and ``float32`` (:issue:`41779`)
- Bug in :meth:`Resampler.aggregate` did not allow the use of Named Aggregation (:issue:`32803`)
@@ -996,37 +995,37 @@ Groupby/resample/rolling
- Bug in :meth:`DataFrame.groupby.rolling` when specifying ``on`` and calling ``__getitem__`` would subsequently return incorrect results (:issue:`43355`)
- Bug in :meth:`GroupBy.apply` with time-based :class:`Grouper` objects incorrectly raising ``ValueError`` in corner cases where the grouping vector contains a ``NaT`` (:issue:`43500`, :issue:`43515`)
- Bug in :meth:`GroupBy.mean` failing with ``complex`` dtype (:issue:`43701`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not calculating window bounds correctly for the first row when ``center=True`` and index is decreasing (:issue:`43927`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` for centered datetimelike windows with uneven nanosecond (:issue:`43997`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not calculating window bounds correctly for the first row when ``center=True`` and index is decreasing (:issue:`43927`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` for centered datetimelike windows with uneven nanosecond (:issue:`43997`)
- Bug in :meth:`GroupBy.mean` raising ``KeyError`` when column was selected at least twice (:issue:`44924`)
- Bug in :meth:`GroupBy.nth` failing on ``axis=1`` (:issue:`43926`)
-- Fixed bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not respecting right bound on centered datetime-like windows, if the index contain duplicates (:issue:`3944`)
+- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` not respecting right bound on centered datetime-like windows, if the index contain duplicates (:issue:`3944`)
- Bug in :meth:`Series.rolling` and :meth:`DataFrame.rolling` when using a :class:`pandas.api.indexers.BaseIndexer` subclass that returned unequal start and end arrays would segfault instead of raising a ``ValueError`` (:issue:`44470`)
-- Bug in :meth:`Groupby.nunique` not respecting ``observed=True`` for Categorical grouping columns (:issue:`45128`)
+- Bug in :meth:`Groupby.nunique` not respecting ``observed=True`` for ``categorical`` grouping columns (:issue:`45128`)
- Bug in :meth:`GroupBy.head` and :meth:`GroupBy.tail` not dropping groups with ``NaN`` when ``dropna=True`` (:issue:`45089`)
-- Fixed bug in :meth:`GroupBy.__iter__` after selecting a subset of columns in a :class:`GroupBy` object, which returned all columns instead of the chosen subset (:issue:`44821`)
+- Bug in :meth:`GroupBy.__iter__` after selecting a subset of columns in a :class:`GroupBy` object, which returned all columns instead of the chosen subset (:issue:`44821`)
- Bug in :meth:`Groupby.rolling` when non-monotonic data passed, fails to correctly raise ``ValueError`` (:issue:`43909`)
-- Fixed bug where grouping by a :class:`Series` that has a categorical data type and length unequal to the axis of grouping raised ``ValueError`` (:issue:`44179`)
+- Bug where grouping by a :class:`Series` that has a ``categorical`` data type and length unequal to the axis of grouping raised ``ValueError`` (:issue:`44179`)
Reshaping
^^^^^^^^^
- Improved error message when creating a :class:`DataFrame` column from a multi-dimensional :class:`numpy.ndarray` (:issue:`42463`)
-- :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
+- Bug in :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42185`, :issue:`42425`)
- Bug in :meth:`DataFrame.append` failing to retain dtypes when appended columns do not match (:issue:`43392`)
- Bug in :func:`concat` of ``bool`` and ``boolean`` dtypes resulting in ``object`` dtype instead of ``boolean`` dtype (:issue:`42800`)
-- Bug in :func:`crosstab` when inputs are categorical Series, there are categories that are not present in one or both of the Series, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
+- Bug in :func:`crosstab` when inputs are categorical :class:`Series`, there are categories that are not present in one or both of the :class:`Series`, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
- Bug in :func:`concat` would fail when the ``objs`` argument all had the same index and the ``keys`` argument contained duplicates (:issue:`43595`)
- Bug in :func:`concat` which ignored the ``sort`` parameter (:issue:`43375`)
-- Fixed bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
+- Bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
- Bug in :func:`crosstab` would fail when inputs are lists or tuples (:issue:`44076`)
- Bug in :meth:`DataFrame.append` failing to retain ``index.name`` when appending a list of :class:`Series` objects (:issue:`44109`)
- Fixed metadata propagation in :meth:`Dataframe.apply` method, consequently fixing the same issue for :meth:`Dataframe.transform`, :meth:`Dataframe.nunique` and :meth:`Dataframe.mode` (:issue:`28283`)
-- Bug in :func:`concat` casting levels of :class:`MultiIndex` to float if the only consist of missing values (:issue:`44900`)
+- Bug in :func:`concat` casting levels of :class:`MultiIndex` to float if all levels only consist of missing values (:issue:`44900`)
- Bug in :meth:`DataFrame.stack` with ``ExtensionDtype`` columns incorrectly raising (:issue:`43561`)
- Bug in :func:`merge` raising ``KeyError`` when joining over differently named indexes with on keywords (:issue:`45094`)
- Bug in :meth:`Series.unstack` with object doing unwanted type inference on resulting columns (:issue:`44595`)
-- Bug in :class:`MultiIndex` failing join operations with overlapping ``IntervalIndex`` levels (:issue:`44096`)
+- Bug in :meth:`MultiIndex.join()` with overlapping ``IntervalIndex`` levels (:issue:`44096`)
- Bug in :meth:`DataFrame.replace` and :meth:`Series.replace` results is different ``dtype`` based on ``regex`` parameter (:issue:`44864`)
- Bug in :meth:`DataFrame.pivot` with ``index=None`` when the :class:`DataFrame` index was a :class:`MultiIndex` (:issue:`23955`)
@@ -1045,24 +1044,24 @@ ExtensionArray
- NumPy ufuncs ``np.abs``, ``np.positive``, ``np.negative`` now correctly preserve dtype when called on ExtensionArrays that implement ``__abs__, __pos__, __neg__``, respectively. In particular this is fixed for :class:`TimedeltaArray` (:issue:`43899`, :issue:`23316`)
- NumPy ufuncs ``np.minimum.reduce`` ``np.maximum.reduce``, ``np.add.reduce``, and ``np.prod.reduce`` now work correctly instead of raising ``NotImplementedError`` on :class:`Series` with ``IntegerDtype`` or ``FloatDtype`` (:issue:`43923`, :issue:`44793`)
- NumPy ufuncs with ``out`` keyword are now supported by arrays with ``IntegerDtype`` and ``FloatingDtype`` (:issue:`45122`)
-- Avoid raising ``PerformanceWarning`` about fragmented DataFrame when using many columns with an extension dtype (:issue:`44098`)
+- Avoid raising ``PerformanceWarning`` about fragmented :class:`DataFrame` when using many columns with an extension dtype (:issue:`44098`)
- Bug in :class:`IntegerArray` and :class:`FloatingArray` construction incorrectly coercing mismatched NA values (e.g. ``np.timedelta64("NaT")``) to numeric NA (:issue:`44514`)
- Bug in :meth:`BooleanArray.__eq__` and :meth:`BooleanArray.__ne__` raising ``TypeError`` on comparison with an incompatible type (like a string). This caused :meth:`DataFrame.replace` to sometimes raise a ``TypeError`` if a nullable boolean column was included (:issue:`44499`)
- Bug in :func:`array` incorrectly raising when passed a ``ndarray`` with ``float16`` dtype (:issue:`44715`)
- Bug in calling ``np.sqrt`` on :class:`BooleanArray` returning a malformed :class:`FloatingArray` (:issue:`44715`)
-- Bug in :meth:`Series.where` with ``ExtensionDtype`` when ``other`` is a NA scalar incompatible with the series dtype (e.g. ``NaT`` with a numeric dtype) incorrectly casting to a compatible NA value (:issue:`44697`)
-- Fixed bug in :meth:`Series.replace` where explicitly passing ``value=None`` is treated as if no ``value`` was passed, and ``None`` not being in the result (:issue:`36984`, :issue:`19998`)
-- Fixed bug in :meth:`Series.replace` with unwanted downcasting being done in no-op replacements (:issue:`44498`)
-- Fixed bug in :meth:`Series.replace` with ``FloatDtype``, ``string[python]``, or ``string[pyarrow]`` dtype not being preserved when possible (:issue:`33484`, :issue:`40732`, :issue:`31644`, :issue:`41215`, :issue:`25438`)
+- Bug in :meth:`Series.where` with ``ExtensionDtype`` when ``other`` is a NA scalar incompatible with the :class:`Series` dtype (e.g. ``NaT`` with a numeric dtype) incorrectly casting to a compatible NA value (:issue:`44697`)
+- Bug in :meth:`Series.replace` where explicitly passing ``value=None`` is treated as if no ``value`` was passed, and ``None`` not being in the result (:issue:`36984`, :issue:`19998`)
+- Bug in :meth:`Series.replace` with unwanted downcasting being done in no-op replacements (:issue:`44498`)
+- Bug in :meth:`Series.replace` with ``FloatDtype``, ``string[python]``, or ``string[pyarrow]`` dtype not being preserved when possible (:issue:`33484`, :issue:`40732`, :issue:`31644`, :issue:`41215`, :issue:`25438`)
Styler
^^^^^^
-- Minor bug in :class:`.Styler` where the ``uuid`` at initialization maintained a floating underscore (:issue:`43037`)
+- Bug in :class:`.Styler` where the ``uuid`` at initialization maintained a floating underscore (:issue:`43037`)
- Bug in :meth:`.Styler.to_html` where the ``Styler`` object was updated if the ``to_html`` method was called with some args (:issue:`43034`)
- Bug in :meth:`.Styler.copy` where ``uuid`` was not previously copied (:issue:`40675`)
-- Bug in :meth:`Styler.apply` where functions which returned Series objects were not correctly handled in terms of aligning their index labels (:issue:`13657`, :issue:`42014`)
-- Bug when rendering an empty DataFrame with a named index (:issue:`43305`).
-- Bug when rendering a single level MultiIndex (:issue:`43383`).
+- Bug in :meth:`Styler.apply` where functions which returned :class:`Series` objects were not correctly handled in terms of aligning their index labels (:issue:`13657`, :issue:`42014`)
+- Bug when rendering an empty :class:`DataFrame` with a named :class:`Index` (:issue:`43305`)
+- Bug when rendering a single level :class:`MultiIndex` (:issue:`43383`)
- Bug when combining non-sparse rendering and :meth:`.Styler.hide_columns` or :meth:`.Styler.hide_index` (:issue:`43464`)
- Bug setting a table style when using multiple selectors in :class:`.Styler` (:issue:`44011`)
- Bugs where row trimming and column trimming failed to reflect hidden rows (:issue:`43703`, :issue:`44247`)
| null | https://api.github.com/repos/pandas-dev/pandas/pulls/45536 | 2022-01-21T18:39:12Z | 2022-01-21T21:33:00Z | 2022-01-21T21:33:00Z | 2022-01-21T21:54:29Z |
PERF: Improve performance for df.duplicated with one column subset | diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py
index 16925b7959e6a..5254bdba14990 100644
--- a/asv_bench/benchmarks/frame_methods.py
+++ b/asv_bench/benchmarks/frame_methods.py
@@ -611,6 +611,9 @@ def time_frame_duplicated(self):
def time_frame_duplicated_wide(self):
self.df2.duplicated()
+ def time_frame_duplicated_subset(self):
+ self.df.duplicated(subset=["a"])
+
class XS:
diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 1ae76984484af..c6f78c97802b0 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -153,7 +153,7 @@ Other Deprecations
Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
--
+- Performance improvement in :meth:`DataFrame.duplicated` when subset consists of only one column (:issue:`45236`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 88b848f34fbe5..95b56c5b9eb7b 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -6252,22 +6252,27 @@ def f(vals) -> tuple[np.ndarray, int]:
# Verify all columns in subset exist in the queried dataframe
# Otherwise, raise a KeyError, same as if you try to __getitem__ with a
# key that doesn't exist.
- diff = Index(subset).difference(self.columns)
- if not diff.empty:
- raise KeyError(diff)
-
- vals = (col.values for name, col in self.items() if name in subset)
- labels, shape = map(list, zip(*map(f, vals)))
-
- ids = get_group_index(
- labels,
- # error: Argument 1 to "tuple" has incompatible type "List[_T]";
- # expected "Iterable[int]"
- tuple(shape), # type: ignore[arg-type]
- sort=False,
- xnull=False,
- )
- result = self._constructor_sliced(duplicated(ids, keep), index=self.index)
+ diff = set(subset) - set(self.columns)
+ if diff:
+ raise KeyError(Index(diff))
+
+ if len(subset) == 1 and self.columns.is_unique:
+ # GH#45236 This is faster than get_group_index below
+ result = self[subset[0]].duplicated(keep)
+ result.name = None
+ else:
+ vals = (col.values for name, col in self.items() if name in subset)
+ labels, shape = map(list, zip(*map(f, vals)))
+
+ ids = get_group_index(
+ labels,
+ # error: Argument 1 to "tuple" has incompatible type "List[_T]";
+ # expected "Iterable[int]"
+ tuple(shape), # type: ignore[arg-type]
+ sort=False,
+ xnull=False,
+ )
+ result = self._constructor_sliced(duplicated(ids, keep), index=self.index)
return result.__finalize__(self, method="duplicated")
# ----------------------------------------------------------------------
diff --git a/pandas/tests/frame/methods/test_duplicated.py b/pandas/tests/frame/methods/test_duplicated.py
index 0b90914281d3b..9d46a8abb9b46 100644
--- a/pandas/tests/frame/methods/test_duplicated.py
+++ b/pandas/tests/frame/methods/test_duplicated.py
@@ -62,7 +62,7 @@ def test_duplicated_keep(keep, expected):
],
)
def test_duplicated_nan_none(keep, expected):
- df = DataFrame({"C": [np.nan, 3, 3, None, np.nan]}, dtype=object)
+ df = DataFrame({"C": [np.nan, 3, 3, None, np.nan], "x": 1}, dtype=object)
result = df.duplicated(keep=keep)
tm.assert_series_equal(result, expected)
@@ -109,5 +109,5 @@ def test_frame_datetime64_duplicated():
assert (-result).all()
tst = DataFrame({"date": dates})
- result = tst.duplicated()
+ result = tst.date.duplicated()
assert (-result).all()
| - [x] closes #45236
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [x] whatsnew entry
```
%timeit df["a"].duplicated()
3.16 ms ± 96 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit df.duplicated(subset=['a'])
3.1 ms ± 75.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
```
The Index creation and the ``get_group_index`` were both at fault for the slowdown. Removing the Index call should improve the performance for longer subsets too. | https://api.github.com/repos/pandas-dev/pandas/pulls/45534 | 2022-01-21T17:03:13Z | 2022-01-21T22:22:05Z | 2022-01-21T22:22:05Z | 2022-06-13T08:25:02Z |
Backport PR #45528 on branch 1.4.x (DOC: tidy 1.4.0 release notes) | diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 234fada5e2ba3..4e5369072e116 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -1,6 +1,6 @@
.. _whatsnew_140:
-What's new in 1.4.0 (January ??, 2022)
+What's new in 1.4.0 (January 22, 2022)
--------------------------------------
These are the changes in pandas 1.4.0. See :ref:`release` for a full changelog
@@ -20,7 +20,8 @@ Enhancements
Improved warning messages
^^^^^^^^^^^^^^^^^^^^^^^^^
-Previously, warning messages may have pointed to lines within the pandas library. Running the script ``setting_with_copy_warning.py``
+Previously, warning messages may have pointed to lines within the pandas
+library. Running the script ``setting_with_copy_warning.py``
.. code-block:: python
@@ -34,7 +35,10 @@ with pandas 1.3 resulted in::
.../site-packages/pandas/core/indexing.py:1951: SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
-This made it difficult to determine where the warning was being generated from. Now pandas will inspect the call stack, reporting the first line outside of the pandas library that gave rise to the warning. The output of the above script is now::
+This made it difficult to determine where the warning was being generated from.
+Now pandas will inspect the call stack, reporting the first line outside of the
+pandas library that gave rise to the warning. The output of the above script is
+now::
setting_with_copy_warning.py:4: SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
@@ -47,8 +51,9 @@ This made it difficult to determine where the warning was being generated from.
Index can hold arbitrary ExtensionArrays
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Until now, passing a custom :class:`ExtensionArray` to ``pd.Index`` would cast the
-array to ``object`` dtype. Now :class:`Index` can directly hold arbitrary ExtensionArrays (:issue:`43930`).
+Until now, passing a custom :class:`ExtensionArray` to ``pd.Index`` would cast
+the array to ``object`` dtype. Now :class:`Index` can directly hold arbitrary
+ExtensionArrays (:issue:`43930`).
*Previous behavior*:
@@ -89,38 +94,43 @@ Styler
- The new method :meth:`.Styler.hide` deprecates :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` (:issue:`43758`)
- The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
- The :meth:`.Styler.export` and :meth:`.Styler.use` have been updated to address all of the added functionality from v1.2.0 and v1.3.0 (:issue:`40675`)
- - Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax``. (:issue:`41395`)
+ - Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax`` (:issue:`41395`)
- Validation of certain keyword arguments, e.g. ``caption`` (:issue:`43368`)
- Various bug fixes as recorded below
Additionally there are specific enhancements to the HTML specific rendering:
- - :meth:`.Styler.bar` introduces additional arguments to control alignment and display (:issue:`26070`, :issue:`36419`), and it also validates the input arguments ``width`` and ``height`` (:issue:`42511`).
- - :meth:`.Styler.to_html` introduces keyword arguments ``sparse_index``, ``sparse_columns``, ``bold_headers``, ``caption``, ``max_rows`` and ``max_columns`` (:issue:`41946`, :issue:`43149`, :issue:`42972`).
+ - :meth:`.Styler.bar` introduces additional arguments to control alignment and display (:issue:`26070`, :issue:`36419`), and it also validates the input arguments ``width`` and ``height`` (:issue:`42511`)
+ - :meth:`.Styler.to_html` introduces keyword arguments ``sparse_index``, ``sparse_columns``, ``bold_headers``, ``caption``, ``max_rows`` and ``max_columns`` (:issue:`41946`, :issue:`43149`, :issue:`42972`)
- :meth:`.Styler.to_html` omits CSSStyle rules for hidden table elements as a performance enhancement (:issue:`43619`)
- Custom CSS classes can now be directly specified without string replacement (:issue:`43686`)
- Ability to render hyperlinks automatically via a new ``hyperlinks`` formatting keyword argument (:issue:`45058`)
There are also some LaTeX specific enhancements:
- - :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`).
+ - :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`)
- Naive sparsification is now possible for LaTeX without the necessity of including the multirow package (:issue:`43369`)
- *cline* support has been added for MultiIndex row sparsification through a keyword argument (:issue:`45138`)
.. _whatsnew_140.enhancements.pyarrow_csv_engine:
-Multithreaded CSV reading with a new CSV Engine based on pyarrow
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multi-threaded CSV reading with a new CSV Engine based on pyarrow
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:func:`pandas.read_csv` now accepts ``engine="pyarrow"`` (requires at least ``pyarrow`` 1.0.1) as an argument, allowing for faster csv parsing on multicore machines
-with pyarrow installed. See the :doc:`I/O docs </user_guide/io>` for more info. (:issue:`23697`, :issue:`43706`)
+:func:`pandas.read_csv` now accepts ``engine="pyarrow"`` (requires at least
+``pyarrow`` 1.0.1) as an argument, allowing for faster csv parsing on multicore
+machines with pyarrow installed. See the :doc:`I/O docs </user_guide/io>` for
+more info. (:issue:`23697`, :issue:`43706`)
.. _whatsnew_140.enhancements.window_rank:
Rank function for rolling and expanding windows
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Added ``rank`` function to :class:`Rolling` and :class:`Expanding`. The new function supports the ``method``, ``ascending``, and ``pct`` flags of :meth:`DataFrame.rank`. The ``method`` argument supports ``min``, ``max``, and ``average`` ranking methods.
+Added ``rank`` function to :class:`Rolling` and :class:`Expanding`. The new
+function supports the ``method``, ``ascending``, and ``pct`` flags of
+:meth:`DataFrame.rank`. The ``method`` argument supports ``min``, ``max``, and
+``average`` ranking methods.
Example:
.. ipython:: python
@@ -135,10 +145,12 @@ Example:
Groupby positional indexing
^^^^^^^^^^^^^^^^^^^^^^^^^^^
-It is now possible to specify positional ranges relative to the ends of each group.
+It is now possible to specify positional ranges relative to the ends of each
+group.
-Negative arguments for :meth:`.GroupBy.head` and :meth:`.GroupBy.tail` now work correctly and result in ranges relative to the end and start of each group, respectively.
-Previously, negative arguments returned empty frames.
+Negative arguments for :meth:`.GroupBy.head` and :meth:`.GroupBy.tail` now work
+correctly and result in ranges relative to the end and start of each group,
+respectively. Previously, negative arguments returned empty frames.
.. ipython:: python
@@ -167,10 +179,11 @@ Previously, negative arguments returned empty frames.
DataFrame.from_dict and DataFrame.to_dict have new ``'tight'`` option
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-A new ``'tight'`` dictionary format that preserves :class:`MultiIndex` entries and names
-is now available with the :meth:`DataFrame.from_dict` and :meth:`DataFrame.to_dict` methods
-and can be used with the standard ``json`` library to produce a tight
-representation of :class:`DataFrame` objects (:issue:`4889`).
+A new ``'tight'`` dictionary format that preserves :class:`MultiIndex` entries
+and names is now available with the :meth:`DataFrame.from_dict` and
+:meth:`DataFrame.to_dict` methods and can be used with the standard ``json``
+library to produce a tight representation of :class:`DataFrame` objects
+(:issue:`4889`).
.. ipython:: python
@@ -188,21 +201,21 @@ representation of :class:`DataFrame` objects (:issue:`4889`).
Other enhancements
^^^^^^^^^^^^^^^^^^
-- :meth:`concat` will preserve the ``attrs`` when it is the same for all objects and discard the ``attrs`` when they are different. (:issue:`41828`)
+- :meth:`concat` will preserve the ``attrs`` when it is the same for all objects and discard the ``attrs`` when they are different (:issue:`41828`)
- :class:`DataFrameGroupBy` operations with ``as_index=False`` now correctly retain ``ExtensionDtype`` dtypes for columns being grouped on (:issue:`41373`)
- Add support for assigning values to ``by`` argument in :meth:`DataFrame.plot.hist` and :meth:`DataFrame.plot.box` (:issue:`15079`)
- :meth:`Series.sample`, :meth:`DataFrame.sample`, and :meth:`.GroupBy.sample` now accept a ``np.random.Generator`` as input to ``random_state``. A generator will be more performant, especially with ``replace=False`` (:issue:`38100`)
-- :meth:`Series.ewm`, :meth:`DataFrame.ewm`, now support a ``method`` argument with a ``'table'`` option that performs the windowing operation over an entire :class:`DataFrame`. See :ref:`Window Overview <window.overview>` for performance and functional benefits (:issue:`42273`)
+- :meth:`Series.ewm` and :meth:`DataFrame.ewm` now support a ``method`` argument with a ``'table'`` option that performs the windowing operation over an entire :class:`DataFrame`. See :ref:`Window Overview <window.overview>` for performance and functional benefits (:issue:`42273`)
- :meth:`.GroupBy.cummin` and :meth:`.GroupBy.cummax` now support the argument ``skipna`` (:issue:`34047`)
- :meth:`read_table` now supports the argument ``storage_options`` (:issue:`39167`)
-- :meth:`DataFrame.to_stata` and :meth:`StataWriter` now accept the keyword only argument ``value_labels`` to save labels for non-categorical columns
+- :meth:`DataFrame.to_stata` and :meth:`StataWriter` now accept the keyword only argument ``value_labels`` to save labels for non-categorical columns (:issue:`38454`)
- Methods that relied on hashmap based algos such as :meth:`DataFrameGroupBy.value_counts`, :meth:`DataFrameGroupBy.count` and :func:`factorize` ignored imaginary component for complex numbers (:issue:`17927`)
- Add :meth:`Series.str.removeprefix` and :meth:`Series.str.removesuffix` introduced in Python 3.9 to remove pre-/suffixes from string-type :class:`Series` (:issue:`36944`)
- Attempting to write into a file in missing parent directory with :meth:`DataFrame.to_csv`, :meth:`DataFrame.to_html`, :meth:`DataFrame.to_excel`, :meth:`DataFrame.to_feather`, :meth:`DataFrame.to_parquet`, :meth:`DataFrame.to_stata`, :meth:`DataFrame.to_json`, :meth:`DataFrame.to_pickle`, and :meth:`DataFrame.to_xml` now explicitly mentions missing parent directory, the same is true for :class:`Series` counterparts (:issue:`24306`)
- Indexing with ``.loc`` and ``.iloc`` now supports ``Ellipsis`` (:issue:`37750`)
- :meth:`IntegerArray.all` , :meth:`IntegerArray.any`, :meth:`FloatingArray.any`, and :meth:`FloatingArray.all` use Kleene logic (:issue:`41967`)
- Added support for nullable boolean and integer types in :meth:`DataFrame.to_stata`, :class:`~pandas.io.stata.StataWriter`, :class:`~pandas.io.stata.StataWriter117`, and :class:`~pandas.io.stata.StataWriterUTF8` (:issue:`40855`)
-- :meth:`DataFrame.__pos__`, :meth:`DataFrame.__neg__` now retain ``ExtensionDtype`` dtypes (:issue:`43883`)
+- :meth:`DataFrame.__pos__` and :meth:`DataFrame.__neg__` now retain ``ExtensionDtype`` dtypes (:issue:`43883`)
- The error raised when an optional dependency can't be imported now includes the original exception, for easier investigation (:issue:`43882`)
- Added :meth:`.ExponentialMovingWindow.sum` (:issue:`13297`)
- :meth:`Series.str.split` now supports a ``regex`` argument that explicitly specifies whether the pattern is a regular expression. Default is ``None`` (:issue:`43563`, :issue:`32835`, :issue:`25549`)
@@ -211,19 +224,19 @@ Other enhancements
- :func:`read_csv` now accepts a ``callable`` function in ``on_bad_lines`` when ``engine="python"`` for custom handling of bad lines (:issue:`5686`)
- :class:`ExcelWriter` argument ``if_sheet_exists="overlay"`` option added (:issue:`40231`)
- :meth:`read_excel` now accepts a ``decimal`` argument that allow the user to specify the decimal point when parsing string columns to numeric (:issue:`14403`)
-- :meth:`.GroupBy.mean`, :meth:`.GroupBy.std`, :meth:`.GroupBy.var`, :meth:`.GroupBy.sum` now supports `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`43731`, :issue:`44862`, :issue:`44939`)
-- :meth:`Timestamp.isoformat`, now handles the ``timespec`` argument from the base :class:``datetime`` class (:issue:`26131`)
+- :meth:`.GroupBy.mean`, :meth:`.GroupBy.std`, :meth:`.GroupBy.var`, and :meth:`.GroupBy.sum` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`43731`, :issue:`44862`, :issue:`44939`)
+- :meth:`Timestamp.isoformat` now handles the ``timespec`` argument from the base ``datetime`` class (:issue:`26131`)
- :meth:`NaT.to_numpy` ``dtype`` argument is now respected, so ``np.timedelta64`` can be returned (:issue:`44460`)
- New option ``display.max_dir_items`` customizes the number of columns added to :meth:`Dataframe.__dir__` and suggested for tab completion (:issue:`37996`)
-- Added "Juneteenth National Independence Day" to ``USFederalHolidayCalendar``. See also `Other API changes`_.
-- :meth:`.Rolling.var`, :meth:`.Expanding.var`, :meth:`.Rolling.std`, :meth:`.Expanding.std` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`44461`)
+- Added "Juneteenth National Independence Day" to ``USFederalHolidayCalendar`` (:issue:`44574`)
+- :meth:`.Rolling.var`, :meth:`.Expanding.var`, :meth:`.Rolling.std`, and :meth:`.Expanding.std` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`44461`)
- :meth:`Series.info` has been added, for compatibility with :meth:`DataFrame.info` (:issue:`5167`)
-- Implemented :meth:`IntervalArray.min`, :meth:`IntervalArray.max`, as a result of which ``min`` and ``max`` now work for :class:`IntervalIndex`, :class:`Series` and :class:`DataFrame` with ``IntervalDtype`` (:issue:`44746`)
+- Implemented :meth:`IntervalArray.min` and :meth:`IntervalArray.max`, as a result of which ``min`` and ``max`` now work for :class:`IntervalIndex`, :class:`Series` and :class:`DataFrame` with ``IntervalDtype`` (:issue:`44746`)
- :meth:`UInt64Index.map` now retains ``dtype`` where possible (:issue:`44609`)
- :meth:`read_json` can now parse unsigned long long integers (:issue:`26068`)
- :meth:`DataFrame.take` now raises a ``TypeError`` when passed a scalar for the indexer (:issue:`42875`)
- :meth:`is_list_like` now identifies duck-arrays as list-like unless ``.ndim == 0`` (:issue:`35131`)
-- :class:`ExtensionDtype` and :class:`ExtensionArray` are now (de)serialized when exporting a :class:`DataFrame` with :meth:`DataFrame.to_json` using ``orient='table'`` (:issue:`20612`, :issue:`44705`).
+- :class:`ExtensionDtype` and :class:`ExtensionArray` are now (de)serialized when exporting a :class:`DataFrame` with :meth:`DataFrame.to_json` using ``orient='table'`` (:issue:`20612`, :issue:`44705`)
- Add support for `Zstandard <http://facebook.github.io/zstd/>`_ compression to :meth:`DataFrame.to_pickle`/:meth:`read_pickle` and friends (:issue:`43925`)
- :meth:`DataFrame.to_sql` now returns an ``int`` of the number of written rows (:issue:`23998`)
@@ -241,15 +254,17 @@ These are bug fixes that might have notable behavior changes.
Inconsistent date string parsing
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-The ``dayfirst`` option of :func:`to_datetime` isn't strict, and this can lead to surprising behaviour:
+The ``dayfirst`` option of :func:`to_datetime` isn't strict, and this can lead
+to surprising behavior:
.. ipython:: python
:okwarning:
pd.to_datetime(["31-12-2021"], dayfirst=False)
-Now, a warning will be raised if a date string cannot be parsed accordance to the given ``dayfirst`` value when
-the value is a delimited date string (e.g. ``31-12-2012``).
+Now, a warning will be raised if a date string cannot be parsed accordance to
+the given ``dayfirst`` value when the value is a delimited date string (e.g.
+``31-12-2012``).
.. _whatsnew_140.notable_bug_fixes.concat_with_empty_or_all_na:
@@ -257,8 +272,9 @@ Ignoring dtypes in concat with empty or all-NA columns
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
When using :func:`concat` to concatenate two or more :class:`DataFrame` objects,
-if one of the DataFrames was empty or had all-NA values, its dtype was *sometimes*
-ignored when finding the concatenated dtype. These are now consistently *not* ignored (:issue:`43507`).
+if one of the DataFrames was empty or had all-NA values, its dtype was
+*sometimes* ignored when finding the concatenated dtype. These are now
+consistently *not* ignored (:issue:`43507`).
.. ipython:: python
@@ -266,7 +282,9 @@ ignored when finding the concatenated dtype. These are now consistently *not* i
df2 = pd.DataFrame({"bar": np.nan}, index=range(1, 2))
res = pd.concat([df1, df2])
-Previously, the float-dtype in ``df2`` would be ignored so the result dtype would be ``datetime64[ns]``. As a result, the ``np.nan`` would be cast to ``NaT``.
+Previously, the float-dtype in ``df2`` would be ignored so the result dtype
+would be ``datetime64[ns]``. As a result, the ``np.nan`` would be cast to
+``NaT``.
*Previous behavior*:
@@ -278,7 +296,8 @@ Previously, the float-dtype in ``df2`` would be ignored so the result dtype woul
0 2013-01-01
1 NaT
-Now the float-dtype is respected. Since the common dtype for these DataFrames is object, the ``np.nan`` is retained.
+Now the float-dtype is respected. Since the common dtype for these DataFrames is
+object, the ``np.nan`` is retained.
*New behavior*:
@@ -291,7 +310,10 @@ Now the float-dtype is respected. Since the common dtype for these DataFrames is
Null-values are no longer coerced to NaN-value in value_counts and mode
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:meth:`Series.value_counts` and :meth:`Series.mode` no longer coerce ``None``, ``NaT`` and other null-values to a NaN-value for ``np.object``-dtype. This behavior is now consistent with ``unique``, ``isin`` and others (:issue:`42688`).
+:meth:`Series.value_counts` and :meth:`Series.mode` no longer coerce ``None``,
+``NaT`` and other null-values to a NaN-value for ``np.object``-dtype. This
+behavior is now consistent with ``unique``, ``isin`` and others
+(:issue:`42688`).
.. ipython:: python
@@ -323,8 +345,9 @@ Now null-values are no longer mangled.
mangle_dupe_cols in read_csv no longer renaming unique columns conflicting with target names
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:func:`read_csv` no longer renaming unique cols, which conflict with the target names of duplicated columns.
-Already existing columns are jumped, e.g. the next available index is used for the target column name (:issue:`14704`).
+:func:`read_csv` no longer renaming unique cols, which conflict with the target
+names of duplicated columns. Already existing columns are jumped, e.g. the next
+available index is used for the target column name (:issue:`14704`).
.. ipython:: python
@@ -333,7 +356,8 @@ Already existing columns are jumped, e.g. the next available index is used for t
data = "a,a,a.1\n1,2,3"
res = pd.read_csv(io.StringIO(data))
-Previously, the second column was called ``a.1``, while the third col was also renamed to ``a.1.1``.
+Previously, the second column was called ``a.1``, while the third column was
+also renamed to ``a.1.1``.
*Previous behavior*:
@@ -344,8 +368,9 @@ Previously, the second column was called ``a.1``, while the third col was also r
a a.1 a.1.1
0 1 2 3
-Now the renaming checks if ``a.1`` already exists when changing the name of the second column and jumps this index. The
-second column is instead renamed to ``a.2``.
+Now the renaming checks if ``a.1`` already exists when changing the name of the
+second column and jumps this index. The second column is instead renamed to
+``a.2``.
*New behavior*:
@@ -358,9 +383,10 @@ second column is instead renamed to ``a.2``.
unstack and pivot_table no longer raises ValueError for result that would exceed int32 limit
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Previously :meth:`DataFrame.pivot_table` and :meth:`DataFrame.unstack` would raise a ``ValueError`` if the operation
-could produce a result with more than ``2**31 - 1`` elements. This operation now raises a :class:`errors.PerformanceWarning`
-instead (:issue:`26314`).
+Previously :meth:`DataFrame.pivot_table` and :meth:`DataFrame.unstack` would
+raise a ``ValueError`` if the operation could produce a result with more than
+``2**31 - 1`` elements. This operation now raises a
+:class:`errors.PerformanceWarning` instead (:issue:`26314`).
*Previous behavior*:
@@ -386,14 +412,13 @@ groupby.apply consistent transform detection
:meth:`.GroupBy.apply` is designed to be flexible, allowing users to perform
aggregations, transformations, filters, and use it with user-defined functions
-that might not fall into any of these categories. As part of this, apply
-will attempt to detect when an operation is a transform, and in such a
-case, the result will have the same index as the input. In order to
-determine if the operation is a transform, pandas compares the
-input's index to the result's and determines if it has been mutated.
-Previously in pandas 1.3, different code paths used different definitions
-of "mutated": some would use Python's ``is`` whereas others would test
-only up to equality.
+that might not fall into any of these categories. As part of this, apply will
+attempt to detect when an operation is a transform, and in such a case, the
+result will have the same index as the input. In order to determine if the
+operation is a transform, pandas compares the input's index to the result's and
+determines if it has been mutated. Previously in pandas 1.3, different code
+paths used different definitions of "mutated": some would use Python's ``is``
+whereas others would test only up to equality.
This inconsistency has been removed, pandas now tests up to equality.
@@ -423,10 +448,10 @@ This inconsistency has been removed, pandas now tests up to equality.
1 3 5
2 4 6
-In the examples above, the first uses a code path where pandas uses
-``is`` and determines that ``func`` is not a transform whereas the second
-tests up to equality and determines that ``func`` is a transform. In the
-first case, the result's index is not the same as the input's.
+In the examples above, the first uses a code path where pandas uses ``is`` and
+determines that ``func`` is not a transform whereas the second tests up to
+equality and determines that ``func`` is a transform. In the first case, the
+result's index is not the same as the input's.
*New behavior*:
@@ -435,8 +460,8 @@ first case, the result's index is not the same as the input's.
df.groupby(['a']).apply(func)
df.set_index(['a', 'b']).groupby(['a']).apply(func)
-Now in both cases it is determined that ``func`` is a transform. In each case, the
-result has the same index as the input.
+Now in both cases it is determined that ``func`` is a transform. In each case,
+the result has the same index as the input.
.. _whatsnew_140.api_breaking:
@@ -475,9 +500,12 @@ If installed, we now require:
| mypy (dev) | 0.930 | | X |
+-----------------+-----------------+----------+---------+
-For `optional libraries <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
-The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
-Optional libraries below the lowest tested version may still work, but are not considered supported.
+For `optional libraries
+<https://pandas.pydata.org/docs/getting_started/install.html>`_ the general
+recommendation is to use the latest version. The following table lists the
+lowest version per library that is currently being tested throughout the
+development of pandas. Optional libraries below the lowest tested version may
+still work, but are not considered supported.
+-----------------+-----------------+---------+
| Package | Minimum Version | Changed |
@@ -559,11 +587,13 @@ Deprecations
Deprecated Int64Index, UInt64Index & Float64Index
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index` have been deprecated
-in favor of the base :class:`Index` class and will be removed in Pandas 2.0 (:issue:`43028`).
+:class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index` have been
+deprecated in favor of the base :class:`Index` class and will be removed in
+Pandas 2.0 (:issue:`43028`).
-For constructing a numeric index, you can use the base :class:`Index` class instead
-specifying the data type (which will also work on older pandas releases):
+For constructing a numeric index, you can use the base :class:`Index` class
+instead specifying the data type (which will also work on older pandas
+releases):
.. code-block:: python
@@ -582,9 +612,10 @@ checks with checking the ``dtype``:
# with
idx.dtype == "int64"
-Currently, in order to maintain backward compatibility, calls to
-:class:`Index` will continue to return :class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index`
-when given numeric data, but in the future, an :class:`Index` will be returned.
+Currently, in order to maintain backward compatibility, calls to :class:`Index`
+will continue to return :class:`Int64Index`, :class:`UInt64Index` and
+:class:`Float64Index` when given numeric data, but in the future, an
+:class:`Index` will be returned.
*Current behavior*:
@@ -610,8 +641,8 @@ when given numeric data, but in the future, an :class:`Index` will be returned.
Deprecated Frame.append and Series.append
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:meth:`DataFrame.append` and :meth:`Series.append` have been deprecated and will be removed in Pandas 2.0.
-Use :func:`pandas.concat` instead (:issue:`35407`).
+:meth:`DataFrame.append` and :meth:`Series.append` have been deprecated and will
+be removed in Pandas 2.0. Use :func:`pandas.concat` instead (:issue:`35407`).
*Deprecated syntax*
@@ -661,11 +692,11 @@ Other Deprecations
- Deprecated the 'kind' argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, :meth:`Index.slice_locs`; in a future version passing 'kind' will raise (:issue:`42857`)
- Deprecated dropping of nuisance columns in :class:`Rolling`, :class:`Expanding`, and :class:`EWM` aggregations (:issue:`42738`)
- Deprecated :meth:`Index.reindex` with a non-unique index (:issue:`42568`)
-- Deprecated :meth:`.Styler.render` in favour of :meth:`.Styler.to_html` (:issue:`42140`)
-- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favour of :meth:`.Styler.hide` (:issue:`43758`)
+- Deprecated :meth:`.Styler.render` in favor of :meth:`.Styler.to_html` (:issue:`42140`)
+- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favor of :meth:`.Styler.hide` (:issue:`43758`)
- Deprecated passing in a string column label into ``times`` in :meth:`DataFrame.ewm` (:issue:`43265`)
- Deprecated the 'include_start' and 'include_end' arguments in :meth:`DataFrame.between_time`; in a future version passing 'include_start' or 'include_end' will raise (:issue:`40245`)
-- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the DataFrame afterwards with ``.squeeze("columns")`` instead. (:issue:`43242`)
+- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the DataFrame afterwards with ``.squeeze("columns")`` instead (:issue:`43242`)
- Deprecated the ``index`` argument to :class:`SparseArray` construction (:issue:`23089`)
- Deprecated the ``closed`` argument in :meth:`date_range` and :meth:`bdate_range` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)
- Deprecated :meth:`.Rolling.validate`, :meth:`.Expanding.validate`, and :meth:`.ExponentialMovingWindow.validate` (:issue:`43665`)
@@ -793,12 +824,12 @@ Datetimelike
Timedelta
^^^^^^^^^
-- Bug in division of all-``NaT`` :class:`TimeDeltaIndex`, :class:`Series` or :class:`DataFrame` column with object-dtype arraylike of numbers failing to infer the result as timedelta64-dtype (:issue:`39750`)
+- Bug in division of all-``NaT`` :class:`TimeDeltaIndex`, :class:`Series` or :class:`DataFrame` column with object-dtype array like of numbers failing to infer the result as timedelta64-dtype (:issue:`39750`)
- Bug in floor division of ``timedelta64[ns]`` data with a scalar returning garbage values (:issue:`44466`)
- Bug in :class:`Timedelta` now properly taking into account any nanoseconds contribution of any kwarg (:issue:`43764`, :issue:`45227`)
-Timezones
-^^^^^^^^^
+Time Zones
+^^^^^^^^^^
- Bug in :func:`to_datetime` with ``infer_datetime_format=True`` failing to parse zero UTC offset (``Z``) correctly (:issue:`41047`)
- Bug in :meth:`Series.dt.tz_convert` resetting index in a :class:`Series` with :class:`CategoricalIndex` (:issue:`43080`)
- Bug in ``Timestamp`` and ``DatetimeIndex`` incorrectly raising a ``TypeError`` when subtracting two timezone-aware objects with mismatched timezones (:issue:`31793`)
@@ -817,7 +848,7 @@ Numeric
Conversion
^^^^^^^^^^
-- Bug in :class:`UInt64Index` constructor when passing a list containing both positive integers small enough to cast to int64 and integers too large too hold in int64 (:issue:`42201`)
+- Bug in :class:`UInt64Index` constructor when passing a list containing both positive integers small enough to cast to int64 and integers too large to hold in int64 (:issue:`42201`)
- Bug in :class:`Series` constructor returning 0 for missing values with dtype ``int64`` and ``False`` for dtype ``bool`` (:issue:`43017`, :issue:`43018`)
- Bug in constructing a :class:`DataFrame` from a :class:`PandasArray` containing :class:`Series` objects behaving differently than an equivalent ``np.ndarray`` (:issue:`43986`)
- Bug in :class:`IntegerDtype` not allowing coercion from string dtype (:issue:`25472`)
@@ -838,7 +869,7 @@ Interval
Indexing
^^^^^^^^
-- Bug in :meth:`Series.rename` when index in Series is MultiIndex and level in rename is provided. (:issue:`43659`)
+- Bug in :meth:`Series.rename` when index in Series is MultiIndex and level in rename is provided (:issue:`43659`)
- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's Index has a length greater than one but only one unique value (:issue:`42365`)
- Bug in :meth:`Series.loc` and :meth:`DataFrame.loc` with a :class:`MultiIndex` when indexing with a tuple in which one of the levels is also a tuple (:issue:`27591`)
- Bug in :meth:`Series.loc` when with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
@@ -849,7 +880,7 @@ Indexing
- Bug in :meth:`Index.get_indexer_non_unique` when index contains multiple ``np.nan`` (:issue:`35392`)
- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a dataframe (:issue:`42826`)
- Bug in :meth:`DataFrame.drop` where the error message did not show missing labels with commas when raising ``KeyError`` (:issue:`42881`)
-- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed. (:issue:`22435`)
+- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed (:issue:`22435`)
- Bug in :meth:`DataFrame.nlargest` and :meth:`Series.nlargest` where sorted result did not count indexes containing ``np.nan`` (:issue:`28984`)
- Bug in indexing on a non-unique object-dtype :class:`Index` with an NA scalar (e.g. ``np.nan``) (:issue:`43711`)
- Bug in :meth:`DataFrame.__setitem__` incorrectly writing into an existing column's array rather than setting a new array when the new dtype and the old dtype match (:issue:`43406`)
@@ -881,7 +912,7 @@ Missing
- Bug in :meth:`DataFrame.fillna` not replacing missing values when using a dict-like ``value`` and duplicate column names (:issue:`43476`)
- Bug in constructing a :class:`DataFrame` with a dictionary ``np.datetime64`` as a value and ``dtype='timedelta64[ns]'``, or vice-versa, incorrectly casting instead of raising (:issue:`44428`)
- Bug in :meth:`Series.interpolate` and :meth:`DataFrame.interpolate` with ``inplace=True`` not writing to the underlying array(s) in-place (:issue:`44749`)
-- Bug in :meth:`Index.fillna` incorrectly returning an un-filled :class:`Index` when NA values are present and ``downcast`` argument is specified. This now raises ``NotImplementedError`` instead; do not pass ``downcast`` argument (:issue:`44873`)
+- Bug in :meth:`Index.fillna` incorrectly returning an unfilled :class:`Index` when NA values are present and ``downcast`` argument is specified. This now raises ``NotImplementedError`` instead; do not pass ``downcast`` argument (:issue:`44873`)
- Bug in :meth:`DataFrame.dropna` changing :class:`Index` even if no entries were dropped (:issue:`41965`)
- Bug in :meth:`Series.fillna` with an object-dtype incorrectly ignoring ``downcast="infer"`` (:issue:`44241`)
@@ -900,7 +931,7 @@ I/O
- Bug in :func:`json_normalize` where ``errors=ignore`` could fail to ignore missing values of ``meta`` when ``record_path`` has a length greater than one (:issue:`41876`)
- Bug in :func:`read_csv` with multi-header input and arguments referencing column names as tuples (:issue:`42446`)
- Bug in :func:`read_fwf`, where difference in lengths of ``colspecs`` and ``names`` was not raising ``ValueError`` (:issue:`40830`)
-- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serialising plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
+- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serializing plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
- Column headers are dropped when constructing a :class:`DataFrame` from a sqlalchemy's ``Row`` object (:issue:`40682`)
- Bug in unpickling a :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raising uncontrolled ``IndexError`` (:issue:`43102`)
@@ -914,7 +945,7 @@ I/O
- Bug in :func:`read_csv` used second row to guess implicit index if ``header`` was set to ``None`` for ``engine="python"`` (:issue:`22144`)
- Bug in :func:`read_csv` not recognizing bad lines when ``names`` were given for ``engine="c"`` (:issue:`22144`)
- Bug in :func:`read_csv` with :code:`float_precision="round_trip"` which did not skip initial/trailing whitespace (:issue:`43713`)
-- Bug when Python is built without lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used. (:issue:`43495`)
+- Bug when Python is built without the lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used (:issue:`43495`)
- Bug in :func:`read_csv` not applying dtype for ``index_col`` (:issue:`9435`)
- Bug in dumping/loading a :class:`DataFrame` with ``yaml.dump(frame)`` (:issue:`42748`)
- Bug in :func:`read_csv` raising ``ValueError`` when names was longer than header but equal to data rows for ``engine="python"`` (:issue:`38453`)
@@ -926,7 +957,7 @@ I/O
- Bug in :func:`read_csv` not replacing ``NaN`` values with ``np.nan`` before attempting date conversion (:issue:`26203`)
- Bug in :func:`read_csv` raising ``AttributeError`` when attempting to read a .csv file and infer index column dtype from an nullable integer type (:issue:`44079`)
- Bug in :func:`to_csv` always coercing datetime columns with different formats to the same format (:issue:`21734`)
-- :meth:`DataFrame.to_csv` and :meth:`Series.to_csv` with ``compression`` set to ``'zip'`` no longer create a zip file containing a file ending with ".zip". Instead, they try to infer the inner file name more smartly. (:issue:`39465`)
+- :meth:`DataFrame.to_csv` and :meth:`Series.to_csv` with ``compression`` set to ``'zip'`` no longer create a zip file containing a file ending with ".zip". Instead, they try to infer the inner file name more smartly (:issue:`39465`)
- Bug in :func:`read_csv` where reading a mixed column of booleans and missing values to a float type results in the missing values becoming 1.0 rather than NaN (:issue:`42808`, :issue:`34120`)
- Bug in :func:`to_xml` raising error for ``pd.NA`` with extension array dtype (:issue:`43903`)
- Bug in :func:`read_csv` when passing simultaneously a parser in ``date_parser`` and ``parse_dates=False``, the parsing was still called (:issue:`44366`)
@@ -935,7 +966,7 @@ I/O
- Bug in :func:`read_csv` when passing a ``tempfile.SpooledTemporaryFile`` opened in binary mode (:issue:`44748`)
- Bug in :func:`read_json` raising ``ValueError`` when attempting to parse json strings containing "://" (:issue:`36271`)
- Bug in :func:`read_csv` when ``engine="c"`` and ``encoding_errors=None`` which caused a segfault (:issue:`45180`)
-- Bug in :func:`read_csv` an invalid value of ``usecols`` leading to an un-closed file handle (:issue:`45384`)
+- Bug in :func:`read_csv` an invalid value of ``usecols`` leading to an unclosed file handle (:issue:`45384`)
Period
^^^^^^
@@ -947,7 +978,7 @@ Period
Plotting
^^^^^^^^
-- When given non-numeric data, :meth:`DataFrame.boxplot` now raises a ``ValueError`` rather than a cryptic ``KeyError`` or ``ZeroDivisionError``, in line with other plotting functions like :meth:`DataFrame.hist`. (:issue:`43480`)
+- When given non-numeric data, :meth:`DataFrame.boxplot` now raises a ``ValueError`` rather than a cryptic ``KeyError`` or ``ZeroDivisionError``, in line with other plotting functions like :meth:`DataFrame.hist` (:issue:`43480`)
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
@@ -981,10 +1012,10 @@ Reshaping
^^^^^^^^^
- Improved error message when creating a :class:`DataFrame` column from a multi-dimensional :class:`numpy.ndarray` (:issue:`42463`)
- :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
-- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices (:issue:`42185`) and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42425`)
+- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42185`, :issue:`42425`)
- Bug in :meth:`DataFrame.append` failing to retain dtypes when appended columns do not match (:issue:`43392`)
- Bug in :func:`concat` of ``bool`` and ``boolean`` dtypes resulting in ``object`` dtype instead of ``boolean`` dtype (:issue:`42800`)
-- Bug in :func:`crosstab` when inputs are are categorical Series, there are categories that are not present in one or both of the Series, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
+- Bug in :func:`crosstab` when inputs are categorical Series, there are categories that are not present in one or both of the Series, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
- Bug in :func:`concat` would fail when the ``objs`` argument all had the same index and the ``keys`` argument contained duplicates (:issue:`43595`)
- Bug in :func:`concat` which ignored the ``sort`` parameter (:issue:`43375`)
- Fixed bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
| Backport PR #45528: DOC: tidy 1.4.0 release notes | https://api.github.com/repos/pandas-dev/pandas/pulls/45533 | 2022-01-21T16:54:43Z | 2022-01-21T18:35:15Z | 2022-01-21T18:35:15Z | 2022-01-21T18:35:16Z |
Fixes #45506 Catch overflow error when converting to datetime | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 919ed926f8195..41b95532f1511 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -247,7 +247,7 @@ Conversion
- Bug in :meth:`Float64Index.astype` to unsigned integer dtype incorrectly casting to ``np.int64`` dtype (:issue:`45309`)
- Bug in :meth:`Series.astype` and :meth:`DataFrame.astype` from floating dtype to unsigned integer dtype failing to raise in the presence of negative values (:issue:`45151`)
- Bug in :func:`array` with ``FloatingDtype`` and values containing float-castable strings incorrectly raising (:issue:`45424`)
--
+- Bug when comparing string and datetime64ns objects causing ``OverflowError`` exception. (:issue:`45506`)
Strings
^^^^^^^
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 9c262fa37d760..8ac1f54059154 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -37,7 +37,10 @@
tzconversion,
)
from pandas._typing import npt
-from pandas.errors import PerformanceWarning
+from pandas.errors import (
+ OutOfBoundsDatetime,
+ PerformanceWarning,
+)
from pandas.util._exceptions import find_stack_level
from pandas.util._validators import validate_inclusive
@@ -2215,6 +2218,9 @@ def objects_to_datetime64ns(
return values.view("i8"), tz_parsed
except (ValueError, TypeError):
raise err
+ except OverflowError as err:
+ # Exception is raised when a part of date is greater than 32 bit signed int
+ raise OutOfBoundsDatetime("Out of bounds nanosecond timestamp") from err
if tz_parsed is not None:
# We can take a shortcut since the datetime64 numpy array
diff --git a/pandas/tests/series/methods/test_compare.py b/pandas/tests/series/methods/test_compare.py
index 8570800048898..fe2016a245ec7 100644
--- a/pandas/tests/series/methods/test_compare.py
+++ b/pandas/tests/series/methods/test_compare.py
@@ -114,3 +114,28 @@ def test_compare_unaligned_objects():
ser1 = pd.Series([1, 2, 3])
ser2 = pd.Series([1, 2, 3, 4])
ser1.compare(ser2)
+
+
+def test_compare_datetime64_and_string():
+ # Issue https://github.com/pandas-dev/pandas/issues/45506
+ # Catch OverflowError when comparing datetime64 and string
+ data = [
+ {"a": "2015-07-01", "b": "08335394550"},
+ {"a": "2015-07-02", "b": "+49 (0) 0345 300033"},
+ {"a": "2015-07-03", "b": "+49(0)2598 04457"},
+ {"a": "2015-07-04", "b": "0741470003"},
+ {"a": "2015-07-05", "b": "04181 83668"},
+ ]
+ dtypes = {"a": "datetime64[ns]", "b": "string"}
+ df = pd.DataFrame(data=data).astype(dtypes)
+
+ result_eq1 = df["a"].eq(df["b"])
+ result_eq2 = df["a"] == df["b"]
+ result_neq = df["a"] != df["b"]
+
+ expected_eq = pd.Series([False] * 5) # For .eq and ==
+ expected_neq = pd.Series([True] * 5) # For !=
+
+ tm.assert_series_equal(result_eq1, expected_eq)
+ tm.assert_series_equal(result_eq2, expected_eq)
+ tm.assert_series_equal(result_neq, expected_neq)
| Exception is raised when date part (like day, month, year) is greater than 32 bit signed integer
- [x] xref #45506
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/45532 | 2022-01-21T16:22:44Z | 2022-01-31T16:31:36Z | 2022-01-31T16:31:36Z | 2022-02-08T16:40:01Z |
Update development docs recommended pyenv version to a supported version | diff --git a/doc/source/development/contributing_environment.rst b/doc/source/development/contributing_environment.rst
index 5f36a2a609c9f..b28f7c833d7ad 100644
--- a/doc/source/development/contributing_environment.rst
+++ b/doc/source/development/contributing_environment.rst
@@ -222,7 +222,7 @@ Consult the docs for setting up pyenv `here <https://github.com/pyenv/pyenv>`__.
pyenv virtualenv <version> <name-to-give-it>
# For instance:
- pyenv virtualenv 3.7.6 pandas-dev
+ pyenv virtualenv 3.9.10 pandas-dev
# Activate the virtualenv
pyenv activate pandas-dev
| **Only doc change**
- [ ] closes #xxxx
- [ ] tests added / passed
- [ ] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [ ] whatsnew entry
As far as i understand - python development should be done on python 3.8 or 3.9
| https://api.github.com/repos/pandas-dev/pandas/pulls/45531 | 2022-01-21T15:16:05Z | 2022-01-21T21:48:21Z | 2022-01-21T21:48:21Z | 2022-01-21T21:48:29Z |
Backport PR #45522 on branch 1.4.x (REGR: read_fwf interpreting infer as list of colspecs when checking names length) | diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index 6d60f94e89291..ef693fcbd3720 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -856,7 +856,7 @@ def read_fwf(
# Ensure length of `colspecs` matches length of `names`
names = kwds.get("names")
if names is not None:
- if len(names) != len(colspecs):
+ if len(names) != len(colspecs) and colspecs != "infer":
# need to check len(index_col) as it might contain
# unnamed indices, in which case it's name is not required
len_index = 0
diff --git a/pandas/tests/io/parser/test_read_fwf.py b/pandas/tests/io/parser/test_read_fwf.py
index 63f783b01d1f3..3de73e51ce6b6 100644
--- a/pandas/tests/io/parser/test_read_fwf.py
+++ b/pandas/tests/io/parser/test_read_fwf.py
@@ -920,3 +920,13 @@ def test_skiprows_passing_as_positional_deprecated():
result = read_fwf(StringIO(data), [(0, 2)])
expected = DataFrame({"0": [1, 2]})
tm.assert_frame_equal(result, expected)
+
+
+def test_names_and_infer_colspecs():
+ # GH#45337
+ data = """X Y Z
+ 959.0 345 22.2
+ """
+ result = read_fwf(StringIO(data), skiprows=1, usecols=[0, 2], names=["a", "b"])
+ expected = DataFrame({"a": [959.0], "b": 22.2})
+ tm.assert_frame_equal(result, expected)
| Backport PR #45522: REGR: read_fwf interpreting infer as list of colspecs when checking names length | https://api.github.com/repos/pandas-dev/pandas/pulls/45530 | 2022-01-21T14:02:44Z | 2022-01-21T16:54:02Z | 2022-01-21T16:54:02Z | 2022-01-21T16:54:02Z |
Backport PR #45523 on branch 1.4.x (DEPR: restore to_frame() name=None behaviour but deprecate it) | diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 1ca4e8cc97df0..234fada5e2ba3 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -696,6 +696,7 @@ Other Deprecations
- Deprecated the behavior of :meth:`Timestamp.utcfromtimestamp`, in the future it will return a timezone-aware UTC :class:`Timestamp` (:issue:`22451`)
- Deprecated :meth:`NaT.freq` (:issue:`45071`)
- Deprecated behavior of :class:`Series` and :class:`DataFrame` construction when passed float-dtype data containing ``NaN`` and an integer dtype ignoring the dtype argument; in a future version this will raise (:issue:`40110`)
+- Deprecated the behaviour of :meth:`Series.to_frame` and :meth:`Index.to_frame` to ignore the ``name`` argument when ``name=None``. Currently, this means to preserve the existing name, but in the future explicitly passing ``name=None`` will set ``None`` as the name of the column in the resulting DataFrame (:issue:`44212`)
.. ---------------------------------------------------------------------------
@@ -1041,7 +1042,6 @@ Other
- Bug in :meth:`CustomBusinessMonthBegin.__add__` (:meth:`CustomBusinessMonthEnd.__add__`) not applying the extra ``offset`` parameter when beginning (end) of the target month is already a business day (:issue:`41356`)
- Bug in :meth:`RangeIndex.union` with another ``RangeIndex`` with matching (even) ``step`` and starts differing by strictly less than ``step / 2`` (:issue:`44019`)
- Bug in :meth:`RangeIndex.difference` with ``sort=None`` and ``step<0`` failing to sort (:issue:`44085`)
-- Bug in :meth:`Series.to_frame` and :meth:`Index.to_frame` ignoring the ``name`` argument when ``name=None`` is explicitly passed (:issue:`44212`)
- Bug in :meth:`Series.replace` and :meth:`DataFrame.replace` with ``value=None`` and ExtensionDtypes (:issue:`44270`, :issue:`37899`)
- Bug in :meth:`FloatingArray.equals` failing to consider two arrays equal if they contain ``np.nan`` values (:issue:`44382`)
- Bug in :meth:`DataFrame.shift` with ``axis=1`` and ``ExtensionDtype`` columns incorrectly raising when an incompatible ``fill_value`` is passed (:issue:`44564`)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index af295384690e9..480ec29c418b8 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1625,6 +1625,17 @@ def to_frame(
"""
from pandas import DataFrame
+ if name is None:
+ warnings.warn(
+ "Explicitly passing `name=None` currently preserves the Index's name "
+ "or uses a default name of 0. This behaviour is deprecated, and in "
+ "the future `None` will be used as the name of the resulting "
+ "DataFrame column.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ name = lib.no_default
+
if name is lib.no_default:
name = self.name or 0
result = DataFrame({name: self._values.copy()})
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 676fa4962cd56..7e59e51174b6f 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1762,6 +1762,17 @@ def to_frame(self, index: bool = True, name=lib.no_default) -> DataFrame:
"""
from pandas import DataFrame
+ if name is None:
+ warnings.warn(
+ "Explicitly passing `name=None` currently preserves the Index's name "
+ "or uses a default name of 0. This behaviour is deprecated, and in "
+ "the future `None` will be used as the name of the resulting "
+ "DataFrame column.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ name = lib.no_default
+
if name is not lib.no_default:
if not is_list_like(name):
raise TypeError("'name' must be a list / sequence of column names.")
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 8c387f60a1a3c..765d4ab86dd6e 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1752,7 +1752,7 @@ def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:
Parameters
----------
- name : object, default None
+ name : object, optional
The passed name should substitute for the series name (if it has
one).
@@ -1771,6 +1771,17 @@ def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:
1 b
2 c
"""
+ if name is None:
+ warnings.warn(
+ "Explicitly passing `name=None` currently preserves the Series' name "
+ "or uses a default name of 0. This behaviour is deprecated, and in "
+ "the future `None` will be used as the name of the resulting "
+ "DataFrame column.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ name = lib.no_default
+
columns: Index
if name is lib.no_default:
name = self.name
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_frame.py b/pandas/tests/indexes/datetimes/methods/test_to_frame.py
index 80e8284abe031..fa5cca1c3e78b 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_frame.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_frame.py
@@ -17,10 +17,15 @@ def test_to_frame_datetime_tz(self):
def test_to_frame_respects_none_name(self):
# GH#44212 if we explicitly pass name=None, then that should be respected,
# not changed to 0
+ # GH-45448 this is first deprecated to only change in the future
idx = date_range(start="2019-01-01", end="2019-01-30", freq="D", tz="UTC")
- result = idx.to_frame(name=None)
- exp_idx = Index([None], dtype=object)
+ with tm.assert_produces_warning(FutureWarning):
+ result = idx.to_frame(name=None)
+ # exp_idx = Index([None], dtype=object)
+ exp_idx = Index([0])
tm.assert_index_equal(exp_idx, result.columns)
- result = idx.rename("foo").to_frame(name=None)
+ with tm.assert_produces_warning(FutureWarning):
+ result = idx.rename("foo").to_frame(name=None)
+ exp_idx = Index(["foo"], dtype=object)
tm.assert_index_equal(exp_idx, result.columns)
diff --git a/pandas/tests/series/methods/test_to_frame.py b/pandas/tests/series/methods/test_to_frame.py
index 55d49b8fbee70..5f303d09dcc33 100644
--- a/pandas/tests/series/methods/test_to_frame.py
+++ b/pandas/tests/series/methods/test_to_frame.py
@@ -10,13 +10,18 @@ class TestToFrame:
def test_to_frame_respects_name_none(self):
# GH#44212 if we explicitly pass name=None, then that should be respected,
# not changed to 0
+ # GH-45448 this is first deprecated to only change in the future
ser = Series(range(3))
- result = ser.to_frame(None)
+ with tm.assert_produces_warning(FutureWarning):
+ result = ser.to_frame(None)
- exp_index = Index([None], dtype=object)
+ # exp_index = Index([None], dtype=object)
+ exp_index = Index([0])
tm.assert_index_equal(result.columns, exp_index)
- result = ser.rename("foo").to_frame(None)
+ with tm.assert_produces_warning(FutureWarning):
+ result = ser.rename("foo").to_frame(None)
+ exp_index = Index(["foo"], dtype=object)
tm.assert_index_equal(result.columns, exp_index)
def test_to_frame(self, datetime_series):
| Backport PR #45523: DEPR: restore to_frame() name=None behaviour but deprecate it | https://api.github.com/repos/pandas-dev/pandas/pulls/45529 | 2022-01-21T14:01:45Z | 2022-01-21T16:53:49Z | 2022-01-21T16:53:49Z | 2022-01-21T16:53:50Z |
DOC: tidy 1.4.0 release notes | diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 1ca4e8cc97df0..a27d9d6c67c98 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -1,6 +1,6 @@
.. _whatsnew_140:
-What's new in 1.4.0 (January ??, 2022)
+What's new in 1.4.0 (January 22, 2022)
--------------------------------------
These are the changes in pandas 1.4.0. See :ref:`release` for a full changelog
@@ -20,7 +20,8 @@ Enhancements
Improved warning messages
^^^^^^^^^^^^^^^^^^^^^^^^^
-Previously, warning messages may have pointed to lines within the pandas library. Running the script ``setting_with_copy_warning.py``
+Previously, warning messages may have pointed to lines within the pandas
+library. Running the script ``setting_with_copy_warning.py``
.. code-block:: python
@@ -34,7 +35,10 @@ with pandas 1.3 resulted in::
.../site-packages/pandas/core/indexing.py:1951: SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
-This made it difficult to determine where the warning was being generated from. Now pandas will inspect the call stack, reporting the first line outside of the pandas library that gave rise to the warning. The output of the above script is now::
+This made it difficult to determine where the warning was being generated from.
+Now pandas will inspect the call stack, reporting the first line outside of the
+pandas library that gave rise to the warning. The output of the above script is
+now::
setting_with_copy_warning.py:4: SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
@@ -47,8 +51,9 @@ This made it difficult to determine where the warning was being generated from.
Index can hold arbitrary ExtensionArrays
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Until now, passing a custom :class:`ExtensionArray` to ``pd.Index`` would cast the
-array to ``object`` dtype. Now :class:`Index` can directly hold arbitrary ExtensionArrays (:issue:`43930`).
+Until now, passing a custom :class:`ExtensionArray` to ``pd.Index`` would cast
+the array to ``object`` dtype. Now :class:`Index` can directly hold arbitrary
+ExtensionArrays (:issue:`43930`).
*Previous behavior*:
@@ -89,38 +94,43 @@ Styler
- The new method :meth:`.Styler.hide` deprecates :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` (:issue:`43758`)
- The keyword arguments ``level`` and ``names`` have been added to :meth:`.Styler.hide` (and implicitly to the deprecated methods :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns`) for additional control of visibility of MultiIndexes and of index names (:issue:`25475`, :issue:`43404`, :issue:`43346`)
- The :meth:`.Styler.export` and :meth:`.Styler.use` have been updated to address all of the added functionality from v1.2.0 and v1.3.0 (:issue:`40675`)
- - Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax``. (:issue:`41395`)
+ - Global options under the category ``pd.options.styler`` have been extended to configure default ``Styler`` properties which address formatting, encoding, and HTML and LaTeX rendering. Note that formerly ``Styler`` relied on ``display.html.use_mathjax``, which has now been replaced by ``styler.html.mathjax`` (:issue:`41395`)
- Validation of certain keyword arguments, e.g. ``caption`` (:issue:`43368`)
- Various bug fixes as recorded below
Additionally there are specific enhancements to the HTML specific rendering:
- - :meth:`.Styler.bar` introduces additional arguments to control alignment and display (:issue:`26070`, :issue:`36419`), and it also validates the input arguments ``width`` and ``height`` (:issue:`42511`).
- - :meth:`.Styler.to_html` introduces keyword arguments ``sparse_index``, ``sparse_columns``, ``bold_headers``, ``caption``, ``max_rows`` and ``max_columns`` (:issue:`41946`, :issue:`43149`, :issue:`42972`).
+ - :meth:`.Styler.bar` introduces additional arguments to control alignment and display (:issue:`26070`, :issue:`36419`), and it also validates the input arguments ``width`` and ``height`` (:issue:`42511`)
+ - :meth:`.Styler.to_html` introduces keyword arguments ``sparse_index``, ``sparse_columns``, ``bold_headers``, ``caption``, ``max_rows`` and ``max_columns`` (:issue:`41946`, :issue:`43149`, :issue:`42972`)
- :meth:`.Styler.to_html` omits CSSStyle rules for hidden table elements as a performance enhancement (:issue:`43619`)
- Custom CSS classes can now be directly specified without string replacement (:issue:`43686`)
- Ability to render hyperlinks automatically via a new ``hyperlinks`` formatting keyword argument (:issue:`45058`)
There are also some LaTeX specific enhancements:
- - :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`).
+ - :meth:`.Styler.to_latex` introduces keyword argument ``environment``, which also allows a specific "longtable" entry through a separate jinja2 template (:issue:`41866`)
- Naive sparsification is now possible for LaTeX without the necessity of including the multirow package (:issue:`43369`)
- *cline* support has been added for MultiIndex row sparsification through a keyword argument (:issue:`45138`)
.. _whatsnew_140.enhancements.pyarrow_csv_engine:
-Multithreaded CSV reading with a new CSV Engine based on pyarrow
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multi-threaded CSV reading with a new CSV Engine based on pyarrow
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:func:`pandas.read_csv` now accepts ``engine="pyarrow"`` (requires at least ``pyarrow`` 1.0.1) as an argument, allowing for faster csv parsing on multicore machines
-with pyarrow installed. See the :doc:`I/O docs </user_guide/io>` for more info. (:issue:`23697`, :issue:`43706`)
+:func:`pandas.read_csv` now accepts ``engine="pyarrow"`` (requires at least
+``pyarrow`` 1.0.1) as an argument, allowing for faster csv parsing on multicore
+machines with pyarrow installed. See the :doc:`I/O docs </user_guide/io>` for
+more info. (:issue:`23697`, :issue:`43706`)
.. _whatsnew_140.enhancements.window_rank:
Rank function for rolling and expanding windows
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Added ``rank`` function to :class:`Rolling` and :class:`Expanding`. The new function supports the ``method``, ``ascending``, and ``pct`` flags of :meth:`DataFrame.rank`. The ``method`` argument supports ``min``, ``max``, and ``average`` ranking methods.
+Added ``rank`` function to :class:`Rolling` and :class:`Expanding`. The new
+function supports the ``method``, ``ascending``, and ``pct`` flags of
+:meth:`DataFrame.rank`. The ``method`` argument supports ``min``, ``max``, and
+``average`` ranking methods.
Example:
.. ipython:: python
@@ -135,10 +145,12 @@ Example:
Groupby positional indexing
^^^^^^^^^^^^^^^^^^^^^^^^^^^
-It is now possible to specify positional ranges relative to the ends of each group.
+It is now possible to specify positional ranges relative to the ends of each
+group.
-Negative arguments for :meth:`.GroupBy.head` and :meth:`.GroupBy.tail` now work correctly and result in ranges relative to the end and start of each group, respectively.
-Previously, negative arguments returned empty frames.
+Negative arguments for :meth:`.GroupBy.head` and :meth:`.GroupBy.tail` now work
+correctly and result in ranges relative to the end and start of each group,
+respectively. Previously, negative arguments returned empty frames.
.. ipython:: python
@@ -167,10 +179,11 @@ Previously, negative arguments returned empty frames.
DataFrame.from_dict and DataFrame.to_dict have new ``'tight'`` option
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-A new ``'tight'`` dictionary format that preserves :class:`MultiIndex` entries and names
-is now available with the :meth:`DataFrame.from_dict` and :meth:`DataFrame.to_dict` methods
-and can be used with the standard ``json`` library to produce a tight
-representation of :class:`DataFrame` objects (:issue:`4889`).
+A new ``'tight'`` dictionary format that preserves :class:`MultiIndex` entries
+and names is now available with the :meth:`DataFrame.from_dict` and
+:meth:`DataFrame.to_dict` methods and can be used with the standard ``json``
+library to produce a tight representation of :class:`DataFrame` objects
+(:issue:`4889`).
.. ipython:: python
@@ -188,21 +201,21 @@ representation of :class:`DataFrame` objects (:issue:`4889`).
Other enhancements
^^^^^^^^^^^^^^^^^^
-- :meth:`concat` will preserve the ``attrs`` when it is the same for all objects and discard the ``attrs`` when they are different. (:issue:`41828`)
+- :meth:`concat` will preserve the ``attrs`` when it is the same for all objects and discard the ``attrs`` when they are different (:issue:`41828`)
- :class:`DataFrameGroupBy` operations with ``as_index=False`` now correctly retain ``ExtensionDtype`` dtypes for columns being grouped on (:issue:`41373`)
- Add support for assigning values to ``by`` argument in :meth:`DataFrame.plot.hist` and :meth:`DataFrame.plot.box` (:issue:`15079`)
- :meth:`Series.sample`, :meth:`DataFrame.sample`, and :meth:`.GroupBy.sample` now accept a ``np.random.Generator`` as input to ``random_state``. A generator will be more performant, especially with ``replace=False`` (:issue:`38100`)
-- :meth:`Series.ewm`, :meth:`DataFrame.ewm`, now support a ``method`` argument with a ``'table'`` option that performs the windowing operation over an entire :class:`DataFrame`. See :ref:`Window Overview <window.overview>` for performance and functional benefits (:issue:`42273`)
+- :meth:`Series.ewm` and :meth:`DataFrame.ewm` now support a ``method`` argument with a ``'table'`` option that performs the windowing operation over an entire :class:`DataFrame`. See :ref:`Window Overview <window.overview>` for performance and functional benefits (:issue:`42273`)
- :meth:`.GroupBy.cummin` and :meth:`.GroupBy.cummax` now support the argument ``skipna`` (:issue:`34047`)
- :meth:`read_table` now supports the argument ``storage_options`` (:issue:`39167`)
-- :meth:`DataFrame.to_stata` and :meth:`StataWriter` now accept the keyword only argument ``value_labels`` to save labels for non-categorical columns
+- :meth:`DataFrame.to_stata` and :meth:`StataWriter` now accept the keyword only argument ``value_labels`` to save labels for non-categorical columns (:issue:`38454`)
- Methods that relied on hashmap based algos such as :meth:`DataFrameGroupBy.value_counts`, :meth:`DataFrameGroupBy.count` and :func:`factorize` ignored imaginary component for complex numbers (:issue:`17927`)
- Add :meth:`Series.str.removeprefix` and :meth:`Series.str.removesuffix` introduced in Python 3.9 to remove pre-/suffixes from string-type :class:`Series` (:issue:`36944`)
- Attempting to write into a file in missing parent directory with :meth:`DataFrame.to_csv`, :meth:`DataFrame.to_html`, :meth:`DataFrame.to_excel`, :meth:`DataFrame.to_feather`, :meth:`DataFrame.to_parquet`, :meth:`DataFrame.to_stata`, :meth:`DataFrame.to_json`, :meth:`DataFrame.to_pickle`, and :meth:`DataFrame.to_xml` now explicitly mentions missing parent directory, the same is true for :class:`Series` counterparts (:issue:`24306`)
- Indexing with ``.loc`` and ``.iloc`` now supports ``Ellipsis`` (:issue:`37750`)
- :meth:`IntegerArray.all` , :meth:`IntegerArray.any`, :meth:`FloatingArray.any`, and :meth:`FloatingArray.all` use Kleene logic (:issue:`41967`)
- Added support for nullable boolean and integer types in :meth:`DataFrame.to_stata`, :class:`~pandas.io.stata.StataWriter`, :class:`~pandas.io.stata.StataWriter117`, and :class:`~pandas.io.stata.StataWriterUTF8` (:issue:`40855`)
-- :meth:`DataFrame.__pos__`, :meth:`DataFrame.__neg__` now retain ``ExtensionDtype`` dtypes (:issue:`43883`)
+- :meth:`DataFrame.__pos__` and :meth:`DataFrame.__neg__` now retain ``ExtensionDtype`` dtypes (:issue:`43883`)
- The error raised when an optional dependency can't be imported now includes the original exception, for easier investigation (:issue:`43882`)
- Added :meth:`.ExponentialMovingWindow.sum` (:issue:`13297`)
- :meth:`Series.str.split` now supports a ``regex`` argument that explicitly specifies whether the pattern is a regular expression. Default is ``None`` (:issue:`43563`, :issue:`32835`, :issue:`25549`)
@@ -211,19 +224,19 @@ Other enhancements
- :func:`read_csv` now accepts a ``callable`` function in ``on_bad_lines`` when ``engine="python"`` for custom handling of bad lines (:issue:`5686`)
- :class:`ExcelWriter` argument ``if_sheet_exists="overlay"`` option added (:issue:`40231`)
- :meth:`read_excel` now accepts a ``decimal`` argument that allow the user to specify the decimal point when parsing string columns to numeric (:issue:`14403`)
-- :meth:`.GroupBy.mean`, :meth:`.GroupBy.std`, :meth:`.GroupBy.var`, :meth:`.GroupBy.sum` now supports `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`43731`, :issue:`44862`, :issue:`44939`)
-- :meth:`Timestamp.isoformat`, now handles the ``timespec`` argument from the base :class:``datetime`` class (:issue:`26131`)
+- :meth:`.GroupBy.mean`, :meth:`.GroupBy.std`, :meth:`.GroupBy.var`, and :meth:`.GroupBy.sum` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`43731`, :issue:`44862`, :issue:`44939`)
+- :meth:`Timestamp.isoformat` now handles the ``timespec`` argument from the base ``datetime`` class (:issue:`26131`)
- :meth:`NaT.to_numpy` ``dtype`` argument is now respected, so ``np.timedelta64`` can be returned (:issue:`44460`)
- New option ``display.max_dir_items`` customizes the number of columns added to :meth:`Dataframe.__dir__` and suggested for tab completion (:issue:`37996`)
-- Added "Juneteenth National Independence Day" to ``USFederalHolidayCalendar``. See also `Other API changes`_.
-- :meth:`.Rolling.var`, :meth:`.Expanding.var`, :meth:`.Rolling.std`, :meth:`.Expanding.std` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`44461`)
+- Added "Juneteenth National Independence Day" to ``USFederalHolidayCalendar`` (:issue:`44574`)
+- :meth:`.Rolling.var`, :meth:`.Expanding.var`, :meth:`.Rolling.std`, and :meth:`.Expanding.std` now support `Numba <http://numba.pydata.org/>`_ execution with the ``engine`` keyword (:issue:`44461`)
- :meth:`Series.info` has been added, for compatibility with :meth:`DataFrame.info` (:issue:`5167`)
-- Implemented :meth:`IntervalArray.min`, :meth:`IntervalArray.max`, as a result of which ``min`` and ``max`` now work for :class:`IntervalIndex`, :class:`Series` and :class:`DataFrame` with ``IntervalDtype`` (:issue:`44746`)
+- Implemented :meth:`IntervalArray.min` and :meth:`IntervalArray.max`, as a result of which ``min`` and ``max`` now work for :class:`IntervalIndex`, :class:`Series` and :class:`DataFrame` with ``IntervalDtype`` (:issue:`44746`)
- :meth:`UInt64Index.map` now retains ``dtype`` where possible (:issue:`44609`)
- :meth:`read_json` can now parse unsigned long long integers (:issue:`26068`)
- :meth:`DataFrame.take` now raises a ``TypeError`` when passed a scalar for the indexer (:issue:`42875`)
- :meth:`is_list_like` now identifies duck-arrays as list-like unless ``.ndim == 0`` (:issue:`35131`)
-- :class:`ExtensionDtype` and :class:`ExtensionArray` are now (de)serialized when exporting a :class:`DataFrame` with :meth:`DataFrame.to_json` using ``orient='table'`` (:issue:`20612`, :issue:`44705`).
+- :class:`ExtensionDtype` and :class:`ExtensionArray` are now (de)serialized when exporting a :class:`DataFrame` with :meth:`DataFrame.to_json` using ``orient='table'`` (:issue:`20612`, :issue:`44705`)
- Add support for `Zstandard <http://facebook.github.io/zstd/>`_ compression to :meth:`DataFrame.to_pickle`/:meth:`read_pickle` and friends (:issue:`43925`)
- :meth:`DataFrame.to_sql` now returns an ``int`` of the number of written rows (:issue:`23998`)
@@ -241,15 +254,17 @@ These are bug fixes that might have notable behavior changes.
Inconsistent date string parsing
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-The ``dayfirst`` option of :func:`to_datetime` isn't strict, and this can lead to surprising behaviour:
+The ``dayfirst`` option of :func:`to_datetime` isn't strict, and this can lead
+to surprising behavior:
.. ipython:: python
:okwarning:
pd.to_datetime(["31-12-2021"], dayfirst=False)
-Now, a warning will be raised if a date string cannot be parsed accordance to the given ``dayfirst`` value when
-the value is a delimited date string (e.g. ``31-12-2012``).
+Now, a warning will be raised if a date string cannot be parsed accordance to
+the given ``dayfirst`` value when the value is a delimited date string (e.g.
+``31-12-2012``).
.. _whatsnew_140.notable_bug_fixes.concat_with_empty_or_all_na:
@@ -257,8 +272,9 @@ Ignoring dtypes in concat with empty or all-NA columns
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
When using :func:`concat` to concatenate two or more :class:`DataFrame` objects,
-if one of the DataFrames was empty or had all-NA values, its dtype was *sometimes*
-ignored when finding the concatenated dtype. These are now consistently *not* ignored (:issue:`43507`).
+if one of the DataFrames was empty or had all-NA values, its dtype was
+*sometimes* ignored when finding the concatenated dtype. These are now
+consistently *not* ignored (:issue:`43507`).
.. ipython:: python
@@ -266,7 +282,9 @@ ignored when finding the concatenated dtype. These are now consistently *not* i
df2 = pd.DataFrame({"bar": np.nan}, index=range(1, 2))
res = pd.concat([df1, df2])
-Previously, the float-dtype in ``df2`` would be ignored so the result dtype would be ``datetime64[ns]``. As a result, the ``np.nan`` would be cast to ``NaT``.
+Previously, the float-dtype in ``df2`` would be ignored so the result dtype
+would be ``datetime64[ns]``. As a result, the ``np.nan`` would be cast to
+``NaT``.
*Previous behavior*:
@@ -278,7 +296,8 @@ Previously, the float-dtype in ``df2`` would be ignored so the result dtype woul
0 2013-01-01
1 NaT
-Now the float-dtype is respected. Since the common dtype for these DataFrames is object, the ``np.nan`` is retained.
+Now the float-dtype is respected. Since the common dtype for these DataFrames is
+object, the ``np.nan`` is retained.
*New behavior*:
@@ -291,7 +310,10 @@ Now the float-dtype is respected. Since the common dtype for these DataFrames is
Null-values are no longer coerced to NaN-value in value_counts and mode
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:meth:`Series.value_counts` and :meth:`Series.mode` no longer coerce ``None``, ``NaT`` and other null-values to a NaN-value for ``np.object``-dtype. This behavior is now consistent with ``unique``, ``isin`` and others (:issue:`42688`).
+:meth:`Series.value_counts` and :meth:`Series.mode` no longer coerce ``None``,
+``NaT`` and other null-values to a NaN-value for ``np.object``-dtype. This
+behavior is now consistent with ``unique``, ``isin`` and others
+(:issue:`42688`).
.. ipython:: python
@@ -323,8 +345,9 @@ Now null-values are no longer mangled.
mangle_dupe_cols in read_csv no longer renaming unique columns conflicting with target names
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:func:`read_csv` no longer renaming unique cols, which conflict with the target names of duplicated columns.
-Already existing columns are jumped, e.g. the next available index is used for the target column name (:issue:`14704`).
+:func:`read_csv` no longer renaming unique cols, which conflict with the target
+names of duplicated columns. Already existing columns are jumped, e.g. the next
+available index is used for the target column name (:issue:`14704`).
.. ipython:: python
@@ -333,7 +356,8 @@ Already existing columns are jumped, e.g. the next available index is used for t
data = "a,a,a.1\n1,2,3"
res = pd.read_csv(io.StringIO(data))
-Previously, the second column was called ``a.1``, while the third col was also renamed to ``a.1.1``.
+Previously, the second column was called ``a.1``, while the third column was
+also renamed to ``a.1.1``.
*Previous behavior*:
@@ -344,8 +368,9 @@ Previously, the second column was called ``a.1``, while the third col was also r
a a.1 a.1.1
0 1 2 3
-Now the renaming checks if ``a.1`` already exists when changing the name of the second column and jumps this index. The
-second column is instead renamed to ``a.2``.
+Now the renaming checks if ``a.1`` already exists when changing the name of the
+second column and jumps this index. The second column is instead renamed to
+``a.2``.
*New behavior*:
@@ -358,9 +383,10 @@ second column is instead renamed to ``a.2``.
unstack and pivot_table no longer raises ValueError for result that would exceed int32 limit
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Previously :meth:`DataFrame.pivot_table` and :meth:`DataFrame.unstack` would raise a ``ValueError`` if the operation
-could produce a result with more than ``2**31 - 1`` elements. This operation now raises a :class:`errors.PerformanceWarning`
-instead (:issue:`26314`).
+Previously :meth:`DataFrame.pivot_table` and :meth:`DataFrame.unstack` would
+raise a ``ValueError`` if the operation could produce a result with more than
+``2**31 - 1`` elements. This operation now raises a
+:class:`errors.PerformanceWarning` instead (:issue:`26314`).
*Previous behavior*:
@@ -386,14 +412,13 @@ groupby.apply consistent transform detection
:meth:`.GroupBy.apply` is designed to be flexible, allowing users to perform
aggregations, transformations, filters, and use it with user-defined functions
-that might not fall into any of these categories. As part of this, apply
-will attempt to detect when an operation is a transform, and in such a
-case, the result will have the same index as the input. In order to
-determine if the operation is a transform, pandas compares the
-input's index to the result's and determines if it has been mutated.
-Previously in pandas 1.3, different code paths used different definitions
-of "mutated": some would use Python's ``is`` whereas others would test
-only up to equality.
+that might not fall into any of these categories. As part of this, apply will
+attempt to detect when an operation is a transform, and in such a case, the
+result will have the same index as the input. In order to determine if the
+operation is a transform, pandas compares the input's index to the result's and
+determines if it has been mutated. Previously in pandas 1.3, different code
+paths used different definitions of "mutated": some would use Python's ``is``
+whereas others would test only up to equality.
This inconsistency has been removed, pandas now tests up to equality.
@@ -423,10 +448,10 @@ This inconsistency has been removed, pandas now tests up to equality.
1 3 5
2 4 6
-In the examples above, the first uses a code path where pandas uses
-``is`` and determines that ``func`` is not a transform whereas the second
-tests up to equality and determines that ``func`` is a transform. In the
-first case, the result's index is not the same as the input's.
+In the examples above, the first uses a code path where pandas uses ``is`` and
+determines that ``func`` is not a transform whereas the second tests up to
+equality and determines that ``func`` is a transform. In the first case, the
+result's index is not the same as the input's.
*New behavior*:
@@ -435,8 +460,8 @@ first case, the result's index is not the same as the input's.
df.groupby(['a']).apply(func)
df.set_index(['a', 'b']).groupby(['a']).apply(func)
-Now in both cases it is determined that ``func`` is a transform. In each case, the
-result has the same index as the input.
+Now in both cases it is determined that ``func`` is a transform. In each case,
+the result has the same index as the input.
.. _whatsnew_140.api_breaking:
@@ -475,9 +500,12 @@ If installed, we now require:
| mypy (dev) | 0.930 | | X |
+-----------------+-----------------+----------+---------+
-For `optional libraries <https://pandas.pydata.org/docs/getting_started/install.html>`_ the general recommendation is to use the latest version.
-The following table lists the lowest version per library that is currently being tested throughout the development of pandas.
-Optional libraries below the lowest tested version may still work, but are not considered supported.
+For `optional libraries
+<https://pandas.pydata.org/docs/getting_started/install.html>`_ the general
+recommendation is to use the latest version. The following table lists the
+lowest version per library that is currently being tested throughout the
+development of pandas. Optional libraries below the lowest tested version may
+still work, but are not considered supported.
+-----------------+-----------------+---------+
| Package | Minimum Version | Changed |
@@ -559,11 +587,13 @@ Deprecations
Deprecated Int64Index, UInt64Index & Float64Index
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index` have been deprecated
-in favor of the base :class:`Index` class and will be removed in Pandas 2.0 (:issue:`43028`).
+:class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index` have been
+deprecated in favor of the base :class:`Index` class and will be removed in
+Pandas 2.0 (:issue:`43028`).
-For constructing a numeric index, you can use the base :class:`Index` class instead
-specifying the data type (which will also work on older pandas releases):
+For constructing a numeric index, you can use the base :class:`Index` class
+instead specifying the data type (which will also work on older pandas
+releases):
.. code-block:: python
@@ -582,9 +612,10 @@ checks with checking the ``dtype``:
# with
idx.dtype == "int64"
-Currently, in order to maintain backward compatibility, calls to
-:class:`Index` will continue to return :class:`Int64Index`, :class:`UInt64Index` and :class:`Float64Index`
-when given numeric data, but in the future, an :class:`Index` will be returned.
+Currently, in order to maintain backward compatibility, calls to :class:`Index`
+will continue to return :class:`Int64Index`, :class:`UInt64Index` and
+:class:`Float64Index` when given numeric data, but in the future, an
+:class:`Index` will be returned.
*Current behavior*:
@@ -610,8 +641,8 @@ when given numeric data, but in the future, an :class:`Index` will be returned.
Deprecated Frame.append and Series.append
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-:meth:`DataFrame.append` and :meth:`Series.append` have been deprecated and will be removed in Pandas 2.0.
-Use :func:`pandas.concat` instead (:issue:`35407`).
+:meth:`DataFrame.append` and :meth:`Series.append` have been deprecated and will
+be removed in Pandas 2.0. Use :func:`pandas.concat` instead (:issue:`35407`).
*Deprecated syntax*
@@ -661,11 +692,11 @@ Other Deprecations
- Deprecated the 'kind' argument in :meth:`Index.get_slice_bound`, :meth:`Index.slice_indexer`, :meth:`Index.slice_locs`; in a future version passing 'kind' will raise (:issue:`42857`)
- Deprecated dropping of nuisance columns in :class:`Rolling`, :class:`Expanding`, and :class:`EWM` aggregations (:issue:`42738`)
- Deprecated :meth:`Index.reindex` with a non-unique index (:issue:`42568`)
-- Deprecated :meth:`.Styler.render` in favour of :meth:`.Styler.to_html` (:issue:`42140`)
-- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favour of :meth:`.Styler.hide` (:issue:`43758`)
+- Deprecated :meth:`.Styler.render` in favor of :meth:`.Styler.to_html` (:issue:`42140`)
+- Deprecated :meth:`.Styler.hide_index` and :meth:`.Styler.hide_columns` in favor of :meth:`.Styler.hide` (:issue:`43758`)
- Deprecated passing in a string column label into ``times`` in :meth:`DataFrame.ewm` (:issue:`43265`)
- Deprecated the 'include_start' and 'include_end' arguments in :meth:`DataFrame.between_time`; in a future version passing 'include_start' or 'include_end' will raise (:issue:`40245`)
-- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the DataFrame afterwards with ``.squeeze("columns")`` instead. (:issue:`43242`)
+- Deprecated the ``squeeze`` argument to :meth:`read_csv`, :meth:`read_table`, and :meth:`read_excel`. Users should squeeze the DataFrame afterwards with ``.squeeze("columns")`` instead (:issue:`43242`)
- Deprecated the ``index`` argument to :class:`SparseArray` construction (:issue:`23089`)
- Deprecated the ``closed`` argument in :meth:`date_range` and :meth:`bdate_range` in favor of ``inclusive`` argument; In a future version passing ``closed`` will raise (:issue:`40245`)
- Deprecated :meth:`.Rolling.validate`, :meth:`.Expanding.validate`, and :meth:`.ExponentialMovingWindow.validate` (:issue:`43665`)
@@ -792,12 +823,12 @@ Datetimelike
Timedelta
^^^^^^^^^
-- Bug in division of all-``NaT`` :class:`TimeDeltaIndex`, :class:`Series` or :class:`DataFrame` column with object-dtype arraylike of numbers failing to infer the result as timedelta64-dtype (:issue:`39750`)
+- Bug in division of all-``NaT`` :class:`TimeDeltaIndex`, :class:`Series` or :class:`DataFrame` column with object-dtype array like of numbers failing to infer the result as timedelta64-dtype (:issue:`39750`)
- Bug in floor division of ``timedelta64[ns]`` data with a scalar returning garbage values (:issue:`44466`)
- Bug in :class:`Timedelta` now properly taking into account any nanoseconds contribution of any kwarg (:issue:`43764`, :issue:`45227`)
-Timezones
-^^^^^^^^^
+Time Zones
+^^^^^^^^^^
- Bug in :func:`to_datetime` with ``infer_datetime_format=True`` failing to parse zero UTC offset (``Z``) correctly (:issue:`41047`)
- Bug in :meth:`Series.dt.tz_convert` resetting index in a :class:`Series` with :class:`CategoricalIndex` (:issue:`43080`)
- Bug in ``Timestamp`` and ``DatetimeIndex`` incorrectly raising a ``TypeError`` when subtracting two timezone-aware objects with mismatched timezones (:issue:`31793`)
@@ -816,7 +847,7 @@ Numeric
Conversion
^^^^^^^^^^
-- Bug in :class:`UInt64Index` constructor when passing a list containing both positive integers small enough to cast to int64 and integers too large too hold in int64 (:issue:`42201`)
+- Bug in :class:`UInt64Index` constructor when passing a list containing both positive integers small enough to cast to int64 and integers too large to hold in int64 (:issue:`42201`)
- Bug in :class:`Series` constructor returning 0 for missing values with dtype ``int64`` and ``False`` for dtype ``bool`` (:issue:`43017`, :issue:`43018`)
- Bug in constructing a :class:`DataFrame` from a :class:`PandasArray` containing :class:`Series` objects behaving differently than an equivalent ``np.ndarray`` (:issue:`43986`)
- Bug in :class:`IntegerDtype` not allowing coercion from string dtype (:issue:`25472`)
@@ -837,7 +868,7 @@ Interval
Indexing
^^^^^^^^
-- Bug in :meth:`Series.rename` when index in Series is MultiIndex and level in rename is provided. (:issue:`43659`)
+- Bug in :meth:`Series.rename` when index in Series is MultiIndex and level in rename is provided (:issue:`43659`)
- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` when the object's Index has a length greater than one but only one unique value (:issue:`42365`)
- Bug in :meth:`Series.loc` and :meth:`DataFrame.loc` with a :class:`MultiIndex` when indexing with a tuple in which one of the levels is also a tuple (:issue:`27591`)
- Bug in :meth:`Series.loc` when with a :class:`MultiIndex` whose first level contains only ``np.nan`` values (:issue:`42055`)
@@ -848,7 +879,7 @@ Indexing
- Bug in :meth:`Index.get_indexer_non_unique` when index contains multiple ``np.nan`` (:issue:`35392`)
- Bug in :meth:`DataFrame.query` did not handle the degree sign in a backticked column name, such as \`Temp(°C)\`, used in an expression to query a dataframe (:issue:`42826`)
- Bug in :meth:`DataFrame.drop` where the error message did not show missing labels with commas when raising ``KeyError`` (:issue:`42881`)
-- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed. (:issue:`22435`)
+- Bug in :meth:`DataFrame.query` where method calls in query strings led to errors when the ``numexpr`` package was installed (:issue:`22435`)
- Bug in :meth:`DataFrame.nlargest` and :meth:`Series.nlargest` where sorted result did not count indexes containing ``np.nan`` (:issue:`28984`)
- Bug in indexing on a non-unique object-dtype :class:`Index` with an NA scalar (e.g. ``np.nan``) (:issue:`43711`)
- Bug in :meth:`DataFrame.__setitem__` incorrectly writing into an existing column's array rather than setting a new array when the new dtype and the old dtype match (:issue:`43406`)
@@ -880,7 +911,7 @@ Missing
- Bug in :meth:`DataFrame.fillna` not replacing missing values when using a dict-like ``value`` and duplicate column names (:issue:`43476`)
- Bug in constructing a :class:`DataFrame` with a dictionary ``np.datetime64`` as a value and ``dtype='timedelta64[ns]'``, or vice-versa, incorrectly casting instead of raising (:issue:`44428`)
- Bug in :meth:`Series.interpolate` and :meth:`DataFrame.interpolate` with ``inplace=True`` not writing to the underlying array(s) in-place (:issue:`44749`)
-- Bug in :meth:`Index.fillna` incorrectly returning an un-filled :class:`Index` when NA values are present and ``downcast`` argument is specified. This now raises ``NotImplementedError`` instead; do not pass ``downcast`` argument (:issue:`44873`)
+- Bug in :meth:`Index.fillna` incorrectly returning an unfilled :class:`Index` when NA values are present and ``downcast`` argument is specified. This now raises ``NotImplementedError`` instead; do not pass ``downcast`` argument (:issue:`44873`)
- Bug in :meth:`DataFrame.dropna` changing :class:`Index` even if no entries were dropped (:issue:`41965`)
- Bug in :meth:`Series.fillna` with an object-dtype incorrectly ignoring ``downcast="infer"`` (:issue:`44241`)
@@ -899,7 +930,7 @@ I/O
- Bug in :func:`json_normalize` where ``errors=ignore`` could fail to ignore missing values of ``meta`` when ``record_path`` has a length greater than one (:issue:`41876`)
- Bug in :func:`read_csv` with multi-header input and arguments referencing column names as tuples (:issue:`42446`)
- Bug in :func:`read_fwf`, where difference in lengths of ``colspecs`` and ``names`` was not raising ``ValueError`` (:issue:`40830`)
-- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serialising plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
+- Bug in :func:`Series.to_json` and :func:`DataFrame.to_json` where some attributes were skipped when serializing plain Python objects to JSON (:issue:`42768`, :issue:`33043`)
- Column headers are dropped when constructing a :class:`DataFrame` from a sqlalchemy's ``Row`` object (:issue:`40682`)
- Bug in unpickling a :class:`Index` with object dtype incorrectly inferring numeric dtypes (:issue:`43188`)
- Bug in :func:`read_csv` where reading multi-header input with unequal lengths incorrectly raising uncontrolled ``IndexError`` (:issue:`43102`)
@@ -913,7 +944,7 @@ I/O
- Bug in :func:`read_csv` used second row to guess implicit index if ``header`` was set to ``None`` for ``engine="python"`` (:issue:`22144`)
- Bug in :func:`read_csv` not recognizing bad lines when ``names`` were given for ``engine="c"`` (:issue:`22144`)
- Bug in :func:`read_csv` with :code:`float_precision="round_trip"` which did not skip initial/trailing whitespace (:issue:`43713`)
-- Bug when Python is built without lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used. (:issue:`43495`)
+- Bug when Python is built without the lzma module: a warning was raised at the pandas import time, even if the lzma capability isn't used (:issue:`43495`)
- Bug in :func:`read_csv` not applying dtype for ``index_col`` (:issue:`9435`)
- Bug in dumping/loading a :class:`DataFrame` with ``yaml.dump(frame)`` (:issue:`42748`)
- Bug in :func:`read_csv` raising ``ValueError`` when names was longer than header but equal to data rows for ``engine="python"`` (:issue:`38453`)
@@ -925,7 +956,7 @@ I/O
- Bug in :func:`read_csv` not replacing ``NaN`` values with ``np.nan`` before attempting date conversion (:issue:`26203`)
- Bug in :func:`read_csv` raising ``AttributeError`` when attempting to read a .csv file and infer index column dtype from an nullable integer type (:issue:`44079`)
- Bug in :func:`to_csv` always coercing datetime columns with different formats to the same format (:issue:`21734`)
-- :meth:`DataFrame.to_csv` and :meth:`Series.to_csv` with ``compression`` set to ``'zip'`` no longer create a zip file containing a file ending with ".zip". Instead, they try to infer the inner file name more smartly. (:issue:`39465`)
+- :meth:`DataFrame.to_csv` and :meth:`Series.to_csv` with ``compression`` set to ``'zip'`` no longer create a zip file containing a file ending with ".zip". Instead, they try to infer the inner file name more smartly (:issue:`39465`)
- Bug in :func:`read_csv` where reading a mixed column of booleans and missing values to a float type results in the missing values becoming 1.0 rather than NaN (:issue:`42808`, :issue:`34120`)
- Bug in :func:`to_xml` raising error for ``pd.NA`` with extension array dtype (:issue:`43903`)
- Bug in :func:`read_csv` when passing simultaneously a parser in ``date_parser`` and ``parse_dates=False``, the parsing was still called (:issue:`44366`)
@@ -934,7 +965,7 @@ I/O
- Bug in :func:`read_csv` when passing a ``tempfile.SpooledTemporaryFile`` opened in binary mode (:issue:`44748`)
- Bug in :func:`read_json` raising ``ValueError`` when attempting to parse json strings containing "://" (:issue:`36271`)
- Bug in :func:`read_csv` when ``engine="c"`` and ``encoding_errors=None`` which caused a segfault (:issue:`45180`)
-- Bug in :func:`read_csv` an invalid value of ``usecols`` leading to an un-closed file handle (:issue:`45384`)
+- Bug in :func:`read_csv` an invalid value of ``usecols`` leading to an unclosed file handle (:issue:`45384`)
Period
^^^^^^
@@ -946,7 +977,7 @@ Period
Plotting
^^^^^^^^
-- When given non-numeric data, :meth:`DataFrame.boxplot` now raises a ``ValueError`` rather than a cryptic ``KeyError`` or ``ZeroDivisionError``, in line with other plotting functions like :meth:`DataFrame.hist`. (:issue:`43480`)
+- When given non-numeric data, :meth:`DataFrame.boxplot` now raises a ``ValueError`` rather than a cryptic ``KeyError`` or ``ZeroDivisionError``, in line with other plotting functions like :meth:`DataFrame.hist` (:issue:`43480`)
Groupby/resample/rolling
^^^^^^^^^^^^^^^^^^^^^^^^
@@ -980,10 +1011,10 @@ Reshaping
^^^^^^^^^
- Improved error message when creating a :class:`DataFrame` column from a multi-dimensional :class:`numpy.ndarray` (:issue:`42463`)
- :func:`concat` creating :class:`MultiIndex` with duplicate level entries when concatenating a :class:`DataFrame` with duplicates in :class:`Index` and multiple keys (:issue:`42651`)
-- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices (:issue:`42185`) and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42425`)
+- Bug in :meth:`pandas.cut` on :class:`Series` with duplicate indices and non-exact :meth:`pandas.CategoricalIndex` (:issue:`42185`, :issue:`42425`)
- Bug in :meth:`DataFrame.append` failing to retain dtypes when appended columns do not match (:issue:`43392`)
- Bug in :func:`concat` of ``bool`` and ``boolean`` dtypes resulting in ``object`` dtype instead of ``boolean`` dtype (:issue:`42800`)
-- Bug in :func:`crosstab` when inputs are are categorical Series, there are categories that are not present in one or both of the Series, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
+- Bug in :func:`crosstab` when inputs are categorical Series, there are categories that are not present in one or both of the Series, and ``margins=True``. Previously the margin value for missing categories was ``NaN``. It is now correctly reported as 0 (:issue:`43505`)
- Bug in :func:`concat` would fail when the ``objs`` argument all had the same index and the ``keys`` argument contained duplicates (:issue:`43595`)
- Bug in :func:`concat` which ignored the ``sort`` parameter (:issue:`43375`)
- Fixed bug in :func:`merge` with :class:`MultiIndex` as column index for the ``on`` argument returning an error when assigning a column internally (:issue:`43734`)
| still more to do but this is what I have so far.
To make review easier could merge this if ok and then follow-up with another PR if I find anything else rather than add more commits. | https://api.github.com/repos/pandas-dev/pandas/pulls/45528 | 2022-01-21T13:58:59Z | 2022-01-21T16:54:33Z | 2022-01-21T16:54:33Z | 2022-01-21T16:56:40Z |
BUG: df.getitem returning copy instead of view for unique column in dup index | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 2346a86ad21f8..4a86194356a71 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -810,6 +810,7 @@ Indexing
^^^^^^^^
- Bug in :meth:`loc.__getitem__` with a list of keys causing an internal inconsistency that could lead to a disconnect between ``frame.at[x, y]`` vs ``frame[y].loc[x]`` (:issue:`22372`)
- Bug in :meth:`DataFrame.iloc` where indexing a single row on a :class:`DataFrame` with a single ExtensionDtype column gave a copy instead of a view on the underlying data (:issue:`45241`)
+- Bug in :meth:`DataFrame.__getitem__` returning copy when :class:`DataFrame` has duplicated columns even if a unique column is selected (:issue:`45316`, :issue:`41062`)
- Bug in :meth:`Series.align` does not create :class:`MultiIndex` with union of levels when both MultiIndexes intersections are identical (:issue:`45224`)
- Bug in setting a NA value (``None`` or ``np.nan``) into a :class:`Series` with int-based :class:`IntervalDtype` incorrectly casting to object dtype instead of a float-based :class:`IntervalDtype` (:issue:`45568`)
- Bug in indexing setting values into an ``ExtensionDtype`` column with ``df.iloc[:, i] = values`` with ``values`` having the same dtype as ``df.iloc[:, i]`` incorrectly inserting a new array instead of setting in-place (:issue:`33457`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 8711d53353185..920358f206770 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3612,11 +3612,18 @@ def __getitem__(self, key):
if is_hashable(key) and not is_iterator(key):
# is_iterator to exclude generator e.g. test_getitem_listlike
# shortcut if the key is in columns
- if self.columns.is_unique and key in self.columns:
- if isinstance(self.columns, MultiIndex):
- return self._getitem_multilevel(key)
+ is_mi = isinstance(self.columns, MultiIndex)
+ # GH#45316 Return view if key is not duplicated
+ # Only use drop_duplicates with duplicates for performance
+ if not is_mi and (
+ self.columns.is_unique
+ and key in self.columns
+ or key in self.columns.drop_duplicates(keep=False)
+ ):
return self._get_item_cache(key)
+ elif is_mi and self.columns.is_unique and key in self.columns:
+ return self._getitem_multilevel(key)
# Do we have a slicer (on rows)?
indexer = convert_to_index_sliceable(self, key)
if indexer is not None:
diff --git a/pandas/tests/frame/indexing/test_getitem.py b/pandas/tests/frame/indexing/test_getitem.py
index 8cc8b487ff44f..7994c56f8d68b 100644
--- a/pandas/tests/frame/indexing/test_getitem.py
+++ b/pandas/tests/frame/indexing/test_getitem.py
@@ -357,6 +357,21 @@ def test_getitem_empty_frame_with_boolean(self):
df2 = df[df > 0]
tm.assert_frame_equal(df, df2)
+ def test_getitem_returns_view_when_column_is_unique_in_df(self):
+ # GH#45316
+ df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=["a", "a", "b"])
+ view = df["b"]
+ view.loc[:] = 100
+ expected = DataFrame([[1, 2, 100], [4, 5, 100]], columns=["a", "a", "b"])
+ tm.assert_frame_equal(df, expected)
+
+ def test_getitem_frozenset_unique_in_column(self):
+ # GH#41062
+ df = DataFrame([[1, 2, 3, 4]], columns=[frozenset(["KEY"]), "B", "C", "C"])
+ result = df[frozenset(["KEY"])]
+ expected = Series([1], name=frozenset(["KEY"]))
+ tm.assert_series_equal(result, expected)
+
class TestGetitemSlice:
def test_getitem_slice_float64(self, frame_or_series):
diff --git a/pandas/tests/indexing/test_chaining_and_caching.py b/pandas/tests/indexing/test_chaining_and_caching.py
index 47f929d87bd6f..adc001695579c 100644
--- a/pandas/tests/indexing/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/test_chaining_and_caching.py
@@ -424,19 +424,6 @@ def test_detect_chained_assignment_warnings_errors(self):
with pytest.raises(SettingWithCopyError, match=msg):
df.loc[0]["A"] = 111
- def test_detect_chained_assignment_warnings_filter_and_dupe_cols(self):
- # xref gh-13017.
- with option_context("chained_assignment", "warn"):
- df = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, -9]], columns=["a", "a", "c"])
-
- with tm.assert_produces_warning(SettingWithCopyWarning):
- df.c.loc[df.c > 0] = None
-
- expected = DataFrame(
- [[1, 2, 3], [4, 5, 6], [7, 8, -9]], columns=["a", "a", "c"]
- )
- tm.assert_frame_equal(df, expected)
-
@pytest.mark.parametrize("rhs", [3, DataFrame({0: [1, 2, 3, 4]})])
def test_detect_chained_assignment_warning_stacklevel(self, rhs):
# GH#42570
| - [x] closes #45316
- [x] closes #41062
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [x] whatsnew entry
I think this is more intuitive (and "more" correct) than the previous behavior. | https://api.github.com/repos/pandas-dev/pandas/pulls/45526 | 2022-01-21T12:29:26Z | 2022-06-22T01:19:38Z | 2022-06-22T01:19:37Z | 2022-06-22T07:41:10Z |
test replace on out of bound datetime | diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index b9024b4233d7f..001a50c3ce1b0 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -753,6 +753,13 @@ def test_replace_for_new_dtypes(self, datetime_frame):
"bar",
DataFrame({"dt": [datetime(3017, 12, 20)], "str": ["bar"]}),
),
+ # GH 36782
+ (
+ DataFrame({"dt": [datetime(2920, 10, 1)]}),
+ datetime(2920, 10, 1),
+ datetime(2020, 10, 1),
+ DataFrame({"dt": [datetime(2020, 10, 1)]}),
+ ),
(
DataFrame(
{
| Just adds a test for the functionality that is working on `main`. Placed the test in amongst the other `DataFrame.replace` tests.
- [x] closes #36782
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/45525 | 2022-01-21T12:27:02Z | 2022-01-23T00:12:09Z | 2022-01-23T00:12:09Z | 2022-01-23T17:56:15Z |
REGR: fix period dtype <-> arrow roundtrip for pyarrow < 4 | diff --git a/pandas/core/internals/api.py b/pandas/core/internals/api.py
index 537ae8f2a4320..371f1e2443b36 100644
--- a/pandas/core/internals/api.py
+++ b/pandas/core/internals/api.py
@@ -24,6 +24,7 @@
from pandas.core.internals.blocks import (
Block,
DatetimeTZBlock,
+ ExtensionBlock,
check_ndim,
ensure_block_shape,
extract_pandas_array,
@@ -51,6 +52,12 @@ def make_block(
values, dtype = extract_pandas_array(values, dtype, ndim)
+ if klass is ExtensionBlock and is_period_dtype(values.dtype):
+ # GH-44681 changed PeriodArray to be stored in the 2D
+ # NDArrayBackedExtensionBlock instead of ExtensionBlock
+ # -> still allow ExtensionBlock to be passed in this case for back compat
+ klass = None
+
if klass is None:
dtype = dtype or values.dtype
klass = get_block_type(dtype)
diff --git a/pandas/tests/arrays/period/test_arrow_compat.py b/pandas/tests/arrays/period/test_arrow_compat.py
index bc557f2e119d5..560299a4a47f5 100644
--- a/pandas/tests/arrays/period/test_arrow_compat.py
+++ b/pandas/tests/arrays/period/test_arrow_compat.py
@@ -1,7 +1,5 @@
import pytest
-from pandas.compat import pa_version_under4p0
-
from pandas.core.dtypes.dtypes import PeriodDtype
import pandas as pd
@@ -71,9 +69,6 @@ def test_arrow_array_missing():
assert result.storage.equals(expected)
-@pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow incorrectly uses pandas internals API"
-)
def test_arrow_table_roundtrip():
from pandas.core.arrays._arrow_utils import ArrowPeriodType
@@ -93,9 +88,6 @@ def test_arrow_table_roundtrip():
tm.assert_frame_equal(result, expected)
-@pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow incorrectly uses pandas internals API"
-)
def test_arrow_load_from_zero_chunks():
# GH-41040
@@ -114,9 +106,6 @@ def test_arrow_load_from_zero_chunks():
tm.assert_frame_equal(result, df)
-@pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow incorrectly uses pandas internals API"
-)
def test_arrow_table_roundtrip_without_metadata():
arr = PeriodArray([1, 2, 3], freq="H")
arr[1] = pd.NaT
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index 4fcb43c1c3e47..df858070f698a 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -2,8 +2,6 @@
import numpy as np
import pytest
-from pandas.compat.pyarrow import pa_version_under4p0
-
import pandas as pd
import pandas._testing as tm
@@ -87,11 +85,7 @@ def test_basic(self):
),
}
)
- if not pa_version_under4p0:
- # older pyarrow incorrectly uses pandas internal API, so
- # constructs invalid Block
- df["periods"] = pd.period_range("2013", freq="M", periods=3)
-
+ df["periods"] = pd.period_range("2013", freq="M", periods=3)
df["timedeltas"] = pd.timedelta_range("1 day", periods=3)
df["intervals"] = pd.interval_range(0, 3, 3)
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index decdf02dd3072..b60ff00f9d59e 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -15,7 +15,6 @@
from pandas.compat.pyarrow import (
pa_version_under2p0,
- pa_version_under4p0,
pa_version_under5p0,
pa_version_under6p0,
)
@@ -652,13 +651,7 @@ def test_use_nullable_dtypes(self, engine, request):
"object",
"datetime64[ns, UTC]",
"float",
- pytest.param(
- "period[D]",
- marks=pytest.mark.xfail(
- pa_version_under4p0,
- reason="pyarrow uses pandas internal API incorrectly",
- ),
- ),
+ "period[D]",
"Float64",
"string",
],
@@ -897,9 +890,6 @@ def test_pyarrow_backed_string_array(self, pa, string_storage):
check_round_trip(df, pa, expected=df.astype(f"string[{string_storage}]"))
@td.skip_if_no("pyarrow")
- @pytest.mark.xfail(
- pa_version_under4p0, reason="pyarrow uses pandas internal API incorrectly"
- )
def test_additional_extension_types(self, pa):
# test additional ExtensionArrays that are supported through the
# __arrow_array__ protocol + by defining a custom ExtensionType
| Closes #45470 | https://api.github.com/repos/pandas-dev/pandas/pulls/45524 | 2022-01-21T12:02:40Z | 2022-01-21T21:33:37Z | 2022-01-21T21:33:36Z | 2022-01-22T09:09:12Z |
DEPR: restore to_frame() name=None behaviour but deprecate it | diff --git a/doc/source/whatsnew/v1.4.0.rst b/doc/source/whatsnew/v1.4.0.rst
index 1ca4e8cc97df0..234fada5e2ba3 100644
--- a/doc/source/whatsnew/v1.4.0.rst
+++ b/doc/source/whatsnew/v1.4.0.rst
@@ -696,6 +696,7 @@ Other Deprecations
- Deprecated the behavior of :meth:`Timestamp.utcfromtimestamp`, in the future it will return a timezone-aware UTC :class:`Timestamp` (:issue:`22451`)
- Deprecated :meth:`NaT.freq` (:issue:`45071`)
- Deprecated behavior of :class:`Series` and :class:`DataFrame` construction when passed float-dtype data containing ``NaN`` and an integer dtype ignoring the dtype argument; in a future version this will raise (:issue:`40110`)
+- Deprecated the behaviour of :meth:`Series.to_frame` and :meth:`Index.to_frame` to ignore the ``name`` argument when ``name=None``. Currently, this means to preserve the existing name, but in the future explicitly passing ``name=None`` will set ``None`` as the name of the column in the resulting DataFrame (:issue:`44212`)
.. ---------------------------------------------------------------------------
@@ -1041,7 +1042,6 @@ Other
- Bug in :meth:`CustomBusinessMonthBegin.__add__` (:meth:`CustomBusinessMonthEnd.__add__`) not applying the extra ``offset`` parameter when beginning (end) of the target month is already a business day (:issue:`41356`)
- Bug in :meth:`RangeIndex.union` with another ``RangeIndex`` with matching (even) ``step`` and starts differing by strictly less than ``step / 2`` (:issue:`44019`)
- Bug in :meth:`RangeIndex.difference` with ``sort=None`` and ``step<0`` failing to sort (:issue:`44085`)
-- Bug in :meth:`Series.to_frame` and :meth:`Index.to_frame` ignoring the ``name`` argument when ``name=None`` is explicitly passed (:issue:`44212`)
- Bug in :meth:`Series.replace` and :meth:`DataFrame.replace` with ``value=None`` and ExtensionDtypes (:issue:`44270`, :issue:`37899`)
- Bug in :meth:`FloatingArray.equals` failing to consider two arrays equal if they contain ``np.nan`` values (:issue:`44382`)
- Bug in :meth:`DataFrame.shift` with ``axis=1`` and ``ExtensionDtype`` columns incorrectly raising when an incompatible ``fill_value`` is passed (:issue:`44564`)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 717abb998dd65..16b44ca4da162 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1628,6 +1628,17 @@ def to_frame(
"""
from pandas import DataFrame
+ if name is None:
+ warnings.warn(
+ "Explicitly passing `name=None` currently preserves the Index's name "
+ "or uses a default name of 0. This behaviour is deprecated, and in "
+ "the future `None` will be used as the name of the resulting "
+ "DataFrame column.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ name = lib.no_default
+
if name is lib.no_default:
name = self.name or 0
result = DataFrame({name: self._values.copy()})
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 676fa4962cd56..7e59e51174b6f 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1762,6 +1762,17 @@ def to_frame(self, index: bool = True, name=lib.no_default) -> DataFrame:
"""
from pandas import DataFrame
+ if name is None:
+ warnings.warn(
+ "Explicitly passing `name=None` currently preserves the Index's name "
+ "or uses a default name of 0. This behaviour is deprecated, and in "
+ "the future `None` will be used as the name of the resulting "
+ "DataFrame column.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ name = lib.no_default
+
if name is not lib.no_default:
if not is_list_like(name):
raise TypeError("'name' must be a list / sequence of column names.")
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 4e69596539bed..cc60cd63ba3ab 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -1758,7 +1758,7 @@ def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:
Parameters
----------
- name : object, default None
+ name : object, optional
The passed name should substitute for the series name (if it has
one).
@@ -1777,6 +1777,17 @@ def to_frame(self, name: Hashable = lib.no_default) -> DataFrame:
1 b
2 c
"""
+ if name is None:
+ warnings.warn(
+ "Explicitly passing `name=None` currently preserves the Series' name "
+ "or uses a default name of 0. This behaviour is deprecated, and in "
+ "the future `None` will be used as the name of the resulting "
+ "DataFrame column.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+ name = lib.no_default
+
columns: Index
if name is lib.no_default:
name = self.name
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_frame.py b/pandas/tests/indexes/datetimes/methods/test_to_frame.py
index 80e8284abe031..fa5cca1c3e78b 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_frame.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_frame.py
@@ -17,10 +17,15 @@ def test_to_frame_datetime_tz(self):
def test_to_frame_respects_none_name(self):
# GH#44212 if we explicitly pass name=None, then that should be respected,
# not changed to 0
+ # GH-45448 this is first deprecated to only change in the future
idx = date_range(start="2019-01-01", end="2019-01-30", freq="D", tz="UTC")
- result = idx.to_frame(name=None)
- exp_idx = Index([None], dtype=object)
+ with tm.assert_produces_warning(FutureWarning):
+ result = idx.to_frame(name=None)
+ # exp_idx = Index([None], dtype=object)
+ exp_idx = Index([0])
tm.assert_index_equal(exp_idx, result.columns)
- result = idx.rename("foo").to_frame(name=None)
+ with tm.assert_produces_warning(FutureWarning):
+ result = idx.rename("foo").to_frame(name=None)
+ exp_idx = Index(["foo"], dtype=object)
tm.assert_index_equal(exp_idx, result.columns)
diff --git a/pandas/tests/series/methods/test_to_frame.py b/pandas/tests/series/methods/test_to_frame.py
index 55d49b8fbee70..5f303d09dcc33 100644
--- a/pandas/tests/series/methods/test_to_frame.py
+++ b/pandas/tests/series/methods/test_to_frame.py
@@ -10,13 +10,18 @@ class TestToFrame:
def test_to_frame_respects_name_none(self):
# GH#44212 if we explicitly pass name=None, then that should be respected,
# not changed to 0
+ # GH-45448 this is first deprecated to only change in the future
ser = Series(range(3))
- result = ser.to_frame(None)
+ with tm.assert_produces_warning(FutureWarning):
+ result = ser.to_frame(None)
- exp_index = Index([None], dtype=object)
+ # exp_index = Index([None], dtype=object)
+ exp_index = Index([0])
tm.assert_index_equal(result.columns, exp_index)
- result = ser.rename("foo").to_frame(None)
+ with tm.assert_produces_warning(FutureWarning):
+ result = ser.rename("foo").to_frame(None)
+ exp_index = Index(["foo"], dtype=object)
tm.assert_index_equal(result.columns, exp_index)
def test_to_frame(self, datetime_series):
| Closes #45448
| https://api.github.com/repos/pandas-dev/pandas/pulls/45523 | 2022-01-21T11:53:10Z | 2022-01-21T14:01:18Z | 2022-01-21T14:01:18Z | 2022-01-21T16:45:31Z |
REGR: read_fwf interpreting infer as list of colspecs when checking names length | diff --git a/pandas/io/parsers/readers.py b/pandas/io/parsers/readers.py
index 6d60f94e89291..ef693fcbd3720 100644
--- a/pandas/io/parsers/readers.py
+++ b/pandas/io/parsers/readers.py
@@ -856,7 +856,7 @@ def read_fwf(
# Ensure length of `colspecs` matches length of `names`
names = kwds.get("names")
if names is not None:
- if len(names) != len(colspecs):
+ if len(names) != len(colspecs) and colspecs != "infer":
# need to check len(index_col) as it might contain
# unnamed indices, in which case it's name is not required
len_index = 0
diff --git a/pandas/tests/io/parser/test_read_fwf.py b/pandas/tests/io/parser/test_read_fwf.py
index 63f783b01d1f3..3de73e51ce6b6 100644
--- a/pandas/tests/io/parser/test_read_fwf.py
+++ b/pandas/tests/io/parser/test_read_fwf.py
@@ -920,3 +920,13 @@ def test_skiprows_passing_as_positional_deprecated():
result = read_fwf(StringIO(data), [(0, 2)])
expected = DataFrame({"0": [1, 2]})
tm.assert_frame_equal(result, expected)
+
+
+def test_names_and_infer_colspecs():
+ # GH#45337
+ data = """X Y Z
+ 959.0 345 22.2
+ """
+ result = read_fwf(StringIO(data), skiprows=1, usecols=[0, 2], names=["a", "b"])
+ expected = DataFrame({"a": [959.0], "b": 22.2})
+ tm.assert_frame_equal(result, expected)
| - [x] closes #45337
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [ ] whatsnew entry
No whatsnew needed if this goes into 1.4, otherwise I will add one for 1.4.1 when available | https://api.github.com/repos/pandas-dev/pandas/pulls/45522 | 2022-01-21T11:38:31Z | 2022-01-21T14:02:36Z | 2022-01-21T14:02:36Z | 2022-01-21T14:03:21Z |
EA interface: rename ExtensionArray._hasnans to ._hasna | diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index c16c404d56295..d955d8e583f1c 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -427,7 +427,7 @@ def __contains__(self, item: object) -> bool | np.bool_:
if not self._can_hold_na:
return False
elif item is self.dtype.na_value or isinstance(item, self.dtype.type):
- return self._hasnans
+ return self._hasna
else:
return False
else:
@@ -606,7 +606,7 @@ def isna(self) -> np.ndarray | ExtensionArraySupportsAnyAll:
raise AbstractMethodError(self)
@property
- def _hasnans(self) -> bool:
+ def _hasna(self) -> bool:
# GH#22680
"""
Equivalent to `self.isna().any()`.
@@ -698,7 +698,7 @@ def argmin(self, skipna: bool = True) -> int:
ExtensionArray.argmax
"""
validate_bool_kwarg(skipna, "skipna")
- if not skipna and self._hasnans:
+ if not skipna and self._hasna:
raise NotImplementedError
return nargminmax(self, "argmin")
@@ -722,7 +722,7 @@ def argmax(self, skipna: bool = True) -> int:
ExtensionArray.argmin
"""
validate_bool_kwarg(skipna, "skipna")
- if not skipna and self._hasnans:
+ if not skipna and self._hasna:
raise NotImplementedError
return nargminmax(self, "argmax")
@@ -1534,6 +1534,9 @@ def _empty(cls, shape: Shape, dtype: ExtensionDtype):
ExtensionDtype.empty
ExtensionDtype.empty is the 'official' public version of this API.
"""
+ # Implementer note: while ExtensionDtype.empty is the public way to
+ # call this method, it is still required to implement this `_empty`
+ # method as well (it is called internally in pandas)
obj = cls._from_sequence([], dtype=dtype)
taker = np.broadcast_to(np.intp(-1), shape)
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index c752e0ddca88e..c845d9c8cdbde 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -841,7 +841,7 @@ def _isnan(self) -> npt.NDArray[np.bool_]:
return self.asi8 == iNaT
@property # NB: override with cache_readonly in immutable subclasses
- def _hasnans(self) -> bool:
+ def _hasna(self) -> bool:
"""
return if I have any nans; enables various perf speedups
"""
@@ -866,7 +866,7 @@ def _maybe_mask_results(
This is an internal routine.
"""
- if self._hasnans:
+ if self._hasna:
if convert:
result = result.astype(convert)
if fill_value is None:
@@ -1125,7 +1125,7 @@ def _add_timedelta_arraylike(self, other):
new_values = checked_add_with_arr(
self_i8, other_i8, arr_mask=self._isnan, b_mask=other._isnan
)
- if self._hasnans or other._hasnans:
+ if self._hasna or other._hasna:
mask = self._isnan | other._isnan
np.putmask(new_values, mask, iNaT)
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index f2618b92b3ffb..87acadc01faad 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -738,7 +738,7 @@ def _sub_datetime_arraylike(self, other):
other_i8 = other.asi8
arr_mask = self._isnan | other._isnan
new_values = checked_add_with_arr(self_i8, -other_i8, arr_mask=arr_mask)
- if self._hasnans or other._hasnans:
+ if self._hasna or other._hasna:
np.putmask(new_values, arr_mask, iNaT)
return new_values.view("timedelta64[ns]")
@@ -1356,7 +1356,7 @@ def isocalendar(self) -> DataFrame:
iso_calendar_df = DataFrame(
sarray, columns=["year", "week", "day"], dtype="UInt32"
)
- if self._hasnans:
+ if self._hasna:
iso_calendar_df.iloc[self._isnan] = None
return iso_calendar_df
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index 487b51735bd4e..04cc70b7efa6a 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -548,7 +548,7 @@ def _time_shift(self, periods: int, freq=None) -> PeriodArray:
f"{type(self).__name__}._time_shift"
)
values = self.asi8 + periods * self.freq.n
- if self._hasnans:
+ if self._hasna:
values[self._isnan] = iNaT
return type(self)(values, freq=self.freq)
@@ -618,7 +618,7 @@ def asfreq(self, freq=None, how: str = "E") -> PeriodArray:
new_data = period_asfreq_arr(ordinal, base1, base2, end)
- if self._hasnans:
+ if self._hasna:
new_data[self._isnan] = iNaT
return type(self)(new_data, freq=freq)
@@ -645,7 +645,7 @@ def _format_native_types(
else:
formatter = lambda dt: str(dt)
- if self._hasnans:
+ if self._hasna:
mask = self._isnan
values[mask] = na_rep
imask = ~mask
@@ -712,7 +712,7 @@ def _sub_period(self, other):
new_data = asi8 - other.ordinal
new_data = np.array([self.freq * x for x in new_data])
- if self._hasnans:
+ if self._hasna:
new_data[self._isnan] = NaT
return new_data
@@ -739,7 +739,7 @@ def _sub_period_array(self, other):
)
new_values = np.array([self.freq.base * x for x in new_values])
- if self._hasnans or other._hasnans:
+ if self._hasna or other._hasna:
mask = self._isnan | other._isnan
new_values[mask] = NaT
return new_values
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index 93255f6677c55..eb195e4facf4a 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -82,7 +82,7 @@ def _field_accessor(name: str, alias: str, docstring: str):
def f(self) -> np.ndarray:
values = self.asi8
result = get_timedelta_field(values, alias)
- if self._hasnans:
+ if self._hasna:
result = self._maybe_mask_results(
result, fill_value=None, convert="float64"
)
@@ -911,7 +911,7 @@ def components(self) -> DataFrame:
"microseconds",
"nanoseconds",
]
- hasnans = self._hasnans
+ hasnans = self._hasna
if hasnans:
def f(x):
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 141a609e86809..ac017146b153a 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -1507,7 +1507,7 @@ def common_dtype_categorical_compat(
hasnas = obj.hasnans
else:
# Categorical
- hasnas = cast("Categorical", obj)._hasnans
+ hasnas = cast("Categorical", obj)._hasna
if hasnas:
# see test_union_int_categorical_with_nan
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 589b92f392ca8..8e94d72752b33 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -96,7 +96,7 @@ class DatetimeIndexOpsMixin(NDArrayBackedExtensionIndex):
hasnans = cast(
bool,
cache_readonly(
- DatetimeLikeArrayMixin._hasnans.fget # type: ignore[attr-defined]
+ DatetimeLikeArrayMixin._hasna.fget # type: ignore[attr-defined]
),
)
diff --git a/pandas/tests/extension/base/constructors.py b/pandas/tests/extension/base/constructors.py
index c86054aed7e4d..b9f8f8512a995 100644
--- a/pandas/tests/extension/base/constructors.py
+++ b/pandas/tests/extension/base/constructors.py
@@ -135,3 +135,8 @@ def test_empty(self, dtype):
assert isinstance(result2, cls)
assert result2.dtype == dtype
assert result2.shape == (4,)
+
+ result2 = dtype.empty(4)
+ assert isinstance(result2, cls)
+ assert result2.dtype == dtype
+ assert result2.shape == (4,)
| As discussed in follow-up on https://github.com/pandas-dev/pandas/pull/45024#discussion_r774711601
Since this is "public" for developers, we need to decide on a name now for 1.4. Using "na" instead of "nan" makes it consistent with the other missing values related methods in the EA interface (isna, dropna, fillna, _can_hold_na) | https://api.github.com/repos/pandas-dev/pandas/pulls/45519 | 2022-01-21T08:02:43Z | 2022-01-21T21:35:04Z | 2022-01-21T21:35:03Z | 2022-01-22T08:18:31Z |
Backport PR #45449: DEPR: undo deprecation of astype(int64) for datetimelike values | diff --git a/doc/source/whatsnew/v1.3.0.rst b/doc/source/whatsnew/v1.3.0.rst
index ed66861efad93..a392aeb5274c2 100644
--- a/doc/source/whatsnew/v1.3.0.rst
+++ b/doc/source/whatsnew/v1.3.0.rst
@@ -811,7 +811,7 @@ Other Deprecations
- Deprecated allowing scalars to be passed to the :class:`Categorical` constructor (:issue:`38433`)
- Deprecated constructing :class:`CategoricalIndex` without passing list-like data (:issue:`38944`)
- Deprecated allowing subclass-specific keyword arguments in the :class:`Index` constructor, use the specific subclass directly instead (:issue:`14093`, :issue:`21311`, :issue:`22315`, :issue:`26974`)
-- Deprecated the :meth:`astype` method of datetimelike (``timedelta64[ns]``, ``datetime64[ns]``, ``Datetime64TZDtype``, ``PeriodDtype``) to convert to integer dtypes, use ``values.view(...)`` instead (:issue:`38544`)
+- Deprecated the :meth:`astype` method of datetimelike (``timedelta64[ns]``, ``datetime64[ns]``, ``Datetime64TZDtype``, ``PeriodDtype``) to convert to integer dtypes, use ``values.view(...)`` instead (:issue:`38544`). This deprecation was later reverted in pandas 1.4.0.
- Deprecated :meth:`MultiIndex.is_lexsorted` and :meth:`MultiIndex.lexsort_depth`, use :meth:`MultiIndex.is_monotonic_increasing` instead (:issue:`32259`)
- Deprecated keyword ``try_cast`` in :meth:`Series.where`, :meth:`Series.mask`, :meth:`DataFrame.where`, :meth:`DataFrame.mask`; cast results manually if desired (:issue:`38836`)
- Deprecated comparison of :class:`Timestamp` objects with ``datetime.date`` objects. Instead of e.g. ``ts <= mydate`` use ``ts <= pd.Timestamp(mydate)`` or ``ts.date() <= mydate`` (:issue:`36131`)
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 58596437b6a3f..c752e0ddca88e 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -430,14 +430,6 @@ def astype(self, dtype, copy: bool = True):
elif is_integer_dtype(dtype):
# we deliberately ignore int32 vs. int64 here.
# See https://github.com/pandas-dev/pandas/issues/24381 for more.
- warnings.warn(
- f"casting {self.dtype} values to int64 with .astype(...) is "
- "deprecated and will raise in a future version. "
- "Use .view(...) instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
-
values = self.asi8
if is_unsigned_integer_dtype(dtype):
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 03fe4c00aa28d..e70fd443d61e8 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -1123,13 +1123,6 @@ def astype_nansafe(
elif is_datetime64_dtype(arr.dtype):
if dtype == np.int64:
- warnings.warn(
- f"casting {arr.dtype} values to int64 with .astype(...) "
- "is deprecated and will raise in a future version. "
- "Use .view(...) instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
if isna(arr).any():
raise ValueError("Cannot convert NaT values to integer")
return arr.view(dtype)
@@ -1142,13 +1135,6 @@ def astype_nansafe(
elif is_timedelta64_dtype(arr.dtype):
if dtype == np.int64:
- warnings.warn(
- f"casting {arr.dtype} values to int64 with .astype(...) "
- "is deprecated and will raise in a future version. "
- "Use .view(...) instead.",
- FutureWarning,
- stacklevel=find_stack_level(),
- )
if isna(arr).any():
raise ValueError("Cannot convert NaT values to integer")
return arr.view(dtype)
diff --git a/pandas/tests/arrays/period/test_astype.py b/pandas/tests/arrays/period/test_astype.py
index e16220acd3210..f05265c910e1c 100644
--- a/pandas/tests/arrays/period/test_astype.py
+++ b/pandas/tests/arrays/period/test_astype.py
@@ -13,18 +13,14 @@ def test_astype(dtype):
# We choose to ignore the sign and size of integers for
# Period/Datetime/Timedelta astype
arr = period_array(["2000", "2001", None], freq="D")
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- result = arr.astype(dtype)
+ result = arr.astype(dtype)
if np.dtype(dtype).kind == "u":
expected_dtype = np.dtype("uint64")
else:
expected_dtype = np.dtype("int64")
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- expected = arr.astype(expected_dtype)
+ expected = arr.astype(expected_dtype)
assert result.dtype == expected_dtype
tm.assert_numpy_array_equal(result, expected)
@@ -32,17 +28,13 @@ def test_astype(dtype):
def test_astype_copies():
arr = period_array(["2000", "2001", None], freq="D")
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- result = arr.astype(np.int64, copy=False)
+ result = arr.astype(np.int64, copy=False)
# Add the `.base`, since we now use `.asi8` which returns a view.
# We could maybe override it in PeriodArray to return ._data directly.
assert result.base is arr._data
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- result = arr.astype(np.int64, copy=True)
+ result = arr.astype(np.int64, copy=True)
assert result is not arr._data
tm.assert_numpy_array_equal(result, arr._data.view("i8"))
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index d905c55c4553a..73b4e7c19dc2e 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -77,18 +77,13 @@ def test_astype_copies(self, dtype, other):
@pytest.mark.parametrize("dtype", [int, np.int32, np.int64, "uint32", "uint64"])
def test_astype_int(self, dtype):
arr = DatetimeArray._from_sequence([pd.Timestamp("2000"), pd.Timestamp("2001")])
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- result = arr.astype(dtype)
+ result = arr.astype(dtype)
if np.dtype(dtype).kind == "u":
expected_dtype = np.dtype("uint64")
else:
expected_dtype = np.dtype("int64")
-
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- expected = arr.astype(expected_dtype)
+ expected = arr.astype(expected_dtype)
assert result.dtype == expected_dtype
tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
index 6b6f677cbf7e8..1db0f6ad56ce3 100644
--- a/pandas/tests/arrays/test_timedeltas.py
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -11,18 +11,13 @@ class TestTimedeltaArray:
@pytest.mark.parametrize("dtype", [int, np.int32, np.int64, "uint32", "uint64"])
def test_astype_int(self, dtype):
arr = TimedeltaArray._from_sequence([Timedelta("1H"), Timedelta("2H")])
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- result = arr.astype(dtype)
+ result = arr.astype(dtype)
if np.dtype(dtype).kind == "u":
expected_dtype = np.dtype("uint64")
else:
expected_dtype = np.dtype("int64")
-
- with tm.assert_produces_warning(FutureWarning):
- # astype(int..) deprecated
- expected = arr.astype(expected_dtype)
+ expected = arr.astype(expected_dtype)
assert result.dtype == expected_dtype
tm.assert_numpy_array_equal(result, expected)
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index e2c5f893b6a2c..4023ed4b444dc 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -743,9 +743,7 @@ def test_astype_nansafe(val, typ):
msg = "Cannot convert NaT values to integer"
with pytest.raises(ValueError, match=msg):
- with tm.assert_produces_warning(FutureWarning):
- # datetimelike astype(int64) deprecated
- astype_nansafe(arr, dtype=typ)
+ astype_nansafe(arr, dtype=typ)
def test_astype_nansafe_copy_false(any_int_numpy_dtype):
diff --git a/pandas/tests/indexes/datetimes/methods/test_astype.py b/pandas/tests/indexes/datetimes/methods/test_astype.py
index 64b57767b155b..9002371f25012 100644
--- a/pandas/tests/indexes/datetimes/methods/test_astype.py
+++ b/pandas/tests/indexes/datetimes/methods/test_astype.py
@@ -32,8 +32,7 @@ def test_astype(self):
)
tm.assert_index_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning):
- result = idx.astype(int)
+ result = idx.astype(int)
expected = Int64Index(
[1463356800000000000] + [-9223372036854775808] * 3,
dtype=np.int64,
@@ -42,8 +41,7 @@ def test_astype(self):
tm.assert_index_equal(result, expected)
rng = date_range("1/1/2000", periods=10, name="idx")
- with tm.assert_produces_warning(FutureWarning):
- result = rng.astype("i8")
+ result = rng.astype("i8")
tm.assert_index_equal(result, Index(rng.asi8, name="idx"))
tm.assert_numpy_array_equal(result.values, rng.asi8)
@@ -53,9 +51,8 @@ def test_astype_uint(self):
np.array([946684800000000000, 946771200000000000], dtype="uint64"),
name="idx",
)
- with tm.assert_produces_warning(FutureWarning):
- tm.assert_index_equal(arr.astype("uint64"), expected)
- tm.assert_index_equal(arr.astype("uint32"), expected)
+ tm.assert_index_equal(arr.astype("uint64"), expected)
+ tm.assert_index_equal(arr.astype("uint32"), expected)
def test_astype_with_tz(self):
diff --git a/pandas/tests/indexes/interval/test_astype.py b/pandas/tests/indexes/interval/test_astype.py
index bdb9c3f97e798..6d5eda9957f68 100644
--- a/pandas/tests/indexes/interval/test_astype.py
+++ b/pandas/tests/indexes/interval/test_astype.py
@@ -208,13 +208,10 @@ def index(self, request):
@pytest.mark.parametrize("subtype", ["int64", "uint64"])
def test_subtype_integer(self, index, subtype):
dtype = IntervalDtype(subtype, "right")
- with tm.assert_produces_warning(FutureWarning):
- result = index.astype(dtype)
- expected = IntervalIndex.from_arrays(
- index.left.astype(subtype),
- index.right.astype(subtype),
- closed=index.closed,
- )
+ result = index.astype(dtype)
+ expected = IntervalIndex.from_arrays(
+ index.left.astype(subtype), index.right.astype(subtype), closed=index.closed
+ )
tm.assert_index_equal(result, expected)
def test_subtype_float(self, index):
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index 2ada97c0965f6..a71a8f9e34ea9 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -74,21 +74,13 @@ def test_constructor(self, constructor, breaks, closed, name):
)
def test_constructor_dtype(self, constructor, breaks, subtype):
# GH 19262: conversion via dtype parameter
- warn = None
- if subtype == "int64" and breaks.dtype.kind in ["M", "m"]:
- # astype(int64) deprecated
- warn = FutureWarning
-
- with tm.assert_produces_warning(warn):
- expected_kwargs = self.get_kwargs_from_breaks(breaks.astype(subtype))
+ expected_kwargs = self.get_kwargs_from_breaks(breaks.astype(subtype))
expected = constructor(**expected_kwargs)
result_kwargs = self.get_kwargs_from_breaks(breaks)
iv_dtype = IntervalDtype(subtype, "right")
for dtype in (iv_dtype, str(iv_dtype)):
- with tm.assert_produces_warning(warn):
-
- result = constructor(dtype=dtype, **result_kwargs)
+ result = constructor(dtype=dtype, **result_kwargs)
tm.assert_index_equal(result, expected)
@pytest.mark.parametrize(
diff --git a/pandas/tests/indexes/period/methods/test_astype.py b/pandas/tests/indexes/period/methods/test_astype.py
index e2340a2db02f7..c3ea72c908459 100644
--- a/pandas/tests/indexes/period/methods/test_astype.py
+++ b/pandas/tests/indexes/period/methods/test_astype.py
@@ -39,8 +39,7 @@ def test_astype_conversion(self):
)
tm.assert_index_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning):
- result = idx.astype(np.int64)
+ result = idx.astype(np.int64)
expected = Int64Index(
[16937] + [-9223372036854775808] * 3, dtype=np.int64, name="idx"
)
@@ -51,17 +50,15 @@ def test_astype_conversion(self):
tm.assert_index_equal(result, expected)
idx = period_range("1990", "2009", freq="A", name="idx")
- with tm.assert_produces_warning(FutureWarning):
- result = idx.astype("i8")
+ result = idx.astype("i8")
tm.assert_index_equal(result, Index(idx.asi8, name="idx"))
tm.assert_numpy_array_equal(result.values, idx.asi8)
def test_astype_uint(self):
arr = period_range("2000", periods=2, name="idx")
expected = UInt64Index(np.array([10957, 10958], dtype="uint64"), name="idx")
- with tm.assert_produces_warning(FutureWarning):
- tm.assert_index_equal(arr.astype("uint64"), expected)
- tm.assert_index_equal(arr.astype("uint32"), expected)
+ tm.assert_index_equal(arr.astype("uint64"), expected)
+ tm.assert_index_equal(arr.astype("uint32"), expected)
def test_astype_object(self):
idx = PeriodIndex([], freq="M")
diff --git a/pandas/tests/indexes/test_common.py b/pandas/tests/indexes/test_common.py
index 30db35525903c..5fb9673cf52d7 100644
--- a/pandas/tests/indexes/test_common.py
+++ b/pandas/tests/indexes/test_common.py
@@ -10,10 +10,7 @@
from pandas.compat import IS64
-from pandas.core.dtypes.common import (
- is_integer_dtype,
- needs_i8_conversion,
-)
+from pandas.core.dtypes.common import is_integer_dtype
import pandas as pd
from pandas import (
@@ -383,10 +380,7 @@ def test_astype_preserves_name(self, index, dtype):
index.name = "idx"
warn = None
- if dtype in ["int64", "uint64"]:
- if needs_i8_conversion(index.dtype):
- warn = FutureWarning
- elif (
+ if (
isinstance(index, DatetimeIndex)
and index.tz is not None
and dtype == "datetime64[ns]"
diff --git a/pandas/tests/indexes/timedeltas/methods/test_astype.py b/pandas/tests/indexes/timedeltas/methods/test_astype.py
index 401b4feef2811..276b0dbf246cc 100644
--- a/pandas/tests/indexes/timedeltas/methods/test_astype.py
+++ b/pandas/tests/indexes/timedeltas/methods/test_astype.py
@@ -58,8 +58,7 @@ def test_astype(self):
)
tm.assert_index_equal(result, expected)
- with tm.assert_produces_warning(FutureWarning):
- result = idx.astype(int)
+ result = idx.astype(int)
expected = Int64Index(
[100000000000000] + [-9223372036854775808] * 3, dtype=np.int64, name="idx"
)
@@ -70,8 +69,7 @@ def test_astype(self):
tm.assert_index_equal(result, expected)
rng = timedelta_range("1 days", periods=10)
- with tm.assert_produces_warning(FutureWarning):
- result = rng.astype("i8")
+ result = rng.astype("i8")
tm.assert_index_equal(result, Index(rng.asi8))
tm.assert_numpy_array_equal(rng.asi8, result.values)
@@ -80,9 +78,8 @@ def test_astype_uint(self):
expected = UInt64Index(
np.array([3600000000000, 90000000000000], dtype="uint64")
)
- with tm.assert_produces_warning(FutureWarning):
- tm.assert_index_equal(arr.astype("uint64"), expected)
- tm.assert_index_equal(arr.astype("uint32"), expected)
+ tm.assert_index_equal(arr.astype("uint64"), expected)
+ tm.assert_index_equal(arr.astype("uint32"), expected)
def test_astype_timedelta64(self):
# GH 13149, GH 13209
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index a5ba684a37edf..26e46e9f38b9b 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -540,9 +540,6 @@ def test_astype(self, t):
# coerce all
mgr = create_mgr("c: f4; d: f2; e: f8")
- warn = FutureWarning if t == "int64" else None
- # datetimelike.astype(int64) deprecated
-
t = np.dtype(t)
tmgr = mgr.astype(t)
assert tmgr.iget(0).dtype.type == t
@@ -553,8 +550,7 @@ def test_astype(self, t):
mgr = create_mgr("a,b: object; c: bool; d: datetime; e: f4; f: f2; g: f8")
t = np.dtype(t)
- with tm.assert_produces_warning(warn):
- tmgr = mgr.astype(t, errors="ignore")
+ tmgr = mgr.astype(t, errors="ignore")
assert tmgr.iget(2).dtype.type == t
assert tmgr.iget(4).dtype.type == t
assert tmgr.iget(5).dtype.type == t
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 7300b8f03ade6..cab5fd456d69f 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -877,9 +877,7 @@ def test_constructor_dtype_datetime64_10(self):
dts = Series(dates, dtype="datetime64[ns]")
# valid astype
- with tm.assert_produces_warning(FutureWarning):
- # astype(np.int64) deprecated
- dts.astype("int64")
+ dts.astype("int64")
# invalid casting
msg = r"cannot astype a datetimelike from \[datetime64\[ns\]\] to \[int32\]"
@@ -889,10 +887,8 @@ def test_constructor_dtype_datetime64_10(self):
# ints are ok
# we test with np.int64 to get similar results on
# windows / 32-bit platforms
- with tm.assert_produces_warning(FutureWarning):
- # astype(np.int64) deprecated
- result = Series(dts, dtype=np.int64)
- expected = Series(dts.astype(np.int64))
+ result = Series(dts, dtype=np.int64)
+ expected = Series(dts.astype(np.int64))
tm.assert_series_equal(result, expected)
def test_constructor_dtype_datetime64_9(self):
@@ -1403,9 +1399,7 @@ def test_constructor_dtype_timedelta64(self):
assert td.dtype == "timedelta64[ns]"
# valid astype
- with tm.assert_produces_warning(FutureWarning):
- # astype(int64) deprecated
- td.astype("int64")
+ td.astype("int64")
# invalid casting
msg = r"cannot astype a datetimelike from \[timedelta64\[ns\]\] to \[int32\]"
@@ -1531,10 +1525,8 @@ def test_constructor_cant_cast_datetimelike(self, index):
# ints are ok
# we test with np.int64 to get similar results on
# windows / 32-bit platforms
- with tm.assert_produces_warning(FutureWarning):
- # asype(np.int64) deprecated, use .view(np.int64) instead
- result = Series(index, dtype=np.int64)
- expected = Series(index.astype(np.int64))
+ result = Series(index, dtype=np.int64)
+ expected = Series(index.astype(np.int64))
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
| Manual backport of https://github.com/pandas-dev/pandas/pull/45449 | https://api.github.com/repos/pandas-dev/pandas/pulls/45518 | 2022-01-21T07:39:14Z | 2022-01-21T08:56:31Z | 2022-01-21T08:56:31Z | 2022-01-21T09:21:08Z |
DEPR: __array_wrap__ | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 1ae76984484af..de27c4229bd4d 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -145,6 +145,7 @@ Other Deprecations
- Deprecated behavior of :meth:`SparseArray.astype`, :meth:`Series.astype`, and :meth:`DataFrame.astype` with :class:`SparseDtype` when passing a non-sparse ``dtype``. In a future version, this will cast to that non-sparse dtype instead of wrapping it in a :class:`SparseDtype` (:issue:`34457`)
- Deprecated behavior of :meth:`DatetimeIndex.intersection` and :meth:`DatetimeIndex.symmetric_difference` (``union`` behavior was already deprecated in version 1.3.0) with mixed timezones; in a future version both will be cast to UTC instead of object dtype (:issue:`39328`, :issue:`45357`)
- Deprecated :meth:`DataFrame.iteritems`, :meth:`Series.iteritems`, :meth:`HDFStore.iteritems` in favor of :meth:`DataFrame.items`, :meth:`Series.items`, :meth:`HDFStore.items` (:issue:`45321`)
+- Deprecated the ``__array_wrap__`` method of DataFrame and Series, rely on standard numpy ufuncs instead (:issue:`45451`)
-
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index b8a7864a3a7e0..ac78a163a6f89 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -2075,6 +2075,12 @@ def __array_wrap__(
Series implements __array_ufunc_ so this not called for ufunc on Series.
"""
# Note: at time of dask 2022.01.0, this is still used by dask
+ warnings.warn(
+ "The __array_wrap__ method of DataFrame and Series will be removed in "
+ "a future version",
+ DeprecationWarning,
+ stacklevel=2,
+ )
res = lib.item_from_zerodim(result)
if is_scalar(res):
# e.g. we get here with np.ptp(series)
diff --git a/pandas/tests/base/test_misc.py b/pandas/tests/base/test_misc.py
index 153981f459ab2..72fb9a9d6b7a2 100644
--- a/pandas/tests/base/test_misc.py
+++ b/pandas/tests/base/test_misc.py
@@ -89,7 +89,8 @@ def test_array_wrap_compat():
# (https://github.com/dask/dask/issues/8580).
# This test is a small dummy ensuring coverage
orig = Series([1, 2, 3], dtype="int64", index=["a", "b", "c"])
- result = orig.__array_wrap__(np.array([2, 4, 6], dtype="int64"))
+ with tm.assert_produces_warning(DeprecationWarning):
+ result = orig.__array_wrap__(np.array([2, 4, 6], dtype="int64"))
expected = orig * 2
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/test_downstream.py b/pandas/tests/test_downstream.py
index 0ec5745fcea92..b843a92850250 100644
--- a/pandas/tests/test_downstream.py
+++ b/pandas/tests/test_downstream.py
@@ -56,6 +56,7 @@ def test_dask(df):
@pytest.mark.filterwarnings("ignore:.*64Index is deprecated:FutureWarning")
+@pytest.mark.filterwarnings("ignore:The __array_wrap__:DeprecationWarning")
def test_dask_ufunc():
# At the time of dask 2022.01.0, dask is still directly using __array_wrap__
# for some ufuncs (https://github.com/dask/dask/issues/8580).
| Follow-up on https://github.com/pandas-dev/pandas/pull/45451 to deprecate the method, so we can actually remove it again in the future. | https://api.github.com/repos/pandas-dev/pandas/pulls/45517 | 2022-01-21T07:32:25Z | 2022-01-21T21:50:05Z | 2022-01-21T21:50:05Z | 2022-01-22T09:06:41Z |
get_dummies to select string dtype in addition to object and categorical | diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index 1ae76984484af..2843ee7551780 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -247,6 +247,7 @@ Groupby/resample/rolling
Reshaping
^^^^^^^^^
- Bug in :func:`concat` between a :class:`Series` with integer dtype and another with :class:`CategoricalDtype` with integer categories and containing ``NaN`` values casting to object dtype instead of ``float64`` (:issue:`45359`)
+- Bug in :func:`get_dummies` that selected object and categorical dtypes but not string (:issue:`44965`)
-
Sparse
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index 75f005489785a..965bd46baa7c7 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -838,7 +838,7 @@ def get_dummies(
columns : list-like, default None
Column names in the DataFrame to be encoded.
If `columns` is None then all the columns with
- `object` or `category` dtype will be converted.
+ `object`, `string`, or `category` dtype will be converted.
sparse : bool, default False
Whether the dummy-encoded columns should be backed by
a :class:`SparseArray` (True) or a regular NumPy array (False).
@@ -915,7 +915,7 @@ def get_dummies(
"""
from pandas.core.reshape.concat import concat
- dtypes_to_encode = ["object", "category"]
+ dtypes_to_encode = ["object", "string", "category"]
if isinstance(data, DataFrame):
# determine columns being encoded
diff --git a/pandas/tests/reshape/test_get_dummies.py b/pandas/tests/reshape/test_get_dummies.py
index 653ea88ed62ac..6c9a60caaa2be 100644
--- a/pandas/tests/reshape/test_get_dummies.py
+++ b/pandas/tests/reshape/test_get_dummies.py
@@ -196,6 +196,22 @@ def test_dataframe_dummies_all_obj(self, df, sparse):
tm.assert_frame_equal(result, expected)
+ def test_dataframe_dummies_string_dtype(self, df):
+ # GH44965
+ df = df[["A", "B"]]
+ df = df.astype({"A": "object", "B": "string"})
+ result = get_dummies(df)
+ expected = DataFrame(
+ {
+ "A_a": [1, 0, 1],
+ "A_b": [0, 1, 0],
+ "B_b": [1, 1, 0],
+ "B_c": [0, 0, 1],
+ },
+ dtype=np.uint8,
+ )
+ tm.assert_frame_equal(result, expected)
+
def test_dataframe_dummies_mix_default(self, df, sparse, dtype):
result = get_dummies(df, sparse=sparse, dtype=dtype)
if sparse:
| - [x] closes #44965
- [x] tests added / passed
- [x] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/45516 | 2022-01-21T04:32:01Z | 2022-01-28T02:21:00Z | 2022-01-28T02:21:00Z | 2022-03-02T01:13:02Z |
ENH: ExtensionEngine | diff --git a/pandas/_libs/index.pyi b/pandas/_libs/index.pyi
index 446a980487cde..86f2429575ebb 100644
--- a/pandas/_libs/index.pyi
+++ b/pandas/_libs/index.pyi
@@ -3,6 +3,7 @@ import numpy as np
from pandas._typing import npt
from pandas import MultiIndex
+from pandas.core.arrays import ExtensionArray
class IndexEngine:
over_size_threshold: bool
@@ -63,3 +64,21 @@ class BaseMultiIndexCodesEngine:
method: str,
limit: int | None,
) -> npt.NDArray[np.intp]: ...
+
+class ExtensionEngine:
+ def __init__(self, values: "ExtensionArray"): ...
+ def __contains__(self, val: object) -> bool: ...
+ def get_loc(self, val: object) -> int | slice | np.ndarray: ...
+ def get_indexer(self, values: np.ndarray) -> npt.NDArray[np.intp]: ...
+ def get_indexer_non_unique(
+ self,
+ targets: np.ndarray,
+ ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+ @property
+ def is_unique(self) -> bool: ...
+ @property
+ def is_monotonic_increasing(self) -> bool: ...
+ @property
+ def is_monotonic_decreasing(self) -> bool: ...
+ def sizeof(self, deep: bool = ...) -> int: ...
+ def clear_mapping(self): ...
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index c3b86165e6d2c..fe8e8d92f699a 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -797,3 +797,274 @@ cdef class BaseMultiIndexCodesEngine:
# Generated from template.
include "index_class_helper.pxi"
+
+
+@cython.internal
+@cython.freelist(32)
+cdef class SharedEngine:
+ cdef readonly:
+ object values # ExtensionArray
+ bint over_size_threshold
+
+ cdef:
+ bint unique, monotonic_inc, monotonic_dec
+ bint need_monotonic_check, need_unique_check
+
+ def __contains__(self, val: object) -> bool:
+ # We assume before we get here:
+ # - val is hashable
+ try:
+ self.get_loc(val)
+ return True
+ except KeyError:
+ return False
+
+ def clear_mapping(self):
+ # for compat with IndexEngine
+ pass
+
+ @property
+ def is_unique(self) -> bool:
+ if self.need_unique_check:
+ arr = self.values.unique()
+ self.unique = len(arr) == len(self.values)
+
+ self.need_unique_check = False
+ return self.unique
+
+ cdef _do_monotonic_check(self):
+ raise NotImplementedError
+
+ @property
+ def is_monotonic_increasing(self) -> bool:
+ if self.need_monotonic_check:
+ self._do_monotonic_check()
+
+ return self.monotonic_inc == 1
+
+ @property
+ def is_monotonic_decreasing(self) -> bool:
+ if self.need_monotonic_check:
+ self._do_monotonic_check()
+
+ return self.monotonic_dec == 1
+
+ cdef _call_monotonic(self, values):
+ return algos.is_monotonic(values, timelike=False)
+
+ def sizeof(self, deep: bool = False) -> int:
+ """ return the sizeof our mapping """
+ return 0
+
+ def __sizeof__(self) -> int:
+ return self.sizeof()
+
+ cdef _check_type(self, object obj):
+ raise NotImplementedError
+
+ cpdef get_loc(self, object val):
+ # -> Py_ssize_t | slice | ndarray[bool]
+ cdef:
+ Py_ssize_t loc
+
+ if is_definitely_invalid_key(val):
+ raise TypeError(f"'{val}' is an invalid key")
+
+ self._check_type(val)
+
+ if self.over_size_threshold and self.is_monotonic_increasing:
+ if not self.is_unique:
+ return self._get_loc_duplicates(val)
+
+ values = self.values
+
+ loc = self._searchsorted_left(val)
+ if loc >= len(values):
+ raise KeyError(val)
+ if values[loc] != val:
+ raise KeyError(val)
+ return loc
+
+ if not self.unique:
+ return self._get_loc_duplicates(val)
+
+ return self._get_loc_duplicates(val)
+
+ cdef inline _get_loc_duplicates(self, object val):
+ # -> Py_ssize_t | slice | ndarray[bool]
+ cdef:
+ Py_ssize_t diff
+
+ if self.is_monotonic_increasing:
+ values = self.values
+ try:
+ left = values.searchsorted(val, side='left')
+ right = values.searchsorted(val, side='right')
+ except TypeError:
+ # e.g. GH#29189 get_loc(None) with a Float64Index
+ raise KeyError(val)
+
+ diff = right - left
+ if diff == 0:
+ raise KeyError(val)
+ elif diff == 1:
+ return left
+ else:
+ return slice(left, right)
+
+ return self._maybe_get_bool_indexer(val)
+
+ cdef Py_ssize_t _searchsorted_left(self, val) except? -1:
+ """
+ See ObjectEngine._searchsorted_left.__doc__.
+ """
+ try:
+ loc = self.values.searchsorted(val, side="left")
+ except TypeError as err:
+ # GH#35788 e.g. val=None with float64 values
+ raise KeyError(val)
+ return loc
+
+ cdef ndarray _get_bool_indexer(self, val):
+ raise NotImplementedError
+
+ cdef _maybe_get_bool_indexer(self, object val):
+ # Returns ndarray[bool] or int
+ cdef:
+ ndarray[uint8_t, ndim=1, cast=True] indexer
+
+ indexer = self._get_bool_indexer(val)
+ return _unpack_bool_indexer(indexer, val)
+
+ def get_indexer(self, values) -> np.ndarray:
+ # values : type(self.values)
+ # Note: we only get here with self.is_unique
+ cdef:
+ Py_ssize_t i, N = len(values)
+
+ res = np.empty(N, dtype=np.intp)
+
+ for i in range(N):
+ val = values[i]
+ try:
+ loc = self.get_loc(val)
+ # Because we are unique, loc should always be an integer
+ except KeyError:
+ loc = -1
+ else:
+ assert util.is_integer_object(loc), (loc, val)
+ res[i] = loc
+
+ return res
+
+ def get_indexer_non_unique(self, targets):
+ """
+ Return an indexer suitable for taking from a non unique index
+ return the labels in the same order as the target
+ and a missing indexer into the targets (which correspond
+ to the -1 indices in the results
+ Parameters
+ ----------
+ targets : type(self.values)
+ Returns
+ -------
+ indexer : np.ndarray[np.intp]
+ missing : np.ndarray[np.intp]
+ """
+ cdef:
+ Py_ssize_t i, N = len(targets)
+
+ indexer = []
+ missing = []
+
+ # See also IntervalIndex.get_indexer_pointwise
+ for i in range(N):
+ val = targets[i]
+
+ try:
+ locs = self.get_loc(val)
+ except KeyError:
+ locs = np.array([-1], dtype=np.intp)
+ missing.append(i)
+ else:
+ if isinstance(locs, slice):
+ # Only needed for get_indexer_non_unique
+ locs = np.arange(locs.start, locs.stop, locs.step, dtype=np.intp)
+ elif util.is_integer_object(locs):
+ locs = np.array([locs], dtype=np.intp)
+ else:
+ assert locs.dtype.kind == "b"
+ locs = locs.nonzero()[0]
+
+ indexer.append(locs)
+
+ try:
+ indexer = np.concatenate(indexer, dtype=np.intp)
+ except TypeError:
+ # numpy<1.20 doesn't accept dtype keyword
+ indexer = np.concatenate(indexer).astype(np.intp, copy=False)
+ missing = np.array(missing, dtype=np.intp)
+
+ return indexer, missing
+
+
+cdef class ExtensionEngine(SharedEngine):
+ def __init__(self, values: "ExtensionArray"):
+ self.values = values
+
+ self.over_size_threshold = len(values) >= _SIZE_CUTOFF
+ self.need_unique_check = True
+ self.need_monotonic_check = True
+ self.need_unique_check = True
+
+ cdef _do_monotonic_check(self):
+ cdef:
+ bint is_unique
+
+ values = self.values
+ if values._hasna:
+ self.monotonic_inc = 0
+ self.monotonic_dec = 0
+
+ nunique = len(values.unique())
+ self.unique = nunique == len(values)
+ self.need_unique_check = 0
+ return
+
+ try:
+ ranks = values._rank()
+
+ except TypeError:
+ self.monotonic_inc = 0
+ self.monotonic_dec = 0
+ is_unique = 0
+ else:
+ self.monotonic_inc, self.monotonic_dec, is_unique = \
+ self._call_monotonic(ranks)
+
+ self.need_monotonic_check = 0
+
+ # we can only be sure of uniqueness if is_unique=1
+ if is_unique:
+ self.unique = 1
+ self.need_unique_check = 0
+
+ cdef ndarray _get_bool_indexer(self, val):
+ if checknull(val):
+ return self.values.isna().view("uint8")
+
+ try:
+ return self.values == val
+ except TypeError:
+ # e.g. if __eq__ returns a BooleanArray instead of ndarry[bool]
+ try:
+ return (self.values == val).to_numpy(dtype=bool, na_value=False)
+ except (TypeError, AttributeError) as err:
+ # e.g. (self.values == val) returned a bool
+ # see test_get_loc_generator[string[pyarrow]]
+ # e.g. self.value == val raises TypeError bc generator has no len
+ # see test_get_loc_generator[string[python]]
+ raise KeyError from err
+
+ cdef _check_type(self, object val):
+ hash(val)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 26ddf89adaea2..e0bd548eff70a 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -144,7 +144,6 @@
tz_to_dtype,
validate_tz_from_dtype,
)
-from pandas.core.arrays.masked import BaseMaskedArray
from pandas.core.arrays.sparse import SparseDtype
from pandas.core.base import (
IndexOpsMixin,
@@ -329,6 +328,9 @@ def _left_indexer_unique(self: _IndexT, other: _IndexT) -> npt.NDArray[np.intp]:
# Caller is responsible for ensuring other.dtype == self.dtype
sv = self._get_engine_target()
ov = other._get_engine_target()
+ # can_use_libjoin assures sv and ov are ndarrays
+ sv = cast(np.ndarray, sv)
+ ov = cast(np.ndarray, ov)
return libjoin.left_join_indexer_unique(sv, ov)
@final
@@ -338,6 +340,9 @@ def _left_indexer(
# Caller is responsible for ensuring other.dtype == self.dtype
sv = self._get_engine_target()
ov = other._get_engine_target()
+ # can_use_libjoin assures sv and ov are ndarrays
+ sv = cast(np.ndarray, sv)
+ ov = cast(np.ndarray, ov)
joined_ndarray, lidx, ridx = libjoin.left_join_indexer(sv, ov)
joined = self._from_join_target(joined_ndarray)
return joined, lidx, ridx
@@ -349,6 +354,9 @@ def _inner_indexer(
# Caller is responsible for ensuring other.dtype == self.dtype
sv = self._get_engine_target()
ov = other._get_engine_target()
+ # can_use_libjoin assures sv and ov are ndarrays
+ sv = cast(np.ndarray, sv)
+ ov = cast(np.ndarray, ov)
joined_ndarray, lidx, ridx = libjoin.inner_join_indexer(sv, ov)
joined = self._from_join_target(joined_ndarray)
return joined, lidx, ridx
@@ -360,6 +368,9 @@ def _outer_indexer(
# Caller is responsible for ensuring other.dtype == self.dtype
sv = self._get_engine_target()
ov = other._get_engine_target()
+ # can_use_libjoin assures sv and ov are ndarrays
+ sv = cast(np.ndarray, sv)
+ ov = cast(np.ndarray, ov)
joined_ndarray, lidx, ridx = libjoin.outer_join_indexer(sv, ov)
joined = self._from_join_target(joined_ndarray)
return joined, lidx, ridx
@@ -387,7 +398,9 @@ def _outer_indexer(
# associated code in pandas 2.0.
_is_backward_compat_public_numeric_index: bool = False
- _engine_type: type[libindex.IndexEngine] = libindex.ObjectEngine
+ _engine_type: type[libindex.IndexEngine] | type[
+ libindex.ExtensionEngine
+ ] = libindex.ObjectEngine
# whether we support partial string indexing. Overridden
# in DatetimeIndex and PeriodIndex
_supports_partial_string_indexing = False
@@ -850,23 +863,21 @@ def _cleanup(self) -> None:
@cache_readonly
def _engine(
self,
- ) -> libindex.IndexEngine:
+ ) -> libindex.IndexEngine | libindex.ExtensionEngine:
# For base class (object dtype) we get ObjectEngine
-
- if isinstance(self._values, BaseMaskedArray):
- # TODO(ExtensionIndex): use libindex.NullableEngine(self._values)
- return libindex.ObjectEngine(self._get_engine_target())
- elif (
- isinstance(self._values, ExtensionArray)
+ target_values = self._get_engine_target()
+ if (
+ isinstance(target_values, ExtensionArray)
and self._engine_type is libindex.ObjectEngine
):
- # TODO(ExtensionIndex): use libindex.ExtensionEngine(self._values)
- return libindex.ObjectEngine(self._get_engine_target())
+ return libindex.ExtensionEngine(target_values)
# to avoid a reference cycle, bind `target_values` to a local variable, so
# `self` is not passed into the lambda.
- target_values = self._get_engine_target()
- return self._engine_type(target_values)
+ target_values = cast(np.ndarray, target_values)
+ # error: Argument 1 to "ExtensionEngine" has incompatible type
+ # "ndarray[Any, Any]"; expected "ExtensionArray"
+ return self._engine_type(target_values) # type:ignore[arg-type]
@final
@cache_readonly
@@ -3322,12 +3333,6 @@ def _wrap_setop_result(self, other: Index, result) -> Index:
result = result.rename(name)
else:
result = self._shallow_copy(result, name=name)
-
- if type(self) is Index and self.dtype != _dtype_obj:
- # i.e. ExtensionArray-backed
- # TODO(ExtensionIndex): revert this astype; it is a kludge to make
- # it possible to split ExtensionEngine from ExtensionIndex PR.
- return result.astype(self.dtype, copy=False)
return result
@final
@@ -3874,12 +3879,16 @@ def _get_indexer(
tgt_values = target._get_engine_target()
if target._is_multi and self._is_multi:
engine = self._engine
- # error: "IndexEngine" has no attribute "_extract_level_codes"
- tgt_values = engine._extract_level_codes( # type: ignore[attr-defined]
+ # error: Item "IndexEngine" of "Union[IndexEngine, ExtensionEngine]"
+ # has no attribute "_extract_level_codes"
+ tgt_values = engine._extract_level_codes( # type: ignore[union-attr]
target
)
- indexer = self._engine.get_indexer(tgt_values)
+ # error: Argument 1 to "get_indexer" of "IndexEngine" has incompatible
+ # type "Union[ExtensionArray, ndarray[Any, Any]]"; expected
+ # "ndarray[Any, Any]"
+ indexer = self._engine.get_indexer(tgt_values) # type:ignore[arg-type]
return ensure_platform_int(indexer)
@@ -3955,13 +3964,18 @@ def _get_fill_indexer(
# TODO: get_indexer_with_fill docstring says values must be _sorted_
# but that doesn't appear to be enforced
# error: "IndexEngine" has no attribute "get_indexer_with_fill"
- return self._engine.get_indexer_with_fill( # type: ignore[attr-defined]
+ engine = self._engine
+ return engine.get_indexer_with_fill( # type: ignore[union-attr]
target=target._values, values=self._values, method=method, limit=limit
)
if self.is_monotonic_increasing and target.is_monotonic_increasing:
target_values = target._get_engine_target()
own_values = self._get_engine_target()
+ if not isinstance(target_values, np.ndarray) or not isinstance(
+ own_values, np.ndarray
+ ):
+ raise NotImplementedError
if method == "pad":
indexer = libalgos.pad(own_values, target_values, limit=limit)
@@ -4889,8 +4903,9 @@ def _can_use_libjoin(self) -> bool:
"""
Whether we can use the fastpaths implement in _libs.join
"""
- # Note: this will need to be updated when e.g. Nullable dtypes
- # are supported in Indexes.
+ if type(self) is Index:
+ # excludes EAs
+ return isinstance(self.dtype, np.dtype)
return not is_interval_dtype(self.dtype)
# --------------------------------------------------------------------
@@ -4956,16 +4971,12 @@ def _values(self) -> ExtensionArray | np.ndarray:
"""
return self._data
- def _get_engine_target(self) -> np.ndarray:
+ def _get_engine_target(self) -> ArrayLike:
"""
- Get the ndarray that we can pass to the IndexEngine constructor.
+ Get the ndarray or ExtensionArray that we can pass to the IndexEngine
+ constructor.
"""
- # error: Incompatible return value type (got "Union[ExtensionArray,
- # ndarray]", expected "ndarray")
- if type(self) is Index and isinstance(self._values, ExtensionArray):
- # TODO(ExtensionIndex): remove special-case, just use self._values
- return self._values.astype(object)
- return self._values # type: ignore[return-value]
+ return self._values
def _from_join_target(self, result: np.ndarray) -> ArrayLike:
"""
@@ -5854,10 +5865,9 @@ def get_indexer_non_unique(
tgt_values = target._get_engine_target()
if self._is_multi and target._is_multi:
engine = self._engine
- # error: "IndexEngine" has no attribute "_extract_level_codes"
- tgt_values = engine._extract_level_codes( # type: ignore[attr-defined]
- target
- )
+ # Item "IndexEngine" of "Union[IndexEngine, ExtensionEngine]" has
+ # no attribute "_extract_level_codes"
+ tgt_values = engine._extract_level_codes(target) # type: ignore[union-attr]
indexer, missing = self._engine.get_indexer_non_unique(tgt_values)
return ensure_platform_int(indexer), ensure_platform_int(missing)
| Follow-up on https://github.com/pandas-dev/pandas/pull/43930/
Avoid object-dtype cast.
Next/last PR in this sequence introduces NullableEngine. | https://api.github.com/repos/pandas-dev/pandas/pulls/45514 | 2022-01-20T21:19:54Z | 2022-01-25T17:31:24Z | 2022-01-25T17:31:24Z | 2022-01-31T13:01:14Z |
Test to datetime null to NaT | diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 5f8e0b4f70ec4..1e05603f704a7 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -1066,6 +1066,33 @@ def test_convert_object_to_datetime_with_cache(
)
tm.assert_series_equal(result_series, expected_series)
+ @pytest.mark.parametrize("cache", [True, False])
+ @pytest.mark.parametrize(
+ ("input", "expected"),
+ (
+ (
+ Series([NaT] * 20 + [None] * 20, dtype="object"), # type: ignore[list-item] # noqa: E501
+ Series([NaT] * 40, dtype="datetime64[ns]"),
+ ),
+ (
+ Series([NaT] * 60 + [None] * 60, dtype="object"), # type: ignore[list-item] # noqa: E501
+ Series([NaT] * 120, dtype="datetime64[ns]"),
+ ),
+ (Series([None] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+ (Series([None] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+ (Series([""] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+ (Series([""] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+ (Series([pd.NA] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+ (Series([pd.NA] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+ (Series([np.NaN] * 20), Series([NaT] * 20, dtype="datetime64[ns]")),
+ (Series([np.NaN] * 60), Series([NaT] * 60, dtype="datetime64[ns]")),
+ ),
+ )
+ def test_to_datetime_converts_null_like_to_nat(self, cache, input, expected):
+ # GH35888
+ result = to_datetime(input, cache=cache)
+ tm.assert_series_equal(result, expected)
+
@pytest.mark.parametrize(
"date, format",
[
| - [x] closes #35888
- [x] tests added / passed
- [ ] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/45512 | 2022-01-20T20:42:50Z | 2022-02-01T00:34:52Z | 2022-02-01T00:34:51Z | 2022-02-01T00:34:55Z |
on branch 1.4.x: follow up to #45450 and #45120 manual backports | diff --git a/ci/deps/actions-38.yaml b/ci/deps/actions-38.yaml
index 60db02def8a3d..b23f686d845e9 100644
--- a/ci/deps/actions-38.yaml
+++ b/ci/deps/actions-38.yaml
@@ -36,7 +36,7 @@ dependencies:
- psycopg2
- pymysql
- pytables
- - pyarrow
+ - pyarrow=3
- pyreadstat
- pyxlsb
- s3fs
diff --git a/ci/deps/azure-macos-39.yaml b/ci/deps/azure-macos-39.yaml
index a0860ef536953..140d67796452c 100644
--- a/ci/deps/azure-macos-39.yaml
+++ b/ci/deps/azure-macos-39.yaml
@@ -23,7 +23,7 @@ dependencies:
- numexpr
- numpy=1.21.3
- openpyxl
- - pyarrow=1.0.1
+ - pyarrow=4
- pyreadstat
- pytables
- python-dateutil==2.8.1
| xref #45450 and #45464 | https://api.github.com/repos/pandas-dev/pandas/pulls/45511 | 2022-01-20T20:18:35Z | 2022-01-21T00:38:26Z | 2022-01-21T00:38:26Z | 2022-01-21T09:08:58Z |
Backport PR #45257 on branch 1.4.x (CI: Simplify GHA dependency files) | diff --git a/ci/deps/actions-39.yaml b/ci/deps/actions-39.yaml
index 0019360d39ec9..631ef40b02e33 100644
--- a/ci/deps/actions-39.yaml
+++ b/ci/deps/actions-39.yaml
@@ -4,37 +4,47 @@ channels:
dependencies:
- python=3.9
- # tools
- - cython>=0.29.24
+ # test dependencies
+ - cython=0.29.24
- pytest>=6.0
- pytest-cov
- pytest-xdist>=1.31
- hypothesis>=5.5.3
+ - psutil
- # pandas dependencies
+ # required dependencies
+ - python-dateutil
+ - numpy
+ - pytz
+
+ # optional dependencies
- beautifulsoup4
+ - blosc
- bottleneck
- - boto3
- - fsspec>=0.8.0
- - gcsfs
+ - fastparquet
+ - fsspec
- html5lib
+ - gcsfs
- jinja2
- lxml
- matplotlib
- - numpy # move up to solve before numba
- numba
- numexpr
- openpyxl
- - pyarrow=5
+ - odfpy
+ - pandas-gbq
+ - psycopg2
+ - pymysql
- pytables
- - python-dateutil
- - pytz
- - s3fs>=0.4.2
+ - pyarrow=5
+ - pyreadstat
+ - pyxlsb
+ - s3fs
- scipy
- sqlalchemy
+ - tabulate
+ - xarray
- xlrd
- xlsxwriter
- xlwt
- - pyreadstat
- - pyxlsb
- zstandard
| Backport PR #45257 | https://api.github.com/repos/pandas-dev/pandas/pulls/45510 | 2022-01-20T20:01:19Z | 2022-01-21T00:37:46Z | 2022-01-21T00:37:46Z | 2022-01-21T09:09:32Z |
TST: Add test inconsistency in group by (#44803) | diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index fb2b9f0632f0d..03c09112be1fe 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -32,6 +32,20 @@
from pandas.core.groupby.base import maybe_normalize_deprecated_kernels
+def test_group_by_copy():
+ # GH#44803
+ df = DataFrame(
+ {
+ "name": ["Alice", "Bob", "Carl"],
+ "age": [20, 21, 20],
+ }
+ ).set_index("name")
+
+ grp_by_same_value = df.groupby(["age"]).apply(lambda group: group)
+ grp_by_copy = df.groupby(["age"]).apply(lambda group: group.copy())
+ tm.assert_frame_equal(grp_by_same_value, grp_by_copy)
+
+
def test_repr():
# GH18203
result = repr(Grouper(key="A", level="B"))
| - [X] closes #44803
- [X] tests added / passed
- [X] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
| https://api.github.com/repos/pandas-dev/pandas/pulls/45509 | 2022-01-20T19:49:56Z | 2022-01-23T00:07:41Z | 2022-01-23T00:07:40Z | 2022-01-23T22:57:18Z |
Backport PR #45355 on branch 1.4.x (CI: Ensure GHA uses major versions of actions) | diff --git a/.github/workflows/asv-bot.yml b/.github/workflows/asv-bot.yml
index ad2e2b4278dd2..f3946aeb84a63 100644
--- a/.github/workflows/asv-bot.yml
+++ b/.github/workflows/asv-bot.yml
@@ -65,7 +65,7 @@ jobs:
echo 'EOF' >> $GITHUB_ENV
echo "REGEX=$REGEX" >> $GITHUB_ENV
- - uses: actions/github-script@v4
+ - uses: actions/github-script@v5
env:
BENCH_OUTPUT: ${{env.BENCH_OUTPUT}}
REGEX: ${{env.REGEX}}
@@ -73,7 +73,7 @@ jobs:
script: |
const ENV_VARS = process.env
const run_url = `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`
- github.issues.createComment({
+ github.rest.issues.createComment({
issue_number: context.issue.number,
owner: context.repo.owner,
repo: context.repo.repo,
diff --git a/.github/workflows/code-checks.yml b/.github/workflows/code-checks.yml
index 838143deafb03..7141b02cac376 100644
--- a/.github/workflows/code-checks.yml
+++ b/.github/workflows/code-checks.yml
@@ -151,7 +151,7 @@ jobs:
if: ${{ steps.build.outcome == 'success' }}
- name: Publish benchmarks artifact
- uses: actions/upload-artifact@master
+ uses: actions/upload-artifact@v2
with:
name: Benchmarks log
path: asv_bench/benchmarks.log
diff --git a/.github/workflows/comment_bot.yml b/.github/workflows/comment_bot.yml
index 24f8d5d0116c5..8f610fd5781ef 100644
--- a/.github/workflows/comment_bot.yml
+++ b/.github/workflows/comment_bot.yml
@@ -13,7 +13,7 @@ jobs:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- - uses: r-lib/actions/pr-fetch@master
+ - uses: r-lib/actions/pr-fetch@v2
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
- name: Cache multiple paths
@@ -35,6 +35,6 @@ jobs:
git config user.name "$(git log -1 --pretty=format:%an)"
git config user.email "$(git log -1 --pretty=format:%ae)"
git commit -a -m 'Fixes from pre-commit [automated commit]' || echo "No changes to commit"
- - uses: r-lib/actions/pr-push@master
+ - uses: r-lib/actions/pr-push@v2
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/posix.yml b/.github/workflows/posix.yml
index f7600a712922d..135ca0703de8b 100644
--- a/.github/workflows/posix.yml
+++ b/.github/workflows/posix.yml
@@ -122,7 +122,7 @@ jobs:
if: ${{ env.IS_PYPY == 'false' }} # No pypy3.8 support
- name: Setup PyPy
- uses: actions/setup-python@v2.3.1
+ uses: actions/setup-python@v2
with:
python-version: "pypy-3.8"
if: ${{ env.IS_PYPY == 'true' }}
@@ -148,7 +148,7 @@ jobs:
run: pushd /tmp && python -c "import pandas; pandas.show_versions();" && popd
- name: Publish test results
- uses: actions/upload-artifact@master
+ uses: actions/upload-artifact@v2
with:
name: Test results
path: test-data.xml
diff --git a/.github/workflows/python-dev.yml b/.github/workflows/python-dev.yml
index 5803e6351231b..fa1eee2db6fc3 100644
--- a/.github/workflows/python-dev.yml
+++ b/.github/workflows/python-dev.yml
@@ -79,7 +79,7 @@ jobs:
ci/run_tests.sh
- name: Publish test results
- uses: actions/upload-artifact@master
+ uses: actions/upload-artifact@v2
with:
name: Test results
path: test-data.xml
| Backport PR #45355: CI: Ensure GHA uses major versions of actions | https://api.github.com/repos/pandas-dev/pandas/pulls/45508 | 2022-01-20T19:37:59Z | 2022-01-21T00:37:29Z | 2022-01-21T00:37:29Z | 2022-01-21T00:37:29Z |
CI: Troubleshoot | diff --git a/pandas/tests/io/parser/test_unsupported.py b/pandas/tests/io/parser/test_unsupported.py
index 0d383cc4bde8f..e223378b600e0 100644
--- a/pandas/tests/io/parser/test_unsupported.py
+++ b/pandas/tests/io/parser/test_unsupported.py
@@ -12,6 +12,7 @@
import pytest
+from pandas.compat import is_platform_windows
from pandas.errors import ParserError
import pandas._testing as tm
@@ -173,6 +174,9 @@ def test_close_file_handle_on_invalide_usecols(all_parsers):
if parser.engine == "pyarrow":
pyarrow = pytest.importorskip("pyarrow")
error = pyarrow.lib.ArrowKeyError
+ if is_platform_windows():
+ # GH#45547 causes timeouts on windows builds
+ pytest.skip("GH#45547 causing timeouts on windows builds 2022-01-22")
with tm.ensure_clean("test.csv") as fname:
Path(fname).write_text("col1,col2\na,b\n1,2")
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] Ensure all linting tests pass, see [here](https://pandas.pydata.org/pandas-docs/dev/development/contributing_codebase.html#pre-commit) for how to run them
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/45507 | 2022-01-20T19:35:57Z | 2022-01-22T22:34:49Z | 2022-01-22T22:34:49Z | 2022-01-22T23:41:50Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.