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 |
|---|---|---|---|---|---|---|---|
ENH: implement EA.size | diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index b5da6d4c11616..6aa303dd04703 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -407,6 +407,13 @@ def shape(self) -> Tuple[int, ...]:
"""
return (len(self),)
+ @property
+ def size(self) -> int:
+ """
+ The number of elements in the array.
+ """
+ return np.prod(self.shape)
+
@property
def ndim(self) -> int:
"""
diff --git a/pandas/tests/extension/base/interface.py b/pandas/tests/extension/base/interface.py
index cdea96334be2a..95fb3d7439b56 100644
--- a/pandas/tests/extension/base/interface.py
+++ b/pandas/tests/extension/base/interface.py
@@ -19,6 +19,9 @@ class BaseInterfaceTests(BaseExtensionTests):
def test_len(self, data):
assert len(data) == 100
+ def test_size(self, data):
+ assert data.size == 100
+
def test_ndim(self, data):
assert data.ndim == 1
| I was surprised this didnt already exist. | https://api.github.com/repos/pandas-dev/pandas/pulls/32644 | 2020-03-11T23:59:44Z | 2020-03-14T03:17:18Z | 2020-03-14T03:17:18Z | 2020-03-14T17:00:56Z |
CLN: trim unnecessary checks | diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 894e1d95a17bc..7889829516f7f 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -22,7 +22,6 @@
is_list_like,
is_period_dtype,
is_scalar,
- needs_i8_conversion,
)
from pandas.core.dtypes.concat import concat_compat
from pandas.core.dtypes.generic import ABCIndex, ABCIndexClass, ABCSeries
@@ -484,7 +483,7 @@ def where(self, cond, other=None):
if is_categorical_dtype(other):
# e.g. we have a Categorical holding self.dtype
- if needs_i8_conversion(other.categories):
+ if is_dtype_equal(other.categories.dtype, self.dtype):
other = other._internal_get_values()
if not is_dtype_equal(self.dtype, other.dtype):
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 024d3b205df77..87892a804dac3 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -2284,11 +2284,7 @@ def to_native_types(
return np.atleast_2d(result)
def should_store(self, value) -> bool:
- return (
- issubclass(value.dtype.type, np.datetime64)
- and not is_datetime64tz_dtype(value)
- and not is_extension_array_dtype(value)
- )
+ return is_datetime64_dtype(value.dtype)
def set(self, locs, values):
"""
@@ -2536,9 +2532,7 @@ def fillna(self, value, **kwargs):
return super().fillna(value, **kwargs)
def should_store(self, value) -> bool:
- return issubclass(
- value.dtype.type, np.timedelta64
- ) and not is_extension_array_dtype(value)
+ return is_timedelta64_dtype(value.dtype)
def to_native_types(self, slicer=None, na_rep=None, quoting=None, **kwargs):
""" convert to our native types format, slicing if desired """
| https://api.github.com/repos/pandas-dev/pandas/pulls/32643 | 2020-03-11T23:57:12Z | 2020-03-12T02:38:18Z | 2020-03-12T02:38:18Z | 2020-03-12T02:41:44Z | |
fix infer_freq raises section | diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 4af516af8a28e..2477ff29fbfd5 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -249,9 +249,14 @@ def infer_freq(index, warn: bool = True) -> Optional[str]:
Returns
-------
str or None
- None if no discernible frequency
- TypeError if the index is not datetime-like
- ValueError if there are less than three values.
+ None if no discernible frequency.
+
+ Raises
+ ------
+ TypeError
+ If the index is not datetime-like.
+ ValueError
+ If there are fewer than three values.
"""
import pandas as pd
| Fixes the raises section of the `infer_freq` doc string. Seems small enough to skip a whats new entry.
- [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32642 | 2020-03-11T23:39:42Z | 2020-03-12T23:19:23Z | 2020-03-12T23:19:23Z | 2020-03-13T09:43:43Z |
DEPR: Index.ravel behavior | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 83064fe22eaff..e130a6c6cb1b7 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -623,6 +623,12 @@ def ravel(self, order="C"):
--------
numpy.ndarray.ravel
"""
+ warnings.warn(
+ f"The behavior of Index.ravel for {self.dtype} is deprecated; "
+ "in a future version it will return the underlying ExtensionArray",
+ FutureWarning,
+ stacklevel=2,
+ )
values = self._get_engine_target()
return values.ravel(order=order)
diff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py
index 9562582393235..3563eae267e70 100644
--- a/pandas/tests/indexes/categorical/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -645,3 +645,8 @@ def test_reindex_base(self):
def test_map_str(self):
# See test_map.py
pass
+
+ def test_ravel_deprecated(self):
+ idx = self.create_index()
+ with tm.assert_produces_warning(FutureWarning):
+ idx.ravel()
diff --git a/pandas/tests/indexes/datetimelike.py b/pandas/tests/indexes/datetimelike.py
index ba10976a67e9a..0655424d67f95 100644
--- a/pandas/tests/indexes/datetimelike.py
+++ b/pandas/tests/indexes/datetimelike.py
@@ -95,3 +95,8 @@ def test_map_dictlike(self, mapper):
expected = pd.Index([np.nan] * len(index))
result = index.map(mapper([], []))
tm.assert_index_equal(result, expected)
+
+ def test_ravel_deprecated(self):
+ idx = self.create_index()
+ with tm.assert_produces_warning(FutureWarning):
+ idx.ravel()
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index efdd3fc9907a2..d00bc5fdfa17a 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -857,6 +857,11 @@ def test_is_all_dates(self):
year_2017_index = pd.IntervalIndex([year_2017])
assert not year_2017_index.is_all_dates
+ def test_ravel_deprecated(self):
+ idx = self.create_index()
+ with tm.assert_produces_warning(FutureWarning):
+ idx.ravel()
+
def test_dir():
# GH#27571 dir(interval_index) should not raise
| The future behavior should match Series.ravel.
- [x] closes #19956
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32641 | 2020-03-11T23:33:09Z | 2020-03-30T16:54:14Z | null | 2022-11-28T20:05:10Z |
PERF: copy cached attributes on extension index shallow_copy | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index c473500c205d8..52919f966f284 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -89,9 +89,9 @@ Backwards incompatible API changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- :meth:`DataFrame.swaplevels` now raises a ``TypeError`` if the axis is not a :class:`MultiIndex`.
Previously a ``AttributeError`` was raised (:issue:`31126`)
-- :meth:`DataFrameGroupby.mean` and :meth:`SeriesGroupby.mean` (and similarly for :meth:`~DataFrameGroupby.median`, :meth:`~DataFrameGroupby.std`` and :meth:`~DataFrameGroupby.var``)
+- :meth:`DataFrameGroupby.mean` and :meth:`SeriesGroupby.mean` (and similarly for :meth:`~DataFrameGroupby.median`, :meth:`~DataFrameGroupby.std` and :meth:`~DataFrameGroupby.var`)
now raise a ``TypeError`` if a not-accepted keyword argument is passed into it.
- Previously a ``UnsupportedFunctionCall`` was raised (``AssertionError`` if ``min_count`` passed into :meth:`~DataFrameGroupby.median``) (:issue:`31485`)
+ Previously a ``UnsupportedFunctionCall`` was raised (``AssertionError`` if ``min_count`` passed into :meth:`~DataFrameGroupby.median`) (:issue:`31485`)
- :meth:`DataFrame.at` and :meth:`Series.at` will raise a ``TypeError`` instead of a ``ValueError`` if an incompatible key is passed, and ``KeyError`` if a missing key is passed, matching the behavior of ``.loc[]`` (:issue:`31722`)
- Passing an integer dtype other than ``int64`` to ``np.array(period_index, dtype=...)`` will now raise ``TypeError`` instead of incorrectly using ``int64`` (:issue:`32255`)
-
@@ -188,9 +188,9 @@ Performance improvements
- Performance improvement in :class:`Timedelta` constructor (:issue:`30543`)
- Performance improvement in :class:`Timestamp` constructor (:issue:`30543`)
- Performance improvement in flex arithmetic ops between :class:`DataFrame` and :class:`Series` with ``axis=0`` (:issue:`31296`)
-- The internal :meth:`Index._shallow_copy` now copies cached attributes over to the new index,
- avoiding creating these again on the new index. This can speed up many operations
- that depend on creating copies of existing indexes (:issue:`28584`)
+- The internal index method :meth:`~Index._shallow_copy` now copies cached attributes over to the new index,
+ avoiding creating these again on the new index. This can speed up many operations that depend on creating copies of
+ existing indexes (:issue:`28584`, :issue:`32640`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 5997843f7ac6d..6388f2007cb12 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -233,6 +233,7 @@ def _simple_new(cls, values: Categorical, name: Label = None):
result._data = values
result.name = name
+ result._cache = {}
result._reset_identity()
result._no_setting_name = False
@@ -242,14 +243,9 @@ def _simple_new(cls, values: Categorical, name: Label = None):
@Appender(Index._shallow_copy.__doc__)
def _shallow_copy(self, values=None, name: Label = no_default):
- name = self.name if name is no_default else name
-
- if values is None:
- values = self.values
-
- cat = Categorical(values, dtype=self.dtype)
-
- return type(self)._simple_new(cat, name=name)
+ if values is not None:
+ values = Categorical(values, dtype=self.dtype)
+ return super()._shallow_copy(values=values, name=name)
def _is_dtype_compat(self, other) -> bool:
"""
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 894e1d95a17bc..a5902916991ca 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -618,6 +618,7 @@ def _set_freq(self, freq):
def _shallow_copy(self, values=None, name: Label = lib.no_default):
name = self.name if name is lib.no_default else name
+ cache = self._cache.copy() if values is None else {}
if values is None:
values = self._data
@@ -636,7 +637,9 @@ def _shallow_copy(self, values=None, name: Label = lib.no_default):
del attributes["freq"]
attributes["name"] = name
- return type(self)._simple_new(values, **attributes)
+ result = self._simple_new(values, **attributes)
+ result._cache = cache
+ return result
# --------------------------------------------------------------------
# Set Operation Methods
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 185ad8e4c365a..c8035a9de432b 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -268,6 +268,7 @@ def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
result = object.__new__(cls)
result._data = dtarr
result.name = name
+ result._cache = {}
result._no_setting_name = False
# For groupby perf. See note in indexes/base about _index_data
result._index_data = dtarr._data
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index efdaf5a331f5f..80d58de6f1437 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -243,6 +243,7 @@ def _simple_new(cls, array: IntervalArray, name: Label = None):
result = IntervalMixin.__new__(cls)
result._data = array
result.name = name
+ result._cache = {}
result._no_setting_name = False
result._reset_identity()
return result
@@ -332,12 +333,15 @@ def from_tuples(
# --------------------------------------------------------------------
@Appender(Index._shallow_copy.__doc__)
- def _shallow_copy(self, values=None, **kwargs):
+ def _shallow_copy(self, values=None, name: Label = lib.no_default):
+ name = self.name if name is lib.no_default else name
+ cache = self._cache.copy() if values is None else {}
if values is None:
values = self._data
- attributes = self._get_attributes_dict()
- attributes.update(kwargs)
- return self._simple_new(values, **attributes)
+
+ result = self._simple_new(values, name=name)
+ result._cache = cache
+ return result
@cache_readonly
def _isnan(self):
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 9ab80c0b6145c..8ae792d3f63b5 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -233,6 +233,7 @@ def _simple_new(cls, values: PeriodArray, name: Label = None):
# For groupby perf. See note in indexes/base about _index_data
result._index_data = values._data
result.name = name
+ result._cache = {}
result._reset_identity()
return result
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 5e4a8e83bd95b..a6d9d4dfc330b 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -180,6 +180,7 @@ def _simple_new(cls, values, name=None, freq=None, dtype=_TD_DTYPE):
result = object.__new__(cls)
result._data = values
result._name = name
+ result._cache = {}
# For groupby perf. See note in indexes/base about _index_data
result._index_data = values._data
| Follow-up to #32568.
Copies ``._cache`` also when copying using ``.shallow_copy`` for:
* CategoricalIndex
* DatetimeIndex
* PeriodIndex
* DateTimeIndex
* IntervalIndex
After this PR, only ``MultiIndex._shallow_copy`` is missing this optimization. ``MultiIndex._shallow_copy`` is a bit special and might require a refactor so I'd like to take that in a seperate PR.
Example performance improvement:
```pythn
>>> idx = pd.CategoricalIndex(np.arange(100_000))
>>> %timeit idx.get_loc(99_999)
4.46 µs ± 62.6 ns per loop # master and this PR
>>> %timeit idx._shallow_copy().get_loc(99_999)
4.19 ms ± 117 µs per loop # master
8.58 µs ± 254 ns per loop # this PR
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/32640 | 2020-03-11T23:29:15Z | 2020-03-12T10:29:49Z | 2020-03-12T10:29:49Z | 2020-03-12T10:29:55Z |
DEPR: Categorical.to_dense | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 4e7bd5a2032a7..06e387d0e5073 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -207,6 +207,7 @@ Deprecations
- :meth:`DataFrame.mean` and :meth:`DataFrame.median` with ``numeric_only=None`` will include datetime64 and datetime64tz columns in a future version (:issue:`29941`)
- Setting values with ``.loc`` using a positional slice is deprecated and will raise in a future version. Use ``.loc`` with labels or ``.iloc`` with positions instead (:issue:`31840`)
- :meth:`DataFrame.to_dict` has deprecated accepting short names for ``orient`` in future versions (:issue:`32515`)
+- :meth:`Categorical.to_dense` is deprecated and will be removed in a future version, use ``np.asarray(cat)`` instead (:issue:`32639`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 56ace48010108..8284a89a29b52 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1675,6 +1675,12 @@ def to_dense(self):
-------
dense : array
"""
+ warn(
+ "Categorical.to_dense is deprecated and will be removed in "
+ "a future version. Use np.asarray(cat) instead.",
+ FutureWarning,
+ stacklevel=2,
+ )
return np.asarray(self)
def fillna(self, value=None, method=None, limit=None):
diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index f49f70f5acf77..b99e172674f66 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -247,7 +247,7 @@ def test_set_categories(self):
tm.assert_index_equal(c.categories, Index([1, 2, 3, 4]))
exp = np.array([1, 2, 3, 4, 1], dtype=np.int64)
- tm.assert_numpy_array_equal(c.to_dense(), exp)
+ tm.assert_numpy_array_equal(np.asarray(c), exp)
# all "pointers" to '4' must be changed from 3 to 0,...
c = c.set_categories([4, 3, 2, 1])
@@ -260,7 +260,7 @@ def test_set_categories(self):
# output is the same
exp = np.array([1, 2, 3, 4, 1], dtype=np.int64)
- tm.assert_numpy_array_equal(c.to_dense(), exp)
+ tm.assert_numpy_array_equal(np.asarray(c), exp)
assert c.min() == 4
assert c.max() == 1
@@ -268,13 +268,19 @@ def test_set_categories(self):
c2 = c.set_categories([4, 3, 2, 1], ordered=False)
assert not c2.ordered
- tm.assert_numpy_array_equal(c.to_dense(), c2.to_dense())
+ tm.assert_numpy_array_equal(np.asarray(c), np.asarray(c2))
# set_categories should pass thru the ordering
c2 = c.set_ordered(False).set_categories([4, 3, 2, 1])
assert not c2.ordered
- tm.assert_numpy_array_equal(c.to_dense(), c2.to_dense())
+ tm.assert_numpy_array_equal(np.asarray(c), np.asarray(c2))
+
+ def test_to_dense_deprecated(self):
+ cat = Categorical(["a", "b", "c", "a"], ordered=True)
+
+ with tm.assert_produces_warning(FutureWarning):
+ cat.to_dense()
@pytest.mark.parametrize(
"values, categories, new_categories",
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Ideally I'd want to keep the method and change the behavior to (an improved variant of) _internal_get_values, but so it goes. | https://api.github.com/repos/pandas-dev/pandas/pulls/32639 | 2020-03-11T23:23:37Z | 2020-03-15T00:36:15Z | 2020-03-15T00:36:15Z | 2020-03-15T01:27:12Z |
Backport PR #32633: TYP: Remove _ensure_type | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 0a1619750de28..d00a418af3ddb 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -28,6 +28,7 @@ Fixed regressions
- Fixed regression in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
- Fixed regression in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with (tz-aware) index and ``method=nearest`` (:issue:`26683`)
+- Fixed regression in :meth:`DataFrame.reindex_like` on a :class:`DataFrame` subclass raised an ``AssertionError`` (:issue:`31925`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 5acf1a28bb4b6..a46b3256a9d48 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -8,7 +8,6 @@
import numpy as np
import pandas._libs.lib as lib
-from pandas._typing import T
from pandas.compat import PYPY
from pandas.compat.numpy import function as nv
from pandas.errors import AbstractMethodError
@@ -85,14 +84,6 @@ def __sizeof__(self):
# object's 'sizeof'
return super().__sizeof__()
- def _ensure_type(self: T, obj) -> T:
- """Ensure that an object has same type as self.
-
- Used by type checkers.
- """
- assert isinstance(obj, type(self)), type(obj)
- return obj
-
class NoNewAttributesMixin:
"""Mixin which prevents adding new attributes.
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b680234cb0afd..819d341d2d5b4 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3853,7 +3853,7 @@ def reindex(self, *args, **kwargs) -> "DataFrame":
# Pop these, since the values are in `kwargs` under different names
kwargs.pop("axis", None)
kwargs.pop("labels", None)
- return self._ensure_type(super().reindex(**kwargs))
+ return super().reindex(**kwargs)
def drop(
self,
@@ -4174,8 +4174,8 @@ def replace(
@Appender(_shared_docs["shift"] % _shared_doc_kwargs)
def shift(self, periods=1, freq=None, axis=0, fill_value=None) -> "DataFrame":
- return self._ensure_type(
- super().shift(periods=periods, freq=freq, axis=axis, fill_value=fill_value)
+ return super().shift(
+ periods=periods, freq=freq, axis=axis, fill_value=fill_value
)
def set_index(
@@ -8410,14 +8410,12 @@ def isin(self, values) -> "DataFrame":
from pandas.core.reshape.concat import concat
values = collections.defaultdict(list, values)
- return self._ensure_type(
- concat(
- (
- self.iloc[:, [i]].isin(values[col])
- for i, col in enumerate(self.columns)
- ),
- axis=1,
- )
+ return concat(
+ (
+ self.iloc[:, [i]].isin(values[col])
+ for i, col in enumerate(self.columns)
+ ),
+ axis=1,
)
elif isinstance(values, Series):
if not values.index.is_unique:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index c8a6c7c760498..3e86e986eae80 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -8536,9 +8536,9 @@ def _align_frame(
)
if method is not None:
- left = self._ensure_type(
- left.fillna(method=method, axis=fill_axis, limit=limit)
- )
+ _left = left.fillna(method=method, axis=fill_axis, limit=limit)
+ assert _left is not None # needed for mypy
+ left = _left
right = right.fillna(method=method, axis=fill_axis, limit=limit)
# if DatetimeIndex have different tz, convert to UTC
@@ -10079,9 +10079,9 @@ def pct_change(
if fill_method is None:
data = self
else:
- data = self._ensure_type(
- self.fillna(method=fill_method, axis=axis, limit=limit)
- )
+ _data = self.fillna(method=fill_method, axis=axis, limit=limit)
+ assert _data is not None # needed for mypy
+ data = _data
rs = data.div(data.shift(periods=periods, freq=freq, axis=axis, **kwargs)) - 1
if freq is not None:
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index b443ba142369c..d91bf3e250f4a 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -148,7 +148,9 @@ def pivot_table(
table = table.sort_index(axis=1)
if fill_value is not None:
- table = table._ensure_type(table.fillna(fill_value, downcast="infer"))
+ _table = table.fillna(fill_value, downcast="infer")
+ assert _table is not None # needed for mypy
+ table = _table
if margins:
if dropna:
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 6adf69a922000..9578bb9f85fda 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -281,9 +281,7 @@ def _chk_truncate(self) -> None:
series = series.iloc[:max_rows]
else:
row_num = max_rows // 2
- series = series._ensure_type(
- concat((series.iloc[:row_num], series.iloc[-row_num:]))
- )
+ series = concat((series.iloc[:row_num], series.iloc[-row_num:]))
self.tr_row_num = row_num
else:
self.tr_row_num = None
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 4418dee66c092..db0c05040a22e 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1596,6 +1596,17 @@ def test_reindex_methods(self, method, expected_values):
actual = df[::-1].reindex(target, method=switched_method)
tm.assert_frame_equal(expected, actual)
+ def test_reindex_subclass(self):
+ # https://github.com/pandas-dev/pandas/issues/31925
+ class MyDataFrame(DataFrame):
+ pass
+
+ expected = DataFrame()
+ df = MyDataFrame()
+ result = df.reindex_like(expected)
+
+ tm.assert_frame_equal(result, expected)
+
def test_reindex_methods_nearest_special(self):
df = pd.DataFrame({"x": list(range(5))})
target = np.array([-0.1, 0.9, 1.1, 1.5])
| https://github.com/pandas-dev/pandas/pull/32633 | https://api.github.com/repos/pandas-dev/pandas/pulls/32637 | 2020-03-11T21:56:16Z | 2020-03-11T23:25:00Z | 2020-03-11T23:25:00Z | 2020-03-12T02:33:57Z |
TST: tighten check_categorical=False tests | diff --git a/pandas/_testing.py b/pandas/_testing.py
index 136dfbd40276d..dff15c66750ac 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -824,10 +824,14 @@ def assert_categorical_equal(
left.codes, right.codes, check_dtype=check_dtype, obj=f"{obj}.codes",
)
else:
+ try:
+ lc = left.categories.sort_values()
+ rc = right.categories.sort_values()
+ except TypeError:
+ # e.g. '<' not supported between instances of 'int' and 'str'
+ lc, rc = left.categories, right.categories
assert_index_equal(
- left.categories.sort_values(),
- right.categories.sort_values(),
- obj=f"{obj}.categories",
+ lc, rc, obj=f"{obj}.categories",
)
assert_index_equal(
left.categories.take(left.codes),
diff --git a/pandas/tests/arrays/categorical/test_replace.py b/pandas/tests/arrays/categorical/test_replace.py
index 52530123bd52f..b9ac3ce9a37ae 100644
--- a/pandas/tests/arrays/categorical/test_replace.py
+++ b/pandas/tests/arrays/categorical/test_replace.py
@@ -1,3 +1,4 @@
+import numpy as np
import pytest
import pandas as pd
@@ -5,44 +6,46 @@
@pytest.mark.parametrize(
- "to_replace,value,expected,check_types,check_categorical",
+ "to_replace,value,expected,flip_categories",
[
# one-to-one
- (1, 2, [2, 2, 3], True, True),
- (1, 4, [4, 2, 3], True, True),
- (4, 1, [1, 2, 3], True, True),
- (5, 6, [1, 2, 3], True, True),
+ (1, 2, [2, 2, 3], False),
+ (1, 4, [4, 2, 3], False),
+ (4, 1, [1, 2, 3], False),
+ (5, 6, [1, 2, 3], False),
# many-to-one
- ([1], 2, [2, 2, 3], True, True),
- ([1, 2], 3, [3, 3, 3], True, True),
- ([1, 2], 4, [4, 4, 3], True, True),
- ((1, 2, 4), 5, [5, 5, 3], True, True),
- ((5, 6), 2, [1, 2, 3], True, True),
+ ([1], 2, [2, 2, 3], False),
+ ([1, 2], 3, [3, 3, 3], False),
+ ([1, 2], 4, [4, 4, 3], False),
+ ((1, 2, 4), 5, [5, 5, 3], False),
+ ((5, 6), 2, [1, 2, 3], False),
# many-to-many, handled outside of Categorical and results in separate dtype
- ([1], [2], [2, 2, 3], False, False),
- ([1, 4], [5, 2], [5, 2, 3], False, False),
+ ([1], [2], [2, 2, 3], True),
+ ([1, 4], [5, 2], [5, 2, 3], True),
# check_categorical sorts categories, which crashes on mixed dtypes
- (3, "4", [1, 2, "4"], True, False),
- ([1, 2, "3"], "5", ["5", "5", 3], True, False),
+ (3, "4", [1, 2, "4"], False),
+ ([1, 2, "3"], "5", ["5", "5", 3], True),
],
)
-def test_replace(to_replace, value, expected, check_types, check_categorical):
+def test_replace(to_replace, value, expected, flip_categories):
# GH 31720
+ stays_categorical = not isinstance(value, list)
+
s = pd.Series([1, 2, 3], dtype="category")
result = s.replace(to_replace, value)
expected = pd.Series(expected, dtype="category")
s.replace(to_replace, value, inplace=True)
+
+ if flip_categories:
+ expected = expected.cat.set_categories(expected.cat.categories[::-1])
+
+ if not stays_categorical:
+ # the replace call loses categorical dtype
+ expected = pd.Series(np.asarray(expected))
+
tm.assert_series_equal(
- expected,
- result,
- check_dtype=check_types,
- check_categorical=check_categorical,
- check_category_order=False,
+ expected, result, check_category_order=False,
)
tm.assert_series_equal(
- expected,
- s,
- check_dtype=check_types,
- check_categorical=check_categorical,
- check_category_order=False,
+ expected, s, check_category_order=False,
)
diff --git a/pandas/tests/generic/test_frame.py b/pandas/tests/generic/test_frame.py
index 8fe49b2ec2299..631f484cfc22a 100644
--- a/pandas/tests/generic/test_frame.py
+++ b/pandas/tests/generic/test_frame.py
@@ -273,17 +273,13 @@ def test_to_xarray_index_types(self, index):
assert isinstance(result, Dataset)
# idempotency
- # categoricals are not preserved
# datetimes w/tz are preserved
# column names are lost
expected = df.copy()
expected["f"] = expected["f"].astype(object)
expected.columns.name = None
tm.assert_frame_equal(
- result.to_dataframe(),
- expected,
- check_index_type=False,
- check_categorical=False,
+ result.to_dataframe(), expected,
)
@td.skip_if_no("xarray", min_version="0.7.0")
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 34f6a73812c97..2702d378fd153 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -13,8 +13,6 @@
from pandas.compat import is_platform_little_endian, is_platform_windows
import pandas.util._test_decorators as td
-from pandas.core.dtypes.common import is_categorical_dtype
-
import pandas as pd
from pandas import (
Categorical,
@@ -1057,18 +1055,7 @@ def test_latin_encoding(self, setup_path, dtype, val):
s_nan = ser.replace(nan_rep, np.nan)
- if is_categorical_dtype(s_nan):
- assert is_categorical_dtype(retr)
- tm.assert_series_equal(
- s_nan, retr, check_dtype=False, check_categorical=False
- )
- else:
- tm.assert_series_equal(s_nan, retr)
-
- # FIXME: don't leave commented-out
- # fails:
- # for x in examples:
- # roundtrip(s, nan_rep=b'\xf8\xfc')
+ tm.assert_series_equal(s_nan, retr)
def test_append_some_nans(self, setup_path):
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 3efac9cd605a8..eaa92fa53d799 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -1026,7 +1026,14 @@ def test_categorical_with_stata_missing_values(self, version):
original.to_stata(path, version=version)
written_and_read_again = self.read_dta(path)
res = written_and_read_again.set_index("index")
- tm.assert_frame_equal(res, original, check_categorical=False)
+
+ expected = original.copy()
+ for col in expected:
+ cat = expected[col]._values
+ new_cats = cat.remove_unused_categories().categories
+ cat = cat.set_categories(new_cats, ordered=True)
+ expected[col] = cat
+ tm.assert_frame_equal(res, expected)
@pytest.mark.parametrize("file", ["dta19_115", "dta19_117"])
def test_categorical_order(self, file):
@@ -1044,7 +1051,9 @@ def test_categorical_order(self, file):
cols = []
for is_cat, col, labels, codes in expected:
if is_cat:
- cols.append((col, pd.Categorical.from_codes(codes, labels)))
+ cols.append(
+ (col, pd.Categorical.from_codes(codes, labels, ordered=True))
+ )
else:
cols.append((col, pd.Series(labels, dtype=np.float32)))
expected = DataFrame.from_dict(dict(cols))
@@ -1052,7 +1061,7 @@ def test_categorical_order(self, file):
# Read with and with out categoricals, ensure order is identical
file = getattr(self, file)
parsed = read_stata(file)
- tm.assert_frame_equal(expected, parsed, check_categorical=False)
+ tm.assert_frame_equal(expected, parsed)
# Check identity of codes
for col in expected:
@@ -1137,18 +1146,30 @@ def test_read_chunks_117(
chunk = itr.read(chunksize)
except StopIteration:
break
- from_frame = parsed.iloc[pos : pos + chunksize, :]
+ from_frame = parsed.iloc[pos : pos + chunksize, :].copy()
+ from_frame = self._convert_categorical(from_frame)
tm.assert_frame_equal(
- from_frame,
- chunk,
- check_dtype=False,
- check_datetimelike_compat=True,
- check_categorical=False,
+ from_frame, chunk, check_dtype=False, check_datetimelike_compat=True,
)
pos += chunksize
itr.close()
+ @staticmethod
+ def _convert_categorical(from_frame: DataFrame) -> DataFrame:
+ """
+ Emulate the categorical casting behavior we expect from roundtripping.
+ """
+ for col in from_frame:
+ ser = from_frame[col]
+ if is_categorical_dtype(ser.dtype):
+ cat = ser._values.remove_unused_categories()
+ if cat.categories.dtype == object:
+ categories = pd.Index(cat.categories._values)
+ cat = cat.set_categories(categories)
+ from_frame[col] = cat
+ return from_frame
+
def test_iterator(self):
fname = self.dta3_117
@@ -1223,13 +1244,10 @@ def test_read_chunks_115(
chunk = itr.read(chunksize)
except StopIteration:
break
- from_frame = parsed.iloc[pos : pos + chunksize, :]
+ from_frame = parsed.iloc[pos : pos + chunksize, :].copy()
+ from_frame = self._convert_categorical(from_frame)
tm.assert_frame_equal(
- from_frame,
- chunk,
- check_dtype=False,
- check_datetimelike_compat=True,
- check_categorical=False,
+ from_frame, chunk, check_dtype=False, check_datetimelike_compat=True,
)
pos += chunksize
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index d80e2e7afceef..51e6f80df657d 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -2077,8 +2077,7 @@ def test_merge_equal_cat_dtypes(cat_dtype, reverse):
}
).set_index("foo")
- # Categorical is unordered, so don't check ordering.
- tm.assert_frame_equal(result, expected, check_categorical=False)
+ tm.assert_frame_equal(result, expected)
def test_merge_equal_cat_dtypes2():
@@ -2100,8 +2099,7 @@ def test_merge_equal_cat_dtypes2():
{"left": [1, 2], "right": [3, 2], "foo": Series(["a", "b"]).astype(cat_dtype)}
).set_index("foo")
- # Categorical is unordered, so don't check ordering.
- tm.assert_frame_equal(result, expected, check_categorical=False)
+ tm.assert_frame_equal(result, expected)
def test_merge_on_cat_and_ext_array():
diff --git a/pandas/tests/series/test_dtypes.py b/pandas/tests/series/test_dtypes.py
index 80a024eda7848..31f17be2fac7b 100644
--- a/pandas/tests/series/test_dtypes.py
+++ b/pandas/tests/series/test_dtypes.py
@@ -296,18 +296,18 @@ def cmp(a, b):
# array conversion
tm.assert_almost_equal(np.array(s), np.array(s.values))
- # valid conversion
- for valid in [
- lambda x: x.astype("category"),
- lambda x: x.astype(CategoricalDtype()),
- lambda x: x.astype("object").astype("category"),
- lambda x: x.astype("object").astype(CategoricalDtype()),
- ]:
-
- result = valid(s)
- # compare series values
- # internal .categories can't be compared because it is sorted
- tm.assert_series_equal(result, s, check_categorical=False)
+ tm.assert_series_equal(s.astype("category"), s)
+ tm.assert_series_equal(s.astype(CategoricalDtype()), s)
+
+ roundtrip_expected = s.cat.set_categories(
+ s.cat.categories.sort_values()
+ ).cat.remove_unused_categories()
+ tm.assert_series_equal(
+ s.astype("object").astype("category"), roundtrip_expected
+ )
+ tm.assert_series_equal(
+ s.astype("object").astype(CategoricalDtype()), roundtrip_expected
+ )
# invalid conversion (these are NOT a dtype)
msg = (
| This removes all check_categorical=False usages except for a) those in tests/util and b) a skipped json test test_latin_encoding (cc @WillAyd is that likely to be enabled in the foreseeable future?) | https://api.github.com/repos/pandas-dev/pandas/pulls/32636 | 2020-03-11T20:20:36Z | 2020-03-12T02:42:47Z | 2020-03-12T02:42:47Z | 2020-03-12T07:11:47Z |
Backport PR #32561 on branch 1.0.x (Ensure valid Block mutation in SeriesBinGrouper.) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 768e08519543c..0a1619750de28 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -20,6 +20,7 @@ Fixed regressions
- Fixed regression in ``groupby(..).rolling(..).apply()`` (``RollingGroupby``) where the ``raw`` parameter was ignored (:issue:`31754`)
- Fixed regression in :meth:`rolling(..).corr() <pandas.core.window.rolling.Rolling.corr>` when using a time offset (:issue:`31789`)
- Fixed regression in :meth:`groupby(..).nunique() <pandas.core.groupby.DataFrameGroupBy.nunique>` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
+- Fixed regression in ``DataFrame.groupby`` raising a ``ValueError`` from an internal operation (:issue:`31802`)
- Fixed regression where :func:`read_pickle` raised a ``UnicodeDecodeError`` when reading a py27 pickle with :class:`MultiIndex` column (:issue:`31988`).
- Fixed regression in :class:`DataFrame` arithmetic operations with mis-matched columns (:issue:`31623`)
- Fixed regression in :meth:`groupby(..).agg() <pandas.core.groupby.GroupBy.agg>` calling a user-provided function an extra time on an empty input (:issue:`31760`)
diff --git a/pandas/_libs/reduction.pyx b/pandas/_libs/reduction.pyx
index 43d253f632f0f..2e0e41528d80f 100644
--- a/pandas/_libs/reduction.pyx
+++ b/pandas/_libs/reduction.pyx
@@ -177,6 +177,8 @@ cdef class _BaseGrouper:
object.__setattr__(cached_ityp, '_index_data', islider.buf)
cached_ityp._engine.clear_mapping()
object.__setattr__(cached_typ._data._block, 'values', vslider.buf)
+ object.__setattr__(cached_typ._data._block, 'mgr_locs',
+ slice(len(vslider.buf)))
object.__setattr__(cached_typ, '_index', cached_ityp)
object.__setattr__(cached_typ, 'name', self.name)
diff --git a/pandas/tests/groupby/test_bin_groupby.py b/pandas/tests/groupby/test_bin_groupby.py
index ad71f73e80e64..15ce28e0e12bd 100644
--- a/pandas/tests/groupby/test_bin_groupby.py
+++ b/pandas/tests/groupby/test_bin_groupby.py
@@ -5,6 +5,7 @@
from pandas.core.dtypes.common import ensure_int64
+import pandas as pd
from pandas import Index, Series, isna
import pandas._testing as tm
@@ -51,6 +52,30 @@ def test_series_bin_grouper():
tm.assert_almost_equal(counts, exp_counts)
+def assert_block_lengths(x):
+ assert len(x) == len(x._data.blocks[0].mgr_locs)
+ return 0
+
+
+def cumsum_max(x):
+ x.cumsum().max()
+ return 0
+
+
+@pytest.mark.parametrize("func", [cumsum_max, assert_block_lengths])
+def test_mgr_locs_updated(func):
+ # https://github.com/pandas-dev/pandas/issues/31802
+ # Some operations may require creating new blocks, which requires
+ # valid mgr_locs
+ df = pd.DataFrame({"A": ["a", "a", "a"], "B": ["a", "b", "b"], "C": [1, 1, 1]})
+ result = df.groupby(["A", "B"]).agg(func)
+ expected = pd.DataFrame(
+ {"C": [0, 0]},
+ index=pd.MultiIndex.from_product([["a"], ["a", "b"]], names=["A", "B"]),
+ )
+ tm.assert_frame_equal(result, expected)
+
+
@pytest.mark.parametrize(
"binner,closed,expected",
[
| Backport PR #32561: Ensure valid Block mutation in SeriesBinGrouper. | https://api.github.com/repos/pandas-dev/pandas/pulls/32635 | 2020-03-11T18:35:00Z | 2020-03-11T19:32:13Z | 2020-03-11T19:32:13Z | 2020-03-11T19:32:13Z |
TYP: Remove _ensure_type | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 123dfa07f4331..3d5e77b0350e6 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -27,6 +27,7 @@ Fixed regressions
- Fixed regression in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
- Fixed regression in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with (tz-aware) index and ``method=nearest`` (:issue:`26683`)
+- Fixed regression in :meth:`DataFrame.reindex_like` on a :class:`DataFrame` subclass raised an ``AssertionError`` (:issue:`31925`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 478b83f538b7d..40ff0640a5bc4 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -9,7 +9,6 @@
import numpy as np
import pandas._libs.lib as lib
-from pandas._typing import T
from pandas.compat import PYPY
from pandas.compat.numpy import function as nv
from pandas.errors import AbstractMethodError
@@ -87,15 +86,6 @@ def __sizeof__(self):
# no memory_usage attribute, so fall back to object's 'sizeof'
return super().__sizeof__()
- def _ensure_type(self: T, obj) -> T:
- """
- Ensure that an object has same type as self.
-
- Used by type checkers.
- """
- assert isinstance(obj, type(self)), type(obj)
- return obj
-
class NoNewAttributesMixin:
"""
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 30abcafb56ffb..d391f1be2c49f 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3637,7 +3637,7 @@ def reindex(self, *args, **kwargs) -> "DataFrame":
# Pop these, since the values are in `kwargs` under different names
kwargs.pop("axis", None)
kwargs.pop("labels", None)
- return self._ensure_type(super().reindex(**kwargs))
+ return super().reindex(**kwargs)
def drop(
self,
@@ -3955,8 +3955,8 @@ def replace(
@Appender(_shared_docs["shift"] % _shared_doc_kwargs)
def shift(self, periods=1, freq=None, axis=0, fill_value=None) -> "DataFrame":
- return self._ensure_type(
- super().shift(periods=periods, freq=freq, axis=axis, fill_value=fill_value)
+ return super().shift(
+ periods=periods, freq=freq, axis=axis, fill_value=fill_value
)
def set_index(
@@ -8409,14 +8409,12 @@ def isin(self, values) -> "DataFrame":
from pandas.core.reshape.concat import concat
values = collections.defaultdict(list, values)
- return self._ensure_type(
- concat(
- (
- self.iloc[:, [i]].isin(values[col])
- for i, col in enumerate(self.columns)
- ),
- axis=1,
- )
+ return concat(
+ (
+ self.iloc[:, [i]].isin(values[col])
+ for i, col in enumerate(self.columns)
+ ),
+ axis=1,
)
elif isinstance(values, Series):
if not values.index.is_unique:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index f53135174741e..6f743d7388574 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -8442,9 +8442,9 @@ def _align_frame(
)
if method is not None:
- left = self._ensure_type(
- left.fillna(method=method, axis=fill_axis, limit=limit)
- )
+ _left = left.fillna(method=method, axis=fill_axis, limit=limit)
+ assert _left is not None # needed for mypy
+ left = _left
right = right.fillna(method=method, axis=fill_axis, limit=limit)
# if DatetimeIndex have different tz, convert to UTC
@@ -9977,9 +9977,9 @@ def pct_change(
if fill_method is None:
data = self
else:
- data = self._ensure_type(
- self.fillna(method=fill_method, axis=axis, limit=limit)
- )
+ _data = self.fillna(method=fill_method, axis=axis, limit=limit)
+ assert _data is not None # needed for mypy
+ data = _data
rs = data.div(data.shift(periods=periods, freq=freq, axis=axis, **kwargs)) - 1
if freq is not None:
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index 61aa34f724307..a8801d8ab3f6e 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -150,7 +150,9 @@ def pivot_table(
table = table.sort_index(axis=1)
if fill_value is not None:
- table = table._ensure_type(table.fillna(fill_value, downcast="infer"))
+ _table = table.fillna(fill_value, downcast="infer")
+ assert _table is not None # needed for mypy
+ table = _table
if margins:
if dropna:
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index c879eaeda64e0..f011293273c5b 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -283,9 +283,7 @@ def _chk_truncate(self) -> None:
series = series.iloc[:max_rows]
else:
row_num = max_rows // 2
- series = series._ensure_type(
- concat((series.iloc[:row_num], series.iloc[-row_num:]))
- )
+ series = concat((series.iloc[:row_num], series.iloc[-row_num:]))
self.tr_row_num = row_num
else:
self.tr_row_num = None
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index ade17860a99b7..7892030a6727e 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1605,6 +1605,17 @@ def test_reindex_methods(self, method, expected_values):
actual = df[::-1].reindex(target, method=switched_method)
tm.assert_frame_equal(expected, actual)
+ def test_reindex_subclass(self):
+ # https://github.com/pandas-dev/pandas/issues/31925
+ class MyDataFrame(DataFrame):
+ pass
+
+ expected = DataFrame()
+ df = MyDataFrame()
+ result = df.reindex_like(expected)
+
+ tm.assert_frame_equal(result, expected)
+
def test_reindex_methods_nearest_special(self):
df = pd.DataFrame({"x": list(range(5))})
target = np.array([-0.1, 0.9, 1.1, 1.5])
| - [ ] closes #31925
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32633 | 2020-03-11T17:22:50Z | 2020-03-11T21:51:41Z | 2020-03-11T21:51:40Z | 2020-03-12T11:21:36Z |
[WIP] Numpy dev 32bit (do not accept) | diff --git a/ci/azure/posix.yml b/ci/azure/posix.yml
index c9a2e4eefd19d..c1d6e51998d13 100644
--- a/ci/azure/posix.yml
+++ b/ci/azure/posix.yml
@@ -60,6 +60,51 @@ jobs:
PANDAS_TESTING_MODE: "deprecate"
EXTRA_APT: "xsel"
+ py37_np_115_32bit:
+ ENV_FILE: ci/deps/azure-37-numpy115-32bit.yaml
+ CONDA_PY: "37"
+ PATTERN: "not slow and not network"
+ TEST_ARGS: "-W error"
+ PANDAS_TESTING_MODE: "deprecate"
+ EXTRA_APT: "xsel"
+ BITS32: "yes"
+
+ py37_np_116_32bit:
+ ENV_FILE: ci/deps/azure-37-numpy116-32bit.yaml
+ CONDA_PY: "37"
+ PATTERN: "not slow and not network"
+ TEST_ARGS: "-W error"
+ PANDAS_TESTING_MODE: "deprecate"
+ EXTRA_APT: "xsel"
+ BITS32: "yes"
+
+ py37_np_117_32bit:
+ ENV_FILE: ci/deps/azure-37-numpy117-32bit.yaml
+ CONDA_PY: "37"
+ PATTERN: "not slow and not network"
+ TEST_ARGS: "-W error"
+ PANDAS_TESTING_MODE: "deprecate"
+ EXTRA_APT: "xsel"
+ BITS32: "yes"
+
+ py37_np_118_32bit:
+ ENV_FILE: ci/deps/azure-37-numpy118-32bit.yaml
+ CONDA_PY: "37"
+ PATTERN: "not slow and not network"
+ TEST_ARGS: "-W error"
+ PANDAS_TESTING_MODE: "deprecate"
+ EXTRA_APT: "xsel"
+ BITS32: "yes"
+
+ py37_np_dev_32bit:
+ ENV_FILE: ci/deps/azure-37-numpydev-32bit.yaml
+ CONDA_PY: "37"
+ PATTERN: "not slow and not network"
+ TEST_ARGS: "-W error"
+ PANDAS_TESTING_MODE: "deprecate"
+ EXTRA_APT: "xsel"
+ BITS32: "yes"
+
steps:
- script: |
if [ "$(uname)" == "Linux" ]; then
diff --git a/ci/deps/azure-37-numpy115-32bit.yaml b/ci/deps/azure-37-numpy115-32bit.yaml
new file mode 100644
index 0000000000000..5588273c90d13
--- /dev/null
+++ b/ci/deps/azure-37-numpy115-32bit.yaml
@@ -0,0 +1,23 @@
+name: pandas-dev
+channels:
+ - defaults
+ - conda-forge
+dependencies:
+ - python=3.7.*
+
+ # tools
+ ### Cython 0.29.13 and pytest 5.0.1 for 32 bits are not available with conda, installing below with pip instead
+ - pytest-xdist>=1.21
+ - hypothesis>=3.58.0
+ - pytest-azurepipelines
+
+ # pandas dependencies
+ - gcc_linux-32
+ - gxx_linux-32
+ - pytz
+ - pip
+ - pip:
+ - pytest>=5.0.1
+ - cython>=0.29.13
+ - numpy==1.15
+ - scipy
diff --git a/ci/deps/azure-37-numpy116-32bit.yaml b/ci/deps/azure-37-numpy116-32bit.yaml
new file mode 100644
index 0000000000000..7f1ed185e7030
--- /dev/null
+++ b/ci/deps/azure-37-numpy116-32bit.yaml
@@ -0,0 +1,23 @@
+name: pandas-dev
+channels:
+ - defaults
+ - conda-forge
+dependencies:
+ - python=3.7.*
+
+ # tools
+ ### Cython 0.29.13 and pytest 5.0.1 for 32 bits are not available with conda, installing below with pip instead
+ - pytest-xdist>=1.21
+ - hypothesis>=3.58.0
+ - pytest-azurepipelines
+
+ # pandas dependencies
+ - gcc_linux-32
+ - gxx_linux-32
+ - pytz
+ - pip
+ - pip:
+ - pytest>=5.0.1
+ - cython>=0.29.13
+ - numpy==1.16
+ - scipy
diff --git a/ci/deps/azure-37-numpy117-32bit.yaml b/ci/deps/azure-37-numpy117-32bit.yaml
new file mode 100644
index 0000000000000..15a95c5813349
--- /dev/null
+++ b/ci/deps/azure-37-numpy117-32bit.yaml
@@ -0,0 +1,23 @@
+name: pandas-dev
+channels:
+ - defaults
+ - conda-forge
+dependencies:
+ - python=3.7.*
+
+ # tools
+ ### Cython 0.29.13 and pytest 5.0.1 for 32 bits are not available with conda, installing below with pip instead
+ - pytest-xdist>=1.21
+ - hypothesis>=3.58.0
+ - pytest-azurepipelines
+
+ # pandas dependencies
+ - gcc_linux-32
+ - gxx_linux-32
+ - pytz
+ - pip
+ - pip:
+ - pytest>=5.0.1
+ - cython>=0.29.13
+ - numpy==1.17
+ - scipy
diff --git a/ci/deps/azure-37-numpy118-32bit.yaml b/ci/deps/azure-37-numpy118-32bit.yaml
new file mode 100644
index 0000000000000..83b708e3cd5ea
--- /dev/null
+++ b/ci/deps/azure-37-numpy118-32bit.yaml
@@ -0,0 +1,23 @@
+name: pandas-dev
+channels:
+ - defaults
+ - conda-forge
+dependencies:
+ - python=3.7.*
+
+ # tools
+ ### Cython 0.29.13 and pytest 5.0.1 for 32 bits are not available with conda, installing below with pip instead
+ - pytest-xdist>=1.21
+ - hypothesis>=3.58.0
+ - pytest-azurepipelines
+
+ # pandas dependencies
+ - gcc_linux-32
+ - gxx_linux-32
+ - pytz
+ - pip
+ - pip:
+ - pytest>=5.0.1
+ - cython>=0.29.13
+ - numpy==1.18
+ - scipy
diff --git a/ci/deps/azure-37-numpydev-32bit.yaml b/ci/deps/azure-37-numpydev-32bit.yaml
new file mode 100644
index 0000000000000..d7768f9cfdb6e
--- /dev/null
+++ b/ci/deps/azure-37-numpydev-32bit.yaml
@@ -0,0 +1,25 @@
+name: pandas-dev
+channels:
+ - defaults
+dependencies:
+ - python=3.7.*
+
+ # tools
+ ### Cython 0.29.13 and pytest 5.0.1 for 32 bits are not available with conda, installing below with pip instead
+ - pytest-xdist>=1.21
+ - hypothesis>=3.58.0
+ - pytest-azurepipelines
+
+ # pandas dependencies
+ - gcc_linux-32
+ - gxx_linux-32
+ - pytz
+ - pip
+ - pip:
+ - "git+git://github.com/dateutil/dateutil.git"
+ - "-f https://7933911d6844c6c53a7d-47bd50c35cd79bd838daf386af554a83.ssl.cf2.rackcdn.com"
+ - "--pre"
+ - "numpy"
+ - "scipy"
+ - pytest>=5.0.1
+ - cython>=0.29.13
| This will hopefull catch 32bit issues with newer numpy versions
Do NOT accept this at this point. Right now I am trying to figure out where a bug is originating and I need the tests to run. | https://api.github.com/repos/pandas-dev/pandas/pulls/32631 | 2020-03-11T15:38:26Z | 2020-03-31T19:08:07Z | null | 2020-03-31T19:08:07Z |
TST: revert parts of #32571 | diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 82f8a102f9c64..3964e790c7c12 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -32,6 +32,7 @@ def assert_stat_op_calc(
has_skipna=True,
check_dtype=True,
check_dates=False,
+ check_less_precise=False,
skipna_alternative=None,
):
"""
@@ -53,6 +54,9 @@ def assert_stat_op_calc(
"alternative(frame)" should be checked.
check_dates : bool, default false
Whether opname should be tested on a Datetime Series
+ check_less_precise : bool, default False
+ Whether results should only be compared approximately;
+ passed on to tm.assert_series_equal
skipna_alternative : function, default None
NaN-safe version of alternative
"""
@@ -80,11 +84,17 @@ def wrapper(x):
result0 = f(axis=0, skipna=False)
result1 = f(axis=1, skipna=False)
tm.assert_series_equal(
- result0, frame.apply(wrapper), check_dtype=check_dtype,
+ result0,
+ frame.apply(wrapper),
+ check_dtype=check_dtype,
+ check_less_precise=check_less_precise,
)
# HACK: win32
tm.assert_series_equal(
- result1, frame.apply(wrapper, axis=1), check_dtype=False,
+ result1,
+ frame.apply(wrapper, axis=1),
+ check_dtype=False,
+ check_less_precise=check_less_precise,
)
else:
skipna_wrapper = alternative
@@ -92,12 +102,17 @@ def wrapper(x):
result0 = f(axis=0)
result1 = f(axis=1)
tm.assert_series_equal(
- result0, frame.apply(skipna_wrapper), check_dtype=check_dtype,
+ result0,
+ frame.apply(skipna_wrapper),
+ check_dtype=check_dtype,
+ check_less_precise=check_less_precise,
)
if opname in ["sum", "prod"]:
expected = frame.apply(skipna_wrapper, axis=1)
- tm.assert_series_equal(result1, expected, check_dtype=False)
+ tm.assert_series_equal(
+ result1, expected, check_dtype=False, check_less_precise=check_less_precise
+ )
# check dtypes
if check_dtype:
@@ -316,9 +331,15 @@ def kurt(x):
check_dates=True,
)
+ # GH#32571 check_less_precise is needed on apparently-random
+ # py37-npdev builds and OSX-PY36-min_version builds
# mixed types (with upcasting happening)
assert_stat_op_calc(
- "sum", np.sum, mixed_float_frame.astype("float32"), check_dtype=False,
+ "sum",
+ np.sum,
+ mixed_float_frame.astype("float32"),
+ check_dtype=False,
+ check_less_precise=True,
)
assert_stat_op_calc(
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 86502a67e1869..bf0ed4fe25346 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -2372,7 +2372,7 @@ def test_write_row_by_row(self):
result = sql.read_sql("select * from test", con=self.conn)
result.index = frame.index
- tm.assert_frame_equal(result, frame)
+ tm.assert_frame_equal(result, frame, check_less_precise=True)
def test_execute(self):
frame = tm.makeTimeDataFrame()
@@ -2632,7 +2632,9 @@ def test_write_row_by_row(self):
result = sql.read_sql("select * from test", con=self.conn)
result.index = frame.index
- tm.assert_frame_equal(result, frame)
+ tm.assert_frame_equal(result, frame, check_less_precise=True)
+ # GH#32571 result comes back rounded to 6 digits in some builds;
+ # no obvious pattern
def test_chunksize_read_type(self):
frame = tm.makeTimeDataFrame()
| Should fix the broken CI builds. | https://api.github.com/repos/pandas-dev/pandas/pulls/32630 | 2020-03-11T15:21:48Z | 2020-03-11T16:40:50Z | 2020-03-11T16:40:50Z | 2020-03-11T16:40:59Z |
Backport PR #31524 on branch 1.0.x (BUG: non-iterable value in meta raise error in json_normalize) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index d7499bba55c97..768e08519543c 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -78,6 +78,7 @@ Bug fixes
**I/O**
- Using ``pd.NA`` with :meth:`DataFrame.to_json` now correctly outputs a null value instead of an empty object (:issue:`31615`)
+- Bug in :meth:`pandas.json_normalize` when value in meta path is not iterable (:issue:`31507`)
- Fixed pickling of ``pandas.NA``. Previously a new object was returned, which broke computations relying on ``NA`` being a singleton (:issue:`31847`)
- Fixed bug in parquet roundtrip with nullable unsigned integer dtypes (:issue:`31896`).
diff --git a/pandas/io/json/_normalize.py b/pandas/io/json/_normalize.py
index c0596c984575a..ea1f2405eec7f 100644
--- a/pandas/io/json/_normalize.py
+++ b/pandas/io/json/_normalize.py
@@ -8,6 +8,7 @@
import numpy as np
from pandas._libs.writers import convert_json_to_lines
+from pandas._typing import Scalar
from pandas.util._decorators import deprecate
import pandas as pd
@@ -230,14 +231,28 @@ def _json_normalize(
Returns normalized data with columns prefixed with the given string.
"""
- def _pull_field(js: Dict[str, Any], spec: Union[List, str]) -> Iterable:
+ def _pull_field(
+ js: Dict[str, Any], spec: Union[List, str]
+ ) -> Union[Scalar, Iterable]:
+ """Internal function to pull field"""
result = js # type: ignore
if isinstance(spec, list):
for field in spec:
result = result[field]
else:
result = result[spec]
+ return result
+
+ def _pull_records(js: Dict[str, Any], spec: Union[List, str]) -> Iterable:
+ """
+ Interal function to pull field for records, and similar to
+ _pull_field, but require to return Iterable. And will raise error
+ if has non iterable value.
+ """
+ result = _pull_field(js, spec)
+ # GH 31507 GH 30145, if result is not Iterable, raise TypeError if not
+ # null, otherwise return an empty list
if not isinstance(result, Iterable):
if pd.isnull(result):
result = [] # type: ignore
@@ -246,7 +261,6 @@ def _pull_field(js: Dict[str, Any], spec: Union[List, str]) -> Iterable:
f"{js} has non iterable value {result} for path {spec}. "
"Must be iterable or null."
)
-
return result
if isinstance(data, list) and not data:
@@ -296,7 +310,7 @@ def _recursive_extract(data, path, seen_meta, level=0):
_recursive_extract(obj[path[0]], path[1:], seen_meta, level=level + 1)
else:
for obj in data:
- recs = _pull_field(obj, path[0])
+ recs = _pull_records(obj, path[0])
recs = [
nested_to_record(r, sep=sep, max_level=max_level)
if isinstance(r, dict)
diff --git a/pandas/tests/io/json/test_normalize.py b/pandas/tests/io/json/test_normalize.py
index efb95a0cb2a42..898ede370f6e0 100644
--- a/pandas/tests/io/json/test_normalize.py
+++ b/pandas/tests/io/json/test_normalize.py
@@ -486,6 +486,16 @@ def test_non_interable_record_path_errors(self):
with pytest.raises(TypeError, match=msg):
json_normalize([test_input], record_path=[test_path])
+ def test_meta_non_iterable(self):
+ # GH 31507
+ data = """[{"id": 99, "data": [{"one": 1, "two": 2}]}]"""
+
+ result = json_normalize(json.loads(data), record_path=["data"], meta=["id"])
+ expected = DataFrame(
+ {"one": [1], "two": [2], "id": np.array([99], dtype=object)}
+ )
+ tm.assert_frame_equal(result, expected)
+
class TestNestedToRecord:
def test_flat_stays_flat(self):
| Backport PR #31524: BUG: non-iterable value in meta raise error in json_normalize | https://api.github.com/repos/pandas-dev/pandas/pulls/32629 | 2020-03-11T15:03:18Z | 2020-03-11T18:11:17Z | 2020-03-11T18:11:17Z | 2020-03-11T18:11:17Z |
Run travis tests on x86 platforms also | diff --git a/.travis.yml b/.travis.yml
index 2c8533d02ddc1..7e91db8dd2c40 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -26,6 +26,10 @@ git:
matrix:
fast_finish: true
+ arch:
+ - amd64
+ - x86
+
include:
- env:
- JOB="3.8" ENV_FILE="ci/deps/travis-38.yaml" PATTERN="(not slow and not network and not clipboard)"
| Enable x86 tests for pandas under travis.
| https://api.github.com/repos/pandas-dev/pandas/pulls/32627 | 2020-03-11T14:10:05Z | 2020-03-11T14:41:05Z | null | 2020-03-11T14:41:15Z |
DOC: fix formatting / links of API refs in 1.0.2 whatsnew (#32620) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index ca693ff177e3b..d7499bba55c97 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -17,16 +17,17 @@ Fixed regressions
- Fixed regression in :meth:`DataFrame.to_excel` when ``columns`` kwarg is passed (:issue:`31677`)
- Fixed regression in :meth:`Series.align` when ``other`` is a DataFrame and ``method`` is not None (:issue:`31785`)
-- Fixed regression in :meth:`pandas.core.groupby.RollingGroupby.apply` where the ``raw`` parameter was ignored (:issue:`31754`)
-- Fixed regression in :meth:`pandas.core.window.Rolling.corr` when using a time offset (:issue:`31789`)
-- Fixed regression in :meth:`pandas.core.groupby.DataFrameGroupBy.nunique` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
+- Fixed regression in ``groupby(..).rolling(..).apply()`` (``RollingGroupby``) where the ``raw`` parameter was ignored (:issue:`31754`)
+- Fixed regression in :meth:`rolling(..).corr() <pandas.core.window.rolling.Rolling.corr>` when using a time offset (:issue:`31789`)
+- Fixed regression in :meth:`groupby(..).nunique() <pandas.core.groupby.DataFrameGroupBy.nunique>` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
- Fixed regression where :func:`read_pickle` raised a ``UnicodeDecodeError`` when reading a py27 pickle with :class:`MultiIndex` column (:issue:`31988`).
- Fixed regression in :class:`DataFrame` arithmetic operations with mis-matched columns (:issue:`31623`)
-- Fixed regression in :meth:`pandas.core.groupby.GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
-- Joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` will preserve ``freq`` in simple cases (:issue:`32166`)
-- Fixed bug in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
+- Fixed regression in :meth:`groupby(..).agg() <pandas.core.groupby.GroupBy.agg>` calling a user-provided function an extra time on an empty input (:issue:`31760`)
+- Fixed regression in joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` to preserve ``freq`` in simple cases (:issue:`32166`)
+- Fixed regression in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
--
+- Fixed regression in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with (tz-aware) index and ``method=nearest`` (:issue:`26683`)
+
.. ---------------------------------------------------------------------------
@@ -64,7 +65,7 @@ Bug fixes
**Datetimelike**
-- Bug in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with a tz-aware index (:issue:`26683`)
+- Bug in :meth:`Series.astype` not copying for tz-naive and tz-aware datetime64 dtype (:issue:`32490`)
- Bug where :func:`to_datetime` would raise when passed ``pd.NA`` (:issue:`32213`)
- Improved error message when subtracting two :class:`Timestamp` that result in an out-of-bounds :class:`Timedelta` (:issue:`31774`)
@@ -82,7 +83,9 @@ Bug fixes
**Experimental dtypes**
-- Fix bug in :meth:`DataFrame.convert_dtypes` for columns that were already using the ``"string"`` dtype (:issue:`31731`).
+- Fixed bug in :meth:`DataFrame.convert_dtypes` for columns that were already using the ``"string"`` dtype (:issue:`31731`).
+- Fixed bug in :meth:`DataFrame.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
+- Fixed bug in :meth:`DataFrame.convert_dtypes` where ``BooleanDtype`` columns were converted to ``Int64`` (:issue:`32287`)
- Fixed bug in setting values using a slice indexer with string dtype (:issue:`31772`)
- Fixed bug where :meth:`pandas.core.groupby.GroupBy.first` and :meth:`pandas.core.groupby.GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
- Fix bug in :meth:`Series.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
| https://github.com/pandas-dev/pandas/pull/32620 | https://api.github.com/repos/pandas-dev/pandas/pulls/32626 | 2020-03-11T13:56:09Z | 2020-03-11T14:48:58Z | 2020-03-11T14:48:58Z | 2020-03-11T14:49:06Z |
DOC: fix formatting / links of API refs in 1.0.2 whatsnew | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index d99ce468d402f..10191542b6d41 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -17,16 +17,17 @@ Fixed regressions
- Fixed regression in :meth:`DataFrame.to_excel` when ``columns`` kwarg is passed (:issue:`31677`)
- Fixed regression in :meth:`Series.align` when ``other`` is a DataFrame and ``method`` is not None (:issue:`31785`)
-- Fixed regression in :meth:`pandas.core.groupby.RollingGroupby.apply` where the ``raw`` parameter was ignored (:issue:`31754`)
-- Fixed regression in :meth:`pandas.core.window.Rolling.corr` when using a time offset (:issue:`31789`)
-- Fixed regression in :meth:`pandas.core.groupby.DataFrameGroupBy.nunique` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
+- Fixed regression in ``groupby(..).rolling(..).apply()`` (``RollingGroupby``) where the ``raw`` parameter was ignored (:issue:`31754`)
+- Fixed regression in :meth:`rolling(..).corr() <pandas.core.window.rolling.Rolling.corr>` when using a time offset (:issue:`31789`)
+- Fixed regression in :meth:`groupby(..).nunique() <pandas.core.groupby.DataFrameGroupBy.nunique>` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
- Fixed regression where :func:`read_pickle` raised a ``UnicodeDecodeError`` when reading a py27 pickle with :class:`MultiIndex` column (:issue:`31988`).
- Fixed regression in :class:`DataFrame` arithmetic operations with mis-matched columns (:issue:`31623`)
-- Fixed regression in :meth:`pandas.core.groupby.GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
-- Joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` will preserve ``freq`` in simple cases (:issue:`32166`)
-- Fixed bug in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
+- Fixed regression in :meth:`groupby(..).agg() <pandas.core.groupby.GroupBy.agg>` calling a user-provided function an extra time on an empty input (:issue:`31760`)
+- Fixed regression in joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` to preserve ``freq`` in simple cases (:issue:`32166`)
+- Fixed regression in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
--
+- Fixed regression in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with (tz-aware) index and ``method=nearest`` (:issue:`26683`)
+
.. ---------------------------------------------------------------------------
@@ -64,7 +65,6 @@ Bug fixes
**Datetimelike**
-- Bug in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with a tz-aware index (:issue:`26683`)
- Bug in :meth:`Series.astype` not copying for tz-naive and tz-aware datetime64 dtype (:issue:`32490`)
- Bug where :func:`to_datetime` would raise when passed ``pd.NA`` (:issue:`32213`)
- Improved error message when subtracting two :class:`Timestamp` that result in an out-of-bounds :class:`Timedelta` (:issue:`31774`)
@@ -83,11 +83,11 @@ Bug fixes
**Experimental dtypes**
-- Fix bug in :meth:`DataFrame.convert_dtypes` for columns that were already using the ``"string"`` dtype (:issue:`31731`).
+- Fixed bug in :meth:`DataFrame.convert_dtypes` for columns that were already using the ``"string"`` dtype (:issue:`31731`).
+- Fixed bug in :meth:`DataFrame.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
+- Fixed bug in :meth:`DataFrame.convert_dtypes` where ``BooleanDtype`` columns were converted to ``Int64`` (:issue:`32287`)
- Fixed bug in setting values using a slice indexer with string dtype (:issue:`31772`)
- Fixed bug where :meth:`pandas.core.groupby.GroupBy.first` and :meth:`pandas.core.groupby.GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
-- Fix bug in :meth:`Series.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
-- Fixed bug in :meth:`DataFrame.convert_dtypes`, where ``BooleanDtype`` columns were converted to ``Int64`` (:issue:`32287`)
**Strings**
| cc @TomAugspurger (did a few other clean-ups directly as well) | https://api.github.com/repos/pandas-dev/pandas/pulls/32620 | 2020-03-11T12:36:46Z | 2020-03-11T13:45:30Z | 2020-03-11T13:45:30Z | 2020-03-11T14:00:18Z |
DOC: Clarify pivot_table fill_value description | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 30abcafb56ffb..e0887c870279b 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5903,7 +5903,8 @@ def pivot(self, index=None, columns=None, values=None) -> "DataFrame":
If dict is passed, the key is column to aggregate and value
is function or list of functions.
fill_value : scalar, default None
- Value to replace missing values with.
+ Value to replace missing values with (in the resulting pivot table,
+ after aggregation).
margins : bool, default False
Add all row / columns (e.g. for subtotal / grand totals).
dropna : bool, default True
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
---
Clarify that `fill_value` gets used after performing the aggregation (i.e. it fills values in the resulting pivot table).
(Depending on the aggfunc and df, the result will be different if performing the filling before/after aggregation).
---
### Actually, why not remove it, requiring the user to more explicitly do `df.pivot_table(...).fillna(...)`? | https://api.github.com/repos/pandas-dev/pandas/pulls/32618 | 2020-03-11T10:14:22Z | 2020-03-11T23:25:48Z | 2020-03-11T23:25:48Z | 2020-03-11T23:25:54Z |
DOC: Validating that the word pandas is correctly capitalized | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index 5401cc81785ab..ce1ab29ef0746 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -237,6 +237,11 @@ if [[ -z "$CHECK" || "$CHECK" == "patterns" ]]; then
invgrep -RI --exclude=\*.{svg,c,cpp,html,js} --exclude-dir=env "\s$" *
RET=$(($RET + $?)) ; echo $MSG "DONE"
unset INVGREP_APPEND
+
+ # Check if pandas is referenced as pandas, not *pandas*,Pandas or PANDAS
+ MSG='Checking if the pandas word reference is always used lowercase (pandas,not Pandas or PANDAS' ; echo $MSG
+ invgrep -R '*pandas*|Pandas|PANDAS' web/* doc/
+ RET=$(($RET + $?)) ; echo $MSG "DONE"
fi
### CODE ###
@@ -279,8 +284,8 @@ if [[ -z "$CHECK" || "$CHECK" == "doctests" ]]; then
pytest -q --doctest-modules pandas/core/groupby/groupby.py -k"-cumcount -describe -pipe"
RET=$(($RET + $?)) ; echo $MSG "DONE"
- MSG='Doctests datetimes.py' ; echo $MSG
- pytest -q --doctest-modules pandas/core/tools/datetimes.py
+ MSG='Doctests tools' ; echo $MSG
+ pytest -q --doctest-modules pandas/core/tools/
RET=$(($RET + $?)) ; echo $MSG "DONE"
MSG='Doctests reshaping functions' ; echo $MSG
@@ -323,6 +328,10 @@ if [[ -z "$CHECK" || "$CHECK" == "doctests" ]]; then
MSG='Doctests tseries' ; echo $MSG
pytest -q --doctest-modules pandas/tseries/
RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+ MSG='Doctests computation' ; echo $MSG
+ pytest -q --doctest-modules pandas/core/computation/
+ RET=$(($RET + $?)) ; echo $MSG "DONE"
fi
### DOCSTRINGS ###
diff --git a/doc/source/development/contributing_docstring.rst b/doc/source/development/contributing_docstring.rst
index efa165e0a2d0c..0c780ad5f5847 100644
--- a/doc/source/development/contributing_docstring.rst
+++ b/doc/source/development/contributing_docstring.rst
@@ -160,7 +160,7 @@ backticks. The following are considered inline code:
.. _docstring.short_summary:
-Section 1: Short summary
+Section 1: short summary
~~~~~~~~~~~~~~~~~~~~~~~~
The short summary is a single sentence that expresses what the function does in
@@ -228,7 +228,7 @@ infinitive verb.
.. _docstring.extended_summary:
-Section 2: Extended summary
+Section 2: extended summary
~~~~~~~~~~~~~~~~~~~~~~~~~~~
The extended summary provides details on what the function does. It should not
@@ -259,7 +259,7 @@ their use cases, if it is not too generic.
.. _docstring.parameters:
-Section 3: Parameters
+Section 3: parameters
~~~~~~~~~~~~~~~~~~~~~
The details of the parameters will be added in this section. This section has
@@ -424,7 +424,7 @@ For axis, the convention is to use something like:
.. _docstring.returns:
-Section 4: Returns or Yields
+Section 4: returns or yields
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If the method returns a value, it will be documented in this section. Also
@@ -505,7 +505,7 @@ If the method yields its value:
.. _docstring.see_also:
-Section 5: See Also
+Section 5: see also
~~~~~~~~~~~~~~~~~~~
This section is used to let users know about pandas functionality
@@ -583,7 +583,7 @@ For example:
.. _docstring.notes:
-Section 6: Notes
+Section 6: notes
~~~~~~~~~~~~~~~~
This is an optional section used for notes about the implementation of the
@@ -597,7 +597,7 @@ This section follows the same format as the extended summary section.
.. _docstring.examples:
-Section 7: Examples
+Section 7: examples
~~~~~~~~~~~~~~~~~~~
This is one of the most important sections of a docstring, despite being
@@ -998,4 +998,4 @@ mapping function names to docstrings. Wherever possible, we prefer using
See ``pandas.core.generic.NDFrame.fillna`` for an example template, and
``pandas.core.series.Series.fillna`` and ``pandas.core.generic.frame.fillna``
-for the filled versions.
+for the filled versions.
\ No newline at end of file
diff --git a/doc/source/development/developer.rst b/doc/source/development/developer.rst
index 33646e5d74757..fbd83af3de82e 100644
--- a/doc/source/development/developer.rst
+++ b/doc/source/development/developer.rst
@@ -62,7 +62,7 @@ for each column, *including the index columns*. This has JSON form:
See below for the detailed specification for these.
-Index Metadata Descriptors
+Index metadata descriptors
~~~~~~~~~~~~~~~~~~~~~~~~~~
``RangeIndex`` can be stored as metadata only, not requiring serialization. The
@@ -89,7 +89,7 @@ with other column names) a disambiguating name with pattern matching
columns, ``name`` attribute is always stored in the column descriptors as
above.
-Column Metadata
+Column metadata
~~~~~~~~~~~~~~~
``pandas_type`` is the logical type of the column, and is one of:
@@ -182,4 +182,4 @@ As an example of fully-formed metadata:
'creator': {
'library': 'pyarrow',
'version': '0.13.0'
- }}
+ }}
\ No newline at end of file
diff --git a/doc/source/development/extending.rst b/doc/source/development/extending.rst
index 98e3ffcf74ad1..c0b20e2d2843b 100644
--- a/doc/source/development/extending.rst
+++ b/doc/source/development/extending.rst
@@ -210,7 +210,7 @@ will
.. _extending.extension.ufunc:
-NumPy Universal Functions
+NumPy universal functions
^^^^^^^^^^^^^^^^^^^^^^^^^
:class:`Series` implements ``__array_ufunc__``. As part of the implementation,
@@ -501,4 +501,4 @@ registers the default "matplotlib" backend as follows.
More information on how to implement a third-party plotting backend can be found at
-https://github.com/pandas-dev/pandas/blob/master/pandas/plotting/__init__.py#L1.
+https://github.com/pandas-dev/pandas/blob/master/pandas/plotting/__init__.py#L1.
\ No newline at end of file
diff --git a/doc/source/development/maintaining.rst b/doc/source/development/maintaining.rst
index 9ae9d47b89341..9f9e9dc2631f3 100644
--- a/doc/source/development/maintaining.rst
+++ b/doc/source/development/maintaining.rst
@@ -1,7 +1,7 @@
.. _maintaining:
******************
-Pandas Maintenance
+pandas maintenance
******************
This guide is for pandas' maintainers. It may also be interesting to contributors
@@ -41,7 +41,7 @@ reading.
.. _maintaining.triage:
-Issue Triage
+Issue triage
------------
@@ -123,7 +123,7 @@ Here's a typical workflow for triaging a newly opened issue.
.. _maintaining.closing:
-Closing Issues
+Closing issues
--------------
Be delicate here: many people interpret closing an issue as us saying that the
@@ -132,7 +132,7 @@ respond or self-close their issue if it's determined that the behavior is not a
or the feature is out of scope. Sometimes reporters just go away though, and
we'll close the issue after the conversation has died.
-Reviewing Pull Requests
+Reviewing pull requests
-----------------------
Anybody can review a pull request: regular contributors, triagers, or core-team
@@ -144,7 +144,7 @@ members. Here are some guidelines to check.
* User-facing changes should have a whatsnew in the appropriate file.
* Regression tests should reference the original GitHub issue number like ``# GH-1234``.
-Cleaning up old Issues
+Cleaning up old issues
----------------------
Every open issue in pandas has a cost. Open issues make finding duplicates harder,
@@ -164,7 +164,7 @@ If an older issue lacks a reproducible example, label it as "Needs Info" and
ask them to provide one (or write one yourself if possible). If one isn't
provide reasonably soon, close it according to the policies in :ref:`maintaining.closing`.
-Cleaning up old Pull Requests
+Cleaning up old pull requests
-----------------------------
Occasionally, contributors are unable to finish off a pull request.
diff --git a/doc/source/development/meeting.rst b/doc/source/development/meeting.rst
index 803f1b7002de0..35826af5912c2 100644
--- a/doc/source/development/meeting.rst
+++ b/doc/source/development/meeting.rst
@@ -1,7 +1,7 @@
.. _meeting:
==================
-Developer Meetings
+Developer meetings
==================
We hold regular developer meetings on the second Wednesday
@@ -29,4 +29,3 @@ You can subscribe to this calendar with the following links:
Additionally, we'll sometimes have one-off meetings on specific topics.
These will be published on the same calendar.
-
diff --git a/doc/source/reference/general_utility_functions.rst b/doc/source/reference/general_utility_functions.rst
index 0d9e0b0f4c668..575b82b4b06de 100644
--- a/doc/source/reference/general_utility_functions.rst
+++ b/doc/source/reference/general_utility_functions.rst
@@ -108,3 +108,11 @@ Scalar introspection
api.types.is_re
api.types.is_re_compilable
api.types.is_scalar
+
+Bug report function
+-------------------
+.. autosummary::
+ :toctree: api/
+
+ show_versions
+
diff --git a/doc/source/user_guide/options.rst b/doc/source/user_guide/options.rst
index 5817efb31814e..398336960e769 100644
--- a/doc/source/user_guide/options.rst
+++ b/doc/source/user_guide/options.rst
@@ -140,7 +140,7 @@ More information can be found in the `ipython documentation
.. _options.frequently_used:
-Frequently Used Options
+Frequently used options
-----------------------
The following is a walk-through of the more frequently used display options.
diff --git a/doc/source/user_guide/reshaping.rst b/doc/source/user_guide/reshaping.rst
index 58733b852e3a1..7e890962d8da1 100644
--- a/doc/source/user_guide/reshaping.rst
+++ b/doc/source/user_guide/reshaping.rst
@@ -272,7 +272,7 @@ the right thing:
.. _reshaping.melt:
-Reshaping by Melt
+Reshaping by melt
-----------------
.. image:: ../_static/reshaping_melt.png
diff --git a/doc/source/user_guide/text.rst b/doc/source/user_guide/text.rst
index 234c12ce79822..bea0f42f6849c 100644
--- a/doc/source/user_guide/text.rst
+++ b/doc/source/user_guide/text.rst
@@ -8,7 +8,7 @@ Working with text data
.. _text.types:
-Text Data Types
+Text data types
---------------
.. versionadded:: 1.0.0
@@ -113,7 +113,7 @@ Everything else that follows in the rest of this document applies equally to
.. _text.string_methods:
-String Methods
+String methods
--------------
Series and Index are equipped with a set of string processing methods
@@ -633,7 +633,7 @@ same result as a ``Series.str.extractall`` with a default index (starts from 0).
pd.Series(["a1a2", "b1", "c1"], dtype="string").str.extractall(two_groups)
-Testing for Strings that match or contain a pattern
+Testing for strings that match or contain a pattern
---------------------------------------------------
You can check whether elements contain a pattern:
diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index f208c8d576131..0d49a2d8db77c 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -122,7 +122,7 @@ as ``np.nan`` does for float data.
.. _timeseries.representation:
-Timestamps vs. Time Spans
+Timestamps vs. time spans
-------------------------
Timestamped data is the most basic type of time series data that associates
@@ -1434,7 +1434,7 @@ or calendars with additional rules.
.. _timeseries.advanced_datetime:
-Time Series-Related Instance Methods
+Time series-related instance methods
------------------------------------
Shifting / lagging
diff --git a/doc/source/user_guide/visualization.rst b/doc/source/user_guide/visualization.rst
index 756dd06aced7f..451ddf046416e 100644
--- a/doc/source/user_guide/visualization.rst
+++ b/doc/source/user_guide/visualization.rst
@@ -796,7 +796,7 @@ before plotting.
.. _visualization.tools:
-Plotting Tools
+Plotting tools
--------------
These functions can be imported from ``pandas.plotting``
@@ -1045,7 +1045,7 @@ for more information.
.. _visualization.formatting:
-Plot Formatting
+Plot formatting
---------------
Setting the plot style
diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 8db837a38170b..25f847c698278 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -313,7 +313,7 @@ Timedelta
Timezones
^^^^^^^^^
--
+- Bug in :func:`to_datetime` with ``infer_datetime_format=True`` where timezone names (e.g. ``UTC``) would not be parsed correctly (:issue:`33133`)
-
@@ -471,6 +471,7 @@ Other
- Fixed bug in :func:`pandas.testing.assert_series_equal` where dtypes were checked for ``Interval`` and ``ExtensionArray`` operands when ``check_dtype`` was ``False`` (:issue:`32747`)
- Bug in :meth:`Series.map` not raising on invalid ``na_action`` (:issue:`32815`)
- Bug in :meth:`DataFrame.__dir__` caused a segfault when using unicode surrogates in a column name (:issue:`25509`)
+- Bug in :meth:`DataFrame.plot.scatter` caused an error when plotting variable marker sizes (:issue:`32904`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/_libs/tslibs/conversion.pyx b/pandas/_libs/tslibs/conversion.pyx
index a318bea14b52b..6fa9159c469c2 100644
--- a/pandas/_libs/tslibs/conversion.pyx
+++ b/pandas/_libs/tslibs/conversion.pyx
@@ -8,8 +8,7 @@ cnp.import_array()
import pytz
# stdlib datetime imports
-from datetime import time as datetime_time
-from cpython.datetime cimport (datetime, tzinfo,
+from cpython.datetime cimport (datetime, time, tzinfo,
PyDateTime_Check, PyDate_Check,
PyDateTime_IMPORT)
PyDateTime_IMPORT
@@ -284,7 +283,7 @@ cdef convert_to_tsobject(object ts, object tz, object unit,
return convert_datetime_to_tsobject(ts, tz, nanos)
elif PyDate_Check(ts):
# Keep the converter same as PyDateTime's
- ts = datetime.combine(ts, datetime_time())
+ ts = datetime.combine(ts, time())
return convert_datetime_to_tsobject(ts, tz)
elif getattr(ts, '_typ', None) == 'period':
raise ValueError("Cannot convert Period to Timestamp "
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index a66c9cd86d00c..306636278bcbe 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -462,7 +462,7 @@ class _BaseOffset:
def _validate_n(self, n):
"""
- Require that `n` be a nonzero integer.
+ Require that `n` be an integer.
Parameters
----------
diff --git a/pandas/_libs/tslibs/parsing.pyx b/pandas/_libs/tslibs/parsing.pyx
index 74b95a2f3076f..5272a0a042d0e 100644
--- a/pandas/_libs/tslibs/parsing.pyx
+++ b/pandas/_libs/tslibs/parsing.pyx
@@ -805,6 +805,7 @@ def _guess_datetime_format(dt_str, dayfirst=False, dt_str_parse=du_parse,
(('second',), '%S', 2),
(('microsecond',), '%f', 6),
(('second', 'microsecond'), '%S.%f', 0),
+ (('tzinfo',), '%Z', 0),
]
if dayfirst:
diff --git a/pandas/_libs/tslibs/period.pyx b/pandas/_libs/tslibs/period.pyx
index c3a47902cff0f..dd745f840d0ab 100644
--- a/pandas/_libs/tslibs/period.pyx
+++ b/pandas/_libs/tslibs/period.pyx
@@ -1,5 +1,3 @@
-from datetime import datetime
-
from cpython.object cimport PyObject_RichCompareBool, Py_EQ, Py_NE
from numpy cimport int64_t, import_array, ndarray
@@ -13,6 +11,7 @@ from libc.string cimport strlen, memset
import cython
from cpython.datetime cimport (
+ datetime,
PyDate_Check,
PyDateTime_Check,
PyDateTime_IMPORT,
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index 64b79200028b6..7858072407a35 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -5,8 +5,7 @@ cimport numpy as cnp
from numpy cimport int64_t
cnp.import_array()
-from datetime import time as datetime_time, timedelta
-from cpython.datetime cimport (datetime, PyDateTime_Check,
+from cpython.datetime cimport (datetime, time, PyDateTime_Check, PyDelta_Check,
PyTZInfo_Check, PyDateTime_IMPORT)
PyDateTime_IMPORT
@@ -33,7 +32,7 @@ from pandas._libs.tslibs.tzconversion import (
# ----------------------------------------------------------------------
# Constants
-_zero_time = datetime_time(0, 0)
+_zero_time = time(0, 0)
_no_input = object()
# ----------------------------------------------------------------------
@@ -879,8 +878,7 @@ default 'raise'
raise ValueError('Cannot infer offset with only one time.')
nonexistent_options = ('raise', 'NaT', 'shift_forward', 'shift_backward')
- if nonexistent not in nonexistent_options and not isinstance(
- nonexistent, timedelta):
+ if nonexistent not in nonexistent_options and not PyDelta_Check(nonexistent):
raise ValueError(
"The nonexistent argument must be one of 'raise', "
"'NaT', 'shift_forward', 'shift_backward' or a timedelta object"
diff --git a/pandas/_testing.py b/pandas/_testing.py
index 1f6b645c821c8..8522ccf1b6bab 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -821,7 +821,7 @@ def assert_categorical_equal(
if check_category_order:
assert_index_equal(left.categories, right.categories, obj=f"{obj}.categories")
assert_numpy_array_equal(
- left.codes, right.codes, check_dtype=check_dtype, obj=f"{obj}.codes",
+ left.codes, right.codes, check_dtype=check_dtype, obj=f"{obj}.codes"
)
else:
try:
@@ -830,9 +830,7 @@ def assert_categorical_equal(
except TypeError:
# e.g. '<' not supported between instances of 'int' and 'str'
lc, rc = left.categories, right.categories
- assert_index_equal(
- lc, rc, obj=f"{obj}.categories",
- )
+ assert_index_equal(lc, rc, obj=f"{obj}.categories")
assert_index_equal(
left.categories.take(left.codes),
right.categories.take(right.codes),
@@ -974,7 +972,7 @@ def _raise(left, right, err_msg):
if err_msg is None:
if left.shape != right.shape:
raise_assert_detail(
- obj, f"{obj} shapes are different", left.shape, right.shape,
+ obj, f"{obj} shapes are different", left.shape, right.shape
)
diff = 0
@@ -1328,7 +1326,7 @@ def assert_frame_equal(
# shape comparison
if left.shape != right.shape:
raise_assert_detail(
- obj, f"{obj} shape mismatch", f"{repr(left.shape)}", f"{repr(right.shape)}",
+ obj, f"{obj} shape mismatch", f"{repr(left.shape)}", f"{repr(right.shape)}"
)
if check_like:
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 2ee64403c7cf4..0b14c12f2356f 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -526,6 +526,64 @@ def empty_frame():
return DataFrame()
+@pytest.fixture
+def int_frame():
+ """
+ Fixture for DataFrame of ints with index of unique strings
+
+ Columns are ['A', 'B', 'C', 'D']
+
+ A B C D
+ vpBeWjM651 1 0 1 0
+ 5JyxmrP1En -1 0 0 0
+ qEDaoD49U2 -1 1 0 0
+ m66TkTfsFe 0 0 0 0
+ EHPaNzEUFm -1 0 -1 0
+ fpRJCevQhi 2 0 0 0
+ OlQvnmfi3Q 0 0 -2 0
+ ... .. .. .. ..
+ uB1FPlz4uP 0 0 0 1
+ EcSe6yNzCU 0 0 -1 0
+ L50VudaiI8 -1 1 -2 0
+ y3bpw4nwIp 0 -1 0 0
+ H0RdLLwrCT 1 1 0 0
+ rY82K0vMwm 0 0 0 0
+ 1OPIUjnkjk 2 0 0 0
+
+ [30 rows x 4 columns]
+ """
+ return DataFrame(tm.getSeriesData()).astype("int64")
+
+
+@pytest.fixture
+def datetime_frame():
+ """
+ Fixture for DataFrame of floats with DatetimeIndex
+
+ Columns are ['A', 'B', 'C', 'D']
+
+ A B C D
+ 2000-01-03 -1.122153 0.468535 0.122226 1.693711
+ 2000-01-04 0.189378 0.486100 0.007864 -1.216052
+ 2000-01-05 0.041401 -0.835752 -0.035279 -0.414357
+ 2000-01-06 0.430050 0.894352 0.090719 0.036939
+ 2000-01-07 -0.620982 -0.668211 -0.706153 1.466335
+ 2000-01-10 -0.752633 0.328434 -0.815325 0.699674
+ 2000-01-11 -2.236969 0.615737 -0.829076 -1.196106
+ ... ... ... ... ...
+ 2000-02-03 1.642618 -0.579288 0.046005 1.385249
+ 2000-02-04 -0.544873 -1.160962 -0.284071 -1.418351
+ 2000-02-07 -2.656149 -0.601387 1.410148 0.444150
+ 2000-02-08 -1.201881 -1.289040 0.772992 -1.445300
+ 2000-02-09 1.377373 0.398619 1.008453 -0.928207
+ 2000-02-10 0.473194 -0.636677 0.984058 0.511519
+ 2000-02-11 -0.965556 0.408313 -1.312844 -0.381948
+
+ [30 rows x 4 columns]
+ """
+ return DataFrame(tm.getTimeSeriesData())
+
+
@pytest.fixture
def float_frame():
"""
diff --git a/pandas/core/accessor.py b/pandas/core/accessor.py
index fc40f1db1918a..b6ca19bde8009 100644
--- a/pandas/core/accessor.py
+++ b/pandas/core/accessor.py
@@ -211,7 +211,9 @@ def _register_accessor(name, cls):
See Also
--------
- {others}
+ register_dataframe_accessor : Register a custom accessor on DataFrame objects.
+ register_series_accessor : Register a custom accessor on Series objects.
+ register_index_accessor : Register a custom accessor on Index objects.
Notes
-----
@@ -279,33 +281,21 @@ def decorator(accessor):
return decorator
-@doc(
- _register_accessor,
- klass="DataFrame",
- others="register_series_accessor, register_index_accessor",
-)
+@doc(_register_accessor, klass="DataFrame")
def register_dataframe_accessor(name):
from pandas import DataFrame
return _register_accessor(name, DataFrame)
-@doc(
- _register_accessor,
- klass="Series",
- others="register_dataframe_accessor, register_index_accessor",
-)
+@doc(_register_accessor, klass="Series")
def register_series_accessor(name):
from pandas import Series
return _register_accessor(name, Series)
-@doc(
- _register_accessor,
- klass="Index",
- others="register_dataframe_accessor, register_series_accessor",
-)
+@doc(_register_accessor, klass="Index")
def register_index_accessor(name):
from pandas import Index
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index c11d879840fb9..edc138574830d 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -416,12 +416,12 @@ def categories(self):
See Also
--------
- rename_categories
- reorder_categories
- add_categories
- remove_categories
- remove_unused_categories
- set_categories
+ rename_categories : Rename categories.
+ reorder_categories : Reorder categories.
+ add_categories : Add new categories.
+ remove_categories : Remove the specified categories.
+ remove_unused_categories : Remove categories which are not used.
+ set_categories : Set the categories to the specified ones.
"""
return self.dtype.categories
@@ -830,11 +830,11 @@ def set_categories(self, new_categories, ordered=None, rename=False, inplace=Fal
See Also
--------
- rename_categories
- reorder_categories
- add_categories
- remove_categories
- remove_unused_categories
+ rename_categories : Rename categories.
+ reorder_categories : Reorder categories.
+ add_categories : Add new categories.
+ remove_categories : Remove the specified categories.
+ remove_unused_categories : Remove categories which are not used.
"""
inplace = validate_bool_kwarg(inplace, "inplace")
if ordered is None:
@@ -901,11 +901,11 @@ def rename_categories(self, new_categories, inplace=False):
See Also
--------
- reorder_categories
- add_categories
- remove_categories
- remove_unused_categories
- set_categories
+ reorder_categories : Reorder categories.
+ add_categories : Add new categories.
+ remove_categories : Remove the specified categories.
+ remove_unused_categories : Remove categories which are not used.
+ set_categories : Set the categories to the specified ones.
Examples
--------
@@ -969,11 +969,11 @@ def reorder_categories(self, new_categories, ordered=None, inplace=False):
See Also
--------
- rename_categories
- add_categories
- remove_categories
- remove_unused_categories
- set_categories
+ rename_categories : Rename categories.
+ add_categories : Add new categories.
+ remove_categories : Remove the specified categories.
+ remove_unused_categories : Remove categories which are not used.
+ set_categories : Set the categories to the specified ones.
"""
inplace = validate_bool_kwarg(inplace, "inplace")
if set(self.dtype.categories) != set(new_categories):
@@ -1009,11 +1009,11 @@ def add_categories(self, new_categories, inplace=False):
See Also
--------
- rename_categories
- reorder_categories
- remove_categories
- remove_unused_categories
- set_categories
+ rename_categories : Rename categories.
+ reorder_categories : Reorder categories.
+ remove_categories : Remove the specified categories.
+ remove_unused_categories : Remove categories which are not used.
+ set_categories : Set the categories to the specified ones.
"""
inplace = validate_bool_kwarg(inplace, "inplace")
if not is_list_like(new_categories):
@@ -1058,11 +1058,11 @@ def remove_categories(self, removals, inplace=False):
See Also
--------
- rename_categories
- reorder_categories
- add_categories
- remove_unused_categories
- set_categories
+ rename_categories : Rename categories.
+ reorder_categories : Reorder categories.
+ add_categories : Add new categories.
+ remove_unused_categories : Remove categories which are not used.
+ set_categories : Set the categories to the specified ones.
"""
inplace = validate_bool_kwarg(inplace, "inplace")
if not is_list_like(removals):
@@ -1100,11 +1100,11 @@ def remove_unused_categories(self, inplace=False):
See Also
--------
- rename_categories
- reorder_categories
- add_categories
- remove_categories
- set_categories
+ rename_categories : Rename categories.
+ reorder_categories : Reorder categories.
+ add_categories : Add new categories.
+ remove_categories : Remove the specified categories.
+ set_categories : Set the categories to the specified ones.
"""
inplace = validate_bool_kwarg(inplace, "inplace")
cat = self if inplace else self.copy()
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 4f3c68aa03b16..d79f2145a91f3 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -124,7 +124,7 @@ def __from_arrow__(
return IntegerArray._concat_same_type(results)
-def integer_array(values, dtype=None, copy: bool = False,) -> "IntegerArray":
+def integer_array(values, dtype=None, copy: bool = False) -> "IntegerArray":
"""
Infer and return an integer array of the values.
@@ -168,7 +168,7 @@ def safe_cast(values, dtype, copy: bool):
def coerce_to_array(
- values, dtype, mask=None, copy: bool = False,
+ values, dtype, mask=None, copy: bool = False
) -> Tuple[np.ndarray, np.ndarray]:
"""
Coerce the input values array to numpy arrays with a mask
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index cf6c16d4cad5d..627135bba5f36 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -61,7 +61,7 @@ def __invert__(self: BaseMaskedArrayT) -> BaseMaskedArrayT:
return type(self)(~self._data, self._mask)
def to_numpy(
- self, dtype=None, copy: bool = False, na_value: Scalar = lib.no_default,
+ self, dtype=None, copy: bool = False, na_value: Scalar = lib.no_default
) -> np.ndarray:
"""
Convert to a NumPy Array.
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 3058e1d6073f3..6699511fdb885 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -281,7 +281,7 @@ def isna(self) -> np.ndarray:
return isna(self._ndarray)
def fillna(
- self, value=None, method: Optional[str] = None, limit: Optional[int] = None,
+ self, value=None, method: Optional[str] = None, limit: Optional[int] = None
) -> "PandasArray":
# TODO(_values_for_fillna): remove this
value, method = validate_fillna_kwargs(value, method)
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index be9cc53d33d6f..426b3710a13f9 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -606,7 +606,7 @@ def _sub_period(self, other):
return new_data
def _addsub_int_array(
- self, other: np.ndarray, op: Callable[[Any, Any], Any],
+ self, other: np.ndarray, op: Callable[[Any, Any], Any]
) -> "PeriodArray":
"""
Add or subtract array of integers; equivalent to applying
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 8021e0babe4e0..8c09aa9176f31 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -232,7 +232,7 @@ class SparseArray(PandasObject, ExtensionArray, ExtensionOpsMixin):
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'
+ kind : {'int', 'block'}, default 'int'
The type of storage for sparse locations.
* 'block': Stores a `block` and `block_length` for each
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 34a3276d03c37..a28a2c9594341 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -13,7 +13,6 @@
from pandas.compat.numpy import function as nv
from pandas.errors import AbstractMethodError
from pandas.util._decorators import cache_readonly, doc
-from pandas.util._validators import validate_bool_kwarg
from pandas.core.dtypes.cast import is_nested_object
from pandas.core.dtypes.common import (
@@ -1505,18 +1504,14 @@ def factorize(self, sort=False, na_sentinel=-1):
def searchsorted(self, value, side="left", sorter=None) -> np.ndarray:
return algorithms.searchsorted(self._values, value, side=side, sorter=sorter)
- def drop_duplicates(self, keep="first", inplace=False):
- inplace = validate_bool_kwarg(inplace, "inplace")
+ def drop_duplicates(self, keep="first"):
if isinstance(self, ABCIndexClass):
if self.is_unique:
return self._shallow_copy()
duplicated = self.duplicated(keep=keep)
result = self[np.logical_not(duplicated)]
- if inplace:
- return self._update_inplace(result)
- else:
- return result
+ return result
def duplicated(self, keep="first"):
if isinstance(self, ABCIndexClass):
@@ -1527,9 +1522,3 @@ def duplicated(self, keep="first"):
return self._constructor(
duplicated(self, keep=keep), index=self.index
).__finalize__(self)
-
- # ----------------------------------------------------------------------
- # abstracts
-
- def _update_inplace(self, result, verify_is_copy=True, **kwargs):
- raise AbstractMethodError(self)
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index d29102cbd4604..ef681cb204598 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -194,7 +194,7 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
See Also
--------
- Categorical
+ Categorical : Represent a categorical variable in classic R / S-plus fashion.
Notes
-----
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index d461db2d05f9d..f7b0615366ba0 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -16,30 +16,24 @@
ensure_object,
is_bool_dtype,
is_complex_dtype,
- is_datetime64_dtype,
- is_datetime64tz_dtype,
is_datetimelike_v_numeric,
is_dtype_equal,
is_extension_array_dtype,
is_float_dtype,
is_integer_dtype,
is_object_dtype,
- is_period_dtype,
is_scalar,
is_string_dtype,
is_string_like_dtype,
- is_timedelta64_dtype,
needs_i8_conversion,
pandas_dtype,
)
from pandas.core.dtypes.generic import (
ABCDataFrame,
- ABCDatetimeArray,
ABCExtensionArray,
ABCIndexClass,
ABCMultiIndex,
ABCSeries,
- ABCTimedeltaArray,
)
from pandas.core.dtypes.inference import is_list_like
@@ -139,17 +133,7 @@ def _isna_new(obj):
raise NotImplementedError("isna is not defined for MultiIndex")
elif isinstance(obj, type):
return False
- elif isinstance(
- obj,
- (
- ABCSeries,
- np.ndarray,
- ABCIndexClass,
- ABCExtensionArray,
- ABCDatetimeArray,
- ABCTimedeltaArray,
- ),
- ):
+ elif isinstance(obj, (ABCSeries, np.ndarray, ABCIndexClass, ABCExtensionArray)):
return _isna_ndarraylike(obj)
elif isinstance(obj, ABCDataFrame):
return obj.isna()
@@ -158,7 +142,7 @@ def _isna_new(obj):
elif hasattr(obj, "__array__"):
return _isna_ndarraylike(np.asarray(obj))
else:
- return obj is None
+ return False
def _isna_old(obj):
@@ -189,7 +173,7 @@ def _isna_old(obj):
elif hasattr(obj, "__array__"):
return _isna_ndarraylike_old(np.asarray(obj))
else:
- return obj is None
+ return False
_isna = _isna_new
@@ -224,37 +208,14 @@ def _use_inf_as_na(key):
def _isna_ndarraylike(obj):
- is_extension = is_extension_array_dtype(obj)
-
- if not is_extension:
- # Avoid accessing `.values` on things like
- # PeriodIndex, which may be expensive.
- values = getattr(obj, "_values", obj)
- else:
- values = obj
-
+ is_extension = is_extension_array_dtype(obj.dtype)
+ values = getattr(obj, "_values", obj)
dtype = values.dtype
if is_extension:
- if isinstance(obj, (ABCIndexClass, ABCSeries)):
- values = obj._values
- else:
- values = obj
result = values.isna()
- elif isinstance(obj, ABCDatetimeArray):
- return obj.isna()
elif is_string_dtype(dtype):
- # Working around NumPy ticket 1542
- shape = values.shape
-
- if is_string_like_dtype(dtype):
- # object array of strings
- result = np.zeros(values.shape, dtype=bool)
- else:
- # object array of non-strings
- result = np.empty(shape, dtype=bool)
- vec = libmissing.isnaobj(values.ravel())
- result[...] = vec.reshape(shape)
+ result = _isna_string_dtype(values, dtype, old=False)
elif needs_i8_conversion(dtype):
# this is the NaT pattern
@@ -274,17 +235,9 @@ def _isna_ndarraylike_old(obj):
dtype = values.dtype
if is_string_dtype(dtype):
- # Working around NumPy ticket 1542
- shape = values.shape
-
- if is_string_like_dtype(dtype):
- result = np.zeros(values.shape, dtype=bool)
- else:
- result = np.empty(shape, dtype=bool)
- vec = libmissing.isnaobj_old(values.ravel())
- result[:] = vec.reshape(shape)
+ result = _isna_string_dtype(values, dtype, old=True)
- elif is_datetime64_dtype(dtype):
+ elif needs_i8_conversion(dtype):
# this is the NaT pattern
result = values.view("i8") == iNaT
else:
@@ -297,6 +250,24 @@ def _isna_ndarraylike_old(obj):
return result
+def _isna_string_dtype(values: np.ndarray, dtype: np.dtype, old: bool) -> np.ndarray:
+ # Working around NumPy ticket 1542
+ shape = values.shape
+
+ if is_string_like_dtype(dtype):
+ result = np.zeros(values.shape, dtype=bool)
+ else:
+ result = np.empty(shape, dtype=bool)
+ if old:
+ vec = libmissing.isnaobj_old(values.ravel())
+ else:
+ vec = libmissing.isnaobj(values.ravel())
+
+ result[...] = vec.reshape(shape)
+
+ return result
+
+
def notna(obj):
"""
Detect non-missing values for an array-like object.
@@ -556,12 +527,7 @@ def na_value_for_dtype(dtype, compat: bool = True):
if is_extension_array_dtype(dtype):
return dtype.na_value
- if (
- is_datetime64_dtype(dtype)
- or is_datetime64tz_dtype(dtype)
- or is_timedelta64_dtype(dtype)
- or is_period_dtype(dtype)
- ):
+ if needs_i8_conversion(dtype):
return NaT
elif is_float_dtype(dtype):
return np.nan
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 8ada8e830b834..a4039aaa510aa 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3042,16 +3042,16 @@ def query(self, expr, inplace=False, **kwargs):
res = self.eval(expr, **kwargs)
try:
- new_data = self.loc[res]
+ result = self.loc[res]
except ValueError:
# when res is multi-dimensional loc raises, but this is sometimes a
# valid query
- new_data = self[res]
+ result = self[res]
if inplace:
- self._update_inplace(new_data)
+ self._update_inplace(result)
else:
- return new_data
+ return result
def eval(self, expr, inplace=False, **kwargs):
"""
@@ -4684,7 +4684,7 @@ def drop_duplicates(
result.index = ibase.default_index(len(result))
if inplace:
- self._update_inplace(result._data)
+ self._update_inplace(result)
return None
else:
return result
@@ -4803,10 +4803,11 @@ def sort_values(
if ignore_index:
new_data.axes[1] = ibase.default_index(len(indexer))
+ result = self._constructor(new_data)
if inplace:
- return self._update_inplace(new_data)
+ return self._update_inplace(result)
else:
- return self._constructor(new_data).__finalize__(self)
+ return result.__finalize__(self)
def sort_index(
self,
@@ -4938,10 +4939,11 @@ def sort_index(
if ignore_index:
new_data.axes[1] = ibase.default_index(len(indexer))
+ result = self._constructor(new_data)
if inplace:
- return self._update_inplace(new_data)
+ return self._update_inplace(result)
else:
- return self._constructor(new_data).__finalize__(self)
+ return result.__finalize__(self)
def value_counts(
self,
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 62f5419c1f4c8..143e4543e7ab8 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -147,7 +147,7 @@ def _single_replace(self, to_replace, method, inplace, limit):
result = pd.Series(values, index=self.index, dtype=self.dtype).__finalize__(self)
if inplace:
- self._update_inplace(result._data)
+ self._update_inplace(result)
return
return result
@@ -988,7 +988,7 @@ def rename(
result._clear_item_cache()
if inplace:
- self._update_inplace(result._data)
+ self._update_inplace(result)
return None
else:
return result.__finalize__(self)
@@ -3957,15 +3957,15 @@ def _update_inplace(self, result, verify_is_copy: bool_t = True) -> None:
Parameters
----------
+ result : same type as self
verify_is_copy : bool, default True
Provide is_copy checks.
"""
# NOTE: This does *not* call __finalize__ and that's an explicit
# decision that we may revisit in the future.
-
self._reset_cache()
self._clear_item_cache()
- self._data = getattr(result, "_data", result)
+ self._data = result._data
self._maybe_update_cacher(verify_is_copy=verify_is_copy)
def add_prefix(self: FrameOrSeries, prefix: str) -> FrameOrSeries:
@@ -6107,15 +6107,15 @@ def fillna(
value=value, limit=limit, inplace=inplace, downcast=downcast
)
elif isinstance(value, ABCDataFrame) and self.ndim == 2:
- new_data = self.where(self.notna(), value)
+ new_data = self.where(self.notna(), value)._data
else:
raise ValueError(f"invalid fill value with a {type(value)}")
+ result = self._constructor(new_data)
if inplace:
- self._update_inplace(new_data)
- return None
+ return self._update_inplace(result)
else:
- return self._constructor(new_data).__finalize__(self)
+ return result.__finalize__(self)
def ffill(
self: FrameOrSeries,
@@ -6627,10 +6627,11 @@ def replace(
f'Invalid "to_replace" type: {repr(type(to_replace).__name__)}'
)
+ result = self._constructor(new_data)
if inplace:
- self._update_inplace(new_data)
+ return self._update_inplace(result)
else:
- return self._constructor(new_data).__finalize__(self)
+ return result.__finalize__(self)
_shared_docs[
"interpolate"
@@ -7231,7 +7232,7 @@ def _clip_with_scalar(self, lower, upper, inplace: bool_t = False):
result[mask] = np.nan
if inplace:
- self._update_inplace(result)
+ return self._update_inplace(result)
else:
return result
@@ -8641,7 +8642,8 @@ def _where(
new_data = self._data.putmask(
mask=cond, new=other, align=align, axis=block_axis,
)
- self._update_inplace(new_data)
+ result = self._constructor(new_data)
+ return self._update_inplace(result)
else:
new_data = self._data.where(
@@ -8652,8 +8654,8 @@ def _where(
try_cast=try_cast,
axis=block_axis,
)
-
- return self._constructor(new_data).__finalize__(self)
+ result = self._constructor(new_data)
+ return result.__finalize__(self)
_shared_docs[
"where"
diff --git a/pandas/core/groupby/__init__.py b/pandas/core/groupby/__init__.py
index 0c5d2658978b4..15d8a996b6e7b 100644
--- a/pandas/core/groupby/__init__.py
+++ b/pandas/core/groupby/__init__.py
@@ -2,10 +2,4 @@
from pandas.core.groupby.groupby import GroupBy
from pandas.core.groupby.grouper import Grouper
-__all__ = [
- "DataFrameGroupBy",
- "NamedAgg",
- "SeriesGroupBy",
- "GroupBy",
- "Grouper",
-]
+__all__ = ["DataFrameGroupBy", "NamedAgg", "SeriesGroupBy", "GroupBy", "Grouper"]
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index ebdb0062491be..dff712ee17ea6 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -211,7 +211,7 @@ class providing the base-class of operations.
Parameters
----------
-func : callable or tuple of (callable, string)
+func : callable or tuple of (callable, str)
Function to apply to this %(klass)s object or, alternatively,
a `(callable, data_keyword)` tuple where `data_keyword` is a
string indicating the keyword of `callable` that expects the
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 2a5dfff35e4a5..d487516ab4abe 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -280,7 +280,7 @@ def _outer_indexer(self, left, right):
# Constructors
def __new__(
- cls, data=None, dtype=None, copy=False, name=None, tupleize_cols=True, **kwargs,
+ cls, data=None, dtype=None, copy=False, name=None, tupleize_cols=True, **kwargs
) -> "Index":
from pandas.core.indexes.range import RangeIndex
@@ -534,10 +534,6 @@ def _shallow_copy_with_infer(self, values, **kwargs):
attributes.pop("tz", None)
return Index(values, **attributes)
- def _update_inplace(self, result, **kwargs):
- # guard when called from IndexOpsMixin
- raise TypeError("Index can't be updated inplace")
-
def is_(self, other) -> bool:
"""
More flexible, faster check like ``is`` but that works through views.
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index d5df661efa692..f54b93b52b4a8 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -184,10 +184,10 @@ def func(intvidx_self, other, sort=False):
)
@inherit_names(["set_closed", "to_tuples"], IntervalArray, wrap=True)
@inherit_names(
- ["__array__", "overlaps", "contains", "left", "right", "length"], IntervalArray,
+ ["__array__", "overlaps", "contains", "left", "right", "length"], IntervalArray
)
@inherit_names(
- ["is_non_overlapping_monotonic", "mid", "closed"], IntervalArray, cache=True,
+ ["is_non_overlapping_monotonic", "mid", "closed"], IntervalArray, cache=True
)
class IntervalIndex(IntervalMixin, ExtensionIndex):
_typ = "intervalindex"
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index b00af4653dfe3..0338a0de7d83e 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1584,7 +1584,8 @@ def to_frame(self, index=True, name=None):
See Also
--------
- DataFrame
+ DataFrame : Two-dimensional, size-mutable, potentially heterogeneous
+ tabular data.
"""
from pandas import DataFrame
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index e2be58a56018d..6714b36638f44 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -462,7 +462,7 @@ def isin(self, values, level=None):
def _is_compatible_with_other(self, other) -> bool:
return super()._is_compatible_with_other(other) or all(
isinstance(
- obj, (ABCInt64Index, ABCFloat64Index, ABCUInt64Index, ABCRangeIndex),
+ obj, (ABCInt64Index, ABCFloat64Index, ABCUInt64Index, ABCRangeIndex)
)
for obj in [self, other]
)
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 0646acab57081..8aaf828787179 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -324,8 +324,8 @@ def _formatter_func(self):
@cache_readonly
def _engine(self):
- # To avoid a reference cycle, pass a weakref of self to _engine_type.
- period = weakref.ref(self)
+ # To avoid a reference cycle, pass a weakref of self._values to _engine_type.
+ period = weakref.ref(self._values)
return self._engine_type(period, len(self))
@doc(Index.__contains__)
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index b463b8d738d30..b1dc83823aa08 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -86,7 +86,7 @@ class RangeIndex(Int64Index):
# Constructors
def __new__(
- cls, start=None, stop=None, step=None, dtype=None, copy=False, name=None,
+ cls, start=None, stop=None, step=None, dtype=None, copy=False, name=None
):
cls._validate_dtype(dtype)
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 778e2866f1eff..7f541537f2de1 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1631,9 +1631,7 @@ def set(self, locs, values):
assert locs.tolist() == [0]
self.values[:] = values
- def putmask(
- self, mask, new, inplace: bool = False, axis: int = 0, transpose: bool = False,
- ) -> List["Block"]:
+ def putmask(self, mask, new, align=True, inplace=False, axis=0, transpose=False):
"""
See Block.putmask.__doc__
"""
@@ -1816,7 +1814,7 @@ def diff(self, n: int, axis: int = 1) -> List["Block"]:
return super().diff(n, axis)
def shift(
- self, periods: int, axis: int = 0, fill_value: Any = None,
+ self, periods: int, axis: int = 0, fill_value: Any = None
) -> List["ExtensionBlock"]:
"""
Shift the block by `periods`.
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 822ab775e7e46..74f45f12e5763 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -1308,7 +1308,7 @@ def _zero_out_fperr(arg):
@disallow("M8", "m8")
def nancorr(
- a: np.ndarray, b: np.ndarray, method="pearson", min_periods: Optional[int] = None,
+ a: np.ndarray, b: np.ndarray, method="pearson", min_periods: Optional[int] = None
):
"""
a, b: ndarrays
diff --git a/pandas/core/ops/__init__.py b/pandas/core/ops/__init__.py
index 10dcb59977cdd..50447624151da 100644
--- a/pandas/core/ops/__init__.py
+++ b/pandas/core/ops/__init__.py
@@ -80,14 +80,7 @@
}
-COMPARISON_BINOPS: Set[str] = {
- "eq",
- "ne",
- "lt",
- "gt",
- "le",
- "ge",
-}
+COMPARISON_BINOPS: Set[str] = {"eq", "ne", "lt", "gt", "le", "ge"}
# -----------------------------------------------------------------------------
# Ops Wrapping Utilities
@@ -385,9 +378,7 @@ def _align_method_SERIES(left, right, align_asobject=False):
return left, right
-def _construct_result(
- left: ABCSeries, result: ArrayLike, index: ABCIndexClass, name,
-):
+def _construct_result(left: ABCSeries, result: ArrayLike, index: ABCIndexClass, name):
"""
Construct an appropriately-labelled Series from the result of an op.
diff --git a/pandas/core/ops/array_ops.py b/pandas/core/ops/array_ops.py
index 5dd7af454cbd1..228dbd4159f2c 100644
--- a/pandas/core/ops/array_ops.py
+++ b/pandas/core/ops/array_ops.py
@@ -257,7 +257,7 @@ def _can_broadcast(lvalues, rvalues) -> bool:
def comparison_op(
- left: ArrayLike, right: Any, op, str_rep: Optional[str] = None,
+ left: ArrayLike, right: Any, op, str_rep: Optional[str] = None
) -> ArrayLike:
"""
Evaluate a comparison operation `=`, `!=`, `>=`, `>`, `<=`, or `<`.
diff --git a/pandas/core/ops/dispatch.py b/pandas/core/ops/dispatch.py
index 2463a1f58a447..e44cf2f6c533c 100644
--- a/pandas/core/ops/dispatch.py
+++ b/pandas/core/ops/dispatch.py
@@ -76,3 +76,36 @@ def should_series_dispatch(left, right, op):
return True
return False
+
+
+def dispatch_to_extension_op(
+ op, left: Union[ABCExtensionArray, np.ndarray], right: Any
+):
+ """
+ Assume that left or right is a Series backed by an ExtensionArray,
+ apply the operator defined by op.
+
+ Parameters
+ ----------
+ op : binary operator
+ left : ExtensionArray or np.ndarray
+ right : object
+
+ Returns
+ -------
+ ExtensionArray or np.ndarray
+ 2-tuple of these if op is divmod or rdivmod
+ """
+ # NB: left and right should already be unboxed, so neither should be
+ # a Series or Index.
+
+ if left.dtype.kind in "mM" and isinstance(left, np.ndarray):
+ # We need to cast datetime64 and timedelta64 ndarrays to
+ # DatetimeArray/TimedeltaArray. But we avoid wrapping others in
+ # PandasArray as that behaves poorly with e.g. IntegerArray.
+ left = array(left)
+
+ # The op calls will raise TypeError if the op is not defined
+ # on the ExtensionArray
+ res_values = op(left, right)
+ return res_values
diff --git a/pandas/core/ops/methods.py b/pandas/core/ops/methods.py
index 0cf1ac4d107f6..7c63bc43de67e 100644
--- a/pandas/core/ops/methods.py
+++ b/pandas/core/ops/methods.py
@@ -98,7 +98,7 @@ def f(self, other):
# this makes sure that we are aligned like the input
# we are updating inplace so we want to ignore is_copy
self._update_inplace(
- result.reindex_like(self, copy=False)._data, verify_is_copy=False
+ result.reindex_like(self, copy=False), verify_is_copy=False
)
return self
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index efb72d1b61d1f..fbc25a0dd97db 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -395,7 +395,7 @@ def __init__(
# Need to flip BlockManager axis in the DataFrame special case
self._is_frame = isinstance(sample, ABCDataFrame)
if self._is_frame:
- axis = 1 if axis == 0 else 0
+ axis = DataFrame._get_block_manager_axis(axis)
self._is_series = isinstance(sample, ABCSeries)
if not 0 <= axis <= sample.ndim:
@@ -436,7 +436,8 @@ def __init__(
self.objs.append(obj)
# note: this is the BlockManager axis (since DataFrame is transposed)
- self.axis = axis
+ self.bm_axis = axis
+ self.axis = 1 - self.bm_axis if self._is_frame else 0
self.keys = keys
self.names = names or getattr(keys, "names", None)
self.levels = levels
@@ -454,7 +455,7 @@ def get_result(self):
if self._is_series:
# stack blocks
- if self.axis == 0:
+ if self.bm_axis == 0:
name = com.consensus_name_attr(self.objs)
mgr = self.objs[0]._data.concat(
@@ -477,21 +478,22 @@ def get_result(self):
else:
mgrs_indexers = []
for obj in self.objs:
- mgr = obj._data
indexers = {}
for ax, new_labels in enumerate(self.new_axes):
- if ax == self.axis:
+ # ::-1 to convert BlockManager ax to DataFrame ax
+ if ax == self.bm_axis:
# Suppress reindexing on concat axis
continue
- obj_labels = mgr.axes[ax]
+ # 1-ax to convert BlockManager axis to DataFrame axis
+ obj_labels = obj.axes[1 - ax]
if not new_labels.equals(obj_labels):
indexers[ax] = obj_labels.reindex(new_labels)[1]
mgrs_indexers.append((obj._data, indexers))
new_data = concatenate_block_managers(
- mgrs_indexers, self.new_axes, concat_axis=self.axis, copy=self.copy
+ mgrs_indexers, self.new_axes, concat_axis=self.bm_axis, copy=self.copy
)
if not self.copy:
new_data._consolidate_inplace()
@@ -500,7 +502,7 @@ def get_result(self):
return cons(new_data).__finalize__(self, method="concat")
def _get_result_dim(self) -> int:
- if self._is_series and self.axis == 1:
+ if self._is_series and self.bm_axis == 1:
return 2
else:
return self.objs[0].ndim
@@ -508,7 +510,7 @@ def _get_result_dim(self) -> int:
def _get_new_axes(self) -> List[Index]:
ndim = self._get_result_dim()
return [
- self._get_concat_axis() if i == self.axis else self._get_comb_axis(i)
+ self._get_concat_axis() if i == self.bm_axis else self._get_comb_axis(i)
for i in range(ndim)
]
@@ -527,7 +529,7 @@ def _get_concat_axis(self) -> Index:
Return index to be used along concatenation axis.
"""
if self._is_series:
- if self.axis == 0:
+ if self.bm_axis == 0:
indexes = [x.index for x in self.objs]
elif self.ignore_index:
idx = ibase.default_index(len(self.objs))
@@ -555,7 +557,7 @@ def _get_concat_axis(self) -> Index:
else:
return ensure_index(self.keys).set_names(self.names)
else:
- indexes = [x._data.axes[self.axis] for x in self.objs]
+ indexes = [x.axes[self.axis] for x in self.objs]
if self.ignore_index:
idx = ibase.default_index(sum(len(i) for i in indexes))
diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index 4b1fd73d9950e..e78d5ccaa30c7 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -596,7 +596,11 @@ def __init__(
self.left = self.orig_left = _left
self.right = self.orig_right = _right
self.how = how
- self.axis = axis
+
+ # bm_axis -> the axis on the BlockManager
+ self.bm_axis = axis
+ # axis --> the axis on the Series/DataFrame
+ self.axis = 1 - axis if self.left.ndim == 2 else 0
self.on = com.maybe_make_list(on)
self.left_on = com.maybe_make_list(left_on)
@@ -664,18 +668,17 @@ def get_result(self):
join_index, left_indexer, right_indexer = self._get_join_info()
- ldata, rdata = self.left._data, self.right._data
lsuf, rsuf = self.suffixes
llabels, rlabels = _items_overlap_with_suffix(
- ldata.items, lsuf, rdata.items, rsuf
+ self.left._info_axis, lsuf, self.right._info_axis, rsuf
)
lindexers = {1: left_indexer} if left_indexer is not None else {}
rindexers = {1: right_indexer} if right_indexer is not None else {}
result_data = concatenate_block_managers(
- [(ldata, lindexers), (rdata, rindexers)],
+ [(self.left._data, lindexers), (self.right._data, rindexers)],
axes=[llabels.append(rlabels), join_index],
concat_axis=0,
copy=self.copy,
@@ -864,8 +867,8 @@ def _get_join_indexers(self):
)
def _get_join_info(self):
- left_ax = self.left._data.axes[self.axis]
- right_ax = self.right._data.axes[self.axis]
+ left_ax = self.left.axes[self.axis]
+ right_ax = self.right.axes[self.axis]
if self.left_index and self.right_index and self.how != "asof":
join_index, left_indexer, right_indexer = left_ax.join(
@@ -1478,12 +1481,10 @@ def __init__(
def get_result(self):
join_index, left_indexer, right_indexer = self._get_join_info()
- # this is a bit kludgy
- ldata, rdata = self.left._data, self.right._data
lsuf, rsuf = self.suffixes
llabels, rlabels = _items_overlap_with_suffix(
- ldata.items, lsuf, rdata.items, rsuf
+ self.left._info_axis, lsuf, self.right._info_axis, rsuf
)
if self.fill_method == "ffill":
@@ -1497,7 +1498,7 @@ def get_result(self):
rindexers = {1: right_join_indexer} if right_join_indexer is not None else {}
result_data = concatenate_block_managers(
- [(ldata, lindexers), (rdata, rindexers)],
+ [(self.left._data, lindexers), (self.right._data, rindexers)],
axes=[llabels.append(rlabels), join_index],
concat_axis=0,
copy=self.copy,
diff --git a/pandas/core/reshape/pivot.py b/pandas/core/reshape/pivot.py
index b3b0166334413..1a5752043b33e 100644
--- a/pandas/core/reshape/pivot.py
+++ b/pandas/core/reshape/pivot.py
@@ -228,7 +228,7 @@ def _add_margins(
elif values:
marginal_result_set = _generate_marginal_results(
- table, data, values, rows, cols, aggfunc, observed, margins_name,
+ table, data, values, rows, cols, aggfunc, observed, margins_name
)
if not isinstance(marginal_result_set, tuple):
return marginal_result_set
@@ -297,7 +297,7 @@ def _compute_grand_margin(data, values, aggfunc, margins_name: str = "All"):
def _generate_marginal_results(
- table, data, values, rows, cols, aggfunc, observed, margins_name: str = "All",
+ table, data, values, rows, cols, aggfunc, observed, margins_name: str = "All"
):
if len(cols) > 0:
# need to "interleave" the margins
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 7e575bf9e6115..03b82365358ac 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -418,10 +418,6 @@ def _set_axis(self, axis: int, labels, fastpath: bool = False) -> None:
# The ensure_index call aabove ensures we have an Index object
self._data.set_axis(axis, labels)
- def _update_inplace(self, result, **kwargs):
- # we want to call the generic version and not the IndexOpsMixin
- return generic.NDFrame._update_inplace(self, result, **kwargs)
-
# ndarray compatibility
@property
def dtype(self) -> DtypeObj:
@@ -1800,7 +1796,7 @@ def unique(self):
result = super().unique()
return result
- def drop_duplicates(self, keep="first", inplace=False) -> "Series":
+ def drop_duplicates(self, keep="first", inplace=False) -> Optional["Series"]:
"""
Return Series with duplicate values removed.
@@ -1875,7 +1871,13 @@ def drop_duplicates(self, keep="first", inplace=False) -> "Series":
5 hippo
Name: animal, dtype: object
"""
- return super().drop_duplicates(keep=keep, inplace=inplace)
+ inplace = validate_bool_kwarg(inplace, "inplace")
+ result = super().drop_duplicates(keep=keep)
+ if inplace:
+ self._update_inplace(result)
+ return None
+ else:
+ return result
def duplicated(self, keep="first") -> "Series":
"""
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index a2042de7f337e..207c5cc98449a 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -606,9 +606,9 @@ def to_datetime(
would calculate the number of milliseconds to the unix epoch start.
infer_datetime_format : bool, default False
If True and no `format` is given, attempt to infer the format of the
- datetime strings, and if it can be inferred, switch to a faster
- method of parsing them. In some cases this can increase the parsing
- speed by ~5-10x.
+ datetime strings based on the first non-NaN element,
+ and if it can be inferred, switch to a faster method of parsing them.
+ In some cases this can increase the parsing speed by ~5-10x.
origin : scalar, default 'unix'
Define the reference date. The numeric values would be parsed as number
of units (defined by `unit`) since this reference date.
diff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py
index a6198f8b752ae..f4eb16602f8a0 100644
--- a/pandas/core/tools/numeric.py
+++ b/pandas/core/tools/numeric.py
@@ -40,13 +40,13 @@ def to_numeric(arg, errors="raise", downcast=None):
- If 'raise', then invalid parsing will raise an exception.
- If 'coerce', then invalid parsing will be set as NaN.
- If 'ignore', then invalid parsing will return the input.
- downcast : {'integer', 'signed', 'unsigned', 'float'}, default None
+ downcast : {'int', 'signed', 'unsigned', 'float'}, default None
If not None, and if the data has been successfully cast to a
numerical dtype (or if the data was numeric to begin with),
downcast that resulting data to the smallest numerical dtype
possible according to the following rules:
- - 'integer' or 'signed': smallest signed int dtype (min.: np.int8)
+ - 'int' or 'signed': smallest signed int dtype (min.: np.int8)
- 'unsigned': smallest unsigned int dtype (min.: np.uint8)
- 'float': smallest float dtype (min.: np.float32)
diff --git a/pandas/core/window/indexers.py b/pandas/core/window/indexers.py
index 921cdb3c2523f..70298d5df3606 100644
--- a/pandas/core/window/indexers.py
+++ b/pandas/core/window/indexers.py
@@ -35,7 +35,7 @@ class BaseIndexer:
"""Base class for window bounds calculations."""
def __init__(
- self, index_array: Optional[np.ndarray] = None, window_size: int = 0, **kwargs,
+ self, index_array: Optional[np.ndarray] = None, window_size: int = 0, **kwargs
):
"""
Parameters
@@ -100,7 +100,7 @@ def get_window_bounds(
) -> Tuple[np.ndarray, np.ndarray]:
return calculate_variable_window_bounds(
- num_values, self.window_size, min_periods, center, closed, self.index_array,
+ num_values, self.window_size, min_periods, center, closed, self.index_array
)
diff --git a/pandas/core/window/numba_.py b/pandas/core/window/numba_.py
index 5d35ec7457ab0..aec294c3c84c2 100644
--- a/pandas/core/window/numba_.py
+++ b/pandas/core/window/numba_.py
@@ -57,7 +57,7 @@ def generate_numba_apply_func(
@numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
def roll_apply(
- values: np.ndarray, begin: np.ndarray, end: np.ndarray, minimum_periods: int,
+ values: np.ndarray, begin: np.ndarray, end: np.ndarray, minimum_periods: int
) -> np.ndarray:
result = np.empty(len(begin))
for i in loop_range(len(result)):
diff --git a/pandas/io/formats/css.py b/pandas/io/formats/css.py
index b40d2a57b8106..4d6f03489725f 100644
--- a/pandas/io/formats/css.py
+++ b/pandas/io/formats/css.py
@@ -20,9 +20,7 @@ def expand(self, prop, value: str):
try:
mapping = self.SIDE_SHORTHANDS[len(tokens)]
except KeyError:
- warnings.warn(
- f'Could not expand "{prop}: {value}"', CSSWarning,
- )
+ warnings.warn(f'Could not expand "{prop}: {value}"', CSSWarning)
return
for key, idx in zip(self.SIDES, mapping):
yield prop_fmt.format(key), tokens[idx]
@@ -117,10 +115,7 @@ def __call__(self, declarations_str, inherited=None):
props[prop] = self.size_to_pt(
props[prop], em_pt=font_size, conversions=self.BORDER_WIDTH_RATIOS
)
- for prop in [
- f"margin-{side}",
- f"padding-{side}",
- ]:
+ for prop in [f"margin-{side}", f"padding-{side}"]:
if prop in props:
# TODO: support %
props[prop] = self.size_to_pt(
diff --git a/pandas/io/formats/excel.py b/pandas/io/formats/excel.py
index aac1df5dcd396..527f6d738d95a 100644
--- a/pandas/io/formats/excel.py
+++ b/pandas/io/formats/excel.py
@@ -141,8 +141,7 @@ def build_border(self, props: Dict) -> Dict[str, Dict[str, str]]:
return {
side: {
"style": self._border_style(
- props.get(f"border-{side}-style"),
- props.get(f"border-{side}-width"),
+ props.get(f"border-{side}-style"), props.get(f"border-{side}-width")
),
"color": self.color_to_excel(props.get(f"border-{side}-color")),
}
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 718534e42ec25..3feae8b0a30dd 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -292,10 +292,7 @@ def format_attr(pair):
# ... except maybe the last for columns.names
name = self.data.columns.names[r]
- cs = [
- BLANK_CLASS if name is None else INDEX_NAME_CLASS,
- f"level{r}",
- ]
+ cs = [BLANK_CLASS if name is None else INDEX_NAME_CLASS, f"level{r}"]
name = BLANK_VALUE if name is None else name
row_es.append(
{
@@ -309,11 +306,7 @@ def format_attr(pair):
if clabels:
for c, value in enumerate(clabels[r]):
- cs = [
- COL_HEADING_CLASS,
- f"level{r}",
- f"col{c}",
- ]
+ cs = [COL_HEADING_CLASS, f"level{r}", f"col{c}"]
cs.extend(
cell_context.get("col_headings", {}).get(r, {}).get(c, [])
)
@@ -357,11 +350,7 @@ def format_attr(pair):
for r, idx in enumerate(self.data.index):
row_es = []
for c, value in enumerate(rlabels[r]):
- rid = [
- ROW_HEADING_CLASS,
- f"level{c}",
- f"row{r}",
- ]
+ rid = [ROW_HEADING_CLASS, f"level{c}", f"row{r}"]
es = {
"type": "th",
"is_visible": (_is_visible(r, c, idx_lengths) and not hidden_index),
diff --git a/pandas/io/html.py b/pandas/io/html.py
index 9efdacadce83e..ce6674ffb9588 100644
--- a/pandas/io/html.py
+++ b/pandas/io/html.py
@@ -1036,7 +1036,7 @@ def read_html(
See Also
--------
- read_csv
+ read_csv : Read a comma-separated values (csv) file into DataFrame.
Notes
-----
diff --git a/pandas/io/orc.py b/pandas/io/orc.py
index ea79efd0579e5..b556732e4d116 100644
--- a/pandas/io/orc.py
+++ b/pandas/io/orc.py
@@ -12,7 +12,7 @@
def read_orc(
- path: FilePathOrBuffer, columns: Optional[List[str]] = None, **kwargs,
+ path: FilePathOrBuffer, columns: Optional[List[str]] = None, **kwargs
) -> "DataFrame":
"""
Load an ORC object from the file path, returning a DataFrame.
diff --git a/pandas/io/parquet.py b/pandas/io/parquet.py
index 9ae9729fc05ee..281ba1fc9e6c2 100644
--- a/pandas/io/parquet.py
+++ b/pandas/io/parquet.py
@@ -105,9 +105,7 @@ def write(
**kwargs,
)
else:
- self.api.parquet.write_table(
- table, path, compression=compression, **kwargs,
- )
+ self.api.parquet.write_table(table, path, compression=compression, **kwargs)
def read(self, path, columns=None, **kwargs):
path, _, _, should_close = get_filepath_or_buffer(path)
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
index 8c213803170a3..189aa1e8fab6c 100644
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -2824,7 +2824,7 @@ def read_index_node(
# If the index was an empty array write_array_empty() will
# have written a sentinel. Here we relace it with the original.
if "shape" in node._v_attrs and np.prod(node._v_attrs.shape) == 0:
- data = np.empty(node._v_attrs.shape, dtype=node._v_attrs.value_type,)
+ data = np.empty(node._v_attrs.shape, dtype=node._v_attrs.value_type)
kind = _ensure_decoded(node._v_attrs.kind)
name = None
@@ -3564,10 +3564,7 @@ def _read_axes(
for a in self.axes:
a.set_info(self.info)
res = a.convert(
- values,
- nan_rep=self.nan_rep,
- encoding=self.encoding,
- errors=self.errors,
+ values, nan_rep=self.nan_rep, encoding=self.encoding, errors=self.errors
)
results.append(res)
@@ -3990,7 +3987,7 @@ def create_description(
return d
def read_coordinates(
- self, where=None, start: Optional[int] = None, stop: Optional[int] = None,
+ self, where=None, start: Optional[int] = None, stop: Optional[int] = None
):
"""
select coordinates (row numbers) from a table; return the
@@ -4259,7 +4256,7 @@ def write_data_chunk(
self.table.flush()
def delete(
- self, where=None, start: Optional[int] = None, stop: Optional[int] = None,
+ self, where=None, start: Optional[int] = None, stop: Optional[int] = None
):
# delete all rows (and return the nrows)
@@ -4690,7 +4687,7 @@ def _convert_index(name: str, index: Index, encoding: str, errors: str) -> Index
if inferred_type == "date":
converted = np.asarray([v.toordinal() for v in values], dtype=np.int32)
return IndexCol(
- name, converted, "date", _tables().Time32Col(), index_name=index_name,
+ name, converted, "date", _tables().Time32Col(), index_name=index_name
)
elif inferred_type == "string":
@@ -4706,13 +4703,13 @@ def _convert_index(name: str, index: Index, encoding: str, errors: str) -> Index
elif inferred_type in ["integer", "floating"]:
return IndexCol(
- name, values=converted, kind=kind, typ=atom, index_name=index_name,
+ name, values=converted, kind=kind, typ=atom, index_name=index_name
)
else:
assert isinstance(converted, np.ndarray) and converted.dtype == object
assert kind == "object", kind
atom = _tables().ObjectAtom()
- return IndexCol(name, converted, kind, atom, index_name=index_name,)
+ return IndexCol(name, converted, kind, atom, index_name=index_name)
def _unconvert_index(
diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index ff647040ebbfb..3891afa5e332d 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -313,7 +313,7 @@ def read_sql_query(
See Also
--------
read_sql_table : Read SQL database table into a DataFrame.
- read_sql
+ read_sql : Read SQL query or database table into a DataFrame.
Notes
-----
diff --git a/pandas/plotting/_core.py b/pandas/plotting/_core.py
index d3db539084609..e466a215091ea 100644
--- a/pandas/plotting/_core.py
+++ b/pandas/plotting/_core.py
@@ -1468,15 +1468,19 @@ def scatter(self, x, y, s=None, c=None, **kwargs):
y : int or str
The column name or column position to be used as vertical
coordinates for each point.
- s : scalar or array_like, optional
+ s : str, scalar or array_like, optional
The size of each point. Possible values are:
+ - A string with the name of the column to be used for marker's size.
+
- A single scalar so all points have the same size.
- A sequence of scalars, which will be used for each point's size
recursively. For instance, when passing [2,14] all points size
will be either 2 or 14, alternatively.
+ .. versionchanged:: 1.1.0
+
c : str, int or array_like, optional
The color of each point. Possible values are:
diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py
index 63d0b8abe59d9..bc8346fd48433 100644
--- a/pandas/plotting/_matplotlib/core.py
+++ b/pandas/plotting/_matplotlib/core.py
@@ -934,6 +934,8 @@ def __init__(self, data, x, y, s=None, c=None, **kwargs):
# hide the matplotlib default for size, in case we want to change
# the handling of this argument later
s = 20
+ elif is_hashable(s) and s in data.columns:
+ s = data[s]
super().__init__(data, x, y, s=s, **kwargs)
if is_integer(c) and not self.data.columns.holds_integer():
c = self.data.columns[c]
diff --git a/pandas/plotting/_misc.py b/pandas/plotting/_misc.py
index 0d24a785b0be2..30c5ba0ed94b6 100644
--- a/pandas/plotting/_misc.py
+++ b/pandas/plotting/_misc.py
@@ -29,10 +29,10 @@ def table(ax, data, rowLabels=None, colLabels=None, **kwargs):
def register():
"""
- Register Pandas Formatters and Converters with matplotlib.
+ Register pandas formatters and converters with matplotlib.
This function modifies the global ``matplotlib.units.registry``
- dictionary. Pandas adds custom converters for
+ dictionary. pandas adds custom converters for
* pd.Timestamp
* pd.Period
@@ -43,7 +43,7 @@ def register():
See Also
--------
- deregister_matplotlib_converters
+ deregister_matplotlib_converters : Remove pandas formatters and converters.
"""
plot_backend = _get_plot_backend("matplotlib")
plot_backend.register()
@@ -51,7 +51,7 @@ def register():
def deregister():
"""
- Remove pandas' formatters and converters.
+ Remove pandas formatters and converters.
Removes the custom converters added by :func:`register`. This
attempts to set the state of the registry back to the state before
@@ -62,7 +62,8 @@ def deregister():
See Also
--------
- register_matplotlib_converters
+ register_matplotlib_converters : Register pandas formatters and converters
+ with matplotlib.
"""
plot_backend = _get_plot_backend("matplotlib")
plot_backend.deregister()
@@ -155,7 +156,7 @@ def radviz(frame, class_column, ax=None, color=None, colormap=None, **kwds):
Parameters
----------
frame : `DataFrame`
- Pandas object holding the data.
+ pandas object holding the data.
class_column : str
Column name containing the name of the data point category.
ax : :class:`matplotlib.axes.Axes`, optional
@@ -270,7 +271,7 @@ def bootstrap_plot(series, fig=None, size=50, samples=500, **kwds):
Parameters
----------
series : pandas.Series
- Pandas Series from where to get the samplings for the bootstrapping.
+ pandas Series from where to get the samplings for the bootstrapping.
fig : matplotlib.figure.Figure, default None
If given, it will use the `fig` reference for plotting instead of
creating a new one with default parameters.
diff --git a/pandas/tests/arithmetic/test_interval.py b/pandas/tests/arithmetic/test_interval.py
index d7c312b2fda1b..14846cf252edc 100644
--- a/pandas/tests/arithmetic/test_interval.py
+++ b/pandas/tests/arithmetic/test_interval.py
@@ -153,9 +153,7 @@ def test_compare_scalar_other(self, op, array, other):
expected = self.elementwise_comparison(op, array, other)
tm.assert_numpy_array_equal(result, expected)
- def test_compare_list_like_interval(
- self, op, array, interval_constructor,
- ):
+ def test_compare_list_like_interval(self, op, array, interval_constructor):
# same endpoints
other = interval_constructor(array.left, array.right)
result = op(array, other)
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index 202e30287881f..85c38dcd3566b 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -97,7 +97,7 @@ class TestNumericArraylikeArithmeticWithDatetimeLike:
# TODO: also check name retentention
@pytest.mark.parametrize("box_cls", [np.array, pd.Index, pd.Series])
@pytest.mark.parametrize(
- "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype),
+ "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype)
)
def test_mul_td64arr(self, left, box_cls):
# GH#22390
@@ -117,7 +117,7 @@ def test_mul_td64arr(self, left, box_cls):
# TODO: also check name retentention
@pytest.mark.parametrize("box_cls", [np.array, pd.Index, pd.Series])
@pytest.mark.parametrize(
- "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype),
+ "left", lefts, ids=lambda x: type(x).__name__ + str(x.dtype)
)
def test_div_td64arr(self, left, box_cls):
# GH#22390
diff --git a/pandas/tests/arrays/categorical/test_replace.py b/pandas/tests/arrays/categorical/test_replace.py
index b9ac3ce9a37ae..8b784fde1d3c5 100644
--- a/pandas/tests/arrays/categorical/test_replace.py
+++ b/pandas/tests/arrays/categorical/test_replace.py
@@ -43,9 +43,5 @@ def test_replace(to_replace, value, expected, flip_categories):
# the replace call loses categorical dtype
expected = pd.Series(np.asarray(expected))
- tm.assert_series_equal(
- expected, result, check_category_order=False,
- )
- tm.assert_series_equal(
- expected, s, check_category_order=False,
- )
+ tm.assert_series_equal(expected, result, check_category_order=False)
+ tm.assert_series_equal(expected, s, check_category_order=False)
diff --git a/pandas/tests/arrays/sparse/test_array.py b/pandas/tests/arrays/sparse/test_array.py
index cb3a70e934dcb..80562b9294126 100644
--- a/pandas/tests/arrays/sparse/test_array.py
+++ b/pandas/tests/arrays/sparse/test_array.py
@@ -676,16 +676,12 @@ def test_getslice_tuple(self):
dense = np.array([np.nan, 0, 3, 4, 0, 5, np.nan, np.nan, 0])
sparse = SparseArray(dense)
- res = sparse[
- 4:,
- ] # noqa: E231
+ res = sparse[4:,] # noqa: E231
exp = SparseArray(dense[4:,]) # noqa: E231
tm.assert_sp_array_equal(res, exp)
sparse = SparseArray(dense, fill_value=0)
- res = sparse[
- 4:,
- ] # noqa: E231
+ res = sparse[4:,] # noqa: E231
exp = SparseArray(dense[4:,], fill_value=0) # noqa: E231
tm.assert_sp_array_equal(res, exp)
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index ad6e6e4a98057..117c42e17caf3 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -35,7 +35,7 @@
np.dtype("float32"),
PandasArray(np.array([1.0, 2.0], dtype=np.dtype("float32"))),
),
- (np.array([1, 2], dtype="int64"), None, IntegerArray._from_sequence([1, 2]),),
+ (np.array([1, 2], dtype="int64"), None, IntegerArray._from_sequence([1, 2])),
# String alias passes through to NumPy
([1, 2], "float32", PandasArray(np.array([1, 2], dtype="float32"))),
# Period alias
@@ -120,10 +120,10 @@
(pd.Series([1, 2]), None, PandasArray(np.array([1, 2], dtype=np.int64))),
# String
(["a", None], "string", StringArray._from_sequence(["a", None])),
- (["a", None], pd.StringDtype(), StringArray._from_sequence(["a", None]),),
+ (["a", None], pd.StringDtype(), StringArray._from_sequence(["a", None])),
# Boolean
([True, None], "boolean", BooleanArray._from_sequence([True, None])),
- ([True, None], pd.BooleanDtype(), BooleanArray._from_sequence([True, None]),),
+ ([True, None], pd.BooleanDtype(), BooleanArray._from_sequence([True, None])),
# Index
(pd.Index([1, 2]), None, PandasArray(np.array([1, 2], dtype=np.int64))),
# Series[EA] returns the EA
@@ -174,7 +174,7 @@ def test_array_copy():
period_array(["2000", "2001"], freq="D"),
),
# interval
- ([pd.Interval(0, 1), pd.Interval(1, 2)], IntervalArray.from_breaks([0, 1, 2]),),
+ ([pd.Interval(0, 1), pd.Interval(1, 2)], IntervalArray.from_breaks([0, 1, 2])),
# datetime
(
[pd.Timestamp("2000"), pd.Timestamp("2001")],
diff --git a/pandas/tests/arrays/test_boolean.py b/pandas/tests/arrays/test_boolean.py
new file mode 100644
index 0000000000000..1a8b03562ead6
--- /dev/null
+++ b/pandas/tests/arrays/test_boolean.py
@@ -0,0 +1,934 @@
+import operator
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.arrays import BooleanArray
+from pandas.core.arrays.boolean import coerce_to_array
+from pandas.tests.extension.base import BaseOpsUtil
+
+
+def make_data():
+ return [True, False] * 4 + [np.nan] + [True, False] * 44 + [np.nan] + [True, False]
+
+
+@pytest.fixture
+def dtype():
+ return pd.BooleanDtype()
+
+
+@pytest.fixture
+def data(dtype):
+ return pd.array(make_data(), dtype=dtype)
+
+
+def test_boolean_array_constructor():
+ values = np.array([True, False, True, False], dtype="bool")
+ mask = np.array([False, False, False, True], dtype="bool")
+
+ result = BooleanArray(values, mask)
+ expected = pd.array([True, False, True, None], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ with pytest.raises(TypeError, match="values should be boolean numpy array"):
+ BooleanArray(values.tolist(), mask)
+
+ with pytest.raises(TypeError, match="mask should be boolean numpy array"):
+ BooleanArray(values, mask.tolist())
+
+ with pytest.raises(TypeError, match="values should be boolean numpy array"):
+ BooleanArray(values.astype(int), mask)
+
+ with pytest.raises(TypeError, match="mask should be boolean numpy array"):
+ BooleanArray(values, None)
+
+ with pytest.raises(ValueError, match="values must be a 1D array"):
+ BooleanArray(values.reshape(1, -1), mask)
+
+ with pytest.raises(ValueError, match="mask must be a 1D array"):
+ BooleanArray(values, mask.reshape(1, -1))
+
+
+def test_boolean_array_constructor_copy():
+ values = np.array([True, False, True, False], dtype="bool")
+ mask = np.array([False, False, False, True], dtype="bool")
+
+ result = BooleanArray(values, mask)
+ assert result._data is values
+ assert result._mask is mask
+
+ result = BooleanArray(values, mask, copy=True)
+ assert result._data is not values
+ assert result._mask is not mask
+
+
+def test_to_boolean_array():
+ expected = BooleanArray(
+ np.array([True, False, True]), np.array([False, False, False])
+ )
+
+ result = pd.array([True, False, True], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+ result = pd.array(np.array([True, False, True]), dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+ result = pd.array(np.array([True, False, True], dtype=object), dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ # with missing values
+ expected = BooleanArray(
+ np.array([True, False, True]), np.array([False, False, True])
+ )
+
+ result = pd.array([True, False, None], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+ result = pd.array(np.array([True, False, None], dtype=object), dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_all_none():
+ expected = BooleanArray(np.array([True, True, True]), np.array([True, True, True]))
+
+ result = pd.array([None, None, None], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+ result = pd.array(np.array([None, None, None], dtype=object), dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "a, b",
+ [
+ ([True, False, None, np.nan, pd.NA], [True, False, None, None, None]),
+ ([True, np.nan], [True, None]),
+ ([True, pd.NA], [True, None]),
+ ([np.nan, np.nan], [None, None]),
+ (np.array([np.nan, np.nan], dtype=float), [None, None]),
+ ],
+)
+def test_to_boolean_array_missing_indicators(a, b):
+ result = pd.array(a, dtype="boolean")
+ expected = pd.array(b, dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "values",
+ [
+ ["foo", "bar"],
+ ["1", "2"],
+ # "foo",
+ [1, 2],
+ [1.0, 2.0],
+ pd.date_range("20130101", periods=2),
+ np.array(["foo"]),
+ np.array([1, 2]),
+ np.array([1.0, 2.0]),
+ [np.nan, {"a": 1}],
+ ],
+)
+def test_to_boolean_array_error(values):
+ # error in converting existing arrays to BooleanArray
+ msg = "Need to pass bool-like value"
+ with pytest.raises(TypeError, match=msg):
+ pd.array(values, dtype="boolean")
+
+
+def test_to_boolean_array_from_integer_array():
+ result = pd.array(np.array([1, 0, 1, 0]), dtype="boolean")
+ expected = pd.array([True, False, True, False], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ # with missing values
+ result = pd.array(np.array([1, 0, 1, None]), dtype="boolean")
+ expected = pd.array([True, False, True, None], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_from_float_array():
+ result = pd.array(np.array([1.0, 0.0, 1.0, 0.0]), dtype="boolean")
+ expected = pd.array([True, False, True, False], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ # with missing values
+ result = pd.array(np.array([1.0, 0.0, 1.0, np.nan]), dtype="boolean")
+ expected = pd.array([True, False, True, None], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_integer_like():
+ # integers of 0's and 1's
+ result = pd.array([1, 0, 1, 0], dtype="boolean")
+ expected = pd.array([True, False, True, False], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ # with missing values
+ result = pd.array([1, 0, 1, None], dtype="boolean")
+ expected = pd.array([True, False, True, None], dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+
+def test_coerce_to_array():
+ # TODO this is currently not public API
+ values = np.array([True, False, True, False], dtype="bool")
+ mask = np.array([False, False, False, True], dtype="bool")
+ result = BooleanArray(*coerce_to_array(values, mask=mask))
+ expected = BooleanArray(values, mask)
+ tm.assert_extension_array_equal(result, expected)
+ assert result._data is values
+ assert result._mask is mask
+ result = BooleanArray(*coerce_to_array(values, mask=mask, copy=True))
+ expected = BooleanArray(values, mask)
+ tm.assert_extension_array_equal(result, expected)
+ assert result._data is not values
+ assert result._mask is not mask
+
+ # mixed missing from values and mask
+ values = [True, False, None, False]
+ mask = np.array([False, False, False, True], dtype="bool")
+ result = BooleanArray(*coerce_to_array(values, mask=mask))
+ expected = BooleanArray(
+ np.array([True, False, True, True]), np.array([False, False, True, True])
+ )
+ tm.assert_extension_array_equal(result, expected)
+ result = BooleanArray(*coerce_to_array(np.array(values, dtype=object), mask=mask))
+ tm.assert_extension_array_equal(result, expected)
+ result = BooleanArray(*coerce_to_array(values, mask=mask.tolist()))
+ tm.assert_extension_array_equal(result, expected)
+
+ # raise errors for wrong dimension
+ values = np.array([True, False, True, False], dtype="bool")
+ mask = np.array([False, False, False, True], dtype="bool")
+
+ with pytest.raises(ValueError, match="values must be a 1D list-like"):
+ coerce_to_array(values.reshape(1, -1))
+
+ with pytest.raises(ValueError, match="mask must be a 1D list-like"):
+ coerce_to_array(values, mask=mask.reshape(1, -1))
+
+
+def test_coerce_to_array_from_boolean_array():
+ # passing BooleanArray to coerce_to_array
+ values = np.array([True, False, True, False], dtype="bool")
+ mask = np.array([False, False, False, True], dtype="bool")
+ arr = BooleanArray(values, mask)
+ result = BooleanArray(*coerce_to_array(arr))
+ tm.assert_extension_array_equal(result, arr)
+ # no copy
+ assert result._data is arr._data
+ assert result._mask is arr._mask
+
+ result = BooleanArray(*coerce_to_array(arr), copy=True)
+ tm.assert_extension_array_equal(result, arr)
+ assert result._data is not arr._data
+ assert result._mask is not arr._mask
+
+ with pytest.raises(ValueError, match="cannot pass mask for BooleanArray input"):
+ coerce_to_array(arr, mask=mask)
+
+
+def test_coerce_to_numpy_array():
+ # with missing values -> object dtype
+ arr = pd.array([True, False, None], dtype="boolean")
+ result = np.array(arr)
+ expected = np.array([True, False, pd.NA], dtype="object")
+ tm.assert_numpy_array_equal(result, expected)
+
+ # also with no missing values -> object dtype
+ arr = pd.array([True, False, True], dtype="boolean")
+ result = np.array(arr)
+ expected = np.array([True, False, True], dtype="object")
+ tm.assert_numpy_array_equal(result, expected)
+
+ # force bool dtype
+ result = np.array(arr, dtype="bool")
+ expected = np.array([True, False, True], dtype="bool")
+ tm.assert_numpy_array_equal(result, expected)
+ # with missing values will raise error
+ arr = pd.array([True, False, None], dtype="boolean")
+ msg = (
+ "cannot convert to 'bool'-dtype NumPy array with missing values. "
+ "Specify an appropriate 'na_value' for this dtype."
+ )
+ with pytest.raises(ValueError, match=msg):
+ np.array(arr, dtype="bool")
+
+
+def test_to_boolean_array_from_strings():
+ result = BooleanArray._from_sequence_of_strings(
+ np.array(["True", "False", np.nan], dtype=object)
+ )
+ expected = BooleanArray(
+ np.array([True, False, False]), np.array([False, False, True])
+ )
+
+ tm.assert_extension_array_equal(result, expected)
+
+
+def test_to_boolean_array_from_strings_invalid_string():
+ with pytest.raises(ValueError, match="cannot be cast"):
+ BooleanArray._from_sequence_of_strings(["donkey"])
+
+
+def test_repr():
+ df = pd.DataFrame({"A": pd.array([True, False, None], dtype="boolean")})
+ expected = " A\n0 True\n1 False\n2 <NA>"
+ assert repr(df) == expected
+
+ expected = "0 True\n1 False\n2 <NA>\nName: A, dtype: boolean"
+ assert repr(df.A) == expected
+
+ expected = "<BooleanArray>\n[True, False, <NA>]\nLength: 3, dtype: boolean"
+ assert repr(df.A.array) == expected
+
+
+@pytest.mark.parametrize("box", [True, False], ids=["series", "array"])
+def test_to_numpy(box):
+ con = pd.Series if box else pd.array
+ # default (with or without missing values) -> object dtype
+ arr = con([True, False, True], dtype="boolean")
+ result = arr.to_numpy()
+ expected = np.array([True, False, True], dtype="object")
+ tm.assert_numpy_array_equal(result, expected)
+
+ arr = con([True, False, None], dtype="boolean")
+ result = arr.to_numpy()
+ expected = np.array([True, False, pd.NA], dtype="object")
+ tm.assert_numpy_array_equal(result, expected)
+
+ arr = con([True, False, None], dtype="boolean")
+ result = arr.to_numpy(dtype="str")
+ expected = np.array([True, False, pd.NA], dtype="<U5")
+ tm.assert_numpy_array_equal(result, expected)
+
+ # no missing values -> can convert to bool, otherwise raises
+ arr = con([True, False, True], dtype="boolean")
+ result = arr.to_numpy(dtype="bool")
+ expected = np.array([True, False, True], dtype="bool")
+ tm.assert_numpy_array_equal(result, expected)
+
+ arr = con([True, False, None], dtype="boolean")
+ with pytest.raises(ValueError, match="cannot convert to 'bool'-dtype"):
+ result = arr.to_numpy(dtype="bool")
+
+ # specify dtype and na_value
+ arr = con([True, False, None], dtype="boolean")
+ result = arr.to_numpy(dtype=object, na_value=None)
+ expected = np.array([True, False, None], dtype="object")
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = arr.to_numpy(dtype=bool, na_value=False)
+ expected = np.array([True, False, False], dtype="bool")
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = arr.to_numpy(dtype="int64", na_value=-99)
+ expected = np.array([1, 0, -99], dtype="int64")
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = arr.to_numpy(dtype="float64", na_value=np.nan)
+ expected = np.array([1, 0, np.nan], dtype="float64")
+ tm.assert_numpy_array_equal(result, expected)
+
+ # converting to int or float without specifying na_value raises
+ with pytest.raises(ValueError, match="cannot convert to 'int64'-dtype"):
+ arr.to_numpy(dtype="int64")
+ with pytest.raises(ValueError, match="cannot convert to 'float64'-dtype"):
+ arr.to_numpy(dtype="float64")
+
+
+def test_to_numpy_copy():
+ # to_numpy can be zero-copy if no missing values
+ arr = pd.array([True, False, True], dtype="boolean")
+ result = arr.to_numpy(dtype=bool)
+ result[0] = False
+ tm.assert_extension_array_equal(
+ arr, pd.array([False, False, True], dtype="boolean")
+ )
+
+ arr = pd.array([True, False, True], dtype="boolean")
+ result = arr.to_numpy(dtype=bool, copy=True)
+ result[0] = False
+ tm.assert_extension_array_equal(arr, pd.array([True, False, True], dtype="boolean"))
+
+
+def test_astype():
+ # with missing values
+ arr = pd.array([True, False, None], dtype="boolean")
+
+ with pytest.raises(ValueError, match="cannot convert NA to integer"):
+ arr.astype("int64")
+
+ with pytest.raises(ValueError, match="cannot convert float NaN to"):
+ arr.astype("bool")
+
+ result = arr.astype("float64")
+ expected = np.array([1, 0, np.nan], dtype="float64")
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = arr.astype("str")
+ expected = np.array(["True", "False", "<NA>"], dtype="object")
+ tm.assert_numpy_array_equal(result, expected)
+
+ # no missing values
+ arr = pd.array([True, False, True], dtype="boolean")
+ result = arr.astype("int64")
+ expected = np.array([1, 0, 1], dtype="int64")
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = arr.astype("bool")
+ expected = np.array([True, False, True], dtype="bool")
+ tm.assert_numpy_array_equal(result, expected)
+
+
+def test_astype_to_boolean_array():
+ # astype to BooleanArray
+ arr = pd.array([True, False, None], dtype="boolean")
+
+ result = arr.astype("boolean")
+ tm.assert_extension_array_equal(result, arr)
+ result = arr.astype(pd.BooleanDtype())
+ tm.assert_extension_array_equal(result, arr)
+
+
+def test_astype_to_integer_array():
+ # astype to IntegerArray
+ arr = pd.array([True, False, None], dtype="boolean")
+
+ result = arr.astype("Int64")
+ expected = pd.array([1, 0, None], dtype="Int64")
+ tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("na", [None, np.nan, pd.NA])
+def test_setitem_missing_values(na):
+ arr = pd.array([True, False, None], dtype="boolean")
+ expected = pd.array([True, None, None], dtype="boolean")
+ arr[1] = na
+ tm.assert_extension_array_equal(arr, expected)
+
+
+@pytest.mark.parametrize(
+ "ufunc", [np.add, np.logical_or, np.logical_and, np.logical_xor]
+)
+def test_ufuncs_binary(ufunc):
+ # two BooleanArrays
+ a = pd.array([True, False, None], dtype="boolean")
+ result = ufunc(a, a)
+ expected = pd.array(ufunc(a._data, a._data), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_extension_array_equal(result, expected)
+
+ s = pd.Series(a)
+ result = ufunc(s, a)
+ expected = pd.Series(ufunc(a._data, a._data), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_series_equal(result, expected)
+
+ # Boolean with numpy array
+ arr = np.array([True, True, False])
+ result = ufunc(a, arr)
+ expected = pd.array(ufunc(a._data, arr), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_extension_array_equal(result, expected)
+
+ result = ufunc(arr, a)
+ expected = pd.array(ufunc(arr, a._data), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_extension_array_equal(result, expected)
+
+ # BooleanArray with scalar
+ result = ufunc(a, True)
+ expected = pd.array(ufunc(a._data, True), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_extension_array_equal(result, expected)
+
+ result = ufunc(True, a)
+ expected = pd.array(ufunc(True, a._data), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_extension_array_equal(result, expected)
+
+ # not handled types
+ with pytest.raises(TypeError):
+ ufunc(a, "test")
+
+
+@pytest.mark.parametrize("ufunc", [np.logical_not])
+def test_ufuncs_unary(ufunc):
+ a = pd.array([True, False, None], dtype="boolean")
+ result = ufunc(a)
+ expected = pd.array(ufunc(a._data), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_extension_array_equal(result, expected)
+
+ s = pd.Series(a)
+ result = ufunc(s)
+ expected = pd.Series(ufunc(a._data), dtype="boolean")
+ expected[a._mask] = np.nan
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize("values", [[True, False], [True, None]])
+def test_ufunc_reduce_raises(values):
+ a = pd.array(values, dtype="boolean")
+ with pytest.raises(NotImplementedError):
+ np.add.reduce(a)
+
+
+class TestUnaryOps:
+ def test_invert(self):
+ a = pd.array([True, False, None], dtype="boolean")
+ expected = pd.array([False, True, None], dtype="boolean")
+ tm.assert_extension_array_equal(~a, expected)
+
+ expected = pd.Series(expected, index=["a", "b", "c"], name="name")
+ result = ~pd.Series(a, index=["a", "b", "c"], name="name")
+ tm.assert_series_equal(result, expected)
+
+ df = pd.DataFrame({"A": a, "B": [True, False, False]}, index=["a", "b", "c"])
+ result = ~df
+ expected = pd.DataFrame(
+ {"A": expected, "B": [False, True, True]}, index=["a", "b", "c"]
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+class TestLogicalOps(BaseOpsUtil):
+ def test_numpy_scalars_ok(self, all_logical_operators):
+ a = pd.array([True, False, None], dtype="boolean")
+ op = getattr(a, all_logical_operators)
+
+ tm.assert_extension_array_equal(op(True), op(np.bool(True)))
+ tm.assert_extension_array_equal(op(False), op(np.bool(False)))
+
+ def get_op_from_name(self, op_name):
+ short_opname = op_name.strip("_")
+ short_opname = short_opname if "xor" in short_opname else short_opname + "_"
+ try:
+ op = getattr(operator, short_opname)
+ except AttributeError:
+ # Assume it is the reverse operator
+ rop = getattr(operator, short_opname[1:])
+ op = lambda x, y: rop(y, x)
+
+ return op
+
+ def test_empty_ok(self, all_logical_operators):
+ a = pd.array([], dtype="boolean")
+ op_name = all_logical_operators
+ result = getattr(a, op_name)(True)
+ tm.assert_extension_array_equal(a, result)
+
+ result = getattr(a, op_name)(False)
+ tm.assert_extension_array_equal(a, result)
+
+ # TODO: pd.NA
+ # result = getattr(a, op_name)(pd.NA)
+ # tm.assert_extension_array_equal(a, result)
+
+ def test_logical_length_mismatch_raises(self, all_logical_operators):
+ op_name = all_logical_operators
+ a = pd.array([True, False, None], dtype="boolean")
+ msg = "Lengths must match to compare"
+
+ with pytest.raises(ValueError, match=msg):
+ getattr(a, op_name)([True, False])
+
+ with pytest.raises(ValueError, match=msg):
+ getattr(a, op_name)(np.array([True, False]))
+
+ with pytest.raises(ValueError, match=msg):
+ getattr(a, op_name)(pd.array([True, False], dtype="boolean"))
+
+ def test_logical_nan_raises(self, all_logical_operators):
+ op_name = all_logical_operators
+ a = pd.array([True, False, None], dtype="boolean")
+ msg = "Got float instead"
+
+ with pytest.raises(TypeError, match=msg):
+ getattr(a, op_name)(np.nan)
+
+ @pytest.mark.parametrize("other", ["a", 1])
+ def test_non_bool_or_na_other_raises(self, other, all_logical_operators):
+ a = pd.array([True, False], dtype="boolean")
+ with pytest.raises(TypeError, match=str(type(other).__name__)):
+ getattr(a, all_logical_operators)(other)
+
+ def test_kleene_or(self):
+ # A clear test of behavior.
+ a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ b = pd.array([True, False, None] * 3, dtype="boolean")
+ result = a | b
+ expected = pd.array(
+ [True, True, True, True, False, None, True, None, None], dtype="boolean"
+ )
+ tm.assert_extension_array_equal(result, expected)
+
+ result = b | a
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ tm.assert_extension_array_equal(
+ a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ )
+ tm.assert_extension_array_equal(
+ b, pd.array([True, False, None] * 3, dtype="boolean")
+ )
+
+ @pytest.mark.parametrize(
+ "other, expected",
+ [
+ (pd.NA, [True, None, None]),
+ (True, [True, True, True]),
+ (np.bool_(True), [True, True, True]),
+ (False, [True, False, None]),
+ (np.bool_(False), [True, False, None]),
+ ],
+ )
+ def test_kleene_or_scalar(self, other, expected):
+ # TODO: test True & False
+ a = pd.array([True, False, None], dtype="boolean")
+ result = a | other
+ expected = pd.array(expected, dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ result = other | a
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ tm.assert_extension_array_equal(
+ a, pd.array([True, False, None], dtype="boolean")
+ )
+
+ def test_kleene_and(self):
+ # A clear test of behavior.
+ a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ b = pd.array([True, False, None] * 3, dtype="boolean")
+ result = a & b
+ expected = pd.array(
+ [True, False, None, False, False, False, None, False, None], dtype="boolean"
+ )
+ tm.assert_extension_array_equal(result, expected)
+
+ result = b & a
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ tm.assert_extension_array_equal(
+ a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ )
+ tm.assert_extension_array_equal(
+ b, pd.array([True, False, None] * 3, dtype="boolean")
+ )
+
+ @pytest.mark.parametrize(
+ "other, expected",
+ [
+ (pd.NA, [None, False, None]),
+ (True, [True, False, None]),
+ (False, [False, False, False]),
+ (np.bool_(True), [True, False, None]),
+ (np.bool_(False), [False, False, False]),
+ ],
+ )
+ def test_kleene_and_scalar(self, other, expected):
+ a = pd.array([True, False, None], dtype="boolean")
+ result = a & other
+ expected = pd.array(expected, dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ result = other & a
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ tm.assert_extension_array_equal(
+ a, pd.array([True, False, None], dtype="boolean")
+ )
+
+ def test_kleene_xor(self):
+ a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ b = pd.array([True, False, None] * 3, dtype="boolean")
+ result = a ^ b
+ expected = pd.array(
+ [False, True, None, True, False, None, None, None, None], dtype="boolean"
+ )
+ tm.assert_extension_array_equal(result, expected)
+
+ result = b ^ a
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ tm.assert_extension_array_equal(
+ a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ )
+ tm.assert_extension_array_equal(
+ b, pd.array([True, False, None] * 3, dtype="boolean")
+ )
+
+ @pytest.mark.parametrize(
+ "other, expected",
+ [
+ (pd.NA, [None, None, None]),
+ (True, [False, True, None]),
+ (np.bool_(True), [False, True, None]),
+ (np.bool_(False), [True, False, None]),
+ ],
+ )
+ def test_kleene_xor_scalar(self, other, expected):
+ a = pd.array([True, False, None], dtype="boolean")
+ result = a ^ other
+ expected = pd.array(expected, dtype="boolean")
+ tm.assert_extension_array_equal(result, expected)
+
+ result = other ^ a
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ tm.assert_extension_array_equal(
+ a, pd.array([True, False, None], dtype="boolean")
+ )
+
+ @pytest.mark.parametrize("other", [True, False, pd.NA, [True, False, None] * 3])
+ def test_no_masked_assumptions(self, other, all_logical_operators):
+ # The logical operations should not assume that masked values are False!
+ a = pd.arrays.BooleanArray(
+ np.array([True, True, True, False, False, False, True, False, True]),
+ np.array([False] * 6 + [True, True, True]),
+ )
+ b = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ if isinstance(other, list):
+ other = pd.array(other, dtype="boolean")
+
+ result = getattr(a, all_logical_operators)(other)
+ expected = getattr(b, all_logical_operators)(other)
+ tm.assert_extension_array_equal(result, expected)
+
+ if isinstance(other, BooleanArray):
+ other._data[other._mask] = True
+ a._data[a._mask] = False
+
+ result = getattr(a, all_logical_operators)(other)
+ expected = getattr(b, all_logical_operators)(other)
+ tm.assert_extension_array_equal(result, expected)
+
+
+class TestComparisonOps(BaseOpsUtil):
+ def _compare_other(self, data, op_name, other):
+ op = self.get_op_from_name(op_name)
+
+ # array
+ result = pd.Series(op(data, other))
+ expected = pd.Series(op(data._data, other), dtype="boolean")
+ # propagate NAs
+ expected[data._mask] = pd.NA
+
+ tm.assert_series_equal(result, expected)
+
+ # series
+ s = pd.Series(data)
+ result = op(s, other)
+
+ expected = pd.Series(data._data)
+ expected = op(expected, other)
+ expected = expected.astype("boolean")
+ # propagate NAs
+ expected[data._mask] = pd.NA
+
+ tm.assert_series_equal(result, expected)
+
+ def test_compare_scalar(self, data, all_compare_operators):
+ op_name = all_compare_operators
+ self._compare_other(data, op_name, True)
+
+ def test_compare_array(self, data, all_compare_operators):
+ op_name = all_compare_operators
+ other = pd.array([True] * len(data), dtype="boolean")
+ self._compare_other(data, op_name, other)
+ other = np.array([True] * len(data))
+ self._compare_other(data, op_name, other)
+ other = pd.Series([True] * len(data))
+ self._compare_other(data, op_name, other)
+
+ @pytest.mark.parametrize("other", [True, False, pd.NA])
+ def test_scalar(self, other, all_compare_operators):
+ op = self.get_op_from_name(all_compare_operators)
+ a = pd.array([True, False, None], dtype="boolean")
+
+ result = op(a, other)
+
+ if other is pd.NA:
+ expected = pd.array([None, None, None], dtype="boolean")
+ else:
+ values = op(a._data, other)
+ expected = BooleanArray(values, a._mask, copy=True)
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ result[0] = None
+ tm.assert_extension_array_equal(
+ a, pd.array([True, False, None], dtype="boolean")
+ )
+
+ def test_array(self, all_compare_operators):
+ op = self.get_op_from_name(all_compare_operators)
+ a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ b = pd.array([True, False, None] * 3, dtype="boolean")
+
+ result = op(a, b)
+
+ values = op(a._data, b._data)
+ mask = a._mask | b._mask
+ expected = BooleanArray(values, mask)
+ tm.assert_extension_array_equal(result, expected)
+
+ # ensure we haven't mutated anything inplace
+ result[0] = None
+ tm.assert_extension_array_equal(
+ a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")
+ )
+ tm.assert_extension_array_equal(
+ b, pd.array([True, False, None] * 3, dtype="boolean")
+ )
+
+
+class TestArithmeticOps(BaseOpsUtil):
+ def test_error(self, data, all_arithmetic_operators):
+ # invalid ops
+
+ op = all_arithmetic_operators
+ s = pd.Series(data)
+ ops = getattr(s, op)
+ opa = getattr(data, op)
+
+ # invalid scalars
+ with pytest.raises(TypeError):
+ ops("foo")
+ with pytest.raises(TypeError):
+ ops(pd.Timestamp("20180101"))
+
+ # invalid array-likes
+ if op not in ("__mul__", "__rmul__"):
+ # TODO(extension) numpy's mul with object array sees booleans as numbers
+ with pytest.raises(TypeError):
+ ops(pd.Series("foo", index=s.index))
+
+ # 2d
+ result = opa(pd.DataFrame({"A": s}))
+ assert result is NotImplemented
+
+ with pytest.raises(NotImplementedError):
+ opa(np.arange(len(s)).reshape(-1, len(s)))
+
+
+@pytest.mark.parametrize("dropna", [True, False])
+def test_reductions_return_types(dropna, data, all_numeric_reductions):
+ op = all_numeric_reductions
+ s = pd.Series(data)
+ if dropna:
+ s = s.dropna()
+
+ if op in ("sum", "prod"):
+ assert isinstance(getattr(s, op)(), np.int64)
+ elif op in ("min", "max"):
+ assert isinstance(getattr(s, op)(), np.bool_)
+ else:
+ # "mean", "std", "var", "median", "kurt", "skew"
+ assert isinstance(getattr(s, op)(), np.float64)
+
+
+@pytest.mark.parametrize(
+ "values, exp_any, exp_all, exp_any_noskip, exp_all_noskip",
+ [
+ ([True, pd.NA], True, True, True, pd.NA),
+ ([False, pd.NA], False, False, pd.NA, False),
+ ([pd.NA], False, True, pd.NA, pd.NA),
+ ([], False, True, False, True),
+ ],
+)
+def test_any_all(values, exp_any, exp_all, exp_any_noskip, exp_all_noskip):
+ # the methods return numpy scalars
+ exp_any = pd.NA if exp_any is pd.NA else np.bool_(exp_any)
+ exp_all = pd.NA if exp_all is pd.NA else np.bool_(exp_all)
+ exp_any_noskip = pd.NA if exp_any_noskip is pd.NA else np.bool_(exp_any_noskip)
+ exp_all_noskip = pd.NA if exp_all_noskip is pd.NA else np.bool_(exp_all_noskip)
+
+ for con in [pd.array, pd.Series]:
+ a = con(values, dtype="boolean")
+ assert a.any() is exp_any
+ assert a.all() is exp_all
+ assert a.any(skipna=False) is exp_any_noskip
+ assert a.all(skipna=False) is exp_all_noskip
+
+ assert np.any(a.any()) is exp_any
+ assert np.all(a.all()) is exp_all
+
+
+# TODO when BooleanArray coerces to object dtype numpy array, need to do conversion
+# manually in the indexing code
+# def test_indexing_boolean_mask():
+# arr = pd.array([1, 2, 3, 4], dtype="Int64")
+# mask = pd.array([True, False, True, False], dtype="boolean")
+# result = arr[mask]
+# expected = pd.array([1, 3], dtype="Int64")
+# tm.assert_extension_array_equal(result, expected)
+
+# # missing values -> error
+# mask = pd.array([True, False, True, None], dtype="boolean")
+# with pytest.raises(IndexError):
+# result = arr[mask]
+
+
+@td.skip_if_no("pyarrow", min_version="0.15.0")
+def test_arrow_array(data):
+ # protocol added in 0.15.0
+ import pyarrow as pa
+
+ arr = pa.array(data)
+
+ # TODO use to_numpy(na_value=None) here
+ data_object = np.array(data, dtype=object)
+ data_object[data.isna()] = None
+ expected = pa.array(data_object, type=pa.bool_(), from_pandas=True)
+ assert arr.equals(expected)
+
+
+@td.skip_if_no("pyarrow", min_version="0.15.1.dev")
+def test_arrow_roundtrip():
+ # roundtrip possible from arrow 1.0.0
+ import pyarrow as pa
+
+ data = pd.array([True, False, None], dtype="boolean")
+ df = pd.DataFrame({"a": data})
+ table = pa.table(df)
+ assert table.field("a").type == "bool"
+ result = table.to_pandas()
+ assert isinstance(result["a"].dtype, pd.BooleanDtype)
+ tm.assert_frame_equal(result, df)
+
+
+def test_value_counts_na():
+ arr = pd.array([True, False, pd.NA], dtype="boolean")
+ result = arr.value_counts(dropna=False)
+ expected = pd.Series([1, 1, 1], index=[True, False, pd.NA], dtype="Int64")
+ tm.assert_series_equal(result, expected)
+
+ result = arr.value_counts(dropna=True)
+ expected = pd.Series([1, 1], index=[True, False], dtype="Int64")
+ tm.assert_series_equal(result, expected)
+
+
+def test_diff():
+ a = pd.array(
+ [True, True, False, False, True, None, True, None, False], dtype="boolean"
+ )
+ result = pd.core.algorithms.diff(a, 1)
+ expected = pd.array(
+ [None, False, True, False, True, None, None, None, None], dtype="boolean"
+ )
+ tm.assert_extension_array_equal(result, expected)
+
+ s = pd.Series(a)
+ result = s.diff()
+ expected = pd.Series(expected)
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
index c86b4f71ee592..a32529cb58ba3 100644
--- a/pandas/tests/arrays/test_timedeltas.py
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -46,7 +46,7 @@ def test_incorrect_dtype_raises(self):
TimedeltaArray(np.array([1, 2, 3], dtype="i8"), dtype="category")
with pytest.raises(
- ValueError, match=r"dtype int64 cannot be converted to timedelta64\[ns\]",
+ ValueError, match=r"dtype int64 cannot be converted to timedelta64\[ns\]"
):
TimedeltaArray(np.array([1, 2, 3], dtype="i8"), dtype=np.dtype("int64"))
diff --git a/pandas/tests/base/test_conversion.py b/pandas/tests/base/test_conversion.py
index 59f9103072fe9..370b887b78eab 100644
--- a/pandas/tests/base/test_conversion.py
+++ b/pandas/tests/base/test_conversion.py
@@ -187,7 +187,7 @@ def test_iter_box(self):
PeriodArray,
pd.core.dtypes.dtypes.PeriodDtype("A-DEC"),
),
- (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval",),
+ (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval"),
# This test is currently failing for datetime64[ns] and timedelta64[ns].
# The NumPy type system is sufficient for representing these types, so
# we just use NumPy for Series / DataFrame columns of these types (so
@@ -289,10 +289,7 @@ def test_array_multiindex_raises():
pd.core.arrays.period_array(["2000", "2001"], freq="D"),
np.array([pd.Period("2000", freq="D"), pd.Period("2001", freq="D")]),
),
- (
- pd.core.arrays.integer_array([0, np.nan]),
- np.array([0, pd.NA], dtype=object),
- ),
+ (pd.core.arrays.integer_array([0, np.nan]), np.array([0, pd.NA], dtype=object)),
(
IntervalArray.from_breaks([0, 1, 2]),
np.array([pd.Interval(0, 1), pd.Interval(1, 2)], dtype=object),
diff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py
index 7ba59786bb0fa..cad46d0a23967 100644
--- a/pandas/tests/dtypes/test_missing.py
+++ b/pandas/tests/dtypes/test_missing.py
@@ -185,6 +185,21 @@ def test_isna_datetime(self):
exp = np.zeros(len(mask), dtype=bool)
tm.assert_numpy_array_equal(mask, exp)
+ def test_isna_old_datetimelike(self):
+ # isna_old should work for dt64tz, td64, and period, not just tznaive
+ dti = pd.date_range("2016-01-01", periods=3)
+ dta = dti._data
+ dta[-1] = pd.NaT
+ expected = np.array([False, False, True], dtype=bool)
+
+ objs = [dta, dta.tz_localize("US/Eastern"), dta - dta, dta.to_period("D")]
+
+ for obj in objs:
+ with cf.option_context("mode.use_inf_as_na", True):
+ result = pd.isna(obj)
+
+ tm.assert_numpy_array_equal(result, expected)
+
@pytest.mark.parametrize(
"value, expected",
[
diff --git a/pandas/tests/extension/test_categorical.py b/pandas/tests/extension/test_categorical.py
index 059d3453995bd..c9b3eb7baf45b 100644
--- a/pandas/tests/extension/test_categorical.py
+++ b/pandas/tests/extension/test_categorical.py
@@ -283,8 +283,7 @@ def _compare_other(self, s, data, op_name, other):
op(data, other)
@pytest.mark.parametrize(
- "categories",
- [["a", "b"], [0, 1], [pd.Timestamp("2019"), pd.Timestamp("2020")]],
+ "categories", [["a", "b"], [0, 1], [pd.Timestamp("2019"), pd.Timestamp("2020")]]
)
def test_not_equal_with_na(self, categories):
# https://github.com/pandas-dev/pandas/issues/32276
diff --git a/pandas/tests/frame/conftest.py b/pandas/tests/frame/conftest.py
index e89b2c6f1fec0..486d140849159 100644
--- a/pandas/tests/frame/conftest.py
+++ b/pandas/tests/frame/conftest.py
@@ -79,66 +79,6 @@ def bool_frame_with_na():
return df
-@pytest.fixture
-def int_frame():
- """
- Fixture for DataFrame of ints with index of unique strings
-
- Columns are ['A', 'B', 'C', 'D']
-
- A B C D
- vpBeWjM651 1 0 1 0
- 5JyxmrP1En -1 0 0 0
- qEDaoD49U2 -1 1 0 0
- m66TkTfsFe 0 0 0 0
- EHPaNzEUFm -1 0 -1 0
- fpRJCevQhi 2 0 0 0
- OlQvnmfi3Q 0 0 -2 0
- ... .. .. .. ..
- uB1FPlz4uP 0 0 0 1
- EcSe6yNzCU 0 0 -1 0
- L50VudaiI8 -1 1 -2 0
- y3bpw4nwIp 0 -1 0 0
- H0RdLLwrCT 1 1 0 0
- rY82K0vMwm 0 0 0 0
- 1OPIUjnkjk 2 0 0 0
-
- [30 rows x 4 columns]
- """
- df = DataFrame({k: v.astype(int) for k, v in tm.getSeriesData().items()})
- # force these all to int64 to avoid platform testing issues
- return DataFrame({c: s for c, s in df.items()}, dtype=np.int64)
-
-
-@pytest.fixture
-def datetime_frame():
- """
- Fixture for DataFrame of floats with DatetimeIndex
-
- Columns are ['A', 'B', 'C', 'D']
-
- A B C D
- 2000-01-03 -1.122153 0.468535 0.122226 1.693711
- 2000-01-04 0.189378 0.486100 0.007864 -1.216052
- 2000-01-05 0.041401 -0.835752 -0.035279 -0.414357
- 2000-01-06 0.430050 0.894352 0.090719 0.036939
- 2000-01-07 -0.620982 -0.668211 -0.706153 1.466335
- 2000-01-10 -0.752633 0.328434 -0.815325 0.699674
- 2000-01-11 -2.236969 0.615737 -0.829076 -1.196106
- ... ... ... ... ...
- 2000-02-03 1.642618 -0.579288 0.046005 1.385249
- 2000-02-04 -0.544873 -1.160962 -0.284071 -1.418351
- 2000-02-07 -2.656149 -0.601387 1.410148 0.444150
- 2000-02-08 -1.201881 -1.289040 0.772992 -1.445300
- 2000-02-09 1.377373 0.398619 1.008453 -0.928207
- 2000-02-10 0.473194 -0.636677 0.984058 0.511519
- 2000-02-11 -0.965556 0.408313 -1.312844 -0.381948
-
- [30 rows x 4 columns]
- """
- return DataFrame(tm.getTimeSeriesData())
-
-
@pytest.fixture
def float_string_frame():
"""
diff --git a/pandas/tests/frame/indexing/test_get.py b/pandas/tests/frame/indexing/test_get.py
new file mode 100644
index 0000000000000..5f2651eec683c
--- /dev/null
+++ b/pandas/tests/frame/indexing/test_get.py
@@ -0,0 +1,27 @@
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestGet:
+ def test_get(self, float_frame):
+ b = float_frame.get("B")
+ tm.assert_series_equal(b, float_frame["B"])
+
+ assert float_frame.get("foo") is None
+ tm.assert_series_equal(
+ float_frame.get("foo", float_frame["B"]), float_frame["B"]
+ )
+
+ @pytest.mark.parametrize(
+ "df",
+ [
+ DataFrame(),
+ DataFrame(columns=list("AB")),
+ DataFrame(columns=list("AB"), index=range(3)),
+ ],
+ )
+ def test_get_none(self, df):
+ # see gh-5652
+ assert df.get(None) is None
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index 4fa5e4196ae5b..9e6d41a8886b3 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -31,29 +31,6 @@
_slice_msg = "slice indices must be integers or None or have an __index__ method"
-class TestGet:
- def test_get(self, float_frame):
- b = float_frame.get("B")
- tm.assert_series_equal(b, float_frame["B"])
-
- assert float_frame.get("foo") is None
- tm.assert_series_equal(
- float_frame.get("foo", float_frame["B"]), float_frame["B"]
- )
-
- @pytest.mark.parametrize(
- "df",
- [
- DataFrame(),
- DataFrame(columns=list("AB")),
- DataFrame(columns=list("AB"), index=range(3)),
- ],
- )
- def test_get_none(self, df):
- # see gh-5652
- assert df.get(None) is None
-
-
class TestDataFrameIndexing:
def test_getitem(self, float_frame):
# Slicing
@@ -1639,11 +1616,6 @@ def test_reindex_methods(self, method, expected_values):
actual = df.reindex(target, method=method)
tm.assert_frame_equal(expected, actual)
- actual = df.reindex_like(df, method=method, tolerance=0)
- tm.assert_frame_equal(df, actual)
- actual = df.reindex_like(df, method=method, tolerance=[0, 0, 0, 0])
- tm.assert_frame_equal(df, actual)
-
actual = df.reindex(target, method=method, tolerance=1)
tm.assert_frame_equal(expected, actual)
actual = df.reindex(target, method=method, tolerance=[1, 1, 1, 1])
@@ -1664,17 +1636,6 @@ def test_reindex_methods(self, method, expected_values):
actual = df[::-1].reindex(target, method=switched_method)
tm.assert_frame_equal(expected, actual)
- def test_reindex_subclass(self):
- # https://github.com/pandas-dev/pandas/issues/31925
- class MyDataFrame(DataFrame):
- pass
-
- expected = DataFrame()
- df = MyDataFrame()
- result = df.reindex_like(expected)
-
- tm.assert_frame_equal(result, expected)
-
def test_reindex_methods_nearest_special(self):
df = pd.DataFrame({"x": list(range(5))})
target = np.array([-0.1, 0.9, 1.1, 1.5])
diff --git a/pandas/tests/frame/methods/test_drop.py b/pandas/tests/frame/methods/test_drop.py
index 0bc234dcb39aa..177d10cdbf615 100644
--- a/pandas/tests/frame/methods/test_drop.py
+++ b/pandas/tests/frame/methods/test_drop.py
@@ -6,7 +6,7 @@
from pandas.errors import PerformanceWarning
import pandas as pd
-from pandas import DataFrame, Index, MultiIndex
+from pandas import DataFrame, Index, MultiIndex, Series, Timestamp
import pandas._testing as tm
@@ -258,3 +258,162 @@ def test_drop_non_empty_list(self, index, drop_labels):
# GH# 21494
with pytest.raises(KeyError, match="not found in axis"):
pd.DataFrame(index=index).drop(drop_labels)
+
+ def test_mixed_depth_drop(self):
+ arrays = [
+ ["a", "top", "top", "routine1", "routine1", "routine2"],
+ ["", "OD", "OD", "result1", "result2", "result1"],
+ ["", "wx", "wy", "", "", ""],
+ ]
+
+ tuples = sorted(zip(*arrays))
+ index = MultiIndex.from_tuples(tuples)
+ df = DataFrame(np.random.randn(4, 6), columns=index)
+
+ result = df.drop("a", axis=1)
+ expected = df.drop([("a", "", "")], axis=1)
+ tm.assert_frame_equal(expected, result)
+
+ result = df.drop(["top"], axis=1)
+ expected = df.drop([("top", "OD", "wx")], axis=1)
+ expected = expected.drop([("top", "OD", "wy")], axis=1)
+ tm.assert_frame_equal(expected, result)
+
+ result = df.drop(("top", "OD", "wx"), axis=1)
+ expected = df.drop([("top", "OD", "wx")], axis=1)
+ tm.assert_frame_equal(expected, result)
+
+ expected = df.drop([("top", "OD", "wy")], axis=1)
+ expected = df.drop("top", axis=1)
+
+ result = df.drop("result1", level=1, axis=1)
+ expected = df.drop(
+ [("routine1", "result1", ""), ("routine2", "result1", "")], axis=1
+ )
+ tm.assert_frame_equal(expected, result)
+
+ def test_drop_multiindex_other_level_nan(self):
+ # GH#12754
+ df = (
+ DataFrame(
+ {
+ "A": ["one", "one", "two", "two"],
+ "B": [np.nan, 0.0, 1.0, 2.0],
+ "C": ["a", "b", "c", "c"],
+ "D": [1, 2, 3, 4],
+ }
+ )
+ .set_index(["A", "B", "C"])
+ .sort_index()
+ )
+ result = df.drop("c", level="C")
+ expected = DataFrame(
+ [2, 1],
+ columns=["D"],
+ index=pd.MultiIndex.from_tuples(
+ [("one", 0.0, "b"), ("one", np.nan, "a")], names=["A", "B", "C"]
+ ),
+ )
+ tm.assert_frame_equal(result, expected)
+
+ def test_drop_nonunique(self):
+ df = DataFrame(
+ [
+ ["x-a", "x", "a", 1.5],
+ ["x-a", "x", "a", 1.2],
+ ["z-c", "z", "c", 3.1],
+ ["x-a", "x", "a", 4.1],
+ ["x-b", "x", "b", 5.1],
+ ["x-b", "x", "b", 4.1],
+ ["x-b", "x", "b", 2.2],
+ ["y-a", "y", "a", 1.2],
+ ["z-b", "z", "b", 2.1],
+ ],
+ columns=["var1", "var2", "var3", "var4"],
+ )
+
+ grp_size = df.groupby("var1").size()
+ drop_idx = grp_size.loc[grp_size == 1]
+
+ idf = df.set_index(["var1", "var2", "var3"])
+
+ # it works! GH#2101
+ result = idf.drop(drop_idx.index, level=0).reset_index()
+ expected = df[-df.var1.isin(drop_idx.index)]
+
+ result.index = expected.index
+
+ tm.assert_frame_equal(result, expected)
+
+ def test_drop_level(self):
+ index = MultiIndex(
+ levels=[["foo", "bar", "baz", "qux"], ["one", "two", "three"]],
+ codes=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]],
+ names=["first", "second"],
+ )
+ frame = DataFrame(
+ np.random.randn(10, 3),
+ index=index,
+ columns=Index(["A", "B", "C"], name="exp"),
+ )
+
+ result = frame.drop(["bar", "qux"], level="first")
+ expected = frame.iloc[[0, 1, 2, 5, 6]]
+ tm.assert_frame_equal(result, expected)
+
+ result = frame.drop(["two"], level="second")
+ expected = frame.iloc[[0, 2, 3, 6, 7, 9]]
+ tm.assert_frame_equal(result, expected)
+
+ result = frame.T.drop(["bar", "qux"], axis=1, level="first")
+ expected = frame.iloc[[0, 1, 2, 5, 6]].T
+ tm.assert_frame_equal(result, expected)
+
+ result = frame.T.drop(["two"], axis=1, level="second")
+ expected = frame.iloc[[0, 2, 3, 6, 7, 9]].T
+ tm.assert_frame_equal(result, expected)
+
+ def test_drop_level_nonunique_datetime(self):
+ # GH#12701
+ idx = Index([2, 3, 4, 4, 5], name="id")
+ idxdt = pd.to_datetime(
+ [
+ "201603231400",
+ "201603231500",
+ "201603231600",
+ "201603231600",
+ "201603231700",
+ ]
+ )
+ df = DataFrame(np.arange(10).reshape(5, 2), columns=list("ab"), index=idx)
+ df["tstamp"] = idxdt
+ df = df.set_index("tstamp", append=True)
+ ts = Timestamp("201603231600")
+ assert df.index.is_unique is False
+
+ result = df.drop(ts, level="tstamp")
+ expected = df.loc[idx != 4]
+ tm.assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize("box", [Series, DataFrame])
+ def test_drop_tz_aware_timestamp_across_dst(self, box):
+ # GH#21761
+ start = Timestamp("2017-10-29", tz="Europe/Berlin")
+ end = Timestamp("2017-10-29 04:00:00", tz="Europe/Berlin")
+ index = pd.date_range(start, end, freq="15min")
+ data = box(data=[1] * len(index), index=index)
+ result = data.drop(start)
+ expected_start = Timestamp("2017-10-29 00:15:00", tz="Europe/Berlin")
+ expected_idx = pd.date_range(expected_start, end, freq="15min")
+ expected = box(data=[1] * len(expected_idx), index=expected_idx)
+ tm.assert_equal(result, expected)
+
+ def test_drop_preserve_names(self):
+ index = MultiIndex.from_arrays(
+ [[0, 0, 0, 1, 1, 1], [1, 2, 3, 1, 2, 3]], names=["one", "two"]
+ )
+
+ df = DataFrame(np.random.randn(6, 3), index=index)
+
+ result = df.drop([(0, 2)])
+ assert result.index.names == ("one", "two")
diff --git a/pandas/tests/frame/methods/test_reindex_like.py b/pandas/tests/frame/methods/test_reindex_like.py
new file mode 100644
index 0000000000000..ce68ec28eec3d
--- /dev/null
+++ b/pandas/tests/frame/methods/test_reindex_like.py
@@ -0,0 +1,39 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+class TestDataFrameReindexLike:
+ def test_reindex_like(self, float_frame):
+ other = float_frame.reindex(index=float_frame.index[:10], columns=["C", "B"])
+
+ tm.assert_frame_equal(other, float_frame.reindex_like(other))
+
+ @pytest.mark.parametrize(
+ "method,expected_values",
+ [
+ ("nearest", [0, 1, 1, 2]),
+ ("pad", [np.nan, 0, 1, 1]),
+ ("backfill", [0, 1, 2, 2]),
+ ],
+ )
+ def test_reindex_like_methods(self, method, expected_values):
+ df = DataFrame({"x": list(range(5))})
+
+ result = df.reindex_like(df, method=method, tolerance=0)
+ tm.assert_frame_equal(df, result)
+ result = df.reindex_like(df, method=method, tolerance=[0, 0, 0, 0])
+ tm.assert_frame_equal(df, result)
+
+ def test_reindex_like_subclass(self):
+ # https://github.com/pandas-dev/pandas/issues/31925
+ class MyDataFrame(DataFrame):
+ pass
+
+ expected = DataFrame()
+ df = MyDataFrame()
+ result = df.reindex_like(expected)
+
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/methods/test_value_counts.py b/pandas/tests/frame/methods/test_value_counts.py
index c409b0bbe6fa9..22aa6091b1d57 100644
--- a/pandas/tests/frame/methods/test_value_counts.py
+++ b/pandas/tests/frame/methods/test_value_counts.py
@@ -77,8 +77,7 @@ def test_data_frame_value_counts_single_col_default():
result = df.value_counts()
expected = pd.Series(
- data=[2, 1, 1],
- index=pd.MultiIndex.from_arrays([[4, 6, 2]], names=["num_legs"]),
+ data=[2, 1, 1], index=pd.MultiIndex.from_arrays([[4, 6, 2]], names=["num_legs"])
)
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/frame/test_alter_axes.py b/pandas/tests/frame/test_alter_axes.py
index 74fe3bfd41b8f..961c18749f055 100644
--- a/pandas/tests/frame/test_alter_axes.py
+++ b/pandas/tests/frame/test_alter_axes.py
@@ -776,35 +776,3 @@ def test_set_reset_index(self):
df = df.set_index("B")
df = df.reset_index()
-
- def test_set_axis_inplace(self):
- # GH14636
- df = DataFrame(
- {"A": [1.1, 2.2, 3.3], "B": [5.0, 6.1, 7.2], "C": [4.4, 5.5, 6.6]},
- index=[2010, 2011, 2012],
- )
-
- expected = {0: df.copy(), 1: df.copy()}
- expected[0].index = list("abc")
- expected[1].columns = list("abc")
- expected["index"] = expected[0]
- expected["columns"] = expected[1]
-
- for axis in expected:
- result = df.copy()
- result.set_axis(list("abc"), axis=axis, inplace=True)
- tm.assert_frame_equal(result, expected[axis])
-
- # inplace=False
- result = df.set_axis(list("abc"), axis=axis)
- tm.assert_frame_equal(expected[axis], result)
-
- # omitting the "axis" parameter
- with tm.assert_produces_warning(None):
- result = df.set_axis(list("abc"))
- tm.assert_frame_equal(result, expected[0])
-
- # wrong values for the "axis" parameter
- for axis in 3, "foo":
- with pytest.raises(ValueError, match="No axis named"):
- df.set_axis(list("abc"), axis=axis)
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 89f8bc433419b..22a167ce5b7fb 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -803,9 +803,7 @@ def test_zero_len_frame_with_series_corner_cases():
def test_frame_single_columns_object_sum_axis_1():
# GH 13758
- data = {
- "One": pd.Series(["A", 1.2, np.nan]),
- }
+ data = {"One": pd.Series(["A", 1.2, np.nan])}
df = pd.DataFrame(data)
result = df.sum(axis=1)
expected = pd.Series(["A", 1.2, 0])
diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py
index 42fb722c92b26..f61512b1a62d9 100644
--- a/pandas/tests/frame/test_axis_select_reindex.py
+++ b/pandas/tests/frame/test_axis_select_reindex.py
@@ -155,11 +155,6 @@ def test_reindex_int(self, int_frame):
smaller = int_frame.reindex(columns=["A", "B"])
assert smaller["A"].dtype == np.int64
- def test_reindex_like(self, float_frame):
- other = float_frame.reindex(index=float_frame.index[:10], columns=["C", "B"])
-
- tm.assert_frame_equal(other, float_frame.reindex_like(other))
-
def test_reindex_columns(self, float_frame):
new_frame = float_frame.reindex(columns=["A", "B", "E"])
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 9f40e8c6931c8..5805a465283c3 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -915,7 +915,7 @@ def test_constructor_mrecarray(self):
# from GH3479
assert_fr_equal = functools.partial(
- tm.assert_frame_equal, check_index_type=True, check_column_type=True,
+ tm.assert_frame_equal, check_index_type=True, check_column_type=True
)
arrays = [
("float", np.array([1.5, 2.0])),
diff --git a/pandas/tests/frame/test_reshape.py b/pandas/tests/frame/test_reshape.py
index 9d3c40ce926d7..7805cb6154d56 100644
--- a/pandas/tests/frame/test_reshape.py
+++ b/pandas/tests/frame/test_reshape.py
@@ -406,7 +406,7 @@ def test_unstack_mixed_type_name_in_multiindex(
result = df.unstack(unstack_idx)
expected = pd.DataFrame(
- expected_values, columns=expected_columns, index=expected_index,
+ expected_values, columns=expected_columns, index=expected_index
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/generic/methods/test_set_axis.py b/pandas/tests/generic/methods/test_set_axis.py
new file mode 100644
index 0000000000000..278d43ef93d2f
--- /dev/null
+++ b/pandas/tests/generic/methods/test_set_axis.py
@@ -0,0 +1,75 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+
+class SharedSetAxisTests:
+ @pytest.fixture
+ def obj(self):
+ raise NotImplementedError("Implemented by subclasses")
+
+ def test_set_axis(self, obj):
+ # GH14636; this tests setting index for both Series and DataFrame
+ new_index = list("abcd")[: len(obj)]
+
+ expected = obj.copy()
+ expected.index = new_index
+
+ # inplace=False
+ result = obj.set_axis(new_index, axis=0, inplace=False)
+ tm.assert_equal(expected, result)
+
+ @pytest.mark.parametrize("axis", [0, "index", 1, "columns"])
+ def test_set_axis_inplace_axis(self, axis, obj):
+ # GH#14636
+ if obj.ndim == 1 and axis in [1, "columns"]:
+ # Series only has [0, "index"]
+ return
+
+ new_index = list("abcd")[: len(obj)]
+
+ expected = obj.copy()
+ if axis in [0, "index"]:
+ expected.index = new_index
+ else:
+ expected.columns = new_index
+
+ result = obj.copy()
+ result.set_axis(new_index, axis=axis, inplace=True)
+ tm.assert_equal(result, expected)
+
+ def test_set_axis_unnamed_kwarg_warns(self, obj):
+ # omitting the "axis" parameter
+ new_index = list("abcd")[: len(obj)]
+
+ expected = obj.copy()
+ expected.index = new_index
+
+ with tm.assert_produces_warning(None):
+ result = obj.set_axis(new_index, inplace=False)
+ tm.assert_equal(result, expected)
+
+ @pytest.mark.parametrize("axis", [3, "foo"])
+ def test_set_axis_invalid_axis_name(self, axis, obj):
+ # wrong values for the "axis" parameter
+ with pytest.raises(ValueError, match="No axis named"):
+ obj.set_axis(list("abc"), axis=axis)
+
+
+class TestDataFrameSetAxis(SharedSetAxisTests):
+ @pytest.fixture
+ def obj(self):
+ df = DataFrame(
+ {"A": [1.1, 2.2, 3.3], "B": [5.0, 6.1, 7.2], "C": [4.4, 5.5, 6.6]},
+ index=[2010, 2011, 2012],
+ )
+ return df
+
+
+class TestSeriesSetAxis(SharedSetAxisTests):
+ @pytest.fixture
+ def obj(self):
+ ser = Series(np.arange(4), index=[1, 3, 5, 7], dtype="int64")
+ return ser
diff --git a/pandas/tests/generic/test_frame.py b/pandas/tests/generic/test_frame.py
index 31501f20db453..eb00fdda058ac 100644
--- a/pandas/tests/generic/test_frame.py
+++ b/pandas/tests/generic/test_frame.py
@@ -226,3 +226,88 @@ def test_unexpected_keyword(self):
with pytest.raises(TypeError, match=msg):
ts.fillna(0, in_place=True)
+<<<<<<< HEAD
+
+
+class TestToXArray:
+ @pytest.mark.skipif(
+ not _XARRAY_INSTALLED
+ or _XARRAY_INSTALLED
+ and LooseVersion(xarray.__version__) < LooseVersion("0.10.0"),
+ reason="xarray >= 0.10.0 required",
+ )
+ @pytest.mark.parametrize("index", tm.all_index_generator(3))
+ def test_to_xarray_index_types(self, index):
+ from xarray import Dataset
+
+ df = DataFrame(
+ {
+ "a": list("abc"),
+ "b": list(range(1, 4)),
+ "c": np.arange(3, 6).astype("u1"),
+ "d": np.arange(4.0, 7.0, dtype="float64"),
+ "e": [True, False, True],
+ "f": pd.Categorical(list("abc")),
+ "g": pd.date_range("20130101", periods=3),
+ "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+ }
+ )
+
+ df.index = index
+ df.index.name = "foo"
+ df.columns.name = "bar"
+ result = df.to_xarray()
+ assert result.dims["foo"] == 3
+ assert len(result.coords) == 1
+ assert len(result.data_vars) == 8
+ tm.assert_almost_equal(list(result.coords.keys()), ["foo"])
+ assert isinstance(result, Dataset)
+
+ # idempotency
+ # datetimes w/tz are preserved
+ # column names are lost
+ expected = df.copy()
+ expected["f"] = expected["f"].astype(object)
+ expected.columns.name = None
+ tm.assert_frame_equal(result.to_dataframe(), expected)
+
+ @td.skip_if_no("xarray", min_version="0.7.0")
+ def test_to_xarray(self):
+ from xarray import Dataset
+
+ df = DataFrame(
+ {
+ "a": list("abc"),
+ "b": list(range(1, 4)),
+ "c": np.arange(3, 6).astype("u1"),
+ "d": np.arange(4.0, 7.0, dtype="float64"),
+ "e": [True, False, True],
+ "f": pd.Categorical(list("abc")),
+ "g": pd.date_range("20130101", periods=3),
+ "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+ }
+ )
+
+ df.index.name = "foo"
+ result = df[0:0].to_xarray()
+ assert result.dims["foo"] == 0
+ assert isinstance(result, Dataset)
+
+ # available in 0.7.1
+ # MultiIndex
+ df.index = pd.MultiIndex.from_product([["a"], range(3)], names=["one", "two"])
+ result = df.to_xarray()
+ assert result.dims["one"] == 1
+ assert result.dims["two"] == 3
+ assert len(result.coords) == 2
+ assert len(result.data_vars) == 8
+ tm.assert_almost_equal(list(result.coords.keys()), ["one", "two"])
+ assert isinstance(result, Dataset)
+
+ result = result.to_dataframe()
+ expected = df.copy()
+ expected["f"] = expected["f"].astype(object)
+ expected.columns.name = None
+ tm.assert_frame_equal(result, expected, check_index_type=False)
+=======
+>>>>>>> master
diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py
index 9ea5252b91e13..3388251ae4a28 100644
--- a/pandas/tests/groupby/test_categorical.py
+++ b/pandas/tests/groupby/test_categorical.py
@@ -1364,7 +1364,7 @@ def test_groupby_agg_categorical_columns(func, expected_values):
result = df.groupby("groups").agg(func)
expected = pd.DataFrame(
- {"value": expected_values}, index=pd.Index([0, 1, 2], name="groups"),
+ {"value": expected_values}, index=pd.Index([0, 1, 2], name="groups")
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py
index 954601ad423bf..543edc6b66ff2 100644
--- a/pandas/tests/indexes/categorical/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -442,18 +442,6 @@ def test_frame_repr(self):
expected = " A\na 1\nb 2\nc 3"
assert result == expected
- def test_fillna_categorical(self):
- # GH 11343
- idx = CategoricalIndex([1.0, np.nan, 3.0, 1.0], name="x")
- # fill by value in categories
- exp = CategoricalIndex([1.0, 1.0, 3.0, 1.0], name="x")
- tm.assert_index_equal(idx.fillna(1.0), exp)
-
- # fill by value not in categories raises ValueError
- msg = "fill value must be in categories"
- with pytest.raises(ValueError, match=msg):
- idx.fillna(2.0)
-
@pytest.mark.parametrize(
"dtype, engine_type",
[
diff --git a/pandas/tests/indexes/categorical/test_fillna.py b/pandas/tests/indexes/categorical/test_fillna.py
new file mode 100644
index 0000000000000..0d878249d3800
--- /dev/null
+++ b/pandas/tests/indexes/categorical/test_fillna.py
@@ -0,0 +1,19 @@
+import numpy as np
+import pytest
+
+from pandas import CategoricalIndex
+import pandas._testing as tm
+
+
+class TestFillNA:
+ def test_fillna_categorical(self):
+ # GH#11343
+ idx = CategoricalIndex([1.0, np.nan, 3.0, 1.0], name="x")
+ # fill by value in categories
+ exp = CategoricalIndex([1.0, 1.0, 3.0, 1.0], name="x")
+ tm.assert_index_equal(idx.fillna(1.0), exp)
+
+ # fill by value not in categories raises ValueError
+ msg = "fill value must be in categories"
+ with pytest.raises(ValueError, match=msg):
+ idx.fillna(2.0)
diff --git a/pandas/tests/indexes/datetimes/test_missing.py b/pandas/tests/indexes/datetimes/test_fillna.py
similarity index 98%
rename from pandas/tests/indexes/datetimes/test_missing.py
rename to pandas/tests/indexes/datetimes/test_fillna.py
index 3399c8eaf6750..5fbe60bb0c50f 100644
--- a/pandas/tests/indexes/datetimes/test_missing.py
+++ b/pandas/tests/indexes/datetimes/test_fillna.py
@@ -4,7 +4,7 @@
import pandas._testing as tm
-class TestDatetimeIndex:
+class TestDatetimeIndexFillNA:
@pytest.mark.parametrize("tz", ["US/Eastern", "Asia/Tokyo"])
def test_fillna_datetime64(self, tz):
# GH 11343
diff --git a/pandas/tests/indexes/multi/test_constructors.py b/pandas/tests/indexes/multi/test_constructors.py
index 1157c7f8bb962..16af884c89e9e 100644
--- a/pandas/tests/indexes/multi/test_constructors.py
+++ b/pandas/tests/indexes/multi/test_constructors.py
@@ -741,18 +741,18 @@ def test_raise_invalid_sortorder():
with pytest.raises(ValueError, match=r".* sortorder 2 with lexsort_depth 1.*"):
MultiIndex(
- levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]], sortorder=2,
+ levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]], sortorder=2
)
with pytest.raises(ValueError, match=r".* sortorder 1 with lexsort_depth 0.*"):
MultiIndex(
- levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]], sortorder=1,
+ levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]], sortorder=1
)
def test_datetimeindex():
idx1 = pd.DatetimeIndex(
- ["2013-04-01 9:00", "2013-04-02 9:00", "2013-04-03 9:00"] * 2, tz="Asia/Tokyo",
+ ["2013-04-01 9:00", "2013-04-02 9:00", "2013-04-03 9:00"] * 2, tz="Asia/Tokyo"
)
idx2 = pd.date_range("2010/01/01", periods=6, freq="M", tz="US/Eastern")
idx = MultiIndex.from_arrays([idx1, idx2])
diff --git a/pandas/tests/indexes/multi/test_get_level_values.py b/pandas/tests/indexes/multi/test_get_level_values.py
index 1215e72be3c59..985fe5773ceed 100644
--- a/pandas/tests/indexes/multi/test_get_level_values.py
+++ b/pandas/tests/indexes/multi/test_get_level_values.py
@@ -89,3 +89,17 @@ def test_get_level_values_na():
result = index.get_level_values(0)
expected = pd.Index([], dtype=object)
tm.assert_index_equal(result, expected)
+
+
+def test_get_level_values_when_periods():
+ # GH33131. See also discussion in GH32669.
+ # This test can probably be removed when PeriodIndex._engine is removed.
+ from pandas import Period, PeriodIndex
+
+ idx = MultiIndex.from_arrays(
+ [PeriodIndex([Period("2019Q1"), Period("2019Q2")], name="b")]
+ )
+ idx2 = MultiIndex.from_arrays(
+ [idx._get_level_values(level) for level in range(idx.nlevels)]
+ )
+ assert all(x.is_monotonic for x in idx2.levels)
diff --git a/pandas/tests/indexes/multi/test_indexing.py b/pandas/tests/indexes/multi/test_indexing.py
index 3b3ae074c774a..d9da059eb9e9c 100644
--- a/pandas/tests/indexes/multi/test_indexing.py
+++ b/pandas/tests/indexes/multi/test_indexing.py
@@ -500,6 +500,34 @@ def test_contains_with_missing_value(self):
assert np.nan not in idx
assert (1, np.nan) in idx
+ def test_multiindex_contains_dropped(self):
+ # GH#19027
+ # test that dropped MultiIndex levels are not in the MultiIndex
+ # despite continuing to be in the MultiIndex's levels
+ idx = MultiIndex.from_product([[1, 2], [3, 4]])
+ assert 2 in idx
+ idx = idx.drop(2)
+
+ # drop implementation keeps 2 in the levels
+ assert 2 in idx.levels[0]
+ # but it should no longer be in the index itself
+ assert 2 not in idx
+
+ # also applies to strings
+ idx = MultiIndex.from_product([["a", "b"], ["c", "d"]])
+ assert "a" in idx
+ idx = idx.drop("a")
+ assert "a" in idx.levels[0]
+ assert "a" not in idx
+
+ def test_contains_td64_level(self):
+ # GH#24570
+ tx = pd.timedelta_range("09:30:00", "16:00:00", freq="30 min")
+ idx = MultiIndex.from_arrays([tx, np.arange(len(tx))])
+ assert tx[0] in idx
+ assert "element_not_exit" not in idx
+ assert "0 day 09:30:00" in idx
+
def test_timestamp_multiindex_indexer():
# https://github.com/pandas-dev/pandas/issues/26944
diff --git a/pandas/tests/indexes/multi/test_isin.py b/pandas/tests/indexes/multi/test_isin.py
index 122263e6ec198..b369b9a50954e 100644
--- a/pandas/tests/indexes/multi/test_isin.py
+++ b/pandas/tests/indexes/multi/test_isin.py
@@ -78,7 +78,7 @@ def test_isin_level_kwarg():
@pytest.mark.parametrize(
"labels,expected,level",
[
- ([("b", np.nan)], np.array([False, False, True]), None,),
+ ([("b", np.nan)], np.array([False, False, True]), None),
([np.nan, "a"], np.array([True, True, False]), 0),
(["d", np.nan], np.array([False, True, True]), 1),
],
diff --git a/pandas/tests/indexes/multi/test_missing.py b/pandas/tests/indexes/multi/test_missing.py
index 54ffec2e03fd3..4c9d518778ceb 100644
--- a/pandas/tests/indexes/multi/test_missing.py
+++ b/pandas/tests/indexes/multi/test_missing.py
@@ -1,55 +1,16 @@
import numpy as np
import pytest
-from pandas._libs.tslib import iNaT
-
import pandas as pd
-from pandas import Int64Index, MultiIndex, PeriodIndex, UInt64Index
+from pandas import MultiIndex
import pandas._testing as tm
-from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
def test_fillna(idx):
# GH 11343
-
- # TODO: Remove or Refactor. Not Implemented for MultiIndex
- for name, index in [("idx", idx)]:
- if len(index) == 0:
- pass
- elif isinstance(index, MultiIndex):
- idx = index.copy()
- msg = "isna is not defined for MultiIndex"
- with pytest.raises(NotImplementedError, match=msg):
- idx.fillna(idx[0])
- else:
- idx = index.copy()
- result = idx.fillna(idx[0])
- tm.assert_index_equal(result, idx)
- assert result is not idx
-
- msg = "'value' must be a scalar, passed: "
- with pytest.raises(TypeError, match=msg):
- idx.fillna([idx[0]])
-
- idx = index.copy()
- values = idx.values
-
- if isinstance(index, DatetimeIndexOpsMixin):
- values[1] = iNaT
- elif isinstance(index, (Int64Index, UInt64Index)):
- continue
- else:
- values[1] = np.nan
-
- if isinstance(index, PeriodIndex):
- idx = type(index)(values, freq=index.freq)
- else:
- idx = type(index)(values)
-
- expected = np.array([False] * len(idx), dtype=bool)
- expected[1] = True
- tm.assert_numpy_array_equal(idx._isnan, expected)
- assert idx.hasnans is True
+ msg = "isna is not defined for MultiIndex"
+ with pytest.raises(NotImplementedError, match=msg):
+ idx.fillna(idx[0])
def test_dropna():
diff --git a/pandas/tests/indexes/period/test_constructors.py b/pandas/tests/indexes/period/test_constructors.py
index 4ec7ef64e2272..b76ec45ac7c1a 100644
--- a/pandas/tests/indexes/period/test_constructors.py
+++ b/pandas/tests/indexes/period/test_constructors.py
@@ -49,11 +49,7 @@ def test_base_constructor_with_period_dtype(self):
)
def test_index_object_dtype(self, values_constructor):
# Index(periods, dtype=object) is an Index (not an PeriodIndex)
- periods = [
- Period("2011-01", freq="M"),
- NaT,
- Period("2011-03", freq="M"),
- ]
+ periods = [Period("2011-01", freq="M"), NaT, Period("2011-03", freq="M")]
values = values_constructor(periods)
result = Index(values, dtype=object)
diff --git a/pandas/tests/indexes/period/test_fillna.py b/pandas/tests/indexes/period/test_fillna.py
new file mode 100644
index 0000000000000..602e87333a6c1
--- /dev/null
+++ b/pandas/tests/indexes/period/test_fillna.py
@@ -0,0 +1,36 @@
+from pandas import Index, NaT, Period, PeriodIndex
+import pandas._testing as tm
+
+
+class TestFillNA:
+ def test_fillna_period(self):
+ # GH#11343
+ idx = PeriodIndex(["2011-01-01 09:00", NaT, "2011-01-01 11:00"], freq="H")
+
+ exp = PeriodIndex(
+ ["2011-01-01 09:00", "2011-01-01 10:00", "2011-01-01 11:00"], freq="H"
+ )
+ result = idx.fillna(Period("2011-01-01 10:00", freq="H"))
+ tm.assert_index_equal(result, exp)
+
+ exp = Index(
+ [
+ Period("2011-01-01 09:00", freq="H"),
+ "x",
+ Period("2011-01-01 11:00", freq="H"),
+ ],
+ dtype=object,
+ )
+ result = idx.fillna("x")
+ tm.assert_index_equal(result, exp)
+
+ exp = Index(
+ [
+ Period("2011-01-01 09:00", freq="H"),
+ Period("2011-01-01", freq="D"),
+ Period("2011-01-01 11:00", freq="H"),
+ ],
+ dtype=object,
+ )
+ result = idx.fillna(Period("2011-01-01", freq="D"))
+ tm.assert_index_equal(result, exp)
diff --git a/pandas/tests/indexes/period/test_indexing.py b/pandas/tests/indexes/period/test_indexing.py
index 39688e5b92380..73d7bcdd16c44 100644
--- a/pandas/tests/indexes/period/test_indexing.py
+++ b/pandas/tests/indexes/period/test_indexing.py
@@ -466,11 +466,7 @@ def test_get_indexer2(self):
idx.get_indexer(target, "nearest", tolerance="1 day"),
np.array([0, 1, 1], dtype=np.intp),
)
- tol_raw = [
- Timedelta("1 hour"),
- Timedelta("1 hour"),
- np.timedelta64(1, "D"),
- ]
+ tol_raw = [Timedelta("1 hour"), Timedelta("1 hour"), np.timedelta64(1, "D")]
tm.assert_numpy_array_equal(
idx.get_indexer(
target, "nearest", tolerance=[np.timedelta64(x) for x in tol_raw]
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index a62936655e09c..0ce10fb8779a1 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -67,35 +67,6 @@ def test_repeat_freqstr(self, index, use_numpy):
tm.assert_index_equal(result, expected)
assert result.freqstr == index.freqstr
- def test_fillna_period(self):
- # GH 11343
- idx = PeriodIndex(["2011-01-01 09:00", NaT, "2011-01-01 11:00"], freq="H")
-
- exp = PeriodIndex(
- ["2011-01-01 09:00", "2011-01-01 10:00", "2011-01-01 11:00"], freq="H"
- )
- tm.assert_index_equal(idx.fillna(Period("2011-01-01 10:00", freq="H")), exp)
-
- exp = Index(
- [
- Period("2011-01-01 09:00", freq="H"),
- "x",
- Period("2011-01-01 11:00", freq="H"),
- ],
- dtype=object,
- )
- tm.assert_index_equal(idx.fillna("x"), exp)
-
- exp = Index(
- [
- Period("2011-01-01 09:00", freq="H"),
- Period("2011-01-01", freq="D"),
- Period("2011-01-01 11:00", freq="H"),
- ],
- dtype=object,
- )
- tm.assert_index_equal(idx.fillna(Period("2011-01-01", freq="D")), exp)
-
def test_no_millisecond_field(self):
msg = "type object 'DatetimeIndex' has no attribute 'millisecond'"
with pytest.raises(AttributeError, match=msg):
diff --git a/pandas/tests/indexes/timedeltas/test_fillna.py b/pandas/tests/indexes/timedeltas/test_fillna.py
new file mode 100644
index 0000000000000..47b2f2ff597f4
--- /dev/null
+++ b/pandas/tests/indexes/timedeltas/test_fillna.py
@@ -0,0 +1,17 @@
+from pandas import Index, NaT, Timedelta, TimedeltaIndex
+import pandas._testing as tm
+
+
+class TestFillNA:
+ def test_fillna_timedelta(self):
+ # GH#11343
+ idx = TimedeltaIndex(["1 day", NaT, "3 day"])
+
+ exp = TimedeltaIndex(["1 day", "2 day", "3 day"])
+ tm.assert_index_equal(idx.fillna(Timedelta("2 day")), exp)
+
+ exp = TimedeltaIndex(["1 day", "3 hour", "3 day"])
+ idx.fillna(Timedelta("3 hour"))
+
+ exp = Index([Timedelta("1 day"), "x", Timedelta("3 day")], dtype=object)
+ tm.assert_index_equal(idx.fillna("x"), exp)
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py
index fa00b870ca757..129bdef870a14 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py
@@ -43,21 +43,6 @@ def test_shift(self):
def test_pickle_compat_construction(self):
pass
- def test_fillna_timedelta(self):
- # GH 11343
- idx = pd.TimedeltaIndex(["1 day", pd.NaT, "3 day"])
-
- exp = pd.TimedeltaIndex(["1 day", "2 day", "3 day"])
- tm.assert_index_equal(idx.fillna(pd.Timedelta("2 day")), exp)
-
- exp = pd.TimedeltaIndex(["1 day", "3 hour", "3 day"])
- idx.fillna(pd.Timedelta("3 hour"))
-
- exp = pd.Index(
- [pd.Timedelta("1 day"), "x", pd.Timedelta("3 day")], dtype=object
- )
- tm.assert_index_equal(idx.fillna("x"), exp)
-
def test_isin(self):
index = tm.makeTimedeltaIndex(4)
diff --git a/pandas/tests/indexing/common.py b/pandas/tests/indexing/common.py
index 9cc031001f81c..656d25bec2a6b 100644
--- a/pandas/tests/indexing/common.py
+++ b/pandas/tests/indexing/common.py
@@ -144,9 +144,7 @@ def check_values(self, f, func, values=False):
tm.assert_almost_equal(result, expected)
- def check_result(
- self, method, key, typs=None, axes=None, fails=None,
- ):
+ def check_result(self, method, key, typs=None, axes=None, fails=None):
def _eq(axis, obj, key):
""" compare equal for these 2 keys """
axified = _axify(obj, key, axis)
diff --git a/pandas/tests/indexing/multiindex/test_multiindex.py b/pandas/tests/indexing/multiindex/test_multiindex.py
index 0064187a94265..5e5fcd3db88d8 100644
--- a/pandas/tests/indexing/multiindex/test_multiindex.py
+++ b/pandas/tests/indexing/multiindex/test_multiindex.py
@@ -26,26 +26,6 @@ def test_multiindex_perf_warn(self):
with tm.assert_produces_warning(PerformanceWarning):
df.loc[(0,)]
- def test_multiindex_contains_dropped(self):
- # GH 19027
- # test that dropped MultiIndex levels are not in the MultiIndex
- # despite continuing to be in the MultiIndex's levels
- idx = MultiIndex.from_product([[1, 2], [3, 4]])
- assert 2 in idx
- idx = idx.drop(2)
-
- # drop implementation keeps 2 in the levels
- assert 2 in idx.levels[0]
- # but it should no longer be in the index itself
- assert 2 not in idx
-
- # also applies to strings
- idx = MultiIndex.from_product([["a", "b"], ["c", "d"]])
- assert "a" in idx
- idx = idx.drop("a")
- assert "a" in idx.levels[0]
- assert "a" not in idx
-
def test_indexing_over_hashtable_size_cutoff(self):
n = 10000
@@ -85,14 +65,6 @@ def test_multi_nan_indexing(self):
)
tm.assert_frame_equal(result, expected)
- def test_contains(self):
- # GH 24570
- tx = pd.timedelta_range("09:30:00", "16:00:00", freq="30 min")
- idx = MultiIndex.from_arrays([tx, np.arange(len(tx))])
- assert tx[0] in idx
- assert "element_not_exit" not in idx
- assert "0 day 09:30:00" in idx
-
def test_nested_tuples_duplicates(self):
# GH#30892
diff --git a/pandas/tests/indexing/test_callable.py b/pandas/tests/indexing/test_callable.py
index 621417eb38d94..be1bd4908fc79 100644
--- a/pandas/tests/indexing/test_callable.py
+++ b/pandas/tests/indexing/test_callable.py
@@ -17,14 +17,10 @@ def test_frame_loc_callable(self):
res = df.loc[lambda x: x.A > 2]
tm.assert_frame_equal(res, df.loc[df.A > 2])
- res = df.loc[
- lambda x: x.A > 2,
- ] # noqa: E231
+ res = df.loc[lambda x: x.A > 2,] # noqa: E231
tm.assert_frame_equal(res, df.loc[df.A > 2,]) # noqa: E231
- res = df.loc[
- lambda x: x.A > 2,
- ] # noqa: E231
+ res = df.loc[lambda x: x.A > 2,] # noqa: E231
tm.assert_frame_equal(res, df.loc[df.A > 2,]) # noqa: E231
res = df.loc[lambda x: x.B == "b", :]
@@ -94,9 +90,7 @@ def test_frame_loc_callable_labels(self):
res = df.loc[lambda x: ["A", "C"]]
tm.assert_frame_equal(res, df.loc[["A", "C"]])
- res = df.loc[
- lambda x: ["A", "C"],
- ] # noqa: E231
+ res = df.loc[lambda x: ["A", "C"],] # noqa: E231
tm.assert_frame_equal(res, df.loc[["A", "C"],]) # noqa: E231
res = df.loc[lambda x: ["A", "C"], :]
diff --git a/pandas/tests/indexing/test_check_indexer.py b/pandas/tests/indexing/test_check_indexer.py
index 69d4065234d93..865ecb129cdfa 100644
--- a/pandas/tests/indexing/test_check_indexer.py
+++ b/pandas/tests/indexing/test_check_indexer.py
@@ -32,7 +32,7 @@ def test_valid_input(indexer, expected):
@pytest.mark.parametrize(
- "indexer", [[True, False, None], pd.array([True, False, None], dtype="boolean")],
+ "indexer", [[True, False, None], pd.array([True, False, None], dtype="boolean")]
)
def test_boolean_na_returns_indexer(indexer):
# https://github.com/pandas-dev/pandas/issues/31503
@@ -61,7 +61,7 @@ def test_bool_raise_length(indexer):
@pytest.mark.parametrize(
- "indexer", [[0, 1, None], pd.array([0, 1, pd.NA], dtype="Int64")],
+ "indexer", [[0, 1, None], pd.array([0, 1, pd.NA], dtype="Int64")]
)
def test_int_raise_missing_values(indexer):
array = np.array([1, 2, 3])
@@ -89,9 +89,7 @@ def test_raise_invalid_array_dtypes(indexer):
check_array_indexer(array, indexer)
-@pytest.mark.parametrize(
- "indexer", [None, Ellipsis, slice(0, 3), (None,)],
-)
+@pytest.mark.parametrize("indexer", [None, Ellipsis, slice(0, 3), (None,)])
def test_pass_through_non_array_likes(indexer):
array = np.array([1, 2, 3])
diff --git a/pandas/tests/indexing/test_floats.py b/pandas/tests/indexing/test_floats.py
index 18b9898e7d800..4804bc63077be 100644
--- a/pandas/tests/indexing/test_floats.py
+++ b/pandas/tests/indexing/test_floats.py
@@ -181,9 +181,7 @@ def test_scalar_with_mixed(self):
expected = 3
assert result == expected
- @pytest.mark.parametrize(
- "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
- )
+ @pytest.mark.parametrize("index_func", [tm.makeIntIndex, tm.makeRangeIndex])
@pytest.mark.parametrize("klass", [Series, DataFrame])
def test_scalar_integer(self, index_func, klass):
@@ -425,9 +423,7 @@ def test_integer_positional_indexing(self, l):
with pytest.raises(TypeError, match=msg):
s.iloc[l]
- @pytest.mark.parametrize(
- "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
- )
+ @pytest.mark.parametrize("index_func", [tm.makeIntIndex, tm.makeRangeIndex])
def test_slice_integer_frame_getitem(self, index_func):
# similar to above, but on the getitem dim (of a DataFrame)
@@ -486,9 +482,7 @@ def test_slice_integer_frame_getitem(self, index_func):
s[l]
@pytest.mark.parametrize("l", [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)])
- @pytest.mark.parametrize(
- "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
- )
+ @pytest.mark.parametrize("index_func", [tm.makeIntIndex, tm.makeRangeIndex])
def test_float_slice_getitem_with_integer_index_raises(self, l, index_func):
# similar to above, but on the getitem dim (of a DataFrame)
diff --git a/pandas/tests/indexing/test_iloc.py b/pandas/tests/indexing/test_iloc.py
index 9664f8d7212ad..cefa3037c8407 100644
--- a/pandas/tests/indexing/test_iloc.py
+++ b/pandas/tests/indexing/test_iloc.py
@@ -56,7 +56,7 @@ def test_is_scalar_access(self):
assert ser.iloc._is_scalar_access((1,))
df = ser.to_frame()
- assert df.iloc._is_scalar_access((1, 0,))
+ assert df.iloc._is_scalar_access((1, 0))
def test_iloc_exceeds_bounds(self):
diff --git a/pandas/tests/indexing/test_loc.py b/pandas/tests/indexing/test_loc.py
index d1f67981b1ec5..5382a265ef334 100644
--- a/pandas/tests/indexing/test_loc.py
+++ b/pandas/tests/indexing/test_loc.py
@@ -27,13 +27,11 @@ def test_loc_getitem_label_out_of_range(self):
# out of range label
self.check_result(
- "loc", "f", typs=["ints", "uints", "labels", "mixed", "ts"], fails=KeyError,
+ "loc", "f", typs=["ints", "uints", "labels", "mixed", "ts"], fails=KeyError
)
self.check_result("loc", "f", typs=["floats"], fails=KeyError)
self.check_result("loc", "f", typs=["floats"], fails=KeyError)
- self.check_result(
- "loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError,
- )
+ self.check_result("loc", 20, typs=["ints", "uints", "mixed"], fails=KeyError)
self.check_result("loc", 20, typs=["labels"], fails=KeyError)
self.check_result("loc", 20, typs=["ts"], axes=0, fails=KeyError)
self.check_result("loc", 20, typs=["floats"], axes=0, fails=KeyError)
@@ -44,26 +42,24 @@ def test_loc_getitem_label_list(self):
pass
def test_loc_getitem_label_list_with_missing(self):
+ self.check_result("loc", [0, 1, 2], typs=["empty"], fails=KeyError)
self.check_result(
- "loc", [0, 1, 2], typs=["empty"], fails=KeyError,
- )
- self.check_result(
- "loc", [0, 2, 10], typs=["ints", "uints", "floats"], axes=0, fails=KeyError,
+ "loc", [0, 2, 10], typs=["ints", "uints", "floats"], axes=0, fails=KeyError
)
self.check_result(
- "loc", [3, 6, 7], typs=["ints", "uints", "floats"], axes=1, fails=KeyError,
+ "loc", [3, 6, 7], typs=["ints", "uints", "floats"], axes=1, fails=KeyError
)
# GH 17758 - MultiIndex and missing keys
self.check_result(
- "loc", [(1, 3), (1, 4), (2, 5)], typs=["multi"], axes=0, fails=KeyError,
+ "loc", [(1, 3), (1, 4), (2, 5)], typs=["multi"], axes=0, fails=KeyError
)
def test_loc_getitem_label_list_fails(self):
# fails
self.check_result(
- "loc", [20, 30, 40], typs=["ints", "uints"], axes=1, fails=KeyError,
+ "loc", [20, 30, 40], typs=["ints", "uints"], axes=1, fails=KeyError
)
def test_loc_getitem_label_array_like(self):
@@ -93,18 +89,14 @@ def test_loc_getitem_label_slice(self):
)
self.check_result(
- "loc", slice("20130102", "20130104"), typs=["ts"], axes=1, fails=TypeError,
+ "loc", slice("20130102", "20130104"), typs=["ts"], axes=1, fails=TypeError
)
- self.check_result(
- "loc", slice(2, 8), typs=["mixed"], axes=0, fails=TypeError,
- )
- self.check_result(
- "loc", slice(2, 8), typs=["mixed"], axes=1, fails=KeyError,
- )
+ self.check_result("loc", slice(2, 8), typs=["mixed"], axes=0, fails=TypeError)
+ self.check_result("loc", slice(2, 8), typs=["mixed"], axes=1, fails=KeyError)
self.check_result(
- "loc", slice(2, 4, 2), typs=["mixed"], axes=0, fails=TypeError,
+ "loc", slice(2, 4, 2), typs=["mixed"], axes=0, fails=TypeError
)
@@ -654,8 +646,7 @@ def test_loc_setitem_with_scalar_index(self, indexer, value):
(1, ["A", "B", "C"]),
np.array([7, 8, 9], dtype=np.int64),
pd.DataFrame(
- [[1, 2, np.nan], [7, 8, 9], [5, 6, np.nan]],
- columns=["A", "B", "C"],
+ [[1, 2, np.nan], [7, 8, 9], [5, 6, np.nan]], columns=["A", "B", "C"]
),
),
(
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 91ec1c29873cf..496ef9d88a894 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -900,16 +900,16 @@ def assert_reindex_indexer_is_ok(mgr, axis, new_labels, indexer, fill_value):
fill_value,
)
assert_reindex_indexer_is_ok(
- mgr, ax, mgr.axes[ax][::-1], np.arange(mgr.shape[ax]), fill_value,
+ mgr, ax, mgr.axes[ax][::-1], np.arange(mgr.shape[ax]), fill_value
)
assert_reindex_indexer_is_ok(
- mgr, ax, mgr.axes[ax], np.arange(mgr.shape[ax])[::-1], fill_value,
+ mgr, ax, mgr.axes[ax], np.arange(mgr.shape[ax])[::-1], fill_value
)
assert_reindex_indexer_is_ok(
mgr, ax, pd.Index(["foo", "bar", "baz"]), [0, 0, 0], fill_value
)
assert_reindex_indexer_is_ok(
- mgr, ax, pd.Index(["foo", "bar", "baz"]), [-1, 0, -1], fill_value,
+ mgr, ax, pd.Index(["foo", "bar", "baz"]), [-1, 0, -1], fill_value
)
assert_reindex_indexer_is_ok(
mgr,
@@ -921,7 +921,7 @@ def assert_reindex_indexer_is_ok(mgr, axis, new_labels, indexer, fill_value):
if mgr.shape[ax] >= 3:
assert_reindex_indexer_is_ok(
- mgr, ax, pd.Index(["foo", "bar", "baz"]), [0, 1, 2], fill_value,
+ mgr, ax, pd.Index(["foo", "bar", "baz"]), [0, 1, 2], fill_value
)
diff --git a/pandas/tests/io/formats/test_css.py b/pandas/tests/io/formats/test_css.py
index 7008cef7b28fa..f6871e7a272b3 100644
--- a/pandas/tests/io/formats/test_css.py
+++ b/pandas/tests/io/formats/test_css.py
@@ -101,11 +101,11 @@ def test_css_side_shorthands(shorthand, expansions):
top, right, bottom, left = expansions
assert_resolves(
- f"{shorthand}: 1pt", {top: "1pt", right: "1pt", bottom: "1pt", left: "1pt"},
+ f"{shorthand}: 1pt", {top: "1pt", right: "1pt", bottom: "1pt", left: "1pt"}
)
assert_resolves(
- f"{shorthand}: 1pt 4pt", {top: "1pt", right: "4pt", bottom: "1pt", left: "4pt"},
+ f"{shorthand}: 1pt 4pt", {top: "1pt", right: "4pt", bottom: "1pt", left: "4pt"}
)
assert_resolves(
@@ -191,9 +191,7 @@ def test_css_absolute_font_size(size, relative_to, resolved):
inherited = None
else:
inherited = {"font-size": relative_to}
- assert_resolves(
- f"font-size: {size}", {"font-size": resolved}, inherited=inherited,
- )
+ assert_resolves(f"font-size: {size}", {"font-size": resolved}, inherited=inherited)
@pytest.mark.parametrize(
@@ -227,6 +225,4 @@ def test_css_relative_font_size(size, relative_to, resolved):
inherited = None
else:
inherited = {"font-size": relative_to}
- assert_resolves(
- f"font-size: {size}", {"font-size": resolved}, inherited=inherited,
- )
+ assert_resolves(f"font-size: {size}", {"font-size": resolved}, inherited=inherited)
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 1a5d122d732a9..2d6ad689f6703 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -2389,8 +2389,7 @@ def test_east_asian_unicode_series(self):
# object dtype, longer than unicode repr
s = Series(
- [1, 22, 3333, 44444],
- index=[1, "AB", pd.Timestamp("2011-01-01"), "あああ"],
+ [1, 22, 3333, 44444], index=[1, "AB", pd.Timestamp("2011-01-01"), "あああ"]
)
expected = (
"1 1\n"
diff --git a/pandas/tests/io/formats/test_info.py b/pandas/tests/io/formats/test_info.py
index 877bd1650ae60..7000daeb9b575 100644
--- a/pandas/tests/io/formats/test_info.py
+++ b/pandas/tests/io/formats/test_info.py
@@ -299,7 +299,7 @@ def test_info_memory_usage():
DataFrame(1, index=["a"], columns=["A"]).memory_usage(index=True)
DataFrame(1, index=["a"], columns=["A"]).index.nbytes
df = DataFrame(
- data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"],
+ data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"]
)
df.index.nbytes
df.memory_usage(index=True)
@@ -336,7 +336,7 @@ def test_info_memory_usage_deep_pypy():
@pytest.mark.skipif(PYPY, reason="PyPy getsizeof() fails by design")
def test_usage_via_getsizeof():
df = DataFrame(
- data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"],
+ data=1, index=MultiIndex.from_product([["a"], range(1000)]), columns=["A"]
)
mem = df.memory_usage(deep=True).sum()
# sys.getsizeof will call the .memory_usage with
@@ -359,16 +359,14 @@ def test_info_memory_usage_qualified():
buf = StringIO()
df = DataFrame(
- 1, columns=list("ab"), index=MultiIndex.from_product([range(3), range(3)]),
+ 1, columns=list("ab"), index=MultiIndex.from_product([range(3), range(3)])
)
df.info(buf=buf)
assert "+" not in buf.getvalue()
buf = StringIO()
df = DataFrame(
- 1,
- columns=list("ab"),
- index=MultiIndex.from_product([range(3), ["foo", "bar"]]),
+ 1, columns=list("ab"), index=MultiIndex.from_product([range(3), ["foo", "bar"]])
)
df.info(buf=buf)
assert "+" in buf.getvalue()
@@ -384,7 +382,7 @@ def memory_usage(f):
N = 100
M = len(uppercase)
index = MultiIndex.from_product(
- [list(uppercase), date_range("20160101", periods=N)], names=["id", "date"],
+ [list(uppercase), date_range("20160101", periods=N)], names=["id", "date"]
)
df = DataFrame({"value": np.random.randn(N * M)}, index=index)
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 6a7a81e88d318..b74abc965f7fa 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -16,20 +16,15 @@
import pandas._testing as tm
_seriesd = tm.getSeriesData()
-_tsd = tm.getTimeSeriesData()
_frame = DataFrame(_seriesd)
-_intframe = DataFrame({k: v.astype(np.int64) for k, v in _seriesd.items()})
-_tsframe = DataFrame(_tsd)
_cat_frame = _frame.copy()
cat = ["bah"] * 5 + ["bar"] * 5 + ["baz"] * 5 + ["foo"] * (len(_cat_frame) - 15)
_cat_frame.index = pd.CategoricalIndex(cat, name="E")
_cat_frame["E"] = list(reversed(cat))
_cat_frame["sort"] = np.arange(len(_cat_frame), dtype="int64")
-_mixed_frame = _frame.copy()
-
def assert_json_roundtrip_equal(result, expected, orient):
if orient == "records" or orient == "values":
@@ -43,17 +38,10 @@ def assert_json_roundtrip_equal(result, expected, orient):
class TestPandasContainer:
@pytest.fixture(autouse=True)
def setup(self):
- self.intframe = _intframe.copy()
- self.tsframe = _tsframe.copy()
- self.mixed_frame = _mixed_frame.copy()
self.categorical = _cat_frame.copy()
yield
- del self.intframe
- del self.tsframe
- del self.mixed_frame
-
def test_frame_double_encoded_labels(self, orient):
df = DataFrame(
[["a", "b"], ["c", "d"]],
@@ -137,12 +125,12 @@ def test_roundtrip_simple(self, orient, convert_axes, numpy, dtype, float_frame)
@pytest.mark.parametrize("dtype", [False, np.int64])
@pytest.mark.parametrize("convert_axes", [True, False])
@pytest.mark.parametrize("numpy", [True, False])
- def test_roundtrip_intframe(self, orient, convert_axes, numpy, dtype):
- data = self.intframe.to_json(orient=orient)
+ def test_roundtrip_intframe(self, orient, convert_axes, numpy, dtype, int_frame):
+ data = int_frame.to_json(orient=orient)
result = pd.read_json(
data, orient=orient, convert_axes=convert_axes, numpy=numpy, dtype=dtype
)
- expected = self.intframe.copy()
+ expected = int_frame
if (
numpy
and (is_platform_32bit() or is_platform_windows())
@@ -236,13 +224,13 @@ def test_roundtrip_empty(self, orient, convert_axes, numpy, empty_frame):
@pytest.mark.parametrize("convert_axes", [True, False])
@pytest.mark.parametrize("numpy", [True, False])
- def test_roundtrip_timestamp(self, orient, convert_axes, numpy):
+ def test_roundtrip_timestamp(self, orient, convert_axes, numpy, datetime_frame):
# TODO: improve coverage with date_format parameter
- data = self.tsframe.to_json(orient=orient)
+ data = datetime_frame.to_json(orient=orient)
result = pd.read_json(
data, orient=orient, convert_axes=convert_axes, numpy=numpy
)
- expected = self.tsframe.copy()
+ expected = datetime_frame.copy()
if not convert_axes: # one off for ts handling
# DTI gets converted to epoch values
@@ -730,23 +718,22 @@ def test_reconstruction_index(self):
result = read_json(df.to_json())
tm.assert_frame_equal(result, df)
- def test_path(self, float_frame):
+ def test_path(self, float_frame, int_frame, datetime_frame):
with tm.ensure_clean("test.json") as path:
for df in [
float_frame,
- self.intframe,
- self.tsframe,
- self.mixed_frame,
+ int_frame,
+ datetime_frame,
]:
df.to_json(path)
read_json(path)
- def test_axis_dates(self, datetime_series):
+ def test_axis_dates(self, datetime_series, datetime_frame):
# frame
- json = self.tsframe.to_json()
+ json = datetime_frame.to_json()
result = read_json(json)
- tm.assert_frame_equal(result, self.tsframe)
+ tm.assert_frame_equal(result, datetime_frame)
# series
json = datetime_series.to_json()
@@ -754,10 +741,10 @@ def test_axis_dates(self, datetime_series):
tm.assert_series_equal(result, datetime_series, check_names=False)
assert result.name is None
- def test_convert_dates(self, datetime_series):
+ def test_convert_dates(self, datetime_series, datetime_frame):
# frame
- df = self.tsframe.copy()
+ df = datetime_frame
df["date"] = Timestamp("20130101")
json = df.to_json()
@@ -837,8 +824,8 @@ def test_convert_dates_infer(self, infer_word):
("20130101 20:43:42.123456789", "ns"),
],
)
- def test_date_format_frame(self, date, date_unit):
- df = self.tsframe.copy()
+ def test_date_format_frame(self, date, date_unit, datetime_frame):
+ df = datetime_frame
df["date"] = Timestamp(date)
df.iloc[1, df.columns.get_loc("date")] = pd.NaT
@@ -853,8 +840,8 @@ def test_date_format_frame(self, date, date_unit):
expected["date"] = expected["date"].dt.tz_localize("UTC")
tm.assert_frame_equal(result, expected)
- def test_date_format_frame_raises(self):
- df = self.tsframe.copy()
+ def test_date_format_frame_raises(self, datetime_frame):
+ df = datetime_frame
msg = "Invalid value 'foo' for option 'date_unit'"
with pytest.raises(ValueError, match=msg):
df.to_json(date_format="iso", date_unit="foo")
@@ -890,8 +877,8 @@ def test_date_format_series_raises(self, datetime_series):
ts.to_json(date_format="iso", date_unit="foo")
@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
- def test_date_unit(self, unit):
- df = self.tsframe.copy()
+ def test_date_unit(self, unit, datetime_frame):
+ df = datetime_frame
df["date"] = Timestamp("20130101 20:43:42")
dl = df.columns.get_loc("date")
df.iloc[1, dl] = Timestamp("19710101 20:43:42")
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index 2fcac6fa57cf8..6d4e39cd6de14 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -1546,5 +1546,5 @@ def test_missing_parse_dates_column_raises(
msg = f"Missing column provided to 'parse_dates': '{missing_cols}'"
with pytest.raises(ValueError, match=msg):
parser.read_csv(
- content, sep=",", names=names, usecols=usecols, parse_dates=parse_dates,
+ content, sep=",", names=names, usecols=usecols, parse_dates=parse_dates
)
diff --git a/pandas/tests/io/parser/test_usecols.py b/pandas/tests/io/parser/test_usecols.py
index 979eb4702cc84..e05575cd79ccc 100644
--- a/pandas/tests/io/parser/test_usecols.py
+++ b/pandas/tests/io/parser/test_usecols.py
@@ -199,7 +199,7 @@ def test_usecols_with_whitespace(all_parsers):
# Column selection by index.
([0, 1], DataFrame(data=[[1000, 2000], [4000, 5000]], columns=["2", "0"])),
# Column selection by name.
- (["0", "1"], DataFrame(data=[[2000, 3000], [5000, 6000]], columns=["0", "1"]),),
+ (["0", "1"], DataFrame(data=[[2000, 3000], [5000, 6000]], columns=["0", "1"])),
],
)
def test_usecols_with_integer_like_header(all_parsers, usecols, expected):
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index d0eaafb787222..3b8e0bbd87f11 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -567,7 +567,7 @@ def test_additional_extension_types(self, pa):
{
# Arrow does not yet support struct in writing to Parquet (ARROW-1644)
# "c": pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2), (3, 4)]),
- "d": pd.period_range("2012-01-01", periods=3, freq="D"),
+ "d": pd.period_range("2012-01-01", periods=3, freq="D")
}
)
check_round_trip(df, pa)
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index eaa92fa53d799..ccf51962f3636 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -1149,7 +1149,7 @@ def test_read_chunks_117(
from_frame = parsed.iloc[pos : pos + chunksize, :].copy()
from_frame = self._convert_categorical(from_frame)
tm.assert_frame_equal(
- from_frame, chunk, check_dtype=False, check_datetimelike_compat=True,
+ from_frame, chunk, check_dtype=False, check_datetimelike_compat=True
)
pos += chunksize
@@ -1247,7 +1247,7 @@ def test_read_chunks_115(
from_frame = parsed.iloc[pos : pos + chunksize, :].copy()
from_frame = self._convert_categorical(from_frame)
tm.assert_frame_equal(
- from_frame, chunk, check_dtype=False, check_datetimelike_compat=True,
+ from_frame, chunk, check_dtype=False, check_datetimelike_compat=True
)
pos += chunksize
diff --git a/pandas/tests/plotting/test_frame.py b/pandas/tests/plotting/test_frame.py
index 45ac18b2661c3..08b33ee547a48 100644
--- a/pandas/tests/plotting/test_frame.py
+++ b/pandas/tests/plotting/test_frame.py
@@ -1306,6 +1306,13 @@ def test_plot_scatter_with_c(self):
float_array = np.array([0.0, 1.0])
df.plot.scatter(x="A", y="B", c=float_array, cmap="spring")
+ def test_plot_scatter_with_s(self):
+ # this refers to GH 32904
+ df = DataFrame(np.random.random((10, 3)) * 100, columns=["a", "b", "c"],)
+
+ ax = df.plot.scatter(x="a", y="b", s="c")
+ tm.assert_numpy_array_equal(df["c"].values, right=ax.collections[0].get_sizes())
+
def test_scatter_colors(self):
df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]})
with pytest.raises(TypeError):
diff --git a/pandas/tests/reshape/test_crosstab.py b/pandas/tests/reshape/test_crosstab.py
index 8795af2e11122..d56e121429e7c 100644
--- a/pandas/tests/reshape/test_crosstab.py
+++ b/pandas/tests/reshape/test_crosstab.py
@@ -350,11 +350,10 @@ def test_crosstab_normalize(self):
tm.assert_frame_equal(crosstab(df.a, df.b, normalize="index"), row_normal)
tm.assert_frame_equal(crosstab(df.a, df.b, normalize="columns"), col_normal)
tm.assert_frame_equal(
- crosstab(df.a, df.b, normalize=1),
- crosstab(df.a, df.b, normalize="columns"),
+ crosstab(df.a, df.b, normalize=1), crosstab(df.a, df.b, normalize="columns")
)
tm.assert_frame_equal(
- crosstab(df.a, df.b, normalize=0), crosstab(df.a, df.b, normalize="index"),
+ crosstab(df.a, df.b, normalize=0), crosstab(df.a, df.b, normalize="index")
)
row_normal_margins = DataFrame(
@@ -377,7 +376,7 @@ def test_crosstab_normalize(self):
crosstab(df.a, df.b, normalize="index", margins=True), row_normal_margins
)
tm.assert_frame_equal(
- crosstab(df.a, df.b, normalize="columns", margins=True), col_normal_margins,
+ crosstab(df.a, df.b, normalize="columns", margins=True), col_normal_margins
)
tm.assert_frame_equal(
crosstab(df.a, df.b, normalize=True, margins=True), all_normal_margins
diff --git a/pandas/tests/reshape/test_reshape.py b/pandas/tests/reshape/test_get_dummies.py
similarity index 84%
rename from pandas/tests/reshape/test_reshape.py
rename to pandas/tests/reshape/test_get_dummies.py
index 6113cfec48df9..ce13762ea8f86 100644
--- a/pandas/tests/reshape/test_reshape.py
+++ b/pandas/tests/reshape/test_get_dummies.py
@@ -6,7 +6,7 @@
from pandas.core.dtypes.common import is_integer_dtype
import pandas as pd
-from pandas import Categorical, DataFrame, Index, Series, get_dummies
+from pandas import Categorical, CategoricalIndex, DataFrame, Series, get_dummies
import pandas._testing as tm
from pandas.core.arrays.sparse import SparseArray, SparseDtype
@@ -31,11 +31,11 @@ def effective_dtype(self, dtype):
return np.uint8
return dtype
- def test_raises_on_dtype_object(self, df):
+ def test_get_dummies_raises_on_dtype_object(self, df):
with pytest.raises(ValueError):
get_dummies(df, dtype="object")
- def test_basic(self, sparse, dtype):
+ def test_get_dummies_basic(self, sparse, dtype):
s_list = list("abc")
s_series = Series(s_list)
s_series_index = Series(s_list, list("ABC"))
@@ -56,7 +56,7 @@ def test_basic(self, sparse, dtype):
result = get_dummies(s_series_index, sparse=sparse, dtype=dtype)
tm.assert_frame_equal(result, expected)
- def test_basic_types(self, sparse, dtype):
+ def test_get_dummies_basic_types(self, sparse, dtype):
# GH 10531
s_list = list("abc")
s_series = Series(s_list)
@@ -106,7 +106,7 @@ def test_basic_types(self, sparse, dtype):
result = result.sort_index()
tm.assert_series_equal(result, expected)
- def test_just_na(self, sparse):
+ def test_get_dummies_just_na(self, sparse):
just_na_list = [np.nan]
just_na_series = Series(just_na_list)
just_na_series_index = Series(just_na_list, index=["A"])
@@ -123,7 +123,7 @@ def test_just_na(self, sparse):
assert res_series.index.tolist() == [0]
assert res_series_index.index.tolist() == ["A"]
- def test_include_na(self, sparse, dtype):
+ def test_get_dummies_include_na(self, sparse, dtype):
s = ["a", "b", np.nan]
res = get_dummies(s, sparse=sparse, dtype=dtype)
exp = DataFrame(
@@ -152,7 +152,7 @@ def test_include_na(self, sparse, dtype):
)
tm.assert_numpy_array_equal(res_just_na.values, exp_just_na.values)
- def test_unicode(self, sparse):
+ def test_get_dummies_unicode(self, sparse):
# See GH 6885 - get_dummies chokes on unicode values
import unicodedata
@@ -161,7 +161,7 @@ def test_unicode(self, sparse):
s = [e, eacute, eacute]
res = get_dummies(s, prefix="letter", sparse=sparse)
exp = DataFrame(
- {"letter_e": [1, 0, 0], f"letter_{eacute}": [0, 1, 1]}, dtype=np.uint8,
+ {"letter_e": [1, 0, 0], f"letter_{eacute}": [0, 1, 1]}, dtype=np.uint8
)
if sparse:
exp = exp.apply(SparseArray, fill_value=0)
@@ -175,7 +175,7 @@ def test_dataframe_dummies_all_obj(self, df, sparse):
dtype=np.uint8,
)
if sparse:
- expected = pd.DataFrame(
+ expected = DataFrame(
{
"A_a": SparseArray([1, 0, 1], dtype="uint8"),
"A_b": SparseArray([0, 1, 0], dtype="uint8"),
@@ -223,7 +223,7 @@ def test_dataframe_dummies_prefix_list(self, df, sparse):
cols = ["from_A_a", "from_A_b", "from_B_b", "from_B_c"]
expected = expected[["C"] + cols]
- typ = SparseArray if sparse else pd.Series
+ typ = SparseArray if sparse else Series
expected[cols] = expected[cols].apply(lambda x: typ(x))
tm.assert_frame_equal(result, expected)
@@ -242,11 +242,11 @@ def test_dataframe_dummies_prefix_str(self, df, sparse):
# 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]"),
+ Series([1, 2, 3], name="C"),
+ Series([1, 0, 1], name="bad_a", dtype="Sparse[uint8]"),
+ Series([0, 1, 0], name="bad_b", dtype="Sparse[uint8]"),
+ Series([1, 1, 0], name="bad_b", dtype="Sparse[uint8]"),
+ Series([0, 0, 1], name="bad_c", dtype="Sparse[uint8]"),
],
axis=1,
)
@@ -267,7 +267,7 @@ def test_dataframe_dummies_subset(self, df, sparse):
expected[["C"]] = df[["C"]]
if sparse:
cols = ["from_A_a", "from_A_b"]
- expected[cols] = expected[cols].astype(pd.SparseDtype("uint8", 0))
+ expected[cols] = expected[cols].astype(SparseDtype("uint8", 0))
tm.assert_frame_equal(result, expected)
def test_dataframe_dummies_prefix_sep(self, df, sparse):
@@ -286,7 +286,7 @@ def test_dataframe_dummies_prefix_sep(self, df, sparse):
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].astype(pd.SparseDtype("uint8", 0))
+ expected[cols] = expected[cols].astype(SparseDtype("uint8", 0))
tm.assert_frame_equal(result, expected)
@@ -323,7 +323,7 @@ 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].astype(pd.SparseDtype("uint8", 0))
+ expected[columns] = expected[columns].astype(SparseDtype("uint8", 0))
tm.assert_frame_equal(result, expected)
@@ -359,7 +359,7 @@ def test_dataframe_dummies_with_na(self, df, sparse, dtype):
tm.assert_frame_equal(result, expected)
def test_dataframe_dummies_with_categorical(self, df, sparse, dtype):
- df["cat"] = pd.Categorical(["x", "y", "y"])
+ df["cat"] = Categorical(["x", "y", "y"])
result = get_dummies(df, sparse=sparse, dtype=dtype).sort_index(axis=1)
if sparse:
arr = SparseArray
@@ -386,30 +386,30 @@ def test_dataframe_dummies_with_categorical(self, df, sparse, dtype):
"get_dummies_kwargs,expected",
[
(
- {"data": pd.DataFrame(({"ä": ["a"]}))},
- pd.DataFrame({"ä_a": [1]}, dtype=np.uint8),
+ {"data": DataFrame(({"ä": ["a"]}))},
+ DataFrame({"ä_a": [1]}, dtype=np.uint8),
),
(
- {"data": pd.DataFrame({"x": ["ä"]})},
- pd.DataFrame({"x_ä": [1]}, dtype=np.uint8),
+ {"data": DataFrame({"x": ["ä"]})},
+ DataFrame({"x_ä": [1]}, dtype=np.uint8),
),
(
- {"data": pd.DataFrame({"x": ["a"]}), "prefix": "ä"},
- pd.DataFrame({"ä_a": [1]}, dtype=np.uint8),
+ {"data": DataFrame({"x": ["a"]}), "prefix": "ä"},
+ DataFrame({"ä_a": [1]}, dtype=np.uint8),
),
(
- {"data": pd.DataFrame({"x": ["a"]}), "prefix_sep": "ä"},
- pd.DataFrame({"xäa": [1]}, dtype=np.uint8),
+ {"data": DataFrame({"x": ["a"]}), "prefix_sep": "ä"},
+ DataFrame({"xäa": [1]}, dtype=np.uint8),
),
],
)
def test_dataframe_dummies_unicode(self, get_dummies_kwargs, expected):
- # GH22084 pd.get_dummies incorrectly encodes unicode characters
+ # GH22084 get_dummies incorrectly encodes unicode characters
# in dataframe column names
result = get_dummies(**get_dummies_kwargs)
tm.assert_frame_equal(result, expected)
- def test_basic_drop_first(self, sparse):
+ def test_get_dummies_basic_drop_first(self, sparse):
# GH12402 Add a new parameter `drop_first` to avoid collinearity
# Basic case
s_list = list("abc")
@@ -430,7 +430,7 @@ def test_basic_drop_first(self, sparse):
result = get_dummies(s_series_index, drop_first=True, sparse=sparse)
tm.assert_frame_equal(result, expected)
- def test_basic_drop_first_one_level(self, sparse):
+ def test_get_dummies_basic_drop_first_one_level(self, sparse):
# Test the case that categorical variable only has one level.
s_list = list("aaa")
s_series = Series(s_list)
@@ -448,7 +448,7 @@ def test_basic_drop_first_one_level(self, sparse):
result = get_dummies(s_series_index, drop_first=True, sparse=sparse)
tm.assert_frame_equal(result, expected)
- def test_basic_drop_first_NA(self, sparse):
+ def test_get_dummies_basic_drop_first_NA(self, sparse):
# Test NA handling together with drop_first
s_NA = ["a", "b", np.nan]
res = get_dummies(s_NA, drop_first=True, sparse=sparse)
@@ -481,7 +481,7 @@ def test_dataframe_dummies_drop_first(self, df, sparse):
tm.assert_frame_equal(result, expected)
def test_dataframe_dummies_drop_first_with_categorical(self, df, sparse, dtype):
- df["cat"] = pd.Categorical(["x", "y", "y"])
+ df["cat"] = Categorical(["x", "y", "y"])
result = get_dummies(df, drop_first=True, sparse=sparse)
expected = DataFrame(
{"C": [1, 2, 3], "A_b": [0, 1, 0], "B_c": [0, 0, 1], "cat_y": [0, 1, 1]}
@@ -521,24 +521,24 @@ def test_dataframe_dummies_drop_first_with_na(self, df, sparse):
expected = expected[["C", "A_b", "B_c"]]
tm.assert_frame_equal(result, expected)
- def test_int_int(self):
+ def test_get_dummies_int_int(self):
data = Series([1, 2, 1])
- result = pd.get_dummies(data)
+ result = get_dummies(data)
expected = DataFrame([[1, 0], [0, 1], [1, 0]], columns=[1, 2], dtype=np.uint8)
tm.assert_frame_equal(result, expected)
- data = Series(pd.Categorical(["a", "b", "a"]))
- result = pd.get_dummies(data)
+ data = Series(Categorical(["a", "b", "a"]))
+ result = get_dummies(data)
expected = DataFrame(
- [[1, 0], [0, 1], [1, 0]], columns=pd.Categorical(["a", "b"]), dtype=np.uint8
+ [[1, 0], [0, 1], [1, 0]], columns=Categorical(["a", "b"]), dtype=np.uint8
)
tm.assert_frame_equal(result, expected)
- def test_int_df(self, dtype):
+ def test_get_dummies_int_df(self, dtype):
data = DataFrame(
{
"A": [1, 2, 1],
- "B": pd.Categorical(["a", "b", "a"]),
+ "B": Categorical(["a", "b", "a"]),
"C": [1, 2, 1],
"D": [1.0, 2.0, 1.0],
}
@@ -549,22 +549,22 @@ def test_int_df(self, dtype):
columns=columns,
)
expected[columns[2:]] = expected[columns[2:]].astype(dtype)
- result = pd.get_dummies(data, columns=["A", "B"], dtype=dtype)
+ result = get_dummies(data, columns=["A", "B"], dtype=dtype)
tm.assert_frame_equal(result, expected)
- def test_dataframe_dummies_preserve_categorical_dtype(self, dtype):
+ @pytest.mark.parametrize("ordered", [True, False])
+ def test_dataframe_dummies_preserve_categorical_dtype(self, dtype, ordered):
# GH13854
- for ordered in [False, True]:
- cat = pd.Categorical(list("xy"), categories=list("xyz"), ordered=ordered)
- result = get_dummies(cat, dtype=dtype)
+ cat = Categorical(list("xy"), categories=list("xyz"), ordered=ordered)
+ result = get_dummies(cat, dtype=dtype)
- data = np.array([[1, 0, 0], [0, 1, 0]], dtype=self.effective_dtype(dtype))
- cols = pd.CategoricalIndex(
- cat.categories, categories=cat.categories, ordered=ordered
- )
- expected = DataFrame(data, columns=cols, dtype=self.effective_dtype(dtype))
+ data = np.array([[1, 0, 0], [0, 1, 0]], dtype=self.effective_dtype(dtype))
+ cols = CategoricalIndex(
+ cat.categories, categories=cat.categories, ordered=ordered
+ )
+ expected = DataFrame(data, columns=cols, dtype=self.effective_dtype(dtype))
- tm.assert_frame_equal(result, expected)
+ tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("sparse", [True, False])
def test_get_dummies_dont_sparsify_all_columns(self, sparse):
@@ -593,10 +593,10 @@ def test_get_dummies_duplicate_columns(self, df):
tm.assert_frame_equal(result, expected)
def test_get_dummies_all_sparse(self):
- df = pd.DataFrame({"A": [1, 2]})
- result = pd.get_dummies(df, columns=["A"], sparse=True)
+ df = DataFrame({"A": [1, 2]})
+ result = get_dummies(df, columns=["A"], sparse=True)
dtype = SparseDtype("uint8", 0)
- expected = pd.DataFrame(
+ expected = DataFrame(
{
"A_1": SparseArray([1, 0], dtype=dtype),
"A_2": SparseArray([0, 1], dtype=dtype),
@@ -607,7 +607,7 @@ def test_get_dummies_all_sparse(self):
@pytest.mark.parametrize("values", ["baz"])
def test_get_dummies_with_string_values(self, values):
# issue #28383
- df = pd.DataFrame(
+ df = DataFrame(
{
"bar": [1, 2, 3, 4, 5, 6],
"foo": ["one", "one", "one", "two", "two", "two"],
@@ -619,26 +619,4 @@ def test_get_dummies_with_string_values(self, values):
msg = "Input must be a list-like for parameter `columns`"
with pytest.raises(TypeError, match=msg):
- pd.get_dummies(df, columns=values)
-
-
-class TestCategoricalReshape:
- def test_reshaping_multi_index_categorical(self):
-
- cols = ["ItemA", "ItemB", "ItemC"]
- data = {c: tm.makeTimeDataFrame() for c in cols}
- df = pd.concat({c: data[c].stack() for c in data}, axis="columns")
- df.index.names = ["major", "minor"]
- df["str"] = "foo"
-
- df["category"] = df["str"].astype("category")
- result = df["category"].unstack()
-
- dti = df.index.levels[0]
- c = Categorical(["foo"] * len(dti))
- expected = DataFrame(
- {"A": c.copy(), "B": c.copy(), "C": c.copy(), "D": c.copy()},
- columns=Index(list("ABCD"), name="minor"),
- index=dti.rename("major"),
- )
- tm.assert_frame_equal(result, expected)
+ get_dummies(df, columns=values)
diff --git a/pandas/tests/scalar/test_na_scalar.py b/pandas/tests/scalar/test_na_scalar.py
index a0e3f8984fbe4..fd72db2118c0e 100644
--- a/pandas/tests/scalar/test_na_scalar.py
+++ b/pandas/tests/scalar/test_na_scalar.py
@@ -100,7 +100,7 @@ def test_pow_special(value, asarray):
@pytest.mark.parametrize(
- "value", [1, 1.0, True, np.bool_(True), np.int_(1), np.float_(1)],
+ "value", [1, 1.0, True, np.bool_(True), np.int_(1), np.float_(1)]
)
@pytest.mark.parametrize("asarray", [True, False])
def test_rpow_special(value, asarray):
@@ -117,9 +117,7 @@ def test_rpow_special(value, asarray):
assert result == value
-@pytest.mark.parametrize(
- "value", [-1, -1.0, np.int_(-1), np.float_(-1)],
-)
+@pytest.mark.parametrize("value", [-1, -1.0, np.int_(-1), np.float_(-1)])
@pytest.mark.parametrize("asarray", [True, False])
def test_rpow_minus_one(value, asarray):
if asarray:
@@ -182,9 +180,7 @@ def test_logical_not():
assert ~NA is NA
-@pytest.mark.parametrize(
- "shape", [(3,), (3, 3), (1, 2, 3)],
-)
+@pytest.mark.parametrize("shape", [(3,), (3, 3), (1, 2, 3)])
def test_arithmetic_ndarray(shape, all_arithmetic_functions):
op = all_arithmetic_functions
a = np.zeros(shape)
diff --git a/pandas/tests/series/indexing/test_alter_index.py b/pandas/tests/series/indexing/test_alter_index.py
index b45f831ff00aa..f2969e15fad8a 100644
--- a/pandas/tests/series/indexing/test_alter_index.py
+++ b/pandas/tests/series/indexing/test_alter_index.py
@@ -1,5 +1,3 @@
-from datetime import datetime
-
import numpy as np
import pytest
@@ -149,25 +147,17 @@ def test_reindex_pad():
def test_reindex_nearest():
s = Series(np.arange(10, dtype="int64"))
target = [0.1, 0.9, 1.5, 2.0]
- actual = s.reindex(target, method="nearest")
+ result = s.reindex(target, method="nearest")
expected = Series(np.around(target).astype("int64"), target)
- tm.assert_series_equal(expected, actual)
-
- actual = s.reindex_like(actual, method="nearest")
- tm.assert_series_equal(expected, actual)
-
- actual = s.reindex_like(actual, method="nearest", tolerance=1)
- tm.assert_series_equal(expected, actual)
- actual = s.reindex_like(actual, method="nearest", tolerance=[1, 2, 3, 4])
- tm.assert_series_equal(expected, actual)
+ tm.assert_series_equal(expected, result)
- actual = s.reindex(target, method="nearest", tolerance=0.2)
+ result = s.reindex(target, method="nearest", tolerance=0.2)
expected = Series([0, 1, np.nan, 2], target)
- tm.assert_series_equal(expected, actual)
+ tm.assert_series_equal(expected, result)
- actual = s.reindex(target, method="nearest", tolerance=[0.3, 0.01, 0.4, 3])
+ result = s.reindex(target, method="nearest", tolerance=[0.3, 0.01, 0.4, 3])
expected = Series([0, np.nan, np.nan, 2], target)
- tm.assert_series_equal(expected, actual)
+ tm.assert_series_equal(expected, result)
def test_reindex_backfill():
@@ -237,25 +227,6 @@ def test_reindex_categorical():
tm.assert_series_equal(result, expected)
-def test_reindex_like(datetime_series):
- other = datetime_series[::2]
- tm.assert_series_equal(
- datetime_series.reindex(other.index), datetime_series.reindex_like(other)
- )
-
- # GH 7179
- day1 = datetime(2013, 3, 5)
- day2 = datetime(2013, 5, 5)
- day3 = datetime(2014, 3, 5)
-
- series1 = Series([5, None, None], [day1, day2, day3])
- series2 = Series([None, None], [day1, day3])
-
- result = series1.reindex_like(series2, method="pad")
- expected = Series([5, np.nan], index=[day1, day3])
- tm.assert_series_equal(result, expected)
-
-
def test_reindex_fill_value():
# -----------------------------------------------------------
# floats
diff --git a/pandas/tests/series/indexing/test_get.py b/pandas/tests/series/indexing/test_get.py
index 5847141a44ef5..3371c47fa1b0a 100644
--- a/pandas/tests/series/indexing/test_get.py
+++ b/pandas/tests/series/indexing/test_get.py
@@ -1,7 +1,9 @@
import numpy as np
+import pytest
import pandas as pd
from pandas import Series
+import pandas._testing as tm
def test_get():
@@ -149,3 +151,44 @@ def test_get_with_default():
for other in others:
assert s.get(other, "z") == "z"
assert s.get(other, other) == other
+
+
+@pytest.mark.parametrize(
+ "arr",
+ [np.random.randn(10), tm.makeDateIndex(10, name="a").tz_localize(tz="US/Eastern")],
+)
+def test_get2(arr):
+ # TODO: better name, possibly split
+ # GH#21260
+ ser = Series(arr, index=[2 * i for i in range(len(arr))])
+ assert ser.get(4) == ser.iloc[2]
+
+ result = ser.get([4, 6])
+ expected = ser.iloc[[2, 3]]
+ tm.assert_series_equal(result, expected)
+
+ result = ser.get(slice(2))
+ expected = ser.iloc[[0, 1]]
+ tm.assert_series_equal(result, expected)
+
+ assert ser.get(-1) is None
+ assert ser.get(ser.index.max() + 1) is None
+
+ ser = Series(arr[:6], index=list("abcdef"))
+ assert ser.get("c") == ser.iloc[2]
+
+ result = ser.get(slice("b", "d"))
+ expected = ser.iloc[[1, 2, 3]]
+ tm.assert_series_equal(result, expected)
+
+ result = ser.get("Z")
+ assert result is None
+
+ assert ser.get(4) == ser.iloc[4]
+ assert ser.get(-1) == ser.iloc[-1]
+ assert ser.get(len(ser)) is None
+
+ # GH#21257
+ ser = Series(arr)
+ ser2 = ser[::2]
+ assert ser2.get(1) is None
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index 5b3786e1a0d3c..f7c7457f3a703 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -188,46 +188,6 @@ def test_getitem_box_float64(datetime_series):
assert isinstance(value, np.float64)
-@pytest.mark.parametrize(
- "arr",
- [np.random.randn(10), tm.makeDateIndex(10, name="a").tz_localize(tz="US/Eastern")],
-)
-def test_get(arr):
- # GH 21260
- s = Series(arr, index=[2 * i for i in range(len(arr))])
- assert s.get(4) == s.iloc[2]
-
- result = s.get([4, 6])
- expected = s.iloc[[2, 3]]
- tm.assert_series_equal(result, expected)
-
- result = s.get(slice(2))
- expected = s.iloc[[0, 1]]
- tm.assert_series_equal(result, expected)
-
- assert s.get(-1) is None
- assert s.get(s.index.max() + 1) is None
-
- s = Series(arr[:6], index=list("abcdef"))
- assert s.get("c") == s.iloc[2]
-
- result = s.get(slice("b", "d"))
- expected = s.iloc[[1, 2, 3]]
- tm.assert_series_equal(result, expected)
-
- result = s.get("Z")
- assert result is None
-
- assert s.get(4) == s.iloc[4]
- assert s.get(-1) == s.iloc[-1]
- assert s.get(len(s)) is None
-
- # GH 21257
- s = pd.Series(arr)
- s2 = s[::2]
- assert s2.get(1) is None
-
-
def test_series_box_timestamp():
rng = pd.date_range("20090415", "20090519", freq="B")
ser = Series(rng)
@@ -669,11 +629,8 @@ def test_timedelta_assignment():
s = s.reindex(s.index.insert(0, "A"))
tm.assert_series_equal(s, Series([np.nan, Timedelta("1 days")], index=["A", "B"]))
- result = s.fillna(timedelta(1))
- expected = Series(Timedelta("1 days"), index=["A", "B"])
- tm.assert_series_equal(result, expected)
-
s.loc["A"] = timedelta(1)
+ expected = Series(Timedelta("1 days"), index=["A", "B"])
tm.assert_series_equal(s, expected)
# GH 14155
diff --git a/pandas/tests/series/methods/test_argsort.py b/pandas/tests/series/methods/test_argsort.py
index 4353eb4c8cd64..ec9ba468c996c 100644
--- a/pandas/tests/series/methods/test_argsort.py
+++ b/pandas/tests/series/methods/test_argsort.py
@@ -9,7 +9,7 @@ class TestSeriesArgsort:
def _check_accum_op(self, name, ser, check_dtype=True):
func = getattr(np, name)
tm.assert_numpy_array_equal(
- func(ser).values, func(np.array(ser)), check_dtype=check_dtype,
+ func(ser).values, func(np.array(ser)), check_dtype=check_dtype
)
# with missing values
diff --git a/pandas/tests/series/methods/test_convert_dtypes.py b/pandas/tests/series/methods/test_convert_dtypes.py
index a41f893e3753f..94dc42bc764fa 100644
--- a/pandas/tests/series/methods/test_convert_dtypes.py
+++ b/pandas/tests/series/methods/test_convert_dtypes.py
@@ -90,7 +90,7 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): np.dtype("O"),
+ ): np.dtype("O")
},
),
(
@@ -112,7 +112,7 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): np.dtype("float"),
+ ): np.dtype("float")
},
),
(
@@ -129,7 +129,7 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): np.dtype("O"),
+ ): np.dtype("O")
},
),
(
@@ -186,7 +186,7 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): pd.CategoricalDtype(),
+ ): pd.CategoricalDtype()
},
),
(
@@ -198,7 +198,7 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): pd.DatetimeTZDtype(tz="UTC"),
+ ): pd.DatetimeTZDtype(tz="UTC")
},
),
(
@@ -210,17 +210,17 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): np.dtype("datetime64[ns]"),
+ ): np.dtype("datetime64[ns]")
},
),
(
pd.to_datetime(["2020-01-14 10:00", "2020-01-15 11:11"]),
object,
{
- ((True,), (True, False), (True, False), (True, False),): np.dtype(
+ ((True,), (True, False), (True, False), (True, False)): np.dtype(
"datetime64[ns]"
),
- ((False,), (True, False), (True, False), (True, False),): np.dtype(
+ ((False,), (True, False), (True, False), (True, False)): np.dtype(
"O"
),
},
@@ -234,7 +234,7 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): pd.PeriodDtype("M"),
+ ): pd.PeriodDtype("M")
},
),
(
@@ -246,7 +246,7 @@ class TestSeriesConvertDtypes:
(True, False),
(True, False),
(True, False),
- ): pd.IntervalDtype("int64"),
+ ): pd.IntervalDtype("int64")
},
),
],
diff --git a/pandas/tests/series/methods/test_fillna.py b/pandas/tests/series/methods/test_fillna.py
new file mode 100644
index 0000000000000..c34838be24fc1
--- /dev/null
+++ b/pandas/tests/series/methods/test_fillna.py
@@ -0,0 +1,176 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas import Categorical, DataFrame, NaT, Period, Series, Timedelta, Timestamp
+import pandas._testing as tm
+
+
+class TestSeriesFillNA:
+ def test_fillna_pytimedelta(self):
+ # GH#8209
+ ser = Series([np.nan, Timedelta("1 days")], index=["A", "B"])
+
+ result = ser.fillna(timedelta(1))
+ expected = Series(Timedelta("1 days"), index=["A", "B"])
+ tm.assert_series_equal(result, expected)
+
+ def test_fillna_period(self):
+ # GH#13737
+ ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+
+ res = ser.fillna(Period("2012-01", freq="M"))
+ exp = Series([Period("2011-01", freq="M"), Period("2012-01", freq="M")])
+ tm.assert_series_equal(res, exp)
+ assert res.dtype == "Period[M]"
+
+ def test_fillna_dt64_timestamp(self):
+ ser = Series(
+ [
+ Timestamp("20130101"),
+ Timestamp("20130101"),
+ Timestamp("20130102"),
+ Timestamp("20130103 9:01:01"),
+ ]
+ )
+ ser[2] = np.nan
+
+ # reg fillna
+ result = ser.fillna(Timestamp("20130104"))
+ expected = Series(
+ [
+ Timestamp("20130101"),
+ Timestamp("20130101"),
+ Timestamp("20130104"),
+ Timestamp("20130103 9:01:01"),
+ ]
+ )
+ tm.assert_series_equal(result, expected)
+
+ result = ser.fillna(NaT)
+ expected = ser
+ tm.assert_series_equal(result, expected)
+
+ def test_fillna_dt64_non_nao(self):
+ # GH#27419
+ ser = Series([Timestamp("2010-01-01"), NaT, Timestamp("2000-01-01")])
+ val = np.datetime64("1975-04-05", "ms")
+
+ result = ser.fillna(val)
+ expected = Series(
+ [Timestamp("2010-01-01"), Timestamp("1975-04-05"), Timestamp("2000-01-01")]
+ )
+ tm.assert_series_equal(result, expected)
+
+ def test_fillna_numeric_inplace(self):
+ x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
+ y = x.copy()
+
+ y.fillna(value=0, inplace=True)
+
+ expected = x.fillna(value=0)
+ tm.assert_series_equal(y, expected)
+
+ # ---------------------------------------------------------------
+ # CategoricalDtype
+
+ @pytest.mark.parametrize(
+ "fill_value, expected_output",
+ [
+ ("a", ["a", "a", "b", "a", "a"]),
+ ({1: "a", 3: "b", 4: "b"}, ["a", "a", "b", "b", "b"]),
+ ({1: "a"}, ["a", "a", "b", np.nan, np.nan]),
+ ({1: "a", 3: "b"}, ["a", "a", "b", "b", np.nan]),
+ (Series("a"), ["a", np.nan, "b", np.nan, np.nan]),
+ (Series("a", index=[1]), ["a", "a", "b", np.nan, np.nan]),
+ (Series({1: "a", 3: "b"}), ["a", "a", "b", "b", np.nan]),
+ (Series(["a", "b"], index=[3, 4]), ["a", np.nan, "b", "a", "b"]),
+ ],
+ )
+ def test_fillna_categorical(self, fill_value, expected_output):
+ # GH#17033
+ # Test fillna for a Categorical series
+ data = ["a", np.nan, "b", np.nan, np.nan]
+ ser = Series(Categorical(data, categories=["a", "b"]))
+ exp = Series(Categorical(expected_output, categories=["a", "b"]))
+ result = ser.fillna(fill_value)
+ tm.assert_series_equal(result, exp)
+
+ @pytest.mark.parametrize(
+ "fill_value, expected_output",
+ [
+ (Series(["a", "b", "c", "d", "e"]), ["a", "b", "b", "d", "e"]),
+ (Series(["b", "d", "a", "d", "a"]), ["a", "d", "b", "d", "a"]),
+ (
+ Series(
+ Categorical(
+ ["b", "d", "a", "d", "a"], categories=["b", "c", "d", "e", "a"]
+ )
+ ),
+ ["a", "d", "b", "d", "a"],
+ ),
+ ],
+ )
+ def test_fillna_categorical_with_new_categories(self, fill_value, expected_output):
+ # GH#26215
+ data = ["a", np.nan, "b", np.nan, np.nan]
+ ser = Series(Categorical(data, categories=["a", "b", "c", "d", "e"]))
+ exp = Series(Categorical(expected_output, categories=["a", "b", "c", "d", "e"]))
+ result = ser.fillna(fill_value)
+ tm.assert_series_equal(result, exp)
+
+ def test_fillna_categorical_raises(self):
+ data = ["a", np.nan, "b", np.nan, np.nan]
+ ser = Series(Categorical(data, categories=["a", "b"]))
+
+ with pytest.raises(ValueError, match="fill value must be in categories"):
+ ser.fillna("d")
+
+ with pytest.raises(ValueError, match="fill value must be in categories"):
+ ser.fillna(Series("d"))
+
+ with pytest.raises(ValueError, match="fill value must be in categories"):
+ ser.fillna({1: "d", 3: "a"})
+
+ msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
+ with pytest.raises(TypeError, match=msg):
+ ser.fillna(["a", "b"])
+
+ msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
+ with pytest.raises(TypeError, match=msg):
+ ser.fillna(("a", "b"))
+
+ msg = (
+ '"value" parameter must be a scalar, dict '
+ 'or Series, but you passed a "DataFrame"'
+ )
+ with pytest.raises(TypeError, match=msg):
+ ser.fillna(DataFrame({1: ["a"], 3: ["b"]}))
+
+ # ---------------------------------------------------------------
+ # Invalid Usages
+
+ def test_fillna_listlike_invalid(self):
+ ser = Series(np.random.randint(-100, 100, 50))
+ msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
+ with pytest.raises(TypeError, match=msg):
+ ser.fillna([1, 2])
+
+ msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
+ with pytest.raises(TypeError, match=msg):
+ ser.fillna((1, 2))
+
+ def test_fillna_method_and_limit_invalid(self):
+
+ # related GH#9217, make sure limit is an int and greater than 0
+ ser = Series([1, 2, 3, None])
+ msg = (
+ r"Cannot specify both 'value' and 'method'\.|"
+ r"Limit must be greater than 0|"
+ "Limit must be an integer"
+ )
+ for limit in [-1, 0, 1.0, 2.0]:
+ for method in ["backfill", "bfill", "pad", "ffill", None]:
+ with pytest.raises(ValueError, match=msg):
+ ser.fillna(1, limit=limit, method=method)
diff --git a/pandas/tests/series/methods/test_reindex_like.py b/pandas/tests/series/methods/test_reindex_like.py
new file mode 100644
index 0000000000000..7f24c778feb1b
--- /dev/null
+++ b/pandas/tests/series/methods/test_reindex_like.py
@@ -0,0 +1,41 @@
+from datetime import datetime
+
+import numpy as np
+
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_reindex_like(datetime_series):
+ other = datetime_series[::2]
+ tm.assert_series_equal(
+ datetime_series.reindex(other.index), datetime_series.reindex_like(other)
+ )
+
+ # GH#7179
+ day1 = datetime(2013, 3, 5)
+ day2 = datetime(2013, 5, 5)
+ day3 = datetime(2014, 3, 5)
+
+ series1 = Series([5, None, None], [day1, day2, day3])
+ series2 = Series([None, None], [day1, day3])
+
+ result = series1.reindex_like(series2, method="pad")
+ expected = Series([5, np.nan], index=[day1, day3])
+ tm.assert_series_equal(result, expected)
+
+
+def test_reindex_like_nearest():
+ ser = Series(np.arange(10, dtype="int64"))
+
+ target = [0.1, 0.9, 1.5, 2.0]
+ other = ser.reindex(target, method="nearest")
+ expected = Series(np.around(target).astype("int64"), target)
+
+ result = ser.reindex_like(other, method="nearest")
+ tm.assert_series_equal(expected, result)
+
+ result = ser.reindex_like(other, method="nearest", tolerance=1)
+ tm.assert_series_equal(expected, result)
+ result = ser.reindex_like(other, method="nearest", tolerance=[1, 2, 3, 4])
+ tm.assert_series_equal(expected, result)
diff --git a/pandas/tests/series/methods/test_searchsorted.py b/pandas/tests/series/methods/test_searchsorted.py
index fd6c6f74a9136..5a6ec0039c7cd 100644
--- a/pandas/tests/series/methods/test_searchsorted.py
+++ b/pandas/tests/series/methods/test_searchsorted.py
@@ -40,6 +40,14 @@ def test_searchsorted_datetime64_scalar(self):
assert is_scalar(res)
assert res == 1
+ def test_searchsorted_datetime64_scalar_mixed_timezones(self):
+ # GH 30086
+ ser = Series(date_range("20120101", periods=10, freq="2D", tz="UTC"))
+ val = Timestamp("20120102", tz="America/New_York")
+ res = ser.searchsorted(val)
+ assert is_scalar(res)
+ assert res == 1
+
def test_searchsorted_datetime64_list(self):
ser = Series(date_range("20120101", periods=10, freq="2D"))
vals = [Timestamp("20120102"), Timestamp("20120104")]
diff --git a/pandas/tests/series/methods/test_sort_index.py b/pandas/tests/series/methods/test_sort_index.py
index d4ebc9062a0c9..2d4fdfd5a3950 100644
--- a/pandas/tests/series/methods/test_sort_index.py
+++ b/pandas/tests/series/methods/test_sort_index.py
@@ -8,6 +8,10 @@
class TestSeriesSortIndex:
+ def test_sort_index_name(self, datetime_series):
+ result = datetime_series.sort_index(ascending=False)
+ assert result.name == datetime_series.name
+
def test_sort_index(self, datetime_series):
rindex = list(datetime_series.index)
random.shuffle(rindex)
diff --git a/pandas/tests/series/methods/test_unstack.py b/pandas/tests/series/methods/test_unstack.py
index 7645fb8759a54..d651315d64561 100644
--- a/pandas/tests/series/methods/test_unstack.py
+++ b/pandas/tests/series/methods/test_unstack.py
@@ -75,9 +75,7 @@ def test_unstack_tuplename_in_multiindex():
expected = pd.DataFrame(
[[1, 1, 1], [1, 1, 1], [1, 1, 1]],
- columns=pd.MultiIndex.from_tuples(
- [("a",), ("b",), ("c",)], names=[("A", "a")],
- ),
+ columns=pd.MultiIndex.from_tuples([("a",), ("b",), ("c",)], names=[("A", "a")]),
index=pd.Index([1, 2, 3], name=("B", "b")),
)
tm.assert_frame_equal(result, expected)
@@ -115,6 +113,23 @@ def test_unstack_mixed_type_name_in_multiindex(
result = ser.unstack(unstack_idx)
expected = pd.DataFrame(
- expected_values, columns=expected_columns, index=expected_index,
+ expected_values, columns=expected_columns, index=expected_index
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+def test_unstack_multi_index_categorical_values():
+
+ mi = tm.makeTimeDataFrame().stack().index.rename(["major", "minor"])
+ ser = pd.Series(["foo"] * len(mi), index=mi, name="category", dtype="category")
+
+ result = ser.unstack()
+
+ dti = ser.index.levels[0]
+ c = pd.Categorical(["foo"] * len(dti))
+ expected = DataFrame(
+ {"A": c.copy(), "B": c.copy(), "C": c.copy(), "D": c.copy()},
+ columns=pd.Index(list("ABCD"), name="minor"),
+ index=dti.rename("major"),
)
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/series/test_alter_axes.py b/pandas/tests/series/test_alter_axes.py
index c2bb498df2be2..203750757e28d 100644
--- a/pandas/tests/series/test_alter_axes.py
+++ b/pandas/tests/series/test_alter_axes.py
@@ -53,39 +53,3 @@ def test_set_index_makes_timeseries(self):
s = Series(range(10))
s.index = idx
assert s.index.is_all_dates
-
- def test_set_axis_inplace_axes(self, axis_series):
- # GH14636
- ser = Series(np.arange(4), index=[1, 3, 5, 7], dtype="int64")
-
- expected = ser.copy()
- expected.index = list("abcd")
-
- # inplace=True
- # The FutureWarning comes from the fact that we would like to have
- # inplace default to False some day
- result = ser.copy()
- result.set_axis(list("abcd"), axis=axis_series, inplace=True)
- tm.assert_series_equal(result, expected)
-
- def test_set_axis_inplace(self):
- # GH14636
-
- s = Series(np.arange(4), index=[1, 3, 5, 7], dtype="int64")
-
- expected = s.copy()
- expected.index = list("abcd")
-
- # inplace=False
- result = s.set_axis(list("abcd"), axis=0, inplace=False)
- tm.assert_series_equal(expected, result)
-
- # omitting the "axis" parameter
- with tm.assert_produces_warning(None):
- result = s.set_axis(list("abcd"), inplace=False)
- tm.assert_series_equal(result, expected)
-
- # wrong values for the "axis" parameter
- for axis in [2, "foo"]:
- with pytest.raises(ValueError, match="No axis named"):
- s.set_axis(list("abcd"), axis=axis, inplace=False)
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index 3e877cf2fc787..302ca8d1aa43e 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -110,10 +110,6 @@ def _pickle_roundtrip(self, obj):
unpickled = pd.read_pickle(path)
return unpickled
- def test_sort_index_name(self, datetime_series):
- result = datetime_series.sort_index(ascending=False)
- assert result.name == datetime_series.name
-
def test_constructor_dict(self):
d = {"a": 0.0, "b": 1.0, "c": 2.0}
result = Series(d)
diff --git a/pandas/tests/series/test_cumulative.py b/pandas/tests/series/test_cumulative.py
index 0cb1c038478f5..038db0b0a70fc 100644
--- a/pandas/tests/series/test_cumulative.py
+++ b/pandas/tests/series/test_cumulative.py
@@ -18,7 +18,7 @@
def _check_accum_op(name, series, check_dtype=True):
func = getattr(np, name)
tm.assert_numpy_array_equal(
- func(series).values, func(np.array(series)), check_dtype=check_dtype,
+ func(series).values, func(np.array(series)), check_dtype=check_dtype
)
# with missing values
diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py
index 1687f80e9f3ed..9e9b93a499487 100644
--- a/pandas/tests/series/test_missing.py
+++ b/pandas/tests/series/test_missing.py
@@ -122,22 +122,6 @@ def test_datetime64_fillna(self):
)
s[2] = np.nan
- # reg fillna
- result = s.fillna(Timestamp("20130104"))
- expected = Series(
- [
- Timestamp("20130101"),
- Timestamp("20130101"),
- Timestamp("20130104"),
- Timestamp("20130103 9:01:01"),
- ]
- )
- tm.assert_series_equal(result, expected)
-
- result = s.fillna(NaT)
- expected = s
- tm.assert_series_equal(result, expected)
-
# ffill
result = s.ffill()
expected = Series(
@@ -177,242 +161,228 @@ def test_datetime64_fillna(self):
result = s.fillna(method="backfill")
tm.assert_series_equal(result, expected)
- def test_datetime64_tz_fillna(self):
-
- for tz in ["US/Eastern", "Asia/Tokyo"]:
- # DatetimeBlock
- s = Series(
- [
- Timestamp("2011-01-01 10:00"),
- pd.NaT,
- Timestamp("2011-01-03 10:00"),
- pd.NaT,
- ]
- )
- null_loc = pd.Series([False, True, False, True])
-
- result = s.fillna(pd.Timestamp("2011-01-02 10:00"))
- expected = Series(
- [
- Timestamp("2011-01-01 10:00"),
- Timestamp("2011-01-02 10:00"),
- Timestamp("2011-01-03 10:00"),
- Timestamp("2011-01-02 10:00"),
- ]
- )
- tm.assert_series_equal(expected, result)
- # check s is not changed
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(pd.Timestamp("2011-01-02 10:00", tz=tz))
- expected = Series(
- [
- Timestamp("2011-01-01 10:00"),
- Timestamp("2011-01-02 10:00", tz=tz),
- Timestamp("2011-01-03 10:00"),
- Timestamp("2011-01-02 10:00", tz=tz),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna("AAA")
- expected = Series(
- [
- Timestamp("2011-01-01 10:00"),
- "AAA",
- Timestamp("2011-01-03 10:00"),
- "AAA",
- ],
- dtype=object,
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(
- {
- 1: pd.Timestamp("2011-01-02 10:00", tz=tz),
- 3: pd.Timestamp("2011-01-04 10:00"),
- }
- )
- expected = Series(
- [
- Timestamp("2011-01-01 10:00"),
- Timestamp("2011-01-02 10:00", tz=tz),
- Timestamp("2011-01-03 10:00"),
- Timestamp("2011-01-04 10:00"),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(
- {
- 1: pd.Timestamp("2011-01-02 10:00"),
- 3: pd.Timestamp("2011-01-04 10:00"),
- }
- )
- expected = Series(
- [
- Timestamp("2011-01-01 10:00"),
- Timestamp("2011-01-02 10:00"),
- Timestamp("2011-01-03 10:00"),
- Timestamp("2011-01-04 10:00"),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- # DatetimeBlockTZ
- idx = pd.DatetimeIndex(
- ["2011-01-01 10:00", pd.NaT, "2011-01-03 10:00", pd.NaT], tz=tz
- )
- s = pd.Series(idx)
- assert s.dtype == f"datetime64[ns, {tz}]"
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(pd.Timestamp("2011-01-02 10:00"))
- expected = Series(
- [
- Timestamp("2011-01-01 10:00", tz=tz),
- Timestamp("2011-01-02 10:00"),
- Timestamp("2011-01-03 10:00", tz=tz),
- Timestamp("2011-01-02 10:00"),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(pd.Timestamp("2011-01-02 10:00", tz=tz))
- idx = pd.DatetimeIndex(
- [
- "2011-01-01 10:00",
- "2011-01-02 10:00",
- "2011-01-03 10:00",
- "2011-01-02 10:00",
- ],
- tz=tz,
- )
- expected = Series(idx)
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(pd.Timestamp("2011-01-02 10:00", tz=tz).to_pydatetime())
- idx = pd.DatetimeIndex(
- [
- "2011-01-01 10:00",
- "2011-01-02 10:00",
- "2011-01-03 10:00",
- "2011-01-02 10:00",
- ],
- tz=tz,
- )
- expected = Series(idx)
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna("AAA")
- expected = Series(
- [
- Timestamp("2011-01-01 10:00", tz=tz),
- "AAA",
- Timestamp("2011-01-03 10:00", tz=tz),
- "AAA",
- ],
- dtype=object,
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(
- {
- 1: pd.Timestamp("2011-01-02 10:00", tz=tz),
- 3: pd.Timestamp("2011-01-04 10:00"),
- }
- )
- expected = Series(
- [
- Timestamp("2011-01-01 10:00", tz=tz),
- Timestamp("2011-01-02 10:00", tz=tz),
- Timestamp("2011-01-03 10:00", tz=tz),
- Timestamp("2011-01-04 10:00"),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(
- {
- 1: pd.Timestamp("2011-01-02 10:00", tz=tz),
- 3: pd.Timestamp("2011-01-04 10:00", tz=tz),
- }
- )
- expected = Series(
- [
- Timestamp("2011-01-01 10:00", tz=tz),
- Timestamp("2011-01-02 10:00", tz=tz),
- Timestamp("2011-01-03 10:00", tz=tz),
- Timestamp("2011-01-04 10:00", tz=tz),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- # filling with a naive/other zone, coerce to object
- result = s.fillna(Timestamp("20130101"))
- expected = Series(
- [
- Timestamp("2011-01-01 10:00", tz=tz),
- Timestamp("2013-01-01"),
- Timestamp("2011-01-03 10:00", tz=tz),
- Timestamp("2013-01-01"),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
-
- result = s.fillna(Timestamp("20130101", tz="US/Pacific"))
- expected = Series(
- [
- Timestamp("2011-01-01 10:00", tz=tz),
- Timestamp("2013-01-01", tz="US/Pacific"),
- Timestamp("2011-01-03 10:00", tz=tz),
- Timestamp("2013-01-01", tz="US/Pacific"),
- ]
- )
- tm.assert_series_equal(expected, result)
- tm.assert_series_equal(pd.isna(s), null_loc)
+ @pytest.mark.parametrize("tz", ["US/Eastern", "Asia/Tokyo"])
+ def test_datetime64_tz_fillna(self, tz):
+ # DatetimeBlock
+ s = Series(
+ [
+ Timestamp("2011-01-01 10:00"),
+ pd.NaT,
+ Timestamp("2011-01-03 10:00"),
+ pd.NaT,
+ ]
+ )
+ null_loc = pd.Series([False, True, False, True])
+
+ result = s.fillna(pd.Timestamp("2011-01-02 10:00"))
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00"),
+ Timestamp("2011-01-02 10:00"),
+ Timestamp("2011-01-03 10:00"),
+ Timestamp("2011-01-02 10:00"),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ # check s is not changed
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(pd.Timestamp("2011-01-02 10:00", tz=tz))
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00"),
+ Timestamp("2011-01-02 10:00", tz=tz),
+ Timestamp("2011-01-03 10:00"),
+ Timestamp("2011-01-02 10:00", tz=tz),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna("AAA")
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00"),
+ "AAA",
+ Timestamp("2011-01-03 10:00"),
+ "AAA",
+ ],
+ dtype=object,
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(
+ {
+ 1: pd.Timestamp("2011-01-02 10:00", tz=tz),
+ 3: pd.Timestamp("2011-01-04 10:00"),
+ }
+ )
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00"),
+ Timestamp("2011-01-02 10:00", tz=tz),
+ Timestamp("2011-01-03 10:00"),
+ Timestamp("2011-01-04 10:00"),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(
+ {1: pd.Timestamp("2011-01-02 10:00"), 3: pd.Timestamp("2011-01-04 10:00")}
+ )
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00"),
+ Timestamp("2011-01-02 10:00"),
+ Timestamp("2011-01-03 10:00"),
+ Timestamp("2011-01-04 10:00"),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ # DatetimeBlockTZ
+ idx = pd.DatetimeIndex(
+ ["2011-01-01 10:00", pd.NaT, "2011-01-03 10:00", pd.NaT], tz=tz
+ )
+ s = pd.Series(idx)
+ assert s.dtype == f"datetime64[ns, {tz}]"
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(pd.Timestamp("2011-01-02 10:00"))
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00", tz=tz),
+ Timestamp("2011-01-02 10:00"),
+ Timestamp("2011-01-03 10:00", tz=tz),
+ Timestamp("2011-01-02 10:00"),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(pd.Timestamp("2011-01-02 10:00", tz=tz))
+ idx = pd.DatetimeIndex(
+ [
+ "2011-01-01 10:00",
+ "2011-01-02 10:00",
+ "2011-01-03 10:00",
+ "2011-01-02 10:00",
+ ],
+ tz=tz,
+ )
+ expected = Series(idx)
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+ result = s.fillna(pd.Timestamp("2011-01-02 10:00", tz=tz).to_pydatetime())
+ idx = pd.DatetimeIndex(
+ [
+ "2011-01-01 10:00",
+ "2011-01-02 10:00",
+ "2011-01-03 10:00",
+ "2011-01-02 10:00",
+ ],
+ tz=tz,
+ )
+ expected = Series(idx)
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna("AAA")
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00", tz=tz),
+ "AAA",
+ Timestamp("2011-01-03 10:00", tz=tz),
+ "AAA",
+ ],
+ dtype=object,
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(
+ {
+ 1: pd.Timestamp("2011-01-02 10:00", tz=tz),
+ 3: pd.Timestamp("2011-01-04 10:00"),
+ }
+ )
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00", tz=tz),
+ Timestamp("2011-01-02 10:00", tz=tz),
+ Timestamp("2011-01-03 10:00", tz=tz),
+ Timestamp("2011-01-04 10:00"),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(
+ {
+ 1: pd.Timestamp("2011-01-02 10:00", tz=tz),
+ 3: pd.Timestamp("2011-01-04 10:00", tz=tz),
+ }
+ )
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00", tz=tz),
+ Timestamp("2011-01-02 10:00", tz=tz),
+ Timestamp("2011-01-03 10:00", tz=tz),
+ Timestamp("2011-01-04 10:00", tz=tz),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ # filling with a naive/other zone, coerce to object
+ result = s.fillna(Timestamp("20130101"))
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00", tz=tz),
+ Timestamp("2013-01-01"),
+ Timestamp("2011-01-03 10:00", tz=tz),
+ Timestamp("2013-01-01"),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ result = s.fillna(Timestamp("20130101", tz="US/Pacific"))
+ expected = Series(
+ [
+ Timestamp("2011-01-01 10:00", tz=tz),
+ Timestamp("2013-01-01", tz="US/Pacific"),
+ Timestamp("2011-01-03 10:00", tz=tz),
+ Timestamp("2013-01-01", tz="US/Pacific"),
+ ]
+ )
+ tm.assert_series_equal(expected, result)
+ tm.assert_series_equal(pd.isna(s), null_loc)
+
+ def test_fillna_dt64tz_with_method(self):
# with timezone
# GH 15855
- df = pd.Series([pd.Timestamp("2012-11-11 00:00:00+01:00"), pd.NaT])
+ ser = pd.Series([pd.Timestamp("2012-11-11 00:00:00+01:00"), pd.NaT])
exp = pd.Series(
[
pd.Timestamp("2012-11-11 00:00:00+01:00"),
pd.Timestamp("2012-11-11 00:00:00+01:00"),
]
)
- tm.assert_series_equal(df.fillna(method="pad"), exp)
+ tm.assert_series_equal(ser.fillna(method="pad"), exp)
- df = pd.Series([pd.NaT, pd.Timestamp("2012-11-11 00:00:00+01:00")])
+ ser = pd.Series([pd.NaT, pd.Timestamp("2012-11-11 00:00:00+01:00")])
exp = pd.Series(
[
pd.Timestamp("2012-11-11 00:00:00+01:00"),
pd.Timestamp("2012-11-11 00:00:00+01:00"),
]
)
- tm.assert_series_equal(df.fillna(method="bfill"), exp)
-
- def test_datetime64_non_nano_fillna(self):
- # GH#27419
- ser = Series([Timestamp("2010-01-01"), pd.NaT, Timestamp("2000-01-01")])
- val = np.datetime64("1975-04-05", "ms")
-
- result = ser.fillna(val)
- expected = Series(
- [Timestamp("2010-01-01"), Timestamp("1975-04-05"), Timestamp("2000-01-01")]
- )
- tm.assert_series_equal(result, expected)
+ tm.assert_series_equal(ser.fillna(method="bfill"), exp)
def test_fillna_consistency(self):
# GH 16402
@@ -486,28 +456,6 @@ def test_fillna_int(self):
s.fillna(method="ffill", inplace=True)
tm.assert_series_equal(s.fillna(method="ffill", inplace=False), s)
- def test_fillna_raise(self):
- s = Series(np.random.randint(-100, 100, 50))
- msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
- with pytest.raises(TypeError, match=msg):
- s.fillna([1, 2])
-
- msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
- with pytest.raises(TypeError, match=msg):
- s.fillna((1, 2))
-
- # related GH 9217, make sure limit is an int and greater than 0
- s = Series([1, 2, 3, None])
- msg = (
- r"Cannot specify both 'value' and 'method'\.|"
- r"Limit must be greater than 0|"
- "Limit must be an integer"
- )
- for limit in [-1, 0, 1.0, 2.0]:
- for method in ["backfill", "bfill", "pad", "ffill", None]:
- with pytest.raises(ValueError, match=msg):
- s.fillna(1, limit=limit, method=method)
-
def test_categorical_nan_equality(self):
cat = Series(Categorical(["a", "b", "c", np.nan]))
exp = Series([True, True, True, False])
@@ -523,77 +471,6 @@ def test_categorical_nan_handling(self):
s.values.codes, np.array([0, 1, -1, 0], dtype=np.int8)
)
- @pytest.mark.parametrize(
- "fill_value, expected_output",
- [
- ("a", ["a", "a", "b", "a", "a"]),
- ({1: "a", 3: "b", 4: "b"}, ["a", "a", "b", "b", "b"]),
- ({1: "a"}, ["a", "a", "b", np.nan, np.nan]),
- ({1: "a", 3: "b"}, ["a", "a", "b", "b", np.nan]),
- (Series("a"), ["a", np.nan, "b", np.nan, np.nan]),
- (Series("a", index=[1]), ["a", "a", "b", np.nan, np.nan]),
- (Series({1: "a", 3: "b"}), ["a", "a", "b", "b", np.nan]),
- (Series(["a", "b"], index=[3, 4]), ["a", np.nan, "b", "a", "b"]),
- ],
- )
- def test_fillna_categorical(self, fill_value, expected_output):
- # GH 17033
- # Test fillna for a Categorical series
- data = ["a", np.nan, "b", np.nan, np.nan]
- s = Series(Categorical(data, categories=["a", "b"]))
- exp = Series(Categorical(expected_output, categories=["a", "b"]))
- tm.assert_series_equal(s.fillna(fill_value), exp)
-
- @pytest.mark.parametrize(
- "fill_value, expected_output",
- [
- (Series(["a", "b", "c", "d", "e"]), ["a", "b", "b", "d", "e"]),
- (Series(["b", "d", "a", "d", "a"]), ["a", "d", "b", "d", "a"]),
- (
- Series(
- Categorical(
- ["b", "d", "a", "d", "a"], categories=["b", "c", "d", "e", "a"]
- )
- ),
- ["a", "d", "b", "d", "a"],
- ),
- ],
- )
- def test_fillna_categorical_with_new_categories(self, fill_value, expected_output):
- # GH 26215
- data = ["a", np.nan, "b", np.nan, np.nan]
- s = Series(Categorical(data, categories=["a", "b", "c", "d", "e"]))
- exp = Series(Categorical(expected_output, categories=["a", "b", "c", "d", "e"]))
- tm.assert_series_equal(s.fillna(fill_value), exp)
-
- def test_fillna_categorical_raise(self):
- data = ["a", np.nan, "b", np.nan, np.nan]
- s = Series(Categorical(data, categories=["a", "b"]))
-
- with pytest.raises(ValueError, match="fill value must be in categories"):
- s.fillna("d")
-
- with pytest.raises(ValueError, match="fill value must be in categories"):
- s.fillna(Series("d"))
-
- with pytest.raises(ValueError, match="fill value must be in categories"):
- s.fillna({1: "d", 3: "a"})
-
- msg = '"value" parameter must be a scalar or dict, but you passed a "list"'
- with pytest.raises(TypeError, match=msg):
- s.fillna(["a", "b"])
-
- msg = '"value" parameter must be a scalar or dict, but you passed a "tuple"'
- with pytest.raises(TypeError, match=msg):
- s.fillna(("a", "b"))
-
- msg = (
- '"value" parameter must be a scalar, dict '
- 'or Series, but you passed a "DataFrame"'
- )
- with pytest.raises(TypeError, match=msg):
- s.fillna(DataFrame({1: ["a"], 3: ["b"]}))
-
def test_fillna_nat(self):
series = Series([0, 1, 2, iNaT], dtype="M8[ns]")
@@ -736,15 +613,6 @@ def test_fillna_bug(self):
expected = Series([1.0, 1.0, 3.0, 3.0, np.nan], x.index)
tm.assert_series_equal(filled, expected)
- def test_fillna_inplace(self):
- x = Series([np.nan, 1.0, np.nan, 3.0, np.nan], ["z", "a", "b", "c", "d"])
- y = x.copy()
-
- y.fillna(value=0, inplace=True)
-
- expected = x.fillna(value=0)
- tm.assert_series_equal(y, expected)
-
def test_fillna_invalid_method(self, datetime_series):
try:
datetime_series.fillna(method="ffil")
diff --git a/pandas/tests/series/test_period.py b/pandas/tests/series/test_period.py
index d5a3efcf5757c..5c2c1db14e70f 100644
--- a/pandas/tests/series/test_period.py
+++ b/pandas/tests/series/test_period.py
@@ -38,15 +38,6 @@ def test_isna(self):
tm.assert_series_equal(s.isna(), Series([False, True]))
tm.assert_series_equal(s.notna(), Series([True, False]))
- def test_fillna(self):
- # GH 13737
- s = Series([pd.Period("2011-01", freq="M"), pd.Period("NaT", freq="M")])
-
- res = s.fillna(pd.Period("2012-01", freq="M"))
- exp = Series([pd.Period("2011-01", freq="M"), pd.Period("2012-01", freq="M")])
- tm.assert_series_equal(res, exp)
- assert res.dtype == "Period[M]"
-
def test_dropna(self):
# GH 13737
s = Series([pd.Period("2011-01", freq="M"), pd.Period("NaT", freq="M")])
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index 84279d874bae1..207b397c3e1ff 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -1252,92 +1252,6 @@ def test_level_with_tuples(self):
tm.assert_frame_equal(result, expected)
tm.assert_frame_equal(result2, expected)
- def test_mixed_depth_drop(self):
- arrays = [
- ["a", "top", "top", "routine1", "routine1", "routine2"],
- ["", "OD", "OD", "result1", "result2", "result1"],
- ["", "wx", "wy", "", "", ""],
- ]
-
- tuples = sorted(zip(*arrays))
- index = MultiIndex.from_tuples(tuples)
- df = DataFrame(randn(4, 6), columns=index)
-
- result = df.drop("a", axis=1)
- expected = df.drop([("a", "", "")], axis=1)
- tm.assert_frame_equal(expected, result)
-
- result = df.drop(["top"], axis=1)
- expected = df.drop([("top", "OD", "wx")], axis=1)
- expected = expected.drop([("top", "OD", "wy")], axis=1)
- tm.assert_frame_equal(expected, result)
-
- result = df.drop(("top", "OD", "wx"), axis=1)
- expected = df.drop([("top", "OD", "wx")], axis=1)
- tm.assert_frame_equal(expected, result)
-
- expected = df.drop([("top", "OD", "wy")], axis=1)
- expected = df.drop("top", axis=1)
-
- result = df.drop("result1", level=1, axis=1)
- expected = df.drop(
- [("routine1", "result1", ""), ("routine2", "result1", "")], axis=1
- )
- tm.assert_frame_equal(expected, result)
-
- def test_drop_multiindex_other_level_nan(self):
- # GH 12754
- df = (
- DataFrame(
- {
- "A": ["one", "one", "two", "two"],
- "B": [np.nan, 0.0, 1.0, 2.0],
- "C": ["a", "b", "c", "c"],
- "D": [1, 2, 3, 4],
- }
- )
- .set_index(["A", "B", "C"])
- .sort_index()
- )
- result = df.drop("c", level="C")
- expected = DataFrame(
- [2, 1],
- columns=["D"],
- index=pd.MultiIndex.from_tuples(
- [("one", 0.0, "b"), ("one", np.nan, "a")], names=["A", "B", "C"]
- ),
- )
- tm.assert_frame_equal(result, expected)
-
- def test_drop_nonunique(self):
- df = DataFrame(
- [
- ["x-a", "x", "a", 1.5],
- ["x-a", "x", "a", 1.2],
- ["z-c", "z", "c", 3.1],
- ["x-a", "x", "a", 4.1],
- ["x-b", "x", "b", 5.1],
- ["x-b", "x", "b", 4.1],
- ["x-b", "x", "b", 2.2],
- ["y-a", "y", "a", 1.2],
- ["z-b", "z", "b", 2.1],
- ],
- columns=["var1", "var2", "var3", "var4"],
- )
-
- grp_size = df.groupby("var1").size()
- drop_idx = grp_size.loc[grp_size == 1]
-
- idf = df.set_index(["var1", "var2", "var3"])
-
- # it works! #2101
- result = idf.drop(drop_idx.index, level=0).reset_index()
- expected = df[-df.var1.isin(drop_idx.index)]
-
- result.index = expected.index
-
- tm.assert_frame_equal(result, expected)
-
def test_mixed_depth_pop(self):
arrays = [
["a", "top", "top", "routine1", "routine1", "routine2"],
@@ -1380,68 +1294,6 @@ def test_reindex_level_partial_selection(self):
result = self.frame.T.loc[:, ["foo", "qux"]]
tm.assert_frame_equal(result, expected.T)
- def test_drop_level(self):
- result = self.frame.drop(["bar", "qux"], level="first")
- expected = self.frame.iloc[[0, 1, 2, 5, 6]]
- tm.assert_frame_equal(result, expected)
-
- result = self.frame.drop(["two"], level="second")
- expected = self.frame.iloc[[0, 2, 3, 6, 7, 9]]
- tm.assert_frame_equal(result, expected)
-
- result = self.frame.T.drop(["bar", "qux"], axis=1, level="first")
- expected = self.frame.iloc[[0, 1, 2, 5, 6]].T
- tm.assert_frame_equal(result, expected)
-
- result = self.frame.T.drop(["two"], axis=1, level="second")
- expected = self.frame.iloc[[0, 2, 3, 6, 7, 9]].T
- tm.assert_frame_equal(result, expected)
-
- def test_drop_level_nonunique_datetime(self):
- # GH 12701
- idx = Index([2, 3, 4, 4, 5], name="id")
- idxdt = pd.to_datetime(
- [
- "201603231400",
- "201603231500",
- "201603231600",
- "201603231600",
- "201603231700",
- ]
- )
- df = DataFrame(np.arange(10).reshape(5, 2), columns=list("ab"), index=idx)
- df["tstamp"] = idxdt
- df = df.set_index("tstamp", append=True)
- ts = Timestamp("201603231600")
- assert df.index.is_unique is False
-
- result = df.drop(ts, level="tstamp")
- expected = df.loc[idx != 4]
- tm.assert_frame_equal(result, expected)
-
- @pytest.mark.parametrize("box", [Series, DataFrame])
- def test_drop_tz_aware_timestamp_across_dst(self, box):
- # GH 21761
- start = Timestamp("2017-10-29", tz="Europe/Berlin")
- end = Timestamp("2017-10-29 04:00:00", tz="Europe/Berlin")
- index = pd.date_range(start, end, freq="15min")
- data = box(data=[1] * len(index), index=index)
- result = data.drop(start)
- expected_start = Timestamp("2017-10-29 00:15:00", tz="Europe/Berlin")
- expected_idx = pd.date_range(expected_start, end, freq="15min")
- expected = box(data=[1] * len(expected_idx), index=expected_idx)
- tm.assert_equal(result, expected)
-
- def test_drop_preserve_names(self):
- index = MultiIndex.from_arrays(
- [[0, 0, 0, 1, 1, 1], [1, 2, 3, 1, 2, 3]], names=["one", "two"]
- )
-
- df = DataFrame(np.random.randn(6, 3), index=index)
-
- result = df.drop([(0, 2)])
- assert result.index.names == ("one", "two")
-
def test_unicode_repr_level_names(self):
index = MultiIndex.from_tuples([(0, 0), (1, 1)], names=["\u0394", "i1"])
@@ -2292,7 +2144,7 @@ def test_multilevel_index_loc_order(self, dim, keys, expected):
# GH 22797
# Try to respect order of keys given for MultiIndex.loc
kwargs = {dim: [["c", "a", "a", "b", "b"], [1, 1, 2, 1, 2]]}
- df = pd.DataFrame(np.arange(25).reshape(5, 5), **kwargs,)
+ df = pd.DataFrame(np.arange(25).reshape(5, 5), **kwargs)
exp_index = MultiIndex.from_arrays(expected)
if dim == "index":
res = df.loc[keys, :]
diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index cac6a59527a6e..9b440a8a84892 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -285,7 +285,7 @@ def test_nansum(self, skipna):
def test_nanmean(self, skipna):
self.check_funs(
- nanops.nanmean, np.mean, skipna, allow_obj=False, allow_date=False,
+ nanops.nanmean, np.mean, skipna, allow_obj=False, allow_date=False
)
def test_nanmean_overflow(self):
diff --git a/pandas/tests/test_strings.py b/pandas/tests/test_strings.py
index 6289c2efea7f1..84b5d64ea1f84 100644
--- a/pandas/tests/test_strings.py
+++ b/pandas/tests/test_strings.py
@@ -3556,9 +3556,7 @@ def test_string_array(any_string_method):
result = getattr(b.str, method_name)(*args, **kwargs)
if isinstance(expected, Series):
- if expected.dtype == "object" and lib.is_string_array(
- expected.dropna().values,
- ):
+ if expected.dtype == "object" and lib.is_string_array(expected.dropna().values):
assert result.dtype == "string"
result = result.astype(object)
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index a751182dbf7af..f3b68caf3dcf5 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -602,7 +602,7 @@ def test_to_datetime_array_of_dt64s(self, cache, unit):
pd.to_datetime(dts_with_oob, errors="coerce", cache=cache),
pd.DatetimeIndex(
[Timestamp(dts_with_oob[0]).asm8, Timestamp(dts_with_oob[1]).asm8] * 30
- + [pd.NaT],
+ + [pd.NaT]
),
)
@@ -1862,6 +1862,18 @@ def test_to_datetime_infer_datetime_format_series_start_with_nans(self, cache):
pd.to_datetime(s, infer_datetime_format=True, cache=cache),
)
+ @pytest.mark.parametrize(
+ "tz_name, offset", [("UTC", 0), ("UTC-3", 180), ("UTC+3", -180)]
+ )
+ def test_infer_datetime_format_tz_name(self, tz_name, offset):
+ # GH 33133
+ s = pd.Series([f"2019-02-02 08:07:13 {tz_name}"])
+ result = to_datetime(s, infer_datetime_format=True)
+ expected = pd.Series(
+ [pd.Timestamp("2019-02-02 08:07:13").tz_localize(pytz.FixedOffset(offset))]
+ )
+ tm.assert_series_equal(result, expected)
+
@pytest.mark.parametrize("cache", [True, False])
def test_to_datetime_iso8601_noleading_0s(self, cache):
# GH 11871
diff --git a/pandas/tseries/frequencies.py b/pandas/tseries/frequencies.py
index 22c0f455fa3ac..12320cd52cec8 100644
--- a/pandas/tseries/frequencies.py
+++ b/pandas/tseries/frequencies.py
@@ -91,7 +91,7 @@ def to_offset(freq) -> Optional[DateOffset]:
See Also
--------
- DateOffset
+ DateOffset : Standard kind of date increment used for a date range.
Examples
--------
diff --git a/pandas/util/_print_versions.py b/pandas/util/_print_versions.py
index 7fc85a04e7d84..72003eeddf5ee 100644
--- a/pandas/util/_print_versions.py
+++ b/pandas/util/_print_versions.py
@@ -88,6 +88,20 @@ def _get_dependency_info() -> Dict[str, JSONSerializable]:
def show_versions(as_json: Union[str, bool] = False) -> None:
+ """
+ Provide useful information, important for bug reports.
+
+ It comprises info about hosting operation system, pandas version,
+ and versions of other installed relative packages.
+
+ Parameters
+ ----------
+ as_json : str or bool, default False
+ * If False, outputs info in a human readable form to the console.
+ * If str, it will be considered as a path to a file.
+ Info will be written to that file in JSON format.
+ * If True, outputs info in JSON format to the console.
+ """
sys_info = _get_sys_info()
deps = _get_dependency_info()
diff --git a/pandas/util/_test_decorators.py b/pandas/util/_test_decorators.py
index 25394dc6775d8..8b3424b70d809 100644
--- a/pandas/util/_test_decorators.py
+++ b/pandas/util/_test_decorators.py
@@ -182,10 +182,10 @@ def skip_if_no(package: str, min_version: Optional[str] = None) -> Callable:
is_platform_windows(), reason="not used on win32"
)
skip_if_has_locale = pytest.mark.skipif(
- _skip_if_has_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}",
+ _skip_if_has_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}"
)
skip_if_not_us_locale = pytest.mark.skipif(
- _skip_if_not_us_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}",
+ _skip_if_not_us_locale(), reason=f"Specific locale is set {locale.getlocale()[0]}"
)
skip_if_no_scipy = pytest.mark.skipif(
_skip_if_no_scipy(), reason="Missing SciPy requirement"
| - [x] closes #32316
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
As suggested by @datapythonista , I've added checks in `ci/code_checks.sh` to look if the `pandas` is being referenced in a standardized way i.e `pandas`, not ` *pandas* ` or `Pandas`
@datapythonista I've only added checks to see if pandas is being referenced correctly, but not showing where it's changed or how many references are wrong.
Should I add checks for that also ? What do you think ? | https://api.github.com/repos/pandas-dev/pandas/pulls/32613 | 2020-03-11T04:48:02Z | 2020-04-01T15:36:21Z | null | 2020-04-01T15:36:21Z |
CLN: remove Block.array_dtype, SingleBlockManager.array_dtype | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 024d3b205df77..bb5b543538220 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -11,7 +11,6 @@
import pandas._libs.internals as libinternals
from pandas._libs.tslibs import Timedelta, conversion
from pandas._libs.tslibs.timezones import tz_compare
-from pandas._typing import DtypeObj
from pandas.util._validators import validate_bool_kwarg
from pandas.core.dtypes.cast import (
@@ -256,14 +255,6 @@ def mgr_locs(self, new_mgr_locs):
self._mgr_locs = new_mgr_locs
- @property
- def array_dtype(self) -> DtypeObj:
- """
- the dtype to return if I want to construct this block as an
- array
- """
- return self.dtype
-
def make_block(self, values, placement=None) -> "Block":
"""
Create a new block, with type inference propagate any values that are
@@ -2922,14 +2913,6 @@ def __init__(self, values, placement, ndim=None):
def _holder(self):
return Categorical
- @property
- def array_dtype(self):
- """
- the dtype to return if I want to construct this block as an
- array
- """
- return np.object_
-
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/core/internals/managers.py b/pandas/core/internals/managers.py
index 0bba8de6682ea..469521426b13a 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -193,8 +193,10 @@ def make_empty(self: T, axes=None) -> T:
# preserve dtype if possible
if self.ndim == 1:
assert isinstance(self, SingleBlockManager) # for mypy
- arr = np.array([], dtype=self.array_dtype)
- blocks = [make_block(arr, placement=slice(0, 0), ndim=1)]
+ blk = self.blocks[0]
+ arr = blk.values[:0]
+ nb = blk.make_block_same_class(arr, placement=slice(0, 0), ndim=1)
+ blocks = [nb]
else:
blocks = []
return type(self).from_blocks(blocks, axes)
@@ -1571,10 +1573,6 @@ def index(self) -> Index:
def dtype(self) -> DtypeObj:
return self._block.dtype
- @property
- def array_dtype(self) -> DtypeObj:
- return self._block.array_dtype
-
def get_dtype_counts(self):
return {self.dtype.name: 1}
| We can get a more accurately-dtyped empty array instead. | https://api.github.com/repos/pandas-dev/pandas/pulls/32612 | 2020-03-11T04:35:40Z | 2020-03-14T03:30:13Z | 2020-03-14T03:30:13Z | 2020-03-14T16:27:26Z |
REF: implement _get_engine_target | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index a5f133fb10d10..929fcafff36af 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -567,10 +567,10 @@ def _cleanup(self):
def _engine(self):
# property, for now, slow to look up
- # to avoid a reference cycle, bind `_ndarray_values` to a local variable, so
+ # to avoid a reference cycle, bind `target_values` to a local variable, so
# `self` is not passed into the lambda.
- _ndarray_values = self._ndarray_values
- return self._engine_type(lambda: _ndarray_values, len(self))
+ target_values = self._get_engine_target()
+ return self._engine_type(lambda: target_values, len(self))
# --------------------------------------------------------------------
# Array-Like Methods
@@ -2972,7 +2972,7 @@ def get_indexer(
"backfill or nearest reindexing"
)
- indexer = self._engine.get_indexer(target._ndarray_values)
+ indexer = self._engine.get_indexer(target._get_engine_target())
return ensure_platform_int(indexer)
@@ -2986,19 +2986,20 @@ def _convert_tolerance(self, tolerance, target):
def _get_fill_indexer(
self, target: "Index", method: str_t, limit=None, tolerance=None
) -> np.ndarray:
+
+ target_values = target._get_engine_target()
+
if self.is_monotonic_increasing and target.is_monotonic_increasing:
engine_method = (
self._engine.get_pad_indexer
if method == "pad"
else self._engine.get_backfill_indexer
)
- indexer = engine_method(target._ndarray_values, limit)
+ indexer = engine_method(target_values, limit)
else:
indexer = self._get_fill_indexer_searchsorted(target, method, limit)
if tolerance is not None:
- indexer = self._filter_indexer_tolerance(
- target._ndarray_values, indexer, tolerance
- )
+ indexer = self._filter_indexer_tolerance(target_values, indexer, tolerance)
return indexer
def _get_fill_indexer_searchsorted(
@@ -3911,6 +3912,12 @@ def _internal_get_values(self) -> np.ndarray:
"""
return self.values
+ def _get_engine_target(self) -> np.ndarray:
+ """
+ Get the ndarray that we can pass to the IndexEngine constructor.
+ """
+ return self._values
+
@Appender(IndexOpsMixin.memory_usage.__doc__)
def memory_usage(self, deep: bool = False) -> int:
result = super().memory_usage(deep=deep)
@@ -4653,7 +4660,7 @@ def get_indexer_non_unique(self, target):
elif self.is_all_dates and target.is_all_dates: # GH 30399
tgt_values = target.asi8
else:
- tgt_values = target._ndarray_values
+ tgt_values = target._get_engine_target()
indexer, missing = self._engine.get_indexer_non_unique(tgt_values)
return ensure_platform_int(indexer), missing
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index 7b11df15f69fb..4984fc27516ff 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -231,6 +231,9 @@ def __array__(self, dtype=None) -> np.ndarray:
def _ndarray_values(self) -> np.ndarray:
return self._data._ndarray_values
+ def _get_engine_target(self) -> np.ndarray:
+ return self._data._values_for_argsort()
+
@Appender(Index.dropna.__doc__)
def dropna(self, how="any"):
if how not in ("any", "all"):
| Follow-up to #32467. | https://api.github.com/repos/pandas-dev/pandas/pulls/32611 | 2020-03-11T03:01:59Z | 2020-03-12T04:30:03Z | 2020-03-12T04:30:03Z | 2020-03-12T15:30:46Z |
CLN: Clean frame/test_constructors.py | diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 071d2409f1be2..4407f204e0a0c 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -47,15 +47,15 @@
class TestDataFrameConstructors:
def test_series_with_name_not_matching_column(self):
# GH#9232
- x = pd.Series(range(5), name=1)
- y = pd.Series(range(5), name=0)
+ x = Series(range(5), name=1)
+ y = Series(range(5), name=0)
- result = pd.DataFrame(x, columns=[0])
- expected = pd.DataFrame([], columns=[0])
+ result = DataFrame(x, columns=[0])
+ expected = DataFrame([], columns=[0])
tm.assert_frame_equal(result, expected)
- result = pd.DataFrame(y, columns=[1])
- expected = pd.DataFrame([], columns=[1])
+ result = DataFrame(y, columns=[1])
+ expected = DataFrame([], columns=[1])
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize(
@@ -126,7 +126,7 @@ def test_constructor_cast_failure(self):
def test_constructor_dtype_copy(self):
orig_df = DataFrame({"col1": [1.0], "col2": [2.0], "col3": [3.0]})
- new_df = pd.DataFrame(orig_df, dtype=float, copy=True)
+ new_df = DataFrame(orig_df, dtype=float, copy=True)
new_df["col1"] = 200.0
assert orig_df["col1"][0] == 1.0
@@ -220,10 +220,10 @@ def test_constructor_rec(self, float_frame):
index = float_frame.index
df = DataFrame(rec)
- tm.assert_index_equal(df.columns, pd.Index(rec.dtype.names))
+ tm.assert_index_equal(df.columns, Index(rec.dtype.names))
df2 = DataFrame(rec, index=index)
- tm.assert_index_equal(df2.columns, pd.Index(rec.dtype.names))
+ tm.assert_index_equal(df2.columns, Index(rec.dtype.names))
tm.assert_index_equal(df2.index, index)
rng = np.arange(len(rec))[::-1]
@@ -298,7 +298,7 @@ def test_constructor_dict(self):
tm.assert_series_equal(frame["col1"], datetime_series.rename("col1"))
- exp = pd.Series(
+ exp = Series(
np.concatenate([[np.nan] * 5, datetime_series_short.values]),
index=datetime_series.index,
name="col2",
@@ -325,7 +325,7 @@ def test_constructor_dict(self):
# Length-one dict micro-optimization
frame = DataFrame({"A": {"1": 1, "2": 2}})
- tm.assert_index_equal(frame.index, pd.Index(["1", "2"]))
+ tm.assert_index_equal(frame.index, Index(["1", "2"]))
# empty dict plus index
idx = Index([0, 1, 2])
@@ -418,8 +418,8 @@ def test_constructor_dict_order_insertion(self):
def test_constructor_dict_nan_key_and_columns(self):
# GH 16894
- result = pd.DataFrame({np.nan: [1, 2], 2: [2, 3]}, columns=[np.nan, 2])
- expected = pd.DataFrame([[1, 2], [2, 3]], columns=[np.nan, 2])
+ result = DataFrame({np.nan: [1, 2], 2: [2, 3]}, columns=[np.nan, 2])
+ expected = DataFrame([[1, 2], [2, 3]], columns=[np.nan, 2])
tm.assert_frame_equal(result, expected)
def test_constructor_multi_index(self):
@@ -428,29 +428,29 @@ def test_constructor_multi_index(self):
tuples = [(2, 3), (3, 3), (3, 3)]
mi = MultiIndex.from_tuples(tuples)
df = DataFrame(index=mi, columns=mi)
- assert pd.isna(df).values.ravel().all()
+ assert isna(df).values.ravel().all()
tuples = [(3, 3), (2, 3), (3, 3)]
mi = MultiIndex.from_tuples(tuples)
df = DataFrame(index=mi, columns=mi)
- assert pd.isna(df).values.ravel().all()
+ assert isna(df).values.ravel().all()
def test_constructor_2d_index(self):
# GH 25416
# handling of 2d index in construction
- df = pd.DataFrame([[1]], columns=[[1]], index=[1, 2])
- expected = pd.DataFrame(
+ df = DataFrame([[1]], columns=[[1]], index=[1, 2])
+ expected = DataFrame(
[1, 1],
index=pd.Int64Index([1, 2], dtype="int64"),
- columns=pd.MultiIndex(levels=[[1]], codes=[[0]]),
+ columns=MultiIndex(levels=[[1]], codes=[[0]]),
)
tm.assert_frame_equal(df, expected)
- df = pd.DataFrame([[1]], columns=[[1]], index=[[1, 2]])
- expected = pd.DataFrame(
+ df = DataFrame([[1]], columns=[[1]], index=[[1, 2]])
+ expected = DataFrame(
[1, 1],
- index=pd.MultiIndex(levels=[[1, 2]], codes=[[0, 1]]),
- columns=pd.MultiIndex(levels=[[1]], codes=[[0]]),
+ index=MultiIndex(levels=[[1, 2]], codes=[[0, 1]]),
+ columns=MultiIndex(levels=[[1]], codes=[[0]]),
)
tm.assert_frame_equal(df, expected)
@@ -471,7 +471,7 @@ def test_constructor_error_msgs(self):
DataFrame(
np.arange(12).reshape((4, 3)),
columns=["foo", "bar", "baz"],
- index=pd.date_range("2000-01-01", periods=3),
+ index=date_range("2000-01-01", periods=3),
)
arr = np.array([[4, 5, 6]])
@@ -713,14 +713,12 @@ def test_constructor_period(self):
# PeriodIndex
a = pd.PeriodIndex(["2012-01", "NaT", "2012-04"], freq="M")
b = pd.PeriodIndex(["2012-02-01", "2012-03-01", "NaT"], freq="D")
- df = pd.DataFrame({"a": a, "b": b})
+ df = DataFrame({"a": a, "b": b})
assert df["a"].dtype == a.dtype
assert df["b"].dtype == b.dtype
# list of periods
- df = pd.DataFrame(
- {"a": a.astype(object).tolist(), "b": b.astype(object).tolist()}
- )
+ df = DataFrame({"a": a.astype(object).tolist(), "b": b.astype(object).tolist()})
assert df["a"].dtype == a.dtype
assert df["b"].dtype == b.dtype
@@ -882,8 +880,8 @@ def test_constructor_maskedarray_nonfloat(self):
def test_constructor_maskedarray_hardened(self):
# Check numpy masked arrays with hard masks -- from GH24574
mat_hard = ma.masked_all((2, 2), dtype=float).harden_mask()
- result = pd.DataFrame(mat_hard, columns=["A", "B"], index=[1, 2])
- expected = pd.DataFrame(
+ result = DataFrame(mat_hard, columns=["A", "B"], index=[1, 2])
+ expected = DataFrame(
{"A": [np.nan, np.nan], "B": [np.nan, np.nan]},
columns=["A", "B"],
index=[1, 2],
@@ -892,8 +890,8 @@ def test_constructor_maskedarray_hardened(self):
tm.assert_frame_equal(result, expected)
# Check case where mask is hard but no data are masked
mat_hard = ma.ones((2, 2), dtype=float).harden_mask()
- result = pd.DataFrame(mat_hard, columns=["A", "B"], index=[1, 2])
- expected = pd.DataFrame(
+ result = DataFrame(mat_hard, columns=["A", "B"], index=[1, 2])
+ expected = DataFrame(
{"A": [1.0, 1.0], "B": [1.0, 1.0]},
columns=["A", "B"],
index=[1, 2],
@@ -907,8 +905,8 @@ def test_constructor_maskedrecarray_dtype(self):
np.ma.zeros(5, dtype=[("date", "<f8"), ("price", "<f8")]), mask=[False] * 5
)
data = data.view(mrecords.mrecarray)
- result = pd.DataFrame(data, dtype=int)
- expected = pd.DataFrame(np.zeros((5, 2), dtype=int), columns=["date", "price"])
+ result = DataFrame(data, dtype=int)
+ expected = DataFrame(np.zeros((5, 2), dtype=int), columns=["date", "price"])
tm.assert_frame_equal(result, expected)
def test_constructor_mrecarray(self):
@@ -1271,9 +1269,9 @@ def test_constructor_list_of_series(self):
tm.assert_frame_equal(result, expected)
def test_constructor_list_of_series_aligned_index(self):
- series = [pd.Series(i, index=["b", "a", "c"], name=str(i)) for i in range(3)]
- result = pd.DataFrame(series)
- expected = pd.DataFrame(
+ series = [Series(i, index=["b", "a", "c"], name=str(i)) for i in range(3)]
+ result = DataFrame(series)
+ expected = DataFrame(
{"b": [0, 1, 2], "a": [0, 1, 2], "c": [0, 1, 2]},
columns=["b", "a", "c"],
index=["0", "1", "2"],
@@ -1500,12 +1498,12 @@ def test_constructor_Series_named_and_columns(self):
s1 = Series(range(5), name=1)
# matching name and column gives standard frame
- tm.assert_frame_equal(pd.DataFrame(s0, columns=[0]), s0.to_frame())
- tm.assert_frame_equal(pd.DataFrame(s1, columns=[1]), s1.to_frame())
+ tm.assert_frame_equal(DataFrame(s0, columns=[0]), s0.to_frame())
+ tm.assert_frame_equal(DataFrame(s1, columns=[1]), s1.to_frame())
# non-matching produces empty frame
- assert pd.DataFrame(s0, columns=[1]).empty
- assert pd.DataFrame(s1, columns=[0]).empty
+ assert DataFrame(s0, columns=[1]).empty
+ assert DataFrame(s1, columns=[0]).empty
def test_constructor_Series_differently_indexed(self):
# name
@@ -1984,7 +1982,7 @@ def test_from_records_to_records(self):
# TODO(wesm): unused
frame = DataFrame.from_records(arr) # noqa
- index = pd.Index(np.arange(len(arr))[::-1])
+ index = Index(np.arange(len(arr))[::-1])
indexed_frame = DataFrame.from_records(arr, index=index)
tm.assert_index_equal(indexed_frame.index, index)
@@ -2283,7 +2281,7 @@ def test_from_records_sequencelike(self):
# empty case
result = DataFrame.from_records([], columns=["foo", "bar", "baz"])
assert len(result) == 0
- tm.assert_index_equal(result.columns, pd.Index(["foo", "bar", "baz"]))
+ tm.assert_index_equal(result.columns, Index(["foo", "bar", "baz"]))
result = DataFrame.from_records([])
assert len(result) == 0
@@ -2442,20 +2440,20 @@ def test_datetime_date_tuple_columns_from_dict(self):
v = date.today()
tup = v, v
result = DataFrame({tup: Series(range(3), index=range(3))}, columns=[tup])
- expected = DataFrame([0, 1, 2], columns=pd.Index(pd.Series([tup])))
+ expected = DataFrame([0, 1, 2], columns=Index(Series([tup])))
tm.assert_frame_equal(result, expected)
def test_construct_with_two_categoricalindex_series(self):
# GH 14600
- s1 = pd.Series(
+ s1 = Series(
[39, 6, 4], index=pd.CategoricalIndex(["female", "male", "unknown"])
)
- s2 = pd.Series(
+ s2 = Series(
[2, 152, 2, 242, 150],
index=pd.CategoricalIndex(["f", "female", "m", "male", "unknown"]),
)
- result = pd.DataFrame([s1, s2])
- expected = pd.DataFrame(
+ result = DataFrame([s1, s2])
+ expected = DataFrame(
np.array(
[[np.nan, 39.0, np.nan, 6.0, 4.0], [2.0, 152.0, 2.0, 242.0, 150.0]]
),
@@ -2554,19 +2552,19 @@ def test_nested_dict_construction(self):
"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(
+ result = DataFrame(pop, index=[2001, 2002, 2003], columns=columns)
+ expected = DataFrame(
[(2.4, 1.7), (2.9, 3.6), (np.nan, np.nan)],
columns=columns,
- index=pd.Index([2001, 2002, 2003]),
+ index=Index([2001, 2002, 2003]),
)
tm.assert_frame_equal(result, expected)
def test_from_tzaware_object_array(self):
# GH#26825 2D object array of tzaware timestamps should not raise
- dti = pd.date_range("2016-04-05 04:30", periods=3, tz="UTC")
+ dti = date_range("2016-04-05 04:30", periods=3, tz="UTC")
data = dti._data.astype(object).reshape(1, -1)
- df = pd.DataFrame(data)
+ df = DataFrame(data)
assert df.shape == (1, 3)
assert (df.dtypes == dti.dtype).all()
assert (df == dti).all().all()
@@ -2605,7 +2603,7 @@ def test_from_tzaware_mixed_object_array(self):
def test_from_2d_ndarray_with_dtype(self):
# GH#12513
array_dim2 = np.arange(10).reshape((5, 2))
- df = pd.DataFrame(array_dim2, dtype="datetime64[ns, UTC]")
+ df = DataFrame(array_dim2, dtype="datetime64[ns, UTC]")
- expected = pd.DataFrame(array_dim2).astype("datetime64[ns, UTC]")
+ expected = DataFrame(array_dim2).astype("datetime64[ns, UTC]")
tm.assert_frame_equal(df, expected)
| I think these classes are all imported directly so don't need to reference the pandas namespace | https://api.github.com/repos/pandas-dev/pandas/pulls/32610 | 2020-03-11T02:41:46Z | 2020-03-14T19:41:00Z | 2020-03-14T19:41:00Z | 2020-03-14T19:44:07Z |
Backport PR #32577 on branch 1.0.x (REG: Restore read_csv function for some file-likes) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 9841df0507138..8db47000480ed 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -25,6 +25,7 @@ Fixed regressions
- Fixed regression in :meth:`pandas.core.groupby.GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
- Joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` will preserve ``freq`` in simple cases (:issue:`32166`)
- Fixed bug in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
+- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index 3077f73a8d1a4..ef887444e516d 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -638,7 +638,8 @@ cdef class TextReader:
raise ValueError(f'Unrecognized compression type: '
f'{self.compression}')
- if self.encoding and isinstance(source, (io.BufferedIOBase, io.RawIOBase)):
+ if (self.encoding and hasattr(source, "read") and
+ not hasattr(source, "encoding")):
source = io.TextIOWrapper(
source, self.encoding.decode('utf-8'), newline='')
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index cb108362f4dc7..3ddfb71fd78e8 100755
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -5,7 +5,7 @@
from collections import abc, defaultdict
import csv
import datetime
-from io import BufferedIOBase, RawIOBase, StringIO, TextIOWrapper
+from io import StringIO, TextIOWrapper
import re
import sys
from textwrap import fill
@@ -1876,7 +1876,7 @@ def __init__(self, src, **kwds):
# Handle the file object with universal line mode enabled.
# We will handle the newline character ourselves later on.
- if isinstance(src, (BufferedIOBase, RawIOBase)):
+ if hasattr(src, "read") and not hasattr(src, "encoding"):
src = TextIOWrapper(src, encoding=encoding, newline="")
kwds["encoding"] = "utf-8"
diff --git a/pandas/tests/io/parser/test_encoding.py b/pandas/tests/io/parser/test_encoding.py
index 620f837935718..e38b7fab6a603 100644
--- a/pandas/tests/io/parser/test_encoding.py
+++ b/pandas/tests/io/parser/test_encoding.py
@@ -175,3 +175,25 @@ def test_encoding_temp_file(all_parsers, utf_value, encoding_fmt, pass_encoding)
result = parser.read_csv(f, encoding=encoding if pass_encoding else None)
tm.assert_frame_equal(result, expected)
+
+
+def test_encoding_named_temp_file(all_parsers):
+ # see gh-31819
+ parser = all_parsers
+ encoding = "shift-jis"
+
+ if parser.engine == "python":
+ pytest.skip("NamedTemporaryFile does not work with Python engine")
+
+ title = "てすと"
+ data = "こむ"
+
+ expected = DataFrame({title: [data]})
+
+ with tempfile.NamedTemporaryFile() as f:
+ f.write(f"{title}\n{data}".encode(encoding))
+
+ f.seek(0)
+
+ result = parser.read_csv(f, encoding=encoding)
+ tm.assert_frame_equal(result, expected)
| Backport PR #32577: REG: Restore read_csv function for some file-likes | https://api.github.com/repos/pandas-dev/pandas/pulls/32609 | 2020-03-11T02:22:12Z | 2020-03-11T04:08:25Z | 2020-03-11T04:08:25Z | 2020-03-11T04:08:25Z |
TST: fixturize skipna in test_nanops | diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index f7e652eb78e2d..852e1ce489893 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -19,6 +19,14 @@
has_c16 = hasattr(np, "complex128")
+@pytest.fixture(params=[True, False])
+def skipna(request):
+ """
+ Fixture to pass skipna to nanops functions.
+ """
+ return request.param
+
+
class TestnanopsDataFrame:
def setup_method(self, method):
np.random.seed(11235)
@@ -89,28 +97,14 @@ def teardown_method(self, method):
def check_results(self, targ, res, axis, check_dtype=True):
res = getattr(res, "asm8", res)
- res = getattr(res, "values", res)
-
- # timedeltas are a beast here
- def _coerce_tds(targ, res):
- if hasattr(targ, "dtype") and targ.dtype == "m8[ns]":
- if len(targ) == 1:
- targ = targ[0].item()
- res = res.item()
- else:
- targ = targ.view("i8")
- return targ, res
- try:
- if (
- axis != 0
- and hasattr(targ, "shape")
- and targ.ndim
- and targ.shape != res.shape
- ):
- res = np.split(res, [targ.shape[0]], axis=0)[0]
- except (ValueError, IndexError):
- targ, res = _coerce_tds(targ, res)
+ if (
+ axis != 0
+ and hasattr(targ, "shape")
+ and targ.ndim
+ and targ.shape != res.shape
+ ):
+ res = np.split(res, [targ.shape[0]], axis=0)[0]
try:
tm.assert_almost_equal(targ, res, check_dtype=check_dtype)
@@ -118,9 +112,7 @@ def _coerce_tds(targ, res):
# handle timedelta dtypes
if hasattr(targ, "dtype") and targ.dtype == "m8[ns]":
- targ, res = _coerce_tds(targ, res)
- tm.assert_almost_equal(targ, res, check_dtype=check_dtype)
- return
+ raise
# There are sometimes rounding errors with
# complex and object dtypes.
@@ -149,29 +141,29 @@ def check_fun_data(
targfunc,
testarval,
targarval,
+ skipna,
check_dtype=True,
empty_targfunc=None,
**kwargs,
):
for axis in list(range(targarval.ndim)) + [None]:
- for skipna in [False, True]:
- targartempval = targarval if skipna else testarval
- if skipna and empty_targfunc and isna(targartempval).all():
- targ = empty_targfunc(targartempval, axis=axis, **kwargs)
- else:
- targ = targfunc(targartempval, axis=axis, **kwargs)
+ targartempval = targarval if skipna else testarval
+ if skipna and empty_targfunc and isna(targartempval).all():
+ targ = empty_targfunc(targartempval, axis=axis, **kwargs)
+ else:
+ targ = targfunc(targartempval, axis=axis, **kwargs)
- res = testfunc(testarval, axis=axis, skipna=skipna, **kwargs)
+ res = testfunc(testarval, axis=axis, skipna=skipna, **kwargs)
+ self.check_results(targ, res, axis, check_dtype=check_dtype)
+ if skipna:
+ res = testfunc(testarval, axis=axis, **kwargs)
+ self.check_results(targ, res, axis, check_dtype=check_dtype)
+ if axis is None:
+ res = testfunc(testarval, skipna=skipna, **kwargs)
+ self.check_results(targ, res, axis, check_dtype=check_dtype)
+ if skipna and axis is None:
+ res = testfunc(testarval, **kwargs)
self.check_results(targ, res, axis, check_dtype=check_dtype)
- if skipna:
- res = testfunc(testarval, axis=axis, **kwargs)
- self.check_results(targ, res, axis, check_dtype=check_dtype)
- if axis is None:
- res = testfunc(testarval, skipna=skipna, **kwargs)
- self.check_results(targ, res, axis, check_dtype=check_dtype)
- if skipna and axis is None:
- res = testfunc(testarval, **kwargs)
- self.check_results(targ, res, axis, check_dtype=check_dtype)
if testarval.ndim <= 1:
return
@@ -184,12 +176,15 @@ def check_fun_data(
targfunc,
testarval2,
targarval2,
+ skipna=skipna,
check_dtype=check_dtype,
empty_targfunc=empty_targfunc,
**kwargs,
)
- def check_fun(self, testfunc, targfunc, testar, empty_targfunc=None, **kwargs):
+ def check_fun(
+ self, testfunc, targfunc, testar, skipna, empty_targfunc=None, **kwargs
+ ):
targar = testar
if testar.endswith("_nan") and hasattr(self, testar[:-4]):
@@ -202,6 +197,7 @@ def check_fun(self, testfunc, targfunc, testar, empty_targfunc=None, **kwargs):
targfunc,
testarval,
targarval,
+ skipna=skipna,
empty_targfunc=empty_targfunc,
**kwargs,
)
@@ -210,6 +206,7 @@ def check_funs(
self,
testfunc,
targfunc,
+ skipna,
allow_complex=True,
allow_all_nan=True,
allow_date=True,
@@ -217,10 +214,10 @@ def check_funs(
allow_obj=True,
**kwargs,
):
- self.check_fun(testfunc, targfunc, "arr_float", **kwargs)
- self.check_fun(testfunc, targfunc, "arr_float_nan", **kwargs)
- self.check_fun(testfunc, targfunc, "arr_int", **kwargs)
- self.check_fun(testfunc, targfunc, "arr_bool", **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_float", skipna, **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_float_nan", skipna, **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_int", skipna, **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_bool", skipna, **kwargs)
objs = [
self.arr_float.astype("O"),
self.arr_int.astype("O"),
@@ -228,18 +225,18 @@ def check_funs(
]
if allow_all_nan:
- self.check_fun(testfunc, targfunc, "arr_nan", **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_nan", skipna, **kwargs)
if allow_complex:
- self.check_fun(testfunc, targfunc, "arr_complex", **kwargs)
- self.check_fun(testfunc, targfunc, "arr_complex_nan", **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_complex", skipna, **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_complex_nan", skipna, **kwargs)
if allow_all_nan:
- self.check_fun(testfunc, targfunc, "arr_nan_nanj", **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_nan_nanj", skipna, **kwargs)
objs += [self.arr_complex.astype("O")]
if allow_date:
targfunc(self.arr_date)
- self.check_fun(testfunc, targfunc, "arr_date", **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_date", skipna, **kwargs)
objs += [self.arr_date.astype("O")]
if allow_tdelta:
@@ -248,7 +245,7 @@ def check_funs(
except TypeError:
pass
else:
- self.check_fun(testfunc, targfunc, "arr_tdelta", **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_tdelta", skipna, **kwargs)
objs += [self.arr_tdelta.astype("O")]
if allow_obj:
@@ -260,7 +257,7 @@ def check_funs(
targfunc = partial(
self._badobj_wrap, func=targfunc, allow_complex=allow_complex
)
- self.check_fun(testfunc, targfunc, "arr_obj", **kwargs)
+ self.check_fun(testfunc, targfunc, "arr_obj", skipna, **kwargs)
def _badobj_wrap(self, value, func, allow_complex=True, **kwargs):
if value.dtype.kind == "O":
@@ -273,28 +270,22 @@ def _badobj_wrap(self, value, func, allow_complex=True, **kwargs):
@pytest.mark.parametrize(
"nan_op,np_op", [(nanops.nanany, np.any), (nanops.nanall, np.all)]
)
- def test_nan_funcs(self, nan_op, np_op):
- # TODO: allow tdelta, doesn't break tests
- self.check_funs(
- nan_op, np_op, allow_all_nan=False, allow_date=False, allow_tdelta=False
- )
+ def test_nan_funcs(self, nan_op, np_op, skipna):
+ self.check_funs(nan_op, np_op, skipna, allow_all_nan=False, allow_date=False)
- def test_nansum(self):
+ def test_nansum(self, skipna):
self.check_funs(
nanops.nansum,
np.sum,
+ skipna,
allow_date=False,
check_dtype=False,
empty_targfunc=np.nansum,
)
- def test_nanmean(self):
+ def test_nanmean(self, skipna):
self.check_funs(
- nanops.nanmean,
- np.mean,
- allow_complex=False, # TODO: allow this, doesn't break test
- allow_obj=False,
- allow_date=False,
+ nanops.nanmean, np.mean, skipna, allow_obj=False, allow_date=False,
)
def test_nanmean_overflow(self):
@@ -336,22 +327,24 @@ def test_returned_dtype(self, dtype):
else:
assert result.dtype == dtype
- def test_nanmedian(self):
+ def test_nanmedian(self, skipna):
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore", RuntimeWarning)
self.check_funs(
nanops.nanmedian,
np.median,
+ skipna,
allow_complex=False,
allow_date=False,
allow_obj="convert",
)
@pytest.mark.parametrize("ddof", range(3))
- def test_nanvar(self, ddof):
+ def test_nanvar(self, ddof, skipna):
self.check_funs(
nanops.nanvar,
np.var,
+ skipna,
allow_complex=False,
allow_date=False,
allow_obj="convert",
@@ -359,10 +352,11 @@ def test_nanvar(self, ddof):
)
@pytest.mark.parametrize("ddof", range(3))
- def test_nanstd(self, ddof):
+ def test_nanstd(self, ddof, skipna):
self.check_funs(
nanops.nanstd,
np.std,
+ skipna,
allow_complex=False,
allow_date=False,
allow_obj="convert",
@@ -371,13 +365,14 @@ def test_nanstd(self, ddof):
@td.skip_if_no_scipy
@pytest.mark.parametrize("ddof", range(3))
- def test_nansem(self, ddof):
+ def test_nansem(self, ddof, skipna):
from scipy.stats import sem
with np.errstate(invalid="ignore"):
self.check_funs(
nanops.nansem,
sem,
+ skipna,
allow_complex=False,
allow_date=False,
allow_tdelta=False,
@@ -388,10 +383,10 @@ def test_nansem(self, ddof):
@pytest.mark.parametrize(
"nan_op,np_op", [(nanops.nanmin, np.min), (nanops.nanmax, np.max)]
)
- def test_nanops_with_warnings(self, nan_op, np_op):
+ def test_nanops_with_warnings(self, nan_op, np_op, skipna):
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore", RuntimeWarning)
- self.check_funs(nan_op, np_op, allow_obj=False)
+ self.check_funs(nan_op, np_op, skipna, allow_obj=False)
def _argminmax_wrap(self, value, axis=None, func=None):
res = func(value, axis)
@@ -408,17 +403,17 @@ def _argminmax_wrap(self, value, axis=None, func=None):
res = -1
return res
- def test_nanargmax(self):
+ def test_nanargmax(self, skipna):
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore", RuntimeWarning)
func = partial(self._argminmax_wrap, func=np.argmax)
- self.check_funs(nanops.nanargmax, func, allow_obj=False)
+ self.check_funs(nanops.nanargmax, func, skipna, allow_obj=False)
- def test_nanargmin(self):
+ def test_nanargmin(self, skipna):
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore", RuntimeWarning)
func = partial(self._argminmax_wrap, func=np.argmin)
- self.check_funs(nanops.nanargmin, func, allow_obj=False)
+ self.check_funs(nanops.nanargmin, func, skipna, allow_obj=False)
def _skew_kurt_wrap(self, values, axis=None, func=None):
if not isinstance(values.dtype.type, np.floating):
@@ -433,7 +428,7 @@ def _skew_kurt_wrap(self, values, axis=None, func=None):
return result
@td.skip_if_no_scipy
- def test_nanskew(self):
+ def test_nanskew(self, skipna):
from scipy.stats import skew
func = partial(self._skew_kurt_wrap, func=skew)
@@ -441,13 +436,14 @@ def test_nanskew(self):
self.check_funs(
nanops.nanskew,
func,
+ skipna,
allow_complex=False,
allow_date=False,
allow_tdelta=False,
)
@td.skip_if_no_scipy
- def test_nankurt(self):
+ def test_nankurt(self, skipna):
from scipy.stats import kurtosis
func1 = partial(kurtosis, fisher=True)
@@ -456,15 +452,17 @@ def test_nankurt(self):
self.check_funs(
nanops.nankurt,
func,
+ skipna,
allow_complex=False,
allow_date=False,
allow_tdelta=False,
)
- def test_nanprod(self):
+ def test_nanprod(self, skipna):
self.check_funs(
nanops.nanprod,
np.prod,
+ skipna,
allow_date=False,
allow_tdelta=False,
empty_targfunc=np.nanprod,
| https://api.github.com/repos/pandas-dev/pandas/pulls/32607 | 2020-03-11T01:56:21Z | 2020-03-11T02:55:24Z | 2020-03-11T02:55:24Z | 2020-03-11T03:09:37Z | |
Backport PR #32386 on branch 1.0.x (BUG: Fix rolling functions with variable windows on decreasing index) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 9841df0507138..3e4dfd4e75a66 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -89,6 +89,10 @@ Bug fixes
- Using ``pd.NA`` with :meth:`Series.str.repeat` now correctly outputs a null value instead of raising error for vector inputs (:issue:`31632`)
+**Rolling**
+
+- Fixed rolling operations with variable window (defined by time duration) on decreasing time index (:issue:`32385`).
+
.. ---------------------------------------------------------------------------
.. _whatsnew_102.contributors:
diff --git a/pandas/_libs/window/aggregations.pyx b/pandas/_libs/window/aggregations.pyx
index 0348843abc129..495b436030120 100644
--- a/pandas/_libs/window/aggregations.pyx
+++ b/pandas/_libs/window/aggregations.pyx
@@ -1008,7 +1008,7 @@ def roll_max_variable(ndarray[float64_t] values, ndarray[int64_t] start,
def roll_min_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
ndarray[int64_t] end, int64_t minp, int64_t win):
"""
- Moving max of 1d array of any numeric type along axis=0 ignoring NaNs.
+ Moving min of 1d array of any numeric type along axis=0 ignoring NaNs.
Parameters
----------
@@ -1025,7 +1025,7 @@ def roll_min_fixed(ndarray[float64_t] values, ndarray[int64_t] start,
def roll_min_variable(ndarray[float64_t] values, ndarray[int64_t] start,
ndarray[int64_t] end, int64_t minp):
"""
- Moving max of 1d array of any numeric type along axis=0 ignoring NaNs.
+ Moving min of 1d array of any numeric type along axis=0 ignoring NaNs.
Parameters
----------
diff --git a/pandas/_libs/window/indexers.pyx b/pandas/_libs/window/indexers.pyx
index 2d01d1964c043..8a1e7feb57ace 100644
--- a/pandas/_libs/window/indexers.pyx
+++ b/pandas/_libs/window/indexers.pyx
@@ -44,6 +44,7 @@ def calculate_variable_window_bounds(
cdef:
bint left_closed = False
bint right_closed = False
+ int index_growth_sign = 1
ndarray[int64_t, ndim=1] start, end
int64_t start_bound, end_bound
Py_ssize_t i, j
@@ -58,6 +59,9 @@ def calculate_variable_window_bounds(
if closed in ['left', 'both']:
left_closed = True
+ if index[num_values - 1] < index[0]:
+ index_growth_sign = -1
+
start = np.empty(num_values, dtype='int64')
start.fill(-1)
end = np.empty(num_values, dtype='int64')
@@ -78,7 +82,7 @@ def calculate_variable_window_bounds(
# end is end of slice interval (not including)
for i in range(1, num_values):
end_bound = index[i]
- start_bound = index[i] - window_size
+ start_bound = index[i] - index_growth_sign * window_size
# left endpoint is closed
if left_closed:
@@ -88,13 +92,13 @@ def calculate_variable_window_bounds(
# within the constraint
start[i] = i
for j in range(start[i - 1], i):
- if index[j] > start_bound:
+ if (index[j] - start_bound) * index_growth_sign > 0:
start[i] = j
break
# end bound is previous end
# or current index
- if index[end[i - 1]] <= end_bound:
+ if (index[end[i - 1]] - end_bound) * index_growth_sign <= 0:
end[i] = i + 1
else:
end[i] = end[i - 1]
diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py
index 5f5e10b5dd497..0c5289cd78fed 100644
--- a/pandas/tests/window/test_timeseries_window.py
+++ b/pandas/tests/window/test_timeseries_window.py
@@ -709,20 +709,25 @@ def test_rolling_cov_offset(self):
tm.assert_series_equal(result, expected2)
def test_rolling_on_decreasing_index(self):
- # GH-19248
+ # GH-19248, GH-32385
index = [
- Timestamp("20190101 09:00:00"),
- Timestamp("20190101 09:00:02"),
- Timestamp("20190101 09:00:03"),
- Timestamp("20190101 09:00:05"),
- Timestamp("20190101 09:00:06"),
+ Timestamp("20190101 09:00:30"),
+ Timestamp("20190101 09:00:27"),
+ Timestamp("20190101 09:00:20"),
+ Timestamp("20190101 09:00:18"),
+ Timestamp("20190101 09:00:10"),
]
- df = DataFrame({"column": [3, 4, 4, 2, 1]}, index=reversed(index))
- result = df.rolling("2s").min()
- expected = DataFrame(
- {"column": [3.0, 3.0, 3.0, 2.0, 1.0]}, index=reversed(index)
- )
+ df = DataFrame({"column": [3, 4, 4, 5, 6]}, index=index)
+ result = df.rolling("5s").min()
+ expected = DataFrame({"column": [3.0, 3.0, 4.0, 4.0, 6.0]}, index=index)
+ tm.assert_frame_equal(result, expected)
+
+ def test_rolling_on_empty(self):
+ # GH-32385
+ df = DataFrame({"column": []}, index=[])
+ result = df.rolling("5s").min()
+ expected = DataFrame({"column": []}, index=[])
tm.assert_frame_equal(result, expected)
def test_rolling_on_multi_index_level(self):
| Backport PR #32386: BUG: Fix rolling functions with variable windows on decreasing index | https://api.github.com/repos/pandas-dev/pandas/pulls/32606 | 2020-03-11T01:53:52Z | 2020-03-11T02:57:58Z | 2020-03-11T02:57:58Z | 2020-03-11T02:57:58Z |
Backport PR #32499 on branch 1.0.x (Better error message for OOB result) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 9841df0507138..88ee732ded071 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -65,6 +65,7 @@ Bug fixes
- Bug in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with a tz-aware index (:issue:`26683`)
- Bug where :func:`to_datetime` would raise when passed ``pd.NA`` (:issue:`32213`)
+- Improved error message when subtracting two :class:`Timestamp` that result in an out-of-bounds :class:`Timedelta` (:issue:`31774`)
**Categorical**
diff --git a/pandas/_libs/tslibs/c_timestamp.pyx b/pandas/_libs/tslibs/c_timestamp.pyx
index ed1df5f4fa595..62a039d15ef6f 100644
--- a/pandas/_libs/tslibs/c_timestamp.pyx
+++ b/pandas/_libs/tslibs/c_timestamp.pyx
@@ -286,6 +286,10 @@ cdef class _Timestamp(datetime):
# coerce if necessary if we are a Timestamp-like
if (PyDateTime_Check(self)
and (PyDateTime_Check(other) or is_datetime64_object(other))):
+ # both_timestamps is to determine whether Timedelta(self - other)
+ # should raise the OOB error, or fall back returning a timedelta.
+ both_timestamps = (isinstance(other, _Timestamp) and
+ isinstance(self, _Timestamp))
if isinstance(self, _Timestamp):
other = type(self)(other)
else:
@@ -301,7 +305,14 @@ cdef class _Timestamp(datetime):
from pandas._libs.tslibs.timedeltas import Timedelta
try:
return Timedelta(self.value - other.value)
- except (OverflowError, OutOfBoundsDatetime):
+ except (OverflowError, OutOfBoundsDatetime) as err:
+ if isinstance(other, _Timestamp):
+ if both_timestamps:
+ raise OutOfBoundsDatetime(
+ "Result is too large for pandas.Timedelta. Convert inputs "
+ "to datetime.datetime with 'Timestamp.to_pydatetime()' "
+ "before subtracting."
+ ) from err
pass
elif is_datetime64_object(self):
# GH#28286 cython semantics for __rsub__, `other` is actually
diff --git a/pandas/tests/scalar/timestamp/test_arithmetic.py b/pandas/tests/scalar/timestamp/test_arithmetic.py
index 1cab007c20a0e..ccd7bf721430a 100644
--- a/pandas/tests/scalar/timestamp/test_arithmetic.py
+++ b/pandas/tests/scalar/timestamp/test_arithmetic.py
@@ -3,6 +3,8 @@
import numpy as np
import pytest
+from pandas.errors import OutOfBoundsDatetime
+
from pandas import Timedelta, Timestamp
from pandas.tseries import offsets
@@ -60,6 +62,18 @@ def test_overflow_offset_raises(self):
with pytest.raises(OverflowError, match=msg):
stamp - offset_overflow
+ def test_overflow_timestamp_raises(self):
+ # https://github.com/pandas-dev/pandas/issues/31774
+ msg = "Result is too large"
+ a = Timestamp("2101-01-01 00:00:00")
+ b = Timestamp("1688-01-01 00:00:00")
+
+ with pytest.raises(OutOfBoundsDatetime, match=msg):
+ a - b
+
+ # but we're OK for timestamp and datetime.datetime
+ assert (a - b.to_pydatetime()) == (a.to_pydatetime() - b)
+
def test_delta_preserve_nanos(self):
val = Timestamp(1337299200000000123)
result = val + timedelta(1)
| Backport PR #32499: Better error message for OOB result | https://api.github.com/repos/pandas-dev/pandas/pulls/32605 | 2020-03-11T01:46:05Z | 2020-03-11T02:33:53Z | 2020-03-11T02:33:53Z | 2020-03-11T02:33:53Z |
Avoid bare pytest.raises in dtypes/test_dtypes.py | diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index 181f0c8906853..d29102cbd4604 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -558,7 +558,7 @@ def validate_categories(categories, fastpath: bool = False):
if not fastpath:
if categories.hasnans:
- raise ValueError("Categorial categories cannot be null")
+ raise ValueError("Categorical categories cannot be null")
if not categories.is_unique:
raise ValueError("Categorical categories must be unique")
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index 55b1ac819049d..e27a6b2102052 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -361,7 +361,7 @@ def test_hash_vs_equality(self, dtype):
assert hash(dtype) == hash(dtype3)
def test_construction(self):
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match="Invalid frequency: xx"):
PeriodDtype("xx")
for s in ["period[D]", "Period[D]", "D"]:
@@ -414,16 +414,17 @@ def test_construction_from_string(self, dtype):
assert is_dtype_equal(dtype, result)
result = PeriodDtype.construct_from_string("period[D]")
assert is_dtype_equal(dtype, result)
- with pytest.raises(TypeError):
+ msg = "Cannot construct a 'PeriodDtype' from "
+ with pytest.raises(TypeError, match=msg):
PeriodDtype.construct_from_string("foo")
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
PeriodDtype.construct_from_string("period[foo]")
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
PeriodDtype.construct_from_string("foo[D]")
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
PeriodDtype.construct_from_string("datetime64[ns]")
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
PeriodDtype.construct_from_string("datetime64[ns, US/Eastern]")
with pytest.raises(TypeError, match="list"):
@@ -475,7 +476,8 @@ def test_basic(self, dtype):
def test_empty(self):
dt = PeriodDtype()
- with pytest.raises(AttributeError):
+ msg = "object has no attribute 'freqstr'"
+ with pytest.raises(AttributeError, match=msg):
str(dt)
def test_not_string(self):
@@ -764,11 +766,13 @@ def test_order_hashes_different(self, v1, v2):
assert c1 is not c3
def test_nan_invalid(self):
- with pytest.raises(ValueError):
+ msg = "Categorical categories cannot be null"
+ with pytest.raises(ValueError, match=msg):
CategoricalDtype([1, 2, np.nan])
def test_non_unique_invalid(self):
- with pytest.raises(ValueError):
+ msg = "Categorical categories must be unique"
+ with pytest.raises(ValueError, match=msg):
CategoricalDtype([1, 2, 1])
def test_same_categories_different_order(self):
| * [x] ref #30999
* [x] tests added / passed
* [x] passes `black pandas`
* [x] passes `git diff origin/master -u -- "*.py" | flake8 --diff`
Please be aware that I changed dtypes.py as there was a typo in the exception message. | https://api.github.com/repos/pandas-dev/pandas/pulls/32604 | 2020-03-11T01:17:22Z | 2020-03-11T02:48:21Z | null | 2020-03-11T02:48:21Z |
Avoid bare pytest.raises in dtypes/cast/test_upcast.py | diff --git a/pandas/tests/dtypes/cast/test_upcast.py b/pandas/tests/dtypes/cast/test_upcast.py
index bb7a7d059c7ee..f9227a4e78a79 100644
--- a/pandas/tests/dtypes/cast/test_upcast.py
+++ b/pandas/tests/dtypes/cast/test_upcast.py
@@ -12,7 +12,7 @@ def test_upcast_error(result):
# GH23823 require result arg to be ndarray
mask = np.array([False, True, False])
other = np.array([61, 62, 63])
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match="The result input must be a ndarray"):
result, _ = maybe_upcast_putmask(result, mask, other)
| * [x] ref #30999
* [x] tests added / passed
* [x] passes `black pandas`
* [x] passes `git diff origin/master -u -- "*.py" | flake8 --diff` | https://api.github.com/repos/pandas-dev/pandas/pulls/32603 | 2020-03-11T00:49:57Z | 2020-03-11T01:50:43Z | 2020-03-11T01:50:43Z | 2020-03-21T00:41:45Z |
DOC: Fix link to monthly meeting calendar | diff --git a/doc/source/development/meeting.rst b/doc/source/development/meeting.rst
index 1d19408692cda..803f1b7002de0 100644
--- a/doc/source/development/meeting.rst
+++ b/doc/source/development/meeting.rst
@@ -25,7 +25,7 @@ This calendar shows all the developer meetings.
You can subscribe to this calendar with the following links:
* `iCal <https://calendar.google.com/calendar/ical/pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com/public/basic.ics>`__
-* `Google calendar <https://calendar.google.com/calendar/embed?src=pgbn14p6poja8a1cf2dv2jhrmg%40group.calendar.google.com>`__
+* `Google calendar <https://calendar.google.com/calendar/r?cid=pgbn14p6poja8a1cf2dv2jhrmg@group.calendar.google.com>`__
Additionally, we'll sometimes have one-off meetings on specific topics.
These will be published on the same calendar.
| The link we currently have for Google calendar is to embed, and let you see the calendar, but not subscribe to it. Fixing it here. | https://api.github.com/repos/pandas-dev/pandas/pulls/32602 | 2020-03-10T23:20:13Z | 2020-03-11T03:10:38Z | 2020-03-11T03:10:38Z | 2020-03-11T03:10:38Z |
TST: assert monotonic is True | diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 071d2409f1be2..7ff97c0abbc5f 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -1314,7 +1314,7 @@ def test_constructor_mixed_dict_and_Series(self):
data["B"] = Series([4, 3, 2, 1], index=["bar", "qux", "baz", "foo"])
result = DataFrame(data)
- assert result.index.is_monotonic
+ assert result.index.is_monotonic is True
# ordering ambiguous, raise exception
with pytest.raises(ValueError, match="ambiguous ordering"):
diff --git a/pandas/tests/indexes/datetimes/test_datetime.py b/pandas/tests/indexes/datetimes/test_datetime.py
index 6217f225d496e..e559f7b169427 100644
--- a/pandas/tests/indexes/datetimes/test_datetime.py
+++ b/pandas/tests/indexes/datetimes/test_datetime.py
@@ -212,17 +212,17 @@ def test_sort_values(self):
idx = DatetimeIndex(["2000-01-04", "2000-01-01", "2000-01-02"])
ordered = idx.sort_values()
- assert ordered.is_monotonic
+ assert ordered.is_monotonic is True
ordered = idx.sort_values(ascending=False)
- assert ordered[::-1].is_monotonic
+ assert ordered[::-1].is_monotonic is True
ordered, dexer = idx.sort_values(return_indexer=True)
- assert ordered.is_monotonic
+ assert ordered.is_monotonic is True
tm.assert_numpy_array_equal(dexer, np.array([1, 2, 0], dtype=np.intp))
ordered, dexer = idx.sort_values(return_indexer=True, ascending=False)
- assert ordered[::-1].is_monotonic
+ assert ordered[::-1].is_monotonic is True
tm.assert_numpy_array_equal(dexer, np.array([0, 2, 1], dtype=np.intp))
def test_map_bug_1677(self):
diff --git a/pandas/tests/indexes/datetimes/test_join.py b/pandas/tests/indexes/datetimes/test_join.py
index 9a9c94fa19e6d..527909d201a80 100644
--- a/pandas/tests/indexes/datetimes/test_join.py
+++ b/pandas/tests/indexes/datetimes/test_join.py
@@ -80,7 +80,7 @@ def test_join_nonunique(self):
idx1 = to_datetime(["2012-11-06 16:00:11.477563", "2012-11-06 16:00:11.477563"])
idx2 = to_datetime(["2012-11-06 15:11:09.006507", "2012-11-06 15:11:09.006507"])
rs = idx1.join(idx2, how="outer")
- assert rs.is_monotonic
+ assert rs.is_monotonic is True
@pytest.mark.parametrize("freq", ["B", "C"])
def test_outer_join(self, freq):
diff --git a/pandas/tests/indexes/multi/test_integrity.py b/pandas/tests/indexes/multi/test_integrity.py
index fd150bb4d57a2..51d4773935e48 100644
--- a/pandas/tests/indexes/multi/test_integrity.py
+++ b/pandas/tests/indexes/multi/test_integrity.py
@@ -219,10 +219,10 @@ def test_metadata_immutable(idx):
def test_level_setting_resets_attributes():
ind = pd.MultiIndex.from_arrays([["A", "A", "B", "B", "B"], [1, 2, 1, 2, 3]])
- assert ind.is_monotonic
+ assert ind.is_monotonic is True
ind.set_levels([["A", "B"], [1, 3, 2]], inplace=True)
# if this fails, probably didn't reset the cache correctly.
- assert not ind.is_monotonic
+ assert not ind.is_monotonic is True
def test_rangeindex_fallback_coercion_bug():
diff --git a/pandas/tests/indexes/multi/test_sorting.py b/pandas/tests/indexes/multi/test_sorting.py
index bb40612b9a55a..4934a6fbb2eb9 100644
--- a/pandas/tests/indexes/multi/test_sorting.py
+++ b/pandas/tests/indexes/multi/test_sorting.py
@@ -144,11 +144,11 @@ def test_reconstruct_sort():
# starts off lexsorted & monotonic
mi = MultiIndex.from_arrays([["A", "A", "B", "B", "B"], [1, 2, 1, 2, 3]])
assert mi.is_lexsorted()
- assert mi.is_monotonic
+ assert mi.is_monotonic is True
recons = mi._sort_levels_monotonic()
assert recons.is_lexsorted()
- assert recons.is_monotonic
+ assert recons.is_monotonic is True
assert mi is recons
assert mi.equals(recons)
@@ -160,11 +160,11 @@ def test_reconstruct_sort():
names=["one", "two"],
)
assert not mi.is_lexsorted()
- assert not mi.is_monotonic
+ assert not mi.is_monotonic is True
recons = mi._sort_levels_monotonic()
assert not recons.is_lexsorted()
- assert not recons.is_monotonic
+ assert not recons.is_monotonic is True
assert mi.equals(recons)
assert Index(mi.values).equals(Index(recons.values))
@@ -176,11 +176,11 @@ def test_reconstruct_sort():
names=["col1", "col2"],
)
assert not mi.is_lexsorted()
- assert not mi.is_monotonic
+ assert not mi.is_monotonic is True
recons = mi._sort_levels_monotonic()
assert not recons.is_lexsorted()
- assert not recons.is_monotonic
+ assert recons.is_monotonic is False
assert mi.equals(recons)
assert Index(mi.values).equals(Index(recons.values))
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 03f0be3f368cb..1385d384f0b86 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -653,7 +653,7 @@ def test_is_monotonic_with_nat():
for obj in [pi, pi._engine, dti, dti._engine, tdi, tdi._engine]:
if isinstance(obj, Index):
# i.e. not Engines
- assert obj.is_monotonic
+ assert obj.is_monotonic is True
assert obj.is_monotonic_increasing
assert not obj.is_monotonic_decreasing
assert obj.is_unique
@@ -665,7 +665,7 @@ def test_is_monotonic_with_nat():
for obj in [pi1, pi1._engine, dti1, dti1._engine, tdi1, tdi1._engine]:
if isinstance(obj, Index):
# i.e. not Engines
- assert not obj.is_monotonic
+ assert obj.is_monotonic is False
assert not obj.is_monotonic_increasing
assert not obj.is_monotonic_decreasing
assert obj.is_unique
@@ -677,7 +677,7 @@ def test_is_monotonic_with_nat():
for obj in [pi2, pi2._engine, dti2, dti2._engine, tdi2, tdi2._engine]:
if isinstance(obj, Index):
# i.e. not Engines
- assert not obj.is_monotonic
+ assert obj.is_monotonic is False
assert not obj.is_monotonic_increasing
assert not obj.is_monotonic_decreasing
assert obj.is_unique
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py
index 971203d6fc720..ca2c7eb4e1720 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py
@@ -96,18 +96,18 @@ def test_sort_values(self):
idx = TimedeltaIndex(["4d", "1d", "2d"])
ordered = idx.sort_values()
- assert ordered.is_monotonic
+ assert ordered.is_monotonic is True
ordered = idx.sort_values(ascending=False)
- assert ordered[::-1].is_monotonic
+ assert ordered[::-1].is_monotonic is True
ordered, dexer = idx.sort_values(return_indexer=True)
- assert ordered.is_monotonic
+ assert ordered.is_monotonic is True
tm.assert_numpy_array_equal(dexer, np.array([1, 2, 0]), check_dtype=False)
ordered, dexer = idx.sort_values(return_indexer=True, ascending=False)
- assert ordered[::-1].is_monotonic
+ assert ordered[::-1].is_monotonic is True
tm.assert_numpy_array_equal(dexer, np.array([0, 2, 1]), check_dtype=False)
diff --git a/pandas/tests/indexing/multiindex/test_sorted.py b/pandas/tests/indexing/multiindex/test_sorted.py
index 4bec0f429a34e..f8518d40f59f3 100644
--- a/pandas/tests/indexing/multiindex/test_sorted.py
+++ b/pandas/tests/indexing/multiindex/test_sorted.py
@@ -44,16 +44,16 @@ def test_frame_getitem_not_sorted2(self):
df2.index.set_levels(["b", "d", "a"], level="col1", inplace=True)
df2.index.set_codes([0, 1, 0, 2], level="col1", inplace=True)
assert not df2.index.is_lexsorted()
- assert not df2.index.is_monotonic
+ assert not df2.index.is_monotonic is True
assert df2_original.index.equals(df2.index)
expected = df2.sort_index()
assert expected.index.is_lexsorted()
- assert expected.index.is_monotonic
+ assert expected.index.is_monotonic is True
result = df2.sort_index(level=0)
assert result.index.is_lexsorted()
- assert result.index.is_monotonic
+ assert result.index.is_monotonic is True
tm.assert_frame_equal(result, expected)
def test_frame_getitem_not_sorted(self, multiindex_dataframe_random_data):
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index 211d0d52d8357..c4b9676e3ee83 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -216,11 +216,11 @@ def test_minmax_timedelta64(self):
# monotonic
idx1 = TimedeltaIndex(["1 days", "2 days", "3 days"])
- assert idx1.is_monotonic
+ assert idx1.is_monotonic is True
# non-monotonic
idx2 = TimedeltaIndex(["1 days", np.nan, "3 days", "NaT"])
- assert not idx2.is_monotonic
+ assert not idx2.is_monotonic is True
for idx in [idx1, idx2]:
assert idx.min() == Timedelta("1 days")
@@ -339,13 +339,13 @@ def test_minmax_tz(self, tz_naive_fixture):
tz = tz_naive_fixture
# monotonic
idx1 = pd.DatetimeIndex(["2011-01-01", "2011-01-02", "2011-01-03"], tz=tz)
- assert idx1.is_monotonic
+ assert idx1.is_monotonic is True
# non-monotonic
idx2 = pd.DatetimeIndex(
["2011-01-01", pd.NaT, "2011-01-03", "2011-01-02", pd.NaT], tz=tz
)
- assert not idx2.is_monotonic
+ assert idx2.is_monotonic is False
for idx in [idx1, idx2]:
assert idx.min() == Timestamp("2011-01-01", tz=tz)
@@ -445,14 +445,14 @@ def test_minmax_period(self):
# monotonic
idx1 = pd.PeriodIndex([NaT, "2011-01-01", "2011-01-02", "2011-01-03"], freq="D")
- assert not idx1.is_monotonic
- assert idx1[1:].is_monotonic
+ assert idx1.is_monotonic is False
+ assert idx1[1:].is_monotonic is True
# non-monotonic
idx2 = pd.PeriodIndex(
["2011-01-01", NaT, "2011-01-03", "2011-01-02", NaT], freq="D"
)
- assert not idx2.is_monotonic
+ assert idx2.is_monotonic is False
for idx in [idx1, idx2]:
assert idx.min() == pd.Period("2011-01-01", freq="D")
diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py
index 725157b7c8523..b27b086993274 100644
--- a/pandas/tests/reshape/merge/test_join.py
+++ b/pandas/tests/reshape/merge/test_join.py
@@ -485,7 +485,7 @@ def test_join_inner_multiindex(self):
expected = expected.drop(["first", "second"], axis=1)
expected.index = joined.index
- assert joined.index.is_monotonic
+ assert joined.index.is_monotonic is True
tm.assert_frame_equal(joined, expected)
# _assert_same_contents(expected, expected2.loc[:, expected.columns])
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index 9b09f0033715d..0a3cd90fc5446 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -570,20 +570,20 @@ def test_non_sorted(self):
quotes = self.quotes.sort_values("time", ascending=False)
# we require that we are already sorted on time & quotes
- assert not trades.time.is_monotonic
- assert not quotes.time.is_monotonic
+ assert trades.time.is_monotonic is False
+ assert quotes.time.is_monotonic is False
with pytest.raises(ValueError):
merge_asof(trades, quotes, on="time", by="ticker")
trades = self.trades.sort_values("time")
- assert trades.time.is_monotonic
- assert not quotes.time.is_monotonic
+ assert trades.time.is_monotonic is True
+ assert quotes.time.is_monotonic is False
with pytest.raises(ValueError):
merge_asof(trades, quotes, on="time", by="ticker")
quotes = self.quotes.sort_values("time")
- assert trades.time.is_monotonic
- assert quotes.time.is_monotonic
+ assert trades.time.is_monotonic is True
+ assert quotes.time.is_monotonic is True
# ok, though has dupes
merge_asof(trades, self.quotes, on="time", by="ticker")
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 75c3c565e9d58..0073f4bc33cca 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -1115,7 +1115,7 @@ def test_pivot_columns_lexsorted(self):
aggfunc="mean",
)
- assert pivoted.columns.is_monotonic
+ assert pivoted.columns.is_monotonic is True
def test_pivot_complex_aggfunc(self):
f = {"D": ["std"], "E": ["sum"]}
diff --git a/pandas/tests/series/methods/test_asof.py b/pandas/tests/series/methods/test_asof.py
index ad5a2de6eabac..c0e1eebd64110 100644
--- a/pandas/tests/series/methods/test_asof.py
+++ b/pandas/tests/series/methods/test_asof.py
@@ -147,7 +147,7 @@ def test_errors(self):
)
# non-monotonic
- assert not s.index.is_monotonic
+ assert s.index.is_monotonic is False
with pytest.raises(ValueError):
s.asof(s.index[0])
diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py
index 6f45b72154805..1a2b744262b53 100644
--- a/pandas/tests/series/test_analytics.py
+++ b/pandas/tests/series/test_analytics.py
@@ -146,7 +146,7 @@ def test_numpy_repeat(self):
def test_is_monotonic(self):
s = Series(np.random.randint(0, 10, size=1000))
- assert not s.is_monotonic
+ assert s.is_monotonic is False
s = Series(np.arange(1000))
assert s.is_monotonic is True
assert s.is_monotonic_increasing is True
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index 84279d874bae1..71f6ec166c700 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -2037,7 +2037,7 @@ def test_sort_index_and_reconstruction(self):
)
result = result.sort_index()
assert result.index.is_lexsorted()
- assert result.index.is_monotonic
+ assert result.index.is_monotonic is True
tm.assert_frame_equal(result, expected)
@@ -2056,7 +2056,7 @@ def test_sort_index_and_reconstruction(self):
result = concatted.sort_index()
assert result.index.is_lexsorted()
- assert result.index.is_monotonic
+ assert result.index.is_monotonic is True
tm.assert_frame_equal(result, expected)
@@ -2073,13 +2073,13 @@ def test_sort_index_and_reconstruction(self):
pd.to_datetime(df.columns.levels[1]), level=1, inplace=True
)
assert not df.columns.is_lexsorted()
- assert not df.columns.is_monotonic
+ assert df.columns.is_monotonic is False
result = df.sort_index(axis=1)
assert result.columns.is_lexsorted()
- assert result.columns.is_monotonic
+ assert result.columns.is_monotonic is True
result = df.sort_index(axis=1, level=1)
assert result.columns.is_lexsorted()
- assert result.columns.is_monotonic
+ assert result.columns.is_monotonic is True
def test_sort_index_and_reconstruction_doc_example(self):
# doc example
@@ -2090,7 +2090,7 @@ def test_sort_index_and_reconstruction_doc_example(self):
),
)
assert df.index.is_lexsorted()
- assert not df.index.is_monotonic
+ assert df.index.is_monotonic is False
# sort it
expected = DataFrame(
@@ -2101,7 +2101,7 @@ def test_sort_index_and_reconstruction_doc_example(self):
)
result = df.sort_index()
assert result.index.is_lexsorted()
- assert result.index.is_monotonic
+ assert result.index.is_monotonic is True
tm.assert_frame_equal(result, expected)
@@ -2109,7 +2109,7 @@ def test_sort_index_and_reconstruction_doc_example(self):
result = df.sort_index().copy()
result.index = result.index._sort_levels_monotonic()
assert result.index.is_lexsorted()
- assert result.index.is_monotonic
+ assert result.index.is_monotonic is True
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py
index 5f5e10b5dd497..8f7f54aad2bc9 100644
--- a/pandas/tests/window/test_timeseries_window.py
+++ b/pandas/tests/window/test_timeseries_window.py
@@ -106,11 +106,11 @@ def test_monotonic_on(self):
{"A": date_range("20130101", periods=5, freq="s"), "B": range(5)}
)
- assert df.A.is_monotonic
+ assert df.A.is_monotonic is True
df.rolling("2s", on="A").sum()
df = df.set_index("A")
- assert df.index.is_monotonic
+ assert df.index.is_monotonic is True
df.rolling("2s").sum()
def test_non_monotonic_on(self):
@@ -123,7 +123,7 @@ def test_non_monotonic_on(self):
non_monotonic_index[0] = non_monotonic_index[3]
df.index = non_monotonic_index
- assert not df.index.is_monotonic
+ assert df.index.is_monotonic is False
with pytest.raises(ValueError):
df.rolling("2s").sum()
| Makes tests for monoticity stricter. Follow-up to #23256. | https://api.github.com/repos/pandas-dev/pandas/pulls/32601 | 2020-03-10T22:52:20Z | 2020-03-10T22:59:20Z | null | 2020-08-08T08:31:25Z |
BUG: Fix file descriptor leak | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 4e7bd5a2032a7..31010c98712ad 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -337,6 +337,7 @@ I/O
- Bug in :meth:`read_csv` was raising `TypeError` when `sep=None` was used in combination with `comment` keyword (:issue:`31396`)
- Bug in :class:`HDFStore` that caused it to set to ``int64`` the dtype of a ``datetime64`` column when reading a DataFrame in Python 3 from fixed format written in Python 2 (:issue:`31750`)
- Bug in :meth:`read_excel` where a UTF-8 string with a high surrogate would cause a segmentation violation (:issue:`23809`)
+- Bug in :meth:`read_csv` was causing a file descriptor leak on an empty file (:issue:`31488`)
Plotting
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 50b5db0274aa5..52783b3a9e134 100755
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -2273,11 +2273,15 @@ def __init__(self, f, **kwds):
# Get columns in two steps: infer from data, then
# infer column indices from self.usecols if it is specified.
self._col_indices = None
- (
- self.columns,
- self.num_original_columns,
- self.unnamed_cols,
- ) = self._infer_columns()
+ try:
+ (
+ self.columns,
+ self.num_original_columns,
+ self.unnamed_cols,
+ ) = self._infer_columns()
+ except (TypeError, ValueError):
+ self.close()
+ raise
# Now self.columns has the set of columns that we will process.
# The original set is stored in self.original_columns.
diff --git a/pandas/tests/io/parser/test_common.py b/pandas/tests/io/parser/test_common.py
index b3aa1aa14a509..33460262a4430 100644
--- a/pandas/tests/io/parser/test_common.py
+++ b/pandas/tests/io/parser/test_common.py
@@ -15,6 +15,7 @@
from pandas._libs.tslib import Timestamp
from pandas.errors import DtypeWarning, EmptyDataError, ParserError
+import pandas.util._test_decorators as td
from pandas import DataFrame, Index, MultiIndex, Series, compat, concat
import pandas._testing as tm
@@ -2079,3 +2080,16 @@ def test_integer_precision(all_parsers):
result = parser.read_csv(StringIO(s), header=None)[4]
expected = Series([4321583677327450765, 4321113141090630389], name=4)
tm.assert_series_equal(result, expected)
+
+
+def test_file_descriptor_leak(all_parsers):
+ # GH 31488
+
+ parser = all_parsers
+ with tm.ensure_clean() as path:
+
+ def test():
+ with pytest.raises(EmptyDataError, match="No columns to parse from file"):
+ parser.read_csv(path)
+
+ td.check_file_leaks(test)()
| - [x] closes #31488
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32598 | 2020-03-10T21:47:38Z | 2020-03-15T00:37:42Z | 2020-03-15T00:37:42Z | 2020-03-15T07:14:03Z |
REF: implement nanops.na_accum_func | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index f53135174741e..427b1bfc28ba5 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -30,7 +30,7 @@
from pandas._config import config
-from pandas._libs import Timestamp, iNaT, lib
+from pandas._libs import Timestamp, lib
from pandas._typing import (
Axis,
FilePathOrBuffer,
@@ -10102,8 +10102,6 @@ def mad(self, axis=None, skipna=None, level=None):
desc="minimum",
accum_func=np.minimum.accumulate,
accum_func_name="min",
- mask_a=np.inf,
- mask_b=np.nan,
examples=_cummin_examples,
)
cls.cumsum = _make_cum_function(
@@ -10115,8 +10113,6 @@ def mad(self, axis=None, skipna=None, level=None):
desc="sum",
accum_func=np.cumsum,
accum_func_name="sum",
- mask_a=0.0,
- mask_b=np.nan,
examples=_cumsum_examples,
)
cls.cumprod = _make_cum_function(
@@ -10128,8 +10124,6 @@ def mad(self, axis=None, skipna=None, level=None):
desc="product",
accum_func=np.cumprod,
accum_func_name="prod",
- mask_a=1.0,
- mask_b=np.nan,
examples=_cumprod_examples,
)
cls.cummax = _make_cum_function(
@@ -10141,8 +10135,6 @@ def mad(self, axis=None, skipna=None, level=None):
desc="maximum",
accum_func=np.maximum.accumulate,
accum_func_name="max",
- mask_a=-np.inf,
- mask_b=np.nan,
examples=_cummax_examples,
)
@@ -11182,8 +11174,6 @@ def _make_cum_function(
desc: str,
accum_func: Callable,
accum_func_name: str,
- mask_a: float,
- mask_b: float,
examples: str,
) -> Callable:
@Substitution(
@@ -11205,61 +11195,15 @@ def cum_func(self, axis=None, skipna=True, *args, **kwargs):
if axis == 1:
return cum_func(self.T, axis=0, skipna=skipna, *args, **kwargs).T
- def na_accum_func(blk_values):
- # We will be applying this function to block values
- if blk_values.dtype.kind in ["m", "M"]:
- # GH#30460, GH#29058
- # numpy 1.18 started sorting NaTs at the end instead of beginning,
- # so we need to work around to maintain backwards-consistency.
- orig_dtype = blk_values.dtype
-
- # We need to define mask before masking NaTs
- mask = isna(blk_values)
-
- if accum_func == np.minimum.accumulate:
- # Note: the accum_func comparison fails as an "is" comparison
- y = blk_values.view("i8")
- y[mask] = np.iinfo(np.int64).max
- changed = True
- else:
- y = blk_values
- changed = False
-
- result = accum_func(y.view("i8"), axis)
- if skipna:
- np.putmask(result, mask, iNaT)
- elif accum_func == np.minimum.accumulate:
- # Restore NaTs that we masked previously
- nz = (~np.asarray(mask)).nonzero()[0]
- if len(nz):
- # everything up to the first non-na entry stays NaT
- result[: nz[0]] = iNaT
-
- if changed:
- # restore NaT elements
- y[mask] = iNaT # TODO: could try/finally for this?
-
- if isinstance(blk_values, np.ndarray):
- result = result.view(orig_dtype)
- else:
- # DatetimeArray
- result = type(blk_values)._from_sequence(result, dtype=orig_dtype)
-
- elif skipna and not issubclass(
- blk_values.dtype.type, (np.integer, np.bool_)
- ):
- vals = blk_values.copy().T
- mask = isna(vals)
- np.putmask(vals, mask, mask_a)
- result = accum_func(vals, axis)
- np.putmask(result, mask, mask_b)
- else:
- result = accum_func(blk_values.T, axis)
+ def block_accum_func(blk_values):
+ values = blk_values.T if hasattr(blk_values, "T") else blk_values
- # transpose back for ndarray, not for EA
- return result.T if hasattr(result, "T") else result
+ result = nanops.na_accum_func(values, accum_func, skipna=skipna)
+
+ result = result.T if hasattr(result, "T") else result
+ return result
- result = self._data.apply(na_accum_func)
+ result = self._data.apply(block_accum_func)
d = self._construct_axes_dict()
d["copy"] = False
diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 269843abb15ee..a5e70bd279d21 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -8,7 +8,7 @@
from pandas._config import get_option
from pandas._libs import NaT, Period, Timedelta, Timestamp, iNaT, lib
-from pandas._typing import Dtype, Scalar
+from pandas._typing import ArrayLike, Dtype, Scalar
from pandas.compat._optional import import_optional_dependency
from pandas.core.dtypes.cast import _int64_max, maybe_upcast_putmask
@@ -1500,3 +1500,75 @@ def nanpercentile(
return result
else:
return np.percentile(values, q, axis=axis, interpolation=interpolation)
+
+
+def na_accum_func(values: ArrayLike, accum_func, skipna: bool) -> ArrayLike:
+ """
+ Cumulative function with skipna support.
+
+ Parameters
+ ----------
+ values : np.ndarray or ExtensionArray
+ accum_func : {np.cumprod, np.maximum.accumulate, np.cumsum, np.minumum.accumulate}
+ skipna : bool
+
+ Returns
+ -------
+ np.ndarray or ExtensionArray
+ """
+ mask_a, mask_b = {
+ np.cumprod: (1.0, np.nan),
+ np.maximum.accumulate: (-np.inf, np.nan),
+ np.cumsum: (0.0, np.nan),
+ np.minimum.accumulate: (np.inf, np.nan),
+ }[accum_func]
+
+ # We will be applying this function to block values
+ if values.dtype.kind in ["m", "M"]:
+ # GH#30460, GH#29058
+ # numpy 1.18 started sorting NaTs at the end instead of beginning,
+ # so we need to work around to maintain backwards-consistency.
+ orig_dtype = values.dtype
+
+ # We need to define mask before masking NaTs
+ mask = isna(values)
+
+ if accum_func == np.minimum.accumulate:
+ # Note: the accum_func comparison fails as an "is" comparison
+ y = values.view("i8")
+ y[mask] = np.iinfo(np.int64).max
+ changed = True
+ else:
+ y = values
+ changed = False
+
+ result = accum_func(y.view("i8"), axis=0)
+ if skipna:
+ result[mask] = iNaT
+ elif accum_func == np.minimum.accumulate:
+ # Restore NaTs that we masked previously
+ nz = (~np.asarray(mask)).nonzero()[0]
+ if len(nz):
+ # everything up to the first non-na entry stays NaT
+ result[: nz[0]] = iNaT
+
+ if changed:
+ # restore NaT elements
+ y[mask] = iNaT # TODO: could try/finally for this?
+
+ if isinstance(values, np.ndarray):
+ result = result.view(orig_dtype)
+ else:
+ # DatetimeArray
+ result = type(values)._from_sequence(result, dtype=orig_dtype)
+
+ elif skipna and not issubclass(values.dtype.type, (np.integer, np.bool_)):
+ vals = values.copy()
+ mask = isna(vals)
+ vals[mask] = mask_a
+ result = accum_func(vals, axis=0)
+ result[mask] = mask_b
+ else:
+ result = accum_func(values, axis=0)
+
+ return result
| this is a follow-up that was requested a few months ago | https://api.github.com/repos/pandas-dev/pandas/pulls/32597 | 2020-03-10T21:41:06Z | 2020-03-14T03:32:24Z | 2020-03-14T03:32:24Z | 2020-03-14T17:03:00Z |
Backport PR #32592 on branch 1.0.x (DOC: cleanup 1.0.2 whatsnew) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 462f243f14494..9841df0507138 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -1,7 +1,7 @@
.. _whatsnew_102:
-What's new in 1.0.2 (February ??, 2020)
----------------------------------------
+What's new in 1.0.2 (March 11, 2020)
+------------------------------------
These are the changes in pandas 1.0.2. See :ref:`release` for a full changelog
including other versions of pandas.
@@ -18,13 +18,13 @@ Fixed regressions
- Fixed regression in :meth:`DataFrame.to_excel` when ``columns`` kwarg is passed (:issue:`31677`)
- Fixed regression in :meth:`Series.align` when ``other`` is a DataFrame and ``method`` is not None (:issue:`31785`)
- Fixed regression in :meth:`pandas.core.groupby.RollingGroupby.apply` where the ``raw`` parameter was ignored (:issue:`31754`)
-- Fixed regression in :meth:`rolling(..).corr() <pandas.core.window.Rolling.corr>` when using a time offset (:issue:`31789`)
-- Fixed regression in :meth:`DataFrameGroupBy.nunique` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
+- Fixed regression in :meth:`pandas.core.window.Rolling.corr` when using a time offset (:issue:`31789`)
+- Fixed regression in :meth:`pandas.core.groupby.DataFrameGroupBy.nunique` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
- Fixed regression where :func:`read_pickle` raised a ``UnicodeDecodeError`` when reading a py27 pickle with :class:`MultiIndex` column (:issue:`31988`).
- Fixed regression in :class:`DataFrame` arithmetic operations with mis-matched columns (:issue:`31623`)
-- Fixed regression in :meth:`GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
+- Fixed regression in :meth:`pandas.core.groupby.GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
- Joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` will preserve ``freq`` in simple cases (:issue:`32166`)
-- Fixed bug in the repr of an object-dtype ``Index`` with bools and missing values (:issue:`32146`)
+- Fixed bug in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
-
.. ---------------------------------------------------------------------------
@@ -82,7 +82,7 @@ Bug fixes
- Fix bug in :meth:`DataFrame.convert_dtypes` for columns that were already using the ``"string"`` dtype (:issue:`31731`).
- Fixed bug in setting values using a slice indexer with string dtype (:issue:`31772`)
-- Fixed bug where :meth:`GroupBy.first` and :meth:`GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
+- Fixed bug where :meth:`pandas.core.groupby.GroupBy.first` and :meth:`pandas.core.groupby.GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
- Fix bug in :meth:`Series.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
**Strings**
| Backport PR #32592: DOC: cleanup 1.0.2 whatsnew | https://api.github.com/repos/pandas-dev/pandas/pulls/32596 | 2020-03-10T20:46:56Z | 2020-03-10T21:52:46Z | 2020-03-10T21:52:46Z | 2020-03-10T21:52:46Z |
BUG: Don't multiply sets during construction | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 48eff0543ad4d..e9e87ec202ef5 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -241,7 +241,7 @@ Conversion
^^^^^^^^^^
- Bug in :class:`Series` construction from NumPy array with big-endian ``datetime64`` dtype (:issue:`29684`)
- Bug in :class:`Timedelta` construction with large nanoseconds keyword value (:issue:`32402`)
--
+- Bug in :class:`DataFrame` construction where sets would be duplicated rather than raising (:issue:`32582`)
Strings
^^^^^^^
diff --git a/pandas/core/construction.py b/pandas/core/construction.py
index e2d8fba8d4148..c9754ff588896 100644
--- a/pandas/core/construction.py
+++ b/pandas/core/construction.py
@@ -5,6 +5,7 @@
These should not depend on core.internals.
"""
+from collections import abc
from typing import TYPE_CHECKING, Any, Optional, Sequence, Union, cast
import numpy as np
@@ -446,6 +447,8 @@ def sanitize_array(
# GH#16804
arr = np.arange(data.start, data.stop, data.step, dtype="int64")
subarr = _try_cast(arr, dtype, copy, raise_cast_failure)
+ elif isinstance(data, abc.Set):
+ raise TypeError("Set type is unordered")
else:
subarr = _try_cast(data, dtype, copy, raise_cast_failure)
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index d938c0f6f1066..924952ad334c4 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -2604,3 +2604,9 @@ def test_from_2d_ndarray_with_dtype(self):
expected = DataFrame(array_dim2).astype("datetime64[ns, UTC]")
tm.assert_frame_equal(df, expected)
+
+ def test_construction_from_set_raises(self):
+ # https://github.com/pandas-dev/pandas/issues/32582
+ msg = "Set type is unordered"
+ with pytest.raises(TypeError, match=msg):
+ pd.DataFrame({"a": {1, 2, 3}})
| - [x] closes #32582
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32594 | 2020-03-10T19:25:56Z | 2020-03-15T00:41:34Z | 2020-03-15T00:41:34Z | 2020-03-15T00:42:47Z |
DOC: cleanup 1.0.2 whatsnew | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 462f243f14494..9841df0507138 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -1,7 +1,7 @@
.. _whatsnew_102:
-What's new in 1.0.2 (February ??, 2020)
----------------------------------------
+What's new in 1.0.2 (March 11, 2020)
+------------------------------------
These are the changes in pandas 1.0.2. See :ref:`release` for a full changelog
including other versions of pandas.
@@ -18,13 +18,13 @@ Fixed regressions
- Fixed regression in :meth:`DataFrame.to_excel` when ``columns`` kwarg is passed (:issue:`31677`)
- Fixed regression in :meth:`Series.align` when ``other`` is a DataFrame and ``method`` is not None (:issue:`31785`)
- Fixed regression in :meth:`pandas.core.groupby.RollingGroupby.apply` where the ``raw`` parameter was ignored (:issue:`31754`)
-- Fixed regression in :meth:`rolling(..).corr() <pandas.core.window.Rolling.corr>` when using a time offset (:issue:`31789`)
-- Fixed regression in :meth:`DataFrameGroupBy.nunique` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
+- Fixed regression in :meth:`pandas.core.window.Rolling.corr` when using a time offset (:issue:`31789`)
+- Fixed regression in :meth:`pandas.core.groupby.DataFrameGroupBy.nunique` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
- Fixed regression where :func:`read_pickle` raised a ``UnicodeDecodeError`` when reading a py27 pickle with :class:`MultiIndex` column (:issue:`31988`).
- Fixed regression in :class:`DataFrame` arithmetic operations with mis-matched columns (:issue:`31623`)
-- Fixed regression in :meth:`GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
+- Fixed regression in :meth:`pandas.core.groupby.GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
- Joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` will preserve ``freq`` in simple cases (:issue:`32166`)
-- Fixed bug in the repr of an object-dtype ``Index`` with bools and missing values (:issue:`32146`)
+- Fixed bug in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
-
.. ---------------------------------------------------------------------------
@@ -82,7 +82,7 @@ Bug fixes
- Fix bug in :meth:`DataFrame.convert_dtypes` for columns that were already using the ``"string"`` dtype (:issue:`31731`).
- Fixed bug in setting values using a slice indexer with string dtype (:issue:`31772`)
-- Fixed bug where :meth:`GroupBy.first` and :meth:`GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
+- Fixed bug where :meth:`pandas.core.groupby.GroupBy.first` and :meth:`pandas.core.groupby.GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
- Fix bug in :meth:`Series.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
**Strings**
| https://api.github.com/repos/pandas-dev/pandas/pulls/32592 | 2020-03-10T19:17:48Z | 2020-03-10T20:46:43Z | 2020-03-10T20:46:43Z | 2020-03-11T12:20:39Z | |
REG: dt64 shift with integer fill_value | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index ee4b265ce3ed9..e6d65b1f828cb 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -29,6 +29,7 @@ Fixed regressions
- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
- Fixed regression in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with (tz-aware) index and ``method=nearest`` (:issue:`26683`)
- Fixed regression in :meth:`DataFrame.reindex_like` on a :class:`DataFrame` subclass raised an ``AssertionError`` (:issue:`31925`)
+- Fixed regression in :meth:`Series.shift` with ``datetime64`` dtype when passing an integer ``fill_value`` (:issue:`32591`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 8c870c6255200..105d9581b1a25 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -745,6 +745,57 @@ def _from_factorized(cls, values, original):
def _values_for_argsort(self):
return self._data
+ @Appender(ExtensionArray.shift.__doc__)
+ def shift(self, periods=1, fill_value=None, axis=0):
+ if not self.size or periods == 0:
+ return self.copy()
+
+ if is_valid_nat_for_dtype(fill_value, self.dtype):
+ fill_value = NaT
+ elif not isinstance(fill_value, self._recognized_scalars):
+ # only warn if we're not going to raise
+ if self._scalar_type is Period and lib.is_integer(fill_value):
+ # kludge for #31971 since Period(integer) tries to cast to str
+ new_fill = Period._from_ordinal(fill_value, freq=self.freq)
+ else:
+ new_fill = self._scalar_type(fill_value)
+
+ # stacklevel here is chosen to be correct when called from
+ # DataFrame.shift or Series.shift
+ warnings.warn(
+ f"Passing {type(fill_value)} to shift is deprecated and "
+ "will raise in a future version, pass "
+ f"{self._scalar_type.__name__} instead.",
+ FutureWarning,
+ stacklevel=7,
+ )
+ fill_value = new_fill
+
+ fill_value = self._unbox_scalar(fill_value)
+
+ new_values = self._data
+
+ # make sure array sent to np.roll is c_contiguous
+ f_ordered = new_values.flags.f_contiguous
+ if f_ordered:
+ new_values = new_values.T
+ axis = new_values.ndim - axis - 1
+
+ new_values = np.roll(new_values, periods, axis=axis)
+
+ axis_indexer = [slice(None)] * self.ndim
+ if periods > 0:
+ axis_indexer[axis] = slice(None, periods)
+ else:
+ axis_indexer[axis] = slice(periods, None)
+ new_values[tuple(axis_indexer)] = fill_value
+
+ # restore original order
+ if f_ordered:
+ new_values = new_values.T
+
+ return type(self)._simple_new(new_values, dtype=self.dtype)
+
# ------------------------------------------------------------------
# Additional array methods
# These are not part of the EA API, but we implement them because
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 024d3b205df77..3f5c27bf5269c 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1917,10 +1917,7 @@ def diff(self, n: int, axis: int = 1) -> List["Block"]:
return super().diff(n, axis)
def shift(
- self,
- periods: int,
- axis: libinternals.BlockPlacement = 0,
- fill_value: Any = None,
+ self, periods: int, axis: int = 0, fill_value: Any = None,
) -> List["ExtensionBlock"]:
"""
Shift the block by `periods`.
@@ -2173,7 +2170,7 @@ def internal_values(self):
def iget(self, key):
# GH#31649 we need to wrap scalars in Timestamp/Timedelta
- # TODO: this can be removed if we ever have 2D EA
+ # TODO(EA2D): this can be removed if we ever have 2D EA
result = super().iget(key)
if isinstance(result, np.datetime64):
result = Timestamp(result)
@@ -2181,6 +2178,12 @@ def iget(self, key):
result = Timedelta(result)
return result
+ def shift(self, periods, axis=0, fill_value=None):
+ # TODO(EA2D) this is unnecessary if these blocks are backed by 2D EAs
+ values = self.array_values()
+ new_values = values.shift(periods, fill_value=fill_value, axis=axis)
+ return self.make_block_same_class(new_values)
+
class DatetimeBlock(DatetimeLikeBlockMixin, Block):
__slots__ = ()
diff --git a/pandas/tests/arrays/test_datetimelike.py b/pandas/tests/arrays/test_datetimelike.py
index f99ee542d543c..b8a70752330c5 100644
--- a/pandas/tests/arrays/test_datetimelike.py
+++ b/pandas/tests/arrays/test_datetimelike.py
@@ -240,6 +240,23 @@ def test_inplace_arithmetic(self):
arr -= pd.Timedelta(days=1)
tm.assert_equal(arr, expected)
+ def test_shift_fill_int_deprecated(self):
+ # GH#31971
+ data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+ arr = self.array_cls(data, freq="D")
+
+ with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+ result = arr.shift(1, fill_value=1)
+
+ expected = arr.copy()
+ if self.array_cls is PeriodArray:
+ fill_val = PeriodArray._scalar_type._from_ordinal(1, freq=arr.freq)
+ else:
+ fill_val = arr._scalar_type(1)
+ expected[0] = fill_val
+ expected[1:] = arr[:-1]
+ tm.assert_equal(result, expected)
+
class TestDatetimeArray(SharedTests):
index_cls = pd.DatetimeIndex
diff --git a/pandas/tests/frame/methods/test_shift.py b/pandas/tests/frame/methods/test_shift.py
index cfb17de892b1c..f6c89172bbf86 100644
--- a/pandas/tests/frame/methods/test_shift.py
+++ b/pandas/tests/frame/methods/test_shift.py
@@ -185,3 +185,26 @@ def test_tshift(self, datetime_frame):
msg = "Freq was not given and was not set in the index"
with pytest.raises(ValueError, match=msg):
no_freq.tshift()
+
+ def test_shift_dt64values_int_fill_deprecated(self):
+ # GH#31971
+ ser = pd.Series([pd.Timestamp("2020-01-01"), pd.Timestamp("2020-01-02")])
+ df = ser.to_frame()
+
+ with tm.assert_produces_warning(FutureWarning):
+ result = df.shift(1, fill_value=0)
+
+ expected = pd.Series([pd.Timestamp(0), ser[0]]).to_frame()
+ tm.assert_frame_equal(result, expected)
+
+ # axis = 1
+ df2 = pd.DataFrame({"A": ser, "B": ser})
+ df2._consolidate_inplace()
+
+ with tm.assert_produces_warning(FutureWarning):
+ result = df2.shift(1, axis=1, fill_value=0)
+
+ expected = pd.DataFrame(
+ {"A": [pd.Timestamp(0), pd.Timestamp(0)], "B": df2["A"]}
+ )
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/series/methods/test_shift.py b/pandas/tests/series/methods/test_shift.py
index 8256e2f33b936..e8d7f5958d0a1 100644
--- a/pandas/tests/series/methods/test_shift.py
+++ b/pandas/tests/series/methods/test_shift.py
@@ -263,3 +263,13 @@ def test_shift_categorical(self):
tm.assert_index_equal(s.values.categories, sp1.values.categories)
tm.assert_index_equal(s.values.categories, sn2.values.categories)
+
+ def test_shift_dt64values_int_fill_deprecated(self):
+ # GH#31971
+ ser = pd.Series([pd.Timestamp("2020-01-01"), pd.Timestamp("2020-01-02")])
+
+ with tm.assert_produces_warning(FutureWarning):
+ result = ser.shift(1, fill_value=0)
+
+ expected = pd.Series([pd.Timestamp(0), ser[0]])
+ tm.assert_series_equal(result, expected)
| - [x] closes #31971
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32591 | 2020-03-10T18:59:28Z | 2020-03-12T02:26:13Z | 2020-03-12T02:26:13Z | 2020-03-12T17:02:55Z |
CLN: remove unreachable code in pandas/core/groupby/generic.py::DataFrameGroupBy::_transform_general | diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 4102b8527b6aa..a7cee5106af30 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -1202,158 +1202,147 @@ def first_not_none(values):
# GH9684. If all values are None, then this will throw an error.
# We'd prefer it return an empty dataframe.
return DataFrame()
+
elif isinstance(v, DataFrame):
return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
- elif self.grouper.groupings is not None:
- if len(self.grouper.groupings) > 1:
- key_index = self.grouper.result_index
-
- else:
- ping = self.grouper.groupings[0]
- if len(keys) == ping.ngroups:
- key_index = ping.group_index
- key_index.name = key_names[0]
- key_lookup = Index(keys)
- indexer = key_lookup.get_indexer(key_index)
+ if len(self.grouper.groupings) > 1:
+ key_index = self.grouper.result_index
+ else:
+ ping = self.grouper.groupings[0]
+ if len(keys) == ping.ngroups:
+ key_index = ping.group_index
+ key_index.name = key_names[0]
- # reorder the values
- values = [values[i] for i in indexer]
- else:
+ key_lookup = Index(keys)
+ indexer = key_lookup.get_indexer(key_index)
- key_index = Index(keys, name=key_names[0])
+ # reorder the values
+ values = [values[i] for i in indexer]
+ else:
- # don't use the key indexer
- if not self.as_index:
- key_index = None
+ key_index = Index(keys, name=key_names[0])
- # make Nones an empty object
- v = first_not_none(values)
- if v is None:
- return DataFrame()
- elif isinstance(v, NDFrame):
+ # don't use the key indexer
+ if not self.as_index:
+ key_index = None
- # this is to silence a DeprecationWarning
- # TODO: Remove when default dtype of empty Series is object
- kwargs = v._construct_axes_dict()
- if v._constructor is Series:
- backup = create_series_with_explicit_dtype(
- **kwargs, dtype_if_empty=object
- )
- else:
- backup = v._constructor(**kwargs)
-
- values = [x if (x is not None) else backup for x in values]
-
- v = values[0]
-
- if isinstance(v, (np.ndarray, Index, Series)):
- if isinstance(v, Series):
- applied_index = self._selected_obj._get_axis(self.axis)
- all_indexed_same = all_indexes_same([x.index for x in values])
- singular_series = len(values) == 1 and applied_index.nlevels == 1
-
- # GH3596
- # provide a reduction (Frame -> Series) if groups are
- # unique
- if self.squeeze:
- # assign the name to this series
- if singular_series:
- values[0].name = keys[0]
-
- # GH2893
- # we have series in the values array, we want to
- # produce a series:
- # if any of the sub-series are not indexed the same
- # OR we don't have a multi-index and we have only a
- # single values
- return self._concat_objects(
- keys, values, not_indexed_same=not_indexed_same
- )
-
- # still a series
- # path added as of GH 5545
- elif all_indexed_same:
- from pandas.core.reshape.concat import concat
-
- return concat(values)
-
- if not all_indexed_same:
- # GH 8467
- return self._concat_objects(keys, values, not_indexed_same=True)
-
- if self.axis == 0 and isinstance(v, ABCSeries):
- # GH6124 if the list of Series have a consistent name,
- # then propagate that name to the result.
- index = v.index.copy()
- if index.name is None:
- # Only propagate the series name to the result
- # if all series have a consistent name. If the
- # series do not have a consistent name, do
- # nothing.
- names = {v.name for v in values}
- if len(names) == 1:
- index.name = list(names)[0]
-
- # normally use vstack as its faster than concat
- # and if we have mi-columns
- if (
- isinstance(v.index, MultiIndex)
- or key_index is None
- or isinstance(key_index, MultiIndex)
- ):
- stacked_values = np.vstack([np.asarray(v) for v in values])
- result = DataFrame(
- stacked_values, index=key_index, columns=index
+ # make Nones an empty object
+ v = first_not_none(values)
+ if v is None:
+ return DataFrame()
+ elif isinstance(v, NDFrame):
+
+ # this is to silence a DeprecationWarning
+ # TODO: Remove when default dtype of empty Series is object
+ kwargs = v._construct_axes_dict()
+ if v._constructor is Series:
+ backup = create_series_with_explicit_dtype(
+ **kwargs, dtype_if_empty=object
+ )
+ else:
+ backup = v._constructor(**kwargs)
+
+ values = [x if (x is not None) else backup for x in values]
+
+ v = values[0]
+
+ if isinstance(v, (np.ndarray, Index, Series)):
+ if isinstance(v, Series):
+ applied_index = self._selected_obj._get_axis(self.axis)
+ all_indexed_same = all_indexes_same([x.index for x in values])
+ singular_series = len(values) == 1 and applied_index.nlevels == 1
+
+ # GH3596
+ # provide a reduction (Frame -> Series) if groups are
+ # unique
+ if self.squeeze:
+ # assign the name to this series
+ if singular_series:
+ values[0].name = keys[0]
+
+ # GH2893
+ # we have series in the values array, we want to
+ # produce a series:
+ # if any of the sub-series are not indexed the same
+ # OR we don't have a multi-index and we have only a
+ # single values
+ return self._concat_objects(
+ keys, values, not_indexed_same=not_indexed_same
)
- else:
- # GH5788 instead of stacking; concat gets the
- # dtypes correct
+
+ # still a series
+ # path added as of GH 5545
+ elif all_indexed_same:
from pandas.core.reshape.concat import concat
- result = concat(
- values,
- keys=key_index,
- names=key_index.names,
- axis=self.axis,
- ).unstack()
- result.columns = index
- elif isinstance(v, ABCSeries):
+ return concat(values)
+
+ if not all_indexed_same:
+ # GH 8467
+ return self._concat_objects(keys, values, not_indexed_same=True)
+
+ if self.axis == 0 and isinstance(v, ABCSeries):
+ # GH6124 if the list of Series have a consistent name,
+ # then propagate that name to the result.
+ index = v.index.copy()
+ if index.name is None:
+ # Only propagate the series name to the result
+ # if all series have a consistent name. If the
+ # series do not have a consistent name, do
+ # nothing.
+ names = {v.name for v in values}
+ if len(names) == 1:
+ index.name = list(names)[0]
+
+ # normally use vstack as its faster than concat
+ # and if we have mi-columns
+ if (
+ isinstance(v.index, MultiIndex)
+ or key_index is None
+ or isinstance(key_index, MultiIndex)
+ ):
stacked_values = np.vstack([np.asarray(v) for v in values])
- result = DataFrame(
- stacked_values.T, index=v.index, columns=key_index
- )
+ result = DataFrame(stacked_values, index=key_index, columns=index)
else:
- # GH#1738: values is list of arrays of unequal lengths
- # fall through to the outer else clause
- # TODO: sure this is right? we used to do this
- # after raising AttributeError above
- return Series(values, index=key_index, name=self._selection_name)
-
- # if we have date/time like in the original, then coerce dates
- # as we are stacking can easily have object dtypes here
- so = self._selected_obj
- if so.ndim == 2 and so.dtypes.apply(needs_i8_conversion).any():
- result = _recast_datetimelike_result(result)
- else:
- result = result._convert(datetime=True)
-
- return self._reindex_output(result)
-
- # values are not series or array-like but scalars
+ # GH5788 instead of stacking; concat gets the
+ # dtypes correct
+ from pandas.core.reshape.concat import concat
+
+ result = concat(
+ values, keys=key_index, names=key_index.names, axis=self.axis,
+ ).unstack()
+ result.columns = index
+ elif isinstance(v, ABCSeries):
+ stacked_values = np.vstack([np.asarray(v) for v in values])
+ result = DataFrame(stacked_values.T, index=v.index, columns=key_index)
else:
- # only coerce dates if we find at least 1 datetime
- should_coerce = any(isinstance(x, Timestamp) for x in values)
- # self._selection_name not passed through to Series as the
- # result should not take the name of original selection
- # of columns
- return Series(values, index=key_index)._convert(
- datetime=True, coerce=should_coerce
- )
+ # GH#1738: values is list of arrays of unequal lengths
+ # fall through to the outer else clause
+ # TODO: sure this is right? we used to do this
+ # after raising AttributeError above
+ return Series(values, index=key_index, name=self._selection_name)
+
+ # if we have date/time like in the original, then coerce dates
+ # as we are stacking can easily have object dtypes here
+ so = self._selected_obj
+ if so.ndim == 2 and so.dtypes.apply(needs_i8_conversion).any():
+ result = _recast_datetimelike_result(result)
+ else:
+ result = result._convert(datetime=True)
+
+ return self._reindex_output(result)
+ # values are not series or array-like but scalars
else:
- # Handle cases like BinGrouper
- return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
+ # only coerce dates if we find at least 1 datetime
+ should_coerce = any(isinstance(x, Timestamp) for x in values)
+ # self._selection_name not passed through to Series as the
+ # result should not take the name of original selection
+ # of columns
+ return Series(values, index=key_index)._convert(
+ datetime=True, coerce=should_coerce
+ )
def _transform_general(self, func, *args, **kwargs):
from pandas.core.reshape.concat import concat
| Is this part of the code
```
else:
# Handle cases like BinGrouper
return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
```
necessary? The condition before it is
```
elif self.grouper.groupings is not None
```
. However, even in the case of `BinGrouper`, I don't believe `BinGrouper.groupings` can be `None`:
```
>>> from pandas.core.groupby.ops import BinGrouper
>>> BinGrouper([], []).groupings
[Grouping(None)]
```
and so this code is unreachable. It's not covered by the tests, at least - https://codecov.io/gh/pandas-dev/pandas/src/master/pandas/core/groupby/generic.py#L1354
If it can be removed, I've taken it out and then shifted the code above it back by one tab (because we no longer need the guard) | https://api.github.com/repos/pandas-dev/pandas/pulls/32583 | 2020-03-10T16:09:32Z | 2020-04-11T13:04:18Z | null | 2020-10-10T14:14:54Z |
Backport PR #31684 on branch 1.0.x (BUG: string methods with NA) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 808e6ae709ce9..35358d8303175 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -84,6 +84,10 @@ Bug fixes
- Fixed bug where :meth:`GroupBy.first` and :meth:`GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
- Fix bug in :meth:`Series.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
+**Strings**
+
+- Using ``pd.NA`` with :meth:`Series.str.repeat` now correctly outputs a null value instead of raising error for vector inputs (:issue:`31632`)
+
.. ---------------------------------------------------------------------------
.. _whatsnew_102.contributors:
diff --git a/pandas/core/strings.py b/pandas/core/strings.py
index 18c7504f2c2f8..9ef066d55689f 100644
--- a/pandas/core/strings.py
+++ b/pandas/core/strings.py
@@ -778,6 +778,8 @@ def scalar_rep(x):
else:
def rep(x, r):
+ if x is libmissing.NA:
+ return x
try:
return bytes.__mul__(x, r)
except TypeError:
diff --git a/pandas/tests/test_strings.py b/pandas/tests/test_strings.py
index 8171072686443..76683d2c35854 100644
--- a/pandas/tests/test_strings.py
+++ b/pandas/tests/test_strings.py
@@ -1157,6 +1157,18 @@ def test_repeat(self):
assert isinstance(rs, Series)
tm.assert_series_equal(rs, xp)
+ def test_repeat_with_null(self):
+ # GH: 31632
+ values = Series(["a", None], dtype="string")
+ result = values.str.repeat([3, 4])
+ exp = Series(["aaa", None], dtype="string")
+ tm.assert_series_equal(result, exp)
+
+ values = Series(["a", "b"], dtype="string")
+ result = values.str.repeat([3, None])
+ exp = Series(["aaa", None], dtype="string")
+ tm.assert_series_equal(result, exp)
+
def test_match(self):
# New match behavior introduced in 0.13
values = Series(["fooBAD__barBAD", np.nan, "foo"])
| Backport PR #31684: BUG: string methods with NA | https://api.github.com/repos/pandas-dev/pandas/pulls/32578 | 2020-03-10T14:09:22Z | 2020-03-10T16:21:21Z | 2020-03-10T16:21:21Z | 2020-03-10T16:21:21Z |
REG: Restore read_csv function for some file-likes | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 9841df0507138..8db47000480ed 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -25,6 +25,7 @@ Fixed regressions
- Fixed regression in :meth:`pandas.core.groupby.GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
- Joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` will preserve ``freq`` in simple cases (:issue:`32166`)
- Fixed bug in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
+- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index 2fd227694800c..3a42a64046abd 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -638,7 +638,8 @@ cdef class TextReader:
raise ValueError(f'Unrecognized compression type: '
f'{self.compression}')
- if self.encoding and isinstance(source, (io.BufferedIOBase, io.RawIOBase)):
+ if (self.encoding and hasattr(source, "read") and
+ not hasattr(source, "encoding")):
source = io.TextIOWrapper(
source, self.encoding.decode('utf-8'), newline='')
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index bc2fb9f0f41bc..50b5db0274aa5 100755
--- a/pandas/io/parsers.py
+++ b/pandas/io/parsers.py
@@ -5,7 +5,7 @@
from collections import abc, defaultdict
import csv
import datetime
-from io import BufferedIOBase, RawIOBase, StringIO, TextIOWrapper
+from io import StringIO, TextIOWrapper
import re
import sys
from textwrap import fill
@@ -1870,7 +1870,7 @@ def __init__(self, src, **kwds):
# Handle the file object with universal line mode enabled.
# We will handle the newline character ourselves later on.
- if isinstance(src, (BufferedIOBase, RawIOBase)):
+ if hasattr(src, "read") and not hasattr(src, "encoding"):
src = TextIOWrapper(src, encoding=encoding, newline="")
kwds["encoding"] = "utf-8"
diff --git a/pandas/tests/io/parser/test_encoding.py b/pandas/tests/io/parser/test_encoding.py
index 3661e4e056db2..13b74cf29f857 100644
--- a/pandas/tests/io/parser/test_encoding.py
+++ b/pandas/tests/io/parser/test_encoding.py
@@ -5,6 +5,7 @@
from io import BytesIO
import os
+import tempfile
import numpy as np
import pytest
@@ -174,3 +175,25 @@ def test_encoding_temp_file(all_parsers, utf_value, encoding_fmt, pass_encoding)
result = parser.read_csv(f, encoding=encoding if pass_encoding else None)
tm.assert_frame_equal(result, expected)
+
+
+def test_encoding_named_temp_file(all_parsers):
+ # see gh-31819
+ parser = all_parsers
+ encoding = "shift-jis"
+
+ if parser.engine == "python":
+ pytest.skip("NamedTemporaryFile does not work with Python engine")
+
+ title = "てすと"
+ data = "こむ"
+
+ expected = DataFrame({title: [data]})
+
+ with tempfile.NamedTemporaryFile() as f:
+ f.write(f"{title}\n{data}".encode(encoding))
+
+ f.seek(0)
+
+ result = parser.read_csv(f, encoding=encoding)
+ tm.assert_frame_equal(result, expected)
| Restore `read_csv` function for some file-likes
Restores behavior down to the fact that the Python engine cannot handle NamedTemporaryFile.
Closes https://github.com/pandas-dev/pandas/issues/31819
Credit to @sasanquaneuf for [originating idea](https://github.com/pandas-dev/pandas/issues/31819#issuecomment-584529415). | https://api.github.com/repos/pandas-dev/pandas/pulls/32577 | 2020-03-10T10:22:21Z | 2020-03-11T02:22:02Z | 2020-03-11T02:22:02Z | 2020-03-11T02:22:06Z |
TST: Add tests for duplicated and drop_duplicates | diff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py
index 543edc6b66ff2..83fe21fd20bfe 100644
--- a/pandas/tests/indexes/categorical/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -292,16 +292,81 @@ def test_is_monotonic(self, data, non_lexsorted_data):
assert c.is_monotonic_decreasing is False
def test_has_duplicates(self):
-
idx = CategoricalIndex([0, 0, 0], name="foo")
assert idx.is_unique is False
assert idx.has_duplicates is True
- def test_drop_duplicates(self):
+ idx = CategoricalIndex([0, 1], categories=[2, 3], name="foo")
+ assert idx.is_unique is False
+ assert idx.has_duplicates is True
- idx = CategoricalIndex([0, 0, 0], name="foo")
- expected = CategoricalIndex([0], name="foo")
- tm.assert_index_equal(idx.drop_duplicates(), expected)
+ idx = CategoricalIndex([0, 1, 2, 3], categories=[1, 2, 3], name="foo")
+ assert idx.is_unique is True
+ assert idx.has_duplicates is False
+
+ @pytest.mark.parametrize(
+ "data, categories, expected",
+ [
+ (
+ [1, 1, 1],
+ [1, 2, 3],
+ {
+ "first": np.array([False, True, True]),
+ "last": np.array([True, True, False]),
+ False: np.array([True, True, True]),
+ },
+ ),
+ (
+ [1, 1, 1],
+ list("abc"),
+ {
+ "first": np.array([False, True, True]),
+ "last": np.array([True, True, False]),
+ False: np.array([True, True, True]),
+ },
+ ),
+ (
+ [2, "a", "b"],
+ list("abc"),
+ {
+ "first": np.zeros(shape=(3), dtype=np.bool),
+ "last": np.zeros(shape=(3), dtype=np.bool),
+ False: np.zeros(shape=(3), dtype=np.bool),
+ },
+ ),
+ (
+ list("abb"),
+ list("abc"),
+ {
+ "first": np.array([False, False, True]),
+ "last": np.array([False, True, False]),
+ False: np.array([False, True, True]),
+ },
+ ),
+ ],
+ )
+ def test_drop_duplicates(self, data, categories, expected):
+
+ idx = CategoricalIndex(data, categories=categories, name="foo")
+ for keep, e in expected.items():
+ tm.assert_numpy_array_equal(idx.duplicated(keep=keep), e)
+ e = idx[~e]
+ result = idx.drop_duplicates(keep=keep)
+ tm.assert_index_equal(result, e)
+
+ @pytest.mark.parametrize(
+ "data, categories, expected_data, expected_categories",
+ [
+ ([1, 1, 1], [1, 2, 3], [1], [1]),
+ ([1, 1, 1], list("abc"), [np.nan], []),
+ ([1, 2, "a"], [1, 2, 3], [1, 2, np.nan], [1, 2]),
+ ([2, "a", "b"], list("abc"), [np.nan, "a", "b"], ["a", "b"]),
+ ],
+ )
+ def test_unique(self, data, categories, expected_data, expected_categories):
+
+ idx = CategoricalIndex(data, categories=categories)
+ expected = CategoricalIndex(expected_data, categories=expected_categories)
tm.assert_index_equal(idx.unique(), expected)
def test_repr_roundtrip(self):
diff --git a/pandas/tests/indexes/conftest.py b/pandas/tests/indexes/conftest.py
index a9fb228073ab4..fb17e1df6341b 100644
--- a/pandas/tests/indexes/conftest.py
+++ b/pandas/tests/indexes/conftest.py
@@ -16,3 +16,12 @@ def sort(request):
in in the Index setops methods.
"""
return request.param
+
+
+@pytest.fixture(params=["D", "3D", "-3D", "H", "2H", "-2H", "T", "2T", "S", "-3S"])
+def freq_sample(request):
+ """
+ Valid values for 'freq' parameter used to create date_range and
+ timedelta_range..
+ """
+ return request.param
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index cbf6b7b63bd50..c55b0481c1041 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -264,9 +264,9 @@ def test_order_without_freq(self, index_dates, expected_dates, tz_naive_fixture)
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
assert ordered.freq is None
- def test_drop_duplicates_metadata(self):
+ def test_drop_duplicates_metadata(self, freq_sample):
# GH 10115
- idx = pd.date_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+ idx = pd.date_range("2011-01-01", freq=freq_sample, periods=10, name="idx")
result = idx.drop_duplicates()
tm.assert_index_equal(idx, result)
assert idx.freq == result.freq
@@ -277,57 +277,38 @@ def test_drop_duplicates_metadata(self):
tm.assert_index_equal(idx, result)
assert result.freq is None
- def test_drop_duplicates(self):
+ @pytest.mark.parametrize(
+ "keep, expected, index",
+ [
+ ("first", np.concatenate(([False] * 10, [True] * 5)), np.arange(0, 10)),
+ ("last", np.concatenate(([True] * 5, [False] * 10)), np.arange(5, 15)),
+ (
+ False,
+ np.concatenate(([True] * 5, [False] * 5, [True] * 5)),
+ np.arange(5, 10),
+ ),
+ ],
+ )
+ def test_drop_duplicates(self, freq_sample, keep, expected, index):
# to check Index/Series compat
- base = pd.date_range("2011-01-01", "2011-01-31", freq="D", name="idx")
- idx = base.append(base[:5])
+ idx = pd.date_range("2011-01-01", freq=freq_sample, periods=10, name="idx")
+ idx = idx.append(idx[:5])
- res = idx.drop_duplicates()
- tm.assert_index_equal(res, base)
- res = Series(idx).drop_duplicates()
- tm.assert_series_equal(res, Series(base))
+ tm.assert_numpy_array_equal(idx.duplicated(keep=keep), expected)
+ expected = idx[~expected]
- res = idx.drop_duplicates(keep="last")
- exp = base[5:].append(base[:5])
- tm.assert_index_equal(res, exp)
- res = Series(idx).drop_duplicates(keep="last")
- tm.assert_series_equal(res, Series(exp, index=np.arange(5, 36)))
+ result = idx.drop_duplicates(keep=keep)
+ tm.assert_index_equal(result, expected)
- res = idx.drop_duplicates(keep=False)
- tm.assert_index_equal(res, base[5:])
- res = Series(idx).drop_duplicates(keep=False)
- tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
+ result = Series(idx).drop_duplicates(keep=keep)
+ tm.assert_series_equal(result, Series(expected, index=index))
- @pytest.mark.parametrize(
- "freq",
- [
- "A",
- "2A",
- "-2A",
- "Q",
- "-1Q",
- "M",
- "-1M",
- "D",
- "3D",
- "-3D",
- "W",
- "-1W",
- "H",
- "2H",
- "-2H",
- "T",
- "2T",
- "S",
- "-3S",
- ],
- )
- def test_infer_freq(self, freq):
+ def test_infer_freq(self, freq_sample):
# GH 11018
- idx = pd.date_range("2011-01-01 09:00:00", freq=freq, periods=10)
+ idx = pd.date_range("2011-01-01 09:00:00", freq=freq_sample, periods=10)
result = pd.DatetimeIndex(idx.asi8, freq="infer")
tm.assert_index_equal(idx, result)
- assert result.freq == freq
+ assert result.freq == freq_sample
def test_nat(self, tz_naive_fixture):
tz = tz_naive_fixture
diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py
index 196946e696c8d..fc44226f9d72f 100644
--- a/pandas/tests/indexes/period/test_ops.py
+++ b/pandas/tests/indexes/period/test_ops.py
@@ -81,9 +81,10 @@ def test_value_counts_unique(self):
tm.assert_index_equal(idx.unique(), exp_idx)
- def test_drop_duplicates_metadata(self):
+ @pytest.mark.parametrize("freq", ["D", "3D", "H", "2H", "T", "2T", "S", "3S"])
+ def test_drop_duplicates_metadata(self, freq):
# GH 10115
- idx = pd.period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
+ idx = pd.period_range("2011-01-01", periods=10, freq=freq, name="idx")
result = idx.drop_duplicates()
tm.assert_index_equal(idx, result)
assert idx.freq == result.freq
@@ -93,26 +94,32 @@ def test_drop_duplicates_metadata(self):
tm.assert_index_equal(idx, result)
assert idx.freq == result.freq
- def test_drop_duplicates(self):
+ @pytest.mark.parametrize("freq", ["D", "3D", "H", "2H", "T", "2T", "S", "3S"])
+ @pytest.mark.parametrize(
+ "keep, expected, index",
+ [
+ ("first", np.concatenate(([False] * 10, [True] * 5)), np.arange(0, 10)),
+ ("last", np.concatenate(([True] * 5, [False] * 10)), np.arange(5, 15)),
+ (
+ False,
+ np.concatenate(([True] * 5, [False] * 5, [True] * 5)),
+ np.arange(5, 10),
+ ),
+ ],
+ )
+ def test_drop_duplicates(self, freq, keep, expected, index):
# to check Index/Series compat
- base = pd.period_range("2011-01-01", "2011-01-31", freq="D", name="idx")
- idx = base.append(base[:5])
-
- res = idx.drop_duplicates()
- tm.assert_index_equal(res, base)
- res = Series(idx).drop_duplicates()
- tm.assert_series_equal(res, Series(base))
-
- res = idx.drop_duplicates(keep="last")
- exp = base[5:].append(base[:5])
- tm.assert_index_equal(res, exp)
- res = Series(idx).drop_duplicates(keep="last")
- tm.assert_series_equal(res, Series(exp, index=np.arange(5, 36)))
-
- res = idx.drop_duplicates(keep=False)
- tm.assert_index_equal(res, base[5:])
- res = Series(idx).drop_duplicates(keep=False)
- tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
+ idx = pd.period_range("2011-01-01", periods=10, freq=freq, name="idx")
+ idx = idx.append(idx[:5])
+
+ tm.assert_numpy_array_equal(idx.duplicated(keep=keep), expected)
+ expected = idx[~expected]
+
+ result = idx.drop_duplicates(keep=keep)
+ tm.assert_index_equal(result, expected)
+
+ result = Series(idx).drop_duplicates(keep=keep)
+ tm.assert_series_equal(result, Series(expected, index=index))
def test_order_compat(self):
def _check_freq(index, expected_index):
diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py
index 4af5df6e2cc55..aa1bf997fc66b 100644
--- a/pandas/tests/indexes/timedeltas/test_ops.py
+++ b/pandas/tests/indexes/timedeltas/test_ops.py
@@ -134,9 +134,9 @@ def test_order(self):
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
assert ordered.freq is None
- def test_drop_duplicates_metadata(self):
+ def test_drop_duplicates_metadata(self, freq_sample):
# GH 10115
- idx = pd.timedelta_range("1 day", "31 day", freq="D", name="idx")
+ idx = pd.timedelta_range("1 day", periods=10, freq=freq_sample, name="idx")
result = idx.drop_duplicates()
tm.assert_index_equal(idx, result)
assert idx.freq == result.freq
@@ -147,36 +147,38 @@ def test_drop_duplicates_metadata(self):
tm.assert_index_equal(idx, result)
assert result.freq is None
- def test_drop_duplicates(self):
+ @pytest.mark.parametrize(
+ "keep, expected, index",
+ [
+ ("first", np.concatenate(([False] * 10, [True] * 5)), np.arange(0, 10)),
+ ("last", np.concatenate(([True] * 5, [False] * 10)), np.arange(5, 15)),
+ (
+ False,
+ np.concatenate(([True] * 5, [False] * 5, [True] * 5)),
+ np.arange(5, 10),
+ ),
+ ],
+ )
+ def test_drop_duplicates(self, freq_sample, keep, expected, index):
# to check Index/Series compat
- base = pd.timedelta_range("1 day", "31 day", freq="D", name="idx")
- idx = base.append(base[:5])
+ idx = pd.timedelta_range("1 day", periods=10, freq=freq_sample, name="idx")
+ idx = idx.append(idx[:5])
- res = idx.drop_duplicates()
- tm.assert_index_equal(res, base)
- res = Series(idx).drop_duplicates()
- tm.assert_series_equal(res, Series(base))
+ tm.assert_numpy_array_equal(idx.duplicated(keep=keep), expected)
+ expected = idx[~expected]
- res = idx.drop_duplicates(keep="last")
- exp = base[5:].append(base[:5])
- tm.assert_index_equal(res, exp)
- res = Series(idx).drop_duplicates(keep="last")
- tm.assert_series_equal(res, Series(exp, index=np.arange(5, 36)))
+ result = idx.drop_duplicates(keep=keep)
+ tm.assert_index_equal(result, expected)
- res = idx.drop_duplicates(keep=False)
- tm.assert_index_equal(res, base[5:])
- res = Series(idx).drop_duplicates(keep=False)
- tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
+ result = Series(idx).drop_duplicates(keep=keep)
+ tm.assert_series_equal(result, Series(expected, index=index))
- @pytest.mark.parametrize(
- "freq", ["D", "3D", "-3D", "H", "2H", "-2H", "T", "2T", "S", "-3S"]
- )
- def test_infer_freq(self, freq):
+ def test_infer_freq(self, freq_sample):
# GH#11018
- idx = pd.timedelta_range("1", freq=freq, periods=10)
+ idx = pd.timedelta_range("1", freq=freq_sample, periods=10)
result = pd.TimedeltaIndex(idx.asi8, freq="infer")
tm.assert_index_equal(idx, result)
- assert result.freq == freq
+ assert result.freq == freq_sample
def test_repeat(self):
index = pd.timedelta_range("1 days", periods=2, freq="D")
| - [x] refers to #15752
- [x] tests added / passed
- [x] tests duplicated and drop_duplicates for period, categorical, datetimes, timedelta | https://api.github.com/repos/pandas-dev/pandas/pulls/32575 | 2020-03-10T09:35:01Z | 2020-04-06T23:23:00Z | 2020-04-06T23:23:00Z | 2020-04-16T17:15:04Z |
Backport PR #31875 on branch 1.0.x (DOC: add redirects from Rolling to rolling.Rolling) | diff --git a/doc/redirects.csv b/doc/redirects.csv
index ef93955c14fe6..3669ff4b7cc0b 100644
--- a/doc/redirects.csv
+++ b/doc/redirects.csv
@@ -49,7 +49,25 @@ internals,development/internals
# api moved function
reference/api/pandas.io.json.json_normalize,pandas.json_normalize
-# api rename
+# rename due to refactors
+reference/api/pandas.core.window.Rolling,pandas.core.window.rolling.Rolling
+reference/api/pandas.core.window.Rolling.aggregate,pandas.core.window.rolling.Rolling.aggregate
+reference/api/pandas.core.window.Rolling.apply,pandas.core.window.rolling.Rolling.apply
+reference/api/pandas.core.window.Rolling.corr,pandas.core.window.rolling.Rolling.corr
+reference/api/pandas.core.window.Rolling.count,pandas.core.window.rolling.Rolling.count
+reference/api/pandas.core.window.Rolling.cov,pandas.core.window.rolling.Rolling.cov
+reference/api/pandas.core.window.Rolling.kurt,pandas.core.window.rolling.Rolling.kurt
+reference/api/pandas.core.window.Rolling.max,pandas.core.window.rolling.Rolling.max
+reference/api/pandas.core.window.Rolling.mean,pandas.core.window.rolling.Rolling.mean
+reference/api/pandas.core.window.Rolling.median,pandas.core.window.rolling.Rolling.median
+reference/api/pandas.core.window.Rolling.min,pandas.core.window.rolling.Rolling.min
+reference/api/pandas.core.window.Rolling.quantile,pandas.core.window.rolling.Rolling.quantile
+reference/api/pandas.core.window.Rolling.skew,pandas.core.window.rolling.Rolling.skew
+reference/api/pandas.core.window.Rolling.std,pandas.core.window.rolling.Rolling.std
+reference/api/pandas.core.window.Rolling.sum,pandas.core.window.rolling.Rolling.sum
+reference/api/pandas.core.window.Rolling.var,pandas.core.window.rolling.Rolling.var
+
+# api url change (generated -> reference/api rename)
api,reference/index
generated/pandas.api.extensions.ExtensionArray.argsort,../reference/api/pandas.api.extensions.ExtensionArray.argsort
generated/pandas.api.extensions.ExtensionArray.astype,../reference/api/pandas.api.extensions.ExtensionArray.astype
| Backport PR #31875: DOC: add redirects from Rolling to rolling.Rolling | https://api.github.com/repos/pandas-dev/pandas/pulls/32574 | 2020-03-10T08:35:58Z | 2020-03-10T10:15:57Z | 2020-03-10T10:15:57Z | 2020-03-10T10:15:57Z |
Backport PR #32564 on branch 1.0.x (DOC: Add missing question mark icon) | diff --git a/doc/source/_static/question_mark_noback.svg b/doc/source/_static/question_mark_noback.svg
new file mode 100644
index 0000000000000..3abb4b806d20a
--- /dev/null
+++ b/doc/source/_static/question_mark_noback.svg
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="6.1681423mm"
+ height="6.1681423mm"
+ viewBox="0 0 6.1681423 6.1681423"
+ version="1.1"
+ id="svg856"
+ inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
+ sodipodi:docname="question_mark_noback.svg">
+ <defs
+ id="defs850" />
+ <sodipodi:namedview
+ id="base"
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1.0"
+ inkscape:pageopacity="0.0"
+ inkscape:pageshadow="2"
+ inkscape:zoom="11.2"
+ inkscape:cx="4.3447038"
+ inkscape:cy="5.995975"
+ inkscape:document-units="mm"
+ inkscape:current-layer="layer1"
+ showgrid="false"
+ fit-margin-top="0"
+ fit-margin-left="0"
+ fit-margin-right="0"
+ fit-margin-bottom="0"
+ inkscape:window-width="1600"
+ inkscape:window-height="876"
+ inkscape:window-x="0"
+ inkscape:window-y="0"
+ inkscape:window-maximized="1" />
+ <metadata
+ id="metadata853">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title></dc:title>
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <g
+ inkscape:label="Layer 1"
+ inkscape:groupmode="layer"
+ id="layer1"
+ transform="translate(-71.755217,-98.124272)">
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-weight:normal;font-size:1.1868099px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458335"
+ x="73.403717"
+ y="103.38733"
+ id="text1405"><tspan
+ sodipodi:role="line"
+ id="tspan1403"
+ x="73.403717"
+ y="103.38733"
+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:5.6966877px;font-family:'Noto Sans Mono CJK HK';-inkscape-font-specification:'Noto Sans Mono CJK HK';fill:#ffffff;fill-opacity:1;stroke-width:0.26458335">?</tspan></text>
+ </g>
+</svg>
| Backport PR #32564: DOC: Add missing question mark icon | https://api.github.com/repos/pandas-dev/pandas/pulls/32573 | 2020-03-10T07:19:02Z | 2020-03-10T07:54:41Z | 2020-03-10T07:54:41Z | 2020-03-10T07:54:42Z |
TST: stricter tests, avoid check_categorical=False, check_less_precise | diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 07e30d41c216d..f4a10abea9757 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -32,7 +32,6 @@ def assert_stat_op_calc(
has_skipna=True,
check_dtype=True,
check_dates=False,
- check_less_precise=False,
skipna_alternative=None,
):
"""
@@ -54,9 +53,6 @@ def assert_stat_op_calc(
"alternative(frame)" should be checked.
check_dates : bool, default false
Whether opname should be tested on a Datetime Series
- check_less_precise : bool, default False
- Whether results should only be compared approximately;
- passed on to tm.assert_series_equal
skipna_alternative : function, default None
NaN-safe version of alternative
"""
@@ -84,17 +80,11 @@ def wrapper(x):
result0 = f(axis=0, skipna=False)
result1 = f(axis=1, skipna=False)
tm.assert_series_equal(
- result0,
- frame.apply(wrapper),
- check_dtype=check_dtype,
- check_less_precise=check_less_precise,
+ result0, frame.apply(wrapper), check_dtype=check_dtype,
)
# HACK: win32
tm.assert_series_equal(
- result1,
- frame.apply(wrapper, axis=1),
- check_dtype=False,
- check_less_precise=check_less_precise,
+ result1, frame.apply(wrapper, axis=1), check_dtype=False,
)
else:
skipna_wrapper = alternative
@@ -102,17 +92,12 @@ def wrapper(x):
result0 = f(axis=0)
result1 = f(axis=1)
tm.assert_series_equal(
- result0,
- frame.apply(skipna_wrapper),
- check_dtype=check_dtype,
- check_less_precise=check_less_precise,
+ result0, frame.apply(skipna_wrapper), check_dtype=check_dtype,
)
if opname in ["sum", "prod"]:
expected = frame.apply(skipna_wrapper, axis=1)
- tm.assert_series_equal(
- result1, expected, check_dtype=False, check_less_precise=check_less_precise
- )
+ tm.assert_series_equal(result1, expected, check_dtype=False)
# check dtypes
if check_dtype:
@@ -333,11 +318,7 @@ def kurt(x):
# mixed types (with upcasting happening)
assert_stat_op_calc(
- "sum",
- np.sum,
- mixed_float_frame.astype("float32"),
- check_dtype=False,
- check_less_precise=True,
+ "sum", np.sum, mixed_float_frame.astype("float32"), check_dtype=False,
)
assert_stat_op_calc(
diff --git a/pandas/tests/frame/test_to_csv.py b/pandas/tests/frame/test_to_csv.py
index cec2bd4b634c1..a49da7a5ec2fc 100644
--- a/pandas/tests/frame/test_to_csv.py
+++ b/pandas/tests/frame/test_to_csv.py
@@ -250,9 +250,7 @@ def make_dtnat_arr(n, nnat=None):
df.to_csv(pth, chunksize=chunksize)
recons = self.read_csv(pth)._convert(datetime=True, coerce=True)
- tm.assert_frame_equal(
- df, recons, check_names=False, check_less_precise=True
- )
+ tm.assert_frame_equal(df, recons, check_names=False)
@pytest.mark.slow
def test_to_csv_moar(self):
@@ -354,9 +352,7 @@ def _to_uni(x):
recons.columns = np.array(recons.columns, dtype=c_dtype)
df.columns = np.array(df.columns, dtype=c_dtype)
- tm.assert_frame_equal(
- df, recons, check_names=False, check_less_precise=True
- )
+ tm.assert_frame_equal(df, recons, check_names=False)
N = 100
chunksize = 1000
diff --git a/pandas/tests/generic/test_series.py b/pandas/tests/generic/test_series.py
index f119eb422a276..388bb8e3f636d 100644
--- a/pandas/tests/generic/test_series.py
+++ b/pandas/tests/generic/test_series.py
@@ -237,9 +237,7 @@ def test_to_xarray_index_types(self, index):
assert isinstance(result, DataArray)
# idempotency
- tm.assert_series_equal(
- result.to_series(), s, check_index_type=False, check_categorical=True
- )
+ tm.assert_series_equal(result.to_series(), s, check_index_type=False)
@td.skip_if_no("xarray", min_version="0.7.0")
def test_to_xarray(self):
diff --git a/pandas/tests/groupby/test_function.py b/pandas/tests/groupby/test_function.py
index 83080aa98648f..03278e69fe94a 100644
--- a/pandas/tests/groupby/test_function.py
+++ b/pandas/tests/groupby/test_function.py
@@ -661,7 +661,7 @@ def test_nlargest_mi_grouper():
]
expected = Series(exp_values, index=exp_idx)
- tm.assert_series_equal(result, expected, check_exact=False, check_less_precise=True)
+ tm.assert_series_equal(result, expected, check_exact=False)
def test_nsmallest():
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index 506d223dbedb4..59899673cfc31 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -564,7 +564,7 @@ def test_roundtrip_indexlabels(self, merge_cells, frame, path):
reader = ExcelFile(path)
recons = pd.read_excel(reader, "test1", index_col=[0, 1])
- tm.assert_frame_equal(df, recons, check_less_precise=True)
+ tm.assert_frame_equal(df, recons)
def test_excel_roundtrip_indexname(self, merge_cells, path):
df = DataFrame(np.random.randn(10, 4))
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index fc3876eee9d66..86502a67e1869 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -2372,7 +2372,7 @@ def test_write_row_by_row(self):
result = sql.read_sql("select * from test", con=self.conn)
result.index = frame.index
- tm.assert_frame_equal(result, frame, check_less_precise=True)
+ tm.assert_frame_equal(result, frame)
def test_execute(self):
frame = tm.makeTimeDataFrame()
@@ -2632,7 +2632,7 @@ def test_write_row_by_row(self):
result = sql.read_sql("select * from test", con=self.conn)
result.index = frame.index
- tm.assert_frame_equal(result, frame, check_less_precise=True)
+ tm.assert_frame_equal(result, frame)
def test_chunksize_read_type(self):
frame = tm.makeTimeDataFrame()
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index b65efac2bd527..3efac9cd605a8 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -254,12 +254,21 @@ def test_read_dta4(self, file):
)
# these are all categoricals
- expected = pd.concat(
- [expected[col].astype("category") for col in expected], axis=1
- )
+ for col in expected:
+ orig = expected[col].copy()
+
+ categories = np.asarray(expected["fully_labeled"][orig.notna()])
+ if col == "incompletely_labeled":
+ categories = orig
+
+ cat = orig.astype("category")._values
+ cat = cat.set_categories(categories, ordered=True)
+ cat.categories.rename(None, inplace=True)
+
+ expected[col] = cat
# stata doesn't save .category metadata
- tm.assert_frame_equal(parsed, expected, check_categorical=False)
+ tm.assert_frame_equal(parsed, expected)
# File containing strls
def test_read_dta12(self):
@@ -952,19 +961,27 @@ def test_categorical_writing(self, version):
original = pd.concat(
[original[col].astype("category") for col in original], axis=1
)
+ expected.index.name = "index"
expected["incompletely_labeled"] = expected["incompletely_labeled"].apply(str)
expected["unlabeled"] = expected["unlabeled"].apply(str)
- expected = pd.concat(
- [expected[col].astype("category") for col in expected], axis=1
- )
- expected.index.name = "index"
+ for col in expected:
+ orig = expected[col].copy()
+
+ cat = orig.astype("category")._values
+ cat = cat.as_ordered()
+ if col == "unlabeled":
+ cat = cat.set_categories(orig, ordered=True)
+
+ cat.categories.rename(None, inplace=True)
+
+ expected[col] = cat
with tm.ensure_clean() as path:
original.to_stata(path, version=version)
written_and_read_again = self.read_dta(path)
res = written_and_read_again.set_index("index")
- tm.assert_frame_equal(res, expected, check_categorical=False)
+ tm.assert_frame_equal(res, expected)
def test_categorical_warnings_and_errors(self):
# Warning for non-string labels
@@ -1056,9 +1073,11 @@ def test_categorical_sorting(self, file):
parsed.index = np.arange(parsed.shape[0])
codes = [-1, -1, 0, 1, 1, 1, 2, 2, 3, 4]
categories = ["Poor", "Fair", "Good", "Very good", "Excellent"]
- cat = pd.Categorical.from_codes(codes=codes, categories=categories)
+ cat = pd.Categorical.from_codes(
+ codes=codes, categories=categories, ordered=True
+ )
expected = pd.Series(cat, name="srh")
- tm.assert_series_equal(expected, parsed["srh"], check_categorical=False)
+ tm.assert_series_equal(expected, parsed["srh"])
@pytest.mark.parametrize("file", ["dta19_115", "dta19_117"])
def test_categorical_ordering(self, file):
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 1a794f8656abe..46ac430a13394 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -393,7 +393,7 @@ def test_constructor_categorical_dtype(self):
expected = Series(
["a", "a"], index=[0, 1], dtype=CategoricalDtype(["a", "b"], ordered=True)
)
- tm.assert_series_equal(result, expected, check_categorical=True)
+ tm.assert_series_equal(result, expected)
def test_constructor_categorical_string(self):
# GH 26336: the string 'category' maintains existing CategoricalDtype
| Won't be too surprised if 32bit builds need some troubleshooting. | https://api.github.com/repos/pandas-dev/pandas/pulls/32571 | 2020-03-10T02:30:06Z | 2020-03-11T02:27:15Z | 2020-03-11T02:27:15Z | 2020-03-11T02:30:00Z |
CLN: avoid _internal_get_values in pandas._testing | diff --git a/pandas/_testing.py b/pandas/_testing.py
index 5e94ac3b3d108..1048e0d8b6dc6 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -1038,7 +1038,8 @@ def assert_extension_array_equal(
if hasattr(left, "asi8") and type(right) == type(left):
# Avoid slow object-dtype comparisons
- assert_numpy_array_equal(left.asi8, right.asi8)
+ # np.asarray for case where we have a np.MaskedArray
+ assert_numpy_array_equal(np.asarray(left.asi8), np.asarray(right.asi8))
return
left_na = np.asarray(left.isna())
@@ -1176,20 +1177,23 @@ def assert_series_equal(
raise AssertionError(msg)
elif is_interval_dtype(left.dtype) or is_interval_dtype(right.dtype):
assert_interval_array_equal(left.array, right.array)
- elif is_datetime64tz_dtype(left.dtype):
- # .values is an ndarray, but ._values is the ExtensionArray.
+ elif is_categorical_dtype(left.dtype) or is_categorical_dtype(right.dtype):
+ _testing.assert_almost_equal(
+ left._values,
+ right._values,
+ check_less_precise=check_less_precise,
+ check_dtype=check_dtype,
+ obj=str(obj),
+ )
+ elif is_extension_array_dtype(left.dtype) or is_extension_array_dtype(right.dtype):
+ assert_extension_array_equal(left._values, right._values)
+ elif needs_i8_conversion(left.dtype) or needs_i8_conversion(right.dtype):
+ # DatetimeArray or TimedeltaArray
assert_extension_array_equal(left._values, right._values)
- elif (
- is_extension_array_dtype(left)
- and not is_categorical_dtype(left)
- and is_extension_array_dtype(right)
- and not is_categorical_dtype(right)
- ):
- assert_extension_array_equal(left.array, right.array)
else:
_testing.assert_almost_equal(
- left._internal_get_values(),
- right._internal_get_values(),
+ left._values,
+ right._values,
check_less_precise=check_less_precise,
check_dtype=check_dtype,
obj=str(obj),
| 7 more usages left after this | https://api.github.com/repos/pandas-dev/pandas/pulls/32570 | 2020-03-10T02:26:43Z | 2020-03-11T02:19:30Z | 2020-03-11T02:19:30Z | 2020-03-13T17:28:11Z |
PERF: copy cached attributes on index shallow_copy | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index e745bf3f5feed..f20c3df027fba 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -187,7 +187,9 @@ Performance improvements
- Performance improvement in :class:`Timedelta` constructor (:issue:`30543`)
- Performance improvement in :class:`Timestamp` constructor (:issue:`30543`)
- Performance improvement in flex arithmetic ops between :class:`DataFrame` and :class:`Series` with ``axis=0`` (:issue:`31296`)
--
+- The internal :meth:`Index._shallow_copy` now copies cached attributes over to the new index,
+ avoiding creating these again on the new index. This can speed up many operations
+ that depend on creating copies of existing indexes (:issue:`28584`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 3eab757311ccb..17a1827fda027 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1,7 +1,7 @@
from datetime import datetime
import operator
from textwrap import dedent
-from typing import TYPE_CHECKING, Any, FrozenSet, Hashable, Union
+from typing import TYPE_CHECKING, Any, Dict, FrozenSet, Hashable, Union
import warnings
import numpy as np
@@ -250,6 +250,7 @@ def _outer_indexer(self, left, right):
_typ = "index"
_data: Union[ExtensionArray, np.ndarray]
+ _cache: Dict[str, Any]
_id = None
_name: Label = None
# MultiIndex.levels previously allowed setting the index name. We
@@ -468,6 +469,7 @@ def _simple_new(cls, values, name: Label = None):
# we actually set this value too.
result._index_data = values
result._name = name
+ result._cache = {}
return result._reset_identity()
@@ -498,11 +500,13 @@ def _shallow_copy(self, values=None, name: Label = no_default):
name : Label, defaults to self.name
"""
name = self.name if name is no_default else name
-
+ cache = self._cache.copy() if values is None else {}
if values is None:
values = self.values
- return self._simple_new(values, name=name)
+ result = self._simple_new(values, name=name)
+ result._cache = cache
+ return result
def _shallow_copy_with_infer(self, values, **kwargs):
"""
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index 6c250ccd09a51..2d1d69772c100 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -104,15 +104,11 @@ def _maybe_cast_slice_bound(self, label, side, kind):
@Appender(Index._shallow_copy.__doc__)
def _shallow_copy(self, values=None, name: Label = lib.no_default):
- name = name if name is not lib.no_default else self.name
-
if values is not None and not self._can_hold_na and values.dtype.kind == "f":
+ name = self.name if name is lib.no_default else name
# Ensure we are not returning an Int64Index with float data:
return Float64Index._simple_new(values, name=name)
-
- if values is None:
- values = self.values
- return type(self)._simple_new(values, name=name)
+ return super()._shallow_copy(values=values, name=name)
def _convert_for_op(self, value):
"""
| - [x] closes #28584
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
The performance of the example in #28584 is:
```python
>>> idx = pd.Index(np.arange(100_000))
>>> %timeit idx.get_loc(99_999)
1.17 µs ± 80.6 ns per loop # master and this PR
>>> %timeit idx._shallow_copy().get_loc(99_999)
3.57 ms ± 286 ns per loop # master
3.67 µs ± 286 ns per loop # this PR
```
The issue is still on the extension indexes, e.g. ``CategoricalIndex._shallow_copy``. I'd like to take them afterwards. | https://api.github.com/repos/pandas-dev/pandas/pulls/32568 | 2020-03-09T22:33:40Z | 2020-03-11T03:06:03Z | 2020-03-11T03:06:03Z | 2020-03-11T09:02:49Z |
TST: add test.indexes.common.Base.create_index and annotate .create_index | diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index 69451501fd7bd..e5af0d9c03979 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -35,6 +35,9 @@ class Base:
_holder: Optional[Type[Index]] = None
_compat_props = ["shape", "ndim", "size", "nbytes"]
+ def create_index(self) -> Index:
+ raise NotImplementedError("Method not implemented")
+
def test_pickle_compat_construction(self):
# need an object to create with
msg = (
diff --git a/pandas/tests/indexes/datetimes/test_datetimelike.py b/pandas/tests/indexes/datetimes/test_datetimelike.py
index da1bd6f091d1a..e4785e5f80256 100644
--- a/pandas/tests/indexes/datetimes/test_datetimelike.py
+++ b/pandas/tests/indexes/datetimes/test_datetimelike.py
@@ -17,7 +17,7 @@ class TestDatetimeIndex(DatetimeLike):
def indices(self, request):
return request.param
- def create_index(self):
+ def create_index(self) -> DatetimeIndex:
return date_range("20130101", periods=5)
def test_shift(self):
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index b4c223be0f6a5..03f0be3f368cb 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -35,7 +35,7 @@ class TestPeriodIndex(DatetimeLike):
def indices(self, request):
return request.param
- def create_index(self):
+ def create_index(self) -> PeriodIndex:
return period_range("20130101", periods=5, freq="D")
def test_pickle_compat_construction(self):
diff --git a/pandas/tests/indexes/ranges/test_range.py b/pandas/tests/indexes/ranges/test_range.py
index c1cc23039eeaf..61ac937f5fda0 100644
--- a/pandas/tests/indexes/ranges/test_range.py
+++ b/pandas/tests/indexes/ranges/test_range.py
@@ -30,7 +30,7 @@ class TestRangeIndex(Numeric):
def indices(self, request):
return request.param
- def create_index(self):
+ def create_index(self) -> RangeIndex:
return RangeIndex(start=0, stop=20, step=2)
def test_can_hold_identifiers(self):
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 9e0cef375fea3..2981f56e58ecc 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -59,7 +59,7 @@ def index(self, request):
# copy to avoid mutation, e.g. setting .name
return indices_dict[key].copy()
- def create_index(self):
+ def create_index(self) -> Index:
return Index(list("abcde"))
def test_can_hold_identifiers(self):
@@ -2277,7 +2277,7 @@ class TestMixedIntIndex(Base):
def indices(self, request):
return Index(request.param)
- def create_index(self):
+ def create_index(self) -> Index:
return Index([0, "a", 1, "b", 2, "c"])
def test_argsort(self):
diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py
index 10d57d8616cf3..23877c2c7607a 100644
--- a/pandas/tests/indexes/test_numeric.py
+++ b/pandas/tests/indexes/test_numeric.py
@@ -118,7 +118,7 @@ def mixed_index(self):
def float_index(self):
return Float64Index([0.0, 2.5, 5.0, 7.5, 10.0])
- def create_index(self):
+ def create_index(self) -> Float64Index:
return Float64Index(np.arange(5, dtype="float64"))
def test_repr_roundtrip(self, indices):
@@ -663,7 +663,7 @@ class TestInt64Index(NumericInt):
def indices(self, request):
return Int64Index(request.param)
- def create_index(self):
+ def create_index(self) -> Int64Index:
# return Int64Index(np.arange(5, dtype="int64"))
return Int64Index(range(0, 20, 2))
@@ -801,7 +801,7 @@ def index_large(self):
large = [2 ** 63, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20, 2 ** 63 + 25]
return UInt64Index(large)
- def create_index(self):
+ def create_index(self) -> UInt64Index:
# compat with shared Int64/Float64 tests; use index_large for UInt64 only tests
return UInt64Index(np.arange(5, dtype="uint64"))
diff --git a/pandas/tests/indexes/timedeltas/test_timedelta.py b/pandas/tests/indexes/timedeltas/test_timedelta.py
index d4a94f8693081..971203d6fc720 100644
--- a/pandas/tests/indexes/timedeltas/test_timedelta.py
+++ b/pandas/tests/indexes/timedeltas/test_timedelta.py
@@ -28,7 +28,7 @@ class TestTimedeltaIndex(DatetimeLike):
def indices(self):
return tm.makeTimedeltaIndex(10)
- def create_index(self):
+ def create_index(self) -> TimedeltaIndex:
return pd.to_timedelta(range(5), unit="d") + pd.offsets.Hour(1)
def test_numeric_compat(self):
| Makes ``test.indexes.common.Base`` and ``create_index`` a bit easier to work with. | https://api.github.com/repos/pandas-dev/pandas/pulls/32567 | 2020-03-09T22:26:59Z | 2020-03-10T11:09:21Z | 2020-03-10T11:09:20Z | 2020-03-10T11:09:31Z |
BUG: Fix segfault in csv tokenizer | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 21e59805fa143..36cfb4a904139 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -340,6 +340,7 @@ I/O
- Bug in :class:`HDFStore` that caused it to set to ``int64`` the dtype of a ``datetime64`` column when reading a DataFrame in Python 3 from fixed format written in Python 2 (:issue:`31750`)
- Bug in :meth:`read_excel` where a UTF-8 string with a high surrogate would cause a segmentation violation (:issue:`23809`)
- Bug in :meth:`read_csv` was causing a file descriptor leak on an empty file (:issue:`31488`)
+- Bug in :meth:`read_csv` was causing a segfault when there were blank lines between the header and data rows (:issue:`28071`)
Plotting
diff --git a/pandas/_libs/src/parser/tokenizer.c b/pandas/_libs/src/parser/tokenizer.c
index 2188ff6b0d464..7ba1a6cd398c9 100644
--- a/pandas/_libs/src/parser/tokenizer.c
+++ b/pandas/_libs/src/parser/tokenizer.c
@@ -1189,8 +1189,14 @@ int parser_consume_rows(parser_t *self, size_t nrows) {
/* cannot guarantee that nrows + 1 has been observed */
word_deletions = self->line_start[nrows - 1] + self->line_fields[nrows - 1];
- char_count = (self->word_starts[word_deletions - 1] +
- strlen(self->words[word_deletions - 1]) + 1);
+ if (word_deletions >= 1) {
+ char_count = (self->word_starts[word_deletions - 1] +
+ strlen(self->words[word_deletions - 1]) + 1);
+ } else {
+ /* if word_deletions == 0 (i.e. this case) then char_count must
+ * be 0 too, as no data needs to be skipped */
+ char_count = 0;
+ }
TRACE(("parser_consume_rows: Deleting %d words, %d chars\n", word_deletions,
char_count));
diff --git a/pandas/tests/io/parser/test_common.py b/pandas/tests/io/parser/test_common.py
index 33460262a4430..0f3a5be76ae60 100644
--- a/pandas/tests/io/parser/test_common.py
+++ b/pandas/tests/io/parser/test_common.py
@@ -2093,3 +2093,16 @@ def test():
parser.read_csv(path)
td.check_file_leaks(test)()
+
+
+@pytest.mark.parametrize("nrows", range(1, 6))
+def test_blank_lines_between_header_and_data_rows(all_parsers, nrows):
+ # GH 28071
+ ref = DataFrame(
+ [[np.nan, np.nan], [np.nan, np.nan], [1, 2], [np.nan, np.nan], [3, 4]],
+ columns=list("ab"),
+ )
+ csv = "\nheader\n\na,b\n\n\n1,2\n\n3,4"
+ parser = all_parsers
+ df = parser.read_csv(StringIO(csv), header=3, nrows=nrows, skip_blank_lines=False)
+ tm.assert_frame_equal(df, ref[:nrows])
| - [x] closes #28071
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32566 | 2020-03-09T22:07:06Z | 2020-03-16T02:21:30Z | 2020-03-16T02:21:29Z | 2020-03-16T20:08:32Z |
TST: Fix bare pytest raises in generic/test_frame.py | diff --git a/pandas/tests/generic/test_frame.py b/pandas/tests/generic/test_frame.py
index dca65152e82db..8fe49b2ec2299 100644
--- a/pandas/tests/generic/test_frame.py
+++ b/pandas/tests/generic/test_frame.py
@@ -72,9 +72,10 @@ def test_nonzero_single_element(self):
assert not df.bool()
df = DataFrame([[False, False]])
- with pytest.raises(ValueError):
+ msg = "The truth value of a DataFrame is ambiguous"
+ with pytest.raises(ValueError, match=msg):
df.bool()
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
bool(df)
def test_get_numeric_data_preserve_dtype(self):
@@ -189,30 +190,31 @@ class TestDataFrame2:
def test_validate_bool_args(self, value):
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
- with pytest.raises(ValueError):
+ msg = 'For argument "inplace" expected type bool, received type'
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df).rename_axis(
mapper={"a": "x", "b": "y"}, axis=1, inplace=value
)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df).drop("a", axis=1, inplace=value)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df)._consolidate(inplace=value)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df).fillna(value=0, inplace=value)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df).replace(to_replace=1, value=7, inplace=value)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df).interpolate(inplace=value)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df)._where(cond=df.a > 2, inplace=value)
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
super(DataFrame, df).mask(cond=df.a > 2, inplace=value)
def test_unexpected_keyword(self):
@@ -222,16 +224,17 @@ def test_unexpected_keyword(self):
ts = df["joe"].copy()
ts[2] = np.nan
- with pytest.raises(TypeError, match="unexpected keyword"):
+ msg = "unexpected keyword"
+ with pytest.raises(TypeError, match=msg):
df.drop("joe", axis=1, in_place=True)
- with pytest.raises(TypeError, match="unexpected keyword"):
+ with pytest.raises(TypeError, match=msg):
df.reindex([1, 0], inplace=True)
- with pytest.raises(TypeError, match="unexpected keyword"):
+ with pytest.raises(TypeError, match=msg):
ca.fillna(0, inplace=True)
- with pytest.raises(TypeError, match="unexpected keyword"):
+ with pytest.raises(TypeError, match=msg):
ts.fillna(0, in_place=True)
| - [x] refers https://github.com/pandas-dev/pandas/issues/30999
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
Adds match arguments to pytest.raises calls in pandas/tests/generic/test_frame.py
| https://api.github.com/repos/pandas-dev/pandas/pulls/32565 | 2020-03-09T20:34:14Z | 2020-03-10T10:37:29Z | 2020-03-10T10:37:29Z | 2020-03-10T10:37:41Z |
DOC: Add missing question mark icon | diff --git a/doc/source/_static/question_mark_noback.svg b/doc/source/_static/question_mark_noback.svg
new file mode 100644
index 0000000000000..3abb4b806d20a
--- /dev/null
+++ b/doc/source/_static/question_mark_noback.svg
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="6.1681423mm"
+ height="6.1681423mm"
+ viewBox="0 0 6.1681423 6.1681423"
+ version="1.1"
+ id="svg856"
+ inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
+ sodipodi:docname="question_mark_noback.svg">
+ <defs
+ id="defs850" />
+ <sodipodi:namedview
+ id="base"
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1.0"
+ inkscape:pageopacity="0.0"
+ inkscape:pageshadow="2"
+ inkscape:zoom="11.2"
+ inkscape:cx="4.3447038"
+ inkscape:cy="5.995975"
+ inkscape:document-units="mm"
+ inkscape:current-layer="layer1"
+ showgrid="false"
+ fit-margin-top="0"
+ fit-margin-left="0"
+ fit-margin-right="0"
+ fit-margin-bottom="0"
+ inkscape:window-width="1600"
+ inkscape:window-height="876"
+ inkscape:window-x="0"
+ inkscape:window-y="0"
+ inkscape:window-maximized="1" />
+ <metadata
+ id="metadata853">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title></dc:title>
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <g
+ inkscape:label="Layer 1"
+ inkscape:groupmode="layer"
+ id="layer1"
+ transform="translate(-71.755217,-98.124272)">
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-weight:normal;font-size:1.1868099px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458335"
+ x="73.403717"
+ y="103.38733"
+ id="text1405"><tspan
+ sodipodi:role="line"
+ id="tspan1403"
+ x="73.403717"
+ y="103.38733"
+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:5.6966877px;font-family:'Noto Sans Mono CJK HK';-inkscape-font-specification:'Noto Sans Mono CJK HK';fill:#ffffff;fill-opacity:1;stroke-width:0.26458335">?</tspan></text>
+ </g>
+</svg>
| - [x] closes #32469
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
I added the question mark to the `_static` folder. When rebuilding the documentation pages locally using the latest version of the `pydata-bootstrap-sphinx-theme`, the `div.highlight` seems to be styled correctly (`background: white`), removing the _strange green around the code block_.
| https://api.github.com/repos/pandas-dev/pandas/pulls/32564 | 2020-03-09T20:29:51Z | 2020-03-10T07:18:29Z | 2020-03-10T07:18:29Z | 2020-03-10T07:18:29Z |
Fix warning in io/excel/test_openpyxl | diff --git a/pandas/tests/io/excel/test_openpyxl.py b/pandas/tests/io/excel/test_openpyxl.py
index 10ed192062d9c..60c943d95e510 100644
--- a/pandas/tests/io/excel/test_openpyxl.py
+++ b/pandas/tests/io/excel/test_openpyxl.py
@@ -114,7 +114,7 @@ def test_to_excel_with_openpyxl_engine(ext, tmpdir):
df2 = DataFrame({"B": np.linspace(1, 20, 10)})
df = pd.concat([df1, df2], axis=1)
styled = df.style.applymap(
- lambda val: "color: %s" % "red" if val < 0 else "black"
+ lambda val: "color: %s" % ("red" if val < 0 else "black")
).highlight_max()
filename = tmpdir / "styled.xlsx"
| as requested in PR #32544 | https://api.github.com/repos/pandas-dev/pandas/pulls/32563 | 2020-03-09T20:28:59Z | 2020-03-10T11:17:12Z | 2020-03-10T11:17:12Z | 2020-03-11T15:47:52Z |
Ensure valid Block mutation in SeriesBinGrouper. | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 123dfa07f4331..bc234bbd31662 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -20,6 +20,7 @@ Fixed regressions
- Fixed regression in ``groupby(..).rolling(..).apply()`` (``RollingGroupby``) where the ``raw`` parameter was ignored (:issue:`31754`)
- Fixed regression in :meth:`rolling(..).corr() <pandas.core.window.rolling.Rolling.corr>` when using a time offset (:issue:`31789`)
- Fixed regression in :meth:`groupby(..).nunique() <pandas.core.groupby.DataFrameGroupBy.nunique>` which was modifying the original values if ``NaN`` values were present (:issue:`31950`)
+- Fixed regression in ``DataFrame.groupby`` raising a ``ValueError`` from an internal operation (:issue:`31802`)
- Fixed regression where :func:`read_pickle` raised a ``UnicodeDecodeError`` when reading a py27 pickle with :class:`MultiIndex` column (:issue:`31988`).
- Fixed regression in :class:`DataFrame` arithmetic operations with mis-matched columns (:issue:`31623`)
- Fixed regression in :meth:`groupby(..).agg() <pandas.core.groupby.GroupBy.agg>` calling a user-provided function an extra time on an empty input (:issue:`31760`)
diff --git a/pandas/_libs/reduction.pyx b/pandas/_libs/reduction.pyx
index b27072aa66708..29a5a73ef08d0 100644
--- a/pandas/_libs/reduction.pyx
+++ b/pandas/_libs/reduction.pyx
@@ -177,6 +177,8 @@ cdef class _BaseGrouper:
object.__setattr__(cached_ityp, '_index_data', islider.buf)
cached_ityp._engine.clear_mapping()
object.__setattr__(cached_typ._data._block, 'values', vslider.buf)
+ object.__setattr__(cached_typ._data._block, 'mgr_locs',
+ slice(len(vslider.buf)))
object.__setattr__(cached_typ, '_index', cached_ityp)
object.__setattr__(cached_typ, 'name', self.name)
diff --git a/pandas/tests/groupby/test_bin_groupby.py b/pandas/tests/groupby/test_bin_groupby.py
index ff74d374e5e3f..152086c241a52 100644
--- a/pandas/tests/groupby/test_bin_groupby.py
+++ b/pandas/tests/groupby/test_bin_groupby.py
@@ -5,6 +5,7 @@
from pandas.core.dtypes.common import ensure_int64
+import pandas as pd
from pandas import Index, Series, isna
import pandas._testing as tm
@@ -51,6 +52,30 @@ def test_series_bin_grouper():
tm.assert_almost_equal(counts, exp_counts)
+def assert_block_lengths(x):
+ assert len(x) == len(x._data.blocks[0].mgr_locs)
+ return 0
+
+
+def cumsum_max(x):
+ x.cumsum().max()
+ return 0
+
+
+@pytest.mark.parametrize("func", [cumsum_max, assert_block_lengths])
+def test_mgr_locs_updated(func):
+ # https://github.com/pandas-dev/pandas/issues/31802
+ # Some operations may require creating new blocks, which requires
+ # valid mgr_locs
+ df = pd.DataFrame({"A": ["a", "a", "a"], "B": ["a", "b", "b"], "C": [1, 1, 1]})
+ result = df.groupby(["A", "B"]).agg(func)
+ expected = pd.DataFrame(
+ {"C": [0, 0]},
+ index=pd.MultiIndex.from_product([["a"], ["a", "b"]], names=["A", "B"]),
+ )
+ tm.assert_frame_equal(result, expected)
+
+
@pytest.mark.parametrize(
"binner,closed,expected",
[
| Closes https://github.com/pandas-dev/pandas/issues/31802
~This "fixes" #31802 by expanding the number of cases where we swallow an
exception in libreduction. Currently, we're creating an invalid Series
in SeriesBinGrouper where the `.mgr_locs` doesn't match the values. See
https://github.com/pandas-dev/pandas/issues/31802#issuecomment-595954511
for more.~
~For now, we simply catch more cases that fall back to Python. I've gone
with a minimal change which addresses only issues hitting this exact
exception. We might want to go broader, but that's not clear.~
cc @jbrockmendel & @WillAyd | https://api.github.com/repos/pandas-dev/pandas/pulls/32561 | 2020-03-09T19:16:11Z | 2020-03-11T18:34:48Z | 2020-03-11T18:34:48Z | 2020-03-11T18:34:49Z |
TST: Add extra test for pandas.to_numeric() for issue #32394 | diff --git a/pandas/tests/tools/test_to_numeric.py b/pandas/tests/tools/test_to_numeric.py
index 19385e797467c..e0dfeac4ab475 100644
--- a/pandas/tests/tools/test_to_numeric.py
+++ b/pandas/tests/tools/test_to_numeric.py
@@ -627,3 +627,13 @@ def test_non_coerce_uint64_conflict(errors, exp):
else:
result = to_numeric(ser, errors=errors)
tm.assert_series_equal(result, ser)
+
+
+def test_failure_to_convert_uint64_string_to_NaN():
+ # GH 32394
+ result = to_numeric("uint64", errors="coerce")
+ assert np.isnan(result)
+
+ ser = Series([32, 64, np.nan])
+ result = to_numeric(pd.Series(["32", "64", "uint64"]), errors="coerce")
+ tm.assert_series_equal(result, ser)
| - [x] closes #32394
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry (covered by PR #32541)
| https://api.github.com/repos/pandas-dev/pandas/pulls/32560 | 2020-03-09T19:01:15Z | 2020-03-15T00:38:58Z | 2020-03-15T00:38:58Z | 2020-03-15T07:16:17Z |
BUG: pivot_table losing tz | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 85fe33b7c83e8..fe9715313f0db 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -367,6 +367,7 @@ Reshaping
- :meth:`Series.append` will now raise a ``TypeError`` when passed a DataFrame or a sequence containing Dataframe (:issue:`31413`)
- :meth:`DataFrame.replace` and :meth:`Series.replace` will raise a ``TypeError`` if ``to_replace`` is not an expected type. Previously the ``replace`` would fail silently (:issue:`18634`)
- Bug in :meth:`DataFrame.apply` where callback was called with :class:`Series` parameter even though ``raw=True`` requested. (:issue:`32423`)
+- Bug in :meth:`DataFrame.pivot_table` losing timezone information when creating a :class:`MultiIndex` level from a column with timezone-aware dtype (:issue:`32558`)
Sparse
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 122097f4478d7..5bffc4ec552af 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -565,6 +565,7 @@ def from_product(cls, iterables, sortorder=None, names=lib.no_default):
if names is lib.no_default:
names = [getattr(it, "name", None) for it in iterables]
+ # codes are all ndarrays, so cartesian_product is lossless
codes = cartesian_product(codes)
return MultiIndex(levels, codes, sortorder=sortorder, names=names)
diff --git a/pandas/core/reshape/util.py b/pandas/core/reshape/util.py
index d8652c9b4fac9..7abb14303f8cc 100644
--- a/pandas/core/reshape/util.py
+++ b/pandas/core/reshape/util.py
@@ -2,8 +2,6 @@
from pandas.core.dtypes.common import is_list_like
-import pandas.core.common as com
-
def cartesian_product(X):
"""
@@ -51,9 +49,20 @@ def cartesian_product(X):
# if any factor is empty, the cartesian product is empty
b = np.zeros_like(cumprodX)
- return [
- np.tile(
- np.repeat(np.asarray(com.values_from_object(x)), b[i]), np.product(a[i])
- )
- for i, x in enumerate(X)
- ]
+ return [_tile_compat(np.repeat(x, b[i]), np.product(a[i])) for i, x in enumerate(X)]
+
+
+def _tile_compat(arr, num: int):
+ """
+ Index compat for np.tile.
+
+ Notes
+ -----
+ Does not support multi-dimensional `num`.
+ """
+ if isinstance(arr, np.ndarray):
+ return np.tile(arr, num)
+
+ # Otherwise we have an Index
+ taker = np.tile(np.arange(len(arr)), num)
+ return arr.take(taker)
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index 75c3c565e9d58..cdb1a73abc431 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -1026,6 +1026,14 @@ def test_pivot_table_multiindex_only(self, cols):
tm.assert_frame_equal(result, expected)
+ def test_pivot_table_retains_tz(self):
+ dti = date_range("2016-01-01", periods=3, tz="Europe/Amsterdam")
+ df = DataFrame({"A": np.random.randn(3), "B": np.random.randn(3), "C": dti})
+ result = df.pivot_table(index=["B", "C"], dropna=False)
+
+ # check tz retention
+ assert result.index.levels[1].equals(dti)
+
def test_pivot_integer_columns(self):
# caused by upstream bug in unstack
diff --git a/pandas/tests/reshape/test_util.py b/pandas/tests/reshape/test_util.py
index cd518dda4edbf..9d074b5ade425 100644
--- a/pandas/tests/reshape/test_util.py
+++ b/pandas/tests/reshape/test_util.py
@@ -25,6 +25,22 @@ def test_datetimeindex(self):
tm.assert_index_equal(result1, expected1)
tm.assert_index_equal(result2, expected2)
+ def test_tzaware_retained(self):
+ x = date_range("2000-01-01", periods=2, tz="US/Pacific")
+ y = np.array([3, 4])
+ result1, result2 = cartesian_product([x, y])
+
+ expected = x.repeat(2)
+ tm.assert_index_equal(result1, expected)
+
+ def test_tzaware_retained_categorical(self):
+ x = date_range("2000-01-01", periods=2, tz="US/Pacific").astype("category")
+ y = np.array([3, 4])
+ result1, result2 = cartesian_product([x, y])
+
+ expected = x.repeat(2)
+ tm.assert_index_equal(result1, expected)
+
def test_empty(self):
# product of empty factors
X = [[], [0, 1], []]
| - [ ] closes #xxxx
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
This gets rid of the last values_from_object usage (pending other PRs)
`_tile_compat` likely makes more sense as an Index method. I kept it here as a proof of concept because I think we actually need it in the EA interface too. Being able to broadcast a length=1 EA to a length=N EA will be necessary for some of the arithmetic perf going on. | https://api.github.com/repos/pandas-dev/pandas/pulls/32558 | 2020-03-09T18:46:52Z | 2020-03-14T23:28:54Z | 2020-03-14T23:28:54Z | 2020-03-14T23:31:12Z |
CLN: values_from_object in computation.pytables | diff --git a/pandas/core/computation/pytables.py b/pandas/core/computation/pytables.py
index 653d014775386..15d9987310f18 100644
--- a/pandas/core/computation/pytables.py
+++ b/pandas/core/computation/pytables.py
@@ -17,6 +17,7 @@
from pandas.core.computation.common import _ensure_decoded
from pandas.core.computation.expr import BaseExprVisitor
from pandas.core.computation.ops import UndefinedVariableError, is_term
+from pandas.core.construction import extract_array
from pandas.io.formats.printing import pprint_thing, pprint_thing_encoded
@@ -202,7 +203,7 @@ def stringify(value):
v = Timedelta(v, unit="s").value
return TermValue(int(v), v, kind)
elif meta == "category":
- metadata = com.values_from_object(self.metadata)
+ metadata = extract_array(self.metadata, extract_numpy=True)
result = metadata.searchsorted(v, side="left")
# result returns 0 if v is first element or if v is not in metadata
| By my count there is just one more `values_from_object` call to go. | https://api.github.com/repos/pandas-dev/pandas/pulls/32557 | 2020-03-09T18:30:47Z | 2020-03-11T02:33:14Z | 2020-03-11T02:33:14Z | 2020-03-11T02:34:56Z |
CLN: avoid _internal_get_values in Categorical.__iter__ | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 40a169d03f39c..7846941ce79d4 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -31,6 +31,7 @@
is_integer_dtype,
is_iterator,
is_list_like,
+ is_numeric_dtype,
is_object_dtype,
is_scalar,
is_sequence,
@@ -1878,7 +1879,10 @@ def __iter__(self):
"""
Returns an Iterator over the values of this Categorical.
"""
- return iter(self._internal_get_values().tolist())
+ if is_numeric_dtype(self.categories):
+ # Convert numpy scalars to python scalars
+ return (self[i].item() for i in range(len(self)))
+ return (self[i] for i in range(len(self)))
def __contains__(self, key) -> bool:
"""
| https://api.github.com/repos/pandas-dev/pandas/pulls/32555 | 2020-03-09T17:23:13Z | 2020-03-11T23:45:21Z | null | 2020-03-11T23:45:34Z | |
CLN: remove Categorical.put | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 92859479ec73f..ba4c2e168e0c4 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1409,12 +1409,6 @@ def notna(self):
notnull = notna
- def put(self, *args, **kwargs):
- """
- Replace specific elements in the Categorical with given values.
- """
- raise NotImplementedError(("'put' is not yet implemented for Categorical"))
-
def dropna(self):
"""
Return the Categorical without null values.
| https://api.github.com/repos/pandas-dev/pandas/pulls/32554 | 2020-03-09T17:16:17Z | 2020-03-09T21:27:57Z | 2020-03-09T21:27:57Z | 2020-03-09T21:28:30Z | |
Backport PR #32242 on branch 1.0.x (BUG: Fixed bug, where pandas._libs.lib.maybe_convert_objects function improperly handled arrays with bools and NaNs) | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 808e6ae709ce9..eec471f989037 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -24,6 +24,7 @@ Fixed regressions
- Fixed regression in :class:`DataFrame` arithmetic operations with mis-matched columns (:issue:`31623`)
- Fixed regression in :meth:`GroupBy.agg` calling a user-provided function an extra time on an empty input (:issue:`31760`)
- Joining on :class:`DatetimeIndex` or :class:`TimedeltaIndex` will preserve ``freq`` in simple cases (:issue:`32166`)
+- Fixed bug in the repr of an object-dtype ``Index`` with bools and missing values (:issue:`32146`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 3f98a479bc587..87d9394be555d 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -2235,7 +2235,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
return uints
else:
return ints
- elif seen.is_bool:
+ elif seen.is_bool and not seen.nan_:
return bools.view(np.bool_)
return objects
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 63c484f5ea68f..b148fc57f0bb6 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -568,6 +568,13 @@ def test_maybe_convert_objects_nullable_integer(self, exp):
tm.assert_extension_array_equal(result, exp)
+ def test_maybe_convert_objects_bool_nan(self):
+ # GH32146
+ ind = pd.Index([True, False, np.nan], dtype=object)
+ exp = np.array([True, False, np.nan], dtype=object)
+ out = lib.maybe_convert_objects(ind.values, safe=1)
+ tm.assert_numpy_array_equal(out, exp)
+
def test_mixed_dtypes_remain_object_array(self):
# GH14956
array = np.array([datetime(2015, 1, 1, tzinfo=pytz.utc), 1], dtype=object)
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index eec1ea68b55e2..7b2a73287cb38 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -2697,6 +2697,17 @@ def test_intersect_str_dates(self):
expected = Index([], dtype=object)
tm.assert_index_equal(result, expected)
+ def test_index_repr_bool_nan(self):
+ # GH32146
+ arr = Index([True, False, np.nan], dtype=object)
+ exp1 = arr.format()
+ out1 = ["True", "False", "NaN"]
+ assert out1 == exp1
+
+ exp2 = repr(arr)
+ out2 = "Index([True, False, nan], dtype='object')"
+ assert out2 == exp2
+
class TestIndexUtils:
@pytest.mark.parametrize(
diff --git a/pandas/tests/series/methods/test_value_counts.py b/pandas/tests/series/methods/test_value_counts.py
index fdb35befeb0c2..f97362ce9c2a9 100644
--- a/pandas/tests/series/methods/test_value_counts.py
+++ b/pandas/tests/series/methods/test_value_counts.py
@@ -1,4 +1,5 @@
import numpy as np
+import pytest
import pandas as pd
from pandas import Categorical, CategoricalIndex, Series
@@ -177,3 +178,28 @@ def test_value_counts_categorical_with_nan(self):
exp = Series([2, 1, 3], index=CategoricalIndex(["a", "b", np.nan]))
res = ser.value_counts(dropna=False, sort=False)
tm.assert_series_equal(res, exp)
+
+ @pytest.mark.parametrize(
+ "ser, dropna, exp",
+ [
+ (
+ pd.Series([False, True, True, pd.NA]),
+ False,
+ pd.Series([2, 1, 1], index=[True, False, pd.NA]),
+ ),
+ (
+ pd.Series([False, True, True, pd.NA]),
+ True,
+ pd.Series([2, 1], index=[True, False]),
+ ),
+ (
+ pd.Series(range(3), index=[True, False, np.nan]).index,
+ False,
+ pd.Series([1, 1, 1], index=[True, False, pd.NA]),
+ ),
+ ],
+ )
+ def test_value_counts_bool_with_nan(self, ser, dropna, exp):
+ # GH32146
+ out = ser.value_counts(dropna=dropna)
+ tm.assert_series_equal(out, exp)
| Backport PR #32242: BUG: Fixed bug, where pandas._libs.lib.maybe_convert_objects function improperly handled arrays with bools and NaNs | https://api.github.com/repos/pandas-dev/pandas/pulls/32552 | 2020-03-09T15:42:45Z | 2020-03-10T16:22:32Z | 2020-03-10T16:22:31Z | 2020-03-10T16:22:32Z |
DOC: Fix EX01 in pandas.DataFrame.idxmax | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index cd5d81bc70dd9..60fc69e8222d6 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -8029,6 +8029,35 @@ def idxmax(self, axis=0, skipna=True) -> Series:
Notes
-----
This method is the DataFrame version of ``ndarray.argmax``.
+
+ Examples
+ --------
+ Consider a dataset containing food consumption in Argentina.
+
+ >>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
+ ... 'co2_emissions': [37.2, 19.66, 1712]},
+ ... index=['Pork', 'Wheat Products', 'Beef'])
+
+ >>> df
+ consumption co2_emissions
+ Pork 10.51 37.20
+ Wheat Products 103.11 19.66
+ Beef 55.48 1712.00
+
+ By default, it returns the index for the maximum value in each column.
+
+ >>> df.idxmax()
+ consumption Wheat Products
+ co2_emissions Beef
+ dtype: object
+
+ To return the index for the maximum value in each row, use ``axis="columns"``.
+
+ >>> df.idxmax(axis="columns")
+ Pork co2_emissions
+ Wheat Products consumption
+ Beef co2_emissions
+ dtype: object
"""
axis = self._get_axis_number(axis)
indices = nanops.nanargmax(self.values, axis=axis, skipna=skipna)
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
Related to #27977.
```
################################################################################
################################## Validation ##################################
################################################################################ | https://api.github.com/repos/pandas-dev/pandas/pulls/32551 | 2020-03-09T05:53:51Z | 2020-03-11T01:35:50Z | 2020-03-11T01:35:50Z | 2020-03-11T01:35:56Z |
DOC: Added docstring for Series.name and corrected docstring guide | diff --git a/doc/source/development/contributing_docstring.rst b/doc/source/development/contributing_docstring.rst
index 1c99b341f6c5a..18c2769d7ca4b 100644
--- a/doc/source/development/contributing_docstring.rst
+++ b/doc/source/development/contributing_docstring.rst
@@ -17,7 +17,7 @@ Also, it is a common practice to generate online (html) documentation
automatically from docstrings. `Sphinx <https://www.sphinx-doc.org>`_ serves
this purpose.
-Next example gives an idea on how a docstring looks like:
+The next example gives an idea of what a docstring looks like:
.. code-block:: python
@@ -26,8 +26,8 @@ Next example gives an idea on how a docstring looks like:
Add up two integer numbers.
This function simply wraps the `+` operator, and does not
- do anything interesting, except for illustrating what is
- the docstring of a very simple function.
+ do anything interesting, except for illustrating what
+ the docstring of a very simple function looks like.
Parameters
----------
@@ -56,14 +56,14 @@ Next example gives an idea on how a docstring looks like:
"""
return num1 + num2
-Some standards exist about docstrings, so they are easier to read, and they can
-be exported to other formats such as html or pdf.
+Some standards regarding docstrings exist, which make them easier to read, and allow them
+be easily exported to other formats such as html or pdf.
The first conventions every Python docstring should follow are defined in
`PEP-257 <https://www.python.org/dev/peps/pep-0257/>`_.
-As PEP-257 is quite open, and some other standards exist on top of it. In the
-case of pandas, the numpy docstring convention is followed. The conventions is
+As PEP-257 is quite broad, other more specific standards also exist. In the
+case of pandas, the numpy docstring convention is followed. These conventions are
explained in this document:
* `numpydoc docstring guide <https://numpydoc.readthedocs.io/en/latest/format.html>`_
@@ -83,8 +83,8 @@ about reStructuredText can be found in:
Pandas has some helpers for sharing docstrings between related classes, see
:ref:`docstring.sharing`.
-The rest of this document will summarize all the above guides, and will
-provide additional convention specific to the pandas project.
+The rest of this document will summarize all the above guidelines, and will
+provide additional conventions specific to the pandas project.
.. _docstring.tutorial:
@@ -101,9 +101,9 @@ left before or after the docstring. The text starts in the next line after the
opening quotes. The closing quotes have their own line
(meaning that they are not at the end of the last sentence).
-In rare occasions reST styles like bold text or italics will be used in
+On rare occasions reST styles like bold text or italics will be used in
docstrings, but is it common to have inline code, which is presented between
-backticks. It is considered inline code:
+backticks. The following are considered inline code:
* The name of a parameter
* Python code, a module, function, built-in, type, literal... (e.g. ``os``,
@@ -235,8 +235,8 @@ The extended summary provides details on what the function does. It should not
go into the details of the parameters, or discuss implementation notes, which
go in other sections.
-A blank line is left between the short summary and the extended summary. And
-every paragraph in the extended summary is finished by a dot.
+A blank line is left between the short summary and the extended summary.
+Every paragraph in the extended summary ends with a dot.
The extended summary should provide details on why the function is useful and
their use cases, if it is not too generic.
@@ -542,19 +542,19 @@ first (not an alias like ``np``). If the function is in a module which is not
the main one, like ``scipy.sparse``, list the full module (e.g.
``scipy.sparse.coo_matrix``).
-This section, as the previous, also has a header, "See Also" (note the capital
-S and A). Also followed by the line with hyphens, and preceded by a blank line.
+This section has a header, "See Also" (note the capital
+S and A), followed by the line with hyphens and preceded by a blank line.
After the header, we will add a line for each related method or function,
followed by a space, a colon, another space, and a short description that
-illustrated what this method or function does, why is it relevant in this
-context, and what are the key differences between the documented function and
-the one referencing. The description must also finish with a dot.
+illustrates what this method or function does, why is it relevant in this
+context, and what the key differences are between the documented function and
+the one being referenced. The description must also end with a dot.
-Note that in "Returns" and "Yields", the description is located in the
-following line than the type. But in this section it is located in the same
-line, with a colon in between. If the description does not fit in the same
-line, it can continue in the next ones, but it has to be indented in them.
+Note that in "Returns" and "Yields", the description is located on the line
+after the type. In this section, however, it is located on the same
+line, with a colon in between. If the description does not fit on the same
+line, it can continue onto other lines which must be further indented.
For example:
@@ -587,7 +587,7 @@ Section 6: Notes
~~~~~~~~~~~~~~~~
This is an optional section used for notes about the implementation of the
-algorithm. Or to document technical aspects of the function behavior.
+algorithm, or to document technical aspects of the function behavior.
Feel free to skip it, unless you are familiar with the implementation of the
algorithm, or you discover some counter-intuitive behavior while writing the
@@ -600,15 +600,15 @@ This section follows the same format as the extended summary section.
Section 7: Examples
~~~~~~~~~~~~~~~~~~~
-This is one of the most important sections of a docstring, even if it is
-placed in the last position. As often, people understand concepts better
-with examples, than with accurate explanations.
+This is one of the most important sections of a docstring, despite being
+placed in the last position, as often people understand concepts better
+by example than through accurate explanations.
Examples in docstrings, besides illustrating the usage of the function or
-method, must be valid Python code, that in a deterministic way returns the
-presented output, and that can be copied and run by users.
+method, must be valid Python code, that returns the given output in a
+deterministic way, and that can be copied and run by users.
-They are presented as a session in the Python terminal. `>>>` is used to
+Examples are presented as a session in the Python terminal. `>>>` is used to
present code. `...` is used for code continuing from the previous line.
Output is presented immediately after the last line of code generating the
output (no blank lines in between). Comments describing the examples can
@@ -636,7 +636,7 @@ A simple example could be:
Return the first elements of the Series.
This function is mainly useful to preview the values of the
- Series without displaying the whole of it.
+ Series without displaying all of it.
Parameters
----------
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 568e99622dd29..ae7251db10fe7 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -435,6 +435,52 @@ def dtypes(self) -> DtypeObj:
@property
def name(self) -> Label:
+ """
+ Return the name of the Series.
+
+ The name of a Series becomes its index or column name if it is used
+ to form a DataFrame. It is also used whenever displaying the Series
+ using the interpreter.
+
+ Returns
+ -------
+ label (hashable object)
+ The name of the Series, also the column name if part of a DataFrame.
+
+ See Also
+ --------
+ Series.rename : Sets the Series name when given a scalar input.
+ Index.name : Corresponding Index property.
+
+ Examples
+ --------
+ The Series name can be set initially when calling the constructor.
+
+ >>> s = pd.Series([1, 2, 3], dtype=np.int64, name='Numbers')
+ >>> s
+ 0 1
+ 1 2
+ 2 3
+ Name: Numbers, dtype: int64
+ >>> s.name = "Integers"
+ >>> s
+ 0 1
+ 1 2
+ 2 3
+ Name: Integers, dtype: int64
+
+ The name of a Series within a DataFrame is its column name.
+
+ >>> df = pd.DataFrame([[1, 2], [3, 4], [5, 6]],
+ ... columns=["Odd Numbers", "Even Numbers"])
+ >>> df
+ Odd Numbers Even Numbers
+ 0 1 2
+ 1 3 4
+ 2 5 6
+ >>> df["Even Numbers"].name
+ 'Even Numbers'
+ """
return self._name
@name.setter
| The main contribution is to add a docstring with examples for the "name" property of the Series object. Also corrected some typos and grammatical points in the "pandas docstring guide".
The type hint gives the type as "Label" and I could not find any other reference to a custom type defined in pandas._typing which was explicitly mentioned in the docs (instead they specify "str" or "int" or somesuch), so I chose "Label (int, str or other hashable object)".
Further I chose "whenever displaying the Series in the interpreter" as clearer alternative to "when invoking the __repr__ method" or a similar precise statement. | https://api.github.com/repos/pandas-dev/pandas/pulls/32549 | 2020-03-08T21:54:37Z | 2020-03-17T00:07:36Z | 2020-03-17T00:07:36Z | 2020-03-17T00:07:43Z |
BUG: Add extra check for failing UTF-8 conversion | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index d644a995a4876..5d962ff04464e 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -302,6 +302,7 @@ I/O
timestamps with ``version="2.0"`` (:issue:`31652`).
- Bug in :meth:`read_csv` was raising `TypeError` when `sep=None` was used in combination with `comment` keyword (:issue:`31396`)
- Bug in :class:`HDFStore` that caused it to set to ``int64`` the dtype of a ``datetime64`` column when reading a DataFrame in Python 3 from fixed format written in Python 2 (:issue:`31750`)
+- Bug in :meth:`read_excel` where a UTF-8 string with a high surrogate would cause a segmentation violation (:issue:`23809`)
Plotting
diff --git a/pandas/_libs/src/parse_helper.h b/pandas/_libs/src/parse_helper.h
index 7fbe7a04d5b22..2ada0a4bd173d 100644
--- a/pandas/_libs/src/parse_helper.h
+++ b/pandas/_libs/src/parse_helper.h
@@ -34,6 +34,9 @@ int floatify(PyObject *str, double *result, int *maybe_int) {
data = PyBytes_AS_STRING(str);
} else if (PyUnicode_Check(str)) {
tmp = PyUnicode_AsUTF8String(str);
+ if (tmp == NULL) {
+ return -1;
+ }
data = PyBytes_AS_STRING(tmp);
} else {
PyErr_SetString(PyExc_TypeError, "Invalid object type");
diff --git a/pandas/tests/io/data/excel/high_surrogate.xlsx b/pandas/tests/io/data/excel/high_surrogate.xlsx
new file mode 100644
index 0000000000000..1e29b6bee6586
Binary files /dev/null and b/pandas/tests/io/data/excel/high_surrogate.xlsx differ
diff --git a/pandas/tests/io/excel/test_readers.py b/pandas/tests/io/excel/test_readers.py
index a59b409809eed..cbc043820e35e 100644
--- a/pandas/tests/io/excel/test_readers.py
+++ b/pandas/tests/io/excel/test_readers.py
@@ -1044,3 +1044,11 @@ def test_excel_read_binary(self, engine, read_ext):
actual = pd.read_excel(data, engine=engine)
tm.assert_frame_equal(expected, actual)
+
+ def test_excel_high_surrogate(self, engine):
+ # GH 23809
+ expected = pd.DataFrame(["\udc88"], columns=["Column1"])
+
+ # should not produce a segmentation violation
+ actual = pd.read_excel("high_surrogate.xlsx")
+ tm.assert_frame_equal(expected, actual)
| - [x] closes #23809
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32548 | 2020-03-08T21:35:41Z | 2020-03-12T00:54:07Z | 2020-03-12T00:54:07Z | 2020-03-12T21:36:19Z |
CLN: remove unnecessary values_from_objects in groupby.ops | diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 7259268ac3f2b..577c874c9cbbe 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -217,7 +217,7 @@ def indices(self):
return self.groupings[0].indices
else:
codes_list = [ping.codes for ping in self.groupings]
- keys = [com.values_from_object(ping.group_index) for ping in self.groupings]
+ keys = [ping.group_index for ping in self.groupings]
return get_indexer_dict(codes_list, keys)
@property
| 2 values_from_object calls left to go... | https://api.github.com/repos/pandas-dev/pandas/pulls/32547 | 2020-03-08T21:19:39Z | 2020-03-11T02:32:41Z | 2020-03-11T02:32:41Z | 2020-03-11T02:49:54Z |
BUG: Dataframe.groupby aggregations with categorical columns lead to incorrect results. | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 92f7c0f6b59a3..0aa5538c92482 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -976,6 +976,7 @@ Groupby/resample/rolling
- Bug in :meth:`GroupBy.apply` raises ``ValueError`` when the ``by`` axis is not sorted and has duplicates and the applied ``func`` does not mutate passed in objects (:issue:`30667`)
- Bug in :meth:`DataFrameGroupby.transform` produces incorrect result with transformation functions (:issue:`30918`)
+- Bug in :meth:`Groupby.transform` was returning the wrong result when grouping by multiple keys of which some were categorical and others not (:issue:`32494`)
- Bug in :meth:`GroupBy.count` causes segmentation fault when grouped-by column contains NaNs (:issue:`32841`)
- Bug in :meth:`DataFrame.groupby` and :meth:`Series.groupby` produces inconsistent type when aggregating Boolean series (:issue:`32894`)
- Bug in :meth:`DataFrameGroupBy.sum` and :meth:`SeriesGroupBy.sum` where a large negative number would be returned when the number of non-null values was below ``min_count`` for nullable integer dtypes (:issue:`32861`)
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 5894066dd33c8..db5df9818b0b0 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -546,6 +546,7 @@ def _transform_fast(self, result, func_nm: str) -> Series:
builtin/cythonizable functions
"""
ids, _, ngroup = self.grouper.group_info
+ result = result.reindex(self.grouper.result_index, copy=False)
cast = self._transform_should_cast(func_nm)
out = algorithms.take_1d(result._values, ids)
if cast:
@@ -1496,6 +1497,7 @@ def _transform_fast(self, result: DataFrame, func_nm: str) -> DataFrame:
# for each col, reshape to to size of original frame
# by take operation
ids, _, ngroup = self.grouper.group_info
+ result = result.reindex(self.grouper.result_index, copy=False)
output = []
for i, _ in enumerate(result.columns):
res = algorithms.take_1d(result.iloc[:, i].values, ids)
diff --git a/pandas/tests/groupby/transform/test_transform.py b/pandas/tests/groupby/transform/test_transform.py
index e7bc3801a08a7..fd4ee2a81ebd8 100644
--- a/pandas/tests/groupby/transform/test_transform.py
+++ b/pandas/tests/groupby/transform/test_transform.py
@@ -1205,3 +1205,36 @@ def test_transform_lambda_indexing():
),
)
tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_and_not_categorical_key(observed):
+ # Checks that groupby-transform, when grouping by both a categorical
+ # and a non-categorical key, doesn't try to expand the output to include
+ # non-observed categories but instead matches the input shape.
+ # GH 32494
+ df_with_categorical = pd.DataFrame(
+ {
+ "A": pd.Categorical(["a", "b", "a"], categories=["a", "b", "c"]),
+ "B": [1, 2, 3],
+ "C": ["a", "b", "a"],
+ }
+ )
+ df_without_categorical = pd.DataFrame(
+ {"A": ["a", "b", "a"], "B": [1, 2, 3], "C": ["a", "b", "a"]}
+ )
+
+ # DataFrame case
+ result = df_with_categorical.groupby(["A", "C"], observed=observed).transform("sum")
+ expected = df_without_categorical.groupby(["A", "C"]).transform("sum")
+ tm.assert_frame_equal(result, expected)
+ expected_explicit = pd.DataFrame({"B": [4, 2, 4]})
+ tm.assert_frame_equal(result, expected_explicit)
+
+ # Series case
+ result = df_with_categorical.groupby(["A", "C"], observed=observed)["B"].transform(
+ "sum"
+ )
+ expected = df_without_categorical.groupby(["A", "C"])["B"].transform("sum")
+ tm.assert_series_equal(result, expected)
+ expected_explicit = pd.Series([4, 2, 4], name="B")
+ tm.assert_series_equal(result, expected_explicit)
| - [x] closes #32494
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32546 | 2020-03-08T19:51:00Z | 2020-06-14T15:02:05Z | 2020-06-14T15:02:05Z | 2020-06-14T16:31:04Z |
CLN: to_dense->np.asarray | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 40a169d03f39c..92859479ec73f 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1728,7 +1728,8 @@ def fillna(self, value=None, method=None, limit=None):
# pad / bfill
if method is not None:
- values = self.to_dense().reshape(-1, len(self))
+ # TODO: dispatch when self.categories is EA-dtype
+ values = np.asarray(self).reshape(-1, len(self))
values = interpolate_2d(values, method, 0, None, value).astype(
self.categories.dtype
)[0]
| This is the only non-test use of Categorical.to_dense, which is slightly different from _internal_get_values (for SparseArray the two methods are identical), and so liable to cause confusion. | https://api.github.com/repos/pandas-dev/pandas/pulls/32545 | 2020-03-08T19:41:28Z | 2020-03-09T13:47:45Z | 2020-03-09T13:47:45Z | 2020-03-09T16:38:51Z |
BUG: pd.ExcelFile closes stream on destruction | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index e6d65b1f828cb..052de47b570da 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -28,6 +28,7 @@ Fixed regressions
- Fixed regression in the repr of an object-dtype :class:`Index` with bools and missing values (:issue:`32146`)
- Fixed regression in :meth:`read_csv` in which the ``encoding`` option was not recognized with certain file-like objects (:issue:`31819`)
- Fixed regression in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with (tz-aware) index and ``method=nearest`` (:issue:`26683`)
+- Fixed regression in :class:`ExcelFile` where the stream passed into the function was closed by the destructor. (:issue:`31467`)
- Fixed regression in :meth:`DataFrame.reindex_like` on a :class:`DataFrame` subclass raised an ``AssertionError`` (:issue:`31925`)
- Fixed regression in :meth:`Series.shift` with ``datetime64`` dtype when passing an integer ``fill_value`` (:issue:`32591`)
diff --git a/pandas/io/excel/_base.py b/pandas/io/excel/_base.py
index f98d9501f1f73..d1139f640cef4 100644
--- a/pandas/io/excel/_base.py
+++ b/pandas/io/excel/_base.py
@@ -366,6 +366,9 @@ def _workbook_class(self):
def load_workbook(self, filepath_or_buffer):
pass
+ def close(self):
+ pass
+
@property
@abc.abstractmethod
def sheet_names(self):
@@ -895,14 +898,7 @@ def sheet_names(self):
def close(self):
"""close io if necessary"""
- if self.engine == "openpyxl":
- # https://stackoverflow.com/questions/31416842/
- # openpyxl-does-not-close-excel-workbook-in-read-only-mode
- wb = self.book
- wb._archive.close()
-
- if hasattr(self.io, "close"):
- self.io.close()
+ self._reader.close()
def __enter__(self):
return self
diff --git a/pandas/io/excel/_openpyxl.py b/pandas/io/excel/_openpyxl.py
index a96c0f814e2d8..0696d82e51f34 100644
--- a/pandas/io/excel/_openpyxl.py
+++ b/pandas/io/excel/_openpyxl.py
@@ -492,6 +492,11 @@ def load_workbook(self, filepath_or_buffer: FilePathOrBuffer):
filepath_or_buffer, read_only=True, data_only=True, keep_links=False
)
+ def close(self):
+ # https://stackoverflow.com/questions/31416842/
+ # openpyxl-does-not-close-excel-workbook-in-read-only-mode
+ self.book.close()
+
@property
def sheet_names(self) -> List[str]:
return self.book.sheetnames
diff --git a/pandas/tests/io/excel/test_readers.py b/pandas/tests/io/excel/test_readers.py
index cbc043820e35e..8732d4063d74c 100644
--- a/pandas/tests/io/excel/test_readers.py
+++ b/pandas/tests/io/excel/test_readers.py
@@ -629,6 +629,17 @@ def test_read_from_py_localpath(self, read_ext):
tm.assert_frame_equal(expected, actual)
+ @td.check_file_leaks
+ def test_close_from_py_localpath(self, read_ext):
+
+ # GH31467
+ str_path = os.path.join("test1" + read_ext)
+ with open(str_path, "rb") as f:
+ x = pd.read_excel(f, "Sheet1", index_col=0)
+ del x
+ # should not throw an exception because the passed file was closed
+ f.read()
+
def test_reader_seconds(self, read_ext):
if pd.read_excel.keywords["engine"] == "pyxlsb":
pytest.xfail("Sheets containing datetimes not supported by pyxlsb")
@@ -1020,10 +1031,10 @@ def test_excel_read_buffer(self, engine, read_ext):
tm.assert_frame_equal(expected, actual)
def test_reader_closes_file(self, engine, read_ext):
- f = open("test1" + read_ext, "rb")
- with pd.ExcelFile(f) as xlsx:
- # parses okay
- pd.read_excel(xlsx, "Sheet1", index_col=0, engine=engine)
+ with open("test1" + read_ext, "rb") as f:
+ with pd.ExcelFile(f) as xlsx:
+ # parses okay
+ pd.read_excel(xlsx, "Sheet1", index_col=0, engine=engine)
assert f.closed
| - [x] closes #31467
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32544 | 2020-03-08T19:14:23Z | 2020-03-12T12:18:21Z | 2020-03-12T12:18:21Z | 2020-03-12T21:35:56Z |
ENH: Add `replace` method to `Index` | diff --git a/doc/source/whatsnew/v1.2.1.rst b/doc/source/whatsnew/v1.2.1.rst
index 24ba9be4383eb..276b015450212 100644
--- a/doc/source/whatsnew/v1.2.1.rst
+++ b/doc/source/whatsnew/v1.2.1.rst
@@ -61,6 +61,7 @@ Other
- Bumped minimum pymysql version to 0.8.1 to avoid test failures (:issue:`38344`)
- Fixed build failure on MacOS 11 in Python 3.9.1 (:issue:`38766`)
- Added reference to backwards incompatible ``check_freq`` arg of :func:`testing.assert_frame_equal` and :func:`testing.assert_series_equal` in :ref:`pandas 1.1.0 whats new <whatsnew_110.api_breaking.testing.check_freq>` (:issue:`34050`)
+- :class:`Index` and :class:`MultiIndex` now have a ``replace()`` method (:issue:`19495`).
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 0b46b43514d92..a89d5c23ee998 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -98,6 +98,7 @@
from pandas.core.indexes.frozen import FrozenList
from pandas.core.ops import get_op_result_name
from pandas.core.ops.invalid import make_invalid_op
+from pandas.core.shared_docs import _shared_docs
from pandas.core.sorting import ensure_key_mapped, nargsort
from pandas.core.strings import StringMethods
@@ -124,6 +125,7 @@
"raises_section": "",
"unique": "Index",
"duplicated": "np.ndarray",
+ "replace_iloc": "",
}
_index_shared_docs = {}
str_t = str
@@ -1536,6 +1538,27 @@ def rename(self, name, inplace=False):
"""
return self.set_names([name], inplace=inplace)
+ @doc(
+ _shared_docs["replace"],
+ klass=_index_doc_kwargs["klass"],
+ inplace=_index_doc_kwargs["inplace"],
+ replace_iloc=_index_doc_kwargs["replace_iloc"],
+ )
+ def replace(
+ self,
+ to_replace=None,
+ value=None,
+ limit=None,
+ regex=False,
+ method="pad",
+ ):
+ new_index = self.to_series().replace(
+ to_replace=to_replace, value=value, limit=limit, regex=regex, method=method
+ )
+ new_index = Index(new_index)
+
+ return new_index
+
# --------------------------------------------------------------------
# Level-Centric Methods
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index a8a872ff38fb8..4b85864c455f1 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -628,3 +628,24 @@ def _delegate_method(self, name: str, *args, **kwargs):
if is_scalar(res):
return res
return CategoricalIndex(res, name=self.name)
+
+ def replace(
+ self,
+ to_replace=None,
+ value=None,
+ limit=None,
+ regex=False,
+ method="pad",
+ ):
+ if regex is not False:
+ raise NotImplementedError(
+ "Regex replace is not yet implemented for CategoricalIndex."
+ )
+
+ new_index = self.to_series().replace(
+ to_replace=to_replace, value=value, limit=limit, regex=regex, method=method
+ )
+
+ new_index = CategoricalIndex(new_index)
+
+ return new_index
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index a04933fc5ddfc..b9232d759abde 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -58,6 +58,7 @@
from pandas.core.indexes.frozen import FrozenList
from pandas.core.indexes.numeric import Int64Index
from pandas.core.ops.invalid import make_invalid_op
+from pandas.core.shared_docs import _shared_docs
from pandas.core.sorting import (
get_group_index,
indexer_from_factorized,
@@ -3776,6 +3777,29 @@ def isin(self, values, level=None):
__abs__ = make_invalid_op("__abs__")
__inv__ = make_invalid_op("__inv__")
+ @doc(
+ _shared_docs["replace"],
+ klass=_index_doc_kwargs["klass"],
+ inplace=_index_doc_kwargs["inplace"],
+ replace_iloc=_index_doc_kwargs["replace_iloc"],
+ )
+ def replace(
+ self,
+ to_replace=None,
+ value=None,
+ limit=None,
+ regex=False,
+ method="pad",
+ ):
+ names = self.names
+
+ result = self.to_frame().replace(
+ to_replace=to_replace, value=value, limit=limit, regex=regex, method=method
+ )
+ new_multi_index = self.from_frame(result, names=names)
+
+ return new_multi_index
+
def _lexsort_depth(codes: List[np.ndarray], nlevels: int) -> int:
"""Count depth (up to a maximum of `nlevels`) with which codes are lexsorted."""
diff --git a/pandas/tests/frame/methods/test_replace.py b/pandas/tests/frame/methods/test_replace.py
index 1b570028964df..2c825f85233ad 100644
--- a/pandas/tests/frame/methods/test_replace.py
+++ b/pandas/tests/frame/methods/test_replace.py
@@ -1637,6 +1637,15 @@ def test_replace_unicode(self):
expected = DataFrame({"positive": np.ones(3)})
tm.assert_frame_equal(result, expected)
+ def test_replace_multiple_bool_datetime_type_mismatch(self):
+ # See https://github.com/pandas-dev/pandas/pull/32542#discussion_r528338117
+ df = DataFrame({"A": [True, False, True], "B": [False, True, False]})
+
+ result = df.replace({"a string": "new value", True: False})
+ expected = DataFrame({"A": [False, False, False], "B": [False, False, False]})
+
+ tm.assert_frame_equal(result, expected)
+
def test_replace_bytes(self, frame_or_series):
# GH#38900
obj = frame_or_series(["o"]).astype("|S")
diff --git a/pandas/tests/indexes/base_class/test_replace.py b/pandas/tests/indexes/base_class/test_replace.py
new file mode 100644
index 0000000000000..1887b171ef5cb
--- /dev/null
+++ b/pandas/tests/indexes/base_class/test_replace.py
@@ -0,0 +1,77 @@
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+ "index, to_replace, value, expected",
+ [
+ ([1, 2, 3], [1, 3], ["a", "c"], ["a", 2, "c"]),
+ ([1, 2, 3], 1, "a", ["a", 2, 3]),
+ (
+ [1, None, 2],
+ [1, 2],
+ "a",
+ ["a", None, "a"],
+ ),
+ ],
+)
+def test_index_replace(index, to_replace, value, expected):
+ index = pd.Index(index)
+ expected = pd.Index(expected)
+
+ result = index.replace(to_replace=to_replace, value=value)
+
+ tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "index, to_replace, value, regex, expected",
+ [
+ (
+ ["bat", "foo", "baait", "bar"],
+ r"^ba.$",
+ "new",
+ True,
+ ["new", "foo", "baait", "new"],
+ ),
+ (
+ ["bat", "foo", "baait", "bar"],
+ None,
+ None,
+ {r"^ba.$": "new", "foo": "xyz"},
+ ["new", "xyz", "baait", "new"],
+ ),
+ ],
+)
+def test_index_replace_regex(index, to_replace, value, regex, expected):
+ index = pd.Index(index)
+ expected = pd.Index(expected)
+
+ result = index.replace(to_replace=to_replace, value=value, regex=regex)
+ tm.assert_equal(expected, result)
+
+
+def test_index_replace_dict_and_value():
+ index = pd.Index([1, 2, 3])
+
+ msg = "Series.replace cannot use dict-like to_replace and non-None value"
+ with pytest.raises(ValueError, match=msg):
+ index.replace({1: "a", 3: "c"}, "x")
+
+
+def test_index_replace_bfill():
+ index = pd.Index([0, 1, 2, 3, 4])
+ expected = pd.Index([0, 3, 3, 3, 4])
+
+ result = index.replace([1, 2], method="bfill")
+ tm.assert_equal(expected, result)
+
+
+def test_index_name_preserved():
+ index = pd.Index(range(2), name="foo")
+ expected = pd.Index([0, 0], name="foo")
+
+ result = index.replace(1, 0)
+ tm.assert_equal(expected, result)
diff --git a/pandas/tests/indexes/categorical/test_replace.py b/pandas/tests/indexes/categorical/test_replace.py
new file mode 100644
index 0000000000000..a1e05b2c25148
--- /dev/null
+++ b/pandas/tests/indexes/categorical/test_replace.py
@@ -0,0 +1,55 @@
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+ "index, to_replace, value, expected",
+ [
+ ([1, 2, 3], 3, "a", [1, 2, "a"]),
+ (
+ [1, None, 2],
+ [1, 2],
+ "a",
+ ["a", None, "a"],
+ ),
+ ],
+)
+def test_categorical_index_replace(index, to_replace, value, expected):
+ index = pd.CategoricalIndex(index)
+ expected = pd.CategoricalIndex(expected)
+
+ result = index.replace(to_replace=to_replace, value=value)
+
+ tm.assert_equal(result, expected)
+
+
+def test_categorical_index_replace_dict_and_value():
+ index = pd.CategoricalIndex([1, 2, 3])
+
+ msg = "Series.replace cannot use dict-like to_replace and non-None value"
+ with pytest.raises(ValueError, match=msg):
+ index.replace({1: "a", 3: "c"}, "x")
+
+
+@pytest.mark.parametrize(
+ "index, to_replace, value, expected",
+ [
+ ([1, 2, 3], [2, 3], ["b", "c"], [1, "b", "c"]),
+ ([1, 2, 3], 3, "c", [1, 2, "c"]),
+ (
+ [1, None, 2],
+ [1, 2],
+ "a",
+ ["a", None, "a"],
+ ),
+ ],
+)
+def test_index_replace(index, to_replace, value, expected):
+ index = pd.CategoricalIndex(index)
+ expected = pd.CategoricalIndex(expected)
+
+ result = index.replace(to_replace=to_replace, value=value)
+
+ tm.assert_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_replace.py b/pandas/tests/indexes/multi/test_replace.py
new file mode 100644
index 0000000000000..3b099680b7d30
--- /dev/null
+++ b/pandas/tests/indexes/multi/test_replace.py
@@ -0,0 +1,70 @@
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+ "names, arrays, to_replace, value, expected_arrays",
+ [
+ (
+ [None, None],
+ [[1, 1, 2, 2], ["red", "blue", "red", "blue"]],
+ [1, "red"],
+ [0, "black"],
+ [[0, 0, 2, 2], ["black", "blue", "black", "blue"]],
+ ),
+ # names should be preserved
+ (
+ ["digits", "colors"],
+ [[1, 1, 2, 2], ["red", "blue", "red", "blue"]],
+ 1,
+ 0,
+ [[0, 0, 2, 2], ["red", "blue", "red", "blue"]],
+ ),
+ (
+ [None, None],
+ [[1, 1, 2, 2], ["red", "blue", "red", "blue"]],
+ 1,
+ 0,
+ [[0, 0, 2, 2], ["red", "blue", "red", "blue"]],
+ ),
+ (
+ [None, None],
+ [[1, 1, 2, 2], ["red", "blue", "red", "blue"]],
+ [1, 2],
+ 0,
+ [[0, 0, 0, 0], ["red", "blue", "red", "blue"]],
+ ),
+ (
+ [None, None],
+ [[1, 1, 2, 2], ["red", "blue", "red", "blue"]],
+ [1, 2],
+ 0,
+ [[0, 0, 0, 0], ["red", "blue", "red", "blue"]],
+ ),
+ # nested dicts
+ (
+ ["digits", "colors"],
+ [[1, 1, 2, 2], ["red", "blue", "red", "blue"]],
+ {"digits": {1: 0}, "colors": {"red": "black"}},
+ None,
+ [[0, 0, 2, 2], ["black", "blue", "black", "blue"]],
+ ),
+ # dicts and value
+ (
+ ["digits", "colors"],
+ [[1, 1, 2, 2], ["red", "blue", "red", "blue"]],
+ {"digits": [1], "colors": ["red", "blue"]},
+ "x",
+ [["x", "x", 2, 2], ["x", "x", "x", "x"]],
+ ),
+ ],
+)
+def test_multi_index_replace(names, arrays, to_replace, value, expected_arrays):
+ multi_index = pd.MultiIndex.from_arrays(arrays, names=names)
+ expected = pd.MultiIndex.from_arrays(expected_arrays, names=names)
+
+ result = multi_index.replace(to_replace=to_replace, value=value)
+
+ tm.assert_equal(result, expected)
| - [X] closes #19495
- [X] tests added / passed
- [X] passes `black pandas`
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
- [x] docstring for the new Index.replace() method
- [X] won't do: type hints
- [ ] merge with `ENH:` commit message
Added a replace method to Index classes, as well as tests. | https://api.github.com/repos/pandas-dev/pandas/pulls/32542 | 2020-03-08T14:03:02Z | 2021-04-11T00:29:52Z | null | 2021-04-11T00:29:52Z |
Fix failure to convert string "uint64" to NaN | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index d644a995a4876..e745bf3f5feed 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -231,7 +231,7 @@ Timezones
Numeric
^^^^^^^
- Bug in :meth:`DataFrame.floordiv` with ``axis=0`` not treating division-by-zero like :meth:`Series.floordiv` (:issue:`31271`)
--
+- Bug in :meth:`to_numeric` with string argument ``"uint64"`` and ``errors="coerce"`` silently fails (:issue:`32394`)
-
Conversion
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 61d6a660a0357..feccb447c5112 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -2024,8 +2024,6 @@ def maybe_convert_numeric(ndarray[object] values, set na_values,
except (TypeError, ValueError) as err:
if not seen.coerce_numeric:
raise type(err)(f"{err} at position {i}")
- elif "uint64" in str(err): # Exception from check functions.
- raise
seen.saw_null()
floats[i] = NaN
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index 48ae1f67297af..b01747ef010c1 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -507,6 +507,13 @@ def test_convert_numeric_int64_uint64(self, case, coerce):
result = lib.maybe_convert_numeric(case, set(), coerce_numeric=coerce)
tm.assert_almost_equal(result, expected)
+ def test_convert_numeric_string_uint64(self):
+ # GH32394
+ result = lib.maybe_convert_numeric(
+ np.array(["uint64"], dtype=object), set(), coerce_numeric=True
+ )
+ assert np.isnan(result)
+
@pytest.mark.parametrize("value", [-(2 ** 63) - 1, 2 ** 64])
def test_convert_int_overflow(self, value):
# see gh-18584
| Including regression test
- [x] closes #32394
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32541 | 2020-03-08T13:44:42Z | 2020-03-09T03:29:30Z | 2020-03-09T03:29:29Z | 2020-03-11T15:48:23Z |
DOC: Remove absolute urls from the docs | diff --git a/doc/source/getting_started/comparison/comparison_with_sql.rst b/doc/source/getting_started/comparison/comparison_with_sql.rst
index 6a03c06de3699..e3c8f8f5ccbcd 100644
--- a/doc/source/getting_started/comparison/comparison_with_sql.rst
+++ b/doc/source/getting_started/comparison/comparison_with_sql.rst
@@ -75,7 +75,7 @@ Filtering in SQL is done via a WHERE clause.
LIMIT 5;
DataFrames can be filtered in multiple ways; the most intuitive of which is using
-`boolean indexing <https://pandas.pydata.org/pandas-docs/stable/indexing.html#boolean-indexing>`_.
+:ref:`boolean indexing <indexing.boolean>`
.. ipython:: python
diff --git a/doc/source/user_guide/cookbook.rst b/doc/source/user_guide/cookbook.rst
index 4afdb14e5c39e..e51b5c9097951 100644
--- a/doc/source/user_guide/cookbook.rst
+++ b/doc/source/user_guide/cookbook.rst
@@ -794,8 +794,7 @@ The :ref:`Resample <timeseries.resampling>` docs.
`Time grouping with some missing values
<https://stackoverflow.com/questions/33637312/pandas-grouper-by-frequency-with-completeness-requirement>`__
-`Valid frequency arguments to Grouper
-<https://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__
+Valid frequency arguments to Grouper :ref:`Timeseries <timeseries.offset_aliases>`
`Grouping using a MultiIndex
<https://stackoverflow.com/questions/41483763/pandas-timegrouper-on-multiindex>`__
| - [x] closes #32529
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32539 | 2020-03-08T05:37:10Z | 2020-03-12T07:15:30Z | 2020-03-12T07:15:30Z | 2020-03-12T08:03:38Z |
ENH: IntegerArray.astype(dt64) | diff --git a/pandas/_libs/tslib.pyx b/pandas/_libs/tslib.pyx
index b78b623bfa187..94e757624c136 100644
--- a/pandas/_libs/tslib.pyx
+++ b/pandas/_libs/tslib.pyx
@@ -14,7 +14,7 @@ PyDateTime_IMPORT
cimport numpy as cnp
-from numpy cimport float64_t, int64_t, ndarray
+from numpy cimport float64_t, int64_t, ndarray, uint8_t
import numpy as np
cnp.import_array()
@@ -351,7 +351,6 @@ def format_array_from_datetime(
def array_with_unit_to_datetime(
ndarray values,
- ndarray mask,
object unit,
str errors='coerce'
):
@@ -373,8 +372,6 @@ def array_with_unit_to_datetime(
----------
values : ndarray of object
Date-like objects to convert.
- mask : boolean ndarray
- Not-a-time mask for non-nullable integer types conversion, can be None.
unit : object
Time unit to use during conversion.
errors : str, default 'raise'
@@ -395,6 +392,7 @@ def array_with_unit_to_datetime(
bint need_to_iterate = True
ndarray[int64_t] iresult
ndarray[object] oresult
+ ndarray mask
object tz = None
assert is_ignore or is_coerce or is_raise
@@ -404,9 +402,6 @@ def array_with_unit_to_datetime(
result = values.astype('M8[ns]')
else:
result, tz = array_to_datetime(values.astype(object), errors=errors)
- if mask is not None:
- iresult = result.view('i8')
- iresult[mask] = NPY_NAT
return result, tz
m = cast_from_unit(None, unit)
@@ -419,9 +414,8 @@ def array_with_unit_to_datetime(
if values.dtype.kind == "i":
# Note: this condition makes the casting="same_kind" redundant
iresult = values.astype('i8', casting='same_kind', copy=False)
- # If no mask, fill mask by comparing to NPY_NAT constant
- if mask is None:
- mask = iresult == NPY_NAT
+ # fill by comparing to NPY_NAT constant
+ mask = iresult == NPY_NAT
iresult[mask] = 0
fvalues = iresult.astype('f8') * m
need_to_iterate = False
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index e2b66b1a006e4..fb33840ad757c 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -13,6 +13,7 @@
from pandas.core.dtypes.cast import astype_nansafe
from pandas.core.dtypes.common import (
is_bool_dtype,
+ is_datetime64_dtype,
is_float,
is_float_dtype,
is_integer,
@@ -469,6 +470,8 @@ def astype(self, dtype, copy: bool = True) -> ArrayLike:
if is_float_dtype(dtype):
# In astype, we consider dtype=float to also mean na_value=np.nan
kwargs = dict(na_value=np.nan)
+ elif is_datetime64_dtype(dtype):
+ kwargs = dict(na_value=np.datetime64("NaT"))
else:
kwargs = {}
diff --git a/pandas/core/tools/datetimes.py b/pandas/core/tools/datetimes.py
index 5580146b37d25..c32b4d81c0988 100644
--- a/pandas/core/tools/datetimes.py
+++ b/pandas/core/tools/datetimes.py
@@ -323,15 +323,13 @@ def _convert_listlike_datetimes(
# GH 30050 pass an ndarray to tslib.array_with_unit_to_datetime
# because it expects an ndarray argument
if isinstance(arg, IntegerArray):
- # Explicitly pass NaT mask to array_with_unit_to_datetime
- mask = arg.isna()
- arg = arg._ndarray_values
+ result = arg.astype(f"datetime64[{unit}]")
+ tz_parsed = None
else:
- mask = None
- result, tz_parsed = tslib.array_with_unit_to_datetime(
- arg, mask, unit, errors=errors
- )
+ result, tz_parsed = tslib.array_with_unit_to_datetime(
+ arg, unit, errors=errors
+ )
if errors == "ignore":
from pandas import Index
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index f42b16cf18f20..ad6e6e4a98057 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -222,6 +222,8 @@ def test_array_copy():
# integer
([1, 2], IntegerArray._from_sequence([1, 2])),
([1, None], IntegerArray._from_sequence([1, None])),
+ ([1, pd.NA], IntegerArray._from_sequence([1, pd.NA])),
+ ([1, np.nan], IntegerArray._from_sequence([1, np.nan])),
# string
(["a", "b"], StringArray._from_sequence(["a", "b"])),
(["a", None], StringArray._from_sequence(["a", None])),
diff --git a/pandas/tests/arrays/test_integer.py b/pandas/tests/arrays/test_integer.py
index 0a5a2362bd290..70a029bd74bda 100644
--- a/pandas/tests/arrays/test_integer.py
+++ b/pandas/tests/arrays/test_integer.py
@@ -633,6 +633,15 @@ def test_astype_specific_casting(self, dtype):
expected = pd.Series([1, 2, 3, None], dtype=dtype)
tm.assert_series_equal(result, expected)
+ def test_astype_dt64(self):
+ # GH#32435
+ arr = pd.array([1, 2, 3, pd.NA]) * 10 ** 9
+
+ result = arr.astype("datetime64[ns]")
+
+ expected = np.array([1, 2, 3, "NaT"], dtype="M8[s]").astype("M8[ns]")
+ tm.assert_numpy_array_equal(result, expected)
+
def test_construct_cast_invalid(self, dtype):
msg = "cannot safely"
diff --git a/pandas/tests/frame/test_dtypes.py b/pandas/tests/frame/test_dtypes.py
index 713d8f3ceeedb..d1a7917bd127b 100644
--- a/pandas/tests/frame/test_dtypes.py
+++ b/pandas/tests/frame/test_dtypes.py
@@ -505,7 +505,7 @@ def test_df_where_change_dtype(self):
@pytest.mark.parametrize("dtype", ["M8", "m8"])
@pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "h", "m", "D"])
- def test_astype_from_datetimelike_to_objectt(self, dtype, unit):
+ def test_astype_from_datetimelike_to_object(self, dtype, unit):
# tests astype to object dtype
# gh-19223 / gh-12425
dtype = f"{dtype}[{unit}]"
| - [x] closes #32435
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
Let's us de-kludge to_datetime code, getting rid of another _ndarray_values usage. | https://api.github.com/repos/pandas-dev/pandas/pulls/32538 | 2020-03-08T03:09:38Z | 2020-03-14T03:37:22Z | 2020-03-14T03:37:22Z | 2020-04-05T17:46:02Z |
CLN: avoid values_from_object in reshape.merge | diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index e75dced21f488..aeec2a43f39bf 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -45,6 +45,7 @@
import pandas.core.algorithms as algos
from pandas.core.arrays.categorical import _recode_for_categories
import pandas.core.common as com
+from pandas.core.construction import extract_array
from pandas.core.frame import _merge_doc
from pandas.core.internals import concatenate_block_managers
from pandas.core.sorting import is_int64_overflow_possible
@@ -1820,9 +1821,14 @@ def _right_outer_join(x, y, max_groups):
def _factorize_keys(lk, rk, sort=True):
# Some pre-processing for non-ndarray lk / rk
- if is_datetime64tz_dtype(lk) and is_datetime64tz_dtype(rk):
- lk = getattr(lk, "_values", lk)._data
- rk = getattr(rk, "_values", rk)._data
+ lk = extract_array(lk, extract_numpy=True)
+ rk = extract_array(rk, extract_numpy=True)
+
+ if is_datetime64tz_dtype(lk.dtype) and is_datetime64tz_dtype(rk.dtype):
+ # Extract the ndarray (UTC-localized) values
+ # Note: we dont need the dtypes to match, as these can still be compared
+ lk, _ = lk._values_for_factorize()
+ rk, _ = rk._values_for_factorize()
elif (
is_categorical_dtype(lk) and is_categorical_dtype(rk) and lk.is_dtype_equal(rk)
@@ -1837,11 +1843,7 @@ def _factorize_keys(lk, rk, sort=True):
lk = ensure_int64(lk.codes)
rk = ensure_int64(rk)
- elif (
- is_extension_array_dtype(lk.dtype)
- and is_extension_array_dtype(rk.dtype)
- and lk.dtype == rk.dtype
- ):
+ elif is_extension_array_dtype(lk.dtype) and is_dtype_equal(lk.dtype, rk.dtype):
lk, _ = lk._values_for_factorize()
rk, _ = rk._values_for_factorize()
@@ -1849,15 +1851,15 @@ def _factorize_keys(lk, rk, sort=True):
# GH#23917 TODO: needs tests for case where lk is integer-dtype
# and rk is datetime-dtype
klass = libhashtable.Int64Factorizer
- lk = ensure_int64(com.values_from_object(lk))
- rk = ensure_int64(com.values_from_object(rk))
- elif issubclass(lk.dtype.type, (np.timedelta64, np.datetime64)) and issubclass(
- rk.dtype.type, (np.timedelta64, np.datetime64)
- ):
+ lk = ensure_int64(np.asarray(lk))
+ rk = ensure_int64(np.asarray(rk))
+
+ elif needs_i8_conversion(lk.dtype) and is_dtype_equal(lk.dtype, rk.dtype):
# GH#23917 TODO: Needs tests for non-matching dtypes
klass = libhashtable.Int64Factorizer
- lk = ensure_int64(com.values_from_object(lk))
- rk = ensure_int64(com.values_from_object(rk))
+ lk = ensure_int64(np.asarray(lk, dtype=np.int64))
+ rk = ensure_int64(np.asarray(rk, dtype=np.int64))
+
else:
klass = libhashtable.Factorizer
lk = ensure_object(lk)
| https://api.github.com/repos/pandas-dev/pandas/pulls/32537 | 2020-03-08T03:03:41Z | 2020-03-12T04:44:25Z | 2020-03-12T04:44:24Z | 2020-03-12T15:23:44Z | |
TST: separate out pd.crosstab tests from test_pivot | diff --git a/pandas/tests/reshape/test_crosstab.py b/pandas/tests/reshape/test_crosstab.py
new file mode 100644
index 0000000000000..8795af2e11122
--- /dev/null
+++ b/pandas/tests/reshape/test_crosstab.py
@@ -0,0 +1,700 @@
+import numpy as np
+import pytest
+
+from pandas import CategoricalIndex, DataFrame, Index, MultiIndex, Series, crosstab
+import pandas._testing as tm
+
+
+class TestCrosstab:
+ def setup_method(self, method):
+ df = DataFrame(
+ {
+ "A": [
+ "foo",
+ "foo",
+ "foo",
+ "foo",
+ "bar",
+ "bar",
+ "bar",
+ "bar",
+ "foo",
+ "foo",
+ "foo",
+ ],
+ "B": [
+ "one",
+ "one",
+ "one",
+ "two",
+ "one",
+ "one",
+ "one",
+ "two",
+ "two",
+ "two",
+ "one",
+ ],
+ "C": [
+ "dull",
+ "dull",
+ "shiny",
+ "dull",
+ "dull",
+ "shiny",
+ "shiny",
+ "dull",
+ "shiny",
+ "shiny",
+ "shiny",
+ ],
+ "D": np.random.randn(11),
+ "E": np.random.randn(11),
+ "F": np.random.randn(11),
+ }
+ )
+
+ self.df = df.append(df, ignore_index=True)
+
+ def test_crosstab_single(self):
+ df = self.df
+ result = crosstab(df["A"], df["C"])
+ expected = df.groupby(["A", "C"]).size().unstack()
+ tm.assert_frame_equal(result, expected.fillna(0).astype(np.int64))
+
+ def test_crosstab_multiple(self):
+ df = self.df
+
+ result = crosstab(df["A"], [df["B"], df["C"]])
+ expected = df.groupby(["A", "B", "C"]).size()
+ expected = expected.unstack("B").unstack("C").fillna(0).astype(np.int64)
+ tm.assert_frame_equal(result, expected)
+
+ result = crosstab([df["B"], df["C"]], df["A"])
+ expected = df.groupby(["B", "C", "A"]).size()
+ expected = expected.unstack("A").fillna(0).astype(np.int64)
+ tm.assert_frame_equal(result, expected)
+
+ def test_crosstab_ndarray(self):
+ a = np.random.randint(0, 5, size=100)
+ b = np.random.randint(0, 3, size=100)
+ c = np.random.randint(0, 10, size=100)
+
+ df = DataFrame({"a": a, "b": b, "c": c})
+
+ result = crosstab(a, [b, c], rownames=["a"], colnames=("b", "c"))
+ expected = crosstab(df["a"], [df["b"], df["c"]])
+ tm.assert_frame_equal(result, expected)
+
+ result = crosstab([b, c], a, colnames=["a"], rownames=("b", "c"))
+ expected = crosstab([df["b"], df["c"]], df["a"])
+ tm.assert_frame_equal(result, expected)
+
+ # assign arbitrary names
+ result = crosstab(self.df["A"].values, self.df["C"].values)
+ assert result.index.name == "row_0"
+ assert result.columns.name == "col_0"
+
+ def test_crosstab_non_aligned(self):
+ # GH 17005
+ a = Series([0, 1, 1], index=["a", "b", "c"])
+ b = Series([3, 4, 3, 4, 3], index=["a", "b", "c", "d", "f"])
+ c = np.array([3, 4, 3])
+
+ expected = DataFrame(
+ [[1, 0], [1, 1]],
+ index=Index([0, 1], name="row_0"),
+ columns=Index([3, 4], name="col_0"),
+ )
+
+ result = crosstab(a, b)
+ tm.assert_frame_equal(result, expected)
+
+ result = crosstab(a, c)
+ tm.assert_frame_equal(result, expected)
+
+ def test_crosstab_margins(self):
+ a = np.random.randint(0, 7, size=100)
+ b = np.random.randint(0, 3, size=100)
+ c = np.random.randint(0, 5, size=100)
+
+ df = DataFrame({"a": a, "b": b, "c": c})
+
+ result = crosstab(a, [b, c], rownames=["a"], colnames=("b", "c"), margins=True)
+
+ assert result.index.names == ("a",)
+ assert result.columns.names == ["b", "c"]
+
+ all_cols = result["All", ""]
+ exp_cols = df.groupby(["a"]).size().astype("i8")
+ # to keep index.name
+ exp_margin = Series([len(df)], index=Index(["All"], name="a"))
+ exp_cols = exp_cols.append(exp_margin)
+ exp_cols.name = ("All", "")
+
+ tm.assert_series_equal(all_cols, exp_cols)
+
+ all_rows = result.loc["All"]
+ exp_rows = df.groupby(["b", "c"]).size().astype("i8")
+ exp_rows = exp_rows.append(Series([len(df)], index=[("All", "")]))
+ exp_rows.name = "All"
+
+ exp_rows = exp_rows.reindex(all_rows.index)
+ exp_rows = exp_rows.fillna(0).astype(np.int64)
+ tm.assert_series_equal(all_rows, exp_rows)
+
+ def test_crosstab_margins_set_margin_name(self):
+ # GH 15972
+ a = np.random.randint(0, 7, size=100)
+ b = np.random.randint(0, 3, size=100)
+ c = np.random.randint(0, 5, size=100)
+
+ df = DataFrame({"a": a, "b": b, "c": c})
+
+ result = crosstab(
+ a,
+ [b, c],
+ rownames=["a"],
+ colnames=("b", "c"),
+ margins=True,
+ margins_name="TOTAL",
+ )
+
+ assert result.index.names == ("a",)
+ assert result.columns.names == ["b", "c"]
+
+ all_cols = result["TOTAL", ""]
+ exp_cols = df.groupby(["a"]).size().astype("i8")
+ # to keep index.name
+ exp_margin = Series([len(df)], index=Index(["TOTAL"], name="a"))
+ exp_cols = exp_cols.append(exp_margin)
+ exp_cols.name = ("TOTAL", "")
+
+ tm.assert_series_equal(all_cols, exp_cols)
+
+ all_rows = result.loc["TOTAL"]
+ exp_rows = df.groupby(["b", "c"]).size().astype("i8")
+ exp_rows = exp_rows.append(Series([len(df)], index=[("TOTAL", "")]))
+ exp_rows.name = "TOTAL"
+
+ exp_rows = exp_rows.reindex(all_rows.index)
+ exp_rows = exp_rows.fillna(0).astype(np.int64)
+ tm.assert_series_equal(all_rows, exp_rows)
+
+ msg = "margins_name argument must be a string"
+ for margins_name in [666, None, ["a", "b"]]:
+ with pytest.raises(ValueError, match=msg):
+ crosstab(
+ a,
+ [b, c],
+ rownames=["a"],
+ colnames=("b", "c"),
+ margins=True,
+ margins_name=margins_name,
+ )
+
+ def test_crosstab_pass_values(self):
+ a = np.random.randint(0, 7, size=100)
+ b = np.random.randint(0, 3, size=100)
+ c = np.random.randint(0, 5, size=100)
+ values = np.random.randn(100)
+
+ table = crosstab(
+ [a, b], c, values, aggfunc=np.sum, rownames=["foo", "bar"], colnames=["baz"]
+ )
+
+ df = DataFrame({"foo": a, "bar": b, "baz": c, "values": values})
+
+ expected = df.pivot_table(
+ "values", index=["foo", "bar"], columns="baz", aggfunc=np.sum
+ )
+ tm.assert_frame_equal(table, expected)
+
+ def test_crosstab_dropna(self):
+ # GH 3820
+ a = np.array(["foo", "foo", "foo", "bar", "bar", "foo", "foo"], dtype=object)
+ b = np.array(["one", "one", "two", "one", "two", "two", "two"], dtype=object)
+ c = np.array(
+ ["dull", "dull", "dull", "dull", "dull", "shiny", "shiny"], dtype=object
+ )
+ res = crosstab(a, [b, c], rownames=["a"], colnames=["b", "c"], dropna=False)
+ m = MultiIndex.from_tuples(
+ [("one", "dull"), ("one", "shiny"), ("two", "dull"), ("two", "shiny")],
+ names=["b", "c"],
+ )
+ tm.assert_index_equal(res.columns, m)
+
+ def test_crosstab_no_overlap(self):
+ # GS 10291
+
+ s1 = Series([1, 2, 3], index=[1, 2, 3])
+ s2 = Series([4, 5, 6], index=[4, 5, 6])
+
+ actual = crosstab(s1, s2)
+ expected = DataFrame()
+
+ tm.assert_frame_equal(actual, expected)
+
+ def test_margin_dropna(self):
+ # GH 12577
+ # pivot_table counts null into margin ('All')
+ # when margins=true and dropna=true
+
+ df = DataFrame({"a": [1, 2, 2, 2, 2, np.nan], "b": [3, 3, 4, 4, 4, 4]})
+ actual = crosstab(df.a, df.b, margins=True, dropna=True)
+ expected = DataFrame([[1, 0, 1], [1, 3, 4], [2, 3, 5]])
+ expected.index = Index([1.0, 2.0, "All"], name="a")
+ expected.columns = Index([3, 4, "All"], name="b")
+ tm.assert_frame_equal(actual, expected)
+
+ df = DataFrame(
+ {"a": [1, np.nan, np.nan, np.nan, 2, np.nan], "b": [3, np.nan, 4, 4, 4, 4]}
+ )
+ actual = crosstab(df.a, df.b, margins=True, dropna=True)
+ expected = DataFrame([[1, 0, 1], [0, 1, 1], [1, 1, 2]])
+ expected.index = Index([1.0, 2.0, "All"], name="a")
+ expected.columns = Index([3.0, 4.0, "All"], name="b")
+ tm.assert_frame_equal(actual, expected)
+
+ df = DataFrame(
+ {"a": [1, np.nan, np.nan, np.nan, np.nan, 2], "b": [3, 3, 4, 4, 4, 4]}
+ )
+ actual = crosstab(df.a, df.b, margins=True, dropna=True)
+ expected = DataFrame([[1, 0, 1], [0, 1, 1], [1, 1, 2]])
+ expected.index = Index([1.0, 2.0, "All"], name="a")
+ expected.columns = Index([3, 4, "All"], name="b")
+ tm.assert_frame_equal(actual, expected)
+
+ # GH 12642
+ # _add_margins raises KeyError: Level None not found
+ # when margins=True and dropna=False
+ df = DataFrame({"a": [1, 2, 2, 2, 2, np.nan], "b": [3, 3, 4, 4, 4, 4]})
+ actual = crosstab(df.a, df.b, margins=True, dropna=False)
+ expected = DataFrame([[1, 0, 1], [1, 3, 4], [2, 4, 6]])
+ expected.index = Index([1.0, 2.0, "All"], name="a")
+ expected.columns = Index([3, 4, "All"], name="b")
+ tm.assert_frame_equal(actual, expected)
+
+ df = DataFrame(
+ {"a": [1, np.nan, np.nan, np.nan, 2, np.nan], "b": [3, np.nan, 4, 4, 4, 4]}
+ )
+ actual = crosstab(df.a, df.b, margins=True, dropna=False)
+ expected = DataFrame([[1, 0, 1], [0, 1, 1], [1, 4, 6]])
+ expected.index = Index([1.0, 2.0, "All"], name="a")
+ expected.columns = Index([3.0, 4.0, "All"], name="b")
+ tm.assert_frame_equal(actual, expected)
+
+ a = np.array(["foo", "foo", "foo", "bar", "bar", "foo", "foo"], dtype=object)
+ b = np.array(["one", "one", "two", "one", "two", np.nan, "two"], dtype=object)
+ c = np.array(
+ ["dull", "dull", "dull", "dull", "dull", "shiny", "shiny"], dtype=object
+ )
+
+ actual = crosstab(
+ a, [b, c], rownames=["a"], colnames=["b", "c"], margins=True, dropna=False
+ )
+ m = MultiIndex.from_arrays(
+ [
+ ["one", "one", "two", "two", "All"],
+ ["dull", "shiny", "dull", "shiny", ""],
+ ],
+ names=["b", "c"],
+ )
+ expected = DataFrame(
+ [[1, 0, 1, 0, 2], [2, 0, 1, 1, 5], [3, 0, 2, 1, 7]], columns=m
+ )
+ expected.index = Index(["bar", "foo", "All"], name="a")
+ tm.assert_frame_equal(actual, expected)
+
+ actual = crosstab(
+ [a, b], c, rownames=["a", "b"], colnames=["c"], margins=True, dropna=False
+ )
+ m = MultiIndex.from_arrays(
+ [["bar", "bar", "foo", "foo", "All"], ["one", "two", "one", "two", ""]],
+ names=["a", "b"],
+ )
+ expected = DataFrame(
+ [[1, 0, 1], [1, 0, 1], [2, 0, 2], [1, 1, 2], [5, 2, 7]], index=m
+ )
+ expected.columns = Index(["dull", "shiny", "All"], name="c")
+ tm.assert_frame_equal(actual, expected)
+
+ actual = crosstab(
+ [a, b], c, rownames=["a", "b"], colnames=["c"], margins=True, dropna=True
+ )
+ m = MultiIndex.from_arrays(
+ [["bar", "bar", "foo", "foo", "All"], ["one", "two", "one", "two", ""]],
+ names=["a", "b"],
+ )
+ expected = DataFrame(
+ [[1, 0, 1], [1, 0, 1], [2, 0, 2], [1, 1, 2], [5, 1, 6]], index=m
+ )
+ expected.columns = Index(["dull", "shiny", "All"], name="c")
+ tm.assert_frame_equal(actual, expected)
+
+ def test_crosstab_normalize(self):
+ # Issue 12578
+ df = DataFrame(
+ {"a": [1, 2, 2, 2, 2], "b": [3, 3, 4, 4, 4], "c": [1, 1, np.nan, 1, 1]}
+ )
+
+ rindex = Index([1, 2], name="a")
+ cindex = Index([3, 4], name="b")
+ full_normal = DataFrame([[0.2, 0], [0.2, 0.6]], index=rindex, columns=cindex)
+ row_normal = DataFrame([[1.0, 0], [0.25, 0.75]], index=rindex, columns=cindex)
+ col_normal = DataFrame([[0.5, 0], [0.5, 1.0]], index=rindex, columns=cindex)
+
+ # Check all normalize args
+ tm.assert_frame_equal(crosstab(df.a, df.b, normalize="all"), full_normal)
+ tm.assert_frame_equal(crosstab(df.a, df.b, normalize=True), full_normal)
+ tm.assert_frame_equal(crosstab(df.a, df.b, normalize="index"), row_normal)
+ tm.assert_frame_equal(crosstab(df.a, df.b, normalize="columns"), col_normal)
+ tm.assert_frame_equal(
+ crosstab(df.a, df.b, normalize=1),
+ crosstab(df.a, df.b, normalize="columns"),
+ )
+ tm.assert_frame_equal(
+ crosstab(df.a, df.b, normalize=0), crosstab(df.a, df.b, normalize="index"),
+ )
+
+ row_normal_margins = DataFrame(
+ [[1.0, 0], [0.25, 0.75], [0.4, 0.6]],
+ index=Index([1, 2, "All"], name="a", dtype="object"),
+ columns=Index([3, 4], name="b", dtype="object"),
+ )
+ col_normal_margins = DataFrame(
+ [[0.5, 0, 0.2], [0.5, 1.0, 0.8]],
+ index=Index([1, 2], name="a", dtype="object"),
+ columns=Index([3, 4, "All"], name="b", dtype="object"),
+ )
+
+ all_normal_margins = DataFrame(
+ [[0.2, 0, 0.2], [0.2, 0.6, 0.8], [0.4, 0.6, 1]],
+ index=Index([1, 2, "All"], name="a", dtype="object"),
+ columns=Index([3, 4, "All"], name="b", dtype="object"),
+ )
+ tm.assert_frame_equal(
+ crosstab(df.a, df.b, normalize="index", margins=True), row_normal_margins
+ )
+ tm.assert_frame_equal(
+ crosstab(df.a, df.b, normalize="columns", margins=True), col_normal_margins,
+ )
+ tm.assert_frame_equal(
+ crosstab(df.a, df.b, normalize=True, margins=True), all_normal_margins
+ )
+
+ # Test arrays
+ crosstab(
+ [np.array([1, 1, 2, 2]), np.array([1, 2, 1, 2])], np.array([1, 2, 1, 2])
+ )
+
+ # Test with aggfunc
+ norm_counts = DataFrame(
+ [[0.25, 0, 0.25], [0.25, 0.5, 0.75], [0.5, 0.5, 1]],
+ index=Index([1, 2, "All"], name="a", dtype="object"),
+ columns=Index([3, 4, "All"], name="b"),
+ )
+ test_case = crosstab(
+ df.a, df.b, df.c, aggfunc="count", normalize="all", margins=True
+ )
+ tm.assert_frame_equal(test_case, norm_counts)
+
+ df = DataFrame(
+ {"a": [1, 2, 2, 2, 2], "b": [3, 3, 4, 4, 4], "c": [0, 4, np.nan, 3, 3]}
+ )
+
+ norm_sum = DataFrame(
+ [[0, 0, 0.0], [0.4, 0.6, 1], [0.4, 0.6, 1]],
+ index=Index([1, 2, "All"], name="a", dtype="object"),
+ columns=Index([3, 4, "All"], name="b", dtype="object"),
+ )
+ test_case = crosstab(
+ df.a, df.b, df.c, aggfunc=np.sum, normalize="all", margins=True
+ )
+ tm.assert_frame_equal(test_case, norm_sum)
+
+ def test_crosstab_with_empties(self):
+ # Check handling of empties
+ df = DataFrame(
+ {
+ "a": [1, 2, 2, 2, 2],
+ "b": [3, 3, 4, 4, 4],
+ "c": [np.nan, np.nan, np.nan, np.nan, np.nan],
+ }
+ )
+
+ empty = DataFrame(
+ [[0.0, 0.0], [0.0, 0.0]],
+ index=Index([1, 2], name="a", dtype="int64"),
+ columns=Index([3, 4], name="b"),
+ )
+
+ for i in [True, "index", "columns"]:
+ calculated = crosstab(df.a, df.b, values=df.c, aggfunc="count", normalize=i)
+ tm.assert_frame_equal(empty, calculated)
+
+ nans = DataFrame(
+ [[0.0, np.nan], [0.0, 0.0]],
+ index=Index([1, 2], name="a", dtype="int64"),
+ columns=Index([3, 4], name="b"),
+ )
+
+ calculated = crosstab(df.a, df.b, values=df.c, aggfunc="count", normalize=False)
+ tm.assert_frame_equal(nans, calculated)
+
+ def test_crosstab_errors(self):
+ # Issue 12578
+
+ df = DataFrame(
+ {"a": [1, 2, 2, 2, 2], "b": [3, 3, 4, 4, 4], "c": [1, 1, np.nan, 1, 1]}
+ )
+
+ error = "values cannot be used without an aggfunc."
+ with pytest.raises(ValueError, match=error):
+ crosstab(df.a, df.b, values=df.c)
+
+ error = "aggfunc cannot be used without values"
+ with pytest.raises(ValueError, match=error):
+ crosstab(df.a, df.b, aggfunc=np.mean)
+
+ error = "Not a valid normalize argument"
+ with pytest.raises(ValueError, match=error):
+ crosstab(df.a, df.b, normalize="42")
+
+ with pytest.raises(ValueError, match=error):
+ crosstab(df.a, df.b, normalize=42)
+
+ error = "Not a valid margins argument"
+ with pytest.raises(ValueError, match=error):
+ crosstab(df.a, df.b, normalize="all", margins=42)
+
+ def test_crosstab_with_categorial_columns(self):
+ # GH 8860
+ df = DataFrame(
+ {
+ "MAKE": ["Honda", "Acura", "Tesla", "Honda", "Honda", "Acura"],
+ "MODEL": ["Sedan", "Sedan", "Electric", "Pickup", "Sedan", "Sedan"],
+ }
+ )
+ categories = ["Sedan", "Electric", "Pickup"]
+ df["MODEL"] = df["MODEL"].astype("category").cat.set_categories(categories)
+ result = crosstab(df["MAKE"], df["MODEL"])
+
+ expected_index = Index(["Acura", "Honda", "Tesla"], name="MAKE")
+ expected_columns = CategoricalIndex(
+ categories, categories=categories, ordered=False, name="MODEL"
+ )
+ expected_data = [[2, 0, 0], [2, 0, 1], [0, 1, 0]]
+ expected = DataFrame(
+ expected_data, index=expected_index, columns=expected_columns
+ )
+ tm.assert_frame_equal(result, expected)
+
+ def test_crosstab_with_numpy_size(self):
+ # GH 4003
+ df = DataFrame(
+ {
+ "A": ["one", "one", "two", "three"] * 6,
+ "B": ["A", "B", "C"] * 8,
+ "C": ["foo", "foo", "foo", "bar", "bar", "bar"] * 4,
+ "D": np.random.randn(24),
+ "E": np.random.randn(24),
+ }
+ )
+ result = crosstab(
+ index=[df["A"], df["B"]],
+ columns=[df["C"]],
+ margins=True,
+ aggfunc=np.size,
+ values=df["D"],
+ )
+ expected_index = MultiIndex(
+ levels=[["All", "one", "three", "two"], ["", "A", "B", "C"]],
+ codes=[[1, 1, 1, 2, 2, 2, 3, 3, 3, 0], [1, 2, 3, 1, 2, 3, 1, 2, 3, 0]],
+ names=["A", "B"],
+ )
+ expected_column = Index(["bar", "foo", "All"], dtype="object", name="C")
+ expected_data = np.array(
+ [
+ [2.0, 2.0, 4.0],
+ [2.0, 2.0, 4.0],
+ [2.0, 2.0, 4.0],
+ [2.0, np.nan, 2.0],
+ [np.nan, 2.0, 2.0],
+ [2.0, np.nan, 2.0],
+ [np.nan, 2.0, 2.0],
+ [2.0, np.nan, 2.0],
+ [np.nan, 2.0, 2.0],
+ [12.0, 12.0, 24.0],
+ ]
+ )
+ expected = DataFrame(
+ expected_data, index=expected_index, columns=expected_column
+ )
+ tm.assert_frame_equal(result, expected)
+
+ def test_crosstab_dup_index_names(self):
+ # GH 13279
+ s = Series(range(3), name="foo")
+
+ result = crosstab(s, s)
+ expected_index = Index(range(3), name="foo")
+ expected = DataFrame(
+ np.eye(3, dtype=np.int64), index=expected_index, columns=expected_index
+ )
+ tm.assert_frame_equal(result, expected)
+
+ @pytest.mark.parametrize("names", [["a", ("b", "c")], [("a", "b"), "c"]])
+ def test_crosstab_tuple_name(self, names):
+ s1 = Series(range(3), name=names[0])
+ s2 = Series(range(1, 4), name=names[1])
+
+ mi = MultiIndex.from_arrays([range(3), range(1, 4)], names=names)
+ expected = Series(1, index=mi).unstack(1, fill_value=0)
+
+ result = crosstab(s1, s2)
+ tm.assert_frame_equal(result, expected)
+
+ def test_crosstab_both_tuple_names(self):
+ # GH 18321
+ s1 = Series(range(3), name=("a", "b"))
+ s2 = Series(range(3), name=("c", "d"))
+
+ expected = DataFrame(
+ np.eye(3, dtype="int64"),
+ index=Index(range(3), name=("a", "b")),
+ columns=Index(range(3), name=("c", "d")),
+ )
+ result = crosstab(s1, s2)
+ tm.assert_frame_equal(result, expected)
+
+ def test_crosstab_unsorted_order(self):
+ df = DataFrame({"b": [3, 1, 2], "a": [5, 4, 6]}, index=["C", "A", "B"])
+ result = crosstab(df.index, [df.b, df.a])
+ e_idx = Index(["A", "B", "C"], name="row_0")
+ e_columns = MultiIndex.from_tuples([(1, 4), (2, 6), (3, 5)], names=["b", "a"])
+ expected = DataFrame(
+ [[1, 0, 0], [0, 1, 0], [0, 0, 1]], index=e_idx, columns=e_columns
+ )
+ tm.assert_frame_equal(result, expected)
+
+ def test_crosstab_normalize_multiple_columns(self):
+ # GH 15150
+ df = DataFrame(
+ {
+ "A": ["one", "one", "two", "three"] * 6,
+ "B": ["A", "B", "C"] * 8,
+ "C": ["foo", "foo", "foo", "bar", "bar", "bar"] * 4,
+ "D": [0] * 24,
+ "E": [0] * 24,
+ }
+ )
+ result = crosstab(
+ [df.A, df.B],
+ df.C,
+ values=df.D,
+ aggfunc=np.sum,
+ normalize=True,
+ margins=True,
+ )
+ expected = DataFrame(
+ np.array([0] * 29 + [1], dtype=float).reshape(10, 3),
+ columns=Index(["bar", "foo", "All"], dtype="object", name="C"),
+ index=MultiIndex.from_tuples(
+ [
+ ("one", "A"),
+ ("one", "B"),
+ ("one", "C"),
+ ("three", "A"),
+ ("three", "B"),
+ ("three", "C"),
+ ("two", "A"),
+ ("two", "B"),
+ ("two", "C"),
+ ("All", ""),
+ ],
+ names=["A", "B"],
+ ),
+ )
+ tm.assert_frame_equal(result, expected)
+
+ def test_margin_normalize(self):
+ # GH 27500
+ df = DataFrame(
+ {
+ "A": ["foo", "foo", "foo", "foo", "foo", "bar", "bar", "bar", "bar"],
+ "B": ["one", "one", "one", "two", "two", "one", "one", "two", "two"],
+ "C": [
+ "small",
+ "large",
+ "large",
+ "small",
+ "small",
+ "large",
+ "small",
+ "small",
+ "large",
+ ],
+ "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
+ "E": [2, 4, 5, 5, 6, 6, 8, 9, 9],
+ }
+ )
+ # normalize on index
+ result = crosstab(
+ [df.A, df.B], df.C, margins=True, margins_name="Sub-Total", normalize=0
+ )
+ expected = DataFrame(
+ [[0.5, 0.5], [0.5, 0.5], [0.666667, 0.333333], [0, 1], [0.444444, 0.555556]]
+ )
+ expected.index = MultiIndex(
+ levels=[["Sub-Total", "bar", "foo"], ["", "one", "two"]],
+ codes=[[1, 1, 2, 2, 0], [1, 2, 1, 2, 0]],
+ names=["A", "B"],
+ )
+ expected.columns = Index(["large", "small"], dtype="object", name="C")
+ tm.assert_frame_equal(result, expected)
+
+ # normalize on columns
+ result = crosstab(
+ [df.A, df.B], df.C, margins=True, margins_name="Sub-Total", normalize=1
+ )
+ expected = DataFrame(
+ [
+ [0.25, 0.2, 0.222222],
+ [0.25, 0.2, 0.222222],
+ [0.5, 0.2, 0.333333],
+ [0, 0.4, 0.222222],
+ ]
+ )
+ expected.columns = Index(
+ ["large", "small", "Sub-Total"], dtype="object", name="C"
+ )
+ expected.index = MultiIndex(
+ levels=[["bar", "foo"], ["one", "two"]],
+ codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
+ names=["A", "B"],
+ )
+ tm.assert_frame_equal(result, expected)
+
+ # normalize on both index and column
+ result = crosstab(
+ [df.A, df.B], df.C, margins=True, margins_name="Sub-Total", normalize=True
+ )
+ expected = DataFrame(
+ [
+ [0.111111, 0.111111, 0.222222],
+ [0.111111, 0.111111, 0.222222],
+ [0.222222, 0.111111, 0.333333],
+ [0.000000, 0.222222, 0.222222],
+ [0.444444, 0.555555, 1],
+ ]
+ )
+ expected.columns = Index(
+ ["large", "small", "Sub-Total"], dtype="object", name="C"
+ )
+ expected.index = MultiIndex(
+ levels=[["Sub-Total", "bar", "foo"], ["", "one", "two"]],
+ codes=[[1, 1, 2, 2, 0], [1, 2, 1, 2, 0]],
+ names=["A", "B"],
+ )
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py
index e09a2a7907177..75c3c565e9d58 100644
--- a/pandas/tests/reshape/test_pivot.py
+++ b/pandas/tests/reshape/test_pivot.py
@@ -17,7 +17,7 @@
)
import pandas._testing as tm
from pandas.api.types import CategoricalDtype as CDT
-from pandas.core.reshape.pivot import crosstab, pivot_table
+from pandas.core.reshape.pivot import pivot_table
@pytest.fixture(params=[True, False])
@@ -2064,708 +2064,3 @@ def agg(l):
)
with pytest.raises(KeyError, match="notpresent"):
foo.pivot_table("notpresent", "X", "Y", aggfunc=agg)
-
-
-class TestCrosstab:
- def setup_method(self, method):
- df = DataFrame(
- {
- "A": [
- "foo",
- "foo",
- "foo",
- "foo",
- "bar",
- "bar",
- "bar",
- "bar",
- "foo",
- "foo",
- "foo",
- ],
- "B": [
- "one",
- "one",
- "one",
- "two",
- "one",
- "one",
- "one",
- "two",
- "two",
- "two",
- "one",
- ],
- "C": [
- "dull",
- "dull",
- "shiny",
- "dull",
- "dull",
- "shiny",
- "shiny",
- "dull",
- "shiny",
- "shiny",
- "shiny",
- ],
- "D": np.random.randn(11),
- "E": np.random.randn(11),
- "F": np.random.randn(11),
- }
- )
-
- self.df = df.append(df, ignore_index=True)
-
- def test_crosstab_single(self):
- df = self.df
- result = crosstab(df["A"], df["C"])
- expected = df.groupby(["A", "C"]).size().unstack()
- tm.assert_frame_equal(result, expected.fillna(0).astype(np.int64))
-
- def test_crosstab_multiple(self):
- df = self.df
-
- result = crosstab(df["A"], [df["B"], df["C"]])
- expected = df.groupby(["A", "B", "C"]).size()
- expected = expected.unstack("B").unstack("C").fillna(0).astype(np.int64)
- tm.assert_frame_equal(result, expected)
-
- result = crosstab([df["B"], df["C"]], df["A"])
- expected = df.groupby(["B", "C", "A"]).size()
- expected = expected.unstack("A").fillna(0).astype(np.int64)
- tm.assert_frame_equal(result, expected)
-
- def test_crosstab_ndarray(self):
- a = np.random.randint(0, 5, size=100)
- b = np.random.randint(0, 3, size=100)
- c = np.random.randint(0, 10, size=100)
-
- df = DataFrame({"a": a, "b": b, "c": c})
-
- result = crosstab(a, [b, c], rownames=["a"], colnames=("b", "c"))
- expected = crosstab(df["a"], [df["b"], df["c"]])
- tm.assert_frame_equal(result, expected)
-
- result = crosstab([b, c], a, colnames=["a"], rownames=("b", "c"))
- expected = crosstab([df["b"], df["c"]], df["a"])
- tm.assert_frame_equal(result, expected)
-
- # assign arbitrary names
- result = crosstab(self.df["A"].values, self.df["C"].values)
- assert result.index.name == "row_0"
- assert result.columns.name == "col_0"
-
- def test_crosstab_non_aligned(self):
- # GH 17005
- a = pd.Series([0, 1, 1], index=["a", "b", "c"])
- b = pd.Series([3, 4, 3, 4, 3], index=["a", "b", "c", "d", "f"])
- c = np.array([3, 4, 3])
-
- expected = pd.DataFrame(
- [[1, 0], [1, 1]],
- index=Index([0, 1], name="row_0"),
- columns=Index([3, 4], name="col_0"),
- )
-
- result = crosstab(a, b)
- tm.assert_frame_equal(result, expected)
-
- result = crosstab(a, c)
- tm.assert_frame_equal(result, expected)
-
- def test_crosstab_margins(self):
- a = np.random.randint(0, 7, size=100)
- b = np.random.randint(0, 3, size=100)
- c = np.random.randint(0, 5, size=100)
-
- df = DataFrame({"a": a, "b": b, "c": c})
-
- result = crosstab(a, [b, c], rownames=["a"], colnames=("b", "c"), margins=True)
-
- assert result.index.names == ("a",)
- assert result.columns.names == ["b", "c"]
-
- all_cols = result["All", ""]
- exp_cols = df.groupby(["a"]).size().astype("i8")
- # to keep index.name
- exp_margin = Series([len(df)], index=Index(["All"], name="a"))
- exp_cols = exp_cols.append(exp_margin)
- exp_cols.name = ("All", "")
-
- tm.assert_series_equal(all_cols, exp_cols)
-
- all_rows = result.loc["All"]
- exp_rows = df.groupby(["b", "c"]).size().astype("i8")
- exp_rows = exp_rows.append(Series([len(df)], index=[("All", "")]))
- exp_rows.name = "All"
-
- exp_rows = exp_rows.reindex(all_rows.index)
- exp_rows = exp_rows.fillna(0).astype(np.int64)
- tm.assert_series_equal(all_rows, exp_rows)
-
- def test_crosstab_margins_set_margin_name(self):
- # GH 15972
- a = np.random.randint(0, 7, size=100)
- b = np.random.randint(0, 3, size=100)
- c = np.random.randint(0, 5, size=100)
-
- df = DataFrame({"a": a, "b": b, "c": c})
-
- result = crosstab(
- a,
- [b, c],
- rownames=["a"],
- colnames=("b", "c"),
- margins=True,
- margins_name="TOTAL",
- )
-
- assert result.index.names == ("a",)
- assert result.columns.names == ["b", "c"]
-
- all_cols = result["TOTAL", ""]
- exp_cols = df.groupby(["a"]).size().astype("i8")
- # to keep index.name
- exp_margin = Series([len(df)], index=Index(["TOTAL"], name="a"))
- exp_cols = exp_cols.append(exp_margin)
- exp_cols.name = ("TOTAL", "")
-
- tm.assert_series_equal(all_cols, exp_cols)
-
- all_rows = result.loc["TOTAL"]
- exp_rows = df.groupby(["b", "c"]).size().astype("i8")
- exp_rows = exp_rows.append(Series([len(df)], index=[("TOTAL", "")]))
- exp_rows.name = "TOTAL"
-
- exp_rows = exp_rows.reindex(all_rows.index)
- exp_rows = exp_rows.fillna(0).astype(np.int64)
- tm.assert_series_equal(all_rows, exp_rows)
-
- msg = "margins_name argument must be a string"
- for margins_name in [666, None, ["a", "b"]]:
- with pytest.raises(ValueError, match=msg):
- crosstab(
- a,
- [b, c],
- rownames=["a"],
- colnames=("b", "c"),
- margins=True,
- margins_name=margins_name,
- )
-
- def test_crosstab_pass_values(self):
- a = np.random.randint(0, 7, size=100)
- b = np.random.randint(0, 3, size=100)
- c = np.random.randint(0, 5, size=100)
- values = np.random.randn(100)
-
- table = crosstab(
- [a, b], c, values, aggfunc=np.sum, rownames=["foo", "bar"], colnames=["baz"]
- )
-
- df = DataFrame({"foo": a, "bar": b, "baz": c, "values": values})
-
- expected = df.pivot_table(
- "values", index=["foo", "bar"], columns="baz", aggfunc=np.sum
- )
- tm.assert_frame_equal(table, expected)
-
- def test_crosstab_dropna(self):
- # GH 3820
- a = np.array(["foo", "foo", "foo", "bar", "bar", "foo", "foo"], dtype=object)
- b = np.array(["one", "one", "two", "one", "two", "two", "two"], dtype=object)
- c = np.array(
- ["dull", "dull", "dull", "dull", "dull", "shiny", "shiny"], dtype=object
- )
- res = pd.crosstab(a, [b, c], rownames=["a"], colnames=["b", "c"], dropna=False)
- m = MultiIndex.from_tuples(
- [("one", "dull"), ("one", "shiny"), ("two", "dull"), ("two", "shiny")],
- names=["b", "c"],
- )
- tm.assert_index_equal(res.columns, m)
-
- def test_crosstab_no_overlap(self):
- # GS 10291
-
- s1 = pd.Series([1, 2, 3], index=[1, 2, 3])
- s2 = pd.Series([4, 5, 6], index=[4, 5, 6])
-
- actual = crosstab(s1, s2)
- expected = pd.DataFrame()
-
- tm.assert_frame_equal(actual, expected)
-
- def test_margin_dropna(self):
- # GH 12577
- # pivot_table counts null into margin ('All')
- # when margins=true and dropna=true
-
- df = pd.DataFrame({"a": [1, 2, 2, 2, 2, np.nan], "b": [3, 3, 4, 4, 4, 4]})
- actual = pd.crosstab(df.a, df.b, margins=True, dropna=True)
- expected = pd.DataFrame([[1, 0, 1], [1, 3, 4], [2, 3, 5]])
- expected.index = Index([1.0, 2.0, "All"], name="a")
- expected.columns = Index([3, 4, "All"], name="b")
- tm.assert_frame_equal(actual, expected)
-
- df = DataFrame(
- {"a": [1, np.nan, np.nan, np.nan, 2, np.nan], "b": [3, np.nan, 4, 4, 4, 4]}
- )
- actual = pd.crosstab(df.a, df.b, margins=True, dropna=True)
- expected = pd.DataFrame([[1, 0, 1], [0, 1, 1], [1, 1, 2]])
- expected.index = Index([1.0, 2.0, "All"], name="a")
- expected.columns = Index([3.0, 4.0, "All"], name="b")
- tm.assert_frame_equal(actual, expected)
-
- df = DataFrame(
- {"a": [1, np.nan, np.nan, np.nan, np.nan, 2], "b": [3, 3, 4, 4, 4, 4]}
- )
- actual = pd.crosstab(df.a, df.b, margins=True, dropna=True)
- expected = pd.DataFrame([[1, 0, 1], [0, 1, 1], [1, 1, 2]])
- expected.index = Index([1.0, 2.0, "All"], name="a")
- expected.columns = Index([3, 4, "All"], name="b")
- tm.assert_frame_equal(actual, expected)
-
- # GH 12642
- # _add_margins raises KeyError: Level None not found
- # when margins=True and dropna=False
- df = pd.DataFrame({"a": [1, 2, 2, 2, 2, np.nan], "b": [3, 3, 4, 4, 4, 4]})
- actual = pd.crosstab(df.a, df.b, margins=True, dropna=False)
- expected = pd.DataFrame([[1, 0, 1], [1, 3, 4], [2, 4, 6]])
- expected.index = Index([1.0, 2.0, "All"], name="a")
- expected.columns = Index([3, 4, "All"], name="b")
- tm.assert_frame_equal(actual, expected)
-
- df = DataFrame(
- {"a": [1, np.nan, np.nan, np.nan, 2, np.nan], "b": [3, np.nan, 4, 4, 4, 4]}
- )
- actual = pd.crosstab(df.a, df.b, margins=True, dropna=False)
- expected = pd.DataFrame([[1, 0, 1], [0, 1, 1], [1, 4, 6]])
- expected.index = Index([1.0, 2.0, "All"], name="a")
- expected.columns = Index([3.0, 4.0, "All"], name="b")
- tm.assert_frame_equal(actual, expected)
-
- a = np.array(["foo", "foo", "foo", "bar", "bar", "foo", "foo"], dtype=object)
- b = np.array(["one", "one", "two", "one", "two", np.nan, "two"], dtype=object)
- c = np.array(
- ["dull", "dull", "dull", "dull", "dull", "shiny", "shiny"], dtype=object
- )
-
- actual = pd.crosstab(
- a, [b, c], rownames=["a"], colnames=["b", "c"], margins=True, dropna=False
- )
- m = MultiIndex.from_arrays(
- [
- ["one", "one", "two", "two", "All"],
- ["dull", "shiny", "dull", "shiny", ""],
- ],
- names=["b", "c"],
- )
- expected = DataFrame(
- [[1, 0, 1, 0, 2], [2, 0, 1, 1, 5], [3, 0, 2, 1, 7]], columns=m
- )
- expected.index = Index(["bar", "foo", "All"], name="a")
- tm.assert_frame_equal(actual, expected)
-
- actual = pd.crosstab(
- [a, b], c, rownames=["a", "b"], colnames=["c"], margins=True, dropna=False
- )
- m = MultiIndex.from_arrays(
- [["bar", "bar", "foo", "foo", "All"], ["one", "two", "one", "two", ""]],
- names=["a", "b"],
- )
- expected = DataFrame(
- [[1, 0, 1], [1, 0, 1], [2, 0, 2], [1, 1, 2], [5, 2, 7]], index=m
- )
- expected.columns = Index(["dull", "shiny", "All"], name="c")
- tm.assert_frame_equal(actual, expected)
-
- actual = pd.crosstab(
- [a, b], c, rownames=["a", "b"], colnames=["c"], margins=True, dropna=True
- )
- m = MultiIndex.from_arrays(
- [["bar", "bar", "foo", "foo", "All"], ["one", "two", "one", "two", ""]],
- names=["a", "b"],
- )
- expected = DataFrame(
- [[1, 0, 1], [1, 0, 1], [2, 0, 2], [1, 1, 2], [5, 1, 6]], index=m
- )
- expected.columns = Index(["dull", "shiny", "All"], name="c")
- tm.assert_frame_equal(actual, expected)
-
- def test_crosstab_normalize(self):
- # Issue 12578
- df = pd.DataFrame(
- {"a": [1, 2, 2, 2, 2], "b": [3, 3, 4, 4, 4], "c": [1, 1, np.nan, 1, 1]}
- )
-
- rindex = pd.Index([1, 2], name="a")
- cindex = pd.Index([3, 4], name="b")
- full_normal = pd.DataFrame([[0.2, 0], [0.2, 0.6]], index=rindex, columns=cindex)
- row_normal = pd.DataFrame(
- [[1.0, 0], [0.25, 0.75]], index=rindex, columns=cindex
- )
- col_normal = pd.DataFrame([[0.5, 0], [0.5, 1.0]], index=rindex, columns=cindex)
-
- # Check all normalize args
- tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize="all"), full_normal)
- tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize=True), full_normal)
- tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize="index"), row_normal)
- tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize="columns"), col_normal)
- tm.assert_frame_equal(
- pd.crosstab(df.a, df.b, normalize=1),
- pd.crosstab(df.a, df.b, normalize="columns"),
- )
- tm.assert_frame_equal(
- pd.crosstab(df.a, df.b, normalize=0),
- pd.crosstab(df.a, df.b, normalize="index"),
- )
-
- row_normal_margins = pd.DataFrame(
- [[1.0, 0], [0.25, 0.75], [0.4, 0.6]],
- index=pd.Index([1, 2, "All"], name="a", dtype="object"),
- columns=pd.Index([3, 4], name="b", dtype="object"),
- )
- col_normal_margins = pd.DataFrame(
- [[0.5, 0, 0.2], [0.5, 1.0, 0.8]],
- index=pd.Index([1, 2], name="a", dtype="object"),
- columns=pd.Index([3, 4, "All"], name="b", dtype="object"),
- )
-
- all_normal_margins = pd.DataFrame(
- [[0.2, 0, 0.2], [0.2, 0.6, 0.8], [0.4, 0.6, 1]],
- index=pd.Index([1, 2, "All"], name="a", dtype="object"),
- columns=pd.Index([3, 4, "All"], name="b", dtype="object"),
- )
- tm.assert_frame_equal(
- pd.crosstab(df.a, df.b, normalize="index", margins=True), row_normal_margins
- )
- tm.assert_frame_equal(
- pd.crosstab(df.a, df.b, normalize="columns", margins=True),
- col_normal_margins,
- )
- tm.assert_frame_equal(
- pd.crosstab(df.a, df.b, normalize=True, margins=True), all_normal_margins
- )
-
- # Test arrays
- pd.crosstab(
- [np.array([1, 1, 2, 2]), np.array([1, 2, 1, 2])], np.array([1, 2, 1, 2])
- )
-
- # Test with aggfunc
- norm_counts = pd.DataFrame(
- [[0.25, 0, 0.25], [0.25, 0.5, 0.75], [0.5, 0.5, 1]],
- index=pd.Index([1, 2, "All"], name="a", dtype="object"),
- columns=pd.Index([3, 4, "All"], name="b"),
- )
- test_case = pd.crosstab(
- df.a, df.b, df.c, aggfunc="count", normalize="all", margins=True
- )
- tm.assert_frame_equal(test_case, norm_counts)
-
- df = pd.DataFrame(
- {"a": [1, 2, 2, 2, 2], "b": [3, 3, 4, 4, 4], "c": [0, 4, np.nan, 3, 3]}
- )
-
- norm_sum = pd.DataFrame(
- [[0, 0, 0.0], [0.4, 0.6, 1], [0.4, 0.6, 1]],
- index=pd.Index([1, 2, "All"], name="a", dtype="object"),
- columns=pd.Index([3, 4, "All"], name="b", dtype="object"),
- )
- test_case = pd.crosstab(
- df.a, df.b, df.c, aggfunc=np.sum, normalize="all", margins=True
- )
- tm.assert_frame_equal(test_case, norm_sum)
-
- def test_crosstab_with_empties(self):
- # Check handling of empties
- df = pd.DataFrame(
- {
- "a": [1, 2, 2, 2, 2],
- "b": [3, 3, 4, 4, 4],
- "c": [np.nan, np.nan, np.nan, np.nan, np.nan],
- }
- )
-
- empty = pd.DataFrame(
- [[0.0, 0.0], [0.0, 0.0]],
- index=pd.Index([1, 2], name="a", dtype="int64"),
- columns=pd.Index([3, 4], name="b"),
- )
-
- for i in [True, "index", "columns"]:
- calculated = pd.crosstab(
- df.a, df.b, values=df.c, aggfunc="count", normalize=i
- )
- tm.assert_frame_equal(empty, calculated)
-
- nans = pd.DataFrame(
- [[0.0, np.nan], [0.0, 0.0]],
- index=pd.Index([1, 2], name="a", dtype="int64"),
- columns=pd.Index([3, 4], name="b"),
- )
-
- calculated = pd.crosstab(
- df.a, df.b, values=df.c, aggfunc="count", normalize=False
- )
- tm.assert_frame_equal(nans, calculated)
-
- def test_crosstab_errors(self):
- # Issue 12578
-
- df = pd.DataFrame(
- {"a": [1, 2, 2, 2, 2], "b": [3, 3, 4, 4, 4], "c": [1, 1, np.nan, 1, 1]}
- )
-
- error = "values cannot be used without an aggfunc."
- with pytest.raises(ValueError, match=error):
- pd.crosstab(df.a, df.b, values=df.c)
-
- error = "aggfunc cannot be used without values"
- with pytest.raises(ValueError, match=error):
- pd.crosstab(df.a, df.b, aggfunc=np.mean)
-
- error = "Not a valid normalize argument"
- with pytest.raises(ValueError, match=error):
- pd.crosstab(df.a, df.b, normalize="42")
-
- with pytest.raises(ValueError, match=error):
- pd.crosstab(df.a, df.b, normalize=42)
-
- error = "Not a valid margins argument"
- with pytest.raises(ValueError, match=error):
- pd.crosstab(df.a, df.b, normalize="all", margins=42)
-
- def test_crosstab_with_categorial_columns(self):
- # GH 8860
- df = pd.DataFrame(
- {
- "MAKE": ["Honda", "Acura", "Tesla", "Honda", "Honda", "Acura"],
- "MODEL": ["Sedan", "Sedan", "Electric", "Pickup", "Sedan", "Sedan"],
- }
- )
- categories = ["Sedan", "Electric", "Pickup"]
- df["MODEL"] = df["MODEL"].astype("category").cat.set_categories(categories)
- result = pd.crosstab(df["MAKE"], df["MODEL"])
-
- expected_index = pd.Index(["Acura", "Honda", "Tesla"], name="MAKE")
- expected_columns = pd.CategoricalIndex(
- categories, categories=categories, ordered=False, name="MODEL"
- )
- expected_data = [[2, 0, 0], [2, 0, 1], [0, 1, 0]]
- expected = pd.DataFrame(
- expected_data, index=expected_index, columns=expected_columns
- )
- tm.assert_frame_equal(result, expected)
-
- def test_crosstab_with_numpy_size(self):
- # GH 4003
- df = pd.DataFrame(
- {
- "A": ["one", "one", "two", "three"] * 6,
- "B": ["A", "B", "C"] * 8,
- "C": ["foo", "foo", "foo", "bar", "bar", "bar"] * 4,
- "D": np.random.randn(24),
- "E": np.random.randn(24),
- }
- )
- result = pd.crosstab(
- index=[df["A"], df["B"]],
- columns=[df["C"]],
- margins=True,
- aggfunc=np.size,
- values=df["D"],
- )
- expected_index = pd.MultiIndex(
- levels=[["All", "one", "three", "two"], ["", "A", "B", "C"]],
- codes=[[1, 1, 1, 2, 2, 2, 3, 3, 3, 0], [1, 2, 3, 1, 2, 3, 1, 2, 3, 0]],
- names=["A", "B"],
- )
- expected_column = pd.Index(["bar", "foo", "All"], dtype="object", name="C")
- expected_data = np.array(
- [
- [2.0, 2.0, 4.0],
- [2.0, 2.0, 4.0],
- [2.0, 2.0, 4.0],
- [2.0, np.nan, 2.0],
- [np.nan, 2.0, 2.0],
- [2.0, np.nan, 2.0],
- [np.nan, 2.0, 2.0],
- [2.0, np.nan, 2.0],
- [np.nan, 2.0, 2.0],
- [12.0, 12.0, 24.0],
- ]
- )
- expected = pd.DataFrame(
- expected_data, index=expected_index, columns=expected_column
- )
- tm.assert_frame_equal(result, expected)
-
- def test_crosstab_dup_index_names(self):
- # GH 13279
- s = pd.Series(range(3), name="foo")
-
- result = pd.crosstab(s, s)
- expected_index = pd.Index(range(3), name="foo")
- expected = pd.DataFrame(
- np.eye(3, dtype=np.int64), index=expected_index, columns=expected_index
- )
- tm.assert_frame_equal(result, expected)
-
- @pytest.mark.parametrize("names", [["a", ("b", "c")], [("a", "b"), "c"]])
- def test_crosstab_tuple_name(self, names):
- s1 = pd.Series(range(3), name=names[0])
- s2 = pd.Series(range(1, 4), name=names[1])
-
- mi = pd.MultiIndex.from_arrays([range(3), range(1, 4)], names=names)
- expected = pd.Series(1, index=mi).unstack(1, fill_value=0)
-
- result = pd.crosstab(s1, s2)
- tm.assert_frame_equal(result, expected)
-
- def test_crosstab_both_tuple_names(self):
- # GH 18321
- s1 = pd.Series(range(3), name=("a", "b"))
- s2 = pd.Series(range(3), name=("c", "d"))
-
- expected = pd.DataFrame(
- np.eye(3, dtype="int64"),
- index=pd.Index(range(3), name=("a", "b")),
- columns=pd.Index(range(3), name=("c", "d")),
- )
- result = crosstab(s1, s2)
- tm.assert_frame_equal(result, expected)
-
- def test_crosstab_unsorted_order(self):
- df = pd.DataFrame({"b": [3, 1, 2], "a": [5, 4, 6]}, index=["C", "A", "B"])
- result = pd.crosstab(df.index, [df.b, df.a])
- e_idx = pd.Index(["A", "B", "C"], name="row_0")
- e_columns = pd.MultiIndex.from_tuples(
- [(1, 4), (2, 6), (3, 5)], names=["b", "a"]
- )
- expected = pd.DataFrame(
- [[1, 0, 0], [0, 1, 0], [0, 0, 1]], index=e_idx, columns=e_columns
- )
- tm.assert_frame_equal(result, expected)
-
- def test_crosstab_normalize_multiple_columns(self):
- # GH 15150
- df = pd.DataFrame(
- {
- "A": ["one", "one", "two", "three"] * 6,
- "B": ["A", "B", "C"] * 8,
- "C": ["foo", "foo", "foo", "bar", "bar", "bar"] * 4,
- "D": [0] * 24,
- "E": [0] * 24,
- }
- )
- result = pd.crosstab(
- [df.A, df.B],
- df.C,
- values=df.D,
- aggfunc=np.sum,
- normalize=True,
- margins=True,
- )
- expected = pd.DataFrame(
- np.array([0] * 29 + [1], dtype=float).reshape(10, 3),
- columns=Index(["bar", "foo", "All"], dtype="object", name="C"),
- index=MultiIndex.from_tuples(
- [
- ("one", "A"),
- ("one", "B"),
- ("one", "C"),
- ("three", "A"),
- ("three", "B"),
- ("three", "C"),
- ("two", "A"),
- ("two", "B"),
- ("two", "C"),
- ("All", ""),
- ],
- names=["A", "B"],
- ),
- )
- tm.assert_frame_equal(result, expected)
-
- def test_margin_normalize(self):
- # GH 27500
- df = pd.DataFrame(
- {
- "A": ["foo", "foo", "foo", "foo", "foo", "bar", "bar", "bar", "bar"],
- "B": ["one", "one", "one", "two", "two", "one", "one", "two", "two"],
- "C": [
- "small",
- "large",
- "large",
- "small",
- "small",
- "large",
- "small",
- "small",
- "large",
- ],
- "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
- "E": [2, 4, 5, 5, 6, 6, 8, 9, 9],
- }
- )
- # normalize on index
- result = pd.crosstab(
- [df.A, df.B], df.C, margins=True, margins_name="Sub-Total", normalize=0
- )
- expected = pd.DataFrame(
- [[0.5, 0.5], [0.5, 0.5], [0.666667, 0.333333], [0, 1], [0.444444, 0.555556]]
- )
- expected.index = MultiIndex(
- levels=[["Sub-Total", "bar", "foo"], ["", "one", "two"]],
- codes=[[1, 1, 2, 2, 0], [1, 2, 1, 2, 0]],
- names=["A", "B"],
- )
- expected.columns = Index(["large", "small"], dtype="object", name="C")
- tm.assert_frame_equal(result, expected)
-
- # normalize on columns
- result = pd.crosstab(
- [df.A, df.B], df.C, margins=True, margins_name="Sub-Total", normalize=1
- )
- expected = pd.DataFrame(
- [
- [0.25, 0.2, 0.222222],
- [0.25, 0.2, 0.222222],
- [0.5, 0.2, 0.333333],
- [0, 0.4, 0.222222],
- ]
- )
- expected.columns = Index(
- ["large", "small", "Sub-Total"], dtype="object", name="C"
- )
- expected.index = MultiIndex(
- levels=[["bar", "foo"], ["one", "two"]],
- codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
- names=["A", "B"],
- )
- tm.assert_frame_equal(result, expected)
-
- # normalize on both index and column
- result = pd.crosstab(
- [df.A, df.B], df.C, margins=True, margins_name="Sub-Total", normalize=True
- )
- expected = pd.DataFrame(
- [
- [0.111111, 0.111111, 0.222222],
- [0.111111, 0.111111, 0.222222],
- [0.222222, 0.111111, 0.333333],
- [0.000000, 0.222222, 0.222222],
- [0.444444, 0.555555, 1],
- ]
- )
- expected.columns = Index(
- ["large", "small", "Sub-Total"], dtype="object", name="C"
- )
- expected.index = MultiIndex(
- levels=[["Sub-Total", "bar", "foo"], ["", "one", "two"]],
- codes=[[1, 1, 2, 2, 0], [1, 2, 1, 2, 0]],
- names=["A", "B"],
- )
- tm.assert_frame_equal(result, expected)
| https://api.github.com/repos/pandas-dev/pandas/pulls/32536 | 2020-03-08T02:57:28Z | 2020-03-09T20:17:16Z | 2020-03-09T20:17:15Z | 2020-03-09T20:18:35Z | |
BUG: retain tz in to_records | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 48eff0543ad4d..77da6fe035248 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -356,6 +356,7 @@ Other
instead of ``TypeError: Can only append a Series if ignore_index=True or if the Series has a name`` (:issue:`30871`)
- Set operations on an object-dtype :class:`Index` now always return object-dtype results (:issue:`31401`)
- Bug in :meth:`AbstractHolidayCalendar.holidays` when no rules were defined (:issue:`31415`)
+- Bug in :meth:`DataFrame.to_records` incorrectly losing timezone information in timezone-aware ``datetime64`` columns (:issue:`32535`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b0909e23b44c5..b76b986c526ef 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1773,7 +1773,9 @@ def to_records(
else:
ix_vals = [self.index.values]
- arrays = ix_vals + [self[c]._internal_get_values() for c in self.columns]
+ arrays = ix_vals + [
+ np.asarray(self.iloc[:, i]) for i in range(len(self.columns))
+ ]
count = 0
index_names = list(self.index.names)
@@ -1788,7 +1790,7 @@ def to_records(
names = [str(name) for name in itertools.chain(index_names, self.columns)]
else:
- arrays = [self[c]._internal_get_values() for c in self.columns]
+ arrays = [np.asarray(self.iloc[:, i]) for i in range(len(self.columns))]
names = [str(c) for c in self.columns]
index_names = []
diff --git a/pandas/tests/frame/methods/test_to_records.py b/pandas/tests/frame/methods/test_to_records.py
index d0181f0309af1..34b323e55d8cd 100644
--- a/pandas/tests/frame/methods/test_to_records.py
+++ b/pandas/tests/frame/methods/test_to_records.py
@@ -3,7 +3,14 @@
import numpy as np
import pytest
-from pandas import CategoricalDtype, DataFrame, MultiIndex, Series, date_range
+from pandas import (
+ CategoricalDtype,
+ DataFrame,
+ MultiIndex,
+ Series,
+ Timestamp,
+ date_range,
+)
import pandas._testing as tm
@@ -18,6 +25,17 @@ def test_to_records_dt64(self):
result = df.to_records()["index"][0]
assert expected == result
+ def test_to_records_dt64tz_column(self):
+ # GH#32535 dont less tz in to_records
+ df = DataFrame({"A": date_range("2012-01-01", "2012-01-02", tz="US/Eastern")})
+
+ result = df.to_records()
+
+ assert result.dtype["A"] == object
+ val = result[0][1]
+ assert isinstance(val, Timestamp)
+ assert val == df.loc[0, "A"]
+
def test_to_records_with_multindex(self):
# GH#3189
index = [
| plus the initial motivation: get rid of two of our `_internal_get_values` calls (of which i count 16 left in master) | https://api.github.com/repos/pandas-dev/pandas/pulls/32535 | 2020-03-08T02:13:42Z | 2020-03-14T21:29:22Z | 2020-03-14T21:29:22Z | 2020-03-14T21:29:43Z |
CLN: remove unused in pd._testing | diff --git a/pandas/_testing.py b/pandas/_testing.py
index 33ec4e4886aa6..dcddb21cd1604 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -32,7 +32,6 @@
is_datetime64tz_dtype,
is_extension_array_dtype,
is_interval_dtype,
- is_list_like,
is_number,
is_period_dtype,
is_sequence,
@@ -417,10 +416,7 @@ def rands_array(nchars, size, dtype="O"):
.view((np.str_, nchars))
.reshape(size)
)
- if dtype is None:
- return retval
- else:
- return retval.astype(dtype)
+ return retval.astype(dtype)
def randu_array(nchars, size, dtype="O"):
@@ -432,10 +428,7 @@ def randu_array(nchars, size, dtype="O"):
.view((np.unicode_, nchars))
.reshape(size)
)
- if dtype is None:
- return retval
- else:
- return retval.astype(dtype)
+ return retval.astype(dtype)
def rands(nchars):
@@ -448,16 +441,6 @@ def rands(nchars):
return "".join(np.random.choice(RANDS_CHARS, nchars))
-def randu(nchars):
- """
- Generate one random unicode string.
-
- See `randu_array` if you want to create an array of random unicode strings.
-
- """
- return "".join(np.random.choice(RANDU_CHARS, nchars))
-
-
def close(fignum=None):
from matplotlib.pyplot import get_fignums, close as _close
@@ -724,10 +707,7 @@ def repr_class(x):
# return Index as it is to include values in the error message
return x
- try:
- return type(x).__name__
- except AttributeError:
- return repr(type(x))
+ return type(x).__name__
if exact == "equiv":
if type(left) != type(right):
@@ -2103,53 +2083,6 @@ def _gen_unique_rand(rng, _extra_size):
return i.tolist(), j.tolist()
-def makeMissingCustomDataframe(
- nrows,
- ncols,
- density=0.9,
- random_state=None,
- c_idx_names=True,
- r_idx_names=True,
- c_idx_nlevels=1,
- r_idx_nlevels=1,
- data_gen_f=None,
- c_ndupe_l=None,
- r_ndupe_l=None,
- dtype=None,
- c_idx_type=None,
- r_idx_type=None,
-):
- """
- Parameters
- ----------
- Density : float, optional
- Float in (0, 1) that gives the percentage of non-missing numbers in
- the DataFrame.
- random_state : {np.random.RandomState, int}, optional
- Random number generator or random seed.
-
- See makeCustomDataframe for descriptions of the rest of the parameters.
- """
- df = makeCustomDataframe(
- nrows,
- ncols,
- c_idx_names=c_idx_names,
- r_idx_names=r_idx_names,
- c_idx_nlevels=c_idx_nlevels,
- r_idx_nlevels=r_idx_nlevels,
- data_gen_f=data_gen_f,
- c_ndupe_l=c_ndupe_l,
- r_ndupe_l=r_ndupe_l,
- dtype=dtype,
- c_idx_type=c_idx_type,
- r_idx_type=r_idx_type,
- )
-
- i, j = _create_missing_idx(nrows, ncols, density, random_state)
- df.values[i, j] = np.nan
- return df
-
-
def makeMissingDataframe(density=0.9, random_state=None):
df = makeDataFrame()
i, j = _create_missing_idx(*df.shape, density=density, random_state=random_state)
@@ -2397,7 +2330,6 @@ def wrapper(*args, **kwargs):
def assert_produces_warning(
expected_warning=Warning,
filter_level="always",
- clear=None,
check_stacklevel=True,
raise_on_extra_warnings=True,
):
@@ -2427,12 +2359,6 @@ class for all warnings. To check that no warning is returned,
from each module
* "once" - print the warning the first time it is generated
- clear : str, default None
- If not ``None`` then remove any previously raised warnings from
- the ``__warningsregistry__`` to ensure that no warning messages are
- suppressed by this context manager. If ``None`` is specified,
- the ``__warningsregistry__`` keeps track of which warnings have been
- shown, and does not show them again.
check_stacklevel : bool, default True
If True, displays the line that called the function containing
the warning to show were the function is called. Otherwise, the
@@ -2465,19 +2391,6 @@ class for all warnings. To check that no warning is returned,
with warnings.catch_warnings(record=True) as w:
- if clear is not None:
- # make sure that we are clearing these warnings
- # if they have happened before
- # to guarantee that we will catch them
- if not is_list_like(clear):
- clear = [clear]
- for m in clear:
- try:
- m.__warningregistry__.clear()
- except AttributeError:
- # module may not have __warningregistry__
- pass
-
saw_warning = False
warnings.simplefilter(filter_level)
yield w
| https://api.github.com/repos/pandas-dev/pandas/pulls/32534 | 2020-03-07T23:52:18Z | 2020-03-10T11:24:34Z | 2020-03-10T11:24:34Z | 2020-03-10T15:03:19Z | |
CLN: remove unnecessary to_dense call | diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 2a528781f8c93..c879eaeda64e0 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1352,8 +1352,6 @@ def format_values_with(float_format):
values = self.values
is_complex = is_complex_dtype(values)
mask = isna(values)
- if hasattr(values, "to_dense"): # sparse numpy ndarray
- values = values.to_dense()
values = np.array(values, dtype="object")
values[mask] = na_rep
imask = (~mask).ravel()
| This call is not reached in the tests, and if it were the following line would make it superfluous anyway.
I'm pretty sure the comment there is wrong too. | https://api.github.com/repos/pandas-dev/pandas/pulls/32533 | 2020-03-07T23:40:04Z | 2020-03-10T13:31:26Z | 2020-03-10T13:31:26Z | 2020-03-10T14:54:35Z |
TYP: Add type hint for DataFrame.T and certain array types | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index ba4c2e168e0c4..da9eef995f193 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1317,7 +1317,7 @@ def __setstate__(self, state):
setattr(self, k, v)
@property
- def T(self):
+ def T(self) -> "Categorical":
"""
Return transposed numpy array.
"""
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 549606795f528..3b5e6b2d2bcd3 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -1296,14 +1296,14 @@ def mean(self, axis=0, *args, **kwargs):
nsparse = self.sp_index.ngaps
return (sp_sum + self.fill_value * nsparse) / (ct + nsparse)
- def transpose(self, *axes):
+ def transpose(self, *axes) -> "SparseArray":
"""
Returns the SparseArray.
"""
return self
@property
- def T(self):
+ def T(self) -> "SparseArray":
"""
Returns the SparseArray.
"""
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 60fc69e8222d6..aac012edf4222 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -2443,7 +2443,9 @@ def transpose(self, *args, copy: bool = False) -> "DataFrame":
return result.__finalize__(self)
- T = property(transpose)
+ @property
+ def T(self) -> "DataFrame":
+ return self.transpose()
# ----------------------------------------------------------------------
# Indexing Methods
| While updating a large pandas codebase with type coverage to 1.0, I noticed that `DataFrame.transpose()` is annotated to return `DataFrame` while `DataFrame.T` has no such hint. This PR also adds hints in a few places other places where they're trivial.
The definition of `pandas.core.base.IndexOpsMixIn.transpose` (and associated `.T`) currently do not have any type hints and fixing this seems more complicated, meaning `Index.T` and `Series.T` are not fixed by this PR.
Happy to amend to cover that case if anyone has suggestions, but I believe `DataFrame.T` to be the vast majority of usage.
- [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32532 | 2020-03-07T23:31:02Z | 2020-03-11T03:19:11Z | 2020-03-11T03:19:11Z | 2020-03-11T03:19:15Z |
DOC: Update pandas.core.groupby.GroupBy.pipe docstring | diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index 48c00140461b5..b30e5e3569c03 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -190,14 +190,14 @@ class providing the base-class of operations.
)
_pipe_template = """
-Apply a function `func` with arguments to this %(klass)s object and return
-the function's result.
+Apply a function `func` with arguments to this %(klass)s object and return the result.
%(versionadded)s
+Instead of writing:
Use `.pipe` when you want to improve readability by chaining together
functions that expect Series, DataFrames, GroupBy or Resampler objects.
-Instead of writing
+
>>> h(g(f(df.groupby('group')), arg1=a), arg2=b, arg3=c)
@@ -212,19 +212,20 @@ class providing the base-class of operations.
Parameters
----------
-func : callable or tuple of (callable, string)
- Function to apply to this %(klass)s object or, alternatively,
+func : callable or tuple of (callable, str)
+ Function to apply to this %(klass)s object or
a `(callable, data_keyword)` tuple where `data_keyword` is a
string indicating the keyword of `callable` that expects the
%(klass)s object.
-args : iterable, optional
- Positional arguments passed into `func`.
-kwargs : dict, optional
- A dictionary of keyword arguments passed into `func`.
+*args : iterable, optional
+ Positional arguments passed into `func`.
+**kwargs : dict, optional
+ A dictionary of keyword arguments passed into `func`.
Returns
-------
-object : the return type of `func`.
+object
+ The return type of `func`.
See Also
--------
| - [x] closes https://github.com/pandanistas/pandanistas_sprint_ui2020/issues/2
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32531 | 2020-03-07T22:09:02Z | 2020-03-31T17:41:31Z | null | 2020-03-31T17:41:32Z |
CI: Update web and docs to OVH with the right structure | diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a337ccbc98650..025b6f1813df7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -125,68 +125,32 @@ jobs:
- name: Check ipython directive errors
run: "! grep -B1 \"^<<<-------------------------------------------------------------------------$\" sphinx.log"
- - name: Merge website and docs
- run: |
- mkdir -p pandas_web/docs
- cp -r web/build/* pandas_web/
- cp -r doc/build/html/* pandas_web/docs/
- if: github.event_name == 'push'
-
- name: Install Rclone
run: sudo apt install rclone -y
if: github.event_name == 'push'
- name: Set up Rclone
run: |
- RCLONE_CONFIG_PATH=$HOME/.config/rclone/rclone.conf
- mkdir -p `dirname $RCLONE_CONFIG_PATH`
- echo "[ovh_cloud_pandas_web]" > $RCLONE_CONFIG_PATH
- echo "type = swift" >> $RCLONE_CONFIG_PATH
- echo "env_auth = false" >> $RCLONE_CONFIG_PATH
- echo "auth_version = 3" >> $RCLONE_CONFIG_PATH
- echo "auth = https://auth.cloud.ovh.net/v3/" >> $RCLONE_CONFIG_PATH
- echo "endpoint_type = public" >> $RCLONE_CONFIG_PATH
- echo "tenant_domain = default" >> $RCLONE_CONFIG_PATH
- echo "tenant = 2977553886518025" >> $RCLONE_CONFIG_PATH
- echo "domain = default" >> $RCLONE_CONFIG_PATH
- echo "user = w4KGs3pmDxpd" >> $RCLONE_CONFIG_PATH
- echo "key = ${{ secrets.ovh_object_store_key }}" >> $RCLONE_CONFIG_PATH
- echo "region = BHS" >> $RCLONE_CONFIG_PATH
+ CONF=$HOME/.config/rclone/rclone.conf
+ mkdir -p `dirname $CONF`
+ echo "[ovh_host]" > $CONF
+ echo "type = swift" >> $CONF
+ echo "env_auth = false" >> $CONF
+ echo "auth_version = 3" >> $CONF
+ echo "auth = https://auth.cloud.ovh.net/v3/" >> $CONF
+ echo "endpoint_type = public" >> $CONF
+ echo "tenant_domain = default" >> $CONF
+ echo "tenant = 2977553886518025" >> $CONF
+ echo "domain = default" >> $CONF
+ echo "user = w4KGs3pmDxpd" >> $CONF
+ echo "key = ${{ secrets.ovh_object_store_key }}" >> $CONF
+ echo "region = BHS" >> $CONF
if: github.event_name == 'push'
- name: Sync web with OVH
- run: rclone sync pandas_web ovh_cloud_pandas_web:dev
- if: github.event_name == 'push'
-
- - name: Create git repo to upload the built docs to GitHub pages
- run: |
- cd pandas_web
- git init
- touch .nojekyll
- echo "dev.pandas.io" > CNAME
- printf "User-agent: *\nDisallow: /" > robots.txt
- git add --all .
- git config user.email "pandas-dev@python.org"
- git config user.name "pandas-bot"
- git commit -m "pandas web and documentation in master"
+ run: rclone sync --exclude pandas-docs/** web/build ovh_host:prod
if: github.event_name == 'push'
- # For this task to work, next steps are required:
- # 1. Generate a pair of private/public keys (i.e. `ssh-keygen -t rsa -b 4096 -C "your_email@example.com"`)
- # 2. Go to https://github.com/pandas-dev/pandas/settings/secrets
- # 3. Click on "Add a new secret"
- # 4. Name: "github_pagas_ssh_key", Value: <Content of the private ssh key>
- # 5. The public key needs to be upladed to https://github.com/pandas-dev/pandas-dev.github.io/settings/keys
- - name: Install GitHub pages ssh deployment key
- uses: shimataro/ssh-key-action@v2
- with:
- key: ${{ secrets.github_pages_ssh_key }}
- known_hosts: 'github.com,192.30.252.128 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ=='
- if: github.event_name == 'push'
-
- - name: Publish web and docs to GitHub pages
- run: |
- cd pandas_web
- git remote add origin git@github.com:pandas-dev/pandas-dev.github.io.git
- git push -f origin master || true
+ - name: Sync dev docs with OVH
+ run: rclone sync doc/build/html ovh_host:prod/pandas-docs/dev
if: github.event_name == 'push'
| - [X] closes #32303
I'm uploading all the docs from the NumFOCUS server to the OVH (manually). And I'm changing the CI in this PR to upload the website and the dev docs to the server automatically.
I'll have a look and see if we can upload a new version of the docs automatically to OVH when a new GitHub release is generated. So, we never need to upload the website manually.
After merging this PR, and when we're confident this is working well, we'll have to redirect pandas.pydata.org to the OVH server. The dev docs will be available at pandas.pydata.org/pandas-docs/dev/ (and we can stop using pandas.io and dev.pandas.io). | https://api.github.com/repos/pandas-dev/pandas/pulls/32530 | 2020-03-07T21:53:36Z | 2020-03-11T12:58:03Z | 2020-03-11T12:58:03Z | 2020-03-20T16:36:14Z |
TST: make tests stricter | diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index d4baf2f374cdf..202e30287881f 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -913,13 +913,13 @@ def test_frame_operators(self, float_frame):
# 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):
+ def _check_op(series, other, op, pos_only=False):
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)
+ tm.assert_series_equal(cython_or_numpy, python)
def check(series, other):
simple_ops = ["add", "sub", "mul", "truediv", "floordiv", "mod"]
@@ -942,15 +942,15 @@ def check(series, other):
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)
+ def check_comparators(series, other):
+ _check_op(series, other, operator.gt)
+ _check_op(series, other, operator.ge)
+ _check_op(series, other, operator.eq)
+ _check_op(series, other, operator.lt)
+ _check_op(series, other, operator.le)
check_comparators(tser, 5)
- check_comparators(tser, tser + 1, check_dtype=False)
+ check_comparators(tser, tser + 1)
# TODO: taken from tests.series.test_operators; needs cleanup
def test_divmod(self):
diff --git a/pandas/tests/dtypes/cast/test_construct_from_scalar.py b/pandas/tests/dtypes/cast/test_construct_from_scalar.py
index cc823a3d6e02c..ed272cef3e7ba 100644
--- a/pandas/tests/dtypes/cast/test_construct_from_scalar.py
+++ b/pandas/tests/dtypes/cast/test_construct_from_scalar.py
@@ -15,6 +15,4 @@ def test_cast_1d_array_like_from_scalar_categorical():
expected = Categorical(["a", "a"], categories=cats)
result = construct_1d_arraylike_from_scalar("a", len(expected), cat_type)
- tm.assert_categorical_equal(
- result, expected, check_category_order=True, check_dtype=True
- )
+ tm.assert_categorical_equal(result, expected)
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 071d2409f1be2..172800e74d181 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -916,10 +916,7 @@ def test_constructor_mrecarray(self):
# from GH3479
assert_fr_equal = functools.partial(
- tm.assert_frame_equal,
- check_index_type=True,
- check_column_type=True,
- check_frame_type=True,
+ tm.assert_frame_equal, check_index_type=True, check_column_type=True,
)
arrays = [
("float", np.array([1.5, 2.0])),
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index 59899673cfc31..7ef4c454c5a5d 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -452,7 +452,7 @@ def test_float_types(self, np_type, path):
reader = ExcelFile(path)
recons = pd.read_excel(reader, "test1", index_col=0).astype(np_type)
- tm.assert_frame_equal(df, recons, check_dtype=False)
+ tm.assert_frame_equal(df, recons)
@pytest.mark.parametrize("np_type", [np.bool8, np.bool_])
def test_bool_types(self, np_type, path):
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index f2d35bfb3b5ae..276dfd666c5d0 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -572,7 +572,6 @@ def test_blocks_compat_GH9037(self):
df_roundtrip,
check_index_type=True,
check_column_type=True,
- check_frame_type=True,
by_blocks=True,
check_exact=True,
)
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index e966db7a1cc71..e86667626deda 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -48,6 +48,18 @@ def numpy(request):
return request.param
+def get_int32_compat_dtype(numpy, orient):
+ # See GH#32527
+ dtype = np.int64
+ if not ((numpy is None or orient == "index") or (numpy is True and orient is None)):
+ if compat.is_platform_windows():
+ dtype = np.int32
+ else:
+ dtype = np.intp
+
+ return dtype
+
+
class TestUltraJSONTests:
@pytest.mark.skipif(
compat.is_platform_32bit(), reason="not compliant on 32-bit, xref #15865"
@@ -833,13 +845,20 @@ def test_dataframe(self, orient, numpy):
if orient == "records" and numpy:
pytest.skip("Not idiomatic pandas")
+ dtype = get_int32_compat_dtype(numpy, orient)
+
df = DataFrame(
- [[1, 2, 3], [4, 5, 6]], index=["a", "b"], columns=["x", "y", "z"]
+ [[1, 2, 3], [4, 5, 6]],
+ index=["a", "b"],
+ columns=["x", "y", "z"],
+ dtype=dtype,
)
encode_kwargs = {} if orient is None else dict(orient=orient)
decode_kwargs = {} if numpy is None else dict(numpy=numpy)
+ assert (df.dtypes == dtype).all()
output = ujson.decode(ujson.encode(df, **encode_kwargs), **decode_kwargs)
+ assert (df.dtypes == dtype).all()
# Ensure proper DataFrame initialization.
if orient == "split":
@@ -857,7 +876,8 @@ def test_dataframe(self, orient, numpy):
elif orient == "index":
df = df.transpose()
- tm.assert_frame_equal(output, df, check_dtype=False)
+ assert (df.dtypes == dtype).all()
+ tm.assert_frame_equal(output, df)
def test_dataframe_nested(self, orient):
df = DataFrame(
@@ -897,14 +917,20 @@ def test_dataframe_numpy_labelled(self, orient):
tm.assert_frame_equal(output, df)
def test_series(self, orient, numpy):
+ dtype = get_int32_compat_dtype(numpy, orient)
s = Series(
- [10, 20, 30, 40, 50, 60], name="series", index=[6, 7, 8, 9, 10, 15]
+ [10, 20, 30, 40, 50, 60],
+ name="series",
+ index=[6, 7, 8, 9, 10, 15],
+ dtype=dtype,
).sort_values()
+ assert s.dtype == dtype
encode_kwargs = {} if orient is None else dict(orient=orient)
decode_kwargs = {} if numpy is None else dict(numpy=numpy)
output = ujson.decode(ujson.encode(s, **encode_kwargs), **decode_kwargs)
+ assert s.dtype == dtype
if orient == "split":
dec = _clean_dict(output)
@@ -920,7 +946,8 @@ def test_series(self, orient, numpy):
s.name = None
s.index = [0, 1, 2, 3, 4, 5]
- tm.assert_series_equal(output, s, check_dtype=False)
+ assert s.dtype == dtype
+ tm.assert_series_equal(output, s)
def test_series_nested(self, orient):
s = Series(
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 2702d378fd153..61ca2e7f5f19d 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -2298,9 +2298,7 @@ def test_index_types(self, setup_path):
with catch_warnings(record=True):
values = np.random.randn(2)
- func = lambda l, r: tm.assert_series_equal(
- l, r, check_dtype=True, check_index_type=True
- )
+ func = lambda l, r: tm.assert_series_equal(l, r, check_index_type=True)
with catch_warnings(record=True):
ser = Series(values, [0, "y"])
diff --git a/pandas/tests/io/test_clipboard.py b/pandas/tests/io/test_clipboard.py
index 3458cfb6ad254..b627e0e1cad54 100644
--- a/pandas/tests/io/test_clipboard.py
+++ b/pandas/tests/io/test_clipboard.py
@@ -75,7 +75,11 @@ def df(request):
)
elif data_type == "mixed":
return DataFrame(
- {"a": np.arange(1.0, 6.0) + 0.01, "b": np.arange(1, 6), "c": list("abcde")}
+ {
+ "a": np.arange(1.0, 6.0) + 0.01,
+ "b": np.arange(1, 6).astype(np.int64),
+ "c": list("abcde"),
+ }
)
elif data_type == "float":
return tm.makeCustomDataframe(
@@ -146,7 +150,7 @@ class TestClipboard:
def check_round_trip_frame(self, data, excel=None, sep=None, encoding=None):
data.to_clipboard(excel=excel, sep=sep, encoding=encoding)
result = read_clipboard(sep=sep or "\t", index_col=0, encoding=encoding)
- tm.assert_frame_equal(data, result, check_dtype=False)
+ tm.assert_frame_equal(data, result)
# Test that default arguments copy as tab delimited
def test_round_trip_frame(self, df):
diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py
index 725157b7c8523..dc1efa46403be 100644
--- a/pandas/tests/reshape/merge/test_join.py
+++ b/pandas/tests/reshape/merge/test_join.py
@@ -298,7 +298,7 @@ def test_join_on_inner(self):
expected = df.join(df2, on="key")
expected = expected[expected["value"].notna()]
- tm.assert_series_equal(joined["key"], expected["key"], check_dtype=False)
+ tm.assert_series_equal(joined["key"], expected["key"])
tm.assert_series_equal(joined["value"], expected["value"], check_dtype=False)
tm.assert_index_equal(joined.index, expected.index)
diff --git a/pandas/tests/reshape/test_union_categoricals.py b/pandas/tests/reshape/test_union_categoricals.py
index a503173bd74b1..8918d19e4ba7b 100644
--- a/pandas/tests/reshape/test_union_categoricals.py
+++ b/pandas/tests/reshape/test_union_categoricals.py
@@ -41,7 +41,7 @@ def test_union_categorical(self):
for box in [Categorical, CategoricalIndex, Series]:
result = union_categoricals([box(Categorical(a)), box(Categorical(b))])
expected = Categorical(combined)
- tm.assert_categorical_equal(result, expected, check_category_order=True)
+ tm.assert_categorical_equal(result, expected)
# new categories ordered by appearance
s = Categorical(["x", "y", "z"])
diff --git a/pandas/tests/series/methods/test_argsort.py b/pandas/tests/series/methods/test_argsort.py
index c7fe6ed19a2eb..4353eb4c8cd64 100644
--- a/pandas/tests/series/methods/test_argsort.py
+++ b/pandas/tests/series/methods/test_argsort.py
@@ -49,8 +49,8 @@ def test_argsort_stable(self):
mexpected = np.argsort(s.values, kind="mergesort")
qexpected = np.argsort(s.values, kind="quicksort")
- tm.assert_series_equal(mindexer, Series(mexpected), check_dtype=False)
- tm.assert_series_equal(qindexer, Series(qexpected), check_dtype=False)
+ tm.assert_series_equal(mindexer.astype(np.intp), Series(mexpected))
+ tm.assert_series_equal(qindexer.astype(np.intp), Series(qexpected))
msg = (
r"ndarray Expected type <class 'numpy\.ndarray'>, "
r"found <class 'pandas\.core\.series\.Series'> instead"
diff --git a/pandas/tests/series/methods/test_replace.py b/pandas/tests/series/methods/test_replace.py
index 26eaf53616282..904a455870ab1 100644
--- a/pandas/tests/series/methods/test_replace.py
+++ b/pandas/tests/series/methods/test_replace.py
@@ -294,7 +294,7 @@ def test_replace_categorical(self, categorical, numeric):
s = pd.Series(categorical)
result = s.replace({"A": 1, "B": 2})
expected = pd.Series(numeric)
- tm.assert_series_equal(expected, result, check_dtype=False)
+ tm.assert_series_equal(expected, result)
def test_replace_categorical_single(self):
# GH 26988
diff --git a/pandas/tests/series/test_duplicates.py b/pandas/tests/series/test_duplicates.py
index 3513db6177951..89181a08819b1 100644
--- a/pandas/tests/series/test_duplicates.py
+++ b/pandas/tests/series/test_duplicates.py
@@ -47,9 +47,9 @@ def test_unique():
# GH 18051
s = Series(Categorical([]))
- tm.assert_categorical_equal(s.unique(), Categorical([]), check_dtype=False)
+ tm.assert_categorical_equal(s.unique(), Categorical([]))
s = Series(Categorical([np.nan]))
- tm.assert_categorical_equal(s.unique(), Categorical([np.nan]), check_dtype=False)
+ tm.assert_categorical_equal(s.unique(), Categorical([np.nan]))
def test_unique_data_ownership():
| I expect to see some platform-specific failures, will be nice to document those where possible. | https://api.github.com/repos/pandas-dev/pandas/pulls/32527 | 2020-03-07T19:52:24Z | 2020-03-14T03:41:07Z | 2020-03-14T03:41:06Z | 2020-03-14T16:09:26Z |
TST: remove unused kwargs in assert_sp_array_equal | diff --git a/pandas/_testing.py b/pandas/_testing.py
index 33ec4e4886aa6..c30810f724245 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -1491,14 +1491,7 @@ def to_array(obj):
# Sparse
-def assert_sp_array_equal(
- left,
- right,
- check_dtype=True,
- check_kind=True,
- check_fill_value=True,
- consolidate_block_indices=False,
-):
+def assert_sp_array_equal(left, right):
"""
Check that the left and right SparseArray are equal.
@@ -1506,38 +1499,17 @@ def assert_sp_array_equal(
----------
left : SparseArray
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.arrays.SparseArray)
- assert_numpy_array_equal(left.sp_values, right.sp_values, check_dtype=check_dtype)
+ assert_numpy_array_equal(left.sp_values, right.sp_values)
# SparseIndex comparison
assert isinstance(left.sp_index, pd._libs.sparse.SparseIndex)
assert isinstance(right.sp_index, pd._libs.sparse.SparseIndex)
- 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()
+ left_index = left.sp_index
+ right_index = right.sp_index
if not left_index.equals(right_index):
raise_assert_detail(
@@ -1547,11 +1519,9 @@ def assert_sp_array_equal(
# Just ensure a
pass
- 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.to_dense(), right.to_dense(), check_dtype=check_dtype)
+ assert_attr_equal("fill_value", left, right)
+ assert_attr_equal("dtype", left, right)
+ assert_numpy_array_equal(left.to_dense(), right.to_dense())
# -----------------------------------------------------------------------------
| https://api.github.com/repos/pandas-dev/pandas/pulls/32525 | 2020-03-07T19:02:03Z | 2020-03-10T11:43:37Z | 2020-03-10T11:43:37Z | 2020-03-10T15:01:32Z | |
CLN: avoid Block.get_values in io.sql | diff --git a/pandas/io/sql.py b/pandas/io/sql.py
index 9a53e7cd241e1..560e7e4781cbb 100644
--- a/pandas/io/sql.py
+++ b/pandas/io/sql.py
@@ -705,8 +705,16 @@ def insert_data(self):
else:
# convert to microsecond resolution for datetime.datetime
d = b.values.astype("M8[us]").astype(object)
+ elif b.is_timedelta:
+ # numpy converts this to an object array of integers,
+ # whereas b.astype(object).values would convert to
+ # object array of Timedeltas
+ d = b.values.astype(object)
else:
- d = np.array(b.get_values(), dtype=object)
+ # TODO(2DEA): astype-first can be avoided with 2D EAs
+ # astype on the block instead of values to ensure we
+ # get the right shape
+ d = b.astype(object).values
# replace NaN with None
if b._can_hold_na:
| This particular usage is especially non-transparent, since it is effectively `blk.get_values().astype(object)` which is apparently _not_ equivalent to `blk.get_values(object)` | https://api.github.com/repos/pandas-dev/pandas/pulls/32524 | 2020-03-07T18:27:24Z | 2020-03-11T02:52:55Z | 2020-03-11T02:52:55Z | 2020-03-11T03:07:37Z |
CLN: simplify get_values usage in groupby | diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index ac522fc7863b2..b7ac3048631c5 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -49,7 +49,7 @@
is_scalar,
needs_i8_conversion,
)
-from pandas.core.dtypes.missing import _isna_ndarraylike, isna, notna
+from pandas.core.dtypes.missing import isna, notna
from pandas.core.aggregation import (
is_multi_agg_with_relabel,
@@ -1772,10 +1772,8 @@ def count(self):
ids, _, ngroups = self.grouper.group_info
mask = ids != -1
- vals = (
- (mask & ~_isna_ndarraylike(np.atleast_2d(blk.get_values())))
- for blk in data.blocks
- )
+ # TODO(2DEA): reshape would not be necessary with 2D EAs
+ vals = ((mask & ~isna(blk.values).reshape(blk.shape)) for blk in data.blocks)
locs = (blk.mgr_locs for blk in data.blocks)
counted = (
| This will avoid an object-casting for e.g. IntervalArray-backed ExtensionBlock. | https://api.github.com/repos/pandas-dev/pandas/pulls/32523 | 2020-03-07T18:17:49Z | 2020-03-11T02:52:01Z | 2020-03-11T02:52:00Z | 2020-03-11T03:10:49Z |
CLN: remove SingleBlockManager.get_values | diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index 98afc5ac3a0e3..b21b3d1b475d9 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -1596,10 +1596,6 @@ def internal_values(self):
"""The array that Series._values returns"""
return self._block.internal_values()
- def get_values(self) -> np.ndarray:
- """ return a dense type view """
- return np.array(self._block.to_dense(), copy=False)
-
@property
def _can_hold_na(self) -> bool:
return self._block._can_hold_na
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 568e99622dd29..96177da1698a5 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -537,7 +537,8 @@ def _internal_get_values(self):
numpy.ndarray
Data of the Series.
"""
- return self._data.get_values()
+ blk = self._data._block
+ return np.array(blk.to_dense(), copy=False)
# ops
def ravel(self, order="C"):
| It is only used in one place, and its behavior doesn't match `self.blocks[0].get_values()`, which is counter-intuitive. | https://api.github.com/repos/pandas-dev/pandas/pulls/32522 | 2020-03-07T18:14:02Z | 2020-03-11T02:20:33Z | 2020-03-11T02:20:33Z | 2020-03-11T14:42:41Z |
CLN: rename get_block_values, simplify | diff --git a/pandas/_libs/src/ujson/python/objToJSON.c b/pandas/_libs/src/ujson/python/objToJSON.c
index 8cfc20ffd2c1c..1d17cce0bc3a9 100644
--- a/pandas/_libs/src/ujson/python/objToJSON.c
+++ b/pandas/_libs/src/ujson/python/objToJSON.c
@@ -237,9 +237,9 @@ static PyObject *get_values(PyObject *obj) {
}
}
- if ((values == NULL) && PyObject_HasAttrString(obj, "get_block_values")) {
+ if ((values == NULL) && PyObject_HasAttrString(obj, "get_block_values_for_json")) {
PRINTMARK();
- values = PyObject_CallMethod(obj, "get_block_values", NULL);
+ values = PyObject_CallMethod(obj, "get_block_values_for_json", NULL);
if (values == NULL) {
// Clear so we can subsequently try another method
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index c088b7020927b..c14225672154b 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -231,11 +231,12 @@ def get_values(self, dtype=None):
return self.values.astype(object)
return self.values
- def get_block_values(self, dtype=None):
+ def get_block_values_for_json(self) -> np.ndarray:
"""
- This is used in the JSON C code
+ This is used in the JSON C code.
"""
- return self.get_values(dtype=dtype)
+ # TODO(2DEA): reshape will be unnecessary with 2D EAs
+ return np.asarray(self.values).reshape(self.shape)
def to_dense(self):
return self.values.view()
| cc @WillAyd name more explicit, implementation more transparent. | https://api.github.com/repos/pandas-dev/pandas/pulls/32521 | 2020-03-07T17:23:11Z | 2020-03-11T02:22:42Z | 2020-03-11T02:22:42Z | 2020-03-11T02:27:23Z |
BUG: Multiindexed series .at fix | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 3b60085e9fa66..f98bd53b6cdf8 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -731,6 +731,7 @@ Indexing
- Bug in :meth:`Series.__getitem__` allowing missing labels with ``np.ndarray``, :class:`Index`, :class:`Series` indexers but not ``list``, these now all raise ``KeyError`` (:issue:`33646`)
- Bug in :meth:`DataFrame.truncate` and :meth:`Series.truncate` where index was assumed to be monotone increasing (:issue:`33756`)
- Indexing with a list of strings representing datetimes failed on :class:`DatetimeIndex` or :class:`PeriodIndex`(:issue:`11278`)
+- Bug in :meth:`Series.at` when used with a :class:`MultiIndex` would raise an exception on valid inputs (:issue:`26989`)
Missing
^^^^^^^
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index b857a59195695..3a146bb0438c5 100644
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -2016,10 +2016,10 @@ def __setitem__(self, key, value):
if not isinstance(key, tuple):
key = _tuplify(self.ndim, key)
+ key = list(self._convert_key(key, is_setter=True))
if len(key) != self.ndim:
raise ValueError("Not enough indexers for scalar access (setting)!")
- key = list(self._convert_key(key, is_setter=True))
self.obj._set_value(*key, value=value, takeable=self._takeable)
@@ -2032,6 +2032,12 @@ def _convert_key(self, key, is_setter: bool = False):
Require they keys to be the same type as the index. (so we don't
fallback)
"""
+ # GH 26989
+ # For series, unpacking key needs to result in the label.
+ # This is already the case for len(key) == 1; e.g. (1,)
+ if self.ndim == 1 and len(key) > 1:
+ key = (key,)
+
# allow arbitrary setting
if is_setter:
return list(key)
diff --git a/pandas/tests/indexing/test_scalar.py b/pandas/tests/indexing/test_scalar.py
index 216d554e22b49..4337f01ea33e0 100644
--- a/pandas/tests/indexing/test_scalar.py
+++ b/pandas/tests/indexing/test_scalar.py
@@ -351,3 +351,65 @@ def test_iat_series_with_period_index():
expected = ser[index[0]]
result = ser.iat[0]
assert expected == result
+
+
+def test_at_with_tuple_index_get():
+ # GH 26989
+ # DataFrame.at getter works with Index of tuples
+ df = DataFrame({"a": [1, 2]}, index=[(1, 2), (3, 4)])
+ assert df.index.nlevels == 1
+ assert df.at[(1, 2), "a"] == 1
+
+ # Series.at getter works with Index of tuples
+ series = df["a"]
+ assert series.index.nlevels == 1
+ assert series.at[(1, 2)] == 1
+
+
+def test_at_with_tuple_index_set():
+ # GH 26989
+ # DataFrame.at setter works with Index of tuples
+ df = DataFrame({"a": [1, 2]}, index=[(1, 2), (3, 4)])
+ assert df.index.nlevels == 1
+ df.at[(1, 2), "a"] = 2
+ assert df.at[(1, 2), "a"] == 2
+
+ # Series.at setter works with Index of tuples
+ series = df["a"]
+ assert series.index.nlevels == 1
+ series.at[1, 2] = 3
+ assert series.at[1, 2] == 3
+
+
+def test_multiindex_at_get():
+ # GH 26989
+ # DataFrame.at and DataFrame.loc getter works with MultiIndex
+ df = DataFrame({"a": [1, 2]}, index=[[1, 2], [3, 4]])
+ assert df.index.nlevels == 2
+ assert df.at[(1, 3), "a"] == 1
+ assert df.loc[(1, 3), "a"] == 1
+
+ # Series.at and Series.loc getter works with MultiIndex
+ series = df["a"]
+ assert series.index.nlevels == 2
+ assert series.at[1, 3] == 1
+ assert series.loc[1, 3] == 1
+
+
+def test_multiindex_at_set():
+ # GH 26989
+ # DataFrame.at and DataFrame.loc setter works with MultiIndex
+ df = DataFrame({"a": [1, 2]}, index=[[1, 2], [3, 4]])
+ assert df.index.nlevels == 2
+ df.at[(1, 3), "a"] = 3
+ assert df.at[(1, 3), "a"] == 3
+ df.loc[(1, 3), "a"] = 4
+ assert df.loc[(1, 3), "a"] == 4
+
+ # Series.at and Series.loc setter works with MultiIndex
+ series = df["a"]
+ assert series.index.nlevels == 2
+ series.at[1, 3] = 5
+ assert series.at[1, 3] == 5
+ series.loc[1, 3] = 6
+ assert series.loc[1, 3] == 6
| - [x] closes #26989
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32520 | 2020-03-07T17:00:57Z | 2020-05-25T22:07:51Z | 2020-05-25T22:07:50Z | 2020-07-11T16:02:07Z |
TST: fix test creating invalid CategoricalBlock | diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index f07fa99fe57d6..83980e9028e9a 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1739,6 +1739,10 @@ def __init__(self, values, placement, ndim=None):
values = self._maybe_coerce_values(values)
super().__init__(values, placement, ndim)
+ if self.ndim == 2 and len(self.mgr_locs) != 1:
+ # TODO(2DEA): check unnecessary with 2D EAs
+ raise AssertionError("block.size != values.size")
+
def _maybe_coerce_values(self, values):
"""
Unbox to an extension array.
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 0bbea671bae19..1a7d5839d9a11 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -540,6 +540,13 @@ def _compare(old_mgr, new_mgr):
assert new_mgr.get("g").dtype == np.float64
assert new_mgr.get("h").dtype == np.float16
+ def test_invalid_ea_block(self):
+ with pytest.raises(AssertionError, match="block.size != values.size"):
+ create_mgr("a: category; b: category")
+
+ with pytest.raises(AssertionError, match="block.size != values.size"):
+ create_mgr("a: category2; b: category2")
+
def test_interleave(self):
# self
@@ -552,14 +559,10 @@ def test_interleave(self):
# will be converted according the actual dtype of the underlying
mgr = create_mgr("a: category")
assert mgr.as_array().dtype == "i8"
- mgr = create_mgr("a: category; b: category")
- assert mgr.as_array().dtype == "i8"
mgr = create_mgr("a: category; b: category2")
assert mgr.as_array().dtype == "object"
mgr = create_mgr("a: category2")
assert mgr.as_array().dtype == "object"
- mgr = create_mgr("a: category2; b: category2")
- assert mgr.as_array().dtype == "object"
# combinations
mgr = create_mgr("a: f8")
@@ -702,7 +705,7 @@ def test_equals(self):
"a:i8;b:f8", # basic case
"a:i8;b:f8;c:c8;d:b", # many types
"a:i8;e:dt;f:td;g:string", # more types
- "a:i8;b:category;c:category2;d:category2", # categories
+ "a:i8;b:category;c:category2", # categories
"c:sparse;d:sparse_na;b:f8", # sparse
],
)
| The incorrect tests here turned up when trying to replace Block.get_values calls with simpler alternatives. | https://api.github.com/repos/pandas-dev/pandas/pulls/32519 | 2020-03-07T16:24:17Z | 2020-03-14T15:50:17Z | 2020-03-14T15:50:16Z | 2020-03-14T15:50:59Z |
CLN: removed unused import | diff --git a/pandas/_libs/tslibs/np_datetime.pyx b/pandas/_libs/tslibs/np_datetime.pyx
index b59a1101e0bf7..9a8a8fdae6d2f 100644
--- a/pandas/_libs/tslibs/np_datetime.pyx
+++ b/pandas/_libs/tslibs/np_datetime.pyx
@@ -1,12 +1,15 @@
from cpython.object cimport Py_EQ, Py_NE, Py_GE, Py_GT, Py_LT, Py_LE
-from cpython.datetime cimport (datetime, date,
- PyDateTime_IMPORT,
- PyDateTime_GET_YEAR, PyDateTime_GET_MONTH,
- PyDateTime_GET_DAY, PyDateTime_DATE_GET_HOUR,
- PyDateTime_DATE_GET_MINUTE,
- PyDateTime_DATE_GET_SECOND,
- PyDateTime_DATE_GET_MICROSECOND)
+from cpython.datetime cimport (
+ PyDateTime_DATE_GET_HOUR,
+ PyDateTime_DATE_GET_MICROSECOND,
+ PyDateTime_DATE_GET_MINUTE,
+ PyDateTime_DATE_GET_SECOND,
+ PyDateTime_GET_DAY,
+ PyDateTime_GET_MONTH,
+ PyDateTime_GET_YEAR,
+ PyDateTime_IMPORT,
+)
PyDateTime_IMPORT
from numpy cimport int64_t
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
---
Not 100% sure about this, can close anytime if not a good PR | https://api.github.com/repos/pandas-dev/pandas/pulls/32518 | 2020-03-07T13:43:01Z | 2020-03-12T17:24:36Z | 2020-03-12T17:24:35Z | 2020-03-14T14:06:31Z |
CLN: Suppres compile warnings of pandas/io/sas/sas.pyx | diff --git a/pandas/io/sas/sas.pyx b/pandas/io/sas/sas.pyx
index 40fea0aaf0d07..11171af1e0c82 100644
--- a/pandas/io/sas/sas.pyx
+++ b/pandas/io/sas/sas.pyx
@@ -120,7 +120,7 @@ cdef const uint8_t[:] rdc_decompress(int result_length, const uint8_t[:] inbuff)
cdef:
uint8_t cmd
- uint16_t ctrl_bits, ctrl_mask = 0, ofs, cnt
+ uint16_t ctrl_bits = 0, ctrl_mask = 0, ofs, cnt
int rpos = 0, k
uint8_t[:] outbuff = np.zeros(result_length, dtype=np.uint8)
Py_ssize_t ipos = 0, length = len(inbuff)
| - [x] ref #32163
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
---
This is the warning that get removed:
```
pandas/io/sas/sas.c: In function ‘__pyx_f_6pandas_2io_3sas_4_sas_rdc_decompress’:
pandas/io/sas/sas.c:3732:65: warning: ‘__pyx_v_ctrl_bits’ may be used uninitialized in this function [-Wmaybe-uninitialized]
3732 | __pyx_t_8 = (((__pyx_v_ctrl_bits & __pyx_v_ctrl_mask) == 0) != 0);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/32517 | 2020-03-07T13:15:03Z | 2020-03-12T04:46:18Z | 2020-03-12T04:46:18Z | 2020-03-13T16:59:08Z |
Deprecate Aliases as orient Argument in DataFrame.to_dict | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 48eff0543ad4d..3a7c7e798ed88 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -175,7 +175,7 @@ Deprecations
- Lookups on a :class:`Series` with a single-item list containing a slice (e.g. ``ser[[slice(0, 4)]]``) are deprecated, will raise in a future version. Either convert the list to tuple, or pass the slice directly instead (:issue:`31333`)
- :meth:`DataFrame.mean` and :meth:`DataFrame.median` with ``numeric_only=None`` will include datetime64 and datetime64tz columns in a future version (:issue:`29941`)
- Setting values with ``.loc`` using a positional slice is deprecated and will raise in a future version. Use ``.loc`` with labels or ``.iloc`` with positions instead (:issue:`31840`)
--
+- :meth:`DataFrame.to_dict` has deprecated accepting short names for ``orient`` in future versions (:issue:`32515`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index b0909e23b44c5..204c916c88fa0 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -1401,11 +1401,45 @@ def to_dict(self, orient="dict", into=dict):
)
# GH16122
into_c = com.standardize_mapping(into)
- if orient.lower().startswith("d"):
+
+ orient = orient.lower()
+ # GH32515
+ if orient.startswith(("d", "l", "s", "r", "i")) and orient not in {
+ "dict",
+ "list",
+ "series",
+ "split",
+ "records",
+ "index",
+ }:
+ warnings.warn(
+ "Using short name for 'orient' is deprecated. Only the "
+ "options: ('dict', list, 'series', 'split', 'records', 'index') "
+ "will be used in a future version. Use one of the above "
+ "to silence this warning.",
+ FutureWarning,
+ )
+
+ if orient.startswith("d"):
+ orient = "dict"
+ elif orient.startswith("l"):
+ orient = "list"
+ elif orient.startswith("sp"):
+ orient = "split"
+ elif orient.startswith("s"):
+ orient = "series"
+ elif orient.startswith("r"):
+ orient = "records"
+ elif orient.startswith("i"):
+ orient = "index"
+
+ if orient == "dict":
return into_c((k, v.to_dict(into)) for k, v in self.items())
- elif orient.lower().startswith("l"):
+
+ elif orient == "list":
return into_c((k, v.tolist()) for k, v in self.items())
- elif orient.lower().startswith("sp"):
+
+ elif orient == "split":
return into_c(
(
("index", self.index.tolist()),
@@ -1419,9 +1453,11 @@ def to_dict(self, orient="dict", into=dict):
),
)
)
- elif orient.lower().startswith("s"):
+
+ elif orient == "series":
return into_c((k, com.maybe_box_datetimelike(v)) for k, v in self.items())
- elif orient.lower().startswith("r"):
+
+ elif orient == "records":
columns = self.columns.tolist()
rows = (
dict(zip(columns, row))
@@ -1431,13 +1467,15 @@ def to_dict(self, orient="dict", into=dict):
into_c((k, com.maybe_box_datetimelike(v)) for k, v in row.items())
for row in rows
]
- elif orient.lower().startswith("i"):
+
+ elif orient == "index":
if not self.index.is_unique:
raise ValueError("DataFrame index must be unique for orient='index'.")
return into_c(
(t[0], dict(zip(self.columns, t[1:])))
for t in self.itertuples(name=None)
)
+
else:
raise ValueError(f"orient '{orient}' not understood")
diff --git a/pandas/tests/frame/methods/test_to_dict.py b/pandas/tests/frame/methods/test_to_dict.py
index cd9bd169322fd..f1656b46cf356 100644
--- a/pandas/tests/frame/methods/test_to_dict.py
+++ b/pandas/tests/frame/methods/test_to_dict.py
@@ -70,8 +70,17 @@ def test_to_dict_invalid_orient(self):
with pytest.raises(ValueError, match=msg):
df.to_dict(orient="xinvalid")
+ @pytest.mark.parametrize("orient", ["d", "l", "r", "sp", "s", "i"])
+ def test_to_dict_short_orient_warns(self, orient):
+ # GH#32515
+ df = DataFrame({"A": [0, 1]})
+ with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+ df.to_dict(orient=orient)
+
@pytest.mark.parametrize("mapping", [dict, defaultdict(list), OrderedDict])
def test_to_dict(self, mapping):
+ # orient= should only take the listed options
+ # see GH#32515
test_data = {"A": {"1": 1, "2": 2}, "B": {"1": "1", "2": "2", "3": "3"}}
# GH#16122
@@ -81,19 +90,19 @@ def test_to_dict(self, mapping):
for k2, v2 in v.items():
assert v2 == recons_data[k][k2]
- recons_data = DataFrame(test_data).to_dict("l", mapping)
+ recons_data = DataFrame(test_data).to_dict("list", mapping)
for k, v in test_data.items():
for k2, v2 in v.items():
assert v2 == recons_data[k][int(k2) - 1]
- recons_data = DataFrame(test_data).to_dict("s", mapping)
+ recons_data = DataFrame(test_data).to_dict("series", mapping)
for k, v in test_data.items():
for k2, v2 in v.items():
assert v2 == recons_data[k][k2]
- recons_data = DataFrame(test_data).to_dict("sp", mapping)
+ recons_data = DataFrame(test_data).to_dict("split", mapping)
expected_split = {
"columns": ["A", "B"],
"index": ["1", "2", "3"],
@@ -101,7 +110,7 @@ def test_to_dict(self, mapping):
}
tm.assert_dict_equal(recons_data, expected_split)
- recons_data = DataFrame(test_data).to_dict("r", mapping)
+ recons_data = DataFrame(test_data).to_dict("records", mapping)
expected_records = [
{"A": 1.0, "B": "1"},
{"A": 2.0, "B": "2"},
@@ -113,7 +122,7 @@ def test_to_dict(self, mapping):
tm.assert_dict_equal(l, r)
# GH#10844
- recons_data = DataFrame(test_data).to_dict("i")
+ recons_data = DataFrame(test_data).to_dict("index")
for k, v in test_data.items():
for k2, v2 in v.items():
@@ -121,7 +130,7 @@ def test_to_dict(self, mapping):
df = DataFrame(test_data)
df["duped"] = df[df.columns[0]]
- recons_data = df.to_dict("i")
+ recons_data = df.to_dict("index")
comp_data = test_data.copy()
comp_data["duped"] = comp_data[df.columns[0]]
for k, v in comp_data.items():
| - [ x] closes #32515
- [x ] tests added / passed
- [x ] passes `black pandas`
- [x ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x ] whatsnew entry | https://api.github.com/repos/pandas-dev/pandas/pulls/32516 | 2020-03-07T12:53:26Z | 2020-03-14T21:33:06Z | 2020-03-14T21:33:06Z | 2020-06-01T14:52:06Z |
CLN: remove check_series_type | diff --git a/pandas/_testing.py b/pandas/_testing.py
index 33ec4e4886aa6..5e94ac3b3d108 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -34,6 +34,7 @@
is_interval_dtype,
is_list_like,
is_number,
+ is_numeric_dtype,
is_period_dtype,
is_sequence,
is_timedelta64_dtype,
@@ -1064,7 +1065,6 @@ def assert_series_equal(
right,
check_dtype=True,
check_index_type="equiv",
- check_series_type=True,
check_less_precise=False,
check_names=True,
check_exact=False,
@@ -1085,8 +1085,6 @@ def assert_series_equal(
check_index_type : bool or {'equiv'}, default 'equiv'
Whether to check the Index class, dtype and inferred_type
are identical.
- check_series_type : bool, default True
- Whether to check the Series class is identical.
check_less_precise : bool or int, default False
Specify comparison precision. Only used when check_exact is False.
5 digits (False) or 3 digits (True) after decimal points are compared.
@@ -1118,11 +1116,10 @@ def assert_series_equal(
# instance validation
_check_isinstance(left, right, Series)
- if check_series_type:
- # ToDo: There are some tests using rhs is sparse
- # lhs is dense. Should use assert_class_equal in future
- assert isinstance(left, type(right))
- # assert_class_equal(left, right, obj=obj)
+ # TODO: There are some tests using rhs is sparse
+ # lhs is dense. Should use assert_class_equal in future
+ assert isinstance(left, type(right))
+ # assert_class_equal(left, right, obj=obj)
# length comparison
if len(left) != len(right):
@@ -1147,8 +1144,8 @@ def assert_series_equal(
# is False. We'll still raise if only one is a `Categorical`,
# regardless of `check_categorical`
if (
- is_categorical_dtype(left)
- and is_categorical_dtype(right)
+ is_categorical_dtype(left.dtype)
+ and is_categorical_dtype(right.dtype)
and not check_categorical
):
pass
@@ -1156,38 +1153,31 @@ def assert_series_equal(
assert_attr_equal("dtype", left, right, obj=f"Attributes of {obj}")
if check_exact:
+ if not is_numeric_dtype(left.dtype):
+ raise AssertionError("check_exact may only be used with numeric Series")
+
assert_numpy_array_equal(
- left._internal_get_values(),
- right._internal_get_values(),
- check_dtype=check_dtype,
- obj=str(obj),
+ left._values, right._values, check_dtype=check_dtype, obj=str(obj)
)
- elif check_datetimelike_compat:
+ elif check_datetimelike_compat and (
+ needs_i8_conversion(left.dtype) or needs_i8_conversion(right.dtype)
+ ):
# we want to check only if we have compat dtypes
# e.g. integer and M|m are NOT compat, but we can simply check
# the values in that case
- if needs_i8_conversion(left) or needs_i8_conversion(right):
-
- # datetimelike may have different objects (e.g. datetime.datetime
- # vs Timestamp) but will compare equal
- if not Index(left._values).equals(Index(right._values)):
- msg = (
- f"[datetimelike_compat=True] {left._values} "
- f"is not equal to {right._values}."
- )
- raise AssertionError(msg)
- else:
- assert_numpy_array_equal(
- left._internal_get_values(),
- right._internal_get_values(),
- check_dtype=check_dtype,
+
+ # datetimelike may have different objects (e.g. datetime.datetime
+ # vs Timestamp) but will compare equal
+ if not Index(left._values).equals(Index(right._values)):
+ msg = (
+ f"[datetimelike_compat=True] {left._values} "
+ f"is not equal to {right._values}."
)
- elif is_interval_dtype(left) or is_interval_dtype(right):
+ raise AssertionError(msg)
+ elif is_interval_dtype(left.dtype) or is_interval_dtype(right.dtype):
assert_interval_array_equal(left.array, right.array)
- elif is_extension_array_dtype(left.dtype) and is_datetime64tz_dtype(left.dtype):
+ elif is_datetime64tz_dtype(left.dtype):
# .values is an ndarray, but ._values is the ExtensionArray.
- # TODO: Use .array
- assert is_extension_array_dtype(right.dtype)
assert_extension_array_equal(left._values, right._values)
elif (
is_extension_array_dtype(left)
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index fd585a73f6ce6..888222b503b10 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -2312,7 +2312,7 @@ def test_index_types(self, setup_path):
values = np.random.randn(2)
func = lambda l, r: tm.assert_series_equal(
- l, r, check_dtype=True, check_index_type=True, check_series_type=True
+ l, r, check_dtype=True, check_index_type=True
)
with catch_warnings(record=True):
| Trying to clean up assert_series_equal and avoid usage of _internal_get_values; I'm finding that these functions are _weird_, and in particular categorical dtype handling is opaque | https://api.github.com/repos/pandas-dev/pandas/pulls/32513 | 2020-03-07T04:52:54Z | 2020-03-08T16:13:46Z | 2020-03-08T16:13:46Z | 2020-03-09T21:13:50Z |
[BUG] add consistency to_numeric on empty list | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 21e59805fa143..a48278d1ce81a 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -268,6 +268,7 @@ Numeric
^^^^^^^
- Bug in :meth:`DataFrame.floordiv` with ``axis=0`` not treating division-by-zero like :meth:`Series.floordiv` (:issue:`31271`)
- Bug in :meth:`to_numeric` with string argument ``"uint64"`` and ``errors="coerce"`` silently fails (:issue:`32394`)
+- Bug in :meth:`to_numeric` with ``downcast="unsigned"`` fails for empty data (:issue:`32493`)
-
Conversion
diff --git a/pandas/core/tools/numeric.py b/pandas/core/tools/numeric.py
index 7d1e4bbd8fb05..a6198f8b752ae 100644
--- a/pandas/core/tools/numeric.py
+++ b/pandas/core/tools/numeric.py
@@ -162,7 +162,7 @@ def to_numeric(arg, errors="raise", downcast=None):
if downcast in ("integer", "signed"):
typecodes = np.typecodes["Integer"]
- elif downcast == "unsigned" and np.min(values) >= 0:
+ elif downcast == "unsigned" and (not len(values) or np.min(values) >= 0):
typecodes = np.typecodes["UnsignedInteger"]
elif downcast == "float":
typecodes = np.typecodes["Float"]
diff --git a/pandas/tests/tools/test_to_numeric.py b/pandas/tests/tools/test_to_numeric.py
index e0dfeac4ab475..263887a8ea36e 100644
--- a/pandas/tests/tools/test_to_numeric.py
+++ b/pandas/tests/tools/test_to_numeric.py
@@ -629,6 +629,18 @@ def test_non_coerce_uint64_conflict(errors, exp):
tm.assert_series_equal(result, ser)
+@pytest.mark.parametrize("dc1", ["integer", "float", "unsigned"])
+@pytest.mark.parametrize("dc2", ["integer", "float", "unsigned"])
+def test_downcast_empty(dc1, dc2):
+ # GH32493
+
+ tm.assert_numpy_array_equal(
+ pd.to_numeric([], downcast=dc1),
+ pd.to_numeric([], downcast=dc2),
+ check_dtype=False,
+ )
+
+
def test_failure_to_convert_uint64_string_to_NaN():
# GH 32394
result = to_numeric("uint64", errors="coerce")
| to_numeric should work similarly on empty lists for
downcast=unsigned/float/integer
Addresses: GH32493
- [x] closes #32493
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32512 | 2020-03-07T04:52:51Z | 2020-03-16T02:30:10Z | 2020-03-16T02:30:10Z | 2020-03-20T02:04:17Z |
[BUG] Add int-array-like into random state | diff --git a/pandas/_testing.py b/pandas/_testing.py
index 33ec4e4886aa6..1b6a350e814f4 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -2125,7 +2125,7 @@ def makeMissingCustomDataframe(
Density : float, optional
Float in (0, 1) that gives the percentage of non-missing numbers in
the DataFrame.
- random_state : {np.random.RandomState, int}, optional
+ random_state : {np.random.RandomState, int, integer array like}, optional
Random number generator or random seed.
See makeCustomDataframe for descriptions of the rest of the parameters.
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 6230ee34bcd50..aa3b417bdc31a 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -22,6 +22,7 @@
is_bool_dtype,
is_extension_array_dtype,
is_integer,
+ is_list_like,
)
from pandas.core.dtypes.generic import ABCIndex, ABCIndexClass, ABCSeries
from pandas.core.dtypes.inference import _iterable_not_string
@@ -408,13 +409,16 @@ def random_state(state=None):
"""
if is_integer(state):
return np.random.RandomState(state)
+ elif is_list_like(state) and all(is_integer(item) for item in state):
+ return np.random.RandomState(state)
elif isinstance(state, np.random.RandomState):
return state
elif state is None:
return np.random
else:
raise ValueError(
- "random_state must be an integer, a numpy RandomState, or None"
+ "random_state must be an integer, integer array like,"
+ "a numpy RandomState, or None"
)
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index f7196073162df..c121d426274b8 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -4691,7 +4691,7 @@ def sample(
If weights do not sum to 1, they will be normalized to sum to 1.
Missing values in the weights column will be treated as zero.
Infinite values not allowed.
- random_state : int or numpy.random.RandomState, optional
+ random_state : int, integer array like or numpy.random.RandomState, optional
Seed for the random number generator (if int), or numpy RandomState
object.
axis : {0 or ‘index’, 1 or ‘columns’, None}, default None
diff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py
index 186c735a0bff9..da5d955e2c71d 100644
--- a/pandas/tests/test_common.py
+++ b/pandas/tests/test_common.py
@@ -56,11 +56,18 @@ def test_random_state():
state2 = npr.RandomState(10)
assert com.random_state(state2).uniform() == npr.RandomState(10).uniform()
+ # Check with array ike
+ state3 = com.random_state([1, 5, 10])
+ assert com.random_state(state3).uniform() == npr.RandomState([1, 5, 10]).uniform()
+
# check with no arg random state
assert com.random_state() is np.random
# Error for floats or strings
- msg = "random_state must be an integer, a numpy RandomState, or None"
+ msg = (
+ "random_state must be an integer, integer array like,"
+ "a numpy RandomState, or None"
+ )
with pytest.raises(ValueError, match=msg):
com.random_state("test")
| - [x] closes #32503
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32511 | 2020-03-07T04:12:27Z | 2020-03-11T00:36:34Z | null | 2020-03-11T00:36:34Z |
[BUG] Loosen random_state input restriction | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 21e59805fa143..6bd5723c5efcf 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -69,6 +69,7 @@ Other enhancements
- `OptionError` is now exposed in `pandas.errors` (:issue:`27553`)
- :func:`timedelta_range` will now infer a frequency when passed ``start``, ``stop``, and ``periods`` (:issue:`32377`)
- Positional slicing on a :class:`IntervalIndex` now supports slices with ``step > 1`` (:issue:`31658`)
+- :meth:`DataFrame.sample` will now also allow array-like and BitGenerator objects to be passed to ``random_state`` as seeds (:issue:`32503`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/common.py b/pandas/core/common.py
index 6230ee34bcd50..d9ce65d44177b 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -15,6 +15,7 @@
from pandas._libs import lib, tslibs
from pandas._typing import T
+from pandas.compat.numpy import _np_version_under1p17
from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
from pandas.core.dtypes.common import (
@@ -395,18 +396,30 @@ def random_state(state=None):
Parameters
----------
- state : int, np.random.RandomState, None.
- If receives an int, passes to np.random.RandomState() as seed.
+ state : int, array-like, BitGenerator (NumPy>=1.17), np.random.RandomState, None.
+ If receives an int, array-like, or BitGenerator, passes to
+ np.random.RandomState() as seed.
If receives an np.random.RandomState object, just returns object.
If receives `None`, returns np.random.
If receives anything else, raises an informative ValueError.
+
+ ..versionchanged:: 1.1.0
+
+ array-like and BitGenerator (for NumPy>=1.17) object now passed to
+ np.random.RandomState() as seed
+
Default None.
Returns
-------
np.random.RandomState
+
"""
- if is_integer(state):
+ if (
+ is_integer(state)
+ or is_array_like(state)
+ or (not _np_version_under1p17 and isinstance(state, np.random.BitGenerator))
+ ):
return np.random.RandomState(state)
elif isinstance(state, np.random.RandomState):
return state
@@ -414,7 +427,10 @@ def random_state(state=None):
return np.random
else:
raise ValueError(
- "random_state must be an integer, a numpy RandomState, or None"
+ (
+ "random_state must be an integer, array-like, a BitGenerator, "
+ "a numpy RandomState, or None"
+ )
)
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 8d56311331d4d..ba4d6dee7f984 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -4794,9 +4794,16 @@ def sample(
If weights do not sum to 1, they will be normalized to sum to 1.
Missing values in the weights column will be treated as zero.
Infinite values not allowed.
- random_state : int or numpy.random.RandomState, optional
- Seed for the random number generator (if int), or numpy RandomState
- object.
+ random_state : int, array-like, BitGenerator, np.random.RandomState, optional
+ If int, array-like, or BitGenerator (NumPy>=1.17), seed for
+ random number generator
+ If np.random.RandomState, use as numpy RandomState object.
+
+ ..versionchanged:: 1.1.0
+
+ array-like and BitGenerator (for NumPy>=1.17) object now passed to
+ np.random.RandomState() as seed
+
axis : {0 or ‘index’, 1 or ‘columns’, None}, default None
Axis to sample. Accepts axis number or name. Default is stat axis
for given data type (0 for Series and DataFrames).
diff --git a/pandas/tests/generic/test_generic.py b/pandas/tests/generic/test_generic.py
index 9c759ff1414fe..6999dea6adfa3 100644
--- a/pandas/tests/generic/test_generic.py
+++ b/pandas/tests/generic/test_generic.py
@@ -3,11 +3,14 @@
import numpy as np
import pytest
+from pandas.compat.numpy import _np_version_under1p17
+
from pandas.core.dtypes.common import is_scalar
import pandas as pd
from pandas import DataFrame, MultiIndex, Series, date_range
import pandas._testing as tm
+import pandas.core.common as com
# ----------------------------------------------------------------------
# Generic types test cases
@@ -641,6 +644,29 @@ def test_sample(sel):
with pytest.raises(ValueError):
df.sample(1, weights=s4)
+ @pytest.mark.parametrize(
+ "func_str,arg",
+ [
+ ("np.array", [2, 3, 1, 0]),
+ pytest.param(
+ "np.random.MT19937",
+ 3,
+ marks=pytest.mark.skipif(_np_version_under1p17, reason="NumPy<1.17"),
+ ),
+ pytest.param(
+ "np.random.PCG64",
+ 11,
+ marks=pytest.mark.skipif(_np_version_under1p17, reason="NumPy<1.17"),
+ ),
+ ],
+ )
+ def test_sample_random_state(self, func_str, arg):
+ # GH32503
+ df = pd.DataFrame({"col1": range(10, 20), "col2": range(20, 30)})
+ result = df.sample(n=3, random_state=eval(func_str)(arg))
+ expected = df.sample(n=3, random_state=com.random_state(eval(func_str)(arg)))
+ tm.assert_frame_equal(result, expected)
+
def test_squeeze(self):
# noop
for s in [tm.makeFloatSeries(), tm.makeStringSeries(), tm.makeObjectSeries()]:
diff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py
index 186c735a0bff9..bcfed2d0d3a10 100644
--- a/pandas/tests/test_common.py
+++ b/pandas/tests/test_common.py
@@ -6,6 +6,8 @@
import numpy as np
import pytest
+from pandas.compat.numpy import _np_version_under1p17
+
import pandas as pd
from pandas import Series, Timestamp
from pandas.core import ops
@@ -59,8 +61,31 @@ def test_random_state():
# check with no arg random state
assert com.random_state() is np.random
+ # check array-like
+ # GH32503
+ state_arr_like = npr.randint(0, 2 ** 31, size=624, dtype="uint32")
+ assert (
+ com.random_state(state_arr_like).uniform()
+ == npr.RandomState(state_arr_like).uniform()
+ )
+
+ # Check BitGenerators
+ # GH32503
+ if not _np_version_under1p17:
+ assert (
+ com.random_state(npr.MT19937(3)).uniform()
+ == npr.RandomState(npr.MT19937(3)).uniform()
+ )
+ assert (
+ com.random_state(npr.PCG64(11)).uniform()
+ == npr.RandomState(npr.PCG64(11)).uniform()
+ )
+
# Error for floats or strings
- msg = "random_state must be an integer, a numpy RandomState, or None"
+ msg = (
+ "random_state must be an integer, array-like, a BitGenerator, "
+ "a numpy RandomState, or None"
+ )
with pytest.raises(ValueError, match=msg):
com.random_state("test")
| Alllow for array-like as well as BitGenerator inputs
Addresses: GH32503
- [x] closes #32503
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32510 | 2020-03-07T02:57:25Z | 2020-03-17T02:38:05Z | 2020-03-17T02:38:04Z | 2020-03-17T02:38:05Z |
CLN: unused code in reshape.merge | diff --git a/pandas/core/reshape/merge.py b/pandas/core/reshape/merge.py
index c301d6e7c7155..08c04cb49f125 100644
--- a/pandas/core/reshape/merge.py
+++ b/pandas/core/reshape/merge.py
@@ -92,9 +92,7 @@ def merge(
merge.__doc__ = _merge_doc % "\nleft : DataFrame"
-def _groupby_and_merge(
- by, on, left, right: "DataFrame", _merge_pieces, check_duplicates: bool = True
-):
+def _groupby_and_merge(by, on, left: "DataFrame", right: "DataFrame", merge_pieces):
"""
groupby & merge; we are always performing a left-by type operation
@@ -102,11 +100,9 @@ def _groupby_and_merge(
----------
by: field to group
on: duplicates field
- left: left frame
- right: right frame
- _merge_pieces: function for merging
- check_duplicates: bool, default True
- should we check & clean duplicates
+ left: DataFrame
+ right: DataFrame
+ merge_pieces: function for merging
"""
pieces = []
if not isinstance(by, (list, tuple)):
@@ -118,18 +114,6 @@ def _groupby_and_merge(
# if we can groupby the rhs
# then we can get vastly better perf
- # we will check & remove duplicates if indicated
- if check_duplicates:
- if on is None:
- on = []
- elif not isinstance(on, (list, tuple)):
- on = [on]
-
- if right.duplicated(by + on).any():
- _right = right.drop_duplicates(by + on, keep="last")
- # TODO: use overload to refine return type of drop_duplicates
- assert _right is not None # needed for mypy
- right = _right
try:
rby = right.groupby(by, sort=False)
except KeyError:
@@ -151,16 +135,13 @@ def _groupby_and_merge(
pieces.append(merged)
continue
- merged = _merge_pieces(lhs, rhs)
+ merged = merge_pieces(lhs, rhs)
# make sure join keys are in the merged
- # TODO, should _merge_pieces do this?
+ # TODO, should merge_pieces do this?
for k in by:
- try:
- if k in merged:
- merged[k] = key
- except KeyError:
- pass
+ if k in merged:
+ merged[k] = key
pieces.append(merged)
@@ -287,16 +268,11 @@ def _merger(x, y):
raise ValueError("Can only group either left or right frames")
elif left_by is not None:
result, _ = _groupby_and_merge(
- left_by, on, left, right, lambda x, y: _merger(x, y), check_duplicates=False
+ left_by, on, left, right, lambda x, y: _merger(x, y)
)
elif right_by is not None:
result, _ = _groupby_and_merge(
- right_by,
- on,
- right,
- left,
- lambda x, y: _merger(y, x),
- check_duplicates=False,
+ right_by, on, right, left, lambda x, y: _merger(y, x)
)
else:
result = _merger(left, right)
@@ -1605,11 +1581,6 @@ def _validate_specification(self):
if self.direction not in ["backward", "forward", "nearest"]:
raise MergeError(f"direction invalid: {self.direction}")
- @property
- def _asof_key(self):
- """ This is our asof key, the 'on' """
- return self.left_on[-1]
-
def _get_merge_keys(self):
# note this function has side effects
| check_duplicates is always passed as False, so we can trim some code | https://api.github.com/repos/pandas-dev/pandas/pulls/32509 | 2020-03-07T01:56:29Z | 2020-03-10T11:48:33Z | 2020-03-10T11:48:33Z | 2020-03-10T15:01:00Z |
CLN: avoid values_from_object in nanops | diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py
index 4398a1569ac56..f0883528db69f 100644
--- a/pandas/core/nanops.py
+++ b/pandas/core/nanops.py
@@ -32,6 +32,8 @@
)
from pandas.core.dtypes.missing import isna, na_value_for_dtype, notna
+from pandas.core.construction import extract_array
+
bn = import_optional_dependency("bottleneck", raise_on_missing=False, on_version="warn")
_BOTTLENECK_INSTALLED = bn is not None
_USE_BOTTLENECK = False
@@ -284,14 +286,8 @@ def _get_values(
mask = _maybe_get_mask(values, skipna, mask)
- if is_datetime64tz_dtype(values):
- # lib.values_from_object returns M8[ns] dtype instead of tz-aware,
- # so this case must be handled separately from the rest
- dtype = values.dtype
- values = getattr(values, "_values", values)
- else:
- values = lib.values_from_object(values)
- dtype = values.dtype
+ values = extract_array(values, extract_numpy=True)
+ dtype = values.dtype
if is_datetime_or_timedelta_dtype(values) or is_datetime64tz_dtype(values):
# changing timedelta64/datetime64 to int64 needs to happen after
@@ -758,7 +754,7 @@ def nanvar(values, axis=None, skipna=True, ddof=1, mask=None):
>>> nanops.nanvar(s)
1.0
"""
- values = lib.values_from_object(values)
+ values = extract_array(values, extract_numpy=True)
dtype = values.dtype
mask = _maybe_get_mask(values, skipna, mask)
if is_any_int_dtype(values):
@@ -985,7 +981,7 @@ def nanskew(
>>> nanops.nanskew(s)
1.7320508075688787
"""
- values = lib.values_from_object(values)
+ values = extract_array(values, extract_numpy=True)
mask = _maybe_get_mask(values, skipna, mask)
if not is_float_dtype(values.dtype):
values = values.astype("f8")
@@ -1069,7 +1065,7 @@ def nankurt(
>>> nanops.nankurt(s)
-1.2892561983471076
"""
- values = lib.values_from_object(values)
+ values = extract_array(values, extract_numpy=True)
mask = _maybe_get_mask(values, skipna, mask)
if not is_float_dtype(values.dtype):
values = values.astype("f8")
| - [ ] closes #xxxx
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32508 | 2020-03-06T23:40:32Z | 2020-03-08T16:09:09Z | 2020-03-08T16:09:09Z | 2020-03-16T15:03:06Z |
CLN: Avoid bare pytest.raises in computation/test_eval.py | diff --git a/pandas/tests/computation/test_eval.py b/pandas/tests/computation/test_eval.py
index a240e6cef5930..08d8d5ca342b7 100644
--- a/pandas/tests/computation/test_eval.py
+++ b/pandas/tests/computation/test_eval.py
@@ -375,7 +375,8 @@ def check_pow(self, lhs, arith1, rhs):
and is_scalar(rhs)
and _is_py3_complex_incompat(result, expected)
):
- with pytest.raises(AssertionError):
+ msg = "(DataFrame.columns|numpy array) are different"
+ with pytest.raises(AssertionError, match=msg):
tm.assert_numpy_array_equal(result, expected)
else:
tm.assert_almost_equal(result, expected)
@@ -449,16 +450,19 @@ def test_frame_invert(self):
# float always raises
lhs = DataFrame(randn(5, 2))
if self.engine == "numexpr":
- with pytest.raises(NotImplementedError):
+ msg = "couldn't find matching opcode for 'invert_dd'"
+ with pytest.raises(NotImplementedError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
- with pytest.raises(TypeError):
+ msg = "ufunc 'invert' not supported for the input types"
+ with pytest.raises(TypeError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
# int raises on numexpr
lhs = DataFrame(randint(5, size=(5, 2)))
if self.engine == "numexpr":
- with pytest.raises(NotImplementedError):
+ msg = "couldn't find matching opcode for 'invert"
+ with pytest.raises(NotImplementedError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
expect = ~lhs
@@ -474,10 +478,11 @@ def test_frame_invert(self):
# object raises
lhs = DataFrame({"b": ["a", 1, 2.0], "c": rand(3) > 0.5})
if self.engine == "numexpr":
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match="unknown type object"):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
- with pytest.raises(TypeError):
+ msg = "bad operand type for unary ~: 'str'"
+ with pytest.raises(TypeError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
def test_series_invert(self):
@@ -488,16 +493,19 @@ def test_series_invert(self):
# float raises
lhs = Series(randn(5))
if self.engine == "numexpr":
- with pytest.raises(NotImplementedError):
+ msg = "couldn't find matching opcode for 'invert_dd'"
+ with pytest.raises(NotImplementedError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
- with pytest.raises(TypeError):
+ msg = "ufunc 'invert' not supported for the input types"
+ with pytest.raises(TypeError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
# int raises on numexpr
lhs = Series(randint(5, size=5))
if self.engine == "numexpr":
- with pytest.raises(NotImplementedError):
+ msg = "couldn't find matching opcode for 'invert"
+ with pytest.raises(NotImplementedError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
expect = ~lhs
@@ -517,10 +525,11 @@ def test_series_invert(self):
# object
lhs = Series(["a", 1, 2.0])
if self.engine == "numexpr":
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match="unknown type object"):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
- with pytest.raises(TypeError):
+ msg = "bad operand type for unary ~: 'str'"
+ with pytest.raises(TypeError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
def test_frame_negate(self):
@@ -541,7 +550,8 @@ def test_frame_negate(self):
# bool doesn't work with numexpr but works elsewhere
lhs = DataFrame(rand(5, 2) > 0.5)
if self.engine == "numexpr":
- with pytest.raises(NotImplementedError):
+ msg = "couldn't find matching opcode for 'neg_bb'"
+ with pytest.raises(NotImplementedError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
expect = -lhs
@@ -566,7 +576,8 @@ def test_series_negate(self):
# bool doesn't work with numexpr but works elsewhere
lhs = Series(rand(5) > 0.5)
if self.engine == "numexpr":
- with pytest.raises(NotImplementedError):
+ msg = "couldn't find matching opcode for 'neg_bb'"
+ with pytest.raises(NotImplementedError, match=msg):
result = pd.eval(expr, engine=self.engine, parser=self.parser)
else:
expect = -lhs
@@ -610,7 +621,8 @@ def test_series_pos(self, lhs):
tm.assert_series_equal(expect, result)
def test_scalar_unary(self):
- with pytest.raises(TypeError):
+ msg = "bad operand type for unary ~: 'float'"
+ with pytest.raises(TypeError, match=msg):
pd.eval("~1.0", engine=self.engine, parser=self.parser)
assert pd.eval("-1.0", parser=self.parser, engine=self.engine) == -1.0
@@ -671,7 +683,8 @@ def test_disallow_scalar_bool_ops(self):
x, a, b, df = np.random.randn(3), 1, 2, DataFrame(randn(3, 2)) # noqa
for ex in exprs:
- with pytest.raises(NotImplementedError):
+ msg = "cannot evaluate scalar only bool ops|'BoolOp' nodes are not"
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(ex, engine=self.engine, parser=self.parser)
def test_identical(self):
@@ -772,7 +785,8 @@ def setup_ops(self):
def check_chained_cmp_op(self, lhs, cmp1, mid, cmp2, rhs):
ex1 = f"lhs {cmp1} mid {cmp2} rhs"
- with pytest.raises(NotImplementedError):
+ msg = "'BoolOp' nodes are not implemented"
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(ex1, engine=self.engine, parser=self.parser)
@@ -1183,7 +1197,8 @@ def test_bool_ops_with_constants(self):
def test_4d_ndarray_fails(self):
x = randn(3, 4, 5, 6)
y = Series(randn(10))
- with pytest.raises(NotImplementedError):
+ msg = "N-dimensional objects, where N > 2, are not supported with eval"
+ with pytest.raises(NotImplementedError, match=msg):
self.eval("x + y", local_dict={"x": x, "y": y})
def test_constant(self):
@@ -1232,7 +1247,7 @@ def test_truediv(self):
def test_failing_subscript_with_name_error(self):
df = DataFrame(np.random.randn(5, 3)) # noqa
- with pytest.raises(NameError):
+ with pytest.raises(NameError, match="name 'x' is not defined"):
self.eval("df[x > 2] > 2")
def test_lhs_expression_subscript(self):
@@ -1379,7 +1394,8 @@ def test_multi_line_expression(self):
assert ans is None
# multi-line not valid if not all assignments
- with pytest.raises(ValueError):
+ msg = "Multi-line expressions are only valid if all expressions contain"
+ with pytest.raises(ValueError, match=msg):
df.eval(
"""
a = b + 2
@@ -1474,7 +1490,8 @@ def test_assignment_in_query(self):
# GH 8664
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
df_orig = df.copy()
- with pytest.raises(ValueError):
+ msg = "cannot assign without a target object"
+ with pytest.raises(ValueError, match=msg):
df.query("a = 1")
tm.assert_frame_equal(df, df_orig)
@@ -1593,19 +1610,21 @@ def test_simple_in_ops(self):
)
assert res
else:
- with pytest.raises(NotImplementedError):
+ msg = "'In' nodes are not implemented"
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval("1 in [1, 2]", engine=self.engine, parser=self.parser)
- with pytest.raises(NotImplementedError):
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval("2 in (1, 2)", engine=self.engine, parser=self.parser)
- with pytest.raises(NotImplementedError):
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval("3 in (1, 2)", engine=self.engine, parser=self.parser)
- with pytest.raises(NotImplementedError):
- pd.eval("3 not in (1, 2)", engine=self.engine, parser=self.parser)
- with pytest.raises(NotImplementedError):
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(
"[(3,)] in (1, 2, [(3,)])", engine=self.engine, parser=self.parser
)
- with pytest.raises(NotImplementedError):
+ msg = "'NotIn' nodes are not implemented"
+ with pytest.raises(NotImplementedError, match=msg):
+ pd.eval("3 not in (1, 2)", engine=self.engine, parser=self.parser)
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(
"[3] not in (1, 2, [[3]])", engine=self.engine, parser=self.parser
)
@@ -1664,13 +1683,15 @@ def test_fails_not(self):
def test_fails_ampersand(self):
df = DataFrame(np.random.randn(5, 3)) # noqa
ex = "(df + 2)[df > 1] > 0 & (df > 0)"
- with pytest.raises(NotImplementedError):
+ msg = "cannot evaluate scalar only bool ops"
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(ex, parser=self.parser, engine=self.engine)
def test_fails_pipe(self):
df = DataFrame(np.random.randn(5, 3)) # noqa
ex = "(df + 2)[df > 1] > 0 | (df > 0)"
- with pytest.raises(NotImplementedError):
+ msg = "cannot evaluate scalar only bool ops"
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(ex, parser=self.parser, engine=self.engine)
def test_bool_ops_with_constants(self):
@@ -1679,7 +1700,8 @@ def test_bool_ops_with_constants(self):
):
ex = f"{lhs} {op} {rhs}"
if op in ("and", "or"):
- with pytest.raises(NotImplementedError):
+ msg = "'BoolOp' nodes are not implemented"
+ with pytest.raises(NotImplementedError, match=msg):
self.eval(ex)
else:
res = self.eval(ex)
@@ -1690,7 +1712,8 @@ def test_simple_bool_ops(self):
for op, lhs, rhs in product(expr._bool_ops_syms, (True, False), (True, False)):
ex = f"lhs {op} rhs"
if op in ("and", "or"):
- with pytest.raises(NotImplementedError):
+ msg = "'BoolOp' nodes are not implemented"
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(ex, engine=self.engine, parser=self.parser)
else:
res = pd.eval(ex, engine=self.engine, parser=self.parser)
@@ -1902,19 +1925,21 @@ def test_disallowed_nodes(engine, parser):
inst = VisitorClass("x + 1", engine, parser)
for ops in uns_ops:
- with pytest.raises(NotImplementedError):
+ msg = "nodes are not implemented"
+ with pytest.raises(NotImplementedError, match=msg):
getattr(inst, ops)()
def test_syntax_error_exprs(engine, parser):
e = "s +"
- with pytest.raises(SyntaxError):
+ with pytest.raises(SyntaxError, match="invalid syntax"):
pd.eval(e, engine=engine, parser=parser)
def test_name_error_exprs(engine, parser):
e = "s + t"
- with pytest.raises(NameError):
+ msg = "name 's' is not defined"
+ with pytest.raises(NameError, match=msg):
pd.eval(e, engine=engine, parser=parser)
@@ -1973,7 +1998,8 @@ def test_bool_ops_fails_on_scalars(lhs, cmp, rhs, engine, parser):
ex2 = f"lhs {cmp} mid and mid {cmp} rhs"
ex3 = f"(lhs {cmp} mid) & (mid {cmp} rhs)"
for ex in (ex1, ex2, ex3):
- with pytest.raises(NotImplementedError):
+ msg = "cannot evaluate scalar only bool ops|'BoolOp' nodes are not"
+ with pytest.raises(NotImplementedError, match=msg):
pd.eval(ex, engine=engine, parser=parser)
@@ -2029,7 +2055,8 @@ def test_negate_lt_eq_le(engine, parser):
tm.assert_frame_equal(result, expected)
if parser == "python":
- with pytest.raises(NotImplementedError):
+ msg = "'Not' nodes are not implemented"
+ with pytest.raises(NotImplementedError, match=msg):
df.query("not (cat > 0)", engine=engine, parser=parser)
else:
result = df.query("not (cat > 0)", engine=engine, parser=parser)
@@ -2041,5 +2068,6 @@ def test_validate_bool_args(self):
invalid_values = [1, "True", [1, 2, 3], 5.0]
for value in invalid_values:
- with pytest.raises(ValueError):
+ msg = 'For argument "inplace" expected type bool, received type'
+ with pytest.raises(ValueError, match=msg):
pd.eval("2+2", inplace=value)
| * [x] ref #30999
* [x] tests added / passed
* [x] passes `black pandas`
* [x] passes `git diff origin/master -u -- "*.py" | flake8 --diff` | https://api.github.com/repos/pandas-dev/pandas/pulls/32507 | 2020-03-06T23:31:35Z | 2020-03-10T23:07:48Z | 2020-03-10T23:07:48Z | 2020-03-11T09:09:06Z |
(wip) BUG: groupby with sort=False create buggy multiindex | diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index ac522fc7863b2..0cb43e3d5d1e5 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -1185,8 +1185,6 @@ def _wrap_applied_output(self, keys, values, not_indexed_same=False):
if len(keys) == 0:
return DataFrame(index=keys)
- key_names = self.grouper.names
-
# GH12824.
def first_not_none(values):
try:
@@ -1203,27 +1201,9 @@ def first_not_none(values):
elif isinstance(v, DataFrame):
return self._concat_objects(keys, values, not_indexed_same=not_indexed_same)
elif self.grouper.groupings is not None:
- if len(self.grouper.groupings) > 1:
- key_index = self.grouper.result_index
-
- else:
- ping = self.grouper.groupings[0]
- if len(keys) == ping.ngroups:
- key_index = ping.group_index
- key_index.name = key_names[0]
-
- key_lookup = Index(keys)
- indexer = key_lookup.get_indexer(key_index)
-
- # reorder the values
- values = [values[i] for i in indexer]
- else:
-
- key_index = Index(keys, name=key_names[0])
-
- # don't use the key indexer
- if not self.as_index:
- key_index = None
+ key_index = self.grouper.result_index
+ if not self.as_index:
+ key_index = None
# make Nones an empty object
v = first_not_none(values)
@@ -1635,7 +1615,7 @@ def _gotitem(self, key, ndim: int, subset=None):
raise AssertionError("invalid ndim for _gotitem")
def _wrap_frame_output(self, result, obj) -> DataFrame:
- result_index = self.grouper.levels[0]
+ result_index = self.grouper.result_index
if self.axis == 0:
return DataFrame(result, index=obj.columns, columns=result_index).T
diff --git a/pandas/core/groupby/grouper.py b/pandas/core/groupby/grouper.py
index 21e171f937de8..dc3df010c1eb0 100644
--- a/pandas/core/groupby/grouper.py
+++ b/pandas/core/groupby/grouper.py
@@ -412,7 +412,7 @@ def _make_codes(self) -> None:
codes = self.grouper.codes_info
uniques = self.grouper.result_index
else:
- codes, uniques = algorithms.factorize(self.grouper, sort=self.sort)
+ codes, uniques = algorithms.factorize(self.grouper, sort=True)
uniques = Index(uniques, name=self.name)
self._codes = codes
self._group_index = uniques
diff --git a/pandas/core/groupby/ops.py b/pandas/core/groupby/ops.py
index 7259268ac3f2b..c16826b2a9b54 100644
--- a/pandas/core/groupby/ops.py
+++ b/pandas/core/groupby/ops.py
@@ -39,12 +39,13 @@
from pandas.core.dtypes.missing import _maybe_fill, isna
import pandas.core.algorithms as algorithms
+from pandas.core.arrays import Categorical
from pandas.core.base import SelectionMixin
import pandas.core.common as com
from pandas.core.frame import DataFrame
from pandas.core.generic import NDFrame
from pandas.core.groupby import base, grouper
-from pandas.core.indexes.api import Index, MultiIndex, ensure_index
+from pandas.core.indexes.api import CategoricalIndex, Index, MultiIndex, ensure_index
from pandas.core.series import Series
from pandas.core.sorting import (
compress_group_index,
@@ -141,7 +142,7 @@ def _get_grouper(self):
def _get_group_keys(self):
if len(self.groupings) == 1:
- return self.levels[0]
+ return self.result_index
else:
comp_ids, _, ngroups = self.group_info
@@ -277,12 +278,13 @@ def codes_info(self) -> np.ndarray:
return codes
def _get_compressed_codes(self) -> Tuple[np.ndarray, np.ndarray]:
+ ping = self.groupings[0]
all_codes = self.codes
- if len(all_codes) > 1:
+ if len(all_codes) > 1 or not isinstance(
+ ping.grouper, (Categorical, CategoricalIndex, BinGrouper)
+ ):
group_index = get_group_index(all_codes, self.shape, sort=True, xnull=True)
return compress_group_index(group_index, sort=self.sort)
-
- ping = self.groupings[0]
return ping.codes, np.arange(len(ping.group_index))
@cache_readonly
@@ -297,14 +299,13 @@ def reconstructed_codes(self) -> List[np.ndarray]:
@cache_readonly
def result_index(self) -> Index:
- if not self.compressed and len(self.groupings) == 1:
- return self.groupings[0].result_index.rename(self.names[0])
-
codes = self.reconstructed_codes
levels = [ping.result_index for ping in self.groupings]
result = MultiIndex(
levels=levels, codes=codes, verify_integrity=False, names=self.names
)
+ if not self.compressed and len(self.groupings) == 1:
+ return result.get_level_values(0)
return result
def get_group_levels(self):
diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py
index 5662d41e19885..845af651aa6b1 100644
--- a/pandas/tests/groupby/test_groupby.py
+++ b/pandas/tests/groupby/test_groupby.py
@@ -2057,3 +2057,27 @@ def test_groups_repr_truncates(max_seq_items, expected):
result = df.groupby(np.array(df.a)).groups.__repr__()
assert result == expected
+
+
+def test_sort_false_multiindex_lexsorted():
+ # GH 32259
+ d = pd.to_datetime(
+ [
+ "2020-11-02",
+ "2019-01-02",
+ "2020-01-02",
+ "2020-02-04",
+ "2020-11-03",
+ "2019-11-03",
+ "2019-11-13",
+ "2019-11-13",
+ ]
+ )
+ a = np.arange(len(d))
+ b = np.random.rand(len(d))
+ df = pd.DataFrame({"d": d, "a": a, "b": b})
+ t = df.groupby(["d", "a"], sort=False).mean()
+ assert not t.index.is_lexsorted()
+
+ t = df.groupby(["d", "a"], sort=True).mean()
+ assert t.index.is_lexsorted()
diff --git a/pandas/tests/groupby/test_grouping.py b/pandas/tests/groupby/test_grouping.py
index efcd22f9c0c82..f9a6ab13d256d 100644
--- a/pandas/tests/groupby/test_grouping.py
+++ b/pandas/tests/groupby/test_grouping.py
@@ -575,16 +575,12 @@ def test_groupby_args(self, mframe):
frame.groupby(by=None, level=None)
@pytest.mark.parametrize(
- "sort,labels",
- [
- [True, [2, 2, 2, 0, 0, 1, 1, 3, 3, 3]],
- [False, [0, 0, 0, 1, 1, 2, 2, 3, 3, 3]],
- ],
+ "sort", [True, False],
)
- def test_level_preserve_order(self, sort, labels, mframe):
+ def test_level_preserve_order(self, sort, mframe):
# GH 17537
grouped = mframe.groupby(level=0, sort=sort)
- exp_labels = np.array(labels, np.intp)
+ exp_labels = np.array([2, 2, 2, 0, 0, 1, 1, 3, 3, 3], np.intp)
tm.assert_almost_equal(grouped.grouper.codes[0], exp_labels)
def test_grouping_labels(self, mframe):
| - [ ] closes #32259
- [ ] tests added / passed
- [ ] passes `black pandas`
- [ ] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
Still messy, just running this through the test suite as my laptop's not great (but please let me know if such behaviour is unwelcome and I won't do it again)
pandas/tests/groupby/test_timegrouper.py
pandas/tests/groupby/test_grouping.py
pandas/tests/groupby/test_categorical.py
pandas/tests/groupby/test_groupby.py
pandas/tests/test_multilevel.py | https://api.github.com/repos/pandas-dev/pandas/pulls/32506 | 2020-03-06T22:11:55Z | 2020-04-22T16:14:06Z | null | 2020-10-10T14:14:56Z |
CLN: avoid values_from_object in Index.equals | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 3eab757311ccb..d912dbbfd1d1d 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -4104,7 +4104,6 @@ def __getitem__(self, key):
if com.is_bool_indexer(key):
key = np.asarray(key, dtype=bool)
- key = com.values_from_object(key)
result = getitem(key)
if not is_scalar(result):
if np.ndim(result) > 1:
@@ -4229,19 +4228,19 @@ def equals(self, other) -> bool:
if not isinstance(other, Index):
return False
- if is_object_dtype(self) and not is_object_dtype(other):
+ if is_object_dtype(self.dtype) and not is_object_dtype(other.dtype):
# if other is not object, use other's logic for coercion
return other.equals(self)
if isinstance(other, ABCMultiIndex):
# d-level MultiIndex can equal d-tuple Index
- if not is_object_dtype(self.dtype):
- if self.nlevels != other.nlevels:
- return False
+ return other.equals(self)
- return array_equivalent(
- com.values_from_object(self), com.values_from_object(other)
- )
+ if is_extension_array_dtype(other.dtype):
+ # All EA-backed Index subclasses override equals
+ return other.equals(self)
+
+ return array_equivalent(self._values, other._values)
def identical(self, other) -> bool:
"""
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index c22b289bb4017..0bb88145646ed 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -3141,11 +3141,10 @@ def equals(self, other) -> bool:
if not isinstance(other, MultiIndex):
# d-level MultiIndex can equal d-tuple Index
if not is_object_dtype(other.dtype):
- if self.nlevels != other.nlevels:
- return False
+ # other cannot contain tuples, so cannot match self
+ return False
- other_vals = com.values_from_object(other)
- return array_equivalent(self._values, other_vals)
+ return array_equivalent(self._values, other._values)
if self.nlevels != other.nlevels:
return False
| https://api.github.com/repos/pandas-dev/pandas/pulls/32505 | 2020-03-06T21:26:37Z | 2020-03-11T02:39:19Z | 2020-03-11T02:39:19Z | 2020-03-11T02:43:30Z | |
CLN: avoid values_from_object in construction | diff --git a/pandas/core/internals/construction.py b/pandas/core/internals/construction.py
index 57ed2555761be..ab363e10eb098 100644
--- a/pandas/core/internals/construction.py
+++ b/pandas/core/internals/construction.py
@@ -36,7 +36,7 @@
from pandas.core import algorithms, common as com
from pandas.core.arrays import Categorical
-from pandas.core.construction import sanitize_array
+from pandas.core.construction import extract_array, sanitize_array
from pandas.core.indexes import base as ibase
from pandas.core.indexes.api import (
Index,
@@ -519,7 +519,7 @@ def _list_of_series_to_arrays(data, columns, coerce_float=False, dtype=None):
else:
indexer = indexer_cache[id(index)] = index.get_indexer(columns)
- values = com.values_from_object(s)
+ values = extract_array(s, extract_numpy=True)
aligned_values.append(algorithms.take_1d(values, indexer))
values = np.vstack(aligned_values)
| https://api.github.com/repos/pandas-dev/pandas/pulls/32504 | 2020-03-06T21:10:41Z | 2020-03-08T16:14:49Z | 2020-03-08T16:14:49Z | 2020-03-08T16:18:52Z | |
Disallow lossy SparseArray conversion | diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 549606795f528..bcd54698689de 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -27,6 +27,7 @@
is_array_like,
is_bool_dtype,
is_datetime64_any_dtype,
+ is_datetime64tz_dtype,
is_dtype_equal,
is_integer,
is_object_dtype,
@@ -42,7 +43,7 @@
from pandas.core.arrays.sparse.dtype import SparseDtype
from pandas.core.base import PandasObject
import pandas.core.common as com
-from pandas.core.construction import sanitize_array
+from pandas.core.construction import extract_array, sanitize_array
from pandas.core.indexers import check_array_indexer
from pandas.core.missing import interpolate_2d
import pandas.core.ops as ops
@@ -312,7 +313,7 @@ def __init__(
dtype = dtype.subtype
if index is not None and not is_scalar(data):
- raise Exception("must only pass scalars with an index ")
+ raise Exception("must only pass scalars with an index")
if is_scalar(data):
if index is not None:
@@ -367,6 +368,19 @@ def __init__(
sparse_index = data._sparse_index
sparse_values = np.asarray(data.sp_values, dtype=dtype)
elif sparse_index is None:
+ data = extract_array(data, extract_numpy=True)
+ if not isinstance(data, np.ndarray):
+ # EA
+ if is_datetime64tz_dtype(data.dtype):
+ warnings.warn(
+ f"Creating SparseArray from {data.dtype} data "
+ "loses timezone information. Cast to object before "
+ "sparse to retain timezone information.",
+ UserWarning,
+ stacklevel=2,
+ )
+ data = np.asarray(data, dtype="datetime64[ns]")
+ data = np.asarray(data)
sparse_values, sparse_index, fill_value = make_sparse(
data, kind=kind, fill_value=fill_value, dtype=dtype
)
@@ -1497,7 +1511,7 @@ def _formatter(self, boxed=False):
SparseArray._add_unary_ops()
-def make_sparse(arr, kind="block", fill_value=None, dtype=None, copy=False):
+def make_sparse(arr: np.ndarray, kind="block", fill_value=None, dtype=None, copy=False):
"""
Convert ndarray to sparse format
@@ -1513,7 +1527,7 @@ def make_sparse(arr, kind="block", fill_value=None, dtype=None, copy=False):
-------
(sparse_values, index, fill_value) : (ndarray, SparseIndex, Scalar)
"""
- arr = com.values_from_object(arr)
+ assert isinstance(arr, np.ndarray)
if arr.ndim > 1:
raise TypeError("expected dimension <= 1 data")
diff --git a/pandas/tests/arrays/sparse/test_array.py b/pandas/tests/arrays/sparse/test_array.py
index baca18239b929..4dab86166e13c 100644
--- a/pandas/tests/arrays/sparse/test_array.py
+++ b/pandas/tests/arrays/sparse/test_array.py
@@ -96,6 +96,22 @@ def test_constructor_na_dtype(self, dtype):
with pytest.raises(ValueError, match="Cannot convert"):
SparseArray([0, 1, np.nan], dtype=dtype)
+ def test_constructor_warns_when_losing_timezone(self):
+ # GH#32501 warn when losing timezone inforamtion
+ dti = pd.date_range("2016-01-01", periods=3, tz="US/Pacific")
+
+ expected = SparseArray(np.asarray(dti, dtype="datetime64[ns]"))
+
+ with tm.assert_produces_warning(UserWarning):
+ result = SparseArray(dti)
+
+ tm.assert_sp_array_equal(result, expected)
+
+ with tm.assert_produces_warning(UserWarning):
+ result = SparseArray(pd.Series(dti))
+
+ tm.assert_sp_array_equal(result, expected)
+
def test_constructor_spindex_dtype(self):
arr = SparseArray(data=[1, 2], sparse_index=IntIndex(4, [1, 2]))
# XXX: Behavior change: specifying SparseIndex no longer changes the
| cc @TomAugspurger | https://api.github.com/repos/pandas-dev/pandas/pulls/32501 | 2020-03-06T18:58:19Z | 2020-03-14T16:33:20Z | 2020-03-14T16:33:20Z | 2020-03-14T16:47:12Z |
Better error message for OOB result | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index eec471f989037..8a8b77fbbb426 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -65,6 +65,7 @@ Bug fixes
- Bug in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with a tz-aware index (:issue:`26683`)
- Bug where :func:`to_datetime` would raise when passed ``pd.NA`` (:issue:`32213`)
+- Improved error message when subtracting two :class:`Timestamp` that result in an out-of-bounds :class:`Timedelta` (:issue:`31774`)
**Categorical**
diff --git a/pandas/_libs/tslibs/c_timestamp.pyx b/pandas/_libs/tslibs/c_timestamp.pyx
index 2c72cec18f096..3c30460a74ece 100644
--- a/pandas/_libs/tslibs/c_timestamp.pyx
+++ b/pandas/_libs/tslibs/c_timestamp.pyx
@@ -286,6 +286,10 @@ cdef class _Timestamp(datetime):
# coerce if necessary if we are a Timestamp-like
if (PyDateTime_Check(self)
and (PyDateTime_Check(other) or is_datetime64_object(other))):
+ # both_timestamps is to determine whether Timedelta(self - other)
+ # should raise the OOB error, or fall back returning a timedelta.
+ both_timestamps = (isinstance(other, _Timestamp) and
+ isinstance(self, _Timestamp))
if isinstance(self, _Timestamp):
other = type(self)(other)
else:
@@ -301,7 +305,14 @@ cdef class _Timestamp(datetime):
from pandas._libs.tslibs.timedeltas import Timedelta
try:
return Timedelta(self.value - other.value)
- except (OverflowError, OutOfBoundsDatetime):
+ except (OverflowError, OutOfBoundsDatetime) as err:
+ if isinstance(other, _Timestamp):
+ if both_timestamps:
+ raise OutOfBoundsDatetime(
+ "Result is too large for pandas.Timedelta. Convert inputs "
+ "to datetime.datetime with 'Timestamp.to_pydatetime()' "
+ "before subtracting."
+ ) from err
pass
elif is_datetime64_object(self):
# GH#28286 cython semantics for __rsub__, `other` is actually
diff --git a/pandas/tests/scalar/timestamp/test_arithmetic.py b/pandas/tests/scalar/timestamp/test_arithmetic.py
index 1cab007c20a0e..ccd7bf721430a 100644
--- a/pandas/tests/scalar/timestamp/test_arithmetic.py
+++ b/pandas/tests/scalar/timestamp/test_arithmetic.py
@@ -3,6 +3,8 @@
import numpy as np
import pytest
+from pandas.errors import OutOfBoundsDatetime
+
from pandas import Timedelta, Timestamp
from pandas.tseries import offsets
@@ -60,6 +62,18 @@ def test_overflow_offset_raises(self):
with pytest.raises(OverflowError, match=msg):
stamp - offset_overflow
+ def test_overflow_timestamp_raises(self):
+ # https://github.com/pandas-dev/pandas/issues/31774
+ msg = "Result is too large"
+ a = Timestamp("2101-01-01 00:00:00")
+ b = Timestamp("1688-01-01 00:00:00")
+
+ with pytest.raises(OutOfBoundsDatetime, match=msg):
+ a - b
+
+ # but we're OK for timestamp and datetime.datetime
+ assert (a - b.to_pydatetime()) == (a.to_pydatetime() - b)
+
def test_delta_preserve_nanos(self):
val = Timestamp(1337299200000000123)
result = val + timedelta(1)
| Closes #31774
| https://api.github.com/repos/pandas-dev/pandas/pulls/32499 | 2020-03-06T17:10:53Z | 2020-03-11T01:45:54Z | 2020-03-11T01:45:54Z | 2020-03-12T12:22:19Z |
BUG: Fix bug, where BooleanDtype columns are converted to Int64 | diff --git a/doc/source/whatsnew/v1.0.2.rst b/doc/source/whatsnew/v1.0.2.rst
index 462f243f14494..7a25f7b58c2e7 100644
--- a/doc/source/whatsnew/v1.0.2.rst
+++ b/doc/source/whatsnew/v1.0.2.rst
@@ -64,6 +64,7 @@ Bug fixes
**Datetimelike**
- Bug in :meth:`DataFrame.reindex` and :meth:`Series.reindex` when reindexing with a tz-aware index (:issue:`26683`)
+- Bug in :meth:`Series.astype` not copying for tz-naive and tz-aware datetime64 dtype (:issue:`32490`)
- Bug where :func:`to_datetime` would raise when passed ``pd.NA`` (:issue:`32213`)
**Categorical**
@@ -84,6 +85,7 @@ Bug fixes
- Fixed bug in setting values using a slice indexer with string dtype (:issue:`31772`)
- Fixed bug where :meth:`GroupBy.first` and :meth:`GroupBy.last` would raise a ``TypeError`` when groups contained ``pd.NA`` in a column of object dtype (:issue:`32123`)
- Fix bug in :meth:`Series.convert_dtypes` for series with mix of integers and strings (:issue:`32117`)
+- Fixed bug in :meth:`DataFrame.convert_dtypes`, where ``BooleanDtype`` columns were converted to ``Int64`` (:issue:`32287`)
**Strings**
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 9f19c7ba0be6e..7223eda22b3d9 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -587,6 +587,8 @@ def astype(self, dtype, copy=True):
if getattr(self.dtype, "tz", None) is None:
return self.tz_localize(new_tz)
result = self.tz_convert(new_tz)
+ if copy:
+ result = result.copy()
if new_tz is None:
# Do we want .astype('datetime64[ns]') to be an ndarray.
# The astype in Block._astype expects this to return an
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 7dac36b53fce5..97c02428cbdf9 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -1049,7 +1049,8 @@ def convert_dtypes(
dtype
new dtype
"""
- if convert_string or convert_integer or convert_boolean:
+ is_extension = is_extension_array_dtype(input_array.dtype)
+ if (convert_string or convert_integer or convert_boolean) and not is_extension:
try:
inferred_dtype = lib.infer_dtype(input_array)
except ValueError:
@@ -1062,9 +1063,7 @@ def convert_dtypes(
if convert_integer:
target_int_dtype = "Int64"
- if is_integer_dtype(input_array.dtype) and not is_extension_array_dtype(
- input_array.dtype
- ):
+ if is_integer_dtype(input_array.dtype):
from pandas.core.arrays.integer import _dtypes
inferred_dtype = _dtypes.get(input_array.dtype.name, target_int_dtype)
@@ -1078,9 +1077,7 @@ def convert_dtypes(
inferred_dtype = input_array.dtype
if convert_boolean:
- if is_bool_dtype(input_array.dtype) and not is_extension_array_dtype(
- input_array.dtype
- ):
+ if is_bool_dtype(input_array.dtype):
inferred_dtype = "boolean"
else:
if isinstance(inferred_dtype, str) and inferred_dtype == "boolean":
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index c088b7020927b..bce440fe09319 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -2228,6 +2228,9 @@ def astype(self, dtype, copy: bool = False, errors: str = "raise"):
# if we are passed a datetime64[ns, tz]
if is_datetime64tz_dtype(dtype):
values = self.values
+ if copy:
+ # this should be the only copy
+ values = values.copy()
if getattr(values, "tz", None) is None:
values = DatetimeArray(values).tz_localize("UTC")
values = values.tz_convert(dtype.tz)
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index a59ed429cc404..2c26e72a245f7 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -151,6 +151,18 @@ def test_astype_to_same(self):
result = arr.astype(DatetimeTZDtype(tz="US/Central"), copy=False)
assert result is arr
+ @pytest.mark.parametrize("dtype", ["datetime64[ns]", "datetime64[ns, UTC]"])
+ @pytest.mark.parametrize(
+ "other", ["datetime64[ns]", "datetime64[ns, UTC]", "datetime64[ns, CET]"]
+ )
+ def test_astype_copies(self, dtype, other):
+ # https://github.com/pandas-dev/pandas/pull/32490
+ s = pd.Series([1, 2], dtype=dtype)
+ orig = s.copy()
+ t = s.astype(other)
+ t[:] = pd.NaT
+ tm.assert_series_equal(s, orig)
+
@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")])
diff --git a/pandas/tests/series/methods/test_convert_dtypes.py b/pandas/tests/series/methods/test_convert_dtypes.py
index 17527a09f07a1..a41f893e3753f 100644
--- a/pandas/tests/series/methods/test_convert_dtypes.py
+++ b/pandas/tests/series/methods/test_convert_dtypes.py
@@ -279,3 +279,8 @@ def test_convert_string_dtype(self):
)
result = df.convert_dtypes()
tm.assert_frame_equal(df, result)
+
+ def test_convert_bool_dtype(self):
+ # GH32287
+ df = pd.DataFrame({"A": pd.array([True])})
+ tm.assert_frame_equal(df, df.convert_dtypes())
| - [x] closes #32287
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
| https://api.github.com/repos/pandas-dev/pandas/pulls/32490 | 2020-03-06T12:34:41Z | 2020-03-11T01:48:35Z | 2020-03-11T01:48:34Z | 2020-03-26T14:28:41Z |
CLN: trying isort-dev | diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 61d6a660a0357..58d1ec9b310c9 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -2,29 +2,29 @@ from collections import abc
from decimal import Decimal
from fractions import Fraction
from numbers import Number
-
import sys
import cython
from cython import Py_ssize_t
-from cpython.object cimport PyObject_RichCompareBool, Py_EQ
-from cpython.ref cimport Py_INCREF
-from cpython.tuple cimport PyTuple_SET_ITEM, PyTuple_New
-from cpython.iterator cimport PyIter_Check
-from cpython.sequence cimport PySequence_Check
-from cpython.number cimport PyNumber_Check
-
from cpython.datetime cimport (
- PyDateTime_Check,
PyDate_Check,
- PyTime_Check,
- PyDelta_Check,
+ PyDateTime_Check,
PyDateTime_IMPORT,
+ PyDelta_Check,
+ PyTime_Check,
)
+from cpython.iterator cimport PyIter_Check
+from cpython.number cimport PyNumber_Check
+from cpython.object cimport Py_EQ, PyObject_RichCompareBool
+from cpython.ref cimport Py_INCREF
+from cpython.sequence cimport PySequence_Check
+from cpython.tuple cimport PyTuple_New, PyTuple_SET_ITEM
+
PyDateTime_IMPORT
import numpy as np
+
cimport numpy as cnp
from numpy cimport (
NPY_OBJECT,
@@ -42,6 +42,7 @@ from numpy cimport (
uint8_t,
uint64_t,
)
+
cnp.import_array()
cdef extern from "numpy/arrayobject.h":
@@ -65,24 +66,23 @@ cdef extern from "numpy/arrayobject.h":
cdef extern from "src/parse_helper.h":
int floatify(object, float64_t *result, int *maybe_int) except -1
-cimport pandas._libs.util as util
-from pandas._libs.util cimport is_nan, UINT64_MAX, INT64_MAX, INT64_MIN
+from pandas._libs cimport util
+from pandas._libs.util cimport INT64_MAX, INT64_MIN, UINT64_MAX, is_nan
from pandas._libs.tslib import array_to_datetime
-from pandas._libs.tslibs.nattype cimport NPY_NAT, c_NaT as NaT
-from pandas._libs.tslibs.conversion cimport convert_to_tsobject
-from pandas._libs.tslibs.timedeltas cimport convert_to_timedelta64
-from pandas._libs.tslibs.timezones cimport get_timezone, tz_compare
from pandas._libs.missing cimport (
+ C_NA,
checknull,
- isnaobj,
is_null_datetime64,
- is_null_timedelta64,
is_null_period,
- C_NA,
+ is_null_timedelta64,
+ isnaobj,
)
-
+from pandas._libs.tslibs.conversion cimport convert_to_tsobject
+from pandas._libs.tslibs.nattype cimport NPY_NAT, c_NaT as NaT
+from pandas._libs.tslibs.timedeltas cimport convert_to_timedelta64
+from pandas._libs.tslibs.timezones cimport get_timezone, tz_compare
# constants that will be compared to potentially arbitrarily large
# python int
@@ -1320,8 +1320,7 @@ def infer_dtype(value: object, skipna: bool = True) -> str:
else:
if not isinstance(value, list):
value = list(value)
- from pandas.core.dtypes.cast import (
- construct_1d_object_array_from_listlike)
+ from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
values = construct_1d_object_array_from_listlike(value)
# make contiguous
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 60d89b2076e92..0a53454f6b544 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -8,7 +8,6 @@
alignment and a host of useful data manipulation methods having to do with the
labeling information
"""
-
import collections
from collections import abc
import datetime
@@ -35,7 +34,7 @@
import warnings
import numpy as np
-import numpy.ma as ma
+from numpy import ma
from pandas._config import get_option
@@ -133,6 +132,7 @@
if TYPE_CHECKING:
from pandas.core.groupby.generic import DataFrameGroupBy
+
from pandas.io.formats.style import Styler
# ---------------------------------------------------------------------
@@ -438,7 +438,7 @@ def __init__(
elif isinstance(data, dict):
mgr = init_dict(data, index, columns, dtype=dtype)
elif isinstance(data, ma.MaskedArray):
- import numpy.ma.mrecords as mrecords
+ from numpy.ma import mrecords
# masked recarray
if isinstance(data, mrecords.MaskedRecords):
@@ -4621,8 +4621,9 @@ def duplicated(
-------
Series
"""
+ from pandas._libs.hashtable import _SIZE_HINT_LIMIT, duplicated_int64
+
from pandas.core.sorting import get_group_index
- from pandas._libs.hashtable import duplicated_int64, _SIZE_HINT_LIMIT
if self.empty:
return Series(dtype=bool)
@@ -5455,7 +5456,7 @@ def combine_first(self, other: "DataFrame") -> "DataFrame":
1 0.0 3.0 1.0
2 NaN 3.0 1.0
"""
- import pandas.core.computation.expressions as expressions
+ from pandas.core.computation import expressions
def extract_values(arr):
# Does two things:
@@ -5602,7 +5603,7 @@ def update(
1 2 500.0
2 3 6.0
"""
- import pandas.core.computation.expressions as expressions
+ from pandas.core.computation import expressions
# TODO: Support other joins
if join != "left": # pragma: no cover
@@ -7161,8 +7162,8 @@ def join(
def _join_compat(
self, other, on=None, how="left", lsuffix="", rsuffix="", sort=False
):
- from pandas.core.reshape.merge import merge
from pandas.core.reshape.concat import concat
+ from pandas.core.reshape.merge import merge
if isinstance(other, Series):
if other.name is None:
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
---
Trying ```isort``` 5.0.0 which is still under development. | https://api.github.com/repos/pandas-dev/pandas/pulls/32489 | 2020-03-06T11:44:45Z | 2020-03-24T13:39:53Z | null | 2020-03-24T13:41:18Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.