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 |
|---|---|---|---|---|---|---|---|
REF: Back IntervalArray by array instead of Index | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index e810fc0239b40..82a360442f8c0 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -280,6 +280,7 @@ Performance improvements
- Performance improvement in :meth:`GroupBy.transform` with the ``numba`` engine (:issue:`36240`)
- ``Styler`` uuid method altered to compress data transmission over web whilst maintaining reasonably low table collision probability (:issue:`36345`)
- Performance improvement in :meth:`pd.to_datetime` with non-ns time unit for ``float`` ``dtype`` columns (:issue:`20445`)
+- Performance improvement in setting values on a :class:`IntervalArray` (:issue:`36310`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/_testing.py b/pandas/_testing.py
index 78b6b3c4f9072..cf6272edc4c05 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing.py
@@ -977,8 +977,14 @@ def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray")
"""
_check_isinstance(left, right, IntervalArray)
- assert_index_equal(left.left, right.left, exact=exact, obj=f"{obj}.left")
- assert_index_equal(left.right, right.right, exact=exact, obj=f"{obj}.left")
+ kwargs = {}
+ if left._left.dtype.kind in ["m", "M"]:
+ # We have a DatetimeArray or TimedeltaArray
+ kwargs["check_freq"] = False
+
+ assert_equal(left._left, right._left, obj=f"{obj}.left", **kwargs)
+ assert_equal(left._right, right._right, obj=f"{obj}.left", **kwargs)
+
assert_attr_equal("closed", left, right, obj=obj)
@@ -989,20 +995,22 @@ def assert_period_array_equal(left, right, obj="PeriodArray"):
assert_attr_equal("freq", left, right, obj=obj)
-def assert_datetime_array_equal(left, right, obj="DatetimeArray"):
+def assert_datetime_array_equal(left, right, obj="DatetimeArray", check_freq=True):
__tracebackhide__ = True
_check_isinstance(left, right, DatetimeArray)
assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
- assert_attr_equal("freq", left, right, obj=obj)
+ if check_freq:
+ assert_attr_equal("freq", left, right, obj=obj)
assert_attr_equal("tz", left, right, obj=obj)
-def assert_timedelta_array_equal(left, right, obj="TimedeltaArray"):
+def assert_timedelta_array_equal(left, right, obj="TimedeltaArray", check_freq=True):
__tracebackhide__ = True
_check_isinstance(left, right, TimedeltaArray)
assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
- assert_attr_equal("freq", left, right, obj=obj)
+ if check_freq:
+ assert_attr_equal("freq", left, right, obj=obj)
def raise_assert_detail(obj, message, left, right, diff=None, index_values=None):
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 5105b5b9cc57b..413430942575d 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -31,7 +31,6 @@
from pandas.core.dtypes.dtypes import IntervalDtype
from pandas.core.dtypes.generic import (
ABCDatetimeIndex,
- ABCIndexClass,
ABCIntervalIndex,
ABCPeriodIndex,
ABCSeries,
@@ -42,7 +41,7 @@
from pandas.core.arrays.base import ExtensionArray, _extension_array_shared_docs
from pandas.core.arrays.categorical import Categorical
import pandas.core.common as com
-from pandas.core.construction import array
+from pandas.core.construction import array, extract_array
from pandas.core.indexers import check_array_indexer
from pandas.core.indexes.base import ensure_index
@@ -161,12 +160,14 @@ def __new__(
verify_integrity: bool = True,
):
- if isinstance(data, ABCSeries) and is_interval_dtype(data.dtype):
- data = data._values
+ if isinstance(data, (ABCSeries, ABCIntervalIndex)) and is_interval_dtype(
+ data.dtype
+ ):
+ data = data._values # TODO: extract_array?
- if isinstance(data, (cls, ABCIntervalIndex)):
- left = data.left
- right = data.right
+ if isinstance(data, cls):
+ left = data._left
+ right = data._right
closed = closed or data.closed
else:
@@ -243,6 +244,20 @@ def _simple_new(
)
raise ValueError(msg)
+ # For dt64/td64 we want DatetimeArray/TimedeltaArray instead of ndarray
+ from pandas.core.ops.array_ops import maybe_upcast_datetimelike_array
+
+ left = maybe_upcast_datetimelike_array(left)
+ left = extract_array(left, extract_numpy=True)
+ right = maybe_upcast_datetimelike_array(right)
+ right = extract_array(right, extract_numpy=True)
+
+ lbase = getattr(left, "_ndarray", left).base
+ rbase = getattr(right, "_ndarray", right).base
+ if lbase is not None and lbase is rbase:
+ # If these share data, then setitem could corrupt our IA
+ right = right.copy()
+
result._left = left
result._right = right
result._closed = closed
@@ -476,18 +491,18 @@ def _validate(self):
if self.closed not in VALID_CLOSED:
msg = f"invalid option for 'closed': {self.closed}"
raise ValueError(msg)
- if len(self.left) != len(self.right):
+ if len(self._left) != len(self._right):
msg = "left and right must have the same length"
raise ValueError(msg)
- left_mask = notna(self.left)
- right_mask = notna(self.right)
+ left_mask = notna(self._left)
+ right_mask = notna(self._right)
if not (left_mask == right_mask).all():
msg = (
"missing values must be missing in the same "
"location both left and right sides"
)
raise ValueError(msg)
- if not (self.left[left_mask] <= self.right[left_mask]).all():
+ if not (self._left[left_mask] <= self._right[left_mask]).all():
msg = "left side of interval must be <= right side"
raise ValueError(msg)
@@ -527,37 +542,29 @@ def __iter__(self):
return iter(np.asarray(self))
def __len__(self) -> int:
- return len(self.left)
+ return len(self._left)
def __getitem__(self, value):
value = check_array_indexer(self, value)
- left = self.left[value]
- right = self.right[value]
+ left = self._left[value]
+ right = self._right[value]
- # scalar
- if not isinstance(left, ABCIndexClass):
+ if not isinstance(left, (np.ndarray, ExtensionArray)):
+ # scalar
if is_scalar(left) and isna(left):
return self._fill_value
- if np.ndim(left) > 1:
- # GH#30588 multi-dimensional indexer disallowed
- raise ValueError("multi-dimensional indexing not allowed")
return Interval(left, right, self.closed)
-
+ if np.ndim(left) > 1:
+ # GH#30588 multi-dimensional indexer disallowed
+ raise ValueError("multi-dimensional indexing not allowed")
return self._shallow_copy(left, right)
def __setitem__(self, key, value):
value_left, value_right = self._validate_setitem_value(value)
key = check_array_indexer(self, key)
- # Need to ensure that left and right are updated atomically, so we're
- # forced to copy, update the copy, and swap in the new values.
- left = self.left.copy(deep=True)
- left._values[key] = value_left
- self._left = left
-
- right = self.right.copy(deep=True)
- right._values[key] = value_right
- self._right = right
+ self._left[key] = value_left
+ self._right[key] = value_right
def __eq__(self, other):
# ensure pandas array for list-like and eliminate non-interval scalars
@@ -588,7 +595,7 @@ def __eq__(self, other):
if is_interval_dtype(other_dtype):
if self.closed != other.closed:
return np.zeros(len(self), dtype=bool)
- return (self.left == other.left) & (self.right == other.right)
+ return (self._left == other.left) & (self._right == other.right)
# non-interval/non-object dtype -> no matches
if not is_object_dtype(other_dtype):
@@ -601,8 +608,8 @@ def __eq__(self, other):
if (
isinstance(obj, Interval)
and self.closed == obj.closed
- and self.left[i] == obj.left
- and self.right[i] == obj.right
+ and self._left[i] == obj.left
+ and self._right[i] == obj.right
):
result[i] = True
@@ -665,6 +672,7 @@ def astype(self, dtype, copy=True):
array : ExtensionArray or ndarray
ExtensionArray or NumPy ndarray with 'dtype' for its dtype.
"""
+ from pandas import Index
from pandas.core.arrays.string_ import StringDtype
if dtype is not None:
@@ -676,8 +684,10 @@ def astype(self, dtype, copy=True):
# need to cast to different subtype
try:
- new_left = self.left.astype(dtype.subtype)
- new_right = self.right.astype(dtype.subtype)
+ # We need to use Index rules for astype to prevent casting
+ # np.nan entries to int subtypes
+ new_left = Index(self._left, copy=False).astype(dtype.subtype)
+ new_right = Index(self._right, copy=False).astype(dtype.subtype)
except TypeError as err:
msg = (
f"Cannot convert {self.dtype} to {dtype}; subtypes are incompatible"
@@ -726,14 +736,14 @@ def copy(self):
-------
IntervalArray
"""
- left = self.left.copy(deep=True)
- right = self.right.copy(deep=True)
+ left = self._left.copy()
+ right = self._right.copy()
closed = self.closed
# TODO: Could skip verify_integrity here.
return type(self).from_arrays(left, right, closed=closed)
- def isna(self):
- return isna(self.left)
+ def isna(self) -> np.ndarray:
+ return isna(self._left)
def shift(self, periods: int = 1, fill_value: object = None) -> "IntervalArray":
if not len(self) or periods == 0:
@@ -749,7 +759,9 @@ def shift(self, periods: int = 1, fill_value: object = None) -> "IntervalArray":
empty_len = min(abs(periods), len(self))
if isna(fill_value):
- fill_value = self.left._na_value
+ from pandas import Index
+
+ fill_value = Index(self._left, copy=False)._na_value
empty = IntervalArray.from_breaks([fill_value] * (empty_len + 1))
else:
empty = self._from_sequence([fill_value] * empty_len)
@@ -815,10 +827,10 @@ def take(self, indices, allow_fill=False, fill_value=None, axis=None, **kwargs):
fill_left, fill_right = self._validate_fill_value(fill_value)
left_take = take(
- self.left, indices, allow_fill=allow_fill, fill_value=fill_left
+ self._left, indices, allow_fill=allow_fill, fill_value=fill_left
)
right_take = take(
- self.right, indices, allow_fill=allow_fill, fill_value=fill_right
+ self._right, indices, allow_fill=allow_fill, fill_value=fill_right
)
return self._shallow_copy(left_take, right_take)
@@ -977,7 +989,9 @@ def left(self):
Return the left endpoints of each Interval in the IntervalArray as
an Index.
"""
- return self._left
+ from pandas import Index
+
+ return Index(self._left, copy=False)
@property
def right(self):
@@ -985,7 +999,9 @@ def right(self):
Return the right endpoints of each Interval in the IntervalArray as
an Index.
"""
- return self._right
+ from pandas import Index
+
+ return Index(self._right, copy=False)
@property
def length(self):
@@ -1146,7 +1162,7 @@ def set_closed(self, closed):
raise ValueError(msg)
return type(self)._simple_new(
- left=self.left, right=self.right, closed=closed, verify_integrity=False
+ left=self._left, right=self._right, closed=closed, verify_integrity=False
)
_interval_shared_docs[
@@ -1172,15 +1188,15 @@ def is_non_overlapping_monotonic(self):
# at a point when both sides of intervals are included
if self.closed == "both":
return bool(
- (self.right[:-1] < self.left[1:]).all()
- or (self.left[:-1] > self.right[1:]).all()
+ (self._right[:-1] < self._left[1:]).all()
+ or (self._left[:-1] > self._right[1:]).all()
)
# non-strict inequality when closed != 'both'; at least one side is
# not included in the intervals, so equality does not imply overlapping
return bool(
- (self.right[:-1] <= self.left[1:]).all()
- or (self.left[:-1] >= self.right[1:]).all()
+ (self._right[:-1] <= self._left[1:]).all()
+ or (self._left[:-1] >= self._right[1:]).all()
)
# ---------------------------------------------------------------------
@@ -1191,8 +1207,8 @@ def __array__(self, dtype=None) -> np.ndarray:
Return the IntervalArray's data as a numpy array of Interval
objects (with dtype='object')
"""
- left = self.left
- right = self.right
+ left = self._left
+ right = self._right
mask = self.isna()
closed = self._closed
@@ -1222,8 +1238,8 @@ def __arrow_array__(self, type=None):
interval_type = ArrowIntervalType(subtype, self.closed)
storage_array = pyarrow.StructArray.from_arrays(
[
- pyarrow.array(self.left, type=subtype, from_pandas=True),
- pyarrow.array(self.right, type=subtype, from_pandas=True),
+ pyarrow.array(self._left, type=subtype, from_pandas=True),
+ pyarrow.array(self._right, type=subtype, from_pandas=True),
],
names=["left", "right"],
)
@@ -1277,7 +1293,7 @@ def __arrow_array__(self, type=None):
_interval_shared_docs["to_tuples"] % dict(return_type="ndarray", examples="")
)
def to_tuples(self, na_tuple=True):
- tuples = com.asarray_tuplesafe(zip(self.left, self.right))
+ tuples = com.asarray_tuplesafe(zip(self._left, self._right))
if not na_tuple:
# GH 18756
tuples = np.where(~self.isna(), tuples, np.nan)
@@ -1343,8 +1359,8 @@ def contains(self, other):
if isinstance(other, Interval):
raise NotImplementedError("contains not implemented for two intervals")
- return (self.left < other if self.open_left else self.left <= other) & (
- other < self.right if self.open_right else other <= self.right
+ return (self._left < other if self.open_left else self._left <= other) & (
+ other < self._right if self.open_right else other <= self._right
)
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 8855d987af745..a56f6a5bb0340 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -183,12 +183,8 @@ 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
-)
-@inherit_names(
- ["is_non_overlapping_monotonic", "mid", "closed"], IntervalArray, cache=True
-)
+@inherit_names(["__array__", "overlaps", "contains"], IntervalArray)
+@inherit_names(["is_non_overlapping_monotonic", "closed"], IntervalArray, cache=True)
class IntervalIndex(IntervalMixin, ExtensionIndex):
_typ = "intervalindex"
_comparables = ["name"]
@@ -201,6 +197,8 @@ class IntervalIndex(IntervalMixin, ExtensionIndex):
_mask = None
_data: IntervalArray
+ _values: IntervalArray
+
# --------------------------------------------------------------------
# Constructors
@@ -409,7 +407,7 @@ def __reduce__(self):
return _new_IntervalIndex, (type(self), d), None
@Appender(Index.astype.__doc__)
- def astype(self, dtype, copy=True):
+ def astype(self, dtype, copy: bool = True):
with rewrite_exception("IntervalArray", type(self).__name__):
new_values = self._values.astype(dtype, copy=copy)
if is_interval_dtype(new_values.dtype):
@@ -438,7 +436,7 @@ def is_monotonic_decreasing(self) -> bool:
return self[::-1].is_monotonic_increasing
@cache_readonly
- def is_unique(self):
+ def is_unique(self) -> bool:
"""
Return True if the IntervalIndex contains unique elements, else False.
"""
@@ -865,6 +863,22 @@ def _convert_list_indexer(self, keyarr):
# --------------------------------------------------------------------
+ @cache_readonly
+ def left(self) -> Index:
+ return Index(self._data.left, copy=False)
+
+ @cache_readonly
+ def right(self) -> Index:
+ return Index(self._data.right, copy=False)
+
+ @cache_readonly
+ def mid(self):
+ return Index(self._data.mid, copy=False)
+
+ @property
+ def length(self):
+ return Index(self._data.length, copy=False)
+
@Appender(Index.where.__doc__)
def where(self, cond, other=None):
if other is None:
diff --git a/pandas/tests/extension/test_interval.py b/pandas/tests/extension/test_interval.py
index 2411f6cfbd936..4fdcf930d224f 100644
--- a/pandas/tests/extension/test_interval.py
+++ b/pandas/tests/extension/test_interval.py
@@ -147,9 +147,7 @@ class TestReshaping(BaseInterval, base.BaseReshapingTests):
class TestSetitem(BaseInterval, base.BaseSetitemTests):
- @pytest.mark.xfail(reason="GH#27147 setitem changes underlying index")
- def test_setitem_preserves_views(self, data):
- super().test_setitem_preserves_views(data)
+ pass
class TestPrinting(BaseInterval, base.BasePrintingTests):
diff --git a/pandas/tests/indexes/interval/test_constructors.py b/pandas/tests/indexes/interval/test_constructors.py
index fa881df8139c6..aec7de549744f 100644
--- a/pandas/tests/indexes/interval/test_constructors.py
+++ b/pandas/tests/indexes/interval/test_constructors.py
@@ -262,6 +262,12 @@ def test_length_one(self):
expected = IntervalIndex.from_breaks([])
tm.assert_index_equal(result, expected)
+ def test_left_right_dont_share_data(self):
+ # GH#36310
+ breaks = np.arange(5)
+ result = IntervalIndex.from_breaks(breaks)._data
+ assert result._left.base is None or result._left.base is not result._right.base
+
class TestFromTuples(Base):
"""Tests specific to IntervalIndex.from_tuples"""
diff --git a/pandas/tests/series/indexing/test_getitem.py b/pandas/tests/series/indexing/test_getitem.py
index 6b7cda89a4714..5b585e8802752 100644
--- a/pandas/tests/series/indexing/test_getitem.py
+++ b/pandas/tests/series/indexing/test_getitem.py
@@ -101,7 +101,7 @@ def test_getitem_intlist_intindex_periodvalues(self):
@pytest.mark.parametrize("box", [list, np.array, pd.Index])
def test_getitem_intlist_intervalindex_non_int(self, box):
# GH#33404 fall back to positional since ints are unambiguous
- dti = date_range("2000-01-03", periods=3)
+ dti = date_range("2000-01-03", periods=3)._with_freq(None)
ii = pd.IntervalIndex.from_breaks(dti)
ser = Series(range(len(ii)), index=ii)
diff --git a/pandas/tests/util/test_assert_interval_array_equal.py b/pandas/tests/util/test_assert_interval_array_equal.py
index 96f2973a1528c..2e8699536c72a 100644
--- a/pandas/tests/util/test_assert_interval_array_equal.py
+++ b/pandas/tests/util/test_assert_interval_array_equal.py
@@ -41,9 +41,9 @@ def test_interval_array_equal_periods_mismatch():
msg = """\
IntervalArray.left are different
-IntervalArray.left length are different
-\\[left\\]: 5, Int64Index\\(\\[0, 1, 2, 3, 4\\], dtype='int64'\\)
-\\[right\\]: 6, Int64Index\\(\\[0, 1, 2, 3, 4, 5\\], dtype='int64'\\)"""
+IntervalArray.left shapes are different
+\\[left\\]: \\(5,\\)
+\\[right\\]: \\(6,\\)"""
with pytest.raises(AssertionError, match=msg):
tm.assert_interval_array_equal(arr1, arr2)
@@ -58,8 +58,8 @@ def test_interval_array_equal_end_mismatch():
IntervalArray.left are different
IntervalArray.left values are different \\(80.0 %\\)
-\\[left\\]: Int64Index\\(\\[0, 2, 4, 6, 8\\], dtype='int64'\\)
-\\[right\\]: Int64Index\\(\\[0, 4, 8, 12, 16\\], dtype='int64'\\)"""
+\\[left\\]: \\[0, 2, 4, 6, 8\\]
+\\[right\\]: \\[0, 4, 8, 12, 16\\]"""
with pytest.raises(AssertionError, match=msg):
tm.assert_interval_array_equal(arr1, arr2)
@@ -74,8 +74,8 @@ def test_interval_array_equal_start_mismatch():
IntervalArray.left are different
IntervalArray.left values are different \\(100.0 %\\)
-\\[left\\]: Int64Index\\(\\[0, 1, 2, 3\\], dtype='int64'\\)
-\\[right\\]: Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+\\[left\\]: \\[0, 1, 2, 3\\]
+\\[right\\]: \\[1, 2, 3, 4\\]"""
with pytest.raises(AssertionError, match=msg):
tm.assert_interval_array_equal(arr1, arr2)
| The benefit I have in mind here is that we could back it by a single 2xN array and a) avoid the kludge needed to make `__setitem__` atomic, b) do a view to get native types for e.g uniqueness checks, c) possibly share some methods with NDarrayBackedExtensionArray.
Also just in principle having EAs not depend on Index is preferable dependency-structure-wise.
cc @jschendel | https://api.github.com/repos/pandas-dev/pandas/pulls/36310 | 2020-09-12T19:04:34Z | 2020-10-02T23:34:11Z | 2020-10-02T23:34:11Z | 2020-10-03T07:21:22Z |
PERF: get_dtype_kinds | diff --git a/pandas/core/dtypes/concat.py b/pandas/core/dtypes/concat.py
index dd005752a4832..07904339b93df 100644
--- a/pandas/core/dtypes/concat.py
+++ b/pandas/core/dtypes/concat.py
@@ -1,7 +1,7 @@
"""
Utility functions related to concat.
"""
-from typing import cast
+from typing import Set, cast
import numpy as np
@@ -9,15 +9,10 @@
from pandas.core.dtypes.cast import find_common_type
from pandas.core.dtypes.common import (
- is_bool_dtype,
is_categorical_dtype,
- is_datetime64_dtype,
- is_datetime64tz_dtype,
is_dtype_equal,
is_extension_array_dtype,
- is_object_dtype,
is_sparse,
- is_timedelta64_dtype,
)
from pandas.core.dtypes.generic import ABCCategoricalIndex, ABCRangeIndex, ABCSeries
@@ -26,7 +21,7 @@
from pandas.core.construction import array
-def get_dtype_kinds(l):
+def _get_dtype_kinds(l) -> Set[str]:
"""
Parameters
----------
@@ -34,34 +29,30 @@ def get_dtype_kinds(l):
Returns
-------
- a set of kinds that exist in this list of arrays
+ set[str]
+ A set of kinds that exist in this list of arrays.
"""
- typs = set()
+ typs: Set[str] = set()
for arr in l:
+ # Note: we use dtype.kind checks because they are much more performant
+ # than is_foo_dtype
dtype = arr.dtype
- if is_categorical_dtype(dtype):
- typ = "category"
- elif is_sparse(dtype):
- typ = "sparse"
+ if not isinstance(dtype, np.dtype):
+ # ExtensionDtype so we get
+ # e.g. "categorical", "datetime64[ns, US/Central]", "Sparse[itn64, 0]"
+ typ = str(dtype)
elif isinstance(arr, ABCRangeIndex):
typ = "range"
- elif is_datetime64tz_dtype(dtype):
- # if to_concat contains different tz,
- # the result must be object dtype
- typ = str(dtype)
- elif is_datetime64_dtype(dtype):
+ elif dtype.kind == "M":
typ = "datetime"
- elif is_timedelta64_dtype(dtype):
+ elif dtype.kind == "m":
typ = "timedelta"
- elif is_object_dtype(dtype):
- typ = "object"
- elif is_bool_dtype(dtype):
- typ = "bool"
- elif is_extension_array_dtype(dtype):
- typ = str(dtype)
+ elif dtype.kind in ["O", "b"]:
+ typ = str(dtype) # i.e. "object", "bool"
else:
typ = dtype.kind
+
typs.add(typ)
return typs
@@ -140,7 +131,7 @@ def is_nonempty(x) -> bool:
if non_empties and axis == 0:
to_concat = non_empties
- typs = get_dtype_kinds(to_concat)
+ typs = _get_dtype_kinds(to_concat)
_contains_datetime = any(typ.startswith("datetime") for typ in typs)
all_empty = not len(non_empties)
@@ -161,13 +152,13 @@ def is_nonempty(x) -> bool:
return np.concatenate(to_concat)
elif _contains_datetime or "timedelta" in typs:
- return concat_datetime(to_concat, axis=axis, typs=typs)
+ return _concat_datetime(to_concat, axis=axis, typs=typs)
elif all_empty:
# we have all empties, but may need to coerce the result dtype to
# object if we have non-numeric type operands (numpy would otherwise
# cast this to float)
- typs = get_dtype_kinds(to_concat)
+ typs = _get_dtype_kinds(to_concat)
if len(typs) != 1:
if not len(typs - {"i", "u", "f"}) or not len(typs - {"bool", "i", "u"}):
@@ -361,7 +352,7 @@ def _concatenate_2d(to_concat, axis: int):
return np.concatenate(to_concat, axis=axis)
-def concat_datetime(to_concat, axis=0, typs=None):
+def _concat_datetime(to_concat, axis=0, typs=None):
"""
provide concatenation of an datetimelike array of arrays each of which is a
single M8[ns], datetime64[ns, tz] or m8[ns] dtype
@@ -377,7 +368,7 @@ def concat_datetime(to_concat, axis=0, typs=None):
a single array, preserving the combined dtypes
"""
if typs is None:
- typs = get_dtype_kinds(to_concat)
+ typs = _get_dtype_kinds(to_concat)
to_concat = [_wrap_datetimelike(x) for x in to_concat]
single_dtype = len({x.dtype for x in to_concat}) == 1
diff --git a/pandas/tests/dtypes/test_concat.py b/pandas/tests/dtypes/test_concat.py
index 5a9ad732792ea..53d53e35c6eb5 100644
--- a/pandas/tests/dtypes/test_concat.py
+++ b/pandas/tests/dtypes/test_concat.py
@@ -44,7 +44,7 @@
)
def test_get_dtype_kinds(index_or_series, to_concat, expected):
to_concat_klass = [index_or_series(c) for c in to_concat]
- result = _concat.get_dtype_kinds(to_concat_klass)
+ result = _concat._get_dtype_kinds(to_concat_klass)
assert result == set(expected)
@@ -76,7 +76,7 @@ def test_get_dtype_kinds(index_or_series, to_concat, expected):
],
)
def test_get_dtype_kinds_period(to_concat, expected):
- result = _concat.get_dtype_kinds(to_concat)
+ result = _concat._get_dtype_kinds(to_concat)
assert result == set(expected)
| Upshot: avoid doing lots of non-performant is_foo_dtype checks.
This fixes a little more than half of the performance hit in the benchmark discussed in #34683. | https://api.github.com/repos/pandas-dev/pandas/pulls/36309 | 2020-09-12T18:49:45Z | 2020-09-12T20:40:21Z | 2020-09-12T20:40:21Z | 2020-09-12T20:55:51Z |
ENH: Support MultiIndex columns in parquet (#34777) | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 454098f4ace04..a3b5ba616b258 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -238,6 +238,7 @@ Other enhancements
-
- Added methods :meth:`IntegerArray.prod`, :meth:`IntegerArray.min`, and :meth:`IntegerArray.max` (:issue:`33790`)
- Where possible :meth:`RangeIndex.difference` and :meth:`RangeIndex.symmetric_difference` will return :class:`RangeIndex` instead of :class:`Int64Index` (:issue:`36564`)
+- :meth:`DataFrame.to_parquet` now supports :class:`MultiIndex` for columns in parquet format (:issue:`34777`)
- Added :meth:`Rolling.sem()` and :meth:`Expanding.sem()` to compute the standard error of mean (:issue:`26476`).
- :meth:`Rolling.var()` and :meth:`Rolling.std()` use Kahan summation and Welfords Method to avoid numerical issues (:issue:`37051`)
- :meth:`DataFrame.corr` and :meth:`DataFrame.cov` use Welfords Method to avoid numerical issues (:issue:`37448`)
diff --git a/pandas/io/parquet.py b/pandas/io/parquet.py
index 1f90da2f57579..10c70b9a5c43a 100644
--- a/pandas/io/parquet.py
+++ b/pandas/io/parquet.py
@@ -9,7 +9,7 @@
from pandas.compat._optional import import_optional_dependency
from pandas.errors import AbstractMethodError
-from pandas import DataFrame, get_option
+from pandas import DataFrame, MultiIndex, get_option
from pandas.io.common import IOHandles, get_handle, is_fsspec_url, stringify_path
@@ -89,9 +89,20 @@ def validate_dataframe(df: DataFrame):
if not isinstance(df, DataFrame):
raise ValueError("to_parquet only supports IO with DataFrames")
- # must have value column names (strings only)
- if df.columns.inferred_type not in {"string", "empty"}:
- raise ValueError("parquet must have string column names")
+ # must have value column names for all index levels (strings only)
+ if isinstance(df.columns, MultiIndex):
+ if not all(
+ x.inferred_type in {"string", "empty"} for x in df.columns.levels
+ ):
+ raise ValueError(
+ """
+ parquet must have string column names for all values in
+ each level of the MultiIndex
+ """
+ )
+ else:
+ if df.columns.inferred_type not in {"string", "empty"}:
+ raise ValueError("parquet must have string column names")
# index level names must be strings
valid_names = all(
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index e5fffb0e3a3e8..3b83eed69c723 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -441,12 +441,6 @@ def test_write_multiindex(self, pa):
df.index = index
check_round_trip(df, engine)
- def test_write_column_multiindex(self, engine):
- # column multi-index
- mi_columns = pd.MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1)])
- df = pd.DataFrame(np.random.randn(4, 3), columns=mi_columns)
- self.check_error_on_write(df, engine, ValueError)
-
def test_multiindex_with_columns(self, pa):
engine = pa
dates = pd.date_range("01-Jan-2018", "01-Dec-2018", freq="MS")
@@ -495,6 +489,66 @@ def test_write_ignoring_index(self, engine):
expected = df.reset_index(drop=True)
check_round_trip(df, engine, write_kwargs=write_kwargs, expected=expected)
+ def test_write_column_multiindex(self, engine):
+ # Not able to write column multi-indexes with non-string column names.
+ mi_columns = pd.MultiIndex.from_tuples([("a", 1), ("a", 2), ("b", 1)])
+ df = pd.DataFrame(np.random.randn(4, 3), columns=mi_columns)
+ self.check_error_on_write(df, engine, ValueError)
+
+ def test_write_column_multiindex_nonstring(self, pa):
+ # GH #34777
+ # Not supported in fastparquet as of 0.1.3
+ engine = pa
+
+ # Not able to write column multi-indexes with non-string column names
+ arrays = [
+ ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+ [1, 2, 1, 2, 1, 2, 1, 2],
+ ]
+ df = pd.DataFrame(np.random.randn(8, 8), columns=arrays)
+ df.columns.names = ["Level1", "Level2"]
+
+ self.check_error_on_write(df, engine, ValueError)
+
+ def test_write_column_multiindex_string(self, pa):
+ # GH #34777
+ # Not supported in fastparquet as of 0.1.3
+ engine = pa
+
+ # Write column multi-indexes with string column names
+ arrays = [
+ ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
+ ["one", "two", "one", "two", "one", "two", "one", "two"],
+ ]
+ df = pd.DataFrame(np.random.randn(8, 8), columns=arrays)
+ df.columns.names = ["ColLevel1", "ColLevel2"]
+
+ check_round_trip(df, engine)
+
+ def test_write_column_index_string(self, pa):
+ # GH #34777
+ # Not supported in fastparquet as of 0.1.3
+ engine = pa
+
+ # Write column indexes with string column names
+ arrays = ["bar", "baz", "foo", "qux"]
+ df = pd.DataFrame(np.random.randn(8, 4), columns=arrays)
+ df.columns.name = "StringCol"
+
+ check_round_trip(df, engine)
+
+ def test_write_column_index_nonstring(self, pa):
+ # GH #34777
+ # Not supported in fastparquet as of 0.1.3
+ engine = pa
+
+ # Write column indexes with string column names
+ arrays = [1, 2, 3, 4]
+ df = pd.DataFrame(np.random.randn(8, 4), columns=arrays)
+ df.columns.name = "NonStringCol"
+
+ self.check_error_on_write(df, engine, ValueError)
+
class TestParquetPyArrow(Base):
def test_basic(self, pa, df_full):
| - [x] closes #34777
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Support MultiIndex for columns in parquet format by updating value column names check to handle MultiIndexes. | https://api.github.com/repos/pandas-dev/pandas/pulls/36305 | 2020-09-12T12:46:15Z | 2020-11-19T02:09:10Z | 2020-11-19T02:09:10Z | 2021-07-23T21:26:09Z |
PERF: creating string Series/Arrays from sequence with many strings | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index e65daa439a225..9b7a96e367af3 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -205,6 +205,7 @@ Deprecations
Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
+- Performance improvements when creating Series with dtype `str` or :class:`StringDtype` from array with many string elements (:issue:`36304`)
- Performance improvement in :meth:`GroupBy.agg` with the ``numba`` engine (:issue:`35759`)
-
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index eadfcefaac73d..af94178af7d7d 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -655,6 +655,10 @@ cpdef ndarray[object] ensure_string_array(
for i in range(n):
val = result[i]
+
+ if isinstance(val, str):
+ continue
+
if not checknull(val):
result[i] = str(val)
else:
| Improves performance of `pandas._libs.lib.ensure_string_array` is cases with many string elements.
Examples:
```python
>>> x = np.array([str(u) for u in range(1_000_000)], dtype=object)
>>> %timeit pd.Series(x, dtype=str)
344 ms ± 59.7 ms per loop # v1.1.0
157 ms ± 7.04 ms per loop # v1.1.1 and master
22.6 ms ± 191 µs per loop # this PR
>>> %timeit pd.Series(x, dtype="string")
357 ms ± 40.2 ms per loop # v1.1.0
148 ms ± 713 µs per loop # v1.1.1 and master
26.3 ms ± 291 µs per loop # this PR
```
#35519 is the cause of the improvement from 1.1.0 to 1.1.1.
Together with #35519 this PR means that the overhead of working with strings in pandas has gotten considerably smaller for cases when we many times instantiate new `Series`/`PandasArrays` with dtype `str`/`StringDtype`, i.e. probably quite often. | https://api.github.com/repos/pandas-dev/pandas/pulls/36304 | 2020-09-12T12:17:42Z | 2020-09-12T21:21:16Z | 2020-09-12T21:21:16Z | 2020-09-12T21:33:08Z |
REGR: Fix IntegerArray unary ops regression | diff --git a/doc/source/whatsnew/v1.1.3.rst b/doc/source/whatsnew/v1.1.3.rst
index 25d223418fc92..c78adcf42f56b 100644
--- a/doc/source/whatsnew/v1.1.3.rst
+++ b/doc/source/whatsnew/v1.1.3.rst
@@ -14,6 +14,7 @@ including other versions of pandas.
Fixed regressions
~~~~~~~~~~~~~~~~~
+- Fixed regression in :class:`IntegerArray` unary plus and minus operations raising a ``TypeError`` (:issue:`36063`)
- Fixed regression in :meth:`Series.__getitem__` incorrectly raising when the input was a tuple (:issue:`35534`)
- Fixed regression in :meth:`Series.__getitem__` incorrectly raising when the input was a frozenset (:issue:`35747`)
-
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 5474005a63b8e..e79370e53ead6 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1055,6 +1055,19 @@ def any_nullable_int_dtype(request):
return request.param
+@pytest.fixture(params=tm.SIGNED_EA_INT_DTYPES)
+def any_signed_nullable_int_dtype(request):
+ """
+ Parameterized fixture for any signed nullable integer dtype.
+
+ * 'Int8'
+ * 'Int16'
+ * 'Int32'
+ * 'Int64'
+ """
+ return request.param
+
+
@pytest.fixture(params=tm.ALL_REAL_DTYPES)
def any_real_dtype(request):
"""
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index dc08e018397bc..94af013d6df2c 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -364,6 +364,15 @@ def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
)
super().__init__(values, mask, copy=copy)
+ def __neg__(self):
+ return type(self)(-self._data, self._mask)
+
+ def __pos__(self):
+ return self
+
+ def __abs__(self):
+ return type(self)(np.abs(self._data), self._mask)
+
@classmethod
def _from_sequence(cls, scalars, dtype=None, copy: bool = False) -> "IntegerArray":
return integer_array(scalars, dtype=dtype, copy=copy)
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 9ed9db801d0a8..d7b82923e7488 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1417,7 +1417,10 @@ def __pos__(self):
):
arr = operator.pos(values)
else:
- raise TypeError(f"Unary plus expects numeric dtype, not {values.dtype}")
+ raise TypeError(
+ "Unary plus expects bool, numeric, timedelta, "
+ f"or object dtype, not {values.dtype}"
+ )
return self.__array_wrap__(arr)
def __invert__(self):
diff --git a/pandas/tests/arrays/integer/test_arithmetic.py b/pandas/tests/arrays/integer/test_arithmetic.py
index d309f6423e0c1..f549a7caeab1d 100644
--- a/pandas/tests/arrays/integer/test_arithmetic.py
+++ b/pandas/tests/arrays/integer/test_arithmetic.py
@@ -261,3 +261,41 @@ def test_reduce_to_float(op):
index=pd.Index(["a", "b"], name="A"),
)
tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "source, target",
+ [
+ ([1, 2, 3], [-1, -2, -3]),
+ ([1, 2, None], [-1, -2, None]),
+ ([-1, 0, 1], [1, 0, -1]),
+ ],
+)
+def test_unary_minus_nullable_int(any_signed_nullable_int_dtype, source, target):
+ dtype = any_signed_nullable_int_dtype
+ arr = pd.array(source, dtype=dtype)
+ result = -arr
+ expected = pd.array(target, dtype=dtype)
+ tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "source", [[1, 2, 3], [1, 2, None], [-1, 0, 1]],
+)
+def test_unary_plus_nullable_int(any_signed_nullable_int_dtype, source):
+ dtype = any_signed_nullable_int_dtype
+ expected = pd.array(source, dtype=dtype)
+ result = +expected
+ tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "source, target",
+ [([1, 2, 3], [1, 2, 3]), ([1, -2, None], [1, 2, None]), ([-1, 0, 1], [1, 0, 1])],
+)
+def test_abs_nullable_int(any_signed_nullable_int_dtype, source, target):
+ dtype = any_signed_nullable_int_dtype
+ s = pd.array(source, dtype=dtype)
+ result = abs(s)
+ expected = pd.array(target, dtype=dtype)
+ tm.assert_extension_array_equal(result, expected)
diff --git a/pandas/tests/frame/test_operators.py b/pandas/tests/frame/test_operators.py
index fede1ca23a8ce..8cf66e2737249 100644
--- a/pandas/tests/frame/test_operators.py
+++ b/pandas/tests/frame/test_operators.py
@@ -119,7 +119,7 @@ def test_pos_object(self, df):
"df", [pd.DataFrame({"a": pd.to_datetime(["2017-01-22", "1970-01-01"])})]
)
def test_pos_raises(self, df):
- msg = re.escape("Unary plus expects numeric dtype, not datetime64[ns]")
+ msg = "Unary plus expects .* dtype, not datetime64\\[ns\\]"
with pytest.raises(TypeError, match=msg):
(+df)
with pytest.raises(TypeError, match=msg):
diff --git a/pandas/tests/series/test_operators.py b/pandas/tests/series/test_operators.py
index e1c9682329271..aee947e738525 100644
--- a/pandas/tests/series/test_operators.py
+++ b/pandas/tests/series/test_operators.py
@@ -536,3 +536,44 @@ def test_invert(self):
ser = tm.makeStringSeries()
ser.name = "series"
tm.assert_series_equal(-(ser < 0), ~(ser < 0))
+
+ @pytest.mark.parametrize(
+ "source, target",
+ [
+ ([1, 2, 3], [-1, -2, -3]),
+ ([1, 2, None], [-1, -2, None]),
+ ([-1, 0, 1], [1, 0, -1]),
+ ],
+ )
+ def test_unary_minus_nullable_int(
+ self, any_signed_nullable_int_dtype, source, target
+ ):
+ dtype = any_signed_nullable_int_dtype
+ s = pd.Series(source, dtype=dtype)
+ result = -s
+ expected = pd.Series(target, dtype=dtype)
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize(
+ "source", [[1, 2, 3], [1, 2, None], [-1, 0, 1]],
+ )
+ def test_unary_plus_nullable_int(self, any_signed_nullable_int_dtype, source):
+ dtype = any_signed_nullable_int_dtype
+ expected = pd.Series(source, dtype=dtype)
+ result = +expected
+ tm.assert_series_equal(result, expected)
+
+ @pytest.mark.parametrize(
+ "source, target",
+ [
+ ([1, 2, 3], [1, 2, 3]),
+ ([1, -2, None], [1, 2, None]),
+ ([-1, 0, 1], [1, 0, 1]),
+ ],
+ )
+ def test_abs_nullable_int(self, any_signed_nullable_int_dtype, source, target):
+ dtype = any_signed_nullable_int_dtype
+ s = pd.Series(source, dtype=dtype)
+ result = abs(s)
+ expected = pd.Series(target, dtype=dtype)
+ tm.assert_series_equal(result, expected)
| - [x] closes #36063
- [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/36303 | 2020-09-12T04:06:22Z | 2020-09-13T12:44:16Z | 2020-09-13T12:44:16Z | 2020-09-13T13:28:19Z |
REF: de-duplicate sort_values | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 67456096e8681..bccc2e0c52568 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -4444,8 +4444,8 @@ def asof_locs(self, where, mask):
def sort_values(
self,
- return_indexer=False,
- ascending=True,
+ return_indexer: bool = False,
+ ascending: bool = True,
na_position: str_t = "last",
key: Optional[Callable] = None,
):
@@ -4509,7 +4509,9 @@ def sort_values(
# GH 35584. Sort missing values according to na_position kwarg
# ignore na_position for MutiIndex
- if not isinstance(self, ABCMultiIndex):
+ if not isinstance(
+ self, (ABCMultiIndex, ABCDatetimeIndex, ABCTimedeltaIndex, ABCPeriodIndex)
+ ):
_as = nargsort(
items=idx, ascending=ascending, na_position=na_position, key=key
)
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 54c8ed60b6097..7f9e39257bc8e 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -41,7 +41,6 @@
)
from pandas.core.indexes.numeric import Int64Index
from pandas.core.ops import get_op_result_name
-from pandas.core.sorting import ensure_key_mapped
from pandas.core.tools.timedeltas import to_timedelta
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
@@ -164,22 +163,6 @@ def __contains__(self, key: Any) -> bool:
is_scalar(res) or isinstance(res, slice) or (is_list_like(res) and len(res))
)
- def sort_values(self, return_indexer=False, ascending=True, key=None):
- """
- Return sorted copy of Index.
- """
- idx = ensure_key_mapped(self, key)
-
- _as = idx.argsort()
- if not ascending:
- _as = _as[::-1]
- sorted_index = self.take(_as)
-
- if return_indexer:
- return sorted_index, _as
- else:
- return sorted_index
-
@Appender(_index_shared_docs["take"] % _index_doc_kwargs)
def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
nv.validate_take(tuple(), kwargs)
| https://api.github.com/repos/pandas-dev/pandas/pulls/36301 | 2020-09-12T03:13:10Z | 2020-09-12T20:33:53Z | 2020-09-12T20:33:53Z | 2020-09-12T20:56:09Z | |
BUG: Index.union() inconsistent with non-unique Indexes | diff --git a/doc/source/whatsnew/v1.3.0.rst b/doc/source/whatsnew/v1.3.0.rst
index 41db72612a66b..9fc111eb203e3 100644
--- a/doc/source/whatsnew/v1.3.0.rst
+++ b/doc/source/whatsnew/v1.3.0.rst
@@ -419,6 +419,8 @@ Interval
Indexing
^^^^^^^^
+
+- Bug in :meth:`Index.union` dropping duplicate ``Index`` values when ``Index`` was not monotonic or ``sort`` was set to ``False`` (:issue:`36289`, :issue:`31326`)
- Bug in :meth:`CategoricalIndex.get_indexer` failing to raise ``InvalidIndexError`` when non-unique (:issue:`38372`)
- Bug in inserting many new columns into a :class:`DataFrame` causing incorrect subsequent indexing behavior (:issue:`38380`)
- Bug in :meth:`DataFrame.__setitem__` raising ``ValueError`` when setting multiple values to duplicate columns (:issue:`15695`)
diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 74fb0e2bd54fb..04eef635dc79b 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -1866,3 +1866,31 @@ def _sort_tuples(values: np.ndarray):
arrays, _ = to_arrays(values, None)
indexer = lexsort_indexer(arrays, orders=True)
return values[indexer]
+
+
+def union_with_duplicates(lvals: np.ndarray, rvals: np.ndarray) -> np.ndarray:
+ """
+ Extracts the union from lvals and rvals with respect to duplicates and nans in
+ both arrays.
+
+ Parameters
+ ----------
+ lvals: np.ndarray
+ left values which is ordered in front.
+ rvals: np.ndarray
+ right values ordered after lvals.
+
+ Returns
+ -------
+ np.ndarray containing the unsorted union of both arrays
+ """
+ indexer = []
+ l_count = value_counts(lvals, dropna=False)
+ r_count = value_counts(rvals, dropna=False)
+ l_count, r_count = l_count.align(r_count, fill_value=0)
+ unique_array = unique(np.append(lvals, rvals))
+ if is_extension_array_dtype(lvals) or is_extension_array_dtype(rvals):
+ unique_array = pd_array(unique_array)
+ for i, value in enumerate(unique_array):
+ indexer += [i] * int(max(l_count[value], r_count[value]))
+ return unique_array.take(indexer)
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 30190ef950af5..44c9b33ae51c7 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -2939,32 +2939,44 @@ def _union(self, other: Index, sort):
lvals = self._values
rvals = other._values
- if sort is None and self.is_monotonic and other.is_monotonic:
+ if (
+ sort is None
+ and self.is_monotonic
+ and other.is_monotonic
+ and not (self.has_duplicates and other.has_duplicates)
+ ):
+ # Both are unique and monotonic, so can use outer join
try:
- result = self._outer_indexer(lvals, rvals)[0]
+ return self._outer_indexer(lvals, rvals)[0]
except (TypeError, IncompatibleFrequency):
# incomparable objects
- result = list(lvals)
+ value_list = list(lvals)
# worth making this faster? a very unusual case
value_set = set(lvals)
- result.extend([x for x in rvals if x not in value_set])
- result = Index(result)._values # do type inference here
- else:
- # find indexes of things in "other" that are not in "self"
- if self.is_unique:
- indexer = self.get_indexer(other)
- missing = (indexer == -1).nonzero()[0]
- else:
- missing = algos.unique1d(self.get_indexer_non_unique(other)[1])
+ value_list.extend([x for x in rvals if x not in value_set])
+ return Index(value_list)._values # do type inference here
- if len(missing) > 0:
- other_diff = algos.take_nd(rvals, missing, allow_fill=False)
- result = concat_compat((lvals, other_diff))
+ elif not other.is_unique and not self.is_unique:
+ # self and other both have duplicates
+ result = algos.union_with_duplicates(lvals, rvals)
+ return _maybe_try_sort(result, sort)
- else:
- result = lvals
+ # Either other or self is not unique
+ # find indexes of things in "other" that are not in "self"
+ if self.is_unique:
+ indexer = self.get_indexer(other)
+ missing = (indexer == -1).nonzero()[0]
+ else:
+ missing = algos.unique1d(self.get_indexer_non_unique(other)[1])
+
+ if len(missing) > 0:
+ other_diff = algos.take_nd(rvals, missing, allow_fill=False)
+ result = concat_compat((lvals, other_diff))
+ else:
+ result = lvals
+ if not self.is_monotonic or not other.is_monotonic:
result = _maybe_try_sort(result, sort)
return result
diff --git a/pandas/tests/indexes/period/test_setops.py b/pandas/tests/indexes/period/test_setops.py
index f847bf58f463f..5b9528d185827 100644
--- a/pandas/tests/indexes/period/test_setops.py
+++ b/pandas/tests/indexes/period/test_setops.py
@@ -348,3 +348,25 @@ def test_intersection_equal_duplicates(self):
idx_dup = idx.append(idx)
result = idx_dup.intersection(idx_dup)
tm.assert_index_equal(result, idx)
+
+ def test_union_duplicates(self):
+ # GH#36289
+ idx = pd.period_range("2011-01-01", periods=2)
+ idx_dup = idx.append(idx)
+
+ idx2 = pd.period_range("2011-01-02", periods=2)
+ idx2_dup = idx2.append(idx2)
+ result = idx_dup.union(idx2_dup)
+
+ expected = PeriodIndex(
+ [
+ "2011-01-01",
+ "2011-01-01",
+ "2011-01-02",
+ "2011-01-02",
+ "2011-01-03",
+ "2011-01-03",
+ ],
+ freq="D",
+ )
+ tm.assert_index_equal(result, expected)
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index b2bab2e720146..5cff23943b57d 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -501,6 +501,84 @@ def check_intersection_commutative(left, right):
assert idx.intersection(idx_non_unique).is_unique
+@pytest.mark.parametrize(
+ "cls",
+ [
+ Int64Index,
+ Float64Index,
+ DatetimeIndex,
+ CategoricalIndex,
+ lambda x: CategoricalIndex(x, categories=set(x)),
+ TimedeltaIndex,
+ lambda x: Index(x, dtype=object),
+ UInt64Index,
+ ],
+)
+def test_union_duplicate_index_subsets_of_each_other(cls):
+ # GH#31326
+ a = cls([1, 2, 2, 3])
+ b = cls([3, 3, 4])
+ expected = cls([1, 2, 2, 3, 3, 4])
+ if isinstance(a, CategoricalIndex):
+ expected = Index([1, 2, 2, 3, 3, 4])
+ result = a.union(b)
+ tm.assert_index_equal(result, expected)
+ result = a.union(b, sort=False)
+ tm.assert_index_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "cls",
+ [
+ Int64Index,
+ Float64Index,
+ DatetimeIndex,
+ CategoricalIndex,
+ TimedeltaIndex,
+ lambda x: Index(x, dtype=object),
+ ],
+)
+def test_union_with_duplicate_index_and_non_monotonic(cls):
+ # GH#36289
+ a = cls([1, 0, 0])
+ b = cls([0, 1])
+ expected = cls([0, 0, 1])
+
+ result = a.union(b)
+ tm.assert_index_equal(result, expected)
+
+ result = a.union(b)
+ tm.assert_index_equal(result, expected)
+
+
+def test_union_duplicate_index_different_dtypes():
+ # GH#36289
+ a = Index([1, 2, 2, 3])
+ b = Index(["1", "0", "0"])
+ expected = Index([1, 2, 2, 3, "1", "0", "0"])
+ result = a.union(b, sort=False)
+ tm.assert_index_equal(result, expected)
+
+
+def test_union_same_value_duplicated_in_both():
+ # GH#36289
+ a = Index([0, 0, 1])
+ b = Index([0, 0, 1, 2])
+ result = a.union(b)
+ expected = Index([0, 0, 1, 2])
+ tm.assert_index_equal(result, expected)
+
+
+@pytest.mark.parametrize("dup", [1, np.nan])
+def test_union_nan_in_both(dup):
+ # GH#36289
+ a = Index([np.nan, 1, 2, 2])
+ b = Index([np.nan, dup, 1, 2])
+ result = a.union(b, sort=False)
+ expected = Index([np.nan, dup, 1.0, 2.0, 2.0])
+ tm.assert_index_equal(result, expected)
+
+
class TestSetOpsUnsorted:
# These may eventually belong in a dtype-specific test_setops, or
# parametrized over a more general fixture
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 27201055dfa5d..26d336bee65ea 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -2416,3 +2416,12 @@ def test_diff_low_precision_int(self, dtype):
result = algos.diff(arr, 1)
expected = np.array([np.nan, 1, 0, -1, 0], dtype="float32")
tm.assert_numpy_array_equal(result, expected)
+
+
+def test_union_with_duplicates():
+ # GH#36289
+ lvals = np.array([3, 1, 3, 4])
+ rvals = np.array([2, 3, 1, 1])
+ result = algos.union_with_duplicates(lvals, rvals)
+ expected = np.array([3, 3, 1, 1, 4, 2])
+ tm.assert_numpy_array_equal(result, expected)
| - [x] closes #36289
- [x] closes #31326
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
The else-block was pretty buggy in case of non unique indexes (was dependent on order of indexes and if one was subset of the other). The function in the try block worked perfectly, so I figured it would be way safer to let that function compute the new index and sort it based on the input indexes. If there is a faster way to achieve the resorting, I would be happy to change the code block.
We could delete the second sort block with the RunTimeWarning too, but then we would no longer get a Warning when incomparable objects should be sorted. | https://api.github.com/repos/pandas-dev/pandas/pulls/36299 | 2020-09-11T23:26:44Z | 2021-03-04T02:01:10Z | 2021-03-04T02:01:10Z | 2021-03-04T21:57:04Z |
BUG: fix duplicate entries in LaTeX List of Tables when using longtable environments | diff --git a/doc/source/whatsnew/v1.2.0.rst b/doc/source/whatsnew/v1.2.0.rst
index 9c2e5427fcd3f..e1fd0ddf99336 100644
--- a/doc/source/whatsnew/v1.2.0.rst
+++ b/doc/source/whatsnew/v1.2.0.rst
@@ -321,6 +321,7 @@ I/O
- :meth:`to_csv` did not support zip compression for binary file object not having a filename (:issue:`35058`)
- :meth:`to_csv` and :meth:`read_csv` did not honor `compression` and `encoding` for path-like objects that are internally converted to file-like objects (:issue:`35677`, :issue:`26124`, and :issue:`32392`)
- :meth:`to_picke` and :meth:`read_pickle` did not support compression for file-objects (:issue:`26237`, :issue:`29054`, and :issue:`29570`)
+- Bug in :func:`LongTableBuilder.middle_separator` was duplicating LaTeX longtable entires in the List of Tables of a LaTeX document (:issue:`34360`)
- Bug in :meth:`read_csv` with `engine='python'` truncating data if multiple items present in first row and first element started with BOM (:issue:`36343`)
Plotting
diff --git a/pandas/io/formats/latex.py b/pandas/io/formats/latex.py
index 8080d953da308..eb35fff3a4f8e 100644
--- a/pandas/io/formats/latex.py
+++ b/pandas/io/formats/latex.py
@@ -431,13 +431,18 @@ class LongTableBuilder(GenericTableBuilder):
>>> from pandas.io.formats import format as fmt
>>> df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
>>> formatter = fmt.DataFrameFormatter(df)
- >>> builder = LongTableBuilder(formatter, caption='caption', label='lab',
- ... column_format='lrl')
+ >>> builder = LongTableBuilder(formatter, caption='a long table',
+ ... label='tab:long', column_format='lrl')
>>> table = builder.get_result()
>>> print(table)
\\begin{longtable}{lrl}
- \\caption{caption}
- \\label{lab}\\\\
+ \\caption{a long table}
+ \\label{tab:long}\\\\
+ \\toprule
+ {} & a & b \\\\
+ \\midrule
+ \\endfirsthead
+ \\caption[]{a long table} \\\\
\\toprule
{} & a & b \\\\
\\midrule
@@ -476,7 +481,16 @@ def _caption_and_label(self) -> str:
@property
def middle_separator(self) -> str:
iterator = self._create_row_iterator(over="header")
+
+ # the content between \endfirsthead and \endhead commands
+ # mitigates repeated List of Tables entries in the final LaTeX
+ # document when dealing with longtable environments; GH #34360
elements = [
+ "\\midrule",
+ "\\endfirsthead",
+ f"\\caption[]{{{self.caption}}} \\\\" if self.caption else "",
+ self.top_separator,
+ self.header,
"\\midrule",
"\\endhead",
"\\midrule",
diff --git a/pandas/tests/io/formats/test_to_latex.py b/pandas/tests/io/formats/test_to_latex.py
index a93ab6f9cc7aa..8df8796d236a5 100644
--- a/pandas/tests/io/formats/test_to_latex.py
+++ b/pandas/tests/io/formats/test_to_latex.py
@@ -411,6 +411,11 @@ def test_to_latex_longtable(self):
df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
withindex_result = df.to_latex(longtable=True)
withindex_expected = r"""\begin{longtable}{lrl}
+\toprule
+{} & a & b \\
+\midrule
+\endfirsthead
+
\toprule
{} & a & b \\
\midrule
@@ -430,6 +435,11 @@ def test_to_latex_longtable(self):
withoutindex_result = df.to_latex(index=False, longtable=True)
withoutindex_expected = r"""\begin{longtable}{rl}
+\toprule
+ a & b \\
+\midrule
+\endfirsthead
+
\toprule
a & b \\
\midrule
@@ -525,6 +535,9 @@ def test_to_latex_longtable_caption_label(self):
df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
+ # test when no caption and no label is provided
+ # is performed by test_to_latex_longtable()
+
# test when only the caption is provided
result_c = df.to_latex(longtable=True, caption=the_caption)
@@ -533,6 +546,11 @@ def test_to_latex_longtable_caption_label(self):
\toprule
{} & a & b \\
\midrule
+\endfirsthead
+\caption[]{a table in a \texttt{longtable} environment} \\
+\toprule
+{} & a & b \\
+\midrule
\endhead
\midrule
\multicolumn{3}{r}{{Continued on next page}} \\
@@ -552,6 +570,11 @@ def test_to_latex_longtable_caption_label(self):
expected_l = r"""\begin{longtable}{lrl}
\label{tab:longtable}\\
+\toprule
+{} & a & b \\
+\midrule
+\endfirsthead
+
\toprule
{} & a & b \\
\midrule
@@ -578,6 +601,11 @@ def test_to_latex_longtable_caption_label(self):
\toprule
{} & a & b \\
\midrule
+\endfirsthead
+\caption[]{a table in a \texttt{longtable} environment} \\
+\toprule
+{} & a & b \\
+\midrule
\endhead
\midrule
\multicolumn{3}{r}{{Continued on next page}} \\
@@ -623,6 +651,11 @@ def test_to_latex_longtable_position(self):
result_p = df.to_latex(longtable=True, position=the_position)
expected_p = r"""\begin{longtable}[t]{lrl}
+\toprule
+{} & a & b \\
+\midrule
+\endfirsthead
+
\toprule
{} & a & b \\
\midrule
| - [x] closes #34360
- [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/36297 | 2020-09-11T22:15:58Z | 2020-09-19T22:05:12Z | 2020-09-19T22:05:12Z | 2020-09-19T22:05:15Z |
[DOC]: Update deprecation warnings, which were already removed | diff --git a/doc/source/user_guide/indexing.rst b/doc/source/user_guide/indexing.rst
index cac18f5bf39cd..74abbc9503db0 100644
--- a/doc/source/user_guide/indexing.rst
+++ b/doc/source/user_guide/indexing.rst
@@ -313,8 +313,10 @@ Selection by label
.. warning::
- Starting in 0.21.0, pandas will show a ``FutureWarning`` if indexing with a list with missing labels. In the future
- this will raise a ``KeyError``. See :ref:`list-like Using loc with missing keys in a list is Deprecated <indexing.deprecate_loc_reindex_listlike>`.
+ .. versionchanged:: 1.0.0
+
+ Pandas will raise a ``KeyError`` if indexing with a list with missing labels. See :ref:`list-like Using loc with
+ missing keys in a list is Deprecated <indexing.deprecate_loc_reindex_listlike>`.
pandas provides a suite of methods in order to have **purely label based indexing**. This is a strict inclusion based protocol.
Every label asked for must be in the index, or a ``KeyError`` will be raised.
@@ -578,8 +580,9 @@ IX indexer is deprecated
.. warning::
- Starting in 0.20.0, the ``.ix`` indexer is deprecated, in favor of the more strict ``.iloc``
- and ``.loc`` indexers.
+ .. versionchanged:: 1.0.0
+
+ The ``.ix`` indexer was removed, in favor of the more strict ``.iloc`` and ``.loc`` indexers.
``.ix`` offers a lot of magic on the inference of what the user wants to do. To wit, ``.ix`` can decide
to index *positionally* OR via *labels* depending on the data type of the index. This has caused quite a
@@ -636,11 +639,13 @@ Indexing with list with missing labels is deprecated
.. warning::
- Starting in 0.21.0, using ``.loc`` or ``[]`` with a list with one or more missing labels, is deprecated, in favor of ``.reindex``.
+ .. versionchanged:: 1.0.0
+
+ Using ``.loc`` or ``[]`` with a list with one or more missing labels will no longer reindex, in favor of ``.reindex``.
In prior versions, using ``.loc[list-of-labels]`` would work as long as *at least 1* of the keys was found (otherwise it
-would raise a ``KeyError``). This behavior is deprecated and will show a warning message pointing to this section. The
-recommended alternative is to use ``.reindex()``.
+would raise a ``KeyError``). This behavior was changed and will now raise a ``KeyError`` if at least one label is missing.
+The recommended alternative is to use ``.reindex()``.
For example.
diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 43030d76d945a..72a2d33522bd5 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -3024,19 +3024,12 @@ It is often the case that users will insert columns to do temporary computations
in Excel and you may not want to read in those columns. ``read_excel`` takes
a ``usecols`` keyword to allow you to specify a subset of columns to parse.
-.. deprecated:: 0.24.0
+.. versionchanged:: 1.0.0
-Passing in an integer for ``usecols`` has been deprecated. Please pass in a list
+Passing in an integer for ``usecols`` will no longer work. Please pass in a list
of ints from 0 to ``usecols`` inclusive instead.
-If ``usecols`` is an integer, then it is assumed to indicate the last column
-to be parsed.
-
-.. code-block:: python
-
- pd.read_excel('path_to_file.xls', 'Sheet1', usecols=2)
-
-You can also specify a comma-delimited set of Excel columns and ranges as a string:
+You can specify a comma-delimited set of Excel columns and ranges as a string:
.. code-block:: python
diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index 0bfe9d9b68cdb..71eefb9a76562 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -327,11 +327,11 @@ which can be specified. These are computed from the starting point specified by
that was discussed :ref:`above<timeseries.converting.format>`). The
available units are listed on the documentation for :func:`pandas.to_datetime`.
+.. versionchanged:: 1.0.0
+
Constructing a :class:`Timestamp` or :class:`DatetimeIndex` with an epoch timestamp
-with the ``tz`` argument specified will currently localize the epoch timestamps to UTC
-first then convert the result to the specified time zone. However, this behavior
-is :ref:`deprecated <whatsnew_0240.deprecations.integer_tz>`, and if you have
-epochs in wall time in another timezone, it is recommended to read the epochs
+with the ``tz`` argument specified will raise a ValueError. If you have
+epochs in wall time in another timezone, you can read the epochs
as timezone-naive timestamps and then localize to the appropriate timezone:
.. ipython:: python
| - [x] closes #36258
Updated the deprecation warnings.
| https://api.github.com/repos/pandas-dev/pandas/pulls/36292 | 2020-09-11T15:59:32Z | 2020-09-11T21:33:03Z | 2020-09-11T21:33:03Z | 2020-09-11T22:29:09Z |
BUG: SystemError in df.sum | diff --git a/pandas/_libs/tslibs/c_timestamp.pyx b/pandas/_libs/tslibs/c_timestamp.pyx
index 6e6b809b9b5a6..ed1df5f4fa595 100644
--- a/pandas/_libs/tslibs/c_timestamp.pyx
+++ b/pandas/_libs/tslibs/c_timestamp.pyx
@@ -57,11 +57,12 @@ def integer_op_not_supported(obj):
# the caller; mypy finds this more palatable.
cls = type(obj).__name__
+ # GH#30886 using an fstring raises SystemError
int_addsub_msg = (
- f"Addition/subtraction of integers and integer-arrays with {cls} is "
+ "Addition/subtraction of integers and integer-arrays with {cls} is "
"no longer supported. Instead of adding/subtracting `n`, "
"use `n * obj.freq`"
- )
+ ).format(cls=cls)
return TypeError(int_addsub_msg)
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 910230c737a2a..25b2997eb088f 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -823,6 +823,16 @@ def test_sum_bool(self, float_frame):
bools.sum(1)
bools.sum(0)
+ def test_sum_mixed_datetime(self):
+ # GH#30886
+ df = pd.DataFrame(
+ {"A": pd.date_range("2000", periods=4), "B": [1, 2, 3, 4]}
+ ).reindex([2, 3, 4])
+ result = df.sum()
+
+ expected = pd.Series({"B": 7.0})
+ tm.assert_series_equal(result, expected)
+
def test_mean_corner(self, float_frame, float_string_frame):
# unit test when have object data
the_mean = float_string_frame.mean(axis=0)
| - [x] closes #30886
- [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/30905 | 2020-01-10T23:21:16Z | 2020-01-15T14:19:18Z | 2020-01-15T14:19:17Z | 2020-01-15T16:12:40Z |
Implement C Level Timedelta ISO Function; fix JSON usage | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index e540626dc1e14..24d14e49b3db0 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -341,6 +341,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:`DataFrame.to_json` where ``Timedelta`` objects would not be serialized correctly with ``date_format="iso"`` (:issue:`28256`)
- :func:`read_csv` will raise a ``ValueError`` when the column names passed in `parse_dates` are missing in the Dataframe (:issue:`31251`)
- 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`)
diff --git a/pandas/_libs/src/ujson/python/date_conversions.c b/pandas/_libs/src/ujson/python/date_conversions.c
index fc4bdef8463af..bcb1334d978ef 100644
--- a/pandas/_libs/src/ujson/python/date_conversions.c
+++ b/pandas/_libs/src/ujson/python/date_conversions.c
@@ -116,3 +116,29 @@ npy_datetime PyDateTimeToEpoch(PyDateTime_Date *dt, NPY_DATETIMEUNIT base) {
npy_datetime npy_dt = npy_datetimestruct_to_datetime(NPY_FR_ns, &dts);
return NpyDateTimeToEpoch(npy_dt, base);
}
+
+/* Converts the int64_t representation of a duration to ISO; mutates len */
+char *int64ToIsoDuration(int64_t value, size_t *len) {
+ pandas_timedeltastruct tds;
+ int ret_code;
+
+ pandas_timedelta_to_timedeltastruct(value, NPY_FR_ns, &tds);
+
+ // Max theoretical length of ISO Duration with 64 bit day
+ // as the largest unit is 70 characters + 1 for a null terminator
+ char *result = PyObject_Malloc(71);
+ if (result == NULL) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+
+ ret_code = make_iso_8601_timedelta(&tds, result, len);
+ if (ret_code == -1) {
+ PyErr_SetString(PyExc_ValueError,
+ "Could not convert timedelta value to string");
+ PyObject_Free(result);
+ return NULL;
+ }
+
+ return result;
+}
diff --git a/pandas/_libs/src/ujson/python/date_conversions.h b/pandas/_libs/src/ujson/python/date_conversions.h
index 45455f4d6128b..1b5cbf2a7e307 100644
--- a/pandas/_libs/src/ujson/python/date_conversions.h
+++ b/pandas/_libs/src/ujson/python/date_conversions.h
@@ -28,4 +28,6 @@ char *PyDateTimeToIso(PyDateTime_Date *obj, NPY_DATETIMEUNIT base, size_t *len);
// Convert a Python Date/Datetime to Unix epoch with resolution base
npy_datetime PyDateTimeToEpoch(PyDateTime_Date *dt, NPY_DATETIMEUNIT base);
+char *int64ToIsoDuration(int64_t value, size_t *len);
+
#endif
diff --git a/pandas/_libs/src/ujson/python/objToJSON.c b/pandas/_libs/src/ujson/python/objToJSON.c
index db1feccb4d0c6..95e98779c2368 100644
--- a/pandas/_libs/src/ujson/python/objToJSON.c
+++ b/pandas/_libs/src/ujson/python/objToJSON.c
@@ -165,7 +165,6 @@ void *initObjToJSON(void) {
cls_index = (PyTypeObject *)PyObject_GetAttrString(mod_pandas, "Index");
cls_series =
(PyTypeObject *)PyObject_GetAttrString(mod_pandas, "Series");
- cls_timedelta = PyObject_GetAttrString(mod_pandas, "Timedelta");
Py_DECREF(mod_pandas);
}
@@ -357,6 +356,12 @@ static char *NpyDateTimeToIsoCallback(JSOBJ Py_UNUSED(unused),
return int64ToIso(GET_TC(tc)->longValue, base, len);
}
+/* JSON callback. returns a char* and mutates the pointer to *len */
+static char *NpyTimeDeltaToIsoCallback(JSOBJ Py_UNUSED(unused),
+ JSONTypeContext *tc, size_t *len) {
+ return int64ToIsoDuration(GET_TC(tc)->longValue, len);
+}
+
/* JSON callback */
static char *PyDateTimeToIsoCallback(JSOBJ obj, JSONTypeContext *tc,
size_t *len) {
@@ -1445,7 +1450,8 @@ char **NpyArr_encodeLabels(PyArrayObject *labels, PyObjectEncoder *enc,
1000000000LL; // nanoseconds per second
} else {
// datetime.* objects don't follow above rules
- nanosecVal = PyDateTimeToEpoch(item, NPY_FR_ns);
+ nanosecVal =
+ PyDateTimeToEpoch((PyDateTime_Date *)item, NPY_FR_ns);
}
}
}
@@ -1457,31 +1463,8 @@ char **NpyArr_encodeLabels(PyArrayObject *labels, PyObjectEncoder *enc,
strncpy(cLabel, "null", len);
} else {
if (enc->datetimeIso) {
- // TODO: Vectorized Timedelta function
if ((type_num == NPY_TIMEDELTA) || (PyDelta_Check(item))) {
- PyObject *td =
- PyObject_CallFunction(cls_timedelta, "(O)", item);
- if (td == NULL) {
- Py_DECREF(item);
- NpyArr_freeLabels(ret, num);
- ret = 0;
- break;
- }
-
- PyObject *iso =
- PyObject_CallMethod(td, "isoformat", NULL);
- Py_DECREF(td);
- if (iso == NULL) {
- Py_DECREF(item);
- NpyArr_freeLabels(ret, num);
- ret = 0;
- break;
- }
-
- len = strlen(PyUnicode_AsUTF8(iso));
- cLabel = PyObject_Malloc(len + 1);
- memcpy(cLabel, PyUnicode_AsUTF8(iso), len + 1);
- Py_DECREF(iso);
+ cLabel = int64ToIsoDuration(nanosecVal, &len);
} else {
if (type_num == NPY_DATETIME) {
cLabel = int64ToIso(nanosecVal, base, &len);
@@ -1614,7 +1597,11 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
if (enc->datetimeIso) {
PRINTMARK();
- pc->PyTypeToUTF8 = NpyDateTimeToIsoCallback;
+ if (enc->npyType == NPY_TIMEDELTA) {
+ pc->PyTypeToUTF8 = NpyTimeDeltaToIsoCallback;
+ } else {
+ pc->PyTypeToUTF8 = NpyDateTimeToIsoCallback;
+ }
// Currently no way to pass longVal to iso function, so use
// state management
GET_TC(tc)->longValue = longVal;
@@ -1695,7 +1682,8 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
PRINTMARK();
NPY_DATETIMEUNIT base =
((PyObjectEncoder *)tc->encoder)->datetimeUnit;
- GET_TC(tc)->longValue = PyDateTimeToEpoch((PyDateTime_Date *)obj, base);
+ GET_TC(tc)->longValue =
+ PyDateTimeToEpoch((PyDateTime_Date *)obj, base);
tc->type = JT_LONG;
}
return;
@@ -1721,7 +1709,8 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
PRINTMARK();
NPY_DATETIMEUNIT base =
((PyObjectEncoder *)tc->encoder)->datetimeUnit;
- GET_TC(tc)->longValue = PyDateTimeToEpoch((PyDateTime_Date *)obj, base);
+ GET_TC(tc)->longValue =
+ PyDateTimeToEpoch((PyDateTime_Date *)obj, base);
tc->type = JT_LONG;
}
return;
@@ -1734,28 +1723,30 @@ void Object_beginTypeContext(JSOBJ _obj, JSONTypeContext *tc) {
value = total_seconds(obj) * 1000000000LL; // nanoseconds per second
}
- unit = ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
- if (scaleNanosecToUnit(&value, unit) != 0) {
- // TODO: Add some kind of error handling here
- }
-
- exc = PyErr_Occurred();
-
- if (exc && PyErr_ExceptionMatches(PyExc_OverflowError)) {
- PRINTMARK();
- goto INVALID;
- }
-
+ PRINTMARK();
if (value == get_nat()) {
PRINTMARK();
tc->type = JT_NULL;
return;
- }
+ } else if (enc->datetimeIso) {
+ pc->PyTypeToUTF8 = NpyTimeDeltaToIsoCallback;
+ tc->type = JT_UTF8;
+ } else {
+ unit = ((PyObjectEncoder *)tc->encoder)->datetimeUnit;
+ if (scaleNanosecToUnit(&value, unit) != 0) {
+ // TODO: Add some kind of error handling here
+ }
- GET_TC(tc)->longValue = value;
+ exc = PyErr_Occurred();
- PRINTMARK();
- tc->type = JT_LONG;
+ if (exc && PyErr_ExceptionMatches(PyExc_OverflowError)) {
+ PRINTMARK();
+ goto INVALID;
+ }
+
+ tc->type = JT_LONG;
+ }
+ GET_TC(tc)->longValue = value;
return;
} else if (PyArray_IsScalar(obj, Integer)) {
PRINTMARK();
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c
index 54ed6ecff21e2..b245ae5880ecb 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.c
@@ -905,3 +905,37 @@ int make_iso_8601_datetime(npy_datetimestruct *dts, char *outstr, int outlen,
outlen);
return -1;
}
+
+
+int make_iso_8601_timedelta(pandas_timedeltastruct *tds,
+ char *outstr, size_t *outlen) {
+ *outlen = 0;
+ *outlen += snprintf(outstr, 60, // NOLINT
+ "P%" NPY_INT64_FMT
+ "DT%" NPY_INT32_FMT
+ "H%" NPY_INT32_FMT
+ "M%" NPY_INT32_FMT,
+ tds->days, tds->hrs, tds->min, tds->sec);
+ outstr += *outlen;
+
+ if (tds->ns != 0) {
+ *outlen += snprintf(outstr, 12, // NOLINT
+ ".%03" NPY_INT32_FMT
+ "%03" NPY_INT32_FMT
+ "%03" NPY_INT32_FMT
+ "S", tds->ms, tds->us, tds->ns);
+ } else if (tds->us != 0) {
+ *outlen += snprintf(outstr, 9, // NOLINT
+ ".%03" NPY_INT32_FMT
+ "%03" NPY_INT32_FMT
+ "S", tds->ms, tds->us);
+ } else if (tds->ms != 0) {
+ *outlen += snprintf(outstr, 6, // NOLINT
+ ".%03" NPY_INT32_FMT "S", tds->ms);
+ } else {
+ *outlen += snprintf(outstr, 2, // NOLINT
+ "%s", "S");
+ }
+
+ return 0;
+}
diff --git a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h
index 880c34ea77638..200a71ff0c2b7 100644
--- a/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h
+++ b/pandas/_libs/tslibs/src/datetime/np_datetime_strings.h
@@ -79,4 +79,14 @@ get_datetime_iso_8601_strlen(int local, NPY_DATETIMEUNIT base);
int
make_iso_8601_datetime(npy_datetimestruct *dts, char *outstr, int outlen,
NPY_DATETIMEUNIT base);
+
+/*
+ * Converts an pandas_timedeltastruct to an ISO 8601 string.
+ *
+ * Mutates outlen to provide size of (non-NULL terminated) string.
+ *
+ * Currently has no error handling
+ */
+int make_iso_8601_timedelta(pandas_timedeltastruct *tds, char *outstr,
+ size_t *outlen);
#endif // PANDAS__LIBS_TSLIBS_SRC_DATETIME_NP_DATETIME_STRINGS_H_
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index 2ac2acc6748d1..c0d40048a72fe 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -603,8 +603,7 @@ def test_timestamp_in_columns(self):
result = df.to_json(orient="table")
js = json.loads(result)
assert js["schema"]["fields"][1]["name"] == "2016-01-01T00:00:00.000Z"
- # TODO - below expectation is not correct; see GH 28256
- assert js["schema"]["fields"][2]["name"] == 10000
+ assert js["schema"]["fields"][2]["name"] == "P0DT0H0M10S"
@pytest.mark.parametrize(
"case",
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 276dfd666c5d0..d56ddb98fa4fa 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -1057,6 +1057,29 @@ def test_mixed_timedelta_datetime(self):
result = pd.read_json(frame.to_json(date_unit="ns"), dtype={"a": "int64"})
tm.assert_frame_equal(result, expected, check_index_type=False)
+ @pytest.mark.parametrize("as_object", [True, False])
+ @pytest.mark.parametrize("date_format", ["iso", "epoch"])
+ @pytest.mark.parametrize("timedelta_typ", [pd.Timedelta, timedelta])
+ def test_timedelta_to_json(self, as_object, date_format, timedelta_typ):
+ # GH28156: to_json not correctly formatting Timedelta
+ data = [timedelta_typ(days=1), timedelta_typ(days=2), pd.NaT]
+ if as_object:
+ data.append("a")
+
+ ser = pd.Series(data, index=data)
+ if date_format == "iso":
+ expected = (
+ '{"P1DT0H0M0S":"P1DT0H0M0S","P2DT0H0M0S":"P2DT0H0M0S","null":null}'
+ )
+ else:
+ expected = '{"86400000":86400000,"172800000":172800000,"null":null}'
+
+ if as_object:
+ expected = expected.replace("}", ',"a":"a"}')
+
+ result = ser.to_json(date_format=date_format)
+ assert result == expected
+
def test_default_handler(self):
value = object()
frame = DataFrame({"a": [7, value]})
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index e86667626deda..34dd9ba9bc7b6 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -16,7 +16,7 @@
from pandas._libs.tslib import Timestamp
import pandas.compat as compat
-from pandas import DataFrame, DatetimeIndex, Index, NaT, Series, date_range
+from pandas import DataFrame, DatetimeIndex, Index, NaT, Series, Timedelta, date_range
import pandas._testing as tm
@@ -1103,3 +1103,24 @@ def test_encode_set(self):
for v in dec:
assert v in s
+
+ @pytest.mark.parametrize(
+ "td",
+ [
+ Timedelta(days=366),
+ Timedelta(days=-1),
+ Timedelta(hours=13, minutes=5, seconds=5),
+ Timedelta(hours=13, minutes=20, seconds=30),
+ Timedelta(days=-1, nanoseconds=5),
+ Timedelta(nanoseconds=1),
+ Timedelta(microseconds=1, nanoseconds=1),
+ Timedelta(milliseconds=1, microseconds=1, nanoseconds=1),
+ Timedelta(milliseconds=999, microseconds=999, nanoseconds=999),
+ ],
+ )
+ def test_encode_timedelta_iso(self, td):
+ # GH 28256
+ result = ujson.encode(td, iso_dates=True)
+ expected = f'"{td.isoformat()}"'
+
+ assert result == expected
| - [X] closes #28256
- [X] tests added / passed
- [X] passes `black pandas`
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [X] whatsnew entry
similar to @cbertinato great work in #28595 but done deeper in the C extension | https://api.github.com/repos/pandas-dev/pandas/pulls/30903 | 2020-01-10T23:08:40Z | 2020-03-19T00:57:22Z | 2020-03-19T00:57:22Z | 2023-04-12T20:17:16Z |
BUG: raise on non-hashable in __contains__ | diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index e5e3b27c41721..e4ec9db560b80 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -72,9 +72,10 @@ cdef class IndexEngine:
self.over_size_threshold = n >= _SIZE_CUTOFF
self.clear_mapping()
- def __contains__(self, object val):
+ def __contains__(self, val: object) -> bool:
+ # We assume before we get here:
+ # - val is hashable
self._ensure_mapping_populated()
- hash(val)
return val in self.mapping
cpdef get_value(self, ndarray arr, object key, object tz=None):
@@ -415,7 +416,9 @@ cdef class DatetimeEngine(Int64Engine):
raise TypeError(scalar)
return scalar.value
- def __contains__(self, object val):
+ def __contains__(self, val: object) -> bool:
+ # We assume before we get here:
+ # - val is hashable
cdef:
int64_t loc, conv
@@ -712,7 +715,9 @@ cdef class BaseMultiIndexCodesEngine:
return indexer
- def __contains__(self, object val):
+ def __contains__(self, val: object) -> bool:
+ # We assume before we get here:
+ # - val is hashable
# Default __contains__ looks in the underlying mapping, which in this
# case only contains integer representations.
try:
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index dc74840958e1f..98e5ed678f945 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 Dict, FrozenSet, Hashable, Optional, Union
+from typing import Any, Dict, FrozenSet, Hashable, Optional, Union
import warnings
import numpy as np
@@ -4145,7 +4145,7 @@ def is_type_compatible(self, kind) -> bool:
"""
@Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
- def __contains__(self, key) -> bool:
+ def __contains__(self, key: Any) -> bool:
hash(key)
try:
return key in self._engine
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 0ff6469d6b19c..268ab9ba4e4c4 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -385,11 +385,12 @@ def _wrap_setop_result(self, other, result):
return self._shallow_copy(result, name=name)
@Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
- def __contains__(self, key) -> bool:
+ def __contains__(self, key: Any) -> bool:
# if key is a NaN, check if any NaN is in self.
if is_scalar(key) and isna(key):
return self.hasnans
+ hash(key)
return contains(self, key, container=self._engine)
def __array__(self, dtype=None) -> np.ndarray:
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index bf1272b223f70..2ba1d3a188c01 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -2,7 +2,7 @@
Base and utility classes for tseries type pandas objects.
"""
import operator
-from typing import List, Optional, Set
+from typing import Any, List, Optional, Set
import numpy as np
@@ -153,7 +153,8 @@ def equals(self, other) -> bool:
return np.array_equal(self.asi8, other.asi8)
@Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
- def __contains__(self, key):
+ def __contains__(self, key: Any) -> bool:
+ hash(key)
try:
res = self.get_loc(key)
except (KeyError, TypeError, ValueError):
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 523d6404f5efa..3108c1a1afd0c 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -374,7 +374,7 @@ def _engine(self):
right = self._maybe_convert_i8(self.right)
return IntervalTree(left, right, closed=self.closed)
- def __contains__(self, key) -> bool:
+ def __contains__(self, key: Any) -> bool:
"""
return a boolean if this key is IN the index
We *only* accept an Interval
@@ -387,6 +387,7 @@ def __contains__(self, key) -> bool:
-------
bool
"""
+ hash(key)
if not isinstance(key, Interval):
return False
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 10a2d9f68a7b6..8682af6ab6369 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -1,6 +1,6 @@
import datetime
from sys import getsizeof
-from typing import Hashable, List, Optional, Sequence, Union
+from typing import Any, Hashable, List, Optional, Sequence, Union
import warnings
import numpy as np
@@ -973,7 +973,7 @@ def _shallow_copy_with_infer(self, values, **kwargs):
return self._shallow_copy(values, **kwargs)
@Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
- def __contains__(self, key) -> bool:
+ def __contains__(self, key: Any) -> bool:
hash(key)
try:
self.get_loc(key)
diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index def77ffbea591..465f21da1278a 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
import numpy as np
@@ -461,7 +461,8 @@ def equals(self, other) -> bool:
except (TypeError, ValueError):
return False
- def __contains__(self, other) -> bool:
+ def __contains__(self, other: Any) -> bool:
+ hash(other)
if super().__contains__(other):
return True
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 35f96e61704f0..af6361826a76d 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -1,4 +1,5 @@
from datetime import datetime, timedelta
+from typing import Any
import weakref
import numpy as np
@@ -369,18 +370,18 @@ def _engine(self):
return self._engine_type(period, len(self))
@Appender(_index_shared_docs["contains"])
- def __contains__(self, key) -> bool:
+ def __contains__(self, key: Any) -> bool:
if isinstance(key, Period):
if key.freq != self.freq:
return False
else:
return key.ordinal in self._engine
else:
+ hash(key)
try:
self.get_loc(key)
return True
- except (TypeError, KeyError):
- # TypeError can be reached if we pass a tuple that is not hashable
+ except KeyError:
return False
@cache_readonly
diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py
index 336f65ca574dc..22940f851ddb0 100644
--- a/pandas/core/indexes/range.py
+++ b/pandas/core/indexes/range.py
@@ -1,7 +1,7 @@
from datetime import timedelta
import operator
from sys import getsizeof
-from typing import Optional, Union
+from typing import Any, Optional
import warnings
import numpy as np
@@ -332,7 +332,7 @@ def is_monotonic_decreasing(self) -> bool:
def has_duplicates(self) -> bool:
return False
- def __contains__(self, key: Union[int, np.integer]) -> bool:
+ def __contains__(self, key: Any) -> bool:
hash(key)
try:
key = ensure_python_int(key)
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index afc068d6696ef..f3ebe8313d0c6 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -883,3 +883,11 @@ def test_getitem_2d_deprecated(self):
res = idx[:, None]
assert isinstance(res, np.ndarray), type(res)
+
+ def test_contains_requires_hashable_raises(self):
+ idx = self.create_index()
+ with pytest.raises(TypeError, match="unhashable type"):
+ [] in idx
+
+ with pytest.raises(TypeError):
+ {} in idx._engine
| By checking before we get to the `Engine.__contains__` call, we can avoid a redundant call to `hash` | https://api.github.com/repos/pandas-dev/pandas/pulls/30902 | 2020-01-10T23:05:59Z | 2020-01-20T17:19:08Z | 2020-01-20T17:19:08Z | 2020-01-20T19:00:48Z |
TYP: typing annotations | diff --git a/pandas/_config/display.py b/pandas/_config/display.py
index 067b7c503baab..ef319f4447565 100644
--- a/pandas/_config/display.py
+++ b/pandas/_config/display.py
@@ -1,6 +1,7 @@
"""
Unopinionated display configuration.
"""
+
import locale
import sys
@@ -11,7 +12,7 @@
_initial_defencoding = None
-def detect_console_encoding():
+def detect_console_encoding() -> str:
"""
Try to find the most capable encoding supported by the console.
slightly modified from the way IPython handles the same issue.
diff --git a/pandas/_config/localization.py b/pandas/_config/localization.py
index dd1d4948aa6e3..0d68e78372d8a 100644
--- a/pandas/_config/localization.py
+++ b/pandas/_config/localization.py
@@ -12,7 +12,7 @@
@contextmanager
-def set_locale(new_locale, lc_var=locale.LC_ALL):
+def set_locale(new_locale, lc_var: int = locale.LC_ALL):
"""
Context manager for temporarily setting a locale.
@@ -44,7 +44,7 @@ def set_locale(new_locale, lc_var=locale.LC_ALL):
locale.setlocale(lc_var, current_locale)
-def can_set_locale(lc, lc_var=locale.LC_ALL):
+def can_set_locale(lc: str, lc_var: int = locale.LC_ALL) -> bool:
"""
Check to see if we can set a locale, and subsequently get the locale,
without raising an Exception.
@@ -58,7 +58,7 @@ def can_set_locale(lc, lc_var=locale.LC_ALL):
Returns
-------
- is_valid : bool
+ bool
Whether the passed locale can be set
"""
diff --git a/pandas/compat/numpy/function.py b/pandas/compat/numpy/function.py
index 7158f251ad805..50f234cbf9419 100644
--- a/pandas/compat/numpy/function.py
+++ b/pandas/compat/numpy/function.py
@@ -33,13 +33,26 @@
class CompatValidator:
- def __init__(self, defaults, fname=None, method=None, max_fname_arg_count=None):
+ def __init__(
+ self,
+ defaults,
+ fname=None,
+ method: Optional[str] = None,
+ max_fname_arg_count=None,
+ ):
self.fname = fname
self.method = method
self.defaults = defaults
self.max_fname_arg_count = max_fname_arg_count
- def __call__(self, args, kwargs, fname=None, max_fname_arg_count=None, method=None):
+ def __call__(
+ self,
+ args,
+ kwargs,
+ fname=None,
+ max_fname_arg_count=None,
+ method: Optional[str] = None,
+ ) -> None:
if args or kwargs:
fname = self.fname if fname is None else fname
max_fname_arg_count = (
@@ -300,7 +313,7 @@ def validate_take_with_convert(convert, args, kwargs):
)
-def validate_window_func(name, args, kwargs):
+def validate_window_func(name, args, kwargs) -> None:
numpy_args = ("axis", "dtype", "out")
msg = (
f"numpy operations are not valid with window objects. "
@@ -315,7 +328,7 @@ def validate_window_func(name, args, kwargs):
raise UnsupportedFunctionCall(msg)
-def validate_rolling_func(name, args, kwargs):
+def validate_rolling_func(name, args, kwargs) -> None:
numpy_args = ("axis", "dtype", "out")
msg = (
f"numpy operations are not valid with window objects. "
@@ -330,7 +343,7 @@ def validate_rolling_func(name, args, kwargs):
raise UnsupportedFunctionCall(msg)
-def validate_expanding_func(name, args, kwargs):
+def validate_expanding_func(name, args, kwargs) -> None:
numpy_args = ("axis", "dtype", "out")
msg = (
f"numpy operations are not valid with window objects. "
@@ -345,7 +358,7 @@ def validate_expanding_func(name, args, kwargs):
raise UnsupportedFunctionCall(msg)
-def validate_groupby_func(name, args, kwargs, allowed=None):
+def validate_groupby_func(name, args, kwargs, allowed=None) -> None:
"""
'args' and 'kwargs' should be empty, except for allowed
kwargs because all of
@@ -359,16 +372,15 @@ def validate_groupby_func(name, args, kwargs, allowed=None):
if len(args) + len(kwargs) > 0:
raise UnsupportedFunctionCall(
- f"numpy operations are not valid with "
- f"groupby. Use .groupby(...).{name}() "
- f"instead"
+ "numpy operations are not valid with groupby. "
+ f"Use .groupby(...).{name}() instead"
)
RESAMPLER_NUMPY_OPS = ("min", "max", "sum", "prod", "mean", "std", "var")
-def validate_resampler_func(method, args, kwargs):
+def validate_resampler_func(method: str, args, kwargs) -> None:
"""
'args' and 'kwargs' should be empty because all of
their necessary parameters are explicitly listed in
@@ -385,7 +397,7 @@ def validate_resampler_func(method, args, kwargs):
raise TypeError("too many arguments passed in")
-def validate_minmax_axis(axis):
+def validate_minmax_axis(axis: Optional[int]) -> None:
"""
Ensure that the axis argument passed to min, max, argmin, or argmax is
zero or None, as otherwise it will be incorrectly ignored.
| - [ ] 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/30901 | 2020-01-10T21:37:12Z | 2020-01-10T23:48:04Z | 2020-01-10T23:48:04Z | 2020-01-12T09:12:26Z |
REGR: Fixed hash_key=None for object values | diff --git a/pandas/core/util/hashing.py b/pandas/core/util/hashing.py
index 43655fa3ea913..3366f10b92604 100644
--- a/pandas/core/util/hashing.py
+++ b/pandas/core/util/hashing.py
@@ -2,6 +2,7 @@
data hash pandas / numpy objects
"""
import itertools
+from typing import Optional
import numpy as np
@@ -58,7 +59,7 @@ def hash_pandas_object(
obj,
index: bool = True,
encoding: str = "utf8",
- hash_key: str = _default_hash_key,
+ hash_key: Optional[str] = _default_hash_key,
categorize: bool = True,
):
"""
@@ -82,6 +83,9 @@ def hash_pandas_object(
"""
from pandas import Series
+ if hash_key is None:
+ hash_key = _default_hash_key
+
if isinstance(obj, ABCMultiIndex):
return Series(hash_tuples(obj, encoding, hash_key), dtype="uint64", copy=False)
diff --git a/pandas/tests/util/test_hashing.py b/pandas/tests/util/test_hashing.py
index c915edad4bb8e..c856585f20138 100644
--- a/pandas/tests/util/test_hashing.py
+++ b/pandas/tests/util/test_hashing.py
@@ -374,3 +374,10 @@ def test_hash_with_tuple():
df3 = pd.DataFrame({"data": [tuple([1, []]), tuple([2, {}])]})
with pytest.raises(TypeError, match="unhashable type: 'list'"):
hash_pandas_object(df3)
+
+
+def test_hash_object_none_key():
+ # https://github.com/pandas-dev/pandas/issues/30887
+ result = pd.util.hash_pandas_object(pd.Series(["a", "b"]), hash_key=None)
+ expected = pd.Series([4578374827886788867, 17338122309987883691], dtype="uint64")
+ tm.assert_series_equal(result, expected)
| Closes https://github.com/pandas-dev/pandas/issues/30887 | https://api.github.com/repos/pandas-dev/pandas/pulls/30900 | 2020-01-10T20:46:18Z | 2020-01-13T15:22:04Z | 2020-01-13T15:22:04Z | 2020-01-13T15:22:07Z |
CLN: simplify Float64Index.__contains__ | diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py
index b9b44284edaa9..fade58eea73b4 100644
--- a/pandas/core/indexes/numeric.py
+++ b/pandas/core/indexes/numeric.py
@@ -477,20 +477,7 @@ def __contains__(self, other) -> bool:
if super().__contains__(other):
return True
- try:
- # if other is a sequence this throws a ValueError
- return np.isnan(other) and self.hasnans
- except ValueError:
- try:
- return len(other) <= 1 and other.item() in self
- except AttributeError:
- return len(other) <= 1 and other in self
- except TypeError:
- pass
- except TypeError:
- pass
-
- return False
+ return is_float(other) and np.isnan(other) and self.hasnans
@Appender(_index_shared_docs["get_loc"])
def get_loc(self, key, method=None, tolerance=None):
| - [ ] 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/30899 | 2020-01-10T19:39:59Z | 2020-01-16T19:56:30Z | 2020-01-16T19:56:30Z | 2020-01-16T21:48:12Z |
DOC: Add pandas_path to the accesor list in the documentation | diff --git a/doc/source/ecosystem.rst b/doc/source/ecosystem.rst
index 7bd5ba7ecdf0b..be61b83d46a26 100644
--- a/doc/source/ecosystem.rst
+++ b/doc/source/ecosystem.rst
@@ -41,6 +41,16 @@ Pyjanitor provides a clean API for cleaning data, using method chaining.
Engarde is a lightweight library used to explicitly state assumptions about your datasets
and check that they're *actually* true.
+`pandas-path <https://github.com/drivendataorg/pandas-path/>`__
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Since Python 3.4, `pathlib <https://docs.python.org/3/library/pathlib.html>`_ has been
+included in the Python standard library. Path objects provide a simple
+and delightful way to interact with the file system. The pandas-path package enables the
+Path API for pandas through a custom accessor ``.path``. Getting just the filenames from
+a series of full file paths is as simple as ``my_files.path.name``. Other convenient operations like
+joining paths, replacing file extensions, and checking if files exist are also available.
+
.. _ecosystem.stats:
Statistics and machine learning
@@ -386,12 +396,16 @@ A directory of projects providing
:ref:`extension accessors <extending.register-accessors>`. This is for users to
discover new accessors and for library authors to coordinate on the namespace.
-============== ========== =========================
-Library Accessor Classes
-============== ========== =========================
-`cyberpandas`_ ``ip`` ``Series``
-`pdvega`_ ``vgplot`` ``Series``, ``DataFrame``
-============== ========== =========================
+=============== ========== ========================= ===============================================================
+Library Accessor Classes Description
+=============== ========== ========================= ===============================================================
+`cyberpandas`_ ``ip`` ``Series`` Provides common operations for working with IP addresses.
+`pdvega`_ ``vgplot`` ``Series``, ``DataFrame`` Provides plotting functions from the Altair_ library.
+`pandas_path`_ ``path`` ``Index``, ``Series`` Provides `pathlib.Path`_ functions for Series.
+=============== ========== ========================= ===============================================================
.. _cyberpandas: https://cyberpandas.readthedocs.io/en/latest
.. _pdvega: https://altair-viz.github.io/pdvega/
+.. _Altair: https://altair-viz.github.io/
+.. _pandas_path: https://github.com/drivendataorg/pandas-path/
+.. _pathlib.Path: https://docs.python.org/3/library/pathlib.html
\ No newline at end of file
| Added the [`pandas_path`](https://github.com/drivendataorg/pandas-path/) package that I just released to the list of third-party accessor extensions.
As a bonus, added a Description column for the existing libraries. | https://api.github.com/repos/pandas-dev/pandas/pulls/30898 | 2020-01-10T19:06:19Z | 2020-01-16T20:00:05Z | 2020-01-16T20:00:05Z | 2020-01-16T20:00:11Z |
TYP: offsets | diff --git a/pandas/tseries/offsets.py b/pandas/tseries/offsets.py
index 8bb98a271bce8..d31c23c7ccf1d 100644
--- a/pandas/tseries/offsets.py
+++ b/pandas/tseries/offsets.py
@@ -365,7 +365,7 @@ def apply_index(self, i):
"applied vectorized"
)
- def is_anchored(self):
+ def is_anchored(self) -> bool:
# TODO: Does this make sense for the general case? It would help
# if there were a canonical docstring for what is_anchored means.
return self.n == 1
@@ -378,7 +378,7 @@ def onOffset(self, dt):
)
return self.is_on_offset(dt)
- def isAnchored(self):
+ def isAnchored(self) -> bool:
warnings.warn(
"isAnchored is a deprecated, use is_anchored instead",
FutureWarning,
@@ -389,7 +389,7 @@ def isAnchored(self):
# TODO: Combine this with BusinessMixin version by defining a whitelisted
# set of attributes on each object rather than the existing behavior of
# iterating over internal ``__dict__``
- def _repr_attrs(self):
+ def _repr_attrs(self) -> str:
exclude = {"n", "inc", "normalize"}
attrs = []
for attr in sorted(self.__dict__):
@@ -405,7 +405,7 @@ def _repr_attrs(self):
return out
@property
- def name(self):
+ def name(self) -> str:
return self.rule_code
def rollback(self, dt):
@@ -452,15 +452,15 @@ def is_on_offset(self, dt):
# way to get around weirdness with rule_code
@property
- def _prefix(self):
+ def _prefix(self) -> str:
raise NotImplementedError("Prefix not defined")
@property
- def rule_code(self):
+ def rule_code(self) -> str:
return self._prefix
@cache_readonly
- def freqstr(self):
+ def freqstr(self) -> str:
try:
code = self.rule_code
except NotImplementedError:
@@ -480,7 +480,7 @@ def freqstr(self):
return fstr
- def _offset_str(self):
+ def _offset_str(self) -> str:
return ""
@property
@@ -529,11 +529,11 @@ def offset(self):
# Alias for backward compat
return self._offset
- def _repr_attrs(self):
+ def _repr_attrs(self) -> str:
if self.offset:
attrs = [f"offset={repr(self.offset)}"]
else:
- attrs = None
+ attrs = []
out = ""
if attrs:
out += ": " + ", ".join(attrs)
@@ -553,7 +553,7 @@ def __init__(self, n=1, normalize=False, offset=timedelta(0)):
BaseOffset.__init__(self, n, normalize)
object.__setattr__(self, "_offset", offset)
- def _offset_str(self):
+ def _offset_str(self) -> str:
def get_str(td):
off_str = ""
if td.days > 0:
@@ -649,7 +649,7 @@ def apply_index(self, i):
result = shifted.to_timestamp() + time
return result
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
return dt.weekday() < 5
@@ -1087,7 +1087,7 @@ def apply(self, other):
def apply_index(self, i):
raise NotImplementedError
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
day64 = _to_dt64(dt, "datetime64[D]")
@@ -1134,14 +1134,14 @@ class MonthOffset(SingleConstructorOffset):
__init__ = BaseOffset.__init__
@property
- def name(self):
+ def name(self) -> str:
if self.is_anchored:
return self.rule_code
else:
month = ccalendar.MONTH_ALIASES[self.n]
return f"{self.code_rule}-{month}"
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
return dt.day == self._get_offset_day(dt)
@@ -1333,7 +1333,7 @@ def _from_name(cls, suffix=None):
return cls(day_of_month=suffix)
@property
- def rule_code(self):
+ def rule_code(self) -> str:
suffix = f"-{self.day_of_month}"
return self._prefix + suffix
@@ -1429,7 +1429,7 @@ class SemiMonthEnd(SemiMonthOffset):
_prefix = "SM"
_min_day_of_month = 1
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
days_in_month = ccalendar.get_days_in_month(dt.year, dt.month)
@@ -1487,7 +1487,7 @@ class SemiMonthBegin(SemiMonthOffset):
_prefix = "SMS"
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
return dt.day in (1, self.day_of_month)
@@ -1556,7 +1556,7 @@ def __init__(self, n=1, normalize=False, weekday=None):
if self.weekday < 0 or self.weekday > 6:
raise ValueError(f"Day must be 0<=day<=6, got {self.weekday}")
- def is_anchored(self):
+ def is_anchored(self) -> bool:
return self.n == 1 and self.weekday is not None
@apply_wraps
@@ -1632,7 +1632,7 @@ def _end_apply_index(self, dtindex):
return base + off + Timedelta(1, "ns") - Timedelta(1, "D")
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
elif self.weekday is None:
@@ -1640,7 +1640,7 @@ def is_on_offset(self, dt):
return dt.weekday() == self.weekday
@property
- def rule_code(self):
+ def rule_code(self) -> str:
suffix = ""
if self.weekday is not None:
weekday = ccalendar.int_to_weekday[self.weekday]
@@ -1717,7 +1717,7 @@ def __init__(self, n=1, normalize=False, week=0, weekday=0):
if self.week < 0 or self.week > 3:
raise ValueError(f"Week must be 0<=week<=3, got {self.week}")
- def _get_offset_day(self, other):
+ def _get_offset_day(self, other: datetime) -> int:
"""
Find the day in the same month as other that has the same
weekday as self.weekday and is the self.week'th such day in the month.
@@ -1736,7 +1736,7 @@ def _get_offset_day(self, other):
return 1 + shift_days + self.week * 7
@property
- def rule_code(self):
+ def rule_code(self) -> str:
weekday = ccalendar.int_to_weekday.get(self.weekday, "")
return f"{self._prefix}-{self.week + 1}{weekday}"
@@ -1785,7 +1785,7 @@ def __init__(self, n=1, normalize=False, weekday=0):
if self.weekday < 0 or self.weekday > 6:
raise ValueError(f"Day must be 0<=day<=6, got {self.weekday}")
- def _get_offset_day(self, other):
+ def _get_offset_day(self, other: datetime) -> int:
"""
Find the day in the same month as other that has the same
weekday as self.weekday and is the last such day in the month.
@@ -1805,7 +1805,7 @@ def _get_offset_day(self, other):
return dim - shift_days
@property
- def rule_code(self):
+ def rule_code(self) -> str:
weekday = ccalendar.int_to_weekday.get(self.weekday, "")
return f"{self._prefix}-{weekday}"
@@ -1842,7 +1842,7 @@ def __init__(self, n=1, normalize=False, startingMonth=None):
startingMonth = self._default_startingMonth
object.__setattr__(self, "startingMonth", startingMonth)
- def is_anchored(self):
+ def is_anchored(self) -> bool:
return self.n == 1 and self.startingMonth is not None
@classmethod
@@ -1856,7 +1856,7 @@ def _from_name(cls, suffix=None):
return cls(**kwargs)
@property
- def rule_code(self):
+ def rule_code(self) -> str:
month = ccalendar.MONTH_ALIASES[self.startingMonth]
return f"{self._prefix}-{month}"
@@ -1874,7 +1874,7 @@ def apply(self, other):
months = qtrs * 3 - months_since
return shift_month(other, months, self._day_opt)
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
mod_month = (dt.month - self.startingMonth) % 3
@@ -1953,7 +1953,7 @@ class YearOffset(DateOffset):
_adjust_dst = True
_attributes = frozenset(["n", "normalize", "month"])
- def _get_offset_day(self, other):
+ def _get_offset_day(self, other: datetime) -> int:
# override BaseOffset method to use self.month instead of other.month
# TODO: there may be a more performant way to do this
return liboffsets.get_day_of_month(
@@ -1977,7 +1977,7 @@ def apply_index(self, dtindex):
shifted, freq=dtindex.freq, dtype=dtindex.dtype
)
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
return dt.month == self.month and dt.day == self._get_offset_day(dt)
@@ -1999,7 +1999,7 @@ def _from_name(cls, suffix=None):
return cls(**kwargs)
@property
- def rule_code(self):
+ def rule_code(self) -> str:
month = ccalendar.MONTH_ALIASES[self.month]
return f"{self._prefix}-{month}"
@@ -2117,12 +2117,12 @@ def __init__(
if self.variation not in ["nearest", "last"]:
raise ValueError(f"{self.variation} is not a valid variation")
- def is_anchored(self):
+ def is_anchored(self) -> bool:
return (
self.n == 1 and self.startingMonth is not None and self.weekday is not None
)
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
dt = datetime(dt.year, dt.month, dt.day)
@@ -2217,18 +2217,18 @@ def get_year_end(self, dt):
return target_date + timedelta(days_forward - 7)
@property
- def rule_code(self):
+ def rule_code(self) -> str:
prefix = self._prefix
suffix = self.get_rule_code_suffix()
return f"{prefix}-{suffix}"
- def _get_suffix_prefix(self):
+ def _get_suffix_prefix(self) -> str:
if self.variation == "nearest":
return "N"
else:
return "L"
- def get_rule_code_suffix(self):
+ def get_rule_code_suffix(self) -> str:
prefix = self._get_suffix_prefix()
month = ccalendar.MONTH_ALIASES[self.startingMonth]
weekday = ccalendar.int_to_weekday[self.weekday]
@@ -2346,7 +2346,7 @@ def _offset(self):
variation=self.variation,
)
- def is_anchored(self):
+ def is_anchored(self) -> bool:
return self.n == 1 and self._offset.is_anchored()
def _rollback_to_year(self, other):
@@ -2434,7 +2434,7 @@ def get_weeks(self, dt):
return ret
- def year_has_extra_week(self, dt):
+ def year_has_extra_week(self, dt: datetime) -> bool:
# Avoid round-down errors --> normalize to get
# e.g. '370D' instead of '360D23H'
norm = Timestamp(dt).normalize().tz_localize(None)
@@ -2445,7 +2445,7 @@ def year_has_extra_week(self, dt):
assert weeks_in_year in [52, 53], weeks_in_year
return weeks_in_year == 53
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
if self._offset.is_on_offset(dt):
@@ -2463,7 +2463,7 @@ def is_on_offset(self, dt):
return False
@property
- def rule_code(self):
+ def rule_code(self) -> str:
suffix = self._offset.get_rule_code_suffix()
qtr = self.qtr_with_extra_week
return f"{self._prefix}-{suffix}-{qtr}"
@@ -2516,7 +2516,7 @@ def apply(self, other):
)
return new
- def is_on_offset(self, dt):
+ def is_on_offset(self, dt: datetime) -> bool:
if self.normalize and not _is_normalized(dt):
return False
return date(dt.year, dt.month, dt.day) == easter(dt.year)
@@ -2596,7 +2596,7 @@ def __eq__(self, other: Any) -> bool:
# This is identical to DateOffset.__hash__, but has to be redefined here
# for Python 3, because we've redefined __eq__.
- def __hash__(self):
+ def __hash__(self) -> int:
return hash(self._params)
def __ne__(self, other):
@@ -2617,7 +2617,7 @@ def __ne__(self, other):
return True
@property
- def delta(self):
+ def delta(self) -> Timedelta:
return self.n * self._inc
@property
@@ -2648,11 +2648,11 @@ def apply(self, other):
raise ApplyTypeError(f"Unhandled type: {type(other).__name__}")
- def is_anchored(self):
+ def is_anchored(self) -> bool:
return False
-def _delta_to_tick(delta):
+def _delta_to_tick(delta: timedelta) -> Tick:
if delta.microseconds == 0 and getattr(delta, "nanoseconds", 0) == 0:
# nanoseconds only for pd.Timedelta
if delta.seconds == 0:
| https://api.github.com/repos/pandas-dev/pandas/pulls/30897 | 2020-01-10T18:01:56Z | 2020-01-10T23:57:34Z | 2020-01-10T23:57:34Z | 2020-01-11T00:19:03Z | |
CLN: remove unnecessary arg from _to_dt64 | diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index f24dce28cd5f7..31dc2945f0395 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -216,7 +216,7 @@ def _get_calendar(weekmask, holidays, calendar):
holidays = holidays + calendar.holidays().tolist()
except AttributeError:
pass
- holidays = [_to_dt64(dt, dtype='datetime64[D]') for dt in holidays]
+ holidays = [_to_dt64D(dt) for dt in holidays]
holidays = tuple(sorted(holidays))
kwargs = {'weekmask': weekmask}
@@ -227,7 +227,7 @@ def _get_calendar(weekmask, holidays, calendar):
return busdaycalendar, holidays
-def _to_dt64(dt, dtype='datetime64'):
+def _to_dt64D(dt):
# Currently
# > np.datetime64(dt.datetime(2013,5,1),dtype='datetime64[D]')
# numpy.datetime64('2013-05-01T02:00:00.000000+0200')
@@ -238,8 +238,8 @@ def _to_dt64(dt, dtype='datetime64'):
dt = np.int64(dt).astype('datetime64[ns]')
else:
dt = np.datetime64(dt)
- if dt.dtype.name != dtype:
- dt = dt.astype(dtype)
+ if dt.dtype.name != "datetime64[D]":
+ dt = dt.astype("datetime64[D]")
return dt
diff --git a/pandas/tseries/offsets.py b/pandas/tseries/offsets.py
index 8bb98a271bce8..001daf7886ee6 100644
--- a/pandas/tseries/offsets.py
+++ b/pandas/tseries/offsets.py
@@ -26,7 +26,7 @@
BaseOffset,
_get_calendar,
_is_normalized,
- _to_dt64,
+ _to_dt64D,
apply_index_wraps,
as_datetime,
roll_yearday,
@@ -1090,7 +1090,7 @@ def apply_index(self, i):
def is_on_offset(self, dt):
if self.normalize and not _is_normalized(dt):
return False
- day64 = _to_dt64(dt, "datetime64[D]")
+ day64 = _to_dt64D(dt)
return np.is_busday(day64, busdaycal=self.calendar)
| https://api.github.com/repos/pandas-dev/pandas/pulls/30895 | 2020-01-10T17:13:56Z | 2020-01-16T19:55:21Z | 2020-01-16T19:55:21Z | 2020-01-16T21:46:04Z | |
WEB: Remove from roadmap moving the docstring script | diff --git a/doc/source/development/roadmap.rst b/doc/source/development/roadmap.rst
index 00598830e2fe9..fafe63d80249c 100644
--- a/doc/source/development/roadmap.rst
+++ b/doc/source/development/roadmap.rst
@@ -129,20 +129,6 @@ Some specific goals include
* Improve the overall organization of the documentation and specific subsections
of the documentation to make navigation and finding content easier.
-Package docstring validation
-----------------------------
-
-To improve the quality and consistency of pandas docstrings, we've developed
-tooling to check docstrings in a variety of ways.
-https://github.com/pandas-dev/pandas/blob/master/scripts/validate_docstrings.py
-contains the checks.
-
-Like many other projects, pandas uses the
-`numpydoc <https://numpydoc.readthedocs.io/en/latest/>`__ style for writing
-docstrings. With the collaboration of the numpydoc maintainers, we'd like to
-move the checks to a package other than pandas so that other projects can easily
-use them as well.
-
Performance monitoring
----------------------
diff --git a/web/pandas/about/roadmap.md b/web/pandas/about/roadmap.md
index 8a5c2735b3d93..35a6b3361f32e 100644
--- a/web/pandas/about/roadmap.md
+++ b/web/pandas/about/roadmap.md
@@ -134,19 +134,6 @@ pandas documentation. Some specific goals include
subsections of the documentation to make navigation and finding
content easier.
-## Package docstring validation
-
-To improve the quality and consistency of pandas docstrings, we've
-developed tooling to check docstrings in a variety of ways.
-<https://github.com/pandas-dev/pandas/blob/master/scripts/validate_docstrings.py>
-contains the checks.
-
-Like many other projects, pandas uses the
-[numpydoc](https://numpydoc.readthedocs.io/en/latest/) style for writing
-docstrings. With the collaboration of the numpydoc maintainers, we'd
-like to move the checks to a package other than pandas so that other
-projects can easily use them as well.
-
## Performance monitoring
Pandas uses [airspeed velocity](https://asv.readthedocs.io/en/stable/)
| The docstring validation script was moved to numpydoc, so it's probably worth removing this task from the roadmap.
The integration of the new numpydoc script in pandas is ready in #30746 | https://api.github.com/repos/pandas-dev/pandas/pulls/30893 | 2020-01-10T17:06:52Z | 2020-01-10T23:21:21Z | 2020-01-10T23:21:21Z | 2020-01-10T23:21:21Z |
WEB: Link from the website to the docs | diff --git a/web/pandas/config.yml b/web/pandas/config.yml
index e2a95a5039884..65844379b0219 100644
--- a/web/pandas/config.yml
+++ b/web/pandas/config.yml
@@ -35,15 +35,7 @@ navbar:
- name: "Getting started"
target: /getting_started.html
- name: "Documentation"
- target:
- - name: "User guide"
- target: /docs/user_guide/index.html
- - name: "API reference"
- target: /docs/reference/index.html
- - name: "Release notes"
- target: /docs/whatsnew/index.html
- - name: "Older versions"
- target: https://pandas.pydata.org/pandas-docs/version/
+ target: /docs/
- name: "Community"
target:
- name: "Blog"
| The navigation of the web was implemented assuming the docs will render with the same layout. Since this is not finally the case, and the website and the docs are finally independent, I guess it makes more sense to simply link to the home of the docs.
Otherwise, we'd need to rethink those links, since the last one is broken, and the rest are inconsistent with the navigation of the docs.
Closes https://github.com/pandas-dev/pandas/issues/31657
| https://api.github.com/repos/pandas-dev/pandas/pulls/30891 | 2020-01-10T16:33:39Z | 2020-02-05T15:50:45Z | 2020-02-05T15:50:44Z | 2020-02-05T15:50:58Z |
WEB: Removing Discourse links | diff --git a/web/pandas/_templates/layout.html b/web/pandas/_templates/layout.html
index 120058afd1190..92126a7b5a2f2 100644
--- a/web/pandas/_templates/layout.html
+++ b/web/pandas/_templates/layout.html
@@ -84,11 +84,6 @@
<i class="fab fa-stack-overflow"></i>
</a>
</li>
- <li class="list-inline-item">
- <a href="https://pandas.discourse.group">
- <i class="fab fa-discourse"></i>
- </a>
- </li>
</ul>
<p>
pandas is a fiscally sponsored project of <a href="https://numfocus.org">NumFOCUS</a>
diff --git a/web/pandas/config.yml b/web/pandas/config.yml
index e2a95a5039884..d1fb7ba0f7b86 100644
--- a/web/pandas/config.yml
+++ b/web/pandas/config.yml
@@ -50,8 +50,6 @@ navbar:
target: /community/blog.html
- name: "Ask a question (StackOverflow)"
target: https://stackoverflow.com/questions/tagged/pandas
- - name: "Discuss"
- target: https://pandas.discourse.group
- name: "Code of conduct"
target: /community/coc.html
- name: "Ecosystem"
| Just realized that the discourse links are still in the web. They should be removed, since we're not planning to use discourse for now. | https://api.github.com/repos/pandas-dev/pandas/pulls/30890 | 2020-01-10T16:26:59Z | 2020-01-10T19:26:21Z | 2020-01-10T19:26:21Z | 2020-01-10T19:26:27Z |
DOC: Move import conventions from wiki to docs #30808 | diff --git a/doc/source/development/code_style.rst b/doc/source/development/code_style.rst
index 2fc2f1fb6ee8d..a295038b5a0bd 100644
--- a/doc/source/development/code_style.rst
+++ b/doc/source/development/code_style.rst
@@ -127,3 +127,29 @@ For example:
value = str
f"Unknown recived type, got: '{type(value).__name__}'"
+
+
+Imports (aim for absolute)
+==========================
+
+In Python 3, absolute imports are recommended. In absolute import doing something
+like ``import string`` will import the string module rather than ``string.py``
+in the same directory. As much as possible, you should try to write out
+absolute imports that show the whole import chain from toplevel pandas.
+
+Explicit relative imports are also supported in Python 3. But it is not
+recommended to use it. Implicit relative imports should never be used
+and is removed in Python 3.
+
+For example:
+
+::
+
+ # preferred
+ import pandas.core.common as com
+
+ # not preferred
+ from .common import test_base
+
+ # wrong
+ from common import test_base
| - [x] closes #30808
- [ ] 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/30888 | 2020-01-10T15:48:25Z | 2020-01-13T13:05:17Z | 2020-01-13T13:05:17Z | 2020-01-13T18:10:26Z |
[DOC] set klass correctly for series and dataframe set_axis | diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 676b78573399c..e22e20febb68e 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -3819,6 +3819,46 @@ def align(
broadcast_axis=broadcast_axis,
)
+ @Appender(
+ """
+ >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+
+ Change the row labels.
+
+ >>> df.set_axis(['a', 'b', 'c'], axis='index')
+ A B
+ a 1 4
+ b 2 5
+ c 3 6
+
+ Change the column labels.
+
+ >>> df.set_axis(['I', 'II'], axis='columns')
+ I II
+ 0 1 4
+ 1 2 5
+ 2 3 6
+
+ Now, update the labels inplace.
+
+ >>> df.set_axis(['i', 'ii'], axis='columns', inplace=True)
+ >>> df
+ i ii
+ 0 1 4
+ 1 2 5
+ 2 3 6
+ """
+ )
+ @Substitution(
+ **_shared_doc_kwargs,
+ extended_summary_sub=" column or",
+ axis_description_sub=", and 1 identifies the columns",
+ see_also_sub=" or columns",
+ )
+ @Appender(NDFrame.set_axis.__doc__)
+ def set_axis(self, labels, axis=0, inplace=False):
+ return super().set_axis(labels, axis=axis, inplace=inplace)
+
@Substitution(**_shared_doc_kwargs)
@Appender(NDFrame.reindex.__doc__)
@rewrite_axis_style_signature(
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 03e86758b64ed..b6c4d62919305 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -573,7 +573,7 @@ def set_axis(self, labels, axis=0, inplace=False):
"""
Assign desired index to given axis.
- Indexes for column or row labels can be changed by assigning
+ Indexes for%(extended_summary_sub)s row labels can be changed by assigning
a list-like or Index.
.. versionchanged:: 0.21.0
@@ -588,9 +588,8 @@ def set_axis(self, labels, axis=0, inplace=False):
labels : list-like, Index
The values for the new index.
- axis : {0 or 'index', 1 or 'columns'}, default 0
- The axis to update. The value 0 identifies the rows, and 1
- identifies the columns.
+ axis : %(axes_single_arg)s, default 0
+ The axis to update. The value 0 identifies the rows%(axis_description_sub)s.
inplace : bool, default False
Whether to return a new %(klass)s instance.
@@ -598,57 +597,14 @@ def set_axis(self, labels, axis=0, inplace=False):
Returns
-------
renamed : %(klass)s or None
- An object of same type as caller if inplace=False, None otherwise.
+ An object of type %(klass)s if inplace=False, None otherwise.
See Also
--------
- DataFrame.rename_axis : Alter the name of the index or columns.
+ %(klass)s.rename_axis : Alter the name of the index%(see_also_sub)s.
Examples
--------
- **Series**
-
- >>> s = pd.Series([1, 2, 3])
- >>> s
- 0 1
- 1 2
- 2 3
- dtype: int64
-
- >>> s.set_axis(['a', 'b', 'c'], axis=0)
- a 1
- b 2
- c 3
- dtype: int64
-
- **DataFrame**
-
- >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
-
- Change the row labels.
-
- >>> df.set_axis(['a', 'b', 'c'], axis='index')
- A B
- a 1 4
- b 2 5
- c 3 6
-
- Change the column labels.
-
- >>> df.set_axis(['I', 'II'], axis='columns')
- I II
- 0 1 4
- 1 2 5
- 2 3 6
-
- Now, update the labels inplace.
-
- >>> df.set_axis(['i', 'ii'], axis='columns', inplace=True)
- >>> df
- i ii
- 0 1 4
- 1 2 5
- 2 3 6
"""
if inplace:
setattr(self, self._get_axis_name(axis), labels)
diff --git a/pandas/core/series.py b/pandas/core/series.py
index ed338700f1011..f29f5ef6bc2ed 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -3986,6 +3986,32 @@ def rename(
else:
return self._set_name(index, inplace=inplace)
+ @Appender(
+ """
+ >>> s = pd.Series([1, 2, 3])
+ >>> s
+ 0 1
+ 1 2
+ 2 3
+ dtype: int64
+
+ >>> s.set_axis(['a', 'b', 'c'], axis=0)
+ a 1
+ b 2
+ c 3
+ dtype: int64
+ """
+ )
+ @Substitution(
+ **_shared_doc_kwargs,
+ extended_summary_sub="",
+ axis_description_sub="",
+ see_also_sub="",
+ )
+ @Appender(generic.NDFrame.set_axis.__doc__)
+ def set_axis(self, labels, axis=0, inplace=False):
+ return super().set_axis(labels, axis=axis, inplace=inplace)
+
@Substitution(**_shared_doc_kwargs)
@Appender(generic.NDFrame.reindex.__doc__)
def reindex(self, index=None, **kwargs):
| - [x] closes #30881
- [ ] 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/30885 | 2020-01-10T14:28:37Z | 2020-01-20T18:04:01Z | 2020-01-20T18:04:01Z | 2020-01-20T22:27:09Z |
Backport PR #30878 on branch 1.0.x (DEPR: fix missing stacklevel in pandas.core.index deprecation) | diff --git a/pandas/core/index.py b/pandas/core/index.py
index a9c8e6731a17e..8cff53d7a8b74 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -27,4 +27,5 @@
"pandas.core.index is deprecated and will be removed in a future version. "
"The public classes are available in the top-level namespace.",
FutureWarning,
+ stacklevel=2,
)
| Backport PR #30878: DEPR: fix missing stacklevel in pandas.core.index deprecation | https://api.github.com/repos/pandas-dev/pandas/pulls/30883 | 2020-01-10T14:01:42Z | 2020-01-10T19:23:33Z | 2020-01-10T19:23:33Z | 2020-01-10T19:23:34Z |
raise more specific error if dict is appended to frame wit… | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 1cd325dad9f07..a9585fd13e36b 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -161,7 +161,8 @@ ExtensionArray
Other
^^^^^
--
+- Appending a dictionary to a :class:`DataFrame` without passing ``ignore_index=True`` will raise ``TypeError: Can only append a dict if ignore_index=True``
+ instead of ``TypeError: Can only append a Series if ignore_index=True or if the Series has a name`` (:issue:`30871`)
-
.. ---------------------------------------------------------------------------
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 1a49388d81243..7817cd08ab9a9 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -7062,6 +7062,8 @@ def append(
"""
if isinstance(other, (Series, dict)):
if isinstance(other, dict):
+ if not ignore_index:
+ raise TypeError("Can only append a dict if ignore_index=True")
other = Series(other)
if other.name is None and not ignore_index:
raise TypeError(
diff --git a/pandas/tests/frame/methods/test_append.py b/pandas/tests/frame/methods/test_append.py
index d128a51f4b390..9fc3629e794e2 100644
--- a/pandas/tests/frame/methods/test_append.py
+++ b/pandas/tests/frame/methods/test_append.py
@@ -50,6 +50,10 @@ def test_append_series_dict(self):
)
tm.assert_frame_equal(result, expected.loc[:, result.columns])
+ msg = "Can only append a dict if ignore_index=True"
+ with pytest.raises(TypeError, match=msg):
+ df.append(series.to_dict())
+
# can append when name set
row = df.loc[4]
row.name = 5
| …hout ignore_index
- [x] closes #30871
- [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/30882 | 2020-01-10T13:39:36Z | 2020-01-20T18:11:02Z | 2020-01-20T18:11:02Z | 2020-01-20T22:28:04Z |
DEPR: fix missing stacklevel in pandas.core.index deprecation | diff --git a/pandas/core/index.py b/pandas/core/index.py
index a9c8e6731a17e..8cff53d7a8b74 100644
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -27,4 +27,5 @@
"pandas.core.index is deprecated and will be removed in a future version. "
"The public classes are available in the top-level namespace.",
FutureWarning,
+ stacklevel=2,
)
| xref https://github.com/pandas-dev/pandas/issues/30872 | https://api.github.com/repos/pandas-dev/pandas/pulls/30878 | 2020-01-10T07:50:41Z | 2020-01-10T14:01:10Z | 2020-01-10T14:01:10Z | 2020-01-10T14:04:27Z |
CLN: misc cleanups | diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 28d269a9a809e..ce6d12d61c521 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -85,7 +85,6 @@ cdef class IndexEngine:
"""
cdef:
object loc
- void* data_ptr
loc = self.get_loc(key)
if isinstance(loc, slice) or util.is_array(loc):
@@ -101,7 +100,6 @@ cdef class IndexEngine:
"""
cdef:
object loc
- void* data_ptr
loc = self.get_loc(key)
value = convert_scalar(arr, value)
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 9eb5ed7cb0911..bf1272b223f70 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -156,13 +156,11 @@ def equals(self, other) -> bool:
def __contains__(self, key):
try:
res = self.get_loc(key)
- return (
- is_scalar(res)
- or isinstance(res, slice)
- or (is_list_like(res) and len(res))
- )
except (KeyError, TypeError, ValueError):
return False
+ return bool(
+ is_scalar(res) or isinstance(res, slice) or (is_list_like(res) and len(res))
+ )
# Try to run function on index first, and then on elements of index
# Especially important for group-by functionality
@@ -875,11 +873,7 @@ def _is_convertible_to_index_for_join(cls, other: Index) -> bool:
def _wrap_joined_index(self, joined, other):
name = get_op_result_name(self, other)
- if (
- isinstance(other, type(self))
- and self.freq == other.freq
- and self._can_fast_union(other)
- ):
+ if self._can_fast_union(other):
joined = self._shallow_copy(joined)
joined.name = name
return joined
| Things I find myself doing in multiple branches. | https://api.github.com/repos/pandas-dev/pandas/pulls/30877 | 2020-01-10T04:12:59Z | 2020-01-13T20:25:58Z | 2020-01-13T20:25:58Z | 2020-01-14T04:20:44Z |
ENH Avoid redundant CSS in Styler.render | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 294183e24c96f..01c089b46b4a1 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -18,6 +18,7 @@ Enhancements
Other enhancements
^^^^^^^^^^^^^^^^^^
+- :class:`Styler` may now render CSS more efficiently where multiple cells have the same styling (:issue:`30876`)
-
-
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 4f2430b6c8568..565752e269d79 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -286,7 +286,7 @@ def format_attr(pair):
clabels = [[x] for x in clabels]
clabels = list(zip(*clabels))
- cellstyle = []
+ cellstyle_map = defaultdict(list)
head = []
for r in range(n_clvls):
@@ -408,12 +408,17 @@ def format_attr(pair):
for x in ctx[r, c]:
# have to handle empty styles like ['']
if x.count(":"):
- props.append(x.split(":"))
+ props.append(tuple(x.split(":")))
else:
- props.append(["", ""])
- cellstyle.append({"props": props, "selector": f"row{r}_col{c}"})
+ props.append(("", ""))
+ cellstyle_map[tuple(props)].append(f"row{r}_col{c}")
body.append(row_es)
+ cellstyle = [
+ {"props": list(props), "selectors": selectors}
+ for props, selectors in cellstyle_map.items()
+ ]
+
table_attr = self.table_attributes
use_mathjax = get_option("display.html.use_mathjax")
if not use_mathjax:
diff --git a/pandas/io/formats/templates/html.tpl b/pandas/io/formats/templates/html.tpl
index 15feafcea6864..97bfda9af089d 100644
--- a/pandas/io/formats/templates/html.tpl
+++ b/pandas/io/formats/templates/html.tpl
@@ -14,7 +14,7 @@
{% block before_cellstyle %}{% endblock before_cellstyle %}
{% block cellstyle %}
{%- for s in cellstyle %}
- #T_{{uuid}}{{s.selector}} {
+ {%- for selector in s.selectors -%}{%- if not loop.first -%},{%- endif -%}#T_{{uuid}}{{selector}}{%- endfor -%} {
{% for p,val in s.props %}
{{p}}: {{val}};
{% endfor %}
diff --git a/pandas/tests/io/formats/test_style.py b/pandas/tests/io/formats/test_style.py
index e5dac18acedf6..a2659079be7c0 100644
--- a/pandas/tests/io/formats/test_style.py
+++ b/pandas/tests/io/formats/test_style.py
@@ -472,8 +472,19 @@ def test_empty(self):
result = s._translate()["cellstyle"]
expected = [
- {"props": [["color", " red"]], "selector": "row0_col0"},
- {"props": [["", ""]], "selector": "row1_col0"},
+ {"props": [("color", " red")], "selectors": ["row0_col0"]},
+ {"props": [("", "")], "selectors": ["row1_col0"]},
+ ]
+ assert result == expected
+
+ def test_duplicate(self):
+ df = pd.DataFrame({"A": [1, 0]})
+ s = df.style
+ s.ctx = {(0, 0): ["color: red"], (1, 0): ["color: red"]}
+
+ result = s._translate()["cellstyle"]
+ expected = [
+ {"props": [("color", " red")], "selectors": ["row0_col0", "row1_col0"]}
]
assert result == expected
| Where multiple styled cells have the same CSS, only make one CSS declaration. This can reduce the output size substantially.
- [x] ~~closes #xxxx~~
- [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/30876 | 2020-01-10T00:51:21Z | 2020-01-20T19:52:09Z | 2020-01-20T19:52:09Z | 2020-01-20T19:52:11Z |
CLN: remove unnecessary overriding in subclasses | diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 7c1e95e12d339..477db9b0dc8d7 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -428,19 +428,6 @@ def _engine(self):
codes = self.codes
return self._engine_type(lambda: codes, len(self))
- # introspection
- @cache_readonly
- def is_unique(self) -> bool:
- return self._engine.is_unique
-
- @property
- def is_monotonic_increasing(self):
- return self._engine.is_monotonic_increasing
-
- @property
- def is_monotonic_decreasing(self) -> bool:
- return self._engine.is_monotonic_decreasing
-
@Appender(_index_shared_docs["index_unique"] % _index_doc_kwargs)
def unique(self, level=None):
if level is not None:
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index d33ba52cc7524..1c86235f9eaa1 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -437,22 +437,8 @@ def memory_usage(self, deep: bool = False) -> int:
# so return the bytes here
return self.left.memory_usage(deep=deep) + self.right.memory_usage(deep=deep)
- @cache_readonly
- def is_monotonic(self) -> bool:
- """
- Return True if the IntervalIndex is monotonic increasing (only equal or
- increasing values), else False
- """
- return self.is_monotonic_increasing
-
- @cache_readonly
- def is_monotonic_increasing(self) -> bool:
- """
- Return True if the IntervalIndex is monotonic increasing (only equal or
- increasing values), else False
- """
- return self._engine.is_monotonic_increasing
-
+ # IntervalTree doesn't have a is_monotonic_decreasing, so have to override
+ # the Index implemenation
@cache_readonly
def is_monotonic_decreasing(self) -> bool:
"""
| https://api.github.com/repos/pandas-dev/pandas/pulls/30875 | 2020-01-10T00:35:00Z | 2020-01-10T02:11:31Z | 2020-01-10T02:11:31Z | 2020-01-10T02:18:23Z | |
CLN: fix wrong types getting passed to TDI._get_string_slice | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index ca929b188dc33..e6747c90168cb 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -96,6 +96,7 @@
duplicated="np.ndarray",
)
_index_shared_docs = dict()
+str_t = str
def _make_comparison_op(op, cls):
@@ -4630,7 +4631,7 @@ def isin(self, values, level=None):
self._validate_index_level(level)
return algos.isin(self, values)
- def _get_string_slice(self, key, use_lhs=True, use_rhs=True):
+ def _get_string_slice(self, key: str_t, use_lhs: bool = True, use_rhs: bool = True):
# this is for partial string indexing,
# overridden in DatetimeIndex, TimedeltaIndex and PeriodIndex
raise NotImplementedError
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 6ab2e66e05d6e..1de7fb0e55869 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -695,7 +695,8 @@ def _parsed_string_to_bounds(self, reso, parsed):
raise KeyError(reso)
return (t1.asfreq(self.freq, how="start"), t1.asfreq(self.freq, how="end"))
- def _get_string_slice(self, key):
+ def _get_string_slice(self, key: str, use_lhs: bool = True, use_rhs: bool = True):
+ # TODO: Check for non-True use_lhs/use_rhs
if not self.is_monotonic:
raise ValueError("Partial indexing only valid for ordered time series")
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 1f3182bc83e1d..903fe9aa24458 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -237,25 +237,18 @@ def get_value(self, series, key):
know what you're doing
"""
- if _is_convertible_to_td(key):
+ if isinstance(key, str):
+ try:
+ key = Timedelta(key)
+ except ValueError:
+ raise KeyError(key)
+
+ if isinstance(key, self._data._recognized_scalars) or key is NaT:
key = Timedelta(key)
return self.get_value_maybe_box(series, key)
- try:
- value = Index.get_value(self, series, key)
- except KeyError:
- try:
- loc = self._get_string_slice(key)
- return series[loc]
- except (TypeError, ValueError, KeyError):
- pass
-
- try:
- return self.get_value_maybe_box(series, key)
- except (TypeError, ValueError, KeyError):
- raise KeyError(key)
- else:
- return com.maybe_box(self, value, series, key)
+ value = Index.get_value(self, series, key)
+ return com.maybe_box(self, value, series, key)
def get_value_maybe_box(self, series, key: Timedelta):
values = self._engine.get_value(com.values_from_object(series), key)
@@ -288,19 +281,7 @@ def get_loc(self, key, method=None, tolerance=None):
key = Timedelta(key)
return Index.get_loc(self, key, method, tolerance)
- try:
- return Index.get_loc(self, key, method, tolerance)
- except (KeyError, ValueError, TypeError):
- try:
- return self._get_string_slice(key)
- except (TypeError, KeyError, ValueError):
- pass
-
- try:
- stamp = Timedelta(key)
- return Index.get_loc(self, stamp, method, tolerance)
- except (KeyError, ValueError):
- raise KeyError(key)
+ return Index.get_loc(self, key, method, tolerance)
def _maybe_cast_slice_bound(self, label, side, kind):
"""
@@ -330,18 +311,10 @@ def _maybe_cast_slice_bound(self, label, side, kind):
return label
- def _get_string_slice(self, key):
- if is_integer(key) or is_float(key) or key is NaT:
- self._invalid_indexer("slice", key)
- loc = self._partial_td_slice(key)
- return loc
-
- def _partial_td_slice(self, key):
-
+ def _get_string_slice(self, key: str, use_lhs: bool = True, use_rhs: bool = True):
+ # TODO: Check for non-True use_lhs/use_rhs
+ assert isinstance(key, str), type(key)
# given a key, try to figure out a location for a partial slice
- if not isinstance(key, str):
- return key
-
raise NotImplementedError
@Substitution(klass="TimedeltaIndex")
| Removes unreachable code paths. | https://api.github.com/repos/pandas-dev/pandas/pulls/30874 | 2020-01-10T00:27:19Z | 2020-01-20T17:21:25Z | 2020-01-20T17:21:25Z | 2020-01-20T18:57:16Z |
DOC: add note about many removals in pandas 1.0 | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 724525476c629..97fdd8d2566b9 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -6,6 +6,15 @@ What's new in 1.0.0 (??)
These are the changes in pandas 1.0.0. See :ref:`release` for a full changelog
including other versions of pandas.
+.. note::
+
+ The pandas 1.0 release removed a lot of functionality that was deprecated
+ in previous releases (see :ref:`below <whatsnew_100.prior_deprecations>`
+ for an overview). It is recommended to first upgrade to pandas 0.25 and to
+ ensure your code is working without warnings, before upgrading to pandas
+ 1.0.
+
+
New Deprecation Policy
~~~~~~~~~~~~~~~~~~~~~~
@@ -14,7 +23,7 @@ version releases. Briefly,
* Deprecations will be introduced in minor releases (e.g. 1.1.0, 1.2.0, 2.1.0, ...)
* Deprecations will be enforced in major releases (e.g. 1.0.0, 2.0.0, 3.0.0, ...)
-* API-breaking changes will be made only in major releases
+* API-breaking changes will be made only in major releases (except for experimental features)
See :ref:`policies.version` for more.
| cc @TomAugspurger
Adding a note about the recommended way to upgrade to pandas 1.0, if that sounds OK | https://api.github.com/repos/pandas-dev/pandas/pulls/30865 | 2020-01-09T20:45:50Z | 2020-01-09T21:14:05Z | 2020-01-09T21:14:05Z | 2020-01-09T21:14:10Z |
DOC: Encourage use of pre-commit in the docs | diff --git a/doc/source/development/contributing.rst b/doc/source/development/contributing.rst
index 93c65ba7358c9..2dc5ed07544d1 100644
--- a/doc/source/development/contributing.rst
+++ b/doc/source/development/contributing.rst
@@ -635,6 +635,8 @@ many errors as possible, but it may not correct *all* of them. Thus, it is
recommended that you run ``cpplint`` to double check and make any other style
fixes manually.
+.. _contributing.code-formatting:
+
Python (PEP8 / black)
~~~~~~~~~~~~~~~~~~~~~
@@ -656,19 +658,8 @@ apply ``black`` as you edit files.
You should use a ``black`` version >= 19.10b0 as previous versions are not compatible
with the pandas codebase.
-Optionally, you may wish to setup `pre-commit hooks <https://pre-commit.com/>`_
-to automatically run ``black`` and ``flake8`` when you make a git commit. This
-can be done by installing ``pre-commit``::
-
- pip install pre-commit
-
-and then running::
-
- pre-commit install
-
-from the root of the pandas repository. Now ``black`` and ``flake8`` will be run
-each time you commit changes. You can skip these checks with
-``git commit --no-verify``.
+If you wish to run these checks automatically, we encourage you to use
+:ref:`pre-commits <contributing.pre-commit>` instead.
One caveat about ``git diff upstream/master -u -- "*.py" | flake8 --diff``: this
command will catch any stylistic errors in your changes specifically, but
@@ -676,7 +667,7 @@ be beware it may not catch all of them. For example, if you delete the only
usage of an imported function, it is stylistically incorrect to import an
unused function. However, style-checking the diff will not catch this because
the actual import is not part of the diff. Thus, for completeness, you should
-run this command, though it will take longer::
+run this command, though it may take longer::
git diff upstream/master --name-only -- "*.py" | xargs -r flake8
@@ -694,6 +685,8 @@ behaviour as follows::
This will get all the files being changed by the PR (and ending with ``.py``),
and run ``flake8`` on them, one after the other.
+Note that these commands can be run analogously with ``black``.
+
.. _contributing.import-formatting:
Import formatting
@@ -716,7 +709,6 @@ A summary of our current import sections ( in order ):
Imports are alphabetically sorted within these sections.
-
As part of :ref:`Continuous Integration <contributing.ci>` checks we run::
isort --recursive --check-only pandas
@@ -740,8 +732,37 @@ to automatically format imports correctly. This will modify your local copy of t
The `--recursive` flag can be passed to sort all files in a directory.
+Alternatively, you can run a command similar to what was suggested for ``black`` and ``flake8`` :ref:`right above <contributing.code-formatting>`::
+
+ git diff upstream/master --name-only -- "*.py" | xargs -r isort
+
+Where similar caveats apply if you are on OSX or Windows.
+
You can then verify the changes look ok, then git :ref:`commit <contributing.commit-code>` and :ref:`push <contributing.push-code>`.
+.. _contributing.pre-commit:
+
+Pre-Commit
+~~~~~~~~~~
+
+You can run many of these styling checks manually as we have described above. However,
+we encourage you to use `pre-commit hooks <https://pre-commit.com/>`_ instead
+to automatically run ``black``, ``flake8``, ``isort`` when you make a git commit. This
+can be done by installing ``pre-commit``::
+
+ pip install pre-commit
+
+and then running::
+
+ pre-commit install
+
+from the root of the pandas repository. Now all of the styling checks will be
+run each time you commit changes without your needing to run each one manually.
+In addition, using this pre-commit hook will also allow you to more easily
+remain up-to-date with our code checks as they change.
+
+Note that if needed, you can skip these checks with ``git commit --no-verify``.
+
Backwards compatibility
~~~~~~~~~~~~~~~~~~~~~~~
| Previously, we stated it as merely optional.
xref https://github.com/pandas-dev/pandas/pull/30773, https://github.com/pandas-dev/pandas/pull/30814
| https://api.github.com/repos/pandas-dev/pandas/pulls/30864 | 2020-01-09T20:33:30Z | 2020-01-10T19:22:38Z | 2020-01-10T19:22:37Z | 2020-01-10T23:52:45Z |
Parallel Cythonization for spawned Processes | diff --git a/setup.py b/setup.py
index 191fe49d1eb89..ca5c67fc079ab 100755
--- a/setup.py
+++ b/setup.py
@@ -9,6 +9,7 @@
import argparse
from distutils.sysconfig import get_config_vars
from distutils.version import LooseVersion
+import multiprocessing
import os
from os.path import join as pjoin
import platform
@@ -35,17 +36,6 @@ def is_platform_mac():
min_numpy_ver = "1.13.3"
min_cython_ver = "0.29.13" # note: sync with pyproject.toml
-setuptools_kwargs = {
- "install_requires": [
- "python-dateutil >= 2.6.1",
- "pytz >= 2017.2",
- f"numpy >= {min_numpy_ver}",
- ],
- "setup_requires": [f"numpy >= {min_numpy_ver}"],
- "zip_safe": False,
-}
-
-
try:
import Cython
@@ -531,11 +521,6 @@ def maybe_cythonize(extensions, *args, **kwargs):
elif parsed.j:
nthreads = parsed.j
- # GH#30356 Cythonize doesn't support parallel on Windows
- if is_platform_windows() and nthreads > 0:
- print("Parallel build for cythonize ignored on Windows")
- nthreads = 0
-
kwargs["nthreads"] = nthreads
build_ext.render_templates(_pxifiles)
return cythonize(extensions, *args, **kwargs)
@@ -744,37 +729,51 @@ def srcpath(name=None, suffix=".pyx", subdir="src"):
# ----------------------------------------------------------------------
-# The build cache system does string matching below this point.
-# if you change something, be careful.
-
-setup(
- name=DISTNAME,
- maintainer=AUTHOR,
- version=versioneer.get_version(),
- packages=find_packages(include=["pandas", "pandas.*"]),
- package_data={"": ["templates/*", "_libs/*.dll"]},
- ext_modules=maybe_cythonize(extensions, compiler_directives=directives),
- maintainer_email=EMAIL,
- description=DESCRIPTION,
- license=LICENSE,
- cmdclass=cmdclass,
- url=URL,
- download_url=DOWNLOAD_URL,
- project_urls=PROJECT_URLS,
- long_description=LONG_DESCRIPTION,
- classifiers=CLASSIFIERS,
- platforms="any",
- python_requires=">=3.6.1",
- extras_require={
- "test": [
- # sync with setup.cfg minversion & install.rst
- "pytest>=4.0.2",
- "pytest-xdist",
- "hypothesis>=3.58",
- ]
- },
- entry_points={
- "pandas_plotting_backends": ["matplotlib = pandas:plotting._matplotlib"]
- },
- **setuptools_kwargs,
-)
+def setup_package():
+ setuptools_kwargs = {
+ "install_requires": [
+ "python-dateutil >= 2.6.1",
+ "pytz >= 2017.2",
+ f"numpy >= {min_numpy_ver}",
+ ],
+ "setup_requires": [f"numpy >= {min_numpy_ver}"],
+ "zip_safe": False,
+ }
+
+ setup(
+ name=DISTNAME,
+ maintainer=AUTHOR,
+ version=versioneer.get_version(),
+ packages=find_packages(include=["pandas", "pandas.*"]),
+ package_data={"": ["templates/*", "_libs/*.dll"]},
+ ext_modules=maybe_cythonize(extensions, compiler_directives=directives),
+ maintainer_email=EMAIL,
+ description=DESCRIPTION,
+ license=LICENSE,
+ cmdclass=cmdclass,
+ url=URL,
+ download_url=DOWNLOAD_URL,
+ project_urls=PROJECT_URLS,
+ long_description=LONG_DESCRIPTION,
+ classifiers=CLASSIFIERS,
+ platforms="any",
+ python_requires=">=3.6.1",
+ extras_require={
+ "test": [
+ # sync with setup.cfg minversion & install.rst
+ "pytest>=4.0.2",
+ "pytest-xdist",
+ "hypothesis>=3.58",
+ ]
+ },
+ entry_points={
+ "pandas_plotting_backends": ["matplotlib = pandas:plotting._matplotlib"]
+ },
+ **setuptools_kwargs,
+ )
+
+
+if __name__ == "__main__":
+ # Freeze to support parallel compilation when using spawn instead of fork
+ multiprocessing.freeze_support()
+ setup_package()
| Originally thought this only affected Windows, but parallel Cythonization is also broken on Python 3.8 on macOS as they shifted from using fork to start sub-processes to using spawn
https://bugs.python.org/issue33725
This fix should make things work regardless of platform / python version
| https://api.github.com/repos/pandas-dev/pandas/pulls/30862 | 2020-01-09T19:33:18Z | 2020-01-24T04:01:16Z | 2020-01-24T04:01:16Z | 2023-04-12T20:17:03Z |
BUG: ExtensionArray._formatter does not need to handle nulls | diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index b981c2feea380..6adf69a922000 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1230,7 +1230,7 @@ def _format(x):
if x is None:
return "None"
elif x is NA:
- return formatter(x)
+ return str(NA)
elif x is NaT or np.isnat(x):
return "NaT"
except (TypeError, ValueError):
| See https://github.com/pandas-dev/pandas/pull/30821/files#r364917242
Currently, I don't think this is really specified whether the `_formatter` of ExtensionArray should be able to handle NAs/nulls or not, but in practice, it didn't need to do that. And eg the geopandas one is also implemented right now that it would fail if passed a NA (https://github.com/geopandas/geopandas/blob/add5fe9139883fa54d14fa28426478619948349c/geopandas/array.py#L1026-L1047)
This is certainly something that can be discussed how to specify this, but for now I think it is best to preserve the existing behaviour. | https://api.github.com/repos/pandas-dev/pandas/pulls/30861 | 2020-01-09T19:31:40Z | 2020-01-09T20:19:39Z | 2020-01-09T20:19:39Z | 2020-01-09T20:19:43Z |
REF: gradually move ExtensionIndex delegation to use inherit_names | diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 268ab9ba4e4c4..85f8515907fd2 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -27,7 +27,7 @@
import pandas.core.common as com
import pandas.core.indexes.base as ibase
from pandas.core.indexes.base import Index, _index_shared_docs, maybe_extract_name
-from pandas.core.indexes.extension import ExtensionIndex
+from pandas.core.indexes.extension import ExtensionIndex, inherit_names
import pandas.core.missing as missing
from pandas.core.ops import get_op_result_name
@@ -35,11 +35,21 @@
_index_doc_kwargs.update(dict(target_klass="CategoricalIndex"))
-@accessor.delegate_names(
- delegate=Categorical,
- accessors=["codes", "categories", "ordered"],
- typ="property",
- overwrite=True,
+@inherit_names(
+ [
+ "argsort",
+ "_internal_get_values",
+ "tolist",
+ "codes",
+ "categories",
+ "ordered",
+ "_reverse_indexer",
+ "searchsorted",
+ "is_dtype_equal",
+ "min",
+ "max",
+ ],
+ Categorical,
)
@accessor.delegate_names(
delegate=Categorical,
@@ -52,14 +62,6 @@
"set_categories",
"as_ordered",
"as_unordered",
- "min",
- "max",
- "is_dtype_equal",
- "tolist",
- "_internal_get_values",
- "_reverse_indexer",
- "searchsorted",
- "argsort",
],
typ="method",
overwrite=True,
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index 9ddc5c01030b1..6a10b3650293c 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -16,7 +16,7 @@
from pandas.core.ops import get_op_result_name
-def inherit_from_data(name: str, delegate, cache: bool = False):
+def inherit_from_data(name: str, delegate, cache: bool = False, wrap: bool = False):
"""
Make an alias for a method of the underlying ExtensionArray.
@@ -27,6 +27,8 @@ def inherit_from_data(name: str, delegate, cache: bool = False):
delegate : class
cache : bool, default False
Whether to convert wrapped properties into cache_readonly
+ wrap : bool, default False
+ Whether to wrap the inherited result in an Index.
Returns
-------
@@ -37,12 +39,23 @@ def inherit_from_data(name: str, delegate, cache: bool = False):
if isinstance(attr, property):
if cache:
- method = cache_readonly(attr.fget)
+
+ def cached(self):
+ return getattr(self._data, name)
+
+ cached.__name__ = name
+ cached.__doc__ = attr.__doc__
+ method = cache_readonly(cached)
else:
def fget(self):
- return getattr(self._data, name)
+ result = getattr(self._data, name)
+ if wrap:
+ if isinstance(result, type(self._data)):
+ return type(self)._simple_new(result, name=self.name)
+ return Index(result, name=self.name)
+ return result
def fset(self, value):
setattr(self._data, name, value)
@@ -60,6 +73,10 @@ def fset(self, value):
def method(self, *args, **kwargs):
result = attr(self._data, *args, **kwargs)
+ if wrap:
+ if isinstance(result, type(self._data)):
+ return type(self)._simple_new(result, name=self.name)
+ return Index(result, name=self.name)
return result
method.__name__ = name
@@ -67,7 +84,7 @@ def method(self, *args, **kwargs):
return method
-def inherit_names(names: List[str], delegate, cache: bool = False):
+def inherit_names(names: List[str], delegate, cache: bool = False, wrap: bool = False):
"""
Class decorator to pin attributes from an ExtensionArray to a Index subclass.
@@ -76,11 +93,13 @@ def inherit_names(names: List[str], delegate, cache: bool = False):
names : List[str]
delegate : class
cache : bool, default False
+ wrap : bool, default False
+ Whether to wrap the inherited result in an Index.
"""
def wrapper(cls):
for name in names:
- meth = inherit_from_data(name, delegate, cache=cache)
+ meth = inherit_from_data(name, delegate, cache=cache, wrap=wrap)
setattr(cls, name, meth)
return cls
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index a756900ff9ae5..3e792eba6ad8e 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -36,7 +36,6 @@
)
from pandas.core.dtypes.missing import isna
-from pandas.core import accessor
from pandas.core.algorithms import take_1d
from pandas.core.arrays.interval import IntervalArray, _interval_shared_docs
import pandas.core.common as com
@@ -186,31 +185,27 @@ def func(intvidx_self, other, sort=False):
),
)
)
-@accessor.delegate_names(
- delegate=IntervalArray,
- accessors=["length", "size", "left", "right", "mid", "closed", "dtype"],
- typ="property",
- overwrite=True,
-)
-@accessor.delegate_names(
- delegate=IntervalArray,
- accessors=[
+@inherit_names(["set_closed", "to_tuples"], IntervalArray, wrap=True)
+@inherit_names(
+ [
+ "__len__",
"__array__",
"overlaps",
"contains",
- "__len__",
- "set_closed",
- "to_tuples",
+ "size",
+ "dtype",
+ "left",
+ "right",
+ "length",
],
- typ="method",
- overwrite=True,
+ IntervalArray,
)
@inherit_names(
- ["is_non_overlapping_monotonic", "mid", "_ndarray_values"],
+ ["is_non_overlapping_monotonic", "mid", "_ndarray_values", "closed"],
IntervalArray,
cache=True,
)
-class IntervalIndex(IntervalMixin, ExtensionIndex, accessor.PandasDelegate):
+class IntervalIndex(IntervalMixin, ExtensionIndex):
_typ = "intervalindex"
_comparables = ["name"]
_attributes = ["name", "closed"]
@@ -221,8 +216,6 @@ class IntervalIndex(IntervalMixin, ExtensionIndex, accessor.PandasDelegate):
# Immutable, so we are able to cache computations like isna in '_mask'
_mask = None
- _raw_inherit = {"__array__", "overlaps", "contains"}
-
# --------------------------------------------------------------------
# Constructors
@@ -1155,21 +1148,6 @@ def is_all_dates(self) -> bool:
# TODO: arithmetic operations
- def _delegate_property_get(self, name, *args, **kwargs):
- """ method delegation to the ._values """
- prop = getattr(self._data, name)
- return prop # no wrapping for now
-
- def _delegate_method(self, name, *args, **kwargs):
- """ method delegation to the ._data """
- method = getattr(self._data, name)
- res = method(*args, **kwargs)
- if is_scalar(res) or name in self._raw_inherit:
- return res
- if isinstance(res, IntervalArray):
- return type(self)._simple_new(res, name=self.name)
- return Index(res)
-
# GH#30817 until IntervalArray implements inequalities, get them from Index
def __lt__(self, other):
return Index.__lt__(self, other)
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index e78714487f01e..1257e410b4125 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -45,13 +45,12 @@ class TimedeltaDelegateMixin(DatetimelikeDelegateMixin):
_raw_methods = {"to_pytimedelta", "sum", "std", "median", "_format_native_types"}
_delegated_properties = TimedeltaArray._datetimelike_ops + list(_raw_properties)
- _delegated_methods = (
- TimedeltaArray._datetimelike_methods
- + list(_raw_methods)
- + ["_box_values", "__neg__", "__pos__", "__abs__"]
- )
+ _delegated_methods = TimedeltaArray._datetimelike_methods + list(_raw_methods)
+@inherit_names(
+ ["_box_values", "__neg__", "__pos__", "__abs__"], TimedeltaArray, wrap=True
+)
@inherit_names(
[
"_bool_ops",
| https://api.github.com/repos/pandas-dev/pandas/pulls/30860 | 2020-01-09T19:25:38Z | 2020-01-28T01:54:14Z | 2020-01-28T01:54:14Z | 2020-04-05T17:34:17Z | |
BUG: aggregations were getting overwritten if they had the same name | diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 088f1d1946fa9..5f71cd0e8b814 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -1101,6 +1101,7 @@ Reshaping
- Bug in :func:`crosstab` when inputs are two Series and have tuple names, the output will keep dummy MultiIndex as columns. (:issue:`18321`)
- :meth:`DataFrame.pivot` can now take lists for ``index`` and ``columns`` arguments (:issue:`21425`)
- Bug in :func:`concat` where the resulting indices are not copied when ``copy=True`` (:issue:`29879`)
+- Bug in :meth:`SeriesGroupBy.aggregate` was resulting in aggregations being overwritten when they shared the same name (:issue:`30880`)
- Bug where :meth:`Index.astype` would lose the name attribute when converting from ``Float64Index`` to ``Int64Index``, or when casting to an ``ExtensionArray`` dtype (:issue:`32013`)
- :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`)
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index 093e1d4ab3942..94dc216c82f55 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -278,7 +278,7 @@ def aggregate(
if isinstance(ret, dict):
from pandas import concat
- ret = concat(ret, axis=1)
+ ret = concat(ret.values(), axis=1, keys=[key.label for key in ret.keys()])
return ret
agg = aggregate
@@ -307,8 +307,8 @@ def _aggregate_multiple_funcs(self, arg):
arg = zip(columns, arg)
- results = {}
- for name, func in arg:
+ results: Dict[base.OutputKey, Union[Series, DataFrame]] = {}
+ for idx, (name, func) in enumerate(arg):
obj = self
# reset the cache so that we
@@ -317,13 +317,14 @@ def _aggregate_multiple_funcs(self, arg):
obj = copy.copy(obj)
obj._reset_cache()
obj._selection = name
- results[name] = obj.aggregate(func)
+ results[base.OutputKey(label=name, position=idx)] = obj.aggregate(func)
if any(isinstance(x, DataFrame) for x in results.values()):
# let higher level handle
return results
- return self.obj._constructor_expanddim(results, columns=columns)
+ output = self._wrap_aggregated_output(results)
+ return self.obj._constructor_expanddim(output, columns=columns)
def _wrap_series_output(
self, output: Mapping[base.OutputKey, Union[Series, np.ndarray]], index: Index,
@@ -354,10 +355,12 @@ def _wrap_series_output(
if len(output) > 1:
result = self.obj._constructor_expanddim(indexed_output, index=index)
result.columns = columns
- else:
+ elif not columns.empty:
result = self.obj._constructor(
indexed_output[0], index=index, name=columns[0]
)
+ else:
+ result = self.obj._constructor_expanddim()
return result
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index dbd713a0af4cf..bf465635c0085 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -2,10 +2,13 @@
test .agg behavior / note that .apply is tested generally in test_groupby.py
"""
import functools
+from functools import partial
import numpy as np
import pytest
+from pandas.errors import PerformanceWarning
+
from pandas.core.dtypes.common import is_integer_dtype
import pandas as pd
@@ -252,6 +255,61 @@ def test_agg_multiple_functions_maintain_order(df):
tm.assert_index_equal(result.columns, exp_cols)
+def test_agg_multiple_functions_same_name():
+ # GH 30880
+ df = pd.DataFrame(
+ np.random.randn(1000, 3),
+ index=pd.date_range("1/1/2012", freq="S", periods=1000),
+ columns=["A", "B", "C"],
+ )
+ result = df.resample("3T").agg(
+ {"A": [partial(np.quantile, q=0.9999), partial(np.quantile, q=0.1111)]}
+ )
+ expected_index = pd.date_range("1/1/2012", freq="3T", periods=6)
+ expected_columns = MultiIndex.from_tuples([("A", "quantile"), ("A", "quantile")])
+ expected_values = np.array(
+ [df.resample("3T").A.quantile(q=q).values for q in [0.9999, 0.1111]]
+ ).T
+ expected = pd.DataFrame(
+ expected_values, columns=expected_columns, index=expected_index
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+def test_agg_multiple_functions_same_name_with_ohlc_present():
+ # GH 30880
+ # ohlc expands dimensions, so different test to the above is required.
+ df = pd.DataFrame(
+ np.random.randn(1000, 3),
+ index=pd.date_range("1/1/2012", freq="S", periods=1000),
+ columns=["A", "B", "C"],
+ )
+ result = df.resample("3T").agg(
+ {"A": ["ohlc", partial(np.quantile, q=0.9999), partial(np.quantile, q=0.1111)]}
+ )
+ expected_index = pd.date_range("1/1/2012", freq="3T", periods=6)
+ expected_columns = pd.MultiIndex.from_tuples(
+ [
+ ("A", "ohlc", "open"),
+ ("A", "ohlc", "high"),
+ ("A", "ohlc", "low"),
+ ("A", "ohlc", "close"),
+ ("A", "quantile", "A"),
+ ("A", "quantile", "A"),
+ ]
+ )
+ non_ohlc_expected_values = np.array(
+ [df.resample("3T").A.quantile(q=q).values for q in [0.9999, 0.1111]]
+ ).T
+ expected_values = np.hstack([df.resample("3T").A.ohlc(), non_ohlc_expected_values])
+ expected = pd.DataFrame(
+ expected_values, columns=expected_columns, index=expected_index
+ )
+ # PerformanceWarning is thrown by `assert col in right` in assert_frame_equal
+ with tm.assert_produces_warning(PerformanceWarning):
+ tm.assert_frame_equal(result, expected)
+
+
def test_multiple_functions_tuples_and_non_tuples(df):
# #1359
funcs = [("foo", "mean"), "std"]
| - [x] closes #30880
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
xref #30092
| https://api.github.com/repos/pandas-dev/pandas/pulls/30858 | 2020-01-09T18:22:21Z | 2020-07-14T20:34:56Z | 2020-07-14T20:34:56Z | 2020-07-15T07:15:33Z |
REF: Move generic methods to aggregation.py | diff --git a/pandas/core/aggregation.py b/pandas/core/aggregation.py
new file mode 100644
index 0000000000000..79b87f146b9a7
--- /dev/null
+++ b/pandas/core/aggregation.py
@@ -0,0 +1,198 @@
+"""
+aggregation.py contains utility functions to handle multiple named and lambda
+kwarg aggregations in groupby and DataFrame/Series aggregation
+"""
+
+from collections import defaultdict
+from functools import partial
+from typing import Any, DefaultDict, List, Sequence, Tuple
+
+from pandas.core.dtypes.common import is_dict_like, is_list_like
+
+import pandas.core.common as com
+from pandas.core.indexes.api import Index
+
+
+def is_multi_agg_with_relabel(**kwargs) -> bool:
+ """
+ Check whether kwargs passed to .agg look like multi-agg with relabeling.
+
+ Parameters
+ ----------
+ **kwargs : dict
+
+ Returns
+ -------
+ bool
+
+ Examples
+ --------
+ >>> is_multi_agg_with_relabel(a='max')
+ False
+ >>> is_multi_agg_with_relabel(a_max=('a', 'max'),
+ ... a_min=('a', 'min'))
+ True
+ >>> is_multi_agg_with_relabel()
+ False
+ """
+ return all(isinstance(v, tuple) and len(v) == 2 for v in kwargs.values()) and (
+ len(kwargs) > 0
+ )
+
+
+def normalize_keyword_aggregation(kwargs: dict) -> Tuple[dict, List[str], List[int]]:
+ """
+ Normalize user-provided "named aggregation" kwargs.
+ Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs
+ to the old Dict[str, List[scalar]]].
+
+ Parameters
+ ----------
+ kwargs : dict
+
+ Returns
+ -------
+ aggspec : dict
+ The transformed kwargs.
+ columns : List[str]
+ The user-provided keys.
+ col_idx_order : List[int]
+ List of columns indices.
+
+ Examples
+ --------
+ >>> normalize_keyword_aggregation({'output': ('input', 'sum')})
+ ({'input': ['sum']}, ('output',), [('input', 'sum')])
+ """
+ # Normalize the aggregation functions as Mapping[column, List[func]],
+ # process normally, then fixup the names.
+ # TODO: aggspec type: typing.Dict[str, List[AggScalar]]
+ # May be hitting https://github.com/python/mypy/issues/5958
+ # saying it doesn't have an attribute __name__
+ aggspec: DefaultDict = defaultdict(list)
+ order = []
+ columns, pairs = list(zip(*kwargs.items()))
+
+ for name, (column, aggfunc) in zip(columns, pairs):
+ aggspec[column].append(aggfunc)
+ order.append((column, com.get_callable_name(aggfunc) or aggfunc))
+
+ # uniquify aggfunc name if duplicated in order list
+ uniquified_order = _make_unique_kwarg_list(order)
+
+ # GH 25719, due to aggspec will change the order of assigned columns in aggregation
+ # uniquified_aggspec will store uniquified order list and will compare it with order
+ # based on index
+ aggspec_order = [
+ (column, com.get_callable_name(aggfunc) or aggfunc)
+ for column, aggfuncs in aggspec.items()
+ for aggfunc in aggfuncs
+ ]
+ uniquified_aggspec = _make_unique_kwarg_list(aggspec_order)
+
+ # get the new indice of columns by comparison
+ col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
+ return aggspec, columns, col_idx_order
+
+
+def _make_unique_kwarg_list(
+ seq: Sequence[Tuple[Any, Any]]
+) -> Sequence[Tuple[Any, Any]]:
+ """Uniquify aggfunc name of the pairs in the order list
+
+ Examples:
+ --------
+ >>> kwarg_list = [('a', '<lambda>'), ('a', '<lambda>'), ('b', '<lambda>')]
+ >>> _make_unique_kwarg_list(kwarg_list)
+ [('a', '<lambda>_0'), ('a', '<lambda>_1'), ('b', '<lambda>')]
+ """
+ return [
+ (pair[0], "_".join([pair[1], str(seq[:i].count(pair))]))
+ if seq.count(pair) > 1
+ else pair
+ for i, pair in enumerate(seq)
+ ]
+
+
+# TODO: Can't use, because mypy doesn't like us setting __name__
+# error: "partial[Any]" has no attribute "__name__"
+# the type is:
+# typing.Sequence[Callable[..., ScalarResult]]
+# -> typing.Sequence[Callable[..., ScalarResult]]:
+
+
+def _managle_lambda_list(aggfuncs: Sequence[Any]) -> Sequence[Any]:
+ """
+ Possibly mangle a list of aggfuncs.
+
+ Parameters
+ ----------
+ aggfuncs : Sequence
+
+ Returns
+ -------
+ mangled: list-like
+ A new AggSpec sequence, where lambdas have been converted
+ to have unique names.
+
+ Notes
+ -----
+ If just one aggfunc is passed, the name will not be mangled.
+ """
+ if len(aggfuncs) <= 1:
+ # don't mangle for .agg([lambda x: .])
+ return aggfuncs
+ i = 0
+ mangled_aggfuncs = []
+ for aggfunc in aggfuncs:
+ if com.get_callable_name(aggfunc) == "<lambda>":
+ aggfunc = partial(aggfunc)
+ aggfunc.__name__ = f"<lambda_{i}>"
+ i += 1
+ mangled_aggfuncs.append(aggfunc)
+
+ return mangled_aggfuncs
+
+
+def maybe_mangle_lambdas(agg_spec: Any) -> Any:
+ """
+ Make new lambdas with unique names.
+
+ Parameters
+ ----------
+ agg_spec : Any
+ An argument to GroupBy.agg.
+ Non-dict-like `agg_spec` are pass through as is.
+ For dict-like `agg_spec` a new spec is returned
+ with name-mangled lambdas.
+
+ Returns
+ -------
+ mangled : Any
+ Same type as the input.
+
+ Examples
+ --------
+ >>> maybe_mangle_lambdas('sum')
+ 'sum'
+ >>> maybe_mangle_lambdas([lambda: 1, lambda: 2]) # doctest: +SKIP
+ [<function __main__.<lambda_0>,
+ <function pandas...._make_lambda.<locals>.f(*args, **kwargs)>]
+ """
+ is_dict = is_dict_like(agg_spec)
+ if not (is_dict or is_list_like(agg_spec)):
+ return agg_spec
+ mangled_aggspec = type(agg_spec)() # dict or OrderdDict
+
+ if is_dict:
+ for key, aggfuncs in agg_spec.items():
+ if is_list_like(aggfuncs) and not is_dict_like(aggfuncs):
+ mangled_aggfuncs = _managle_lambda_list(aggfuncs)
+ else:
+ mangled_aggfuncs = aggfuncs
+
+ mangled_aggspec[key] = mangled_aggfuncs
+ else:
+ mangled_aggspec = _managle_lambda_list(agg_spec)
+
+ return mangled_aggspec
diff --git a/pandas/core/groupby/generic.py b/pandas/core/groupby/generic.py
index c49677fa27a31..98cdcd0f2b6ee 100644
--- a/pandas/core/groupby/generic.py
+++ b/pandas/core/groupby/generic.py
@@ -5,7 +5,7 @@
These are user facing as the result of the ``df.groupby(...)`` operations,
which here returns a DataFrameGroupBy object.
"""
-from collections import abc, defaultdict, namedtuple
+from collections import abc, namedtuple
import copy
from functools import partial
from textwrap import dedent
@@ -42,10 +42,8 @@
ensure_int64,
ensure_platform_int,
is_bool,
- is_dict_like,
is_integer_dtype,
is_interval_dtype,
- is_list_like,
is_numeric_dtype,
is_object_dtype,
is_scalar,
@@ -53,6 +51,11 @@
)
from pandas.core.dtypes.missing import _isna_ndarraylike, isna, notna
+from pandas.core.aggregation import (
+ is_multi_agg_with_relabel,
+ maybe_mangle_lambdas,
+ normalize_keyword_aggregation,
+)
import pandas.core.algorithms as algorithms
from pandas.core.base import DataError, SpecificationError
import pandas.core.common as com
@@ -249,7 +252,7 @@ def aggregate(self, func=None, *args, **kwargs):
elif isinstance(func, abc.Iterable):
# Catch instances of lists / tuples
# but not the class list / tuple itself.
- func = _maybe_mangle_lambdas(func)
+ func = maybe_mangle_lambdas(func)
ret = self._aggregate_multiple_funcs(func)
if relabeling:
ret.columns = columns
@@ -918,9 +921,9 @@ class DataFrameGroupBy(GroupBy):
@Appender(_shared_docs["aggregate"])
def aggregate(self, func=None, *args, **kwargs):
- relabeling = func is None and _is_multi_agg_with_relabel(**kwargs)
+ relabeling = func is None and is_multi_agg_with_relabel(**kwargs)
if relabeling:
- func, columns, order = _normalize_keyword_aggregation(kwargs)
+ func, columns, order = normalize_keyword_aggregation(kwargs)
kwargs = {}
elif isinstance(func, list) and len(func) > len(set(func)):
@@ -935,7 +938,7 @@ def aggregate(self, func=None, *args, **kwargs):
# nicer error message
raise TypeError("Must provide 'func' or tuples of '(column, aggfunc).")
- func = _maybe_mangle_lambdas(func)
+ func = maybe_mangle_lambdas(func)
result, how = self._aggregate(func, *args, **kwargs)
if how is None:
@@ -1860,190 +1863,6 @@ def groupby_series(obj, col=None):
boxplot = boxplot_frame_groupby
-def _is_multi_agg_with_relabel(**kwargs) -> bool:
- """
- Check whether kwargs passed to .agg look like multi-agg with relabeling.
-
- Parameters
- ----------
- **kwargs : dict
-
- Returns
- -------
- bool
-
- Examples
- --------
- >>> _is_multi_agg_with_relabel(a='max')
- False
- >>> _is_multi_agg_with_relabel(a_max=('a', 'max'),
- ... a_min=('a', 'min'))
- True
- >>> _is_multi_agg_with_relabel()
- False
- """
- return all(isinstance(v, tuple) and len(v) == 2 for v in kwargs.values()) and (
- len(kwargs) > 0
- )
-
-
-def _normalize_keyword_aggregation(kwargs):
- """
- Normalize user-provided "named aggregation" kwargs.
-
- Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs
- to the old Dict[str, List[scalar]]].
-
- Parameters
- ----------
- kwargs : dict
-
- Returns
- -------
- aggspec : dict
- The transformed kwargs.
- columns : List[str]
- The user-provided keys.
- col_idx_order : List[int]
- List of columns indices.
-
- Examples
- --------
- >>> _normalize_keyword_aggregation({'output': ('input', 'sum')})
- ({'input': ['sum']}, ('output',), [('input', 'sum')])
- """
- # Normalize the aggregation functions as Mapping[column, List[func]],
- # process normally, then fixup the names.
- # TODO: aggspec type: typing.Dict[str, List[AggScalar]]
- # May be hitting https://github.com/python/mypy/issues/5958
- # saying it doesn't have an attribute __name__
- aggspec = defaultdict(list)
- order = []
- columns, pairs = list(zip(*kwargs.items()))
-
- for name, (column, aggfunc) in zip(columns, pairs):
- aggspec[column].append(aggfunc)
- order.append((column, com.get_callable_name(aggfunc) or aggfunc))
-
- # uniquify aggfunc name if duplicated in order list
- uniquified_order = _make_unique(order)
-
- # GH 25719, due to aggspec will change the order of assigned columns in aggregation
- # uniquified_aggspec will store uniquified order list and will compare it with order
- # based on index
- aggspec_order = [
- (column, com.get_callable_name(aggfunc) or aggfunc)
- for column, aggfuncs in aggspec.items()
- for aggfunc in aggfuncs
- ]
- uniquified_aggspec = _make_unique(aggspec_order)
-
- # get the new indice of columns by comparison
- col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
- return aggspec, columns, col_idx_order
-
-
-def _make_unique(seq):
- """Uniquify aggfunc name of the pairs in the order list
-
- Examples:
- --------
- >>> _make_unique([('a', '<lambda>'), ('a', '<lambda>'), ('b', '<lambda>')])
- [('a', '<lambda>_0'), ('a', '<lambda>_1'), ('b', '<lambda>')]
- """
- return [
- (pair[0], "_".join([pair[1], str(seq[:i].count(pair))]))
- if seq.count(pair) > 1
- else pair
- for i, pair in enumerate(seq)
- ]
-
-
-# TODO: Can't use, because mypy doesn't like us setting __name__
-# error: "partial[Any]" has no attribute "__name__"
-# the type is:
-# typing.Sequence[Callable[..., ScalarResult]]
-# -> typing.Sequence[Callable[..., ScalarResult]]:
-
-
-def _managle_lambda_list(aggfuncs: Sequence[Any]) -> Sequence[Any]:
- """
- Possibly mangle a list of aggfuncs.
-
- Parameters
- ----------
- aggfuncs : Sequence
-
- Returns
- -------
- mangled: list-like
- A new AggSpec sequence, where lambdas have been converted
- to have unique names.
-
- Notes
- -----
- If just one aggfunc is passed, the name will not be mangled.
- """
- if len(aggfuncs) <= 1:
- # don't mangle for .agg([lambda x: .])
- return aggfuncs
- i = 0
- mangled_aggfuncs = []
- for aggfunc in aggfuncs:
- if com.get_callable_name(aggfunc) == "<lambda>":
- aggfunc = partial(aggfunc)
- aggfunc.__name__ = f"<lambda_{i}>"
- i += 1
- mangled_aggfuncs.append(aggfunc)
-
- return mangled_aggfuncs
-
-
-def _maybe_mangle_lambdas(agg_spec: Any) -> Any:
- """
- Make new lambdas with unique names.
-
- Parameters
- ----------
- agg_spec : Any
- An argument to GroupBy.agg.
- Non-dict-like `agg_spec` are pass through as is.
- For dict-like `agg_spec` a new spec is returned
- with name-mangled lambdas.
-
- Returns
- -------
- mangled : Any
- Same type as the input.
-
- Examples
- --------
- >>> _maybe_mangle_lambdas('sum')
- 'sum'
-
- >>> _maybe_mangle_lambdas([lambda: 1, lambda: 2]) # doctest: +SKIP
- [<function __main__.<lambda_0>,
- <function pandas...._make_lambda.<locals>.f(*args, **kwargs)>]
- """
- is_dict = is_dict_like(agg_spec)
- if not (is_dict or is_list_like(agg_spec)):
- return agg_spec
- mangled_aggspec = type(agg_spec)() # dict or OrderdDict
-
- if is_dict:
- for key, aggfuncs in agg_spec.items():
- if is_list_like(aggfuncs) and not is_dict_like(aggfuncs):
- mangled_aggfuncs = _managle_lambda_list(aggfuncs)
- else:
- mangled_aggfuncs = aggfuncs
-
- mangled_aggspec[key] = mangled_aggfuncs
- else:
- mangled_aggspec = _managle_lambda_list(agg_spec)
-
- return mangled_aggspec
-
-
def _recast_datetimelike_result(result: DataFrame) -> DataFrame:
"""
If we have date/time like in the original, then coerce dates
diff --git a/pandas/tests/groupby/aggregate/test_aggregate.py b/pandas/tests/groupby/aggregate/test_aggregate.py
index 0b72a61ed84de..3d842aca210ed 100644
--- a/pandas/tests/groupby/aggregate/test_aggregate.py
+++ b/pandas/tests/groupby/aggregate/test_aggregate.py
@@ -10,7 +10,6 @@
from pandas import DataFrame, Index, MultiIndex, Series, concat
import pandas._testing as tm
from pandas.core.base import SpecificationError
-from pandas.core.groupby.generic import _make_unique, _maybe_mangle_lambdas
from pandas.core.groupby.grouper import Grouping
@@ -632,41 +631,6 @@ def test_lambda_named_agg(func):
class TestLambdaMangling:
- def test_maybe_mangle_lambdas_passthrough(self):
- assert _maybe_mangle_lambdas("mean") == "mean"
- assert _maybe_mangle_lambdas(lambda x: x).__name__ == "<lambda>"
- # don't mangel single lambda.
- assert _maybe_mangle_lambdas([lambda x: x])[0].__name__ == "<lambda>"
-
- def test_maybe_mangle_lambdas_listlike(self):
- aggfuncs = [lambda x: 1, lambda x: 2]
- result = _maybe_mangle_lambdas(aggfuncs)
- assert result[0].__name__ == "<lambda_0>"
- assert result[1].__name__ == "<lambda_1>"
- assert aggfuncs[0](None) == result[0](None)
- assert aggfuncs[1](None) == result[1](None)
-
- def test_maybe_mangle_lambdas(self):
- func = {"A": [lambda x: 0, lambda x: 1]}
- result = _maybe_mangle_lambdas(func)
- assert result["A"][0].__name__ == "<lambda_0>"
- assert result["A"][1].__name__ == "<lambda_1>"
-
- def test_maybe_mangle_lambdas_args(self):
- func = {"A": [lambda x, a, b=1: (0, a, b), lambda x: 1]}
- result = _maybe_mangle_lambdas(func)
- assert result["A"][0].__name__ == "<lambda_0>"
- assert result["A"][1].__name__ == "<lambda_1>"
-
- assert func["A"][0](0, 1) == (0, 1, 1)
- assert func["A"][0](0, 1, 2) == (0, 1, 2)
- assert func["A"][0](0, 2, b=3) == (0, 2, 3)
-
- def test_maybe_mangle_lambdas_named(self):
- func = {"C": np.mean, "D": {"foo": np.mean, "bar": np.mean}}
- result = _maybe_mangle_lambdas(func)
- assert result == func
-
def test_basic(self):
df = pd.DataFrame({"A": [0, 0, 1, 1], "B": [1, 2, 3, 4]})
result = df.groupby("A").agg({"B": [lambda x: 0, lambda x: 1]})
@@ -784,48 +748,3 @@ def test_agg_multiple_lambda(self):
weight_min=pd.NamedAgg(column="weight", aggfunc=lambda x: np.min(x)),
)
tm.assert_frame_equal(result2, expected)
-
- @pytest.mark.parametrize(
- "order, expected_reorder",
- [
- (
- [
- ("height", "<lambda>"),
- ("height", "max"),
- ("weight", "max"),
- ("height", "<lambda>"),
- ("weight", "<lambda>"),
- ],
- [
- ("height", "<lambda>_0"),
- ("height", "max"),
- ("weight", "max"),
- ("height", "<lambda>_1"),
- ("weight", "<lambda>"),
- ],
- ),
- (
- [
- ("col2", "min"),
- ("col1", "<lambda>"),
- ("col1", "<lambda>"),
- ("col1", "<lambda>"),
- ],
- [
- ("col2", "min"),
- ("col1", "<lambda>_0"),
- ("col1", "<lambda>_1"),
- ("col1", "<lambda>_2"),
- ],
- ),
- (
- [("col", "<lambda>"), ("col", "<lambda>"), ("col", "<lambda>")],
- [("col", "<lambda>_0"), ("col", "<lambda>_1"), ("col", "<lambda>_2")],
- ),
- ],
- )
- def test_make_unique(self, order, expected_reorder):
- # GH 27519, test if make_unique function reorders correctly
- result = _make_unique(order)
-
- assert result == expected_reorder
diff --git a/pandas/tests/test_aggregation.py b/pandas/tests/test_aggregation.py
new file mode 100644
index 0000000000000..74ccebc8e2275
--- /dev/null
+++ b/pandas/tests/test_aggregation.py
@@ -0,0 +1,90 @@
+import numpy as np
+import pytest
+
+from pandas.core.aggregation import _make_unique_kwarg_list, maybe_mangle_lambdas
+
+
+def test_maybe_mangle_lambdas_passthrough():
+ assert maybe_mangle_lambdas("mean") == "mean"
+ assert maybe_mangle_lambdas(lambda x: x).__name__ == "<lambda>"
+ # don't mangel single lambda.
+ assert maybe_mangle_lambdas([lambda x: x])[0].__name__ == "<lambda>"
+
+
+def test_maybe_mangle_lambdas_listlike():
+ aggfuncs = [lambda x: 1, lambda x: 2]
+ result = maybe_mangle_lambdas(aggfuncs)
+ assert result[0].__name__ == "<lambda_0>"
+ assert result[1].__name__ == "<lambda_1>"
+ assert aggfuncs[0](None) == result[0](None)
+ assert aggfuncs[1](None) == result[1](None)
+
+
+def test_maybe_mangle_lambdas():
+ func = {"A": [lambda x: 0, lambda x: 1]}
+ result = maybe_mangle_lambdas(func)
+ assert result["A"][0].__name__ == "<lambda_0>"
+ assert result["A"][1].__name__ == "<lambda_1>"
+
+
+def test_maybe_mangle_lambdas_args():
+ func = {"A": [lambda x, a, b=1: (0, a, b), lambda x: 1]}
+ result = maybe_mangle_lambdas(func)
+ assert result["A"][0].__name__ == "<lambda_0>"
+ assert result["A"][1].__name__ == "<lambda_1>"
+
+ assert func["A"][0](0, 1) == (0, 1, 1)
+ assert func["A"][0](0, 1, 2) == (0, 1, 2)
+ assert func["A"][0](0, 2, b=3) == (0, 2, 3)
+
+
+def test_maybe_mangle_lambdas_named():
+ func = {"C": np.mean, "D": {"foo": np.mean, "bar": np.mean}}
+ result = maybe_mangle_lambdas(func)
+ assert result == func
+
+
+@pytest.mark.parametrize(
+ "order, expected_reorder",
+ [
+ (
+ [
+ ("height", "<lambda>"),
+ ("height", "max"),
+ ("weight", "max"),
+ ("height", "<lambda>"),
+ ("weight", "<lambda>"),
+ ],
+ [
+ ("height", "<lambda>_0"),
+ ("height", "max"),
+ ("weight", "max"),
+ ("height", "<lambda>_1"),
+ ("weight", "<lambda>"),
+ ],
+ ),
+ (
+ [
+ ("col2", "min"),
+ ("col1", "<lambda>"),
+ ("col1", "<lambda>"),
+ ("col1", "<lambda>"),
+ ],
+ [
+ ("col2", "min"),
+ ("col1", "<lambda>_0"),
+ ("col1", "<lambda>_1"),
+ ("col1", "<lambda>_2"),
+ ],
+ ),
+ (
+ [("col", "<lambda>"), ("col", "<lambda>"), ("col", "<lambda>")],
+ [("col", "<lambda>_0"), ("col", "<lambda>_1"), ("col", "<lambda>_2")],
+ ),
+ ],
+)
+def test_make_unique(order, expected_reorder):
+ # GH 27519, test if make_unique function reorders correctly
+ result = _make_unique_kwarg_list(order)
+
+ assert result == expected_reorder
| xref #29116
https://github.com/pandas-dev/pandas/pull/29116#pullrequestreview-340272465
based on @jreback comment, this PR is a precursor PR for #29116 to make PR smaller and more readable | https://api.github.com/repos/pandas-dev/pandas/pulls/30856 | 2020-01-09T18:04:47Z | 2020-01-20T23:31:20Z | 2020-01-20T23:31:20Z | 2020-01-20T23:31:25Z |
DOC: fixed about link | diff --git a/web/pandas/index.html b/web/pandas/index.html
index df6e5ab9a330b..5aac5da16295b 100644
--- a/web/pandas/index.html
+++ b/web/pandas/index.html
@@ -35,7 +35,7 @@ <h5>Documentation</h5>
<div class="col-md-4">
<h5>Community</h5>
<ul>
- <li><a href="{{ base_url }}/community/about.html">About pandas</a></li>
+ <li><a href="{{ base_url }}/about/index.html">About pandas</a></li>
<li><a href="https://stackoverflow.com/questions/tagged/pandas">Ask a question</a></li>
<li><a href="{{ base_url }}/community/ecosystem.html">Ecosystem</a></li>
</ul>
| https://api.github.com/repos/pandas-dev/pandas/pulls/30855 | 2020-01-09T18:00:36Z | 2020-01-09T18:37:50Z | 2020-01-09T18:37:50Z | 2020-01-09T18:38:09Z | |
CLN: remove pydt_to_i8 | diff --git a/pandas/_libs/tslibs/conversion.pxd b/pandas/_libs/tslibs/conversion.pxd
index d4ae3fa8c5b99..c74307a3d2887 100644
--- a/pandas/_libs/tslibs/conversion.pxd
+++ b/pandas/_libs/tslibs/conversion.pxd
@@ -23,6 +23,4 @@ cdef _TSObject convert_datetime_to_tsobject(datetime ts, object tz,
cdef int64_t get_datetime64_nanos(object val) except? -1
-cpdef int64_t pydt_to_i8(object pydt) except? -1
-
cpdef datetime localize_pydatetime(datetime dt, object tz)
diff --git a/pandas/_libs/tslibs/conversion.pyx b/pandas/_libs/tslibs/conversion.pyx
index 77f46016ee846..e0862b9250045 100644
--- a/pandas/_libs/tslibs/conversion.pyx
+++ b/pandas/_libs/tslibs/conversion.pyx
@@ -223,27 +223,6 @@ cdef class _TSObject:
return self.value
-cpdef int64_t pydt_to_i8(object pydt) except? -1:
- """
- Convert to int64 representation compatible with numpy datetime64; converts
- to UTC
-
- Parameters
- ----------
- pydt : object
-
- Returns
- -------
- i8value : np.int64
- """
- cdef:
- _TSObject ts
-
- ts = convert_to_tsobject(pydt, None, None, 0, 0)
-
- return ts.value
-
-
cdef convert_to_tsobject(object ts, object tz, object unit,
bint dayfirst, bint yearfirst, int32_t nanos=0):
"""
diff --git a/pandas/_libs/tslibs/offsets.pyx b/pandas/_libs/tslibs/offsets.pyx
index 31dc2945f0395..48a3886c20a3a 100644
--- a/pandas/_libs/tslibs/offsets.pyx
+++ b/pandas/_libs/tslibs/offsets.pyx
@@ -22,7 +22,10 @@ from pandas._libs.tslibs.util cimport is_integer_object
from pandas._libs.tslibs.ccalendar import MONTHS, DAYS
from pandas._libs.tslibs.ccalendar cimport get_days_in_month, dayofweek
-from pandas._libs.tslibs.conversion cimport pydt_to_i8, localize_pydatetime
+from pandas._libs.tslibs.conversion cimport (
+ convert_datetime_to_tsobject,
+ localize_pydatetime,
+)
from pandas._libs.tslibs.nattype cimport NPY_NAT
from pandas._libs.tslibs.np_datetime cimport (
npy_datetimestruct, dtstruct_to_dt64, dt64_to_dtstruct)
@@ -233,7 +236,10 @@ def _to_dt64D(dt):
# numpy.datetime64('2013-05-01T02:00:00.000000+0200')
# Thus astype is needed to cast datetime to datetime64[D]
if getattr(dt, 'tzinfo', None) is not None:
- i8 = pydt_to_i8(dt)
+ # Get the nanosecond timestamp,
+ # equiv `Timestamp(dt).value` or `dt.timestamp() * 10**9`
+ nanos = getattr(dt, "nanosecond", 0)
+ i8 = convert_datetime_to_tsobject(dt, tz=None, nanos=nanos).value
dt = tz_convert_single(i8, UTC, dt.tzinfo)
dt = np.int64(dt).astype('datetime64[ns]')
else:
diff --git a/pandas/tests/scalar/timestamp/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py
index c60406fdbc8a6..410e449656dbc 100644
--- a/pandas/tests/scalar/timestamp/test_timestamp.py
+++ b/pandas/tests/scalar/timestamp/test_timestamp.py
@@ -12,7 +12,6 @@
import pytz
from pytz import timezone, utc
-from pandas._libs.tslibs import conversion
from pandas._libs.tslibs.timezones import dateutil_gettz as gettz, get_timezone
import pandas.compat as compat
from pandas.compat.numpy import np_datetime64_compat
@@ -241,24 +240,20 @@ def test_constructor(self):
for result in [Timestamp(date_str), Timestamp(date)]:
# only with timestring
assert result.value == expected
- assert conversion.pydt_to_i8(result) == expected
# re-creation shouldn't affect to internal value
result = Timestamp(result)
assert result.value == expected
- assert conversion.pydt_to_i8(result) == expected
# with timezone
for tz, offset in timezones:
for result in [Timestamp(date_str, tz=tz), Timestamp(date, tz=tz)]:
expected_tz = expected - offset * 3600 * 1_000_000_000
assert result.value == expected_tz
- assert conversion.pydt_to_i8(result) == expected_tz
# should preserve tz
result = Timestamp(result)
assert result.value == expected_tz
- assert conversion.pydt_to_i8(result) == expected_tz
# should convert to UTC
if tz is not None:
@@ -267,7 +262,6 @@ def test_constructor(self):
result = Timestamp(result, tz="UTC")
expected_utc = expected - offset * 3600 * 1_000_000_000
assert result.value == expected_utc
- assert conversion.pydt_to_i8(result) == expected_utc
def test_constructor_with_stringoffset(self):
# GH 7833
@@ -300,30 +294,25 @@ def test_constructor_with_stringoffset(self):
for result in [Timestamp(date_str)]:
# only with timestring
assert result.value == expected
- assert conversion.pydt_to_i8(result) == expected
# re-creation shouldn't affect to internal value
result = Timestamp(result)
assert result.value == expected
- assert conversion.pydt_to_i8(result) == expected
# with timezone
for tz, offset in timezones:
result = Timestamp(date_str, tz=tz)
expected_tz = expected
assert result.value == expected_tz
- assert conversion.pydt_to_i8(result) == expected_tz
# should preserve tz
result = Timestamp(result)
assert result.value == expected_tz
- assert conversion.pydt_to_i8(result) == expected_tz
# should convert to UTC
result = Timestamp(result).tz_convert("UTC")
expected_utc = expected
assert result.value == expected_utc
- assert conversion.pydt_to_i8(result) == expected_utc
# This should be 2013-11-01 05:00 in UTC
# converted to Chicago tz
| It's only used in one non-test place, and all supported python versions now support datetime.timestamp, so we can use that directly. Its a little bit less performant, but not used often. | https://api.github.com/repos/pandas-dev/pandas/pulls/30854 | 2020-01-09T17:05:39Z | 2020-01-24T03:56:07Z | 2020-01-24T03:56:07Z | 2020-01-24T04:32:18Z |
ENH: Added DataFrame.compare and Series.compare (GH30429) | diff --git a/doc/source/reference/frame.rst b/doc/source/reference/frame.rst
index cf81540a77d11..12b9f67ddb846 100644
--- a/doc/source/reference/frame.rst
+++ b/doc/source/reference/frame.rst
@@ -240,13 +240,14 @@ Reshaping, sorting, transposing
DataFrame.T
DataFrame.transpose
-Combining / joining / merging
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Combining / comparing / joining / merging
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. autosummary::
:toctree: api/
DataFrame.append
DataFrame.assign
+ DataFrame.compare
DataFrame.join
DataFrame.merge
DataFrame.update
diff --git a/doc/source/reference/series.rst b/doc/source/reference/series.rst
index ab0540a930396..797ade9594c7d 100644
--- a/doc/source/reference/series.rst
+++ b/doc/source/reference/series.rst
@@ -240,12 +240,13 @@ Reshaping, sorting
Series.squeeze
Series.view
-Combining / joining / merging
------------------------------
+Combining / comparing / joining / merging
+-----------------------------------------
.. autosummary::
:toctree: api/
Series.append
+ Series.compare
Series.replace
Series.update
diff --git a/doc/source/user_guide/merging.rst b/doc/source/user_guide/merging.rst
index 0450c81958a51..56ff8c1fc7c9b 100644
--- a/doc/source/user_guide/merging.rst
+++ b/doc/source/user_guide/merging.rst
@@ -10,15 +10,18 @@
p = doctools.TablePlotter()
-****************************
-Merge, join, and concatenate
-****************************
+************************************
+Merge, join, concatenate and compare
+************************************
pandas provides various facilities for easily combining together Series or
DataFrame with various kinds of set logic for the indexes
and relational algebra functionality in the case of join / merge-type
operations.
+In addition, pandas also provides utilities to compare two Series or DataFrame
+and summarize their differences.
+
.. _merging.concat:
Concatenating objects
@@ -1477,3 +1480,61 @@ exclude exact matches on time. Note that though we exclude the exact matches
by='ticker',
tolerance=pd.Timedelta('10ms'),
allow_exact_matches=False)
+
+.. _merging.compare:
+
+Comparing objects
+-----------------
+
+The :meth:`~Series.compare` and :meth:`~DataFrame.compare` methods allow you to
+compare two DataFrame or Series, respectively, and summarize their differences.
+
+This feature was added in :ref:`V1.1.0 <whatsnew_110.dataframe_or_series_comparing>`.
+
+For example, you might want to compare two `DataFrame` and stack their differences
+side by side.
+
+.. ipython:: python
+
+ df = pd.DataFrame(
+ {
+ "col1": ["a", "a", "b", "b", "a"],
+ "col2": [1.0, 2.0, 3.0, np.nan, 5.0],
+ "col3": [1.0, 2.0, 3.0, 4.0, 5.0]
+ },
+ columns=["col1", "col2", "col3"],
+ )
+ df
+
+.. ipython:: python
+
+ df2 = df.copy()
+ df2.loc[0, 'col1'] = 'c'
+ df2.loc[2, 'col3'] = 4.0
+ df2
+
+.. ipython:: python
+
+ df.compare(df2)
+
+By default, if two corresponding values are equal, they will be shown as ``NaN``.
+Furthermore, if all values in an entire row / column, the row / column will be
+omitted from the result. The remaining differences will be aligned on columns.
+
+If you wish, you may choose to stack the differences on rows.
+
+.. ipython:: python
+
+ df.compare(df2, align_axis=0)
+
+If you wish to keep all original rows and columns, set `keep_shape` argument
+to ``True``.
+
+.. ipython:: python
+
+ df.compare(df2, keep_shape=True)
+
+You may also keep all the original values even if they are equal.
+
+.. ipython:: python
+ df.compare(df2, keep_shape=True, keep_equal=True)
diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index a1b7e09fe3ae1..a366afb98cfee 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -55,6 +55,39 @@ For example:
ser.loc["May 2015"]
+.. _whatsnew_110.dataframe_or_series_comparing:
+
+Comparing two `DataFrame` or two `Series` and summarizing the differences
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We've added :meth:`DataFrame.compare` and :meth:`Series.compare` for comparing two `DataFrame` or two `Series` (:issue:`30429`)
+
+.. ipython:: python
+
+ df = pd.DataFrame(
+ {
+ "col1": ["a", "a", "b", "b", "a"],
+ "col2": [1.0, 2.0, 3.0, np.nan, 5.0],
+ "col3": [1.0, 2.0, 3.0, 4.0, 5.0]
+ },
+ columns=["col1", "col2", "col3"],
+ )
+ df
+
+.. ipython:: python
+
+ df2 = df.copy()
+ df2.loc[0, 'col1'] = 'c'
+ df2.loc[2, 'col3'] = 4.0
+ df2
+
+.. ipython:: python
+
+ df.compare(df2)
+
+See :ref:`User Guide <merging.compare>` for more details.
+
+
.. _whatsnew_110.groupby_key:
Allow NA in groupby key
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index 6532d084aa6fa..4911617b8eed4 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -5755,6 +5755,116 @@ def _construct_result(self, result) -> "DataFrame":
out.index = self.index
return out
+ @Appender(
+ """
+Returns
+-------
+DataFrame
+ DataFrame that shows the differences stacked side by side.
+
+ The resulting index will be a MultiIndex with 'self' and 'other'
+ stacked alternately at the inner level.
+
+See Also
+--------
+Series.compare : Compare with another Series and show differences.
+
+Notes
+-----
+Matching NaNs will not appear as a difference.
+
+Examples
+--------
+>>> df = pd.DataFrame(
+... {
+... "col1": ["a", "a", "b", "b", "a"],
+... "col2": [1.0, 2.0, 3.0, np.nan, 5.0],
+... "col3": [1.0, 2.0, 3.0, 4.0, 5.0]
+... },
+... columns=["col1", "col2", "col3"],
+... )
+>>> df
+ col1 col2 col3
+0 a 1.0 1.0
+1 a 2.0 2.0
+2 b 3.0 3.0
+3 b NaN 4.0
+4 a 5.0 5.0
+
+>>> df2 = df.copy()
+>>> df2.loc[0, 'col1'] = 'c'
+>>> df2.loc[2, 'col3'] = 4.0
+>>> df2
+ col1 col2 col3
+0 c 1.0 1.0
+1 a 2.0 2.0
+2 b 3.0 4.0
+3 b NaN 4.0
+4 a 5.0 5.0
+
+Align the differences on columns
+
+>>> df.compare(df2)
+ col1 col3
+ self other self other
+0 a c NaN NaN
+2 NaN NaN 3.0 4.0
+
+Stack the differences on rows
+
+>>> df.compare(df2, align_axis=0)
+ col1 col3
+0 self a NaN
+ other c NaN
+2 self NaN 3.0
+ other NaN 4.0
+
+Keep the equal values
+
+>>> df.compare(df2, keep_equal=True)
+ col1 col3
+ self other self other
+0 a c 1.0 1.0
+2 b b 3.0 4.0
+
+Keep all original rows and columns
+
+>>> df.compare(df2, keep_shape=True)
+ col1 col2 col3
+ self other self other self other
+0 a c NaN NaN NaN NaN
+1 NaN NaN NaN NaN NaN NaN
+2 NaN NaN NaN NaN 3.0 4.0
+3 NaN NaN NaN NaN NaN NaN
+4 NaN NaN NaN NaN NaN NaN
+
+Keep all original rows and columns and also all original values
+
+>>> df.compare(df2, keep_shape=True, keep_equal=True)
+ col1 col2 col3
+ self other self other self other
+0 a c 1.0 1.0 1.0 1.0
+1 a a 2.0 2.0 2.0 2.0
+2 b b 3.0 3.0 3.0 4.0
+3 b b NaN NaN 4.0 4.0
+4 a a 5.0 5.0 5.0 5.0
+"""
+ )
+ @Appender(_shared_docs["compare"] % _shared_doc_kwargs)
+ def compare(
+ self,
+ other: "DataFrame",
+ align_axis: Axis = 1,
+ keep_shape: bool = False,
+ keep_equal: bool = False,
+ ) -> "DataFrame":
+ return super().compare(
+ other=other,
+ align_axis=align_axis,
+ keep_shape=keep_shape,
+ keep_equal=keep_equal,
+ )
+
def combine(
self, other: "DataFrame", func, fill_value=None, overwrite=True
) -> "DataFrame":
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 79805bec85af0..0260f30b9e7e2 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -8403,6 +8403,104 @@ def ranker(data):
return ranker(data)
+ _shared_docs[
+ "compare"
+ ] = """
+ Compare to another %(klass)s and show the differences.
+
+ .. versionadded:: 1.1.0
+
+ Parameters
+ ----------
+ other : %(klass)s
+ Object to compare with.
+
+ align_axis : {0 or 'index', 1 or 'columns'}, default 1
+ Determine which axis to align the comparison on.
+
+ * 0, or 'index' : Resulting differences are stacked vertically
+ with rows drawn alternately from self and other.
+ * 1, or 'columns' : Resulting differences are aligned horizontally
+ with columns drawn alternately from self and other.
+
+ keep_shape : bool, default False
+ If true, all rows and columns are kept.
+ Otherwise, only the ones with different values are kept.
+
+ keep_equal : bool, default False
+ If true, the result keeps values that are equal.
+ Otherwise, equal values are shown as NaNs.
+ """
+
+ @Appender(_shared_docs["compare"] % _shared_doc_kwargs)
+ def compare(
+ self,
+ other,
+ align_axis: Axis = 1,
+ keep_shape: bool_t = False,
+ keep_equal: bool_t = False,
+ ):
+ from pandas.core.reshape.concat import concat
+
+ if type(self) is not type(other):
+ cls_self, cls_other = type(self).__name__, type(other).__name__
+ raise TypeError(
+ f"can only compare '{cls_self}' (not '{cls_other}') with '{cls_self}'"
+ )
+
+ mask = ~((self == other) | (self.isna() & other.isna()))
+ keys = ["self", "other"]
+
+ if not keep_equal:
+ self = self.where(mask)
+ other = other.where(mask)
+
+ if not keep_shape:
+ if isinstance(self, ABCDataFrame):
+ cmask = mask.any()
+ rmask = mask.any(axis=1)
+ self = self.loc[rmask, cmask]
+ other = other.loc[rmask, cmask]
+ else:
+ self = self[mask]
+ other = other[mask]
+
+ if align_axis in (1, "columns"): # This is needed for Series
+ axis = 1
+ else:
+ axis = self._get_axis_number(align_axis)
+
+ diff = concat([self, other], axis=axis, keys=keys)
+
+ if axis >= self.ndim:
+ # No need to reorganize data if stacking on new axis
+ # This currently applies for stacking two Series on columns
+ return diff
+
+ ax = diff._get_axis(axis)
+ ax_names = np.array(ax.names)
+
+ # set index names to positions to avoid confusion
+ ax.names = np.arange(len(ax_names))
+
+ # bring self-other to inner level
+ order = list(range(1, ax.nlevels)) + [0]
+ if isinstance(diff, ABCDataFrame):
+ diff = diff.reorder_levels(order, axis=axis)
+ else:
+ diff = diff.reorder_levels(order)
+
+ # restore the index names in order
+ diff._get_axis(axis=axis).names = ax_names[order]
+
+ # reorder axis to keep things organized
+ indices = (
+ np.arange(diff.shape[axis]).reshape([2, diff.shape[axis] // 2]).T.flatten()
+ )
+ diff = diff.take(indices, axis=axis)
+
+ return diff
+
@doc(**_shared_doc_kwargs)
def align(
self,
diff --git a/pandas/core/reshape/concat.py b/pandas/core/reshape/concat.py
index 28dfaea8ed425..db7e9265ac21d 100644
--- a/pandas/core/reshape/concat.py
+++ b/pandas/core/reshape/concat.py
@@ -7,7 +7,7 @@
import numpy as np
-from pandas._typing import FrameOrSeriesUnion, Label
+from pandas._typing import FrameOrSeries, FrameOrSeriesUnion, Label
from pandas.core.dtypes.concat import concat_compat
from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
@@ -50,7 +50,7 @@ def concat(
@overload
def concat(
- objs: Union[Iterable[FrameOrSeriesUnion], Mapping[Label, FrameOrSeriesUnion]],
+ objs: Union[Iterable[FrameOrSeries], Mapping[Label, FrameOrSeries]],
axis=0,
join: str = "outer",
ignore_index: bool = False,
@@ -65,7 +65,7 @@ def concat(
def concat(
- objs: Union[Iterable[FrameOrSeriesUnion], Mapping[Label, FrameOrSeriesUnion]],
+ objs: Union[Iterable[FrameOrSeries], Mapping[Label, FrameOrSeries]],
axis=0,
join="outer",
ignore_index: bool = False,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index bc13d5376ec96..ba8bd95cd1749 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -24,7 +24,15 @@
from pandas._libs import lib, properties, reshape, tslibs
from pandas._libs.lib import no_default
-from pandas._typing import ArrayLike, Axis, DtypeObj, IndexKeyFunc, Label, ValueKeyFunc
+from pandas._typing import (
+ ArrayLike,
+ Axis,
+ DtypeObj,
+ FrameOrSeriesUnion,
+ IndexKeyFunc,
+ Label,
+ ValueKeyFunc,
+)
from pandas.compat.numpy import function as nv
from pandas.util._decorators import Appender, Substitution, doc
from pandas.util._validators import validate_bool_kwarg, validate_percentile
@@ -2676,6 +2684,83 @@ def _construct_result(
out.name = name
return out
+ @Appender(
+ """
+Returns
+-------
+Series or DataFrame
+ If axis is 0 or 'index' the result will be a Series.
+ The resulting index will be a MultiIndex with 'self' and 'other'
+ stacked alternately at the inner level.
+
+ If axis is 1 or 'columns' the result will be a DataFrame.
+ It will have two columns namely 'self' and 'other'.
+
+See Also
+--------
+DataFrame.compare : Compare with another DataFrame and show differences.
+
+Notes
+-----
+Matching NaNs will not appear as a difference.
+
+Examples
+--------
+>>> s1 = pd.Series(["a", "b", "c", "d", "e"])
+>>> s2 = pd.Series(["a", "a", "c", "b", "e"])
+
+Align the differences on columns
+
+>>> s1.compare(s2)
+ self other
+1 b a
+3 d b
+
+Stack the differences on indices
+
+>>> s1.compare(s2, align_axis=0)
+1 self b
+ other a
+3 self d
+ other b
+dtype: object
+
+Keep all original rows
+
+>>> s1.compare(s2, keep_shape=True)
+ self other
+0 NaN NaN
+1 b a
+2 NaN NaN
+3 d b
+4 NaN NaN
+
+Keep all original rows and also all original values
+
+>>> s1.compare(s2, keep_shape=True, keep_equal=True)
+ self other
+0 a a
+1 b a
+2 c c
+3 d b
+4 e e
+"""
+ )
+ @Appender(generic._shared_docs["compare"] % _shared_doc_kwargs)
+ def compare(
+ self,
+ other: "Series",
+ align_axis: Axis = 1,
+ keep_shape: bool = False,
+ keep_equal: bool = False,
+ ) -> FrameOrSeriesUnion:
+ return super().compare(
+ other=other,
+ align_axis=align_axis,
+ keep_shape=keep_shape,
+ keep_equal=keep_equal,
+ )
+
def combine(self, other, func, fill_value=None) -> "Series":
"""
Combine the Series with a Series or scalar according to `func`.
diff --git a/pandas/tests/frame/methods/test_compare.py b/pandas/tests/frame/methods/test_compare.py
new file mode 100644
index 0000000000000..468811eba0d39
--- /dev/null
+++ b/pandas/tests/frame/methods/test_compare.py
@@ -0,0 +1,182 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("align_axis", [0, 1, "index", "columns"])
+def test_compare_axis(align_axis):
+ # GH#30429
+ df = pd.DataFrame(
+ {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+ columns=["col1", "col2", "col3"],
+ )
+ df2 = df.copy()
+ df2.loc[0, "col1"] = "c"
+ df2.loc[2, "col3"] = 4.0
+
+ result = df.compare(df2, align_axis=align_axis)
+
+ if align_axis in (1, "columns"):
+ indices = pd.Index([0, 2])
+ columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+ expected = pd.DataFrame(
+ [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, 4.0]],
+ index=indices,
+ columns=columns,
+ )
+ else:
+ indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+ columns = pd.Index(["col1", "col3"])
+ expected = pd.DataFrame(
+ [["a", np.nan], ["c", np.nan], [np.nan, 3.0], [np.nan, 4.0]],
+ index=indices,
+ columns=columns,
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "keep_shape, keep_equal",
+ [
+ (True, False),
+ (False, True),
+ (True, True),
+ # False, False case is already covered in test_compare_axis
+ ],
+)
+def test_compare_various_formats(keep_shape, keep_equal):
+ df = pd.DataFrame(
+ {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+ columns=["col1", "col2", "col3"],
+ )
+ df2 = df.copy()
+ df2.loc[0, "col1"] = "c"
+ df2.loc[2, "col3"] = 4.0
+
+ result = df.compare(df2, keep_shape=keep_shape, keep_equal=keep_equal)
+
+ if keep_shape:
+ indices = pd.Index([0, 1, 2])
+ columns = pd.MultiIndex.from_product(
+ [["col1", "col2", "col3"], ["self", "other"]]
+ )
+ if keep_equal:
+ expected = pd.DataFrame(
+ [
+ ["a", "c", 1.0, 1.0, 1.0, 1.0],
+ ["b", "b", 2.0, 2.0, 2.0, 2.0],
+ ["c", "c", np.nan, np.nan, 3.0, 4.0],
+ ],
+ index=indices,
+ columns=columns,
+ )
+ else:
+ expected = pd.DataFrame(
+ [
+ ["a", "c", np.nan, np.nan, np.nan, np.nan],
+ [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+ [np.nan, np.nan, np.nan, np.nan, 3.0, 4.0],
+ ],
+ index=indices,
+ columns=columns,
+ )
+ else:
+ indices = pd.Index([0, 2])
+ columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+ expected = pd.DataFrame(
+ [["a", "c", 1.0, 1.0], ["c", "c", 3.0, 4.0]], index=indices, columns=columns
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_equal_nulls():
+ # We want to make sure two NaNs are considered the same
+ # and dropped where applicable
+ df = pd.DataFrame(
+ {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+ columns=["col1", "col2", "col3"],
+ )
+ df2 = df.copy()
+ df2.loc[0, "col1"] = "c"
+
+ result = df.compare(df2)
+ indices = pd.Index([0])
+ columns = pd.MultiIndex.from_product([["col1"], ["self", "other"]])
+ expected = pd.DataFrame([["a", "c"]], index=indices, columns=columns)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_non_equal_nulls():
+ # We want to make sure the relevant NaNs do not get dropped
+ # even if the entire row or column are NaNs
+ df = pd.DataFrame(
+ {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]},
+ columns=["col1", "col2", "col3"],
+ )
+ df2 = df.copy()
+ df2.loc[0, "col1"] = "c"
+ df2.loc[2, "col3"] = np.nan
+
+ result = df.compare(df2)
+
+ indices = pd.Index([0, 2])
+ columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
+ expected = pd.DataFrame(
+ [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, np.nan]],
+ index=indices,
+ columns=columns,
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("align_axis", [0, 1])
+def test_compare_multi_index(align_axis):
+ df = pd.DataFrame(
+ {"col1": ["a", "b", "c"], "col2": [1.0, 2.0, np.nan], "col3": [1.0, 2.0, 3.0]}
+ )
+ df.columns = pd.MultiIndex.from_arrays([["a", "a", "b"], ["col1", "col2", "col3"]])
+ df.index = pd.MultiIndex.from_arrays([["x", "x", "y"], [0, 1, 2]])
+
+ df2 = df.copy()
+ df2.iloc[0, 0] = "c"
+ df2.iloc[2, 2] = 4.0
+
+ result = df.compare(df2, align_axis=align_axis)
+
+ if align_axis == 0:
+ indices = pd.MultiIndex.from_arrays(
+ [["x", "x", "y", "y"], [0, 0, 2, 2], ["self", "other", "self", "other"]]
+ )
+ columns = pd.MultiIndex.from_arrays([["a", "b"], ["col1", "col3"]])
+ data = [["a", np.nan], ["c", np.nan], [np.nan, 3.0], [np.nan, 4.0]]
+ else:
+ indices = pd.MultiIndex.from_arrays([["x", "y"], [0, 2]])
+ columns = pd.MultiIndex.from_arrays(
+ [
+ ["a", "a", "b", "b"],
+ ["col1", "col1", "col3", "col3"],
+ ["self", "other", "self", "other"],
+ ]
+ )
+ data = [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, 4.0]]
+
+ expected = pd.DataFrame(data=data, index=indices, columns=columns)
+ tm.assert_frame_equal(result, expected)
+
+
+def test_compare_unaligned_objects():
+ # test DataFrames with different indices
+ msg = "Can only compare identically-labeled DataFrame objects"
+ with pytest.raises(ValueError, match=msg):
+ df1 = pd.DataFrame([1, 2, 3], index=["a", "b", "c"])
+ df2 = pd.DataFrame([1, 2, 3], index=["a", "b", "d"])
+ df1.compare(df2)
+
+ # test DataFrames with different shapes
+ msg = "Can only compare identically-labeled DataFrame objects"
+ with pytest.raises(ValueError, match=msg):
+ df1 = pd.DataFrame(np.ones((3, 3)))
+ df2 = pd.DataFrame(np.zeros((2, 1)))
+ df1.compare(df2)
diff --git a/pandas/tests/series/methods/test_compare.py b/pandas/tests/series/methods/test_compare.py
new file mode 100644
index 0000000000000..8570800048898
--- /dev/null
+++ b/pandas/tests/series/methods/test_compare.py
@@ -0,0 +1,116 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize("align_axis", [0, 1, "index", "columns"])
+def test_compare_axis(align_axis):
+ # GH#30429
+ s1 = pd.Series(["a", "b", "c"])
+ s2 = pd.Series(["x", "b", "z"])
+
+ result = s1.compare(s2, align_axis=align_axis)
+
+ if align_axis in (1, "columns"):
+ indices = pd.Index([0, 2])
+ columns = pd.Index(["self", "other"])
+ expected = pd.DataFrame(
+ [["a", "x"], ["c", "z"]], index=indices, columns=columns
+ )
+ tm.assert_frame_equal(result, expected)
+ else:
+ indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+ expected = pd.Series(["a", "x", "c", "z"], index=indices)
+ tm.assert_series_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+ "keep_shape, keep_equal",
+ [
+ (True, False),
+ (False, True),
+ (True, True),
+ # False, False case is already covered in test_compare_axis
+ ],
+)
+def test_compare_various_formats(keep_shape, keep_equal):
+ s1 = pd.Series(["a", "b", "c"])
+ s2 = pd.Series(["x", "b", "z"])
+
+ result = s1.compare(s2, keep_shape=keep_shape, keep_equal=keep_equal)
+
+ if keep_shape:
+ indices = pd.Index([0, 1, 2])
+ columns = pd.Index(["self", "other"])
+ if keep_equal:
+ expected = pd.DataFrame(
+ [["a", "x"], ["b", "b"], ["c", "z"]], index=indices, columns=columns
+ )
+ else:
+ expected = pd.DataFrame(
+ [["a", "x"], [np.nan, np.nan], ["c", "z"]],
+ index=indices,
+ columns=columns,
+ )
+ else:
+ indices = pd.Index([0, 2])
+ columns = pd.Index(["self", "other"])
+ expected = pd.DataFrame(
+ [["a", "x"], ["c", "z"]], index=indices, columns=columns
+ )
+ tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_equal_nulls():
+ # We want to make sure two NaNs are considered the same
+ # and dropped where applicable
+ s1 = pd.Series(["a", "b", np.nan])
+ s2 = pd.Series(["x", "b", np.nan])
+
+ result = s1.compare(s2)
+ expected = pd.DataFrame([["a", "x"]], columns=["self", "other"])
+ tm.assert_frame_equal(result, expected)
+
+
+def test_compare_with_non_equal_nulls():
+ # We want to make sure the relevant NaNs do not get dropped
+ s1 = pd.Series(["a", "b", "c"])
+ s2 = pd.Series(["x", "b", np.nan])
+
+ result = s1.compare(s2, align_axis=0)
+
+ indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+ expected = pd.Series(["a", "x", "c", np.nan], index=indices)
+ tm.assert_series_equal(result, expected)
+
+
+def test_compare_multi_index():
+ index = pd.MultiIndex.from_arrays([[0, 0, 1], [0, 1, 2]])
+ s1 = pd.Series(["a", "b", "c"], index=index)
+ s2 = pd.Series(["x", "b", "z"], index=index)
+
+ result = s1.compare(s2, align_axis=0)
+
+ indices = pd.MultiIndex.from_arrays(
+ [[0, 0, 1, 1], [0, 0, 2, 2], ["self", "other", "self", "other"]]
+ )
+ expected = pd.Series(["a", "x", "c", "z"], index=indices)
+ tm.assert_series_equal(result, expected)
+
+
+def test_compare_unaligned_objects():
+ # test Series with different indices
+ msg = "Can only compare identically-labeled Series objects"
+ with pytest.raises(ValueError, match=msg):
+ ser1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
+ ser2 = pd.Series([1, 2, 3], index=["a", "b", "d"])
+ ser1.compare(ser2)
+
+ # test Series with different lengths
+ msg = "Can only compare identically-labeled Series objects"
+ with pytest.raises(ValueError, match=msg):
+ ser1 = pd.Series([1, 2, 3])
+ ser2 = pd.Series([1, 2, 3, 4])
+ ser1.compare(ser2)
| Added `DataFrame.differences` and `Series.differences` methods.
Have not yet added whatsnew entries. Will do so after review of API and behavior design.
A few design considerations open for discussion (among other things):
1. Index/column names: (self, other) vs (left, right) vs (old, new)
I used the (self, other) pair as I think they naturally match with the parameter names and the concept of comparing `self` with `other`. Although (left, right) or (old, new) may be slight more intuitive for users in some use cases, these new functions not necessarily compare two objects that are left and right (may be stacked on `axis=0`, or old and new.
1. Parameter name: axis
I feel axis may not be a very clear name, since we are stacking the output along this axis, rather than comparing objects along this axis. I considered using the name `stack_axis` or `orient` like `DataFrame.to_json` does.
1. I made the methods such that two NaNs are considered equal, hence not different. I think this should be the desired behavior since we are trying to compare two objects. However, under current implementation, a `None` will be considered equal to `np.nan` too. This is probably something we need to be careful for.
Let me know what you guys think. I'm ready to be scrutinized and criticized!
- [x] closes #30429
- [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/30852 | 2020-01-09T16:14:08Z | 2020-05-28T17:08:46Z | 2020-05-28T17:08:46Z | 2020-05-28T17:08:53Z |
BLD: Run flake8 check on Cython files in pre-commit | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 139b9e31df46c..896765722bf32 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -10,6 +10,20 @@ repos:
- id: flake8
language: python_venv
additional_dependencies: [flake8-comprehensions>=3.1.0]
+ - id: flake8
+ name: flake8-pyx
+ language: python_venv
+ files: \.(pyx|pxd)$
+ types:
+ - file
+ args: [--append-config=flake8/cython.cfg]
+ - id: flake8
+ name: flake8-pxd
+ language: python_venv
+ files: \.pxi\.in$
+ types:
+ - file
+ args: [--append-config=flake8/cython-template.cfg]
- repo: https://github.com/pre-commit/mirrors-isort
rev: v4.3.21
hooks:
diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index fdc9fef5d7f77..7eb80077c4fab 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -65,12 +65,12 @@ if [[ -z "$CHECK" || "$CHECK" == "lint" ]]; then
flake8 --format="$FLAKE8_FORMAT" .
RET=$(($RET + $?)) ; echo $MSG "DONE"
- MSG='Linting .pyx code' ; echo $MSG
- flake8 --format="$FLAKE8_FORMAT" pandas --filename=*.pyx --select=E501,E302,E203,E111,E114,E221,E303,E128,E231,E126,E265,E305,E301,E127,E261,E271,E129,W291,E222,E241,E123,F403,C400,C401,C402,C403,C404,C405,C406,C407,C408,C409,C410,C411
+ MSG='Linting .pyx and .pxd code' ; echo $MSG
+ flake8 --format="$FLAKE8_FORMAT" pandas --append-config=flake8/cython.cfg
RET=$(($RET + $?)) ; echo $MSG "DONE"
- MSG='Linting .pxd and .pxi.in' ; echo $MSG
- flake8 --format="$FLAKE8_FORMAT" pandas/_libs --filename=*.pxi.in,*.pxd --select=E501,E302,E203,E111,E114,E221,E303,E231,E126,F403
+ MSG='Linting .pxi.in' ; echo $MSG
+ flake8 --format="$FLAKE8_FORMAT" pandas/_libs --append-config=flake8/cython-template.cfg
RET=$(($RET + $?)) ; echo $MSG "DONE"
echo "flake8-rst --version"
diff --git a/flake8/cython-template.cfg b/flake8/cython-template.cfg
new file mode 100644
index 0000000000000..61562bd7701b1
--- /dev/null
+++ b/flake8/cython-template.cfg
@@ -0,0 +1,4 @@
+[flake8]
+filename = *.pxi.in
+select = E501,E302,E203,E111,E114,E221,E303,E231,E126,F403
+
diff --git a/flake8/cython.cfg b/flake8/cython.cfg
new file mode 100644
index 0000000000000..2dfe47b60b4c1
--- /dev/null
+++ b/flake8/cython.cfg
@@ -0,0 +1,3 @@
+[flake8]
+filename = *.pyx,*.pxd
+select=E501,E302,E203,E111,E114,E221,E303,E128,E231,E126,E265,E305,E301,E127,E261,E271,E129,W291,E222,E241,E123,F403,C400,C401,C402,C403,C404,C405,C406,C407,C408,C409,C410,C411
diff --git a/pandas/_libs/sparse_op_helper.pxi.in b/pandas/_libs/sparse_op_helper.pxi.in
index 996da4ca2f92b..ce665ca812131 100644
--- a/pandas/_libs/sparse_op_helper.pxi.in
+++ b/pandas/_libs/sparse_op_helper.pxi.in
@@ -235,7 +235,7 @@ cdef inline tuple int_op_{{opname}}_{{dtype}}({{dtype}}_t[:] x_,
{{dtype}}_t yfill):
cdef:
IntIndex out_index
- Py_ssize_t xi = 0, yi = 0, out_i = 0 # fp buf indices
+ Py_ssize_t xi = 0, yi = 0, out_i = 0 # fp buf indices
int32_t xloc, yloc
int32_t[:] xindices, yindices, out_indices
{{dtype}}_t[:] x, y
diff --git a/pandas/_libs/tslibs/util.pxd b/pandas/_libs/tslibs/util.pxd
index 936532a81c6d6..e7f6b3334eb65 100644
--- a/pandas/_libs/tslibs/util.pxd
+++ b/pandas/_libs/tslibs/util.pxd
@@ -42,7 +42,7 @@ cdef extern from "numpy/ndarrayobject.h":
bint PyArray_IsIntegerScalar(obj) nogil
bint PyArray_Check(obj) nogil
-cdef extern from "numpy/npy_common.h":
+cdef extern from "numpy/npy_common.h":
int64_t NPY_MIN_INT64
diff --git a/web/pandas_web.py b/web/pandas_web.py
index a34a31feabce0..38ab78f5690e7 100755
--- a/web/pandas_web.py
+++ b/web/pandas_web.py
@@ -34,12 +34,13 @@
import time
import typing
-import feedparser
import jinja2
-import markdown
import requests
import yaml
+import feedparser
+import markdown
+
class Preprocessors:
"""
| - [x] closes #30843
- [ ] 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/30847 | 2020-01-09T13:27:14Z | 2020-02-12T16:00:42Z | 2020-02-12T16:00:42Z | 2020-02-12T16:00:49Z |
BUG: Handle nested arrays in array_equivalent_object | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 77e19953ba970..fed88d0f7016b 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -1074,6 +1074,7 @@ Other
- Bug in :class:`DataFrame` constructor when passing a 2D ``ndarray`` and an extension dtype (:issue:`12513`)
- Bug in :meth:`DaataFrame.to_csv` when supplied a series with a ``dtype="string"`` and a ``na_rep``, the ``na_rep`` was being truncated to 2 characters. (:issue:`29975`)
- Bug where :meth:`DataFrame.itertuples` would incorrectly determine whether or not namedtuples could be used for dataframes of 255 columns (:issue:`28282`)
+- Handle nested NumPy ``object`` arrays in :func:`testing.assert_series_equal` for ExtensionArray implementations (:issue:`30841`)
.. ---------------------------------------------------------------------------
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index 2b8ba06aa8a82..719db5c03f07f 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -19,7 +19,7 @@ PyDateTime_IMPORT
import numpy as np
cimport numpy as cnp
-from numpy cimport (ndarray, PyArray_GETITEM,
+from numpy cimport (ndarray, PyArray_Check, PyArray_GETITEM,
PyArray_ITER_DATA, PyArray_ITER_NEXT, PyArray_IterNew,
flatiter, NPY_OBJECT,
int64_t, float32_t, float64_t,
@@ -524,8 +524,11 @@ def array_equivalent_object(left: object[:], right: object[:]) -> bool:
# we are either not equal or both nan
# I think None == None will be true here
try:
- if not (PyObject_RichCompareBool(x, y, Py_EQ) or
- (x is None or is_nan(x)) and (y is None or is_nan(y))):
+ if PyArray_Check(x) and PyArray_Check(y):
+ if not array_equivalent_object(x, y):
+ return False
+ elif not (PyObject_RichCompareBool(x, y, Py_EQ) or
+ (x is None or is_nan(x)) and (y is None or is_nan(y))):
return False
except TypeError as err:
# Avoid raising TypeError on tzawareness mismatch
diff --git a/pandas/tests/dtypes/test_missing.py b/pandas/tests/dtypes/test_missing.py
index 7d4811857db5f..7ba59786bb0fa 100644
--- a/pandas/tests/dtypes/test_missing.py
+++ b/pandas/tests/dtypes/test_missing.py
@@ -294,6 +294,11 @@ def test_array_equivalent():
np.array([np.nan, None], dtype="object"),
np.array([np.nan, None], dtype="object"),
)
+ # Check the handling of nested arrays in array_equivalent_object
+ assert array_equivalent(
+ np.array([np.array([np.nan, None], dtype="object"), None], dtype="object"),
+ np.array([np.array([np.nan, None], dtype="object"), None], dtype="object"),
+ )
assert array_equivalent(
np.array([np.nan, 1 + 1j], dtype="complex"),
np.array([np.nan, 1 + 1j], dtype="complex"),
| - [x] closes #30841
- [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/30842 | 2020-01-09T06:53:25Z | 2020-01-09T15:51:26Z | 2020-01-09T15:51:26Z | 2020-01-09T18:11:49Z |
CLN: remove _to_M8 | diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index d9c4b27da8698..60ee60876075a 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -70,22 +70,6 @@ def tz_to_dtype(tz):
return DatetimeTZDtype(tz=tz)
-def _to_M8(key, tz=None):
- """
- Timestamp-like => dt64
- """
- if not isinstance(key, Timestamp):
- # this also converts strings
- key = Timestamp(key)
- if key.tzinfo is not None and tz is not None:
- # Don't tz_localize(None) if key is already tz-aware
- key = key.tz_convert(tz)
- else:
- key = key.tz_localize(tz)
-
- return np.int64(conversion.pydt_to_i8(key)).view(_NS_DTYPE)
-
-
def _field_accessor(name, field, docstring=None):
def f(self):
values = self.asi8
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 0c40900d54b53..b620818004f98 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -16,7 +16,6 @@
from pandas.core.accessor import delegate_names
from pandas.core.arrays.datetimes import (
DatetimeArray,
- _to_M8,
tz_to_dtype,
validate_tz_from_dtype,
)
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index c8b322b3c832a..2f00a58fe80be 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -23,7 +23,7 @@
from pandas.errors import PerformanceWarning
import pandas._testing as tm
-from pandas.core.indexes.datetimes import DatetimeIndex, _to_M8, date_range
+from pandas.core.indexes.datetimes import DatetimeIndex, date_range
from pandas.core.series import Series
from pandas.io.pickle import read_pickle
@@ -81,17 +81,6 @@ class WeekDay:
SUN = 6
-####
-# Misc function tests
-####
-
-
-def test_to_M8():
- valb = datetime(2007, 10, 1)
- valu = _to_M8(valb)
- assert isinstance(valu, np.datetime64)
-
-
#####
# DateOffset Tests
#####
| a couple of recently-merged PRs removed the last usages of this function | https://api.github.com/repos/pandas-dev/pandas/pulls/30840 | 2020-01-09T04:57:17Z | 2020-01-09T05:44:38Z | 2020-01-09T05:44:38Z | 2020-01-09T05:47:59Z |
TYP: __array__ | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index a67d31344ff55..8e33596bd86c1 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -1264,7 +1264,7 @@ def shift(self, periods, fill_value=None):
return self.from_codes(codes, dtype=self.dtype)
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
"""
The numpy array interface.
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 06c1338dbf5ab..6b11f156dafa0 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -481,7 +481,7 @@ def _formatter(self, boxed=False):
def nbytes(self):
return self._data.nbytes
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
# used for Timedelta/DatetimeArray, overwritten by PeriodArray
if is_object_dtype(dtype):
return np.array(list(self), dtype=object)
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index d9c4b27da8698..ba89c55a8a86e 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -562,7 +562,7 @@ def _resolution(self):
# ----------------------------------------------------------------
# Array-Like / EA-Interface Methods
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
if dtype is None and self.tz:
# The default for tz-aware is object, to preserve tz info
dtype = object
diff --git a/pandas/core/arrays/interval.py b/pandas/core/arrays/interval.py
index 75dd00104db1b..2a09cbfdb2386 100644
--- a/pandas/core/arrays/interval.py
+++ b/pandas/core/arrays/interval.py
@@ -1063,7 +1063,7 @@ def is_non_overlapping_monotonic(self):
)
# Conversion
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
"""
Return the IntervalArray's data as a numpy array of Interval
objects (with dtype='object')
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index 6fd9f1efbb408..0253cab39fb45 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -136,7 +136,7 @@ def to_numpy(
__array_priority__ = 1000 # higher than ndarray so ops dispatch to us
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
"""
the array interface, return my values
We return an object array here to preserve our scalar values
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 3ad6e7cb3c176..4db3d3010adaf 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -182,7 +182,7 @@ def dtype(self):
# ------------------------------------------------------------------------
# NumPy Array Interface
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
return np.asarray(self._ndarray, dtype=dtype)
_HANDLED_TYPES = (np.ndarray, numbers.Number)
diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index db84a522f55b1..2bca4e642841f 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -279,7 +279,7 @@ def freq(self):
"""
return self.dtype.freq
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
# overriding DatetimelikeArray
return np.array(list(self), dtype=object)
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 95d6136a2dad6..e2562a375515d 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -427,7 +427,7 @@ def from_spmatrix(cls, data):
return cls._simple_new(arr, index, dtype)
- def __array__(self, dtype=None, copy=True):
+ def __array__(self, dtype=None, copy=True) -> np.ndarray:
fill_value = self.fill_value
if self.sp_index.ngaps == 0:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 22655bf9889c7..be1c0a9c785a0 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -1882,7 +1882,7 @@ def empty(self) -> bool_t:
# GH#23114 Ensure ndarray.__op__(DataFrame) returns NotImplemented
__array_priority__ = 1000
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
return com.values_from_object(self)
def __array_wrap__(self, result, context=None):
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index b02c0a08c93fa..1489e100b5682 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -597,7 +597,7 @@ def __len__(self) -> int:
"""
return len(self._data)
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
"""
The array interface, return my values.
"""
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 7c1e95e12d339..41072d4ce6a93 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -392,7 +392,7 @@ def __contains__(self, key) -> bool:
return contains(self, key, container=self._engine)
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
""" the array interface, return my values """
return np.array(self._data, dtype=dtype)
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 0c40900d54b53..952a788f77347 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -294,7 +294,7 @@ def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
# --------------------------------------------------------------------
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
return np.asarray(self._data, dtype=dtype)
@cache_readonly
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 1144e6d597fba..84d7399cc4f2d 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -951,7 +951,7 @@ def copy(
_set_identity=_set_identity,
)
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
""" the array interface, return my values """
return self.values
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index cc10197f80c6f..6ab2e66e05d6e 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -391,7 +391,7 @@ def _int64index(self):
# ------------------------------------------------------------------------
# Index Methods
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
if is_integer_dtype(dtype):
return self.asi8
else:
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 446654374f37c..f4437bbe95fd2 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -670,7 +670,7 @@ def construct_return(result):
else:
return construct_return(result)
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
"""
Return the values as a NumPy array.
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 2c7fc8b320325..bbcf53f107048 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -245,7 +245,7 @@ class ArrayLike:
def __init__(self, array):
self.array = array
- def __array__(self, dtype=None):
+ def __array__(self, dtype=None) -> np.ndarray:
return self.array
expected = pd.Index(array)
| https://api.github.com/repos/pandas-dev/pandas/pulls/30839 | 2020-01-09T04:55:16Z | 2020-01-09T18:54:35Z | 2020-01-09T18:54:35Z | 2020-01-09T19:00:15Z | |
BUG: added missing fill_na parameter to DataFrame.unstack() with list of levels | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 58a7a466471b7..bb4996258111f 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -1040,6 +1040,7 @@ Reshaping
- Dtypes are now preserved when transposing a ``DataFrame`` where each column is the same extension dtype (:issue:`30091`)
- Bug in :func:`merge_asof` merging on a tz-aware ``left_index`` and ``right_on`` a tz-aware column (:issue:`29864`)
- Improved error message and docstring in :func:`cut` and :func:`qcut` when `labels=True` (:issue:`13318`)
+- Bug in missing `fill_na` parameter to :meth:`DataFrame.unstack` with list of levels (:issue:`30740`)
Sparse
^^^^^^
diff --git a/pandas/core/reshape/reshape.py b/pandas/core/reshape/reshape.py
index da92e1154556a..97f416e32d07b 100644
--- a/pandas/core/reshape/reshape.py
+++ b/pandas/core/reshape/reshape.py
@@ -358,7 +358,7 @@ def _unstack_multiple(data, clocs, fill_value=None):
result = data
for i in range(len(clocs)):
val = clocs[i]
- result = result.unstack(val)
+ result = result.unstack(val, fill_value=fill_value)
clocs = [v if i > v else v - 1 for v in clocs]
return result
diff --git a/pandas/tests/frame/test_reshape.py b/pandas/tests/frame/test_reshape.py
index b77d3029a5446..56a0c8cf4f5bd 100644
--- a/pandas/tests/frame/test_reshape.py
+++ b/pandas/tests/frame/test_reshape.py
@@ -1128,3 +1128,34 @@ def test_stack_timezone_aware_values():
),
)
tm.assert_series_equal(result, expected)
+
+
+def test_unstacking_multi_index_df():
+ # see gh-30740
+ df = DataFrame(
+ {
+ "name": ["Alice", "Bob"],
+ "score": [9.5, 8],
+ "employed": [False, True],
+ "kids": [0, 0],
+ "gender": ["female", "male"],
+ }
+ )
+ df = df.set_index(["name", "employed", "kids", "gender"])
+ df = df.unstack(["gender"], fill_value=0)
+ expected = df.unstack("employed", fill_value=0).unstack("kids", fill_value=0)
+ result = df.unstack(["employed", "kids"], fill_value=0)
+ expected = DataFrame(
+ [[9.5, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 8.0]],
+ index=Index(["Alice", "Bob"], name="name"),
+ columns=MultiIndex.from_tuples(
+ [
+ ("score", "female", False, 0),
+ ("score", "female", True, 0),
+ ("score", "male", False, 0),
+ ("score", "male", True, 0),
+ ],
+ names=[None, "gender", "employed", "kids"],
+ ),
+ )
+ tm.assert_frame_equal(result, expected)
| - [x] closes #30740
- [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/30838 | 2020-01-09T04:44:29Z | 2020-01-09T19:19:07Z | 2020-01-09T19:19:07Z | 2020-01-09T19:19:10Z |
DOC: whatsnew fixes | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 77e19953ba970..762a293e41801 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -1,4 +1,4 @@
-.. _whatsnew_1000:
+.. _whatsnew_100:
What's new in 1.0.0 (??)
------------------------
@@ -148,7 +148,7 @@ You can use the alias ``"boolean"`` as well.
s = pd.Series([True, False, None], dtype="boolean")
s
-.. _whatsnew_1000.numba_rolling_apply:
+.. _whatsnew_100.numba_rolling_apply:
Using Numba in ``rolling.apply``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -159,7 +159,7 @@ can yield significant performance gains if the apply function can operate on num
the data set is larger (1 million rows or greater). For more details, see
:ref:`rolling apply documentation <stats.rolling_apply>` (:issue:`28987`)
-.. _whatsnew_1000.custom_window:
+.. _whatsnew_100.custom_window:
Defining custom windows for rolling operations
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -170,7 +170,7 @@ method on a :func:`pandas.api.indexers.BaseIndexer` subclass that will generate
indices used for each window during the rolling aggregation. For more details and example usage, see
the :ref:`custom window rolling documentation <stats.custom_rolling_window>`
-.. _whatsnew_1000.to_markdown:
+.. _whatsnew_100.to_markdown:
Converting to Markdown
^^^^^^^^^^^^^^^^^^^^^^
@@ -182,7 +182,7 @@ We've added :meth:`~DataFrame.to_markdown` for creating a markdown table (:issue
df = pd.DataFrame({"A": [1, 2, 3], "B": [1, 2, 3]}, index=['a', 'a', 'b'])
print(df.to_markdown())
-.. _whatsnew_1000.enhancements.other:
+.. _whatsnew_100.enhancements.other:
Other enhancements
^^^^^^^^^^^^^^^^^^
@@ -210,7 +210,7 @@ Other enhancements
- The ``partition_cols`` argument in :meth:`DataFrame.to_parquet` now accepts a string (:issue:`27117`)
- :func:`pandas.read_json` now parses ``NaN``, ``Infinity`` and ``-Infinity`` (:issue:`12213`)
- The ``pandas.np`` submodule is now deprecated. Import numpy directly instead (:issue:`30296`)
-- :func:`to_parquet` now appropriately handles the ``schema`` argument for user defined schemas in the pyarrow engine. (:issue: `30270`)
+- :func:`to_parquet` now appropriately handles the ``schema`` argument for user defined schemas in the pyarrow engine. (:issue:`30270`)
- DataFrame constructor preserve `ExtensionArray` dtype with `ExtensionArray` (:issue:`11363`)
- :meth:`DataFrame.sort_values` and :meth:`Series.sort_values` have gained ``ignore_index`` keyword to be able to reset index after sorting (:issue:`30114`)
- :meth:`DataFrame.sort_index` and :meth:`Series.sort_index` have gained ``ignore_index`` keyword to reset index (:issue:`30114`)
@@ -232,12 +232,12 @@ source, you should no longer need to install Cython into your build environment
.. ---------------------------------------------------------------------------
-.. _whatsnew_1000.api_breaking:
+.. _whatsnew_100.api_breaking:
Backwards incompatible API changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. _whatsnew_1000.api_breaking.MultiIndex._names:
+.. _whatsnew_100.api_breaking.MultiIndex._names:
Avoid using names from ``MultiIndex.levels``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -294,7 +294,7 @@ New repr for :class:`~pandas.arrays.IntervalArray`
Extended verbose info output for :class:`~pandas.DataFrame`
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- :meth:`Dataframe.info` now shows line numbers for the columns summary (:issue:`17304`)
+- :meth:`DataFrame.info` now shows line numbers for the columns summary (:issue:`17304`)
*pandas 0.25.x*
@@ -479,14 +479,14 @@ consistent with the behaviour of :class:`DataFrame` and :class:`Index`.
DeprecationWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.
Series([], dtype: float64)
-.. _whatsnew_1000.api_breaking.python:
+.. _whatsnew_100.api_breaking.python:
Increased minimum version for Python
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Pandas 1.0.0 supports Python 3.6.1 and higher (:issue:`29212`).
-.. _whatsnew_1000.api_breaking.deps:
+.. _whatsnew_100.api_breaking.deps:
Increased minimum versions for dependencies
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -555,7 +555,7 @@ Optional libraries below the lowest tested version may still work, but are not c
See :ref:`install.dependencies` and :ref:`install.optional_dependencies` for more.
-.. _whatsnew_1000.api.other:
+.. _whatsnew_100.api.other:
Other API changes
^^^^^^^^^^^^^^^^^
@@ -570,14 +570,14 @@ Other API changes
- Changed the default configuration value for ``options.matplotlib.register_converters`` from ``True`` to ``"auto"`` (:issue:`18720`).
Now, pandas custom formatters will only be applied to plots created by pandas, through :meth:`~DataFrame.plot`.
Previously, pandas' formatters would be applied to all plots created *after* a :meth:`~DataFrame.plot`.
- See :ref:`units registration <whatsnew_1000.matplotlib_units>` for more.
+ See :ref:`units registration <whatsnew_100.matplotlib_units>` for more.
- :meth:`Series.dropna` has dropped its ``**kwargs`` argument in favor of a single ``how`` parameter.
Supplying anything else than ``how`` to ``**kwargs`` raised a ``TypeError`` previously (:issue:`29388`)
- When testing pandas, the new minimum required version of pytest is 5.0.1 (:issue:`29664`)
- :meth:`Series.str.__iter__` was deprecated and will be removed in future releases (:issue:`28277`).
-.. _whatsnew_1000.api.documentation:
+.. _whatsnew_100.api.documentation:
Documentation Improvements
^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -587,7 +587,7 @@ Documentation Improvements
.. ---------------------------------------------------------------------------
-.. _whatsnew_1000.deprecations:
+.. _whatsnew_100.deprecations:
Deprecations
~~~~~~~~~~~~
@@ -646,7 +646,7 @@ a list of items should be used instead. (:issue:`23566`) For example:
.. ---------------------------------------------------------------------------
-.. _whatsnew_1000.prior_deprecations:
+.. _whatsnew_100.prior_deprecations:
Removal of prior version deprecations/changes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -658,7 +658,7 @@ have been removed (:issue:`28425`). We recommend using a ``Series`` or
``DataFrame`` with sparse values instead. See :ref:`sparse.migration` for help
with migrating existing code.
-.. _whatsnew_1000.matplotlib_units:
+.. _whatsnew_100.matplotlib_units:
**Matplotlib unit registration**
@@ -680,24 +680,24 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
**Other removals**
- Removed the previously deprecated keyword "index" from :func:`read_stata`, :class:`StataReader`, and :meth:`StataReader.read`, use "index_col" instead (:issue:`17328`)
-- Removed :meth:`StataReader.data` method, use :meth:`StataReader.read` instead (:issue:`9493`)
-- Removed :func:`pandas.plotting._matplotlib.tsplot`, use :meth:`Series.plot` instead (:issue:`19980`)
-- :func:`pandas.tseries.converter.register` has been moved to :func:`pandas.plotting.register_matplotlib_converters` (:issue:`18307`)
+- Removed ``StataReader.data`` method, use :meth:`StataReader.read` instead (:issue:`9493`)
+- Removed ``pandas.plotting._matplotlib.tsplot``, use :meth:`Series.plot` instead (:issue:`19980`)
+- ``pandas.tseries.converter.register`` has been moved to :func:`pandas.plotting.register_matplotlib_converters` (:issue:`18307`)
- :meth:`Series.plot` no longer accepts positional arguments, pass keyword arguments instead (:issue:`30003`)
- :meth:`DataFrame.hist` and :meth:`Series.hist` no longer allows ``figsize="default"``, specify figure size by passinig a tuple instead (:issue:`30003`)
- Floordiv of integer-dtyped array by :class:`Timedelta` now raises ``TypeError`` (:issue:`21036`)
- :class:`TimedeltaIndex` and :class:`DatetimeIndex` no longer accept non-nanosecond dtype strings like "timedelta64" or "datetime64", use "timedelta64[ns]" and "datetime64[ns]" instead (:issue:`24806`)
- Changed the default "skipna" argument in :func:`pandas.api.types.infer_dtype` from ``False`` to ``True`` (:issue:`24050`)
-- Removed :attr:`Series.ix` and :attr:`DataFrame.ix` (:issue:`26438`)
-- Removed :meth:`Index.summary` (:issue:`18217`)
+- Removed ``Series.ix`` and ``DataFrame.ix`` (:issue:`26438`)
+- Removed ``Index.summary`` (:issue:`18217`)
- Removed the previously deprecated keyword "fastpath" from the :class:`Index` constructor (:issue:`23110`)
-- Removed :meth:`Series.get_value`, :meth:`Series.set_value`, :meth:`DataFrame.get_value`, :meth:`DataFrame.set_value` (:issue:`17739`)
-- Removed :meth:`Series.compound` and :meth:`DataFrame.compound` (:issue:`26405`)
+- Removed ``Series.get_value``, ``Series.set_value``, ``DataFrame.get_value``, ``DataFrame.set_value`` (:issue:`17739`)
+- Removed ``Series.compound`` and ``DataFrame.compound`` (:issue:`26405`)
- Changed the default "inplace" argument in :meth:`DataFrame.set_index` and :meth:`Series.set_axis` from ``None`` to ``False`` (:issue:`27600`)
-- Removed :attr:`Series.cat.categorical`, :attr:`Series.cat.index`, :attr:`Series.cat.name` (:issue:`24751`)
+- Removed ``Series.cat.categorical``, ``Series.cat.index``, ``Series.cat.name`` (:issue:`24751`)
- Removed the previously deprecated keyword "box" from :func:`to_datetime` and :func:`to_timedelta`; in addition these now always returns :class:`DatetimeIndex`, :class:`TimedeltaIndex`, :class:`Index`, :class:`Series`, or :class:`DataFrame` (:issue:`24486`)
- :func:`to_timedelta`, :class:`Timedelta`, and :class:`TimedeltaIndex` no longer allow "M", "y", or "Y" for the "unit" argument (:issue:`23264`)
-- Removed the previously deprecated keyword "time_rule" from (non-public) :func:`offsets.generate_range`, which has been moved to :func:`core.arrays._ranges.generate_range` (:issue:`24157`)
+- Removed the previously deprecated keyword "time_rule" from (non-public) ``offsets.generate_range``, which has been moved to :func:`core.arrays._ranges.generate_range` (:issue:`24157`)
- :meth:`DataFrame.loc` or :meth:`Series.loc` with listlike indexers and missing labels will no longer reindex (:issue:`17295`)
- :meth:`DataFrame.to_excel` and :meth:`Series.to_excel` with non-existent columns will no longer reindex (:issue:`17295`)
- Removed the previously deprecated keyword "join_axes" from :func:`concat`; use ``reindex_like`` on the result instead (:issue:`22318`)
@@ -706,14 +706,14 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
- Passing ``datetime64`` data to :class:`TimedeltaIndex` or ``timedelta64`` data to ``DatetimeIndex`` now raises ``TypeError`` (:issue:`23539`, :issue:`23937`)
- Passing ``int64`` values to :class:`DatetimeIndex` and a timezone now interprets the values as nanosecond timestamps in UTC, not wall times in the given timezone (:issue:`24559`)
- A tuple passed to :meth:`DataFrame.groupby` is now exclusively treated as a single key (:issue:`18314`)
-- Removed :meth:`Index.contains`, use ``key in index`` instead (:issue:`30103`)
+- Removed ``Index.contains``, use ``key in index`` instead (:issue:`30103`)
- Addition and subtraction of ``int`` or integer-arrays is no longer allowed in :class:`Timestamp`, :class:`DatetimeIndex`, :class:`TimedeltaIndex`, use ``obj + n * obj.freq`` instead of ``obj + n`` (:issue:`22535`)
-- Removed :meth:`Series.ptp` (:issue:`21614`)
-- Removed :meth:`Series.from_array` (:issue:`18258`)
-- Removed :meth:`DataFrame.from_items` (:issue:`18458`)
-- Removed :meth:`DataFrame.as_matrix`, :meth:`Series.as_matrix` (:issue:`18458`)
-- Removed :meth:`Series.asobject` (:issue:`18477`)
-- Removed :meth:`DataFrame.as_blocks`, :meth:`Series.as_blocks`, `DataFrame.blocks`, :meth:`Series.blocks` (:issue:`17656`)
+- Removed ``Series.ptp`` (:issue:`21614`)
+- Removed ``Series.from_array`` (:issue:`18258`)
+- Removed ``DataFrame.from_items`` (:issue:`18458`)
+- Removed ``DataFrame.as_matrix``, ``Series.as_matrix`` (:issue:`18458`)
+- Removed ``Series.asobject`` (:issue:`18477`)
+- Removed ``DataFrame.as_blocks``, ``Series.as_blocks``, ``DataFrame.blocks``, ``Series.blocks`` (:issue:`17656`)
- :meth:`pandas.Series.str.cat` now defaults to aligning ``others``, using ``join='left'`` (:issue:`27611`)
- :meth:`pandas.Series.str.cat` does not accept list-likes *within* list-likes anymore (:issue:`27611`)
- :meth:`Series.where` with ``Categorical`` dtype (or :meth:`DataFrame.where` with ``Categorical`` column) no longer allows setting new categories (:issue:`24114`)
@@ -721,37 +721,37 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
- Removed the previously deprecated keyword "verify_integrity" from the :class:`DatetimeIndex` and :class:`TimedeltaIndex` constructors (:issue:`23919`)
- Removed the previously deprecated keyword "fastpath" from ``pandas.core.internals.blocks.make_block`` (:issue:`19265`)
- Removed the previously deprecated keyword "dtype" from :meth:`Block.make_block_same_class` (:issue:`19434`)
-- Removed :meth:`ExtensionArray._formatting_values`. Use :attr:`ExtensionArray._formatter` instead. (:issue:`23601`)
-- Removed :meth:`MultiIndex.to_hierarchical` (:issue:`21613`)
-- Removed :attr:`MultiIndex.labels`, use :attr:`MultiIndex.codes` instead (:issue:`23752`)
+- Removed ``ExtensionArray._formatting_values``. Use :attr:`ExtensionArray._formatter` instead. (:issue:`23601`)
+- Removed ``MultiIndex.to_hierarchical`` (:issue:`21613`)
+- Removed ``MultiIndex.labels``, use :attr:`MultiIndex.codes` instead (:issue:`23752`)
- Removed the previously deprecated keyword "labels" from the :class:`MultiIndex` constructor, use "codes" instead (:issue:`23752`)
-- Removed :meth:`MultiIndex.set_labels`, use :meth:`MultiIndex.set_codes` instead (:issue:`23752`)
+- Removed ``MultiIndex.set_labels``, use :meth:`MultiIndex.set_codes` instead (:issue:`23752`)
- Removed the previously deprecated keyword "labels" from :meth:`MultiIndex.set_codes`, :meth:`MultiIndex.copy`, :meth:`MultiIndex.drop`, use "codes" instead (:issue:`23752`)
- Removed support for legacy HDF5 formats (:issue:`29787`)
- Passing a dtype alias (e.g. 'datetime64[ns, UTC]') to :class:`DatetimeTZDtype` is no longer allowed, use :meth:`DatetimeTZDtype.construct_from_string` instead (:issue:`23990`)
- Removed the previously deprecated keyword "skip_footer" from :func:`read_excel`; use "skipfooter" instead (:issue:`18836`)
- :func:`read_excel` no longer allows an integer value for the parameter ``usecols``, instead pass a list of integers from 0 to ``usecols`` inclusive (:issue:`23635`)
- Removed the previously deprecated keyword "convert_datetime64" from :meth:`DataFrame.to_records` (:issue:`18902`)
-- Removed :meth:`IntervalIndex.from_intervals` in favor of the :class:`IntervalIndex` constructor (:issue:`19263`)
+- Removed ``IntervalIndex.from_intervals`` in favor of the :class:`IntervalIndex` constructor (:issue:`19263`)
- Changed the default "keep_tz" argument in :meth:`DatetimeIndex.to_series` from ``None`` to ``True`` (:issue:`23739`)
-- Removed :func:`api.types.is_period` and :func:`api.types.is_datetimetz` (:issue:`23917`)
+- Removed ``api.types.is_period`` and ``api.types.is_datetimetz`` (:issue:`23917`)
- Ability to read pickles containing :class:`Categorical` instances created with pre-0.16 version of pandas has been removed (:issue:`27538`)
-- Removed :func:`pandas.tseries.plotting.tsplot` (:issue:`18627`)
+- Removed ``pandas.tseries.plotting.tsplot`` (:issue:`18627`)
- Removed the previously deprecated keywords "reduce" and "broadcast" from :meth:`DataFrame.apply` (:issue:`18577`)
- Removed the previously deprecated ``assert_raises_regex`` function in ``pandas._testing`` (:issue:`29174`)
- Removed the previously deprecated ``FrozenNDArray`` class in ``pandas.core.indexes.frozen`` (:issue:`29335`)
- Removed the previously deprecated keyword "nthreads" from :func:`read_feather`, use "use_threads" instead (:issue:`23053`)
-- Removed :meth:`Index.is_lexsorted_for_tuple` (:issue:`29305`)
+- Removed ``Index.is_lexsorted_for_tuple`` (:issue:`29305`)
- Removed support for nested renaming in :meth:`DataFrame.aggregate`, :meth:`Series.aggregate`, :meth:`core.groupby.DataFrameGroupBy.aggregate`, :meth:`core.groupby.SeriesGroupBy.aggregate`, :meth:`core.window.rolling.Rolling.aggregate` (:issue:`29608`)
-- Removed :meth:`Series.valid`; use :meth:`Series.dropna` instead (:issue:`18800`)
-- Removed :attr:`DataFrame.is_copy`, :attr:`Series.is_copy` (:issue:`18812`)
-- Removed :meth:`DataFrame.get_ftype_counts`, :meth:`Series.get_ftype_counts` (:issue:`18243`)
-- Removed :meth:`DataFrame.ftypes`, :meth:`Series.ftypes`, :meth:`Series.ftype` (:issue:`26744`)
-- Removed :meth:`Index.get_duplicates`, use ``idx[idx.duplicated()].unique()`` instead (:issue:`20239`)
-- Removed :meth:`Series.clip_upper`, :meth:`Series.clip_lower`, :meth:`DataFrame.clip_upper`, :meth:`DataFrame.clip_lower` (:issue:`24203`)
+- Removed ``Series.valid``; use :meth:`Series.dropna` instead (:issue:`18800`)
+- Removed ``DataFrame.is_copy``, ``Series.is_copy`` (:issue:`18812`)
+- Removed ``DataFrame.get_ftype_counts``, ``Series.get_ftype_counts`` (:issue:`18243`)
+- Removed ``DataFrame.ftypes``, ``Series.ftypes``, ``Series.ftype`` (:issue:`26744`)
+- Removed ``Index.get_duplicates``, use ``idx[idx.duplicated()].unique()`` instead (:issue:`20239`)
+- Removed ``Series.clip_upper``, ``Series.clip_lower``, ``DataFrame.clip_upper``, ``DataFrame.clip_lower`` (:issue:`24203`)
- Removed the ability to alter :attr:`DatetimeIndex.freq`, :attr:`TimedeltaIndex.freq`, or :attr:`PeriodIndex.freq` (:issue:`20772`)
-- Removed :attr:`DatetimeIndex.offset` (:issue:`20730`)
-- Removed :meth:`DatetimeIndex.asobject`, :meth:`TimedeltaIndex.asobject`, :meth:`PeriodIndex.asobject`, use ``astype(object)`` instead (:issue:`29801`)
+- Removed ``DatetimeIndex.offset`` (:issue:`20730`)
+- Removed ``DatetimeIndex.asobject``, ``TimedeltaIndex.asobject``, ``PeriodIndex.asobject``, use ``astype(object)`` instead (:issue:`29801`)
- Removed the previously deprecated keyword "order" from :func:`factorize` (:issue:`19751`)
- Removed the previously deprecated keyword "encoding" from :func:`read_stata` and :meth:`DataFrame.to_stata` (:issue:`21400`)
- Changed the default "sort" argument in :func:`concat` from ``None`` to ``False`` (:issue:`20613`)
@@ -760,28 +760,28 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
- Removed the previously deprecated keywords "how", "fill_method", and "limit" from :meth:`DataFrame.resample` (:issue:`30139`)
- Passing an integer to :meth:`Series.fillna` or :meth:`DataFrame.fillna` with ``timedelta64[ns]`` dtype now raises ``TypeError`` (:issue:`24694`)
- Passing multiple axes to :meth:`DataFrame.dropna` is no longer supported (:issue:`20995`)
-- Removed :meth:`Series.nonzero`, use ``to_numpy().nonzero()`` instead (:issue:`24048`)
+- Removed ``Series.nonzero``, use ``to_numpy().nonzero()`` instead (:issue:`24048`)
- Passing floating dtype ``codes`` to :meth:`Categorical.from_codes` is no longer supported, pass ``codes.astype(np.int64)`` instead (:issue:`21775`)
- Removed the previously deprecated keyword "pat" from :meth:`Series.str.partition` and :meth:`Series.str.rpartition`, use "sep" instead (:issue:`23767`)
-- Removed :meth:`Series.put` (:issue:`27106`)
-- Removed :attr:`Series.real`, :attr:`Series.imag` (:issue:`27106`)
-- Removed :meth:`Series.to_dense`, :meth:`DataFrame.to_dense` (:issue:`26684`)
-- Removed :meth:`Index.dtype_str`, use ``str(index.dtype)`` instead (:issue:`27106`)
+- Removed ``Series.put`` (:issue:`27106`)
+- Removed ``Series.real``, ``Series.imag`` (:issue:`27106`)
+- Removed ``Series.to_dense``, ``DataFrame.to_dense`` (:issue:`26684`)
+- Removed ``Index.dtype_str``, use ``str(index.dtype)`` instead (:issue:`27106`)
- :meth:`Categorical.ravel` returns a :class:`Categorical` instead of a ``ndarray`` (:issue:`27199`)
- The 'outer' method on Numpy ufuncs, e.g. ``np.subtract.outer`` operating on :class:`Series` objects is no longer supported, and will raise ``NotImplementedError`` (:issue:`27198`)
-- Removed :meth:`Series.get_dtype_counts` and :meth:`DataFrame.get_dtype_counts` (:issue:`27145`)
+- Removed ``Series.get_dtype_counts`` and ``DataFrame.get_dtype_counts`` (:issue:`27145`)
- Changed the default "fill_value" argument in :meth:`Categorical.take` from ``True`` to ``False`` (:issue:`20841`)
- Changed the default value for the `raw` argument in :func:`Series.rolling().apply() <pandas.core.window.Rolling.apply>`, :func:`DataFrame.rolling().apply() <pandas.core.window.Rolling.apply>`, :func:`Series.expanding().apply() <pandas.core.window.Expanding.apply>`, and :func:`DataFrame.expanding().apply() <pandas.core.window.Expanding.apply>` from ``None`` to ``False`` (:issue:`20584`)
- Removed deprecated behavior of :meth:`Series.argmin` and :meth:`Series.argmax`, use :meth:`Series.idxmin` and :meth:`Series.idxmax` for the old behavior (:issue:`16955`)
- Passing a tz-aware ``datetime.datetime`` or :class:`Timestamp` into the :class:`Timestamp` constructor with the ``tz`` argument now raises a ``ValueError`` (:issue:`23621`)
-- Removed :attr:`Series.base`, :attr:`Index.base`, :attr:`Categorical.base`, :attr:`Series.flags`, :attr:`Index.flags`, :attr:`PeriodArray.flags`, :attr:`Series.strides`, :attr:`Index.strides`, :attr:`Series.itemsize`, :attr:`Index.itemsize`, :attr:`Series.data`, :attr:`Index.data` (:issue:`20721`)
+- Removed ``Series.base``, ``Index.base``, ``Categorical.base``, ``Series.flags``, ``Index.flags``, ``PeriodArray.flags``, ``Series.strides``, ``Index.strides``, ``Series.itemsize``, ``Index.itemsize``, ``Series.data``, ``Index.data`` (:issue:`20721`)
- Changed :meth:`Timedelta.resolution` to match the behavior of the standard library ``datetime.timedelta.resolution``, for the old behavior, use :meth:`Timedelta.resolution_string` (:issue:`26839`)
-- Removed :attr:`Timestamp.weekday_name`, :attr:`DatetimeIndex.weekday_name`, and :attr:`Series.dt.weekday_name` (:issue:`18164`)
+- Removed ``Timestamp.weekday_name``, ``DatetimeIndex.weekday_name``, and ``Series.dt.weekday_name`` (:issue:`18164`)
- Removed the previously deprecated keyword "errors" in :meth:`Timestamp.tz_localize`, :meth:`DatetimeIndex.tz_localize`, and :meth:`Series.tz_localize` (:issue:`22644`)
- Changed the default "ordered" argument in :class:`CategoricalDtype` from ``None`` to ``False`` (:issue:`26336`)
- :meth:`Series.set_axis` and :meth:`DataFrame.set_axis` now require "labels" as the first argument and "axis" as an optional named parameter (:issue:`30089`)
-- Removed :func:`to_msgpack`, :func:`read_msgpack`, :meth:`DataFrame.to_msgpack`, :meth:`Series.to_msgpack` (:issue:`27103`)
-- Removed :meth:`Series.compress` (:issue:`21930`)
+- Removed ``to_msgpack``, ``read_msgpack``, ``DataFrame.to_msgpack``, ``Series.to_msgpack`` (:issue:`27103`)
+- Removed ``Series.compress`` (:issue:`21930`)
- Removed the previously deprecated keyword "fill_value" from :meth:`Categorical.fillna`, use "value" instead (:issue:`19269`)
- Removed the previously deprecated keyword "data" from :func:`andrews_curves`, use "frame" instead (:issue:`6956`)
- Removed the previously deprecated keyword "data" from :func:`parallel_coordinates`, use "frame" instead (:issue:`6956`)
@@ -792,7 +792,7 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
.. ---------------------------------------------------------------------------
-.. _whatsnew_1000.performance:
+.. _whatsnew_100.performance:
Performance improvements
~~~~~~~~~~~~~~~~~~~~~~~~
@@ -814,7 +814,7 @@ Performance improvements
.. ---------------------------------------------------------------------------
-.. _whatsnew_1000.bug_fixes:
+.. _whatsnew_100.bug_fixes:
Bug fixes
~~~~~~~~~
@@ -914,7 +914,7 @@ Conversion
Strings
^^^^^^^
-- Calling :meth:`Series.str.isalnum` (and other "ismethods") on an empty Series would return an object dtype instead of bool (:issue:`29624`)
+- Calling :meth:`Series.str.isalnum` (and other "ismethods") on an empty ``Series`` would return an ``object`` dtype instead of ``bool`` (:issue:`29624`)
-
@@ -937,7 +937,7 @@ Indexing
- Bug in :meth:`Float64Index.astype` where ``np.inf`` was not handled properly when casting to an integer dtype (:issue:`28475`)
- :meth:`Index.union` could fail when the left contained duplicates (:issue:`28257`)
- Bug when indexing with ``.loc`` where the index was a :class:`CategoricalIndex` with non-string categories didn't work (:issue:`17569`, :issue:`30225`)
-- :meth:`Index.get_indexer_non_unique` could fail with `TypeError` in some cases, such as when searching for ints in a string index (:issue:`28257`)
+- :meth:`Index.get_indexer_non_unique` could fail with ``TypeError`` in some cases, such as when searching for ints in a string index (:issue:`28257`)
- Bug in :meth:`Float64Index.get_loc` incorrectly raising ``TypeError`` instead of ``KeyError`` (:issue:`29189`)
- :meth:`MultiIndex.get_loc` can't find missing values when input includes missing values (:issue:`19132`)
- Bug in :meth:`Series.__setitem__` incorrectly assigning values with boolean indexer when the length of new data matches the number of ``True`` values and new data is not a ``Series`` or an ``np.array`` (:issue:`30567`)
@@ -985,17 +985,16 @@ Plotting
^^^^^^^^
- Bug in :meth:`Series.plot` not able to plot boolean values (:issue:`23719`)
--
- Bug in :meth:`DataFrame.plot` not able to plot when no rows (:issue:`27758`)
- Bug in :meth:`DataFrame.plot` producing incorrect legend markers when plotting multiple series on the same axis (:issue:`18222`)
- Bug in :meth:`DataFrame.plot` when ``kind='box'`` and data contains datetime or timedelta data. These types are now automatically dropped (:issue:`22799`)
- Bug in :meth:`DataFrame.plot.line` and :meth:`DataFrame.plot.area` produce wrong xlim in x-axis (:issue:`27686`, :issue:`25160`, :issue:`24784`)
-- Bug where :meth:`DataFrame.boxplot` would not accept a `color` parameter like `DataFrame.plot.box` (:issue:`26214`)
+- Bug where :meth:`DataFrame.boxplot` would not accept a ``color`` parameter like :meth:`DataFrame.plot.box` (:issue:`26214`)
- Bug in the ``xticks`` argument being ignored for :meth:`DataFrame.plot.bar` (:issue:`14119`)
- :func:`set_option` now validates that the plot backend provided to ``'plotting.backend'`` implements the backend when the option is set, rather than when a plot is created (:issue:`28163`)
- :meth:`DataFrame.plot` now allow a ``backend`` keyword argument to allow changing between backends in one session (:issue:`28619`).
- Bug in color validation incorrectly raising for non-color styles (:issue:`29122`).
-- Allow :meth: `DataFrame.plot.scatter` to plot ``objects`` and ``datetime`` type data (:issue:`18755`, :issue:`30391`)
+- Allow :meth:`DataFrame.plot.scatter` to plot ``objects`` and ``datetime`` type data (:issue:`18755`, :issue:`30391`)
- Bug in :meth:`DataFrame.hist`, ``xrot=0`` does not work with ``by`` and subplots (:issue:`30288`).
Groupby/resample/rolling
@@ -1003,7 +1002,7 @@ Groupby/resample/rolling
- Bug in :meth:`core.groupby.DataFrameGroupBy.apply` only showing output from a single group when function returns an :class:`Index` (:issue:`28652`)
- Bug in :meth:`DataFrame.groupby` with multiple groups where an ``IndexError`` would be raised if any group contained all NA values (:issue:`20519`)
-- Bug in :meth:`pandas.core.resample.Resampler.size` and :meth:`pandas.core.resample.Resampler.count` returning wrong dtype when used with an empty series or dataframe (:issue:`28427`)
+- Bug in :meth:`pandas.core.resample.Resampler.size` and :meth:`pandas.core.resample.Resampler.count` returning wrong dtype when used with an empty :class:`Series` or :class:`DataFrame` (:issue:`28427`)
- Bug in :meth:`DataFrame.rolling` not allowing for rolling over datetimes when ``axis=1`` (:issue:`28192`)
- Bug in :meth:`DataFrame.rolling` not allowing rolling over multi-index levels (:issue:`15584`).
- Bug in :meth:`DataFrame.rolling` not allowing rolling on monotonic decreasing time indexes (:issue:`19248`).
@@ -1032,7 +1031,7 @@ Reshaping
- Fix to ensure all int dtypes can be used in :func:`merge_asof` when using a tolerance value. Previously every non-int64 type would raise an erroneous ``MergeError`` (:issue:`28870`).
- Better error message in :func:`get_dummies` when `columns` isn't a list-like value (:issue:`28383`)
- Bug in :meth:`Index.join` that caused infinite recursion error for mismatched ``MultiIndex`` name orders. (:issue:`25760`, :issue:`28956`)
-- Bug :meth:`Series.pct_change` where supplying an anchored frequency would throw a ValueError (:issue:`28664`)
+- Bug :meth:`Series.pct_change` where supplying an anchored frequency would throw a ``ValueError`` (:issue:`28664`)
- Bug where :meth:`DataFrame.equals` returned True incorrectly in some cases when two DataFrames had the same columns in different orders (:issue:`28839`)
- Bug in :meth:`DataFrame.replace` that caused non-numeric replacer's dtype not respected (:issue:`26632`)
- Bug in :func:`melt` where supplying mixed strings and numeric values for ``id_vars`` or ``value_vars`` would incorrectly raise a ``ValueError`` (:issue:`29718`)
@@ -1051,7 +1050,7 @@ ExtensionArray
- Bug in :class:`arrays.PandasArray` when setting a scalar string (:issue:`28118`, :issue:`28150`).
- Bug where nullable integers could not be compared to strings (:issue:`28930`)
-- Bug where :class:`DataFrame` constructor raised ValueError with list-like data and ``dtype`` specified (:issue:`30280`)
+- Bug where :class:`DataFrame` constructor raised ``ValueError`` with list-like data and ``dtype`` specified (:issue:`30280`)
Other
@@ -1067,17 +1066,17 @@ Other
- Bug in :meth:`DataFrame.append` that raised ``IndexError`` when appending with empty list (:issue:`28769`)
- Fix :class:`AbstractHolidayCalendar` to return correct results for
years after 2030 (now goes up to 2200) (:issue:`27790`)
-- Fixed :class:`IntegerArray` returning ``inf`` rather than ``NaN`` for operations dividing by 0 (:issue:`27398`)
-- Fixed ``pow`` operations for :class:`IntegerArray` when the other value is ``0`` or ``1`` (:issue:`29997`)
+- Fixed :class:`~arrays.IntegerArray` returning ``inf`` rather than ``NaN`` for operations dividing by ``0`` (:issue:`27398`)
+- Fixed ``pow`` operations for :class:`~arrays.IntegerArray` when the other value is ``0`` or ``1`` (:issue:`29997`)
- Bug in :meth:`Series.count` raises if use_inf_as_na is enabled (:issue:`29478`)
- Bug in :class:`Index` where a non-hashable name could be set without raising ``TypeError`` (:issue:`29069`)
- Bug in :class:`DataFrame` constructor when passing a 2D ``ndarray`` and an extension dtype (:issue:`12513`)
-- Bug in :meth:`DaataFrame.to_csv` when supplied a series with a ``dtype="string"`` and a ``na_rep``, the ``na_rep`` was being truncated to 2 characters. (:issue:`29975`)
+- Bug in :meth:`DataFrame.to_csv` when supplied a series with a ``dtype="string"`` and a ``na_rep``, the ``na_rep`` was being truncated to 2 characters. (:issue:`29975`)
- Bug where :meth:`DataFrame.itertuples` would incorrectly determine whether or not namedtuples could be used for dataframes of 255 columns (:issue:`28282`)
.. ---------------------------------------------------------------------------
-.. _whatsnew_1000.contributors:
+.. _whatsnew_100.contributors:
Contributors
~~~~~~~~~~~~
| Some small fixes I noticed reading over the whatsnew. | https://api.github.com/repos/pandas-dev/pandas/pulls/30836 | 2020-01-09T02:05:16Z | 2020-01-09T09:18:58Z | 2020-01-09T09:18:58Z | 2020-01-09T16:34:17Z |
REF: get_value do less inside try | diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 9db30ce710c0d..dcc28446f50e5 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -657,7 +657,7 @@ def get_value(self, series, key):
return series.take(locs)
try:
- return com.maybe_box(self, Index.get_value(self, series, key), series, key)
+ value = Index.get_value(self, series, key)
except KeyError:
try:
loc = self._get_string_slice(key)
@@ -669,6 +669,8 @@ def get_value(self, series, key):
return self.get_value_maybe_box(series, key)
except (TypeError, ValueError, KeyError):
raise KeyError(key)
+ else:
+ return com.maybe_box(self, value, series, key)
def get_value_maybe_box(self, series, key):
# needed to localize naive datetimes
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index d34ac1a541d27..5815d4a8ecb16 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -509,7 +509,7 @@ def get_value(self, series, key):
"""
s = com.values_from_object(series)
try:
- return com.maybe_box(self, super().get_value(s, key), series, key)
+ value = super().get_value(s, key)
except (KeyError, IndexError):
if isinstance(key, str):
asdt, parsed, reso = parse_time_string(key, self.freq)
@@ -541,6 +541,8 @@ def get_value(self, series, key):
period = Period(key, self.freq)
key = period.value if isna(period) else period.ordinal
return com.maybe_box(self, self._int64index.get_value(s, key), series, key)
+ else:
+ return com.maybe_box(self, value, series, key)
@Appender(_index_shared_docs["get_indexer"] % _index_doc_kwargs)
def get_indexer(self, target, method=None, limit=None, tolerance=None):
| Separating out mostly-cosmetic bits from other get_value work | https://api.github.com/repos/pandas-dev/pandas/pulls/30835 | 2020-01-09T01:43:34Z | 2020-01-09T02:33:00Z | 2020-01-09T02:33:00Z | 2020-01-09T05:03:51Z |
DOC: Fix indentation in docstring example | diff --git a/doc/source/development/contributing_docstring.rst b/doc/source/development/contributing_docstring.rst
index d897889ed9eff..cb32f0e1ee475 100644
--- a/doc/source/development/contributing_docstring.rst
+++ b/doc/source/development/contributing_docstring.rst
@@ -22,39 +22,39 @@ Next example gives an idea on how a docstring looks like:
.. code-block:: python
def add(num1, num2):
- """
- 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.
-
- Parameters
- ----------
- num1 : int
- First number to add
- num2 : int
- Second number to add
-
- Returns
- -------
- int
- The sum of `num1` and `num2`
-
- See Also
- --------
- subtract : Subtract one integer from another
-
- Examples
- --------
- >>> add(2, 2)
- 4
- >>> add(25, 0)
- 25
- >>> add(10, -10)
- 0
- """
- return num1 + num2
+ """
+ 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.
+
+ Parameters
+ ----------
+ num1 : int
+ First number to add
+ num2 : int
+ Second number to add
+
+ Returns
+ -------
+ int
+ The sum of `num1` and `num2`
+
+ See Also
+ --------
+ subtract : Subtract one integer from another
+
+ Examples
+ --------
+ >>> add(2, 2)
+ 4
+ >>> add(25, 0)
+ 25
+ >>> add(10, -10)
+ 0
+ """
+ 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.
| - [x] closes #30830
- [ ] 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/30833 | 2020-01-09T01:19:40Z | 2020-01-09T15:52:31Z | 2020-01-09T15:52:31Z | 2020-01-10T20:42:33Z |
CLN: Removed "# noqa: F401" comments | diff --git a/pandas/api/extensions/__init__.py b/pandas/api/extensions/__init__.py
index a7e84bb046e61..3019dd0e9b371 100644
--- a/pandas/api/extensions/__init__.py
+++ b/pandas/api/extensions/__init__.py
@@ -1,15 +1,27 @@
-"""Public API for extending pandas objects."""
-from pandas._libs.lib import no_default # noqa: F401
+"""
+Public API for extending pandas objects.
+"""
-from pandas.core.dtypes.dtypes import ( # noqa: F401
- ExtensionDtype,
- register_extension_dtype,
-)
+from pandas._libs.lib import no_default
+
+from pandas.core.dtypes.dtypes import ExtensionDtype, register_extension_dtype
-from pandas.core.accessor import ( # noqa: F401
+from pandas.core.accessor import (
register_dataframe_accessor,
register_index_accessor,
register_series_accessor,
)
-from pandas.core.algorithms import take # noqa: F401
-from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin # noqa: F401
+from pandas.core.algorithms import take
+from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin
+
+__all__ = [
+ "no_default",
+ "ExtensionDtype",
+ "register_extension_dtype",
+ "register_dataframe_accessor",
+ "register_index_accessor",
+ "register_series_accessor",
+ "take",
+ "ExtensionArray",
+ "ExtensionScalarOpsMixin",
+]
diff --git a/pandas/api/indexers/__init__.py b/pandas/api/indexers/__init__.py
index 64383d8ecbd24..10654eb0888ee 100644
--- a/pandas/api/indexers/__init__.py
+++ b/pandas/api/indexers/__init__.py
@@ -1,3 +1,8 @@
-"""Public API for Rolling Window Indexers"""
-from pandas.core.indexers import check_bool_array_indexer # noqa: F401
-from pandas.core.window.indexers import BaseIndexer # noqa: F401
+"""
+Public API for Rolling Window Indexers.
+"""
+
+from pandas.core.indexers import check_bool_array_indexer
+from pandas.core.window.indexers import BaseIndexer
+
+__all__ = ["check_bool_array_indexer", "BaseIndexer"]
diff --git a/pandas/api/types/__init__.py b/pandas/api/types/__init__.py
index f32e1abe28cc1..3495b493707c2 100644
--- a/pandas/api/types/__init__.py
+++ b/pandas/api/types/__init__.py
@@ -1,12 +1,23 @@
-""" public toolkit API """
+"""
+Public toolkit API.
+"""
-from pandas._libs.lib import infer_dtype # noqa: F401
+from pandas._libs.lib import infer_dtype
from pandas.core.dtypes.api import * # noqa: F403, F401
-from pandas.core.dtypes.concat import union_categoricals # noqa: F401
-from pandas.core.dtypes.dtypes import ( # noqa: F401
+from pandas.core.dtypes.concat import union_categoricals
+from pandas.core.dtypes.dtypes import (
CategoricalDtype,
DatetimeTZDtype,
IntervalDtype,
PeriodDtype,
)
+
+__all__ = [
+ "infer_dtype",
+ "union_categoricals",
+ "CategoricalDtype",
+ "DatetimeTZDtype",
+ "IntervalDtype",
+ "PeriodDtype",
+]
diff --git a/pandas/core/arrays/__init__.py b/pandas/core/arrays/__init__.py
index ad9a26043e5ce..bf3469924a700 100644
--- a/pandas/core/arrays/__init__.py
+++ b/pandas/core/arrays/__init__.py
@@ -1,16 +1,36 @@
-from pandas.core.arrays.base import ( # noqa: F401
+from pandas.core.arrays.base import (
ExtensionArray,
ExtensionOpsMixin,
ExtensionScalarOpsMixin,
try_cast_to_ea,
)
-from pandas.core.arrays.boolean import BooleanArray # noqa: F401
-from pandas.core.arrays.categorical import Categorical # noqa: F401
-from pandas.core.arrays.datetimes import DatetimeArray # noqa: F401
-from pandas.core.arrays.integer import IntegerArray, integer_array # noqa: F401
-from pandas.core.arrays.interval import IntervalArray # noqa: F401
-from pandas.core.arrays.numpy_ import PandasArray, PandasDtype # noqa: F401
-from pandas.core.arrays.period import PeriodArray, period_array # noqa: F401
-from pandas.core.arrays.sparse import SparseArray # noqa: F401
-from pandas.core.arrays.string_ import StringArray # noqa: F401
-from pandas.core.arrays.timedeltas import TimedeltaArray # noqa: F401
+from pandas.core.arrays.boolean import BooleanArray
+from pandas.core.arrays.categorical import Categorical
+from pandas.core.arrays.datetimes import DatetimeArray
+from pandas.core.arrays.integer import IntegerArray, integer_array
+from pandas.core.arrays.interval import IntervalArray
+from pandas.core.arrays.numpy_ import PandasArray, PandasDtype
+from pandas.core.arrays.period import PeriodArray, period_array
+from pandas.core.arrays.sparse import SparseArray
+from pandas.core.arrays.string_ import StringArray
+from pandas.core.arrays.timedeltas import TimedeltaArray
+
+__all__ = [
+ "ExtensionArray",
+ "ExtensionOpsMixin",
+ "ExtensionScalarOpsMixin",
+ "try_cast_to_ea",
+ "BooleanArray",
+ "Categorical",
+ "DatetimeArray",
+ "IntegerArray",
+ "integer_array",
+ "IntervalArray",
+ "PandasArray",
+ "PandasDtype",
+ "PeriodArray",
+ "period_array",
+ "SparseArray",
+ "StringArray",
+ "TimedeltaArray",
+]
diff --git a/pandas/core/groupby/__init__.py b/pandas/core/groupby/__init__.py
index 252f20ed40068..0c5d2658978b4 100644
--- a/pandas/core/groupby/__init__.py
+++ b/pandas/core/groupby/__init__.py
@@ -1,7 +1,11 @@
-from pandas.core.groupby.generic import ( # noqa: F401
- DataFrameGroupBy,
- NamedAgg,
- SeriesGroupBy,
-)
-from pandas.core.groupby.groupby import GroupBy # noqa: F401
-from pandas.core.groupby.grouper import Grouper # noqa: F401
+from pandas.core.groupby.generic import DataFrameGroupBy, NamedAgg, SeriesGroupBy
+from pandas.core.groupby.groupby import GroupBy
+from pandas.core.groupby.grouper import Grouper
+
+__all__ = [
+ "DataFrameGroupBy",
+ "NamedAgg",
+ "SeriesGroupBy",
+ "GroupBy",
+ "Grouper",
+]
diff --git a/pandas/core/internals/__init__.py b/pandas/core/internals/__init__.py
index 91706bc283c25..37a3405554745 100644
--- a/pandas/core/internals/__init__.py
+++ b/pandas/core/internals/__init__.py
@@ -1,4 +1,4 @@
-from pandas.core.internals.blocks import ( # noqa: F401;; io.pytables, io.packers
+from pandas.core.internals.blocks import ( # io.pytables, io.packers
Block,
BoolBlock,
CategoricalBlock,
@@ -10,11 +10,11 @@
IntBlock,
ObjectBlock,
TimeDeltaBlock,
+ _block_shape,
_safe_reshape,
make_block,
- _block_shape,
)
-from pandas.core.internals.managers import ( # noqa: F401
+from pandas.core.internals.managers import (
BlockManager,
SingleBlockManager,
_transform_index,
@@ -22,3 +22,26 @@
create_block_manager_from_arrays,
create_block_manager_from_blocks,
)
+
+__all__ = [
+ "Block",
+ "BoolBlock",
+ "CategoricalBlock",
+ "ComplexBlock",
+ "DatetimeBlock",
+ "DatetimeTZBlock",
+ "ExtensionBlock",
+ "FloatBlock",
+ "IntBlock",
+ "ObjectBlock",
+ "TimeDeltaBlock",
+ "_safe_reshape",
+ "make_block",
+ "_block_shape",
+ "BlockManager",
+ "SingleBlockManager",
+ "_transform_index",
+ "concatenate_block_managers",
+ "create_block_manager_from_arrays",
+ "create_block_manager_from_blocks",
+]
| Implemented ```__all__``` for each changed file
- [x] ref https://github.com/pandas-dev/pandas/pull/30828#discussion_r364500688
- [ ] 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/30832 | 2020-01-09T01:13:40Z | 2020-01-09T02:39:51Z | 2020-01-09T02:39:51Z | 2020-01-10T20:43:01Z |
BUG: TimedeltaIndex.searchsorted accepting invalid types/dtypes | diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index d1d8db0746cf8..a94e19d99c867 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -357,11 +357,25 @@ def _partial_td_slice(self, key):
@Appender(_shared_docs["searchsorted"])
def searchsorted(self, value, side="left", sorter=None):
if isinstance(value, (np.ndarray, Index)):
- value = np.array(value, dtype=_TD_DTYPE, copy=False)
- else:
- value = Timedelta(value).asm8.view(_TD_DTYPE)
+ if not type(self._data)._is_recognized_dtype(value):
+ raise TypeError(
+ "searchsorted requires compatible dtype or scalar, "
+ f"not {type(value).__name__}"
+ )
+ value = type(self._data)(value)
+ self._data._check_compatible_with(value)
+
+ elif isinstance(value, self._data._recognized_scalars):
+ self._data._check_compatible_with(value)
+ value = self._data._scalar_type(value)
+
+ elif not isinstance(value, TimedeltaArray):
+ raise TypeError(
+ "searchsorted requires compatible dtype or scalar, "
+ f"not {type(value).__name__}"
+ )
- return self.values.searchsorted(value, side=side, sorter=sorter)
+ return self._data.searchsorted(value, side=side, sorter=sorter)
def is_type_compatible(self, typ) -> bool:
return typ == self.inferred_type or typ == "timedelta"
diff --git a/pandas/tests/arrays/test_timedeltas.py b/pandas/tests/arrays/test_timedeltas.py
index 667fe36ddf572..62cb4766171a4 100644
--- a/pandas/tests/arrays/test_timedeltas.py
+++ b/pandas/tests/arrays/test_timedeltas.py
@@ -140,6 +140,42 @@ def test_setitem_objects(self, obj):
arr[0] = obj
assert arr[0] == pd.Timedelta(seconds=1)
+ @pytest.mark.parametrize(
+ "other",
+ [
+ 1,
+ np.int64(1),
+ 1.0,
+ np.datetime64("NaT"),
+ pd.Timestamp.now(),
+ "invalid",
+ np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9,
+ (np.arange(10) * 24 * 3600 * 10 ** 9).view("datetime64[ns]"),
+ pd.Timestamp.now().to_period("D"),
+ ],
+ )
+ @pytest.mark.parametrize(
+ "index",
+ [
+ True,
+ pytest.param(
+ False,
+ marks=pytest.mark.xfail(
+ reason="Raises ValueError instead of TypeError", raises=ValueError
+ ),
+ ),
+ ],
+ )
+ def test_searchsorted_invalid_types(self, other, index):
+ data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+ arr = TimedeltaArray(data, freq="D")
+ if index:
+ arr = pd.Index(arr)
+
+ msg = "searchsorted requires compatible dtype or scalar"
+ with pytest.raises(TypeError, match=msg):
+ arr.searchsorted(other)
+
class TestReductions:
@pytest.mark.parametrize("name", ["sum", "std", "min", "max", "median"])
| TimedeltaIndex analogue to #30826. | https://api.github.com/repos/pandas-dev/pandas/pulls/30831 | 2020-01-09T01:07:04Z | 2020-01-09T02:37:24Z | 2020-01-09T02:37:24Z | 2020-01-09T05:11:15Z |
DOC: Added a single '-' | diff --git a/pandas/core/arrays/period.py b/pandas/core/arrays/period.py
index d1c574adeb236..db84a522f55b1 100644
--- a/pandas/core/arrays/period.py
+++ b/pandas/core/arrays/period.py
@@ -743,7 +743,7 @@ def raise_on_incompatible(left, right):
right : None, DateOffset, Period, ndarray, or timedelta-like
Returns
- ------
+ -------
IncompatibleFrequency
Exception to be raised by the caller.
"""
| Feels weird to open a PR just for that, but I must get this fixed ;) | https://api.github.com/repos/pandas-dev/pandas/pulls/30829 | 2020-01-09T00:03:19Z | 2020-01-09T00:42:47Z | 2020-01-09T00:42:47Z | 2020-01-09T01:20:21Z |
STY: absolute imports in __init__ files | diff --git a/pandas/api/__init__.py b/pandas/api/__init__.py
index d0a26864a1102..bebbb38b4aefa 100644
--- a/pandas/api/__init__.py
+++ b/pandas/api/__init__.py
@@ -1,2 +1,2 @@
""" public toolkit API """
-from . import extensions, indexers, types # noqa
+from pandas.api import extensions, indexers, types # noqa
diff --git a/pandas/core/arrays/__init__.py b/pandas/core/arrays/__init__.py
index df26cd94b5ed9..ad9a26043e5ce 100644
--- a/pandas/core/arrays/__init__.py
+++ b/pandas/core/arrays/__init__.py
@@ -1,16 +1,16 @@
-from .base import ( # noqa: F401
+from pandas.core.arrays.base import ( # noqa: F401
ExtensionArray,
ExtensionOpsMixin,
ExtensionScalarOpsMixin,
try_cast_to_ea,
)
-from .boolean import BooleanArray # noqa: F401
-from .categorical import Categorical # noqa: F401
-from .datetimes import DatetimeArray # noqa: F401
-from .integer import IntegerArray, integer_array # noqa: F401
-from .interval import IntervalArray # noqa: F401
-from .numpy_ import PandasArray, PandasDtype # noqa: F401
-from .period import PeriodArray, period_array # noqa: F401
-from .sparse import SparseArray # noqa: F401
-from .string_ import StringArray # noqa: F401
-from .timedeltas import TimedeltaArray # noqa: F401
+from pandas.core.arrays.boolean import BooleanArray # noqa: F401
+from pandas.core.arrays.categorical import Categorical # noqa: F401
+from pandas.core.arrays.datetimes import DatetimeArray # noqa: F401
+from pandas.core.arrays.integer import IntegerArray, integer_array # noqa: F401
+from pandas.core.arrays.interval import IntervalArray # noqa: F401
+from pandas.core.arrays.numpy_ import PandasArray, PandasDtype # noqa: F401
+from pandas.core.arrays.period import PeriodArray, period_array # noqa: F401
+from pandas.core.arrays.sparse import SparseArray # noqa: F401
+from pandas.core.arrays.string_ import StringArray # noqa: F401
+from pandas.core.arrays.timedeltas import TimedeltaArray # noqa: F401
diff --git a/pandas/core/arrays/sparse/__init__.py b/pandas/core/arrays/sparse/__init__.py
index 75f3819fb19fd..e928db499a771 100644
--- a/pandas/core/arrays/sparse/__init__.py
+++ b/pandas/core/arrays/sparse/__init__.py
@@ -1,5 +1,10 @@
# flake8: noqa: F401
-from .accessor import SparseAccessor, SparseFrameAccessor
-from .array import BlockIndex, IntIndex, SparseArray, _make_index
-from .dtype import SparseDtype
+from pandas.core.arrays.sparse.accessor import SparseAccessor, SparseFrameAccessor
+from pandas.core.arrays.sparse.array import (
+ BlockIndex,
+ IntIndex,
+ SparseArray,
+ _make_index,
+)
+from pandas.core.arrays.sparse.dtype import SparseDtype
diff --git a/pandas/core/internals/__init__.py b/pandas/core/internals/__init__.py
index 8ac0df2fa4e0a..91706bc283c25 100644
--- a/pandas/core/internals/__init__.py
+++ b/pandas/core/internals/__init__.py
@@ -1,4 +1,4 @@
-from .blocks import ( # noqa: F401
+from pandas.core.internals.blocks import ( # noqa: F401;; io.pytables, io.packers
Block,
BoolBlock,
CategoricalBlock,
@@ -10,19 +10,15 @@
IntBlock,
ObjectBlock,
TimeDeltaBlock,
+ _safe_reshape,
+ make_block,
+ _block_shape,
)
-from .managers import ( # noqa: F401
+from pandas.core.internals.managers import ( # noqa: F401
BlockManager,
SingleBlockManager,
- create_block_manager_from_arrays,
- create_block_manager_from_blocks,
-)
-
-from .blocks import _safe_reshape # noqa: F401; io.packers
-from .blocks import make_block # noqa: F401; io.pytables, io.packers
-from .managers import ( # noqa: F401; reshape.concat, reshape.merge
_transform_index,
concatenate_block_managers,
+ create_block_manager_from_arrays,
+ create_block_manager_from_blocks,
)
-
-from .blocks import _block_shape # noqa:F401; io.pytables
diff --git a/pandas/io/sas/__init__.py b/pandas/io/sas/__init__.py
index fa6b29a1a3fcc..8f81352e6aecb 100644
--- a/pandas/io/sas/__init__.py
+++ b/pandas/io/sas/__init__.py
@@ -1 +1 @@
-from .sasreader import read_sas # noqa
+from pandas.io.sas.sasreader import read_sas # noqa
| - [ ] 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/30828 | 2020-01-08T23:30:57Z | 2020-01-09T00:06:59Z | 2020-01-09T00:06:59Z | 2020-01-09T13:38:33Z |
STY: absolute imports | diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index 524e3fcf309cb..a67d31344ff55 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -46,6 +46,11 @@
from pandas.core.accessor import PandasDelegate, delegate_names
import pandas.core.algorithms as algorithms
from pandas.core.algorithms import _get_data_algo, factorize, take, take_1d, unique1d
+from pandas.core.arrays.base import (
+ ExtensionArray,
+ _extension_array_shared_docs,
+ try_cast_to_ea,
+)
from pandas.core.base import NoNewAttributesMixin, PandasObject, _shared_docs
import pandas.core.common as com
from pandas.core.construction import array, extract_array, sanitize_array
@@ -56,8 +61,6 @@
from pandas.io.formats import console
-from .base import ExtensionArray, _extension_array_shared_docs, try_cast_to_ea
-
def _cat_compare_op(op):
opname = f"__{op.__name__}__"
diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 4a37b4f0f29ba..06c1338dbf5ab 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -40,6 +40,7 @@
from pandas.core import missing, nanops, ops
from pandas.core.algorithms import checked_add_with_arr, take, unique1d, value_counts
+from pandas.core.arrays.base import ExtensionArray, ExtensionOpsMixin
import pandas.core.common as com
from pandas.core.indexers import check_bool_array_indexer
from pandas.core.ops.common import unpack_zerodim_and_defer
@@ -48,8 +49,6 @@
from pandas.tseries import frequencies
from pandas.tseries.offsets import DateOffset, Tick
-from .base import ExtensionArray, ExtensionOpsMixin
-
def _datetimelike_array_cmp(cls, op):
"""
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index 55499291d3f4a..3ad6e7cb3c176 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -17,13 +17,12 @@
from pandas import compat
from pandas.core import nanops
from pandas.core.algorithms import searchsorted, take, unique
+from pandas.core.arrays.base import ExtensionArray, ExtensionOpsMixin
import pandas.core.common as com
from pandas.core.construction import extract_array
from pandas.core.indexers import check_bool_array_indexer
from pandas.core.missing import backfill_1d, pad_1d
-from .base import ExtensionArray, ExtensionOpsMixin
-
class PandasDtype(ExtensionDtype):
"""
diff --git a/pandas/core/arrays/sparse/array.py b/pandas/core/arrays/sparse/array.py
index 9838cdfabbb95..95d6136a2dad6 100644
--- a/pandas/core/arrays/sparse/array.py
+++ b/pandas/core/arrays/sparse/array.py
@@ -39,6 +39,7 @@
import pandas.core.algorithms as algos
from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
+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
@@ -48,8 +49,6 @@
import pandas.io.formats.printing as printing
-from .dtype import SparseDtype
-
# ----------------------------------------------------------------------------
# Array
diff --git a/pandas/core/arrays/sparse/dtype.py b/pandas/core/arrays/sparse/dtype.py
index 55de41794b30e..6f15681cab87e 100644
--- a/pandas/core/arrays/sparse/dtype.py
+++ b/pandas/core/arrays/sparse/dtype.py
@@ -175,7 +175,7 @@ def construct_array_type(cls):
-------
type
"""
- from .array import SparseArray
+ from pandas.core.arrays.sparse.array import SparseArray
return SparseArray
diff --git a/pandas/core/arrays/timedeltas.py b/pandas/core/arrays/timedeltas.py
index fc92521c97dae..c34d14f15075c 100644
--- a/pandas/core/arrays/timedeltas.py
+++ b/pandas/core/arrays/timedeltas.py
@@ -37,13 +37,12 @@
from pandas.core import nanops
from pandas.core.algorithms import checked_add_with_arr
+from pandas.core.arrays import datetimelike as dtl
import pandas.core.common as com
from pandas.tseries.frequencies import to_offset
from pandas.tseries.offsets import Tick
-from . import datetimelike as dtl
-
_BAD_DTYPE = "dtype {dtype} cannot be converted to timedelta64[ns]"
diff --git a/pandas/core/dtypes/api.py b/pandas/core/dtypes/api.py
index cb0912cbcf880..051affd0af1f9 100644
--- a/pandas/core/dtypes/api.py
+++ b/pandas/core/dtypes/api.py
@@ -1,6 +1,6 @@
# flake8: noqa
-from .common import (
+from pandas.core.dtypes.common import (
is_array_like,
is_bool,
is_bool_dtype,
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 0579c97747bae..1dbdb8dbba48b 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -9,7 +9,7 @@
from pandas._libs.tslibs.timezones import tz_compare
from pandas.util._validators import validate_bool_kwarg
-from .common import (
+from pandas.core.dtypes.common import (
_INT64_DTYPE,
_NS_DTYPE,
_POSSIBLY_CAST_DTYPES,
@@ -42,8 +42,13 @@
is_unsigned_integer_dtype,
pandas_dtype,
)
-from .dtypes import DatetimeTZDtype, ExtensionDtype, IntervalDtype, PeriodDtype
-from .generic import (
+from pandas.core.dtypes.dtypes import (
+ DatetimeTZDtype,
+ ExtensionDtype,
+ IntervalDtype,
+ PeriodDtype,
+)
+from pandas.core.dtypes.generic import (
ABCDataFrame,
ABCDatetimeArray,
ABCDatetimeIndex,
@@ -51,8 +56,8 @@
ABCPeriodIndex,
ABCSeries,
)
-from .inference import is_list_like
-from .missing import isna, notna
+from pandas.core.dtypes.inference import is_list_like
+from pandas.core.dtypes.missing import isna, notna
_int8_max = np.iinfo(np.int8).max
_int16_max = np.iinfo(np.int16).max
diff --git a/pandas/core/dtypes/dtypes.py b/pandas/core/dtypes/dtypes.py
index eed4514baa817..c0eda37a5cb08 100644
--- a/pandas/core/dtypes/dtypes.py
+++ b/pandas/core/dtypes/dtypes.py
@@ -9,10 +9,9 @@
from pandas._libs.tslibs import NaT, Period, Timestamp, timezones
from pandas._typing import Ordered
+from pandas.core.dtypes.base import ExtensionDtype
from pandas.core.dtypes.generic import ABCCategoricalIndex, ABCDateOffset, ABCIndexClass
-
-from .base import ExtensionDtype
-from .inference import is_bool, is_list_like
+from pandas.core.dtypes.inference import is_bool, is_list_like
str_type = str
diff --git a/pandas/core/dtypes/missing.py b/pandas/core/dtypes/missing.py
index f7d61486ce8cd..fb579f2f58a57 100644
--- a/pandas/core/dtypes/missing.py
+++ b/pandas/core/dtypes/missing.py
@@ -9,7 +9,7 @@
import pandas._libs.missing as libmissing
from pandas._libs.tslibs import NaT, iNaT
-from .common import (
+from pandas.core.dtypes.common import (
_NS_DTYPE,
_TD_DTYPE,
ensure_object,
@@ -31,7 +31,7 @@
needs_i8_conversion,
pandas_dtype,
)
-from .generic import (
+from pandas.core.dtypes.generic import (
ABCDatetimeArray,
ABCExtensionArray,
ABCGeneric,
@@ -40,7 +40,7 @@
ABCSeries,
ABCTimedeltaArray,
)
-from .inference import is_list_like
+from pandas.core.dtypes.inference import is_list_like
isposinf_scalar = libmissing.isposinf_scalar
isneginf_scalar = libmissing.isneginf_scalar
diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index e7d3abf5611af..b02c0a08c93fa 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -277,11 +277,11 @@ def __new__(
cls, data=None, dtype=None, copy=False, name=None, tupleize_cols=True, **kwargs,
) -> "Index":
- from .range import RangeIndex
+ from pandas.core.indexes.range import RangeIndex
from pandas import PeriodIndex, DatetimeIndex, TimedeltaIndex
- from .numeric import Float64Index, Int64Index, UInt64Index
- from .interval import IntervalIndex
- from .category import CategoricalIndex
+ from pandas.core.indexes.numeric import Float64Index, Int64Index, UInt64Index
+ from pandas.core.indexes.interval import IntervalIndex
+ from pandas.core.indexes.category import CategoricalIndex
name = maybe_extract_name(name, data, cls)
@@ -408,7 +408,7 @@ def __new__(
if data and all(isinstance(e, tuple) for e in data):
# we must be all tuples, otherwise don't construct
# 10697
- from .multi import MultiIndex
+ from pandas.core.indexes.multi import MultiIndex
return MultiIndex.from_tuples(
data, names=name or kwargs.get("names")
@@ -679,7 +679,7 @@ def astype(self, dtype, copy=True):
return self.copy() if copy else self
elif is_categorical_dtype(dtype):
- from .category import CategoricalIndex
+ from pandas.core.indexes.category import CategoricalIndex
return CategoricalIndex(self.values, name=self.name, dtype=dtype, copy=copy)
@@ -1514,7 +1514,7 @@ def droplevel(self, level=0):
result._name = new_names[0]
return result
else:
- from .multi import MultiIndex
+ from pandas.core.indexes.multi import MultiIndex
return MultiIndex(
levels=new_levels,
@@ -3328,7 +3328,7 @@ def join(self, other, how="left", level=None, return_indexers=False, sort=False)
return join_index
def _join_multi(self, other, how, return_indexers=True):
- from .multi import MultiIndex
+ from pandas.core.indexes.multi import MultiIndex
from pandas.core.reshape.merge import _restore_dropped_levels_multijoin
# figure out join names
@@ -3435,7 +3435,7 @@ def _join_level(
MultiIndex will not be changed; otherwise, it will tie out
with `other`.
"""
- from .multi import MultiIndex
+ from pandas.core.indexes.multi import MultiIndex
def _get_leaf_sorter(labels):
"""
@@ -4519,7 +4519,7 @@ def map(self, mapper, na_action=None):
a MultiIndex will be returned.
"""
- from .multi import MultiIndex
+ from pandas.core.indexes.multi import MultiIndex
new_values = super()._map_values(mapper, na_action=na_action)
@@ -5240,7 +5240,7 @@ def ensure_index_from_sequences(sequences, names=None):
--------
ensure_index
"""
- from .multi import MultiIndex
+ from pandas.core.indexes.multi import MultiIndex
if len(sequences) == 1:
if names is not None:
@@ -5301,7 +5301,7 @@ def ensure_index(index_like, copy=False):
converted, all_arrays = lib.clean_index_list(index_like)
if len(converted) > 0 and all_arrays:
- from .multi import MultiIndex
+ from pandas.core.indexes.multi import MultiIndex
return MultiIndex.from_arrays(converted)
else:
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 53eef9d195af4..171e1d05259d1 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -40,18 +40,17 @@
from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
import pandas.core.indexes.base as ibase
from pandas.core.indexes.base import Index, _index_shared_docs
-from pandas.core.indexes.numeric import Int64Index
-from pandas.core.ops import get_op_result_name
-from pandas.core.tools.timedeltas import to_timedelta
-
-from pandas.tseries.frequencies import DateOffset, to_offset
-
-from .extension import (
+from pandas.core.indexes.extension import (
ExtensionIndex,
inherit_names,
make_wrapped_arith_op,
make_wrapped_comparison_op,
)
+from pandas.core.indexes.numeric import Int64Index
+from pandas.core.ops import get_op_result_name
+from pandas.core.tools.timedeltas import to_timedelta
+
+from pandas.tseries.frequencies import DateOffset, to_offset
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index 8c9f8a08b42ca..efa5aa3c036c9 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -10,10 +10,9 @@
from pandas.core.dtypes.generic import ABCSeries
from pandas.core.arrays import ExtensionArray
+from pandas.core.indexes.base import Index
from pandas.core.ops import get_op_result_name
-from .base import Index
-
def inherit_from_data(name: str, delegate, cache: bool = False):
"""
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 24e3289d37c41..caba33aa13e87 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -51,7 +51,11 @@
maybe_extract_name,
)
from pandas.core.indexes.datetimes import DatetimeIndex, date_range
-from pandas.core.indexes.extension import make_wrapped_comparison_op
+from pandas.core.indexes.extension import (
+ ExtensionIndex,
+ inherit_names,
+ make_wrapped_comparison_op,
+)
from pandas.core.indexes.multi import MultiIndex
from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
from pandas.core.ops import get_op_result_name
@@ -59,8 +63,6 @@
from pandas.tseries.frequencies import to_offset
from pandas.tseries.offsets import DateOffset
-from .extension import ExtensionIndex, inherit_names
-
_VALID_CLOSED = {"left", "right", "both", "neither"}
_index_doc_kwargs = dict(ibase._index_doc_kwargs)
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index ea8d4d2329d09..91e1a6137f79f 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -2931,7 +2931,7 @@ def get_locs(self, seq):
>>> mi.get_locs([[True, False, True], slice('e', 'f')]) # doctest: +SKIP
array([2], dtype=int64)
"""
- from .numeric import Int64Index
+ from pandas.core.indexes.numeric import Int64Index
# must be lexsorted to at least as many levels
true_slices = [i for (i, s) in enumerate(com.is_true_slices(seq)) if s]
diff --git a/pandas/core/internals/managers.py b/pandas/core/internals/managers.py
index d4425764f4dbd..066689b3e374e 100644
--- a/pandas/core/internals/managers.py
+++ b/pandas/core/internals/managers.py
@@ -34,10 +34,7 @@
from pandas.core.base import PandasObject
from pandas.core.indexers import maybe_convert_indices
from pandas.core.indexes.api import Index, MultiIndex, ensure_index
-
-from pandas.io.formats.printing import pprint_thing
-
-from .blocks import (
+from pandas.core.internals.blocks import (
Block,
CategoricalBlock,
DatetimeTZBlock,
@@ -49,13 +46,15 @@
get_block_type,
make_block,
)
-from .concat import ( # all for concatenate_block_managers
+from pandas.core.internals.concat import ( # all for concatenate_block_managers
combine_concat_plans,
concatenate_join_units,
get_mgr_concatenation_plan,
is_uniform_join_units,
)
+from pandas.io.formats.printing import pprint_thing
+
# TODO: flexible with index=None and/or items=None
diff --git a/pandas/core/ops/missing.py b/pandas/core/ops/missing.py
index 96a615d488bf2..5039ffab33fbd 100644
--- a/pandas/core/ops/missing.py
+++ b/pandas/core/ops/missing.py
@@ -27,7 +27,7 @@
from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype, is_scalar
-from .roperator import rdivmod, rfloordiv, rmod
+from pandas.core.ops.roperator import rdivmod, rfloordiv, rmod
def fill_zeros(result, x, y):
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index 7f2aab569ab71..baaa560d5d5f3 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -24,11 +24,10 @@
infer_compression,
stringify_path,
)
+from pandas.io.json._normalize import convert_to_line_delimits
+from pandas.io.json._table_schema import build_table_schema, parse_table_schema
from pandas.io.parsers import _validate_integer
-from ._normalize import convert_to_line_delimits
-from ._table_schema import build_table_schema, parse_table_schema
-
loads = json.loads
dumps = json.dumps
| - [ ] 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/30827 | 2020-01-08T23:07:17Z | 2020-01-08T23:49:21Z | 2020-01-08T23:49:21Z | 2020-01-08T23:50:56Z |
BUG: DTI.searchsorted accepting invalid types/dtypes | diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 88b841e7d4a88..1d7f84352d9da 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -359,7 +359,7 @@ def _convert_for_op(self, value):
Convert value to be insertable to ndarray.
"""
if self._has_same_tz(value):
- return _to_M8(value)
+ return Timestamp(value).asm8
raise ValueError("Passed item and index have different timezone")
# --------------------------------------------------------------------
@@ -892,11 +892,25 @@ def __getitem__(self, key):
@Appender(_shared_docs["searchsorted"])
def searchsorted(self, value, side="left", sorter=None):
if isinstance(value, (np.ndarray, Index)):
- value = np.array(value, dtype=_NS_DTYPE, copy=False)
- else:
- value = _to_M8(value, tz=self.tz)
+ if not type(self._data)._is_recognized_dtype(value):
+ raise TypeError(
+ "searchsorted requires compatible dtype or scalar, "
+ f"not {type(value).__name__}"
+ )
+ value = type(self._data)(value)
+ self._data._check_compatible_with(value)
+
+ elif isinstance(value, self._data._recognized_scalars):
+ self._data._check_compatible_with(value)
+ value = self._data._scalar_type(value)
+
+ elif not isinstance(value, DatetimeArray):
+ raise TypeError(
+ "searchsorted requires compatible dtype or scalar, "
+ f"not {type(value).__name__}"
+ )
- return self.values.searchsorted(value, side=side)
+ return self._data.searchsorted(value, side=side)
def is_type_compatible(self, typ) -> bool:
return typ == self.inferred_type or typ == "datetime"
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index b5f9c8957c2b8..5608ab5fbd9db 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -282,6 +282,77 @@ def test_array_interface(self):
)
tm.assert_numpy_array_equal(result, expected)
+ @pytest.mark.parametrize("index", [True, False])
+ def test_searchsorted_different_tz(self, index):
+ data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+ arr = DatetimeArray(data, freq="D").tz_localize("Asia/Tokyo")
+ if index:
+ arr = pd.Index(arr)
+
+ expected = arr.searchsorted(arr[2])
+ result = arr.searchsorted(arr[2].tz_convert("UTC"))
+ assert result == expected
+
+ expected = arr.searchsorted(arr[2:6])
+ result = arr.searchsorted(arr[2:6].tz_convert("UTC"))
+ tm.assert_equal(result, expected)
+
+ @pytest.mark.parametrize("index", [True, False])
+ def test_searchsorted_tzawareness_compat(self, index):
+ data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+ arr = DatetimeArray(data, freq="D")
+ if index:
+ arr = pd.Index(arr)
+
+ mismatch = arr.tz_localize("Asia/Tokyo")
+
+ msg = "Cannot compare tz-naive and tz-aware datetime-like objects"
+ with pytest.raises(TypeError, match=msg):
+ arr.searchsorted(mismatch[0])
+ with pytest.raises(TypeError, match=msg):
+ arr.searchsorted(mismatch)
+
+ with pytest.raises(TypeError, match=msg):
+ mismatch.searchsorted(arr[0])
+ with pytest.raises(TypeError, match=msg):
+ mismatch.searchsorted(arr)
+
+ @pytest.mark.parametrize(
+ "other",
+ [
+ 1,
+ np.int64(1),
+ 1.0,
+ np.timedelta64("NaT"),
+ pd.Timedelta(days=2),
+ "invalid",
+ np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9,
+ np.arange(10).view("timedelta64[ns]") * 24 * 3600 * 10 ** 9,
+ pd.Timestamp.now().to_period("D"),
+ ],
+ )
+ @pytest.mark.parametrize(
+ "index",
+ [
+ True,
+ pytest.param(
+ False,
+ marks=pytest.mark.xfail(
+ reason="Raises ValueError instead of TypeError", raises=ValueError
+ ),
+ ),
+ ],
+ )
+ def test_searchsorted_invalid_types(self, other, index):
+ data = np.arange(10, dtype="i8") * 24 * 3600 * 10 ** 9
+ arr = DatetimeArray(data, freq="D")
+ if index:
+ arr = pd.Index(arr)
+
+ msg = "searchsorted requires compatible dtype or scalar"
+ with pytest.raises(TypeError, match=msg):
+ arr.searchsorted(other)
+
class TestSequenceToDT64NS:
def test_tz_dtype_mismatch_raises(self):
| Analogous to #30763 which fixed the same issue for PeriodIndex. After this will be a PR to fix TimedeltaIndex, then one to move the fixes up to the EA methods (and share searchsorted). | https://api.github.com/repos/pandas-dev/pandas/pulls/30826 | 2020-01-08T22:14:47Z | 2020-01-09T02:36:12Z | 2020-01-09T02:36:12Z | 2020-01-09T05:10:31Z |
TST: Added 'match=' to some bare pytest.raises | diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index b2826ab139ed6..f55e2b98ee912 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -65,13 +65,16 @@ def test_df_numeric_cmp_dt64_raises(self):
# GH#8932, GH#22163
ts = pd.Timestamp.now()
df = pd.DataFrame({"x": range(5)})
- with pytest.raises(TypeError):
+
+ msg = "Invalid comparison between dtype=int64 and Timestamp"
+
+ with pytest.raises(TypeError, match=msg):
df > ts
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
df < ts
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
ts < df
- with pytest.raises(TypeError):
+ with pytest.raises(TypeError, match=msg):
ts > df
assert not (df == ts).any().any()
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 41b96cea1538c..64c4ad800f49d 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -66,8 +66,11 @@
class TestHDFStore:
def test_format_kwarg_in_constructor(self, setup_path):
# GH 13291
+
+ msg = "format is not a defined argument for HDFStore"
+
with ensure_clean_path(setup_path) as path:
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
HDFStore(path, format="table")
def test_context(self, setup_path):
@@ -203,21 +206,27 @@ def test_api(self, setup_path):
# Invalid.
df = tm.makeDataFrame()
- with pytest.raises(ValueError):
+ msg = "Can only append to Tables"
+
+ with pytest.raises(ValueError, match=msg):
df.to_hdf(path, "df", append=True, format="f")
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
df.to_hdf(path, "df", append=True, format="fixed")
- with pytest.raises(TypeError):
+ msg = r"invalid HDFStore format specified \[foo\]"
+
+ with pytest.raises(TypeError, match=msg):
df.to_hdf(path, "df", append=True, format="foo")
- with pytest.raises(TypeError):
- df.to_hdf(path, "df", append=False, format="bar")
+ with pytest.raises(TypeError, match=msg):
+ df.to_hdf(path, "df", append=False, format="foo")
# File path doesn't exist
path = ""
- with pytest.raises(FileNotFoundError):
+ msg = f"File {path} does not exist"
+
+ with pytest.raises(FileNotFoundError, match=msg):
read_hdf(path, "df")
def test_api_default_format(self, setup_path):
@@ -230,7 +239,10 @@ def test_api_default_format(self, setup_path):
_maybe_remove(store, "df")
store.put("df", df)
assert not store.get_storer("df").is_table
- with pytest.raises(ValueError):
+
+ msg = "Can only append to Tables"
+
+ with pytest.raises(ValueError, match=msg):
store.append("df2", df)
pd.set_option("io.hdf.default_format", "table")
@@ -251,7 +263,7 @@ def test_api_default_format(self, setup_path):
df.to_hdf(path, "df")
with HDFStore(path) as store:
assert not store.get_storer("df").is_table
- with pytest.raises(ValueError):
+ with pytest.raises(ValueError, match=msg):
df.to_hdf(path, "df2", append=True)
pd.set_option("io.hdf.default_format", "table")
@@ -384,7 +396,10 @@ def test_versioning(self, setup_path):
# this is an error because its table_type is appendable, but no
# version info
store.get_node("df2")._v_attrs.pandas_version = None
- with pytest.raises(Exception):
+
+ msg = "'NoneType' object has no attribute 'startswith'"
+
+ with pytest.raises(Exception, match=msg):
store.select("df2")
def test_mode(self, setup_path):
@@ -428,7 +443,11 @@ def check(mode):
# conv read
if mode in ["w"]:
- with pytest.raises(ValueError):
+ msg = (
+ "mode w is not allowed while performing a read. "
+ r"Allowed modes are r, r\+ and a."
+ )
+ with pytest.raises(ValueError, match=msg):
read_hdf(path, "df", mode=mode)
else:
result = read_hdf(path, "df", mode=mode)
| - [ ] 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/30825 | 2020-01-08T22:04:20Z | 2020-01-08T23:51:58Z | 2020-01-08T23:51:58Z | 2020-01-08T23:57:45Z |
BUG: BooleanArray.value_counts dropna | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 11a6f2628ac52..381c83c4f6c8f 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -411,6 +411,24 @@ Use :meth:`arrays.IntegerArray.to_numpy` with an explicit ``na_value`` instead.
a.to_numpy(dtype="float", na_value=np.nan)
+**value_counts returns a nullable integer dtype**
+
+:meth:`Series.value_counts` with a nullable integer dtype now returns a nullable
+integer dtype for the values.
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+ >>> pd.Series([2, 1, 1, None], dtype="Int64").value_counts().dtype
+ dtype('int64')
+
+*pandas 1.0.0*
+
+.. ipython:: python
+
+ pd.Series([2, 1, 1, None], dtype="Int64").value_counts().dtype
+
See :ref:`missing_data.NA` for more on the differences between :attr:`pandas.NA`
and :attr:`numpy.nan`.
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index c065fdeba2177..b8952fc016570 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -410,52 +410,6 @@ def astype(self, dtype, copy=True):
data = self.to_numpy(na_value=na_value)
return astype_nansafe(data, dtype, copy=False)
- def value_counts(self, dropna=True):
- """
- Returns a Series containing counts of each category.
-
- Every category will have an entry, even those with a count of 0.
-
- Parameters
- ----------
- dropna : bool, default True
- Don't include counts of NaN.
-
- Returns
- -------
- counts : Series
-
- See Also
- --------
- Series.value_counts
-
- """
-
- from pandas import Index, Series
-
- # compute counts on the data with no nans
- data = self._data[~self._mask]
- value_counts = Index(data).value_counts()
- array = value_counts.values
-
- # TODO(extension)
- # if we have allow Index to hold an ExtensionArray
- # this is easier
- index = value_counts.index.values.astype(bool).astype(object)
-
- # if we want nans, count the mask
- if not dropna:
-
- # TODO(extension)
- # appending to an Index *always* infers
- # w/o passing the dtype
- array = np.append(array, [self._mask.sum()])
- index = Index(
- np.concatenate([index, np.array([np.nan], dtype=object)]), dtype=object
- )
-
- return Series(array, index=index)
-
def _values_for_argsort(self) -> np.ndarray:
"""
Return values for sorting.
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 50062f09495aa..90cb3f4ffe2c2 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -467,55 +467,6 @@ def _ndarray_values(self) -> np.ndarray:
"""
return self._data
- def value_counts(self, dropna=True):
- """
- Returns a Series containing counts of each category.
-
- Every category will have an entry, even those with a count of 0.
-
- Parameters
- ----------
- dropna : bool, default True
- Don't include counts of NaN.
-
- Returns
- -------
- counts : Series
-
- See Also
- --------
- Series.value_counts
-
- """
-
- from pandas import Index, Series
-
- # compute counts on the data with no nans
- data = self._data[~self._mask]
- value_counts = Index(data).value_counts()
- array = value_counts.values
-
- # TODO(extension)
- # if we have allow Index to hold an ExtensionArray
- # this is easier
- index = value_counts.index.astype(object)
-
- # if we want nans, count the mask
- if not dropna:
-
- # TODO(extension)
- # appending to an Index *always* infers
- # w/o passing the dtype
- array = np.append(array, [self._mask.sum()])
- index = Index(
- np.concatenate(
- [index.values, np.array([self.dtype.na_value], dtype=object)]
- ),
- dtype=object,
- )
-
- return Series(array, index=index)
-
def _values_for_factorize(self) -> Tuple[np.ndarray, Any]:
# TODO: https://github.com/pandas-dev/pandas/issues/30037
# use masked algorithms, rather than object-dtype / np.nan.
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
index 6fd9f1efbb408..53bb05873a8e9 100644
--- a/pandas/core/arrays/masked.py
+++ b/pandas/core/arrays/masked.py
@@ -201,3 +201,50 @@ def copy(self):
data = data.copy()
mask = mask.copy()
return type(self)(data, mask, copy=False)
+
+ def value_counts(self, dropna=True):
+ """
+ Returns a Series containing counts of each unique value.
+
+ Parameters
+ ----------
+ dropna : bool, default True
+ Don't include counts of missing values.
+
+ Returns
+ -------
+ counts : Series
+
+ See Also
+ --------
+ Series.value_counts
+ """
+ from pandas import Index, Series
+ from pandas.arrays import IntegerArray
+
+ # compute counts on the data with no nans
+ data = self._data[~self._mask]
+ value_counts = Index(data).value_counts()
+
+ # TODO(extension)
+ # if we have allow Index to hold an ExtensionArray
+ # this is easier
+ index = value_counts.index.values.astype(object)
+
+ # if we want nans, count the mask
+ if dropna:
+ counts = value_counts.values
+ else:
+ counts = np.empty(len(value_counts) + 1, dtype="int64")
+ counts[:-1] = value_counts
+ counts[-1] = self._mask.sum()
+
+ index = Index(
+ np.concatenate([index, np.array([self.dtype.na_value], dtype=object)]),
+ dtype=object,
+ )
+
+ mask = np.zeros(len(counts), dtype="bool")
+ counts = IntegerArray(counts, mask)
+
+ return Series(counts, index=index)
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 0da877fb1ad45..fe476ab6ffaa1 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -253,7 +253,7 @@ def _reduce(self, name, skipna=True, **kwargs):
def value_counts(self, dropna=False):
from pandas import value_counts
- return value_counts(self._ndarray, dropna=dropna)
+ return value_counts(self._ndarray, dropna=dropna).astype("Int64")
# Overrride parent because we have different return types.
@classmethod
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index ec7e35e5c6db4..32c1e697b15b5 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -237,3 +237,14 @@ def test_arrow_roundtrip():
tm.assert_frame_equal(result, df)
# ensure the missing value is represented by NA and not np.nan or None
assert result.loc[2, "a"] is pd.NA
+
+
+def test_value_counts_na():
+ arr = pd.array(["a", "b", "a", pd.NA], dtype="string")
+ result = arr.value_counts(dropna=False)
+ expected = pd.Series([2, 1, 1], index=["a", "b", pd.NA], dtype="Int64")
+ tm.assert_series_equal(result, expected)
+
+ result = arr.value_counts(dropna=True)
+ expected = pd.Series([2, 1], index=["a", "b"], dtype="Int64")
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/arrays/test_boolean.py b/pandas/tests/arrays/test_boolean.py
index b89aece3f982c..bc406e4cd9520 100644
--- a/pandas/tests/arrays/test_boolean.py
+++ b/pandas/tests/arrays/test_boolean.py
@@ -856,3 +856,14 @@ def test_arrow_roundtrip():
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)
diff --git a/pandas/tests/arrays/test_integer.py b/pandas/tests/arrays/test_integer.py
index 6a3ef75157d5d..14dbdcafb3088 100644
--- a/pandas/tests/arrays/test_integer.py
+++ b/pandas/tests/arrays/test_integer.py
@@ -1039,6 +1039,17 @@ def test_stat_method(pandasmethname, kwargs):
assert expected == result
+def test_value_counts_na():
+ arr = pd.array([1, 2, 1, pd.NA], dtype="Int64")
+ result = arr.value_counts(dropna=False)
+ expected = pd.Series([2, 1, 1], index=[1, 2, pd.NA], dtype="Int64")
+ tm.assert_series_equal(result, expected)
+
+ result = arr.value_counts(dropna=True)
+ expected = pd.Series([2, 1], index=[1, 2], dtype="Int64")
+ tm.assert_series_equal(result, expected)
+
+
# TODO(jreback) - these need testing / are broken
# shift
diff --git a/pandas/tests/extension/test_boolean.py b/pandas/tests/extension/test_boolean.py
index 9c151b5482c9d..a7ce0fb097599 100644
--- a/pandas/tests/extension/test_boolean.py
+++ b/pandas/tests/extension/test_boolean.py
@@ -226,6 +226,10 @@ def test_searchsorted(self, data_for_sorting, as_series):
sorter = np.array([1, 0])
assert data_for_sorting.searchsorted(a, sorter=sorter) == 0
+ @pytest.mark.skip(reason="uses nullable integer")
+ def test_value_counts(self, all_data, dropna):
+ return super().test_value_counts(all_data, dropna)
+
class TestCasting(base.BaseCastingTests):
pass
diff --git a/pandas/tests/extension/test_integer.py b/pandas/tests/extension/test_integer.py
index 8e54543e5437c..afb8412f12ea9 100644
--- a/pandas/tests/extension/test_integer.py
+++ b/pandas/tests/extension/test_integer.py
@@ -209,7 +209,7 @@ class TestMissing(base.BaseMissingTests):
class TestMethods(base.BaseMethodsTests):
- @pytest.mark.parametrize("dropna", [True, False])
+ @pytest.mark.skip(reason="uses nullable integer")
def test_value_counts(self, all_data, dropna):
all_data = all_data[:10]
if dropna:
diff --git a/pandas/tests/extension/test_string.py b/pandas/tests/extension/test_string.py
index 8519c2999ade3..86aed671f1b88 100644
--- a/pandas/tests/extension/test_string.py
+++ b/pandas/tests/extension/test_string.py
@@ -81,7 +81,9 @@ class TestNoReduce(base.BaseNoReduceTests):
class TestMethods(base.BaseMethodsTests):
- pass
+ @pytest.mark.skip(reason="returns nullable")
+ def test_value_counts(self, all_data, dropna):
+ return super().test_value_counts(all_data, dropna)
class TestCasting(base.BaseCastingTests):
| Closes https://github.com/pandas-dev/pandas/issues/30685 | https://api.github.com/repos/pandas-dev/pandas/pulls/30824 | 2020-01-08T21:49:10Z | 2020-01-09T19:19:35Z | 2020-01-09T19:19:35Z | 2020-01-09T19:19:40Z |
STY: Absolute imports | diff --git a/pandas/core/arrays/sparse/accessor.py b/pandas/core/arrays/sparse/accessor.py
index eb4d7cdf2709f..92c05f44d677c 100644
--- a/pandas/core/arrays/sparse/accessor.py
+++ b/pandas/core/arrays/sparse/accessor.py
@@ -7,9 +7,8 @@
from pandas.core.dtypes.cast import find_common_type
from pandas.core.accessor import PandasDelegate, delegate_names
-
-from .array import SparseArray
-from .dtype import SparseDtype
+from pandas.core.arrays.sparse.array import SparseArray
+from pandas.core.arrays.sparse.dtype import SparseDtype
class BaseAccessor:
| - [x] ref #30808
- [ ] 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/30822 | 2020-01-08T20:22:03Z | 2020-01-08T22:17:13Z | 2020-01-08T22:17:13Z | 2020-01-08T23:07:58Z |
Update NA repr | diff --git a/ci/code_checks.sh b/ci/code_checks.sh
index a90774d2e8ff1..83ceb11dfcbf4 100755
--- a/ci/code_checks.sh
+++ b/ci/code_checks.sh
@@ -298,8 +298,11 @@ if [[ -z "$CHECK" || "$CHECK" == "doctests" ]]; then
-k"-from_arrays -from_breaks -from_intervals -from_tuples -set_closed -to_tuples -interval_range"
RET=$(($RET + $?)) ; echo $MSG "DONE"
- MSG='Doctests arrays/string_.py' ; echo $MSG
- pytest -q --doctest-modules pandas/core/arrays/string_.py
+ MSG='Doctests arrays'; echo $MSG
+ pytest -q --doctest-modules \
+ pandas/core/arrays/string_.py \
+ pandas/core/arrays/integer.py \
+ pandas/core/arrays/boolean.py
RET=$(($RET + $?)) ; echo $MSG "DONE"
MSG='Doctests arrays/boolean.py' ; echo $MSG
diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index e174060647018..55bbf6848820b 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -1153,7 +1153,7 @@ To completely override the default values that are recognized as missing, specif
.. _io.navaluesconst:
The default ``NaN`` recognized values are ``['-1.#IND', '1.#QNAN', '1.#IND', '-1.#QNAN', '#N/A N/A', '#N/A', 'N/A',
-'n/a', 'NA', '#NA', 'NULL', 'null', 'NaN', '-NaN', 'nan', '-nan', '']``.
+'n/a', 'NA', '<NA>', '#NA', 'NULL', 'null', 'NaN', '-NaN', 'nan', '-nan', '']``.
Let us consider some examples:
diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 11a6f2628ac52..216e53036c44f 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -576,6 +576,7 @@ Other API changes
Supplying anything else than ``how`` to ``**kwargs`` raised a ``TypeError`` previously (:issue:`29388`)
- When testing pandas, the new minimum required version of pytest is 5.0.1 (:issue:`29664`)
- :meth:`Series.str.__iter__` was deprecated and will be removed in future releases (:issue:`28277`).
+- Added ``<NA>`` to the list of default NA values for :meth:`read_csv` (:issue:`30821`)
.. _whatsnew_100.api.documentation:
diff --git a/pandas/_libs/missing.pyx b/pandas/_libs/missing.pyx
index afaf9115abfd3..26653438356b1 100644
--- a/pandas/_libs/missing.pyx
+++ b/pandas/_libs/missing.pyx
@@ -354,10 +354,7 @@ class NAType(C_NAType):
return NAType._instance
def __repr__(self) -> str:
- return "NA"
-
- def __str__(self) -> str:
- return "NA"
+ return "<NA>"
def __bool__(self):
raise TypeError("boolean value of NA is ambiguous")
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index 3df2362f41f0f..377d49f2bbd29 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -1369,6 +1369,7 @@ STR_NA_VALUES = {
"N/A",
"n/a",
"NA",
+ "<NA>",
"#NA",
"NULL",
"null",
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index c065fdeba2177..af6232fcc3367 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -244,7 +244,7 @@ class BooleanArray(BaseMaskedArray):
>>> pd.array([True, False, None], dtype="boolean")
<BooleanArray>
- [True, False, NA]
+ [True, False, <NA>]
Length: 3, dtype: boolean
"""
@@ -527,7 +527,7 @@ def any(self, skipna: bool = True, **kwargs):
>>> pd.array([True, False, pd.NA]).any(skipna=False)
True
>>> pd.array([False, False, pd.NA]).any(skipna=False)
- NA
+ <NA>
"""
kwargs.pop("axis", None)
nv.validate_any((), kwargs)
@@ -592,7 +592,7 @@ def all(self, skipna: bool = True, **kwargs):
required (whether ``pd.NA`` is True or False influences the result):
>>> pd.array([True, True, pd.NA]).all(skipna=False)
- NA
+ <NA>
>>> pd.array([True, False, pd.NA]).all(skipna=False)
False
"""
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 50062f09495aa..be93bb7363ed3 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -301,19 +301,19 @@ class IntegerArray(BaseMaskedArray):
>>> int_array = pd.array([1, None, 3], dtype=pd.Int32Dtype())
>>> int_array
<IntegerArray>
- [1, NaN, 3]
+ [1, <NA>, 3]
Length: 3, dtype: Int32
String aliases for the dtypes are also available. They are capitalized.
>>> pd.array([1, None, 3], dtype='Int32')
<IntegerArray>
- [1, NaN, 3]
+ [1, <NA>, 3]
Length: 3, dtype: Int32
>>> pd.array([1, None, 3], dtype='UInt16')
<IntegerArray>
- [1, NaN, 3]
+ [1, <NA>, 3]
Length: 3, dtype: UInt16
"""
diff --git a/pandas/core/arrays/string_.py b/pandas/core/arrays/string_.py
index 0da877fb1ad45..b41b6d53e90f4 100644
--- a/pandas/core/arrays/string_.py
+++ b/pandas/core/arrays/string_.py
@@ -131,7 +131,7 @@ class StringArray(PandasArray):
--------
>>> pd.array(['This is', 'some text', None, 'data.'], dtype="string")
<StringArray>
- ['This is', 'some text', NA, 'data.']
+ ['This is', 'some text', <NA>, 'data.']
Length: 4, dtype: string
Unlike ``object`` dtype arrays, ``StringArray`` doesn't allow non-string
@@ -146,7 +146,7 @@ class StringArray(PandasArray):
>>> pd.array(["a", None, "c"], dtype="string") == "a"
<BooleanArray>
- [True, NA, False]
+ [True, <NA>, False]
Length: 3, dtype: boolean
"""
diff --git a/pandas/core/internals/blocks.py b/pandas/core/internals/blocks.py
index 5d240a3d7821f..f74033924f64e 100644
--- a/pandas/core/internals/blocks.py
+++ b/pandas/core/internals/blocks.py
@@ -1777,12 +1777,8 @@ def to_native_types(self, slicer=None, na_rep="nan", quoting=None, **kwargs):
values = values[slicer]
mask = isna(values)
- try:
- values[mask] = na_rep
- except Exception:
- # eg SparseArray does not support setitem, needs to be converted to ndarray
- return super().to_native_types(slicer, na_rep, quoting, **kwargs)
- values = values.astype(str)
+ values = np.asarray(values.astype(object))
+ values[mask] = na_rep
# we are expected to return a 2-d ndarray
return values.reshape(1, len(values))
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 5c4b7d103d271..b981c2feea380 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -1230,7 +1230,7 @@ def _format(x):
if x is None:
return "None"
elif x is NA:
- return "NA"
+ return formatter(x)
elif x is NaT or np.isnat(x):
return "NaT"
except (TypeError, ValueError):
diff --git a/pandas/tests/arrays/string_/test_string.py b/pandas/tests/arrays/string_/test_string.py
index ec7e35e5c6db4..2c61744ef953c 100644
--- a/pandas/tests/arrays/string_/test_string.py
+++ b/pandas/tests/arrays/string_/test_string.py
@@ -9,14 +9,16 @@
import pandas._testing as tm
-def test_repr_with_NA():
- a = pd.array(["a", pd.NA, "b"], dtype="string")
- for obj in [a, pd.Series(a), pd.DataFrame({"a": a})]:
- assert "NA" in repr(obj) and "NaN" not in repr(obj)
- assert "NA" in str(obj) and "NaN" not in str(obj)
- if hasattr(obj, "_repr_html_"):
- html_repr = obj._repr_html_()
- assert "NA" in html_repr and "NaN" not in html_repr
+def test_repr():
+ df = pd.DataFrame({"A": pd.array(["a", pd.NA, "b"], dtype="string")})
+ expected = " A\n0 a\n1 <NA>\n2 b"
+ assert repr(df) == expected
+
+ expected = "0 a\n1 <NA>\n2 b\nName: A, dtype: string"
+ assert repr(df.A) == expected
+
+ expected = "<StringArray>\n['a', <NA>, 'b']\nLength: 3, dtype: string"
+ assert repr(df.A.array) == expected
def test_none_to_nan():
diff --git a/pandas/tests/arrays/test_boolean.py b/pandas/tests/arrays/test_boolean.py
index b89aece3f982c..fc1abce8c077a 100644
--- a/pandas/tests/arrays/test_boolean.py
+++ b/pandas/tests/arrays/test_boolean.py
@@ -251,6 +251,18 @@ def test_coerce_to_numpy_array():
np.array(arr, dtype="bool")
+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
@@ -335,7 +347,7 @@ def test_astype():
tm.assert_numpy_array_equal(result, expected)
result = arr.astype("str")
- expected = np.array(["True", "False", "NA"], dtype="object")
+ expected = np.array(["True", "False", "<NA>"], dtype="object")
tm.assert_numpy_array_equal(result, expected)
# no missing values
diff --git a/pandas/tests/arrays/test_integer.py b/pandas/tests/arrays/test_integer.py
index 6a3ef75157d5d..4ccaa4431c998 100644
--- a/pandas/tests/arrays/test_integer.py
+++ b/pandas/tests/arrays/test_integer.py
@@ -90,7 +90,7 @@ def test_repr_dtype(dtype, expected):
def test_repr_array():
result = repr(integer_array([1, None, 3]))
- expected = "<IntegerArray>\n[1, NA, 3]\nLength: 3, dtype: Int64"
+ expected = "<IntegerArray>\n[1, <NA>, 3]\nLength: 3, dtype: Int64"
assert result == expected
@@ -98,9 +98,9 @@ def test_repr_array_long():
data = integer_array([1, 2, None] * 1000)
expected = (
"<IntegerArray>\n"
- "[ 1, 2, NA, 1, 2, NA, 1, 2, NA, 1,\n"
+ "[ 1, 2, <NA>, 1, 2, <NA>, 1, 2, <NA>, 1,\n"
" ...\n"
- " NA, 1, 2, NA, 1, 2, NA, 1, 2, NA]\n"
+ " <NA>, 1, 2, <NA>, 1, 2, <NA>, 1, 2, <NA>]\n"
"Length: 3000, dtype: Int64"
)
result = repr(data)
@@ -673,7 +673,7 @@ def test_to_numpy_na_raises(self, dtype):
def test_astype_str(self):
a = pd.array([1, 2, None], dtype="Int64")
- expected = np.array(["1", "2", "NA"], dtype=object)
+ expected = np.array(["1", "2", "<NA>"], dtype=object)
tm.assert_numpy_array_equal(a.astype(str), expected)
tm.assert_numpy_array_equal(a.astype("str"), expected)
@@ -683,7 +683,7 @@ def test_frame_repr(data_missing):
df = pd.DataFrame({"A": data_missing})
result = repr(df)
- expected = " A\n0 NA\n1 1"
+ expected = " A\n0 <NA>\n1 1"
assert result == expected
diff --git a/pandas/tests/io/parser/test_na_values.py b/pandas/tests/io/parser/test_na_values.py
index c9a0889cdd8b7..f9a083d7f5d22 100644
--- a/pandas/tests/io/parser/test_na_values.py
+++ b/pandas/tests/io/parser/test_na_values.py
@@ -89,6 +89,7 @@ def test_default_na_values(all_parsers):
"N/A",
"n/a",
"NA",
+ "<NA>",
"#NA",
"NULL",
"null",
diff --git a/pandas/tests/scalar/test_na_scalar.py b/pandas/tests/scalar/test_na_scalar.py
index a72378e02bec6..7d05511239ebc 100644
--- a/pandas/tests/scalar/test_na_scalar.py
+++ b/pandas/tests/scalar/test_na_scalar.py
@@ -16,8 +16,8 @@ def test_singleton():
def test_repr():
- assert repr(NA) == "NA"
- assert str(NA) == "NA"
+ assert repr(NA) == "<NA>"
+ assert str(NA) == "<NA>"
def test_truthiness():
| Closes https://github.com/pandas-dev/pandas/issues/30415
```python
In [2]: df = pd.DataFrame({"A": pd.array([1, 2, None])})
In [3]: df
Out[3]:
A
0 1
1 2
2 <NA>
In [4]: df.A
Out[4]:
0 1
1 2
2 <NA>
Name: A, dtype: Int64
In [5]: df.A.array
Out[5]:
<IntegerArray>
[1, 2, <NA>]
Length: 3, dtype: Int64
```
I think adding color with ANSI codes / custom HTML formatting is still worth doing as in #30778, but this is an improvement for now. | https://api.github.com/repos/pandas-dev/pandas/pulls/30821 | 2020-01-08T19:56:20Z | 2020-01-09T16:18:59Z | 2020-01-09T16:18:58Z | 2020-01-09T19:26:10Z |
API: Limit assert_*_equal functions in public API | diff --git a/doc/source/reference/general_utility_functions.rst b/doc/source/reference/general_utility_functions.rst
index e2e47d9f87960..0d9e0b0f4c668 100644
--- a/doc/source/reference/general_utility_functions.rst
+++ b/doc/source/reference/general_utility_functions.rst
@@ -28,16 +28,7 @@ Testing functions
testing.assert_frame_equal
testing.assert_series_equal
testing.assert_index_equal
- testing.assert_equal
- testing.assert_almost_equal
- testing.assert_categorical_equal
- testing.assert_datetime_array_equal
testing.assert_extension_array_equal
- testing.assert_interval_array_equal
- testing.assert_numpy_array_equal
- testing.assert_period_array_equal
- testing.assert_sp_array_equal
- testing.assert_timedelta_array_equal
Exceptions and warnings
-----------------------
diff --git a/pandas/testing.py b/pandas/testing.py
index 26a60d80854b8..0445fa5b5efc0 100644
--- a/pandas/testing.py
+++ b/pandas/testing.py
@@ -3,33 +3,15 @@
"""
from pandas._testing import (
- assert_almost_equal,
- assert_categorical_equal,
- assert_datetime_array_equal,
- assert_equal,
assert_extension_array_equal,
assert_frame_equal,
assert_index_equal,
- assert_interval_array_equal,
- assert_numpy_array_equal,
- assert_period_array_equal,
assert_series_equal,
- assert_sp_array_equal,
- assert_timedelta_array_equal,
)
__all__ = [
+ "assert_extension_array_equal",
"assert_frame_equal",
"assert_series_equal",
"assert_index_equal",
- "assert_equal",
- "assert_almost_equal",
- "assert_categorical_equal",
- "assert_datetime_array_equal",
- "assert_extension_array_equal",
- "assert_interval_array_equal",
- "assert_numpy_array_equal",
- "assert_period_array_equal",
- "assert_sp_array_equal",
- "assert_timedelta_array_equal",
]
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index 72e2413ce87d9..fb2615a7b34f3 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -271,16 +271,7 @@ class TestTesting(Base):
"assert_frame_equal",
"assert_series_equal",
"assert_index_equal",
- "assert_equal",
- "assert_almost_equal",
- "assert_categorical_equal",
- "assert_datetime_array_equal",
"assert_extension_array_equal",
- "assert_interval_array_equal",
- "assert_numpy_array_equal",
- "assert_period_array_equal",
- "assert_sp_array_equal",
- "assert_timedelta_array_equal",
]
def test_testing(self):
| As discussed on today's call. Just adding `assert_extension_array_equal` relative to 0.25. | https://api.github.com/repos/pandas-dev/pandas/pulls/30820 | 2020-01-08T19:34:24Z | 2020-01-08T22:33:24Z | 2020-01-08T22:33:24Z | 2020-01-09T09:03:10Z |
CLN: de-duplicate boxing in DTI.get_value | diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 9db30ce710c0d..ae0a71dfa2c49 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -641,15 +641,7 @@ def get_value(self, series, key):
know what you're doing
"""
- if isinstance(key, datetime):
-
- # needed to localize naive datetimes
- if self.tz is not None:
- if key.tzinfo is not None:
- key = Timestamp(key).tz_convert(self.tz)
- else:
- key = Timestamp(key).tz_localize(self.tz)
-
+ if isinstance(key, (datetime, np.datetime64)):
return self.get_value_maybe_box(series, key)
if isinstance(key, time):
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index 97290c8c635b8..99a362e25d58d 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -613,6 +613,23 @@ def test_delete_slice(self):
assert result.freq == expected.freq
assert result.tz == expected.tz
+ def test_get_value(self):
+ # specifically make sure we have test for np.datetime64 key
+ dti = pd.date_range("2016-01-01", periods=3)
+
+ arr = np.arange(6, 8)
+
+ key = dti[1]
+
+ result = dti.get_value(arr, key)
+ assert result == 7
+
+ result = dti.get_value(arr, key.to_pydatetime())
+ assert result == 7
+
+ result = dti.get_value(arr, key.to_datetime64())
+ assert result == 7
+
def test_get_loc(self):
idx = pd.date_range("2000-01-01", periods=3)
| Also add a dedicated test or it to hit currently un-covered case of np.datetime64 key. That case works in master, but doesn't go through the expected code path | https://api.github.com/repos/pandas-dev/pandas/pulls/30819 | 2020-01-08T19:31:40Z | 2020-01-09T02:48:28Z | 2020-01-09T02:48:27Z | 2020-01-09T05:08:52Z |
REF: share comparison methods between ExtensionIndex subclasses | diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index 77165034f313d..7c1e95e12d339 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -1,4 +1,3 @@
-import operator
from typing import Any, List
import warnings
@@ -9,7 +8,6 @@
from pandas._libs import index as libindex
from pandas._libs.hashtable import duplicated_int64
from pandas._typing import AnyArrayLike
-import pandas.compat as compat
from pandas.util._decorators import Appender, cache_readonly
from pandas.core.dtypes.common import (
@@ -29,7 +27,7 @@
import pandas.core.common as com
import pandas.core.indexes.base as ibase
from pandas.core.indexes.base import Index, _index_shared_docs, maybe_extract_name
-from pandas.core.indexes.extension import ExtensionIndex, make_wrapped_comparison_op
+from pandas.core.indexes.extension import ExtensionIndex
import pandas.core.missing as missing
from pandas.core.ops import get_op_result_name
@@ -858,24 +856,6 @@ def _concat_same_dtype(self, to_concat, name):
result.name = name
return result
- @classmethod
- def _add_comparison_methods(cls):
- """ add in comparison methods """
-
- def _make_compare(op):
- opname = f"__{op.__name__}__"
-
- _evaluate_compare = make_wrapped_comparison_op(opname)
-
- return compat.set_function_name(_evaluate_compare, opname, cls)
-
- cls.__eq__ = _make_compare(operator.eq)
- cls.__ne__ = _make_compare(operator.ne)
- cls.__lt__ = _make_compare(operator.lt)
- cls.__gt__ = _make_compare(operator.gt)
- cls.__le__ = _make_compare(operator.le)
- cls.__ge__ = _make_compare(operator.ge)
-
def _delegate_property_get(self, name, *args, **kwargs):
""" method delegation to the ._values """
prop = getattr(self._values, name)
@@ -895,4 +875,3 @@ def _delegate_method(self, name, *args, **kwargs):
CategoricalIndex._add_numeric_methods_add_sub_disabled()
CategoricalIndex._add_numeric_methods_disabled()
CategoricalIndex._add_logical_methods_disabled()
-CategoricalIndex._add_comparison_methods()
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 171e1d05259d1..c4dac9d1c4a11 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -31,12 +31,7 @@
from pandas.core import algorithms
from pandas.core.accessor import PandasDelegate
-from pandas.core.arrays import (
- DatetimeArray,
- ExtensionArray,
- ExtensionOpsMixin,
- TimedeltaArray,
-)
+from pandas.core.arrays import DatetimeArray, ExtensionArray, TimedeltaArray
from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
import pandas.core.indexes.base as ibase
from pandas.core.indexes.base import Index, _index_shared_docs
@@ -44,7 +39,6 @@
ExtensionIndex,
inherit_names,
make_wrapped_arith_op,
- make_wrapped_comparison_op,
)
from pandas.core.indexes.numeric import Int64Index
from pandas.core.ops import get_op_result_name
@@ -90,7 +84,7 @@ def wrapper(left, right):
["__iter__", "mean", "freq", "freqstr", "_ndarray_values", "asi8", "_box_values"],
DatetimeLikeArrayMixin,
)
-class DatetimeIndexOpsMixin(ExtensionIndex, ExtensionOpsMixin):
+class DatetimeIndexOpsMixin(ExtensionIndex):
"""
Common ops mixin to support a unified interface datetimelike Index.
"""
@@ -109,13 +103,6 @@ class DatetimeIndexOpsMixin(ExtensionIndex, ExtensionOpsMixin):
def is_all_dates(self) -> bool:
return True
- @classmethod
- def _create_comparison_method(cls, op):
- """
- Create a comparison method that dispatches to ``cls.values``.
- """
- return make_wrapped_comparison_op(f"__{op.__name__}__")
-
# ------------------------------------------------------------------------
# Abstract data attributes
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 9db30ce710c0d..21a571c3ee638 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -1013,7 +1013,6 @@ def indexer_between_time(
return mask.nonzero()[0]
-DatetimeIndex._add_comparison_ops()
DatetimeIndex._add_numeric_methods_disabled()
DatetimeIndex._add_logical_methods_disabled()
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index efa5aa3c036c9..9011616dfe496 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -86,7 +86,7 @@ def wrapper(cls):
return wrapper
-def make_wrapped_comparison_op(opname):
+def _make_wrapped_comparison_op(opname):
"""
Create a comparison method that dispatches to ``._data``.
"""
@@ -163,6 +163,13 @@ class ExtensionIndex(Index):
_data: ExtensionArray
+ __eq__ = _make_wrapped_comparison_op("__eq__")
+ __ne__ = _make_wrapped_comparison_op("__ne__")
+ __lt__ = _make_wrapped_comparison_op("__lt__")
+ __gt__ = _make_wrapped_comparison_op("__gt__")
+ __le__ = _make_wrapped_comparison_op("__le__")
+ __ge__ = _make_wrapped_comparison_op("__ge__")
+
def repeat(self, repeats, axis=None):
nv.validate_repeat(tuple(), dict(axis=axis))
result = self._data.repeat(repeats, axis=axis)
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index caba33aa13e87..d33ba52cc7524 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -51,11 +51,7 @@
maybe_extract_name,
)
from pandas.core.indexes.datetimes import DatetimeIndex, date_range
-from pandas.core.indexes.extension import (
- ExtensionIndex,
- inherit_names,
- make_wrapped_comparison_op,
-)
+from pandas.core.indexes.extension import ExtensionIndex, inherit_names
from pandas.core.indexes.multi import MultiIndex
from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
from pandas.core.ops import get_op_result_name
@@ -1195,14 +1191,20 @@ def _delegate_method(self, name, *args, **kwargs):
return type(self)._simple_new(res, name=self.name)
return Index(res)
- @classmethod
- def _add_comparison_methods(cls):
- """ add in comparison methods """
- cls.__eq__ = make_wrapped_comparison_op("__eq__")
- cls.__ne__ = make_wrapped_comparison_op("__ne__")
+ # GH#30817 until IntervalArray implements inequalities, get them from Index
+ def __lt__(self, other):
+ return Index.__lt__(self, other)
+
+ def __le__(self, other):
+ return Index.__le__(self, other)
+
+ def __gt__(self, other):
+ return Index.__gt__(self, other)
+
+ def __ge__(self, other):
+ return Index.__ge__(self, other)
-IntervalIndex._add_comparison_methods()
IntervalIndex._add_logical_methods_disabled()
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index d34ac1a541d27..dd591634abc04 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -838,7 +838,6 @@ def memory_usage(self, deep=False):
return result
-PeriodIndex._add_comparison_ops()
PeriodIndex._add_numeric_methods_disabled()
PeriodIndex._add_logical_methods_disabled()
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index d1d8db0746cf8..b360adf7bb8cf 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -422,7 +422,6 @@ def insert(self, loc, item):
raise TypeError("cannot insert TimedeltaIndex with incompatible label")
-TimedeltaIndex._add_comparison_ops()
TimedeltaIndex._add_logical_methods_disabled()
| https://api.github.com/repos/pandas-dev/pandas/pulls/30817 | 2020-01-08T18:55:37Z | 2020-01-09T02:51:22Z | 2020-01-09T02:51:22Z | 2020-01-09T05:09:30Z | |
replacing '.format' with f-strings in some test files | diff --git a/pandas/tests/util/test_assert_almost_equal.py b/pandas/tests/util/test_assert_almost_equal.py
index ffa49f6ba442b..b8048891e4876 100644
--- a/pandas/tests/util/test_assert_almost_equal.py
+++ b/pandas/tests/util/test_assert_almost_equal.py
@@ -39,9 +39,7 @@ def _assert_not_almost_equal(a, b, **kwargs):
"""
try:
tm.assert_almost_equal(a, b, **kwargs)
- msg = (
- "{a} and {b} were approximately equal when they shouldn't have been"
- ).format(a=a, b=b)
+ msg = f"{a} and {b} were approximately equal when they shouldn't have been"
pytest.fail(msg=msg)
except AssertionError:
pass
@@ -248,13 +246,12 @@ def test_assert_almost_equal_value_mismatch():
[(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
)
def test_assert_almost_equal_class_mismatch(a, b, klass1, klass2):
- msg = """numpy array are different
+
+ msg = f"""numpy array are different
numpy array classes are different
\\[left\\]: {klass1}
-\\[right\\]: {klass2}""".format(
- klass1=klass1, klass2=klass2
- )
+\\[right\\]: {klass2}"""
with pytest.raises(AssertionError, match=msg):
tm.assert_almost_equal(a, b)
diff --git a/pandas/tests/util/test_assert_categorical_equal.py b/pandas/tests/util/test_assert_categorical_equal.py
index 6ae16cee89ee3..8957e7a172666 100644
--- a/pandas/tests/util/test_assert_categorical_equal.py
+++ b/pandas/tests/util/test_assert_categorical_equal.py
@@ -77,13 +77,11 @@ def test_categorical_equal_ordered_mismatch():
@pytest.mark.parametrize("obj", ["index", "foo", "pandas"])
def test_categorical_equal_object_override(obj):
data = [1, 2, 3, 4]
- msg = """{obj} are different
+ msg = f"""{obj} are different
Attribute "ordered" are different
\\[left\\]: False
-\\[right\\]: True""".format(
- obj=obj
- )
+\\[right\\]: True"""
c1 = Categorical(data, ordered=False)
c2 = Categorical(data, ordered=True)
diff --git a/pandas/tests/util/test_assert_extension_array_equal.py b/pandas/tests/util/test_assert_extension_array_equal.py
index 320d5a4de9d08..0547323b882f6 100644
--- a/pandas/tests/util/test_assert_extension_array_equal.py
+++ b/pandas/tests/util/test_assert_extension_array_equal.py
@@ -96,7 +96,7 @@ def test_assert_extension_array_equal_non_extension_array(side):
numpy_array = np.arange(5)
extension_array = SparseArray(numpy_array)
- msg = "{side} is not an ExtensionArray".format(side=side)
+ msg = f"{side} is not an ExtensionArray"
args = (
(numpy_array, extension_array)
if side == "left"
diff --git a/pandas/tests/util/test_assert_frame_equal.py b/pandas/tests/util/test_assert_frame_equal.py
index dcb3859c5f166..23c845f2b2795 100644
--- a/pandas/tests/util/test_assert_frame_equal.py
+++ b/pandas/tests/util/test_assert_frame_equal.py
@@ -80,7 +80,7 @@ def test_frame_equal_row_order_mismatch(check_like, obj_fixture):
df2 = DataFrame({"A": [3, 2, 1], "B": [6, 5, 4]}, index=["c", "b", "a"])
if not check_like: # Do not ignore row-column orderings.
- msg = "{obj}.index are different".format(obj=obj_fixture)
+ msg = f"{obj_fixture}.index are different"
with pytest.raises(AssertionError, match=msg):
tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
else:
@@ -95,7 +95,7 @@ def test_frame_equal_row_order_mismatch(check_like, obj_fixture):
],
)
def test_frame_equal_shape_mismatch(df1, df2, obj_fixture):
- msg = "{obj} are different".format(obj=obj_fixture)
+ msg = f"{obj_fixture} are different"
with pytest.raises(AssertionError, match=msg):
tm.assert_frame_equal(df1, df2, obj=obj_fixture)
@@ -149,13 +149,11 @@ def test_empty_dtypes(check_dtype):
def test_frame_equal_index_mismatch(obj_fixture):
- msg = """{obj}\\.index are different
+ msg = f"""{obj_fixture}\\.index are different
-{obj}\\.index values are different \\(33\\.33333 %\\)
+{obj_fixture}\\.index values are different \\(33\\.33333 %\\)
\\[left\\]: Index\\(\\['a', 'b', 'c'\\], dtype='object'\\)
-\\[right\\]: Index\\(\\['a', 'b', 'd'\\], dtype='object'\\)""".format(
- obj=obj_fixture
- )
+\\[right\\]: Index\\(\\['a', 'b', 'd'\\], dtype='object'\\)"""
df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "d"])
@@ -165,13 +163,11 @@ def test_frame_equal_index_mismatch(obj_fixture):
def test_frame_equal_columns_mismatch(obj_fixture):
- msg = """{obj}\\.columns are different
+ msg = f"""{obj_fixture}\\.columns are different
-{obj}\\.columns values are different \\(50\\.0 %\\)
+{obj_fixture}\\.columns values are different \\(50\\.0 %\\)
\\[left\\]: Index\\(\\['A', 'B'\\], dtype='object'\\)
-\\[right\\]: Index\\(\\['A', 'b'\\], dtype='object'\\)""".format(
- obj=obj_fixture
- )
+\\[right\\]: Index\\(\\['A', 'b'\\], dtype='object'\\)"""
df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
df2 = DataFrame({"A": [1, 2, 3], "b": [4, 5, 6]}, index=["a", "b", "c"])
@@ -181,13 +177,12 @@ def test_frame_equal_columns_mismatch(obj_fixture):
def test_frame_equal_block_mismatch(by_blocks_fixture, obj_fixture):
- msg = """{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) are different
+ obj = obj_fixture
+ msg = f"""{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) are different
{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) values are different \\(33\\.33333 %\\)
\\[left\\]: \\[4, 5, 6\\]
-\\[right\\]: \\[4, 5, 7\\]""".format(
- obj=obj_fixture
- )
+\\[right\\]: \\[4, 5, 7\\]"""
df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 7]})
diff --git a/pandas/tests/util/test_assert_index_equal.py b/pandas/tests/util/test_assert_index_equal.py
index 9257e52fe34ab..bbbeebcec2569 100644
--- a/pandas/tests/util/test_assert_index_equal.py
+++ b/pandas/tests/util/test_assert_index_equal.py
@@ -135,11 +135,6 @@ def test_index_equal_level_values_mismatch(check_exact, check_less_precise):
[(None, "x"), ("x", "x"), (np.nan, np.nan), (NaT, NaT), (np.nan, NaT)],
)
def test_index_equal_names(name1, name2):
- msg = """Index are different
-
-Attribute "names" are different
-\\[left\\]: \\[{name1}\\]
-\\[right\\]: \\[{name2}\\]"""
idx1 = Index([1, 2, 3], name=name1)
idx2 = Index([1, 2, 3], name=name2)
@@ -149,7 +144,11 @@ def test_index_equal_names(name1, name2):
else:
name1 = "'x'" if name1 == "x" else name1
name2 = "'x'" if name2 == "x" else name2
- msg = msg.format(name1=name1, name2=name2)
+ msg = f"""Index are different
+
+Attribute "names" are different
+\\[left\\]: \\[{name1}\\]
+\\[right\\]: \\[{name2}\\]"""
with pytest.raises(AssertionError, match=msg):
tm.assert_index_equal(idx1, idx2)
diff --git a/pandas/tests/util/test_assert_numpy_array_equal.py b/pandas/tests/util/test_assert_numpy_array_equal.py
index a6b32610f592d..c8ae9ebdd8651 100644
--- a/pandas/tests/util/test_assert_numpy_array_equal.py
+++ b/pandas/tests/util/test_assert_numpy_array_equal.py
@@ -28,13 +28,11 @@ def test_assert_numpy_array_equal_bad_type():
[(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
)
def test_assert_numpy_array_equal_class_mismatch(a, b, klass1, klass2):
- msg = """numpy array are different
+ msg = f"""numpy array are different
numpy array classes are different
\\[left\\]: {klass1}
-\\[right\\]: {klass2}""".format(
- klass1=klass1, klass2=klass2
- )
+\\[right\\]: {klass2}"""
with pytest.raises(AssertionError, match=msg):
tm.assert_numpy_array_equal(a, b)
diff --git a/pandas/tests/util/test_validate_args_and_kwargs.py b/pandas/tests/util/test_validate_args_and_kwargs.py
index eaf5f99b7e8f9..941ba86c61319 100644
--- a/pandas/tests/util/test_validate_args_and_kwargs.py
+++ b/pandas/tests/util/test_validate_args_and_kwargs.py
@@ -15,10 +15,8 @@ def test_invalid_total_length_max_length_one():
actual_length = len(kwargs) + len(args) + min_fname_arg_count
msg = (
- r"{fname}\(\) takes at most {max_length} "
- r"argument \({actual_length} given\)".format(
- fname=_fname, max_length=max_length, actual_length=actual_length
- )
+ fr"{_fname}\(\) takes at most {max_length} "
+ fr"argument \({actual_length} given\)"
)
with pytest.raises(TypeError, match=msg):
@@ -35,10 +33,8 @@ def test_invalid_total_length_max_length_multiple():
actual_length = len(kwargs) + len(args) + min_fname_arg_count
msg = (
- r"{fname}\(\) takes at most {max_length} "
- r"arguments \({actual_length} given\)".format(
- fname=_fname, max_length=max_length, actual_length=actual_length
- )
+ fr"{_fname}\(\) takes at most {max_length} "
+ fr"arguments \({actual_length} given\)"
)
with pytest.raises(TypeError, match=msg):
@@ -53,8 +49,8 @@ def test_missing_args_or_kwargs(args, kwargs):
compat_args = {"foo": -5, bad_arg: 1}
msg = (
- r"the '{arg}' parameter is not supported "
- r"in the pandas implementation of {func}\(\)".format(arg=bad_arg, func=_fname)
+ fr"the '{bad_arg}' parameter is not supported "
+ fr"in the pandas implementation of {_fname}\(\)"
)
with pytest.raises(ValueError, match=msg):
| - [X] contributes to #29547
- [ ] tests added / passed
- [X] passes `black pandas`
- [X] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
One format that I left untouched in `pandas/tests/util/test_assert_frame_equal.py`:
```
def test_frame_equal_unicode(df1, df2, msg, by_blocks_fixture, obj_fixture):
# see gh-20503
#
# Test ensures that `tm.assert_frame_equals` raises the right exception
# when comparing DataFrames containing differing unicode objects.
msg = msg.format(obj=obj_fixture)
with pytest.raises(AssertionError, match=msg):
tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
```
However it looks the the test function isnt being used anywhere:
```
$ grep -rnw . -e "test_frame_equal_unicode"
./pandas/tests/util/test_assert_frame_equal.py:217:def test_frame_equal_unicode(df1, df2, msg, by_blocks_fixture, obj_fixture):
```
Wasn't sure if I should leave as is? or assume person calling the function will format `msg` properly before passing to the test function. | https://api.github.com/repos/pandas-dev/pandas/pulls/30816 | 2020-01-08T18:49:58Z | 2020-01-08T22:22:46Z | 2020-01-08T22:22:46Z | 2020-01-08T22:22:52Z |
BLD: More lightweight mypy pre-commit hook | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 809764a20a713..139b9e31df46c 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -20,11 +20,11 @@ repos:
rev: v0.730
hooks:
- id: mypy
- # We run mypy over all files because of:
- # * changes in type definitions may affect non-touched files.
- # * Running it with `mypy pandas` and the filenames will lead to
- # spurious duplicate module errors,
- # see also https://github.com/pre-commit/mirrors-mypy/issues/5
- pass_filenames: false
args:
- - pandas
+ # As long as a some files are excluded from check-untyped-defs
+ # we have to exclude it from the pre-commit hook as the configuration
+ # is based on modules but the hook runs on files.
+ - --no-check-untyped-defs
+ - --follow-imports
+ - skip
+ files: pandas/
| Fixes #30811
This now will only detect typing problems in the files you have edited. This may still lead to typing problems detected in CI but is hopefully a compromise between speed and early detection of issues before they hit public CI. One line changes in a single file still stay for me in the <1s mark.
cc @gfyoung @jorisvandenbossche | https://api.github.com/repos/pandas-dev/pandas/pulls/30814 | 2020-01-08T15:10:33Z | 2020-01-15T09:49:50Z | 2020-01-15T09:49:49Z | 2020-01-15T09:49:50Z |
[DOC] add example of rolling with win_type gaussian | diff --git a/pandas/core/window/rolling.py b/pandas/core/window/rolling.py
index 02efd4e37472a..f612826132fd7 100644
--- a/pandas/core/window/rolling.py
+++ b/pandas/core/window/rolling.py
@@ -872,6 +872,17 @@ class Window(_Window):
3 NaN
4 NaN
+ Rolling sum with a window length of 2, using the 'gaussian'
+ window type (note how we need to specify std).
+
+ >>> df.rolling(2, win_type='gaussian').sum(std=3)
+ B
+ 0 NaN
+ 1 0.986207
+ 2 2.958621
+ 3 NaN
+ 4 NaN
+
Rolling sum with a window length of 2, min_periods defaults
to the window length.
| Admittedly this is not the first issue I address, but this one's been open for several months now and so I figured I'd take it
- [x] closes #26462
- [ ] 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/30813 | 2020-01-08T13:53:43Z | 2020-01-08T16:13:54Z | 2020-01-08T16:13:52Z | 2020-01-08T16:47:30Z |
COMPAT: bump minimum version to pyarrow 0.13 | diff --git a/ci/deps/azure-36-locale.yaml b/ci/deps/azure-36-locale.yaml
index c6940f9327e0d..810554632a507 100644
--- a/ci/deps/azure-36-locale.yaml
+++ b/ci/deps/azure-36-locale.yaml
@@ -27,7 +27,7 @@ dependencies:
- openpyxl
# lowest supported version of pyarrow (putting it here instead of in
# azure-36-minimum_versions because it needs numpy >= 1.14)
- - pyarrow=0.12
+ - pyarrow=0.13
- pytables
- python-dateutil
- pytz
diff --git a/ci/deps/azure-macos-36.yaml b/ci/deps/azure-macos-36.yaml
index f393ed84ecf63..3bbbdb4cf32ad 100644
--- a/ci/deps/azure-macos-36.yaml
+++ b/ci/deps/azure-macos-36.yaml
@@ -22,7 +22,7 @@ dependencies:
- numexpr
- numpy=1.14
- openpyxl
- - pyarrow>=0.12.0
+ - pyarrow>=0.13.0
- pytables
- python-dateutil==2.6.1
- pytz
diff --git a/ci/deps/azure-windows-36.yaml b/ci/deps/azure-windows-36.yaml
index 7fa9dee7445a6..663c55492e69e 100644
--- a/ci/deps/azure-windows-36.yaml
+++ b/ci/deps/azure-windows-36.yaml
@@ -22,7 +22,7 @@ dependencies:
- numpy=1.15.*
- openpyxl
- jinja2
- - pyarrow>=0.12.0
+ - pyarrow>=0.13.0
- pytables
- python-dateutil
- pytz
diff --git a/ci/deps/azure-windows-37.yaml b/ci/deps/azure-windows-37.yaml
index 928896efd5fc4..62be1075b3337 100644
--- a/ci/deps/azure-windows-37.yaml
+++ b/ci/deps/azure-windows-37.yaml
@@ -24,6 +24,7 @@ dependencies:
- numexpr
- numpy=1.14.*
- openpyxl
+ - pyarrow=0.14
- pytables
- python-dateutil
- pytz
diff --git a/ci/deps/travis-36-cov.yaml b/ci/deps/travis-36-cov.yaml
index f44bf8c14b467..a46001c58d165 100644
--- a/ci/deps/travis-36-cov.yaml
+++ b/ci/deps/travis-36-cov.yaml
@@ -31,7 +31,7 @@ dependencies:
# https://github.com/pandas-dev/pandas/pull/30009 openpyxl 3.0.2 broke
- pandas-gbq
- psycopg2
- - pyarrow>=0.12.0
+ - pyarrow>=0.13.0
- pymysql
- pytables
- python-snappy
diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 9d86921bc3be4..42399a0da8c9b 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -530,7 +530,7 @@ Optional libraries below the lowest tested version may still work, but are not c
+-----------------+-----------------+---------+
| openpyxl | 2.5.7 | X |
+-----------------+-----------------+---------+
-| pyarrow | 0.12.0 | X |
+| pyarrow | 0.13.0 | X |
+-----------------+-----------------+---------+
| pymysql | 0.7.1 | |
+-----------------+-----------------+---------+
diff --git a/pandas/compat/_optional.py b/pandas/compat/_optional.py
index bac976333ef0a..7aeb0327139f1 100644
--- a/pandas/compat/_optional.py
+++ b/pandas/compat/_optional.py
@@ -16,7 +16,7 @@
"odfpy": "1.3.0",
"openpyxl": "2.5.7",
"pandas_gbq": "0.8.0",
- "pyarrow": "0.12.0",
+ "pyarrow": "0.13.0",
"pytables": "3.4.2",
"pytest": "5.0.1",
"s3fs": "0.3.0",
diff --git a/pandas/tests/extension/arrow/test_bool.py b/pandas/tests/extension/arrow/test_bool.py
index 033cb4437cfbe..94dd09d3eb053 100644
--- a/pandas/tests/extension/arrow/test_bool.py
+++ b/pandas/tests/extension/arrow/test_bool.py
@@ -5,7 +5,7 @@
import pandas._testing as tm
from pandas.tests.extension import base
-pytest.importorskip("pyarrow", minversion="0.12.0")
+pytest.importorskip("pyarrow", minversion="0.13.0")
from .arrays import ArrowBoolArray, ArrowBoolDtype # isort:skip
diff --git a/pandas/tests/extension/arrow/test_string.py b/pandas/tests/extension/arrow/test_string.py
index baedcf0dd9088..abd5c1f386dc5 100644
--- a/pandas/tests/extension/arrow/test_string.py
+++ b/pandas/tests/extension/arrow/test_string.py
@@ -2,7 +2,7 @@
import pandas as pd
-pytest.importorskip("pyarrow", minversion="0.12.0")
+pytest.importorskip("pyarrow", minversion="0.13.0")
from .arrays import ArrowStringDtype # isort:skip
| xref discussion in https://github.com/pandas-dev/pandas/pull/28371
If in the future we want to always try to import pyarrow, having pyarrow 0.13 (instead of 0.12) as the minimum required version will make this easier. | https://api.github.com/repos/pandas-dev/pandas/pulls/30812 | 2020-01-08T12:59:36Z | 2020-01-09T09:34:12Z | 2020-01-09T09:34:12Z | 2020-01-09T09:34:17Z |
ASV: compatibility import for testing module | diff --git a/asv_bench/benchmarks/algorithms.py b/asv_bench/benchmarks/algorithms.py
index 7d97f2c740acb..0f3b3838de1b2 100644
--- a/asv_bench/benchmarks/algorithms.py
+++ b/asv_bench/benchmarks/algorithms.py
@@ -5,7 +5,8 @@
from pandas._libs import lib
import pandas as pd
-from pandas.util import testing as tm
+
+from .pandas_vb_common import tm
for imp in ["pandas.util", "pandas.tools.hashing"]:
try:
diff --git a/asv_bench/benchmarks/categoricals.py b/asv_bench/benchmarks/categoricals.py
index 43b1b31a0bfe8..1dcd52ac074a6 100644
--- a/asv_bench/benchmarks/categoricals.py
+++ b/asv_bench/benchmarks/categoricals.py
@@ -3,7 +3,8 @@
import numpy as np
import pandas as pd
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
try:
from pandas.api.types import union_categoricals
diff --git a/asv_bench/benchmarks/ctors.py b/asv_bench/benchmarks/ctors.py
index a9e45cad22d27..7c43485f5ef45 100644
--- a/asv_bench/benchmarks/ctors.py
+++ b/asv_bench/benchmarks/ctors.py
@@ -1,7 +1,8 @@
import numpy as np
from pandas import DatetimeIndex, Index, MultiIndex, Series, Timestamp
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
def no_change(arr):
diff --git a/asv_bench/benchmarks/frame_ctor.py b/asv_bench/benchmarks/frame_ctor.py
index 1deca8fe3aad0..2b24bab85bc57 100644
--- a/asv_bench/benchmarks/frame_ctor.py
+++ b/asv_bench/benchmarks/frame_ctor.py
@@ -1,7 +1,8 @@
import numpy as np
from pandas import DataFrame, MultiIndex, Series, Timestamp, date_range
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
try:
from pandas.tseries.offsets import Nano, Hour
diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py
index ae6c07107f4a0..2187668c96ca4 100644
--- a/asv_bench/benchmarks/frame_methods.py
+++ b/asv_bench/benchmarks/frame_methods.py
@@ -4,7 +4,8 @@
import numpy as np
from pandas import DataFrame, MultiIndex, NaT, Series, date_range, isnull, period_range
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
class GetNumericData:
diff --git a/asv_bench/benchmarks/gil.py b/asv_bench/benchmarks/gil.py
index f07d31f0b9db8..e266d871f5bc6 100644
--- a/asv_bench/benchmarks/gil.py
+++ b/asv_bench/benchmarks/gil.py
@@ -2,7 +2,8 @@
from pandas import DataFrame, Series, date_range, factorize, read_csv
from pandas.core.algorithms import take_1d
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
try:
from pandas import (
diff --git a/asv_bench/benchmarks/groupby.py b/asv_bench/benchmarks/groupby.py
index d51c53e2264f1..28e0dcc5d9b13 100644
--- a/asv_bench/benchmarks/groupby.py
+++ b/asv_bench/benchmarks/groupby.py
@@ -13,7 +13,8 @@
date_range,
period_range,
)
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
method_blacklist = {
"object": {
diff --git a/asv_bench/benchmarks/index_object.py b/asv_bench/benchmarks/index_object.py
index d69799eb70040..103141545504b 100644
--- a/asv_bench/benchmarks/index_object.py
+++ b/asv_bench/benchmarks/index_object.py
@@ -12,7 +12,8 @@
Series,
date_range,
)
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
class SetOperations:
diff --git a/asv_bench/benchmarks/indexing.py b/asv_bench/benchmarks/indexing.py
index 6453649b91270..087fe3916845b 100644
--- a/asv_bench/benchmarks/indexing.py
+++ b/asv_bench/benchmarks/indexing.py
@@ -17,7 +17,8 @@
option_context,
period_range,
)
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
class NumericSeriesIndexing:
diff --git a/asv_bench/benchmarks/inference.py b/asv_bench/benchmarks/inference.py
index e85b3bd2c7687..1a8d5ede52512 100644
--- a/asv_bench/benchmarks/inference.py
+++ b/asv_bench/benchmarks/inference.py
@@ -1,9 +1,8 @@
import numpy as np
from pandas import DataFrame, Series, to_numeric
-import pandas.util.testing as tm
-from .pandas_vb_common import lib, numeric_dtypes
+from .pandas_vb_common import lib, numeric_dtypes, tm
class NumericInferOps:
diff --git a/asv_bench/benchmarks/io/csv.py b/asv_bench/benchmarks/io/csv.py
index b8e8630e663ee..9bcd125f56bbb 100644
--- a/asv_bench/benchmarks/io/csv.py
+++ b/asv_bench/benchmarks/io/csv.py
@@ -5,9 +5,8 @@
import numpy as np
from pandas import Categorical, DataFrame, date_range, read_csv, to_datetime
-import pandas.util.testing as tm
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
class ToCSV(BaseIO):
diff --git a/asv_bench/benchmarks/io/excel.py b/asv_bench/benchmarks/io/excel.py
index 75d87140488e3..80af2cff41769 100644
--- a/asv_bench/benchmarks/io/excel.py
+++ b/asv_bench/benchmarks/io/excel.py
@@ -6,7 +6,8 @@
from odf.text import P
from pandas import DataFrame, ExcelWriter, date_range, read_excel
-import pandas.util.testing as tm
+
+from ..pandas_vb_common import tm
def _generate_dataframe():
diff --git a/asv_bench/benchmarks/io/hdf.py b/asv_bench/benchmarks/io/hdf.py
index 88c1a3dc48ea4..4ca399a293a4b 100644
--- a/asv_bench/benchmarks/io/hdf.py
+++ b/asv_bench/benchmarks/io/hdf.py
@@ -1,9 +1,8 @@
import numpy as np
from pandas import DataFrame, HDFStore, date_range, read_hdf
-import pandas.util.testing as tm
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
class HDFStoreDataFrame(BaseIO):
diff --git a/asv_bench/benchmarks/io/json.py b/asv_bench/benchmarks/io/json.py
index 27096bcaba78b..f478bf2aee0ba 100644
--- a/asv_bench/benchmarks/io/json.py
+++ b/asv_bench/benchmarks/io/json.py
@@ -1,9 +1,8 @@
import numpy as np
from pandas import DataFrame, concat, date_range, read_json, timedelta_range
-import pandas.util.testing as tm
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
class ReadJSON(BaseIO):
diff --git a/asv_bench/benchmarks/io/pickle.py b/asv_bench/benchmarks/io/pickle.py
index 12620656dd2bf..4ca9a82ae4827 100644
--- a/asv_bench/benchmarks/io/pickle.py
+++ b/asv_bench/benchmarks/io/pickle.py
@@ -1,9 +1,8 @@
import numpy as np
from pandas import DataFrame, date_range, read_pickle
-import pandas.util.testing as tm
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
class Pickle(BaseIO):
diff --git a/asv_bench/benchmarks/io/sql.py b/asv_bench/benchmarks/io/sql.py
index 6cc7f56ae3d65..b71bb832280b9 100644
--- a/asv_bench/benchmarks/io/sql.py
+++ b/asv_bench/benchmarks/io/sql.py
@@ -4,7 +4,8 @@
from sqlalchemy import create_engine
from pandas import DataFrame, date_range, read_sql_query, read_sql_table
-import pandas.util.testing as tm
+
+from ..pandas_vb_common import tm
class SQL:
diff --git a/asv_bench/benchmarks/io/stata.py b/asv_bench/benchmarks/io/stata.py
index f3125f8598418..9faafa82ff46e 100644
--- a/asv_bench/benchmarks/io/stata.py
+++ b/asv_bench/benchmarks/io/stata.py
@@ -1,9 +1,8 @@
import numpy as np
from pandas import DataFrame, date_range, read_stata
-import pandas.util.testing as tm
-from ..pandas_vb_common import BaseIO
+from ..pandas_vb_common import BaseIO, tm
class Stata(BaseIO):
diff --git a/asv_bench/benchmarks/join_merge.py b/asv_bench/benchmarks/join_merge.py
index 5cf9f6336ba0c..1333b3a0f0560 100644
--- a/asv_bench/benchmarks/join_merge.py
+++ b/asv_bench/benchmarks/join_merge.py
@@ -3,7 +3,8 @@
import numpy as np
from pandas import DataFrame, MultiIndex, Series, concat, date_range, merge, merge_asof
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
try:
from pandas import merge_ordered
diff --git a/asv_bench/benchmarks/multiindex_object.py b/asv_bench/benchmarks/multiindex_object.py
index 5a396c9f0deff..0e188c58012fa 100644
--- a/asv_bench/benchmarks/multiindex_object.py
+++ b/asv_bench/benchmarks/multiindex_object.py
@@ -3,7 +3,8 @@
import numpy as np
from pandas import DataFrame, MultiIndex, RangeIndex, date_range
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
class GetLoc:
diff --git a/asv_bench/benchmarks/pandas_vb_common.py b/asv_bench/benchmarks/pandas_vb_common.py
index 1faf13329110d..6da2b2270c04a 100644
--- a/asv_bench/benchmarks/pandas_vb_common.py
+++ b/asv_bench/benchmarks/pandas_vb_common.py
@@ -13,6 +13,13 @@
except (ImportError, TypeError, ValueError):
pass
+# Compatibility import for the testing module
+try:
+ import pandas._testing as tm # noqa
+except ImportError:
+ import pandas.util.testing as tm # noqa
+
+
numeric_dtypes = [
np.int64,
np.int32,
diff --git a/asv_bench/benchmarks/reindex.py b/asv_bench/benchmarks/reindex.py
index cd450f801c805..03394e6fe08cb 100644
--- a/asv_bench/benchmarks/reindex.py
+++ b/asv_bench/benchmarks/reindex.py
@@ -1,9 +1,8 @@
import numpy as np
from pandas import DataFrame, Index, MultiIndex, Series, date_range, period_range
-import pandas.util.testing as tm
-from .pandas_vb_common import lib
+from .pandas_vb_common import lib, tm
class Reindex:
diff --git a/asv_bench/benchmarks/series_methods.py b/asv_bench/benchmarks/series_methods.py
index a3f1d92545c3f..57c625ced8a43 100644
--- a/asv_bench/benchmarks/series_methods.py
+++ b/asv_bench/benchmarks/series_methods.py
@@ -3,7 +3,8 @@
import numpy as np
from pandas import NaT, Series, date_range
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
class SeriesConstructor:
diff --git a/asv_bench/benchmarks/strings.py b/asv_bench/benchmarks/strings.py
index f30b2482615bd..d7fb2775376c0 100644
--- a/asv_bench/benchmarks/strings.py
+++ b/asv_bench/benchmarks/strings.py
@@ -3,7 +3,8 @@
import numpy as np
from pandas import DataFrame, Series
-import pandas.util.testing as tm
+
+from .pandas_vb_common import tm
class Methods:
| See https://github.com/pandas-dev/pandas/pull/30779, this avoids a warning in the benchmarks | https://api.github.com/repos/pandas-dev/pandas/pulls/30810 | 2020-01-08T07:49:36Z | 2020-01-08T14:06:40Z | 2020-01-08T14:06:40Z | 2020-01-08T14:06:42Z |
REF: move repeat to ExtensionIndex | diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index a10e0f63b841d..06678672c8126 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -460,12 +460,6 @@ def isin(self, values, level=None):
return algorithms.isin(self.asi8, values.asi8)
- @Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
- def repeat(self, repeats, axis=None):
- nv.validate_repeat(tuple(), dict(axis=axis))
- result = type(self._data)(self.asi8.repeat(repeats), dtype=self.dtype)
- return self._shallow_copy(result)
-
@Appender(_index_shared_docs["where"] % _index_doc_kwargs)
def where(self, cond, other=None):
values = self.view("i8")
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index f0f407e9e8308..0178fe864801f 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -164,6 +164,11 @@ class ExtensionIndex(Index):
_data: ExtensionArray
+ def repeat(self, repeats, axis=None):
+ nv.validate_repeat(tuple(), dict(axis=axis))
+ result = self._data.repeat(repeats, axis=axis)
+ return self._shallow_copy(result)
+
def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
nv.validate_take(tuple(), kwargs)
indices = ensure_platform_int(indices)
| https://api.github.com/repos/pandas-dev/pandas/pulls/30809 | 2020-01-08T03:17:45Z | 2020-01-08T13:30:44Z | 2020-01-08T13:30:44Z | 2020-01-08T18:21:39Z | |
CLN: remove Index __setstate__ methods | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 087db014de5b3..732eba804d469 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -1726,35 +1726,6 @@ def __reduce__(self):
d.update(self._get_attributes_dict())
return _new_Index, (type(self), d), None
- def __setstate__(self, state):
- """
- Necessary for making this object picklable.
- """
-
- if isinstance(state, dict):
- self._data = state.pop("data")
- for k, v in state.items():
- setattr(self, k, v)
-
- elif isinstance(state, tuple):
-
- if len(state) == 2:
- nd_state, own_state = state
- data = np.empty(nd_state[1], dtype=nd_state[2])
- np.ndarray.__setstate__(data, nd_state)
- self._name = own_state[0]
-
- else: # pragma: no cover
- data = np.empty(state)
- np.ndarray.__setstate__(data, state)
-
- self._data = data
- self._reset_identity()
- else:
- raise Exception("invalid pickle state")
-
- _unpickle_compat = __setstate__
-
# --------------------------------------------------------------------
# Null Handling Methods
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 88b841e7d4a88..9db30ce710c0d 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -319,41 +319,6 @@ def __reduce__(self):
d.update(self._get_attributes_dict())
return _new_DatetimeIndex, (type(self), d), None
- def __setstate__(self, state):
- """
- Necessary for making this object picklable.
- """
- if isinstance(state, dict):
- super().__setstate__(state)
-
- elif isinstance(state, tuple):
-
- # < 0.15 compat
- if len(state) == 2:
- nd_state, own_state = state
- data = np.empty(nd_state[1], dtype=nd_state[2])
- np.ndarray.__setstate__(data, nd_state)
-
- freq = own_state[1]
- tz = timezones.tz_standardize(own_state[2])
- dtype = tz_to_dtype(tz)
- dtarr = DatetimeArray._simple_new(data, freq=freq, dtype=dtype)
-
- self.name = own_state[0]
-
- else: # pragma: no cover
- data = np.empty(state)
- np.ndarray.__setstate__(data, state)
- dtarr = DatetimeArray(data)
-
- self._data = dtarr
- self._reset_identity()
-
- else:
- raise Exception("invalid pickle state")
-
- _unpickle_compat = __setstate__
-
def _convert_for_op(self, value):
"""
Convert value to be insertable to ndarray.
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 1fed0201f7b2b..c3832e0bac2d6 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -826,36 +826,6 @@ def _apply_meta(self, rawarr):
rawarr = PeriodIndex._simple_new(rawarr, freq=self.freq, name=self.name)
return rawarr
- def __setstate__(self, state):
- """Necessary for making this object picklable"""
-
- if isinstance(state, dict):
- super().__setstate__(state)
-
- elif isinstance(state, tuple):
-
- # < 0.15 compat
- if len(state) == 2:
- nd_state, own_state = state
- data = np.empty(nd_state[1], dtype=nd_state[2])
- np.ndarray.__setstate__(data, nd_state)
-
- # backcompat
- freq = Period._maybe_convert_freq(own_state[1])
-
- else: # pragma: no cover
- data = np.empty(state)
- np.ndarray.__setstate__(self, state)
- freq = None # ?
-
- data = PeriodArray(data, freq=freq)
- self._data = data
-
- else:
- raise Exception("invalid pickle state")
-
- _unpickle_compat = __setstate__
-
def memory_usage(self, deep=False):
result = super().memory_usage(deep=deep)
if hasattr(self, "_cache") and "_int64index" in self._cache:
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index 59fc53a17590c..d1d8db0746cf8 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -202,17 +202,6 @@ def _simple_new(cls, values, name=None, freq=None, dtype=_TD_DTYPE):
result._reset_identity()
return result
- # -------------------------------------------------------------------
-
- def __setstate__(self, state):
- """Necessary for making this object picklable"""
- if isinstance(state, dict):
- super().__setstate__(state)
- else:
- raise Exception("invalid pickle state")
-
- _unpickle_compat = __setstate__
-
# -------------------------------------------------------------------
# Rendering Methods
| They are not hit in tests, AFAICT they are subsumed by `__reduce__` methods | https://api.github.com/repos/pandas-dev/pandas/pulls/30807 | 2020-01-08T01:26:01Z | 2020-01-08T12:49:25Z | 2020-01-08T12:49:25Z | 2020-01-08T18:01:46Z |
REF: use shareable code for DTI/TDI.insert | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 78a8ba5cddea0..40737899ba98e 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -872,6 +872,7 @@ Datetimelike
- Bug in :func:`pandas.to_datetime` when called with ``Series`` storing ``IntegerArray`` raising ``TypeError`` instead of returning ``Series`` (:issue:`30050`)
- Bug in :func:`date_range` with custom business hours as ``freq`` and given number of ``periods`` (:issue:`30593`)
- Bug in :class:`PeriodIndex` comparisons with incorrectly casting integers to :class:`Period` objects, inconsistent with the :class:`Period` comparison behavior (:issue:`30722`)
+- Bug in :meth:`DatetimeIndex.insert` raising a ``ValueError`` instead of a ``TypeError`` when trying to insert a timezone-aware :class:`Timestamp` into a timezone-naive :class:`DatetimeIndex`, or vice-versa (:issue:`30806`)
Timedelta
^^^^^^^^^
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index 9db30ce710c0d..f5dc12fe73c9f 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -887,7 +887,9 @@ def insert(self, loc, item):
-------
new_index : Index
"""
- if is_valid_nat_for_dtype(item, self.dtype):
+ if isinstance(item, self._data._recognized_scalars):
+ item = self._data._scalar_type(item)
+ elif is_valid_nat_for_dtype(item, self.dtype):
# GH 18295
item = self._na_value
elif is_scalar(item) and isna(item):
@@ -897,11 +899,8 @@ def insert(self, loc, item):
)
freq = None
-
- if isinstance(item, (datetime, np.datetime64)):
- self._assert_can_do_op(item)
- if not self._has_same_tz(item) and not isna(item):
- raise ValueError("Passed item and index have different timezone")
+ if isinstance(item, self._data._scalar_type) or item is NaT:
+ self._data._check_compatible_with(item, setitem=True)
# check freq can be preserved on edge cases
if self.size and self.freq is not None:
@@ -911,19 +910,21 @@ def insert(self, loc, item):
freq = self.freq
elif (loc == len(self)) and item - self.freq == self[-1]:
freq = self.freq
- item = _to_M8(item, tz=self.tz)
+ item = item.asm8
try:
- new_dates = np.concatenate(
+ new_i8s = np.concatenate(
(self[:loc].asi8, [item.view(np.int64)], self[loc:].asi8)
)
- return self._shallow_copy(new_dates, freq=freq)
+ return self._shallow_copy(new_i8s, freq=freq)
except (AttributeError, TypeError):
# fall back to object index
if isinstance(item, str):
return self.astype(object).insert(loc, item)
- raise TypeError("cannot insert DatetimeIndex with incompatible label")
+ raise TypeError(
+ f"cannot insert {type(self).__name__} with incompatible label"
+ )
def indexer_at_time(self, time, asof=False):
"""
diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py
index d1d8db0746cf8..695e03843e896 100644
--- a/pandas/core/indexes/timedeltas.py
+++ b/pandas/core/indexes/timedeltas.py
@@ -387,7 +387,7 @@ def insert(self, loc, item):
"""
# try to convert if possible
if isinstance(item, self._data._recognized_scalars):
- item = Timedelta(item)
+ item = self._data._scalar_type(item)
elif is_valid_nat_for_dtype(item, self.dtype):
# GH 18295
item = self._na_value
@@ -398,28 +398,32 @@ def insert(self, loc, item):
)
freq = None
- if isinstance(item, Timedelta) or (is_scalar(item) and isna(item)):
+ if isinstance(item, self._data._scalar_type) or item is NaT:
+ self._data._check_compatible_with(item, setitem=True)
# check freq can be preserved on edge cases
- if self.freq is not None:
- if (loc == 0 or loc == -len(self)) and item + self.freq == self[0]:
+ if self.size and self.freq is not None:
+ if item is NaT:
+ pass
+ elif (loc == 0 or loc == -len(self)) and item + self.freq == self[0]:
freq = self.freq
elif (loc == len(self)) and item - self.freq == self[-1]:
freq = self.freq
- item = Timedelta(item).asm8.view(_TD_DTYPE)
+ item = item.asm8
try:
- new_tds = np.concatenate(
+ new_i8s = np.concatenate(
(self[:loc].asi8, [item.view(np.int64)], self[loc:].asi8)
)
- return self._shallow_copy(new_tds, freq=freq)
-
+ return self._shallow_copy(new_i8s, freq=freq)
except (AttributeError, TypeError):
# fall back to object index
if isinstance(item, str):
return self.astype(object).insert(loc, item)
- raise TypeError("cannot insert TimedeltaIndex with incompatible label")
+ raise TypeError(
+ f"cannot insert {type(self).__name__} with incompatible label"
+ )
TimedeltaIndex._add_comparison_ops()
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index 1dfd95551f68d..d3f9ac4f3f8b2 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -27,7 +27,6 @@
date_range,
)
import pandas._testing as tm
-from pandas.core.indexes.datetimes import _to_M8
from pandas.core.ops import roperator
from pandas.tests.arithmetic.common import (
assert_invalid_addsub_type,
@@ -341,7 +340,7 @@ class TestDatetimeIndexComparisons:
def test_comparators(self, op):
index = tm.makeDateIndex(100)
element = index[len(index) // 2]
- element = _to_M8(element)
+ element = Timestamp(element).to_datetime64()
arr = np.array(index)
arr_result = op(arr, element)
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index 97290c8c635b8..1153d1619899c 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -434,9 +434,9 @@ def test_insert(self):
# see gh-7299
idx = date_range("1/1/2000", periods=3, freq="D", tz="Asia/Tokyo", name="idx")
- with pytest.raises(ValueError):
+ with pytest.raises(TypeError, match="Cannot compare tz-naive and tz-aware"):
idx.insert(3, pd.Timestamp("2000-01-04"))
- with pytest.raises(ValueError):
+ with pytest.raises(TypeError, match="Cannot compare tz-naive and tz-aware"):
idx.insert(3, datetime(2000, 1, 4))
with pytest.raises(ValueError):
idx.insert(3, pd.Timestamp("2000-01-04", tz="US/Eastern"))
diff --git a/pandas/tests/indexing/test_coercion.py b/pandas/tests/indexing/test_coercion.py
index 8843f6c08fe80..b904755b099d0 100644
--- a/pandas/tests/indexing/test_coercion.py
+++ b/pandas/tests/indexing/test_coercion.py
@@ -432,13 +432,19 @@ def test_insert_index_datetimes(self, fill_val, exp_dtype):
)
self._assert_insert_conversion(obj, fill_val, exp, exp_dtype)
- msg = "Passed item and index have different timezone"
if fill_val.tz:
- with pytest.raises(ValueError, match=msg):
+ msg = "Cannot compare tz-naive and tz-aware"
+ with pytest.raises(TypeError, match=msg):
obj.insert(1, pd.Timestamp("2012-01-01"))
- with pytest.raises(ValueError, match=msg):
- obj.insert(1, pd.Timestamp("2012-01-01", tz="Asia/Tokyo"))
+ msg = "Timezones don't match"
+ with pytest.raises(ValueError, match=msg):
+ obj.insert(1, pd.Timestamp("2012-01-01", tz="Asia/Tokyo"))
+
+ else:
+ msg = "Cannot compare tz-naive and tz-aware"
+ with pytest.raises(TypeError, match=msg):
+ obj.insert(1, pd.Timestamp("2012-01-01", tz="Asia/Tokyo"))
msg = "cannot insert DatetimeIndex with incompatible label"
with pytest.raises(TypeError, match=msg):
| xref #30757 should go in before this because it contains the tests. After this, we'll be able to de-duplicate the two methods. | https://api.github.com/repos/pandas-dev/pandas/pulls/30806 | 2020-01-08T01:20:50Z | 2020-01-09T02:54:53Z | 2020-01-09T02:54:53Z | 2020-01-09T05:06:37Z |
Multi Phase JSON Initialization | diff --git a/pandas/_libs/src/ujson/python/ujson.c b/pandas/_libs/src/ujson/python/ujson.c
index 39320d73d0cab..4a88fb7a4e849 100644
--- a/pandas/_libs/src/ujson/python/ujson.c
+++ b/pandas/_libs/src/ujson/python/ujson.c
@@ -65,35 +65,15 @@ static PyMethodDef ujsonMethods[] = {
{NULL, NULL, 0, NULL} /* Sentinel */
};
-static struct PyModuleDef moduledef = {
- PyModuleDef_HEAD_INIT,
- "_libjson",
- 0, /* m_doc */
- -1, /* m_size */
- ujsonMethods, /* m_methods */
- NULL, /* m_reload */
- NULL, /* m_traverse */
- NULL, /* m_clear */
- NULL /* m_free */
+static PyModuleDef moduledef = {
+ .m_base = PyModuleDef_HEAD_INIT,
+ .m_name = "_libjson",
+ .m_methods = ujsonMethods
};
-#define PYMODINITFUNC PyMODINIT_FUNC PyInit_json(void)
-#define PYMODULE_CREATE() PyModule_Create(&moduledef)
-#define MODINITERROR return NULL
-PYMODINITFUNC {
- PyObject *module;
- PyObject *version_string;
+PyMODINIT_FUNC PyInit_json(void) {
+ initObjToJSON(); // TODO: clean up, maybe via tp_free?
+ return PyModuleDef_Init(&moduledef);
- initObjToJSON();
- module = PYMODULE_CREATE();
-
- if (module == NULL) {
- MODINITERROR;
- }
-
- version_string = PyUnicode_FromString(UJSON_VERSION);
- PyModule_AddObject(module, "__version__", version_string);
-
- return module;
}
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index f50492c58a370..bedd60084124c 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -559,11 +559,6 @@ def test_loads_non_str_bytes_raises(self):
with pytest.raises(TypeError, match=msg):
ujson.loads(None)
- def test_version(self):
- assert re.match(
- r"^\d+\.\d+(\.\d+)?$", ujson.__version__
- ), "ujson.__version__ must be a string like '1.4.0'"
-
def test_encode_numeric_overflow(self):
with pytest.raises(OverflowError):
ujson.encode(12839128391289382193812939)
| Feature in Python 3.5 that should simplify instantiation of the JSON module and make it more "pythonic"
https://docs.python.org/3/c-api/module.html?highlight=multi%20phase#multi-phase-initialization
https://www.python.org/dev/peps/pep-0489/
Also removed a version string from within the extension, as I don't see where that is useful
| https://api.github.com/repos/pandas-dev/pandas/pulls/30805 | 2020-01-08T00:53:34Z | 2020-01-08T12:55:47Z | 2020-01-08T12:55:47Z | 2020-01-08T16:17:01Z |
REF: PeriodIndex._union | diff --git a/pandas/core/indexes/base.py b/pandas/core/indexes/base.py
index 087db014de5b3..0ede340720922 100644
--- a/pandas/core/indexes/base.py
+++ b/pandas/core/indexes/base.py
@@ -2310,11 +2310,11 @@ def _union(self, other, sort):
return other._get_reconciled_name_object(self)
# TODO(EA): setops-refactor, clean all this up
- if is_period_dtype(self) or is_datetime64tz_dtype(self):
+ if is_datetime64tz_dtype(self):
lvals = self._ndarray_values
else:
lvals = self._values
- if is_period_dtype(other) or is_datetime64tz_dtype(other):
+ if is_datetime64tz_dtype(other):
rvals = other._ndarray_values
else:
rvals = other._values
diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index f61721a0e51e6..0c709e562517b 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -388,6 +388,8 @@ def values(self):
def _wrap_setop_result(self, other, result):
name = get_op_result_name(self, other)
+ # We use _shallow_copy rather than the Index implementation
+ # (which uses _constructor) in order to preserve dtype.
return self._shallow_copy(result, name=name)
@Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 1fed0201f7b2b..89ae665c36376 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -768,12 +768,6 @@ def _assert_can_do_setop(self, other):
if isinstance(other, PeriodIndex) and self.freq != other.freq:
raise raise_on_incompatible(self, other)
- def _wrap_setop_result(self, other, result):
- name = get_op_result_name(self, other)
- result = self._apply_meta(result)
- result.name = name
- return result
-
def intersection(self, other, sort=False):
self._validate_sort_keyword(sort)
self._assert_can_do_setop(other)
@@ -819,6 +813,26 @@ def difference(self, other, sort=None):
result = self._shallow_copy(np.asarray(i8result, dtype=np.int64), name=res_name)
return result
+ def _union(self, other, sort):
+ if not len(other) or self.equals(other) or not len(self):
+ return super()._union(other, sort=sort)
+
+ # We are called by `union`, which is responsible for this validation
+ assert isinstance(other, type(self))
+
+ if not is_dtype_equal(self.dtype, other.dtype):
+ this = self.astype("O")
+ other = other.astype("O")
+ return this._union(other, sort=sort)
+
+ i8self = Int64Index._simple_new(self.asi8)
+ i8other = Int64Index._simple_new(other.asi8)
+ i8result = i8self._union(i8other, sort=sort)
+
+ res_name = get_op_result_name(self, other)
+ result = self._shallow_copy(np.asarray(i8result, dtype=np.int64), name=res_name)
+ return result
+
# ------------------------------------------------------------------------
def _apply_meta(self, rawarr):
| Let's us get rid of PeriodIndex._wrap_setop_result, soon we'll share code among the PeriodIndex set ops, so this will be less verbose | https://api.github.com/repos/pandas-dev/pandas/pulls/30803 | 2020-01-08T00:13:06Z | 2020-01-08T02:08:55Z | 2020-01-08T02:08:55Z | 2020-01-08T02:22:39Z |
CI: Fix spelling in requirements-dev generator script | diff --git a/requirements-dev.txt b/requirements-dev.txt
index f4f5fed82662c..017e6258d9941 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,5 +1,5 @@
# This file is auto-generated from environment.yml, do not modify.
-# See that file for comments about the need/usage of each depdendency.
+# See that file for comments about the need/usage of each dependency.
numpy>=1.15
python-dateutil>=2.6.1
diff --git a/scripts/generate_pip_deps_from_conda.py b/scripts/generate_pip_deps_from_conda.py
index 3b14d61ce4254..53a27e8782ad7 100755
--- a/scripts/generate_pip_deps_from_conda.py
+++ b/scripts/generate_pip_deps_from_conda.py
@@ -92,7 +92,7 @@ def main(conda_fname, pip_fname, compare=False):
fname = os.path.split(conda_fname)[1]
header = (
f"# This file is auto-generated from {fname}, do not modify.\n"
- "# See that file for comments about the need/usage of each depdendency.\n\n"
+ "# See that file for comments about the need/usage of each dependency.\n\n"
)
pip_content = header + "\n".join(pip_deps)
| Fixes the spelling of _dependency_ in `script/generate_pip_deps_from_conda.py`.
This script creates `requirements-dev.txt` which contains the spelling mistake, so is also fixed (using the updated script). | https://api.github.com/repos/pandas-dev/pandas/pulls/30802 | 2020-01-08T00:08:06Z | 2020-01-08T01:21:05Z | 2020-01-08T01:21:05Z | 2020-01-08T10:22:08Z |
REF: remove PeriodIndex._coerce_scalar_to_index | diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 1fed0201f7b2b..e805c2512dc3b 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -391,16 +391,6 @@ def _int64index(self):
# ------------------------------------------------------------------------
# Index Methods
- def _coerce_scalar_to_index(self, item):
- """
- we need to coerce a scalar to a compat for our index type
-
- Parameters
- ----------
- item : scalar item to coerce
- """
- return PeriodIndex([item], **self._get_attributes_dict())
-
def __array__(self, dtype=None):
if is_integer_dtype(dtype):
return self.asi8
| It is only used by Index.insert, but PeriodIndex now overrides insert. | https://api.github.com/repos/pandas-dev/pandas/pulls/30801 | 2020-01-08T00:02:52Z | 2020-01-08T03:21:17Z | 2020-01-08T03:21:17Z | 2020-01-08T18:07:47Z |
REF: move astype to ExtensionIndex | diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py
index f61721a0e51e6..dc1e8d359af55 100644
--- a/pandas/core/indexes/category.py
+++ b/pandas/core/indexes/category.py
@@ -190,13 +190,7 @@ def _engine_type(self):
# Constructors
def __new__(
- cls,
- data=None,
- categories=None,
- ordered=None,
- dtype=None,
- copy=False,
- name=None,
+ cls, data=None, categories=None, ordered=None, dtype=None, copy=False, name=None
):
dtype = CategoricalDtype._from_values_or_dtype(data, categories, ordered, dtype)
@@ -414,7 +408,7 @@ def astype(self, dtype, copy=True):
if dtype == self.dtype:
return self.copy() if copy else self
- return super().astype(dtype=dtype, copy=copy)
+ return Index.astype(self, dtype=dtype, copy=copy)
@cache_readonly
def _isnan(self):
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index a10e0f63b841d..6abd7d52d4071 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -542,18 +542,6 @@ def _concat_same_dtype(self, to_concat, name):
return self._simple_new(new_data, **attribs)
- @Appender(_index_shared_docs["astype"])
- def astype(self, dtype, copy=True):
- if is_dtype_equal(self.dtype, dtype) and copy is False:
- # Ensure that self.astype(self.dtype) is self
- return self
-
- new_values = self._data.astype(dtype, copy=copy)
-
- # pass copy=False because any copying will be done in the
- # _data.astype call above
- return Index(new_values, dtype=new_values.dtype, name=self.name, copy=False)
-
def shift(self, periods=1, freq=None):
"""
Shift index by desired number of time frequency increments.
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index f0f407e9e8308..bb8b0343a3e2c 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -6,7 +6,7 @@
from pandas.compat.numpy import function as nv
from pandas.util._decorators import cache_readonly
-from pandas.core.dtypes.common import ensure_platform_int
+from pandas.core.dtypes.common import ensure_platform_int, is_dtype_equal
from pandas.core.dtypes.generic import ABCSeries
from pandas.core.arrays import ExtensionArray
@@ -192,3 +192,14 @@ def _get_unique_index(self, dropna=False):
if dropna and self.hasnans:
result = result[~result.isna()]
return self._shallow_copy(result)
+
+ def astype(self, dtype, copy=True):
+ if is_dtype_equal(self.dtype, dtype) and copy is False:
+ # Ensure that self.astype(self.dtype) is self
+ return self
+
+ new_values = self._data.astype(dtype, copy=copy)
+
+ # pass copy=False because any copying will be done in the
+ # _data.astype call above
+ return Index(new_values, dtype=new_values.dtype, name=self.name, copy=False)
diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 6cf577f498162..24e3289d37c41 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -426,7 +426,7 @@ def astype(self, dtype, copy=True):
new_values = self.values.astype(dtype, copy=copy)
if is_interval_dtype(new_values):
return self._shallow_copy(new_values.left, new_values.right)
- return super().astype(dtype, copy=copy)
+ return Index.astype(self, dtype, copy=copy)
@property
def inferred_type(self) -> str:
| Broken off from #30717 | https://api.github.com/repos/pandas-dev/pandas/pulls/30800 | 2020-01-07T23:58:34Z | 2020-01-08T12:54:51Z | 2020-01-08T12:54:51Z | 2020-01-08T18:20:44Z |
Tests for Deprecate SparseArray for python 3.6 and 3.7 and fixes to other deprecation tests | diff --git a/pandas/__init__.py b/pandas/__init__.py
index 10d65e41d3030..491bcb21f245d 100644
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -297,13 +297,25 @@ def __getattr__(self, item):
np = __numpy()
- class __Datetime:
- def __init__(self):
- from datetime import datetime as dt
+ class __Datetime(type):
- self.datetime = dt
+ from datetime import datetime as dt
- def __getattr__(self, item):
+ datetime = dt
+
+ def __getattr__(cls, item):
+ cls.emit_warning()
+
+ try:
+ return getattr(cls.datetime, item)
+ except AttributeError:
+ raise AttributeError(f"module datetime has no attribute {item}")
+
+ def __instancecheck__(cls, other):
+ return isinstance(other, cls.datetime)
+
+ class __DatetimeSub(metaclass=__Datetime):
+ def emit_warning(dummy=0):
import warnings
warnings.warn(
@@ -311,18 +323,45 @@ def __getattr__(self, item):
"and will be removed from pandas in a future version. "
"Import from datetime instead.",
FutureWarning,
- stacklevel=2,
+ stacklevel=3,
)
- try:
- return getattr(self.datetime, item)
- except AttributeError:
- raise AttributeError(f"module datetime has no attribute {item}")
+ def __new__(cls, *args, **kwargs):
+ cls.emit_warning()
+ from datetime import datetime as dt
- datetime = __Datetime().datetime
+ return dt(*args, **kwargs)
- class SparseArray:
- pass
+ datetime = __DatetimeSub
+
+ class __SparseArray(type):
+
+ from pandas.core.arrays.sparse import SparseArray as sa
+
+ SparseArray = sa
+
+ def __instancecheck__(cls, other):
+ return isinstance(other, cls.SparseArray)
+
+ class __SparseArraySub(metaclass=__SparseArray):
+ def emit_warning(dummy=0):
+ import warnings
+
+ warnings.warn(
+ "The pandas.SparseArray class is deprecated "
+ "and will be removed from pandas in a future version. "
+ "Use pandas.arrays.SparseArray instead.",
+ FutureWarning,
+ stacklevel=3,
+ )
+
+ def __new__(cls, *args, **kwargs):
+ cls.emit_warning()
+ from pandas.core.arrays.sparse import SparseArray as sa
+
+ return sa(*args, **kwargs)
+
+ SparseArray = __SparseArraySub
# module level doc-string
diff --git a/pandas/tests/api/test_api.py b/pandas/tests/api/test_api.py
index fb2615a7b34f3..8b897524cb053 100644
--- a/pandas/tests/api/test_api.py
+++ b/pandas/tests/api/test_api.py
@@ -43,7 +43,7 @@ class TestPDApi(Base):
]
# these are already deprecated; awaiting removal
- deprecated_modules: List[str] = []
+ deprecated_modules: List[str] = ["np", "datetime"]
# misc
misc = ["IndexSlice", "NaT", "NA"]
@@ -90,15 +90,17 @@ class TestPDApi(Base):
"UInt64Dtype",
"NamedAgg",
]
- if not compat.PY37:
- classes.extend(["Panel", "SparseSeries", "SparseDataFrame", "SparseArray"])
- deprecated_modules.extend(["np", "datetime"])
# these are already deprecated; awaiting removal
deprecated_classes: List[str] = []
# these should be deprecated in the future
- deprecated_classes_in_future: List[str] = []
+ deprecated_classes_in_future: List[str] = ["SparseArray"]
+
+ if not compat.PY37:
+ classes.extend(["Panel", "SparseSeries", "SparseDataFrame"])
+ # deprecated_modules.extend(["np", "datetime"])
+ # deprecated_classes_in_future.extend(["SparseArray"])
# external modules exposed in pandas namespace
modules: List[str] = []
@@ -201,44 +203,46 @@ class TestPDApi(Base):
def test_api(self):
- self.check(
- pd,
+ checkthese = (
self.lib
+ self.misc
+ self.modules
- + self.deprecated_modules
+ self.classes
- + self.deprecated_classes
- + self.deprecated_classes_in_future
+ self.funcs
+ self.funcs_option
+ self.funcs_read
+ self.funcs_json
+ self.funcs_to
- + self.deprecated_funcs_in_future
- + self.deprecated_funcs
- + self.private_modules,
- self.ignored,
+ + self.private_modules
)
+ if not compat.PY37:
+ checkthese.extend(
+ self.deprecated_modules
+ + self.deprecated_classes
+ + self.deprecated_classes_in_future
+ + self.deprecated_funcs_in_future
+ + self.deprecated_funcs
+ )
+ self.check(pd, checkthese, self.ignored)
def test_depr(self):
- deprecated = (
+ deprecated_list = (
self.deprecated_modules
+ self.deprecated_classes
+ self.deprecated_classes_in_future
+ self.deprecated_funcs
+ self.deprecated_funcs_in_future
)
- for depr in deprecated:
+ for depr in deprecated_list:
with tm.assert_produces_warning(FutureWarning):
- if compat.PY37:
- getattr(pd, depr)
- elif depr == "datetime":
- deprecated = getattr(pd, "__Datetime")
- deprecated().__getattr__(dir(pd.datetime)[-1])
- else:
- deprecated = getattr(pd, depr)
- deprecated.__getattr__(dir(deprecated)[-1])
+ deprecated = getattr(pd, depr)
+ if not compat.PY37:
+ if depr == "datetime":
+ deprecated.__getattr__(dir(pd.datetime.datetime)[-1])
+ elif depr == "SparseArray":
+ deprecated([])
+ else:
+ deprecated.__getattr__(dir(deprecated)[-1])
def test_datetime():
@@ -249,6 +253,16 @@ def test_datetime():
warnings.simplefilter("ignore", FutureWarning)
assert datetime(2015, 1, 2, 0, 0) == pd.datetime(2015, 1, 2, 0, 0)
+ assert isinstance(pd.datetime(2015, 1, 2, 0, 0), pd.datetime)
+
+
+def test_sparsearray():
+ import warnings
+
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore", FutureWarning)
+ assert isinstance(pd.array([1, 2, 3], dtype="Sparse"), pd.SparseArray)
+
def test_np():
import numpy as np
| - [x] closes #30642
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
- N/A
Turns out that the existing tests were not testing deprecation correctly for both python 3.7 and python 3.6, so had to change some of the code in `test_api.py` to make that work right.
For `pd.SparseArray` in python 3.6, we can only issue a warning when the constructor `pd.SparseArray` is used. But this is consistent with `pd.datetime` and `pd.np` with python 3.6, which will issue warnings when things like `pd.datetime.now()` are called. However, for python 3.6, I could not figure out a way to issue a warning on `pd.datetime(2015, 10, 11, 0, 0)`, so we may just have to live with that.
| https://api.github.com/repos/pandas-dev/pandas/pulls/30799 | 2020-01-07T23:14:28Z | 2020-01-09T12:29:05Z | 2020-01-09T12:29:05Z | 2020-01-10T17:02:42Z |
API: Store name outside attrs | diff --git a/doc/source/reference/frame.rst b/doc/source/reference/frame.rst
index 4c9df35ea8d9d..01aa6c60e3b2f 100644
--- a/doc/source/reference/frame.rst
+++ b/doc/source/reference/frame.rst
@@ -273,6 +273,8 @@ Metadata
:attr:`DataFrame.attrs` is a dictionary for storing global metadata for this DataFrame.
+.. warning:: ``DataFrame.attrs`` is considered experimental and may change without warning.
+
.. autosummary::
:toctree: api/
diff --git a/doc/source/reference/series.rst b/doc/source/reference/series.rst
index 0639730e2dcde..4ad6a7b014532 100644
--- a/doc/source/reference/series.rst
+++ b/doc/source/reference/series.rst
@@ -525,6 +525,8 @@ Metadata
:attr:`Series.attrs` is a dictionary for storing global metadata for this Series.
+.. warning:: ``Series.attrs`` is considered experimental and may change without warning.
+
.. autosummary::
:toctree: api/
diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 8564ef0527125..82077f39f6ef7 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -228,6 +228,7 @@ Other enhancements
- Added new writer for exporting Stata dta files in version 118, ``StataWriter118``. This format supports exporting strings containing Unicode characters (:issue:`23573`)
- :meth:`Series.map` now accepts ``collections.abc.Mapping`` subclasses as a mapper (:issue:`29733`)
- The ``pandas.datetime`` class is now deprecated. Import from ``datetime`` instead (:issue:`30296`)
+- Added an experimental :attr:`~DataFrame.attrs` for storing global metadata about a dataset (:issue:`29062`)
- :meth:`Timestamp.fromisocalendar` is now compatible with python 3.8 and above (:issue:`28115`)
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 24c794cd710a9..c2c95e09da279 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -231,6 +231,10 @@ def _init_mgr(self, mgr, axes=None, dtype=None, copy=False):
def attrs(self) -> Dict[Optional[Hashable], Any]:
"""
Dictionary of global attributes on this object.
+
+ .. warning::
+
+ attrs is experimental and may change without warning.
"""
if self._attrs is None:
self._attrs = {}
diff --git a/pandas/core/series.py b/pandas/core/series.py
index b81659920cfe8..446654374f37c 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -159,7 +159,8 @@ class Series(base.IndexOpsMixin, generic.NDFrame):
_typ = "series"
- _metadata: List[str] = []
+ _name: Optional[Hashable]
+ _metadata: List[str] = ["name"]
_accessors = {"dt", "cat", "str", "sparse"}
_deprecations = (
base.IndexOpsMixin._deprecations
@@ -425,13 +426,13 @@ def dtypes(self):
@property
def name(self) -> Optional[Hashable]:
- return self.attrs.get("name", None)
+ return self._name
@name.setter
def name(self, value: Optional[Hashable]) -> None:
if not is_hashable(value):
raise TypeError("Series.name must be a hashable type")
- self.attrs["name"] = value
+ object.__setattr__(self, "_name", value)
@property
def values(self):
diff --git a/pandas/tests/frame/test_api.py b/pandas/tests/frame/test_api.py
index 26d6a917fe1ca..9263409f7a7f8 100644
--- a/pandas/tests/frame/test_api.py
+++ b/pandas/tests/frame/test_api.py
@@ -551,3 +551,11 @@ async def test_tab_complete_warning(self, ip):
with tm.assert_produces_warning(None):
with provisionalcompleter("ignore"):
list(ip.Completer.completions("df.", 1))
+
+ def test_attrs(self):
+ df = pd.DataFrame({"A": [2, 3]})
+ assert df.attrs == {}
+ df.attrs["version"] = 1
+
+ result = df.rename(columns=str)
+ assert result.attrs == {"version": 1}
diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py
index d235e51d00793..f96d6ddfc357e 100644
--- a/pandas/tests/series/test_api.py
+++ b/pandas/tests/series/test_api.py
@@ -512,6 +512,13 @@ def test_integer_series_size(self):
s = Series(range(9), dtype="Int64")
assert s.size == 9
+ def test_attrs(self):
+ s = pd.Series([0, 1], name="abc")
+ assert s.attrs == {}
+ s.attrs["version"] = 1
+ result = s + 1
+ assert result.attrs == {"version": 1}
+
class TestCategoricalSeries:
@pytest.mark.parametrize(
| This aligns with xarray and h5py:
https://github.com/pandas-dev/pandas/pull/29062#issuecomment-545703586 | https://api.github.com/repos/pandas-dev/pandas/pulls/30798 | 2020-01-07T22:10:47Z | 2020-01-08T14:09:40Z | 2020-01-08T14:09:40Z | 2020-04-03T11:15:44Z |
PERF: cache IntervalIndex._ndarray_values | diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py
index 9ce917b004bc1..6cf577f498162 100644
--- a/pandas/core/indexes/interval.py
+++ b/pandas/core/indexes/interval.py
@@ -187,16 +187,7 @@ def func(intvidx_self, other, sort=False):
)
@accessor.delegate_names(
delegate=IntervalArray,
- accessors=[
- "_ndarray_values",
- "length",
- "size",
- "left",
- "right",
- "mid",
- "closed",
- "dtype",
- ],
+ accessors=["length", "size", "left", "right", "mid", "closed", "dtype"],
typ="property",
overwrite=True,
)
@@ -213,7 +204,11 @@ def func(intvidx_self, other, sort=False):
typ="method",
overwrite=True,
)
-@inherit_names(["is_non_overlapping_monotonic", "mid"], IntervalArray, cache=True)
+@inherit_names(
+ ["is_non_overlapping_monotonic", "mid", "_ndarray_values"],
+ IntervalArray,
+ cache=True,
+)
class IntervalIndex(IntervalMixin, ExtensionIndex, accessor.PandasDelegate):
_typ = "intervalindex"
_comparables = ["name"]
@@ -225,12 +220,7 @@ class IntervalIndex(IntervalMixin, ExtensionIndex, accessor.PandasDelegate):
# Immutable, so we are able to cache computations like isna in '_mask'
_mask = None
- _raw_inherit = {
- "_ndarray_values",
- "__array__",
- "overlaps",
- "contains",
- }
+ _raw_inherit = {"__array__", "overlaps", "contains"}
# --------------------------------------------------------------------
# Constructors
| closes #30742 | https://api.github.com/repos/pandas-dev/pandas/pulls/30797 | 2020-01-07T21:18:19Z | 2020-01-07T22:25:36Z | 2020-01-07T22:25:36Z | 2020-01-08T08:28:52Z |
DOC: whatsnew updates | diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 82e01b62efbb9..f6315ea894e62 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -3877,6 +3877,8 @@ specified in the format: ``<float>(<unit>)``, where float may be signed (and fra
store.append('dftd', dftd, data_columns=True)
store.select('dftd', "C<'-3.5D'")
+.. _io.query_multi:
+
Query MultiIndex
++++++++++++++++
diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 330510c2c883c..b7460bf78b984 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -3,38 +3,18 @@
What's new in 1.0.0 (??)
------------------------
-.. warning::
-
- Starting with the 1.x series of releases, pandas only supports Python 3.6.1 and higher.
+These are the changes in pandas 1.0.0. See :ref:`release` for a full changelog
+including other versions of pandas.
New Deprecation Policy
~~~~~~~~~~~~~~~~~~~~~~
-Starting with Pandas 1.0.0, pandas will adopt a version of `SemVer`_.
-
-Historically, pandas has used a "rolling" deprecation policy, with occasional
-outright breaking API changes. Where possible, we would deprecate the behavior
-we'd like to change, giving an option to adopt the new behavior (via a keyword
-or an alternative method), and issuing a warning for users of the old behavior.
-Sometimes, a deprecation was not possible, and we would make an outright API
-breaking change.
-
-We'll continue to *introduce* deprecations in major and minor releases (e.g.
-1.0.0, 1.1.0, ...). Those deprecations will be *enforced* in the next major
-release.
-
-Note that *behavior changes* and *API breaking changes* are not identical. API
-breaking changes will only be released in major versions. If we consider a
-behavior to be a bug, and fixing that bug induces a behavior change, we'll
-release that change in a minor release. This is a sometimes difficult judgment
-call that we'll do our best on.
+Starting with Pandas 1.0.0, pandas will adopt a variant of `SemVer`_ to
+version releases. Briefly,
-This doesn't mean that pandas' pace of development will slow down. In the `2019
-Pandas User Survey`_, about 95% of the respondents said they considered pandas
-"stable enough". This indicates there's an appetite for new features, even if it
-comes at the cost of break API. The difference is that now API breaking changes
-will be accompanied with a bump in the major version number (e.g. pandas 1.5.1
--> 2.0.0).
+* Deprecations will be introduced in minor releases (e.g. 1.1.0, 1.2.0, 2.1.0, ...)
+* Deprecations will be enforced in major releases (e.g. 1.0.0, 2.0,0, 3.0.0, ...)
+* API-breaking changes will be made only in major releases
See :ref:`policies.version` for more.
@@ -43,13 +23,56 @@ See :ref:`policies.version` for more.
{{ header }}
-These are the changes in pandas 1.0.0. See :ref:`release` for a full changelog
-including other versions of pandas.
-
+.. ---------------------------------------------------------------------------
Enhancements
~~~~~~~~~~~~
+.. _whatsnew_100.NA:
+
+Experimental ``NA`` scalar to denote missing values
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A new ``pd.NA`` value (singleton) is introduced to represent scalar missing
+values. Up to now, pandas used several values to represent missing data: ``np.nan`` is used for this for float data, ``np.nan`` or
+``None`` for object-dtype data and ``pd.NaT`` for datetime-like data. The
+goal of ``pd.NA`` is to provide a "missing" indicator that can be used
+consistently across data types. ``pd.NA`` is currently used by the nullable integer and boolean
+data types and the new string data type (:issue:`28095`).
+
+.. warning::
+
+ Experimental: the behaviour of ``pd.NA`` can still change without warning.
+
+For example, creating a Series using the nullable integer dtype:
+
+.. ipython:: python
+
+ s = pd.Series([1, 2, None], dtype="Int64")
+ s
+ s[2]
+
+Compared to ``np.nan``, ``pd.NA`` behaves differently in certain operations.
+In addition to arithmetic operations, ``pd.NA`` also propagates as "missing"
+or "unknown" in comparison operations:
+
+.. ipython:: python
+
+ np.nan > 1
+ pd.NA > 1
+
+For logical operations, ``pd.NA`` follows the rules of the
+`three-valued logic <https://en.wikipedia.org/wiki/Three-valued_logic>`__ (or
+*Kleene logic*). For example:
+
+.. ipython:: python
+
+ pd.NA | True
+
+For more, see :ref:`NA section <missing_data.NA>` in the user guide on missing
+data.
+
+
.. _whatsnew_100.string:
Dedicated string data type
@@ -102,59 +125,15 @@ String accessor methods returning integers will return a value with :class:`Int6
We recommend explicitly using the ``string`` data type when working with strings.
See :ref:`text.types` for more.
-.. _whatsnew_100.NA:
-
-Experimental ``NA`` scalar to denote missing values
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-A new ``pd.NA`` value (singleton) is introduced to represent scalar missing
-values. Up to now, ``np.nan`` is used for this for float data, ``np.nan`` or
-``None`` for object-dtype data and ``pd.NaT`` for datetime-like data. The
-goal of ``pd.NA`` is provide a "missing" indicator that can be used
-consistently across data types. For now, the nullable integer and boolean
-data types and the new string data type make use of ``pd.NA`` (:issue:`28095`).
-
-.. warning::
-
- Experimental: the behaviour of ``pd.NA`` can still change without warning.
-
-For example, creating a Series using the nullable integer dtype:
-
-.. ipython:: python
-
- s = pd.Series([1, 2, None], dtype="Int64")
- s
- s[2]
-
-Compared to ``np.nan``, ``pd.NA`` behaves differently in certain operations.
-In addition to arithmetic operations, ``pd.NA`` also propagates as "missing"
-or "unknown" in comparison operations:
-
-.. ipython:: python
-
- np.nan > 1
- pd.NA > 1
-
-For logical operations, ``pd.NA`` follows the rules of the
-`three-valued logic <https://en.wikipedia.org/wiki/Three-valued_logic>`__ (or
-*Kleene logic*). For example:
-
-.. ipython:: python
-
- pd.NA | True
-
-For more, see :ref:`NA section <missing_data.NA>` in the user guide on missing
-data.
-
.. _whatsnew_100.boolean:
Boolean data type with missing values support
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
We've added :class:`BooleanDtype` / :class:`~arrays.BooleanArray`, an extension
-type dedicated to boolean data that can hold missing values. With the default
-``'bool`` data type based on a numpy bool array, the column can only hold
-True or False values and not missing values. This new :class:`BooleanDtype`
+type dedicated to boolean data that can hold missing values. The default
+``bool`` data type based on a bool-dtype NumPy array, the column can only hold
+``True`` or ``False``, and not missing values. This new :class:`~arrays.BooleanArray`
can store missing values as well by keeping track of this in a separate mask.
(:issue:`29555`, :issue:`30095`)
@@ -191,6 +170,18 @@ method on a :func:`pandas.api.indexers.BaseIndexer` subclass that will generate
indices used for each window during the rolling aggregation. For more details and example usage, see
the :ref:`custom window rolling documentation <stats.custom_rolling_window>`
+.. _whatsnew_1000.to_markdown:
+
+Converting to Markdown
+^^^^^^^^^^^^^^^^^^^^^^
+
+We've added :meth:`~DataFrame.to_markdown` for creating a markdown table (:issue:`11052`)
+
+.. ipython:: python
+
+ df = pd.DataFrame({"A": [1, 2, 3], "B": [1, 2, 3]}, index=['a', 'a', 'b'])
+ print(df.to_markdown())
+
.. _whatsnew_1000.enhancements.other:
Other enhancements
@@ -222,7 +213,6 @@ Other enhancements
- :func:`to_parquet` now appropriately handles the ``schema`` argument for user defined schemas in the pyarrow engine. (:issue: `30270`)
- DataFrame constructor preserve `ExtensionArray` dtype with `ExtensionArray` (:issue:`11363`)
- :meth:`DataFrame.sort_values` and :meth:`Series.sort_values` have gained ``ignore_index`` keyword to be able to reset index after sorting (:issue:`30114`)
-- :meth:`DataFrame.to_markdown` and :meth:`Series.to_markdown` added (:issue:`11052`)
- :meth:`DataFrame.sort_index` and :meth:`Series.sort_index` have gained ``ignore_index`` keyword to reset index (:issue:`30114`)
- :meth:`DataFrame.drop_duplicates` has gained ``ignore_index`` keyword to reset index (:issue:`30114`)
- Added new writer for exporting Stata dta files in version 118, ``StataWriter118``. This format supports exporting strings containing Unicode characters (:issue:`23573`)
@@ -231,7 +221,6 @@ Other enhancements
- :meth:`Timestamp.fromisocalendar` is now compatible with python 3.8 and above (:issue:`28115`)
-
Build Changes
^^^^^^^^^^^^^
@@ -240,6 +229,8 @@ cythonized files in the source distribution uploaded to PyPI (:issue:`28341`, :i
a built distribution (wheel) or via conda, this shouldn't have any effect on you. If you're building pandas from
source, you should no longer need to install Cython into your build environment before calling ``pip install pandas``.
+.. ---------------------------------------------------------------------------
+
.. _whatsnew_1000.api_breaking:
Backwards incompatible API changes
@@ -458,6 +449,13 @@ consistent with the behaviour of :class:`DataFrame` and :class:`Index`.
DeprecationWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.
Series([], dtype: float64)
+.. _whatsnew_1000.api_breaking.python:
+
+Increased minimum version for Python
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Pandas 1.0.0 supports Python 3.6.1 and higher (:issue:`29212`).
+
.. _whatsnew_1000.api_breaking.deps:
Increased minimum versions for dependencies
@@ -555,7 +553,9 @@ Documentation Improvements
^^^^^^^^^^^^^^^^^^^^^^^^^^
- Added new section on :ref:`scale` (:issue:`28315`).
-- Added sub-section Query MultiIndex in IO tools user guide (:issue:`28791`)
+- Added sub-section on :ref:`io.query_multi` for HDF5 datasets (:issue:`28791`).
+
+.. ---------------------------------------------------------------------------
.. _whatsnew_1000.deprecations:
@@ -613,21 +613,20 @@ a list of items should be used instead. (:issue:`23566`) For example:
# proper way, returns DataFrameGroupBy
g[['B', 'C']]
+.. ---------------------------------------------------------------------------
.. _whatsnew_1000.prior_deprecations:
+Removal of prior version deprecations/changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Removed SparseSeries and SparseDataFrame
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+**Removed SparseSeries and SparseDataFrame**
``SparseSeries``, ``SparseDataFrame`` and the ``DataFrame.to_sparse`` method
have been removed (:issue:`28425`). We recommend using a ``Series`` or
``DataFrame`` with sparse values instead. See :ref:`sparse.migration` for help
with migrating existing code.
-Removal of prior version deprecations/changes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
.. _whatsnew_1000.matplotlib_units:
**Matplotlib unit registration**
@@ -760,6 +759,8 @@ or ``matplotlib.Axes.plot``. See :ref:`plotting.formatters` for more.
- Calling ``np.array`` and ``np.asarray`` on tz-aware :class:`Series` and :class:`DatetimeIndex` will now return an object array of tz-aware :class:`Timestamp` (:issue:`24596`)
-
+.. ---------------------------------------------------------------------------
+
.. _whatsnew_1000.performance:
Performance improvements
@@ -780,6 +781,8 @@ Performance improvements
- Performance improvement in :meth:`Index.equals` and :meth:`MultiIndex.equals` (:issue:`29134`)
- Performance improvement in :func:`~pandas.api.types.infer_dtype` when ``skipna`` is ``True`` (:issue:`28814`)
+.. ---------------------------------------------------------------------------
+
.. _whatsnew_1000.bug_fixes:
Bug fixes
@@ -1037,6 +1040,8 @@ Other
- Bug in :meth:`DaataFrame.to_csv` when supplied a series with a ``dtype="string"`` and a ``na_rep``, the ``na_rep`` was being truncated to 2 characters. (:issue:`29975`)
- Bug where :meth:`DataFrame.itertuples` would incorrectly determine whether or not namedtuples could be used for dataframes of 255 columns (:issue:`28282`)
+.. ---------------------------------------------------------------------------
+
.. _whatsnew_1000.contributors:
Contributors
| Primarily reordering roughly in order of importance.
1. Some rewording for clarity
2. Fixed some links
3. Simplified the SemVer discussion | https://api.github.com/repos/pandas-dev/pandas/pulls/30795 | 2020-01-07T20:19:46Z | 2020-01-07T22:28:21Z | 2020-01-07T22:28:21Z | 2020-01-09T20:45:00Z |
IntegerArray.to_numpy | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 330510c2c883c..297315d57427d 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -387,8 +387,37 @@ As a reminder, you can specify the ``dtype`` to disable all inference.
.. ipython:: python
a = pd.array([1, 2, None], dtype="Int64")
+ a
a[2]
+This has a few API-breaking consequences.
+
+**Converting to a NumPy ndarray**
+
+When converting to a NumPy array missing values will be ``pd.NA``, which cannot
+be converted to a float. So calling ``np.asarray(integer_array, dtype="float")``
+will now raise.
+
+*pandas 0.25.x*
+
+.. code-block:: python
+
+ >>> np.asarray(a, dtype="float")
+ array([ 1., 2., nan])
+
+*pandas 1.0.0*
+
+.. ipython:: python
+ :okexcept:
+
+ np.asarray(a, dtype="float")
+
+Use :meth:`arrays.IntegerArray.to_numpy` with an explicit ``na_value`` instead.
+
+.. ipython:: python
+
+ a.to_numpy(dtype="float", na_value=np.nan)
+
See :ref:`missing_data.NA` for more on the differences between :attr:`pandas.NA`
and :attr:`numpy.nan`.
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index 3ba632660a325..c2ce799c64aac 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -19,7 +19,9 @@
is_integer_dtype,
is_list_like,
is_numeric_dtype,
+ is_object_dtype,
is_scalar,
+ is_string_dtype,
pandas_dtype,
)
from pandas.core.dtypes.dtypes import register_extension_dtype
@@ -382,9 +384,14 @@ def to_numpy(
if dtype is None:
dtype = object
if self._hasna:
- if is_bool_dtype(dtype) and na_value is libmissing.NA:
+ if (
+ not (is_object_dtype(dtype) or is_string_dtype(dtype))
+ and na_value is libmissing.NA
+ ):
raise ValueError(
- "cannot convert to bool numpy array in presence of missing values"
+ f"cannot convert to '{dtype}'-dtype NumPy array "
+ "with missing values. Specify an appropriate 'na_value' "
+ "for this dtype."
)
# don't pass copy to astype -> always need a copy since we are mutating
data = self._data.astype(dtype)
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 337ff7f448586..d63692c5ba972 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -5,6 +5,7 @@
import numpy as np
from pandas._libs import lib, missing as libmissing
+from pandas._typing import Scalar
from pandas.compat import set_function_name
from pandas.util._decorators import cache_readonly
@@ -19,6 +20,7 @@
is_list_like,
is_object_dtype,
is_scalar,
+ is_string_dtype,
)
from pandas.core.dtypes.dtypes import register_extension_dtype
from pandas.core.dtypes.missing import isna, notna
@@ -376,30 +378,35 @@ def __getitem__(self, item):
return type(self)(self._data[item], self._mask[item])
- def _coerce_to_ndarray(self, dtype=None, na_value=lib.no_default):
- """
- coerce to an ndarary of object dtype
- """
+ @property
+ def _hasna(self) -> bool:
+ # Note: this is expensive right now! The hope is that we can
+ # make this faster by having an optional mask, but not have to change
+ # source code using it..
+ return self._mask.any()
+
+ def to_numpy(
+ self, dtype=None, copy=False, na_value: "Scalar" = lib.no_default,
+ ):
+ if na_value is lib.no_default:
+ na_value = libmissing.NA
if dtype is None:
dtype = object
-
- if na_value is lib.no_default and is_float_dtype(dtype):
- na_value = np.nan
- elif na_value is lib.no_default:
- na_value = libmissing.NA
-
- if is_integer_dtype(dtype):
- # Specifically, a NumPy integer dtype, not a pandas integer dtype,
- # since we're coercing to a numpy dtype by definition in this function.
- if not self.isna().any():
- return self._data.astype(dtype)
- else:
+ if self._hasna:
+ if (
+ not (is_object_dtype(dtype) or is_string_dtype(dtype))
+ and na_value is libmissing.NA
+ ):
raise ValueError(
- "cannot convert to integer NumPy array with missing values"
+ f"cannot convert to '{dtype}'-dtype NumPy array "
+ "with missing values. Specify an appropriate 'na_value' "
+ "for this dtype."
)
-
- data = self._data.astype(dtype)
- data[self._mask] = na_value
+ # don't pass copy to astype -> always need a copy since we are mutating
+ data = self._data.astype(dtype)
+ data[self._mask] = na_value
+ else:
+ data = self._data.astype(dtype, copy=copy)
return data
__array_priority__ = 1000 # higher than ndarray so ops dispatch to us
@@ -409,7 +416,7 @@ def __array__(self, dtype=None):
the array interface, return my values
We return an object array here to preserve our scalar values
"""
- return self._coerce_to_ndarray(dtype=dtype)
+ return self.to_numpy(dtype=dtype)
def __arrow_array__(self, type=None):
"""
@@ -564,7 +571,13 @@ def astype(self, dtype, copy=True):
return type(self)(result, mask=self._mask, copy=False)
# coerce
- data = self._coerce_to_ndarray(dtype=dtype)
+ if is_float_dtype(dtype):
+ # In astype, we consider dtype=float to also mean na_value=np.nan
+ kwargs = dict(na_value=np.nan)
+ else:
+ kwargs = {}
+
+ data = self.to_numpy(dtype=dtype, **kwargs)
return astype_nansafe(data, dtype, copy=False)
@property
@@ -630,7 +643,7 @@ def value_counts(self, dropna=True):
def _values_for_factorize(self) -> Tuple[np.ndarray, Any]:
# TODO: https://github.com/pandas-dev/pandas/issues/30037
# use masked algorithms, rather than object-dtype / np.nan.
- return self._coerce_to_ndarray(na_value=np.nan), np.nan
+ return self.to_numpy(na_value=np.nan), np.nan
def _values_for_argsort(self) -> np.ndarray:
"""Return values for sorting.
diff --git a/pandas/core/dtypes/common.py b/pandas/core/dtypes/common.py
index a716bc8e0a337..5a007f28d63cb 100644
--- a/pandas/core/dtypes/common.py
+++ b/pandas/core/dtypes/common.py
@@ -171,6 +171,8 @@ def ensure_int_or_float(arr: ArrayLike, copy: bool = False) -> np.array:
try:
return arr.astype("uint64", copy=copy, casting="safe") # type: ignore
except TypeError:
+ if is_extension_array_dtype(arr.dtype):
+ return arr.to_numpy(dtype="float64", na_value=np.nan)
return arr.astype("float64", copy=copy)
diff --git a/pandas/tests/arrays/test_boolean.py b/pandas/tests/arrays/test_boolean.py
index 089cda7f434e9..b89aece3f982c 100644
--- a/pandas/tests/arrays/test_boolean.py
+++ b/pandas/tests/arrays/test_boolean.py
@@ -265,6 +265,11 @@ def test_to_numpy(box):
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")
@@ -272,7 +277,7 @@ def test_to_numpy(box):
tm.assert_numpy_array_equal(result, expected)
arr = con([True, False, None], dtype="boolean")
- with pytest.raises(ValueError, match="cannot convert to bool numpy"):
+ with pytest.raises(ValueError, match="cannot convert to 'bool'-dtype"):
result = arr.to_numpy(dtype="bool")
# specify dtype and na_value
@@ -294,9 +299,9 @@ def test_to_numpy(box):
tm.assert_numpy_array_equal(result, expected)
# converting to int or float without specifying na_value raises
- with pytest.raises(TypeError):
+ with pytest.raises(ValueError, match="cannot convert to 'int64'-dtype"):
arr.to_numpy(dtype="int64")
- with pytest.raises(TypeError):
+ with pytest.raises(ValueError, match="cannot convert to 'float64'-dtype"):
arr.to_numpy(dtype="float64")
@@ -329,6 +334,10 @@ def test_astype():
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")
diff --git a/pandas/tests/arrays/test_integer.py b/pandas/tests/arrays/test_integer.py
index f172280202e64..6a3ef75157d5d 100644
--- a/pandas/tests/arrays/test_integer.py
+++ b/pandas/tests/arrays/test_integer.py
@@ -118,7 +118,9 @@ def test_from_dtype_from_float(self, data):
# from float
expected = pd.Series(data)
- result = pd.Series(np.array(data, dtype="float"), dtype=str(dtype))
+ result = pd.Series(
+ data.to_numpy(na_value=np.nan, dtype="float"), dtype=str(dtype)
+ )
tm.assert_series_equal(result, expected)
# from int / list
@@ -634,10 +636,47 @@ def test_construct_cast_invalid(self, dtype):
with pytest.raises(TypeError, match=msg):
pd.Series(arr).astype(dtype)
- def test_coerce_to_ndarray_float_NA_rasies(self):
- a = pd.array([0, 1, 2], dtype="Int64")
- with pytest.raises(TypeError, match="NAType"):
- a._coerce_to_ndarray(dtype="float", na_value=pd.NA)
+ @pytest.mark.parametrize("in_series", [True, False])
+ def test_to_numpy_na_nan(self, in_series):
+ a = pd.array([0, 1, None], dtype="Int64")
+ if in_series:
+ a = pd.Series(a)
+
+ result = a.to_numpy(dtype="float64", na_value=np.nan)
+ expected = np.array([0.0, 1.0, np.nan], dtype="float64")
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = a.to_numpy(dtype="int64", na_value=-1)
+ expected = np.array([0, 1, -1], dtype="int64")
+ tm.assert_numpy_array_equal(result, expected)
+
+ result = a.to_numpy(dtype="bool", na_value=False)
+ expected = np.array([False, True, False], dtype="bool")
+ tm.assert_numpy_array_equal(result, expected)
+
+ @pytest.mark.parametrize("in_series", [True, False])
+ @pytest.mark.parametrize("dtype", ["int32", "int64", "bool"])
+ def test_to_numpy_dtype(self, dtype, in_series):
+ a = pd.array([0, 1], dtype="Int64")
+ if in_series:
+ a = pd.Series(a)
+
+ result = a.to_numpy(dtype=dtype)
+ expected = np.array([0, 1], dtype=dtype)
+ tm.assert_numpy_array_equal(result, expected)
+
+ @pytest.mark.parametrize("dtype", ["float64", "int64", "bool"])
+ def test_to_numpy_na_raises(self, dtype):
+ a = pd.array([0, 1, None], dtype="Int64")
+ with pytest.raises(ValueError, match=dtype):
+ a.to_numpy(dtype=dtype)
+
+ def test_astype_str(self):
+ a = pd.array([1, 2, None], dtype="Int64")
+ expected = np.array(["1", "2", "NA"], dtype=object)
+
+ tm.assert_numpy_array_equal(a.astype(str), expected)
+ tm.assert_numpy_array_equal(a.astype("str"), expected)
def test_frame_repr(data_missing):
@@ -887,7 +926,7 @@ def test_reduce_to_float(op):
def test_astype_nansafe():
# see gh-22343
arr = integer_array([np.nan, 1, 2], dtype="Int8")
- msg = "cannot convert to integer NumPy array with missing values"
+ msg = "cannot convert to 'uint32'-dtype NumPy array with missing values."
with pytest.raises(ValueError, match=msg):
arr.astype("uint32")
| This implements IntegerArray.to_numpy with similar semantics to BooleanArray.to_numpy. The implementation is now identical between BooleanArray & IntegerArray. #30789 will merge them.
1. `.to_numpy(dtype=float/bool/int)` will raise if there are missing values
2. `.astype(float)` will convert NA to NaN.
I've made a slight change from the BooleanArray implementation on master, which I'll annotate inline.
Closes https://github.com/pandas-dev/pandas/issues/30038 | https://api.github.com/repos/pandas-dev/pandas/pulls/30792 | 2020-01-07T19:19:16Z | 2020-01-08T04:36:33Z | 2020-01-08T04:36:33Z | 2020-01-08T04:37:13Z |
BUG: DTI/TDI/PI `where` accepting non-matching dtypes | diff --git a/pandas/core/arrays/datetimelike.py b/pandas/core/arrays/datetimelike.py
index 0fadf3a05a1d3..4a37b4f0f29ba 100644
--- a/pandas/core/arrays/datetimelike.py
+++ b/pandas/core/arrays/datetimelike.py
@@ -34,7 +34,7 @@
is_unsigned_integer_dtype,
pandas_dtype,
)
-from pandas.core.dtypes.generic import ABCIndexClass, ABCPeriodArray, ABCSeries
+from pandas.core.dtypes.generic import ABCSeries
from pandas.core.dtypes.inference import is_array_like
from pandas.core.dtypes.missing import is_valid_nat_for_dtype, isna
@@ -368,16 +368,19 @@ class TimelikeOps:
def _round(self, freq, mode, ambiguous, nonexistent):
# round the local times
- values = _ensure_datetimelike_to_i8(self)
+ if is_datetime64tz_dtype(self):
+ # operate on naive timestamps, then convert back to aware
+ naive = self.tz_localize(None)
+ result = naive._round(freq, mode, ambiguous, nonexistent)
+ aware = result.tz_localize(
+ self.tz, ambiguous=ambiguous, nonexistent=nonexistent
+ )
+ return aware
+
+ values = self.view("i8")
result = round_nsint64(values, mode, freq)
result = self._maybe_mask_results(result, fill_value=NaT)
-
- dtype = self.dtype
- if is_datetime64tz_dtype(self):
- dtype = None
- return self._ensure_localized(
- self._simple_new(result, dtype=dtype), ambiguous, nonexistent
- )
+ return self._simple_new(result, dtype=self.dtype)
@Appender((_round_doc + _round_example).format(op="round"))
def round(self, freq, ambiguous="raise", nonexistent="raise"):
@@ -1411,45 +1414,6 @@ def __isub__(self, other): # type: ignore
self._freq = result._freq
return self
- # --------------------------------------------------------------
- # Comparison Methods
-
- def _ensure_localized(
- self, arg, ambiguous="raise", nonexistent="raise", from_utc=False
- ):
- """
- Ensure that we are re-localized.
-
- This is for compat as we can then call this on all datetimelike
- arrays generally (ignored for Period/Timedelta)
-
- Parameters
- ----------
- arg : Union[DatetimeLikeArray, DatetimeIndexOpsMixin, ndarray]
- ambiguous : str, bool, or bool-ndarray, default 'raise'
- nonexistent : str, default 'raise'
- from_utc : bool, default False
- If True, localize the i8 ndarray to UTC first before converting to
- the appropriate tz. If False, localize directly to the tz.
-
- Returns
- -------
- localized array
- """
-
- # reconvert to local tz
- tz = getattr(self, "tz", None)
- if tz is not None:
- if not isinstance(arg, type(self)):
- arg = self._simple_new(arg)
- if from_utc:
- arg = arg.tz_localize("UTC").tz_convert(self.tz)
- else:
- arg = arg.tz_localize(
- self.tz, ambiguous=ambiguous, nonexistent=nonexistent
- )
- return arg
-
# --------------------------------------------------------------
# Reductions
@@ -1687,38 +1651,3 @@ def maybe_infer_freq(freq):
freq_infer = True
freq = None
return freq, freq_infer
-
-
-def _ensure_datetimelike_to_i8(other, to_utc=False):
- """
- Helper for coercing an input scalar or array to i8.
-
- Parameters
- ----------
- other : 1d array
- to_utc : bool, default False
- If True, convert the values to UTC before extracting the i8 values
- If False, extract the i8 values directly.
-
- Returns
- -------
- i8 1d array
- """
- from pandas import Index
-
- if lib.is_scalar(other) and isna(other):
- return iNaT
- elif isinstance(other, (ABCPeriodArray, ABCIndexClass, DatetimeLikeArrayMixin)):
- # convert tz if needed
- if getattr(other, "tz", None) is not None:
- if to_utc:
- other = other.tz_convert("UTC")
- else:
- other = other.tz_localize(None)
- else:
- try:
- return np.array(other, copy=False).view("i8")
- except TypeError:
- # period array cannot be coerced to int
- other = Index(other)
- return other.asi8
diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 3a58794a8b19e..bb8e04e87724f 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -16,15 +16,18 @@
from pandas.core.dtypes.common import (
ensure_int64,
is_bool_dtype,
+ is_categorical_dtype,
is_dtype_equal,
is_float,
is_integer,
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
+from pandas.core.dtypes.missing import isna
from pandas.core import algorithms
from pandas.core.accessor import PandasDelegate
@@ -34,10 +37,7 @@
ExtensionOpsMixin,
TimedeltaArray,
)
-from pandas.core.arrays.datetimelike import (
- DatetimeLikeArrayMixin,
- _ensure_datetimelike_to_i8,
-)
+from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
import pandas.core.indexes.base as ibase
from pandas.core.indexes.base import Index, _index_shared_docs
from pandas.core.indexes.numeric import Int64Index
@@ -177,18 +177,6 @@ def equals(self, other) -> bool:
return np.array_equal(self.asi8, other.asi8)
- def _ensure_localized(
- self, arg, ambiguous="raise", nonexistent="raise", from_utc=False
- ):
- # See DatetimeLikeArrayMixin._ensure_localized.__doc__
- if getattr(self, "tz", None):
- # ensure_localized is only relevant for tz-aware DTI
- result = self._data._ensure_localized(
- arg, ambiguous=ambiguous, nonexistent=nonexistent, from_utc=from_utc
- )
- return type(self)._simple_new(result, name=self.name)
- return arg
-
@Appender(_index_shared_docs["contains"] % _index_doc_kwargs)
def __contains__(self, key):
try:
@@ -491,11 +479,27 @@ def repeat(self, repeats, axis=None):
@Appender(_index_shared_docs["where"] % _index_doc_kwargs)
def where(self, cond, other=None):
- other = _ensure_datetimelike_to_i8(other, to_utc=True)
- values = _ensure_datetimelike_to_i8(self, to_utc=True)
- result = np.where(cond, values, other).astype("i8")
+ values = self.view("i8")
+
+ if is_scalar(other) and isna(other):
+ other = NaT.value
- result = self._ensure_localized(result, from_utc=True)
+ else:
+ # Do type inference if necessary up front
+ # e.g. we passed PeriodIndex.values and got an ndarray of Periods
+ other = Index(other)
+
+ if is_categorical_dtype(other):
+ # e.g. we have a Categorical holding self.dtype
+ if needs_i8_conversion(other.categories):
+ other = other._internal_get_values()
+
+ if not is_dtype_equal(self.dtype, other.dtype):
+ raise TypeError(f"Where requires matching dtype, not {other.dtype}")
+
+ other = other.view("i8")
+
+ result = np.where(cond, values, other).astype("i8")
return self._shallow_copy(result)
def _summary(self, name=None):
diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py
index 210b28aa0c393..97290c8c635b8 100644
--- a/pandas/tests/indexes/datetimes/test_indexing.py
+++ b/pandas/tests/indexes/datetimes/test_indexing.py
@@ -132,9 +132,32 @@ def test_where_other(self):
i2 = i.copy()
i2 = Index([pd.NaT, pd.NaT] + i[2:].tolist())
- result = i.where(notna(i2), i2.values)
+ result = i.where(notna(i2), i2._values)
tm.assert_index_equal(result, i2)
+ def test_where_invalid_dtypes(self):
+ dti = pd.date_range("20130101", periods=3, tz="US/Eastern")
+
+ i2 = dti.copy()
+ i2 = Index([pd.NaT, pd.NaT] + dti[2:].tolist())
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ # passing tz-naive ndarray to tzaware DTI
+ dti.where(notna(i2), i2.values)
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ # passing tz-aware DTI to tznaive DTI
+ dti.tz_localize(None).where(notna(i2), i2)
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ dti.where(notna(i2), i2.tz_localize(None).to_period("D"))
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ dti.where(notna(i2), i2.asi8.view("timedelta64[ns]"))
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ dti.where(notna(i2), i2.asi8)
+
def test_where_tz(self):
i = pd.date_range("20130101", periods=3, tz="US/Eastern")
result = i.where(notna(i))
diff --git a/pandas/tests/indexes/period/test_indexing.py b/pandas/tests/indexes/period/test_indexing.py
index e95b4ae5397b4..7dbefbdaff98e 100644
--- a/pandas/tests/indexes/period/test_indexing.py
+++ b/pandas/tests/indexes/period/test_indexing.py
@@ -235,6 +235,21 @@ def test_where_other(self):
result = i.where(notna(i2), i2.values)
tm.assert_index_equal(result, i2)
+ def test_where_invalid_dtypes(self):
+ pi = period_range("20130101", periods=5, freq="D")
+
+ i2 = pi.copy()
+ i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + pi[2:].tolist(), freq="D")
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ pi.where(notna(i2), i2.asi8)
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ pi.where(notna(i2), i2.asi8.view("timedelta64[ns]"))
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ pi.where(notna(i2), i2.to_timestamp("S"))
+
class TestTake:
def test_take(self):
diff --git a/pandas/tests/indexes/timedeltas/test_indexing.py b/pandas/tests/indexes/timedeltas/test_indexing.py
index b70a3d17a10ab..36105477ba9ee 100644
--- a/pandas/tests/indexes/timedeltas/test_indexing.py
+++ b/pandas/tests/indexes/timedeltas/test_indexing.py
@@ -4,7 +4,7 @@
import pytest
import pandas as pd
-from pandas import Index, Timedelta, TimedeltaIndex, timedelta_range
+from pandas import Index, Timedelta, TimedeltaIndex, notna, timedelta_range
import pandas._testing as tm
@@ -58,8 +58,20 @@ def test_timestamp_invalid_key(self, key):
class TestWhere:
- # placeholder for symmetry with DatetimeIndex and PeriodIndex tests
- pass
+ def test_where_invalid_dtypes(self):
+ tdi = timedelta_range("1 day", periods=3, freq="D", name="idx")
+
+ i2 = tdi.copy()
+ i2 = Index([pd.NaT, pd.NaT] + tdi[2:].tolist())
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ tdi.where(notna(i2), i2.asi8)
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ tdi.where(notna(i2), i2 + pd.Timestamp.now())
+
+ with pytest.raises(TypeError, match="Where requires matching dtype"):
+ tdi.where(notna(i2), (i2 + pd.Timestamp.now()).to_period("D"))
class TestTake:
| This bug was hidden by _ensure_datetimelike_to_i8, and the only other place where that is used is in _round. _round is clearer without using it, so ensure_datetimelike_to_i8 gets ripped out, and with it we can get rid of _ensure_localized. | https://api.github.com/repos/pandas-dev/pandas/pulls/30791 | 2020-01-07T18:53:35Z | 2020-01-07T22:27:55Z | 2020-01-07T22:27:55Z | 2020-01-07T23:06:40Z |
REF: Implement BaseMaskedArray class for integer/boolean ExtensionArrays | diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index c2ce799c64aac..c065fdeba2177 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -15,13 +15,10 @@
is_extension_array_dtype,
is_float,
is_float_dtype,
- is_integer,
is_integer_dtype,
is_list_like,
is_numeric_dtype,
- is_object_dtype,
is_scalar,
- is_string_dtype,
pandas_dtype,
)
from pandas.core.dtypes.dtypes import register_extension_dtype
@@ -29,10 +26,8 @@
from pandas.core.dtypes.missing import isna, notna
from pandas.core import nanops, ops
-from pandas.core.algorithms import take
-from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
-import pandas.core.common as com
-from pandas.core.indexers import check_bool_array_indexer
+
+from .masked import BaseMaskedArray
if TYPE_CHECKING:
from pandas._typing import Scalar
@@ -199,7 +194,7 @@ def coerce_to_array(values, mask=None, copy: bool = False):
return values, mask
-class BooleanArray(ExtensionArray, ExtensionOpsMixin):
+class BooleanArray(BaseMaskedArray):
"""
Array of boolean (True/False) data with missing values.
@@ -253,6 +248,9 @@ class BooleanArray(ExtensionArray, ExtensionOpsMixin):
Length: 3, dtype: boolean
"""
+ # The value used to fill '_data' to avoid upcasting
+ _internal_fill_value = False
+
def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool = False):
if not (isinstance(values, np.ndarray) and values.dtype == np.bool_):
raise TypeError(
@@ -297,127 +295,6 @@ def _values_for_factorize(self) -> Tuple[np.ndarray, Any]:
def _from_factorized(cls, values, original: "BooleanArray"):
return cls._from_sequence(values, dtype=original.dtype)
- def _formatter(self, boxed=False):
- return str
-
- @property
- def _hasna(self) -> bool:
- # Note: this is expensive right now! The hope is that we can
- # make this faster by having an optional mask, but not have to change
- # source code using it..
- return self._mask.any()
-
- def __getitem__(self, item):
- if is_integer(item):
- if self._mask[item]:
- return self.dtype.na_value
- return self._data[item]
-
- elif com.is_bool_indexer(item):
- item = check_bool_array_indexer(self, item)
-
- return type(self)(self._data[item], self._mask[item])
-
- def to_numpy(
- self, dtype=None, copy=False, na_value: "Scalar" = lib.no_default,
- ):
- """
- Convert to a NumPy Array.
-
- By default converts to an object-dtype NumPy array. Specify the `dtype` and
- `na_value` keywords to customize the conversion.
-
- Parameters
- ----------
- dtype : dtype, default object
- The numpy dtype to convert to.
- copy : bool, default False
- Whether to ensure that the returned value is a not a view on
- the array. Note that ``copy=False`` does not *ensure* that
- ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
- a copy is made, even if not strictly necessary. This is typically
- only possible when no missing values are present and `dtype`
- is a boolean dtype.
- na_value : scalar, optional
- Scalar missing value indicator to use in numpy array. Defaults
- to the native missing value indicator of this array (pd.NA).
-
- Returns
- -------
- numpy.ndarray
-
- Examples
- --------
- An object-dtype is the default result
-
- >>> a = pd.array([True, False], dtype="boolean")
- >>> a.to_numpy()
- array([True, False], dtype=object)
-
- When no missing values are present, a boolean dtype can be used.
-
- >>> a.to_numpy(dtype="bool")
- array([ True, False])
-
- However, requesting a bool dtype will raise a ValueError if
- missing values are present and the default missing value :attr:`NA`
- is used.
-
- >>> a = pd.array([True, False, pd.NA], dtype="boolean")
- >>> a
- <BooleanArray>
- [True, False, NA]
- Length: 3, dtype: boolean
-
- >>> a.to_numpy(dtype="bool")
- Traceback (most recent call last):
- ...
- ValueError: cannot convert to bool numpy array in presence of missing values
-
- Specify a valid `na_value` instead
-
- >>> a.to_numpy(dtype="bool", na_value=False)
- array([ True, False, False])
- """
- if na_value is lib.no_default:
- na_value = libmissing.NA
- if dtype is None:
- dtype = object
- if self._hasna:
- if (
- not (is_object_dtype(dtype) or is_string_dtype(dtype))
- and na_value is libmissing.NA
- ):
- raise ValueError(
- f"cannot convert to '{dtype}'-dtype NumPy array "
- "with missing values. Specify an appropriate 'na_value' "
- "for this dtype."
- )
- # don't pass copy to astype -> always need a copy since we are mutating
- data = self._data.astype(dtype)
- data[self._mask] = na_value
- else:
- data = self._data.astype(dtype, copy=copy)
- return data
-
- __array_priority__ = 1000 # higher than ndarray so ops dispatch to us
-
- def __array__(self, dtype=None):
- """
- the array interface, return my values
- We return an object array here to preserve our scalar values
- """
- # by default (no dtype specified), return an object array
- return self.to_numpy(dtype=dtype)
-
- def __arrow_array__(self, type=None):
- """
- Convert myself into a pyarrow Array.
- """
- import pyarrow as pa
-
- return pa.array(self._data, mask=self._mask, type=type)
-
_HANDLED_TYPES = (np.ndarray, numbers.Number, bool, np.bool_)
def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
@@ -465,40 +342,6 @@ def reconstruct(x):
else:
return reconstruct(result)
- def __iter__(self):
- for i in range(len(self)):
- if self._mask[i]:
- yield self.dtype.na_value
- else:
- yield self._data[i]
-
- def take(self, indexer, allow_fill=False, fill_value=None):
- # we always fill with False internally
- # to avoid upcasting
- data_fill_value = False if isna(fill_value) else fill_value
- result = take(
- self._data, indexer, fill_value=data_fill_value, allow_fill=allow_fill
- )
-
- mask = take(self._mask, indexer, fill_value=True, allow_fill=allow_fill)
-
- # if we are filling
- # we only fill where the indexer is null
- # not existing missing values
- # TODO(jreback) what if we have a non-na float as a fill value?
- if allow_fill and notna(fill_value):
- fill_mask = np.asarray(indexer) == -1
- result[fill_mask] = fill_value
- mask = mask ^ fill_mask
-
- return type(self)(result, mask, copy=False)
-
- def copy(self):
- data, mask = self._data, self._mask
- data = data.copy()
- mask = mask.copy()
- return type(self)(data, mask, copy=False)
-
def __setitem__(self, key, value):
_is_scalar = is_scalar(value)
if _is_scalar:
@@ -512,26 +355,6 @@ def __setitem__(self, key, value):
self._data[key] = value
self._mask[key] = mask
- def __len__(self):
- return len(self._data)
-
- @property
- def nbytes(self):
- return self._data.nbytes + self._mask.nbytes
-
- def isna(self):
- return self._mask
-
- @property
- def _na_value(self):
- return self._dtype.na_value
-
- @classmethod
- def _concat_same_type(cls, to_concat):
- data = np.concatenate([x._data for x in to_concat])
- mask = np.concatenate([x._mask for x in to_concat])
- return cls(data, mask)
-
def astype(self, dtype, copy=True):
"""
Cast to a NumPy array or ExtensionArray with 'dtype'.
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index d63692c5ba972..91b334a6654e3 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -5,7 +5,6 @@
import numpy as np
from pandas._libs import lib, missing as libmissing
-from pandas._typing import Scalar
from pandas.compat import set_function_name
from pandas.util._decorators import cache_readonly
@@ -20,20 +19,17 @@
is_list_like,
is_object_dtype,
is_scalar,
- is_string_dtype,
)
from pandas.core.dtypes.dtypes import register_extension_dtype
from pandas.core.dtypes.missing import isna, notna
from pandas.core import nanops, ops
-from pandas.core.algorithms import take
-from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
-import pandas.core.common as com
-from pandas.core.indexers import check_bool_array_indexer
from pandas.core.ops import invalid_comparison
from pandas.core.ops.common import unpack_zerodim_and_defer
from pandas.core.tools.numeric import to_numeric
+from .masked import BaseMaskedArray
+
class _IntegerDtype(ExtensionDtype):
"""
@@ -261,7 +257,7 @@ def coerce_to_array(values, dtype, mask=None, copy=False):
return values, mask
-class IntegerArray(ExtensionArray, ExtensionOpsMixin):
+class IntegerArray(BaseMaskedArray):
"""
Array of integer (optional missing) values.
@@ -331,6 +327,9 @@ class IntegerArray(ExtensionArray, ExtensionOpsMixin):
Length: 3, dtype: UInt16
"""
+ # The value used to fill '_data' to avoid upcasting
+ _internal_fill_value = 1
+
@cache_readonly
def dtype(self):
return _dtypes[str(self._data.dtype)]
@@ -367,65 +366,6 @@ def _from_sequence_of_strings(cls, strings, dtype=None, copy=False):
def _from_factorized(cls, values, original):
return integer_array(values, dtype=original.dtype)
- def __getitem__(self, item):
- if is_integer(item):
- if self._mask[item]:
- return self.dtype.na_value
- return self._data[item]
-
- elif com.is_bool_indexer(item):
- item = check_bool_array_indexer(self, item)
-
- return type(self)(self._data[item], self._mask[item])
-
- @property
- def _hasna(self) -> bool:
- # Note: this is expensive right now! The hope is that we can
- # make this faster by having an optional mask, but not have to change
- # source code using it..
- return self._mask.any()
-
- def to_numpy(
- self, dtype=None, copy=False, na_value: "Scalar" = lib.no_default,
- ):
- if na_value is lib.no_default:
- na_value = libmissing.NA
- if dtype is None:
- dtype = object
- if self._hasna:
- if (
- not (is_object_dtype(dtype) or is_string_dtype(dtype))
- and na_value is libmissing.NA
- ):
- raise ValueError(
- f"cannot convert to '{dtype}'-dtype NumPy array "
- "with missing values. Specify an appropriate 'na_value' "
- "for this dtype."
- )
- # don't pass copy to astype -> always need a copy since we are mutating
- data = self._data.astype(dtype)
- data[self._mask] = na_value
- else:
- data = self._data.astype(dtype, copy=copy)
- return data
-
- __array_priority__ = 1000 # higher than ndarray so ops dispatch to us
-
- def __array__(self, dtype=None):
- """
- the array interface, return my values
- We return an object array here to preserve our scalar values
- """
- return self.to_numpy(dtype=dtype)
-
- def __arrow_array__(self, type=None):
- """
- Convert myself into a pyarrow Array.
- """
- import pyarrow as pa
-
- return pa.array(self._data, mask=self._mask, type=type)
-
_HANDLED_TYPES = (np.ndarray, numbers.Number)
def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
@@ -473,40 +413,6 @@ def reconstruct(x):
else:
return reconstruct(result)
- def __iter__(self):
- for i in range(len(self)):
- if self._mask[i]:
- yield self.dtype.na_value
- else:
- yield self._data[i]
-
- def take(self, indexer, allow_fill=False, fill_value=None):
- # we always fill with 1 internally
- # to avoid upcasting
- data_fill_value = 1 if isna(fill_value) else fill_value
- result = take(
- self._data, indexer, fill_value=data_fill_value, allow_fill=allow_fill
- )
-
- mask = take(self._mask, indexer, fill_value=True, allow_fill=allow_fill)
-
- # if we are filling
- # we only fill where the indexer is null
- # not existing missing values
- # TODO(jreback) what if we have a non-na float as a fill value?
- if allow_fill and notna(fill_value):
- fill_mask = np.asarray(indexer) == -1
- result[fill_mask] = fill_value
- mask = mask ^ fill_mask
-
- return type(self)(result, mask, copy=False)
-
- def copy(self):
- data, mask = self._data, self._mask
- data = data.copy()
- mask = mask.copy()
- return type(self)(data, mask, copy=False)
-
def __setitem__(self, key, value):
_is_scalar = is_scalar(value)
if _is_scalar:
@@ -520,26 +426,6 @@ def __setitem__(self, key, value):
self._data[key] = value
self._mask[key] = mask
- def __len__(self) -> int:
- return len(self._data)
-
- @property
- def nbytes(self):
- return self._data.nbytes + self._mask.nbytes
-
- def isna(self):
- return self._mask
-
- @property
- def _na_value(self):
- return self.dtype.na_value
-
- @classmethod
- def _concat_same_type(cls, to_concat):
- data = np.concatenate([x._data for x in to_concat])
- mask = np.concatenate([x._mask for x in to_concat])
- return cls(data, mask)
-
def astype(self, dtype, copy=True):
"""
Cast to a NumPy array or IntegerArray with 'dtype'.
diff --git a/pandas/core/arrays/masked.py b/pandas/core/arrays/masked.py
new file mode 100644
index 0000000000000..6fd9f1efbb408
--- /dev/null
+++ b/pandas/core/arrays/masked.py
@@ -0,0 +1,203 @@
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas._libs import lib, missing as libmissing
+
+from pandas.core.dtypes.common import is_integer, is_object_dtype, is_string_dtype
+from pandas.core.dtypes.missing import isna, notna
+
+from pandas.core.algorithms import take
+from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
+import pandas.core.common as com
+from pandas.core.indexers import check_bool_array_indexer
+
+if TYPE_CHECKING:
+ from pandas._typing import Scalar
+
+
+class BaseMaskedArray(ExtensionArray, ExtensionOpsMixin):
+ """
+ Base class for masked arrays (which use _data and _mask to store the data).
+
+ numpy based
+ """
+
+ _data: np.ndarray
+ _mask: np.ndarray
+
+ # The value used to fill '_data' to avoid upcasting
+ _internal_fill_value: "Scalar"
+
+ def __getitem__(self, item):
+ if is_integer(item):
+ if self._mask[item]:
+ return self.dtype.na_value
+ return self._data[item]
+
+ elif com.is_bool_indexer(item):
+ item = check_bool_array_indexer(self, item)
+
+ return type(self)(self._data[item], self._mask[item])
+
+ def __iter__(self):
+ for i in range(len(self)):
+ if self._mask[i]:
+ yield self.dtype.na_value
+ else:
+ yield self._data[i]
+
+ def __len__(self) -> int:
+ return len(self._data)
+
+ def to_numpy(
+ self, dtype=None, copy=False, na_value: "Scalar" = lib.no_default,
+ ):
+ """
+ Convert to a NumPy Array.
+
+ By default converts to an object-dtype NumPy array. Specify the `dtype` and
+ `na_value` keywords to customize the conversion.
+
+ Parameters
+ ----------
+ dtype : dtype, default object
+ The numpy dtype to convert to.
+ copy : bool, default False
+ Whether to ensure that the returned value is a not a view on
+ the array. Note that ``copy=False`` does not *ensure* that
+ ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
+ a copy is made, even if not strictly necessary. This is typically
+ only possible when no missing values are present and `dtype`
+ is the equivalent numpy dtype.
+ na_value : scalar, optional
+ Scalar missing value indicator to use in numpy array. Defaults
+ to the native missing value indicator of this array (pd.NA).
+
+ Returns
+ -------
+ numpy.ndarray
+
+ Examples
+ --------
+ An object-dtype is the default result
+
+ >>> a = pd.array([True, False, pd.NA], dtype="boolean")
+ >>> a.to_numpy()
+ array([True, False, NA], dtype=object)
+
+ When no missing values are present, an equivalent dtype can be used.
+
+ >>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
+ array([ True, False])
+ >>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
+ array([1, 2])
+
+ However, requesting such dtype will raise a ValueError if
+ missing values are present and the default missing value :attr:`NA`
+ is used.
+
+ >>> a = pd.array([True, False, pd.NA], dtype="boolean")
+ >>> a
+ <BooleanArray>
+ [True, False, NA]
+ Length: 3, dtype: boolean
+
+ >>> a.to_numpy(dtype="bool")
+ Traceback (most recent call last):
+ ...
+ ValueError: cannot convert to bool numpy array in presence of missing values
+
+ Specify a valid `na_value` instead
+
+ >>> a.to_numpy(dtype="bool", na_value=False)
+ array([ True, False, False])
+ """
+ if na_value is lib.no_default:
+ na_value = libmissing.NA
+ if dtype is None:
+ dtype = object
+ if self._hasna:
+ if (
+ not (is_object_dtype(dtype) or is_string_dtype(dtype))
+ and na_value is libmissing.NA
+ ):
+ raise ValueError(
+ f"cannot convert to '{dtype}'-dtype NumPy array "
+ "with missing values. Specify an appropriate 'na_value' "
+ "for this dtype."
+ )
+ # don't pass copy to astype -> always need a copy since we are mutating
+ data = self._data.astype(dtype)
+ data[self._mask] = na_value
+ else:
+ data = self._data.astype(dtype, copy=copy)
+ return data
+
+ __array_priority__ = 1000 # higher than ndarray so ops dispatch to us
+
+ def __array__(self, dtype=None):
+ """
+ the array interface, return my values
+ We return an object array here to preserve our scalar values
+ """
+ return self.to_numpy(dtype=dtype)
+
+ def __arrow_array__(self, type=None):
+ """
+ Convert myself into a pyarrow Array.
+ """
+ import pyarrow as pa
+
+ return pa.array(self._data, mask=self._mask, type=type)
+
+ @property
+ def _hasna(self) -> bool:
+ # Note: this is expensive right now! The hope is that we can
+ # make this faster by having an optional mask, but not have to change
+ # source code using it..
+ return self._mask.any()
+
+ def isna(self):
+ return self._mask
+
+ @property
+ def _na_value(self):
+ return self.dtype.na_value
+
+ @property
+ def nbytes(self):
+ return self._data.nbytes + self._mask.nbytes
+
+ @classmethod
+ def _concat_same_type(cls, to_concat):
+ data = np.concatenate([x._data for x in to_concat])
+ mask = np.concatenate([x._mask for x in to_concat])
+ return cls(data, mask)
+
+ def take(self, indexer, allow_fill=False, fill_value=None):
+ # we always fill with 1 internally
+ # to avoid upcasting
+ data_fill_value = self._internal_fill_value if isna(fill_value) else fill_value
+ result = take(
+ self._data, indexer, fill_value=data_fill_value, allow_fill=allow_fill
+ )
+
+ mask = take(self._mask, indexer, fill_value=True, allow_fill=allow_fill)
+
+ # if we are filling
+ # we only fill where the indexer is null
+ # not existing missing values
+ # TODO(jreback) what if we have a non-na float as a fill value?
+ if allow_fill and notna(fill_value):
+ fill_mask = np.asarray(indexer) == -1
+ result[fill_mask] = fill_value
+ mask = mask ^ fill_mask
+
+ return type(self)(result, mask, copy=False)
+
+ def copy(self):
+ data, mask = self._data, self._mask
+ data = data.copy()
+ mask = mask.copy()
+ return type(self)(data, mask, copy=False)
| Todo item of https://github.com/pandas-dev/pandas/issues/29556, consolidating common code for IntegerArray and BooleanArray.
This is only a start, there is more to share. | https://api.github.com/repos/pandas-dev/pandas/pulls/30789 | 2020-01-07T17:25:23Z | 2020-01-09T02:57:55Z | 2020-01-09T02:57:55Z | 2020-01-09T08:26:16Z |
API: no_default | diff --git a/doc/source/reference/extensions.rst b/doc/source/reference/extensions.rst
index 374e1395b42f7..c072237850d82 100644
--- a/doc/source/reference/extensions.rst
+++ b/doc/source/reference/extensions.rst
@@ -69,6 +69,6 @@ behaves correctly.
api.indexers.check_bool_array_indexer
-The sentinel ``pandas.api.extensions._no_default`` is used as the default
+The sentinel ``pandas.api.extensions.no_default`` is used as the default
value in some methods. Use an ``is`` comparison to check if the user
provides a non-default value.
diff --git a/pandas/_libs/lib.pyx b/pandas/_libs/lib.pyx
index f88989b5e8d0e..2b8ba06aa8a82 100644
--- a/pandas/_libs/lib.pyx
+++ b/pandas/_libs/lib.pyx
@@ -2232,14 +2232,14 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0,
return objects
-# Note: _no_default is exported to the public API in pandas.api.extensions
-_no_default = object() #: Sentinel indicating the default value.
+# Note: no_default is exported to the public API in pandas.api.extensions
+no_default = object() #: Sentinel indicating the default value.
@cython.boundscheck(False)
@cython.wraparound(False)
def map_infer_mask(ndarray arr, object f, const uint8_t[:] mask, bint convert=1,
- object na_value=_no_default, object dtype=object):
+ object na_value=no_default, object dtype=object):
"""
Substitute for np.vectorize with pandas-friendly dtype inference.
@@ -2270,7 +2270,7 @@ def map_infer_mask(ndarray arr, object f, const uint8_t[:] mask, bint convert=1,
result = np.empty(n, dtype=dtype)
for i in range(n):
if mask[i]:
- if na_value is _no_default:
+ if na_value is no_default:
val = arr[i]
else:
val = na_value
diff --git a/pandas/api/extensions/__init__.py b/pandas/api/extensions/__init__.py
index 1f782e10396e3..a7e84bb046e61 100644
--- a/pandas/api/extensions/__init__.py
+++ b/pandas/api/extensions/__init__.py
@@ -1,5 +1,5 @@
"""Public API for extending pandas objects."""
-from pandas._libs.lib import _no_default # noqa: F401
+from pandas._libs.lib import no_default # noqa: F401
from pandas.core.dtypes.dtypes import ( # noqa: F401
ExtensionDtype,
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 1be6f5886cb75..9723343ea7af5 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -351,7 +351,7 @@ def __iter__(self):
for i in range(len(self)):
yield self[i]
- def to_numpy(self, dtype=None, copy=False, na_value=lib._no_default):
+ def to_numpy(self, dtype=None, copy=False, na_value=lib.no_default):
"""
Convert to a NumPy ndarray.
@@ -378,9 +378,9 @@ def to_numpy(self, dtype=None, copy=False, na_value=lib._no_default):
numpy.ndarray
"""
result = np.asarray(self, dtype=dtype)
- if copy or na_value is not lib._no_default:
+ if copy or na_value is not lib.no_default:
result = result.copy()
- if na_value is not lib._no_default:
+ if na_value is not lib.no_default:
result[self.isna()] = na_value
return result
diff --git a/pandas/core/arrays/boolean.py b/pandas/core/arrays/boolean.py
index 9ef1c4b1bbb1c..3ba632660a325 100644
--- a/pandas/core/arrays/boolean.py
+++ b/pandas/core/arrays/boolean.py
@@ -317,7 +317,7 @@ def __getitem__(self, item):
return type(self)(self._data[item], self._mask[item])
def to_numpy(
- self, dtype=None, copy=False, na_value: "Scalar" = lib._no_default,
+ self, dtype=None, copy=False, na_value: "Scalar" = lib.no_default,
):
"""
Convert to a NumPy Array.
@@ -377,7 +377,7 @@ def to_numpy(
>>> a.to_numpy(dtype="bool", na_value=False)
array([ True, False, False])
"""
- if na_value is lib._no_default:
+ if na_value is lib.no_default:
na_value = libmissing.NA
if dtype is None:
dtype = object
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
index 0922f4ac6f71d..337ff7f448586 100644
--- a/pandas/core/arrays/integer.py
+++ b/pandas/core/arrays/integer.py
@@ -376,16 +376,16 @@ def __getitem__(self, item):
return type(self)(self._data[item], self._mask[item])
- def _coerce_to_ndarray(self, dtype=None, na_value=lib._no_default):
+ def _coerce_to_ndarray(self, dtype=None, na_value=lib.no_default):
"""
coerce to an ndarary of object dtype
"""
if dtype is None:
dtype = object
- if na_value is lib._no_default and is_float_dtype(dtype):
+ if na_value is lib.no_default and is_float_dtype(dtype):
na_value = np.nan
- elif na_value is lib._no_default:
+ elif na_value is lib.no_default:
na_value = libmissing.NA
if is_integer_dtype(dtype):
diff --git a/pandas/core/arrays/numpy_.py b/pandas/core/arrays/numpy_.py
index ec6f9278f6bf7..55499291d3f4a 100644
--- a/pandas/core/arrays/numpy_.py
+++ b/pandas/core/arrays/numpy_.py
@@ -421,13 +421,13 @@ def skew(self, axis=None, dtype=None, out=None, keepdims=False, skipna=True):
# ------------------------------------------------------------------------
# Additional Methods
- def to_numpy(self, dtype=None, copy=False, na_value=lib._no_default):
+ def to_numpy(self, dtype=None, copy=False, na_value=lib.no_default):
result = np.asarray(self._ndarray, dtype=dtype)
- if (copy or na_value is not lib._no_default) and result is self._ndarray:
+ if (copy or na_value is not lib.no_default) and result is self._ndarray:
result = result.copy()
- if na_value is not lib._no_default:
+ if na_value is not lib.no_default:
result[self.isna()] = na_value
return result
diff --git a/pandas/core/base.py b/pandas/core/base.py
index 319ca142fc041..66d7cd59dcfa4 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -768,7 +768,7 @@ def array(self) -> ExtensionArray:
return result
- def to_numpy(self, dtype=None, copy=False, na_value=lib._no_default, **kwargs):
+ def to_numpy(self, dtype=None, copy=False, na_value=lib.no_default, **kwargs):
"""
A NumPy ndarray representing the values in this Series or Index.
@@ -874,9 +874,9 @@ def to_numpy(self, dtype=None, copy=False, na_value=lib._no_default, **kwargs):
result = np.asarray(self._values, dtype=dtype)
# TODO(GH-24345): Avoid potential double copy
- if copy or na_value is not lib._no_default:
+ if copy or na_value is not lib.no_default:
result = result.copy()
- if na_value is not lib._no_default:
+ if na_value is not lib.no_default:
result[self.isna()] = na_value
return result
diff --git a/pandas/core/computation/eval.py b/pandas/core/computation/eval.py
index 72a0fda9098fd..51892b8c02d87 100644
--- a/pandas/core/computation/eval.py
+++ b/pandas/core/computation/eval.py
@@ -8,7 +8,7 @@
from typing import Optional
import warnings
-from pandas._libs.lib import _no_default
+from pandas._libs.lib import no_default
from pandas.util._validators import validate_bool_kwarg
from pandas.core.computation.engines import _engines
@@ -171,7 +171,7 @@ def eval(
expr,
parser="pandas",
engine: Optional[str] = None,
- truediv=_no_default,
+ truediv=no_default,
local_dict=None,
global_dict=None,
resolvers=(),
@@ -288,7 +288,7 @@ def eval(
inplace = validate_bool_kwarg(inplace, "inplace")
- if truediv is not _no_default:
+ if truediv is not no_default:
warnings.warn(
"The `truediv` parameter in pd.eval is deprecated and will be "
"removed in a future version.",
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 1edcf581c5131..24c794cd710a9 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -106,10 +106,6 @@
Name or list of names to sort by""",
)
-# sentinel value to use as kwarg in place of None when None has special meaning
-# and needs to be distinguished from a user explicitly passing None.
-sentinel = object()
-
def _single_replace(self, to_replace, method, inplace, limit):
"""
@@ -1086,7 +1082,7 @@ def rename(self, *args, **kwargs):
return result.__finalize__(self)
@rewrite_axis_style_signature("mapper", [("copy", True), ("inplace", False)])
- def rename_axis(self, mapper=sentinel, **kwargs):
+ def rename_axis(self, mapper=lib.no_default, **kwargs):
"""
Set the name of the axis for the index or columns.
@@ -1211,7 +1207,7 @@ class name
monkey 2 2
"""
axes, kwargs = self._construct_axes_from_arguments(
- (), kwargs, sentinel=sentinel
+ (), kwargs, sentinel=lib.no_default
)
copy = kwargs.pop("copy", True)
inplace = kwargs.pop("inplace", False)
@@ -1227,7 +1223,7 @@ class name
inplace = validate_bool_kwarg(inplace, "inplace")
- if mapper is not sentinel:
+ if mapper is not lib.no_default:
# Use v0.23 behavior if a scalar or list
non_mapper = is_scalar(mapper) or (
is_list_like(mapper) and not is_dict_like(mapper)
@@ -1243,7 +1239,7 @@ class name
for axis in range(self._AXIS_LEN):
v = axes.get(self._AXIS_NAMES[axis])
- if v is sentinel:
+ if v is lib.no_default:
continue
non_mapper = is_scalar(v) or (is_list_like(v) and not is_dict_like(v))
if non_mapper:
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index c2edfd53e1207..88b841e7d4a88 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -421,7 +421,7 @@ def _get_time_micros(self):
values = self._data._local_timestamps()
return fields.get_time_micros(values)
- def to_series(self, keep_tz=lib._no_default, index=None, name=None):
+ def to_series(self, keep_tz=lib.no_default, index=None, name=None):
"""
Create a Series with both index and values equal to the index keys
useful with map for returning an indexer based on an index.
@@ -466,7 +466,7 @@ def to_series(self, keep_tz=lib._no_default, index=None, name=None):
if name is None:
name = self.name
- if keep_tz is not lib._no_default:
+ if keep_tz is not lib.no_default:
if keep_tz:
warnings.warn(
"The 'keep_tz' keyword in DatetimeIndex.to_series "
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index db9806a046305..ea8d4d2329d09 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -61,8 +61,6 @@
dict(klass="MultiIndex", target_klass="MultiIndex or list of tuples")
)
-_no_default_names = object()
-
class MultiIndexUIntEngine(libindex.BaseMultiIndexCodesEngine, libindex.UInt64Engine):
"""
@@ -373,7 +371,7 @@ def _verify_integrity(
return new_codes
@classmethod
- def from_arrays(cls, arrays, sortorder=None, names=_no_default_names):
+ def from_arrays(cls, arrays, sortorder=None, names=lib.no_default):
"""
Convert arrays to MultiIndex.
@@ -427,7 +425,7 @@ def from_arrays(cls, arrays, sortorder=None, names=_no_default_names):
raise ValueError("all arrays must be same length")
codes, levels = factorize_from_iterables(arrays)
- if names is _no_default_names:
+ if names is lib.no_default:
names = [getattr(arr, "name", None) for arr in arrays]
return MultiIndex(
@@ -497,7 +495,7 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
return MultiIndex.from_arrays(arrays, sortorder=sortorder, names=names)
@classmethod
- def from_product(cls, iterables, sortorder=None, names=_no_default_names):
+ def from_product(cls, iterables, sortorder=None, names=lib.no_default):
"""
Make a MultiIndex from the cartesian product of multiple iterables.
@@ -548,7 +546,7 @@ def from_product(cls, iterables, sortorder=None, names=_no_default_names):
iterables = list(iterables)
codes, levels = factorize_from_iterables(iterables)
- if names is _no_default_names:
+ if names is lib.no_default:
names = [getattr(it, "name", None) for it in iterables]
codes = cartesian_product(codes)
diff --git a/pandas/io/formats/html.py b/pandas/io/formats/html.py
index 020b4952f5549..b46b2f6c671d6 100644
--- a/pandas/io/formats/html.py
+++ b/pandas/io/formats/html.py
@@ -7,6 +7,8 @@
from pandas._config import get_option
+from pandas._libs import lib
+
from pandas.core.dtypes.generic import ABCMultiIndex
from pandas import option_context
@@ -245,7 +247,7 @@ def _write_col_header(self, indent: int) -> None:
if self.fmt.sparsify:
# GH3547
- sentinel = object()
+ sentinel = lib.no_default
else:
sentinel = False
levels = self.columns.format(sparsify=sentinel, adjoin=False, names=False)
@@ -451,7 +453,7 @@ def _write_hierarchical_rows(
if self.fmt.sparsify:
# GH3547
- sentinel = object()
+ sentinel = lib.no_default
levels = frame.index.format(sparsify=sentinel, adjoin=False, names=False)
level_lengths = get_level_lengths(levels, sentinel)
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 30d850faddd9f..8570875569e44 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -15,6 +15,7 @@
from pandas._config import get_option
+from pandas._libs import lib
from pandas.compat._optional import import_optional_dependency
from pandas.util._decorators import Appender
@@ -1475,8 +1476,7 @@ def _get_level_lengths(index, hidden_elements=None):
Result is a dictionary of (level, initial_position): span
"""
- sentinel = object()
- levels = index.format(sparsify=sentinel, adjoin=False, names=False)
+ levels = index.format(sparsify=lib.no_default, adjoin=False, names=False)
if hidden_elements is None:
hidden_elements = []
@@ -1492,10 +1492,10 @@ def _get_level_lengths(index, hidden_elements=None):
for j, row in enumerate(lvl):
if not get_option("display.multi_sparse"):
lengths[(i, j)] = 1
- elif (row != sentinel) and (j not in hidden_elements):
+ elif (row is not lib.no_default) and (j not in hidden_elements):
last_label = j
lengths[(i, last_label)] = 1
- elif row != sentinel:
+ elif row is not lib.no_default:
# even if its hidden, keep track of it in case
# length >1 and later elements are visible
last_label = j
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index b67703c7f80e0..85bd5f7a33fe1 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -5,12 +5,10 @@
import numpy as np
-from pandas._libs import lib
-
from pandas.core.dtypes.base import ExtensionDtype
import pandas as pd
-from pandas.api.extensions import register_extension_dtype
+from pandas.api.extensions import no_default, register_extension_dtype
from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin
@@ -86,7 +84,7 @@ def _from_factorized(cls, values, original):
_HANDLED_TYPES = (decimal.Decimal, numbers.Number, np.ndarray)
- def to_numpy(self, dtype=None, copy=False, na_value=lib._no_default, decimals=None):
+ def to_numpy(self, dtype=None, copy=False, na_value=no_default, decimals=None):
result = np.asarray(self, dtype=dtype)
if decimals is not None:
result = np.asarray([round(x, decimals) for x in result])
| Changes lib._no_default to lib.no_default, uses it in more places.
Closes #30785 | https://api.github.com/repos/pandas-dev/pandas/pulls/30788 | 2020-01-07T17:05:11Z | 2020-01-07T19:03:02Z | 2020-01-07T19:03:02Z | 2020-01-07T19:03:06Z |
REV: move unique, _get_unique_index to ExtensionIndex | diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 3a58794a8b19e..9f0a6994d66ad 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -110,17 +110,6 @@ class DatetimeIndexOpsMixin(ExtensionIndex, ExtensionOpsMixin):
def is_all_dates(self) -> bool:
return True
- def unique(self, level=None):
- if level is not None:
- self._validate_index_level(level)
-
- result = self._data.unique()
-
- # Note: if `self` is already unique, then self.unique() should share
- # a `freq` with self. If not already unique, then self.freq must be
- # None, so again sharing freq is correct.
- return self._shallow_copy(result._data)
-
@classmethod
def _create_comparison_method(cls, op):
"""
diff --git a/pandas/core/indexes/extension.py b/pandas/core/indexes/extension.py
index 6f581c4ebb594..f0f407e9e8308 100644
--- a/pandas/core/indexes/extension.py
+++ b/pandas/core/indexes/extension.py
@@ -176,3 +176,19 @@ def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
na_value=self._na_value,
)
return type(self)(taken, name=self.name)
+
+ def unique(self, level=None):
+ if level is not None:
+ self._validate_index_level(level)
+
+ result = self._data.unique()
+ return self._shallow_copy(result)
+
+ def _get_unique_index(self, dropna=False):
+ if self.is_unique and not dropna:
+ return self
+
+ result = self._data.unique()
+ if dropna and self.hasnans:
+ result = result[~result.isna()]
+ return self._shallow_copy(result)
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 6ba778bc83dd1..1fed0201f7b2b 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -583,15 +583,6 @@ def get_indexer_non_unique(self, target):
indexer, missing = self._int64index.get_indexer_non_unique(target)
return ensure_platform_int(indexer), missing
- def _get_unique_index(self, dropna=False):
- if self.is_unique and not dropna:
- return self
-
- result = self._data.unique()
- if dropna and self.hasnans:
- result = result[~result.isna()]
- return self._shallow_copy(result)
-
def get_loc(self, key, method=None, tolerance=None):
"""
Get integer location for requested label
| Broken off from #30717. | https://api.github.com/repos/pandas-dev/pandas/pulls/30786 | 2020-01-07T16:31:38Z | 2020-01-07T20:45:35Z | 2020-01-07T20:45:35Z | 2020-01-07T21:00:36Z |
API: DataFrame.take always returns a copy | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index f0ba1250b7f8d..5d925c1b235f8 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -752,7 +752,7 @@ Deprecations
- The deprecated internal attributes ``_start``, ``_stop`` and ``_step`` of :class:`RangeIndex` now raise a ``FutureWarning`` instead of a ``DeprecationWarning`` (:issue:`26581`)
- The ``pandas.util.testing`` module has been deprecated. Use the public API in ``pandas.testing`` documented at :ref:`api.general.testing` (:issue:`16232`).
- ``pandas.SparseArray`` has been deprecated. Use ``pandas.arrays.SparseArray`` (:class:`arrays.SparseArray`) instead. (:issue:`30642`)
-- The parameter ``is_copy`` of :meth:`DataFrame.take` has been deprecated and will be removed in a future version. (:issue:`27357`)
+- The parameter ``is_copy`` of :meth:`Series.take` and :meth:`DataFrame.take` has been deprecated and will be removed in a future version. (:issue:`27357`)
- Support for multi-dimensional indexing (e.g. ``index[:, None]``) on a :class:`Index` is deprecated and will be removed in a future version, convert to a numpy array before indexing instead (:issue:`30588`)
- The ``pandas.np`` submodule is now deprecated. Import numpy directly instead (:issue:`30296`)
- The ``pandas.datetime`` class is now deprecated. Import from ``datetime`` instead (:issue:`30610`)
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
index a5e134617b71a..f3a0cf3841b5b 100644
--- a/pandas/core/frame.py
+++ b/pandas/core/frame.py
@@ -2805,7 +2805,7 @@ def __getitem__(self, key):
if getattr(indexer, "dtype", None) == bool:
indexer = np.where(indexer)[0]
- data = self.take(indexer, axis=1)
+ data = self._take_with_is_copy(indexer, axis=1)
if is_single_key:
# What does looking for a single key in a non-unique index return?
@@ -2838,7 +2838,7 @@ def _getitem_bool_array(self, key):
# be reindexed to match DataFrame rows
key = check_bool_indexer(self.index, key)
indexer = key.nonzero()[0]
- return self.take(indexer, axis=0)
+ return self._take_with_is_copy(indexer, axis=0)
def _getitem_multilevel(self, key):
# self.columns is a MultiIndex
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index bfeaf8bca48e9..a2e348bf98e33 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -3211,8 +3211,11 @@ def take(
axis : {0 or 'index', 1 or 'columns', None}, default 0
The axis on which to select elements. ``0`` means that we are
selecting rows, ``1`` means that we are selecting columns.
- is_copy : bool, default True
- Whether to return a copy of the original object or not.
+ is_copy : bool
+ Before pandas 1.0, ``is_copy=False`` can be specified to ensure
+ that the return value is an actual copy. Starting with pandas 1.0,
+ ``take`` always returns a copy, and the keyword is therefore
+ deprecated.
.. deprecated:: 1.0.0
**kwargs
@@ -3276,12 +3279,10 @@ class max_speed
if is_copy is not None:
warnings.warn(
"is_copy is deprecated and will be removed in a future version. "
- "take will always return a copy in the future.",
+ "'take' always returns a copy, so there is no need to specify this.",
FutureWarning,
stacklevel=2,
)
- else:
- is_copy = True
nv.validate_take(tuple(), kwargs)
@@ -3290,13 +3291,22 @@ class max_speed
new_data = self._data.take(
indices, axis=self._get_block_manager_axis(axis), verify=True
)
- result = self._constructor(new_data).__finalize__(self)
+ return self._constructor(new_data).__finalize__(self)
- # Maybe set copy if we didn't actually change the index.
- if is_copy:
- if not result._get_axis(axis).equals(self._get_axis(axis)):
- result._set_is_copy(self)
+ def _take_with_is_copy(
+ self: FrameOrSeries, indices, axis=0, **kwargs
+ ) -> FrameOrSeries:
+ """
+ Internal version of the `take` method that sets the `_is_copy`
+ attribute to keep track of the parent dataframe (using in indexing
+ for the SettingWithCopyWarning).
+ See the docstring of `take` for full explanation of the parameters.
+ """
+ result = self.take(indices=indices, axis=axis, **kwargs)
+ # Maybe set copy if we didn't actually change the index.
+ if not result._get_axis(axis).equals(self._get_axis(axis)):
+ result._set_is_copy(self)
return result
def xs(self, key, axis=0, level=None, drop_level: bool_t = True):
@@ -3426,9 +3436,9 @@ class animal locomotion
if isinstance(loc, np.ndarray):
if loc.dtype == np.bool_:
(inds,) = loc.nonzero()
- return self.take(inds, axis=axis)
+ return self._take_with_is_copy(inds, axis=axis)
else:
- return self.take(loc, axis=axis)
+ return self._take_with_is_copy(loc, axis=axis)
if not is_scalar(loc):
new_index = self.index[loc]
@@ -3485,7 +3495,7 @@ def _iget_item_cache(self, item):
if ax.is_unique:
lower = self._get_item_cache(ax[item])
else:
- lower = self.take(item, axis=self._info_axis_number)
+ lower = self._take_with_is_copy(item, axis=self._info_axis_number)
return lower
def _box_item_values(self, key, values):
@@ -7003,8 +7013,7 @@ def asof(self, where, subset=None):
# mask the missing
missing = locs == -1
- d = self.take(locs)
- data = d.copy()
+ data = self.take(locs)
data.index = where
data.loc[missing] = np.nan
return data if is_list else data.iloc[-1]
@@ -7550,7 +7559,7 @@ def at_time(
except AttributeError:
raise TypeError("Index must be DatetimeIndex")
- return self.take(indexer, axis=axis)
+ return self._take_with_is_copy(indexer, axis=axis)
def between_time(
self: FrameOrSeries,
@@ -7632,7 +7641,7 @@ def between_time(
except AttributeError:
raise TypeError("Index must be DatetimeIndex")
- return self.take(indexer, axis=axis)
+ return self._take_with_is_copy(indexer, axis=axis)
def resample(
self,
diff --git a/pandas/core/groupby/groupby.py b/pandas/core/groupby/groupby.py
index a8c96840ff17b..aa21aa452be95 100644
--- a/pandas/core/groupby/groupby.py
+++ b/pandas/core/groupby/groupby.py
@@ -685,7 +685,7 @@ def get_group(self, name, obj=None):
if not len(inds):
raise KeyError(name)
- return obj.take(inds, axis=self.axis)
+ return obj._take_with_is_copy(inds, axis=self.axis)
def __iter__(self):
"""
diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py
index 4550be791b1ec..f88ad0287440d 100755
--- a/pandas/core/indexing.py
+++ b/pandas/core/indexing.py
@@ -1509,7 +1509,7 @@ def _getitem_iterable(self, key, axis: int):
# A boolean indexer
key = check_bool_indexer(labels, key)
(inds,) = key.nonzero()
- return self.obj.take(inds, axis=axis)
+ return self.obj._take_with_is_copy(inds, axis=axis)
else:
# A collection of keys
keyarr, indexer = self._get_listlike_indexer(key, axis, raise_missing=False)
@@ -1694,7 +1694,7 @@ def _getbool_axis(self, key, axis: int):
labels = self.obj._get_axis(axis)
key = check_bool_indexer(labels, key)
inds = key.nonzero()[0]
- return self.obj.take(inds, axis=axis)
+ return self.obj._take_with_is_copy(inds, axis=axis)
@Appender(IndexingMixin.loc.__doc__)
@@ -2009,7 +2009,7 @@ def _get_list_axis(self, key, axis: int):
`axis` can only be zero.
"""
try:
- return self.obj.take(key, axis=axis)
+ return self.obj._take_with_is_copy(key, axis=axis)
except IndexError:
# re-raise with different error message
raise IndexError("positional indexers are out-of-bounds")
diff --git a/pandas/core/series.py b/pandas/core/series.py
index e79404ccd9521..f061158a4d2e2 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -786,7 +786,14 @@ def axes(self) -> List[Index]:
# Indexing Methods
@Appender(generic.NDFrame.take.__doc__)
- def take(self, indices, axis=0, is_copy=False, **kwargs) -> "Series":
+ def take(self, indices, axis=0, is_copy=None, **kwargs) -> "Series":
+ if is_copy is not None:
+ warnings.warn(
+ "is_copy is deprecated and will be removed in a future version. "
+ "'take' always returns a copy, so there is no need to specify this.",
+ FutureWarning,
+ stacklevel=2,
+ )
nv.validate_take(tuple(), kwargs)
indices = ensure_platform_int(indices)
@@ -801,16 +808,20 @@ def take(self, indices, axis=0, is_copy=False, **kwargs) -> "Series":
kwargs = {}
new_values = self._values.take(indices, **kwargs)
- result = self._constructor(
+ return self._constructor(
new_values, index=new_index, fastpath=True
).__finalize__(self)
- # Maybe set copy if we didn't actually change the index.
- if is_copy:
- if not result._get_axis(axis).equals(self._get_axis(axis)):
- result._set_is_copy(self)
+ def _take_with_is_copy(self, indices, axis=0, **kwargs):
+ """
+ Internal version of the `take` method that sets the `_is_copy`
+ attribute to keep track of the parent dataframe (using in indexing
+ for the SettingWithCopyWarning). For Series this does the same
+ as the public take (it never sets `_is_copy`).
- return result
+ See the docstring of `take` for full explanation of the parameters.
+ """
+ return self.take(indices=indices, axis=axis, **kwargs)
def _ixs(self, i: int, axis: int = 0):
"""
diff --git a/pandas/tests/frame/methods/test_asof.py b/pandas/tests/frame/methods/test_asof.py
index 0291be0a4083e..e2b417972638e 100644
--- a/pandas/tests/frame/methods/test_asof.py
+++ b/pandas/tests/frame/methods/test_asof.py
@@ -143,3 +143,16 @@ def test_time_zone_aware_index(self, stamp, expected):
result = df.asof(stamp)
tm.assert_series_equal(result, expected)
+
+ def test_is_copy(self, date_range_frame):
+ # GH-27357, GH-30784: ensure the result of asof is an actual copy and
+ # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+ df = date_range_frame
+ N = 50
+ df.loc[15:30, "A"] = np.nan
+ dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+ result = df.asof(dates)
+
+ with tm.assert_produces_warning(None):
+ result["C"] = 1
diff --git a/pandas/tests/generic/test_generic.py b/pandas/tests/generic/test_generic.py
index efb04c7f63c66..7645c6b4cf709 100644
--- a/pandas/tests/generic/test_generic.py
+++ b/pandas/tests/generic/test_generic.py
@@ -446,6 +446,15 @@ def test_sample_upsampling_without_replacement(self):
with pytest.raises(ValueError, match=msg):
df.sample(frac=2, replace=False)
+ def test_sample_is_copy(self):
+ # GH-27357, GH-30784: ensure the result of sample is an actual copy and
+ # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+ df = pd.DataFrame(np.random.randn(10, 3), columns=["a", "b", "c"])
+ df2 = df.sample(3)
+
+ with tm.assert_produces_warning(None):
+ df2["d"] = 1
+
def test_size_compat(self):
# GH8846
# size property should be defined
@@ -817,18 +826,23 @@ def test_take_invalid_kwargs(self):
with pytest.raises(ValueError, match=msg):
obj.take(indices, mode="clip")
- def test_depr_take_kwarg_is_copy(self):
+ @pytest.mark.parametrize("is_copy", [True, False])
+ def test_depr_take_kwarg_is_copy(self, is_copy):
# GH 27357
df = DataFrame({"A": [1, 2, 3]})
msg = (
"is_copy is deprecated and will be removed in a future version. "
- "take will always return a copy in the future."
+ "'take' always returns a copy, so there is no need to specify this."
)
with tm.assert_produces_warning(FutureWarning) as w:
- df.take([0, 1], is_copy=True)
+ df.take([0, 1], is_copy=is_copy)
assert w[0].message.args[0] == msg
+ s = Series([1, 2, 3])
+ with tm.assert_produces_warning(FutureWarning):
+ s.take([0, 1], is_copy=is_copy)
+
def test_equals(self):
s1 = pd.Series([1, 2, 3], index=[0, 2, 1])
s2 = s1.copy()
| Closes #27357
This adds an internal version of `take` with the behaviour of setting `_is_copy` for DataFrames that the public `take` did before, so this version can be used in the indexing code (where we want to keep track of parent dataframe with `_is_copy` for SettingWithCopyWarnings).
I named it `_take_with_is_copy` which is literally what it is doing, but happy to hear alternatives.
This then updates the deprecation to fully ignore the keyword and indicate in the deprecation message the keyword has no effect anymore.
I checked https://github.com/pandas-dev/pandas/pull/27349 and https://github.com/pandas-dev/pandas/pull/30615 to ensure that where previously the internal version was used or `is_copy` was specified, now the appropriate function is used. I suppose that in some of the cases where I now use the internal `_take_with_is_copy` this is not actually needed, but it's the safest thing anyway (it will do the same as it did before). | https://api.github.com/repos/pandas-dev/pandas/pulls/30784 | 2020-01-07T15:44:56Z | 2020-01-27T12:29:36Z | 2020-01-27T12:29:35Z | 2020-01-28T04:00:51Z |
CLN: Removed outdated comment | diff --git a/pandas/tests/arrays/categorical/test_repr.py b/pandas/tests/arrays/categorical/test_repr.py
index 9321813b42b33..d08c4b47dd3cb 100644
--- a/pandas/tests/arrays/categorical/test_repr.py
+++ b/pandas/tests/arrays/categorical/test_repr.py
@@ -147,8 +147,6 @@ def test_categorical_repr_datetime(self):
idx = date_range("2011-01-01 09:00", freq="H", periods=5)
c = Categorical(idx)
- # TODO(wesm): exceeding 80 characters in the console is not good
- # behavior
exp = (
"[2011-01-01 09:00:00, 2011-01-01 10:00:00, 2011-01-01 11:00:00, "
"2011-01-01 12:00:00, 2011-01-01 13:00:00]\n"
| - [ ] closes #xxxx
- [ ] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
I think this is a bit outdated, since we are using black and it's doing the work for us, right?
according to git blame, this is 2 years old. | https://api.github.com/repos/pandas-dev/pandas/pulls/30782 | 2020-01-07T14:15:27Z | 2020-01-07T17:12:20Z | 2020-01-07T17:12:20Z | 2020-01-08T20:28:00Z |
STY: Spaces in wrong place | diff --git a/pandas/tests/arrays/categorical/test_api.py b/pandas/tests/arrays/categorical/test_api.py
index df6623acfefee..f49f70f5acf77 100644
--- a/pandas/tests/arrays/categorical/test_api.py
+++ b/pandas/tests/arrays/categorical/test_api.py
@@ -87,8 +87,8 @@ def test_rename_categories(self):
def test_rename_categories_wrong_length_raises(self, new_categories):
cat = Categorical(["a", "b", "c", "a"])
msg = (
- "new categories need to have the same number of items as the"
- " old categories!"
+ "new categories need to have the same number of items as the "
+ "old categories!"
)
with pytest.raises(ValueError, match=msg):
cat.rename_categories(new_categories)
diff --git a/pandas/tests/arrays/categorical/test_indexing.py b/pandas/tests/arrays/categorical/test_indexing.py
index 8ff6a4709c0d7..85d5a6a3dc3ac 100644
--- a/pandas/tests/arrays/categorical/test_indexing.py
+++ b/pandas/tests/arrays/categorical/test_indexing.py
@@ -157,8 +157,8 @@ def test_categories_assigments(self):
def test_categories_assigments_wrong_length_raises(self, new_categories):
cat = Categorical(["a", "b", "c", "a"])
msg = (
- "new categories need to have the same number of items"
- " as the old categories!"
+ "new categories need to have the same number of items "
+ "as the old categories!"
)
with pytest.raises(ValueError, match=msg):
cat.categories = new_categories
diff --git a/pandas/tests/arrays/categorical/test_operators.py b/pandas/tests/arrays/categorical/test_operators.py
index f58524a86b4aa..8643e7f6f89c1 100644
--- a/pandas/tests/arrays/categorical/test_operators.py
+++ b/pandas/tests/arrays/categorical/test_operators.py
@@ -172,8 +172,8 @@ def test_comparison_with_unknown_scalars(self):
cat = Categorical([1, 2, 3], ordered=True)
msg = (
- "Cannot compare a Categorical for op __{}__ with a scalar,"
- " which is not a category"
+ "Cannot compare a Categorical for op __{}__ with a scalar, "
+ "which is not a category"
)
with pytest.raises(TypeError, match=msg.format("lt")):
cat < 4
diff --git a/pandas/tests/frame/methods/test_quantile.py b/pandas/tests/frame/methods/test_quantile.py
index 9ad2417592fe1..64461c08d34f4 100644
--- a/pandas/tests/frame/methods/test_quantile.py
+++ b/pandas/tests/frame/methods/test_quantile.py
@@ -103,8 +103,8 @@ def test_quantile_axis_parameter(self):
with pytest.raises(ValueError, match=msg):
df.quantile(0.1, axis=-1)
msg = (
- "No axis named column for object type"
- " <class 'pandas.core.frame.DataFrame'>"
+ "No axis named column for object type "
+ "<class 'pandas.core.frame.DataFrame'>"
)
with pytest.raises(ValueError, match=msg):
df.quantile(0.1, axis="column")
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index b70a006ca3603..97956489e7da6 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -2659,14 +2659,14 @@ def test_format_explicit(self):
assert exp == res
res = repr(test_sers["asc"])
exp = (
- "0 a\n1 ab\n ... \n4 abcde\n5"
- " abcdef\ndtype: object"
+ "0 a\n1 ab\n ... \n4 abcde\n5 "
+ "abcdef\ndtype: object"
)
assert exp == res
res = repr(test_sers["desc"])
exp = (
- "5 abcdef\n4 abcde\n ... \n1 ab\n0"
- " a\ndtype: object"
+ "5 abcdef\n4 abcde\n ... \n1 ab\n0 "
+ "a\ndtype: object"
)
assert exp == res
diff --git a/pandas/tests/io/formats/test_style.py b/pandas/tests/io/formats/test_style.py
index d4c5414c301f9..e5dac18acedf6 100644
--- a/pandas/tests/io/formats/test_style.py
+++ b/pandas/tests/io/formats/test_style.py
@@ -530,20 +530,17 @@ def test_bar_align_left_0points(self):
(1, 0): [
"width: 10em",
" height: 80%",
- "background: linear-gradient(90deg,#d65f5f 50.0%,"
- " transparent 50.0%)",
+ "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
],
(1, 1): [
"width: 10em",
" height: 80%",
- "background: linear-gradient(90deg,#d65f5f 50.0%,"
- " transparent 50.0%)",
+ "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
],
(1, 2): [
"width: 10em",
" height: 80%",
- "background: linear-gradient(90deg,#d65f5f 50.0%,"
- " transparent 50.0%)",
+ "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
],
(2, 0): [
"width: 10em",
@@ -572,8 +569,7 @@ def test_bar_align_left_0points(self):
(0, 1): [
"width: 10em",
" height: 80%",
- "background: linear-gradient(90deg,#d65f5f 50.0%,"
- " transparent 50.0%)",
+ "background: linear-gradient(90deg,#d65f5f 50.0%, transparent 50.0%)",
],
(0, 2): [
"width: 10em",
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index 060072e5103f4..d3f044a42eb28 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -12,13 +12,13 @@
import pandas.io.formats.format as fmt
lorem_ipsum = (
- "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod"
- " tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim"
- " veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex"
- " ea commodo consequat. Duis aute irure dolor in reprehenderit in"
- " voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur"
- " sint occaecat cupidatat non proident, sunt in culpa qui officia"
- " deserunt mollit anim id est laborum."
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod "
+ "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim "
+ "veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex "
+ "ea commodo consequat. Duis aute irure dolor in reprehenderit in "
+ "voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur "
+ "sint occaecat cupidatat non proident, sunt in culpa qui officia "
+ "deserunt mollit anim id est laborum."
)
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 9e34abd43ad6b..1d3cddbf01738 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -1296,8 +1296,8 @@ def test_write_variable_label_errors(self):
}
msg = (
- "Variable labels must contain only characters that can be"
- " encoded in Latin-1"
+ "Variable labels must contain only characters that can be "
+ "encoded in Latin-1"
)
with pytest.raises(ValueError, match=msg):
with tm.ensure_clean() as path:
@@ -1467,8 +1467,8 @@ def test_out_of_range_float(self):
original.loc[2, "ColumnTooBig"] = np.inf
msg = (
- "Column ColumnTooBig has a maximum value of infinity which"
- " is outside the range supported by Stata"
+ "Column ColumnTooBig has a maximum value of infinity which "
+ "is outside the range supported by Stata"
)
with pytest.raises(ValueError, match=msg):
with tm.ensure_clean() as path:
diff --git a/pandas/tests/series/indexing/test_boolean.py b/pandas/tests/series/indexing/test_boolean.py
index e3acc0f5d6457..d75efcf52c271 100644
--- a/pandas/tests/series/indexing/test_boolean.py
+++ b/pandas/tests/series/indexing/test_boolean.py
@@ -285,8 +285,8 @@ def test_where_error():
with pytest.raises(ValueError, match=msg):
s[[True, False]] = [0, 2, 3]
msg = (
- "NumPy boolean array indexing assignment cannot assign 0 input"
- " values to the 1 output values where the mask is true"
+ "NumPy boolean array indexing assignment cannot assign 0 input "
+ "values to the 1 output values where the mask is true"
)
with pytest.raises(ValueError, match=msg):
s[[True, False]] = []
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index e62963bcfb5f9..4601cabf69b52 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -294,8 +294,8 @@ def test_getitem_dataframe():
s = pd.Series(10, index=rng)
df = pd.DataFrame(rng, index=rng)
msg = (
- "Indexing a Series with DataFrame is not supported,"
- " use the appropriate DataFrame column"
+ "Indexing a Series with DataFrame is not supported, "
+ "use the appropriate DataFrame column"
)
with pytest.raises(TypeError, match=msg):
s[df > 5]
diff --git a/pandas/tests/series/methods/test_rank.py b/pandas/tests/series/methods/test_rank.py
index 1d538e06ccc4e..3d4688c8274f9 100644
--- a/pandas/tests/series/methods/test_rank.py
+++ b/pandas/tests/series/methods/test_rank.py
@@ -203,8 +203,7 @@ def test_rank_signature(self):
s = Series([0, 1])
s.rank(method="average")
msg = (
- "No axis named average for object type"
- " <class 'pandas.core.series.Series'>"
+ "No axis named average for object type <class 'pandas.core.series.Series'>"
)
with pytest.raises(ValueError, match=msg):
s.rank("average")
diff --git a/pandas/tests/series/methods/test_sort_values.py b/pandas/tests/series/methods/test_sort_values.py
index a3017480ad9d7..caa2abd61af6a 100644
--- a/pandas/tests/series/methods/test_sort_values.py
+++ b/pandas/tests/series/methods/test_sort_values.py
@@ -77,8 +77,8 @@ def test_sort_values(self, datetime_series):
s = df.iloc[:, 0]
msg = (
- "This Series is a view of some other array, to sort in-place"
- " you must create a copy"
+ "This Series is a view of some other array, to sort in-place "
+ "you must create a copy"
)
with pytest.raises(ValueError, match=msg):
s.sort_values(inplace=True)
diff --git a/pandas/tests/series/test_alter_axes.py b/pandas/tests/series/test_alter_axes.py
index 62ff0a075d2ca..c40efd1e0bf1b 100644
--- a/pandas/tests/series/test_alter_axes.py
+++ b/pandas/tests/series/test_alter_axes.py
@@ -19,8 +19,8 @@ def test_setindex(self, string_series):
# wrong length
msg = (
- "Length mismatch: Expected axis has 30 elements, new"
- " values have 29 elements"
+ "Length mismatch: Expected axis has 30 elements, "
+ "new values have 29 elements"
)
with pytest.raises(ValueError, match=msg):
string_series.index = np.arange(len(string_series) - 1)
diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py
index 3972e7ff4f3f4..7b6d9210ed3d9 100644
--- a/pandas/tests/series/test_missing.py
+++ b/pandas/tests/series/test_missing.py
@@ -1180,8 +1180,8 @@ def test_interpolate_index_values(self):
def test_interpolate_non_ts(self):
s = Series([1, 3, np.nan, np.nan, np.nan, 11])
msg = (
- "time-weighted interpolation only works on Series or DataFrames"
- " with a DatetimeIndex"
+ "time-weighted interpolation only works on Series or DataFrames "
+ "with a DatetimeIndex"
)
with pytest.raises(ValueError, match=msg):
s.interpolate(method="time")
diff --git a/pandas/tests/series/test_timeseries.py b/pandas/tests/series/test_timeseries.py
index 9f6cf155c7c51..a135c0cf7cd7e 100644
--- a/pandas/tests/series/test_timeseries.py
+++ b/pandas/tests/series/test_timeseries.py
@@ -501,10 +501,7 @@ def test_between_time_raises(self):
def test_between_time_types(self):
# GH11818
rng = date_range("1/1/2000", "1/5/2000", freq="5min")
- msg = (
- r"Cannot convert arg \[datetime\.datetime\(2010, 1, 2, 1, 0\)\]"
- " to a time"
- )
+ msg = r"Cannot convert arg \[datetime\.datetime\(2010, 1, 2, 1, 0\)\] to a time"
with pytest.raises(ValueError, match=msg):
rng.indexer_between_time(datetime(2010, 1, 2, 1), datetime(2010, 1, 2, 5))
| - [ ] 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/30781 | 2020-01-07T14:03:33Z | 2020-01-09T15:58:02Z | 2020-01-09T15:58:02Z | 2020-01-10T20:42:06Z |
ASV: use pandas.util.testing for back compat | diff --git a/asv_bench/benchmarks/categoricals.py b/asv_bench/benchmarks/categoricals.py
index eb903e28ff719..43b1b31a0bfe8 100644
--- a/asv_bench/benchmarks/categoricals.py
+++ b/asv_bench/benchmarks/categoricals.py
@@ -3,7 +3,7 @@
import numpy as np
import pandas as pd
-import pandas._testing as tm
+import pandas.util.testing as tm
try:
from pandas.api.types import union_categoricals
diff --git a/asv_bench/benchmarks/ctors.py b/asv_bench/benchmarks/ctors.py
index a1ae83373528b..a9e45cad22d27 100644
--- a/asv_bench/benchmarks/ctors.py
+++ b/asv_bench/benchmarks/ctors.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DatetimeIndex, Index, MultiIndex, Series, Timestamp
-import pandas._testing as tm
+import pandas.util.testing as tm
def no_change(arr):
diff --git a/asv_bench/benchmarks/frame_ctor.py b/asv_bench/benchmarks/frame_ctor.py
index fdcdcc06bef4d..1deca8fe3aad0 100644
--- a/asv_bench/benchmarks/frame_ctor.py
+++ b/asv_bench/benchmarks/frame_ctor.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DataFrame, MultiIndex, Series, Timestamp, date_range
-import pandas._testing as tm
+import pandas.util.testing as tm
try:
from pandas.tseries.offsets import Nano, Hour
diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py
index 33c415d91de60..ae6c07107f4a0 100644
--- a/asv_bench/benchmarks/frame_methods.py
+++ b/asv_bench/benchmarks/frame_methods.py
@@ -4,7 +4,7 @@
import numpy as np
from pandas import DataFrame, MultiIndex, NaT, Series, date_range, isnull, period_range
-import pandas._testing as tm
+import pandas.util.testing as tm
class GetNumericData:
diff --git a/asv_bench/benchmarks/gil.py b/asv_bench/benchmarks/gil.py
index 6efae0b7222ad..f07d31f0b9db8 100644
--- a/asv_bench/benchmarks/gil.py
+++ b/asv_bench/benchmarks/gil.py
@@ -1,8 +1,8 @@
import numpy as np
from pandas import DataFrame, Series, date_range, factorize, read_csv
-import pandas._testing as tm
from pandas.core.algorithms import take_1d
+import pandas.util.testing as tm
try:
from pandas import (
diff --git a/asv_bench/benchmarks/groupby.py b/asv_bench/benchmarks/groupby.py
index f526369b634b4..d51c53e2264f1 100644
--- a/asv_bench/benchmarks/groupby.py
+++ b/asv_bench/benchmarks/groupby.py
@@ -13,7 +13,7 @@
date_range,
period_range,
)
-import pandas._testing as tm
+import pandas.util.testing as tm
method_blacklist = {
"object": {
diff --git a/asv_bench/benchmarks/index_object.py b/asv_bench/benchmarks/index_object.py
index 0ba0ac764172b..d69799eb70040 100644
--- a/asv_bench/benchmarks/index_object.py
+++ b/asv_bench/benchmarks/index_object.py
@@ -12,7 +12,7 @@
Series,
date_range,
)
-import pandas._testing as tm
+import pandas.util.testing as tm
class SetOperations:
diff --git a/asv_bench/benchmarks/indexing.py b/asv_bench/benchmarks/indexing.py
index 8cec418ff8a41..6453649b91270 100644
--- a/asv_bench/benchmarks/indexing.py
+++ b/asv_bench/benchmarks/indexing.py
@@ -17,7 +17,7 @@
option_context,
period_range,
)
-import pandas._testing as tm
+import pandas.util.testing as tm
class NumericSeriesIndexing:
diff --git a/asv_bench/benchmarks/inference.py b/asv_bench/benchmarks/inference.py
index 9e33f91b4d548..e85b3bd2c7687 100644
--- a/asv_bench/benchmarks/inference.py
+++ b/asv_bench/benchmarks/inference.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DataFrame, Series, to_numeric
-import pandas._testing as tm
+import pandas.util.testing as tm
from .pandas_vb_common import lib, numeric_dtypes
diff --git a/asv_bench/benchmarks/io/csv.py b/asv_bench/benchmarks/io/csv.py
index d25ad1026f91c..b8e8630e663ee 100644
--- a/asv_bench/benchmarks/io/csv.py
+++ b/asv_bench/benchmarks/io/csv.py
@@ -5,7 +5,7 @@
import numpy as np
from pandas import Categorical, DataFrame, date_range, read_csv, to_datetime
-import pandas._testing as tm
+import pandas.util.testing as tm
from ..pandas_vb_common import BaseIO
diff --git a/asv_bench/benchmarks/io/excel.py b/asv_bench/benchmarks/io/excel.py
index d3ab8a12c1e2b..75d87140488e3 100644
--- a/asv_bench/benchmarks/io/excel.py
+++ b/asv_bench/benchmarks/io/excel.py
@@ -6,7 +6,7 @@
from odf.text import P
from pandas import DataFrame, ExcelWriter, date_range, read_excel
-import pandas._testing as tm
+import pandas.util.testing as tm
def _generate_dataframe():
diff --git a/asv_bench/benchmarks/io/hdf.py b/asv_bench/benchmarks/io/hdf.py
index 1bb8411d005cf..88c1a3dc48ea4 100644
--- a/asv_bench/benchmarks/io/hdf.py
+++ b/asv_bench/benchmarks/io/hdf.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DataFrame, HDFStore, date_range, read_hdf
-import pandas._testing as tm
+import pandas.util.testing as tm
from ..pandas_vb_common import BaseIO
diff --git a/asv_bench/benchmarks/io/json.py b/asv_bench/benchmarks/io/json.py
index d758693b4b0a9..27096bcaba78b 100644
--- a/asv_bench/benchmarks/io/json.py
+++ b/asv_bench/benchmarks/io/json.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DataFrame, concat, date_range, read_json, timedelta_range
-import pandas._testing as tm
+import pandas.util.testing as tm
from ..pandas_vb_common import BaseIO
diff --git a/asv_bench/benchmarks/io/pickle.py b/asv_bench/benchmarks/io/pickle.py
index 158a9386696e6..12620656dd2bf 100644
--- a/asv_bench/benchmarks/io/pickle.py
+++ b/asv_bench/benchmarks/io/pickle.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DataFrame, date_range, read_pickle
-import pandas._testing as tm
+import pandas.util.testing as tm
from ..pandas_vb_common import BaseIO
diff --git a/asv_bench/benchmarks/io/sql.py b/asv_bench/benchmarks/io/sql.py
index a5f4d54710dde..6cc7f56ae3d65 100644
--- a/asv_bench/benchmarks/io/sql.py
+++ b/asv_bench/benchmarks/io/sql.py
@@ -4,7 +4,7 @@
from sqlalchemy import create_engine
from pandas import DataFrame, date_range, read_sql_query, read_sql_table
-import pandas._testing as tm
+import pandas.util.testing as tm
class SQL:
diff --git a/asv_bench/benchmarks/io/stata.py b/asv_bench/benchmarks/io/stata.py
index 70a773f994d8a..f3125f8598418 100644
--- a/asv_bench/benchmarks/io/stata.py
+++ b/asv_bench/benchmarks/io/stata.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DataFrame, date_range, read_stata
-import pandas._testing as tm
+import pandas.util.testing as tm
from ..pandas_vb_common import BaseIO
diff --git a/asv_bench/benchmarks/join_merge.py b/asv_bench/benchmarks/join_merge.py
index 77e5afffc6260..5cf9f6336ba0c 100644
--- a/asv_bench/benchmarks/join_merge.py
+++ b/asv_bench/benchmarks/join_merge.py
@@ -3,7 +3,7 @@
import numpy as np
from pandas import DataFrame, MultiIndex, Series, concat, date_range, merge, merge_asof
-import pandas._testing as tm
+import pandas.util.testing as tm
try:
from pandas import merge_ordered
diff --git a/asv_bench/benchmarks/multiindex_object.py b/asv_bench/benchmarks/multiindex_object.py
index 1d2412975046b..5a396c9f0deff 100644
--- a/asv_bench/benchmarks/multiindex_object.py
+++ b/asv_bench/benchmarks/multiindex_object.py
@@ -3,7 +3,7 @@
import numpy as np
from pandas import DataFrame, MultiIndex, RangeIndex, date_range
-import pandas._testing as tm
+import pandas.util.testing as tm
class GetLoc:
diff --git a/asv_bench/benchmarks/reindex.py b/asv_bench/benchmarks/reindex.py
index d5bfaa1fb0314..cd450f801c805 100644
--- a/asv_bench/benchmarks/reindex.py
+++ b/asv_bench/benchmarks/reindex.py
@@ -1,7 +1,7 @@
import numpy as np
from pandas import DataFrame, Index, MultiIndex, Series, date_range, period_range
-import pandas._testing as tm
+import pandas.util.testing as tm
from .pandas_vb_common import lib
diff --git a/asv_bench/benchmarks/series_methods.py b/asv_bench/benchmarks/series_methods.py
index e335963aa2d7c..a3f1d92545c3f 100644
--- a/asv_bench/benchmarks/series_methods.py
+++ b/asv_bench/benchmarks/series_methods.py
@@ -3,7 +3,7 @@
import numpy as np
from pandas import NaT, Series, date_range
-import pandas._testing as tm
+import pandas.util.testing as tm
class SeriesConstructor:
diff --git a/asv_bench/benchmarks/strings.py b/asv_bench/benchmarks/strings.py
index aca18553f1086..f30b2482615bd 100644
--- a/asv_bench/benchmarks/strings.py
+++ b/asv_bench/benchmarks/strings.py
@@ -3,7 +3,7 @@
import numpy as np
from pandas import DataFrame, Series
-import pandas._testing as tm
+import pandas.util.testing as tm
class Methods:
| cc @TomAugspurger I propose to keep the old deprecated imports (as long as they are not removed), so the benchmarks can still be run when eg doing a comparison of 0.25 with current master.
| https://api.github.com/repos/pandas-dev/pandas/pulls/30779 | 2020-01-07T12:44:08Z | 2020-01-07T21:27:06Z | 2020-01-07T21:27:06Z | 2020-01-08T07:50:07Z |
DOC: Fixtures docs in io/parser/conftest.py | diff --git a/pandas/tests/io/parser/conftest.py b/pandas/tests/io/parser/conftest.py
index a87e1e796c194..1b9edd1f6883c 100644
--- a/pandas/tests/io/parser/conftest.py
+++ b/pandas/tests/io/parser/conftest.py
@@ -46,11 +46,17 @@ class PythonParser(BaseParser):
@pytest.fixture
def csv_dir_path(datapath):
+ """
+ The directory path to the data files needed for parser tests.
+ """
return datapath("io", "parser", "data")
@pytest.fixture
def csv1(csv_dir_path):
+ """
+ The path to the data file "test1.csv" needed for parser tests.
+ """
return os.path.join(csv_dir_path, "test1.csv")
@@ -69,14 +75,23 @@ def csv1(csv_dir_path):
@pytest.fixture(params=_all_parsers, ids=_all_parser_ids)
def all_parsers(request):
+ """
+ Fixture all of the CSV parsers.
+ """
return request.param
@pytest.fixture(params=_c_parsers_only, ids=_c_parser_ids)
def c_parser_only(request):
+ """
+ Fixture all of the CSV parsers using the C engine.
+ """
return request.param
@pytest.fixture(params=_py_parsers_only, ids=_py_parser_ids)
def python_parser_only(request):
+ """
+ Fixture all of the CSV parsers using the Python engine.
+ """
return request.param
| Partially addresses:
https://github.com/pandas-dev/pandas/issues/19159 | https://api.github.com/repos/pandas-dev/pandas/pulls/30775 | 2020-01-07T11:00:27Z | 2020-01-07T12:09:44Z | 2020-01-07T12:09:44Z | 2020-01-07T12:09:44Z |
BLD: more informative error message when trying to cythonize with old cython version | diff --git a/setup.py b/setup.py
index 076b77bf5d4df..c33ce063cb4d9 100755
--- a/setup.py
+++ b/setup.py
@@ -49,11 +49,12 @@ def is_platform_mac():
try:
import Cython
- ver = Cython.__version__
+ _CYTHON_VERSION = Cython.__version__
from Cython.Build import cythonize
- _CYTHON_INSTALLED = ver >= LooseVersion(min_cython_ver)
+ _CYTHON_INSTALLED = _CYTHON_VERSION >= LooseVersion(min_cython_ver)
except ImportError:
+ _CYTHON_VERSION = None
_CYTHON_INSTALLED = False
cythonize = lambda x, *args, **kwargs: x # dummy func
@@ -506,6 +507,11 @@ def maybe_cythonize(extensions, *args, **kwargs):
elif not cython:
# GH#28836 raise a helfpul error message
+ if _CYTHON_VERSION:
+ raise RuntimeError(
+ f"Cannot cythonize with old Cython version ({_CYTHON_VERSION} "
+ f"installed, needs {min_cython_ver})"
+ )
raise RuntimeError("Cannot cythonize without Cython installed.")
numpy_incl = pkg_resources.resource_filename("numpy", "core/include")
| cc @jbrockmendel building upon your https://github.com/pandas-dev/pandas/pull/30498, but making the error message more specific when cython is actually installed but too old. | https://api.github.com/repos/pandas-dev/pandas/pulls/30774 | 2020-01-07T09:08:53Z | 2020-01-07T11:59:57Z | 2020-01-07T11:59:57Z | 2020-01-07T16:09:34Z |
BUG: Expand encoding for C engine beyond utf-16 | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 5b4761c3bc6c5..c9815ae63baaa 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -941,6 +941,7 @@ I/O
- :meth:`read_gbq` now accepts ``progress_bar_type`` to display progress bar while the data downloads. (:issue:`29857`)
- Bug in :func:`pandas.io.json.json_normalize` where a missing value in the location specified by `record_path` would raise a ``TypeError`` (:issue:`30148`)
- :func:`read_excel` now accepts binary data (:issue:`15914`)
+- Bug in :meth:`read_csv` in which encoding handling was limited to just the string `utf-16` for the C engine (:issue:`24130`)
Plotting
^^^^^^^^
diff --git a/pandas/_libs/parsers.pyx b/pandas/_libs/parsers.pyx
index 5122bb3d4e75b..3df2362f41f0f 100644
--- a/pandas/_libs/parsers.pyx
+++ b/pandas/_libs/parsers.pyx
@@ -2,6 +2,7 @@
# See LICENSE for the license
import bz2
import gzip
+import io
import os
import sys
import time
@@ -637,11 +638,10 @@ cdef class TextReader:
raise ValueError(f'Unrecognized compression type: '
f'{self.compression}')
- if b'utf-16' in (self.encoding or b''):
- # we need to read utf-16 through UTF8Recoder.
- # if source is utf-16, convert source to utf-8 by UTF8Recoder.
- source = icom.UTF8Recoder(source,
- self.encoding.decode('utf-8'))
+ if self.encoding and isinstance(source, io.BufferedIOBase):
+ source = io.TextIOWrapper(
+ source, self.encoding.decode('utf-8'), newline='')
+
self.encoding = b'utf-8'
self.c_encoding = <char*>self.encoding
diff --git a/pandas/io/common.py b/pandas/io/common.py
index 43cd7d81ae4cd..771a302d647ec 100644
--- a/pandas/io/common.py
+++ b/pandas/io/common.py
@@ -1,25 +1,13 @@
"""Common IO api utilities"""
import bz2
-import codecs
from collections import abc
import gzip
from io import BufferedIOBase, BytesIO
import mmap
import os
import pathlib
-from typing import (
- IO,
- Any,
- AnyStr,
- BinaryIO,
- Dict,
- List,
- Mapping,
- Optional,
- Tuple,
- Union,
-)
+from typing import IO, Any, AnyStr, Dict, List, Mapping, Optional, Tuple, Union
from urllib.parse import ( # noqa
urlencode,
urljoin,
@@ -538,24 +526,3 @@ def __next__(self) -> str:
if newline == "":
raise StopIteration
return newline
-
-
-class UTF8Recoder(abc.Iterator):
- """
- Iterator that reads an encoded stream and re-encodes the input to UTF-8
- """
-
- def __init__(self, f: BinaryIO, encoding: str):
- self.reader = codecs.getreader(encoding)(f)
-
- def read(self, bytes: int = -1) -> bytes:
- return self.reader.read(bytes).encode("utf-8")
-
- def readline(self) -> bytes:
- return self.reader.readline().encode("utf-8")
-
- def __next__(self) -> bytes:
- return next(self.reader).encode("utf-8")
-
- def close(self):
- self.reader.close()
diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py
index 21e1ef98fc55c..b4eb2fb1411d0 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 StringIO
+from io import BufferedIOBase, StringIO, TextIOWrapper
import re
import sys
from textwrap import fill
@@ -62,7 +62,6 @@
from pandas.core.tools import datetimes as tools
from pandas.io.common import (
- UTF8Recoder,
get_filepath_or_buffer,
get_handle,
infer_compression,
@@ -1868,12 +1867,18 @@ def __init__(self, src, **kwds):
ParserBase.__init__(self, kwds)
- if kwds.get("compression") is None and "utf-16" in (kwds.get("encoding") or ""):
- # if source is utf-16 plain text, convert source to utf-8
+ encoding = kwds.get("encoding")
+
+ if kwds.get("compression") is None and encoding:
if isinstance(src, str):
src = open(src, "rb")
self.handles.append(src)
- src = UTF8Recoder(src, kwds["encoding"])
+
+ # Handle the file object with universal line mode enabled.
+ # We will handle the newline character ourselves later on.
+ if isinstance(src, BufferedIOBase):
+ src = TextIOWrapper(src, encoding=encoding, newline="")
+
kwds["encoding"] = "utf-8"
# #2442
diff --git a/pandas/tests/io/parser/conftest.py b/pandas/tests/io/parser/conftest.py
index a87e1e796c194..1fe8951a2d5f0 100644
--- a/pandas/tests/io/parser/conftest.py
+++ b/pandas/tests/io/parser/conftest.py
@@ -80,3 +80,29 @@ def c_parser_only(request):
@pytest.fixture(params=_py_parsers_only, ids=_py_parser_ids)
def python_parser_only(request):
return request.param
+
+
+_utf_values = [8, 16, 32]
+
+_encoding_seps = ["", "-", "_"]
+_encoding_prefixes = ["utf", "UTF"]
+
+_encoding_fmts = [
+ f"{prefix}{sep}" + "{0}" for sep in _encoding_seps for prefix in _encoding_prefixes
+]
+
+
+@pytest.fixture(params=_utf_values)
+def utf_value(request):
+ """
+ Fixture for all possible integer values for a UTF encoding.
+ """
+ return request.param
+
+
+@pytest.fixture(params=_encoding_fmts)
+def encoding_fmt(request):
+ """
+ Fixture for all possible string formats of a UTF encoding.
+ """
+ return request.param
diff --git a/pandas/tests/io/parser/data/utf32_ex_small.zip b/pandas/tests/io/parser/data/utf32_ex_small.zip
new file mode 100644
index 0000000000000..9a6d5c08da9db
Binary files /dev/null and b/pandas/tests/io/parser/data/utf32_ex_small.zip differ
diff --git a/pandas/tests/io/parser/data/utf8_ex_small.zip b/pandas/tests/io/parser/data/utf8_ex_small.zip
new file mode 100644
index 0000000000000..a4c5440bdffa7
Binary files /dev/null and b/pandas/tests/io/parser/data/utf8_ex_small.zip differ
diff --git a/pandas/tests/io/parser/test_compression.py b/pandas/tests/io/parser/test_compression.py
index e2b6fdd3af2ff..dc03370daa1e2 100644
--- a/pandas/tests/io/parser/test_compression.py
+++ b/pandas/tests/io/parser/test_compression.py
@@ -123,12 +123,13 @@ def test_infer_compression(all_parsers, csv1, buffer, ext):
tm.assert_frame_equal(result, expected)
-def test_compression_utf16_encoding(all_parsers, csv_dir_path):
- # see gh-18071
+def test_compression_utf_encoding(all_parsers, csv_dir_path, utf_value, encoding_fmt):
+ # see gh-18071, gh-24130
parser = all_parsers
- path = os.path.join(csv_dir_path, "utf16_ex_small.zip")
+ encoding = encoding_fmt.format(utf_value)
+ path = os.path.join(csv_dir_path, f"utf{utf_value}_ex_small.zip")
- result = parser.read_csv(path, encoding="utf-16", compression="zip", sep="\t")
+ result = parser.read_csv(path, encoding=encoding, compression="zip", sep="\t")
expected = pd.DataFrame(
{
"Country": ["Venezuela", "Venezuela"],
diff --git a/pandas/tests/io/parser/test_encoding.py b/pandas/tests/io/parser/test_encoding.py
index 2540dd9b19fce..33abf4bb7d9ee 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
@@ -119,14 +120,12 @@ def _encode_data_with_bom(_data):
tm.assert_frame_equal(result, expected)
-@pytest.mark.parametrize("byte", [8, 16])
-@pytest.mark.parametrize("fmt", ["utf-{0}", "utf_{0}", "UTF-{0}", "UTF_{0}"])
-def test_read_csv_utf_aliases(all_parsers, byte, fmt):
+def test_read_csv_utf_aliases(all_parsers, utf_value, encoding_fmt):
# see gh-13549
expected = DataFrame({"mb_num": [4.8], "multibyte": ["test"]})
parser = all_parsers
- encoding = fmt.format(byte)
+ encoding = encoding_fmt.format(utf_value)
data = "mb_num,multibyte\n4.8,test".encode(encoding)
result = parser.read_csv(BytesIO(data), encoding=encoding)
@@ -155,3 +154,19 @@ def test_binary_mode_file_buffers(all_parsers, csv_dir_path, fname, encoding):
with open(fpath, mode="rb") as fb:
result = parser.read_csv(fb, encoding=encoding)
tm.assert_frame_equal(expected, result)
+
+
+@pytest.mark.parametrize("pass_encoding", [True, False])
+def test_encoding_temp_file(all_parsers, utf_value, encoding_fmt, pass_encoding):
+ # see gh-24130
+ parser = all_parsers
+ encoding = encoding_fmt.format(utf_value)
+
+ expected = DataFrame({"foo": ["bar"]})
+
+ with tempfile.TemporaryFile(mode="w+", encoding=encoding) as f:
+ f.write("foo\nbar")
+ f.seek(0)
+
+ result = parser.read_csv(f, encoding=encoding if pass_encoding else None)
+ tm.assert_frame_equal(result, expected)
| And by `utf-16`, we mean the string `"utf-16"`
Closes https://github.com/pandas-dev/pandas/issues/24130 | https://api.github.com/repos/pandas-dev/pandas/pulls/30771 | 2020-01-07T06:20:00Z | 2020-01-07T20:46:54Z | 2020-01-07T20:46:54Z | 2020-01-07T20:46:58Z |
TST: Add tests for fixed issues | diff --git a/pandas/tests/frame/methods/test_sort_values.py b/pandas/tests/frame/methods/test_sort_values.py
index 7c19ae8147930..96f4d6ed90d6b 100644
--- a/pandas/tests/frame/methods/test_sort_values.py
+++ b/pandas/tests/frame/methods/test_sort_values.py
@@ -497,3 +497,22 @@ def test_sort_values_ignore_index(
tm.assert_frame_equal(result_df, expected)
tm.assert_frame_equal(df, DataFrame(original_dict))
+
+ def test_sort_values_nat_na_position_default(self):
+ # GH 13230
+ expected = pd.DataFrame(
+ {
+ "A": [1, 2, 3, 4, 4],
+ "date": pd.DatetimeIndex(
+ [
+ "2010-01-01 09:00:00",
+ "2010-01-01 09:00:01",
+ "2010-01-01 09:00:02",
+ "2010-01-01 09:00:03",
+ "NaT",
+ ]
+ ),
+ }
+ )
+ result = expected.sort_values(["A", "date"])
+ tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/frame/test_apply.py b/pandas/tests/frame/test_apply.py
index d3b5d82280ced..e98f74e133ea9 100644
--- a/pandas/tests/frame/test_apply.py
+++ b/pandas/tests/frame/test_apply.py
@@ -691,6 +691,18 @@ def test_apply_dup_names_multi_agg(self):
tm.assert_frame_equal(result, expected)
+ def test_apply_nested_result_axis_1(self):
+ # GH 13820
+ def apply_list(row):
+ return [2 * row["A"], 2 * row["C"], 2 * row["B"]]
+
+ df = pd.DataFrame(np.zeros((4, 4)), columns=list("ABCD"))
+ result = df.apply(apply_list, axis=1)
+ expected = Series(
+ [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
+ )
+ tm.assert_series_equal(result, expected)
+
class TestInferOutputShape:
# the user has supplied an opaque UDF where
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 156cc18ded1bf..659b55756c4b6 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -726,3 +726,14 @@ def test_zero_len_frame_with_series_corner_cases():
result = df + ser
expected = df
tm.assert_frame_equal(result, expected)
+
+
+def test_frame_single_columns_object_sum_axis_1():
+ # GH 13758
+ 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])
+ tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/series/test_apply.py b/pandas/tests/series/test_apply.py
index a997e2e0a3ab9..a4c55a80a9f0f 100644
--- a/pandas/tests/series/test_apply.py
+++ b/pandas/tests/series/test_apply.py
@@ -780,3 +780,10 @@ def test_apply_scaler_on_date_time_index_aware_series(self):
series = tm.makeTimeSeries(nper=30).tz_localize("UTC")
result = pd.Series(series.index).apply(lambda x: 1)
tm.assert_series_equal(result, pd.Series(np.ones(30), dtype="int64"))
+
+ def test_map_float_to_string_precision(self):
+ # GH 13228
+ ser = pd.Series(1 / 3)
+ result = ser.map(lambda val: str(val)).to_dict()
+ expected = {0: "0.3333333333333333"}
+ assert result == expected
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index 8b5c139571b57..f3ffdc373e178 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -47,6 +47,22 @@ def test_flex_method_equivalence(self, opname, ts):
expected = alt(other, series)
tm.assert_almost_equal(result, expected)
+ def test_flex_method_subclass_metadata_preservation(self, all_arithmetic_operators):
+ # GH 13208
+ class MySeries(Series):
+ _metadata = ["x"]
+
+ @property
+ def _constructor(self):
+ return MySeries
+
+ opname = all_arithmetic_operators
+ op = getattr(Series, opname)
+ m = MySeries([1, 2, 3], name="test")
+ m.x = 42
+ result = op(m, 1)
+ assert result.x == 42
+
class TestSeriesArithmetic:
# Some of these may end up in tests/arithmetic, but are not yet sorted
| - [x] closes #13230
- [x] closes #13820
- [x] closes #13758
- [x] closes #13228
- [x] closes #13208
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
| https://api.github.com/repos/pandas-dev/pandas/pulls/30769 | 2020-01-07T05:50:58Z | 2020-01-07T23:45:41Z | 2020-01-07T23:45:40Z | 2020-01-07T23:45:46Z |
CLN: Simplify logic in _format_labels function for cut/qcut | diff --git a/pandas/core/reshape/tile.py b/pandas/core/reshape/tile.py
index ceb4e3290ff75..8cf51ae09fbcb 100644
--- a/pandas/core/reshape/tile.py
+++ b/pandas/core/reshape/tile.py
@@ -4,7 +4,6 @@
import numpy as np
from pandas._libs import Timedelta, Timestamp
-from pandas._libs.interval import Interval
from pandas._libs.lib import infer_dtype
from pandas.core.dtypes.common import (
@@ -516,17 +515,11 @@ def _format_labels(
adjust = lambda x: x - 10 ** (-precision)
breaks = [formatter(b) for b in bins]
- labels = IntervalIndex.from_breaks(breaks, closed=closed)
-
if right and include_lowest:
- # we will adjust the left hand side by precision to
- # account that we are all right closed
- v = adjust(labels[0].left)
-
- i = IntervalIndex([Interval(v, labels[0].right, closed="right")])
- labels = i.append(labels[1:])
+ # adjust lhs of first interval by precision to account for being right closed
+ breaks[0] = adjust(breaks[0])
- return labels
+ return IntervalIndex.from_breaks(breaks, closed=closed)
def _preprocess_for_cut(x):
| Small simplification: modify the `breaks` metadata before creating an `IntervalIndex` then create and an `IntervalIndex` from the modified `breaks`. The existing approach creates an `IntervalIndex`, modifies the first `Interval`, then creates a new `IntervalIndex` with the updated first `Interval`.
This yields a slight performance improvement but doesn't seem dramatic enough to warrant a whatsnew entry, though I can add one if desired.
On this branch:
```python
In [1]: import numpy as np; import pandas as pd; pd.__version__
Out[1]: '0.26.0.dev0+1668.ga6c08fc02'
In [2]: a = np.arange(10**5)
In [3]: %timeit pd.qcut(a, 10**4)
273 ms ± 914 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
```
On `master`:
```python
In [1]: import numpy as np; import pandas as pd; pd.__version__
Out[1]: '0.26.0.dev0+1667.g40bff2fed'
In [2]: a = np.arange(10**5)
In [3]: %timeit pd.qcut(a, 10**4)
317 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/30768 | 2020-01-07T05:18:48Z | 2020-01-07T12:16:03Z | 2020-01-07T12:16:03Z | 2020-01-07T16:11:42Z |
STY: spaces in wrong place | diff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py
index 61e30d3e5c139..d09dc586fe056 100644
--- a/pandas/tests/indexes/categorical/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -298,8 +298,8 @@ def test_insert(self):
# invalid
msg = (
- "cannot insert an item into a CategoricalIndex that is not"
- " already an existing category"
+ "cannot insert an item into a CategoricalIndex that is not "
+ "already an existing category"
)
with pytest.raises(TypeError, match=msg):
ci.insert(0, "d")
@@ -528,8 +528,8 @@ def test_get_indexer(self):
tm.assert_almost_equal(r1, np.array([0, 1, 2, -1], dtype=np.intp))
msg = (
- "method='pad' and method='backfill' not implemented yet for"
- " CategoricalIndex"
+ "method='pad' and method='backfill' not implemented yet for "
+ "CategoricalIndex"
)
with pytest.raises(NotImplementedError, match=msg):
idx2.get_indexer(idx1, method="pad")
@@ -673,8 +673,8 @@ def test_equals_categorical(self):
ci1 == Index(["a", "b", "c"])
msg = (
- "categorical index comparisons must have the same categories"
- " and ordered attributes"
+ "categorical index comparisons must have the same categories "
+ "and ordered attributes"
"|"
"Categoricals can only be compared if 'categories' are the same. "
"Categories are different lengths"
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index c75c296e724db..2095eea30cbed 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -528,15 +528,15 @@ def test_constructor_coverage(self):
# non-conforming
msg = (
- "Inferred frequency None from passed values does not conform"
- " to passed frequency D"
+ "Inferred frequency None from passed values does not conform "
+ "to passed frequency D"
)
with pytest.raises(ValueError, match=msg):
DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-04"], freq="D")
msg = (
- "Of the four parameters: start, end, periods, and freq, exactly"
- " three must be specified"
+ "Of the four parameters: start, end, periods, and freq, exactly "
+ "three must be specified"
)
with pytest.raises(ValueError, match=msg):
date_range(start="2011-01-01", freq="b")
diff --git a/pandas/tests/indexes/datetimes/test_tools.py b/pandas/tests/indexes/datetimes/test_tools.py
index a6a43697c36dc..fe65653ba6545 100644
--- a/pandas/tests/indexes/datetimes/test_tools.py
+++ b/pandas/tests/indexes/datetimes/test_tools.py
@@ -616,8 +616,8 @@ def test_to_datetime_tz(self, cache):
pd.Timestamp("2013-01-02 14:00:00", tz="US/Eastern"),
]
msg = (
- "Tz-aware datetime.datetime cannot be converted to datetime64"
- " unless utc=True"
+ "Tz-aware datetime.datetime cannot be "
+ "converted to datetime64 unless utc=True"
)
with pytest.raises(ValueError, match=msg):
pd.to_datetime(arr, cache=cache)
diff --git a/pandas/tests/indexes/interval/test_indexing.py b/pandas/tests/indexes/interval/test_indexing.py
index 3c54442cf40c5..1bfc58733a110 100644
--- a/pandas/tests/indexes/interval/test_indexing.py
+++ b/pandas/tests/indexes/interval/test_indexing.py
@@ -349,8 +349,8 @@ def test_slice_locs_with_interval(self):
with pytest.raises(
KeyError,
match=re.escape(
- '"Cannot get left slice bound for non-unique label:'
- " Interval(0, 2, closed='right')\""
+ '"Cannot get left slice bound for non-unique label: '
+ "Interval(0, 2, closed='right')\""
),
):
index.slice_locs(start=Interval(0, 2), end=Interval(2, 4))
@@ -358,8 +358,8 @@ def test_slice_locs_with_interval(self):
with pytest.raises(
KeyError,
match=re.escape(
- '"Cannot get left slice bound for non-unique label:'
- " Interval(0, 2, closed='right')\""
+ '"Cannot get left slice bound for non-unique label: '
+ "Interval(0, 2, closed='right')\""
),
):
index.slice_locs(start=Interval(0, 2))
@@ -369,8 +369,8 @@ def test_slice_locs_with_interval(self):
with pytest.raises(
KeyError,
match=re.escape(
- '"Cannot get right slice bound for non-unique label:'
- " Interval(0, 2, closed='right')\""
+ '"Cannot get right slice bound for non-unique label: '
+ "Interval(0, 2, closed='right')\""
),
):
index.slice_locs(end=Interval(0, 2))
@@ -378,8 +378,8 @@ def test_slice_locs_with_interval(self):
with pytest.raises(
KeyError,
match=re.escape(
- '"Cannot get right slice bound for non-unique label:'
- " Interval(0, 2, closed='right')\""
+ '"Cannot get right slice bound for non-unique label: '
+ "Interval(0, 2, closed='right')\""
),
):
index.slice_locs(start=Interval(2, 4), end=Interval(0, 2))
@@ -431,8 +431,8 @@ def test_slice_locs_with_ints_and_floats_errors(self, tuples, query):
with pytest.raises(
KeyError,
match=(
- "'can only get slices from an IntervalIndex if bounds are"
- " non-overlapping and all monotonic increasing or decreasing'"
+ "'can only get slices from an IntervalIndex if bounds are "
+ "non-overlapping and all monotonic increasing or decreasing'"
),
):
index.slice_locs(start, stop)
diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py
index 58f88ffb16318..47a0ba7fe0f21 100644
--- a/pandas/tests/indexes/interval/test_interval.py
+++ b/pandas/tests/indexes/interval/test_interval.py
@@ -586,8 +586,8 @@ def test_missing_values(self, closed):
assert idx.equals(idx2)
msg = (
- "missing values must be missing in the same location both left"
- " and right sides"
+ "missing values must be missing in the same location both left "
+ "and right sides"
)
with pytest.raises(ValueError, match=msg):
IntervalIndex.from_arrays(
diff --git a/pandas/tests/indexes/multi/test_analytics.py b/pandas/tests/indexes/multi/test_analytics.py
index 8e6a360af797b..ac1e0893683d1 100644
--- a/pandas/tests/indexes/multi/test_analytics.py
+++ b/pandas/tests/indexes/multi/test_analytics.py
@@ -348,9 +348,9 @@ def test_numpy_ufuncs(idx, func):
)
def test_numpy_type_funcs(idx, func):
msg = (
- f"ufunc '{func.__name__}' not supported for the input types, and the inputs"
- " could not be safely coerced to any supported types according to"
- " the casting rule ''safe''"
+ f"ufunc '{func.__name__}' not supported for the input types, and the inputs "
+ "could not be safely coerced to any supported types according to "
+ "the casting rule ''safe''"
)
with pytest.raises(TypeError, match=msg):
func(idx)
diff --git a/pandas/tests/indexes/multi/test_constructors.py b/pandas/tests/indexes/multi/test_constructors.py
index 4beae4fa1a9af..2c4b3ce04f96d 100644
--- a/pandas/tests/indexes/multi/test_constructors.py
+++ b/pandas/tests/indexes/multi/test_constructors.py
@@ -65,8 +65,8 @@ def test_constructor_mismatched_codes_levels(idx):
MultiIndex(levels=levels, codes=codes)
length_error = (
- r"On level 0, code max \(3\) >= length of level \(1\)\."
- " NOTE: this index is in an inconsistent state"
+ r"On level 0, code max \(3\) >= length of level \(1\)\. "
+ "NOTE: this index is in an inconsistent state"
)
label_error = r"Unequal code lengths: \[4, 2\]"
code_value_error = r"On level 0, code value \(-2\) < -1"
diff --git a/pandas/tests/indexes/multi/test_drop.py b/pandas/tests/indexes/multi/test_drop.py
index 25261dd25d717..b909025b3f2f9 100644
--- a/pandas/tests/indexes/multi/test_drop.py
+++ b/pandas/tests/indexes/multi/test_drop.py
@@ -108,8 +108,8 @@ def test_droplevel_list():
assert dropped.equals(expected)
msg = (
- "Cannot remove 3 levels from an index with 3 levels: at least one"
- " level must be left"
+ "Cannot remove 3 levels from an index with 3 levels: "
+ "at least one level must be left"
)
with pytest.raises(ValueError, match=msg):
index[:2].droplevel(["one", "two", "three"])
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 3276fea4dd575..4eacf4038b794 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -223,8 +223,8 @@ def test_period_index_length(self):
i1 = period_range(start=start, end=end_intv)
msg = (
- "Of the three parameters: start, end, and periods, exactly two"
- " must be specified"
+ "Of the three parameters: start, end, and periods, exactly two "
+ "must be specified"
)
with pytest.raises(ValueError, match=msg):
period_range(start=start)
@@ -427,8 +427,8 @@ def test_contains_nat(self):
def test_periods_number_check(self):
msg = (
- "Of the three parameters: start, end, and periods, exactly two"
- " must be specified"
+ "Of the three parameters: start, end, and periods, exactly two "
+ "must be specified"
)
with pytest.raises(ValueError, match=msg):
period_range("2011-1-1", "2012-1-1", "B")
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index c1ab5a9dbe3eb..2c7fc8b320325 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -109,8 +109,8 @@ def test_constructor_copy(self, index):
def test_constructor_corner(self):
# corner case
msg = (
- r"Index\(\.\.\.\) must be called with a collection of some"
- " kind, 0 was passed"
+ r"Index\(\.\.\.\) must be called with a collection of some "
+ "kind, 0 was passed"
)
with pytest.raises(TypeError, match=msg):
Index(0)
diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py
index 69a3983128a51..f025168643ab9 100644
--- a/pandas/tests/indexes/test_numeric.py
+++ b/pandas/tests/indexes/test_numeric.py
@@ -194,8 +194,8 @@ def test_constructor_invalid(self):
with pytest.raises(TypeError, match=msg):
Float64Index(0.0)
msg = (
- "String dtype not supported, you may need to explicitly cast to"
- " a numeric type"
+ "String dtype not supported, "
+ "you may need to explicitly cast to a numeric type"
)
with pytest.raises(TypeError, match=msg):
Float64Index(["a", "b", 0.0])
@@ -570,8 +570,8 @@ def test_union_noncomparable(self):
def test_cant_or_shouldnt_cast(self):
msg = (
- "String dtype not supported, you may need to explicitly cast to"
- " a numeric type"
+ "String dtype not supported, "
+ "you may need to explicitly cast to a numeric type"
)
# can't
data = ["foo", "bar", "baz"]
@@ -655,8 +655,8 @@ def test_constructor(self):
# scalar raise Exception
msg = (
- r"Int64Index\(\.\.\.\) must be called with a collection of some"
- " kind, 5 was passed"
+ r"Int64Index\(\.\.\.\) must be called with a collection of some "
+ "kind, 5 was passed"
)
with pytest.raises(TypeError, match=msg):
Int64Index(5)
diff --git a/pandas/tests/indexes/timedeltas/test_constructors.py b/pandas/tests/indexes/timedeltas/test_constructors.py
index e9540c950a32b..39abbf59d1e56 100644
--- a/pandas/tests/indexes/timedeltas/test_constructors.py
+++ b/pandas/tests/indexes/timedeltas/test_constructors.py
@@ -176,15 +176,15 @@ def test_constructor_coverage(self):
# non-conforming freq
msg = (
- "Inferred frequency None from passed values does not conform to"
- " passed frequency D"
+ "Inferred frequency None from passed values does not conform to "
+ "passed frequency D"
)
with pytest.raises(ValueError, match=msg):
TimedeltaIndex(["1 days", "2 days", "4 days"], freq="D")
msg = (
- "Of the four parameters: start, end, periods, and freq, exactly"
- " three must be specified"
+ "Of the four parameters: start, end, periods, and freq, exactly "
+ "three must be specified"
)
with pytest.raises(ValueError, match=msg):
timedelta_range(periods=10, freq="D")
diff --git a/pandas/tests/indexes/timedeltas/test_tools.py b/pandas/tests/indexes/timedeltas/test_tools.py
index 223bde8b0e2c2..477fc092a4e16 100644
--- a/pandas/tests/indexes/timedeltas/test_tools.py
+++ b/pandas/tests/indexes/timedeltas/test_tools.py
@@ -73,8 +73,7 @@ def test_to_timedelta_invalid(self):
# time not supported ATM
msg = (
- "Value must be Timedelta, string, integer, float, timedelta or"
- " convertible"
+ "Value must be Timedelta, string, integer, float, timedelta or convertible"
)
with pytest.raises(ValueError, match=msg):
to_timedelta(time(second=1))
| - [ ] 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/30767 | 2020-01-07T00:00:28Z | 2020-01-07T01:48:04Z | 2020-01-07T01:48:04Z | 2020-01-07T13:33:32Z |
BUG: Fix reindexing with multi-indexed DataFrames | diff --git a/asv_bench/benchmarks/multiindex_object.py b/asv_bench/benchmarks/multiindex_object.py
index 793f0c7c03c77..18dbb7eae0615 100644
--- a/asv_bench/benchmarks/multiindex_object.py
+++ b/asv_bench/benchmarks/multiindex_object.py
@@ -74,10 +74,38 @@ def setup(self):
],
dtype=object,
)
+ self.other_mi_many_mismatches = MultiIndex.from_tuples(
+ [
+ (-7, 41),
+ (-2, 3),
+ (-0.7, 5),
+ (0, 0),
+ (0, 1.5),
+ (0, 340),
+ (0, 1001),
+ (1, -4),
+ (1, 20),
+ (1, 1040),
+ (432, -5),
+ (432, 17),
+ (439, 165.5),
+ (998, -4),
+ (998, 24065),
+ (999, 865.2),
+ (999, 1000),
+ (1045, -843),
+ ]
+ )
def time_get_indexer(self):
self.mi_int.get_indexer(self.obj_index)
+ def time_get_indexer_and_backfill(self):
+ self.mi_int.get_indexer(self.other_mi_many_mismatches, method="backfill")
+
+ def time_get_indexer_and_pad(self):
+ self.mi_int.get_indexer(self.other_mi_many_mismatches, method="pad")
+
def time_is_monotonic(self):
self.mi_int.is_monotonic
diff --git a/doc/source/whatsnew/v1.1.0.rst b/doc/source/whatsnew/v1.1.0.rst
index 6f2b9b4f946c7..f3d4c8c557dd8 100644
--- a/doc/source/whatsnew/v1.1.0.rst
+++ b/doc/source/whatsnew/v1.1.0.rst
@@ -115,6 +115,67 @@ Backwards incompatible API changes
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`)
+
+``MultiIndex.get_indexer`` interprets `method` argument differently
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This restores the behavior of :meth:`MultiIndex.get_indexer` with ``method='backfill'`` or ``method='pad'`` to the behavior before pandas 0.23.0. In particular, MultiIndexes are treated as a list of tuples and padding or backfilling is done with respect to the ordering of these lists of tuples (:issue:`29896`).
+
+As an example of this, given:
+
+.. ipython:: python
+
+ df = pd.DataFrame({
+ 'a': [0, 0, 0, 0],
+ 'b': [0, 2, 3, 4],
+ 'c': ['A', 'B', 'C', 'D'],
+ }).set_index(['a', 'b'])
+ mi_2 = pd.MultiIndex.from_product([[0], [-1, 0, 1, 3, 4, 5]])
+
+The differences in reindexing ``df`` with ``mi_2`` and using ``method='backfill'`` can be seen here:
+
+*pandas >= 0.23, < 1.1.0*:
+
+.. code-block:: ipython
+
+ In [1]: df.reindex(mi_2, method='backfill')
+ Out[1]:
+ c
+ 0 -1 A
+ 0 A
+ 1 D
+ 3 A
+ 4 A
+ 5 C
+
+*pandas <0.23, >= 1.1.0*
+
+.. ipython:: python
+
+ df.reindex(mi_2, method='backfill')
+
+And the differences in reindexing ``df`` with ``mi_2`` and using ``method='pad'`` can be seen here:
+
+*pandas >= 0.23, < 1.1.0*
+
+.. code-block:: ipython
+
+ In [1]: df.reindex(mi_2, method='pad')
+ Out[1]:
+ c
+ 0 -1 NaN
+ 0 NaN
+ 1 D
+ 3 NaN
+ 4 A
+ 5 C
+
+*pandas < 0.23, >= 1.1.0*
+
+.. ipython:: python
+
+ df.reindex(mi_2, method='pad')
+
-
.. _whatsnew_110.api_breaking.indexing_raises_key_errors:
diff --git a/pandas/_libs/index.pyx b/pandas/_libs/index.pyx
index 4a9b504ffb0d9..d8e0d9c6bd7ab 100644
--- a/pandas/_libs/index.pyx
+++ b/pandas/_libs/index.pyx
@@ -612,25 +612,113 @@ cdef class BaseMultiIndexCodesEngine:
in zip(self.levels, zip(*target))]
return self._codes_to_ints(np.array(level_codes, dtype='uint64').T)
- def get_indexer(self, object target, object method=None,
- object limit=None):
+ def get_indexer_no_fill(self, object target) -> np.ndarray:
+ """
+ Returns an array giving the positions of each value of `target` in
+ `self.values`, where -1 represents a value in `target` which does not
+ appear in `self.values`
+
+ Parameters
+ ----------
+ target : list-like of keys
+ Each key is a tuple, with a label for each level of the index
+
+ Returns
+ -------
+ np.ndarray[int64_t, ndim=1] of the indexer of `target` into
+ `self.values`
+ """
lab_ints = self._extract_level_codes(target)
+ return self._base.get_indexer(self, lab_ints)
- # All methods (exact, backfill, pad) directly map to the respective
- # methods of the underlying (integers) index...
- if method is not None:
- # but underlying backfill and pad methods require index and keys
- # to be sorted. The index already is (checked in
- # Index._get_fill_indexer), sort (integer representations of) keys:
- order = np.argsort(lab_ints)
- lab_ints = lab_ints[order]
- indexer = (getattr(self._base, f'get_{method}_indexer')
- (self, lab_ints, limit=limit))
- indexer = indexer[order]
- else:
- indexer = self._base.get_indexer(self, lab_ints)
+ def get_indexer(self, object target, object values = None,
+ object method = None, object limit = None) -> np.ndarray:
+ """
+ Returns an array giving the positions of each value of `target` in
+ `values`, where -1 represents a value in `target` which does not
+ appear in `values`
- return indexer
+ If `method` is "backfill" then the position for a value in `target`
+ which does not appear in `values` is that of the next greater value
+ in `values` (if one exists), and -1 if there is no such value.
+
+ Similarly, if the method is "pad" then the position for a value in
+ `target` which does not appear in `values` is that of the next smaller
+ value in `values` (if one exists), and -1 if there is no such value.
+
+ Parameters
+ ----------
+ target: list-like of tuples
+ need not be sorted, but all must have the same length, which must be
+ the same as the length of all tuples in `values`
+ values : list-like of tuples
+ must be sorted and all have the same length. Should be the set of
+ the MultiIndex's values. Needed only if `method` is not None
+ method: string
+ "backfill" or "pad"
+ limit: int, optional
+ if provided, limit the number of fills to this value
+
+ Returns
+ -------
+ np.ndarray[int64_t, ndim=1] of the indexer of `target` into `values`,
+ filled with the `method` (and optionally `limit`) specified
+ """
+ if method is None:
+ return self.get_indexer_no_fill(target)
+
+ assert method in ("backfill", "pad")
+ cdef:
+ int64_t i, j, next_code
+ int64_t num_values, num_target_values
+ ndarray[int64_t, ndim=1] target_order
+ ndarray[object, ndim=1] target_values
+ ndarray[int64_t, ndim=1] new_codes, new_target_codes
+ ndarray[int64_t, ndim=1] sorted_indexer
+
+ target_order = np.argsort(target.values).astype('int64')
+ target_values = target.values[target_order]
+ num_values, num_target_values = len(values), len(target_values)
+ new_codes, new_target_codes = (
+ np.empty((num_values,)).astype('int64'),
+ np.empty((num_target_values,)).astype('int64'),
+ )
+
+ # `values` and `target_values` are both sorted, so we walk through them
+ # and memoize the (ordered) set of indices in the (implicit) merged-and
+ # sorted list of the two which belong to each of them
+ # the effect of this is to create a factorization for the (sorted)
+ # merger of the index values, where `new_codes` and `new_target_codes`
+ # are the subset of the factors which appear in `values` and `target`,
+ # respectively
+ i, j, next_code = 0, 0, 0
+ while i < num_values and j < num_target_values:
+ val, target_val = values[i], target_values[j]
+ if val <= target_val:
+ new_codes[i] = next_code
+ i += 1
+ if target_val <= val:
+ new_target_codes[j] = next_code
+ j += 1
+ next_code += 1
+
+ # at this point, at least one should have reached the end
+ # the remaining values of the other should be added to the end
+ assert i == num_values or j == num_target_values
+ while i < num_values:
+ new_codes[i] = next_code
+ i += 1
+ next_code += 1
+ while j < num_target_values:
+ new_target_codes[j] = next_code
+ j += 1
+ next_code += 1
+
+ # get the indexer, and undo the sorting of `target.values`
+ sorted_indexer = (
+ algos.backfill if method == "backfill" else algos.pad
+ )(new_codes, new_target_codes, limit=limit).astype('int64')
+ return sorted_indexer[np.argsort(target_order)]
def get_loc(self, object key):
if is_definitely_invalid_key(key):
diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py
index 4e2d07ddf9225..7aa1456846612 100644
--- a/pandas/core/indexes/multi.py
+++ b/pandas/core/indexes/multi.py
@@ -2455,7 +2455,9 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
raise NotImplementedError(
"tolerance not implemented yet for MultiIndex"
)
- indexer = self._engine.get_indexer(target, method, limit)
+ indexer = self._engine.get_indexer(
+ values=self.values, target=target, method=method, limit=limit
+ )
elif method == "nearest":
raise NotImplementedError(
"method='nearest' not implemented yet "
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index a71b4a0983c63..c3b9a7bf05c7b 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -1432,6 +1432,81 @@ def test_set_value_resize(self, float_frame):
with pytest.raises(ValueError, match=msg):
res._set_value("foobar", "baz", "sam")
+ def test_reindex_with_multi_index(self):
+ # https://github.com/pandas-dev/pandas/issues/29896
+ # tests for reindexing a multi-indexed DataFrame with a new MultiIndex
+ #
+ # confirms that we can reindex a multi-indexed DataFrame with a new
+ # MultiIndex object correctly when using no filling, backfilling, and
+ # padding
+ #
+ # The DataFrame, `df`, used in this test is:
+ # c
+ # a b
+ # -1 0 A
+ # 1 B
+ # 2 C
+ # 3 D
+ # 4 E
+ # 5 F
+ # 6 G
+ # 0 0 A
+ # 1 B
+ # 2 C
+ # 3 D
+ # 4 E
+ # 5 F
+ # 6 G
+ # 1 0 A
+ # 1 B
+ # 2 C
+ # 3 D
+ # 4 E
+ # 5 F
+ # 6 G
+ #
+ # and the other MultiIndex, `new_multi_index`, is:
+ # 0: 0 0.5
+ # 1: 2.0
+ # 2: 5.0
+ # 3: 5.8
+ df = pd.DataFrame(
+ {
+ "a": [-1] * 7 + [0] * 7 + [1] * 7,
+ "b": list(range(7)) * 3,
+ "c": ["A", "B", "C", "D", "E", "F", "G"] * 3,
+ }
+ ).set_index(["a", "b"])
+ new_index = [0.5, 2.0, 5.0, 5.8]
+ new_multi_index = MultiIndex.from_product([[0], new_index], names=["a", "b"])
+
+ # reindexing w/o a `method` value
+ reindexed = df.reindex(new_multi_index)
+ expected = pd.DataFrame(
+ {"a": [0] * 4, "b": new_index, "c": [np.nan, "C", "F", np.nan]}
+ ).set_index(["a", "b"])
+ tm.assert_frame_equal(expected, reindexed)
+
+ # reindexing with backfilling
+ expected = pd.DataFrame(
+ {"a": [0] * 4, "b": new_index, "c": ["B", "C", "F", "G"]}
+ ).set_index(["a", "b"])
+ reindexed_with_backfilling = df.reindex(new_multi_index, method="bfill")
+ tm.assert_frame_equal(expected, reindexed_with_backfilling)
+
+ reindexed_with_backfilling = df.reindex(new_multi_index, method="backfill")
+ tm.assert_frame_equal(expected, reindexed_with_backfilling)
+
+ # reindexing with padding
+ expected = pd.DataFrame(
+ {"a": [0] * 4, "b": new_index, "c": ["A", "C", "F", "F"]}
+ ).set_index(["a", "b"])
+ reindexed_with_padding = df.reindex(new_multi_index, method="pad")
+ tm.assert_frame_equal(expected, reindexed_with_padding)
+
+ reindexed_with_padding = df.reindex(new_multi_index, method="ffill")
+ tm.assert_frame_equal(expected, reindexed_with_padding)
+
def test_set_value_with_index_dtype_change(self):
df_orig = DataFrame(np.random.randn(3, 3), index=range(3), columns=list("ABC"))
diff --git a/pandas/tests/indexes/multi/test_indexing.py b/pandas/tests/indexes/multi/test_indexing.py
index d104c773227d5..8c0dae433c8f4 100644
--- a/pandas/tests/indexes/multi/test_indexing.py
+++ b/pandas/tests/indexes/multi/test_indexing.py
@@ -239,6 +239,203 @@ def test_get_indexer_with_missing_value(self, index_arr, labels, expected):
result = idx.get_indexer(labels)
tm.assert_numpy_array_equal(result, expected)
+ def test_get_indexer_methods(self):
+ # https://github.com/pandas-dev/pandas/issues/29896
+ # test getting an indexer for another index with different methods
+ # confirms that getting an indexer without a filling method, getting an
+ # indexer and backfilling, and getting an indexer and padding all behave
+ # correctly in the case where all of the target values fall in between
+ # several levels in the MultiIndex into which they are getting an indexer
+ #
+ # visually, the MultiIndexes used in this test are:
+ # mult_idx_1:
+ # 0: -1 0
+ # 1: 2
+ # 2: 3
+ # 3: 4
+ # 4: 0 0
+ # 5: 2
+ # 6: 3
+ # 7: 4
+ # 8: 1 0
+ # 9: 2
+ # 10: 3
+ # 11: 4
+ #
+ # mult_idx_2:
+ # 0: 0 1
+ # 1: 3
+ # 2: 4
+ mult_idx_1 = MultiIndex.from_product([[-1, 0, 1], [0, 2, 3, 4]])
+ mult_idx_2 = MultiIndex.from_product([[0], [1, 3, 4]])
+
+ indexer = mult_idx_1.get_indexer(mult_idx_2)
+ expected = np.array([-1, 6, 7], dtype=indexer.dtype)
+ tm.assert_almost_equal(expected, indexer)
+
+ backfill_indexer = mult_idx_1.get_indexer(mult_idx_2, method="backfill")
+ expected = np.array([5, 6, 7], dtype=backfill_indexer.dtype)
+ tm.assert_almost_equal(expected, backfill_indexer)
+
+ # ensure the legacy "bfill" option functions identically to "backfill"
+ backfill_indexer = mult_idx_1.get_indexer(mult_idx_2, method="bfill")
+ expected = np.array([5, 6, 7], dtype=backfill_indexer.dtype)
+ tm.assert_almost_equal(expected, backfill_indexer)
+
+ pad_indexer = mult_idx_1.get_indexer(mult_idx_2, method="pad")
+ expected = np.array([4, 6, 7], dtype=pad_indexer.dtype)
+ tm.assert_almost_equal(expected, pad_indexer)
+
+ # ensure the legacy "ffill" option functions identically to "pad"
+ pad_indexer = mult_idx_1.get_indexer(mult_idx_2, method="ffill")
+ expected = np.array([4, 6, 7], dtype=pad_indexer.dtype)
+ tm.assert_almost_equal(expected, pad_indexer)
+
+ def test_get_indexer_three_or_more_levels(self):
+ # https://github.com/pandas-dev/pandas/issues/29896
+ # tests get_indexer() on MultiIndexes with 3+ levels
+ # visually, these are
+ # mult_idx_1:
+ # 0: 1 2 5
+ # 1: 7
+ # 2: 4 5
+ # 3: 7
+ # 4: 6 5
+ # 5: 7
+ # 6: 3 2 5
+ # 7: 7
+ # 8: 4 5
+ # 9: 7
+ # 10: 6 5
+ # 11: 7
+ #
+ # mult_idx_2:
+ # 0: 1 1 8
+ # 1: 1 5 9
+ # 2: 1 6 7
+ # 3: 2 1 6
+ # 4: 2 7 6
+ # 5: 2 7 8
+ # 6: 3 6 8
+ mult_idx_1 = pd.MultiIndex.from_product([[1, 3], [2, 4, 6], [5, 7]])
+ mult_idx_2 = pd.MultiIndex.from_tuples(
+ [
+ (1, 1, 8),
+ (1, 5, 9),
+ (1, 6, 7),
+ (2, 1, 6),
+ (2, 7, 7),
+ (2, 7, 8),
+ (3, 6, 8),
+ ]
+ )
+ # sanity check
+ assert mult_idx_1.is_monotonic
+ assert mult_idx_1.is_unique
+ assert mult_idx_2.is_monotonic
+ assert mult_idx_2.is_unique
+
+ # show the relationships between the two
+ assert mult_idx_2[0] < mult_idx_1[0]
+ assert mult_idx_1[3] < mult_idx_2[1] < mult_idx_1[4]
+ assert mult_idx_1[5] == mult_idx_2[2]
+ assert mult_idx_1[5] < mult_idx_2[3] < mult_idx_1[6]
+ assert mult_idx_1[5] < mult_idx_2[4] < mult_idx_1[6]
+ assert mult_idx_1[5] < mult_idx_2[5] < mult_idx_1[6]
+ assert mult_idx_1[-1] < mult_idx_2[6]
+
+ indexer_no_fill = mult_idx_1.get_indexer(mult_idx_2)
+ expected = np.array([-1, -1, 5, -1, -1, -1, -1], dtype=indexer_no_fill.dtype)
+ tm.assert_almost_equal(expected, indexer_no_fill)
+
+ # test with backfilling
+ indexer_backfilled = mult_idx_1.get_indexer(mult_idx_2, method="backfill")
+ expected = np.array([0, 4, 5, 6, 6, 6, -1], dtype=indexer_backfilled.dtype)
+ tm.assert_almost_equal(expected, indexer_backfilled)
+
+ # now, the same thing, but forward-filled (aka "padded")
+ indexer_padded = mult_idx_1.get_indexer(mult_idx_2, method="pad")
+ expected = np.array([-1, 3, 5, 5, 5, 5, 11], dtype=indexer_padded.dtype)
+ tm.assert_almost_equal(expected, indexer_padded)
+
+ # now, do the indexing in the other direction
+ assert mult_idx_2[0] < mult_idx_1[0] < mult_idx_2[1]
+ assert mult_idx_2[0] < mult_idx_1[1] < mult_idx_2[1]
+ assert mult_idx_2[0] < mult_idx_1[2] < mult_idx_2[1]
+ assert mult_idx_2[0] < mult_idx_1[3] < mult_idx_2[1]
+ assert mult_idx_2[1] < mult_idx_1[4] < mult_idx_2[2]
+ assert mult_idx_2[2] == mult_idx_1[5]
+ assert mult_idx_2[5] < mult_idx_1[6] < mult_idx_2[6]
+ assert mult_idx_2[5] < mult_idx_1[7] < mult_idx_2[6]
+ assert mult_idx_2[5] < mult_idx_1[8] < mult_idx_2[6]
+ assert mult_idx_2[5] < mult_idx_1[9] < mult_idx_2[6]
+ assert mult_idx_2[5] < mult_idx_1[10] < mult_idx_2[6]
+ assert mult_idx_2[5] < mult_idx_1[11] < mult_idx_2[6]
+
+ indexer = mult_idx_2.get_indexer(mult_idx_1)
+ expected = np.array(
+ [-1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, -1], dtype=indexer.dtype
+ )
+ tm.assert_almost_equal(expected, indexer)
+
+ backfill_indexer = mult_idx_2.get_indexer(mult_idx_1, method="bfill")
+ expected = np.array(
+ [1, 1, 1, 1, 2, 2, 6, 6, 6, 6, 6, 6], dtype=backfill_indexer.dtype
+ )
+ tm.assert_almost_equal(expected, backfill_indexer)
+
+ pad_indexer = mult_idx_2.get_indexer(mult_idx_1, method="pad")
+ expected = np.array(
+ [0, 0, 0, 0, 1, 2, 5, 5, 5, 5, 5, 5], dtype=pad_indexer.dtype
+ )
+ tm.assert_almost_equal(expected, pad_indexer)
+
+ def test_get_indexer_crossing_levels(self):
+ # https://github.com/pandas-dev/pandas/issues/29896
+ # tests a corner case with get_indexer() with MultiIndexes where, when we
+ # need to "carry" across levels, proper tuple ordering is respected
+ #
+ # the MultiIndexes used in this test, visually, are:
+ # mult_idx_1:
+ # 0: 1 1 1 1
+ # 1: 2
+ # 2: 2 1
+ # 3: 2
+ # 4: 1 2 1 1
+ # 5: 2
+ # 6: 2 1
+ # 7: 2
+ # 8: 2 1 1 1
+ # 9: 2
+ # 10: 2 1
+ # 11: 2
+ # 12: 2 2 1 1
+ # 13: 2
+ # 14: 2 1
+ # 15: 2
+ #
+ # mult_idx_2:
+ # 0: 1 3 2 2
+ # 1: 2 3 2 2
+ mult_idx_1 = pd.MultiIndex.from_product([[1, 2]] * 4)
+ mult_idx_2 = pd.MultiIndex.from_tuples([(1, 3, 2, 2), (2, 3, 2, 2)])
+
+ # show the tuple orderings, which get_indexer() should respect
+ assert mult_idx_1[7] < mult_idx_2[0] < mult_idx_1[8]
+ assert mult_idx_1[-1] < mult_idx_2[1]
+
+ indexer = mult_idx_1.get_indexer(mult_idx_2)
+ expected = np.array([-1, -1], dtype=indexer.dtype)
+ tm.assert_almost_equal(expected, indexer)
+
+ backfill_indexer = mult_idx_1.get_indexer(mult_idx_2, method="bfill")
+ expected = np.array([8, -1], dtype=backfill_indexer.dtype)
+ tm.assert_almost_equal(expected, backfill_indexer)
+
+ pad_indexer = mult_idx_1.get_indexer(mult_idx_2, method="ffill")
+ expected = np.array([7, 15], dtype=pad_indexer.dtype)
+ tm.assert_almost_equal(expected, pad_indexer)
+
def test_getitem(idx):
# scalar
| - [x] closes https://github.com/pandas-dev/pandas/issues/29896
- [x] tests added / passed
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [x] whatsnew entry
Addresses an issue which appears to have existed since 0.23.0 where bugs in the `get_indexer()` method for the `MultiIndex` class cause incorrect reindexing behavior for multi-indexed DataFrames.
motivating, example, from (the issue)
```python
>>>
>>> df = pd.DataFrame({
... 'a': [0, 0, 0, 0],
... 'b': [0, 2, 3, 4],
... 'c': ['A', 'B', 'C', 'D']
... }).set_index(['a', 'b'])
>>>
>>> df
c
a b
0 0 A
2 B
3 C
4 D
>>> df.index
MultiIndex([(0, 0),
(0, 2),
(0, 3),
(0, 4)],
names=['a', 'b'])
>>> mi_2 = pd.MultiIndex.from_product([[0], [-1, 0, 1, 3, 4, 5]])
>>> mi_2
MultiIndex([(0, -1),
(0, 0),
(0, 1),
(0, 3),
(0, 4),
(0, 5)],
)
```
as expected, without a `method` value:
```python
>>> df.reindex(mi_2)
c
0 -1 NaN
0 A
1 NaN
3 C
4 D
5 NaN
```
using `method="backfill"`, it is:
```python
>>>
>>> df.reindex(mi_2, method="backfill")
c
0 -1 A
0 A
1 D
3 A
4 A
5 C
>>>
```
but should (IMHO) be:
```python
>>> df.reindex(mi_2, method="backfill")
c
0 -1 A
0 A
1 B
3 C
4 D
5 NaN
>>>
```
similarly, using `method="pad"`, it is:
```python
>>> df.reindex(mi_2, method="pad")
c
0 -1 NaN
0 NaN
1 D
3 NaN
4 A
5 C
```
but should (IMHO) be:
```python
>>> df.reindex(mi_2, method="pad")
c
0 -1 NaN
0 A
1 A
3 C
4 D
5 D
``` | https://api.github.com/repos/pandas-dev/pandas/pulls/30766 | 2020-01-06T23:35:31Z | 2020-04-08T17:22:44Z | 2020-04-08T17:22:44Z | 2020-04-08T17:27:44Z |
in tests, change pd.arrays.SparseArray to SparseArray | diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index d6d7db0d99d96..b1b5a9482e34f 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -11,6 +11,15 @@
import pandas._testing as tm
from pandas.api.extensions import register_extension_dtype
from pandas.api.types import is_scalar
+from pandas.arrays import (
+ BooleanArray,
+ DatetimeArray,
+ IntegerArray,
+ IntervalArray,
+ SparseArray,
+ StringArray,
+ TimedeltaArray,
+)
from pandas.core.arrays import PandasArray, integer_array, period_array
from pandas.tests.extension.decimal import DecimalArray, DecimalDtype, to_decimal
@@ -19,18 +28,14 @@
"data, dtype, expected",
[
# Basic NumPy defaults.
- ([1, 2], None, pd.arrays.IntegerArray._from_sequence([1, 2])),
+ ([1, 2], None, IntegerArray._from_sequence([1, 2])),
([1, 2], object, PandasArray(np.array([1, 2], dtype=object))),
(
[1, 2],
np.dtype("float32"),
PandasArray(np.array([1.0, 2.0], dtype=np.dtype("float32"))),
),
- (
- np.array([1, 2], dtype="int64"),
- None,
- pd.arrays.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
@@ -49,37 +54,33 @@
(
[1, 2],
np.dtype("datetime64[ns]"),
- pd.arrays.DatetimeArray._from_sequence(
- np.array([1, 2], dtype="datetime64[ns]")
- ),
+ DatetimeArray._from_sequence(np.array([1, 2], dtype="datetime64[ns]")),
),
(
np.array([1, 2], dtype="datetime64[ns]"),
None,
- pd.arrays.DatetimeArray._from_sequence(
- np.array([1, 2], dtype="datetime64[ns]")
- ),
+ DatetimeArray._from_sequence(np.array([1, 2], dtype="datetime64[ns]")),
),
(
pd.DatetimeIndex(["2000", "2001"]),
np.dtype("datetime64[ns]"),
- pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+ DatetimeArray._from_sequence(["2000", "2001"]),
),
(
pd.DatetimeIndex(["2000", "2001"]),
None,
- pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+ DatetimeArray._from_sequence(["2000", "2001"]),
),
(
["2000", "2001"],
np.dtype("datetime64[ns]"),
- pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+ DatetimeArray._from_sequence(["2000", "2001"]),
),
# Datetime (tz-aware)
(
["2000", "2001"],
pd.DatetimeTZDtype(tz="CET"),
- pd.arrays.DatetimeArray._from_sequence(
+ DatetimeArray._from_sequence(
["2000", "2001"], dtype=pd.DatetimeTZDtype(tz="CET")
),
),
@@ -87,17 +88,17 @@
(
["1H", "2H"],
np.dtype("timedelta64[ns]"),
- pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+ TimedeltaArray._from_sequence(["1H", "2H"]),
),
(
pd.TimedeltaIndex(["1H", "2H"]),
np.dtype("timedelta64[ns]"),
- pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+ TimedeltaArray._from_sequence(["1H", "2H"]),
),
(
pd.TimedeltaIndex(["1H", "2H"]),
None,
- pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+ TimedeltaArray._from_sequence(["1H", "2H"]),
),
# Category
(["a", "b"], "category", pd.Categorical(["a", "b"])),
@@ -110,27 +111,19 @@
(
[pd.Interval(1, 2), pd.Interval(3, 4)],
"interval",
- pd.arrays.IntervalArray.from_tuples([(1, 2), (3, 4)]),
+ IntervalArray.from_tuples([(1, 2), (3, 4)]),
),
# Sparse
- ([0, 1], "Sparse[int64]", pd.arrays.SparseArray([0, 1], dtype="int64")),
+ ([0, 1], "Sparse[int64]", SparseArray([0, 1], dtype="int64")),
# IntegerNA
([1, None], "Int16", integer_array([1, None], dtype="Int16")),
(pd.Series([1, 2]), None, PandasArray(np.array([1, 2], dtype=np.int64))),
# String
- (["a", None], "string", pd.arrays.StringArray._from_sequence(["a", None])),
- (
- ["a", None],
- pd.StringDtype(),
- pd.arrays.StringArray._from_sequence(["a", None]),
- ),
+ (["a", None], "string", StringArray._from_sequence(["a", None])),
+ (["a", None], pd.StringDtype(), StringArray._from_sequence(["a", None]),),
# Boolean
- ([True, None], "boolean", pd.arrays.BooleanArray._from_sequence([True, None])),
- (
- [True, None],
- pd.BooleanDtype(),
- pd.arrays.BooleanArray._from_sequence([True, None]),
- ),
+ ([True, None], "boolean", 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
@@ -181,31 +174,28 @@ def test_array_copy():
period_array(["2000", "2001"], freq="D"),
),
# interval
- (
- [pd.Interval(0, 1), pd.Interval(1, 2)],
- pd.arrays.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")],
- pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+ DatetimeArray._from_sequence(["2000", "2001"]),
),
(
[datetime.datetime(2000, 1, 1), datetime.datetime(2001, 1, 1)],
- pd.arrays.DatetimeArray._from_sequence(["2000", "2001"]),
+ DatetimeArray._from_sequence(["2000", "2001"]),
),
(
np.array([1, 2], dtype="M8[ns]"),
- pd.arrays.DatetimeArray(np.array([1, 2], dtype="M8[ns]")),
+ DatetimeArray(np.array([1, 2], dtype="M8[ns]")),
),
(
np.array([1, 2], dtype="M8[us]"),
- pd.arrays.DatetimeArray(np.array([1000, 2000], dtype="M8[ns]")),
+ DatetimeArray(np.array([1000, 2000], dtype="M8[ns]")),
),
# datetimetz
(
[pd.Timestamp("2000", tz="CET"), pd.Timestamp("2001", tz="CET")],
- pd.arrays.DatetimeArray._from_sequence(
+ DatetimeArray._from_sequence(
["2000", "2001"], dtype=pd.DatetimeTZDtype(tz="CET")
),
),
@@ -214,30 +204,30 @@ def test_array_copy():
datetime.datetime(2000, 1, 1, tzinfo=cet),
datetime.datetime(2001, 1, 1, tzinfo=cet),
],
- pd.arrays.DatetimeArray._from_sequence(["2000", "2001"], tz=cet),
+ DatetimeArray._from_sequence(["2000", "2001"], tz=cet),
),
# timedelta
(
[pd.Timedelta("1H"), pd.Timedelta("2H")],
- pd.arrays.TimedeltaArray._from_sequence(["1H", "2H"]),
+ TimedeltaArray._from_sequence(["1H", "2H"]),
),
(
np.array([1, 2], dtype="m8[ns]"),
- pd.arrays.TimedeltaArray(np.array([1, 2], dtype="m8[ns]")),
+ TimedeltaArray(np.array([1, 2], dtype="m8[ns]")),
),
(
np.array([1, 2], dtype="m8[us]"),
- pd.arrays.TimedeltaArray(np.array([1000, 2000], dtype="m8[ns]")),
+ TimedeltaArray(np.array([1000, 2000], dtype="m8[ns]")),
),
# integer
- ([1, 2], pd.arrays.IntegerArray._from_sequence([1, 2])),
- ([1, None], pd.arrays.IntegerArray._from_sequence([1, None])),
+ ([1, 2], IntegerArray._from_sequence([1, 2])),
+ ([1, None], IntegerArray._from_sequence([1, None])),
# string
- (["a", "b"], pd.arrays.StringArray._from_sequence(["a", "b"])),
- (["a", None], pd.arrays.StringArray._from_sequence(["a", None])),
+ (["a", "b"], StringArray._from_sequence(["a", "b"])),
+ (["a", None], StringArray._from_sequence(["a", None])),
# Boolean
- ([True, False], pd.arrays.BooleanArray._from_sequence([True, False])),
- ([True, None], pd.arrays.BooleanArray._from_sequence([True, None])),
+ ([True, False], BooleanArray._from_sequence([True, False])),
+ ([True, None], BooleanArray._from_sequence([True, None])),
],
)
def test_array_inference(data, expected):
diff --git a/pandas/tests/dtypes/test_common.py b/pandas/tests/dtypes/test_common.py
index c96886a1bc7a8..ce925891f62c0 100644
--- a/pandas/tests/dtypes/test_common.py
+++ b/pandas/tests/dtypes/test_common.py
@@ -19,6 +19,7 @@
import pandas as pd
import pandas._testing as tm
+from pandas.arrays import SparseArray
from pandas.conftest import (
ALL_EA_INT_DTYPES,
ALL_INT_DTYPES,
@@ -182,7 +183,7 @@ def test_is_object():
"check_scipy", [False, pytest.param(True, marks=td.skip_if_no_scipy)]
)
def test_is_sparse(check_scipy):
- assert com.is_sparse(pd.arrays.SparseArray([1, 2, 3]))
+ assert com.is_sparse(SparseArray([1, 2, 3]))
assert not com.is_sparse(np.array([1, 2, 3]))
@@ -198,7 +199,7 @@ def test_is_scipy_sparse():
assert com.is_scipy_sparse(bsr_matrix([1, 2, 3]))
- assert not com.is_scipy_sparse(pd.arrays.SparseArray([1, 2, 3]))
+ assert not com.is_scipy_sparse(SparseArray([1, 2, 3]))
def test_is_categorical():
@@ -576,7 +577,7 @@ def test_is_extension_type(check_scipy):
cat = pd.Categorical([1, 2, 3])
assert com.is_extension_type(cat)
assert com.is_extension_type(pd.Series(cat))
- assert com.is_extension_type(pd.arrays.SparseArray([1, 2, 3]))
+ assert com.is_extension_type(SparseArray([1, 2, 3]))
assert com.is_extension_type(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
dtype = DatetimeTZDtype("ns", tz="US/Eastern")
@@ -605,7 +606,7 @@ def test_is_extension_array_dtype(check_scipy):
cat = pd.Categorical([1, 2, 3])
assert com.is_extension_array_dtype(cat)
assert com.is_extension_array_dtype(pd.Series(cat))
- assert com.is_extension_array_dtype(pd.arrays.SparseArray([1, 2, 3]))
+ assert com.is_extension_array_dtype(SparseArray([1, 2, 3]))
assert com.is_extension_array_dtype(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
dtype = DatetimeTZDtype("ns", tz="US/Eastern")
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index f47246898b821..fddd6239df309 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -28,7 +28,7 @@
import pandas as pd
from pandas import Categorical, CategoricalIndex, IntervalIndex, Series, date_range
import pandas._testing as tm
-from pandas.core.arrays.sparse import SparseDtype
+from pandas.core.arrays.sparse import SparseArray, SparseDtype
class Base:
@@ -914,7 +914,7 @@ def test_registry_find(dtype, expected):
(pd.Series([1, 2]), False),
(np.array([True, False]), True),
(pd.Series([True, False]), True),
- (pd.arrays.SparseArray([True, False]), True),
+ (SparseArray([True, False]), True),
(SparseDtype(bool), True),
],
)
@@ -924,7 +924,7 @@ def test_is_bool_dtype(dtype, expected):
def test_is_bool_dtype_sparse():
- result = is_bool_dtype(pd.Series(pd.arrays.SparseArray([True, False])))
+ result = is_bool_dtype(pd.Series(SparseArray([True, False])))
assert result is True
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index e85f40329a2c5..33c0e92845484 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -21,6 +21,7 @@
notna,
)
import pandas._testing as tm
+from pandas.arrays import SparseArray
import pandas.core.common as com
from pandas.core.indexing import IndexingError
@@ -1776,7 +1777,7 @@ def test_getitem_ix_float_duplicates(self):
def test_getitem_sparse_column(self):
# https://github.com/pandas-dev/pandas/issues/23559
- data = pd.arrays.SparseArray([0, 1])
+ data = SparseArray([0, 1])
df = pd.DataFrame({"A": data})
expected = pd.Series(data, name="A")
result = df["A"]
@@ -1791,7 +1792,7 @@ def test_getitem_sparse_column(self):
def test_setitem_with_sparse_value(self):
# GH8131
df = pd.DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
- sp_array = pd.arrays.SparseArray([0, 0, 1])
+ sp_array = SparseArray([0, 0, 1])
df["new_column"] = sp_array
tm.assert_series_equal(
df["new_column"], pd.Series(sp_array, name="new_column"), check_names=False
@@ -1799,9 +1800,9 @@ def test_setitem_with_sparse_value(self):
def test_setitem_with_unaligned_sparse_value(self):
df = pd.DataFrame({"c_1": ["a", "b", "c"], "n_1": [1.0, 2.0, 3.0]})
- sp_series = pd.Series(pd.arrays.SparseArray([0, 0, 1]), index=[2, 1, 0])
+ sp_series = pd.Series(SparseArray([0, 0, 1]), index=[2, 1, 0])
df["new_column"] = sp_series
- exp = pd.Series(pd.arrays.SparseArray([1, 0, 0]), name="new_column")
+ exp = pd.Series(SparseArray([1, 0, 0]), name="new_column")
tm.assert_series_equal(df["new_column"], exp)
def test_setitem_with_unaligned_tz_aware_datetime_column(self):
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 1f190221b456a..ea1e339f44d93 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -26,7 +26,7 @@
isna,
)
import pandas._testing as tm
-from pandas.arrays import IntervalArray, PeriodArray
+from pandas.arrays import IntervalArray, PeriodArray, SparseArray
from pandas.core.construction import create_series_with_explicit_dtype
MIXED_FLOAT_DTYPES = ["float16", "float32", "float64"]
@@ -2414,7 +2414,7 @@ class List(list):
"extension_arr",
[
Categorical(list("aabbc")),
- pd.arrays.SparseArray([1, np.nan, np.nan, np.nan]),
+ SparseArray([1, np.nan, np.nan, np.nan]),
IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)]),
PeriodArray(pd.period_range(start="1/1/2017", end="1/1/2018", freq="M")),
],
diff --git a/pandas/tests/reshape/test_reshape.py b/pandas/tests/reshape/test_reshape.py
index 776f610f17e8e..f25291f4aef12 100644
--- a/pandas/tests/reshape/test_reshape.py
+++ b/pandas/tests/reshape/test_reshape.py
@@ -45,7 +45,7 @@ def test_basic(self, sparse, dtype):
dtype=self.effective_dtype(dtype),
)
if sparse:
- expected = expected.apply(pd.arrays.SparseArray, fill_value=0.0)
+ expected = expected.apply(SparseArray, fill_value=0.0)
result = get_dummies(s_list, sparse=sparse, dtype=dtype)
tm.assert_frame_equal(result, expected)
@@ -132,7 +132,7 @@ def test_include_na(self, sparse, dtype):
{"a": [1, 0, 0], "b": [0, 1, 0]}, dtype=self.effective_dtype(dtype)
)
if sparse:
- exp = exp.apply(pd.arrays.SparseArray, fill_value=0.0)
+ exp = exp.apply(SparseArray, fill_value=0.0)
tm.assert_frame_equal(res, exp)
# Sparse dataframes do not allow nan labelled columns, see #GH8822
@@ -145,7 +145,7 @@ def test_include_na(self, sparse, dtype):
# hack (NaN handling in assert_index_equal)
exp_na.columns = res_na.columns
if sparse:
- exp_na = exp_na.apply(pd.arrays.SparseArray, fill_value=0.0)
+ exp_na = exp_na.apply(SparseArray, fill_value=0.0)
tm.assert_frame_equal(res_na, exp_na)
res_just_na = get_dummies([np.nan], dummy_na=True, sparse=sparse, dtype=dtype)
@@ -167,7 +167,7 @@ def test_unicode(self, sparse):
dtype=np.uint8,
)
if sparse:
- exp = exp.apply(pd.arrays.SparseArray, fill_value=0)
+ exp = exp.apply(SparseArray, fill_value=0)
tm.assert_frame_equal(res, exp)
def test_dataframe_dummies_all_obj(self, df, sparse):
@@ -180,10 +180,10 @@ def test_dataframe_dummies_all_obj(self, df, sparse):
if sparse:
expected = pd.DataFrame(
{
- "A_a": pd.arrays.SparseArray([1, 0, 1], dtype="uint8"),
- "A_b": pd.arrays.SparseArray([0, 1, 0], dtype="uint8"),
- "B_b": pd.arrays.SparseArray([1, 1, 0], dtype="uint8"),
- "B_c": pd.arrays.SparseArray([0, 0, 1], dtype="uint8"),
+ "A_a": SparseArray([1, 0, 1], dtype="uint8"),
+ "A_b": SparseArray([0, 1, 0], dtype="uint8"),
+ "B_b": SparseArray([1, 1, 0], dtype="uint8"),
+ "B_c": SparseArray([0, 0, 1], dtype="uint8"),
}
)
@@ -226,7 +226,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 = pd.arrays.SparseArray if sparse else pd.Series
+ typ = SparseArray if sparse else pd.Series
expected[cols] = expected[cols].apply(lambda x: typ(x))
tm.assert_frame_equal(result, expected)
@@ -423,7 +423,7 @@ def test_basic_drop_first(self, sparse):
result = get_dummies(s_list, drop_first=True, sparse=sparse)
if sparse:
- expected = expected.apply(pd.arrays.SparseArray, fill_value=0)
+ expected = expected.apply(SparseArray, fill_value=0)
tm.assert_frame_equal(result, expected)
result = get_dummies(s_series, drop_first=True, sparse=sparse)
@@ -457,7 +457,7 @@ def test_basic_drop_first_NA(self, sparse):
res = get_dummies(s_NA, drop_first=True, sparse=sparse)
exp = DataFrame({"b": [0, 1, 0]}, dtype=np.uint8)
if sparse:
- exp = exp.apply(pd.arrays.SparseArray, fill_value=0)
+ exp = exp.apply(SparseArray, fill_value=0)
tm.assert_frame_equal(res, exp)
@@ -466,7 +466,7 @@ def test_basic_drop_first_NA(self, sparse):
["b", np.nan], axis=1
)
if sparse:
- exp_na = exp_na.apply(pd.arrays.SparseArray, fill_value=0)
+ exp_na = exp_na.apply(SparseArray, fill_value=0)
tm.assert_frame_equal(res_na, exp_na)
res_just_na = get_dummies(
@@ -480,7 +480,7 @@ def test_dataframe_dummies_drop_first(self, df, sparse):
result = get_dummies(df, drop_first=True, sparse=sparse)
expected = DataFrame({"A_b": [0, 1, 0], "B_c": [0, 0, 1]}, dtype=np.uint8)
if sparse:
- expected = expected.apply(pd.arrays.SparseArray, fill_value=0)
+ expected = expected.apply(SparseArray, fill_value=0)
tm.assert_frame_equal(result, expected)
def test_dataframe_dummies_drop_first_with_categorical(self, df, sparse, dtype):
@@ -494,7 +494,7 @@ def test_dataframe_dummies_drop_first_with_categorical(self, df, sparse, dtype):
expected = expected[["C", "A_b", "B_c", "cat_y"]]
if sparse:
for col in cols:
- expected[col] = pd.arrays.SparseArray(expected[col])
+ expected[col] = SparseArray(expected[col])
tm.assert_frame_equal(result, expected)
def test_dataframe_dummies_drop_first_with_na(self, df, sparse):
@@ -516,7 +516,7 @@ def test_dataframe_dummies_drop_first_with_na(self, df, sparse):
expected = expected.sort_index(axis=1)
if sparse:
for col in cols:
- expected[col] = pd.arrays.SparseArray(expected[col])
+ expected[col] = SparseArray(expected[col])
tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/series/test_ufunc.py b/pandas/tests/series/test_ufunc.py
index 067ee1b465bb1..ece7f1f21ab23 100644
--- a/pandas/tests/series/test_ufunc.py
+++ b/pandas/tests/series/test_ufunc.py
@@ -6,6 +6,7 @@
import pandas as pd
import pandas._testing as tm
+from pandas.arrays import SparseArray
UNARY_UFUNCS = [np.positive, np.floor, np.exp]
BINARY_UFUNCS = [np.add, np.logaddexp] # dunder op
@@ -33,7 +34,7 @@ def test_unary_ufunc(ufunc, sparse):
array = np.random.randint(0, 10, 10, dtype="int64")
array[::2] = 0
if sparse:
- array = pd.arrays.SparseArray(array, dtype=pd.SparseDtype("int64", 0))
+ array = SparseArray(array, dtype=pd.SparseDtype("int64", 0))
index = list(string.ascii_letters[:10])
name = "name"
@@ -51,8 +52,8 @@ def test_binary_ufunc_with_array(flip, sparse, ufunc, arrays_for_binary_ufunc):
# Test that ufunc(Series(a), array) == Series(ufunc(a, b))
a1, a2 = arrays_for_binary_ufunc
if sparse:
- a1 = pd.arrays.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
- a2 = pd.arrays.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+ a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+ a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
name = "name" # op(Series, array) preserves the name.
series = pd.Series(a1, name=name)
@@ -79,8 +80,8 @@ def test_binary_ufunc_with_index(flip, sparse, ufunc, arrays_for_binary_ufunc):
# * ufunc(Index, Series) dispatches to Series (returns a Series)
a1, a2 = arrays_for_binary_ufunc
if sparse:
- a1 = pd.arrays.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
- a2 = pd.arrays.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+ a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+ a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
name = "name" # op(Series, array) preserves the name.
series = pd.Series(a1, name=name)
@@ -110,8 +111,8 @@ def test_binary_ufunc_with_series(
# with alignment between the indices
a1, a2 = arrays_for_binary_ufunc
if sparse:
- a1 = pd.arrays.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
- a2 = pd.arrays.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+ a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+ a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
name = "name" # op(Series, array) preserves the name.
series = pd.Series(a1, name=name)
@@ -149,7 +150,7 @@ def test_binary_ufunc_scalar(ufunc, sparse, flip, arrays_for_binary_ufunc):
# * ufunc(Series, scalar) == ufunc(scalar, Series)
array, _ = arrays_for_binary_ufunc
if sparse:
- array = pd.arrays.SparseArray(array)
+ array = SparseArray(array)
other = 2
series = pd.Series(array, name="name")
@@ -183,8 +184,8 @@ def test_multiple_ouput_binary_ufuncs(ufunc, sparse, shuffle, arrays_for_binary_
a2[a2 == 0] = 1
if sparse:
- a1 = pd.arrays.SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
- a2 = pd.arrays.SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
+ a1 = SparseArray(a1, dtype=pd.SparseDtype("int64", 0))
+ a2 = SparseArray(a2, dtype=pd.SparseDtype("int64", 0))
s1 = pd.Series(a1)
s2 = pd.Series(a2)
@@ -209,7 +210,7 @@ def test_multiple_ouput_ufunc(sparse, arrays_for_binary_ufunc):
array, _ = arrays_for_binary_ufunc
if sparse:
- array = pd.arrays.SparseArray(array)
+ array = SparseArray(array)
series = pd.Series(array, name="name")
result = np.modf(series)
| - [x] closes https://github.com/pandas-dev/pandas/pull/30656#discussion_r363060184
- [x] tests added / passed
- modified most tests that use `pd.arrays.SparseArray` to just import `SparseArray`
- [x] passes `black pandas`
- [x] passes `git diff upstream/master -u -- "*.py" | flake8 --diff`
- [ ] whatsnew entry
- N/A
For @jreback to review based on his comment previous PR #30656
In a few files (see below), left it as is because usage was pretty local (and allows `pd.arrays.SparseArray` reference to be tested in code)
```bash
$ grep -c -r arrays.SparseArray . | grep -v ":0"
./dtypes/test_generic.py:1
./frame/methods/test_quantile.py:2
./series/test_missing.py:2
```
| https://api.github.com/repos/pandas-dev/pandas/pulls/30765 | 2020-01-06T23:34:09Z | 2020-01-08T18:41:50Z | 2020-01-08T18:41:50Z | 2020-01-10T17:02:42Z |
BUG: TDI/DTI _shallow_copy creating invalid arrays | diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py
index 34560065525dd..3a58794a8b19e 100644
--- a/pandas/core/indexes/datetimelike.py
+++ b/pandas/core/indexes/datetimelike.py
@@ -28,7 +28,12 @@
from pandas.core import algorithms
from pandas.core.accessor import PandasDelegate
-from pandas.core.arrays import ExtensionArray, ExtensionOpsMixin
+from pandas.core.arrays import (
+ DatetimeArray,
+ ExtensionArray,
+ ExtensionOpsMixin,
+ TimedeltaArray,
+)
from pandas.core.arrays.datetimelike import (
DatetimeLikeArrayMixin,
_ensure_datetimelike_to_i8,
@@ -251,15 +256,10 @@ def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
if isinstance(maybe_slice, slice):
return self[maybe_slice]
- taken = ExtensionIndex.take(
+ return ExtensionIndex.take(
self, indices, axis, allow_fill, fill_value, **kwargs
)
- # keep freq in PeriodArray/Index, reset otherwise
- freq = self.freq if is_period_dtype(self) else None
- assert taken.freq == freq, (taken.freq, freq, taken)
- return self._shallow_copy(taken, freq=freq)
-
_can_hold_na = True
_na_value = NaT
@@ -486,8 +486,8 @@ def isin(self, values, level=None):
@Appender(_index_shared_docs["repeat"] % _index_doc_kwargs)
def repeat(self, repeats, axis=None):
nv.validate_repeat(tuple(), dict(axis=axis))
- freq = self.freq if is_period_dtype(self) else None
- return self._shallow_copy(self.asi8.repeat(repeats), freq=freq)
+ result = type(self._data)(self.asi8.repeat(repeats), dtype=self.dtype)
+ return self._shallow_copy(result)
@Appender(_index_shared_docs["where"] % _index_doc_kwargs)
def where(self, cond, other=None):
@@ -650,6 +650,22 @@ def _set_freq(self, freq):
self._data._freq = freq
+ def _shallow_copy(self, values=None, **kwargs):
+ if values is None:
+ values = self._data
+ if isinstance(values, type(self)):
+ values = values._data
+
+ attributes = self._get_attributes_dict()
+
+ if "freq" not in kwargs and self.freq is not None:
+ if isinstance(values, (DatetimeArray, TimedeltaArray)):
+ if values.freq is None:
+ del attributes["freq"]
+
+ attributes.update(kwargs)
+ return self._simple_new(values, **attributes)
+
# --------------------------------------------------------------------
# Set Operation Methods
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index c75c296e724db..46d7cd2c13626 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -29,6 +29,25 @@ def test_freq_validation_with_nat(self, dt_cls):
with pytest.raises(ValueError, match=msg):
dt_cls([pd.NaT, pd.Timestamp("2011-01-01").value], freq="D")
+ # TODO: better place for tests shared by DTI/TDI?
+ @pytest.mark.parametrize(
+ "index",
+ [
+ pd.date_range("2016-01-01", periods=5, tz="US/Pacific"),
+ pd.timedelta_range("1 Day", periods=5),
+ ],
+ )
+ def test_shallow_copy_inherits_array_freq(self, index):
+ # If we pass a DTA/TDA to shallow_copy and dont specify a freq,
+ # we should inherit the array's freq, not our own.
+ array = index._data
+
+ arr = array[[0, 3, 2, 4, 1]]
+ assert arr.freq is None
+
+ result = index._shallow_copy(arr)
+ assert result.freq is None
+
def test_categorical_preserves_tz(self):
# GH#18664 retain tz when going DTI-->Categorical-->DTI
# TODO: parametrize over DatetimeIndex/DatetimeArray
| Following this we should be able to use shallow_copy in indexes.extension more, which will help with perf (xref #30717) | https://api.github.com/repos/pandas-dev/pandas/pulls/30764 | 2020-01-06T23:31:50Z | 2020-01-07T00:39:39Z | 2020-01-07T00:39:38Z | 2020-01-07T01:40:36Z |
BUG: PeriodIndex.searchsorted accepting invalid inputs | diff --git a/doc/source/whatsnew/v1.0.0.rst b/doc/source/whatsnew/v1.0.0.rst
index 330510c2c883c..f759e33d395b8 100755
--- a/doc/source/whatsnew/v1.0.0.rst
+++ b/doc/source/whatsnew/v1.0.0.rst
@@ -905,6 +905,7 @@ Indexing
- :meth:`Index.get_indexer_non_unique` could fail with `TypeError` in some cases, such as when searching for ints in a string index (:issue:`28257`)
- Bug in :meth:`Float64Index.get_loc` incorrectly raising ``TypeError`` instead of ``KeyError`` (:issue:`29189`)
- Bug in :meth:`Series.__setitem__` incorrectly assigning values with boolean indexer when the length of new data matches the number of ``True`` values and new data is not a ``Series`` or an ``np.array`` (:issue:`30567`)
+- Bug in indexing with a :class:`PeriodIndex` incorrectly accepting integers representing years, use e.g. ``ser.loc["2007"]`` instead of ``ser.loc[2007]`` (:issue:`30763`)
Missing
^^^^^^^
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 1edcf581c5131..cd2cc2d8b324f 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -6976,8 +6976,7 @@ def asof(self, where, subset=None):
if not is_list:
start = self.index[0]
if isinstance(self.index, PeriodIndex):
- where = Period(where, freq=self.index.freq).ordinal
- start = start.ordinal
+ where = Period(where, freq=self.index.freq)
if where < start:
if not is_series:
diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py
index 6ba778bc83dd1..a7c4bfbacc5e8 100644
--- a/pandas/core/indexes/period.py
+++ b/pandas/core/indexes/period.py
@@ -479,17 +479,19 @@ def astype(self, dtype, copy=True, how="start"):
@Substitution(klass="PeriodIndex")
@Appender(_shared_docs["searchsorted"])
def searchsorted(self, value, side="left", sorter=None):
- if isinstance(value, Period):
- if value.freq != self.freq:
- raise raise_on_incompatible(self, value)
- value = value.ordinal
+ if isinstance(value, Period) or value is NaT:
+ self._data._check_compatible_with(value)
elif isinstance(value, str):
try:
- value = Period(value, freq=self.freq).ordinal
+ value = Period(value, freq=self.freq)
except DateParseError:
raise KeyError(f"Cannot interpret '{value}' as period")
+ elif not isinstance(value, PeriodArray):
+ raise TypeError(
+ "PeriodIndex.searchsorted requires either a Period or PeriodArray"
+ )
- return self._ndarray_values.searchsorted(value, side=side, sorter=sorter)
+ return self._data.searchsorted(value, side=side, sorter=sorter)
@property
def is_full(self) -> bool:
@@ -722,8 +724,7 @@ def _get_string_slice(self, key):
t1, t2 = self._parsed_string_to_bounds(reso, parsed)
return slice(
- self.searchsorted(t1.ordinal, side="left"),
- self.searchsorted(t2.ordinal, side="right"),
+ self.searchsorted(t1, side="left"), self.searchsorted(t2, side="right")
)
def _convert_tolerance(self, tolerance, target):
diff --git a/pandas/core/resample.py b/pandas/core/resample.py
index 056ba73edfe34..0e43880dfda07 100644
--- a/pandas/core/resample.py
+++ b/pandas/core/resample.py
@@ -1586,7 +1586,10 @@ def _get_period_bins(self, ax):
rng += freq_mult
# adjust bin edge indexes to account for base
rng -= bin_shift
- bins = memb.searchsorted(rng, side="left")
+
+ # Wrap in PeriodArray for PeriodArray.searchsorted
+ prng = type(memb._data)(rng, dtype=memb.dtype)
+ bins = memb.searchsorted(prng, side="left")
if nat_count > 0:
# NaT handling as in pandas._lib.lib.generate_bins_dt64()
diff --git a/pandas/tests/frame/methods/test_asof.py b/pandas/tests/frame/methods/test_asof.py
index 774369794cb90..0291be0a4083e 100644
--- a/pandas/tests/frame/methods/test_asof.py
+++ b/pandas/tests/frame/methods/test_asof.py
@@ -1,7 +1,7 @@
import numpy as np
import pytest
-from pandas import DataFrame, Series, Timestamp, date_range, to_datetime
+from pandas import DataFrame, Period, Series, Timestamp, date_range, to_datetime
import pandas._testing as tm
@@ -80,6 +80,12 @@ def test_missing(self, date_range_frame):
)
tm.assert_frame_equal(result, expected)
+ # Check that we handle PeriodIndex correctly, dont end up with
+ # period.ordinal for series name
+ df = df.to_period("D")
+ result = df.asof("1989-12-31")
+ assert isinstance(result.name, Period)
+
def test_all_nans(self, date_range_frame):
# GH 15713
# DataFrame is all nans
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 4eacf4038b794..16fa0b0c25925 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -451,7 +451,7 @@ def test_index_duplicate_periods(self):
idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq="A-JUN")
ts = Series(np.random.randn(len(idx)), index=idx)
- result = ts[2007]
+ result = ts["2007"]
expected = ts[1:3]
tm.assert_series_equal(result, expected)
result[:] = 1
@@ -461,7 +461,7 @@ def test_index_duplicate_periods(self):
idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq="A-JUN")
ts = Series(np.random.randn(len(idx)), index=idx)
- result = ts[2007]
+ result = ts["2007"]
expected = ts[idx == "2007"]
tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 2135b8a992128..28ab14af71362 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -231,14 +231,43 @@ def test_searchsorted(self, freq):
p2 = pd.Period("2014-01-04", freq=freq)
assert pidx.searchsorted(p2) == 3
- msg = "Input has different freq=H from PeriodIndex"
+ assert pidx.searchsorted(pd.NaT) == 0
+
+ msg = "Input has different freq=H from PeriodArray"
with pytest.raises(IncompatibleFrequency, match=msg):
pidx.searchsorted(pd.Period("2014-01-01", freq="H"))
- msg = "Input has different freq=5D from PeriodIndex"
+ msg = "Input has different freq=5D from PeriodArray"
with pytest.raises(IncompatibleFrequency, match=msg):
pidx.searchsorted(pd.Period("2014-01-01", freq="5D"))
+ def test_searchsorted_invalid(self):
+ pidx = pd.PeriodIndex(
+ ["2014-01-01", "2014-01-02", "2014-01-03", "2014-01-04", "2014-01-05"],
+ freq="D",
+ )
+
+ other = np.array([0, 1], dtype=np.int64)
+
+ msg = "requires either a Period or PeriodArray"
+ with pytest.raises(TypeError, match=msg):
+ pidx.searchsorted(other)
+
+ with pytest.raises(TypeError, match=msg):
+ pidx.searchsorted(other.astype("timedelta64[ns]"))
+
+ with pytest.raises(TypeError, match=msg):
+ pidx.searchsorted(np.timedelta64(4))
+
+ with pytest.raises(TypeError, match=msg):
+ pidx.searchsorted(np.timedelta64("NaT", "ms"))
+
+ with pytest.raises(TypeError, match=msg):
+ pidx.searchsorted(np.datetime64(4, "ns"))
+
+ with pytest.raises(TypeError, match=msg):
+ pidx.searchsorted(np.datetime64("NaT", "ns"))
+
class TestPeriodIndexConversion:
def test_tolist(self):
| also a bug in `DataFrame.asof` with a PeriodIndex returning an incorrectly-named Series. | https://api.github.com/repos/pandas-dev/pandas/pulls/30763 | 2020-01-06T23:29:22Z | 2020-01-08T14:02:13Z | 2020-01-08T14:02:13Z | 2020-01-08T18:17:11Z |
DOC: Fix the string example. | diff --git a/doc/source/user_guide/text.rst b/doc/source/user_guide/text.rst
index 7a8400d124b22..88c86ac212f11 100644
--- a/doc/source/user_guide/text.rst
+++ b/doc/source/user_guide/text.rst
@@ -87,8 +87,9 @@ l. For ``StringDtype``, :ref:`string accessor methods<api.series.str>`
.. ipython:: python
- s.astype(object).str.count("a")
- s.astype(object).dropna().str.count("a")
+ s2 = pd.Series(["a", None, "b"], dtype="object")
+ s2.str.count("a")
+ s2.dropna().str.count("a")
When NA values are present, the output dtype is float64. Similarly for
methods returning boolean values.
| After moving StringArray to use pd.NA `.astype(object)` had
NA instead of NaN, so the output was object rather than float. | https://api.github.com/repos/pandas-dev/pandas/pulls/30762 | 2020-01-06T22:40:35Z | 2020-01-06T23:39:57Z | 2020-01-06T23:39:57Z | 2020-01-06T23:39:57Z |
TYP: type up parts of series.py | diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index 0116207675889..03e86758b64ed 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -4121,7 +4121,6 @@ def add_suffix(self: FrameOrSeries, suffix: str) -> FrameOrSeries:
def sort_values(
self,
- by=None,
axis=0,
ascending=True,
inplace: bool_t = False,
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 3e1f011fde51a..ed338700f1011 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4,7 +4,18 @@
from io import StringIO
from shutil import get_terminal_size
from textwrap import dedent
-from typing import IO, Any, Callable, Hashable, List, Optional
+from typing import (
+ IO,
+ TYPE_CHECKING,
+ Any,
+ Callable,
+ Hashable,
+ Iterable,
+ List,
+ Optional,
+ Tuple,
+ Type,
+)
import warnings
import numpy as np
@@ -12,6 +23,7 @@
from pandas._config import get_option
from pandas._libs import index as libindex, lib, reshape, tslibs
+from pandas._typing import Label
from pandas.compat.numpy import function as nv
from pandas.util._decorators import Appender, Substitution
from pandas.util._validators import validate_bool_kwarg, validate_percentile
@@ -80,6 +92,9 @@
import pandas.io.formats.format as fmt
import pandas.plotting
+if TYPE_CHECKING:
+ from pandas.core.frame import DataFrame
+
__all__ = ["Series"]
_shared_doc_kwargs = dict(
@@ -356,11 +371,11 @@ def _init_dict(self, data, index=None, dtype=None):
# ----------------------------------------------------------------------
@property
- def _constructor(self):
+ def _constructor(self) -> Type["Series"]:
return Series
@property
- def _constructor_expanddim(self):
+ def _constructor_expanddim(self) -> Type["DataFrame"]:
from pandas.core.frame import DataFrame
return DataFrame
@@ -372,7 +387,7 @@ def _can_hold_na(self):
_index = None
- def _set_axis(self, axis, labels, fastpath=False):
+ def _set_axis(self, axis, labels, fastpath=False) -> None:
"""
Override generic, we want to set the _typ here.
"""
@@ -517,7 +532,7 @@ def __len__(self) -> int:
"""
return len(self._data)
- def view(self, dtype=None):
+ def view(self, dtype=None) -> "Series":
"""
Create a new view of the Series.
@@ -729,7 +744,7 @@ def __array__(self, dtype=None) -> np.ndarray:
# ----------------------------------------------------------------------
- def _unpickle_series_compat(self, state):
+ def _unpickle_series_compat(self, state) -> None:
if isinstance(state, dict):
self._data = state["_data"]
self.name = state["name"]
@@ -760,7 +775,7 @@ def _unpickle_series_compat(self, state):
# indexers
@property
- def axes(self):
+ def axes(self) -> List[Index]:
"""
Return a list of the row axis labels.
"""
@@ -770,7 +785,7 @@ def axes(self):
# Indexing Methods
@Appender(generic.NDFrame.take.__doc__)
- def take(self, indices, axis=0, is_copy=False, **kwargs):
+ def take(self, indices, axis=0, is_copy=False, **kwargs) -> "Series":
nv.validate_take(tuple(), kwargs)
indices = ensure_platform_int(indices)
@@ -816,7 +831,7 @@ def _ixs(self, i: int, axis: int = 0):
else:
return values[i]
- def _slice(self, slobj: slice, axis: int = 0, kind=None):
+ def _slice(self, slobj: slice, axis: int = 0, kind=None) -> "Series":
slobj = self.index._convert_slice_indexer(slobj, kind=kind or "getitem")
return self._get_values(slobj)
@@ -1100,7 +1115,7 @@ def _set_value(self, label, value, takeable: bool = False):
def _is_mixed_type(self):
return False
- def repeat(self, repeats, axis=None):
+ def repeat(self, repeats, axis=None) -> "Series":
"""
Repeat elements of a Series.
@@ -1425,7 +1440,7 @@ def to_markdown(
# ----------------------------------------------------------------------
- def items(self):
+ def items(self) -> Iterable[Tuple[Label, Any]]:
"""
Lazily iterate over (index, value) tuples.
@@ -1455,13 +1470,13 @@ def items(self):
return zip(iter(self.index), iter(self))
@Appender(items.__doc__)
- def iteritems(self):
+ def iteritems(self) -> Iterable[Tuple[Label, Any]]:
return self.items()
# ----------------------------------------------------------------------
# Misc public methods
- def keys(self):
+ def keys(self) -> Index:
"""
Return alias for index.
@@ -1507,7 +1522,7 @@ def to_dict(self, into=dict):
into_c = com.standardize_mapping(into)
return into_c(self.items())
- def to_frame(self, name=None):
+ def to_frame(self, name=None) -> "DataFrame":
"""
Convert Series to DataFrame.
@@ -1539,7 +1554,7 @@ def to_frame(self, name=None):
return df
- def _set_name(self, name, inplace=False):
+ def _set_name(self, name, inplace=False) -> "Series":
"""
Set the Series name.
@@ -1681,7 +1696,7 @@ def count(self, level=None):
out = np.bincount(obs, minlength=len(lev) or None)
return self._constructor(out, index=lev, dtype="int64").__finalize__(self)
- def mode(self, dropna=True):
+ def mode(self, dropna=True) -> "Series":
"""
Return the mode(s) of the dataset.
@@ -1766,7 +1781,7 @@ def unique(self):
result = super().unique()
return result
- def drop_duplicates(self, keep="first", inplace=False):
+ def drop_duplicates(self, keep="first", inplace=False) -> "Series":
"""
Return Series with duplicate values removed.
@@ -1843,7 +1858,7 @@ def drop_duplicates(self, keep="first", inplace=False):
"""
return super().drop_duplicates(keep=keep, inplace=inplace)
- def duplicated(self, keep="first"):
+ def duplicated(self, keep="first") -> "Series":
"""
Indicate duplicate Series values.
@@ -2062,7 +2077,7 @@ def idxmax(self, axis=0, skipna=True, *args, **kwargs):
return np.nan
return self.index[i]
- def round(self, decimals=0, *args, **kwargs):
+ def round(self, decimals=0, *args, **kwargs) -> "Series":
"""
Round each value in a Series to the given number of decimals.
@@ -2157,7 +2172,7 @@ def quantile(self, q=0.5, interpolation="linear"):
# scalar
return result.iloc[0]
- def corr(self, other, method="pearson", min_periods=None):
+ def corr(self, other, method="pearson", min_periods=None) -> float:
"""
Compute correlation with `other` Series, excluding missing values.
@@ -2210,7 +2225,7 @@ def corr(self, other, method="pearson", min_periods=None):
f"'{method}' was supplied"
)
- def cov(self, other, min_periods=None):
+ def cov(self, other, min_periods=None) -> float:
"""
Compute covariance with Series, excluding missing values.
@@ -2239,7 +2254,7 @@ def cov(self, other, min_periods=None):
return np.nan
return nanops.nancov(this.values, other.values, min_periods=min_periods)
- def diff(self, periods=1):
+ def diff(self, periods=1) -> "Series":
"""
First discrete difference of element.
@@ -2303,7 +2318,7 @@ def diff(self, periods=1):
result = algorithms.diff(com.values_from_object(self), periods)
return self._constructor(result, index=self.index).__finalize__(self)
- def autocorr(self, lag=1):
+ def autocorr(self, lag=1) -> float:
"""
Compute the lag-N autocorrelation.
@@ -2446,7 +2461,7 @@ def searchsorted(self, value, side="left", sorter=None):
# -------------------------------------------------------------------
# Combination
- def append(self, to_append, ignore_index=False, verify_integrity=False):
+ def append(self, to_append, ignore_index=False, verify_integrity=False) -> "Series":
"""
Concatenate two or more Series.
@@ -2523,8 +2538,10 @@ def append(self, to_append, ignore_index=False, verify_integrity=False):
to_concat.extend(to_append)
else:
to_concat = [self, to_append]
- return concat(
- to_concat, ignore_index=ignore_index, verify_integrity=verify_integrity
+ return self._ensure_type(
+ concat(
+ to_concat, ignore_index=ignore_index, verify_integrity=verify_integrity
+ )
)
def _binop(self, other, func, level=None, fill_value=None):
@@ -2566,7 +2583,7 @@ def _binop(self, other, func, level=None, fill_value=None):
ret = ops._construct_result(self, result, new_index, name)
return ret
- def combine(self, other, func, fill_value=None):
+ def combine(self, other, func, fill_value=None) -> "Series":
"""
Combine the Series with a Series or scalar according to `func`.
@@ -2663,7 +2680,7 @@ def combine(self, other, func, fill_value=None):
new_values = try_cast_to_ea(self._values, new_values)
return self._constructor(new_values, index=new_index, name=new_name)
- def combine_first(self, other):
+ def combine_first(self, other) -> "Series":
"""
Combine Series values, choosing the calling Series's values first.
@@ -2703,7 +2720,7 @@ def combine_first(self, other):
return this.where(notna(this), other)
- def update(self, other):
+ def update(self, other) -> None:
"""
Modify Series in place using non-NA values from passed
Series. Aligns on index.
@@ -2762,10 +2779,10 @@ def sort_values(
self,
axis=0,
ascending=True,
- inplace=False,
- kind="quicksort",
- na_position="last",
- ignore_index=False,
+ inplace: bool = False,
+ kind: str = "quicksort",
+ na_position: str = "last",
+ ignore_index: bool = False,
):
"""
Sort by the values.
@@ -3117,7 +3134,7 @@ def sort_index(
else:
return result.__finalize__(self)
- def argsort(self, axis=0, kind="quicksort", order=None):
+ def argsort(self, axis=0, kind="quicksort", order=None) -> "Series":
"""
Override ndarray.argsort. Argsorts the value, omitting NA/null values,
and places the result in the same locations as the non-NA values.
@@ -3155,7 +3172,7 @@ def argsort(self, axis=0, kind="quicksort", order=None):
np.argsort(values, kind=kind), index=self.index, dtype="int64"
).__finalize__(self)
- def nlargest(self, n=5, keep="first"):
+ def nlargest(self, n=5, keep="first") -> "Series":
"""
Return the largest `n` elements.
@@ -3253,7 +3270,7 @@ def nlargest(self, n=5, keep="first"):
"""
return algorithms.SelectNSeries(self, n=n, keep=keep).nlargest()
- def nsmallest(self, n=5, keep="first"):
+ def nsmallest(self, n=5, keep="first") -> "Series":
"""
Return the smallest `n` elements.
@@ -3350,7 +3367,7 @@ def nsmallest(self, n=5, keep="first"):
"""
return algorithms.SelectNSeries(self, n=n, keep=keep).nsmallest()
- def swaplevel(self, i=-2, j=-1, copy=True):
+ def swaplevel(self, i=-2, j=-1, copy=True) -> "Series":
"""
Swap levels i and j in a :class:`MultiIndex`.
@@ -3373,7 +3390,7 @@ def swaplevel(self, i=-2, j=-1, copy=True):
self
)
- def reorder_levels(self, order):
+ def reorder_levels(self, order) -> "Series":
"""
Rearrange index levels using input order.
@@ -3497,7 +3514,7 @@ def unstack(self, level=-1, fill_value=None):
# ----------------------------------------------------------------------
# function application
- def map(self, arg, na_action=None):
+ def map(self, arg, na_action=None) -> "Series":
"""
Map values of Series according to input correspondence.
@@ -3575,7 +3592,7 @@ def map(self, arg, na_action=None):
new_values = super()._map_values(arg, na_action=na_action)
return self._constructor(new_values, index=self.index).__finalize__(self)
- def _gotitem(self, key, ndim, subset=None):
+ def _gotitem(self, key, ndim, subset=None) -> "Series":
"""
Sub-classes to define. Return a sliced object.
@@ -3983,7 +4000,7 @@ def drop(
level=None,
inplace=False,
errors="raise",
- ):
+ ) -> "Series":
"""
Return Series with specified index labels removed.
@@ -4124,7 +4141,7 @@ def replace(
)
@Appender(generic._shared_docs["shift"] % _shared_doc_kwargs)
- def shift(self, periods=1, freq=None, axis=0, fill_value=None):
+ def shift(self, periods=1, freq=None, axis=0, fill_value=None) -> "Series":
return super().shift(
periods=periods, freq=freq, axis=axis, fill_value=fill_value
)
@@ -4183,7 +4200,7 @@ def memory_usage(self, index=True, deep=False):
v += self.index.memory_usage(deep=deep)
return v
- def isin(self, values):
+ def isin(self, values) -> "Series":
"""
Check whether `values` are contained in Series.
@@ -4239,7 +4256,7 @@ def isin(self, values):
result = algorithms.isin(self, values)
return self._constructor(result, index=self.index).__finalize__(self)
- def between(self, left, right, inclusive=True):
+ def between(self, left, right, inclusive=True) -> "Series":
"""
Return boolean Series equivalent to left <= series <= right.
@@ -4315,19 +4332,19 @@ def between(self, left, right, inclusive=True):
return lmask & rmask
@Appender(generic._shared_docs["isna"] % _shared_doc_kwargs)
- def isna(self):
+ def isna(self) -> "Series":
return super().isna()
@Appender(generic._shared_docs["isna"] % _shared_doc_kwargs)
- def isnull(self):
+ def isnull(self) -> "Series":
return super().isnull()
@Appender(generic._shared_docs["notna"] % _shared_doc_kwargs)
- def notna(self):
+ def notna(self) -> "Series":
return super().notna()
@Appender(generic._shared_docs["notna"] % _shared_doc_kwargs)
- def notnull(self):
+ def notnull(self) -> "Series":
return super().notnull()
def dropna(self, axis=0, inplace=False, how=None):
@@ -4421,7 +4438,7 @@ def dropna(self, axis=0, inplace=False, how=None):
# ----------------------------------------------------------------------
# Time series-oriented methods
- def to_timestamp(self, freq=None, how="start", copy=True):
+ def to_timestamp(self, freq=None, how="start", copy=True) -> "Series":
"""
Cast to DatetimeIndex of Timestamps, at *beginning* of period.
@@ -4446,7 +4463,7 @@ def to_timestamp(self, freq=None, how="start", copy=True):
new_index = self.index.to_timestamp(freq=freq, how=how)
return self._constructor(new_values, index=new_index).__finalize__(self)
- def to_period(self, freq=None, copy=True):
+ def to_period(self, freq=None, copy=True) -> "Series":
"""
Convert Series from DatetimeIndex to PeriodIndex with desired
frequency (inferred from index if not passed).
| More typing. | https://api.github.com/repos/pandas-dev/pandas/pulls/30761 | 2020-01-06T22:38:46Z | 2020-01-12T14:32:16Z | 2020-01-12T14:32:16Z | 2020-01-12T14:55:37Z |
DOC: new EAs | diff --git a/pandas/core/base.py b/pandas/core/base.py
index 7d499181c6ed1..c7ef10e3900f6 100644
--- a/pandas/core/base.py
+++ b/pandas/core/base.py
@@ -716,6 +716,8 @@ def array(self) -> ExtensionArray:
period PeriodArray
interval IntervalArray
IntegerNA IntegerArray
+ string StringArray
+ boolean BooleanArray
datetime64[ns, tz] DatetimeArray
================== =============================
| https://api.github.com/repos/pandas-dev/pandas/pulls/30760 | 2020-01-06T22:29:19Z | 2020-01-06T23:37:09Z | 2020-01-06T23:37:09Z | 2020-01-06T23:37:14Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.